mécanismes d'authentification multiples dans une seule application utilisant java config

j'ai passé pas mal de temps à me concentrer sur la sécurité des sources en utilisant la configuration java pure. Il y a quelques étapes à franchir pour que cela fonctionne. Ce devrait être quelque chose dans ce sens. Le processus de base est la suivante:

• créer des filtres personnalisés pour vérifier les demandes d'informations d'autorisation spécifiques

• chaque filtre renvoie null (si aucune autorisation de ce type n'est trouvée), ou une AbstractAuthenticationToken

• si un filtre renvoie un token, chaque méthode de support(classe) D'AuthenticationProvider sera invoquée avec ce token retournant true|false si elle doit essayer l'authentification

• tentative d'authentification sera alors appelée Sur le fournisseur D'authentification qui supporte le token. Ici vous effectuez des appels de service pour authentifier l'utilisateur. Vous pouvez alors lancer LoginException ou l'authentification d'appel.setathenticated (true) et retourner le jeton pour une authentification réussie.

j'utilise cette configuration depuis un certain temps en supportant différentes méthodes d'authentification (demande signée, nom d'utilisateur/mot de passe, etc.) et cela fonctionne assez bien.

vous pouvez également passer les Authentifications Successhandler's et Authenticationfailuershandler's aux filtres de sécurité personnalisés pour fournir des stratégies de redirection personnalisées et la gestion des échecs.

assurez-vous également de mettre en place la fourmi matchers dans les constructeurs du filtre pour contrôler les motifs d'url que les filtres appliquent aussi. Par exemple, un filtre de requête ldap devrait probablement être vérifié avec n'importe quelle requête "/*" alors qu'un filtre de nom d'utilisateur/mot de passe peut simplement être vérifié sur POST's to /login ou quelque chose de similaire.

Exemple De Code:

1) Créez des authentifications personnalisées pour chaque type d'authentification que vous voulez prendre en charge

public class LDAPAuthorizationToken extends AbstractAuthenticationToken {
    private String token;

    public LDAPAuthorizationToken( String token ) {
        super( null );
        this.token = token;
    }

    public Object getCredentials() {
        return token;
    }

    public Object getPrincipal() {
        return null;
    }
}

public class OTPAuthorizationToken extends UsernamePasswordAuthenticationToken {
    private String otp;

    public OTPAuthorizationToken( String username, String password, String otp ) {
        super( username, password );
        this.otp = otp;
    }

    public String getOTP() {
        return otp;
    }
}

2) Créer des filtres de sécurité personnalisés pour chaque type

public class LDAPAuthorizationFilter extends AbstractAuthenticationProcessingFilter {
    @Autowired
    private UserDetailsService userDetailsService;

    public LDAPAuthorizationFilter() {
        super( "/*" ); // allow any request to contain an authorization header
    }

    public Authentication attemptAuthentication( HttpServletRequest request, HttpServletResponse response ) throws AuthenticationException
    {

        if ( request.getHeader( "Authorization" ) == null ) {
            return null; // no header found, continue on to other security filters
        }

        // return a new authentication token to be processed by the authentication provider
        return new LDAPAuthorizationToken( request.getHeader( "Authorization" ) );
    }
}

public class OTPAuthorizationFilter extends AbstractAuthenticationProcessingFilter {
    @Autowired
    private UserDetailsService userDetailsService;

    public OTPAuthorizationFilter() {
        super( "/otp_login" );
    }

    public Authentication attemptAuthentication( HttpServletRequest request, HttpServletResponse response ) throws AuthenticationException
    {

        if ( request.getParameter( "username" ) == null || request.getParameter( "password" ) == null || request.getParameter( "otp" ) == null ) {
            return null;
        }

        // return a new authentication token to be processed by the authentication provider
        return new OTPAuthorizationToken( request.getParameter( "username" ), request.getParameter( "password" ), request.getParameter( "otp" ) );
    }
}

3) Créer des fournisseurs d'authentification sur mesure

public class LDAPAuthenticationProvider implements AuthenticationProvider {

    @Autowired
    private MyAuthenticationService sampleService;

    @Override
    public Authentication authenticate( Authentication authentication ) throws AuthenticationException {
        LDAPAuthorizationToken auth = (LDAPAuthorizationToken)authentication;

        String username = sampleService.verifyToken( auth.getCredentials() );
        if ( username == null ) {
            throw new LoginException( "Invalid Token" );
        }

        auth.setAuthenticated( true );

        return auth;
    }

    @Override
    public boolean supports( Class<?> authentication ) {
        if ( authentication.isAssignableFrom( LDAPAuthorizationToken.class ) ) {
            return true;
        }
        return false;
    }
}

public class OTPAuthenticationProvider implements AuthenticationProvider {

    @Autowired
    private MyAuthenticationService sampleService;

    @Override
    public Authentication authenticate( Authentication authentication ) throws AuthenticationException {
        OTPAuthorizationToken auth = (OTPAuthorizationToken)authentication;

        String error = sampleService.loginWithOTP( auth.getPrincipal(), auth.getCredentials(), auth.getOTP() );
        if ( error != null ) {
            throw new LoginException( error );
        }

        auth.setAuthenticated( true );

        return auth;
    }

    @Override
    public boolean supports( Class<?> authentication ) {
        if ( authentication.isAssignableFrom( OTPAuthorizationToken.class ) ) {
            return true;
        }
        return false;
    }
}

4) Configurer la sécurité du printemps

public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure( HttpSecurity http ) throws Exception {
        // configure filters
        http.addFilterBefore( new LDAPAuthorizationFilter(), UsernamePasswordAuthenticationFilter.class );
        http.addFilterBefore( new OTPAuthorizationFilter(), UsernamePasswordAuthenticationFilter.class );

        // configure authentication providers
        http.authenticationProvider( new LDAPAuthenticationProvider() );
        http.authenticationProvider( new OTPAuthenticationProvider() );

        // disable csrf
        http.csrf().disable();

        // setup security
        http.authorizeRequests()
            .anyRequest()
                .fullyAuthenticated()
                .and().httpBasic();
    }
}

j'Espère que ça aide!