* This wrapper class is assumed to be available directly in the activation * group VM; that is, it is assumed to be in the application classloader, * the extension classloader, or the boot classloader, rather than being * downloaded. Since this class also needs considerable permissions, the * easiest thing to do is to make it an installed extension. *
* This wrapper class performs a security check to control what
* policy files can be used with a given codebase.
* It does this by querying the VM's (global) policy for
* {@link com.sun.jini.start.SharedActivationPolicyPermission}
* grants. The service's associated
* {@link com.sun.jini.start.ActivateWrapper.ActivateDesc#importLocation
* ActivateDesc.importLocation} is used as
* the {@link java.security.CodeSource}
* for selecting the appropriate permission set to
* check against. If multiple codebases are used, then all the codebases must
* have the necessary SharedActivationPolicyPermission grants.
*
* An example of how to use this wrapper: *
* URL[] importURLs = new URL[] {new URL("http://myhost:8080/service.jar")};
* URL[] exportURLs = new URL[] {new URL("http://myhost:8080/service-dl.jar")};
* ActivationID aid
* = ActivateWrapper.register(
* gid,
* new ActivateWrapper.ActivateDesc(
* "foo.bar.ServiceImpl",
* importURLs,
* exportURLs,
* "http://myhost:8080/service.policy",
* new MarshalledObject(
* new String[] { "/tmp/service.config" })
* ),
* true,
* activationSystem);
*
*
* Clients of this wrapper service need to implement the following "activation
* constructor":
* * where, ** <impl>(ActivationID activationID, MarshalledObject data) *
| • * |
* com.sun.jini.start.servicePolicyProvider
* | |
|---|---|---|
| * Default: |
* "net.jini.security.policy.DynamicPolicyProvider"
*
* | |
| * Description: | The fully qualified class name of a
* dynamic policy provider (see {@link net.jini.security.policy.DynamicPolicy})
* which will be used to "wrap" all service policy files.
* The implementation class needs to:
*
* A custom service policy provider can be very useful when trying to
* debug security related issues.
* | |
Policy object that aggregates the individual
* service policy objects.
*/
private static AggregatePolicyProvider globalPolicy;
/**
* The Policy object in effect at startup.
*/
private static Policy initialGlobalPolicy;
/**
* The "wrapped" activatable object.
* @serial
*/
private /*final*/ Object impl;
/**
* The parameter types for the "activation constructor".
*/
private static final Class[] actTypes = {
ActivationID.class, MarshalledObject.class
};
/**
* Fully qualified name of custom, service policy provider
*/
private static String servicePolicyProvider =
((String) AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
return Security.getProperty(
"com.sun.jini.start." +
"servicePolicyProvider");
}
}));
/**
* The parameter types for the
* "custom, service policy constructor".
*/
private static final Class[] policyTypes = {
Policy.class
};
/**
* Descriptor for registering a "wrapped" activatable object. This
* descriptor gets stored as the MarshalledObject
* initialization data in the ActivationDesc.
*/
public static class ActivateDesc implements Serializable {
private static final long serialVersionUID = 2L;
/**
* The activatable object's class name.
* @serial
*/
public final String className;
/**
* The codebase where the server classes are loaded from by the
* activation group.
* @serial
*/
public final URL[] importLocation;
/**
* The codebase where clients should load classes from for stubs, etc.
* @serial
*/
public final URL[] exportLocation;
/**
* The security policy filename or URL.
* @serial
*/
public final String policy;
/**
* The activatable object's initialization data.
* @serial
*/
public final MarshalledObject data;
/**
* Trivial constructor.
*/
public ActivateDesc(String className,
URL[] importLocation,
URL[] exportLocation,
String policy,
MarshalledObject data)
{
//TODO - clone non-String objects?
this.className = className;
this.importLocation = importLocation;
this.exportLocation = exportLocation;
this.policy = policy;
this.data = data;
}
// Javadoc inherited from supertype
public String toString() {
return "[className=" + className + ","
+ "importLocation="
+ ((importLocation == null)
? null : Arrays.asList(importLocation))
+ ","
+ "exportLocation="
+ ((exportLocation == null)
? null : Arrays.asList(exportLocation))
+ ","
+ "policy=" + policy + ","
+ "data=" + data + "]";
}
}
/**
* A simple subclass of PreferredClassLoader that overrides
* getURLs to
* return the URLs of the provided export codebase.
* getURLs
* is called by the RMI subsystem in order to annotate objects
* leaving the virtual machine.
*/
/*
* Implementation note. Subclasses of this class that override
* getClassAnnotation might need to override getURLs because getURLs
* uses a "cached" version of the export annotation.
*/
static class ExportClassLoader extends PreferredClassLoader
{
/** Cached value of the provided export codebase URLs */
private final URL[] exportURLs;
/** Id field used to make toString() unique */
private final Uuid id = UuidFactory.generate();
/** Trivial constructor that calls
*
* super(importURLs, parent, urlsToPath(exportURLs), false);
*
* and assigns exportURLs to an internal field.
*/
public ExportClassLoader(URL[] importURLs, URL[] exportURLs,
ClassLoader parent)
{
super(importURLs, parent, urlsToPath(exportURLs), false);
// Not safe to call getClassAnnotation() w/i cons if subclassed,
// so need to redo "super" logic here.
if (exportURLs == null) {
this.exportURLs = importURLs;
} else {
this.exportURLs = exportURLs;
}
}
//Javadoc inherited from super type
public URL[] getURLs() {
return (URL[])exportURLs.clone();
}
// Javadoc inherited from supertype
public String toString() {
URL[] urls = super.getURLs();
return this.getClass().getName()
+ "[importURLs="
+ (urls==null?null:Arrays.asList(urls))
+ ","
+ "exportURLs="
+ (exportURLs==null?null:Arrays.asList(exportURLs))
+ ","
+ "parent=" + getParent()
+ ","
+ "id=" + id
+ "]";
}
}
/**
* Activatable constructor. This constructor:
* ActivateDesc from the
* provided data parameter.
* ExportClassLoader using the
* import and export codebases obtained from the provided
* ActivateDesc,
* SharedActivationPolicyPermission
* ExportClassLoader
* and the corresponding policy file obtained from the
* ActivateDesc with the
* AggregatePolicyProvider
* ExportClassLoader.
* Policy object, if any,
* with a AggregatePolicyProvider.
*
* @param id The ActivationID of this object
* @param data The activation data for this object
*
* @see com.sun.jini.start.ActivateWrapper.ExportClassLoader
* @see com.sun.jini.start.ActivateWrapper.ActivateDesc
* @see com.sun.jini.start.AggregatePolicyProvider
* @see com.sun.jini.start.SharedActivationPolicyPermission
* @see java.security.Policy
*
*/
public ActivateWrapper(ActivationID id, MarshalledObject data)
throws Exception
{
try {
logger.entering(ActivateWrapper.class.getName(),
"ActivateWrapper", new Object[] { id, data });
ActivateDesc desc = (ActivateDesc)data.get();
logger.log(Level.FINEST, "ActivateDesc: {0}", desc);
Thread t = Thread.currentThread();
ClassLoader ccl = t.getContextClassLoader();
logger.log(Level.FINEST, "Saved current context class loader: {0}",
ccl);
ExportClassLoader cl = null;
try {
cl = new ExportClassLoader(desc.importLocation,
desc.exportLocation,
ccl);
logger.log(Level.FINEST, "Created ExportClassLoader: {0}", cl);
} catch (Exception e) {
logger.throwing(ActivateWrapper.class.getName(),
"ActivateWrapper", e);
throw e;
}
checkPolicyPermission(desc.policy, desc.importLocation);
synchronized (ActivateWrapper.class) {
// supplant global policy 1st time through
if (globalPolicy == null) {
initialGlobalPolicy = Policy.getPolicy();
if (!(initialGlobalPolicy instanceof DynamicPolicy)) {
initialGlobalPolicy =
new DynamicPolicyProvider(initialGlobalPolicy);
}
globalPolicy =
new AggregatePolicyProvider(initialGlobalPolicy);
Policy.setPolicy(globalPolicy);
logger.log(Level.FINEST,
"Global policy set: {0}", globalPolicy);
}
Policy service_policy =
getServicePolicyProvider(
new PolicyFileProvider(desc.policy));
Policy backstop_policy =
getServicePolicyProvider(initialGlobalPolicy);
LoaderSplitPolicyProvider split_service_policy =
new LoaderSplitPolicyProvider(
cl, service_policy, backstop_policy);
/* Grant "this" code enough permission to do its work
* under the service policy, which takes effect (below)
* after the context loader is (re)set.
* Note: Throws UnsupportedOperationException if dynamic grants
* aren't supported (because underlying policies don't support it).
*/
split_service_policy.grant(
this.getClass(),
null, /* Principal[] */
new Permission[] { new AllPermission() } );
globalPolicy.setPolicy(cl, split_service_policy);
logger.log(Level.FINEST,
"Added policy to set: {0}", desc.policy);
}
boolean initialize = false;
Class ac = Class.forName(desc.className, initialize, cl);
logger.log(Level.FINEST, "Obtained implementation class: {0}", ac);
t.setContextClassLoader(cl);
try {
logger.log(Level.FINEST,
"Set new context class loader: {0}", cl);
Constructor constructor =
ac.getDeclaredConstructor(actTypes);
logger.log(Level.FINEST,
"Obtained implementation constructor: {0}",
constructor);
constructor.setAccessible(true);
impl =
constructor.newInstance(new Object[]{id, desc.data});
logger.log(Level.FINEST,
"Obtained implementation instance: {0}", impl);
} finally {
t.setContextClassLoader(ccl);
logger.log(Level.FINEST, "Context class loader reset to: {0}",
ccl);
}
} catch (Exception e) {
logger.throwing(ActivateWrapper.class.getName(),
"ActivateWrapper", e);
throw e;
}
logger.exiting(ActivateWrapper.class.getName(),
"ActivateWrapper");
}
/**
* Return a reference to service being wrapped in place
* of this object.
*/
private Object writeReplace() throws ObjectStreamException {
Object impl_proxy = impl;
if (impl instanceof ProxyAccessor) {
impl_proxy = ((ProxyAccessor) impl).getProxy();
logger.log(Level.FINEST,
"Obtained implementation proxy: {0}", impl_proxy);
if (impl_proxy == null) {
throw new InvalidObjectException(
"Implementation's getProxy() returned null");
}
}
return impl_proxy;
}
/**
* Analog to
* {@link java.rmi.activation.Activatable#register(java.rmi.activation.ActivationDesc)
* Activatable.register()} for activatable objects that want
* to use this wrapper mechanism.
*
* @return activation ID of the registered service
*
* @throws ActivationException if there was a problem registering
* the activatable class with the activation system
* @throws RemoteException if there was a problem communicating
* with the activation system
*/
public static ActivationID register(ActivationGroupID gid,
ActivateDesc desc,
boolean restart,
ActivationSystem sys)
throws ActivationException, RemoteException
{
logger.entering(ActivateWrapper.class.getName(),
"register", new Object[] { gid, desc, Boolean.valueOf(restart), sys });
MarshalledObject data;
try {
data = new MarshalledObject(desc);
} catch (Exception e) {
MarshalException me =
new MarshalException("marshalling ActivateDesc", e);
logger.throwing(ActivateWrapper.class.getName(),
"register", me);
throw me;
}
ActivationDesc adesc =
new ActivationDesc(gid,
ActivateWrapper.class.getName(),
null,
data,
restart
);
logger.log(Level.FINEST,
"Registering descriptor with activation: {0}", adesc);
ActivationID aid = sys.registerObject(adesc);
logger.exiting(ActivateWrapper.class.getName(),
"register", aid);
return aid;
}
/**
* Checks that all the provided URLs have permission to
* use the given policy.
*/
private static void checkPolicyPermission(String policy, URL[] urls) {
logger.entering(ActivateWrapper.class.getName(),
"checkPolicyPermission", new Object[] { policy, urlsToPath(urls) });
// Create desired permission object
Permission perm = new SharedActivationPolicyPermission(policy);
Certificate[] certs = null;
CodeSource cs = null;
ProtectionDomain pd = null;
// Loop over all codebases
for (int i=0; i < urls.length; i++) {
// Create ProtectionDomain for given codesource
cs = new CodeSource(urls[i], certs);
pd = new ProtectionDomain(cs, null, null, null);
logger.log(Level.FINEST,
"Checking protection domain: {0}", pd);
// Check if current domain allows desired permission
if(!pd.implies(perm)) {
SecurityException se = new SecurityException(
"ProtectionDomain " + pd
+ " does not have required permission: " + perm);
logger.throwing(ActivateWrapper.class.getName(),
"checkPolicyPermission", se);
throw se;
}
}
logger.exiting(ActivateWrapper.class.getName(),
"checkPolicyPermission");
}
/**
* Utility method that converts a URL[]
* into a corresponding, space-separated string with
* the same array elements.
*
* Note that if the array has zero elements, the return value is
* null, not the empty string.
*/
private static String urlsToPath(URL[] urls) {
//TODO - check if spaces in file paths are properly escaped (i.e.% chars)
if (urls == null) {
return null;
} else if (urls.length == 0) {
return "";
} else if (urls.length == 1) {
return urls[0].toExternalForm();
} else {
StringBuffer path = new StringBuffer(urls[0].toExternalForm());
for (int i = 1; i < urls.length; i++) {
path.append(' ');
path.append(urls[i].toExternalForm());
}
return path.toString();
}
}
static Policy getServicePolicyProvider(Policy service_policy) throws Exception {
Policy servicePolicyWrapper = null;
if (servicePolicyProvider != null) {
Class sp = Class.forName(servicePolicyProvider);
logger.log(Level.FINEST,
"Obtained custom service policy implementation class: {0}", sp);
Constructor constructor =
sp.getConstructor(policyTypes);
logger.log(Level.FINEST,
"Obtained custom service policy implementation constructor: {0}",
constructor);
servicePolicyWrapper = (Policy)
constructor.newInstance(new Object[]{service_policy});
logger.log(Level.FINEST,
"Obtained custom service policy implementation instance: {0}",
servicePolicyWrapper);
} else {
servicePolicyWrapper = new DynamicPolicyProvider(service_policy);
logger.log(Level.FINEST,
"Using default service policy implementation instance: {0}",
servicePolicyWrapper);
}
return servicePolicyWrapper;
}
}