HTTPS mit selbstsigniertem Zertifikat im Spring Boot

1. Überblick

In diesem Tutorial werden wir Schritt für Schritt ein Beispiel für die Aktivierung von HTTPS in einer Spring Boot-Anwendung veranschaulichen.

Wir generieren ein selbstsigniertes Zertifikat und konfigurieren es in einer Beispiel-App. Weitere Informationen zu Spring Boot-Projekten finden Sie in einer Reihe von Ressourcenhere.

Weitere Lektüre:

Automatische Konfiguration der Spring Boot-Sicherheit

Eine schnelle und praktische Anleitung zur Standardkonfiguration von Spring Boot für Spring Security.

Einführung in Java Config für Spring Security

Eine schnelle und praktische Anleitung zu Java Config für Spring Security

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 vonhere 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.

Mit dem folgenden Befehl können wir unser PKCS12-Keystore-Format generieren:

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

Wir können so viele Nummern von Schlüsselpaaren in demselben Schlüsselspeicher speichern, die jeweils durch einen eindeutigen Alias identifiziert werden.

Zum Generieren unseres Keystores im JKS-Format können wir den folgenden Befehl verwenden:

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

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

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

Wir müssen das Quell-Keystore-Passwort angeben und außerdem ein neues Keystore-Passwort festlegen. Das Alias- und das Keystore-Passwort werden später benötigt.

3. Aktivieren von HTTPS im Spring Boot

Spring Boot bietet eine Reihe von deklarativenserver.ssl.* properties.. Wir konfigurieren diese Eigenschaften in unserer Beispielanwendung, um HTTPS zu konfigurieren.

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

Wir kopieren die aus dem vorherigen Schritt generierte Datei mit dem Namen "example.p12″" in das Verzeichnis "src/main/resources/keystore".

3.1. SSL-Eigenschaften konfigurieren

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/example.p12
# The password used to generate the certificate
server.ssl.key-store-password=password
# The alias mapped to the certificate
server.ssl.key-alias=example

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

security.require-ssl=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.

Zunächst 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/example.p12
#trust store password
trust.store.password=password

Jetzt müssen wir einSSLContext mit dem Trust Store vorbereiten und ein benutzerdefiniertesRestTemplate: 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, dassSpring Security alle eingehenden Anforderungen zulässt:

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

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

@Test
public void whenGETanHTTPSResource_thenCorrectResponse() throws Exception {
    ResponseEntity response =
      restTemplate().getForEntity(WELCOME_URL, String.class, Collections.emptyMap());

    assertEquals("Welcome to Secured Site", response.getBody());
    assertEquals(HttpStatus.OK, response.getStatusCode());
}

5. Fazit

In diesem Tutorial haben wir gelernt, wie Sie ein selbstsigniertes Zertifikat erstellen, um HTTPS in einer Spring Boot-Anwendung zu aktivieren. Wir haben auch gelernt, wie ein HTTPS-fähiger Endpunkt aufgerufen wird.

Wie immer finden wir den vollständigen Quellcode überGitHub repository.

Um das Codebeispiel auszuführen, müssen Sie die folgende Eigenschaft der Startklasse inpom.xml auskommentieren:

org.example.ssl.HttpsEnabledApplication

TOC

HTTPS mit selbstsigniertem Zertifikat im Spring Boot