Uwierzytelnianie certyfikatu klienta Java HTTPS

Inne odpowiedzi pokazują, jak globalnie konfigurować certyfikaty klientów. Jeśli jednak chcesz programowo zdefiniować klucz klienta dla jednego konkretnego połączenia, zamiast definiować go globalnie dla każdej aplikacji uruchomionej na Twoim JVM, możesz skonfigurować swój własny SSLContext w następujący sposób:

String keyPassphrase = "";

KeyStore keyStore = KeyStore.getInstance("PKCS12");
keyStore.load(new FileInputStream("cert-key-pair.pfx"), keyPassphrase.toCharArray());

SSLContext sslContext = SSLContexts.custom()
        .loadKeyMaterial(keyStore, null)
        .build();

HttpClient httpClient = HttpClients.custom().setSSLContext(sslContext).build();
HttpResponse response = httpClient.execute(new HttpGet("https://example.com"));

Plik JKS jest tylko kontenerem dla certyfikatów i par kluczy. W scenariuszu uwierzytelniania po stronie klienta, różne części kluczy będą znajdować się tutaj:

• sklep client będzie zawierał parę kluczy klienta private i public . To się nazywa keystore.
• sklep serwera będzie zawierał klucz klienta public. Nazywa się to truststore .

Rozdzielenie truststore i keystore nie jest obowiązkowe, ale zalecane. Mogą być tym samym plikiem fizycznym.

Aby ustawić lokalizacje systemu plików obu sklepów, użyj następujących właściwości systemu:

-Djavax.net.ssl.keyStore=clientsidestore.jks

I na serwerze:

-Djavax.net.ssl.trustStore=serversidestore.jks

Aby wyeksportować certyfikat klienta (klucz publiczny) do pliku, dzięki czemu można go skopiować na serwer, użyj

keytool -export -alias MYKEY -file publicclientkey.cer -store clientsidestore.jks

Aby zaimportować klucz publiczny klienta do magazynu kluczy serwera, użyj (jak wspomniano na plakacie, zostało to już zrobione przez administratorów serwera)

keytool -import -file publicclientkey.cer -store serversidestore.jks

Maven pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>some.examples</groupId>
    <artifactId>sslcliauth</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>sslcliauth</name>
    <dependencies>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.4</version>
        </dependency>
    </dependencies>
</project>

Kod Javy:

package some.examples;

import java.io.FileInputStream;
import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLContext;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.apache.http.entity.InputStreamEntity;

public class SSLCliAuthExample {

private static final Logger LOG = Logger.getLogger(SSLCliAuthExample.class.getName());

private static final String CA_KEYSTORE_TYPE = KeyStore.getDefaultType(); //"JKS";
private static final String CA_KEYSTORE_PATH = "./cacert.jks";
private static final String CA_KEYSTORE_PASS = "changeit";

private static final String CLIENT_KEYSTORE_TYPE = "PKCS12";
private static final String CLIENT_KEYSTORE_PATH = "./client.p12";
private static final String CLIENT_KEYSTORE_PASS = "changeit";

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

public final static void requestTimestamp() throws Exception {
    SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(
            createSslCustomContext(),
            new String[]{"TLSv1"}, // Allow TLSv1 protocol only
            null,
            SSLConnectionSocketFactory.getDefaultHostnameVerifier());
    try (CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(csf).build()) {
        HttpPost req = new HttpPost("https://changeit.com/changeit");
        req.setConfig(configureRequest());
        HttpEntity ent = new InputStreamEntity(new FileInputStream("./bytes.bin"));
        req.setEntity(ent);
        try (CloseableHttpResponse response = httpclient.execute(req)) {
            HttpEntity entity = response.getEntity();
            LOG.log(Level.INFO, "*** Reponse status: {0}", response.getStatusLine());
            EntityUtils.consume(entity);
            LOG.log(Level.INFO, "*** Response entity: {0}", entity.toString());
        }
    }
}

public static RequestConfig configureRequest() {
    HttpHost proxy = new HttpHost("changeit.local", 8080, "http");
    RequestConfig config = RequestConfig.custom()
            .setProxy(proxy)
            .build();
    return config;
}

public static SSLContext createSslCustomContext() throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException, KeyManagementException, UnrecoverableKeyException {
    // Trusted CA keystore
    KeyStore tks = KeyStore.getInstance(CA_KEYSTORE_TYPE);
    tks.load(new FileInputStream(CA_KEYSTORE_PATH), CA_KEYSTORE_PASS.toCharArray());

    // Client keystore
    KeyStore cks = KeyStore.getInstance(CLIENT_KEYSTORE_TYPE);
    cks.load(new FileInputStream(CLIENT_KEYSTORE_PATH), CLIENT_KEYSTORE_PASS.toCharArray());

    SSLContext sslcontext = SSLContexts.custom()
            //.loadTrustMaterial(tks, new TrustSelfSignedStrategy()) // use it to customize
            .loadKeyMaterial(cks, CLIENT_KEYSTORE_PASS.toCharArray()) // load client certificate
            .build();
    return sslcontext;
}

}

Dla tych z Was, którzy po prostu chcą skonfigurować uwierzytelnianie dwukierunkowe( certyfikaty serwera i klienta), połączenie tych dwóch łączy zapewni Ci dostęp do tego miejsca:

Dwukierunkowa konfiguracja auth:

Https://linuxconfig.org/apache-web-server-ssl-authentication

Nie musisz używać pliku konfiguracyjnego openssl, o którym wspominają; po prostu użyj

• $ openssl genrsa-des3-out ca.klucz 4096

• $ openssl req-new-x509-days 365 - klucz ca.key-out ca.crt

Aby wygenerować własny certyfikat CA, a następnie wygenerować i podpisać klucze serwera i klienta poprzez:

• $ OpenSSL genrsa-des3-serwer out.klucz 4096

• $ OpenSSL REQ-new-key client.serwer key-out.csr

• $ OpenSSL x509-REQ-days 365-in server.csr-CA ca.crt-CAkey ca.key-set_serial 100-out server.crt

I

• $ OpenSSL genrsa-des3-out client.klucz 4096

• $ OpenSSL REQ-new-key client.kluczowy klient.csr

• $ openssl x509-req-days 365-in client.csr-CA ca.crt-CAkey ca.key-set_serial 101-out client.crt

Dla reszty wykonaj kroki w linku. Zarządzanie certyfikatami dla Chrome działa tak samo jak w przykładzie dla Firefoksa, o którym mowa.

Następnie skonfiguruj serwer poprzez:

Https://www.digitalocean.com/community/tutorials/how-to-create-a-ssl-certificate-on-apache-for-ubuntu-14-04

Zauważ, że masz już utworzony serwer .crt i .klucz, więc nie musisz już robić tego kroku.

Wydaje mi się, że poprawką był Typ keystore, pkcs12(pfx) zawsze ma klucz prywatny, A Typ JKS może istnieć bez klucza prywatnego. O ile nie określisz w kodzie lub nie wybierzesz certyfikatu przez przeglądarkę, serwer nie ma możliwości poznania, że reprezentuje klienta po drugiej stronie.