Java篇：Java的安全模型

记录学习过程，整理笔记。

Java的安全模型是其多个重要结构特点之一，它使Java成为适用于网络环境的技术。Java安全模型侧重于保护终端用户免受从网络下载的、来自不可靠来源的、恶意程序（以及善意程序中的bug）的侵犯。

1、Java中的安全模型

Java 安全模型，你了解了吗

在Java中将执行程序分为本地和远程两种，本地代码默认视为可信任的，而远程代码则被看作是不受信的。对于受信的本地代码，可以访问一切本地资源。而对于非受信的远程代码在早期的Java实现中，安全依赖于沙箱(Sandbox)机制。沙箱机制就是将Java代码限定在虚拟机（JVM）特定的运行范围中，并且严格限制代码对本地系统的资源访问，通过这样的措施来保证对远程代码的有效隔离，防止对本地系统造成破坏，如图1所示，

 

但如此严格的安全机制也给程序的功能扩展带来了障碍，比如当用户希望远程代码访问本地系统的文件时候，就无法实现。因此在后续的Java1.1版本中，针对安全机制做了改进，增进了安全策略，允许用户指定代码对本地资源的访问权限，如图2所示，

 

在Java 1.2版本中，再次改进了安全机制，增加了代码签名。不论本地代码或是远程代码，都会按照用户的安全策略设定，由类加载器加载到虚拟机中权限不同的运行空间，来实现差异化的代码执行权限控制。如图3所示，

 

当前最新的安全机制实现，则引入了域(Domain)的概念。虚拟机会把所有代码加载到不同的系统域和应用域，系统域部分专门负责与关键资源进行交互，而各个应用域部分则通过系统与的部分代理来对各种需要的资源进行访问。虚拟机中不同的受保护域(Protected Domain)，对应不一样的权限(Permission)。存在于不同域中的类文件就具有了当前域的全部权限，如图4所示：

 

以上提到的都是基本的Java安全模型概念，在应用开发中还有一些关于安全的复杂用法，其中最长用到的API就是doPrivileged。doPrivileged方法能够使一段受信任代码获得更大的权限，甚至比调用它的应用程序还要多，可做到临时访问更多的资源。有时候这是非常必要的，可以应付一些特殊的应用场景。例如应用程序可能无法直接访问某些系统资源，但这样的应用程序必须得到这些资源才能够完成功能。针对这种情况，Java SDK给域提供了doPrivileged方法，让程序突破当前域权限限制，临时扩大访问权限。

2、理解Java 沙箱

Java安全——理解Java沙箱

2.1 什么是沙箱

Java安全模型的核心就是Java沙箱(sandbox)，什么是沙箱？沙箱是一个限制程序运行的环境。限制程序运行一方面是为了保护系统资源，同时另一方面也为了保护程序自己。沙箱主要限制系统资源访问，那系统资源包括什么？---CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也可以不一样。

所有的Java程序运行都可以指定沙箱，可以定制安全策略。而一个Java程序运行的安全策略，包括了以下几点基础：

  • 字节码校验器(bytecode verifier)：确保Java类文件遵循Java语言规范。这样可以帮助Java程序实现内存保护。但是不是所有的类文件都会经过字节码校验，比如核心类。

  • 类加载器(class loader)：所有的java类都是通过类加载器加载的，可以自定义类加载器来设置加载类的权限。

  • 存取控制器(access controller)：存取控制器可以控制核心API对操作系统的存取权限，而这个控制的策略设定，可以由用户指定。

  • 安全管理器(security manager)：是核心API和操作系统之间的主要接口。实现权限控制，比存取控制器优先级高。

  • 安全软件包(security package)：java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括：

    • 安全提供者

    • 消息摘要

    • 数字签名

    • 加密

    • 鉴别

2.2 沙箱包含哪些要素

2.2.1 权限

权限是指允许代码执行的操作。包含三部分：权限类型、权限名和允许的操作。权限名一般就是对哪类资源进行操作的资源定位（比如说一个文件名或者通配符、网络主机等），一般基于权限类型来设置，有的比如java.security.AllPermission不需要权限名。允许的操作也和权限类型对应，指定了都目标可以执行的操作行为，比如读、写等。如下面的例子：

permission java.security.AllPermission; //权限类型
permission java.lang.RuntimePermission "StopThread"; //权限类型+权限名
permission java.io.FilePermission "/tmp/foo" "read";    //权限类型+权限名+允许的操作
?

标准权限有哪些

 类型权限名操作例子
文件权限 java.io.FilePermission 文件名（平台依赖） 读、写、删除、执行 允许所有问价的读写删除执行：permission java.io.FilePermission "<< ALL FILES>>", "read,write,delete,execute";。允许对用户主目录的读：permission java.io.FilePermission "${user.home}/-", "read";。
套接字权限 java.net.SocketPermission 主机名:端口 接收、监听、连接、解析 允许实现所有套接字操作：permission java.net.SocketPermission ":1-", "accept,listen,connect,resolve";。允许建立到特定网站的连接：permission java.net.SocketPermission ".abc.com:1-", "connect,resolve";。
属性权限 java.util.PropertyPermission 需要访问的jvm属性名 读、写 读标准Java属性：permission java.util.PropertyPermission "java.", "read";。在sdo包中创建属性：permission java.util.PropertyPermission "sdo.", "read,write";。
运行时权限 java.lang.RuntimePermission 多种权限名[见附录A] 无 允许代码初始化打印任务：permission java.lang.RuntimePermission "queuePrintJob"
AWT权限 java.awt.AWTPermission 6种权限名[见附录B] 无 允许代码充分使用robot类：permission java.awt.AWTPermission "createRobot"; permission java.awt.AWTPermission "readDisplayPixels";。
网络权限 java.net.NetPermission 3种权限名[见附录C] 无 允许安装流处理器：permission java.net.NetPermission "specifyStreamHandler";。
安全权限 java.security.SecurityPermission 多种权限名[见附录D] 无  
序列化权限 java.io.SerializablePermission 2种权限名[见附录E] 无  
反射权限 java.lang.reflect.ReflectPermission suppressAccessChecks（允许利用反射检查任意类的私有变量） 无  
完全权限 java.security.AllPermission 无（拥有执行任何操作的权限） 无  

2.2.2 代码源

代码源是类所在的位置，表示为以URL地址。

2.2.3 保护域

保护域用来组合代码源和权限，这是沙箱的基本概念。保护域就在于声明了比如由代码A可以做权限B这样的事情。

2.2.4 策略文件

策略文件在控制沙箱的管理元素，一个策略文件包含一个或多个保护域的项。策略文件完成了代码权限的指定任务，策略文件包含全局和用户专属两种。

为了管理沙箱，策略文件我认为是最重要的内容。JVM可以使用多个策略文件，不过一般两个最常用。一个是全局的：$JREHOME/lib/security/java.policy，作用域JVM的所有实例。另一个是用户自己的，可以存储到用户的主目录下。策略文件可以使用jdk自带的policytool工具编辑。

默认的策略文件我们先参考一下：

// Standard extensions get all permissions by default
?
grant codeBase "file:${{java.ext.dirs}}/*" {
        permission java.security.AllPermission;
};
?
// default permissions granted to all domains
?
grant {
        // Allows any thread to stop itself using the java.lang.Thread.stop()
        // method that takes no argument.
        // Note that this permission is granted by default only to remain
        // backwards compatible.
        // It is strongly recommended that you either remove this permission
        // from this policy file or further restrict it to code sources
        // that you specify, because Thread.stop() is potentially unsafe.
        // See the API specification of java.lang.Thread.stop() for more
        // information.
        permission java.lang.RuntimePermission "stopThread";
?
        // allows anyone to listen on dynamic ports
        permission java.net.SocketPermission "localhost:0", "listen";
?
        // permission for standard RMI registry port
        permission java.net.SocketPermission "localhost:1099", "listen";
?
        // "standard" properies that can be read by anyone
?
        permission java.util.PropertyPermission "java.version", "read";
        permission java.util.PropertyPermission "java.vendor", "read";
        permission java.util.PropertyPermission "java.vendor.url", "read";
        permission java.util.PropertyPermission "java.class.version", "read";
        permission java.util.PropertyPermission "os.name", "read";
        permission java.util.PropertyPermission "os.version", "read";
        permission java.util.PropertyPermission "os.arch", "read";
        permission java.util.PropertyPermission "file.separator", "read";
        permission java.util.PropertyPermission "path.separator", "read";
        permission java.util.PropertyPermission "line.separator", "read";
?
        permission java.util.PropertyPermission "java.specification.version", "read";
        permission java.util.PropertyPermission "java.specification.vendor", "read";
        permission java.util.PropertyPermission "java.specification.name", "read";
?
        permission java.util.PropertyPermission "java.vm.specification.version", "read";
        permission java.util.PropertyPermission "java.vm.specification.vendor", "read";
        permission java.util.PropertyPermission "java.vm.specification.name", "read";
        permission java.util.PropertyPermission "java.vm.version", "read";
        permission java.util.PropertyPermission "java.vm.vendor", "read";
        permission java.util.PropertyPermission "java.vm.name", "read";
};

策略文件的内容格式就是这样，grant授权允许操作某个权限。这个默认的策略文件就指明了jdk扩展包可以有全部权限，允许代码stop线程，允许监听1099端口等等。

另一个很重要的是参数文件——java.security，这个文件和策略文件在同一个目录下。这个参数文件定义了沙箱的一些参数。比如默认的沙箱文件时这样的（截取部分）：

# The default is to have a single system-wide policy file,
# and a policy file in the user's home directory.
policy.url.1=file:${java.home}/lib/security/java.policy
policy.url.2=file:${user.home}/.java.policy
?
# whether or not we expand properties in the policy file
# if this is set to false, properties (${...}) will not be expanded in policy
# files.
policy.expandProperties=true
?
# whether or not we allow an extra policy to be passed on the command line
# with -Djava.security.policy=somefile. Comment out this line to disable
# this feature.
policy.allowSystemProperty=true

policy.url.*这个属性指明了使用的策略文件，如上文所述，默认的两个位置就在这里配置，用户可以自行更改顺序和存储位置。而policy.allowSystemProperty指明是否允许用户自行通过命令行指定policy文件。

2.2.5 密钥库

保存密钥证书的地方。

2.3 默认沙箱

通过Java命令行启动的Java应用程序，默认不启用沙箱。要想启用沙箱，启动命令需要做如下形式的变更：

java -Djava.security.manager

沙箱启动后，安全管理器会使用两个默认的策略文件来确定沙箱启动参数。当然也可以通过命令指定：

java -Djava.security.policy=

如果要求自动时只遵循一个策略文件，那么启动参数要加个等号，如下：

java -Djava.security.policy==

2.4 如何使用

2.4.1 限制读文件

这个例子很简单，首先写一个r.txtx文件，里面的内容时“abcd”，再写个程序如下读取这个r.txtx。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
?
public class PolicyTest {
?
    public static void file() {
        File f = new File("D:\\github\\CDLib\\src\\main\\resources\\security\\r.txt");
        InputStream is;
        try {
            is = new FileInputStream(f);
            byte[] content = new byte[1024];
            while (is.read(content) != -1) {
                System.out.println(new String(content));
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        // test read file.
        file();
    }
}

发现输出时abcd。

接下来修改java启动参数，加入-Djava.security.manager，启动了安全沙箱。再运行，输出变成了异常。

Exception in thread "main" java.security.AccessControlException: access denied ("java.io.FilePermission" "D:githubCDLibsrcmainresourcessecurityr.txt" "read")
?
at java.security.AccessControlContext.checkPermission(Unknown Source)
at java.security.AccessController.checkPermission(Unknown Source)
at java.lang.SecurityManager.checkPermission(Unknown Source)
at java.lang.SecurityManager.checkRead(Unknown Source)
at java.io.FileInputStream.(Unknown Source)
at com.taobao.cd.security.PolicyTest.main(PolicyTest.java:15)

这里已经提示了，访问被拒绝，说明沙箱启动，同时也验证了默认沙箱---禁止本地文件访问。

再来，我们构建一个custom.policy文件如下：

grant {
    permission java.io.FilePermission "D:\\github\\CDLib\\src\\main\\resources\\security\\*", "read";
};

这里构建了一条安全策略---允许读取security目录下的文件。

修改启动文件，添加-Djava.security.policy=D:\\github\\CDLib\\src\\main\\resources\\security\\custom.policy，再执行，结果输出了abcd。

如上例。我们通过自定义policy文件修改了默认沙箱的安全策略，再通过启动参数开启沙箱模式。这样就可以构造我们自己想要的沙箱效果了。

2.4.2 限制访问网络

通过HttpClient访问www.baidu.com

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
?
import com.taobao.cd.http.util.HttpUtil;
?
public class PolicyTest {
?
    public static void network() {
        try {
            String text = HttpUtil.createHtmlText("http://www.baidu.com", HttpUtil.UA);
            System.out.println(text);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
?
    public static void main(String[] args) {
        // test use network.
        network();
    }
}

开启沙箱后，输出如下：

java.security.AccessControlException: access denied ("java.net.SocketPermission" "www.baidu.com" "resolve")
?
at java.security.AccessControlContext.checkPermission(Unknown Source)
at java.security.AccessController.checkPermission(Unknown Source)
at java.lang.SecurityManager.checkPermission(Unknown Source)
at java.lang.SecurityManager.checkConnect(Unknown Source)
at java.net.InetAddress.getAllByName0(Unknown Source)
at java.net.InetAddress.getAllByName(Unknown Source)
at java.net.InetAddress.getAllByName(Unknown Source)
at org.apache.http.impl.conn.DefaultClientConnectionOperator.resolveHostname(DefaultClientConnectionOperator.java:242)
at org.apache.http.impl.conn.DefaultClientConnectionOperator.openConnection(DefaultClientConnectionOperator.java:130)
at org.apache.http.impl.conn.AbstractPoolEntry.open(AbstractPoolEntry.java:149)
at org.apache.http.impl.conn.AbstractPooledConnAdapter.open(AbstractPooledConnAdapter.java:121)
at org.apache.http.impl.client.DefaultRequestDirector.tryConnect(DefaultRequestDirector.java:573)
at org.apache.http.impl.client.DefaultRequestDirector.execute(DefaultRequestDirector.java:425)
at org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:820)
at org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:754)
at org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:732)
at com.taobao.cd.http.util.HttpUtil.createHtmlText(HttpUtil.java:38)
at com.taobao.cd.security.PolicyTest.network(PolicyTest.java:15)
at com.taobao.cd.security.PolicyTest.main(PolicyTest.java:45)

根据错误提示，知道是访问socket没有权限。那么修改下policy，指定权限：

grant {
    permission java.net.SocketPermission "www.baidu.com:1-", "connect,resolve";
};

在指定权限文件下再运行，得到了正常的text形式的baidu首页的页面文档。权限策略成功。

代码参考github：https://github.com/changedi/CDLib/blob/master/src/main/java/com/taobao/cd/security/PolicyTest.java

2.5 附录

A

权限名用途说明
accessClassInPackage. 允许代码访问指定包中的类
accessDeclaredMembers 允许代码使用反射访问其他类中私有或保护的成员
createClassLoader 允许代码实例化类加载器
createSecurityManager 允许代码实例化安全管理器，它将允许程序化的实现对沙箱的控制
defineClassInPackage. 允许代码在指定包中定义类
exitVM 允许代码关闭整个虚拟机
getClassLoader 允许代码访问类加载器以获得某个特定的类
getProtectionDomain 允许代码访问保护域对象以获得某个特定类
loadlibrary. 允许代码装载指定类库
modifyThread 允许代码调整指定的线程参数
modifyThreadGroup 允许代码调整指定的线程组参数
queuePrintJob 允许代码初始化一个打印任务
readFileDescriptor 允许代码读文件描述符（相应的文件是由其他保护域中的代码打开的）
setContextClassLoader 允许代码为某线程设置上下文类加载器
setFactory 允许代码创建套接字工厂
setIO 允许代码重定向System.in、System.out或System.err输入输出流
setSecurityManager 允许代码设置安全管理器
stopThread 允许代码调用线程类的stop()方法
writeFileDescriptor 允许代码写文件描述符

B

权限名用途说明
accessClipboard 允许访问系统的全局剪贴板
accessEventQueue 允许直接访问事件队列
createRobot 允许代码创建AWT的Robot类
listenToAllAWTEvents 允许代码直接监听事件分发
readDisplayPixels 允许AWT Robot读显示屏上的像素
showWindowWithoutWarningBanner 允许创建无标题栏的窗口

C

权限名用途说明
specifyStreamHandler 允许在URL类中安装新的流处理器
setDefaultAuthenticator 可以安装鉴别类
requestPassworkAuthentication 可以完成鉴别

D

权限名用途说明
addIdentityCertificate 为Identity增加一个证书
clearProviderProperties. 针对指定的提供者，删除所有属性
createAccessControlContext 允许创建一个存取控制器的上下文环境
getDomainCombiner 允许撤销保护域
getPolicy 检索可以实现沙箱策略的类
getProperty. 读取指定的安全属性
getSignerPrivateKey 由Signer对象获取私有密钥
insertProvider. 将指定的提供者添加到响应的安全提供者组中
loadProviderProperties. 装载指定的提供者的属性
printIdentity 打印Identity类内容
putAllProviderProperties. 更新指定的提供者的属性
putProviderProperty. 为指定的提供者增加一个属性
removeIdentityCertificate 取消Identity对象的证书
removeProvider. 将指定的提供者从相应的安全提供者组中删除
removeProviderProperty. 删除指定的安全提供者的某个属性
setIdentityInfo 为某个Identity对象设置信息串
setIdentityPublicKey 为某个Identity对象设置公钥
setPolicy 设置可以实现沙箱策略的类
setProperty. 设置指定的安全属性
setSignerKeyPair 在Signer对象中设置密钥对
setSystemScope 设置系统所用的IdentityScope

E

权限名用途说明
enableSubstitution 允许实现ObjectInputStream类的enableResolveObject()方法和ObjectOutputStream类的enableReplaceObject()方法
enableSubclassImplementation 允许ObjectInputStream和ObjectOutputStream创建子类，子类可以覆盖readObject()和writeObject()方法

 

3、安全管理器、访问控制器和类装载器

Java安全——安全管理器、访问控制器和类装载器

3.1 安全管理器 SecurityManager

java.lang.SecurityManager

安全管理器在Java语言中的作用就是检查操作是否有权限执行。是Java沙箱的基础组件。我们一般所说的打开沙箱，也就是加-Djava.security.manager选项。

其实日常的很多API都涉及到安全管理器，它的工作原理一般是：

  1. 请求Java API

  2. Java API使用安全管理器判断许可权限

  3. 通过则顺序执行，否则抛出一个Exception

比如在之前的“理解沙箱”这一章提到的，开启沙箱后，会限制文件访问，那这个代码时如何的呢？看下源码：

  
  public FileInputStream(File file) throws FileNotFoundException {
        String name = (file != null ? file.getPath() : null);
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(name);
        }
        if (name == null) {
            throw new NullPointerException();
        }
        if (file.isInvalid()) {
            throw new FileNotFoundException("Invalid file path");
        }
        fd = new FileDescriptor();
        fd.attach(this);
        path = name;
        open(name);
    }

可以看到代码中先尝试获取安全管理器，如果开启沙箱，则安全管理器不是空，则需要检查读取权限checkRead(name)。而checkRead方法最内层的实现，其实利用了后面要说的访问控制器。

具体点，我们看下SecurityManager的主要方法列表：

checkAccept(String, int)
checkAccess(Thread)
checkAccess(ThreadGroup)
checkAwtEventQueueAccess()
checkConnect(String, int)
checkConnect(String, int, Object)
checkCreateClassLoader()
checkDelete(String)
checkExec(String)
checkExit(int)
checkLink(String)
checkListen(int)
checkMemberAccess(Class<?>, int)
checkMulticast(InetAddress)
checkMulticast(InetAddress, byte)
checkPackageAccess(String)
checkPackageDefinition(String)
checkPermission(Permission)
checkPermission(Permission, Object)
checkPrintJobAccess()
checkPropertiesAccess()
checkPropertyAccess(String)
checkRead(FileDescriptor)
checkRead(String)
checkRead(String, Object)
checkSecurityAccess(String)
checkSetFactory()
checkSystemClipboardAccess()
checkTopLevelWindow(Object)
checkWrite(FileDescriptor)
checkWrite(String)

?

都是check方法，分别囊括了文件的读写删除和执行、网络的连接和监听、线程的访问、以及其他包括打印机剪贴板等系统功能。而这些check代码也基本横叉到了所有的核心Java API上。

安全管理器可以自定义，作为核心API调用的部分，我们可以自己为自己的业务定制安全管理逻辑。举个例子如下：

public class SecurityManagerTest {
static class MySM extends SecurityManager {
    public void checkExit(int status) {
        throw new SecurityException("no exit");
    }
?
}
?
public static void main(String[] args) {
    MySM sm = new MySM();
    System.out.println(System.getSecurityManager());
    System.setSecurityManager(sm);//注释掉测一下
    System.exit(0);
}
}

注释掉代码中的注释行，系统打印null，然后正常退出。当我们打开注释，并且自己扩展一个SecurityManager——MySM，它做的事情很简单，就是覆盖了checkExit方法，在系统退出时抛出一个“no exit”的异常。再执行，结果变成了

null
Exception in thread "main" java.lang.SecurityException: no exit
    at com.taobao.cd.security.SecurityManagerTest$MySM.checkExit(SecurityManagerTest.java:7)
    at java.lang.Runtime.exit(Runtime.java:107)
    at java.lang.System.exit(System.java:971)
    at com.taobao.cd.security.SecurityManagerTest.main(SecurityManagerTest.java:16)

显然，安全管理器生效了。

3.2 访问控制器 AccessController

java.security.AccessController

揭开沙箱面纱，第一步时安全管理器，那么第二步就是访问控制器了。因为沙箱的所有check方法实现，都是基于AccessController的。

3.2.1 组成

  • 代码源CodeSource

CodeSource就是一个简单的类，用来声明从哪里加载类。

  • 权限Permission

Permission类是AccessController处理的基本实体。Permission类本身是抽象的，它的一个实例代表一个具体的权限。权限有两个作用，一个是允许Java API完成对某些资源的访问。另一个是可以为自定义权限提供一个范本。权限包含了权限类型、权限名和一组权限操作。具体可以看看BasicPermission类的代码。典型的也可以参看FilePermission的实现。

  • 策略Policy

策略是一组权限的总称，用于确定权限应该用于哪些代码源。话说回来，代码源标识了类的来源，权限声明了具体的限制。那么策略就是将二者联系起来，策略类Policy主要的方法就是getPermissions(CodeSource)和refresh()方法。Policy类在老版本中是abstract的，且这两个方法也是。在jdk1.8中已经不再有abstract方法。这两个方法也都有了默认实现。

在JVM中，任何情况下只能安装一个策略类的实例。安装策略类可以通过Policy.setPolicy()方法来进行，也可以通过java.security文件里的policy.provider=sun.security.provider.PolicyFile来进行。jdk1.6以后，Policy引入了PolicySpi，后续的扩展基于SPI进行。

  • 保护域ProtectionDomain

保护域可以理解为代码源和相应权限的一个组合。表示指派给一个代码源的所有权限。看概念，感觉和策略很像，其实策略要比这个大一点，保护域是一个代码源的一组权限，而策略是所有的代码源对应的所有的权限的关系。

JVM中的每一个类都一定属于且仅属于一个保护域，这由ClassLoader在define class的时候决定。但不是每个ClassLoader都有相应的保护域，核心Java API的ClassLoader就没有指定保护域，可以理解为属于系统保护域。

3.2.2 AccessController

了解了组成，再回头看AccessController。这是一个无法实例化的类——仅仅可以使用其static方法。AccessController最重要的方法就是checkPermission()方法，作用是基于已经安装的Policy对象，能否得到某个权限。

回到Java 安全模型，你了解了吗

Java安全——理解Java沙箱

Java安全——安全管理器、访问控制器和类装载器

为什么说Java语言是安全的？（Java安全机制）

java安全性语言

Spring源码--关于AccessController.doPrivileged

 

 

知识整理

相关

「笔记」数论知识整理

ML知识整理

UBNT ex-r +netgear gs105e v2 +ap 设置vlan 步骤记录 及相关知识整理

Kafka基本知识整理

【测试平台开发】十九、前端vue重构 — computed、watch、组件通信等常用知识整理

标签