HTTPS mit selbstsigniertem Zertifikat im Spring Boot

1. Übersicht

In diesem Tutorial zeigen wir, wie HTTPS in Spring Boot aktiviert wird. Zu diesem Zweck generieren wir auch ein selbstsigniertes Zertifikat und konfigurieren eine einfache Anwendung.

Weitere Informationen zu Spring Boot-Projekten finden Sie hier.

2. Generieren eines selbstsignierten Zertifikats

Bevor wir beginnen, erstellen wir ein selbstsigniertes Zertifikat. Wir verwenden eines der folgenden Zertifikatformate:

  • PKCS12: Public Key Cryptographic Standards ist ein kennwortgeschütztes Format, das mehrere Zertifikate und Schlüssel enthalten kann. Es ist ein branchenweit verwendetes Format
  • JKS: Java KeyStore ähnelt PKCS12. Es ist ein proprietäres Format und auf die Java-Umgebung beschränkt.

Wir können entweder Keytool- oder OpenSSL-Tools verwenden, um die Zertifikate über die Befehlszeile zu generieren. Keytool wird mit Java Runtime Environment ausgeliefert und OpenSSL kann von hier heruntergeladen werden.

Verwenden wir Keytool für unsere Demonstration.

2.1. Generieren eines Keystores

Jetzt erstellen wir einen Satz kryptografischer Schlüssel und speichern ihn in einem Schlüsselspeicher.

Wir können den folgenden Befehl verwenden, um unser PKCS12-Keystore-Format zu generieren:

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

Wir können so viele Schlüsselpaare im selben Schlüsselspeicher speichern, die jeweils durch einen eindeutigen Alias ​​gekennzeichnet sind.

Zum Generieren unseres Schlüsselspeichers in einem JKS-Format können wir den folgenden Befehl verwenden:

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

Es wird empfohlen, das PKCS12-Format zu verwenden, das ein Industriestandardformat ist. Falls wir bereits einen JKS-Keystore haben, können wir ihn mit dem folgenden Befehl in das PKCS12-Format konvertieren:

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

Wir müssen das Quell-Keystore-Passwort angeben und auch ein neues Keystore-Passwort festlegen. Der Alias ​​und das Keystore-Passwort werden später benötigt.

3. Aktivieren von HTTPS im Spring Boot

Spring Boot bietet eine Reihe deklarativer server.ssl. * -Eigenschaften. Wir werden diese Eigenschaften in unserer Beispielanwendung verwenden, um HTTPS zu konfigurieren.

Wir beginnen mit einer einfachen Spring Boot-Anwendung mit Spring Security, die eine Begrüßungsseite enthält, die vom Endpunkt " / welcome " verwaltet wird.

Anschließend kopieren wir die im vorherigen Schritt generierte Datei mit dem Namen " baeldung.p12" in das Verzeichnis " src / main / resources / keystore ".

3.1. Konfigurieren von SSL-Eigenschaften

Jetzt konfigurieren wir die SSL-bezogenen Eigenschaften:

# 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

Da wir eine Spring Security-fähige Anwendung verwenden, konfigurieren wir sie so, dass nur HTTPS-Anforderungen akzeptiert werden:

server.ssl.enabled=true

4. Aufrufen einer HTTPS-URL

Nachdem wir HTTPS in unserer Anwendung aktiviert haben, gehen wir zum Client über und untersuchen, wie ein HTTPS-Endpunkt mit dem selbstsignierten Zertifikat aufgerufen wird.

Zuerst müssen wir einen Trust Store erstellen. Da wir eine PKCS12-Datei generiert haben, können wir dieselbe wie den Trust Store verwenden. Definieren wir neue Eigenschaften für die Trust Store-Details:

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

Jetzt müssen wir einen SSLContext mit dem Trust Store vorbereiten und eine angepasste RestTemplate erstellen :

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

Stellen Sie für die Demo sicher, dass Spring Security eingehende Anforderungen zulässt:

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

Schließlich können wir den HTTPS-Endpunkt aufrufen:

@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. Schlussfolgerung

Im Tutorial haben wir zunächst gelernt, wie Sie ein selbstsigniertes Zertifikat generieren, um HTTPS in einer Spring Boot-Anwendung zu aktivieren. Darüber hinaus haben wir gezeigt, wie ein HTTPS-fähiger Endpunkt aufgerufen wird.

Wie immer finden wir den vollständigen Quellcode im GitHub-Repository.

Um das Codebeispiel auszuführen, müssen Sie die folgende Eigenschaft der Startklasse in der Datei pom.xml entfernen :

com.baeldung.ssl.HttpsEnabledApplication