Umsetzung von 2-Wege-SSL-mit spring boot

Stieß ich auf ein ähnliches problem, und dachte, ich würde teilen die Lösung, die ich kam mit.

Zuerst müssen Sie verstehen, dass das SSL-Zertifikat wird für die Authentifizierung behandelt werden, die auf Ihren web-server die Seite (cfr. dur die Erklärung, mit der "clientAuth=wollen" - Einstellung).
Dann, Ihre web-app muss konfiguriert werden, um die bereitgestellten (und zulässig) Zertifikat anzeigen an einen Benutzer usw.

Dem leichten Unterschied, den ich mit Euch habe, ist, dass ich die Verpackung meiner spring-boot-Anwendung in ein KRIEGS-Archiv, das ist dann bereitgestellt, die auf einem vorhandenen Tomcat application server.

Mein Tomcat server.xml Konfigurations-Datei definiert, eine HTTPS-connector wie folgt:

<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” />

Kleine Anmerkung um Verwirrung zu vermeiden: Attribute keystoreFile enthält das Zertifikat/private key pair verwendet für SSL (nur), während truststoreFile enthält die erlaubten CA-Zertifikate für SSL-client-Authentifizierung (Hinweis: Sie können auch fügen Sie die client Zertifikate direkt in das trust-store).

Wenn Sie über einen embedded tomcat-container mit spring-boot-Anwendung, sollten Sie in der Lage sein, um diese Einstellungen zu konfigurieren, die in Ihrer Anwendung-Eigenschaften-Datei, mit der folgenden Eigenschaft-Schlüssel/- Werte:

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

Dann, auf meiner web-app, ich erkläre ein bestimmtes SSL-Konfiguration wie folgt:

@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");
    }

}

Ich dann erklären müssen das UserDetailsService bean (z.B. in meiner Anwendung die main-Klasse):

@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;
        }
    };
}

... Und das ist es! Ich kann dann fügen Sie @PreAuthorize("hasRole('ROLE_SSL_USER')") Anmerkungen zu den Methoden, die ich sichern will.

Summe die Dinge ein wenig, die Authentifizierung wie folgt:

1. Benutzer SSL-Zertifikat,
2. Tomcat überprüft für Ihr Vertrauen-store ;
3. Die benutzerdefinierte WebSecurityConfigurerAdapter ruft einen "Benutzernamen" aus dem Zertifikat-CN ;
4. Die Anwendung authentifiziert den Benutzer verbunden, um die abgerufene Benutzername ;
5. Auf methodenebene, wenn annotiert mit @PreAuthorize("hasRole('SSL_USER')"), wird die Anwendung überprüfen, ob der Benutzer die gewünschte Rolle.