7.6.4. Modifier l'identité du contexte de sécurité

Procédure 7.12. Modifier l'identité du contexte de sécurité

1. Créer l'intercepteur côté client

   Cet intercepteur côté client doit implémenter l'interface org.jboss.ejb.client.EJBClientInterceptor. L'intercepteur doit passer l'identité requise par le mappage de données contextuelles, par l'intermédiaire d'un appel EJBClientInvocationContext.getContextData(). Voici un exemple de code d'intercepteur côté client  :

   public class ClientSecurityInterceptor implements EJBClientInterceptor {
   
       public void handleInvocation(EJBClientInvocationContext context) throws Exception {
           Principal currentPrincipal = SecurityActions.securityContextGetPrincipal();
   
           if (currentPrincipal != null) {
               Map<String, Object> contextData = context.getContextData();
               contextData.put(ServerSecurityInterceptor.DELEGATED_USER_KEY, currentPrincipal.getName());
           }
           context.sendRequest();
       }
   
       public Object handleInvocationResult(EJBClientInvocationContext context) throws Exception {
           return context.getResult();
       }
   }
   

   Les applications utilisateur peuvent insérer l'intercepteur dans la chaîne d'intercepteur dans le EJBClientContext par l'un des moyens suivants  :

   • Par programmation

     Par cette approche, vous appelez la méthode org.jboss.ejb.client.EJBClientContext.registerInterceptor(int order, EJBClientInterceptor interceptor) et passez l'instance order et l'instance interceptor. L'instance order est utilisé pour déterminer où exactement cet intercepteur est placé dans la chaîne d'intercepteur.

   • Mécanisme ServiceLoader

     Cette approche nécessite la création d'un fichier META-INF/services/org.jboss.ejb.client.EJBClientInterceptor et de le placer ou le mettre dans le chemin de classe de l'application client. Les règles du fichier sont dictées par le Java ServiceLoader Mechanism. Ce fichier doit contenir, dans chaque ligne distincte, le nom de classe qualifié complet de l'implémentation d'intercepteur de client EJB. Les classes d'intercepteur de client EJB doivent être disponibles dans le chemin de classe. Les intercepteurs de client EJB ajoutés en utilisant le mécanisme de ServiceLoader sont ajoutés à la fin de la chaîne d'intercepteur de client, dans l'ordre dans lequel ils se trouvent dans le chemin de classe (classpath). Le démarrage rapide ou quickstart ejb-security-interceptors utilise cette approche.

2. Créer et configurer l'intercepteur du conteneur côté serveur

   Les classes d'intercepteur de conteneur sont de simples Plain Old Java Objects (POJOs). Elles utilisent @javax.annotation.AroundInvoke pour marquer la méthode qui sera invoquée lors de l'invocation sur le bean. Pour plus d'informations sur les intercepteurs de conteneur, consulter : Section 7.6.1, « Intercepteurs de conteneurs ».

   1. Créer l'intercepteur de conteneur

      Cet intercepteur reçoit le InvocationContext en même temps que l'identité et demande le changement d'identité nouvelle. Ce qui suit est une version modifiée de l'exemple de code  :

          public class ServerSecurityInterceptor {
      
          private static final Logger logger = Logger.getLogger(ServerSecurityInterceptor.class);
      
          static final String DELEGATED_USER_KEY = ServerSecurityInterceptor.class.getName() + ".DelegationUser";
      
          @AroundInvoke
          public Object aroundInvoke(final InvocationContext invocationContext) throws Exception {
              Principal desiredUser = null;
              UserPrincipal connectionUser = null;
      
              Map<String, Object> contextData = invocationContext.getContextData();
              if (contextData.containsKey(DELEGATED_USER_KEY)) {
                  desiredUser = new SimplePrincipal((String) contextData.get(DELEGATED_USER_KEY));
      
                  Collection<Principal> connectionPrincipals = SecurityActions.getConnectionPrincipals();
      
                  if (connectionPrincipals != null) {
                      for (Principal current : connectionPrincipals) {
                          if (current instanceof UserPrincipal) {
                              connectionUser = (UserPrincipal) current;
                              break;
                          }
                      }
      
                  } else {
                      throw new IllegalStateException("Delegation user requested but no user on connection found.");
                  }
              }
      
      
              ContextStateCache stateCache = null;
              try {
                  if (desiredUser != null && connectionUser != null
                      && (desiredUser.getName().equals(connectionUser.getName()) == false)) {
                      // The final part of this check is to verify that the change does actually indicate a change in user.
                      try {
                          // We have been requested to use an authentication token
                          // so now we attempt the switch.
                          stateCache = SecurityActions.pushIdentity(desiredUser, new OuterUserCredential(connectionUser));
                      } catch (Exception e) {
                          logger.error("Failed to switch security context for user", e);
                          // Don't propagate the exception stacktrace back to the client for security reasons
                          throw new EJBAccessException("Unable to attempt switching of user.");
                      }
                  }
      
                  return invocationContext.proceed();
              } finally {
                  // switch back to original context
                  if (stateCache != null) {
                      SecurityActions.popIdentity(stateCache);;
                  }
              }
          }
      

   2. Configurer l'intercepteur du conteneur

      Pour plus d'informations sur la façon de configurer les intercepteurs de conteneurs côté serveur, consulter : Section 7.6.3, « Configurer un intercepteur de conteneur ».

3. Créer le JAAS LoginModule

   Ce composant doit vérifier que l'utilisateur est en mesure d'exécuter les requêtes selon l'identité de la requête. Les exemples de code abrégés suivants indiquent les méthodes de login et de validation :

       @SuppressWarnings("unchecked")
       @Override
       public boolean login() throws LoginException {
           if (super.login() == true) {
               log.debug("super.login()==true");
               return true;
           }
   
           // Time to see if this is a delegation request.
           NameCallback ncb = new NameCallback("Username:");
           ObjectCallback ocb = new ObjectCallback("Password:");
   
           try {
               callbackHandler.handle(new Callback[] { ncb, ocb });
           } catch (Exception e) {
               if (e instanceof RuntimeException) {
                   throw (RuntimeException) e;
               }
               return false; // If the CallbackHandler can not handle the required callbacks then no chance.
           }
   
           String name = ncb.getName();
           Object credential = ocb.getCredential();
   
           if (credential instanceof OuterUserCredential) {
               // This credential type will only be seen for a delegation request, if not seen then the request is not for us.
   
               if (delegationAcceptable(name, (OuterUserCredential) credential)) {
   
                   identity = new SimplePrincipal(name);
                   if (getUseFirstPass()) {
                       String userName = identity.getName();
                       if (log.isDebugEnabled())
                           log.debug("Storing username '" + userName + "' and empty password");
                       // Add the username and an empty password to the shared state map
                       sharedState.put("javax.security.auth.login.name", identity);
                       sharedState.put("javax.security.auth.login.password", "");
                   }
                   loginOk = true;
                   return true;
               }
           }
   
           return false; // Attempted login but not successful.
       }
   
       protected boolean delegationAcceptable(String requestedUser, OuterUserCredential connectionUser) {
       if (delegationMappings == null) {
           return false;
       }
   
       String[] allowedMappings = loadPropertyValue(connectionUser.getName(), connectionUser.getRealm());
       if (allowedMappings.length == 1 && "*".equals(allowedMappings[1])) {
           // A wild card mapping was found.
           return true;
       }
       for (String current : allowedMappings) {
           if (requestedUser.equals(current)) {
               return true;
           }
       }
       return false;
   }