Comment appeler l'API de repos sécurisé à l'aide du certificat et du mot de passe .pfx dans le modèle de repos de démarrage de printemps? [fermé]
Je dois appeler une API de repos sécurisée externe (ssl activé) à partir de mon application Spring Boot. L'API externe est accessible depuis Postman en utilisant le certificat et le mot de passe .pfx. Maintenant, je voudrais passer un appel à l'API externe en utilisant le modèle de repos en attachant le fichier .pfx et le mot de passe à chaque demande.
Je ne sais pas comment faire un appel de modèle de repos via SSL en utilisant un certificat pfx. Toute aide serait appréciée.
Réponses
Ce que vous devez faire est de configurer le client http apache sous-jacent du modèle rest. Voici un exemple de configuration:
SSLContext sslContext = ...;
HttpClient httpClient = HttpClients.custom()
.setSSLContext(sslContext)
.build();
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
requestFactory.setHttpClient(httpClient);
RestTemplate restTemplate = new RestTemplate(requestFactory);
Il existe quelques bibliothèques qui fournissent des classes utilitaires / usine / constructeur faciles à utiliser pour vous aider à créer un SSLContext.
- Apache SSLContextBuilder
- Jetée SslContextFactory
- SSLContext-Kickstart
Il pourrait y avoir un tas d'autres bibliothèques qui fournissent des fonctionnalités similaires, mais je ne connais que ces trois. Au fait, sslcontext-kickstart est une bibliothèque qui est maintenue par moi.
Vous trouverez ci-dessous un aperçu de quatre façons de charger les fichiers de clés et de créer un SSLContext. Vanilla Java et en utilisant les trois bibliothèques.
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();
}
}