La mise en œuvre de manière 2 SSL à l'aide de spring boot

Je suis tombé sur un problème similaire, et j'ai pensé partager la solution je suis venu avec.

Tout d'abord, vous devez comprendre que le certificat SSL authentification seront traitées sur votre serveur web côté (cfr. dur d'explication, avec le “clientAuth=voulez”).
Ensuite, votre application web doit être configuré pour gérer la condition (et autorisé) certificat, carte à un utilisateur etc.

La légère différence que j'ai avec vous, c'est que je suis emballage de mon ressort de démarrage de l'application dans une GUERRE d'archive, qui est ensuite déployée sur un serveur d'application Tomcat.

Mon Tomcat server.xml fichier de configuration définit un connecteur HTTPS comme suit:

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
    maxThreads="150" SSLEnabled="true" scheme="https" secure="true"
    keystoreFile="/opt/tomcat/conf/key-stores/ssl-keystore.jks"
    keystorePass=“some-complex-password“
    clientAuth="want" sslProtocol="TLS"
    truststoreFile="/opt/tomcat/conf/trust-stores/ssl-truststore.jks"
    truststorePass=“some-other-complex-password” />

Petit commentaire pour éviter toute confusion: keystoreFile contient le certificat/clé privée de la paire de SSL (seulement), tandis que truststoreFile contient le permis de certificats d'autorité de certification pour le client, de l'authentification SSL (notez que vous pouvez également ajouter le certificat du client directement dans cette confiance-store).

Si vous utilisez un tomcat intégré contenant printemps de démarrage de l'application, vous devriez être en mesure de configurer ces paramètres dans votre application fichier de propriétés, en utilisant la propriété suivante clés/valeurs:

server.ssl.key-store=/opt/tomcat/conf/key-stores/ssl-keystore.jks
server.ssl.key-store-password=some-complex-password
server.ssl.trust-store=/opt/tomcat/conf/trust-stores/ssl-truststore.jks
server.ssl.trust-store-password=some-other-complex-password
server.ssl.client-auth=want

Puis, dans mon application web, je déclare un SSL configuration comme suit:

@Configuration
@EnableWebSecurity
//In order to use @PreAuthorise() annotations later on...
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SSLAuthConfiguration extends WebSecurityConfigurerAdapter {

    @Value("${allowed.user}")
    private String ALLOWED_USER;

    @Value("${server.ssl.client.regex}")
    private String CN_REGEX;

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure (final HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
                .authorizeRequests()
                .antMatchers("/url-path-to-protect").authenticated() //Specify the URL path(s) requiring authentication...
            .and()
                .x509() //... and that x509 authentication is enabled
                    .subjectPrincipalRegex(CN_REGEX)
                    .userDetailsService(userDetailsService);
    }

    @Autowired
    //Simplified case, where the application has only one user...
    public void configureGlobal (final AuthenticationManagerBuilder auth) throws Exception {
        //... whose username is defined in the application's properties.
        auth
            .inMemoryAuthentication()
                .withUser(ALLOWED_USER).password("").roles("SSL_USER");
    }

}

Que je puis avoir besoin de déclarer la UserDetailsService bean (par exemple, dans mon Application principale de la classe):

@Value("${allowed.user}")
private String ALLOWED_USER;

@Bean
public UserDetailsService userDetailsService () {

    return new UserDetailsService() {

        @Override
        public UserDetails loadUserByUsername(final String username) throws UsernameNotFoundException {
            if (username.equals(ALLOWED_USER)) {
                final User user = new User(username, "", AuthorityUtils.createAuthorityList("ROLE_SSL_USER"));
                return user;
            }
            return null;
        }
    };
}

Et c'est tout! Je peux alors ajouter @exiger une autorisation préalable(“hasRole(‘ROLE_SSL_USER’)”) des annotations pour les méthodes que je veux sécurisé.

Pour résumer un peu les choses, le flux d'authentification sera comme suit:

1. Utilisateur fournit un certificat SSL ;
2. Tomcat valide à l'encontre de sa confiance magasin ;
3. La coutume WebSecurityConfigurerAdapter récupère un “nom d'utilisateur” à partir de la CN du certificat ;
4. L'application authentifie l'utilisateur associé à l'extrait de nom d'utilisateur ;
5. Au niveau de la méthode, si annotée avec @exiger une autorisation préalable("hasRole('SSL_USER')"), l'application va vérifier si l'utilisateur a le rôle requis.

OriginalL'auteur veebee