| java.lang.Object
 com.ecyrd.jspwiki.auth.AuthorizationManager
| AuthorizationManager | | final public class AuthorizationManager (Code) | | Manages all access control and authorization; determines what authenticated
users are allowed to do.
Privileges in JSPWiki are expressed as Java-standard
java.security.Permission classes. There are two types of permissions:
Calling classes determine whether they are entitled to perform a particular action
by constructing the appropriate permission first, then passing it and the current
com.ecyrd.jspwiki.WikiSession to the
AuthorizationManager.checkPermission(WikiSession,Permission) method. If the session's
Subject possesses the permission, the action is allowed.
For WikiPermissions, the decision criteria is relatively simple: the caller either
possesses the permission, as granted by the wiki security policy -- or not.
For PagePermissions, the logic is exactly the same if the page being checked
does not have an access control list. However, if the page does have an ACL, the
authorization decision is made based the union of the permissions
granted in the ACL and in the security policy. In other words, the user must
be named in the ACL (or belong to a group or role that is named in the ACL)
and be granted (at least) the same permission in the security policy. We
do this to prevent a user from gaining more permissions than they already
have, based on the security policy.
See the
AuthorizationManager.checkPermission(WikiSession,Permission) and
AuthorizationManager.hasRoleOrPrincipal(WikiSession,Principal) methods for more information
on the authorization logic.
author:
Andrew Jaquith
since:
2.3
See Also: AuthenticationManager |
| Method Summary | |
| final public synchronized void | addWikiEventListener(WikiEventListener listener)
Registers a WikiEventListener with this instance. | | protected boolean | allowedByLocalPolicy(Principal[] principals, Permission permission)
Checks to see if the local security policy allows a particular static Permission. | | final public boolean | checkPermission(WikiSession session, Permission permission)
Returns true or false, depending on
whether a Permission is allowed for the Subject associated with
a supplied WikiSession. | | final protected boolean | checkStaticPermission(WikiSession session, Permission permission)
Determines whether a Subject posesses a given "static" Permission as
defined in the security policy file. | | final protected void | fireEvent(int type, Principal user, Object permission)
Fires a WikiSecurityEvent of the provided type, user,
and permission to all registered listeners. | | final public Authorizer | getAuthorizer()
Returns the current external
Authorizer in use. | | protected boolean | hasRoleOrPrincipal(WikiSession session, Principal principal)
Determines if the Subject associated with a supplied WikiSession contains
a desired user Principal or built-in Role principal, OR is a member a
Group or external Role. | | final public void | initialize(WikiEngine engine, Properties properties)
Initializes AuthorizationManager with an engine and set of properties. | | protected boolean | isJAASAuthorized()
Returns true if JSPWiki's JAAS authorization system
is used for authorization in addition to container controls. | | final public boolean | isUserInRole(WikiSession session, Principal principal)
Determines if the Subject associated with a
supplied WikiSession contains a desired Role or GroupPrincipal.
The algorithm simply checks to see if the Subject possesses
the Role or GroupPrincipal it in its Principal set. | | final public synchronized void | removeWikiEventListener(WikiEventListener listener)
Un-registers a WikiEventListener with this instance. | | final public Principal | resolvePrincipal(String name)
Given a supplied string representing a Principal's name from an Acl, this
method resolves the correct type of Principal (role, group, or user).
This method is guaranteed to always return a Principal.
The algorithm is straightforward:
- If the name matches one of the built-in
com.ecyrd.jspwiki.auth.authorize.Role names,
return that built-in Role
- If the name matches one supplied by the current
com.ecyrd.jspwiki.auth.Authorizer , return that Role
- If the name matches a group managed by the
current
com.ecyrd.jspwiki.auth.authorize.GroupManager , return that Group
- Otherwise, assume that the name represents a user
principal.
|
| DEFAULT_POLICY | | final protected static String DEFAULT_POLICY(Code) | | Name of the default security policy file, in WEB-INF.
|
| PROP_AUTHORIZER | | final public static String PROP_AUTHORIZER(Code) | | The property name in jspwiki.properties for specifying the external
Authorizer .
|
| AuthorizationManager | | public AuthorizationManager()(Code) | | Constructs a new AuthorizationManager instance.
|
| addWikiEventListener | | final public synchronized void addWikiEventListener(WikiEventListener listener)(Code) | | Registers a WikiEventListener with this instance.
Parameters:
listener - the event listener |
| checkPermission | | final public boolean checkPermission(WikiSession session, Permission permission)(Code) | | Returns true or false, depending on
whether a Permission is allowed for the Subject associated with
a supplied WikiSession. The access control algorithm works this way:
- The
com.ecyrd.jspwiki.auth.acl.Acl for the page is obtained
- The Subject associated with the current
com.ecyrd.jspwiki.WikiSession is obtained
- If the Subject's Principal set includes the Role Principal that is
the administrator group, always allow the Permission
- For all permissions, check to see if the Permission is allowed according
to the default security policy. If it isn't, deny the permission and halt
further processing.
- If there is an Acl, get the list of Principals assigned this
Permission in the Acl: these will be role, group or user Principals, or
com.ecyrd.jspwiki.auth.acl.UnresolvedPrincipal s (see below).
Then iterate through the Subject's Principal set and determine whether
the user (Subject) posesses any one of these specified Roles or
Principals. The matching process delegates to
AuthorizationManager.hasRoleOrPrincipal(WikiSession,Principal) .
Note that when iterating through the Acl's list of authorized Principals,
it is possible that one or more of the Acl's Principal entries are of
type UnresolvedPrincipal. This means that the last time
the ACL was read, the Principal (user, built-in Role, authorizer Role, or
wiki Group) could not be resolved: the Role was not valid, the user
wasn't found in the UserDatabase, or the Group wasn't known to (e.g.,
cached) in the GroupManager. If an UnresolvedPrincipal is
encountered, this method will attempt to resolve it first before
checking to see if the Subject possesses this principal, by calling
AuthorizationManager.resolvePrincipal(String) . If the (re-)resolution does not
succeed, the access check for the principal will fail by definition (the
Subject should never contain UnresolvedPrincipals).
If security not set to JAAS, will return true.
Parameters:
session - the current wiki session
Parameters:
permission - the Permission being checked
See Also: AuthorizationManager.hasRoleOrPrincipal(WikiSession,Principal) the result of the Permission check |
| checkStaticPermission | | final protected boolean checkStaticPermission(WikiSession session, Permission permission)(Code) | | Determines whether a Subject posesses a given "static" Permission as
defined in the security policy file. This method uses standard Java 2
security calls to do its work. Note that the current access control
context's codeBase is effectively this class,
not that of the caller. Therefore, this method will work best when what
matters in the policy is who makes the permission check, not
what the caller's code source is. Internally, this method works by
excuting Subject.doAsPrivileged with a privileged action
that simply calls
java.security.AccessController.checkPermission(Permission) .
AccessController#checkPermission(java.security.Permission). Acaught exception (or lack thereof) determines whether the privilegeis absent (or present).
Parameters:
session - the WikiSession whose permission status is being queried
Parameters:
permission - the Permission the Subject must possess true if the Subject posesses the permission,false otherwise |
| fireEvent | | final protected void fireEvent(int type, Principal user, Object permission)(Code) | | Fires a WikiSecurityEvent of the provided type, user,
and permission to all registered listeners.
See Also: com.ecyrd.jspwiki.event.WikiSecurityEvent
Parameters:
type - the event type to be fired
Parameters:
user - the user associated with the event
Parameters:
permission - the permission the subject must possess |
| hasRoleOrPrincipal | | protected boolean hasRoleOrPrincipal(WikiSession session, Principal principal)(Code) | | Determines if the Subject associated with a supplied WikiSession contains
a desired user Principal or built-in Role principal, OR is a member a
Group or external Role. The rules are as follows:
- First, if desired Principal is a Role or GroupPrincipal, delegate to
AuthorizationManager.isUserInRole(WikiSession,Principal) and
return the result.
- Otherwise, we're looking for a user Principal,
so iterate through the Principal set and see if
any share the same name as the one we are looking for.
Note: if the Principal parameter is a user principal, the session
must be authenticated in order for the user to "possess it". Anonymous
or asserted sessions will never posseess a named user principal.
Parameters:
session - the current wiki session, which must be non-null. If null,the result of this method always returns false
Parameters:
principal - the Principal (role, group, or user principal) to lookfor, which must be non-null. If null, the result of thismethod always returns false true if the Subject supplied with the WikiContextposesses the Role, GroupPrincipal or desireduser Principal, false otherwise |
| initialize | | final public void initialize(WikiEngine engine, Properties properties) throws WikiException(Code) | | Initializes AuthorizationManager with an engine and set of properties.
Expects to find property 'jspwiki.authorizer' with a valid Authorizer
implementation name to take care of group lookup operations.
Parameters:
engine - the wiki engine
Parameters:
properties - the set of properties used to initialize the wiki engine
throws:
WikiException - if the AuthorizationManager cannot be initialized |
| isJAASAuthorized | | protected boolean isJAASAuthorized()(Code) | | Returns true if JSPWiki's JAAS authorization system
is used for authorization in addition to container controls.
the result |
| isUserInRole | | final public boolean isUserInRole(WikiSession session, Principal principal)(Code) | | Determines if the Subject associated with a
supplied WikiSession contains a desired Role or GroupPrincipal.
The algorithm simply checks to see if the Subject possesses
the Role or GroupPrincipal it in its Principal set. Note that
any user (anyonymous, asserted, authenticated) can possess
a built-in role. But a user must be authenticated to
possess a role other than one of the built-in ones.
We do this to prevent privilege escalation.
For all other cases, this method returns false.
Note that this method does not consult the external
Authorizer or GroupManager; it relies on the Principals that
have been injected into the user's Subject at login time, or
after group creation/modification/deletion.
Parameters:
session - the current wiki session, which must be non-null. If null,the result of this method always returns false
Parameters:
principal - the Principal (role or group principal) to lookfor, which must be non-null. If null,the result of this method always returns false true if the Subject supplied with the WikiContextposesses the Role or GroupPrincipal, false otherwise |
| removeWikiEventListener | | final public synchronized void removeWikiEventListener(WikiEventListener listener)(Code) | | Un-registers a WikiEventListener with this instance.
Parameters:
listener - the event listener |
| resolvePrincipal | | final public Principal resolvePrincipal(String name)(Code) | | Given a supplied string representing a Principal's name from an Acl, this
method resolves the correct type of Principal (role, group, or user).
This method is guaranteed to always return a Principal.
The algorithm is straightforward:
- If the name matches one of the built-in
com.ecyrd.jspwiki.auth.authorize.Role names,
return that built-in Role
- If the name matches one supplied by the current
com.ecyrd.jspwiki.auth.Authorizer , return that Role
- If the name matches a group managed by the
current
com.ecyrd.jspwiki.auth.authorize.GroupManager , return that Group
- Otherwise, assume that the name represents a user
principal. Using the current
com.ecyrd.jspwiki.auth.user.UserDatabase , find the
first user who matches the supplied name by calling
com.ecyrd.jspwiki.auth.user.UserDatabase.find(String) .
- Finally, if a user cannot be found, manufacture
and return a generic
com.ecyrd.jspwiki.auth.acl.UnresolvedPrincipal
Parameters:
name - the name of the Principal to resolve the fully-resolved Principal |
|
|