Was ist ein Beispiel für Zwei-Wege-SSL-Java?
Secure Sockets Layer (SSL) ist eine Standardsicherheitstechnologie zur Herstellung einer verschlüsselten Verbindung zwischen einem Server und einem Client. Sie wird häufig bei Transaktionen mit sensiblen oder persönlichen Daten wie Kreditkartennummern, Anmeldedaten und Sozialversicherungsnummern eingesetzt. Die Verschlüsselung kann in eine Richtung oder in beide Richtungen erfolgen - in eine Richtung oder in beide Richtungen. Bei einseitigem SSL bestätigt der Kunde die Identität des Servers, während die Identität des Kunden anonym bleibt. Bei Zwei-Wege-SSL, auch bekannt als gegenseitiges SSL, bestätigt der Kunde die Identität des Servers und der Server die Identität des Kunden.
Zwei-Wege-SSL beginnt mit einem "Hallo" vom Client zum Server. Der Server antwortet mit einem "Hallo", gepaart mit seinem öffentlichen Zertifikat. Der Client prüft das empfangene Zertifikat anhand der in den TrustStores des Clients gespeicherten Zertifikate. Wenn die Überprüfung des Server-Zertifikats erfolgreich ist, präsentiert der Client die in seinen KeyStores gespeicherten Zertifikate. Der Server validiert das empfangene Zertifikat anhand der TrustStores des Servers. Der Server entschlüsselt die Sitzungsschlüssel mit dem privaten Schlüssel des Servers, um eine sichere Verbindung herzustellen.
Java verwendet den Java Keystore (JKS), eine passwortgeschützte Datenbank für Zertifikate und Schlüssel. Jeder Eintrag muss durch einen eindeutigen Alias identifiziert werden. Keystore liefert Anmeldeinformationen.
Java verwendet auch den Truststore, der sich in $JAVA_HOME/lb/security/cacerts befindet. Er speichert vertrauenswürdige Einträge von Zertifizierungsstellen (CA) und selbstsignierte Zertifikate von vertrauenswürdigen Dritten. Truststore verifiziert Server-Identitäten.
Java bietet auch keytool, ein Befehlszeilentool zur Verwaltung des Keystore und des Truststore.
Sie können TrustStore mit folgendem Code ausführen. Ersetzen Sie $CERT_ALIAS und $CERT_PASSWORD durch Ihren Alias bzw. Ihr Passwort.
1) Wenn wir das Serverzertifikat nicht haben, verwenden wir openssl, um es abzurufen
echo -n | openssl s_client -connect SERVERDOMAIN:PORT -servername SERVERDOMAIN
-Schlüssel myclient.key -Zertifikat myclient.cert.pem
| sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p'
| tee "server.crt"
2) Erstellen Sie den Truststore aus dem Server-Zertifikat
keytool -import -alias $CERT_ALIAS -file server.crt -keystore truststore.jks -deststorepass $CERT_PASSWORT
Als nächstes erzeugen Sie den IdentityStore. Ersetzen Sie $CERT_ALIAS und $CERT_PASSWORD durch Ihren Alias bzw. Ihr Passwort.
1) Verketten Sie alle Zertifikate in eine PEM-Datei
cat intermediate.cert.pem myclient.cert.pem myclient.key > full-chain.keycert.pem
2) Erzeugen Sie den PKCS12-Keystore mit dem Alias der Server-URL
openssl pkcs12 -export -in full-chain.keycert.pem
-out full-chain.keycert.p12
-passwort env:$CERT_PASSWORT
-name $CERT_ALIAS
-noiter -nomaciter
3) Konvertieren von .p12 in .jks
keytool -importkeystore -srckeystore full-chain.keycert.p12
-srcstoretype pkcs12 -srcalias $CERT_ALIAS -srcstorepass $CERT_PASSWORT
-destkeystore identity.jks -deststoretype jks
-deststorepass $CERT_PASSWORD -destalias $CERT_ALIAS
Dieser Java-Code lädt Keystore und Truststore in einen benutzerdefinierten SSL-Kontext, erstellt eine SSLConnectionSocketFactory und bindet sie dann an einen HttpClient.
public class SSLMutualAuthTest {
publicSSLMutualAuthTest() {
// TODO Auto-generated constructor stub
}
public static void main (String[] args) {
System.out.println("MagicDude4Eva 2-way / mutual SSL-authentication test");
org.apache.log4j.BasicConfigurator.configure();
Logger.getRootLogger().setLevel(Level.INFO);
versuchen {
String CERT_ALIAS = "myalias", CERT_PASSWORD = "mypassword";
KeyStore identityKeyStore = KeyStore.getInstance("jks");
FileInputStream identityKeyStoreFile = new FileInputStream(new File("identity.jks"));
identityKeyStore.load(identityKeyStoreFile, CERT_PASSWORD.toCharArray());
KeyStore trustKeyStore = KeyStore.getInstance("jks");
FileInputStream trustKeyStoreFile = new FileInputStream(new File("truststore.jks"));
trustKeyStore.load(trustKeyStoreFile, CERT_PASSWORD.toCharArray());
SSLContext sslContext = SSLContexts.custom()
// load identity keystore
.loadKeyMaterial(identityKeyStore, CERT_PASSWORD.toCharArray(), new PrivateKeyStrategy() {
@Override
public String chooseAlias(Map<String, PrivateKeyDetails> aliases, Socket socket) {
return CERT_ALIAS;
}
})
// load trust keystore
.loadTrustMaterial(trustKeyStore, null)
.build();
SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext,
new String[]{"TLSv1.2", "TLSv1.1"},
Null,
SSLConnectionSocketFactory.getDefaultHostnameVerifier());
CloseableHttpClient client = HttpClients.custom()
.setSSLSocketFactory(sslConnectionSocketFactory)
.build();
// Call a SSL-endpoint
callEndPoint (client, "https://secure.server.com/endpoint",
neues JSONObject()
.put("param1", "wert1")
.put("param2", "wert2")
);
} catch (Exception ex) {
System.out.println("Boom, wir sind gescheitert: " + ex);
ex.printStackTrace();
}
}
private static void callEndPoint (CloseableHttpClient aHTTPClient, String aEndPointURL, JSONObject aPostParams) {
versuchen {
System.out.println("Aufruf der URL: " + aEndPointURL);
HttpPost post = new HttpPost(aEndPointURL);
post.setHeader("Accept", "application/json");
post.setHeader("Content-type", "application/json");
StringEntity entity = new StringEntity(aPostParams.toString());
post.setEntity(Entität);
System.out.println("**POST** Anfrage Url: " + post.getURI());
System.out.println("Parameter : " + aPostParams);
HttpResponse response = aHTTPClient.execute(post);
int responseCode = response.getStatusLine().getStatusCode();
System.out.println("Antwortcode: " + responseCode);
System.out.println("Inhalt:-n");
BufferedReader rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
String line = "";
while ((line = rd.readLine()) != null) {
System.out.println(Zeile);
}
} catch (Exception ex) {
System.out.println("Boom, wir sind gescheitert: " + ex);
ex.printStackTrace();
}
}
}
Natürlich gibt es eine weitaus einfachere Lösung für die Einrichtung einer zweiseitigen SSL-Authentifizierung. SnapLogic hat mehrere Snaps, die die Validierung und Authentifizierung von SSL-Zertifikaten unterstützen, einschließlich SOAP, Splunk und REST.
