/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* A Policy object is responsible for determining whether code executing
* in the Java runtime environment has permission to perform a
* security-sensitive operation.
*
* <p> There is only one Policy object installed in the runtime at any
* given time. A Policy object can be installed by calling the
* <code>setPolicy</code> method. The installed Policy object can be
* obtained by calling the <code>getPolicy</code> method.
*
* <p> If no Policy object has been installed in the runtime, a call to
* <code>getPolicy</code> installs an instance of the default Policy
* implementation (a default subclass implementation of this abstract class).
* The default Policy implementation can be changed by setting the value
* of the "policy.provider" security property (in the Java security properties
* file) to the fully qualified name of the desired Policy subclass
* implementation. The Java security properties file is located in the
* file named <JAVA_HOME>/lib/security/java.security.
* <JAVA_HOME> refers to the value of the java.home system property,
* and specifies the directory where the JRE is installed.
*
* <p> Application code can directly subclass Policy to provide a custom
* implementation. In addition, an instance of a Policy object can be
* constructed by invoking one of the <code>getInstance</code> factory methods
* with a standard type. The default policy type is "JavaPolicy".
*
* <p> Once a Policy instance has been installed (either by default, or by
* calling <code>setPolicy</code>), the Java runtime invokes its
* <code>implies</code> method when it needs to
* determine whether executing code (encapsulated in a ProtectionDomain)
* can perform SecurityManager-protected operations. How a Policy object
* retrieves its policy data is up to the Policy implementation itself.
* The policy data may be stored, for example, in a flat ASCII file,
* in a serialized binary file of the Policy class, or in a database.
*
* <p> The <code>refresh</code> method causes the policy object to
* For example, if the policy object stores its data in configuration files,
* calling <code>refresh</code> will cause it to re-read the configuration
* policy files. If a refresh operation is not supported, this method does
* nothing. Note that refreshed policy may not have an effect on classes
* in a particular ProtectionDomain. This is dependent on the Policy
* provider's implementation of the <code>implies</code>
* method and its PermissionCollection caching strategy.
*
* @author Roland Schemers
* @author Gary Ellison
* @see java.security.Provider
* @see java.security.ProtectionDomain
* @see java.security.Permission
*/
public abstract class Policy {
/**
* A read-only empty PermissionCollection instance.
* @since 1.6
*/
new UnsupportedEmptyCollection();
// Information about the system-wide policy.
private static class PolicyInfo {
// the system-wide policy
// a flag indicating if the system-wide policy has been initialized
final boolean initialized;
this.initialized = initialized;
}
}
// PolicyInfo is stored in an AtomicReference
// Cache mapping ProtectionDomain.Key to PermissionCollection
/** package private for AccessControlContext and ProtectionDomain */
static boolean isSet()
{
}
}
}
/**
* Returns the installed Policy object. This value should not be cached,
* as it may be changed by a call to <code>setPolicy</code>.
* This method first calls
* <code>SecurityManager.checkPermission</code> with a
* <code>SecurityPermission("getPolicy")</code> permission
* to ensure it's ok to get the Policy object.
*
* @return the installed Policy.
*
* @throws SecurityException
* if a security manager exists and its
* <code>checkPermission</code> method doesn't allow
* getting the Policy object.
*
* @see SecurityManager#checkPermission(Permission)
* @see #setPolicy(java.security.Policy)
*/
{
return getPolicyNoCheck();
}
/**
* Returns the installed Policy object, skipping the security check.
* Used by ProtectionDomain and getPolicy.
*
* @return the installed Policy.
*/
{
// Use double-check idiom to avoid locking if system-wide policy is
// already initialized
synchronized (Policy.class) {
new PrivilegedAction<String>() {
}
});
if (policy_class == null) {
policy_class = "sun.security.provider.PolicyFile";
}
try {
pinfo = new PolicyInfo(
true);
} catch (Exception e) {
/*
* The policy_class seems to be an extension
* so we have to bootstrap loading it via a policy
* provider that is on the bootclasspath.
* If it loads then shift gears to using the configured
* provider.
*/
// install the bootstrap provider to avoid recursion
new PrivilegedAction<Policy>() {
try {
// we want the extension loader
}
} catch (Exception e) {
pc +
" not available");
e.printStackTrace();
}
return null;
}
}
});
/*
* if it loaded install it as the policy provider. Otherwise
* continue to use the system default implementation
*/
} else {
}
}
}
}
}
}
}
/**
* Sets the system-wide Policy object. This method first calls
* <code>SecurityManager.checkPermission</code> with a
* <code>SecurityPermission("setPolicy")</code>
* permission to ensure it's ok to set the Policy.
*
* @param p the new system Policy object.
*
* @throws SecurityException
* if a security manager exists and its
* <code>checkPermission</code> method doesn't allow
* setting the Policy.
*
* @see SecurityManager#checkPermission(Permission)
* @see #getPolicy()
*
*/
{
new SecurityPermission("setPolicy"));
if (p != null) {
initPolicy(p);
}
synchronized (Policy.class) {
}
}
/**
* Initialize superclass state such that a legacy provider can
* handle queries for itself.
*
* @since 1.4
*/
/*
* A policy provider not on the bootclasspath could trigger
* security checks fulfilling a call to either Policy.implies
* or Policy.getPermissions. If this does occur the provider
* must be able to answer for it's own ProtectionDomain
* without triggering additional security checks, otherwise
* the policy implementation will end up in an infinite
* recursion.
*
* To mitigate this, the provider can collect it's own
* ProtectionDomain and associate a PermissionCollection while
* it is being installed. The currently installed policy
* provider (if there is one) will handle calls to
* Policy.implies or Policy.getPermissions during this
* process.
*
* This Policy superclass caches away the ProtectionDomain and
* statically binds permissions so that legacy Policy
* implementations will continue to function.
*/
public ProtectionDomain run() {
return p.getClass().getProtectionDomain();
}
});
/*
* Collect the permissions granted to this protection domain
* so that the provider can be security checked while processing
* calls to Policy.implies or Policy.getPermissions.
*/
synchronized (p) {
p.pdMapping = new WeakHashMap<>();
}
}
}
policyPerms = new Permissions();
}
synchronized (p.pdMapping) {
// cache of pd to permissions
}
}
return;
}
/**
* Returns a Policy object of the specified type.
*
* <p> This method traverses the list of registered security providers,
* starting with the most preferred Provider.
* A new Policy object encapsulating the
* PolicySpi implementation from the first
* Provider that supports the specified type is returned.
*
* <p> Note that the list of registered providers may be retrieved via
* the {@link Security#getProviders() Security.getProviders()} method.
*
* @param type the specified Policy type. See the Policy section in the
* <a href=
* "{@docRoot}/../technotes/guides/security/StandardNames.html#Policy">
* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
* for a list of standard Policy types.
*
* @param params parameters for the Policy, which may be null.
*
* @return the new Policy object.
*
* @exception SecurityException if the caller does not have permission
* to get a Policy instance for the specified type.
*
* @exception NullPointerException if the specified type is null.
*
* @exception IllegalArgumentException if the specified parameters
* are not understood by the PolicySpi implementation
* from the selected Provider.
*
* @exception NoSuchAlgorithmException if no Provider supports a PolicySpi
* implementation for the specified type.
*
* @see Provider
* @since 1.6
*/
throws NoSuchAlgorithmException {
try {
PolicySpi.class,
type,
params);
type,
params);
} catch (NoSuchAlgorithmException nsae) {
return handleException(nsae);
}
}
/**
* Returns a Policy object of the specified type.
*
* <p> A new Policy object encapsulating the
* PolicySpi implementation from the specified provider
* is returned. The specified provider must be registered
* in the provider list.
*
* <p> Note that the list of registered providers may be retrieved via
* the {@link Security#getProviders() Security.getProviders()} method.
*
* @param type the specified Policy type. See the Policy section in the
* <a href=
* "{@docRoot}/../technotes/guides/security/StandardNames.html#Policy">
* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
* for a list of standard Policy types.
*
* @param params parameters for the Policy, which may be null.
*
* @param provider the provider.
*
* @return the new Policy object.
*
* @exception SecurityException if the caller does not have permission
* to get a Policy instance for the specified type.
*
* @exception NullPointerException if the specified type is null.
*
* @exception IllegalArgumentException if the specified provider
* is null or empty,
* or if the specified parameters are not understood by
* the PolicySpi implementation from the specified provider.
*
* @exception NoSuchProviderException if the specified provider is not
* registered in the security provider list.
*
* @exception NoSuchAlgorithmException if the specified provider does not
* support a PolicySpi implementation for the specified type.
*
* @see Provider
* @since 1.6
*/
throw new IllegalArgumentException("missing provider");
}
try {
PolicySpi.class,
type,
provider);
type,
params);
} catch (NoSuchAlgorithmException nsae) {
return handleException(nsae);
}
}
/**
* Returns a Policy object of the specified type.
*
* <p> A new Policy object encapsulating the
* PolicySpi implementation from the specified Provider
* object is returned. Note that the specified Provider object
* does not have to be registered in the provider list.
*
* @param type the specified Policy type. See the Policy section in the
* <a href=
* "{@docRoot}/../technotes/guides/security/StandardNames.html#Policy">
* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
* for a list of standard Policy types.
*
* @param params parameters for the Policy, which may be null.
*
* @param provider the Provider.
*
* @return the new Policy object.
*
* @exception SecurityException if the caller does not have permission
* to get a Policy instance for the specified type.
*
* @exception NullPointerException if the specified type is null.
*
* @exception IllegalArgumentException if the specified Provider is null,
* or if the specified parameters are not understood by
* the PolicySpi implementation from the specified Provider.
*
* @exception NoSuchAlgorithmException if the specified Provider does not
* support a PolicySpi implementation for the specified type.
*
* @see Provider
* @since 1.6
*/
throws NoSuchAlgorithmException {
throw new IllegalArgumentException("missing provider");
}
try {
PolicySpi.class,
type,
provider);
type,
params);
} catch (NoSuchAlgorithmException nsae) {
return handleException(nsae);
}
}
throws NoSuchAlgorithmException {
if (cause instanceof IllegalArgumentException) {
throw (IllegalArgumentException)cause;
}
throw nsae;
}
/**
* Return the Provider of this Policy.
*
* <p> This Policy instance will only have a Provider if it
* was obtained via a call to <code>Policy.getInstance</code>.
* Otherwise this method returns null.
*
* @return the Provider of this Policy, or null.
*
* @since 1.6
*/
return null;
}
/**
* Return the type of this Policy.
*
* <p> This Policy instance will only have a type if it
* was obtained via a call to <code>Policy.getInstance</code>.
* Otherwise this method returns null.
*
* @return the type of this Policy, or null.
*
* @since 1.6
*/
return null;
}
/**
* Return Policy parameters.
*
* <p> This Policy instance will only have parameters if it
* was obtained via a call to <code>Policy.getInstance</code>.
* Otherwise this method returns null.
*
* @return Policy parameters, or null.
*
* @since 1.6
*/
return null;
}
/**
* Return a PermissionCollection object containing the set of
* permissions granted to the specified CodeSource.
*
* <p> Applications are discouraged from calling this method
* since this operation may not be supported by all policy implementations.
* Applications should solely rely on the <code>implies</code> method
* to perform policy checks. If an application absolutely must call
* a getPermissions method, it should call
* <code>getPermissions(ProtectionDomain)</code>.
*
* <p> The default implementation of this method returns
* Policy.UNSUPPORTED_EMPTY_COLLECTION. This method can be
* overridden if the policy implementation can return a set of
* permissions granted to a CodeSource.
*
* @param codesource the CodeSource to which the returned
* PermissionCollection has been granted.
*
* @return a set of permissions granted to the specified CodeSource.
* If this operation is supported, the returned
* set of permissions must be a new mutable instance
* and it must support heterogeneous Permission types.
* If this operation is not supported,
* Policy.UNSUPPORTED_EMPTY_COLLECTION is returned.
*/
return Policy.UNSUPPORTED_EMPTY_COLLECTION;
}
/**
* Return a PermissionCollection object containing the set of
* permissions granted to the specified ProtectionDomain.
*
* <p> Applications are discouraged from calling this method
* since this operation may not be supported by all policy implementations.
* Applications should rely on the <code>implies</code> method
* to perform policy checks.
*
* <p> The default implementation of this method first retrieves
* the permissions returned via <code>getPermissions(CodeSource)</code>
* (the CodeSource is taken from the specified ProtectionDomain),
* as well as the permissions located inside the specified ProtectionDomain.
* All of these permissions are then combined and returned in a new
* PermissionCollection object. If <code>getPermissions(CodeSource)</code>
* returns Policy.UNSUPPORTED_EMPTY_COLLECTION, then this method
* returns the permissions contained inside the specified ProtectionDomain
* in a new PermissionCollection object.
*
* <p> This method can be overridden if the policy implementation
* supports returning a set of permissions granted to a ProtectionDomain.
*
* @param domain the ProtectionDomain to which the returned
* PermissionCollection has been granted.
*
* @return a set of permissions granted to the specified ProtectionDomain.
* If this operation is supported, the returned
* set of permissions must be a new mutable instance
* and it must support heterogeneous Permission types.
* If this operation is not supported,
* Policy.UNSUPPORTED_EMPTY_COLLECTION is returned.
*
* @since 1.4
*/
return new Permissions();
initPolicy(this);
}
synchronized (pdMapping) {
}
synchronized (pc) {
}
}
return perms;
}
pc = new Permissions();
}
return pc;
}
/**
* add static permissions to provided permission collection
*/
synchronized (statics) {
while (e.hasMoreElements()) {
}
}
}
}
/**
* Evaluates the global policy for the permissions granted to
* the ProtectionDomain and tests whether the permission is
* granted.
*
* @param domain the ProtectionDomain to test
* @param permission the Permission object to be tested for implication.
*
* @return true if "permission" is a proper subset of a permission
* granted to this ProtectionDomain.
*
* @see java.security.ProtectionDomain
* @since 1.4
*/
initPolicy(this);
}
synchronized (pdMapping) {
}
}
return false;
}
synchronized (pdMapping) {
// cache it
}
}
/**
* depends on the implementation. For example, calling <code>refresh</code>
* on a file-based policy will cause the file to be re-read.
*
* <p> The default implementation of this method does nothing.
* This method should be overridden if a refresh operation is supported
* by the policy implementation.
*/
public void refresh() { }
/**
* This subclass is returned by the getInstance calls. All Policy calls
* are delegated to the underlying PolicySpi.
*/
private Provider p;
this.p = p;
}
}
}
}
public void refresh() {
spi.engineRefresh();
}
}
/**
* This represents a marker interface for Policy parameters.
*
* @since 1.6
*/
public static interface Parameters { }
/**
* This class represents a read-only empty PermissionCollection object that
* is returned from the <code>getPermissions(CodeSource)</code> and
* <code>getPermissions(ProtectionDomain)</code>
* methods in the Policy class when those operations are not
* supported by the Policy implementation.
*/
private static class UnsupportedEmptyCollection
extends PermissionCollection {
/**
* Create a read-only empty PermissionCollection object.
*/
public UnsupportedEmptyCollection() {
this.perms = new Permissions();
perms.setReadOnly();
}
/**
* Adds a permission object to the current collection of permission
* objects.
*
* @param permission the Permission object to add.
*
* @exception SecurityException - if this PermissionCollection object
* has been marked readonly
*/
}
/**
* Checks to see if the specified permission is implied by the
* collection of Permission objects held in this PermissionCollection.
*
* @param permission the Permission object to compare.
*
* @return true if "permission" is implied by the permissions in
* the collection, false if not.
*/
}
/**
* Returns an enumeration of all the Permission objects in the
* collection.
*
* @return an enumeration of all the Permissions.
*/
}
}
}