protected boolean isSecurityManagerPresent() { return (System.getSecurityManager() != null); }
public DefaultThreadFactory(String poolName, boolean daemon, int priority) { this(poolName, daemon, priority, System.getSecurityManager() == null ? Thread.currentThread().getThreadGroup() : System.getSecurityManager().getThreadGroup()); }
static ClassLoader getSystemClassLoader() { if (System.getSecurityManager() == null) { return ClassLoader.getSystemClassLoader(); } else { return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { @Override public ClassLoader run() { return ClassLoader.getSystemClassLoader(); } }); } }
static ClassLoader getClassLoader(final Class<?> clazz) { if (System.getSecurityManager() == null) { return clazz.getClassLoader(); } else { return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { @Override public ClassLoader run() { return clazz.getClassLoader(); } }); } }
public NamedThreadFactory(String prefix, boolean daemon) { mPrefix = prefix + "-thread-"; mDaemon = daemon; SecurityManager s = System.getSecurityManager(); mGroup = (s == null) ? Thread.currentThread().getThreadGroup() : s.getThreadGroup(); }
public NamedThreadFactory(String prefix, boolean daemon) { mPrefix = prefix + "-thread-"; mDaemon = daemon; SecurityManager s = System.getSecurityManager(); mGroup = (s == null) ? Thread.currentThread().getThreadGroup() : s.getThreadGroup(); }
static ClassLoader getContextClassLoader() { if (System.getSecurityManager() == null) { return Thread.currentThread().getContextClassLoader(); } else { return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { @Override public ClassLoader run() { return Thread.currentThread().getContextClassLoader(); } }); } }
/** * Checks whether the user has permission 'ConverterManager.alterPartialConverters'. * * @throws SecurityException if the user does not have the permission */ private void checkAlterPartialConverters() throws SecurityException { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(new JodaTimePermission("ConverterManager.alterPartialConverters")); } }
@Override public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner, final Constructor<?> ctor, Object... args) { if (!bd.hasMethodOverrides()) { if (System.getSecurityManager() != null) { // use own privileged to change accessibility (when security is on) AccessController.doPrivileged((PrivilegedAction<Object>) () -> { ReflectionUtils.makeAccessible(ctor); return null; }); } return BeanUtils.instantiateClass(ctor, args); } else { return instantiateWithMethodInjection(bd, beanName, owner, ctor, args); } }
@Override public void freeDirectBuffer(ByteBuffer buffer) { // Try to minimize overhead when there is no SecurityManager present. // See https://bugs.openjdk.java.net/browse/JDK-8191053. if (System.getSecurityManager() == null) { try { INVOKE_CLEANER.invoke(PlatformDependent0.UNSAFE, buffer); } catch (Throwable cause) { PlatformDependent0.throwException(cause); } } else { freeDirectBufferPrivileged(buffer); } }
@Nullable private Method determineDestroyMethod(String name) { try { if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedAction<Method>) () -> findDestroyMethod(name)); } else { return findDestroyMethod(name); } } catch (IllegalArgumentException ex) { throw new BeanDefinitionValidationException("Could not find unique destroy method on bean with name '" + this.beanName + ": " + ex.getMessage()); } }
/** * Retrieve all candidate methods for the given class, considering * the {@link RootBeanDefinition#isNonPublicAccessAllowed()} flag. * Called as the starting point for factory method determination. */ private Method[] getCandidateMethods(Class<?> factoryClass, RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedAction<Method[]>) () -> (mbd.isNonPublicAccessAllowed() ? ReflectionUtils.getAllDeclaredMethods(factoryClass) : factoryClass.getMethods())); } else { return (mbd.isNonPublicAccessAllowed() ? ReflectionUtils.getAllDeclaredMethods(factoryClass) : factoryClass.getMethods()); } }
public void testExistsThrowsSecurityException() throws IOException, URISyntaxException { SecurityManager oldSecurityManager = System.getSecurityManager(); try { doTestExistsThrowsSecurityException(); } finally { System.setSecurityManager(oldSecurityManager); } }
@Override public void freeDirectBuffer(ByteBuffer buffer) { if (!buffer.isDirect()) { return; } if (System.getSecurityManager() == null) { try { freeDirectBuffer0(buffer); } catch (Throwable cause) { PlatformDependent0.throwException(cause); } } else { freeDirectBufferPrivileged(buffer); } }
private Object instantiate( String beanName, RootBeanDefinition mbd, Constructor constructorToUse, Object[] argsToUse) { try { InstantiationStrategy strategy = this.beanFactory.getInstantiationStrategy(); if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedAction<Object>) () -> strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse), this.beanFactory.getAccessControlContext()); } else { return strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse); } } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean instantiation via constructor failed", ex); } }
private Object instantiate(String beanName, RootBeanDefinition mbd, @Nullable Object factoryBean, Method factoryMethod, Object[] args) { try { if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedAction<Object>) () -> this.beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args), this.beanFactory.getAccessControlContext()); } else { return this.beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args); } } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean instantiation via factory method failed", ex); } }
public CallbacksSecurityTests() { // setup security if (System.getSecurityManager() == null) { Policy policy = Policy.getPolicy(); URL policyURL = getClass() .getResource( "/org/springframework/beans/factory/support/security/policy.all"); System.setProperty("java.security.policy", policyURL.toString()); System.setProperty("policy.allowSystemProperty", "true"); policy.refresh(); System.setSecurityManager(new SecurityManager()); } }
@Before public void setUp() { originalSecurityManager = System.getSecurityManager(); env = StandardEnvironmentTests.getModifiableSystemEnvironment(); env.put(AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME, "p1"); }
/** * Tests that the use of a {@link FinalizableReferenceQueue} does not subsequently prevent the * loader of that class from being garbage-collected. */ public void testUnloadableWithoutSecurityManager() throws Exception { if (isJdk9OrHigher()) { return; } SecurityManager oldSecurityManager = System.getSecurityManager(); try { System.setSecurityManager(null); doTestUnloadable(); } finally { System.setSecurityManager(oldSecurityManager); } }
public void testUnloadableInStaticFieldIfClosed() throws Exception { if (isJdk9OrHigher()) { return; } Policy oldPolicy = Policy.getPolicy(); SecurityManager oldSecurityManager = System.getSecurityManager(); try { Policy.setPolicy(new PermissivePolicy()); System.setSecurityManager(new SecurityManager()); WeakReference<ClassLoader> loaderRef = doTestUnloadableInStaticFieldIfClosed(); GcFinalization.awaitClear(loaderRef); } finally { System.setSecurityManager(oldSecurityManager); Policy.setPolicy(oldPolicy); } }