Configurer un nouveau type d’authentification CAS

Voici comment configurer un nouveau type d'authentification CAS :

En partant du principe que vous avez suivi le tutoriel “Comment configurer l’authentification CAS”.
Les dossiers dans notre exemple se situent aux emplacements suivants :

• Pour le CAS   ->   Téléchargements/cas60X
• Pour Tomcat  ->   /opt/tomcat9.0.14

Nous pouvons accéder à Tomcat à partir du navigateur :

• Pour le manager      ->  http://localhost:8334/manager
• Pour le CAS (login)  ->  http://localhost:8334/cas ou http://127.0.0.1:8334/cas

Nous allons faire une nouvelle authentification par login et mot de passe en suivant la documentation officielle. 

Pour l’exemple nous allons nous authentifier avec l'utilisateur suivant :

• Utilisateur : Demo User
• Mot de passe : DemoPass

Créer un nouveau type d’authentification dans la version 6 du CAS requiert de coder de nouvelles classes java.

Pour démarrer la configuration du CAS nous allons commencer par ajouter les dépendances dans le fichier “build.gradle”. Dans le dossier Téléchargements/cas60X, nous ouvrons le fichier build.gradle.
Sous le commentaire  “// Other CAS dependencies/modules may be listed here...”, nous devons ajouter :

compile "org.apereo.cas:cas-server-core-authentication-api:${casServerVersion}"
compile "org.apereo.cas:cas-server-core-configuration:${casServerVersion}"

Ces deux lignes indiquent au compilateur d’importer les paquets “api authentication” et “configuration” du coeur de CAS. Ces paquets possèdent les classes nous permettant de faire le nécessaire pour créer un nouveau type d’authentification dans cet exemple.

Ensuite nous allons créer un dossier “authentication” dans le dossier "src" :

mkdir -p src/main/java/com/server/cas/demo/authentication

Dans ce dossier nous devons créer une classe “Handler” :

touch src/main/java/com/server/cas/demo/authentication/TestAuthenticationHandler.java

Cette classe va nous servir de nouveau gestionnaire d'authentification.
Dans ce fichier nous allons redéfinir la fonction qui permet de faire l’authentification par login/password (nous allons hériter de la classe “authenticateUsernamePasswordInternal”).

TestAuthenticationHandler.java :

package com.server.cas.demo.authentication;

import org.apereo.cas.authentication.AuthenticationHandlerExecutionResult;
import org.apereo.cas.authentication.credential.UsernamePasswordCredential;
import org.apereo.cas.authentication.handler.support.AbstractUsernamePasswordAuthenticationHandler;
import org.apereo.cas.authentication.principal.PrincipalFactory;
import org.apereo.cas.services.ServicesManager;
import java.security.GeneralSecurityException;
import javax.security.auth.login.FailedLoginException;
import org.apache.commons.lang3.StringUtils;

/**
 * This is {@link TestAuthenticationHandler}.
 */

public class TestAuthenticationHandler extends AbstractUsernamePasswordAuthenticationHandler {

    private String testUsername = "Demo User";

    private String testPassword = "DemoPass";

    public TestAuthenticationHandler(final ServicesManager servicesManager,
                                     final PrincipalFactory principalFactory) {
        super(null, servicesManager, principalFactory, null);
    }

    @Override
    protected AuthenticationHandlerExecutionResult authenticateUsernamePasswordInternal(final UsernamePasswordCredential credential, final String originalPassword)
        throws GeneralSecurityException {

            if (!StringUtils.equalsIgnoreCase(credential.getUsername(), this.testUsername) ||
                !StringUtils.equals(credential.getPassword(), this.testPassword)) {
                throw new FailedLoginException("Authentication error ");
            }

            return createHandlerResult(credential,
                this.principalFactory.createPrincipal(credential.getUsername()));
    }
}

Ensuite, nous allons ajouter un fichier de configuration pour que le système reconnaisse notre nouvelle authentification. Pour cela nous devons instancier la classe TestSoapAuthenticationConfiguration.java dans le dossier java/com/server/cas/demo/config/.

touch src/main/java/com/server/cas/demo/config/TestAuthenticationConfiguration.java

Dans cette classe nous allons écrire la configuration nécessaire pour avoir les changements que nous avons fait sur le gestionnaire d’authentification.

TestAuthenticationConfiguration.java :

package com.server.cas.demo.config;

import org.apereo.cas.authentication.AuthenticationEventExecutionPlanConfigurer;
import org.apereo.cas.authentication.AuthenticationEventExecutionPlan;
import org.apereo.cas.authentication.AuthenticationHandler;
import org.apereo.cas.authentication.principal.PrincipalFactory;
import org.apereo.cas.authentication.principal.PrincipalFactoryUtils;
import org.apereo.cas.configuration.CasConfigurationProperties;
import org.apereo.cas.services.ServicesManager;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.server.cas.demo.authentication.TestAuthenticationHandler;

/**
 * This is {@link TestAuthenticationConfiguration}.
 */

@Configuration("testAuthenticationConfiguration")
@EnableConfigurationProperties(CasConfigurationProperties.class)
public class TestAuthenticationConfiguration implements AuthenticationEventExecutionPlanConfigurer {

    @Autowired
    @Qualifier("servicesManager")
    private ObjectProvider<ServicesManager> servicesManager;

    @Bean
    public PrincipalFactory testAuthenticationPrincipalFactory() {
        return PrincipalFactoryUtils.newPrincipalFactory();
    }

    @Bean
    public AuthenticationHandler testAuthenticationHandler() {
        return new TestAuthenticationHandler(
            servicesManager.getIfAvailable(),
            testAuthenticationPrincipalFactory()
        );
    }

    @Override
    public void configureAuthenticationExecutionPlan(final AuthenticationEventExecutionPlan plan) {
        plan.registerAuthenticationHandler(testAuthenticationHandler());
    }
}

Pour finir nous allons valider nos changements. Pour cela nous ouvrons le fichier spring.factories (fichier créé dans le précédent guide). Pour rappel ce fichier se situe à l’emplacement suivant : src/main/resources/META-INF/spring.factories.

Voici notre fichier après avoir ajouter notre nouveau fichier de configuration.

spring.factories :

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.server.cas.demo.config.TestRegisteredServicesConfiguration,\
com.server.cas.demo.config.TestAuthenticationConfiguration

CAS lis le fichier spring.factories et regarde chaque fichier défini par “org.springframework.boot.autoconfigure.EnableAutoConfiguration”.  Ces fichiers listent les classes définies et utilisables par CAS. Si vous créez une classe Handler mais que vous ne créez pas un nouveau fichier qui signale au CAS que cette classe existe alors elle ne sera jamais appelée. Dans l’exemple nous ajoutons dans spring.factories :

com.server.cas.demo.config.TestAuthenticationConfiguration

Ainsi CAS reconnait le fichier TestAuthenticationConfiguration comme un fichier de configuration (indice : Dans CAS les fichiers de configuration java auront des balises @Bean, CAS reconnait cela comme un lien action <--> classe).

On espère que notre dernier billet de blog sur l'authentification CAS vous aura plus ! 

N'hésitez pas à nous faire parvenir tous vos commentaires ou questions en dessous de nos articles.