RSA -Verschlüsselungsalgorithmus
Lassen Sie uns den Verschlüsselungsalgorithmus von RSA überprüfen. Wir verwenden eine relativ standardisierte Sprache, um diesen Algorithmus auf der Grundlage der Definition des Verschlüsselungsalgorithmus für öffentliche Schlüssel und des Signaturalgorithmus zu beschreiben.
Das RSA Public Key Encryption -System enthält die folgenden 3 Algorithmen: Keygen (Schlüsselgenerierungsalgorithmus), Verschlüsselung (Verschlüsselung) und Entschlüsselung (Entschlüsselungsalgorithmus).
Der Schlüsselgenerierungsalgorithmus verwendet eine Sicherheitskonstante als Eingabe, um einen öffentlichen Key -PK und einen privaten Key SK auszugeben. Die Sicherheitskonstante wird verwendet, um zu bestimmen, wie sicher der Verschlüsselungsalgorithmus ist, der im Allgemeinen mit der Größe der Primzahl P zusammenhängt, die vom Verschlüsselungsalgorithmus verwendet wird. Je größer die Primzahl P ist, desto größer ist das System, was eine höhere Sicherheit gewährleistet. In RSA lautet der Schlüsselgenerierungsalgorithmus wie folgt: Der Algorithmus erzeugt zunächst zufällig zwei verschiedene große Primzahlen P und Q und berechnet N = PQ. Dann berechnet der Algorithmus die Euler -Funktion. Als nächstes wählt der Algorithmus nach dem Zufallsprinzip eine ganze Zahl weniger als E aus und berechnet das Modulo -inverse Element D von E. Schließlich lautet der öffentliche Schlüssel PK = (n, e) und der private Schlüssel ist sk = (n, d).
Der Verschlüsselungsalgorithmus verwendet die öffentliche Taste PK und die Nachricht m, um als Eingabe verschlüsselt zu werden, und gibt den Ciphertext CT aus. In RSA lautet der Verschlüsselungsalgorithmus wie folgt: Der Algorithmus gibt direkt den Chiffretext aus, da der Entschlüsselungsalgorithmus den privaten Schlüssel -SK und die Ciphertext CT als Eingänge verwendet und die Nachricht M. in RSA ausgibt. Der Entschlüsselungsalgorithmus ist wie folgt: Der Algorithmus gibt den Plaintext aus. Da E und D umgekehrt zueinander sind, haben wir:
Aus der Beschreibung der Algorithmus können wir daher auch sehen, dass der öffentliche Schlüssel zum Verschlüsseln der Daten verwendet wird und der private Schlüssel zum Entschlüsseln der Daten verwendet wird. Dies kann natürlich auch intuitiv verstanden werden: Ein öffentlicher Schlüssel ist ein öffentlicher Schlüssel, und nur wenn er offengelegt wird, kann jeder sie verwenden, um Daten zu verschlüsseln. Ein privater Schlüssel ist ein privater Schlüssel, und wer diesen Schlüssel hat, kann den Chiffretext entschlüsseln. Andernfalls ist es ein Chaos, wenn jeder den privaten Schlüssel sehen und ihn entschlüsseln kann.
Schauen wir uns die einfache Implementierung in Java an:
Paket com.stone.security; Java.security.keypair; Import Java.Security.Keypairgenerator; Import Java.security.PrivateKey; import Java.security.publickey; Import Java.util.Arrays; importieren javax.crypto.cipher; / *** RSA -Algorithmus öffentlicher Schlüsselverschlüsselung Asymmetrische Verschlüsselung*/ öffentliche Klasse RSA {public static Final String KEY_ALGORITHM = "RSA"; public static Final String cipher_algorithm_ecb1 = "RSA/ECB/PKCS1Padding"; public static Final String cipher_algorithm_ecb2 = "RSA/ECB/OAEPWithSHA-1AndMgf1padding"; // Sie können keine öffentliche statische endgültige String-String-String-String-Cipher_Algorithm_ecb3 = "oaepwithsha-256andMgf1padding" verwenden; // Sie können static PublicKey nicht verwenden. statischer privatkey privatkey; statische Chiffre -Chiffre; statischer Tastatur -Tastatur; public static void main (String [] args) löst Ausnahme aus {method1 ("Skoda u*(sfsad7f ()*^%% $"); methode2 ("Skoda u*(sfsad7f ()*^%% $"); CIPHER_ALGORITHM_ECB1 * @PARAM STROWS -Ausnahme */ statische Void -Methode (String Str) Ausnahme {KeypairGenerator Keygenerator tastepair.getPrivate (); Arrays.toString (Verschlüsselung)); CIPHER_ALGORITHM_ECB1 * @PARAM STR * @Throws Exception */ static void methode2 (String Str) Ausnahme aus der Ausnahme {KeypairGenerator KeyGenerator = keypairGenerator.getInstance (KEY_ALGORITHM); Tastair tastepair = keygenerator.generateKeypair (); publicKey = keypair.getPublic (); privateschlüssel = keypair.getPrivate (); cipher = cipher.getInstance (KEY_ALGORITHM); cipher.init (cipher.encrypt_mode, privateKey); // private Schlüsselverschlüsselungs -Byte [] Encrypt = cipher.dofinal (str.getBytes ()); System.out.println ("private Schlüsselverschlüsselung 2:" + arrays.toString (Encrypt)); cipher.init (cipher.decrypt_mode, PublicKey); // public key decrypt byte [] decrypt = cipher.dofinal (Encrypt); System.out.println ("Public Key Decrypt 2:" + New String (entschlüsselt)); }/** * private Schlüsselverschlüsselung, öffentliche Schlüsselentschlüsselung verwendet Cipher_algorithm_ecb1 = rsa/ecb/pkcs1padding * @param Str * @throws Exception */static void methode3 (String st) stürzt Ausnahme {Keypairgenerator Keygenerator = KeypairGener. Tastair tastepair = keygenerator.generateKeypair (); publicKey = keypair.getPublic (); privateschlüssel = keypair.getPrivate (); cipher = cipher.getInstance (cipher_algorithm_ecb1); cipher.init (cipher.encrypt_mode, privateKey); // private Schlüsselverschlüsselungs -Byte [] Encrypt = cipher.dofinal (str.getBytes ()); System.out.println ("private Schlüsselverschlüsselung 3:" + arrays.toString (Encrypt)); cipher.init (cipher.decrypt_mode, PublicKey); // Public Key Decryption Byte [] decrypt = cipher.dofinal (Encrypt); System.out.println ("3 nach der öffentlichen Schlüsselentschlüsselung:" + neue String (entschlüsselt)); }} DSA -Algorithmus und digitale Signatur
DSA wird im Allgemeinen für digitale Signaturen und Zertifizierung verwendet.
DSA ist eine Variante von Schnorr- und Elgamal -Signaturalgorithmen und wird von NIST in den USA als DSS (digitaler Signaturstandard) verwendet.
DSA basiert auf dem Integer Finite Domain Discrete Logarithmic Problem, und ihre Sicherheit ähnelt RSA.
In DSA Digital Signature und Authentifizierung verwendet der Absender seinen eigenen privaten Schlüssel, um eine Datei oder Nachricht zu unterschreiben, und der Empfänger verwendet den öffentlichen Schlüssel des Absenders, um die Authentizität der Signatur nach Empfang der Nachricht zu überprüfen. DSA ist nur ein Algorithmus, und der Unterschied zwischen RSA besteht darin, dass sie nicht zur Verschlüsselung und Entschlüsselung oder für den Schlüsselaustausch verwendet werden kann.
Nur für Unterschriften ist es viel schneller als RSA.
Paket com.stone.security; import Java.Security.Key; Java.Security.KeyFactory importieren; Java.security.keypair; Import Java.Security.Keypairgenerator; Import Java.security.PrivateKey; import Java.security.publickey; Java.security.securerandom importieren; Java.Security.signature importieren; importieren java.security.spec.pkcs8EnencodedKeyspec; import Java.security.spec.x509EncodedKeyspec; import Java.util.hashMap; import Java.util.map; import sun.misc.base64Decoder; import sun.misc.base64Encoder; /*** DSA-DIGITAL-Signaturalgorithmus ist eine Variante von Schnorr- und Elgamal-Signaturalgorithmen und wird von NIST in den USA als DSS verwendet. * Kurz gesagt, dies ist eine fortgeschrittenere Verifizierungsmethode, die als digitale Signatur verwendet wird. Nicht nur öffentliche und private Schlüssel, sondern auch digitale Signaturen. Die private Schlüsselverschlüsselung generiert digitale Signaturen, Daten und Unterschriften für öffentliche Schlüssel. * Wenn die Daten und die Signatur nicht übereinstimmen, wird die Überprüfung als fehlgeschlagen angesehen! Das heißt, die Daten in der Übertragung können nicht mehr verschlüsselt werden. Nachdem der Empfänger die Daten erhalten hat, erhält er den öffentlichen Schlüssel und die Signatur, um zu überprüfen, ob die Daten gültig sind. */ öffentliche Klasse DSA {/ ***können nicht nur den DSA -Algorithmus verwenden, sondern auch den RSA -Algorithmus für digitale Signaturen*/ public static Final String key_algorithmus = "RSA"; public static Final String Signature_Algorithmus = "Md5withrsa";*/ public static Final String KEY_ALGORITHM = "DSA"; public static Final String Signature_Algorithmus = "DSA"; public static final String default_seed = "$%^*%^() (hjg8awfjas7"; // Standard Seed Public Static Final String public_key = "dsapublickey"; public static final String privat_key = "dsaprivateKey"; public static void Main (String [] args) throws {String strath. Liebt dich*() _ + "; byte [] data = str.getBytes (); map <String, Objekt> keymap = initkey (); // bauen key publicKey publicKey = (publicKey) keymap.get (public_key); privateKey privateKey = (privateKey) keymap.get (privat_key); System.out.println ("öffentliches Schlüsselformat:" + publicKey.getFormat ()); verifizieren1); } / *** Taste generieren** @param Seed* @return Schlüsselobjekt* @throws Exception* / public static map <String, Objekt> InitKey (String Seed) löst die Ausnahme aus {System.out.println ("Taste generieren"); Keypairgenerator keygen = keypairgenerator.getInstance (KEY_ALGORITHM); Securerandom Securerandom = new Securerandom (); Securerandom.SetSeed (Seed.getBytes ()); // Modulgröße muss zwischen 512 und 1024 liegen und ein Vielfaches von 64 Keygen sein. Tastair keys = keygen.genkeypair (); PrivateKey privateKey = keys.getPrivate (); PublicKey PublicKey = Keys.getPublic (); Karte <String, Objekt> map = new HashMap <String, Objekt> (2); map.put (public_key, publicKey); map.put (private_key, privateKey); Rückgabekarte; } / *** generieren Sie den Standardschlüssel** @returnschlüsselobjekt* @throws Exception* / public static map <String, Objekt> InitKey () Ausnahme {return initKey (default_seed); } / ** * den privaten Schlüssel erhalten * * @param keymap * @return * @throws Exception * / public static String getPrivateKey (MAP <String, Object> Keymap) löst eine Ausnahme aus {Key Key = (Schlüssel) keymap.get (private_key); return Encryptbase64 (key.getEcoded ()); // Base64 Verschlüsselung privater Schlüssel}/** * den öffentlichen Schlüssel erhalten * * @param keymap * @return * @throws Exception */public static String getPublicke (MAP <string, Objekt> Keymap) löst Ausnahme aus {Key Key = (Key) keymap.get (public_key); return Encryptbase64 (key.getEcoded ()); // Base64 Verschlüsselung public Key}/** * Verwenden Sie den privaten Schlüssel, um die Informationen digital zu signieren byte [] keyBytes = decryptbase64 (privateKey); PKCS8EncodedKeySpec KeySpec = New PKCS8EncodedKeySpec (KeyBytes); KeyFactory factory = keyFactory.getInstance (KEY_ALGORITHM); Privatekey priikey = factory.generatePrivate (keyspec); // private Schlüssel // Digitsign -Informationen mit privaten Schlüssel Signature Signature = Signature.getInstance (Signature_Algorithmus) erstellen; Signature.initsign (priey); Signature.Update (Daten); return Encryptbase64 (Signature.Sign ()); } / *** Base64Encoder -Verschlüsselung* @param -Daten, die verschlüsselt werden sollen String enCodes = cccoder.encode (Daten); Return Encode; } / *** Base64DeCoder decrypt* @param data String, die entschlüsselt werden soll byte [] buffer = decoder.decodeBuffer (Daten); Rückpuffer; } / *** Überprüfen Sie die digitale Signatur* @param datenverschlüsselte Daten* @param publicKey* @param Sign digitales Signatur* @return* @throws Exception* / public static boolean verifizieren (byte [] data, String PublicKey, String Sign) Ausnahme {] byte [] keyBytes = decryptbase64 (publicKey); X509EncodedKeySpec keyspec = new x509EncodedKeySpec (KeyBytes); KEYFACTORY KEYFACTORY PublicKey pubkey = keyFactory.generatePublic (Keyspec); Signature Signatur = Signature.getInstance (Signature_Algorithmus); Signature.initverify (Pubkey); Signature.Update (Daten); Rückgabesignatur.Verify (decryptbase64 (Zeichen)); // Signatur überprüfen}}