/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.security;
import java.util.ArrayList;
import java.util.WeakHashMap;
import org.apache.harmony.security.fortress.SecurityUtils;
/**
* {@code AccessController} provides static methods to perform access control
* checks and privileged operations.
*/
public final class AccessController {
private AccessController() {
throw new Error("statics only.");
}
/**
* A map used to store a mapping between a given Thread and
* AccessControllerContext-s used in successive calls of doPrivileged(). A
* WeakHashMap is used to allow automagical wiping of the dead threads from
* the map. The thread (normally Thread.currentThread()) is used as a key
* for the map, and a value is ArrayList where all AccessControlContext-s
* are stored.
* ((ArrayList)contexts.get(Thread.currentThread())).lastElement() - is
* reference to the latest context passed to the doPrivileged() call.
*/
private static final WeakHashMap<Thread, ArrayList<AccessControlContext>> contexts = new WeakHashMap<Thread, ArrayList<AccessControlContext>>();
/**
* Returns the result of executing the specified privileged action. Only the
* {@code ProtectionDomain} of the direct caller of this method and the
* {@code ProtectionDomain}s of all subsequent classes in the call chain are
* checked to be granted the necessary permission if access checks are
* performed.
* <p>
* If an instance of {@code RuntimeException} is thrown during the execution
* of the {@code PrivilegedAction#run()} method of the given action, it will
* be propagated through this method.
*
* @param action
* the action to be executed with privileges
* @return the result of executing the privileged action
* @throws NullPointerException
* if the specified action is {@code null}
* @since Android 1.0
*/
public static <T> T doPrivileged(PrivilegedAction<T> action) {
if (action == null) {
throw new NullPointerException("action can not be null");
}
return doPrivilegedImpl(action, null);
}
/**
* Returns the result of executing the specified privileged action. The
* {@code ProtectionDomain} of the direct caller of this method, the {@code
* ProtectionDomain}s of all subsequent classes in the call chain and all
* {@code ProtectionDomain}s of the given context are checked to be granted
* the necessary permission if access checks are performed.
* <p>
* If an instance of {@code RuntimeException} is thrown during the execution
* of the {@code PrivilegedAction#run()} method of the given action, it will
* be propagated through this method.
*
* @param action
* the action to be executed with privileges
* @param context
* the {@code AccessControlContext} whose protection domains are
* checked additionally
* @return the result of executing the privileged action
* @throws NullPointerException
* if the specified action is {@code null}
* @since Android 1.0
*/
public static <T> T doPrivileged(PrivilegedAction<T> action,
AccessControlContext context) {
if (action == null) {
throw new NullPointerException("action can not be null");
}
return doPrivilegedImpl(action, context);
}
/**
* Returns the result of executing the specified privileged action. Only the
* {@code ProtectionDomain} of the direct caller of this method and the
* {@code ProtectionDomain}s of all subsequent classes in the call chain are
* checked to be granted the necessary permission if access checks are
* performed.
* <p>
* If a checked exception is thrown by the action's run method, it will be
* wrapped and propagated through this method.
* <p>
* If an instance of {@code RuntimeException} is thrown during the execution
* of the {@code PrivilegedAction#run()} method of the given action, it will
* be propagated through this method.
*
* @param action
* the action to be executed with privileges
* @return the result of executing the privileged action
* @throws PrivilegedActionException
* if the action's run method throws any checked exception
* @throws NullPointerException
* if the specified action is {@code null}
* @since Android 1.0
*/
public static <T> T doPrivileged(PrivilegedExceptionAction<T> action)
throws PrivilegedActionException {
if (action == null) {
throw new NullPointerException("action can not be null");
}
return doPrivilegedImpl(action, null);
}
/**
* Returns the result of executing the specified privileged action. The
* {@code ProtectionDomain} of the direct caller of this method, the {@code
* ProtectionDomain}s of all subsequent classes in the call chain and all
* {@code ProtectionDomain}s of the given context are checked to be granted
* the necessary permission if access checks are performed.
* <p>
* If a checked exception is thrown by the action's run method, it will be
* wrapped and propagated through this method.
* <p>
* If an instance of {@code RuntimeException} is thrown during the execution
* of the {@code PrivilegedAction#run()} method of the given action, it will
* be propagated through this method.
*
* @param action
* the action to be executed with privileges
* @param context
* the {@code AccessControlContext} whose protection domains are
* checked additionally
* @return the result of executing the privileged action
* @throws PrivilegedActionException
* if the action's run method throws any checked exception
* @throws NullPointerException
* if the specified action is {@code null}
* @since Android 1.0
*/
public static <T> T doPrivileged(PrivilegedExceptionAction<T> action,
AccessControlContext context) throws PrivilegedActionException {
if (action == null) {
throw new NullPointerException("action can not be null");
}
return doPrivilegedImpl(action, context);
}
/**
* The real implementation of doPrivileged() method. It pushes the passed
* context into this thread's contexts stack, and then invokes
* <code>action.run()</code>. The pushed context is then investigated in the
* {@link #getContext()} which is called in the {@link #checkPermission}.
*/
private static <T> T doPrivilegedImpl(PrivilegedExceptionAction<T> action,
AccessControlContext context) throws PrivilegedActionException {
Thread currThread = Thread.currentThread();
ArrayList<AccessControlContext> a = null;
try {
// currThread==null means that VM warm up is in progress
if (currThread != null && contexts != null) {
synchronized (contexts) {
a = contexts.get(currThread);
if (a == null) {
a = new ArrayList<AccessControlContext>();
contexts.put(currThread, a);
}
}
a.add(context);
}
return action.run();
} catch (Exception ex) {
// Errors automagically go through - they are not catched by this
// block
// Unchecked exceptions must pass through without modification
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
}
// All other (==checked) exceptions get wrapped
throw new PrivilegedActionException(ex);
} finally {
if (currThread != null) {
// No need to sync() here, as each given 'a' will be accessed
// only from one Thread. 'contexts' still need sync() however,
// as it's accessed from different threads simultaneously
if (a != null) {
// it seems I will never have here [v.size() == 0]
a.remove(a.size() - 1);
}
}
}
}
/**
* The real implementation of appropriate doPrivileged() method.<br>
* It pushes the passed context into this thread's stack of contexts and
* then invokes <code>action.run()</code>.<br>
* The pushed context is then investigated in the {@link #getContext()}
* which is called in the {@link #checkPermission}.
*/
private static <T> T doPrivilegedImpl(PrivilegedAction<T> action,
AccessControlContext context) {
Thread currThread = Thread.currentThread();
if (currThread == null || contexts == null) {
// Big boom time - VM is starting... No need to check permissions:
// 1st, I do believe there is no malicious code available here for
// this moment
// 2d, I cant use currentThread() as a key anyway - when it will
// turn into the real Thread, I'll be unable to retrieve the value
// stored with 'currThread==null' as a key.
return action.run();
}
ArrayList<AccessControlContext> a = null;
try {
synchronized (contexts) {
a = contexts.get(currThread);
if (a == null) {
a = new ArrayList<AccessControlContext>();
contexts.put(currThread, a);
}
}
a.add(context);
return action.run();
} finally {
// No need to sync() here, as each given 'a' will be accessed
// only from one Thread. 'contexts' still need sync() however,
// as it's accessed from different threads simultaneously
if (a != null) {
a.remove(a.size() - 1);
}
}
}
/**
* Checks the specified permission against the vm's current security policy.
* The check is performed in the context of the current thread. This method
* returns silently if the permission is granted, otherwise an {@code
* AccessControlException} is thrown.
* <p>
* A permission is considered granted if every {@link ProtectionDomain} in
* the current execution context has been granted the specified permission.
* If privileged operations are on the execution context, only the {@code
* ProtectionDomain}s from the last privileged operation are taken into
* account.
* <p>
* This method delegates the permission check to
* {@link AccessControlContext#checkPermission(Permission)} on the current
* callers' context obtained by {@link #getContext()}.
*
* @param perm
* the permission to check against the policy
* @throws AccessControlException
* if the specified permission is not granted
* @throws NullPointerException
* if the specified permission is {@code null}
* @see AccessControlContext#checkPermission(Permission)
*
* @since Android 1.0
*/
public static void checkPermission(Permission perm)
throws AccessControlException {
if (perm == null) {
throw new NullPointerException("permission can not be null");
}
getContext().checkPermission(perm);
}
/**
* Returns array of ProtectionDomains from the classes residing on the stack
* of the current thread, up to and including the caller of the nearest
* privileged frame. Reflection frames are skipped. The returned array is
* never null and never contains null elements, meaning that bootstrap
* classes are effectively ignored.
*/
private static native ProtectionDomain[] getStackDomains();
/**
* Returns the {@code AccessControlContext} for the current {@code Thread}
* including the inherited access control context of the thread that spawned
* the current thread (recursively).
* <p>
* The returned context may be used to perform access checks at a later
* point in time, possibly by another thread.
*
* @return the {@code AccessControlContext} for the current {@code Thread}
* @see Thread#currentThread
* @since Android 1.0
*/
public static AccessControlContext getContext() {
// duplicates (if any) will be removed in ACC constructor
ProtectionDomain[] stack = getStackDomains();
Thread currThread = Thread.currentThread();
if (currThread == null || contexts == null) {
// Big boo time. No need to check anything ?
return new AccessControlContext(stack);
}
ArrayList<AccessControlContext> threadContexts;
synchronized (contexts) {
threadContexts = contexts.get(currThread);
}
AccessControlContext that;
if ((threadContexts == null) || (threadContexts.size() == 0)) {
// We were not in doPrivileged method, so
// have inherited context here
that = SecurityUtils.getContext(currThread);
} else {
// We were in doPrivileged method, so
// Use context passed to the doPrivileged()
that = threadContexts.get(threadContexts.size() - 1);
}
if (that != null && that.combiner != null) {
ProtectionDomain[] assigned = null;
if (that.context != null && that.context.length != 0) {
assigned = new ProtectionDomain[that.context.length];
System.arraycopy(that.context, 0, assigned, 0, assigned.length);
}
ProtectionDomain[] allpds = that.combiner.combine(stack, assigned);
if (allpds == null) {
allpds = new ProtectionDomain[0];
}
return new AccessControlContext(allpds, that.combiner);
}
return new AccessControlContext(stack, that);
}
}
|
