HTTPS met zelfondertekend certificaat in Spring Boot

1. Overzicht

In deze zelfstudie laten we zien hoe u HTTPS in Spring Boot inschakelt. Voor dit doel genereren we ook een zelfondertekend certificaat en configureren we een eenvoudige applicatie.

Voor meer details over Spring Boot-projecten kunnen we hier een heleboel bronnen raadplegen.

2. Een zelfondertekend certificaat genereren

Voordat we aan de slag gaan, maken we een zelfondertekend certificaat. We gebruiken een van de volgende certificaatindelingen:

  • PKCS12: Public Key Cryptographic Standards is een met een wachtwoord beveiligd formaat dat meerdere certificaten en sleutels kan bevatten; het is een industriebreed gebruikt formaat
  • JKS: Java KeyStore is vergelijkbaar met PKCS12; het is een eigen formaat en is beperkt tot de Java-omgeving.

We kunnen zowel keytool als OpenSSL-tools gebruiken om de certificaten vanaf de opdrachtregel te genereren. Keytool wordt geleverd met Java Runtime Environment en OpenSSL kan vanaf hier worden gedownload.

Laten we keytool gebruiken voor onze demonstratie.

2.1. Een keystore genereren

Nu gaan we een set cryptografische sleutels maken en deze opslaan in een keystore.

We kunnen de volgende opdracht gebruiken om ons PKCS12-sleutelarchiefformaat te genereren:

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

We kunnen zoveel mogelijk nummers van sleutelparen in dezelfde sleutelopslag opslaan, elk geïdentificeerd door een unieke alias.

Voor het genereren van onze keystore in een JKS-indeling kunnen we de volgende opdracht gebruiken:

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

Het wordt aanbevolen om het PKCS12-formaat te gebruiken, dat een industriestandaardformaat is. Dus als we al een JKS-keystore hebben, kunnen we deze converteren naar PKCS12-indeling met behulp van de volgende opdracht:

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

We moeten het bronsleutelarchiefwachtwoord opgeven en ook een nieuw sleutelarchiefwachtwoord instellen. De alias en het keystore-wachtwoord zijn later nodig.

3. HTTPS inschakelen in Spring Boot

Spring Boot biedt een set van een declaratief server.ssl. * eigenschappen. We gebruiken die eigenschappen in onze voorbeeldtoepassing om HTTPS te configureren.

We beginnen met een eenvoudige Spring Boot-applicatie met Spring Security die een welkomstpagina bevat die wordt afgehandeld door de "/Welkom”Eindpunt.

Vervolgens kopiëren we het bestand met de naam 'baeldung.p12 ″ gegenereerd in de vorige stap naar de "src / main / resources / keystore”Directory.

3.1. SSL-eigenschappen configureren

Nu gaan we de SSL-gerelateerde eigenschappen configureren:

# Het formaat dat wordt gebruikt voor de keystore. Het kan worden ingesteld op JKS in het geval dat het een JKS-bestandsserver is. Sssl.key-store-type = PKCS12 # Het pad naar de keystore met het certificaat server.ssl.key-store = classpath: keystore / baeldung.p12 # De wachtwoord dat wordt gebruikt om het certificaat te genereren server.ssl.key-store-password = wachtwoord # De alias toegewezen aan het certificaat server.ssl.key-alias = baeldung

Omdat we een Spring Security-geactiveerde applicatie gebruiken, laten we deze configureren om alleen HTTPS-verzoeken te accepteren:

server.ssl.enabled = waar

4. Een HTTPS-URL aanroepen

Nu we HTTPS in onze applicatie hebben ingeschakeld, gaan we verder met de client en gaan we kijken hoe we een HTTPS-eindpunt kunnen aanroepen met het zelfondertekende certificaat.

Eerst moeten we een truststore maken. Omdat we een PKCS12-bestand hebben gegenereerd, kunnen we hetzelfde gebruiken als de trust store. Laten we nieuwe eigenschappen definiëren voor de details van de trust store:

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

Nu moeten we een SSLContext met de trust store en maak een aangepast RestTemplate:

RestTemplate restTemplate () genereert uitzondering {SSLContext sslContext = nieuwe SSLContextBuilder () .loadTrustMaterial (trustStore.getURL (), trustStorePassword.toCharArray ()) .build (); SSLConnectionSocketFactory socketFactory = nieuwe SSLConnectionSocketFactory (sslContext); HttpClient httpClient = HttpClients.custom () .setSSLSocketFactory (socketFactory) .build (); HttpComponentsClientHttpRequestFactory factory = nieuwe HttpComponentsClientHttpRequestFactory (httpClient); retourneer nieuwe RestTemplate (fabriek); }

Laten we er omwille van de demo voor zorgen Lente beveiliging staat alle inkomende verzoeken toe:

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

Ten slotte kunnen we een oproep doen naar het HTTPS-eindpunt:

@Test openbare leegte whenGETanHTTPSResource_thenCorrectResponse () gooit uitzondering {ResponseEntity response = restTemplate (). GetForEntity (WELCOME_URL, String.class, Collections.emptyMap ()); assertEquals ("", response.getBody ()); assertEquals (HttpStatus.OK, response.getStatusCode ()); }

5. Conclusie

In de zelfstudie hebben we eerst geleerd hoe we een zelfondertekend certificaat kunnen genereren om HTTPS in een Spring Boot-applicatie in te schakelen. Bovendien hebben we laten zien hoe u een HTTPS-eindpunt aanroept.

Zoals altijd kunnen we de volledige broncode vinden op de GitHub-repository.

Om het codevoorbeeld uit te voeren, moeten we ten slotte de opmerking van de volgende startklasse-eigenschap in het pom.xml:

com.baeldung.ssl.HttpsEnabledApplication