Java:SecurityManager 安全管理器SecurityPermission的使用

已于 2022-04-10 11:48:26 修改
阅读量5k 收藏 3
点赞数
分类专栏： Java 文章标签： java SecurityManager 安全管理器
于 2022-04-08 00:22:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_rain/article/details/124023503
版权

关于SecurityManager的细节本文章不做介绍，主要聚集在场景搭建以及核心流程的代码跟踪，理解其设计思路。

文章目录

场景搭建

主要验证System.getSecurityManager().checkSecurityAccess(“a.b.c”)的三个场景：

  • 与MainClass在同一个module
  • 与MainClass在不同的module
  • 在另一个jar包中

分别新增A、B、C、SecurityManagerTest四个类：

ClassPositionDescribe
Amodule: learn-main与Main class SecurityManagerTest在同一个module
Bmodule: learn-module在单独一个module
Cjar: com.saleson:personal:1.0-SNAPSHOT.jar在jar包中
SecurityManagerTestmodule: learn-mainmain class

A、B、C三个类的代码是一样的，仅是输出的日志为了区分会有调整，代码如下：

package com.saleson.learn.java.security;

import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Objects;

/**
 * @author saleson
 * @date 2022-04-07 13:47
 */
public class A {

    public void print() {
        print(true);
    }

    public void print(boolean direct) {
        if (direct) {
            _print();
        } else {
            AccessController.doPrivileged(new PrivilegedAction() {

                @Override
                public Object run() {
                    _print();
                    return null;
                }
            });
        }
    }
    
    private void _print() {
        SecurityManager securityManager = System.getSecurityManager();
        if (Objects.nonNull(securityManager)) {
            securityManager.checkSecurityAccess("a.b.c");
        }
        System.out.println(this.getClass().getSimpleName() + ".print");
    }
}

security.policy内容如下：

# grant1: main classess所在module的权限配置
grant codeBase "file:/Users/saleson/IdeaProjects/learn/learn-main/target/classess" {
    permission java.security.SecurityPermission "a.b.*";
};

# grant2: 另一个module的权限配置
grant codeBase "file:/Users/saleson/IdeaProjects/learn/learn-module/target/classess" {
    permission java.security.SecurityPermission "a.b.*";
};

# grant3: jar的权限配置
grant codeBase "file:///Users/saleson/m2/repository/com/saleson/personal/1.0-SNAPSHOT/personal-1.0-SNAPSHOT.jar" {
    permission java.security.SecurityPermission "a.b.*";
};

# idea debug 
grant {
  permission java.io.FilePermission "/Users/saleson/Library/Caches/IntelliJIdea2019.1/captureAgent/debugger-agent-storage.jar", "read";
  permission java.io.FilePermission "*", "read,write";
  permission java.util.PropertyPermission "*", "read,write";
};

SecurityManagerTest类代码：

package com.saleson.learn.java.security;

import com.saleson.learn.module.java.security.B;

/**
 * @author saleson
 * @date 2022-04-02 20:26
 */
public class SecurityManagerTest {

    public static void main(String[] args) {
        // -Djava.security.manager -Djava.security.policy=/Users/saleson/IdeaProjects/learn/learn-main/src/main/java/com/saleson/learn/java/security/security.policy
//        System.setSecurityManager(new SecurityManager());
        new A().print();
        new B().print();
        new com.saleson.java.security.test2.C().print();
    }
}

在debug SecurityManagerTest类时，添加jvm参数:

-Djava.security.manager -Djava.security.policy=/Users/saleson/IdeaProjects/learn/learn-main/src/main/java/com/saleson/learn/java/security/security.policy

在这里插入图片描述

验证场景介绍

全部正常执行

运行 SecurityManagerTest类，全部正常执行完成，输出如下：

/Users/saleson/dev_tools/openjdk/jdk-11.0.14.1+1/Contents/Home/bin/java -Djava.security.manager -Djava.security.policy=/Users/saleson/IdeaProjects/learn/learn-main/src/main/java/com/saleson/learn/java/security/security.policy ... com.saleson.learn.java.security.SecurityManagerTest
Connected to the target VM, address: '127.0.0.1:58939', transport: 'socket'
A.print
B.print
C.print
Disconnected from the target VM, address: '127.0.0.1:58939', transport: 'socket'

Process finished with exit code 0
grant1 注释掉

运行 SecurityManagerTest类，在执行A.print()时会抛错，输出如下：

/Users/saleson/dev_tools/openjdk/jdk-11.0.14.1+1/Contents/Home/bin/java -Djava.security.manager -Djava.security.policy=/Users/saleson/IdeaProjects/learn/learn-main/src/main/java/com/saleson/learn/java/security/security.policy ... com.saleson.learn.java.security.SecurityManagerTest
Connected to the target VM, address: '127.0.0.1:60206', transport: 'socket'
Exception in thread "main" java.security.AccessControlException: access denied ("java.security.SecurityPermission" "a.b.c")
	at java.base/java.security.AccessControlContext.checkPermission(AccessControlContext.java:472)
	at java.base/java.security.AccessController.checkPermission(AccessController.java:897)
	at java.base/java.lang.SecurityManager.checkPermission(SecurityManager.java:322)
	at java.base/java.lang.SecurityManager.checkSecurityAccess(SecurityManager.java:1435)
	at com.saleson.learn.java.security.A._print(A.java:37)
	at com.saleson.learn.java.security.A.print(A.java:20)
	at com.saleson.learn.java.security.A.print(A.java:14)
	at com.saleson.learn.java.security.SecurityManagerTest.main(SecurityManagerTest.java:17)
Disconnected from the target VM, address: '127.0.0.1:60206', transport: 'socket'

Process finished with exit code 1

A.print()无法执行；

grant1 和 A.print() 注释掉

把SecurityManagerTest类中的代码调整下：

public class SecurityManagerTest {

    public static void main(String[] args) {
//        System.setSecurityManager(new SecurityManager());
//        new A().print();
        new B().print();
        new com.saleson.java.security.test2.C().print();
    }
}

运行 SecurityManagerTest类，在执行A.print()时会抛错，输出如下：

/Users/saleson/dev_tools/openjdk/jdk-11.0.14.1+1/Contents/Home/bin/java -Djava.security.manager -Djava.security.policy=/Users/saleson/IdeaProjects/learn/learn-main/src/main/java/com/saleson/learn/java/security/security.policy ... com.saleson.learn.java.security.SecurityManagerTest
Connected to the target VM, address: '127.0.0.1:60738', transport: 'socket'
Exception in thread "main" java.security.AccessControlException: access denied ("java.security.SecurityPermission" "a.b.c")
	at java.base/java.security.AccessControlContext.checkPermission(AccessControlContext.java:472)
	at java.base/java.security.AccessController.checkPermission(AccessController.java:897)
	at java.base/java.lang.SecurityManager.checkPermission(SecurityManager.java:322)
	at java.base/java.lang.SecurityManager.checkSecurityAccess(SecurityManager.java:1435)
	at com.saleson.learn.module.java.security.B._print(B.java:37)
	at com.saleson.learn.module.java.security.B.print(B.java:20)
	at com.saleson.learn.module.java.security.B.print(B.java:14)
	at com.saleson.learn.java.security.SecurityManagerTest.main(SecurityManagerTest.java:18)
Disconnected from the target VM, address: '127.0.0.1:60738', transport: 'socket'

Process finished with exit code 1

将SecurityManagerTest的代码再调整下，print() 改为 print(false), 仍能正常执行：

public class SecurityManagerTest {

    public static void main(String[] args) {
//        System.setSecurityManager(new SecurityManager());
//        new A().print();
        new B().print(false);
        new com.saleson.java.security.test2.C().print(false);
    }
}

运行 SecurityManagerTest类，输出如下：

/Users/saleson/dev_tools/openjdk/jdk-11.0.14.1+1/Contents/Home/bin/java -Djava.security.manager -Djava.security.policy=/Users/saleson/IdeaProjects/learn/learn-main/src/main/java/com/saleson/learn/java/security/security.policy ... com.saleson.learn.java.security.SecurityManagerTest
Connected to the target VM, address: '127.0.0.1:62839', transport: 'socket'
B.print
C.print
Disconnected from the target VM, address: '127.0.0.1:62839', transport: 'socket'

Process finished with exit code 0

为啥能正常执行了呢，这是因为AccessController.doPrivileged()，再重新看下B.print()方法：

    public void print(boolean direct) {
        if (direct) {
            _print();
        } else {
            AccessController.doPrivileged(new PrivilegedAction() {

                @Override
                public Object run() {
                    _print();
                    return null;
                }
            });
        }
    }

后面的节章会从代码debug的视角对比有无使用AccessController.doPrivileged()的区别。

grant2 和 grant3 注释掉之后执行结果类似。

源码跟踪

首先放一张调用栈的图：
在这里插入图片描述
关于ProtectionDemain和CodeSource跟类加载有关，简单的介绍下：

  • codeSource
    代码源，该对象是由ClassLoader生成，ClassLoader读取class和jar包得知类的所在目录或者jar包路径、签名者以及证书等。
public class CodeSource implements java.io.Serializable {

    /**
     * The code location.
     *
     * @serial
     */
    private final URL location;

    /*
     * The code signers.
     */
    private transient CodeSigner[] signers = null;

    /*
     * The code signers. Certificate chains are concatenated.
     */
    private transient java.security.cert.Certificate[] certs = null;

    private transient String locationNoFragString;
}
  • ProtectionDomain
    从类名就可以看出来这是保护域对象，它内部包含了CodeSource、PermissionCollection。

想了解更多相关内容可以查阅java之jvm学习笔记十(策略和保护域) 进行了解。

下面主要从debug的视角跟踪AccessController、AccessControlContext、SecurityPermission进行对比和理解。

AccessController

我们在代码里调用System.getSecurityManager().checkPermission(Permission)方法检测相关的执行权限时，真正去执行检测逻辑的是在AccessControlContext.checkPermission(Permission)方法中，完整的调用链见下面的时序图：
在这里插入图片描述
从security.policy的结构来看，grant codeBase “file:/…” 管理的是class的目录或者jar，而且为什么C.class所在的jar赋予了权限，如果SecurityManagerTest.class所在的目录没有赋予权限仍会无法执行呢？

原因在于AccessControlContext，AccessControlContext是由AccessController.getStackAccessControlContext()获取的，这是一个静态方法，从方法名可以看出，获取一个stack结构的AccessControlContext；AccessControlContext类中确实也一个跟调用栈有关的field：AccessControlContext.context，该field是一个ProtectionDomain[]；ProtectionDomain包含CodeSource对象，前面介绍过，CodeSource包含调用类的所在目录或者jar包路径，并且是以先进后出的栈结构存储的，如图：
在这里插入图片描述
上面是AccessControlContext.checkPermission(Permission)的断点信息，该方法内有一个for循环，以后进先出的方式进行循环访问，所以即使C.pring()方法通过了安全权限检测，但是SecurityManagerTest.class没有通过安全权限检测仍是无法执行。这种情况也是可以通过其它方式避过的：AccessController.doPrivileged(PrivilegedAction)

AccessController.doPrivileged

AccessController.doPrivileged(PrivilegedAction)也是一个native方法，调用该方法后，jvm会重新生成一个access control object并且替换掉当前的。openjdk中的注释是:
在这里插入图片描述

在SecurityManagerTest.main()方法中改为C.print(false)，采用AccessController.doPrivileged(PrivilegedAction)的方式进行调用。

public class SecurityManagerTest {

    public static void main(String[] args) {
//        new A().print();
        new B().print(false);
        new com.saleson.java.security.test2.C().print(false);
    }
}

print() 方法：

public void print(boolean direct) {
        if (direct) {
            this._print();
        } else {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    C.this._print();
                    return null;
                }
            });
        }

调用之后断点再看一下：
在这里插入图片描述
采用AccessController.doPrivileged(PrivilegedAction)后，AccessControlContext.context只有1个ProtectionDomain对象，安全权限检测通过，所以能够正常执行。

SecurityPermission

在执行SecurityPermission.implies(Permission)方法之前，会先在BasicPermissionCollection.implies(Permission)方法中找到匹配的Permission。

BasicPermissionCollection.implies(Permission)代码逻辑：

    @Override
    public boolean implies(Permission permission) {
        if (! (permission instanceof BasicPermission))
            return false;

        BasicPermission bp = (BasicPermission) permission;

        // random subclasses of BasicPermission do not imply each other
        if (bp.getClass() != permClass)
            return false;

        // short circuit if the "*" Permission was added
        if (all_allowed)
            return true;

        // strategy:
        // Check for full match first. Then work our way up the
        // path looking for matches on a.b..*

        String path = bp.getCanonicalName();
        //System.out.println("check "+path);

        Permission x = perms.get(path);

        if (x != null) {
            // we have a direct hit!
            return x.implies(permission);
        }

        // work our way up the tree...
        int last, offset;

        offset = path.length()-1;

        while ((last = path.lastIndexOf('.', offset)) != -1) {

            path = path.substring(0, last+1) + "*";
            //System.out.println("check "+path);

            x = perms.get(path);

            if (x != null) {
                return x.implies(permission);
            }
            offset = last -1;
        }

        // we don't have to check for "*" as it was already checked
        // at the top (all_allowed), so we just return false
        return false;
    }

找到之后再调用Permission.implies(Permission)。

SecurityPermission类的逻辑都在其父类BasicPermission中，BasicPermission在构造方法中会init()进行简单的解析：

  1. 先判断后缀是否为*
  2. 如果是则对path进行处理，例如name = “x.x.*”
    wildcard = true
    path = “x.x.”

BasicPermission.init(String)

    private void init(String name) {
        if (name == null)
            throw new NullPointerException("name can't be null");

        int len = name.length();

        if (len == 0) {
            throw new IllegalArgumentException("name can't be empty");
        }

        char last = name.charAt(len - 1);

        // Is wildcard or ends with ".*"?
        if (last == '*' && (len == 1 || name.charAt(len - 2) == '.')) {
            wildcard = true;
            if (len == 1) {
                path = "";
            } else {
                path = name.substring(0, len - 1);
            }
        } else {
            if (name.equals("exitVM")) {
                wildcard = true;
                path = "exitVM.";
                exitVM = true;
            } else {
                path = name;
            }
        }
    }

BasicPermission.implies(Permission)方法也是一个简单的对比逻辑：

    @Override
    public boolean implies(Permission p) {
        if ((p == null) || (p.getClass() != getClass()))
            return false;

        BasicPermission that = (BasicPermission) p;

        if (this.wildcard) {
            if (that.wildcard) {
                // one wildcard can imply another
                return that.path.startsWith(path);
            } else {
                // make sure ap.path is longer so a.b.* doesn't imply a.b
                return (that.path.length() > this.path.length()) &&
                    that.path.startsWith(this.path);
            }
        } else {
            if (that.wildcard) {
                // a non-wildcard can't imply a wildcard
                return false;
            }
            else {
                return this.path.equals(that.path);
            }
        }
    }
SecurityPermission的使用案例

在SecurityPermission的构造参数中仅有name参数会参与到对比计算中，但是name支持’*'这个通配符；在使用时可以在.policy文件中配置：

grant {
	permission java.security.SecurityPermission "a.b.*";
}

在check时，可以将name以’.'进行任意的组合用于检测：

// check pass
System.getSecurityManager().securityManager.checkSecurityAccess("a.b.c");
// check pass
System.getSecurityManager().securityManager.checkSecurityAccess("a.b.c.c");
// check fail
System.getSecurityManager().securityManager.checkSecurityAccess("a.c.c");

参考

java之jvm学习笔记四(安全管理器)
java之jvm学习笔记八(实践对jar包的代码签名)
java之jvm学习笔记十(策略和保护域)
java之jvm学习笔记十二(访问控制器的栈校验机制)
使用Policy文件来设置Java的安全策略
使用Policy文件来设置Java的安全策略
java 权限 库,java – 授予多个代码库的权限
java安全管理器SecurityManager介绍
Java安全——安全管理器、访问控制器和类装载器
Java安全——理解Java沙箱
Java沙箱机制的实现——安全管理器、访问控制器

Saleson
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java安全管理器——SecurityManager
seaboat——a free boat on the sea.（公众号：远洋号）
08-11 8180
总的来说，Java安全应该包括两方面的内容，一是Java平台（即是Java运行环境）的安全性；二是Java语言开发的应用程序的安全性。由于我们不是Java本身语言的制定开发者，所以第一个安全性不需要我们考虑。其中第二个安全性是我们重点考虑的问题，一般我们可以通过安全管理器机制来完善安全性，安全管理器是安全的实施者，可对此类进行扩展，它提供了加在应用程序上的安全措施，通过配置安全策略文件达到对网络、
java安全权限_java.security.SecurityPermission
weixin_33605464的博客
03-08 1530
public final class SecurityPermission此类用于安全权限。SecurityPermission 包含一个名称(也称为“目标名称”)，但没有操作列表；可以使用，也可以不使用指定权限。目标名称就是安全配置参数的名称(见下表)。目前 SecurityPermission 对象可用来保护对 Policy、Security、Provider、Signer 和 Identit...
Shiro框架：Shiro SecurityManager安全管理器解析
博客园
01-13 1650
​Shiro作为一款比较流行的登录认证、访问控制安全框架，被广泛应用在程序员社区；Shiro登录验证、访问控制、Session管理等流程内部都是委托给SecurityManager安全管理器来完成的，在前述文章全面解析Shiro框架原理的基础之上，详见：Shiro框架：ShiroFilterFactoryBean过滤器源码解析-CSDN博客、Shiro框架：Shiro内置过滤器源码解析-CSDN博客，本篇文章继续深入解析Shiro SecurityManager安全管理器的结构和功能。
Java中的安全管理器和权限控制
最新发布
weixin_53840353的博客
06-13 773
Java安全管理器是一种允许应用程序在运行时检查对系统资源（如文件和网络）的访问权限的机制。通过定义和安装自定义的安全策略，程序员可以控制哪些代码能够执行特定的操作，从而保护系统资源的安全。@Override// 自定义安全策略throw new SecurityException("写文件操作被禁止！");try {// 尝试写文件操作System.err.println("安全异常：" + e.getMessage());在这个示例中，自定义的禁止所有文件写操作。
Java之SecurityManager安全管理器
we.think
10-19 3112
目录一、 启停安全管理器1.1 启用1.2 关闭二、安全策略2.1 默认配置2.2 策略准则三、SecurityManager3.1 概要描述3.2 方法摘要3.3 使用 SecurityManager是一个允许应用实现一种安全策略的类。应用在执行一个安全或敏感的操作之前，可以明确此操作是否在一个安全的上下文中被执行。 一、 启停安全管理器 1.1 启用 系统启动开启 JVM参数：-Djava.security.manager 当运行一个程序，可以指定JVM命令-Djava.security.manage
java安全管理器SecurityManager入门
weixin_30703911的博客
12-21 1512
一、文章的目的 　　这是一篇对Java安全管理器入门的文章，目的是简单了解什么是SecurityManager，对管理器进行简单配置，解决简单问题。 　　比如在阅读源码的时候，发现这样的代码，想了解是做什么的： SecurityManager security = System.getSecurityManager(); if (security != null) { s...
Java安全管理器（Security Manager)
yuanyong
03-15 154
每个Java应用都可以有自己的安全管理器，它是防范恶意攻击的主要安全卫士。安全管理器通过执行运行阶段检查和访问授权，以实施应用所需的安全策略，从而保护资源免受恶意操作的攻击。实际上，安全管理器根据Java安全策略文件决定将哪组权限授予类。然而，当不可信的类和第三方应用使用JVM时，Java安全管理器将使用与JVM相关的安全策略来识别恶意操作。在很多情况下，威胁模型不包含运行于JVM中的恶意代码，此...
dappFinance#Note#【Java多线程】安全管理器SecurityManager1
07-25
创建安全管理器利用安全管理器public static void main(String args[]){方法调用此方法时，返回所有新创建的线程实例化后所在的线
securesm:解决Java中设计缺陷的SecurityManager实现
04-29
总之，`securesm`项目致力于提供一个更强大、更安全、更易管理的`SecurityManager`实现，帮助开发者在Java环境中更好地保护系统资源和数据安全。通过深入理解和应用`securesm`，可以提高应用程序的安全性，降低潜在...
Java安全权限控制机制研究综述.pdf
04-11
Java安全管理器（SecurityManager）是Java中的一种安全机制，允许应用程序实现安全策略。它包含了很多名称以单词check开头的方法，Java库中的各种方法在执行某些潜在的敏感操作前可以调用这些方法。安全管理器通过抛...
Java安全技术.pptx
05-09
Java2 安全模型的核心组件包括 ProtectionDomain、ClassLoader、SecurityManager、ByteCode Verifier 和 AccessController。 ProtectionDomain 是在策略数据库中指定的，授予 CodeSource 的 Permission 的聚合体。 ...
Java安全学习（权限验证）1
08-08
在这个领域，主要涉及四个关键概念：Java认证与授权服务、Java密钥框架、公钥基础设施以及Java安全套接字扩展。下面我们将深入探讨这些知识点。 **Java认证与授权服务（JAAS）** Java认证与授权服务提供了一种标准...
Java 安全管理器--SecurityManager
谨慎对事 低调行事 0与1的世界 浩瀚如海 学无止境
11-17 1216
安全管理器是一个允许应用程序实现安全策略的类。它允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么，以及是否是在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。       SecurityManager 类包含了很多名称以单词 check 开头的方法。Java 库中的各种方法在执行某些潜在的敏感操作前可以调用这些方法。对 checkXXX 方法的典
Java安全管理器-SecurityManager
sunyingboaini的博客
04-11 1881
SecurityManager是Java中的一个类，用于实现安全管理功能。它允许应用程序在运行时对安全策略进行动态管理，并控制哪些操作可以执行，哪些应该被拒绝。主要功能包括：安全策略管理：SecurityManager允许定义一组安全策略，这些策略规定了在运行时哪些操作是允许的，哪些是禁止的。权限控制：通过SecurityManager可以控制对敏感资源的访问权限，比如文件系统、网络等。
关于Java SecurityManager的用途以及使用方法
weixin_45735347的博客
07-04 626
为了让我们的程序在运行时private类也不可以被访问，我们就需要使用安全管理器(SecurityManager)通过以上代码，我们就可以调用AccessTest 中的私有方法multiple，显然这是不应该被允许的。众所周知，java中被设置了private的属性以及方法是不能被类本身外的其他类调用的。在了解安全管理器的用途前，先看以下前言，这会帮助你更好的理解它的作用。但是如果在运行状态下我们便可以实现对private的属性或方法的访问。当然，java有自带的默认政策文件，在以下目录下。
java 的 AccessController.doPrivileged使用
weixin_34129696的博客
01-15 543
AccessController.doPrivileged意思是这个是特别的,不用做权限检查. 在什么地方会用到呢:加入1.jar中有类可以读取一个文件,现在我们要使用1.jar去做这个事情.但是我们的类本生是没有权限去读取那个文件的,一般情况下就是眼睁睁的看着了.   但是jiava提供了doPrivileged.在1.jar中如果读取文件的方法是通过doPrivileged来实现的...
认识java安全管理器SecurityManager
zhangningboyj的博客
01-30 3921
1，什么是Java安全管理器？ SecurityManager 在看java源码的过程中，经常会遇到如下一段代码： SecurityManager s = System.getSecurityManager(); ThreadGroup group = (s != null) ? s.getThreadGroup():Thread.currentThread().getThreadGroup() 或 SecurityManager security = System.getSecurityManager
java.security.Permission翻译
07-08 1312
 Overview Package  Class Use Tree Deprecated Index Help JavaTM 2 PlatformStd. Ed. v1.4.2  PREV CLASS   NEXT CLASSFRAMES    NO FRAMES    <!-- if(window==top) { document.writeln(All Classes)
spark.SecurityManager: SecurityManager: authentication disabled
05-14
这个信息是 Spark 的安全管理器（SecurityManager）记录的日志，它表示身份验证（authentication）被禁用了。Spark 默认情况下启用了身份验证机制来确保集群中的用户只能访问他们被授权的资源。但是在某些情况下，比如开发环境或者测试环境，身份验证可能不是必须的，可以将其禁用以提高集群的性能。 如果你想启用身份验证机制，可以通过设置 `spark.authenticate` 参数为 `true` 来实现。例如，在 Spark submit 命令中指定： ``` spark-submit --conf spark.authenticate=true ... ``` 如果你想在运行时禁用身份验证，可以通过设置 `spark.authenticate` 参数为 `false` 来实现。例如，在 Spark shell 中执行： ``` spark-shell --conf spark.authenticate=false ``` 需要注意的是，禁用身份验证可能会带来一定的安全隐患，因此在生产环境中应该谨慎使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值