HTTPS utilizzando il certificato autofirmato in Spring Boot

1. Panoramica

In questo tutorial, mostreremo come abilitare HTTPS in Spring Boot. A tale scopo, genereremo anche un certificato autofirmato e configureremo una semplice applicazione.

Per maggiori dettagli sui progetti Spring Boot, possiamo fare riferimento a una serie di risorse qui.

2. Generazione di un certificato autofirmato

Prima di iniziare, creeremo un certificato autofirmato. Useremo uno dei seguenti formati di certificato:

  • PKCS12: Public Key Cryptographic Standards è un formato protetto da password che può contenere più certificati e chiavi; è un formato utilizzato in tutto il settore
  • JKS: Java KeyStore è simile a PKCS12; è un formato proprietario ed è limitato all'ambiente Java.

Possiamo utilizzare uno degli strumenti keytool o OpenSSL per generare i certificati dalla riga di comando. Keytool viene fornito con Java Runtime Environment e OpenSSL può essere scaricato da qui.

Usiamo keytool per la nostra dimostrazione.

2.1. Generazione di un keystore

Ora creeremo un set di chiavi crittografiche e lo memorizzeremo in un keystore.

Possiamo usare il seguente comando per generare il nostro formato keystore PKCS12:

keytool -genkeypair -alias baeldung -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore baeldung.p12 -validity 3650

Possiamo memorizzare tanti numeri di coppie di chiavi nello stesso keystore, ognuno identificato da un alias univoco.

Per generare il nostro keystore in un formato JKS, possiamo utilizzare il seguente comando:

keytool -genkeypair -alias baeldung -keyalg RSA -keysize 2048 -keystore baeldung.jks -validity 3650

Si consiglia di utilizzare il formato PKCS12, che è un formato standard del settore. Quindi, nel caso in cui abbiamo già un keystore JKS, possiamo convertirlo nel formato PKCS12 utilizzando il seguente comando:

keytool -importkeystore -srckeystore baeldung.jks -destkeystore baeldung.p12 -deststoretype pkcs12

Dovremo fornire la password del keystore di origine e anche impostare una nuova password del keystore. L'alias e la password del keystore saranno necessari in seguito.

3. Abilitazione di HTTPS in Spring Boot

Spring Boot fornisce una serie di proprietà dichiarative server.ssl. *. Useremo queste proprietà nella nostra applicazione di esempio per configurare HTTPS.

Inizieremo da una semplice applicazione Spring Boot con Spring Security che contiene una pagina di benvenuto gestita dall'endpoint " / welcome ".

Quindi, copieremo il file denominato " baeldung.p12 ″ generato nel passaggio precedente nella directory " src / main / resources / keystore ".

3.1. Configurazione delle proprietà SSL

Ora configureremo le proprietà relative a SSL:

# The format used for the keystore. It could be set to JKS in case it is a JKS file server.ssl.key-store-type=PKCS12 # The path to the keystore containing the certificate server.ssl.key-store=classpath:keystore/baeldung.p12 # The password used to generate the certificate server.ssl.key-store-password=password # The alias mapped to the certificate server.ssl.key-alias=baeldung

Dato che stiamo utilizzando l'applicazione abilitata Spring Security, configuriamola per accettare solo le richieste HTTPS:

server.ssl.enabled=true

4. Invocare un URL HTTPS

Ora che abbiamo abilitato HTTPS nella nostra applicazione, passiamo al client ed esploriamo come richiamare un endpoint HTTPS con il certificato autofirmato.

Innanzitutto, dobbiamo creare un trust store. Poiché abbiamo generato un file PKCS12, possiamo utilizzare lo stesso del truststore. Definiamo nuove proprietà per i dettagli del truststore:

#trust store location trust.store=classpath:keystore/baeldung.p12 #trust store password trust.store.password=password

Ora dobbiamo preparare un SSLContext con il truststore e creare un RestTemplate personalizzato :

RestTemplate restTemplate() throws Exception { SSLContext sslContext = new SSLContextBuilder() .loadTrustMaterial(trustStore.getURL(), trustStorePassword.toCharArray()) .build(); SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext); HttpClient httpClient = HttpClients.custom() .setSSLSocketFactory(socketFactory) .build(); HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient); return new RestTemplate(factory); }

Per il bene della demo, assicuriamoci che Spring Security consenta tutte le richieste in arrivo:

protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/**") .permitAll(); }

Infine, possiamo effettuare una chiamata all'endpoint HTTPS:

@Test public void whenGETanHTTPSResource_thenCorrectResponse() throws Exception { ResponseEntity response = restTemplate().getForEntity(WELCOME_URL, String.class, Collections.emptyMap()); assertEquals("", response.getBody()); assertEquals(HttpStatus.OK, response.getStatusCode()); }

5. conclusione

Nel tutorial, abbiamo prima appreso come generare un certificato autofirmato per abilitare HTTPS in un'applicazione Spring Boot. Inoltre, abbiamo mostrato come richiamare un endpoint abilitato per HTTPS.

Come sempre, possiamo trovare il codice sorgente completo sul repository GitHub.

Infine, per eseguire l'esempio di codice, è necessario rimuovere il commento dalla seguente proprietà della classe iniziale nel pom.xml :

com.baeldung.ssl.HttpsEnabledApplication