Ich habe das Gefühl, dass es lange her ist, seit ich das letzte Mal einen Blog geschrieben habe. Lassen Sie mich zuerst beschweren. In diesem Monat hat das Unternehmen Überstunden gearbeitet, die Veröffentlichung veröffentlicht und gestartet, und neue Projekte sind zu eng, daher werde ich nicht viel über die spezifischen sagen. Heute ist es wirklich wichtig, über asymmetrische Verschlüsselung zu sprechen. Die asymmetrische Verschlüsselung ist in unserem täglichen Leben unverzichtbar.
Konzept
Bevor wir über RSA sprechen, sprechen wir zunächst darüber, was eine asymmetrische Verschlüsselung ist. Wenn man über symmetrische Verschlüsselung sprach, wurde einmal gesagt, dass symmetrische Verschlüsselungsalgorithmen bei Verschlüsseln und Entschlüsseln denselben geheimen Schlüssel verwenden, und beide Parteien zum Verschlüsseln und Entschlüsseln müssen denselben Schlüssel verwenden, um normal zu kommunizieren. Die asymmetrische Verschlüsselung ist nicht der Fall. Der asymmetrische Verschlüsselungsalgorithmus erfordert zwei Schlüssel zum Verschlingen und Entschlüsseln, nämlich den öffentlichen Schlüssel und den privaten Schlüssel.
Eine Sache zu beachten ist, dass der öffentliche Schlüssel und der private Schlüssel ein Paar sein müssen. Wenn die Daten mit dem öffentlichen Schlüssel verschlüsselt sind, kann nur der entsprechende private Schlüssel entschlüsselt und umgekehrt. Da Verschlüsselung und Entschlüsselung zwei verschiedene Schlüssel verwenden, wird dieser Algorithmus als asymmetrischer Verschlüsselungsalgorithmus bezeichnet.
Arbeitsprozess
Wie in der folgenden Abbildung gezeigt, werden die Daten unter Verwendung einer asymmetrischen Verschlüsselung übertragen.
Zu den wichtigsten Algorithmen, die in der asymmetrischen Verschlüsselung verwendet werden, gehören: RSA, Elgamal, Rucksackalgorithmus, Rabin, DH, ECC (elliptische Kurvenverschlüsselungsalgorithmus) usw. Heute werden wir hauptsächlich RSA einführen. Was andere Algorithmen betrifft, wählen wir einige, um sie später vorzustellen.
RSA
Tatsächlich trat RSA bereits 1978 auf und war der erste Algorithmus, der sowohl für die Datenverschlüsselung als auch für digitale Signaturen verwendet werden kann. Es ist leicht zu verstehen und zu arbeiten und ist auch sehr beliebt. Das Prinzip ist wie im obigen Arbeitsprozess beschrieben.
Der RSA -Algorithmus basiert auf einer sehr einfachen Zahlen -Theorie -Tatsache: Es ist einfach, zwei große Primzahlen zu multiplizieren, aber es ist äußerst schwierig, ihre Produkte zu faktorisieren, sodass das Produkt als Verschlüsselungsschlüssel offenbart werden kann.
Code -Implementierung
Werfen wir einen Blick auf die jeweilige Code -Implementierung unten.
import com.google.common.collect.maps; import sun.misc.base64Decoder; import sun.misc.base64Encoder; importieren javax.crypto.cipher; Java.Security importieren.*; Java.security.interfaces.rsaprivateKey; import Java.security.interfaces.rsapublickey; importieren java.security.spec.pkcs8EnencodedKeyspec; import Java.security.spec.x509EncodedKeyspec; import Java.util.map; /*** Erstellt von xiang.li am 2015/3/3. * RSA -Verschlüsselungs- und Entschlüsselungswerkzeugklasse*/ öffentliche Klasse RSA {/ *** Verschlüsselungsmethode definieren*/ private endgültige statische String key_rsa = "rsa"; / *** Signaturalgorithmus definieren*/ private endgültige statische String key_rsa_signature = "md5withrsa"; / *** Definieren Sie den öffentlichen Schlüsselalgorithmus*/ Private Final Static String key_rsa_publickey = "rsapublickey"; / *** Private Schlüsselalgorithmus definieren*/ private endgültige statische String key_rsa_privateKey = "rsaprivateKey"; / *** Initialisierungsschlüssel* @return*/ public static map <String, Object> init () {map <String, Objekt> map = null; try {keypairGenerator Generator Generator = keypairGenerator.getInstance (KEY_RSA); Generator.initialize (1024); Tastair tastepair = generator.generateKeypair (); // public key rsapublickey publicKey = (rsapublickey) keypair.getPublic (); // Private Key RsaprivateKey privateKey = (rsaprivateKey) keypair.getPrivate (); // den Schlüssel als map map = maps.newHasMap () einkapseln; map.put (KEY_RSA_PUBLICKEY, PublicKey); map.put (KEY_RSA_PRIVATEKEY, privateKey); } catch (nosuchalgorithmException e) {e.printstacktrace (); } Rückgabekarte; } / *** Verwenden Sie den privaten Schlüssel, um eine digitale Signatur für die Informationen zu generieren Versuchen Sie {// entschlüsseln Sie das private Schlüssel -byte [] bytes = decryptbase64 (privateKey); // Konstruieren Sie das PKCS8EncodedKeySpec -Objekt PKCS8EncodedKeySpec PKCS = NEU PKCS8EncodedKeySpec (Bytes); // Die angegebene Verschlüsselungsalgorithmus keyFactory factory = keyFactory.getInstance (KEY_RSA); // Erhalten Sie das private Key -Objekt privateKey key = factory.generatePrivate (PKCS); // Verwenden Sie den privaten Schlüssel, um eine digitale Signatur für Informationen zu generieren Signature Signature = Signature.getInstance (KEY_RSA_IGNATION); Signature.initsign (Schlüssel); Signature.Update (Daten); Str = Encryptbase64 (Signature.Sign ()); } catch (Ausnahme e) {e.printstacktrace (); } return str; } / *** Überprüfen Sie die digitale Signatur* @param Daten verschlüsselte Daten* @param publicKey publicKey Key* @param Zeichen digitale Signatur* @Return erfolgreiche Rückgabe true, fehlgeschlagener Rückgabe Falsch* / public static boolean verifizieren (byte [] data, String PublicKey, String -Zeichen) {boolean Flag = false; Versuchen Sie {// Das öffentliche Schlüssel -Codierte Byte [] bytes = decryptbase64 (PublicKey); // Konstruieren Sie das X509EncodedKeySpec -Objekt x509EncodedKeySpec keyspec = new x509EncodedKeyspec (Bytes); // Die angegebene Verschlüsselungsalgorithmus keyFactory factory = keyFactory.getInstance (KEY_RSA); // das öffentliche Key -Objekt PublicKey Key = factory.generatePublic (keyspec) erhalten; // Überprüfen Sie die digitale Signatur mit dem öffentlichen Schlüssel Signature Signature = Signature.getInstance (KEY_RSA_Ignature); Signature.initverify (Schlüssel); Signature.Update (Daten); Flag = Signature.Verify (decryptbase64 (Zeichen)); } catch (Ausnahme e) {e.printstacktrace (); } Rückkehrflag; } / *** privatschlüssel decrypt* @param data verschlüsselte Daten* @param Key Private Key* @return* / public static byte [] decryptByPrivateKey (Byte [] Daten, String -Schlüssel) {byte [] result = null; Versuchen Sie {// das private Schlüssel Byte [] bytes = decryptbase64 (Schlüssel) entschlüsseln; // Erhalten Sie den privaten Schlüssel PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeyspec (Bytes); KeyFactory factory = keyFactory.getInstance (KEY_RSA); Privatekey privateKey = factory.generatePrivate (keyspec); // DATA CHIPHER CIPHER = CIPHER.getInstance (factory.getalgorithmus ()) entschlüsseln; cipher.init (cipher.decrypt_mode, privateKey); result = cipher.dofinal (Daten); } catch (Ausnahme e) {e.printstacktrace (); } Rückgabeergebnis; } / *** private Schlüsselentwurf* @Param Daten verschlüsselte Daten* @param Key Public Key* @return* / public static byte [] decryptbypublickey (byte [] Daten, String -Schlüssel) {Byte [] result = null; Versuchen Sie {// das öffentliche Schlüssel Byte [] bytes = decryptbase64 (Schlüssel); // den öffentlichen Schlüssel x509EncodedKeySpec keyspec = neu x509EncodedKeyspec (Bytes) erhalten; KeyFactory factory = keyFactory.getInstance (KEY_RSA); PublicKey publicKey = factory.generatePublic (keyspec); // DATA CHIPHER CIPHER = CIPHER.getInstance (factory.getalgorithmus ()) entschlüsseln; cipher.init (cipher.decrypt_mode, PublicKey); result = cipher.dofinal (Daten); } catch (Ausnahme e) {e.printstacktrace (); } Rückgabeergebnis; } / *** public key Verschlüsselung* @param -Datendaten, die verschlüsselt werden sollen try {byte [] bytes = decryptbase64 (Schlüssel); // den öffentlichen Schlüssel x509EncodedKeySpec keyspec = neu x509EncodedKeyspec (Bytes) erhalten; KeyFactory factory = keyFactory.getInstance (KEY_RSA); PublicKey publicKey = factory.generatePublic (keyspec); // Data cipher Cipher = Cipher.getInstance (factory.getalgorithmus ()) verschlüsseln; cipher.init (cipher.encrypt_mode, publicKey); result = cipher.dofinal (Daten); } catch (Ausnahme e) {e.printstacktrace (); } Rückgabeergebnis; } / *** private Schlüsselverschlüsselung* @param -Daten, die verschlüsselt werden sollen try {byte [] bytes = decryptbase64 (Schlüssel); // Erhalten Sie den privaten Schlüssel PKCS8EncodedKeySpec Keyspec = New PKCS8EncodedKeySpec (Bytes); KeyFactory factory = keyFactory.getInstance (KEY_RSA); Privatekey privateKey = factory.generatePrivate (keyspec); // Data cipher Cipher = Cipher.getInstance (factory.getalgorithmus ()) verschlüsseln; cipher.init (cipher.encrypt_mode, privateKey); result = cipher.dofinal (Daten); } catch (Ausnahme e) {e.printstacktrace (); } Rückgabeergebnis; } / ** * den öffentlichen Schlüssel erhalten * @param map * @return * / public static String getPublickey (Karte <String, Objekt> Karte) {String str = ""; try {key key = (Schlüssel) map.get (KEY_RSA_PUBLICKEY); Str = Encryptbase64 (Key.GetEnCoded ()); } catch (Ausnahme e) {e.printstacktrace (); } return str; } / ** * Holen Sie sich den privaten Schlüssel * @param map * @return * / public static String getPrivateKey (Karte <String, Objekt> Karte) {String str = ""; try {key key = (Schlüssel) map.get (KEY_RSA_PRIVATEKEY); Str = Encryptbase64 (Key.GetEnCoded ()); } catch (Ausnahme e) {e.printstacktrace (); } return str; } / *** base64 decrypt* @param key string, der entschlüsselt werden muss } / *** Base64 -Verschlüsselung* @param Key Byte -Array, das verschlüsselt werden muss } / *** Testmethode* @param args* / public static void main (String [] args) {String privateKey = ""; String PublicKey = ""; // öffentliche Schlüssel -Taste -Map <String, Objekt> map = init () generieren; PublicKey = GetPublickey (Karte); privateKey = getPrivateKey (Karte); System.out.println ("public key: /n /r" + publicKey); System.out.println ("Private Key: /n /r" + privateKey); System.out.println ("Public Key-Verschlüsselung -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- recryptbypublickey (word.getBytes (), PublicKey); Verschlüsselung -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- EncryptByPrivateKey (englisch.getBytes (), privateKey); String Decenglish = New String (decryptbypublickey (English, PublicKey)); System.out.println ("Vor der Verschlüsselung:" + englisch + "/n/r" + "nach der Entschlüsselung:" + Decenglish); System.out.println ("private wichtige Signatur-öffentliche Schlüsselüberprüfung"); // Signature String Sign = Sign (english, privateKey) generieren; System.out.println ("Signatur:/r" + signy); // Überprüfen Sie den Signature booleschen Status = Verify (English, PublicKey, Zeichen); System.out.println ("Status:/r" + Status); }} Ergebnisse verschlüsseln und entschlüsseln
Abschluss
Tatsächlich kann ein scheinbar komplexer Prozess in einem Satz beschrieben werden: Die Verwendung öffentlicher Schlüsselverschlüsselung und private Schlüsselentschlüsselung, eine Datenübertragung von Partei B zu Party A wird durch private Schlüsselverschlüsselung und öffentliche Schlüsselentschlüsselung und gleichzeitig durch private Schlüsselunterzeichnung und öffentliche Schlüsselüberprüfung, eine Datenübertragung und eine Verifizierung von Partei A abgeschlossen, und zwei Datenübertragungen werden einen vollständigen Datenübertragungspflicht abgeschlossen.
Das Auftreten von asymmetrischen Verschlüsselungsalgorithmen besteht darin, das Problem der Verschlüsselung und Entschlüsslung nur einen Schlüssel zu lösen. Solange dieser Schlüssel verloren geht oder offengelegt ist, können die verschlüsselten Daten leicht angegriffen werden. Gleichzeitig werden die nachfolgenden digitalen Signaturen, digitalen Zertifikate usw. genauso aufgrund der Entstehung asymmetrischer Verschlüsselungsalgorithmen erhalten.
Okay, lass uns heute hier aufhören. Der nächste Artikel setzt die asymmetrische Verschlüsselung fort. Welches werde ich damals wissen. Halten Sie es hier zuerst geheim