Bagaimana cara memanggil safe rest api menggunakan sertifikat & kata sandi .pfx di template spring boot rest? [Tutup]

Aug 15 2020

Saya perlu memanggil api istirahat aman eksternal (ssl diaktifkan) dari aplikasi boot musim semi saya. Api eksternal dapat diakses dari tukang pos menggunakan sertifikat & kata sandi .pfx. Sekarang saya ingin melakukan panggilan ke api eksternal menggunakan template rest dengan melampirkan file .pfx dan kata sandi pada setiap permintaan.

Saya tidak tahu bagaimana membuat panggilan template istirahat melalui ssl menggunakan sertifikat pfx. Bantuan apa pun akan dihargai.

Jawaban

2 Hakan54 Aug 15 2020 at 19:30

Yang perlu Anda lakukan adalah mengkonfigurasi klien http apache yang mendasari dari template lainnya. Di bawah ini adalah contoh konfigurasi:

SSLContext sslContext = ...;

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

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

RestTemplate restTemplate = new RestTemplate(requestFactory);

Ada beberapa pustaka yang menyediakan kelas utilitas / pabrik / pembangun yang mudah digunakan untuk membantu Anda membuat konteks SSLC.

  • Apache SSLContextBuilder
  • Jetty SslContextFactory
  • SSLContext-Kickstart

Mungkin ada banyak pustaka lain yang menyediakan fungsi serupa, tetapi saya hanya mengetahui ketiganya. Ngomong-ngomong, sslcontext-kickstart adalah pustaka yang saya kelola.

Di bawah ini adalah ikhtisar dari empat cara untuk memuat keystore dan membuat konteks SSLC. Vanilla Java dan dengan menggunakan tiga perpustakaan.

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

}