Dieser Artikel beschreibt die Methode zur Implementierung der SSL-Zwei-Wege-Authentifizierung in Java. Teilen Sie es für Ihre Referenz wie folgt weiter:
Die gemeinsame SSL -Überprüfung ist häufiger. Überprüfen Sie nur, ob unser Server wahr oder korrekt ist. Wenn die URL, die Sie besuchen, überhaupt falsch ist, kann es natürlich niemand tun. Dies wird als SSL-Einwegauthentifizierung bezeichnet.
In Wirklichkeit können wir jedoch auch überprüfen, ob der Kunde die Anforderungen erfüllt, dh an jedem unserer Benutzer ein Zertifikat ausgibt, und jedes digitale Zertifikat ist eindeutig und nicht öffentlich. Auf diese Weise können Sie sicherstellen, dass der Benutzer, der derzeit auf meinen Server zugreift, vom Server erkannt wird und von anderen nicht zugegriffen werden kann.
Die Zwei-Wege-Authentifizierung stellt sicher, dass sowohl der Server als auch der Client sich auf der ersten Ebene erkennen. Wenn sie dann kommunizieren möchten, werden dem Kommunikationsprotokoll ein SSL -Protokoll angeschlossen, um sicherzustellen, dass der Inhalt der Kommunikation verschlüsselt wird. Sogar Netzwerk -Sniffer -Tools wie Sniffer sehen verstümmelten Code. In Zukunft werde ich Ihnen demonstrieren, was Sie mit Sniffer ohne Verschlüsselung sehen. Ich fürchte, Sie werden auf diese Weise wachsamer sein.
Der folgende Inhalt wird aus dem Internet ausgewählt und nach der tatsächlichen Überprüfung geändert.
Simulationsszenario:
Wenn die Serverseite mit der Client -Seite kommuniziert, sind die Autorisierungs- und Identitätsprüfung erforderlich, dh der Client kann nur Nachrichten vom Server akzeptieren und der Server kann nur Nachrichten vom Client akzeptieren.
Implementierungstechnologie:
JSSE (Java Security Socket -Erweiterung)
Es handelt sich um eine von Sun gestartete Lösung, um sichere Kommunikation im Internet zu lösen. Es implementiert SSL- und TSL -Protokolle (Transport Layer Security). Die JSSE enthält Technologien wie Datenverschlüsselung, Serverüberprüfung, Nachrichtenintegrität und Clientüberprüfung. Durch die Verwendung von JSSE können Entwickler Daten zwischen dem Client und dem Server über das TCP/IP -Protokoll sicher übertragen.
Um die Nachrichtenauthentifizierung zu implementieren.
Server erfordert:
1) Keystore: Wenn der private Schlüssel des Servers gespeichert wird
2) Vertrauenswürdigkeit Keystore: Es speichert das Autorisierungszertifikat des Kunden
In ähnlicher Weise erfordert der Kunde:
1) Keystore: Wenn der private Schlüssel des Kunden gespeichert wird
2) Vertrauen Sie Keystore: Hier empfehle ich den Befehl keytool, der mit Java geliefert wird, um solche Informationsdateien zu generieren. OpenSSL ist natürlich auch die beliebteste Open -Source -SSL -Zertifikaterzeugung. OpenSSL ist in C-Sprache, Cross-System. Wir können jedoch die Bequemlichkeit in Betracht ziehen, Java -Programme zu verwenden, um in Zukunft Zertifikate zu generieren und die mit JDK gelieferte Keytool zu verwenden.
1) Generieren Sie den privaten Taste Server und importieren Sie ihn in die Keystore -Datei Server
keytool -genkey -alias serverkey -keystore kServer.KeyStore
Während des Vorgangs müssen Sie es separat ausfüllen und nach Ihren Anforderungen einrichten.
Keystore -Passwort: 123456
Erster und Nachname: Jin
Name der Organisationseinheit: Keine
Organisationsname: Keine
Stadt- oder Regionenname: BJ
Staats- oder Provinzname: BJ
Ländercode: CN
Das Kennwort des privaten Tastens Serverkey ist nicht das gleiche wie das Kennwort des Keystore. Achten Sie hier unbedingt, drücken Sie einfach die Eingabetaste, ohne Ihr Passwort zu ändern. Andernfalls wird ein Fehler gemeldet, wenn dieser private Schlüssel nicht direkt im nachfolgenden Programm angewendet werden kann.
Sie können die Datei kServer.keyStore generieren
Server.KeyStore wird für den Server verwendet, der seinen eigenen privaten Schlüssel speichert.
2) Exportieren Sie das Serverzertifikat basierend auf dem privaten Schlüssel
keytool -export -alias serverkey -keystore kServer.keystore -file server.crt
server.crt ist das Zertifikat auf der Serverseite
3) Importieren Sie das Serverzertifikat in den Trust -Keystore des Clients
keytool -import -alias serverkey -file server.crt -keystore tclient.KeyStore
Tclient.KeyStore ist für Kunden und es ist ein vertrauenswürdiges Zertifikat.
Generieren Sie auf die gleiche Weise den privaten Schlüssel- und das Client -Zertifikat des Kunden und importieren Sie es in den Trust -Keystore des Servers
1) Keytool -genkey -alias clientkey -keystore kclient.KeyStore
2) KeyTool -export -alias ClientKey -keystore Kclient.KeyStore -file Client.crt
3) KeyTool -import -alias ClientKey -Datei Client.crt -keystore Tserver.KeyStore
Auf diese Weise sind die generierten Dateien in zwei Gruppen unterteilt
Server speichern: KSERVER.KeyStore Tserver.KeyStore
Client Save: kclient.keystore tclient.kystore
Das Folgende ist zu überprüfen, ob das von uns generierte Zertifikat über das Java -Socket -Kommunikationsprogramm verfügbar ist.
Kunde:
Paketbeispiele.SSL; Import Java.io.BufferedInputStream; Import Java.io.BuffenedOutputStream; Import Java.io.FileInputStream; Import Java.io.ioException; importieren Java.io.inputstream; Importputstream. javax.net.ssl.keyManagerFactory; importieren javax.net.ssl.sslcontext; import Javax.net.ssl.sslsocket; import javax.net.ssl.trustmanagerFactory;/** * SSL Client private statische endgültige int default_port = 7777; private statische endgültige Zeichenfolge client_key_store_password = "123456"; private statische endgültige Zeichenfolge client_trust_key_store_password = "123456"; privates SSLSocket SSLSocket; / ** * Starten Sie das Client -Programm * * @param args */ public static void main (string [] args) {sslclient client = new SSLCLIENT (); Client.init (); Client.Process (); } / *** Stellen Sie über den SSL -Socket eine Verbindung zum Server her und senden Sie eine Nachricht* / public void process () {if (SSLSocket == null) {System.out.println ("Fehler"); zurückkehren; } try {inputStream input = sslsocket.getInputStream (); OutputStream output = sslsocket.getOutputStream (); BufferedInputStream bis = neuer bufferedInputStream (Eingabe); BufferedOutputStream bos = neuer bufferedOutputStream (Ausgabe); bos.write ("client meldung" .getBytes ()); bos.flush (); byte [] buffer = neues byte [20]; Bis.read (Puffer); System.out.println (neuer String (Puffer)); sslsocket.close (); } catch (ioException e) {System.out.println (e); }}/** * <ul> * <li> Die Schlüsselpunkte der SSL -Verbindung: </li> * <li> Initialisieren von SSLSocket </li> * <li> Importieren Sie den Client -KeyStore, den Client Trusted Keystore (Server -Zertifikat) </li> * </ul> */public void init () {try {try {try {sslcontext ctx SSLContext.getInstance ("SSL"); KeyManagerFactory kmf = keyManagerFactory.getInstance ("sunx509"); TrustManagerFactory tmf = trustManagerFactory.getInstance ("sunx509"); Keystore ks = keystore.getInstance ("jks"); Keystore tks = keystore.getInstance ("jks"); Ks.load (neuer FileInputStream ("e: //kclient.keyStore"), client_key_store_password.toCharArray ()); tks.load (neuer FileInputStream ("e: //tclient.keyStore"), client_trust_key_store_password.toCharArray ()); kmf.init (ks, client_key_store_password.toarArray ()); tmf.init (tks); ctx.init (kmf.getKeyManagers (), tmf.getTrustmanagers (), null); SSLSOCKET = (SSLSOCKET) ctx.getSocketFactory (). CreateSocket (default_host, default_port); } catch (Ausnahme e) {System.out.println (e); }}}Serverseite:
Paketbeispiele.SSL; Import Java.io.BuffenedInputStream; Import Java.io.BuffeDeredOutputStream; Import Java.io.FileInputStream; Import Java.io.inputStream; Import Java.io.IO.OutputStream; Imporation Java.net. javax.net.sl.keyManagerFactory; importieren javax.net.ssl.sslcontext; importieren javax.net.ssl.slServersocket; importieren javax.net.ssl.trustmanagerFactory;/************ ************** ************** ************** ************** ************** ************** ********************************************************************************************************************************************************************************************* Serverkey -keyStore KSERVER.KeyStore -File Server.crt </li> * <li> 3) Fügen Sie das Zertifikat dem vertrauenswürdigen Keystore des Clients hinzu ********** ********** ********** ********** ********** ********** ********** ******* Server * */öffentliche Klasse SSLSERVER {private statische endgültige int default_port = 7777; private statische endgültige String Server_key_store_password = "123456"; private statische endgültige String server_trust_key_store_password = "123456"; private sslServersocket ServerSocket; / ** * das Programm starten * * @param args */ public static void main (String [] args) {sslServer server = new SSLServer (); server.init (); server.start (); }/** * <ul> * <li> Hören Sie sich den SSL-Server-Socket an </li> * <li> Da dieses Programm keine Demonstration des Socket-Hörens ist, wird einfach eine einzel-thread-Form angewendet und nur die Nachrichten des Clients akzeptiert und die angegebene Nachricht des Clients zurückgibt. zurückkehren; } while (true) {try {socket s = serversocket.accept (); InputStream input = S.GetInputStream (); OutputStream output = S.GetOutputStream (); BufferedInputStream bis = neuer bufferedInputStream (Eingabe); BufferedOutputStream bos = neuer bufferedOutputStream (Ausgabe); byte [] buffer = neues byte [20]; Bis.read (Puffer); System.out.println (neuer String (Puffer)); bos.write ("server echo" .getBytes ()); bos.flush (); S.CLOSE (); } catch (Ausnahme e) {System.out.println (e); } } } } /** * <ul> * <li>The key points of ssl connection: </li> * <li>Initialize SSLServerSocket</li> * <li>Import the server private key KeyStore, and import the server trusted KeyStore (client certificate) </li> * </ul> */ public void init() { try { SSLContext ctx = SSLContext.getInstance ("SSL"); KeyManagerFactory kmf = keyManagerFactory.getInstance ("sunx509"); TrustManagerFactory tmf = trustManagerFactory.getInstance ("sunx509"); Keystore ks = keystore.getInstance ("jks"); Keystore tks = keystore.getInstance ("jks"); Ks.load (neuer FileInputStream ("e: //kserver.keyStore"), server_key_store_password.toCharArray ()); tks.load (neuer FileInputStream ("e: //tserver.keystore"), server_trust_key_store_password.toCharArray ()); kmf.init (ks, server_key_store_password.toCharArray ()); tmf.init (tks); ctx.init (kmf.getKeyManagers (), tmf.getTrustmanagers (), null); ServerSocket = (sslServerSocket) ctx.getServerSocketFactory (). CreateServerSocket (default_port); ServerSocket.SetNeedClientAuth (true); } catch (Ausnahme e) {e.printstacktrace (); }}}Weitere Informationen zu Java -verwandten Inhalten finden Sie in den Themen dieser Website: "Java -Datenstruktur und Algorithmus -Tutorial", "Zusammenfassung der Dom -Knoten -Tipps der Java -Operation", "Zusammenfassung der Tipps für Java -Dateien und Verzeichnisoperationen" und "Zusammenfassung der Java -Cache -Operation TIPS" "
Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.