C01 RSA-Verschlüsselung mit einem String

Wir starten mit einem Basismodell, welches alle Bestandteile der RSA-Routinen mitbringt. Aus Darstellungsgründen habe ich als Schlüssellänge 512 Bit gewählt, welche allerdings in der realen Welt niemals verwendet werden darf, da sie als unsicher einzustufen ist.

Ganz wichtig ist es, sich den Einsatz des Public und des Private Keys in Erinnerung zu rufen, da an dieser Stelle immer wieder Fehler gemacht werden. Bei der asymmetrischen Verschlüsselung veröffentlicht der (spätere) Empfänger der Nachricht seinen Public (öffentlichen) Schlüssel, z.B. auf seiner Webseite. Der Absender der geheimen Nachricht benutzt den Public Keys des Empfängers für die Verschlüsselung und sendet die verschlüsselte Nachricht (ciphertext) an den Empfänger. Der Empfänger entschlüsselt die geheime Nachricht mit seinem (und nur ihm bekannten) Private (privaten) Key.
Hier noch einmal die Kurzform: verschlüsseln mit dem Public Key, entschlüsseln mit dem Private Key.

Die maximal Größe des Klartextes hängt unmittelbar von der Länge des Schlüssels ab, beim hier genutzten Schlüssel von 512 Bit (=64 Byte) können maximal 53 Byte verschlüsselt werden. Bei einem längeren Klartext bricht das Programm mit einer Fehlermeldung ab – dieses simuliere ich im zweiten Beitrag zum RSA-Verfahren (C02 RSA maximaler Klartext).

Verschlüsselungssteckbrief
Name des Verfahrens	RSA
Langname	RSA Verschlüsselung
Art der Chiffre	Kompletter Plaintext
Blocklänge (Byte)	–
Schlüssellänge (Byte/Bit)	64/512, 128/1024, 256/2048, 512/4096, 1024/9192
Padding genutzt	Nein
Sicherheit	nur ab 2048 Bit Schlüssellänge
Besonderes	Geeignet nur für kleine Datenmengen

Bitte die nachfolgende Routine nicht für den Echteinsatz nutzen, da sie aus kryptographischer Sicht sehr angreifbar ist !

package net.bplaced.javacrypto.asymmetricencryption;

/*
* Herkunft/Origin: http://javacrypto.bplaced.net/
* Programmierer/Programmer: Michael Fehr
* Copyright/Copyright: frei verwendbares Programm (Public Domain)
* Copyright: This is free and unencumbered software released into the public domain.
* Lizenttext/Licence: <http://unlicense.org>
* getestet mit/tested with: Java Runtime Environment 8 Update 191 x64
* Datum/Date (dd.mm.jjjj): 21.12.2018 
* Funktion: verschlüsselt einen Text mittels RSA (Asymmetrisch)
* Function: encrypts a text string using RSA (asymmetric)
*
* Sicherheitshinweis/Security notice
* Die Programmroutinen dienen nur der Darstellung und haben keinen Anspruch auf eine 
* korrekte Funktion, insbesondere mit Blick auf die Sicherheit ! 
* Prüfen Sie die Sicherheit bevor das Programm in der echten Welt eingesetzt wird.
* The program routines just show the function but please be aware of the security part - 
* check yourself before using in the real world !
*/

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.xml.bind.DatatypeConverter;

public class C01_Rsa {

	public static void main(String[] args)
			throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeyException,
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
		System.out.println("C01 RSA Verschlüsselung mit einem String");

		String plaintextString = "Das ist die geheime Nachricht.";
		byte[] plaintextByte = plaintextString.getBytes("utf-8");
		byte[] ciphertextByte = null;
		byte[] decryptedtextByte = null;

		// erzeugung eines schlüsselpaares
		KeyPairGenerator rsaGenerator = KeyPairGenerator.getInstance("RSA");
		SecureRandom random = new SecureRandom();
		// schlüssellänge von 512 bit ist unsicher * BITTE NICHT VERWENDEN *
		// keylength of 512 bit is not secure * DO NOT USE *
		rsaGenerator.initialize(512, random);
		KeyPair rsaKeyPair = rsaGenerator.generateKeyPair();
		PublicKey rsaPublicKey = rsaKeyPair.getPublic();
		PrivateKey rsaPrivateKey = rsaKeyPair.getPrivate();

		// verschlüsselung mit dem öffentlichen schlüssel
		ciphertextByte = RsaEncrypt(plaintextByte, rsaPublicKey);
		// entschlüsselung mit dem privaten schlüssel
		decryptedtextByte = RsaDecrypt(ciphertextByte, rsaPrivateKey);

		System.out.println();
		System.out.println("RSA Schlüsselerzeugung");
		System.out.println("rsaPrivateKey (Byte) Länge:" + rsaPrivateKey.getEncoded().length + " Bytes");
		System.out.println(byteArrayPrint(rsaPrivateKey.getEncoded(), 33));
		System.out.println("rsaPublicKey (Byte)  Länge:" + rsaPublicKey.getEncoded().length + " Bytes");
		System.out.println(byteArrayPrint(rsaPublicKey.getEncoded(), 33));
		System.out.println();
		System.out.println("RSA Verschlüsselung");
		System.out.println("plaintextString    :" + plaintextString);
		System.out.println("plaintextByte      :" + DatatypeConverter.printHexBinary(plaintextByte));
		System.out.println("ciphertextByte     :");
		System.out.println(byteArrayPrint(ciphertextByte,33));
		System.out.println("decryptedtextByte  :" + DatatypeConverter.printHexBinary(decryptedtextByte));
		System.out.println("decryptedtextString:" + new String(decryptedtextByte));
		System.out.println();
	}

	public static byte[] RsaEncrypt(byte[] plaintextByte, PublicKey publicKey) throws NoSuchAlgorithmException,
			NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		byte[] ciphertextByte = null;
		Cipher encryptCipher = Cipher.getInstance("RSA");
		encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey);
		ciphertextByte = encryptCipher.doFinal(plaintextByte);
		return ciphertextByte;
	}

	public static byte[] RsaDecrypt(byte[] ciphertextByte, PrivateKey privateKey) throws NoSuchAlgorithmException,
			NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		byte[] decryptedtextByte = null;
		Cipher decryptCipher = Cipher.getInstance("RSA");
		decryptCipher.init(Cipher.DECRYPT_MODE, privateKey);
		decryptedtextByte = decryptCipher.doFinal(ciphertextByte);
		return decryptedtextByte;
	}

	public static String byteArrayPrint(byte[] byteData, int numberPerRow) {
		String returnString = "";
		String rawString = DatatypeConverter.printHexBinary(byteData);
		int rawLength = rawString.length();
		int i = 0;
		int j = 1;
		int z = 0;
		for (i = 0; i < rawLength; i++) {
			z++;
			returnString = returnString + rawString.charAt(i);
			if (j == 2) {
				returnString = returnString + " ";
				j = 0;
			}
			j++;
			if (z == (numberPerRow * 2)) {
				returnString = returnString + "\n";
				z = 0;
			}
		}
		return returnString;
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

package net.bplaced.javacrypto.asymmetricencryption;

* Herkunft/Origin: http://javacrypto.bplaced.net/

* Programmierer/Programmer: Michael Fehr

* Copyright/Copyright: frei verwendbares Programm (Public Domain)

* Copyright: This is free and unencumbered software released into the public domain.

* Lizenttext/Licence: <http://unlicense.org>

* getestet mit/tested with: Java Runtime Environment 8 Update 191 x64

* Datum/Date (dd.mm.jjjj): 21.12.2018

* Funktion: verschlüsselt einen Text mittels RSA (Asymmetrisch)

* Function: encrypts a text string using RSA (asymmetric)

* Sicherheitshinweis/Security notice

* Die Programmroutinen dienen nur der Darstellung und haben keinen Anspruch auf eine

* korrekte Funktion, insbesondere mit Blick auf die Sicherheit !

* Prüfen Sie die Sicherheit bevor das Programm in der echten Welt eingesetzt wird.

* The program routines just show the function but please be aware of the security part -

* check yourself before using in the real world !

import java.io.UnsupportedEncodingException;

import java.security.InvalidKeyException;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.NoSuchProviderException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.SecureRandom;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import javax.xml.bind.DatatypeConverter;

public class C01_Rsa {

public static void main(String[] args)

throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeyException,

NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {

System.out.println("C01 RSA Verschlüsselung mit einem String");

String plaintextString = "Das ist die geheime Nachricht.";

byte[] plaintextByte = plaintextString.getBytes("utf-8");

byte[] ciphertextByte = null;

byte[] decryptedtextByte = null;

// erzeugung eines schlüsselpaares

KeyPairGenerator rsaGenerator = KeyPairGenerator.getInstance("RSA");

SecureRandom random = new SecureRandom();

// schlüssellänge von 512 bit ist unsicher * BITTE NICHT VERWENDEN *

// keylength of 512 bit is not secure * DO NOT USE *

rsaGenerator.initialize(512, random);

KeyPair rsaKeyPair = rsaGenerator.generateKeyPair();

PublicKey rsaPublicKey = rsaKeyPair.getPublic();

PrivateKey rsaPrivateKey = rsaKeyPair.getPrivate();

// verschlüsselung mit dem öffentlichen schlüssel

ciphertextByte = RsaEncrypt(plaintextByte, rsaPublicKey);

// entschlüsselung mit dem privaten schlüssel

decryptedtextByte = RsaDecrypt(ciphertextByte, rsaPrivateKey);

System.out.println();

System.out.println("RSA Schlüsselerzeugung");

System.out.println("rsaPrivateKey (Byte) Länge:" + rsaPrivateKey.getEncoded().length + " Bytes");

System.out.println(byteArrayPrint(rsaPrivateKey.getEncoded(), 33));

System.out.println("rsaPublicKey (Byte) Länge:" + rsaPublicKey.getEncoded().length + " Bytes");

System.out.println(byteArrayPrint(rsaPublicKey.getEncoded(), 33));

System.out.println();

System.out.println("RSA Verschlüsselung");

System.out.println("plaintextString :" + plaintextString);

System.out.println("plaintextByte :" + DatatypeConverter.printHexBinary(plaintextByte));

System.out.println("ciphertextByte :");

System.out.println(byteArrayPrint(ciphertextByte,33));

System.out.println("decryptedtextByte :" + DatatypeConverter.printHexBinary(decryptedtextByte));

System.out.println("decryptedtextString:" + new String(decryptedtextByte));

System.out.println();

}

public static byte[] RsaEncrypt(byte[] plaintextByte, PublicKey publicKey) throws NoSuchAlgorithmException,

NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {

byte[] ciphertextByte = null;

Cipher encryptCipher = Cipher.getInstance("RSA");

encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey);

ciphertextByte = encryptCipher.doFinal(plaintextByte);

return ciphertextByte;

}

public static byte[] RsaDecrypt(byte[] ciphertextByte, PrivateKey privateKey) throws NoSuchAlgorithmException,

NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {

byte[] decryptedtextByte = null;

Cipher decryptCipher = Cipher.getInstance("RSA");

decryptCipher.init(Cipher.DECRYPT_MODE, privateKey);

decryptedtextByte = decryptCipher.doFinal(ciphertextByte);

return decryptedtextByte;

}

public static String byteArrayPrint(byte[] byteData, int numberPerRow) {

String returnString = "";

String rawString = DatatypeConverter.printHexBinary(byteData);

int rawLength = rawString.length();

int i = 0;

int j = 1;

int z = 0;

for (i = 0; i < rawLength; i++) {

z++;

returnString = returnString + rawString.charAt(i);

if (j == 2) {

returnString = returnString + " ";

j = 0;

}

j++;

if (z == (numberPerRow * 2)) {

returnString = returnString + "\n";

z = 0;

}

return returnString;

}

Die Konsole gibt Euch diese Daten aus (Hinweis: die erzeugten Schlüssel wurden aus Zufallszahlen erzeugt, damit ist auch der Ciphertext bei jedem Lauf des Programms unterschiedlich):

C01 RSA Verschlüsselung  mit einem String

RSA Schlüsselerzeugung
rsaPrivateKey (Byte) Länge:346 Bytes
30 82 01 56 02 01 00 30 0D 06 09 2A 86 48 86 F7 0D 01 01 01 05 00 04 82 01 40 30 82 01 3C 02 01 00 
02 41 00 B6 48 FE 66 5A F7 9F 1A 80 F2 19 AC CA E4 2F 42 B3 20 0D 9A EB E2 B1 94 7F 8B E8 6F AE A2 
7E E9 B4 29 D1 7F B5 82 BF D6 EF B8 57 71 A1 22 05 D9 A3 BD E2 24 76 E1 95 7C D0 30 CE 63 77 C7 5C 
4D 02 03 01 00 01 02 41 00 8E 3D 09 1E 4F 8F 77 BC 53 B0 16 AE C9 A7 22 E5 B6 26 A5 D7 24 87 C1 2F 
F2 12 F7 2D E6 A4 6F C8 93 F2 79 02 40 16 78 FA 9F D1 F2 4A 92 24 71 AA 0F FA 79 38 F9 3C 05 DE 7B 
8B C7 BF BE E8 6D 95 02 21 00 F2 2D 3B 75 49 3A A6 B7 66 11 E1 43 99 2E 15 C4 2D 03 17 26 2D 7E B6 
52 72 69 2B F8 E9 A9 99 03 02 21 00 C0 B0 9B 15 46 82 0D 46 0A 21 65 C5 CE 02 3E EF 6C DD 7F 8F AA 
E7 04 C7 1C 6A 66 E1 F6 D0 AC 6F 02 21 00 9B 25 51 1F 0D 3F CE C8 55 52 85 0E AA 56 74 C9 4D D0 DA 
06 B2 44 A8 06 DF 96 F2 FD AE AB E1 03 02 20 75 CB 81 03 00 97 80 85 D0 AB 9A 0B D2 64 8D 14 D0 F8 
97 82 BC 77 7D F4 3A EA D0 FA 52 68 3F 01 02 21 00 CC 6B F4 06 72 16 C3 AC F0 55 E7 12 35 3D 6F 26 
CE 48 5A 6C 80 25 0E 89 F9 C1 56 F2 CF 60 7C 07 
rsaPublicKey (Byte)  Länge:94 Bytes
30 5C 30 0D 06 09 2A 86 48 86 F7 0D 01 01 01 05 00 03 4B 00 30 48 02 41 00 B6 48 FE 66 5A F7 9F 1A 
80 F2 19 AC CA E4 2F 42 B3 20 0D 9A EB E2 B1 94 7F 8B E8 6F AE A2 7E E9 B4 29 D1 7F B5 82 BF D6 EF 
B8 57 71 A1 22 05 D9 A3 BD E2 24 76 E1 95 7C D0 30 CE 63 77 C7 5C 4D 02 03 01 00 01 

RSA Verschlüsselung
plaintextString    :Das ist die geheime Nachricht.
plaintextByte      :44617320697374206469652067656865696D65204E61636872696368742E
ciphertextByte     :
A1 41 D0 DE 47 81 FF 3C AC 65 C3 72 A4 8E B6 33 B1 A8 73 7D BE 09 15 BE 80 92 C6 0E 2E A4 2D 08 04 
E5 8E 3C F2 08 73 F1 AD F8 64 7D 02 1E C4 F2 17 CA 46 A1 E4 CB C2 A6 E1 88 1A 68 2A D2 9B 97 
decryptedtextByte  :44617320697374206469652067656865696D65204E61636872696368742E
decryptedtextString:Das ist die geheime Nachricht.

C01 RSA Verschlüsselung mit einem String

RSA Schlüsselerzeugung

rsaPrivateKey (Byte) Länge:346 Bytes

30 82 01 56 02 01 00 30 0D 06 09 2A 86 48 86 F7 0D 01 01 01 05 00 04 82 01 40 30 82 01 3C 02 01 00

02 41 00 B6 48 FE 66 5A F7 9F 1A 80 F2 19 AC CA E4 2F 42 B3 20 0D 9A EB E2 B1 94 7F 8B E8 6F AE A2

7E E9 B4 29 D1 7F B5 82 BF D6 EF B8 57 71 A1 22 05 D9 A3 BD E2 24 76 E1 95 7C D0 30 CE 63 77 C7 5C

4D 02 03 01 00 01 02 41 00 8E 3D 09 1E 4F 8F 77 BC 53 B0 16 AE C9 A7 22 E5 B6 26 A5 D7 24 87 C1 2F

F2 12 F7 2D E6 A4 6F C8 93 F2 79 02 40 16 78 FA 9F D1 F2 4A 92 24 71 AA 0F FA 79 38 F9 3C 05 DE 7B

8B C7 BF BE E8 6D 95 02 21 00 F2 2D 3B 75 49 3A A6 B7 66 11 E1 43 99 2E 15 C4 2D 03 17 26 2D 7E B6

52 72 69 2B F8 E9 A9 99 03 02 21 00 C0 B0 9B 15 46 82 0D 46 0A 21 65 C5 CE 02 3E EF 6C DD 7F 8F AA

E7 04 C7 1C 6A 66 E1 F6 D0 AC 6F 02 21 00 9B 25 51 1F 0D 3F CE C8 55 52 85 0E AA 56 74 C9 4D D0 DA

06 B2 44 A8 06 DF 96 F2 FD AE AB E1 03 02 20 75 CB 81 03 00 97 80 85 D0 AB 9A 0B D2 64 8D 14 D0 F8

97 82 BC 77 7D F4 3A EA D0 FA 52 68 3F 01 02 21 00 CC 6B F4 06 72 16 C3 AC F0 55 E7 12 35 3D 6F 26

CE 48 5A 6C 80 25 0E 89 F9 C1 56 F2 CF 60 7C 07

rsaPublicKey (Byte) Länge:94 Bytes

30 5C 30 0D 06 09 2A 86 48 86 F7 0D 01 01 01 05 00 03 4B 00 30 48 02 41 00 B6 48 FE 66 5A F7 9F 1A

80 F2 19 AC CA E4 2F 42 B3 20 0D 9A EB E2 B1 94 7F 8B E8 6F AE A2 7E E9 B4 29 D1 7F B5 82 BF D6 EF

B8 57 71 A1 22 05 D9 A3 BD E2 24 76 E1 95 7C D0 30 CE 63 77 C7 5C 4D 02 03 01 00 01

RSA Verschlüsselung

plaintextString :Das ist die geheime Nachricht.

plaintextByte :44617320697374206469652067656865696D65204E61636872696368742E

ciphertextByte :

A1 41 D0 DE 47 81 FF 3C AC 65 C3 72 A4 8E B6 33 B1 A8 73 7D BE 09 15 BE 80 92 C6 0E 2E A4 2D 08 04

E5 8E 3C F2 08 73 F1 AD F8 64 7D 02 1E C4 F2 17 CA 46 A1 E4 CB C2 A6 E1 88 1A 68 2A D2 9B 97

decryptedtextByte :44617320697374206469652067656865696D65204E61636872696368742E

decryptedtextString:Das ist die geheime Nachricht.

Die Lizenz zum obigen Beispiel findet Ihr auf der eigenen Lizenz-Seite.

Letzte Aktualisierung: 21.12.2018