Java SecurityConstants类代码示例

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * Creates one of the well-known permissions directly instead of
 * via reflection. Keep list short to not penalize non-JDK-defined
 * permissions.
 */
private static final Permission getKnownInstance(Class<?> claz,
    String name, String actions) {
    if (claz.equals(FilePermission.class)) {
        return new FilePermission(name, actions);
    } else if (claz.equals(SocketPermission.class)) {
        return new SocketPermission(name, actions);
    } else if (claz.equals(RuntimePermission.class)) {
        return new RuntimePermission(name, actions);
    } else if (claz.equals(PropertyPermission.class)) {
        return new PropertyPermission(name, actions);
    } else if (claz.equals(NetPermission.class)) {
        return new NetPermission(name, actions);
    } else if (claz.equals(AllPermission.class)) {
        return SecurityConstants.ALL_PERMISSION;
    } else {
        return null;
    }
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * Return true (merge policy permissions) in the following cases:
 *
 * . SecurityManager is null
 *
 * . SecurityManager is not null,
 *          debug is not null,
 *          SecurityManager impelmentation is in bootclasspath,
 *          Policy implementation is in bootclasspath
 *          (the bootclasspath restrictions avoid recursion)
 *
 * . SecurityManager is not null,
 *          debug is null,
 *          caller has Policy.getPolicy permission
 */
private static boolean seeAllp() {
    SecurityManager sm = System.getSecurityManager();

    if (sm == null) {
        return true;
    } else {
        if (debug != null) {
            if (sm.getClass().getClassLoader() == null &&
                Policy.getPolicyNoCheck().getClass().getClassLoader()
                                                            == null) {
                return true;
            }
        } else {
            try {
                sm.checkPermission(SecurityConstants.GET_POLICY_PERMISSION);
                return true;
            } catch (SecurityException se) {
                // fall thru and return false
            }
        }
    }

    return false;
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
private void setWarningString() {
    warningString = null;
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        try {
            sm.checkPermission(SecurityConstants.AWT.TOPLEVEL_WINDOW_PERMISSION);
        } catch (SecurityException se) {
            // make sure the privileged action is only
            // for getting the property! We don't want the
            // above checkPermission call to always succeed!
            warningString = AccessController.doPrivileged(
                  new GetPropertyAction("awt.appletWarning",
                                        "Java Applet Window"));
        }
    }
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        // Calls to getContextClassLoader from this class
        // never trigger a security check, but we check
        // whether our callers have this permission anyways.
        sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);

        // Whether setContextClassLoader turns out to be necessary
        // or not, we fail fast if permission is not available.
        sm.checkPermission(new RuntimePermission("setContextClassLoader"));
    }
    this.task = task;
    this.acc = AccessController.getContext();
    this.ccl = Thread.currentThread().getContextClassLoader();
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
private void checkMemberAccess(int which, Class<?> caller, boolean checkProxyInterfaces) {
    final SecurityManager s = System.getSecurityManager();
    if (s != null) {
        /* Default policy allows access to all {@link Member#PUBLIC} members,
         * as well as access to classes that have the same class loader as the caller.
         * In all other cases, it requires RuntimePermission("accessDeclaredMembers")
         * permission.
         */
        final ClassLoader ccl = ClassLoader.getClassLoader(caller);
        final ClassLoader cl = getClassLoader0();
        if (which != Member.PUBLIC) {
            if (ccl != cl) {
                s.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
            }
        }
        this.checkPackageAccess(ccl, checkProxyInterfaces);
    }
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * checks the security permissions for accessing system clipboard
 *
 * for untrusted context (see isTrustedContext) checks the
 * permissions for the current event being handled
 *
 */
public static boolean canAccessSystemClipboard() {
    boolean canAccess = false;
    if (!GraphicsEnvironment.isHeadless()) {
        SecurityManager sm = System.getSecurityManager();
        if (sm == null) {
            canAccess = true;
        } else {
            try {
                sm.checkPermission(SecurityConstants.AWT.ACCESS_CLIPBOARD_PERMISSION);
                canAccess = true;
            } catch (SecurityException e) {
            }
            if (canAccess && ! isTrustedContext()) {
                canAccess = canCurrentEventAccessSystemClipboard(true);
            }
        }
    }
    return canAccess;
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * package private to allow calls from ProtectionDomain without performing
 * the security check for {@linkplain SecurityConstants#CREATE_ACC_PERMISSION}
 * permission
 */
AccessControlContext(AccessControlContext acc,
                    DomainCombiner combiner,
                    boolean preauthorized) {
    if (!preauthorized) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(SecurityConstants.CREATE_ACC_PERMISSION);
            this.isAuthorized = true;
        }
    } else {
        this.isAuthorized = true;
    }

    this.context = acc.context;

    // we do not need to run the combine method on the
    // provided ACC.  it was already "combined" when the
    // context was originally retrieved.
    //
    // at this point in time, we simply throw away the old
    // combiner and use the newly provided one.
    this.combiner = combiner;
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * Perform necessary <a href="MethodHandles.Lookup.html#secmgr">access checks</a>.
 * Determines a trustable caller class to compare with refc, the symbolic reference class.
 * If this lookup object has private access, then the caller class is the lookupClass.
 */
void checkSecurityManager(Class<?> refc, MemberName m) {
    SecurityManager smgr = System.getSecurityManager();
    if (smgr == null)  return;
    if (allowedModes == TRUSTED)  return;

    // Step 1:
    boolean fullPowerLookup = hasPrivateAccess();
    if (!fullPowerLookup ||
        !VerifyAccess.classLoaderIsAncestor(lookupClass, refc)) {
        ReflectUtil.checkPackageAccess(refc);
    }

    // Step 2:
    if (m.isPublic()) return;
    if (!fullPowerLookup) {
        smgr.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
    }

    // Step 3:
    Class<?> defc = m.getDeclaringClass();
    if (!fullPowerLookup && defc != refc) {
        ReflectUtil.checkPackageAccess(defc);
    }
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
private static void checkProxyAccess(Class<?> caller,
                                     ClassLoader loader,
                                     Class<?>... interfaces)
{
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        ClassLoader ccl = caller.getClassLoader();
        if (VM.isSystemDomainLoader(loader) && !VM.isSystemDomainLoader(ccl)) {
            sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
        }
        ReflectUtil.checkProxyPackageAccess(ccl, interfaces);
    }
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * Tests if a client can get access to the AWT event queue.
 * <p>
 * This method calls <code>checkPermission</code> with the
 * <code>AWTPermission("accessEventQueue")</code> permission.
 *
 * @since   JDK1.1
 * @exception  SecurityException  if the caller does not have
 *             permission to access the AWT event queue.
 */
public void checkAwtEventQueueAccess() {
    AppContext appContext = AppContext.getAppContext();
    AppletClassLoader appletClassLoader = currentAppletClassLoader();

    if (AppContext.isMainContext(appContext) && (appletClassLoader != null)) {
        // If we're about to allow access to the main EventQueue,
        // and anything untrusted is on the class context stack,
        // disallow access.
        super.checkPermission(SecurityConstants.AWT.CHECK_AWT_EVENTQUEUE_PERMISSION);
    }
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * Does a conservative approximation of member access check. Use this if
 * you don't have an actual 'userland' caller Class/ClassLoader available.
 * This might be more restrictive than a precise member access check where
 * you have a caller, but should never allow a member access that is
 * forbidden.
 *
 * @param m the {@code Member} about to be accessed
 */
public static void conservativeCheckMemberAccess(Member m) throws SecurityException{
    final SecurityManager sm = System.getSecurityManager();
    if (sm == null)
        return;

    // Check for package access on the declaring class.
    //
    // In addition, unless the member and the declaring class are both
    // public check for access declared member permissions.
    //
    // This is done regardless of ClassLoader relations between the {@code
    // Member m} and any potential caller.

    final Class<?> declaringClass = m.getDeclaringClass();

    checkPackageAccess(declaringClass);

    if (Modifier.isPublic(m.getModifiers()) &&
            Modifier.isPublic(declaringClass.getModifiers()))
        return;

    // Check for declared member access.
    sm.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * Applets are not allowed to manipulate thread groups outside
 * applet thread groups.
 */
public synchronized void checkAccess(ThreadGroup g) {
    if (inThreadGroupCheck) {
        // if we are in a recursive check, it is because
        // inThreadGroup is calling appletLoader.getThreadGroup
        // in that case, only do the super check, as appletLoader
        // has a begin/endPrivileged
        checkPermission(SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
    } else {
        try {
            inThreadGroupCheck = true;
            if (!inThreadGroup(g)) {
                checkPermission(SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
            }
        } finally {
            inThreadGroupCheck = false;
        }
    }
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
@Override
public Path readSymbolicLink(Path obj1) throws IOException {
    UnixPath link = UnixPath.toUnixPath(obj1);
    // permission check
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        FilePermission perm = new FilePermission(link.getPathForPermissionCheck(),
            SecurityConstants.FILE_READLINK_ACTION);
        sm.checkPermission(perm);
    }
    try {
        byte[] target = readlink(link);
        return new UnixPath(link.getFileSystem(), target);
    } catch (UnixException x) {
       if (x.errno() == UnixConstants.EINVAL)
            throw new NotLinkException(link.getPathForExceptionMessage());
        x.rethrowAsIOException(link);
        return null;    // keep compiler happy
    }
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
private boolean canAccessSystemClipboard() {
    boolean b = false;

    if (!GraphicsEnvironment.isHeadless()) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            try {
                sm.checkPermission(SecurityConstants.AWT.ACCESS_CLIPBOARD_PERMISSION);
                b = true;
            } catch (SecurityException se) {
                if (logger.isLoggable(PlatformLogger.Level.FINE)) {
                    logger.fine("InputEvent.canAccessSystemClipboard() got SecurityException ", se);
                }
            }
        } else {
            b = true;
        }
    }

    return b;
}
 

import sun.security.util.SecurityConstants; //导入依赖的package包/类
/**
 * package private to allow calls from ProtectionDomain without performing
 * the security check for {@linkplain SecurityConstants.CREATE_ACC_PERMISSION}
 * permission
 */
AccessControlContext(AccessControlContext acc,
                    DomainCombiner combiner,
                    boolean preauthorized) {
    if (!preauthorized) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(SecurityConstants.CREATE_ACC_PERMISSION);
            this.isAuthorized = true;
        }
    } else {
        this.isAuthorized = true;
    }

    this.context = acc.context;

    // we do not need to run the combine method on the
    // provided ACC.  it was already "combined" when the
    // context was originally retrieved.
    //
    // at this point in time, we simply throw away the old
    // combiner and use the newly provided one.
    this.combiner = combiner;
}