Google 翻译 - Java Development Kit（JDK）中的权限 - JDK中的权限

跳到内容

主页

搜索

    • *

Java Development Kit（JDK）中的权限

权限表示对系统资源的访问。为了允许applet（或使用安全管理器运行的应用程序）进行资源访问，必须为尝试访问的代码显式授予相应的权限。

权限通常具有名称（通常称为“目标名称”），在某些情况下，还包含一个或多个动作的逗号分隔列表。例如，以下代码创建一个FilePermission对象，表示abc对/tmp目录中指定的文件的读访问权 ：

perm = new java.io.FilePermission（“/ tmp / abc”，“read”）;

在此，目标名称为“ /tmp/abc”，操作字符串为“ read”。

重要说明：上述语句创建了一个权限对象。权限对象表示系统资源，但不授予对系统资源的访问权限。根据有效的策略构造和分配（“授予”）权限对象的权限对象。将权限对象分配给某些代码时，将以指定的方式授予该代码访问权限对象中指定的系统资源的权限。当做出访问决定时，当前安全管理器也可以构造许可对象。在这种情况下，（目标）许可对象是基于请求的访问创建的，并根据发出请求的代码授予和保持的权限对象进行检查。

Java应用程序环境的策略由Policy对象表示。在"JavaPolicy"策略实施中，可以在一个或多个策略配置文件中指定策略。策略文件指定允许来自指定代码源的代码的权限。从授予代码样本政策文件条目 /home/sysadmin读访问目录的文件 /tmp/abc是

grant codeBase“file：/ home / sysadmin /”{ permission java.io.FilePermission“/ tmp / abc”，“read”; };

有关策略文件位置和授予策略文件权限的信息，请参阅默认策略实施和策略文件语法。有关使用策略工具指定权限的信息，请参阅策略工具文档（适用于Solaris，Linux或Mac OS X）（适用于Windows）。使用 策略工具可以节省输入，并且无需了解策略文件所需的语法。

从技术上讲，每当尝试资源访问时， 执行线程到达该点的_所有_代码_都_必须具有该资源访问权限，除非该线程上的某些代码已被标记为“特权”。有关“特权”代码的详细信息，请参阅特权块API。

本文档包含描述内置JDK权限类型的表，并讨论授予每个权限的风险。它还包含表格，显示需要权限才能成功的方法，以及每个列出所需权限的方法。

涵盖以下主题：

有关权限的详细信息，包括超java.security.Permission和 java.security.BasicPermission，以及创建权限对象和授予权限的示例，请参阅 安全体系结构规范。

    • *

许可说明和风险

下表描述了内置的JDK权限类型，并讨论了授予每个权限的风险。

AWTPermission

A java.awt.AWTPermission 代表AWT权限。

下表列出了所有可能的 AWTPermission目标名称，每个名称都提供了权限允许的说明，并讨论了授予代码权限的风险。

java.awt.AWTPermission
目标名称

权限允许的内容

允许此许可的风险

accessClipboard

向AWT剪贴板发送信息和从AWT剪贴板检索信息

这将允许恶意代码共享潜在的敏感或机密信息。

accessEventQueue

访问AWT事件队列

在检索AWT事件队列之后，恶意代码可以查看甚至从系统中删除现有事件，以及发布虚假事件，这些事件可能故意导致应用程序或applet以不安全的方式行为不当。

accessSystemTray

访问AWT SystemTray实例

这将允许恶意代码将托盘图标添加到系统托盘。首先，这样的图标可能看起来像某个已知应用程序（例如防火墙或防病毒）的图标，并命令用户做一些不安全的事情（借助气球消息）。其次，系统托盘可能充满托盘图标，因此任何人都不能添加托盘图标。

createRobot

创建java.awt.Robot对象

该java.awt.Robot对象允许代码生成本机级鼠标和键盘事件以及读取屏幕。它可能允许恶意代码控制系统，运行其他程序，读取显示，并拒绝用户的鼠标和键盘访问。

fullScreenExclusive

进入全屏独占模式

进入全屏独占模式允许直接访问低级别的图形卡内存。这可以用来欺骗系统，因为程序直接控制渲染。

listenToAllAWTEvents

聆听全系统的所有AWT活动

添加AWT事件侦听器后，恶意代码可能会扫描系统中调度的所有AWT事件，从而允许它读取所有用户输入（例如密码）。每个AWT事件侦听器都是从该事件队列的上下文中调用的 EventDispatchThread，因此如果还启用了accessEventQueue权限，恶意代码可能会在系统范围内修改AWT事件队列的内容，从而导致应用程序或applet以不安全的方式行为异常。

readDisplayPixels

从显示屏幕回读像素

诸如java.awt.Composite 允许任意代码检查显示器上的像素的接口之类的接口使得恶意代码能够窥探用户的活动。

replaceKeyboardFocusManager

设置KeyboardFocusManager特定线程。

安装SecurityManager时，必须为调用线程授予此权限才能替换当前的KeyboardFocusManager。如果未授予权限，则将抛出SecurityException。

setAppletStub

设置实现Applet容器服务的存根

恶意代码可能会设置applet的存根，并导致applet的意外行为或拒绝服务。

setWindowsAlwaysOnTop

设置窗口的always-on-top属性： Window.setAlwaysOnTop(boolean)

恶意窗口可能使自己看起来和行为像真正的完整桌面，因此毫无戒心的用户输入的信息被捕获并随后被滥用。

showWindowWithoutWarningBanner

显示窗口时不显示窗口是由applet创建的横幅警告

如果没有此警告，applet可能会弹出窗口而用户不知道它们属于applet。由于用户可以基于窗口是否属于applet（例如，在对话框中输入用户名和密码）来做出安全敏感决策，因此禁用此警告标题可能允许applet欺骗用户输入此类信息。

toolkitModality

创建TOOLKIT_MODAL对话框并设置TOOLKIT_EXCLUDE窗口属性。

当从applet显示工具包模式对话框时，它会阻止浏览器中的所有其他applet。从Java Web Start启动应用程序时，其窗口（例如安全对话框）也可能被工具包模式对话框阻止，从这些应用程序中显示。

watchMousePointer

随时获取有关鼠标指针位置的信息

不断观察鼠标指针，applet可以猜测用户正在做什么，即将鼠标移动到屏幕的左下角很可能意味着用户即将启动应用程序。如果使用虚拟键盘以便使用鼠标模拟键盘，则applet可能会猜测键入的内容。

FilePermission

A java.io.FilePermission 表示对文件或目录的访问。A FilePermission由路径名和对该路径名有效的一组操作组成。

Pathname是授予指定操作的文件或目录的路径名。以“/ *”结尾的路径名（其中“/”是文件分隔符，File.separatorChar）表示目录和该目录中包含的所有文件。以“/ - ”结尾的路径名表示（递归地）该目录中包含的所有文件和子目录。由特殊标记“<< ALL FILES >>”组成的路径名匹配任何文件。

由单个“*”组成的路径名表示当前目录中的所有文件，而由单个“ - ”组成的路径名表示当前目录中的所有文件，并且（递归地）表示当前目录中包含的所有文件和子目录。

要授予的操作将以包含零个或多个逗号分隔关键字的列表的字符串形式传递给构造函数。可能的关键字是“read”，“write”，“execute”，“delete”和“readLink”。它们的含义定义如下：

关键词

含义

read

阅读权限。

write

写入权限（包括创建权限）。

execute

执行权限。允许 Runtime.exec被调用。对应于 SecurityManager.checkExec。

delete

删除权限。允许 File.delete被调用。对应于 SecurityManager.checkDelete。

readLink

阅读链接的权限。允许通过调用readSymbolicLink方法读取符号链接的目标。

在处理之前，actions字符串将转换为小写。

授予FilePermissions 时要小心。考虑授予读取特别是对各种文件和目录的写访问权的含义。写入动作的“<< ALL FILES >>”权限特别危险。这授予了写入整个文件系统的权限。这有效地允许更换系统二进制文件，包括JVM运行时环境。

注意：代码总是可以从它所在的同一目录（或该目录的子目录）中读取文件; 它不需要明确的许可。代码还可以获取其执行目录的路径名，并且此路径名可能包含敏感信息。例如，如果从主目录（或主目录的子目录）执行代码，则路径名可以显示当前用户的名称。

SerializablePermission

A java.io.SerializablePermission 用于可序列化的权限。A SerializablePermission包含名称（也称为“目标名称”）但没有动作列表; 你要么拥有命名权限，要么没有。

目标名称是Serializable权限的名称（请参阅下文）。

下表列出了所有可能的 SerializablePermission目标名称，每个名称都提供了权限允许的说明，并讨论了授予代码权限的风险。

java.io.SerializablePermission
目标名称

权限允许的内容

允许此许可的风险

enableSubclassImplementation

实现ObjectOutputStream或 的子类ObjectInputStream分别覆盖对象的默认序列化或反序列化

代码可以使用它以有目的的恶意方式序列化或反序列化类。例如，在序列化期间，恶意代码可以使用此方法以攻击者可以轻松访问的方式有目的地存储机密私有字段数据。或者，在deserializaiton期间，它可以，例如，反序列化一个类，其所有私有字段归零。

enableSubstitution

在序列化或反序列化期间将一个对象替换为另一个对象

这很危险，因为恶意代码可以用具有错误或恶意数据的对象替换实际对象。

ManagementPermission

SecurityManager将SecurityManager使用在Java平台的管理界面中定义的调用方法运行的代码检查 的权限。

下表提供了权限允许的摘要说明，并讨论了授予代码权限的风险。

java.lang.management.ManagementPermission目标名称

权限允许的内容

允许此许可的风险

control

能够控制Java虚拟机的运行时特性，例如，为类加载或内存系统启用和禁用详细输出，设置内存池的阈值，以及启用和禁用线程争用监视支持。由此权限控制的某些操作可以公开有关正在运行的应用程序的信息，例如-verbose:class 标志。

这允许攻击者控制Java虚拟机的运行时特性并导致系统行为异常。攻击者还可以访问与正在运行的应用程序相关的一些信息。

monitor

能够检索有关Java虚拟机的运行时信息，例如线程堆栈跟踪，所有已加载类名的列表以及Java虚拟机的输入参数。

这允许恶意代码监视运行时信息并发现漏洞。

程序员通常不ManagementPermission直接创建对象。相反，它们是由安全策略代码基于读取安全策略文件创建的。

ReflectPermission

A java.lang.reflect.ReflectPermission 用于反射操作。ReflectPermission是一个_命名权限_，没有任何操作。该 suppressAccessChecks名称允许禁止标准语言访问检查 - 对于公共，默认（包）访问，受保护和私有成员 - 由反射对象在其使用点执行。该newProxyInPackage.{package name} 规定在指定的包来创建一个代理实例，它的非公共接口，代理类实现的能力。

下表提供了权限允许的摘要说明，并讨论了授予代码权限的风险。

java.lang.reflect.ReflectPermission
目标名称

权限允许的内容

允许此许可的风险

suppressAccessChecks

警告： _在授予代码权限之前应格外小心_，因为它提供了访问字段和调用类中方法的能力。这不仅包括公共领域，还包括受保护和私人领域和方法。

这是危险的，因为恶意代码可以访问通常不可用的信息（可能是机密信息）。

newProxyInPackage.{package name}

能够在指定包中创建代理实例，其中代理类实现非公共接口。

这使代码可以访问通常无法访问的包中的类，动态代理类位于系统保护域中。恶意代码可能会使用这些类来帮助尝试破坏系统中的安全性。

RuntimePermission

A java.lang.RuntimePermission 用于运行时权限。A RuntimePermission 包含名称（也称为“目标名称”）但没有动作列表; 你要么拥有命名权限，要么没有。

目标名称是运行时权限的名称（请参见下文）。命名约定遵循分层属性命名约定。此外，星号可能出现在名称的末尾，在“ .”之后，或单独出现，以表示通配符匹配。例如：“ loadLibrary.*”或“ *”有效，“ *loadLibrary”或“ a*b”无效。

下表列出了所有可能的 RuntimePermission目标名称，每个名称都提供了权限允许的说明，并讨论了授予代码权限的风险。

java.lang.RuntimePermission目标名称

权限允许的内容

允许此许可的风险

createClassLoader

创建一个类加载器

这是非常危险的许可。可以实例化自己的类加载器的恶意应用程序然后可以将自己的恶意类加载到系统中。这些新加载的类可以由类加载器放入任何保护域，从而自动授予类该域的权限。

getClassLoader

检索类加载器（例如，调用类的类加载器）

这将授予攻击者获取特定类的类加载器的权限。这很危险，因为访问类的类加载器允许攻击者加载该类加载器可用的其他类。通常，攻击者无法访问这些类。

setContextClassLoader

设置线程使用的上下文类加载器

当系统代码和扩展需要查找系统类加载器中可能不存在的资源时，它们将由上下文类加载器使用。授予setContextClassLoader权限将允许代码更改用于特定线程的上下文类加载器，包括系统线程。

enableContextClassLoaderOverride

子类实现线程上下文类加载器方法

当系统代码和扩展需要查找系统类加载器中可能不存在的资源时，它们将由上下文类加载器使用。授予enableContextClassLoaderOverride权限将允许Thread的子类覆盖用于获取或设置特定线程的上下文类加载器的方法。

closeClassLoader

关闭ClassLoader

授予此权限允许代码关闭它具有引用的任何URLClassLoader。

setSecurityManager

设置安全管理器（可能替换现有的安全管理器）

安全管理器是一个允许应用程序实现安全策略的类。授予setSecurityManager权限将允许代码通过安装不同的，可能限制较少的安全管理器来更改使用的安全管理器，从而绕过原始安全管理器强制执行的检查。

createSecurityManager

创建一个新的安全管理器

这使代码可以访问受保护的敏感方法，这些方法可能会泄露有关其他类或执行堆栈的信息。

getenv.{variable name}

读取指定环境变量的值

这将允许代码读取特定环境变量的值或确定其存在。如果变量包含机密数据，则这很危险。

exitVM.{exit status}

使用指定的退出状态暂停Java虚拟机

这允许攻击者通过自动强制虚拟机停止来发起拒绝服务攻击。注意：“exitVM。”权限自动授予从应用程序类路径加载的所有代码，从而使应用程序能够自行终止。此外，“exitVM”权限等同于“exitVM。”。

shutdownHooks

注册和取消虚拟机关闭挂钩

这允许攻击者注册恶意关闭挂钩，干扰虚拟机的干净关闭。

setFactory

设置ServerSocket或Socket使用的套接字工厂，或URL使用的流处理程序工厂

这允许代码设置套接字，服务器套接字，流处理程序或RMI套接字工厂的实际实现。攻击者可能会设置错误的实现，从而破坏数据流。

setIO

设置System.out，System.in和System.err

这允许更改标准系统流的值。攻击者可能会更改System.in以监视和窃取用户输入，或者可能将System.err设置为“null”OutputSteam，这将隐藏发送到System.err的任何错误消息。

modifyThread

线程，例如修改，通过调用主题 interrupt，stop，suspend， resume，setDaemon， setPriority，setName和 setUncaughtExceptionHandler方法

这允许攻击者修改系统中任何线程的行为。

stopThread

通过调用Thread stop 方法停止线程

这允许代码停止系统中的任何线程，前提是它已被授予访问该线程的权限。这构成了威胁，因为该代码可能通过杀死现有线程来破坏系统。

modifyThreadGroup

线程组，例如修改，通过对线程组的呼叫 destroy，getParent，resume， setDaemon，setMaxPriority， stop，和suspend方法

这允许攻击者创建线程组并设置其运行优先级。

getProtectionDomain

检索ProtectionDomain一个类

这允许代码获取特定代码源的策略信息。虽然获取策略信息不会损害系统的安全性，但它确实为攻击者提供了额外的信息，例如本地文件名，以便更好地针对攻击。

getFileSystemAttributes

检索文件系统属性

这允许代码获取文件系统信息，例如磁盘使用或调用者可用的磁盘空间。这有潜在危险，因为它公开了有关系统硬件配置的信息以及有关调用者写入文件权限的一些信息。

readFileDescriptor

读取文件描述符

这将允许代码读取与读取的文件描述符相关联的特定文件。如果文件包含机密数据，则这很危险。

writeFileDescriptor

写入文件描述符

这允许代码写入与描述符相关联的特定文件。这很危险，因为它可能允许恶意代码植入病毒，或者至少填满整个磁盘。

loadLibrary.{library name}

动态链接指定的库

允许applet权限加载本机代码库是危险的，因为Java安全体系结构并非旨在并且不会阻止本机代码级别的恶意行为。

`accessClassInPackage.
{package name}`

loadClass当类加载器调用SecurityManager checkPackageAcesss方法时，通过类加载器的方法访问指定的包

这使代码可以访问通常无法访问的包中的类。恶意代码可能会使用这些类来帮助尝试破坏系统中的安全性。

`defineClassInPackage.
{package name}`

defineClass当类加载器调用SecurityManager checkPackageDefinition 方法时，通过类加载器的方法定义指定包中的类。

这授予了在特定包中定义类的代码权限。这是危险的，因为具有此权限的恶意代码可能会在受信任的程序包中定义恶意类，例如 java.security或java.lang。

accessDeclaredMembers

警告：_在授予代码权限之前，应格外小心_，因为它提供了对类的声明成员的访问。

这授予代码查询类的公共，受保护，默认（包）访问以及私有字段和/或方法的权限。虽然代码可以访问私有和受保护的字段和方法名称，但它不能访问私有/受保护的字段数据，也无法调用任何私有方法。然而，恶意代码可能会使用此信息来更好地针对攻击。此外，它可以调用任何公共方法和/或访问类中的公共字段。如果代码通常无法调用这些方法和/或访问字段，这可能会很危险，因为它无法使用这些方法和字段将对象强制转换为类/接口。

queuePrintJob

启动打印作业请求

这可能会将敏感信息打印到打印机，或者只是浪费纸张。

getStackTrace

检索另一个线程的堆栈跟踪信息。

这允许检索另一个线程的堆栈跟踪信息。这可能允许恶意代码监视线程的执行并发现应用程序中的漏洞。

setDefaultUncaughtExceptionHandler

设置当线程由于未捕获的异常而突然终止时使用的默认处理程序。

这允许攻击者注册可能干扰线程终止的恶意未捕获异常处理程序。

preferences

表示访问java.util.prefs.Preferences实现用户或系统root所需的权限，而后者又允许在Preferences持久性后备存储中进行检索或更新操作。

如果运行代码的用户具有足够的OS权限来读取/写入该后备存储，则此权限允许用户读取或写入首选项后备存储。实际后备存储可以驻留在传统文件系统目录内或注册表内，具体取决于平台OS。

usePolicy

授予此权限会禁用Java Plug-In的默认安全提示行为。

有关更多信息，请参阅Java Plug-In的指南，Applet安全基础知识和usePolicy Permission。

与NIO相关的目标

RuntimePermission在JavaSE JDK的1.4版本中添加了 两个与NIO相关的目标：

selectorProvider charsetProvider

这些RuntimePermission都需要秒至授予其子类，并实现类 java.nio.channel.spi.SelectorProvider或 java.nio.charset.spi.CharsetProvider。在调用抽象基类构造函数期间检查权限。这些权限可确保对实现这些安全敏感提供程序机制的类的信任。

请参阅java.nio.channels.spi.SelectorProvider 和java.nio.channels.spi.CharsetProvider 了解更多信息。

NetPermission

A java.net.NetPermission 用于各种网络权限。A NetPermission 包含名称但不包含操作列表; 你要么拥有命名权限，要么没有。

下表列出了所有可能的 NetPermission目标名称，每个名称都提供了权限允许的说明，并讨论了授予代码权限的风险。

java.net.NetPermission
目标名称

权限允许的内容

允许此许可的风险

setDefaultAuthenticator

当代理或HTTP服务器请求身份验证时，能够设置检索身份验证信息的方式

恶意代码可以设置一个身份验证器，用于在检索用户输入时监视和窃取用户身份验证输入。

requestPasswordAuthentication

能够向在系统中注册的验证者请求密码

恶意代码可能会窃取此密码。

specifyStreamHandler

在构造URL时指定流处理程序的能力

恶意代码可能会创建一个URL，其中包含通常无法访问的资源（如file：/ foo / fum /），指定一个流处理程序，从其可以访问的某个位置获取实际字节。因此，它可能会欺骗系统为类创建一个ProtectionDomain / CodeSource，即使该类实际上并非来自该位置。

setProxySelector

能够设置代理选择器，用于决定在进行网络连接时使用哪些代理。

恶意代码可以设置ProxySelector，将网络流量定向到任意网络主机。

getProxySelector

获取代理选择器的能力用于决定在进行网络连接时使用哪些代理。

恶意代码可以使ProxySelector发现内部网络上的代理主机和端口，然后可能成为攻击的目标。

setCookieHandler

能够设置处理Http会话的高安全性敏感cookie信息的cookie处理程序。

恶意代码可以设置cookie处理程序以获取对高度安全性敏感的cookie信息的访问权限。某些Web服务器使用cookie来保存用户隐私信息（如访问控制信息）或跟踪用户浏览习惯。

getCookieHandler

获取处理Http会话的高安全性敏感cookie信息的cookie处理程序的能力。

恶意代码可以获取cookie处理程序以获取对高度安全性敏感的cookie信息的访问权限。某些Web服务器使用cookie来保存用户隐私信息（如访问控制信息）或跟踪用户浏览习惯。

setResponseCache

能够设置提供对本地响应缓存的访问的响应缓存。

访问本地响应缓存的恶意代码可能会访问安全敏感信息，或在响应缓存中创建错误条目。

getResponseCache

获取响应缓存的能力，该缓存提供对本地响应缓存的访问。

访问本地响应缓存的恶意代码可以访问安全敏感信息。

SocketPermission

A java.net.SocketPermission 表示通过套接字访问网络。SocketPermission包含主机规范和一组“操作”，指定连接到该主机的方法。主机指定为

host =（hostname | IPaddress）[：portrange] portrange = portnumber | -portnumber | portnumber- [端口号]

主机表示为DNS名称，数字IP地址或“localhost”（对于本地计算机）。通配符“*”可以包含在DNS名称主机规范中一次。如果包含它，它必须位于最左边的位置，如“* .sun.com”。

端口或端口范围是可选的。形式为“N-”的端口规范，其中_N_是端口号，表示编号为_N_及以上的所有端口，而形式“-N”的规范表示编号为_N_及以下的所有端口。

连接主机的可能方法是

接受 连 听 解决

“listen”操作仅在与“localhost”一起使用时才有意义。当存在任何其他操作时，隐含“解析”（解析主机/ IP名称服务查找）操作。

作为SocketPermissions的创建和含义的示例，请注意，如果策略文件中包含以下条目：

grant signedBy“mrm”{ 权限java.net.SocketPermission“puffin.example.com：7777”，“connect，accept”; };

这会导致生成以下权限对象并将其授予由“mrm”签名的代码。

p1 = new SocketPermission（“puffin.example.com：7777”，“connect，accept”）;

p1表示允许连接到端口7777的权限puffin.example.com，并且还接受该端口上的连接。

同样，如果您的政策中包含以下条目：

grant signedBy“paul”{ permission java.net.SocketPermission“localhost：1024-”，“accept，connect，listen”; };

这会导致生成以下权限对象并将其授予由“paul”签名的代码。

p2 = new SocketPermission（“localhost：1024-”，“accept，connect，listen”）;

p2 表示允许在本地主机上接受连接，连接或侦听1024和65535之间的任何端口的权限。

注意：授予代码接受或连接到远程主机的权限可能是危险的，因为恶意代码可以更容易地在可能无法访问数据的各方之间传输和共享机密数据。

URLPermission

表示访问由给定URL定义的资源或资源集的权限，以及给定的一组用户可设置的请求方法和请求标头的权限。权限的_名称_是url字符串。该_行动_字符串的请求方法和头的串联。方法和标题名称的范围不受此类的限制。

网址

url字符串具有以下预期结构。

scheme：//权限[/ path]

_scheme_通常是http或https，但不受此类的限制。 _权限_指定为：

authority = [userinfo @] hostrange [：portrange] portrange = portnumber | -portnumber | portnumber- [portnumber] | hostrange =（[。] dnsname）| IPv4地址| IPv6address

_dnsname_是标准DNS主机或域名，即。由“。”分隔的一个或多个标签。_IPv4address_是一个标准的文字IPv4地址和 _IPv6address_限定如 RFC 2732。但是，文字IPv6地址必须用“[]”字符括起来。该_DNSNAME_规范可以通过前面有“*”。这意味着该名称将匹配其最右侧域标签与此名称相同的任何主机名。例如，“* .oracle.com”匹配“foo.bar.oracle.com”

_portrange_用于指定此权限适用的端口号或有界或无界范围的端口。如果portrange不存在或无效，则假定方案是http（默认为80）或https （默认为443），则假定为默认端口号。其他方案没有默认值。可以指定通配符，表示所有端口。

_userinfo_是可选的。创建URLPermission时，将忽略userinfo组件（如果存在），并且不会影响此类定义的任何其他方法。

的_路径_成分包括路径段的序列，通过“/”字符分隔。_路径_也可能是空的。路径的指定方式与路径类似FilePermission。以下示例显示了三种不同的方式：

网址示例

示例网址

描述

http://www.oracle.com/a/b/c.html

标识特定（单个）资源的URL

http://www.oracle.com/a/b/*

'*'字符指的是同一“目录”中的所有资源 - 换句话说，所有资源具有相同数量的路径组件，并且仅在最终路径组件中有所不同，由'*'表示。

http://www.oracle.com/a/b/-

' - '字符在前面的路径下递归地引用所有资源（例如http://www.oracle.com/a/b/c/d/e.html匹配此示例）。

'*'和' - '只能在路径的最后一段中指定，并且必须是该段中唯一的字符。构造URLPermissions时，将忽略URL的任何查询或片段组件。

作为一种特殊情况，形式的网址“scheme：*”被认为是指给定方案的任何网址。

url字符串 的_方案_和_权限_组件在不考虑大小写的情况下进行处理。这意味着equals(Object)， hashCode()并且implies(Permission)对这些组件不区分大小写。如果_权限_包含文字IP地址，则对地址进行规范化以进行比较。路径组件区分大小写。

动作字符串

URLPermission的actions字符串是_方法列表_ 和_请求标头列表_的串联。这些是允许的请求方法和许可的允许请求标题（分别）的列表。这两个列表用冒号'：'字符分隔，每个列表的元素用逗号分隔。一些例子是：

“POST，GET，DELETE” “GET：X-美孚请求，X-BAR-请求” “POST，GET：头1，头2”

第一个示例指定方法：POST，GET和DELETE，但没有请求标头。第二个示例指定一个请求方法和两个标头。第三个示例指定了两个请求方法和两个标头。

如果请求标头列表为空，则不需要存在冒号分隔符。操作字符串中不允许使用空格。提供给URLPermission构造函数的操作字符串不区分大小写，并通过将方法名称转换为大写和标题名称到RFC2616中定义的格式进行规范化（小写，每个单词的首字母大写）。两个列表都可以包含通配符'*'字符，分别表示所有请求方法或标头。

注意：根据使用环境，可能始终允许某些请求方法和标头，并且可能随时不允许其他请求方法和标头。例如，HTTP协议处理程序可能会禁止某些标头（如Content-Length）由应用程序代码设置，无论有效的安全策略是否允许它。

注意：授予访问远程主机上的资源的代码权限可能是危险的，因为恶意代码可以更容易地在可能无法访问数据的各方之间传输和共享机密数据。

LinkPermission

Permission链接创建操作 的类。

下表提供了权限允许的摘要说明，并讨论了授予代码权限的风险。

java.nio.file.LinkPermission目标名称

权限允许的内容

允许此许可的风险

hard

能够将现有文件添加到目录。这有时被称为创建链接或硬链接。

在授予此权限时应格外小心。它允许链接到文件系统中的任何文件或目录，从而允许攻击者访问所有文件。

symbolic

能够创建符号链接。

在授予此权限时应格外小心。它允许链接到文件系统中的任何文件或目录，从而允许攻击者访问所有文件。

AllPermission

该java.security.AllPermission 权限暗示所有其他权限。

注意：授予AllPermission应该非常小心，因为它意味着所有其他权限。因此，它授予代码在禁用安全性的情况下运行的能力。在授予代码许可权之前，应格外小心。此权限仅应在测试期间使用，或者在极少数情况下，应用程序或applet完全受信任，并且对策略添加必要的权限非常麻烦。

SecurityPermission

A java.security.SecurityPermission 用于安全权限。A SecurityPermission 包含名称（也称为“目标名称”）但没有动作列表; 你要么拥有命名权限，要么没有。

目标名称是安全配置参数的名称（请参见下文）。目前，该 SecurityPermission对象被用于保护访问Policy，Security， Provider，Signer，和 Identity对象。

下表列出了所有可能的 SecurityPermission目标名称，每个名称都提供了权限允许的说明，并讨论了授予代码权限的风险。

java.security.SecurityPermission
目标名称

权限允许的内容

允许此许可的风险

createAccessControlContext

创造一个 AccessControlContext

这允许某人AccessControlContext用a 实例化 DomainCombiner。在授予此权限时必须格外小心。恶意代码可以创建一个 DomainCombiner扩充授予代码的权限集，甚至授予代码 AllPermission。

getDomainCombiner

检索一个AccessControlContext's DomainCombiner

这允许某人通过getPermissions调用查询策略，该调用公开了授予给定CodeSource的权限。虽然揭示该策略并未损害系统的安全性，但它确实为恶意代码提供了可用于更好地针对攻击的其他信息。明智的做法是不要泄露超出必要的信息。

getPolicy

检索系统范围的安全策略（特别是当前安装的Policy对象）

这允许某人通过getPermissions调用查询策略，该 调用公开了将给予给定的权限CodeSource。虽然揭示该策略并未损害系统的安全性，但它确实为恶意代码提供了可用于更好地针对攻击的其他信息。明智的做法是不要泄露超出必要的信息。

setPolicy

设置系统范围的安全策略（特别是Policy对象）

授予此权限非常危险，因为恶意代码可能会授予自己成功装入系统所需的所有必要权限。

createPolicy.{policy type}

通过Policy.getInstance获取策略实例

授予此权限可使代码获取Policy对象。恶意代码可能会查询Policy对象以确定已授予除其自身之外的代码的权限。

getProperty.{key}

使用指定的密钥检索安全属性

根据授予访问权限的特定密钥，代码可以访问安全提供程序列表，以及系统范围和用户安全策略的位置。虽然揭示这些信息并不会损害系统的安全性，但它确实为恶意代码提供了可用于更好地瞄准攻击的附加信息。

setProperty.{key}

使用指定密钥设置安全属性

这可能包括设置安全提供程序或定义系统范围的安全策略的位置。有权设置新安全提供程序的恶意代码可能会设置窃取加密私钥等机密信息的恶意程序提供程序。此外，具有设置系统范围安全策略位置权限的恶意代码可能会将其指向一个安全策略，该策略授予攻击者成功在系统上安装攻击所需的所有必要权限。

insertProvider

增加一个新的提供者

这将允许某人引入可能恶意的提供者（例如，公开传递给它的私钥的提供者）作为最高优先级的提供者。这是可能的，因为Security对象（管理已安装的提供程序）当前不会在附加提供程序之前检查提供程序的完整性或真实性。“insertProvider”权限包含“insertProvider。{provider name}”权限（有关详细信息，请参阅下面的部分）。

removeProvider.{provider name}

删除指定的提供程序

这可能会改变行为或禁用程序其他部分的执行。如果程序随后请求的提供程序已被删除，则执行可能会失败。此外，如果程序的其余部分未明确请求删除的提供程序，但通常是在请求加密服务时选择的提供程序（由于其先前在提供程序列表中的顺序），将选择不同的提供程序相反，或者找不到合适的提供者，从而导致程序失败。

clearProviderProperties.{provider name}

“清除”提供程序，使其不再包含用于查找提供程序实现的服务的属性

这将禁用查找提供程序实现的服务。因此，这可能会改变行为或禁止执行通常使用Provider的程序的其他部分，如“removeProvider。{provider name}”权限所述。

putProviderProperty.{provider name}

设置指定Provider的属性

提供程序属性均指定提供程序实现的特定服务的名称和位置。通过授予此权限，您可以让代码将服务规范替换为另一个，从而指定不同的实现。

removeProviderProperty.{provider name}

从指定的Provider中删除属性

这将禁用查找提供程序实现的服务。由于删除了指定其名称和位置的属性，因此无法再访问它们。这可能会改变行为或禁用通常使用Provider的程序的其他部分的执行，如“removeProvider。{provider name}”权限中所述。

：下面的权限与已过时的类相关联的Identity，IdentityScope， Signer。不鼓励使用它们。有关更多信息，请参阅适用的类。

java.security.SecurityPermission
目标名称

权限允许的内容

允许此许可的风险

insertProvider.{provider name}

添加具有指定名称的新提供程序

这将允许某人引入可能恶意的提供者（例如，公开传递给它的私钥的提供者）作为最高优先级的提供者。这是可能的，因为Security对象（管理已安装的提供程序）当前不会在附加提供程序之前检查提供程序的完整性或真实性。

setSystemScope

设置系统标识范围

这将允许攻击者使用不应信任的证书配置系统标识范围，从而授予使用系统原始标识范围拒绝的那些证书特权签名的applet或应用程序代码。

setIdentityPublicKey

设置身份的公钥

如果身份被标记为“受信任”，则允许攻击者引入不受系统身份范围信任的不同公钥（例如，其自己），从而授予使用该公钥特权签名的applet或应用程序代码。否则被拒绝。

setIdentityInfo

设置标识的常规信息字符串

这允许攻击者设置身份的一般描述。这可能会欺骗应用程序使用与预期不同的身份，或者可能阻止应用程序查找特定身份。

addIdentityCertificate

为身份添加证书

这允许攻击者为身份的公钥设置证书。这很危险，因为它会影响整个系统的信任关系。这个公钥突然变得比其他人更可信。

removeIdentityCertificate

删除身份证书

这允许攻击者删除身份公钥的证书。这很危险，因为它会影响整个系统的信任关系。这个公钥突然被认为不如它本来可信。

printIdentity

查看主体的名称以及可选的使用范围，以及在该范围内是否将其视为“受信任”。

打印出的范围可以是文件名，在这种情况下，它可以传达本地系统信息。例如，这是一个名为“carol”的身份的打印输出示例，在用户的身份数据库中标记为不受信任：
carol [/home/luehe/identitydb.obj] [不信任]

getSignerPrivateKey

检索签名者的私钥

允许访问私钥是非常危险的; 私钥应该保密。否则，代码可以使用私钥对各种文件进行签名，并声明签名来自签名者。

setSignerKeyPair

设置签名者的密钥对（公钥和私钥）

这将允许攻击者用可能较弱的密钥对（例如，较小密钥大小的密钥对）替换其他人（“目标”）密钥对。这也将允许攻击者监听目标与其对等体之间的加密通信。目标的对等体可以在目标的“新”公钥下包装加密会话密钥，这将允许攻击者（拥有相应的私钥）解包会话密钥并解密在该会话密钥下加密的通信数据。

UnresolvedPermission

该java.security.UnresolvedPermission 级用来保持Permissions表示是“悬而未决”的时候Policy被初始化。未解析的权限是Permission 在Policy初始化时其实际类尚不存在的权限（见下文）。

Java运行时的策略（指定哪些权限可用于来自各种主体的代码）由Policy对象表示 。每当Policy初始化或刷新a时，都会Permission为所允许的所有权限创建适当类的对象 Policy。

策略配置引用的许多权限类类型是本地存在的权限类型（即可以在CLASSPATH上找到的权限类型）。可以在初始化期间实例化用于此类权限的对象Policy。例如，始终可以实例化a java.io.FilePermission，因为FilePermission在CLASSPATH上找到了 类。

Policy初始化期间可能尚不存在其他权限类 。例如，引用的权限类可能位于稍后将加载的JAR文件中。对于每个这样的类，UnresolvedPermission都会实例化。因此，a UnresolvedPermission本质上是包含有关权限的信息的“占位符”。

稍后，当代码调用 AccessController.checkPermission以前未解析的类型的权限，但其类已被加载时，该类型的先前未解析的权限将被“解析”。也就是说，对于每个这样的 UnresolvedPermission，基于中的信息来实例化适当类类型的新对象 UnresolvedPermission。这个新对象取代了UnresolvedPermission被删除的对象 。

SQLPermission

SecurityManager将在applet中运行的代码或具有SecurityManager启用实例的应用程序检查的权限将调用以下方法之一：

  • java.sql.DriverManager.setLogWriter
  • java.sql.DriverManager.setLogStream （废弃）
  • javax.sql.rowset.spi.SyncFactory.setJNDIContext
  • javax.sql.rowset.spi.SyncFactory.setLogger
  • java.sql.Connection.setNetworktimeout
  • java.sql.Connection.abort

如果没有SQLPermission对象，这些方法会抛出java.lang.SecurityException一个运行时异常。

甲SQLPermission对象包含一个名称（也被称为“目标名称”），但没有动作列表; 有命名权限或没有。目标名称是权限的名称（请参阅下表列出所有可能的SQLPermission名称）。命名约定遵循分层属性命名约定。此外，星号（*）可能出现在名称的末尾，跟在点（.）之后，或者单独出现，以表示通配符匹配。例如：loadLibrary.*或者 *是有效的，但*loadLibrary还是 a*b无效。

下表列出了所有可能的 SQLPermission目标名称。该表描述了权限允许的内容，并讨论了授予代码权限的风险。

java.sql.SQLPermission目标名称

什么权限允许

允许此许可的风险

setLog

设置日志记录流

这是一项危险的授权许可。日志的内容可以包含用户名和密码，SQL语句和SQL数据。

callAbort

调用Connection方法 abort

允许应用程序终止与数据库的物理连接。

setSyncFactory

调用SyncFactory方法 setJNDIContext和setLogger

允许应用程序指定SyncProvider可从中检索实现的JNDI上下文以及实现要使用的日志记录对象SyncProvider 。

setNetworkTimeout

调用Connection方法 setNetworkTimeout

允许应用程序指定Connection从对象创建的Connection对象或 对象将等待数据库回复任何一个请求的最长期限 。

deregisterDriver

允许调用DriverManager方法deregisterDriver。

允许应用程序从已注册的驱动程序列表中删除JDBC驱动程序并释放其资源。

LoggingPermission

当代码运行时， A SecurityManager将检查java.util.logging.LoggingPermission对象，并SecurityManager调用其中一个日志记录控制方法（例如 Logger.setLevel）。

目前只有一个名为 LoggingPermission“ control”。 control授予控制日志记录配置的能力; 例如，通过添加或删除处理程序，添加或删除过滤器，或更改日志记录级别。

通常你不LoggingPermission 直接创建对象; 相反，它们是由安全策略代码基于读取安全策略文件创建的。

PropertyPermission

A java.util.PropertyPermission 用于属性权限。

名称是属性的名称（“java.home”，“os.name”等）。命名约定遵循分层属性命名约定。此外，星号可能出现在名称的末尾，在“。”之后，或单独出现，以表示通配符匹配。例如：“java。”或“”有效，“ java”或“a b”无效。

要授予的操作将以包含零个或多个逗号分隔关键字的列表的字符串形式传递给构造函数。可能的关键字是“读”和“写”。它们的含义定义如下：

关键词

含义

read

阅读权限。允许 System.getProperty被调用。

write

写入权限。允许 System.setProperty被调用。

在处理之前，actions字符串将转换为小写。

在授予访问某些系统属性的代码权限之前，应该小心。例如，授予访问“java.home”系统属性的权限可能会提供有关系统环境（运行时环境目录的位置）的潜在恶意代码敏感信息。此外，授予访问“user.name”和“user.home”系统属性的权限可能会提供有关用户环境（用户的帐户名和主目录）的潜在恶意代码敏感信息。

MBeanPermission

权限控制对MBeanServer操作的访问。如果已设置安全管理器System.setSecurityManager(java.lang.SecurityManager)，则大多数操作MBeanServer 都要求调用者的权限意味着MBeanPermission 适合该操作。这在MBeanServer界面文档中有详细描述。

与其他Permission对象一样，MBeanPermission可以表示您_拥有_的权限或您_需要_的权限。在检查敏感操作的权限时，将MBeanPermission构造一个表示您需要的权限的操作。如果你有权限的操作只能意味着你需要的权限。

一个MBeanPermission包含四项信息：

  • 该_行动_。对于您需要的权限，这是以下列表中的操作之一。对于您拥有的权限，这是以逗号分隔的这些操作列表，或*代表所有操作。

    该操作由返回getActions()。

  • 在_类名_。

    对于您需要的权限，这是MBean 您正在访问的类名，如返回的MBeanServer.getMBeanInfo(name)。getClassName()。某些操作不引用类名，在这种情况下类名为null。

    对于您拥有的权限，这可以是空的或_类名模式_。类名模式是遵循点分隔类名的Java约定的字符串。它可能以“ .*” 结尾，表示权限授予对以“ .*” 之前的字符串开头的任何类的访问权限。例如，“ javax.management.*”授予访问javax.management.MBeanServerDelegate和 javax.management.timer.Timer其他类的访问权限 。

    类名模式也可以是空的或单个字符“ *”，两者都授予对任何类的访问权限。

  • 该_成员_。

    对于您需要的权限，这是您正在访问的属性或操作的名称。对于不引用属性或操作的操作，该成员为null。

    对于您拥有的权限，这可以是您可以访问的属性或操作的名称，也可以是空或单个字符“ *”，两者都授予对任何成员的访问权限。

  • 该_对象名称_。

    你需要一个许可，这是ObjectName的 MBean，你正在访问。对于不引用单个操作的操作MBean，它为null。它永远不是对象名称模式。

    对于你有一个权限，这是ObjectName的 MBean或者MBean是你能访问。它可能是一个对象名称模式，用于授予对MBean名称与模式匹配的所有s的访问权限。它也可能是空的，无论其名称如何，都可以访问所有MBean。

如果你有MBeanPermission，它只允许所有四个项目匹配时的操作。

类名，成员和对象名可以作为单个字符串一起写入，该字符串是此权限的_名称_。权限的名称是返回的字符串getName()。字符串的格式是：

className#member[objectName]

对象名称使用通常的语法编写ObjectName。它可能包含任何合法字符，包括 ]。它由]字符串终止，该字符是字符串中的最后一个字符。

一个或多个的className，member或objectName可被省略。如果 member省略，则#可能也是（但不一定）。如果objectName省略，则[]可能也是（但不一定）。省略所有三个项目是不合法的，即具有 空字符串的_名称_。

一个或多个的className，member或objectName可以是字符“ -”，其等同于一个空值。任何值（包括另一个空值）都隐含空值，但不暗示任何其他值。

可能的行动是这些：

  • addNotificationListener
  • getAttribute
  • getClassLoader
  • getClassLoaderFor
  • getClassLoaderRepository
  • getDomains
  • getMBeanInfo
  • getObjectInstance
  • instantiate
  • invoke
  • isInstanceOf
  • queryMBeans
  • queryNames
  • registerMBean
  • removeNotificationListener
  • setAttribute
  • unregisterMBean

在逗号分隔的操作列表中，每个操作之前和之后都允许使用空格。

MBeanServerPermission

执行与MBeanServers 相关的操作的权限。权限的_名称_指定权限请求或授予的操作。对于授予的权限，可以 *允许MBeanServer下面指定的所有操作。否则，对于授予或请求的权限，它必须是以下之一：

createMBeanServer

使用方法MBeanServerFactory.createMBeanServer()或 创建新的MBeanServer对象 MBeanServerFactory.createMBeanServer(java.lang.String)。

findMBeanServer

使用该方法查找MBeanServer具有给定名称或MBeanServer此JVM中的所有名称的内容MBeanServerFactory.findMBeanServer(java.lang.String)。

newMBeanServer

MBeanServer使用方法MBeanServerFactory.newMBeanServer()或 创建新对象而不保留对它的引用MBeanServerFactory.newMBeanServer(java.lang.String)。

releaseMBeanServer

使用该方法删除对a MBeanServerFactory的引用。 MBeanServerMBeanServerFactory.releaseMBeanServer(javax.management.MBeanServer)

权限 的_名称_还可以表示一个或多个以逗号分隔的操作的列表。在_名称_的开头和结尾以及逗号前后都允许使用空格。

MBeanServerPermission("createMBeanServer")暗示 MBeanServerPermission("newMBeanServer")。

MBeanTrustPermission

此权限表示签名者或代码库中的“信任”。

MBeanTrustPermission包含目标名称但没有操作列表。为此权限定义了单个目标名称“register”。目标“*”也是允许的，允许“注册”以及可能定义的任何未来目标。该操作仅允许空值或空字符串，以允许策略对象创建策略文件中指定的权限。

如果签名者或codesource被授予此权限，则它被视为MBeans 的可信源。只有MBean来自可靠来源的s才能注册MBeanServer。

SubjectDelegationPermission

身份验证标识要求的权限，以代表授权标识执行操作。

A SubjectDelegationPermission包含名称（也称为“目标名称”）但没有动作列表; 你要么拥有命名权限，要么没有。

目标名称是授权主体类名的名称，后跟句点和授权主体名称，即 。"_PrincipalClassName_._PrincipalName_"

星号可以单独出现，或者如果紧接着前面有“。”。可能出现在目标名称的末尾，表示通配符匹配。

例如"*"，"javax.management.remote.JMXPrincipal.*"并且 "javax.management.remote.JMXPrincipal.delegate"是有效的目标名称。第一种是指任何主要名称从任何主要类，第二个表示具体主体类的任何主体名称javax.management.remote.JMXPrincipal 和第三个表示混凝土主体名称 delegate混凝土主体类的 javax.management.remote.JMXPrincipal。

SSLPermission

该javax.net.ssl.SSLPermission 班是用于各种网络权限。一个 SSLPermission包含一个名称（也被称为“目标名称”），但没有动作列表; 你要么拥有命名权限，要么没有。

目标名称是网络权限的名称（见下文）。命名约定遵循分层属性命名约定。此外，星号可能出现在名称的末尾，在“ .”之后，或单独出现，以表示通配符匹配。例如：“ foo.*”或“ *”有效，“ *foo”或“ a*b”无效。

下表列出了所有可能的SSLPermission目标名称，每个目录名称都提供了权限允许的说明，并讨论了授予代码权限的风险。

权限目标名称

权限允许的内容

允许此许可的风险

setHostnameVerifier

能够设置回调，该回调可以决定是否允许连接的主机与HttpsURLConnection服务器证书中的公共名称字段不匹配 。

恶意代码可以设置验证程序，该验证程序监视HttpsURLConnection请求访问的主机名，或允许具有无效公用名的服务器证书。

getSSLSessionContext

得到SSLSessionContext一个 的能力SSLSession。

恶意代码可能会监视已使用SSL对等方建立的会话，或者可能使会话无效以降低性能。

setDefaultSSLContext

能够设置默认SSL上下文。

当应用程序使用默认SSLContext时，通过设置默认SSL上下文，恶意代码可能使用未经证实的信任材料，密钥材料和随机生成器，或使用危险的SSL套接字工厂和SSL服务器套接字工厂。

AuthPermission

在javax.security.auth.AuthPermission 类用于身份验证权限。一个 AuthPermission包含一个名称（也被称为“目标名称”），但没有动作列表; 你要么拥有命名权限，要么没有。

目前，该AuthPermission对象被用于保护访问Subject， SubjectDomainCombiner，LoginContext和 Configuration对象。

下表列出了所有可能的 AuthPermission目标名称，每个名称都提供了权限允许的说明，并讨论了授予代码权限的风险。

权限目标名称

权限允许的内容

允许此许可的风险

doAs

调用Subject.doAs方法

这使应用程序Subject能够在doAs方法指定 的任何标识下调用代码（Actions）。

doAsPrivileged

调用Subject.doAsPrivileged 方法

这使应用程序Subject能够在doAsPrivileged方法指定 的任何标识下调用代码（Actions）。此外，呼叫者可以从调用栈（因此从后续安全决定和）如果通过除去本身null为 AccessControlContext。

getSubject

Subject从提供的中 检索AccessControlContext

这允许应用程序访问经过身份验证的访问 Subject。然后，应用程序可以访问Subject的经过身份验证的Principal和公共凭据。

getSubjectFromDomainCombiner

Subject从a中 检索SubjectDomainCombiner

这允许应用程序访问Subject与a关联 的已验证身份 SubjectDomainCombiner。然后，应用程序可以访问Subject的经过身份验证的Principal和公共凭据。

setReadOnly

设置Subject只读

这允许应用程序将Subject Principal，Public凭据和私有凭证集设置为只读。这可能会被用作一种拒绝服务攻击。

modifyPrincipals

对主题Principal 集进行修改

访问控制决策基于与a关联的Principals Subject。此权限允许应用程序对主题Principal 集进行任何修改，从而影响后续安全决策。

modifyPublicCredentials

对Subject的公共凭据集进行修改

此权限允许应用程序从a添加或删除公共凭据Subject。这可能会影响依赖于其中存在的适当私有凭证集的代码 Subject。

modifyPrivateCredentials

对Subject的私有凭证集进行修改

此权限允许应用程序从a添加或删除私有凭据Subject。这可能会影响依赖于其中存在的适当私有凭证集的代码 Subject。

refreshCredential

刷新Object实现该 Refreshable接口的凭据

此权限允许应用程序刷新旨在过期的凭据。

destroyCredential

销毁Object实现 Destroyable接口的凭证

此权限允许应用程序潜在地破坏凭证作为拒绝服务攻击。

createLoginContext.{name}

LoginContext使用指定的 _名称_实例化a

出于安全考虑，管理员可能不希望应用程序能够对任何应用程序进行身份验证 LoginModule。此权限允许应用程序对为指定_名称_配置的LoginModule进行身份验证 。

getLoginConfiguration

检索系统范围的登录 Configuration

允许应用程序确定为系统中的每个应用程序配置的所有LoginModule。

setLoginConfiguration

设置系统范围的登录 Configuration

允许应用程序为系统中的每个应用程序配置LoginModule。

createLoginConfiguration.{configuration type}

通过Configuration.getInstance获取Configuration对象

允许应用程序查看配置中指定的所有LoginModule。

refreshLoginConfiguration

刷新系统范围的登录 Configuration

允许应用程序刷新登录 Configuration。

DelegationPermission

所述 类用于限制Kerberos代理模型的使用; 即可转发和可代理的门票。 javax.security.auth.kerberos.DelegationPermission

此Permission的目标名称指定一对kerberos服务主体。第一个是委托使用票证授予票证（TGT）的从属服务主体。第二服务主体指定下级服务主体代表发起进行交互的目标服务 KerberosPrincipal。后一服务主体被指定用于限制可代理票证的使用。

例如，要指定可转发TGT的“主机”服务使用，目标权限指定如下：

DelegationPermission（“\”host/foo.example.com@EXAMPLE.COM \“\”krbtgt/EXAMPLE.COM@EXAMPLE.COM \“”）;

要为“备份”服务提供可代理的NFS服务票证，可以指定目标权限：

DelegationPermission（“\”backup/bar.example.com@EXAMPLE.COM \“\”nfs / home.EXAMPLE.COM@EXAMPLE.COM \“”）;

ServicePermission

该 javax.security.auth.kerberos.ServicePermission班是用来保护需要访问这些服务Kerberos服务和凭据。服务主体与访问服务所需的凭证之间存在一对一的映射。因此，授予对服务主体的访问权限会隐式授予对与服务主体建立安全上下文所必需的凭证的访问权限。无论凭据是在缓存中还是通过与KDC的交换获取，这都适用。凭证可以是票证授予票证，服务票证或密钥表中的密钥。

A ServicePermission contains a service principal name and a list of actions which specify the context the credential can be used within.

The service principal name is the canonical name of the KereberosPrincipal supplying the service, that is the KerberosPrincipal represents a Kerberos service principal. This name is treated in a case sensitive manner.

Granting this permission implies that the caller can use a cached credential (Ticket Granting Ticket, service ticket or secret key) within the context designated by the action. In the case of the TGT, granting this permission also implies that the TGT can be obtained by an Authentication Service exchange.

The possible actions are:

Action

Meaning

initiate

Allows the caller to use the credential to initiate a security context with a service principal.

accept

允许调用者使用凭据接受安全上下文作为特定主体。

例如，要指定访问TGT以启动安全上下文的权限，权限的构造如下：

ServicePermission（“krbtgt/EXAMPLE.COM@EXAMPLE.COM”，“启动”）;

要获取服务票证以使用“host”服务启动上下文，权限的构造如下：

ServicePermission（“host/foo.example.com@EXAMPLE.COM”，“发起”）;

对于Kerberized服务器，操作是“接受”。例如，访问和使用Kerberized“主机”服务（telnet等）的密钥所需的权限将按如下方式构造：

ServicePermission（“host/foo.example.com@EXAMPLE.COM”，“接受”）;

PrivateCredentialPermission

该 班是用来保护对属于一个特定的私人证书主题。本主题由一组校长表示。 javax.security.auth.PrivateCredentialPermission

此Permission的目标名称指定 Credential类名称和一组Principal。这个动作唯一有效的值Permission是“读”。目标名称必须遵循以下语法：

CredentialClass {PrincipalClass“PrincipalName”} *

例如，以下权限授予对com.sun.PrivateCredential拥有 名称为“ ”的Subjects 的所有者的 访问权限 。 com.sun.Principal`duke`

Note: Although this example, as well as all the examples below, do not contain Codebase, SignedBy, or Principal information in the grant statement (for simplicity reasons), actual policy configurations should specify that information when appropriate.

grant {

permission javax.security.auth.PrivateCredentialPermission
         "com.sun.PrivateCredential com.sun.Principal \\"duke\\"",
         "read";

};

如果CredentialClass是“ *”，则授予Credential属于指定主题的所有私有的访问权限。如果“ PrincipalName”是“ *”，则访问被授予 Credential由具有指定Principal的任何Subject所拥有的指定（实际 无关紧要）。例如，下面的授权访问 所拥有的任何主题有一个。 PrincipalName`a.b.Credential`a.b.Principal

授予{ 权限javax.security.auth.PrivateCredentialPermission “abCredential abPrincipal”*“”， “读”; };

如果PrincipalClass和“ PrincipalName”都是“ *”，则访问被授予Credential任何Subject所拥有 的指定。此外， PrincipalClass/ PrincipalName配对可以重复：

授予{ 权限javax.security.auth.PrivateCredentialPermission “abCredential abPrincipal”duke“cdPrincipal”dukette“”， “读”; };

上面的代码授予对属于具有至少两个关联 s 的主题的私有Credential“ a.b.Credential”的访问权 ：“ ”具有名称“ ”和“ ”，名称为“ ”。 Principal`a.b.Principaldukec.d.Principal`dukette

AudioPermission

The javax.sound.sampled.AudioPermission class represents access rights to the audio system resources. An AudioPermission contains a target name but no actions list; you either have the named permission or you don't.

The target name is the name of the audio permission (see the table below). The names follow the hierarchical property-naming convention. Also, an asterisk can be used to represent all the audio permissions.

The following table lists the possible AudioPermission target names. For each name, the table provides a description of exactly what that permission allows, as well as a discussion of the risks of granting code the permission.

Permission Target Name

What the Permission Allows

Risks of Allowing this Permission

play

Audio playback through the audio device or devices on the system. Allows the application to obtain and manipulate lines and mixers for audio playback (rendering).

In some cases use of this permission may affect other applications because the audio from one line may be mixed with other audio being played on the system, or because manipulation of a mixer affects the audio for all lines using that mixer.

record

Audio recording through the audio device or devices on the system. Allows the application to obtain and manipulate lines and mixers for audio recording (capture).

In some cases use of this permission may affect other applications because manipulation of a mixer affects the audio for all lines using that mixer. This permission can enable an applet or application to eavesdrop on a user.

JAXBPermission

此类用于JAXB权限。A JAXBPermission 包含名称（也称为“目标名称”）但没有动作列表; 你要么拥有命名权限，要么没有。

目标名称是JAXB权限的名称（参见下文）。

下表列出了所有可能的JAXBPermission目标名称，每个名称都提供了权限允许的说明，并讨论了授予代码权限的风险。

javax.xml.bind.JAXBPermission目标名称

权限允许的内容

允许此许可的风险

setDatatypeConverter

允许代码DatatypeConverterInterface 通过the setDatatypeConverter method 所有DatatypeConverter使用的方法设置VM范围。

DatatypeConverterInterface在真正的JAXB实现设置 恶意代码之前，可以设置具有VM范围的单例语义的恶意代码。这允许恶意代码访问其可能无法访问的对象，例如Frame.getFrames()属于在同一JVM中运行的另一个应用程序的对象。

WebServicePermission

此类定义Web服务权限。

Web服务权限仅通过名称（也称为“目标名称”）进行标识。没有与他们相关的行动。

定义了以下权限目标名称：

publishEndpoint

该publishEndpoint权限允许使用类publish定义的方法发布Web服务端点javax.xml.ws.Endpoint。

授予publishEndpoint允许将应用程序公开为网络服务。根据运行时的安全性和应用程序的安全性，这可能会引入可远程利用的安全漏洞。

    • *

方法和他们需要的权限

下表包含所有需要权限的方法的列表，并且每个SecurityManager方法都告诉它调用哪个方法以及该方法的默认实现检查哪个权限 SecurityManager。

注意：此列表不完整，并且不包含几个需要在最新版本的JDK中引入的权限的新方法。有关抛出的方法和所需权限的其他信息，请参阅API规范SecurityException。

因此，使用默认SecurityManager方法实现，只有当前生效的策略允许右侧列中相应条目中指定的权限时，才能成功调用左侧列中的方法。例如，以下行：

方法

调用SecurityManager方法

允许

java.awt.Toolkit中 getSystemEventQueue（）;

checkPermission

java.awt.AWTPermission "accessEventQueue";

指定getSystemEventQueue 对java.awt.Toolkit类中方法的调用导致对checkPermissionSecurityManager方法的调用，只有在调用堆栈上的代码被授予以下权限时才能成功：

java.awt.AWTPermission“accessEventQueue”;

惯例：

方法

调用SecurityManager方法

允许

some.package.class public static void someMethod（String foo）;

checkXXX

SomePermission "{foo}";

表示foo替换{foo}权限名称中的字符串的运行时值。

例如，这是一个表条目：

方法

调用SecurityManager方法

允许

java.io.FileInputStream中 FileInputStream（String name）

checkRead(String)

java.io.FilePermission "{name}", "read";

如果FileInputStream使用“/ test / MyTestFile”作为name参数调用方法（在本例中为构造函数），则如

的FileInputStream（ “/测试/ MyTestFile”）;

然后，为了使调用成功，必须在当前策略中设置以下权限，允许对文件“/ test / MyTestFile”进行读访问：

java.io.FilePermission“/ test / MyTestFile”，“read”;

更具体地说，必须如上所述明确设置权限，或者通过其他权限隐含权限，例如：

java.io.FilePermission“/ test / *”，“read”;

它允许对"/test"目录中的任何文件进行读访问。

在某些情况下，大括号中的术语与特定方法参数的名称不完全相同，但是表示相关值。这是一个例子：

方法

调用SecurityManager方法

允许

java.net.DatagramSocket中 公共同步无效 接收（DatagramPacket p）;

checkAccept({host}, {port})

java.net.SocketPermission "{host}:{port}", "accept";

在这里，适当的主机和端口值由receive方法计算并传递给checkAccept。

在大多数情况下，只列出所调用的SecurityManager方法的名称。如果该方法是同名的多个方法之一，则还会列出参数类型，例如for checkRead(String)和checkRead(FileDescriptor)。在参数可能相关的其他情况下，它们也被列出。

下表按包名排序。也就是说，java.awt首先列出包中类的方法，然后列出包中类的方法java.io，依此类推。

方法和他们需要的权限

方法

调用SecurityManager方法

允许

java.awt.Graphics2D中 公共抽象无效 setComposite（复合comp）

的checkPermission

java.awt.AWTPermission“readDisplayPixels”如果此Graphics2D上下文在显示屏幕上绘制到Component，而Composite是自定义对象而不是AlphaComposite类的实例。注意：setComposite方法实际上是抽象的，因此无法调用安全检查。该方法的每个实际实现都应在所述条件下使用java.awt.AWTPermission（“readDisplayPixels”）权限调用java.lang.SecurityManager checkPermission方法。

java.awt.Robot中 公共机器人（） 公共机器人（GraphicsDevice屏幕）

的checkPermission

java.awt.AWTPermission“createRobot”

java.awt.Toolkit中 public void addAWTEventListener（ AWTEventListener监听器， long eventMask） public void removeAWTEventListener（ AWTEventListener监听器）

的checkPermission

java.awt.AWTPermission“listenToAllAWTEvents”

java.awt.Toolkit中 公共抽象PrintJob getPrintJob（ 框架，字符串作业标题， 属性道具）

使用checkPrintJobAccess

java.lang.RuntimePermission“queuePrintJob”

注意：getPrintJob方法实际上是抽象的，因此无法调用安全检查。该方法的每个实际实现都应该调用java.lang.SecurityManager checkPrintJobAccess方法，该方法仅在当前允许java.lang.RuntimePermission“queuePrintJob”权限时才成功。

java.awt.Toolkit中 公共抽象剪贴板 getSystemClipboard（）

的checkPermission

java.awt.AWTPermission“accessClipboard”

注意：getSystemClipboard方法实际上是抽象的，因此无法调用安全检查。该方法的每个实际实现都应该调用checkPermission方法，该方法仅在当前允许java.awt.AWTPermission“accessClipboard”权限时才成功。

java.awt.Toolkit中 公共决赛EventQueue getSystemEventQueue（）

的checkPermission

java.awt.AWTPermission“accessEventQueue”

java.awt.Window中 窗口（）

的checkPermission

如果设置了java.awt.AWTPermission“showWindowWithoutWarningBanner”，则将显示该窗口，而不显示该窗口是由applet创建的横幅警告。它没有设置，将显示这样的横幅。

java.beans.Beans中 public static void setDesignTime（ boolean isDesignTime） public static void setGuiAvailable（ boolean isGuiAvailable）
java.beans.Introspector中 public static synchronized void setBeanInfoSearchPath（String path []）
java.beans.PropertyEditorManager中 public static void registerEditor（ 类targetType， 班级编辑班） public static synchronized void setEditorSearchPath（String path []）

checkPropertiesAccess

java.util.PropertyPermission“*”，“读，写”

的java.io.File public boolean delete（） public void deleteOnExit（）

checkDelete（字符串）

java.io.FilePermission“{name}”，“delete”

java.io.FileInputStream中 FileInputStream（FileDescriptor fdObj）

的checkRead（的FileDescriptor）

java.lang.RuntimePermission“readFileDescriptor”

java.io.FileInputStream中 FileInputStream（String name） FileInputStream（文件文件）
的java.io.File public boolean exists（） public boolean canRead（） public boolean isFile（） public boolean isDirectory（） public boolean isHidden（） public long lastModified（） 公共长度（） public String [] list（） public String [] list（ FilenameFilter过滤器） public File [] listFiles（） public File [] listFiles（ FilenameFilter过滤器） public File [] listFiles（ FileFilter过滤器）
java.io.RandomAccessFile中 RandomAccessFile（String name，String mode） RandomAccessFile（文件文件，字符串模式） （其中两个模式都是“r”）

的checkRead（字符串）

java.io.FilePermission“{name}”，“read”

java.io.FileOutputStream中 FileOutputStream（FileDescriptor fdObj）

checkWrite（的FileDescriptor）

java.lang.RuntimePermission“writeFileDescriptor”

java.io.FileOutputStream中 FileOutputStream（文件文件） FileOutputStream（String name） FileOutputStream（String name， 布尔附加）
的java.io.File public boolean canWrite（） public boolean createNewFile（） public static File createTempFile（ 字符串前缀，字符串后缀） public static File createTempFile（ 字符串前缀，字符串后缀， 文件目录） public boolean mkdir（） public boolean mkdirs（） public boolean renameTo（File dest） public boolean setLastModified（很长一段时间） public boolean setReadOnly（）

checkWrite（字符串）

java.io.FilePermission“{name}”，“写”

java.io.ObjectInputStream中 protected final boolean enableResolveObject（boolean enable）;
java.io.ObjectOutputStream中 protected final boolean enableReplaceObject（boolean enable）

的checkPermission

java.io.SerializablePermission“enableSubstitution”

java.io.ObjectInputStream中 protected ObjectInputStream（）
java.io.ObjectOutputStream中 protected ObjectOutputStream（）

的checkPermission

java.io.SerializablePermission“enableSubclassImplementation”

java.io.RandomAccessFile中 RandomAccessFile（String name，String mode） （模式为“rw”）

checkRead（String）和checkWrite（String）

java.io.FilePermission“{name}”，“读，写”

java.lang.Class中 public static Class forName（ 字符串名称，布尔初始化， ClassLoader加载器）

的checkPermission

如果loader为null，并且调用者的类加载器不为null，则java.lang.RuntimePermission（“getClassLoader”）

java.lang.Class中 public ClassLoader getClassLoader（）

的checkPermission

如果调用者的类加载器为null，或者与请求类加载器的类的类加载器相同或者是祖先，则不需要权限。否则，需要
java.lang.RuntimePermission“getClassLoader”
。

java.lang.Class中 public Class [] getDeclaredClasses（） public Field [] getDeclaredFields（） public Method [] getDeclaredMethods（） public Constructor [] getDeclaredConstructors（） public Field getDeclaredField（ 字符串名称） public方法getDeclaredMethod（...） 公共构造函数 getDeclaredConstructor（...）

checkMemberAccess（this，Member.DECLARED），如果这个类在一个包中，checkPackageAccess（{pkgName}）

如果“this”类的类加载器与调用者的类加载器相同，则默认checkMemberAccess不需要任何权限。否则，它需要java.lang.RuntimePermission“accessDeclaredMembers”。如果此类在包中，则还需要java.lang.RuntimePermission“accessClassInPackage。{pkgName}”。

java.lang.Class中 public Class [] getClasses（） public Field [] getFields（） public Method [] getMethods（） public Constructor [] getConstructors（） public Field getField（String name） public方法getMethod（...） public构造函数getConstructor（...）

checkMemberAccess（this，Member.PUBLIC），如果类在包中，checkPackageAccess（{pkgName}）

当访问类型为Member.PUBLIC时，默认checkMemberAccess不需要任何权限。如果此类在包中，则需要java.lang.RuntimePermission“accessClassInPackage。{pkgName}”。

java.lang.Class中 公共保护域 getProtectionDomain（）

的checkPermission

java.lang.RuntimePermission“getProtectionDomain”

java.lang.ClassLoader中 类加载器（） ClassLoader（ClassLoader父级）

checkCreateClassLoader

java.lang.RuntimePermission“createClassLoader”

java.lang.ClassLoader中 public static ClassLoader getSystemClassLoader（） public ClassLoader getParent（）

的checkPermission

如果调用者的类加载器为null，或者与请求类加载器的类的类加载器相同或者是祖先，则不需要权限。否则，需要
java.lang.RuntimePermission“getClassLoader”
。

java.lang.Runtime中 public Process exec（String命令） public Process exec（String命令， String envp []） public Process exec（String cmdarray []） public Process exec（String cmdarray []， String envp []）

的checkExec

java.io.FilePermission“{command}”，“execute”

java.lang.Runtime中 public void exit（int status） public static void runFinalizersOnExit（boolean value） java.lang.System中 public static void exit（int status） public static void runFinalizersOnExit（boolean value）

checkExit（status）其中status为0表示runFinalizersOnExit

java.lang.RuntimePermission“exitVM。{status}”

java.lang.Runtime中 public void addShutdownHook（Thread hook） public boolean removeShutdownHook（Thread hook）

的checkPermission

java.lang.RuntimePermission“shutdownHooks”

java.lang.Runtime中 public void load（String lib） public void loadLibrary（String lib） java.lang.System中 public static void load（String filename） public static void loadLibrary（ 字符串libname）

checkLink（{libName}）其中{libName}是lib，filename或libname参数

java.lang.RuntimePermission“loadLibrary。{libName}”

java.lang.SecurityManager方法

的checkPermission

见邻桌。

java.lang.System中 公共静态属性 的GetProperties（） public static void setProperties（属性道具）

checkPropertiesAccess

java.util.PropertyPermission“*”，“读，写”

java.lang.System中 public static String getProperty（String key） public static String getProperty（String key，String def）

checkPropertyAccess

java.util.PropertyPermission“{key}”，“read”

java.lang.System中 public static void setIn（InputStream in） public static void setOut（PrintStream out） public static void setErr（PrintStream err）

的checkPermission

java.lang.RuntimePermission“setIO”

java.lang.System中 public static String setProperty（String key，String value）

的checkPermission

java.util.PropertyPermission“{key}”，“write”

java.lang.System中 public static synchronized void setSecurityManager（SecurityManager s）

的checkPermission

java.lang.RuntimePermission“setSecurityManager”

java.lang.Thread中 public ClassLoader getContextClassLoader（）

的checkPermission

如果调用者的类加载器为null，或者与请求上下文类加载器的线程的上下文类加载器相同或者是祖先，则不需要任何权限。否则，需要
java.lang.RuntimePermission“getClassLoader”
。

java.lang.Thread中 public void setContextClassLoader （ClassLoader cl）

的checkPermission

java.lang.RuntimePermission“setContextClassLoader”

java.lang.Thread中 public final void checkAccess（） public void interrupt（） public final void suspend（） public final void resume（） public final void setPriority （int newPriority） public final void setName（String name） public final void setDaemon（boolean on）

的checkAccess（本）

java.lang.RuntimePermission“modifyThread”

java.lang.Thread中 public static int 枚举（Thread tarray []）

的checkAccess（{线程组}）

java.lang.RuntimePermission“modifyThreadGroup”

java.lang.Thread中 public final void stop（）

的checkAccess（本）。如果当前线程试图阻止除自身之外的线程，也检查checkPermission。

java.lang.RuntimePermission“modifyThread”。
如果当前线程试图阻止除自身之外的线程，则java.lang.RuntimePermission“stopThread”。

java.lang.Thread中 公共最终同步无效 停止（Throwable obj）

的checkAccess（本）。如果当前线程试图阻止除自身之外的线程或者obj不是ThreadDeath的实例，也检查checkPermission。

java.lang.RuntimePermission“modifyThread”。
另外java.lang.RuntimePermission“stopThread”如果当前线程试图阻止除自身之外的线程或obj不是ThreadDeath的实例。

java.lang.Thread中 线（） 线程（可运行目标） 线程（字符串名称） 线程（可运行目标，字符串名称）
java.lang.ThreadGroup中 ThreadGroup（String name） ThreadGroup（ThreadGroup父级， 字符串名称）

的checkAccess（{parentThreadGroup}）

java.lang.RuntimePermission“modifyThreadGroup”

java.lang.Thread中 线程（ThreadGroup组，...）
java.lang.ThreadGroup中 public final void checkAccess（） public int enumerate（Thread list []） public int enumerate（Thread list []， 布尔递归） public int enumerate（ThreadGroup list []） public int enumerate（ThreadGroup list []， 布尔递归） public final ThreadGroup getParent（） 公众最终无效 setDaemon（boolean daemon） public final void setMaxPriority（int pri） public final void suspend（） public final void resume（） public final void destroy（）

checkAccess（this）用于ThreadGroup方法，或checkAccess（group）用于Thread方法

java.lang.RuntimePermission“modifyThreadGroup”

java.lang.ThreadGroup中 public final void interrupt（）

的checkAccess（本）

需要java.lang.RuntimePermission“modifyThreadGroup”。
还需要java.lang.RuntimePermission“modifyThread”，因为为线程组及其所有子组中的每个线程调用java.lang.Thread interrupt（）方法。请参见Thread interrupt（）方法。

java.lang.ThreadGroup中 public final void stop（）

的checkAccess（本）

需要java.lang.RuntimePermission“modifyThreadGroup”。
还需要java.lang.RuntimePermission“modifyThread”以及可能的java.lang.RuntimePermission“stopThread”，因为为线程组及其所有子组中的每个线程调用了java.lang.Thread stop（）方法。请参见Thread stop（）方法。

java.lang.reflect.AccessibleObject中 public static void setAccessible（...） public void setAccessible（...）

的checkPermission

java.lang.reflect.ReflectPermission“suppressAccessChecks”

java.net.Authenticator中 public static PasswordAuthentication requestPasswordAuthentication（ InetAddress addr， int端口， 字符串协议， 字符串提示， 字符串方案）

的checkPermission

java.net.NetPermission“requestPasswordAuthentication”

java.net.Authenticator中 public static void setDefault（Authenticator a）

的checkPermission

java.net.NetPermission“setDefaultAuthenticator”

java.net.MulticastSocket中 公共无效 joinGroup（InetAddress mcastaddr） 公共无效 leaveGroup（InetAddress mcastaddr）

checkMulticast（InetAddress类）

java.net.SocketPermission（mcastaddr.getHostAddress（），“accept，connect”）

java.net.DatagramSocket中 public void send（DatagramPacket p）

checkMulticast（p.getAddress（））或checkConnect（
p.getAddress（）。getHostAddress（），p.getPort（））

if（p.getAddress（）。isMulticastAddress（））{
java.net.SocketPermission（
（p.getAddress（））。getHostAddress（），“accept，connect”）
}
else {
port = p.getPort（）;
host = p.getAddress（）。getHostAddress（）;
if（port == -1）java.net.SocketPermission“{host}”，“resolve”;
else java.net.SocketPermission“{host}：{port}”，“connect”
}

java.net.MulticastSocket中 公共同步无效 send（DatagramPacket p，byte ttl）

checkMulticast（p.getAddress（），ttl）或checkConnect（
p.getAddress（）。getHostAddress（），p.getPort（））

if（p.getAddress（）。isMulticastAddress（））{
java.net.SocketPermission（
（p.getAddress（））。getHostAddress（），“accept，connect”）
}
else {
port = p.getPort（）;
host = p.getAddress（）。getHostAddress（）;
if（port == -1）java.net.SocketPermission“{host}”，“resolve”;
else java.net.SocketPermission“{host}：{port}”，“connect”
}

java.net.InetAddress中 public String getHostName（） public static InetAddress [] getAllByName（String host） public static InetAddress getLocalHost（）
java.net.DatagramSocket中 public InetAddress getLocalAddress（）

checkConnect（{host}，-1）

java.net.SocketPermission“{host}”，“resolve”

java.net.ServerSocket中 ServerSocket的（...）
java.net.DatagramSocket中 DatagramSocket类（...）
java.net.MulticastSocket中 MulticastSocket时（...）

checkListen（{端口}）

java.net.SocketPermission“localhost：{port}”，“listen”;

java.net.ServerSocket中 public Socket accept（） protected final void implAccept（Socket s）

checkAccept（{host}，{port}）

java.net.SocketPermission“{host}：{port}”，“accept”

java.net.ServerSocket中 public static synchronized void setSocketFactory（...）
java.net.Socket中 public static synchronized void setSocketImplFactory（...）
的java.net.URL public static synchronized void setURLStreamHandlerFactory（...）
java.net.URLConnection中 public static synchronized void setContentHandlerFactory（...） public static void setFileNameMap（FileNameMap map）
java.net.HttpURLConnection中 public static void setFollowRedirects（布尔集）
java.rmi.activation.ActivationGroup public static synchronized ActivationGroup createGroup（...） public static synchronized void setSystem（ActivationSystem系统）
java.rmi.server.RMISocketFactory中 public synchronized static void setSocketFactory（...）

器checkSetFactory

java.lang.RuntimePermission“setFactory”

java.net.Socket中 插座（...）

checkConnect（{host}，{port}）

java.net.SocketPermission“{host}：{port}”，“connect”

java.net.DatagramSocket中 公共同步无效 接收（DatagramPacket p）

checkAccept（{host}，{port}）

java.net.SocketPermission“{host}：{port}”，“accept”

的java.net.URL URL（...）

的checkPermission

java.net.NetPermission“specifyStreamHandler”

java.net.URLClassLoader的 URLClassLoader的（...）

checkCreateClassLoader

java.lang.RuntimePermission“createClassLoader”

java.security.AccessControlContext public AccessControlContext（AccessControlContext acc， DomainCombiner组合器） public DomainCombiner getDomainCombiner（）

的checkPermission

java.security.SecurityPermission“createAccessControlContext”

java.security.Identity中 public void addCertificate（...）

checkSecurityAccess（
“addIdentityCertificate”）

java.security.SecurityPermission“addIdentityCertificate”

java.security.Identity中 public void removeCertificate（...）

checkSecurityAccess（
“removeIdentityCertificate”）

java.security.SecurityPermission“removeIdentityCertificate”

java.security.Identity中 public void setInfo（String info）

checkSecurityAccess（
“setIdentityInfo”）

java.security.SecurityPermission“setIdentityInfo”

java.security.Identity中 public void setPublicKey（PublicKey key）

checkSecurityAccess（
“setIdentityPublicKey”）

java.security.SecurityPermission“setIdentityPublicKey”

java.security.Identity中 public String toString（...）

checkSecurityAccess（
“printIdentity”）

java.security.SecurityPermission“printIdentity”

java.security.IdentityScope中 protected static void setSystemScope（）

checkSecurityAccess（
“setSystemScope”）

java.security.SecurityPermission“setSystemScope”

java.security.Permission中 public void checkGuard（Object object）

的checkPermission（本）

此Permission对象是已检查的权限

java.security.Policy中 public static Policy getPolicy（）

的checkPermission

java.security.SecurityPermission“getPolicy”

java.security.Policy中 public static void setPolicy（政策政策）

的checkPermission

java.security.SecurityPermission“setPolicy”

java.security.Policy中 公共静态政策 getInstance（String type，SpiParameter params） getInstance（String type，SpiParameter params，String provider） getInstance（String type，SpiParameter params，Provider provider）

的checkPermission

java.security.SecurityPermission“createPolicy。{type}”

java.security.Provider中 public synchronized void clear（）

checkSecurityAccess（
“clearProviderProperties。”+ {name}）

java.security.SecurityPermission“clearProviderProperties。{name}”其中_name_是提供者名称。

java.security.Provider中 公共同步对象 put（对象键，对象值）

checkSecurityAccess（
“putProviderProperty。”+ {name}）

java.security.SecurityPermission“putProviderProperty。{name}”其中_name_是提供者名称。

java.security.Provider中 公共同步对象 删除（对象键）

checkSecurityAccess（
“removeProviderProperty。”+ {name}）

java.security.SecurityPermission“removeProviderProperty。{name}”其中_name_是提供者名称。

java.security.SecureClassLoader的 SecureClassLoader的（...）

checkCreateClassLoader

java.lang.RuntimePermission“createClassLoader”

java.security.Security public static void getProperty（String key）

的checkPermission

java.security.SecurityPermission“getProperty。{key}”

java.security.Security public static int addProvider（提供者提供者） public static int insertProviderAt（提供者提供者， int position）;

checkSecurityAccess（
“insertProvider。”+ provider.getName（））

java.security.SecurityPermission“insertProvider。{name}”

java.security.Security public static void removeProvider（String name）

checkSecurityAccess（
“removeProvider。”+ name）

java.security.SecurityPermission“removeProvider。{name}”

java.security.Security public static void setProperty（String key，String datum）

checkSecurityAccess（
“setProperty。”+ key）

java.security.SecurityPermission“setProperty。{key}”

java.security.Signer的 public PrivateKey getPrivateKey（）

checkSecurityAccess（
“getSignerPrivateKey”）

java.security.SecurityPermission“getSignerPrivateKey”

java.security.Signer的 公众最终无效 setKeyPair（KeyPair对）

checkSecurityAccess（
“setSignerKeypair”）

java.security.SecurityPermission“setSignerKeypair”

java.lang.DriverManager中 public static synchronized void setLogWriter（PrintWriter out）

的checkPermission

java.sql.SQLPermission“setLog”

java.lang.DriverManager中 public static synchronized void setLogStream（PrintWriter out）

的checkPermission

java.sql.SQLPermission“setLog”

java.util.Locale中 public static synchronized void setDefault（Locale newLocale）

的checkPermission

java.util.PropertyPermission“user.language”，“write”

java.util.zip.ZipFile中 ZipFile（String name）

的checkRead

java.io.FilePermission“{name}”，“read”

javax.security.auth.Subject public static Subject getSubject（最终AccessControlContext acc）

的checkPermission

javax.security.auth.AuthPermission“getSubject”

javax.security.auth.Subject public void setReadOnly（）

的checkPermission

javax.security.auth.AuthPermission“setReadOnly”

javax.security.auth.Subject public static Object doAs（最终主题主题， 最终的PrivilegedAction动作）

的checkPermission

javax.security.auth.AuthPermission“doAs”

javax.security.auth.Subject public static Object doAs（最终主题主题， 最终的PrivilegedExceptionAction动作） 抛出java.security.PrivilegedActionException

的checkPermission

javax.security.auth.AuthPermission“doAs”

javax.security.auth.Subject public static Object doAsPrivileged（最终主题主题， 最终的PrivilegedAction动作， 最终的AccessControlContext acc）

的checkPermission

javax.security.auth.AuthPermission“doAsPrivileged”

javax.security.auth.Subject public static Object doAsPrivileged（最终主题主题， 最终的PrivilegedExceptionAction动作， 最终的AccessControlContext acc） 抛出java.security.PrivilegedActionException

的checkPermission

javax.security.auth.AuthPermission“doAsPrivileged”

javax.security.auth.SubjectDomainCombiner public subject getSubject（）

的checkPermission

javax.security.auth.AuthPermission“getSubjectFromDomainCombiner”

javax.security.auth.SubjectDomainCombiner public subject getSubject（）

的checkPermission

javax.security.auth.AuthPermission“getSubjectFromDomainCombiner”

javax.security.auth.login.LoginContext中 public LoginContext（String name） 抛出LoginException

的checkPermission

javax.security.auth.AuthPermission“createLoginContext。{name}”

javax.security.auth.login.LoginContext中 public LoginContext（String name， 主题科目） 抛出LoginException

的checkPermission

javax.security.auth.AuthPermission“createLoginContext。{name}”

javax.security.auth.login.LoginContext中 public LoginContext（String name， CallbackHandler callbackHandler） 抛出LoginException

的checkPermission

javax.security.auth.AuthPermission“createLoginContext。{name}”

javax.security.auth.login.LoginContext中 public LoginContext（String name， 主题， CallbackHandler callbackHandler） 抛出LoginException

的checkPermission

javax.security.auth.AuthPermission“createLoginContext。{name}”

javax.security.auth.login.Configuration public static Configuration getConfiguration（）

的checkPermission

javax.security.auth.AuthPermission“getLoginConfiguration”

javax.security.auth.login.Configuration public static void setConfiguration（配置配置）

的checkPermission

javax.security.auth.AuthPermission“setLoginConfiguration”

javax.security.auth.login.Configuration public static void refresh（）

的checkPermission

javax.security.auth.AuthPermission“refreshLoginConfiguration”

javax.security.auth.login.Configuration 公共静态配置 getInstance（String type，SpiParameter params） getInstance（String type，SpiParameter params，String provider） getInstance（String type，SpiParameter params，Provider provider）

的checkPermission

javax.security.auth.AuthPermission“createLoginConfiguration。{type}”

    • *

java.lang.SecurityManager方法权限检查

此表显示java.lang.SecurityManager方法的默认实现检查哪些权限 。

除了带有上下文参数的和方法之外，每个指定check的SecurityManager checkPermission方法都使用指定的权限调用该 方法 。这些方法期望上下文是一个， 并且它们使用指定的权限调用上下文的 方法。checkConnect`checkReadAccessControlContextcheckPermission`

方法

允许

public void checkAccept（String host，int port）;

java.net.SocketPermission“{host}：{port}”，“accept”;

public void checkAccess（Thread t）;

java.lang.RuntimePermission“modifyThread”;

public void checkAccess（ThreadGroup g）;

java.lang.RuntimePermission“modifyThreadGroup”;

public void checkAwtEventQueueAccess（）;
注意：不推荐使用此方法; 使用
public void checkPermission（Permission perm）;

java.awt.AWTPermission“accessEventQueue”;

public void checkConnect（String host，int port）;

if（port == -1）java.net.SocketPermission“{host}”，“resolve”;
else java.net.SocketPermission“{host}：{port}”，“connect”;

public void checkConnect（String host，int port，Object context）;

if（port == -1）java.net.SocketPermission“{host}”，“resolve”;
else java.net.SocketPermission“{host}：{port}”，“connect”;

public void checkCreateClassLoader（）;

java.lang.RuntimePermission“createClassLoader”;

public void checkDelete（String file）;

java.io.FilePermission“{file}”，“delete”;

public void checkExec（String cmd）;

如果cmd是绝对路径：java.io.FilePermission“{cmd}”，“execute”;
else java.io.FilePermission“<< ALL_FILES >>”，“execute”;

public void checkExit（int status）;

java.lang.RuntimePermission“exitVM。{status}”;

public void checkLink（String lib）;

java.lang.RuntimePermission“loadLibrary。{lib}”;

public void checkListen（int port）;

java.net.SocketPermission“localhost：{port}”，“listen”;

public void checkMemberAccess（Class clazz，int which which）;
注意：不推荐使用此方法; 使用
public void checkPermission（Permission perm）;

if（which！= Member.PUBLIC）{ if（currentClassLoader（）！= clazz.getClassLoader（））{ 的checkPermission（ new java.lang.RuntimePermission（“accessDeclaredMembers”））; } }

public void checkMulticast（InetAddress maddr）;

java.net.SocketPermission（maddr.getHostAddress（）， “接受，连接”）;

public void checkMulticast（InetAddress maddr，byte ttl）;
注意：不推荐使用此方法; 使用
public void checkPermission（Permission perm）;

java.net.SocketPermission（maddr.getHostAddress（）， “接受，连接”）;

public void checkPackageAccess（String pkg）;

java.lang.RuntimePermission“accessClassInPackage。{pkg}”;

public void checkPackageDefinition（String pkg）;

java.lang.RuntimePermission“defineClassInPackage。{pkg}”;

public void checkPrintJobAccess（）;

java.lang.RuntimePermission“queuePrintJob”;

public void checkPropertiesAccess（）;

java.util.PropertyPermission“*”，“读，写”;

public void checkPropertyAccess（String key）;

java.util.PropertyPermission“{key}”，“read，write”;

public void checkRead（FileDescriptor fd）;

java.lang.RuntimePermission“readFileDescriptor”;

public void checkRead（String file）;

java.io.FilePermission“{file}”，“read”;

public void checkRead（String file，Object context）;

java.io.FilePermission“{file}”，“read”;

public void checkSecurityAccess（String target）;

java.security.SecurityPermission“{target}”;

public void checkSetFactory（）;

java.lang.RuntimePermission“setFactory”;

public void checkSystemClipboardAccess（）;
注意：不推荐使用此方法; 使用
public void checkPermission（Permission perm）;

java.awt.AWTPermission“accessClipboard”;

public boolean checkTopLevelWindow（Object window）;
注意：不推荐使用此方法; 使用
public void checkPermission（Permission perm）;

java.awt.AWTPermission“showWindowWithoutWarningBanner”;

public void checkWrite（FileDescriptor fd）;

java.lang.RuntimePermission“writeFileDescriptor”;

public void checkWrite（String file）;

java.io.FilePermission“{file}”，“写”;

public SecurityManager（）;

java.lang.RuntimePermission“createSecurityManager”;

    • *

版权所有© 1993,2019，Oracle和/或其附属公司。版权所有。

联系我们

Original url: Access
Created at: 2019-04-24 17:45:38
Category: default
Tags: none

未标明原创文章均为采集，版权归作者所有，转载无需和我联系，请注明原出处，南摩阿彌陀佛，知识，不只知道，要得到

请先后发表评论
  • 最新评论
  • 总共0条评论