How to use

getSecurityManager

method

in

java.lang.System

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);
 }
}