Policy is an abstract class for managing the system security
* policy for the Java application environment. It specifies which permissions
* are available for code from various sources. The security policy is
* represented through a subclass of Policy.
*
* Only one Policy is in effect at any time. A
* {@link ProtectionDomain} initializes itself with information from this class
* on the set of permssions to grant.
The location for the actual Policy could be anywhere in any
* form because it depends on the Policy implementation. The default system is
* in a flat ASCII file or it could be in a database.
The current installed Policy can be accessed with
* {@link #getPolicy()} and changed with {@link #setPolicy(Policy)} if the code
* has the correct permissions.
The {@link #refresh()} method causes the Policy instance to
* refresh/reload its configuration. The method used to refresh depends on the
* Policy implementation.
When a protection domain initializes its permissions, it uses code like * the following:
* *
* policy = Policy.getPolicy();
* PermissionCollection perms = policy.getPermissions(myCodeSource);
*
*
* The protection domain passes the Policy handler a
* {@link CodeSource} instance which contains the codebase URL and a public key.
* The Policy implementation then returns the proper set of
* permissions for that {@link CodeSource}.
The default Policy implementation can be changed by setting
* the "policy.provider" security provider in the "java.security" file to the
* correct Policy implementation class.
Policy object. */
public Policy()
{
}
/**
* Returns the currently installed Policy handler. The value
* should not be cached as it can be changed any time by
* {@link #setPolicy(Policy)}.
*
* @return the current Policy.
* @throws SecurityException
* if a {@link SecurityManager} is installed which disallows this
* operation.
*/
public static Policy getPolicy()
{
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkPermission(new SecurityPermission("getPolicy"));
return getCurrentPolicy();
}
/**
* Sets the Policy handler to a new value.
*
* @param policy
* the new Policy to use.
* @throws SecurityException
* if a {@link SecurityManager} is installed which disallows this
* operation.
*/
public static void setPolicy(Policy policy)
{
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkPermission(new SecurityPermission("setPolicy"));
setup(policy);
currentPolicy = policy;
}
private static void setup(final Policy policy)
{
if (policy.pd2pc == null)
policy.pd2pc = Collections.synchronizedMap(new LinkedHashMap());
ProtectionDomain pd = policy.getClass().getProtectionDomain();
if (pd.getCodeSource() != null)
{
PermissionCollection pc = null;
if (currentPolicy != null)
pc = currentPolicy.getPermissions(pd);
if (pc == null) // assume it has all
{
pc = new Permissions();
pc.add(new AllPermission());
}
policy.pd2pc.put(pd, pc); // add the mapping pd -> pc
}
}
/**
* Ensures/forces loading of the configured policy provider, while bypassing
* the {@link SecurityManager} checks for "getPolicy" security
* permission. Needed by {@link ProtectionDomain}.
*/
static Policy getCurrentPolicy()
{
// FIXME: The class name of the Policy provider should really be sourced
// from the "java.security" configuration file. For now, just hard-code
// a stub implementation.
if (currentPolicy == null)
{
String pp = System.getProperty ("policy.provider");
if (pp != null)
try
{
currentPolicy = (Policy) Class.forName(pp).newInstance();
}
catch (Exception e)
{
// Ignored.
}
if (currentPolicy == null)
currentPolicy = new gnu.java.security.provider.DefaultPolicy();
}
return currentPolicy;
}
/**
* Tests if currentPolicy is not null,
* thus allowing clients to not force loading of any policy
* provider; needed by {@link ProtectionDomain}.
*/
static boolean isLoaded()
{
return currentPolicy != null;
}
/**
* Returns the set of Permissions allowed for a given {@link CodeSource}.
*
* @param codesource
* the {@link CodeSource} for which, the caller needs to find the
* set of granted permissions.
* @return a set of permissions for {@link CodeSource} specified by the
* current Policy.
* @throws SecurityException
* if a {@link SecurityManager} is installed which disallows this
* operation.
*/
public abstract PermissionCollection getPermissions(CodeSource codesource);
/**
* Returns the set of Permissions allowed for a given {@link ProtectionDomain}.
*
* @param domain
* the {@link ProtectionDomain} for which, the caller needs to find
* the set of granted permissions.
* @return a set of permissions for {@link ProtectionDomain} specified by the
* current Policy..
* @since 1.4
* @see ProtectionDomain
* @see SecureClassLoader
*/
public PermissionCollection getPermissions(ProtectionDomain domain)
{
if (domain == null)
return new Permissions();
if (pd2pc == null)
setup(this);
PermissionCollection result = (PermissionCollection) pd2pc.get(domain);
if (result != null)
{
Permissions realResult = new Permissions();
for (Enumeration e = result.elements(); e.hasMoreElements(); )
realResult.add((Permission) e.nextElement());
return realResult;
}
result = getPermissions(domain.getCodeSource());
if (result == null)
result = new Permissions();
PermissionCollection pc = domain.getPermissions();
if (pc != null)
for (Enumeration e = pc.elements(); e.hasMoreElements(); )
result.add((Permission) e.nextElement());
return result;
}
/**
* Checks if the designated {@link Permission} is granted to a designated
* {@link ProtectionDomain}.
*
* @param domain
* the {@link ProtectionDomain} to test.
* @param permission
* the {@link Permission} to check.
* @return true if permission is implied by a
* permission granted to this {@link ProtectionDomain}. Returns
* false otherwise.
* @since 1.4
* @see ProtectionDomain
*/
public boolean implies(ProtectionDomain domain, Permission permission)
{
if (pd2pc == null)
setup(this);
PermissionCollection pc = (PermissionCollection) pd2pc.get(domain);
if (pc != null)
return pc.implies(permission);
boolean result = false;
pc = getPermissions(domain);
if (pc != null)
{
result = pc.implies(permission);
pd2pc.put(domain, pc);
}
return result;
}
/**
* Causes this Policy instance to refresh / reload its
* configuration. The method used to refresh depends on the concrete
* implementation.
*/
public abstract void refresh();
}