Comment configurer un nouveau type d'authentification CAS ?

Laura Homar   jeu 20/02/2020 - 11:38  1106 vues

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 :

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.

Inclure dans drupal.fr

À propos de Laura

ITSS vous présente Laura, la nouvelle Business Developer. Elle s’occupe de toute la partie communication de l’agence. Passionnée par la communication et le marketing digital, Laura est prête à relever de nouveaux défis.

sa rigueur et sa ponctualité

Les guêpes

Articles liés

HTTP/2 finalisé

Dorénavant finalisé, HTTP/2 vient d’être dévoilé au grand public. Caractérisé comme une version qui révolutionne l’internet d'aujourd'hui, notre…

Commentaire

Soumis par baba le mar 26/10/2021 - 22:01

Bonsoir
merci pour ce tutoriel mais est ce que vous pourriez mieux détailler vos tutoriels . j'aimerais faire un couplage CAS avec authentification par LDAP amis j'ai des blocages soit en générant le fichier cas.war ou en essayant de m'authentifier avec un utilisateur LDAP

Ajouter un commentaire