Package java.lang

## Class SecurityManager

- java.lang.Object
- - java.lang.SecurityManager

-     public class SecurityManager
      extends Object

  The security manager is a class that allows applications to implement a security policy. It allows an application to determine, before performing a possibly unsafe or sensitive operation, what the operation is and whether it is being attempted in a security context that allows the operation to be performed. The application can allow or disallow the operation.

  The `SecurityManager` class contains many methods with names that begin with the word `check`. These methods are called by various methods in the Java libraries before those methods perform certain potentially sensitive operations. The invocation of such a `check` method typically looks like this:

  >          SecurityManager security = System.getSecurityManager();
  >          if (security != null) {
  >              security.checkXXX(argument,  . . . );
  >          }

  The security manager is thereby given an opportunity to prevent completion of the operation by throwing an exception. A security manager routine simply returns if the operation is permitted, but throws a `SecurityException` if the operation is not permitted. The only exception to this convention is `checkTopLevelWindow`, which returns a `boolean` value.

  The current security manager is set by the `setSecurityManager` method in class `System`. The current security manager is obtained by the `getSecurityManager` method.

  The special method `checkPermission(java.security.Permission)` determines whether an access request indicated by a specified permission should be granted or denied.

  If a requested access is allowed, `checkPermission` returns quietly. If denied, a `SecurityException` is thrown.

  As of Java 2 SDK v1.2, the default implementation of each of the other `check` methods in `SecurityManager` is to call the `SecurityManager checkPermission` method to determine if the calling thread has permission to perform the requested operation.

  Note that the `checkPermission` method with just a single permission argument always performs security checks within the context of the currently executing thread.

  Permissions fall into these categories: Runtime and Property. The classes managing these various permission categories are `java.lang.RuntimePermission`, `java.util.PropertyPermission`,

  Some of the permission classes have an "actions" list that tells the actions that are permitted for the object.

  Other permission classes are for "named" permissions - ones that contain a name but no actions list; you either have the named permission or you don't.

  See Also:
    `SecurityException`, `getSecurityManager`, `setSecurityManager`, `Permission`, `BasicPermission`

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `SecurityManager()` | Constructs a new `SecurityManager`.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `checkAccess​(Thread t)` | Throws a `SecurityException` if the calling thread is not allowed to modify the thread argument.
    `void` | `checkPermission​(Permission perm)` | Throws a `SecurityException` if the requested access, specified by the given permission, is not permitted based on the security policy currently in effect.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### SecurityManager

          public SecurityManager()

      Constructs a new `SecurityManager`.

      If there is a security manager already installed, this method first calls the security manager's `checkPermission` method with the `RuntimePermission("createSecurityManager")` permission to ensure the calling thread has permission to create a new security manager. This may result in throwing a `SecurityException`.

      Throws:
        `SecurityException` - if a security manager already exists and its `checkPermission` method doesn't allow creation of a new security manager.
      See Also:
        `System.getSecurityManager()`, `checkPermission`, `RuntimePermission`

  - ### Method Detail

    - #### checkAccess

          public void checkAccess​(Thread t)

      Throws a `SecurityException` if the calling thread is not allowed to modify the thread argument.

      This method is invoked for the current security manager by the `setPriority` and `setName` methods of class `Thread`.

      If the thread argument is a system thread then this method calls `checkPermission` with the `RuntimePermission("modifyThread")` permission. If the thread argument is not a system thread, this method just returns silently.

      Applications that want a stricter policy should override this method. If this method is overridden, the method that overrides it should additionally check to see if the calling thread has the `RuntimePermission("modifyThread")` permission, and if so, return silently. This is to ensure that code granted that permission is allowed to manipulate any thread.

      If this method is overridden, then `super.checkAccess` should be called by the first statement in the overridden method, or the equivalent security check should be placed in the overridden method.

      Parameters:
        `t` - the thread to be checked.
      Throws:
        `SecurityException` - if the calling thread does not have permission to modify the thread.
        `NullPointerException` - if the thread argument is `null`.
      See Also:
        `setName`, `setPriority`, `checkPermission`

    - #### checkPermission

          public void checkPermission​(Permission perm)

      Throws a `SecurityException` if the requested access, specified by the given permission, is not permitted based on the security policy currently in effect.

      Parameters:
        `perm` - the requested permission.
      Throws:
        `SecurityException` - if access is not permitted based on the current security policy.
        `NullPointerException` - if the permission argument is `null`.