org.jboss.security.SecurityContext Java Examples

static Principal getPrincipal()
{
   return AccessController.doPrivileged(new PrivilegedAction<Principal>()
   {
      public Principal run()
      {
         Principal principal = null;
         SecurityContext sc = getSecurityContext();
         if(sc != null)
         {
            principal = sc.getUtil().getUserPrincipal();
         }
         return principal;
      }
   });
}
 

/**
 * Get the caller subject
 * @return 
 * @throws PicketBoxProcessingException 
 */
public Subject getCallerSubject() throws PicketBoxProcessingException
{
   Subject subject = new Subject();
   SecurityContext securityContext = null;
   try
   {
      securityContext = SecurityActions.getSecurityContext();
   }
   catch (PrivilegedActionException pae)
   {
      throw new PicketBoxProcessingException(pae.getCause());
   }
   if(securityContext != null)
      subject = securityContext.getUtil().getSubject();
   return subject;
}
 

/**
 * Get the caller roles
 * @return 
 * @throws PicketBoxProcessingException 
 */
public RoleGroup getCallerRoles() throws PicketBoxProcessingException
{
   RoleGroup roleGroup = null;
   
   SecurityContext securityContext = null;
   try
   {
      securityContext = SecurityActions.getSecurityContext();
   }
   catch (PrivilegedActionException pae)
   {
      throw new PicketBoxProcessingException(pae.getCause());
   }
   if(securityContext != null)
      roleGroup = securityContext.getUtil().getRoles(); 
   return roleGroup;
}
 

/**
 * Get the authenticated principal
 * @return 
 * @throws PicketBoxProcessingException 
 */
public Principal getCallerPrincipal() throws PicketBoxProcessingException
{
   Principal principal = null;
   
   SecurityContext securityContext = null;
   try
   {
      securityContext = SecurityActions.getSecurityContext();
   }
   catch (PrivilegedActionException pae)
   {
      throw new PicketBoxProcessingException(pae.getCause());
   }
   if(securityContext != null)
      principal = securityContext.getUtil().getUserPrincipal(); 
   return principal;
}
 

/** Get the currently authenticated Subject. This is a thread local
 property shared across all JaasSecurityManager instances.
 @return The Subject authenticated in the current thread if one
 exists, null otherwise.
 */
public Subject getActiveSubject()
{
   /* This does not use SubjectActions.getActiveSubject since the caller
      must have the correct permissions to access the
      SecurityAssociation.getSubject method.
   */
   //return SecurityAssociation.getSubject();
   Subject subj = null;
   SecurityContext sc = SecurityContextAssociation.getSecurityContext();
   if(sc != null)
   {
      subj = sc.getUtil().getSubject();
   }
   return subj;
}
 

public void push(Principal principal, Object credential, Subject subject,
      String securityDomain)
{
   //SecurityAssociation.pushSubjectContext(subject, principal, credential);
   SecurityContext sc = SecurityContextAssociation.getSecurityContext();
   if(sc == null)
   {
      try
      {
         sc = SecurityContextFactory.createSecurityContext(principal, credential,
               subject, securityDomain);
      }
      catch (Exception e)
      {
         throw new RuntimeException(e);
      }
   }
   else
   {
      sc.getUtil().createSubjectInfo(principal, credential, subject); 
   }
   SecurityContextAssociation.setSecurityContext(sc); 
}
 

static LoginException getContextLoginException()
{
   LoginException exp = null;
   SecurityContext sc = getSecurityContext();
   if (sc != null) {
       Map<String, Object> ctxInfo = sc.getData();
       if (ctxInfo != null) {
           for (Object obj: ctxInfo.values()) {
               if (obj != null && obj instanceof LoginException) {
                   return (LoginException)obj;
               }
           }
       }
   }
   return exp;
}
 

static Object getCredential()
{
   return AccessController.doPrivileged(new PrivilegedAction<Object>()
   {
      public Object run()
      {
         Object credential = null;
         SecurityContext sc = getSecurityContext();
         if(sc != null)
         {
            credential = sc.getUtil().getCredential();
         }
         return credential;
      }
   });
}
 

/**
 * @see IdentityTrustManager#isTrusted(org.jboss.security.SecurityContext)
 */
public TrustDecision isTrusted(SecurityContext securityContext)
{  
   if(securityContext == null)
      throw PicketBoxMessages.MESSAGES.invalidNullArgument("securityContext");
   if(this.identityTrustContext == null)
      this.identityTrustContext = new JBossIdentityTrustContext(securityDomain, securityContext);
   TrustDecision td = TrustDecision.NotApplicable;
   if(this.identityTrustContext == null)
      throw PicketBoxMessages.MESSAGES.invalidNullProperty("identityTrustContext");

   try
   {
      td = this.identityTrustContext.isTrusted();
   }
   catch (IdentityTrustException e)
   {
       PicketBoxLogger.LOGGER.debugIgnoredException(e);
   }
   return td;
}
 

public void push(Principal principal, Object credential, Subject subject,
      String securityDomain)
{
   //SecurityAssociation.pushSubjectContext(subject, principal, credential);
   SecurityContext sc = SecurityContextAssociation.getSecurityContext();
   if(sc == null)
   {
      try
      {
         sc = SecurityContextFactory.createSecurityContext(principal, credential,
               subject, securityDomain);
      }
      catch (Exception e)
      {
         throw new RuntimeException(e);
      }
   }
   else
   {
      sc.getUtil().createSubjectInfo(principal, credential, subject); 
   }
   SecurityContextAssociation.setSecurityContext(sc); 
}
 

/**
 * Establish a security context on the thread
 * @param securityDomainName
 */
public static SecurityContext establishSecurityContext(String securityDomainName)
{ 
   SecurityManager sm = System.getSecurityManager();
   if (sm != null) {
      sm.checkPermission(new RuntimePermission(SecurityFactory.class.getName() + ".establishSecurityContext"));
   }
   SecurityContext securityContext = null;
   try
   {
      securityContext = SecurityContextFactory.createSecurityContext(securityDomainName);
   }
   catch (Exception e)
   {
      throw new RuntimeException(e);
   }
   SecurityActions.setSecurityContext(securityContext);
   return securityContext;
}
 

public Object run()
{
   //Set it on the current security context also
   SecurityContext sc = SecurityContextAssociation.getSecurityContext();
   if(sc != null)
   {
      sc.getData().put(key, value);
   }
   return SecurityContextAssociation.setContextInfo(key, value);
}
 

static void setSecurityContext(final SecurityContext sc)
{ 
   AccessController.doPrivileged(new PrivilegedAction<SecurityContext>(){

      public SecurityContext run()
      { 
         SecurityContextAssociation.setSecurityContext(sc);
         return null;
      }});
}
 

static SecurityContext getSecurityContext()
{ 
   return AccessController.doPrivileged(new PrivilegedAction<SecurityContext>(){

      public SecurityContext run()
      {   
         return SecurityContextAssociation.getSecurityContext();
      }});
}
 

/**
 * @see IdentityTrustModule#initialize(SecurityContext, CallbackHandler, Map, Map)
 */
public void initialize(SecurityContext sc, 
      CallbackHandler handler, Map<String,Object> sharedState
      , Map<String,Object> options) 
throws IdentityTrustException
{ 
   this.securityContext = sc;
   this.callbackHandler = handler;
   this.sharedState = sharedState;
   this.options = options;
}
 

public void push(final Principal principal, final Object credential,
   final Subject subject, final String securityDomain) 
{
   AccessController.doPrivileged(
      new PrivilegedAction<Object>()
      {
         public Object run()
         {
            //SecurityAssociation.pushSubjectContext(subject, principal, credential);
            SecurityContext sc = SecurityContextAssociation.getSecurityContext();
            if(sc == null)
            {
               try
               {
                  sc = SecurityContextFactory.createSecurityContext(principal, credential,
                        subject, securityDomain);
               }
               catch (Exception e)
               {
                  throw new RuntimeException(e);
               }
            }
            SecurityContextAssociation.setSecurityContext(sc);
            return null;
         }
      }
   );
}
 

@Override
public SecurityContext getSecurityContext() {
   return AccessController.doPrivileged(new PrivilegedAction<SecurityContext>() {
      @Override
      public SecurityContext run() {
         return NON_PRIVILEGED.getSecurityContext();
      }
   });
}
 

private RoleGroup getCurrentRoles(Principal principal)
{ 
   //Check that the caller is authenticated to the current thread
   Subject subject = SubjectActions.getActiveSubject();  
   
   //Deal with the security context
   SecurityContext sc = SubjectActions.getSecurityContext(); 
   if(sc == null)
   {
      sc = new JBossSecurityContext(securityDomain); 
      SubjectActions.setSecurityContext(sc);   
   } 
   
   return getCurrentRoles(principal,subject,sc); 
}
 

static RunAs getIncomingRunAs(final SecurityContext sc)
{
   return AccessController.doPrivileged(new PrivilegedAction<RunAs>()
   {
      public RunAs run()
      {
         return sc.getIncomingRunAs();
      }
   });  
}
 

public void push(final Principal principal, final Object credential,
   final Subject subject, final String securityDomain) 
{
   AccessController.doPrivileged(
      new PrivilegedAction<Object>()
      {
         public Object run()
         {
            SecurityContext sc = SecurityContextAssociation.getSecurityContext();
            if(sc == null)
            {
               try
               {
                  sc = SecurityContextFactory.createSecurityContext(principal, credential,
                        subject, securityDomain);
               }
               catch (Exception e)
               {
                  throw new RuntimeException(e);
               }
            }
            SecurityContextAssociation.setSecurityContext(sc);
            return null;
         }
      }
   );
}
 

public Object run()
{
   //Set it on the current security context also
   SecurityContext sc = SecurityContextAssociation.getSecurityContext();
   if(sc != null)
   {
      sc.getData().put(key, value);
   }
   return SecurityContextAssociation.setContextInfo(key, value);
}
 

@Override
public void createSubjectInfo(final SecurityContext securityContext, final Principal principal, final Object credential, final Subject subject) {
   AccessController.doPrivileged(new PrivilegedAction<Void>() {
      @Override
      public Void run() {
         NON_PRIVILEGED.createSubjectInfo(securityContext, principal, credential, subject);
         return null;
      }
   });
}
 

@Override
public void setSecurityContext(final SecurityContext securityContext) {
   AccessController.doPrivileged(new PrivilegedAction<Void>() {
      @Override
      public Void run() {
         NON_PRIVILEGED.setSecurityContext(securityContext);
         return null;
      }
   });
}
 

@Override
public SecurityContext createClientSecurityContext() throws Exception {
   try {
      return AccessController.doPrivileged(new PrivilegedExceptionAction<SecurityContext>() {
         @Override
         public SecurityContext run() throws Exception {
            return NON_PRIVILEGED.createClientSecurityContext();
         }
      });
   } catch (PrivilegedActionException pae) {
      throw pae.getException();
   }
}
 

static void setSecurityContext(final SecurityContext sc)
{
   AccessController.doPrivileged(new PrivilegedAction<Object>()
   {
      public Object run()
      {
         SecurityContextAssociation.setSecurityContext(sc);
         return null;
      }
   });
}
 

static SecurityContext getSecurityContext() throws PrivilegedActionException
{
   return AccessController.doPrivileged(new PrivilegedExceptionAction<SecurityContext>()
   {
      public SecurityContext run() throws Exception
      {
         return SecurityContextAssociation.getSecurityContext();
      }
   });
}
 

static SecurityContext createSecurityContext(final String name) throws PrivilegedActionException
{
   return AccessController.doPrivileged(new PrivilegedExceptionAction<SecurityContext>()
   {
      public SecurityContext run() throws Exception
      {
         return SecurityContextFactory.createSecurityContext(name);
      }
   });
}
 

static void setSecurityContext(final SecurityContext sc)
{
   AccessController.doPrivileged(new PrivilegedAction<Object>()
   {
      public Object run()
      {
         SecurityContextAssociation.setSecurityContext(sc);
         return null;
      }
   });
}
 

static void register(final SecurityContext sc, final Principal principal, final Object credential, final Subject subject)
{
   AccessController.doPrivileged(new PrivilegedAction<Object>()
   {
      public Object run()
      {
         sc.getUtil().createSubjectInfo(principal, credential, subject); 
         return null;
      }
   });        
}
 

static SecurityContext getCurrentSecurityContext()
 {
    return AccessController.doPrivileged( new PrivilegedAction<SecurityContext>() 
    {

public SecurityContext run() 
{
	return SecurityContextAssociation.getSecurityContext();
}
    });
 }