Java RoleGroup类代码示例

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
@Test
public void testAuthenticationAndMappingAnnotation() throws Exception
{
   AuthPlusMappingAnnotatedPOJO pojo = new AuthPlusMappingAnnotatedPOJO();
   
   PicketBoxProcessor processor = new PicketBoxProcessor(); 
   processor.setSecurityInfo("anil", "pass");
   processor.process(pojo);
   
   Principal anil = new SimplePrincipal("anil");
   assertEquals("Principal == anil", anil, processor.getCallerPrincipal());
   Subject callerSubject = processor.getCallerSubject();
   assertNotNull("Subject is not null", callerSubject);
   assertTrue("Subject contains principal anil", callerSubject.getPrincipals().contains(anil));
   RoleGroup callerRoles = processor.getCallerRoles();
   assertTrue("InternalUser is a role", callerRoles.containsRole(new SimpleRole("InternalUser")));
   assertTrue("AuthorizedUser is a role", callerRoles.containsRole(new SimpleRole("AuthorizedUser")));
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
private void addRole(String roleName, RoleGroup roleGroup)
{
   if (roleName != null)
   {
      try
      {
         SimpleRole role = new SimpleRole(roleName);
         PicketBoxLogger.LOGGER.traceAssignUserToRole(roleName);
         roleGroup.addRole(role);
      }
      catch (Exception e)
      {
         PicketBoxLogger.LOGGER.debugFailureToCreatePrincipal(roleName, e);
      }
   }
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
/** 
 * Create the set of roles the user belongs to by parsing the roles.properties
 * data for username=role1,role2,...
 * 
 * @param username - name of user
 * @param roleGroup - group containing the user's roles
 * @param roles - the Properties containing the user=roles mappings
 * @return Group[] containing the sets of roles
 */
static void addRolesToGroup(String username, RoleGroup roleGroup, Properties roles)
{
   String[] roleNames = null;
   if (roles.containsKey(username))
   {
      String value = roles.getProperty(username);
      PicketBoxLogger.LOGGER.traceAdditionOfRoleToGroup(value, roleGroup.getRoleName());
      roleNames = parseRoles(value);
   }
   if (roleNames != null)
   {
      for (int i = 0; i < roleNames.length; i++)
      {
         roleGroup.addRole(new SimpleRole(roleNames[i]));
      }
   }
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
@Test
public void testAPI() throws Exception
{
   SecurityMappingAnnotationRolePOJO pojo = new SecurityMappingAnnotationRolePOJO();
   
   PicketBoxProcessor processor = new PicketBoxProcessor(); 
   processor.setSecurityInfo("anil", "pass");
   processor.process(pojo);
   
   Principal anil = new SimplePrincipal("anil");
   assertEquals("Principal == anil", anil, processor.getCallerPrincipal());
   Subject callerSubject = processor.getCallerSubject();
   assertNotNull("Subject is not null", callerSubject);
   assertTrue("Subject contains principal anil", callerSubject.getPrincipals().contains(anil));
   RoleGroup callerRoles = processor.getCallerRoles();
   assertTrue("InternalUser is a role", callerRoles.containsRole(new SimpleRole("InternalUser")));
   assertTrue("AuthorizedUser is a role", callerRoles.containsRole(new SimpleRole("AuthorizedUser")));
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
public void performMapping(Map<String, Object> contextMap, RoleGroup mappedObject)
{
   if (contextMap == null || contextMap.isEmpty())
      throw PicketBoxMessages.MESSAGES.invalidNullArgument("contextMap");

   //Obtain the principal to roles mapping
   Principal principal = getCallerPrincipal(contextMap);

   if (principal != null && rolesQuery != null)
   {
      String username = principal.getName();
      Util.addRolesToGroup(username, mappedObject, dsJndiName, rolesQuery, suspendResume, tm);
      result.setMappedObject(mappedObject);
   }

}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
private RoleGroup mapGroup(Principal principal, Map<String, Set<String>> principalRolesMap,
      RoleGroup mappedObject)
{
   Set<String> roleset = (Set<String>)principalRolesMap.get(principal.getName());
   if(roleset != null)
   {
      RoleGroup newRoles = new SimpleRoleGroup(SecurityConstants.ROLES_IDENTIFIER);
      
      if(roleset != null)
      {
         for(String r:roleset)
         {
            newRoles.addRole(new SimpleRole(r));            
         }
      }
      
      mappedObject.clearRoles();
      mappedObject.addAll(newRoles.getRoles()); 
   } 
   return mappedObject;
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
private Set<Principal> getPrincipalSetFromRole(Role role)
{
   Set<Principal> principalsSet = new HashSet<Principal>();
   if(role instanceof RoleGroup)
   {
      RoleGroup rg = (RoleGroup) role;
      Collection<Role> rolesList = rg.getRoles();
      for(Role r: rolesList)
      {
        principalsSet.add(new SimplePrincipal(r.getRoleName()));      
      }
   }
   else
      principalsSet.add(new SimplePrincipal(role.getRoleName()));
   return principalsSet;
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
/**
 * @see AuthorizationModule#initialize(javax.security.auth.Subject, javax.security.auth.callback.CallbackHandler, java.util.Map, java.util.Map, org.jboss.security.identity.RoleGroup)
 */
public void initialize(Subject subject, CallbackHandler handler, Map<String,Object> sharedState,
      Map<String,Object> options, RoleGroup subjectRole)
{
   this.subject = subject;
   this.handler = handler;
   this.sharedState = sharedState;
   this.options = options;
   //Check if there is a delegate map via options
   if(options != null)
   {
      String commaSeparatedDelegates = (String)options.get("delegateMap");
      if(commaSeparatedDelegates != null && commaSeparatedDelegates.length() > 0)
         populateDelegateMap(commaSeparatedDelegates);
   } 
   this.role = subjectRole;
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
/**
 * Process the ejb request
 * @param callerRoles
 * @return
 */ 
private int process(RoleGroup callerRoles) 
{ 
   int result = AuthorizationContext.DENY;
   EJBXACMLUtil util = new EJBXACMLUtil();
   try
   {
      RequestContext requestCtx = util.createXACMLRequest(this.ejbName,
            this.ejbMethod, this.ejbPrincipal, callerRoles);
      
      PolicyDecisionPoint pdp = util.getPDP(policyRegistration, this.policyContextID); 
      if(pdp == null)
         throw PicketBoxMessages.MESSAGES.invalidNullProperty("PDP");

      ResponseContext response = pdp.evaluate(requestCtx);
      result = response.getDecision() == XACMLConstants.DECISION_PERMIT ? 
            AuthorizationContext.PERMIT : AuthorizationContext.DENY;
   }
   catch(Exception e)
   {
      PicketBoxLogger.LOGGER.debugIgnoredException(e);
      result = AuthorizationContext.DENY;
   }  
   return result;
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
/**
  * 
  * @param ejbName
  * @param methodName
  * @param principal
  * @param callerRoles
  * @return
  * @throws Exception
  */
 public RequestContext createXACMLRequest(String ejbName, String methodName,
       Principal principal, RoleGroup callerRoles) throws Exception
 {  
    String action = methodName;
    //Create an action type
    ActionType actionType = getActionType( action );

    RequestContext requestCtx = this.getRequestContext(ejbName, actionType, principal, callerRoles);

    if(PicketBoxLogger.LOGGER.isDebugEnabled())
    {
       ByteArrayOutputStream baos = new ByteArrayOutputStream();

       requestCtx.marshall(baos);
       PicketBoxLogger.LOGGER.debug(new String(baos.toByteArray()));
    }
    return requestCtx;
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
private RequestContext getRequestContext( String ejbName, ActionType actionType,
      Principal principal, RoleGroup callerRoles ) throws IOException
{
   if(principal == null)
      throw PicketBoxMessages.MESSAGES.invalidNullArgument("principal");

   RequestContext requestCtx = RequestResponseContextFactory.createRequestCtx();

   //Create a subject type
   SubjectType subject = this.getSubjectType( principal, callerRoles ); 

   //Create a resource type
   ResourceType resourceType = getResourceType( ejbName ); 

   //Create an Environment Type (Optional)
   EnvironmentType environmentType = getEnvironmentType();

   //Create a Request Type
   RequestType requestType = getRequestType( subject, resourceType, actionType, environmentType );

   requestCtx.setRequest( requestType );
   
   return requestCtx; 
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
private SubjectType getSubjectType( Principal principal, RoleGroup callerRoles )
{
   String subjectID_NS =  XACMLConstants.ATTRIBUTEID_SUBJECT_ID;
   String roleID_NS = XACMLConstants.ATTRIBUTEID_ROLE;
   String principalName = principal.getName();
   
   //Create a subject type
   SubjectType subject = new SubjectType();
   AttributeType attribute = RequestAttributeFactory.createStringAttributeType( subjectID_NS, "jboss.org", principalName );

   subject.getAttribute().add( attribute );

   Collection<Role> rolesList = callerRoles.getRoles();
   if(rolesList != null)
   {
      for(Role role:rolesList)
      {
         String roleName = role.getRoleName(); 
         AttributeType attSubjectID = RequestAttributeFactory.createStringAttributeType( roleID_NS , "jboss.org", roleName );
         subject.getAttribute().add(attSubjectID);
      }
   }  
   return subject;
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
/** Does the current Subject have a role(a Principal) that equates to one
 of the role names. This method obtains the Group named 'Roles' from
 the principal set of the currently authenticated Subject as determined
 by the SecurityAssociation.getSubject() method and then creates a
 SimplePrincipal for each name in roleNames. If the role is a member of the
 Roles group, then the user has the role. This requires that the caller
 establish the correct SecurityAssociation subject prior to calling this
 method. In the past this was done as a side-effect of an isValid() call,
 but this is no longer the case.
 
 @param principal - ignored. The current authenticated Subject determines
 the active user and assigned user roles.
 @param rolePrincipals - a Set of Principals for the roles to check.
 
 @see java.security.acl.Group;
 @see Subject#getPrincipals()
 */
public boolean doesUserHaveRole(Principal principal, Set<Principal> rolePrincipals)
{
   boolean hasRole = false;
   RoleGroup roles = this.getCurrentRoles(principal);
   if (PicketBoxLogger.LOGGER.isTraceEnabled())
   {
      PicketBoxLogger.LOGGER.traceBeginDoesUserHaveRole(principal, roles != null ? roles.toString() : "");
   }
   if(roles != null)
   {
      Iterator<Principal> iter = rolePrincipals.iterator();
      while( hasRole == false && iter.hasNext() )
      {
         Principal role = iter.next();
         hasRole = doesRoleGroupHaveRole(role, roles);
      }
      PicketBoxLogger.LOGGER.traceEndDoesUserHaveRole(hasRole);
   }
   return hasRole;
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
/** Check that the indicated application domain role is a member of the
 user's assigned roles. This handles the special AnybodyPrincipal and
 NobodyPrincipal independent of the Group implementation.
 
 @param role , the application domain role required for access
 @param userRoles , the set of roles assigned to the user
 @return true if role is in userRoles or an AnybodyPrincipal instance, false
 if role is a NobodyPrincipal or no a member of userRoles
 */
protected boolean doesRoleGroupHaveRole(Principal role, RoleGroup userRoles)
{
   // First check that role is not a NobodyPrincipal
   if (role instanceof NobodyPrincipal)
      return false;
   
   // Check for inclusion in the user's role set
   boolean isMember = userRoles.containsRole(new SimpleRole(role.getName())); 
   if (isMember == false)
   {   // Check the AnybodyPrincipal special cases
      isMember = (role instanceof AnybodyPrincipal);
   }
   
   return isMember;
}
 

import org.jboss.security.identity.RoleGroup; //导入依赖的package包/类
@Test
public void testAuthenticationAndAuthorization() throws Exception
{
   AuthAuthorizationAnnotatedPOJO pojo = new AuthAuthorizationAnnotatedPOJO();
   
   PicketBoxProcessor processor = new PicketBoxProcessor(); 
   processor.setSecurityInfo("anil", "pass");
   processor.process(pojo);
   
   Principal anil = new SimplePrincipal("anil");
   assertEquals("Principal == anil", anil, processor.getCallerPrincipal());
   Subject callerSubject = processor.getCallerSubject();
   assertNotNull("Subject is not null", callerSubject);
   assertTrue("Subject contains principal anil", callerSubject.getPrincipals().contains(anil));
   RoleGroup callerRoles = processor.getCallerRoles();
   assertNotNull("Roles are not null", callerRoles);
}