Wie rufe ich eine gesicherte Rest-API mit dem PFX-Zertifikat und dem Passwort in der Spring Boot Rest-Vorlage auf? [geschlossen]

Aug 15 2020

Ich muss eine externe gesicherte Rest-API (ssl aktiviert) aus meiner Spring-Boot-Anwendung aufrufen. Auf die externe API kann vom Postboten über das PFX-Zertifikat und das Kennwort zugegriffen werden. Jetzt möchte ich die externe API mithilfe der Restvorlage aufrufen, indem ich bei jeder Anforderung eine PFX-Datei und ein Kennwort anhänge.

Ich weiß nicht, wie ich mit dem pfx-Zertifikat einen Rest Template-Aufruf über ssl durchführen soll. Jede Hilfe wird geschätzt.

Antworten

2 Hakan54 Aug 15 2020 at 19:30

Sie müssen lediglich den zugrunde liegenden Apache-HTTP-Client der Restvorlage konfigurieren. Unten finden Sie eine Beispielkonfiguration:

SSLContext sslContext = ...;

HttpClient httpClient = HttpClients.custom()
    .setSSLContext(sslContext)
    .build();

HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
requestFactory.setHttpClient(httpClient);

RestTemplate restTemplate = new RestTemplate(requestFactory);

Es gibt einige Bibliotheken, die benutzerfreundliche Utility- / Factory- / Builder-Klassen bereitstellen, mit denen Sie einen SSLContext erstellen können.

  • Apache SSLContextBuilder
  • Anlegestelle SslContextFactory
  • SSLContext-Kickstart

Es könnte eine Reihe anderer Bibliotheken geben, die ähnliche Funktionen bieten, aber mir sind nur diese drei bekannt. Der sslcontext-kickstart ist übrigens eine Bibliothek, die von mir gepflegt wird.

Im Folgenden finden Sie eine Übersicht über vier Möglichkeiten zum Laden der Schlüsselspeicher und zum Erstellen eines SSLContext. Vanilla Java und unter Verwendung der drei Bibliotheken.

import io.netty.handler.ssl.SslContextBuilder;
import nl.altindag.ssl.SSLFactory;
import org.apache.http.ssl.SSLContextBuilder;
import org.eclipse.jetty.util.ssl.SslContextFactory;

import javax.net.ssl.*;
import java.io.File;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.SecureRandom;
import java.util.Objects;

class SslExample {

    public static void main(String[] args) throws Exception {

        //creating sslContext with sslcontext-kickstart
        SSLFactory sslFactory = SSLFactory.builder()
                .withIdentityMaterial("keystore.pfx", "secret".toCharArray())
                .withTrustMaterial("truststore.pfx", "secret".toCharArray())
                .build();

        SSLContext sslContext = sslFactory.getSslContext();

        //Traditional flow of creating sslContext
        String keyStorePath = "keystore.pfx";
        String trustStorePath = "truststore.pfx";

        char[] keyStorePassword = "secret".toCharArray();
        char[] trustStorePassword = "secret".toCharArray();

        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        KeyStore trustStore = KeyStore.getInstance("PKCS12");

        try(InputStream keyStoreInputStream = SslExample.class.getClassLoader().getResourceAsStream(keyStorePath);
            InputStream trustStoreInputStream = SslExample.class.getClassLoader().getResourceAsStream(trustStorePath)) {

            Objects.requireNonNull(keyStoreInputStream);
            Objects.requireNonNull(trustStoreInputStream);

            keyStore.load(keyStoreInputStream, keyStorePassword);
            trustStore.load(trustStoreInputStream, trustStorePassword);
        }

        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, keyStorePassword);
        KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();

        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(trustStore);
        TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();

        SSLContext sslContext1 = SSLContext.getInstance("TLSv1.2");
        sslContext.init(keyManagers, trustManagers, new SecureRandom());

        //creating sslContext with Apache SSLContextBuilder
        SSLContext sslContext2 = SSLContextBuilder.create()
                .loadKeyMaterial(new File("keystore.pfx"), "secret".toCharArray(), "secret".toCharArray())
                .loadTrustMaterial(new File("truststore.pfx"), "secret".toCharArray())
                .build();

        //creating sslContext with Jetty SslContextFactory
        SslContextFactory.Client sslContextFactory = new SslContextFactory.Client();
        sslContextFactory.setKeyStorePath("keystore.pfx");
        sslContextFactory.setKeyStorePassword("secret");
        sslContextFactory.setTrustStorePath("truststore.pfx");
        sslContextFactory.setTrustStorePassword("secret");
        sslContextFactory.start();

        SSLContext sslContext3 = sslContextFactory.getSslContext();
    }

}