Cet article décrit la méthode d'implémentation d'authentification bidirectionnelle SSL en Java. Partagez-le pour votre référence, comme suit:
La vérification SSL commune est plus courante. Vérifiez uniquement si notre serveur est vrai ou correct. Bien sûr, si l'URL que vous visitez est erronée, alors personne ne peut le faire. C'est ce qu'on appelle l'authentification SSL unidirectionnelle.
Mais en réalité, nous pouvons également vérifier si le client répond aux exigences, c'est-à-dire délivrer un certificat à chacun de nos utilisateurs, et chaque certificat numérique est unique et non public. De cette façon, vous pouvez vous assurer que l'utilisateur accéder actuellement à mon serveur est reconnu par le serveur et n'est pas accessible par d'autres.
L'authentification bidirectionnelle garantit que le serveur et le client se reconnaissent au premier niveau. Ensuite, s'ils veulent communiquer, ils joigneront un protocole SSL au protocole de communication pour s'assurer que le contenu de la communication est crypté. Même les outils de renifleur de réseau comme Sniffer Voir le code brouillé. À l'avenir, je vais vous montrer ce que vous voyez avec Sniffer sans cryptage. J'ai peur que vous soyez plus vigilant de cette façon.
Le contenu suivant est extrait d'Internet et modifié après vérification réelle.
Scénario de simulation:
Lorsque le côté serveur communique avec le côté client, l'autorisation et la vérification d'identité sont requises, c'est-à-dire que le client ne peut accepter que des messages du serveur et le serveur ne peut accepter que les messages du client.
Technologie de mise en œuvre:
JSSE (Java Security Socket Extension)
Il s'agit d'une solution lancée par Sun pour résoudre des communications sécurisées sur Internet. Il implémente les protocoles SSL et TSL (Transport Layer Security). Le JSSE comprend des technologies telles que le chiffrement des données, la vérification du serveur, l'intégrité des messages et la vérification du client. En utilisant JSSE, les développeurs peuvent transférer des données en toute sécurité entre le client et le serveur via le protocole TCP / IP.
Afin d'implémenter l'authentification des messages.
Le serveur nécessite:
1) Keystore: où la clé privée du serveur est enregistrée
2) Confiancez le clés: il enregistre le certificat d'autorisation du client
De même, le client nécessite:
1) Keystore: où la clé privée du client est enregistrée
2) Faites confiance à Keystore: je recommande ici d'utiliser la commande keytool fournie avec Java pour générer ces fichiers d'informations. Bien sûr, OpenSSL est également la génération de certificat SSL open source la plus populaire. OpenSSL est rédigé en langue C, système croisé. Cependant, nous pouvons envisager la commodité de l'utilisation de programmes Java pour générer des certificats à l'avenir et utiliser le Keytool fourni avec JDK.
1) Générez la clé privée du serveur et importez-la dans le fichier du stage du serveur
Keytool -Genkey -alias ServerKey -Keystore kserver.keystore
Pendant le processus, vous devez le remplir séparément et le configurer en fonction de vos besoins.
Mot de passe de Keystore: 123456
Nom et nom de famille: Jin
Nom de l'unité organisationnelle: aucun
Nom de l'organisation: aucun
Nom de la ville ou de la région: BJ
Nom de l'État ou de la province: BJ
Code de pays: CN
Le mot de passe de la clé privée ServerKey n'est pas rempli de la même chose que le mot de passe du gesserie. Assurez-vous de faire attention ici, appuyez simplement sur Entrée sans modifier votre mot de passe. Sinon, si cette clé privée ne peut pas être appliquée directement dans le programme suivant, une erreur sera signalée.
Vous pouvez générer le fichier kserver.keystore
Server.KeyStore est utilisé pour le serveur, qui stocke sa propre clé privée.
2) Exporter le certificat de serveur en fonction de la clé privée
keytool -export -alias serverkey -Keystore kserver.keystore -file server.crt
server.crt est le certificat du côté serveur
3) Importez le certificat de serveur dans le clés de confiance du client
keytool -import -alias serverkey -file server.crt -Keystore tclient.keystore
TClient.KeyStore est destiné aux clients, et il détient un certificat de confiance.
De la même manière, générez la clé privée du client et le certificat du client et importez-les dans le clés de confiance du serveur
1) Keytool -Genkey -alias ClientKey -Keystore kclient.keystore
2) keytool -export -alias clientKey -Keystore kclient.keystore -file client.crt
3) keytool -import -alias clientKey -file client.crt -Keystore tserver.keystore
De cette façon, les fichiers générés sont divisés en deux groupes
ENREGISTREMENT: KSERVER.KEYSTORE TSERVER.KEYSTORE
Save du client: kclient.keystore tclient.kystore
Ce qui suit est de vérifier que le certificat que nous avons généré est disponible via le programme de communication Java Socket.
Client:
Exemples de packages.ssl; import java.io.bufferedinputstream; import java.io.bfferedoutputStream; import java.io.fileInputStream; importer java.io.ioexception; import java.io.outputstream; importation java.iserectater javax.net.ssl.keyManagerFactory; Importer javax.net.ssl.sslcontext; Importer javax.net.ssl.sslsocket; Importer Javax.net.SSL.TrustManagerFactory; / ** * SSL Client * * / public class SSLCIENT {private static final string default_host = "127.0.0.1"; private static final int default_port = 7777; chaîne finale statique privée client_key_store_password = "123456"; chaîne finale statique privée client_trust_key_store_password = "123456"; SSLSocket privé SSLSocket; / ** * Démarrez le programme client * * @param args * / public static void main (String [] args) {sslClient client = new sslClient (); client.init (); client.process (); } / ** * Connectez-vous au serveur via la prise SSL et envoyez un message * / public void process () {if (sslsocket == null) {System.out.println ("error"); retour; } try {inputStream input = sslsocket.getInputStream (); OutputStream output = sslsocket.getOutputStream (); BufferedInputStream bis = new BufferedInputStream (entrée); BufferedOutputStream bos = new BufferedOutputStream (sortie); bos.write ("message client" .getBytes ()); bos.flush (); octet [] tampon = nouveau octet [20]; bis.read (tampon); System.out.println (nouvelle chaîne (tampon)); sslsocket.close (); } catch (ioException e) {System.out.println (e); }} / ** * <ul> * <li> Les points clés de la connexion SSL: </li> * <li> Initialisez SSLSocket </li> * <li> Importez la clé de clés privée du client, Importez le client de touche de fiducie client (certificat de serveur) </li> * </ul> * / public void init () {try {sslcontext ctx = sslCon.Get. KeyManagerFactory kmf = keyManagerFactory.getInstance ("SUNX509"); TrustManagerFactory TMF = TrustManagerFactory.getInstance ("SUNX509"); Keystore ks = keystore.getInstance ("jks"); Keystore tks = keystore.getInstance ("jks"); ksload (new FileInputStream ("e: //kclient.keystore"), client_key_store_password.tocharArray ()); tks.load (new FileInputStream ("e: //tclient.keystore"), client_trust_key_store_password.tocharArray ()); kmf.init (ks, client_key_store_password.tocharArray ()); tmf.init (tks); ctx.init (kmf.getKeyManagers (), tmf.getTrustManagers (), null); sslsocket = (sslsocket) ctx.getSocketFactory (). createSocket (default_host, default_port); } catch (exception e) {System.out.println (e); }}}Côté serveur:
Package Examples.SSL; Importer java.io.BufferedInputStream; Importer Java.io.BUfferedOutputStream; Importer Java.io.fileInputStream; Importer Java.io.inputStream; Importer Java.io.OutputStream; javax.net.ssl.keymanagerfactory; import javax.net.ssl.sslcontext; import javax.net.ssl.sslServersocket; import; javax.net.ssl.trustManagerFactory; / *********************************************************************************************************** ************************************************************************************************************************************************************************************************************************************************************************************************. ************************************************************************************************************************************************************************************************************************************************************************************************. ************************************************************************************************************************************************************************************************************************************************************************************************. ************************************************************************************************************************************************************************************************************************************************************************************************. ************************************************************************************************************************************************************************************************************************************************************************************************. ************************************************************************************************************************************************************************************************************************************************************************************************. ******************************************************************************************************************************************************************************************* ServerKey -KeyStore KServer.KeyStore -File Server.Crt </li> * <li> 3) Ajoutez le certificat au clés de confiance du client </li> * <li> keytool -import -alias servery -file server.crt -Keystore tclient.keystore </li> * </ul> ********************************************************************************************************************************************************************. ********************************************************************************************************************************************************************. ********************************************************************************************************************************************************************. ********************************************************************************************************************************************************************. ********************************************************************************************************************************************************************. ********************************************************************************************************************************************************************. ********************************************************************************************************************************************************************. ***************************************************************************************************************************************************************************. Server * * / classe publique SSLServer {private static final int default_port = 7777; String final statique privé server_key_store_password = "123456"; String final statique privé server_trust_key_store_password = "123456"; SSLSERVERVERSOCK PRIVÉ SERVERSOCKET; / ** * Démarrez le programme * * @param args * / public static void main (String [] args) {sslServer Server = new sslServer (); server.init (); server.start (); } / ** * <ul> * <li> Écoutez SSL Server Socket </li> * <li> Puisque ce programme n'est pas une démonstration de l'écoute du socket, il adopte simplement un formulaire unique et accepte uniquement les messages du client et renvoie le message spécifié du client </li> * </ul> * / public Void start () {if (Serversocket == Null) {System.out.out.print ("Error"); retour; } while (true) {try {socket s = serversocket.accept (); InputStream input = s.getInputStream (); OutputStream output = s.getOutputStream (); BufferedInputStream bis = new BufferedInputStream (entrée); BufferedOutputStream bos = new BufferedOutputStream (sortie); octet [] tampon = nouveau octet [20]; bis.read (tampon); System.out.println (nouvelle chaîne (tampon)); bos.write ("Server echo" .getBytes ()); bos.flush (); S.Close (); } catch (exception e) {System.out.println (e); }}}} / ** * <ul> * <li> Les points clés de la connexion SSL: </li> * <li> Initialisez SSLServersocket </li> * <li> Importez le serveur de clés privés de la clé privée, et importez le serveur de keystore de confiance (certificat client) </li> * </ul> * / public Void init () {Try {SSLCON CTX = Sslcontext.getInstance ("ssl"); KeyManagerFactory kmf = keyManagerFactory.getInstance ("SUNX509"); TrustManagerFactory TMF = TrustManagerFactory.getInstance ("SUNX509"); Keystore ks = keystore.getInstance ("jks"); Keystore tks = keystore.getInstance ("jks"); ksload (new FileInputStream ("e: //kserver.keystore"), server_key_store_password.tocharArray ()); tks.load (new 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 (exception e) {e.printStackTrace (); }}}Pour plus d'informations sur le contenu lié à Java, veuillez consulter les sujets de ce site: "Structure de données Java et tutoriel d'algorithme", "Résumé des conseils de nœud DOM de l'opération Java", "Résumé du fichier Java et des conseils d'opération de répertoire" et "Résumé des conseils de fonctionnement de Java Cache"
J'espère que cet article sera utile à la programmation Java de tous.