javax.resource.spi.security.PasswordCredential Java Examples

@Override
public Subject createSubject(String securityDomain)
{
   //we just ignore atm the arg using a singleton for each security domain
   if (userName == null)
      throw new IllegalStateException("UserName is null");

   if (password == null)
      throw new IllegalStateException("Password is null");

   Subject subject = new Subject();

   Principal p = new SimplePrincipal(userName);
   subject.getPrincipals().add(p);

   PasswordCredential credential = new PasswordCredential(userName, password.toCharArray());
   subject.getPrivateCredentials().add(credential);

   return subject;
}
 

/**
 * Get a subject
 * @return The subject
 */
private Subject getSubject()
{
   Subject subject = null;

   if (subjectFactory != null && securityDomain != null)
   {
      subject = SecurityActions.createSubject(subjectFactory, securityDomain);

      Set<PasswordCredential> credentials = SecurityActions.getPasswordCredentials(subject);
      if (credentials != null && credentials.size() > 0)
      {
         ManagedConnectionFactory pcMcf = getManagedConnectionFactory();
         for (PasswordCredential pc : credentials)
         {
            pc.setManagedConnectionFactory(pcMcf);
         }
      }
   }

   log.tracef("Subject: %s", subject);

   return subject;
}
 

@Override
public Subject createSubject()
{
   if (userName == null)
      throw new IllegalStateException("UserName is null");

   if (password == null)
      throw new IllegalStateException("Password is null");

   Subject subject = new Subject();

   Principal p = new SimplePrincipal(userName);
   subject.getPrincipals().add(p);

   PasswordCredential credential = new PasswordCredential(userName, password.toCharArray());
   subject.getPrivateCredentials().add(credential);

   return subject;
}
 

@Override
public boolean commit() throws LoginException
{
   Principal principal = new SimplePrincipal(username);
   SubjectActions.addPrincipals(subject, principal);
   sharedState.put("javax.security.auth.login.name", username);
   // Decode the encrypted password
   try
   {
      char[] decodedPassword = decode(password);
      PasswordCredential cred = new PasswordCredential(username, decodedPassword);
      SubjectActions.addCredentials(subject, cred);
   }
   catch(Exception e)
   {
      LoginException le = new LoginException(e.getLocalizedMessage());
      le.initCause(e);
      throw le;
   }
   return true;
}
 

@SuppressWarnings("unchecked")
@Override
public boolean commit() throws LoginException
{
   Principal principal = new SimplePrincipal(username);
   SubjectActions.addPrincipals(subject, principal);
   sharedState.put("javax.security.auth.login.name", username);
   // Decode the encrypted password
   try
   {
      char[] decodedPassword = decode(password);
      PasswordCredential cred = new PasswordCredential(username, decodedPassword);
      SubjectActions.addCredentials(subject, cred);
   }
   catch(Exception e)
   {
      LoginException le = new LoginException(e.getLocalizedMessage());
      le.initCause(e);
      throw le;
   }
   return true;
}
 

@Override
public boolean login() throws LoginException
{
   PicketBoxLogger.LOGGER.traceBeginLogin();
   if (super.login())
      return true;

   Principal principal = new SimplePrincipal(principalName);
   SubjectActions.addPrincipals(subject, principal);
   // Put the principal name into the sharedState map
   sharedState.put("javax.security.auth.login.name", principalName);
   PasswordCredential cred = new PasswordCredential(userName, password.toCharArray());
   SubjectActions.addCredentials(subject, cred);
   super.loginOk = true;
   return true;
}
 

@Override
public boolean commit() throws LoginException
{
   // Put the principal name into the sharedState map
   sharedState.put("javax.security.auth.login.name", userName);
   // Add any run-as roles if addRunAsRoles is true
   if( addRunAsRoles && runAsRoles != null )
   {
      SubjectActions.addRoles(subject, runAsRoles);         
   }

   // Add the PasswordCredential
   PasswordCredential cred = new PasswordCredential(userName, password);
   SubjectActions.addCredentials(subject, cred);
   return super.commit();
}
 

/**
 * Returns name of the user associated with the ManagedConnection instance
 *
 * @return Name of the user
 * @throws ResourceException Thrown if an error occurs
 */
@Override
public String getUserName() throws ResourceException
{
   log.trace("getUserName()");
   if (mc.getCri() != null)
   {
      return ((UnifiedSecurityCri) mc.getCri()).getUserName();
   }
   else if (mc.getSubject() != null)
   {
      Set<PasswordCredential> credentials = this.getPasswordCredentials(mc.getSubject());
      if (credentials != null && !credentials.isEmpty())
      {
         for (PasswordCredential pc : credentials)
         {
            return pc.getUserName();
         }
      }
   }

   return null;

}
 

/**
 * Run
 *
 * @return The credential
 */
@Override
public PasswordCredential run() {
   if (ActiveMQRALogger.LOGGER.isTraceEnabled()) {
      ActiveMQRALogger.LOGGER.trace("run()");
   }

   Set<PasswordCredential> creds = subject.getPrivateCredentials(PasswordCredential.class);
   PasswordCredential pwdc = null;

   for (PasswordCredential curCred : creds) {
      if (curCred.getManagedConnectionFactory().equals(mcf)) {
         pwdc = curCred;
         break;
      }
   }
   return pwdc;
}
 

/**
 * Get the PasswordCredential from the Subject
 *
 * @param subject The subject
 * @return The instances
 */
private Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(
         (PrivilegedAction<Set<PasswordCredential>>) () -> subject.getPrivateCredentials(PasswordCredential.class));
}
 

/**
 * Get the PasswordCredential from the Subject
 *
 * @param subject The subject
 * @return The instances
 */
private Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(
         (PrivilegedAction<Set<PasswordCredential>>) () -> subject.getPrivateCredentials(PasswordCredential.class));
}
 

/**
 * Get the PasswordCredential from the Subject
 *
 * @param subject The subject
 * @return The instances
 */
private Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(
         (PrivilegedAction<Set<PasswordCredential>>) () -> subject.getPrivateCredentials(PasswordCredential.class));
}
 

private PasswordCredential getPasswordCredential(Subject s)
{
   Set<PasswordCredential> credentials = this.getPasswordCredentials(s);
   assertNotNull(credentials);
   assertFalse(credentials.isEmpty());
   return credentials.iterator().next();
}
 

/**
 * Get the PasswordCredential from the Subject
 *
 * @param subject The subject
 * @return The instances
 */
private Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(
         (PrivilegedAction<Set<PasswordCredential>>) () -> subject.getPrivateCredentials(PasswordCredential.class));
}
 

private PasswordCredential getPasswordCredential(Subject s)
{
   Set<PasswordCredential> credentials = this.getPasswordCredentials(s);
   assertNotNull(credentials);
   assertFalse(credentials.isEmpty());
   return credentials.iterator().next();
}
 

/**
 * Get the PasswordCredential from the Subject
 *
 * @param subject The subject
 * @return The instances
 */
private Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(
         (PrivilegedAction<Set<PasswordCredential>>) () -> subject.getPrivateCredentials(PasswordCredential.class));
}
 

private PasswordCredential getPasswordCredential(Subject s)
{
   Set<PasswordCredential> credentials = this.getPasswordCredentials(s);
   assertNotNull(credentials);
   assertFalse(credentials.isEmpty());
   return credentials.iterator().next();
}
 

/**
 * Get the PasswordCredential from the Subject
 *
 * @param subject The subject
 * @return The instances
 */
private Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(
         (PrivilegedAction<Set<PasswordCredential>>) () -> subject.getPrivateCredentials(PasswordCredential.class));
}
 

/**
 * Get the PasswordCredential from the Subject
 * @param subject The subject
 * @return The instances
 */
static Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(new PrivilegedAction<Set<PasswordCredential>>() 
   {
      public Set<PasswordCredential> run()
      {
         return subject.getPrivateCredentials(PasswordCredential.class);
      }
   });
}
 

/**
 * Get the PasswordCredential from the Subject
 * @param subject The subject
 * @return The instances
 */
static Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(new PrivilegedAction<Set<PasswordCredential>>() 
   {
      public Set<PasswordCredential> run()
      {
         return subject.getPrivateCredentials(PasswordCredential.class);
      }
   });
}
 

/**
 * Get the PasswordCredential from the Subject
 * @param subject The subject
 * @return The instances
 */
static Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(new PrivilegedAction<Set<PasswordCredential>>() 
   {
      public Set<PasswordCredential> run()
      {
         return subject.getPrivateCredentials(PasswordCredential.class);
      }
   });
}
 

@Test
public void testGetConnectionWithSubject() throws ResourceException {
    String user = new String("user");
    char[] password = {'a', 'b', 'c'};
    PasswordCredential creds = new PasswordCredential(user, password);
    creds.setManagedConnectionFactory(factory);
    subj.getPrivateCredentials().add(creds);
    Object o = mci.getConnection(subj, cri);

    verifyProxyInterceptors(o);
}
 

/**
 * Create a subject
 * @param subjectFactory The subject factory
 * @param securityDomain The security domain
 * @param mcf The managed connection factory
 * @param jndiName The jndi-name
 * @return The subject; <code>null</code> in case of an error
 */
protected Subject createSubject(final SubjectFactory subjectFactory,
                                final String securityDomain,
                                final ManagedConnectionFactory mcf,
                                final String jndiName)
{
   if (subjectFactory == null)
      throw new IllegalArgumentException("SubjectFactory is null");

   if (securityDomain == null)
      throw new IllegalArgumentException("SecurityDomain is null");

   return AccessController.doPrivileged(new PrivilegedAction<Subject>() 
   {
      public Subject run()
      {
         try
         {
            Subject subject = subjectFactory.createSubject(securityDomain);

            Set<PasswordCredential> pcs = subject.getPrivateCredentials(PasswordCredential.class);
            if (pcs.size() > 0)
            {
               for (PasswordCredential pc : pcs)
               {
                  pc.setManagedConnectionFactory(mcf);
               }
            }

            return subject;
         }
         catch (Throwable t)
         {
            log.exceptionDuringCreateSubject(jndiName, t.getMessage(), t);
         }

         return null;
      }
   });
}
 

/**
 * Get the PasswordCredential from the Subject
 * @param subject The subject
 * @return The instances
 */
static Set<PasswordCredential> getPasswordCredentials(final Subject subject)
{
   if (System.getSecurityManager() == null)
      return subject.getPrivateCredentials(PasswordCredential.class);

   return AccessController.doPrivileged(new PrivilegedAction<Set<PasswordCredential>>() 
   {
      public Set<PasswordCredential> run()
      {
         return subject.getPrivateCredentials(PasswordCredential.class);
      }
   });
}
 

public Void run()
{
   Iterator<PasswordCredential> i = subject.getPrivateCredentials(PasswordCredential.class).iterator();
   while (i.hasNext())
   {
      i.remove();
   }
   return null;
}
 

/**
 * Get credentials
 *
 * @param mcf     The managed connection factory
 * @param subject The subject
 * @param info    The connection request info
 * @return The credentials
 * @throws SecurityException Thrown if the credentials can't be retrieved
 */
public static ActiveMQRACredential getCredential(final ManagedConnectionFactory mcf,
                                                 final Subject subject,
                                                 final ConnectionRequestInfo info) throws SecurityException {
   if (ActiveMQRALogger.LOGGER.isTraceEnabled()) {
      ActiveMQRALogger.LOGGER.trace("getCredential(" + mcf + ", " + subject + ", " + info + ")");
   }

   ActiveMQRACredential jc = new ActiveMQRACredential();
   if (subject == null && info != null) {
      jc.setUserName(((ActiveMQRAConnectionRequestInfo) info).getUserName());
      jc.setPassword(((ActiveMQRAConnectionRequestInfo) info).getPassword());
   } else if (subject != null) {
      PasswordCredential pwdc = GetCredentialAction.getCredential(subject, mcf);

      if (pwdc == null) {
         throw new SecurityException("No password credentials found");
      }

      jc.setUserName(pwdc.getUserName());
      jc.setPassword(new String(pwdc.getPassword()));
   } else {
      throw new SecurityException("No Subject or ConnectionRequestInfo set, could not get credentials");
   }

   return jc;
}
 

/**
 * Get credentials
 *
 * @param subject The subject
 * @param mcf     The managed connection factory
 * @return The credential
 */
static PasswordCredential getCredential(final Subject subject, final ManagedConnectionFactory mcf) {
   if (ActiveMQRALogger.LOGGER.isTraceEnabled()) {
      ActiveMQRALogger.LOGGER.trace("getCredential(" + subject + ", " + mcf + ")");
   }

   GetCredentialAction action = new GetCredentialAction(subject, mcf);
   return AccessController.doPrivileged(action);
}
 

@Test
public void testGetConnectionWithDudSubjectB() throws ResourceException {
    String user = new String("user");
    char[] password = {'a', 'b', 'c'};
    PasswordCredential creds = new PasswordCredential(user, password);
    subj.getPrivateCredentials().add(creds);
    Object o = mci.getConnection(subj, cri);

    verifyProxyInterceptors(o);
}
 

/**
 * get the user name
 * @return the user name
 */
String getUserName()
{
   if (cri != null && cri instanceof UnifiedSecurityCri)
   {
      return ((UnifiedSecurityCri) cri).getUserName();
   }
   if (subject != null)
   {
      PasswordCredential pc = getPasswordCredential(subject);
      return pc.getUserName();
   }

   return null;
}
 

/**
 * get the password
 * @return the password
 */
String getPassword()
{
   if (cri != null && cri instanceof UnifiedSecurityCri)
   {
      return ((UnifiedSecurityCri) cri).getPassword();
   }
   if (subject != null)
   {
      PasswordCredential pc = getPasswordCredential(subject);
      return pc.getPassword().toString();
   }

   return null;
}