Asymmetrisches Passwortkonzept
1. Der Hauptunterschied zu symmetrischen Verschlüsselungsalgorithmen besteht darin, dass die Verschlüsselungs- und Entschlüsselungsschlüssel unterschiedlich sind, einer öffentlich (öffentlicher Schlüssel) und der andere vertraulich (privater Schlüssel). Es löst hauptsächlich das Problem der wichtigen Allokationsverwaltung symmetrischer Verschlüsselungsalgorithmen und verbessert die Sicherheit der Algorithmus.
2. Die Verschlüsselungs- und Entschlüsselungseffizienz von asymmetrischen Verschlüsselungsalgorithmen ist relativ niedrig. Im Algorithmus -Design haben asymmetrische Verschlüsselungsalgorithmen strenge Anforderungen an die Länge der verschlüsselten Daten. Zum Beispiel verlangt der RSA -Algorithmus, dass die zu verschlüsselten Daten nicht größer als 53 Bytes sein dürfen.
3. Asymmetrische Verschlüsselungsalgorithmen werden hauptsächlich zum Austausch von Schlüssel von symmetrischen Verschlüsselungsalgorithmen und nicht zum Datenaustausch verwendet.
4. Java6 bietet zwei Algorithmen, die DH und RSA implementieren. Bouncy Castle bietet Unterstützung für E1gamal -Algorithmus. Zusätzlich zu den oben genannten drei Algorithmen gibt es auch einen ECC -Algorithmus, und derzeit gibt es keine relevante Open -Source -Komponente zur Unterstützung.
Für Verschlüsselung oder Entschlüsselung sind zwei Schlüssel erforderlich, die in öffentliche und private Schlüssel unterteilt sind
Merkmale: hohe Sicherheit, langsame Geschwindigkeit
verwenden
【Schlüsselaustausch (DH)】】
Ohne den gemeinsamen Schlüssel zu bestimmen, generieren beide Parteien den Schlüssel und liefern keine Verschlüsselungsarbeiten. Verschlüsselung und Entschlüsselung erfordert auch andere symmetrische Verschlüsselungsalgorithmen.
Beispiel für DH -Algorithmus
importieren javax.crypto.keyagreement; import javax.crypto.interfaces.dhprivateKey; import Javax.Crypto.Interfaces.dhpublickey; Javax.crypto.spec.dhparametersspec; java.security.spec.x509CodedKeyspec; import Java.util.hashMap; Import Java.util.map; // 1 Generieren Sie den Quellschlüssel // 2 Der öffentliche Schlüssel der Quelle wird dem Ziel übergeben, und das Ziel generiert den öffentlichen Schlüssel und privaten Schlüssel über die Quelle. // 3 Der öffentliche Schlüssel des Ziels wird an die Quelle übergeben // 4 Beide Parteien verwenden den öffentlichen Schlüssel der anderen Partei und seinen eigenen privaten Schlüssel, um den lokalen Schlüssel zu generieren // 5 Wenn beide Parteien den lokalen Schlüssel gleich generieren, vervollständigen Sie die Schlüsselklasse für die Schlüsselklasse von Key Austausch. public static final String private_key = "dh_private_key"; /** * Quellschlüsselpaar generieren * @return * @throws Exception */public static map <string, Object> InitSourceKey () löst eine Ausnahme aus {// Erstellen Sie eine Instanz von KeypairGenerator, wählen Sie den DH -Algorithmus Keypairgenerator Keypairgenerator = KeypairGenerator.Getinstance ("dh"); // Initialisieren Sie die Schlüssellänge, Standard 1024, optionaler Bereich 512-65536 & Multiples von 64 Tastaturen.initialize (1024); // Taste Pair Tastair TastAirt tastar = keypairgenerator.generateKeypair (); Dhpublickey dhpublickey = (dhpublickey) keypair.getPublic (); DhprivateKey dhprivateKey = (dhprivateKey) keypair.getPrivate (); // das Schlüsselpaar in Map Map <String, Objekt> keymap = new HashMap <String, Object> () eingeben; keymap.put (public_key, dhpublickey); keymap.put (private_key, dhprivateKey); Keymap zurückgeben; } / ** * Generieren Sie das Zielschlüsselpaar über den öffentlichen Quellschlüssel * @param SourcePublickey * @return * @throws Exception * / public static map <String, Objekt> InittargetKey (byte [] SourcePublickey) löst eine Ausnahme aus {KeyFactory keyFactory = keyFactory.getInstance ("dh"); // Verwenden Sie den öffentlichen Schlüssel für den Source Public, generieren Sie Schlüsselspezifikation und generieren KeyFactory, um Source PublicKey -Informationen X509CodedKeySpec KeySpec = New X509CodedKeySpec (SourcePublickey) zu generieren. Dhpublickey SourcePublic = (dhpublickey) keyFactory.generatePublic (keyspec); Dhparameterspec dhpublickeyparams = sourcePublic.getParams (); Tastypairgenerator keypairgenerator = keypairgenerator.getInstance ("dh"); keypairgenerator.initialize (dhpublickeyparams); Tastatur Tastatur = Keypairgenerator.generateKeypair (); Dhpublickey dhpublickey = (dhpublickey) keypair.getPublic (); DhprivateKey dhprivateKey = (dhprivateKey) keypair.getPrivate (); // das Schlüsselpaar in Map Map <String, Objekt> keymap = new HashMap <String, Object> () eingeben; keymap.put (public_key, dhpublickey); keymap.put (private_key, dhprivateKey); Keymap zurückgeben; } / *** Verwenden Sie den öffentlichen Schlüssel einer Partei und den privaten Schlüssel der anderen Partei, um den lokalen Schlüssel zu generieren. // Verwenden Sie einen öffentlichen Schlüssel, generieren Sie KEYSPEC und verwenden Sie KeyFactory, um eine von PublicKey verwandte Informationen zu generieren. PublicKey publicKey = keyFactory.generatePublic (keyspec); // BED -BETRISCHE KEY BEGRENZEN, B -privateschlüsselbezogene Informationen pkcs8EncodedKeyspec pkcs8EncodedKeySpec = Neue PKCS8EncodedKeySpec (BPrivateKey); Privatekey privateKey = keyFactory.generatePrivate (PKCS8EncodedKeySpec); // Verschlüsseln Sie den PublicKey und Bs privatenkey von KeyAgreement KeyAgreement keyAgreement = keyagreement.getInstance ("DH"); KeyAgreement.init (privatKey); KeyAgreement.dophase (PublicKey, True); return keyAgreement.generateSecret ("aes"). getCoded (); // Der Algorithmus verwendet einen symmetrischen Verschlüsselungsalgorithmus (DES, Dese, AES) // Rückgabe keyAgreement.generateSecret (); // Der Algorithmus kann auch verwendet werden, um die Standardmethode mit der Standardmethode zu berechnen, ohne den Algorithmus auszuwählen} // das öffentliche Schlüssel -Byte -Array Public static Byte [] getPublicke (map <String, Object> map) {return ((dhpublicke) map.get (public_key). GetEcoded (); } // Erhalten Sie das private Schlüsselbyte -Array Public static Byte [] getPrivateKey (MAP <String, Object> Map) {return ((dhPrivateKey) map.get (privat_key)). GetCoded (); } public static void main (String [] args) löst eine Ausnahme aus {byte [] socal_public_key; byte [] source_private_key; byte [] source_local_key; byte [] target_public_key; byte [] target_private_key; byte [] target_local_key; Map <string, Object> SourceKey = InitSourceKey (); socus_public_key = getPublickey (SourceKey); Source_private_key = getPrivateKey (SourceKey); System.out.println ("Quell öffentlicher Schlüssel:"+bytestohex.fromByTestohex (socal_public_key)); System.out.println ("Quelle private Schlüssel:"+byTestohex.fromByTestohex (Source_private_key)); Map <string, Object> targetKey = InittargetKey (getPublickey (SourceKey)); target_public_key = getPublickey (targetKey); target_private_key = getPrivateKey (targetKey); System.out.println ("Zielpublikumschlüssel:"+bytestohex.fromByTestohex (target_public_key)); System.out.println ("Ziel private Schlüssel:"+bytestohex.fromByTestohex (Target_private_key)); source_local_key = Generatelocalsecretkey (target_public_key, socal_private_key); target_local_key = Generatelocalsecretkey (socal_public_key, target_private_key); System.out.println ("Quelle Lokalschlüssel:"+byTestohex.fromByTestohex (Source_local_key)); System.out.println ("Ziel lokaler Schlüssel:"+bytestohex.fromByTestohex (target_local_key)); }}【Verschlüsselung/Entschlüsselung (RSA) 】【 Digitale Signatur (RSA)】
Der RSA -Algorithmus ist später als der DH -Algorithmus, und all diese fünf Buchstaben sind die ersten Buchstaben des menschlichen Namens. Der DH -Algorithmus ist das erste asymmetrische kryptografische System.
Der RSA -Algorithmus hat eine langsame Rechengeschwindigkeit und ist nicht zum Verschlingen großer Datenmengen geeignet. Eine Lösung besteht darin, RSA- und symmetrische Verschlüsselungsmethoden zu mischen, Daten mithilfe symmetrischer Verschlüsselungsmethoden zu verschlüsseln, und symmetrische Verschlüsselungsschlüssel werden mit RSA -Algorithmen verschlüsselt. Da der Schlüssel sehr kurz ist, ist die Zeit nicht zu viel. Tatsächlich ist der einzige Nachteil symmetrischer Verschlüsselungsmethoden, dass der Schlüssel schwer zu bestehen ist und symmetrische Verschlüsselungsmethoden auch schwer zu knacken sind.
Anwendbare Szenarien von RSA:
(1) Der Server generiert einen öffentlichen Schlüssel und einen privaten Schlüssel und veröffentlicht den öffentlichen Schlüssel.
(2) Der Client verwendet einen öffentlichen Schlüssel, um die Daten zu verschlüsseln und dem Server zu übergeben. Andere können die verschlüsselten Daten nicht verstehen.
(3) Der Server verwendet einen privaten Schlüssel, um die Daten zu entschlüsseln und die vom Benutzer übermittelten Daten anzeigen.
In diesem Fall ist der öffentliche Schlüssel wie ein Mailbox, und jeder kann eine Nachricht in diese Mailbox einfügen, aber nur diejenigen, die die Mailbox -Schlüssel haben, können die Briefe in diesem Postfach enttäuschen und anzeigen.
RSA anwendbares Szenario 2:
(1) Der Kaiser generiert einen öffentlichen Schlüssel und einen geheimen Schlüssel und veröffentlicht den öffentlichen Schlüssel.
(2) Der Kaiser gab ein Edikt heraus, um die Welt zu informieren. In der unteren rechten Ecke des Edikts befinden sich zwei Zahlenketten. Die erste Zeichenfolge ist eine zufällige Zeichenfolge, und die zweite Zeichenfolge ist das Ergebnis des Verschlingens der ersten Zeichenfolge mit einem privaten Schlüssel.
(3) Einige Leute glauben nicht, dass das Edikt vom Kaiser geschrieben wurde und die zweite Zahlenfolge mit dem öffentlichen Schlüssel entschlüsselt hat. Nach dem Entschlüsseln stellten sie fest, dass es dasselbe wie die erste Zahlenfolge war, was bedeutet, dass es tatsächlich vom Kaiser geschrieben wurde. Da die meisten Menschen keinen Schlüssel haben, können sie die Daten, die mit dem öffentlichen Schlüssel entschlüsselt werden können, nicht verschlüsseln.
In diesem Fall wird der öffentliche Schlüssel zur Entschlüsselung verwendet und der private Schlüssel zur Verschlüsselung verwendet. Dies kann verwendet werden, um zu beweisen, dass die Ankündigung tatsächlich von jemandem gesendet wurde. Es entspricht einer Signatur.
In der Tat besteht keine Notwendigkeit, für Unterschriften besonders lange zu sein. Im Allgemeinen sind Unterschriften festgelegt. Wenn Sie eine feste Länge haben möchten, können Sie den MessagedIGest-Algorithmus wie die MD5- und SHA-Serie verwenden. Daher gibt es eine Vielzahl von Signaturalgorithmen wie MD5 WithRSA usw.
Beispiele für RSA -Verschlüsselung/Entschlüsselung
importieren javax.crypto.cipher; import java.security.keypair; import java.security java.util.map;/*** RSA -Verschlüsselungsinstrument*/public class rsautil {public static final String public_key = "rsa_public_key"; public static final String private_key = "rsa_private_key"; / ** * Initialisierungsschlüssel * @return * @throws Exception */ public static map <String, Object> InitKey () löst eine Ausnahme aus {KeypairGenerator keypairGenerator = keypairGenerator.getInstance ("RSA"); keypairGenerator.initialize (1024); // 512-65536 & Multiples von 64 TastAir Tastair = Keypairgenerator.GenerateKeypair (); Rsapublickey publicKey = (rsapublickey) tastypair.getPublic (); RsaprivateKey privateKey = (rsaprivateKey) keypair.getPrivate (); Karte <string, Objekt> keyMap = new HashMap <String, Object> (); Keymap.put (Public_key, PublicKey); keymap.put (private_key, privateKey); Keymap zurückgeben; } public static rsapublickey getPublickey (MAP <string, Object> keymap) {return (rsapublickey) keymap.get (public_key); } public static rsaprivateKey getPrivateKey (MAP <string, Object> keymap) {return (rsaprivateKey) keymap.get (private_key); } / ** * Verschlüsseln Sie Daten mit öffentlichem Schlüssel * @param data * @param publicKey * @return * @throws Exception * / public static byte [] Encrypt (byte [] data, rsapublickey publicKey) Ausnahme {Cipher Cipher = cipher.getInstance ("rsa"); cipher.init (cipher.encrypt_mode, publicKey); cipher.dofinal (Daten) zurückgeben; } / ** * Verwenden Sie den privaten Schlüssel zum Entschlüsseln * @param data * @param privateKey * @return * @throws Exception * / public static byte [] entschlüsselt (Byte [] data, rsaprivateKey privateKey) Ausnahme {Cipher Cipher = cipher.getInstance ("rsa"); cipher.init (cipher.decrypt_mode, privateKey); cipher.dofinal (Daten) zurückgeben; } public static void main (String [] args) löst Ausnahme aus {String data = "jay chou-dongfeng break"; Karte <String, Objekt> Keymap = initKey (); byte [] miwen = encrypt (data.getBytes (), getPublickey (keymap)); System.out.println ("verschlüsselter Inhalt:"+bytestohex.frombyTestohex (Miwen)); byte [] plain = entschlüsseln (Miwen, GetPrivateKey (Keymap)); System.out.println ("entschlüsselter Inhalt:"+neue String (einfache)); }}Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.