B09 AES Modus CBC PKCS5Padding Zufalls-Initvektor Datei

Da die verschlüsselten Daten sehr häufig per Mail oder eine Webseite verschickt werden oder die Datenmenge größer ist, ist die Verschlüsselung einer ganzen Datei wünschenswert. Das nachfolgende Beispiel zeigt Euch, wie Ihr das mit der bekannten Methode aus Beispiel B08 hin bekommt.

Noch ein kleiner aber wichtiger Hinweis: damit der Empfänger der verschlüsselten Nachricht diese auch entschlüsseln kann, benötigt er neben dem Passwort auch den genutzten Initialisierungsvektor (iV). Dieser ist (im Gegensatz zum Passwort) aber nicht geheim und kann somit zusammen mit den verschlüsselten Daten verschickt werden.

Zum Test solltet Ihr eine einfache Textdatei mit dem Namen „b09_test.txt“ anlegen, welche Ihr z.B. hier herunterladen könnt. Im Beispiel B05 ist beschrieben, wo die Datei in Eclipse liegen sollte.

Ich empfehle Euch den ergänzenden Blick in die 2. Seite, denn dort wird gezeigt, wie der Initialisierungsvektor mit in der verschlüsselten Datei gespeichert und bei der Entschlüsselung wieder eingelesen wird – das erspart Euch die mühevolle und fehlerträchtige manuelle Weitergabe des Initialisierungsvektors.

Hier der Steckbrief des Verfahrens:

Verschlüsselungssteckbrief
Name des Verfahrens	AES/CBC/PKCS5PADDING
Langname	CBC Cipher Block Chaining
Art der Chiffre	Blockchiffre
Blocklänge (Byte)	16
Schlüssellänge (Byte/Bit)	16/128, 24/192, 32/256
Padding genutzt	Ja
Sicherheit	sicher bei Nutzung von unterschiedlichen Initialvektoren
Besonderes	Benötigt einen Initialvektor, der als Zufallszahl erzeugt wird.

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

package net.bplaced.javacrypto.symmetricencryption;

/*
* 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): 01.11.2018 
* Funktion: liest eine datei und verschlüsselt sie im aes cbc modus pkcs5 padding
* Function: encrypts a file using aes cbc modus with pkcs5 padding
*
* 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.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;

public class B09_AesCbcPkcs5PaddingRandomFile {

	public static void main(String[] args)
			throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
			IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
		System.out.println("B09 AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei");
		// es werden ein paar variablen benötigt:
		String dateinameReadString = "b09_test.txt"; // aus der datei wird das plaintextByte eingelesen
		String dateinameWriteString = "b09_test.enc"; // in diese datei wird das ciphertextByte geschrieben

		String plaintextString = ""; // die daten werden aus der datei gelesen
		byte[] plaintextByte = null; // die daten werden aus der datei gelesen

		String decryptedtextString = ""; // enthält später den entschlüsselten text

		// zuerst testen wir ob die einzulesende datei existiert
		if (FileExistsCheck(dateinameReadString) == false) {
			System.out.println("Die Datei " + dateinameReadString + " existiert nicht. Das Programm wird beendet.");
			System.exit(0);
		};

		// datei in byte array einlesen
		plaintextByte = readBytesFromFileNio(dateinameReadString);
		plaintextString = new String(plaintextByte, "UTF-8"); // die umwandlung erfolgt nur zur späteren anzeige

		// diese konstanten und variablen benötigen wir zur ver- und entschlüsselung
		// der schlüssel ist exakt 32 zeichen lang und bestimmt die stärke der
		// verschlüsselung
		// mögliche schlüssellängen sind 16 byte (128 bit), 24 byte (192 bit) und 32
		// byte (256 bit)
		// final byte[] keyByte = "1234567890123456".getBytes("UTF-8"); // 16 byte
		final byte[] keyByte = "12345678901234567890123456789012".getBytes("UTF-8"); // 32 byte
		// der initialisierungsvektor ist exakt 16 zeichen lang
		final byte[] initvectorByte = new byte[16];
		SecureRandom secureRandom = new SecureRandom();
		secureRandom.nextBytes(initvectorByte);

		// der verschluesselte (encrypted) text kommt in diese variable in form eines
		// byte arrays
		byte[] ciphertextByte = null; // die länge steht noch nicht fest, da sie von der größe des plaintextes abhängt
		// der entschlüsselte (decrypted) text kommt in dieses byte array, welches
		// später in einen string umkodiert wird
		byte[] decryptedtextByte = null; // die länge steht noch nicht fest, da sie von der größe des plaintextes
											// abhängt

		// ab hier arbeiten wir nun im verschlüsselungsmodus
		// umwandlung des klartextes in ein byte array
		plaintextByte = plaintextString.getBytes("UTF-8");
		// der schlüssel wird in die richtige form gebracht
		SecretKeySpec keySpec = new SecretKeySpec(keyByte, "AES");
		// der initvector wird in die richtige form gebracht
		IvParameterSpec ivKeySpec = new IvParameterSpec(initvectorByte);
		// die verschlüsselungsroutine wird mit dem gewünschten parameter erstellt
		Cipher aesCipherEnc = Cipher.getInstance("AES/CBC/PKCS5PADDING");
		// nun wird die routine mit dem schlüssel initialisiert
		aesCipherEnc.init(Cipher.ENCRYPT_MODE, keySpec, ivKeySpec);
		// hier erfolgt nun die verschlüsselung des plaintextes
		ciphertextByte = aesCipherEnc.doFinal(plaintextByte);

		// byte array in eine datei schreiben
		writeBytesToFileNio(ciphertextByte, dateinameWriteString);

		System.out.println("");
		System.out.println("Klartextdaten einlesen und als verschlüsselte Datei speichern");
		System.out.println("keyByte (hex)          :" + DatatypeConverter.printHexBinary(keyByte));
		System.out.println("initvectorByte (hex)   :" + DatatypeConverter.printHexBinary(initvectorByte));
		System.out.println("Dateiname Lesen        :" + dateinameReadString);
		System.out.println("Dateiname Schreiben    :" + dateinameWriteString);
		System.out.println("plaintextByte (hex)    :" + DatatypeConverter.printHexBinary(plaintextByte));
		System.out.println("plaintextString        :" + plaintextString);
		System.out.println("= = = Verschlüsselung = = =");
		System.out.println("ciphertextByte (hex)   :" + DatatypeConverter.printHexBinary(ciphertextByte));

		// ab hier arbeiten wir nun im entschlüsselungsmodus
		// wir starten die entschlüsselung mit einem leeren ciphertext
		ciphertextByte = null;

		// byte array einlesen
		dateinameReadString = "b09_test.enc"; // ciphertextByte lesen
		dateinameWriteString = "b09_test.dec"; // decryptedtextByte schreiben

		// zuerst testen wir ob die einzulesende datei existiert
		if (FileExistsCheck(dateinameReadString) == false) {
			System.out.println("Die Datei " + dateinameReadString + " existiert nicht. Das Programm wird beendet.");
			System.exit(0);
		};
		// das ciphertextByte wird aus der datei gelesen
		ciphertextByte = readBytesFromFileNio(dateinameReadString);

		// die verschlüsselungsroutine wird mit dem gewünschten parameter erstellt
		Cipher aesCipherDec = Cipher.getInstance("AES/CBC/PKCS5PADDING");
		// zum einsatz kommt derselbe schlüssel, daher symmetrische verschlüsselung
		// achtung: hier wird der DECRYPT_MODE = entschlüsselung genutzt
		aesCipherDec.init(Cipher.DECRYPT_MODE, keySpec, ivKeySpec);
		// nun wird der ciphertext wieder entschlüsselt
		decryptedtextByte = aesCipherDec.doFinal(ciphertextByte);

		// wir schreiben die entschlüsselten daten in eine datei
		writeBytesToFileNio(decryptedtextByte, dateinameWriteString);

		// zurück-kodierung des byte array in text
		decryptedtextString = new String(decryptedtextByte, "UTF-8");

		// ausgabe der variablen
		System.out.println("");
		System.out.println("keyByte (hex)          :" + DatatypeConverter.printHexBinary(keyByte));
		System.out.println("Dateiname Lesen        :" + dateinameReadString);
		System.out.println("Dateiname Schreiben    :" + dateinameWriteString);
		System.out.println("initvectorByte (hex)   :" + DatatypeConverter.printHexBinary(initvectorByte));
		System.out.println("plaintextString        :" + plaintextString);
		System.out.println("plaintextByte (hex)    :" + DatatypeConverter.printHexBinary(plaintextByte));
		System.out.println("= = = Verschlüsselung = = =");
		System.out.println("ciphertextByte (hex)   :" + DatatypeConverter.printHexBinary(ciphertextByte));
		System.out.println("= = = Entschlüsselung = = =");
		System.out.println("decryptedtextByte (hex):" + DatatypeConverter.printHexBinary(decryptedtextByte));
		System.out.println("decryptedtextString    :" + decryptedtextString);
	}

	private static boolean FileExistsCheck(String dateinameString) {
		return Files.exists(Paths.get(dateinameString), new LinkOption[] { LinkOption.NOFOLLOW_LINKS });
	}

	private static void writeBytesToFileNio(byte[] byteToFileByte, String filenameString) {
		try {
			Path path = Paths.get(filenameString);
			Files.write(path, byteToFileByte);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private static byte[] readBytesFromFileNio(String filenameString) {
		byte[] byteFromFileByte = null;
		try {
			byteFromFileByte = Files.readAllBytes(Paths.get(filenameString));
		} catch (IOException e) {
			e.printStackTrace();
		}
		return byteFromFileByte;
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

package net.bplaced.javacrypto.symmetricencryption;

* 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): 01.11.2018

* Funktion: liest eine datei und verschlüsselt sie im aes cbc modus pkcs5 padding

* Function: encrypts a file using aes cbc modus with pkcs5 padding

* 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.IOException;

import java.io.UnsupportedEncodingException;

import java.nio.file.Files;

import java.nio.file.LinkOption;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.security.InvalidAlgorithmParameterException;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.spec.IvParameterSpec;

import javax.crypto.spec.SecretKeySpec;

import javax.xml.bind.DatatypeConverter;

public class B09_AesCbcPkcs5PaddingRandomFile {

public static void main(String[] args)

throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,

IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {

System.out.println("B09 AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei");

// es werden ein paar variablen benötigt:

String dateinameReadString = "b09_test.txt"; // aus der datei wird das plaintextByte eingelesen

String dateinameWriteString = "b09_test.enc"; // in diese datei wird das ciphertextByte geschrieben

String plaintextString = ""; // die daten werden aus der datei gelesen

byte[] plaintextByte = null; // die daten werden aus der datei gelesen

String decryptedtextString = ""; // enthält später den entschlüsselten text

// zuerst testen wir ob die einzulesende datei existiert

if (FileExistsCheck(dateinameReadString) == false) {

System.out.println("Die Datei " + dateinameReadString + " existiert nicht. Das Programm wird beendet.");

System.exit(0);

};

// datei in byte array einlesen

plaintextByte = readBytesFromFileNio(dateinameReadString);

plaintextString = new String(plaintextByte, "UTF-8"); // die umwandlung erfolgt nur zur späteren anzeige

// diese konstanten und variablen benötigen wir zur ver- und entschlüsselung

// der schlüssel ist exakt 32 zeichen lang und bestimmt die stärke der

// verschlüsselung

// mögliche schlüssellängen sind 16 byte (128 bit), 24 byte (192 bit) und 32

// byte (256 bit)

// final byte[] keyByte = "1234567890123456".getBytes("UTF-8"); // 16 byte

final byte[] keyByte = "12345678901234567890123456789012".getBytes("UTF-8"); // 32 byte

// der initialisierungsvektor ist exakt 16 zeichen lang

final byte[] initvectorByte = new byte[16];

SecureRandom secureRandom = new SecureRandom();

secureRandom.nextBytes(initvectorByte);

// der verschluesselte (encrypted) text kommt in diese variable in form eines

// byte arrays

byte[] ciphertextByte = null; // die länge steht noch nicht fest, da sie von der größe des plaintextes abhängt

// der entschlüsselte (decrypted) text kommt in dieses byte array, welches

// später in einen string umkodiert wird

byte[] decryptedtextByte = null; // die länge steht noch nicht fest, da sie von der größe des plaintextes

// abhängt

// ab hier arbeiten wir nun im verschlüsselungsmodus

// umwandlung des klartextes in ein byte array

plaintextByte = plaintextString.getBytes("UTF-8");

// der schlüssel wird in die richtige form gebracht

SecretKeySpec keySpec = new SecretKeySpec(keyByte, "AES");

// der initvector wird in die richtige form gebracht

IvParameterSpec ivKeySpec = new IvParameterSpec(initvectorByte);

// die verschlüsselungsroutine wird mit dem gewünschten parameter erstellt

Cipher aesCipherEnc = Cipher.getInstance("AES/CBC/PKCS5PADDING");

// nun wird die routine mit dem schlüssel initialisiert

aesCipherEnc.init(Cipher.ENCRYPT_MODE, keySpec, ivKeySpec);

// hier erfolgt nun die verschlüsselung des plaintextes

ciphertextByte = aesCipherEnc.doFinal(plaintextByte);

// byte array in eine datei schreiben

writeBytesToFileNio(ciphertextByte, dateinameWriteString);

System.out.println("");

System.out.println("Klartextdaten einlesen und als verschlüsselte Datei speichern");

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

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

System.out.println("Dateiname Lesen :" + dateinameReadString);

System.out.println("Dateiname Schreiben :" + dateinameWriteString);

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

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

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

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

// ab hier arbeiten wir nun im entschlüsselungsmodus

// wir starten die entschlüsselung mit einem leeren ciphertext

ciphertextByte = null;

// byte array einlesen

dateinameReadString = "b09_test.enc"; // ciphertextByte lesen

dateinameWriteString = "b09_test.dec"; // decryptedtextByte schreiben

// zuerst testen wir ob die einzulesende datei existiert

if (FileExistsCheck(dateinameReadString) == false) {

System.out.println("Die Datei " + dateinameReadString + " existiert nicht. Das Programm wird beendet.");

System.exit(0);

};

// das ciphertextByte wird aus der datei gelesen

ciphertextByte = readBytesFromFileNio(dateinameReadString);

// die verschlüsselungsroutine wird mit dem gewünschten parameter erstellt

Cipher aesCipherDec = Cipher.getInstance("AES/CBC/PKCS5PADDING");

// zum einsatz kommt derselbe schlüssel, daher symmetrische verschlüsselung

// achtung: hier wird der DECRYPT_MODE = entschlüsselung genutzt

aesCipherDec.init(Cipher.DECRYPT_MODE, keySpec, ivKeySpec);

// nun wird der ciphertext wieder entschlüsselt

decryptedtextByte = aesCipherDec.doFinal(ciphertextByte);

// wir schreiben die entschlüsselten daten in eine datei

writeBytesToFileNio(decryptedtextByte, dateinameWriteString);

// zurück-kodierung des byte array in text

decryptedtextString = new String(decryptedtextByte, "UTF-8");

// ausgabe der variablen

System.out.println("");

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

System.out.println("Dateiname Lesen :" + dateinameReadString);

System.out.println("Dateiname Schreiben :" + dateinameWriteString);

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

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

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

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

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

System.out.println("= = = Entschlüsselung = = =");

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

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

}

private static boolean FileExistsCheck(String dateinameString) {

return Files.exists(Paths.get(dateinameString), new LinkOption[] { LinkOption.NOFOLLOW_LINKS });

}

private static void writeBytesToFileNio(byte[] byteToFileByte, String filenameString) {

try {

Path path = Paths.get(filenameString);

Files.write(path, byteToFileByte);

} catch (IOException e) {

e.printStackTrace();

}

private static byte[] readBytesFromFileNio(String filenameString) {

byte[] byteFromFileByte = null;

try {

byteFromFileByte = Files.readAllBytes(Paths.get(filenameString));

} catch (IOException e) {

e.printStackTrace();

}

return byteFromFileByte;

}

Die Konsole gibt Euch diese Ausgaben (bitte dran denken: der Initialisierungsvektor ist eine Zufallszahl, daher werden Eure Daten etwas anders aussehen als auf dem Screenshot:

B09 AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei

Klartextdaten einlesen und als verschlüsselte Datei speichern
keyByte (hex)          :3132333435363738393031323334353637383930313233343536373839303132
initvectorByte (hex)   :54B7E0235496BD09E1DE8A7D2CD2F53B
Dateiname Lesen        :b09_test.txt
Dateiname Schreiben    :b09_test.enc
plaintextByte (hex)    :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E
plaintextString        :Dieses ist eine Testdatei mit 84 Zeichen, die am 27.10.2018 gespeichert worden ist.
= = = Verschlüsselung = = =
ciphertextByte (hex)   :F6A4EE8D0A22A46C04329C7E194697BCB0B288A95FAF538FEDA191D8E88B2991CB08EA7E957F1AEAD2B4A49A820218A47C4C2028783123A8518355B89E9266FD5D57F58F25459F7089AE0952D30C65AC7233E183CC757747C897F8B6A76B7E80

keyByte (hex)          :3132333435363738393031323334353637383930313233343536373839303132
Dateiname Lesen        :b09_test.enc
Dateiname Schreiben    :b09_test.dec
initvectorByte (hex)   :54B7E0235496BD09E1DE8A7D2CD2F53B
plaintextString        :Dieses ist eine Testdatei mit 84 Zeichen, die am 27.10.2018 gespeichert worden ist.
plaintextByte (hex)    :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E
= = = Verschlüsselung = = =
ciphertextByte (hex)   :F6A4EE8D0A22A46C04329C7E194697BCB0B288A95FAF538FEDA191D8E88B2991CB08EA7E957F1AEAD2B4A49A820218A47C4C2028783123A8518355B89E9266FD5D57F58F25459F7089AE0952D30C65AC7233E183CC757747C897F8B6A76B7E80
= = = Entschlüsselung = = =
decryptedtextByte (hex):446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E
decryptedtextString    :Dieses ist eine Testdatei mit 84 Zeichen, die am 27.10.2018 gespeichert worden ist.

B09 AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei

Klartextdaten einlesen und als verschlüsselte Datei speichern

keyByte (hex) :3132333435363738393031323334353637383930313233343536373839303132

initvectorByte (hex) :54B7E0235496BD09E1DE8A7D2CD2F53B

Dateiname Lesen :b09_test.txt

Dateiname Schreiben :b09_test.enc

plaintextByte (hex) :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E

plaintextString :Dieses ist eine Testdatei mit 84 Zeichen, die am 27.10.2018 gespeichert worden ist.

= = = Verschlüsselung = = =

ciphertextByte (hex) :F6A4EE8D0A22A46C04329C7E194697BCB0B288A95FAF538FEDA191D8E88B2991CB08EA7E957F1AEAD2B4A49A820218A47C4C2028783123A8518355B89E9266FD5D57F58F25459F7089AE0952D30C65AC7233E183CC757747C897F8B6A76B7E80

keyByte (hex) :3132333435363738393031323334353637383930313233343536373839303132

Dateiname Lesen :b09_test.enc

Dateiname Schreiben :b09_test.dec

initvectorByte (hex) :54B7E0235496BD09E1DE8A7D2CD2F53B

plaintextString :Dieses ist eine Testdatei mit 84 Zeichen, die am 27.10.2018 gespeichert worden ist.

plaintextByte (hex) :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E

= = = Verschlüsselung = = =

= = = Entschlüsselung = = =

decryptedtextByte (hex):446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E

decryptedtextString :Dieses ist eine Testdatei mit 84 Zeichen, die am 27.10.2018 gespeichert worden ist.

Nun noch die Variante mit Nutzung von Methoden.
Bitte die nachfolgende Routine nicht für den Echteinsatz nutzen, da sie aus kryptographischer Sicht sehr angreifbar ist !

package net.bplaced.javacrypto.symmetricencryption;

/*
* 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): 01.11.2018 
* Funktion: liest eine datei und verschlüsselt sie im aes cbc modus pkcs5 padding
* Function: encrypts a file using aes cbc modus with pkcs5 padding
*
* 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.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;

public class B09b_AesCbcPkcs5PaddingRandomFile {

	public static void main(String[] args)
			throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
			IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
		System.out.println("B09b AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei");
		// es werden ein paar variablen benötigt:
		String dateinameReadString = "b09_test.txt"; // aus der datei wird das plaintextByte eingelesen
		String dateinameWriteString = "b09b_test.enc"; // in diese datei wird das ciphertextByte geschrieben

		String plaintextString = ""; // die daten werden aus der datei gelesen
		byte[] plaintextByte = null; // die daten werden aus der datei gelesen

		String decryptedtextString = ""; // enthält später den entschlüsselten text

		// zuerst testen wir ob die einzulesende datei existiert
		if (FileExistsCheck(dateinameReadString) == false) {
			System.out.println("Die Datei " + dateinameReadString + " existiert nicht. Das Programm wird beendet.");
			System.exit(0);
		};

		// datei in byte array einlesen
		plaintextByte = readBytesFromFileNio(dateinameReadString);
		plaintextString = new String(plaintextByte, "UTF-8"); // die umwandlung erfolgt nur zur späteren anzeige

		// diese konstanten und variablen benötigen wir zur ver- und entschlüsselung
		// der schlüssel ist exakt 32 zeichen lang und bestimmt die stärke der
		// verschlüsselung
		// hier ist der schlüssel 32 byte = 256 bit lang
		// mögliche schlüssellängen sind 16 byte (128 bit), 24 byte (192 bit) und 32
		// byte (256 bit)
		// final byte[] keyByte = "1234567890123456".getBytes("UTF-8"); // 16 byte
		final byte[] keyByte = "12345678901234567890123456789012".getBytes("UTF-8"); // 32 byte
		// der initialisierungsvektor ist exakt 16 zeichen lang
		final byte[] initvectorByte = new byte[16];
		SecureRandom secureRandom = new SecureRandom();
		secureRandom.nextBytes(initvectorByte);

		// der verschluesselte (encrypted) text kommt in diese variable in form eines
		// byte arrays
		byte[] ciphertextByte = null; // die länge steht noch nicht fest, da sie von der größe des plaintextes abhängt
		// der entschlüsselte (decrypted) text kommt in dieses byte array, welches
		// später in einen string umkodiert wird
		byte[] decryptedtextByte = null; // die länge steht noch nicht fest, da sie von der größe des plaintextes
											// abhängt

		// ab hier arbeiten wir nun im verschlüsselungsmodus
		// umwandlung des klartextes in ein byte array
		plaintextByte = plaintextString.getBytes("UTF-8");
		// hier erfolgt nun die verschlüsselung des plaintextes
		ciphertextByte = AesCbcPaddingEncrypt(plaintextByte, keyByte, initvectorByte);

		// byte array in eine datei schreiben
		writeBytesToFileNio(ciphertextByte, dateinameWriteString);

		System.out.println("");
		System.out.println("Klartextdaten einlesen und als verschlüsselte Datei speichern");
		System.out.println("keyByte (hex)          :" + DatatypeConverter.printHexBinary(keyByte));
		System.out.println("initvectorByte (hex)   :" + DatatypeConverter.printHexBinary(initvectorByte));
		System.out.println("Dateiname Lesen        :" + dateinameReadString);
		System.out.println("Dateiname Schreiben    :" + dateinameWriteString);
		System.out.println("plaintextByte (hex)    :" + DatatypeConverter.printHexBinary(plaintextByte));
		System.out.println("plaintextString        :" + plaintextString);
		System.out.println("= = = Verschlüsselung = = =");
		System.out.println("ciphertextByte (hex)   :" + DatatypeConverter.printHexBinary(ciphertextByte));

		// ab hier arbeiten wir nun im entschlüsselungsmodus
		// wir starten die entschlüsselung mit einem leeren ciphertext
		ciphertextByte = null;

		// byte array einlesen
		dateinameReadString = "b09b_test.enc"; // ciphertextByte lesen
		dateinameWriteString = "b09b_test.dec"; // decryptedtextByte schreiben

		// zuerst testen wir ob die einzulesende datei existiert
		if (FileExistsCheck(dateinameReadString) == false) {
			System.out.println("Die Datei " + dateinameReadString + " existiert nicht. Das Programm wird beendet.");
			System.exit(0);
		};
		
		// das ciphertextByte wird aus der datei gelesen
		ciphertextByte = readBytesFromFileNio(dateinameReadString);

		// nun wird der ciphertext wieder entschlüsselt
		decryptedtextByte = AesCbcPaddingDecrypt(ciphertextByte, keyByte, initvectorByte);

		// wir schreiben die entschlüsselten daten in eine datei
		writeBytesToFileNio(decryptedtextByte, dateinameWriteString);

		// zurück-kodierung des byte array in text
		decryptedtextString = new String(decryptedtextByte, "UTF-8");

		// ausgabe der variablen
		System.out.println("");
		System.out.println("keyByte (hex)          :" + DatatypeConverter.printHexBinary(keyByte));
		System.out.println("Dateiname Lesen        :" + dateinameReadString);
		System.out.println("Dateiname Schreiben    :" + dateinameWriteString);
		System.out.println("initvectorByte (hex)   :" + DatatypeConverter.printHexBinary(initvectorByte));
		System.out.println("plaintextString        :" + plaintextString);
		System.out.println("plaintextByte (hex)    :" + DatatypeConverter.printHexBinary(plaintextByte));
		System.out.println("= = = Verschlüsselung = = =");
		System.out.println("ciphertextByte (hex)   :" + DatatypeConverter.printHexBinary(ciphertextByte));
		System.out.println("= = = Entschlüsselung = = =");
		System.out.println("decryptedtextByte (hex):" + DatatypeConverter.printHexBinary(decryptedtextByte));
		System.out.println("decryptedtextString    :" + decryptedtextString);
	}
	
	public static byte[] AesCbcPaddingEncrypt(byte[] plaintextByte, byte[] keyByte, byte[] initvectorByte)
			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
			InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
		// der genutzte algorithmus
		final String AESMODE_CBC_PKCS5PADDING = "AES/CBC/PKCS5PADDING";
		byte[] ciphertextByte = null;
		// der schlüssel wird in die richtige form gebracht
		SecretKeySpec keySpec = new SecretKeySpec(keyByte, "AES");
		// der initvector wird in die richtige form gebracht
		IvParameterSpec ivKeySpec = new IvParameterSpec(initvectorByte);
		// die verschlüsselungsroutine wird mit dem gewünschten parameter erstellt
		Cipher aesCipherEnc = Cipher.getInstance(AESMODE_CBC_PKCS5PADDING);
		// nun wird die routine mit dem schlüssel initialisiert
		aesCipherEnc.init(Cipher.ENCRYPT_MODE, keySpec, ivKeySpec);
		// hier erfolgt nun die verschlüsselung des plaintextes
		ciphertextByte = aesCipherEnc.doFinal(plaintextByte);
		return ciphertextByte;
	}

	public static byte[] AesCbcPaddingDecrypt(byte[] ciphertextByte, byte[] keyByte, byte[] initvectorByte)
			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
			InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
		// der genutzte algorithmus
		final String AESMODE_CBC_PKCS5PADDING = "AES/CBC/PKCS5PADDING";
		byte[] decryptedtextByte = null;
		// der schlüssel wird in die richtige form gebracht
		SecretKeySpec keySpec = new SecretKeySpec(keyByte, "AES");
		// der initvector wird in die richtige form gebracht
		IvParameterSpec ivKeySpec = new IvParameterSpec(initvectorByte);
		// die verschlüsselungsroutine wird mit dem gewünschten parameter erstellt
		Cipher aesCipherDec = Cipher.getInstance(AESMODE_CBC_PKCS5PADDING);
		// nun wird die routine mit dem schlüssel initialisiert
		aesCipherDec.init(Cipher.DECRYPT_MODE, keySpec, ivKeySpec);
		// hier erfolgt nun die verschlüsselung des plaintextes
		decryptedtextByte = aesCipherDec.doFinal(ciphertextByte);
		return decryptedtextByte;
	}

	private static boolean FileExistsCheck(String dateinameString) {
		return Files.exists(Paths.get(dateinameString), new LinkOption[] { LinkOption.NOFOLLOW_LINKS });
	}

	private static void writeBytesToFileNio(byte[] byteToFileByte, String filenameString) {
		try {
			Path path = Paths.get(filenameString);
			Files.write(path, byteToFileByte);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private static byte[] readBytesFromFileNio(String filenameString) {
		byte[] byteFromFileByte = null;
		try {
			byteFromFileByte = Files.readAllBytes(Paths.get(filenameString));
		} catch (IOException e) {
			e.printStackTrace();
		}
		return byteFromFileByte;
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

package net.bplaced.javacrypto.symmetricencryption;

* 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): 01.11.2018

* Funktion: liest eine datei und verschlüsselt sie im aes cbc modus pkcs5 padding

* Function: encrypts a file using aes cbc modus with pkcs5 padding

* 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.IOException;

import java.io.UnsupportedEncodingException;

import java.nio.file.Files;

import java.nio.file.LinkOption;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.security.InvalidAlgorithmParameterException;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.spec.IvParameterSpec;

import javax.crypto.spec.SecretKeySpec;

import javax.xml.bind.DatatypeConverter;

public class B09b_AesCbcPkcs5PaddingRandomFile {

public static void main(String[] args)

throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,

IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {

System.out.println("B09b AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei");

// es werden ein paar variablen benötigt:

String dateinameReadString = "b09_test.txt"; // aus der datei wird das plaintextByte eingelesen

String dateinameWriteString = "b09b_test.enc"; // in diese datei wird das ciphertextByte geschrieben

String plaintextString = ""; // die daten werden aus der datei gelesen

byte[] plaintextByte = null; // die daten werden aus der datei gelesen

String decryptedtextString = ""; // enthält später den entschlüsselten text

// zuerst testen wir ob die einzulesende datei existiert

if (FileExistsCheck(dateinameReadString) == false) {

System.out.println("Die Datei " + dateinameReadString + " existiert nicht. Das Programm wird beendet.");

System.exit(0);

};

// datei in byte array einlesen

plaintextByte = readBytesFromFileNio(dateinameReadString);

plaintextString = new String(plaintextByte, "UTF-8"); // die umwandlung erfolgt nur zur späteren anzeige

// diese konstanten und variablen benötigen wir zur ver- und entschlüsselung

// der schlüssel ist exakt 32 zeichen lang und bestimmt die stärke der

// verschlüsselung

// hier ist der schlüssel 32 byte = 256 bit lang

// mögliche schlüssellängen sind 16 byte (128 bit), 24 byte (192 bit) und 32

// byte (256 bit)

// final byte[] keyByte = "1234567890123456".getBytes("UTF-8"); // 16 byte

final byte[] keyByte = "12345678901234567890123456789012".getBytes("UTF-8"); // 32 byte

// der initialisierungsvektor ist exakt 16 zeichen lang

final byte[] initvectorByte = new byte[16];

SecureRandom secureRandom = new SecureRandom();

secureRandom.nextBytes(initvectorByte);

// der verschluesselte (encrypted) text kommt in diese variable in form eines

// byte arrays

byte[] ciphertextByte = null; // die länge steht noch nicht fest, da sie von der größe des plaintextes abhängt

// der entschlüsselte (decrypted) text kommt in dieses byte array, welches

// später in einen string umkodiert wird

byte[] decryptedtextByte = null; // die länge steht noch nicht fest, da sie von der größe des plaintextes

// abhängt

// ab hier arbeiten wir nun im verschlüsselungsmodus

// umwandlung des klartextes in ein byte array

plaintextByte = plaintextString.getBytes("UTF-8");

// hier erfolgt nun die verschlüsselung des plaintextes

ciphertextByte = AesCbcPaddingEncrypt(plaintextByte, keyByte, initvectorByte);

// byte array in eine datei schreiben

writeBytesToFileNio(ciphertextByte, dateinameWriteString);

System.out.println("");

System.out.println("Klartextdaten einlesen und als verschlüsselte Datei speichern");

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

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

System.out.println("Dateiname Lesen :" + dateinameReadString);

System.out.println("Dateiname Schreiben :" + dateinameWriteString);

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

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

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

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

// ab hier arbeiten wir nun im entschlüsselungsmodus

// wir starten die entschlüsselung mit einem leeren ciphertext

ciphertextByte = null;

// byte array einlesen

dateinameReadString = "b09b_test.enc"; // ciphertextByte lesen

dateinameWriteString = "b09b_test.dec"; // decryptedtextByte schreiben

// zuerst testen wir ob die einzulesende datei existiert

if (FileExistsCheck(dateinameReadString) == false) {

System.out.println("Die Datei " + dateinameReadString + " existiert nicht. Das Programm wird beendet.");

System.exit(0);

};

// das ciphertextByte wird aus der datei gelesen

ciphertextByte = readBytesFromFileNio(dateinameReadString);

// nun wird der ciphertext wieder entschlüsselt

decryptedtextByte = AesCbcPaddingDecrypt(ciphertextByte, keyByte, initvectorByte);

// wir schreiben die entschlüsselten daten in eine datei

writeBytesToFileNio(decryptedtextByte, dateinameWriteString);

// zurück-kodierung des byte array in text

decryptedtextString = new String(decryptedtextByte, "UTF-8");

// ausgabe der variablen

System.out.println("");

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

System.out.println("Dateiname Lesen :" + dateinameReadString);

System.out.println("Dateiname Schreiben :" + dateinameWriteString);

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

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

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

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

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

System.out.println("= = = Entschlüsselung = = =");

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

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

}

public static byte[] AesCbcPaddingEncrypt(byte[] plaintextByte, byte[] keyByte, byte[] initvectorByte)

throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,

InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {

// der genutzte algorithmus

final String AESMODE_CBC_PKCS5PADDING = "AES/CBC/PKCS5PADDING";

byte[] ciphertextByte = null;

// der schlüssel wird in die richtige form gebracht

SecretKeySpec keySpec = new SecretKeySpec(keyByte, "AES");

// der initvector wird in die richtige form gebracht

IvParameterSpec ivKeySpec = new IvParameterSpec(initvectorByte);

// die verschlüsselungsroutine wird mit dem gewünschten parameter erstellt

Cipher aesCipherEnc = Cipher.getInstance(AESMODE_CBC_PKCS5PADDING);

// nun wird die routine mit dem schlüssel initialisiert

aesCipherEnc.init(Cipher.ENCRYPT_MODE, keySpec, ivKeySpec);

// hier erfolgt nun die verschlüsselung des plaintextes

ciphertextByte = aesCipherEnc.doFinal(plaintextByte);

return ciphertextByte;

}

public static byte[] AesCbcPaddingDecrypt(byte[] ciphertextByte, byte[] keyByte, byte[] initvectorByte)

throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,

InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {

// der genutzte algorithmus

final String AESMODE_CBC_PKCS5PADDING = "AES/CBC/PKCS5PADDING";

byte[] decryptedtextByte = null;

// der schlüssel wird in die richtige form gebracht

SecretKeySpec keySpec = new SecretKeySpec(keyByte, "AES");

// der initvector wird in die richtige form gebracht

IvParameterSpec ivKeySpec = new IvParameterSpec(initvectorByte);

// die verschlüsselungsroutine wird mit dem gewünschten parameter erstellt

Cipher aesCipherDec = Cipher.getInstance(AESMODE_CBC_PKCS5PADDING);

// nun wird die routine mit dem schlüssel initialisiert

aesCipherDec.init(Cipher.DECRYPT_MODE, keySpec, ivKeySpec);

// hier erfolgt nun die verschlüsselung des plaintextes

decryptedtextByte = aesCipherDec.doFinal(ciphertextByte);

return decryptedtextByte;

}

private static boolean FileExistsCheck(String dateinameString) {

return Files.exists(Paths.get(dateinameString), new LinkOption[] { LinkOption.NOFOLLOW_LINKS });

}

private static void writeBytesToFileNio(byte[] byteToFileByte, String filenameString) {

try {

Path path = Paths.get(filenameString);

Files.write(path, byteToFileByte);

} catch (IOException e) {

e.printStackTrace();

}

private static byte[] readBytesFromFileNio(String filenameString) {

byte[] byteFromFileByte = null;

try {

byteFromFileByte = Files.readAllBytes(Paths.get(filenameString));

} catch (IOException e) {

e.printStackTrace();

}

return byteFromFileByte;

}

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

Letzte Aktualisierung: 07.11.2018