Mappage du nom de principal client Kerberos sur l'ID de registre d'utilisateurs WebSphere pour l'intercepteur TAI SPNEGO (déprécié)

Vous pouvez utiliser une interface de programmation de système pour personnaliser le comportement de l'intercepteur TAI (Trust Association Interceptor) SPNEGO (Simple and Protected GSS-API Negotiation Mechanism) en implémentant des mappages arbitraires de l'identité de l'utilisateur final, extraite de Microsoft Active Directory sur l'identité utilisée dans le registre de sécurité WebSphere Application Server.

Avant de commencer

Vous devez effectuer certaines tâches d'administration dans l'environnement WebSphere Application Server pour utiliser l'intercepteur TAI SPNEGO et vous assurer que l'identité du demandeur correspond à celle figurant dans le registre d'utilisateurs WebSphere Application Server.
Fonction obsolète Fonction obsolète:

WebSphere Application Server version 6.1 fournit un intercepteur de relations de confiance (TAI) qui utilise le mécanisme SPNEGO (Simple and Protected GSS-API Negotiation Mechanism) pour négocier et authentifier en toute sécurité les demandes HTTP portant sur des ressources sécurisées. Dans WebSphere Application Server 7.0, cette fonction est obsolète. L'authentification Web SPNEGO fournit un rechargement dynamique des filtres SPNEGO et active la rétromigration sur la méthode de connexion d'application.

depfeat
Remarque : Assurez-vous que les tâches suivantes ont été effectuées :
  1. Configuration du navigateur web pour l'utilisation de SPNEGO. Reportez-vous à Configuration du navigateur client pour utiliser l'intercepteur TAI SPNEGO (déprécié)
  2. Configuration des propriétés JVM (Java™ virtual machine), des propriétés TAI SPNEGO personnalisées, et activation de l'intercepteur TAI SPNEGO. Reportez-vous à Configuration des propriétés personnalisées JVM, filtrage des requêtes HTTP et activation de l'intercepteur TAI SPNEGO dans WebSphere Application Server (obsolète)

Pourquoi et quand exécuter cette tâche

Dans le déploiement le plus simple de l'intercepteur TAI SPNEGO, il est supposé que l'identité du demandeur se trouvant dans le registre d'utilisateurs WebSphere Application Server est identique à celle extraite. C'est le cas lorsque le serveur Microsoft Windows Active Directory est le serveur LDAP (Lightweight Directory Access Protocol) utilisé dans WebSphere Application Server. Il s'agit du comportement par défaut de l'intercepteur TAI SPNEGO.

Il est inutile d'utiliser ce simple déploiement de l'intercepteur TAI SPNEGO. WebSphere Application Server peut utiliser un autre registre que Microsoft Active Directory (tel que le registre du système d'exploitation local, le registre LDAP ou le registre personnalisé). Si WebSphere Application Server utilise un registre autre que Microsoft Active Directory, un mappage de l'ID utilisateur de Microsoft Windows sur un ID utilisateur de WebSphere Application Server est nécessaire.

Procédure

Utilisez le module de connexion personnalisé JAAS pour effectuer n'importe quel mappage personnalisé d'un nom de principal Kerberos client de Microsoft Active Directory l'identité du registre d'utilisateurs WebSphere. Le module de connexion personnalisé JAAS est un mécanisme de plug-in défini pour l'authentification des requêtes entrantes et sortantes dans WebSphere Application Server et est inséré avant le ltpaLoginModule. Le module de connexion personnalisée JAAS extrait un nom de principal Kerberos client de javax.security.auth.Subject en utilisant la méthode subject.getPrincipals(KerberosPrincipal.class), mappe le nom du principal Kerberos client sur l'identité de registre d'utilisateurs WebSphere, et insère l'identité de mappage dans la propriété de table de hachage com.ibm.wsspi.security.cred.userId. Le module ltpaLoginModule utilise ensuite l'identité mappée pour créer un WSCredential.
Remarque : Le module de connexion personnalisé peut également fournir l'ensemble complet de propriétés de sécurité de javax.security.auth.Subject dans l'élément com.ibm.wsspi.security.tai.TAIResult afin de vérifier intégralement l'identité mappée. Lorsque l'identité est entièrement vérifiée, l'élément wsMapDefaultInboundLoginModule mappe ces propriétés de sécurité vers un WSCredential.
Voici un exemple de module de connexion personnalisé :
package com.ibm.ws.security.server.lm;

import java.util.Map;
import java.lang.reflect.Array;
import javax.security.auth.Subject;
import javax.security.auth.callback.*;
import javax.security.auth.login.LoginException;
import javax.security.auth.spi.LoginModule;
import javax.security.auth.kerberos.*;
import com.ibm.websphere.security.auth.WSLoginFailedException;
import com.ibm.wsspi.security.token.AttributeNameConstants;

/**
 * 
 * @author IBM Corporation
 * @version 1.0
 * @since 1.0    
 *
 */

public class sampleSpnegoMappingLoginModule implements LoginModule {
    /*
     * 
     * Constant that represents the name of this mapping module.  Whenever this sample
     * code is used to create a class with a different name, this value should be changed.
     * 
     */
    private final static String MAPPING_MODULE_NAME = "com.ibm.websphere.security.sampleSpnegoMappingLoginModule";

    private String mapUid = null;
    /**
     * Construct an uninitialized WSLoginModuleImpl object.
     */
    public sampleSpnegoMappingLoginModule() {
        debugOut("sampleSpnegoMappingLoginModule() entry");
        debugOut("sampleSpnegoMappingLoginModule() exit");
    }

    /**
     * Initialize this login module.
     *
     * 
     * This is called by the  LoginContext after this login module is
     * instantiated. The relevant information is passed from the LoginContext
     * to this login module. If the login module does not understands any of the data
     * stored in the sharedState and options parameters,
     * they can be ignored.
     * 
     *
     * @param subject The subject to be authenticated.
     * @param callbackHandler
     *                A  CallbackHandler for communicating with the end user to gather 
                      login information (e.g., username and password).
     * @param sharedState
     *                The state shared with other configured login modules.
     * @param options The options specified in the login configuration for this particular login module.
     */
    public void initialize(Subject subject, CallbackHandler callbackHandler,
                           Map sharedState, Map options) {
        debugOut("initialize(subject = \"" + subject.toString() +
                 "\", callbackHandler = \"" + callbackHandler.toString() +
                 "\", sharedState = \"" + sharedState.toString() +
                 "\", options = \"" + options.toString() + "\")");

        this.subject = subject;
        this.callbackHandler = callbackHandler;
        this.sharedState = sharedState;
        this.options = options;

        debug = "true".equalsIgnoreCase((String)this.options.get("debug"));

        debugOut("initialize() exit");
    }

    /**
     * 
     * Method to authenticate a Subject (phase 1).
     * 
     *
     * 
     * This method authenticates a Subject. It uses CallbackHandler to gather
     * the Subject information, like username and password for example, and verify these
     * information. The result of the authentication is saved in the private state within
     * this login module.
     * 
     *
     * @return  true if the authentication succeeded, or false
     *         if this login module should be ignored.
     * @exception LoginException
     *                   If the authentication fails.
     */
    public boolean login() throws LoginException
    {
        debugOut("sampleSpnegoMappingLoginModule.login() entry"); 

        boolean succeeded = false;
        java.util.Set krb5Principals= subject.getPrincipals(KerberosPrincipal.class);
        java.util.Iterator krb5PrincIter = krb5Principals.iterator();

        while (krb5PrincIter.hasNext()) {
            Object princObj = krb5PrincIter.next();
            debugOut("Kerberos principal name: "+ princObj.toString());
            
            if (princObj != null && princObj.toString().equals("utle@WSSEC.AUSTIN.IBM.COM")){
                mapUid = "user1";
                debugOut("mapUid: "+mapUid);

                                 java.util.Hashtable customProperties = (java.util.Hashtable)
                                 sharedState.get(AttributeNameConstants.WSCREDENTIAL_PROPERTIES_KEY);
                                 if (customProperties == null) {
                                     customProperties = new java.util.Hashtable();
                                 }
                                 succeeded = true;
                                 customProperties.put(AttributeNameConstants.WSCREDENTIAL_USERID, mapUid);

                                 Map<String,java.util.Hashtable)>
                                 mySharedState=(Map<String,java.util.Hashtable>)sharedState;
                                 mySharedState.put((AttributeNameConstants.WSCREDENTIAL_PROPERTIES_KEY.customProperties);

                                 debugOut("Add a mapping user ID to Hashtable, mapping ID = "+mapUid); 

                                    }
                                 debugOut("login() custom properties = " + customProperties);
            }
        }

        succeeded = true;
        debugOut("sampleSpnegoMappingLoginModule.login() exit"); 

        return succeeded;
    }

    /**
     * 
     * Method to commit the authentication result (phase 2).
     * 
     *
     * 
     * This method is called if the LoginContext's overall authentication
     * succeeded (the revelant REQUIRED, REQUISITE, SUFFICIENT and OPTIONAL login module
     * succeeded).
     * 
     *
     * @return true if the commit succeeded, or false
     *         if this login module should be ignored.
     * @exception LoginException
     *                   If the commit fails.
     */
    public boolean commit() throws LoginException              
    {
        debugOut("commit()");

        debugOut("commit()");

        return true;
    }

    /**
     * Method to abort the authentication process (phase 2).
     *
     * 
     * This method is called if the LoginContext's overall authentication
     * failed (the revelant REQUIRED, REQUISITE, SUFFICIENT and OPTIONAL login module
     * did not succeed).
     * 
     *
     * 
     * If this login module's authentication attempt succeeded, then this method cleans
     * up the previous state saved in phase 1.
     * 
     *
     * @return true if the abort succeeded, or false
     *         if this login module should be ignored.
     * @exception LoginException
     *                   If the abort fails.
     */
    public boolean abort() throws LoginException {
        debugOut("abort() entry");
        debugOut("abort() exit");
        return true;
    }

    /**
     * Method which logs out a Subject.
     *
     * @return true if the logout succeeded, or false
     *         if this login module should be ignored.
     * @exception LoginException
     *                   If the logout fails.
     */
    public boolean logout() throws LoginException
    {
        debugOut("logout() entry");
        debugOut("logout() exit");

        return true;
    }

    private void cleanup()
    {
        debugOut("cleanup() entry");
        debugOut("cleanup() exit");
    }

    /*
     * 
     * Private method to print trace information.  This implementation uses System.out
     * to print trace information to standard output, but a custom tracing system can
     * be implemented here as well.
     * 
     */
    private void debugOut(Object o)
    {
        System.out.println("Debug: " + MAPPING_MODULE_NAME);
        if (o != null) {
            if (o.getClass().isArray()) {
                int length = Array.getLength(o);
                for (int i = 0; i < length; i++) {
                    System.out.println("\t" + Array.get(o, i));
                }
            } else {
                System.out.println("\t" + o);
            }
        }
    }
    private Subject subject;
    private CallbackHandler callbackHandler;
    private Map sharedState;
    private Map options;

    protected boolean debug = false;
}

Résultats

A l'aide du module de connexion personnalisé, les identités de Microsoft Active Directory sont mappées sur le registre de sécurité de WebSphere Application Server et le comportement de l'intercepteur TAI SPNEGO est personnalisé.

Icône indiquant le type de rubrique Rubrique de tâche



Icône d'horodatage Dernière mise à jour: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tsec_SPNEGO_tai_umapper
Nom du fichier : tsec_SPNEGO_tai_umapper.html