B09c AES Modus CBC PKCS5Padding Zufalls-Initvektor Datei Infile-Initvector

Die separate Weitergabe des genutzten Initialisierungsvektors (iV) kann Fehler verursachen und sollte daher vermieden werden. Da der iV nicht geheim ist speichert dieses Beispiel den iV am Anfang der verschlüsselten Datei (daher auch der Name „Infile-Initvector“).

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.

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): 07.11.2018 
* Funktion: liest eine datei und verschlüsselt sie im aes cbc modus pkcs5 padding
*           speicherung des initvector in der verschluesselten datei
* Function: encrypts a file using aes cbc modus with pkcs5 padding
*           saves the initvector in the encrypted file 
*
* 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.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
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 B09c_AesCbcPkcs5PaddingRandomFileWithInitvector {

	public static void main(String[] args)
			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
			IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException, FileNotFoundException, IOException {
		System.out.println("B09c AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei und Infile-Initvector");
		// es werden ein paar variablen benötigt:
		String dateinameReadString = "b09_test.txt"; // aus der datei wird das plaintextByte eingelesen
		String dateinameWriteString = "b09c_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
		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
		try (DataOutputStream out = new DataOutputStream(new FileOutputStream(dateinameWriteString))) {
			out.writeInt(initvectorByte.length);
			out.write(initvectorByte);
			out.writeInt(ciphertextByte.length);
			out.write(ciphertextByte);
		}

		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("initvectorByte File (hex):" + DatatypeConverter.printHexBinary(initvectorByte));
		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;
		// ebenso ist der initvector leer - wird auch aus der datei gelesen
		initvectorByte = null;
		
		// byte array einlesen
		dateinameReadString = "b09c_test.enc"; // ciphertextByte lesen
		dateinameWriteString = "b09c_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
		try(DataInputStream dataIn = new DataInputStream(new FileInputStream(dateinameReadString))){
			int initvectorSize = dataIn.readInt();
			initvectorByte = new byte[initvectorSize];
			dataIn.read(initvectorByte, 0, initvectorSize);
			int ciphertextSize = dataIn.readInt();
			ciphertextByte = new byte[ciphertextSize];
			dataIn.read(ciphertextByte, 0, ciphertextSize);
		}

		// 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("initvectorByte File (hex):" + DatatypeConverter.printHexBinary(initvectorByte));
		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 {
		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("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);
		return ciphertextByte;
	}

	public static byte[] AesCbcPaddingDecrypt(byte[] ciphertextByte, byte[] keyByte, byte[] initvectorByte)
			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
			InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
		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("AES/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

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

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): 07.11.2018

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

* speicherung des initvector in der verschluesselten datei

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

* saves the initvector in the encrypted file

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

import java.io.DataOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

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 B09c_AesCbcPkcs5PaddingRandomFileWithInitvector {

public static void main(String[] args)

throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,

IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException, FileNotFoundException, IOException {

System.out.println("B09c AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei und Infile-Initvector");

// es werden ein paar variablen benötigt:

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

String dateinameWriteString = "b09c_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

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

try (DataOutputStream out = new DataOutputStream(new FileOutputStream(dateinameWriteString))) {

out.writeInt(initvectorByte.length);

out.write(initvectorByte);

out.writeInt(ciphertextByte.length);

out.write(ciphertextByte);

}

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("initvectorByte File (hex):" + DatatypeConverter.printHexBinary(initvectorByte));

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;

// ebenso ist der initvector leer - wird auch aus der datei gelesen

initvectorByte = null;

// byte array einlesen

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

dateinameWriteString = "b09c_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

try(DataInputStream dataIn = new DataInputStream(new FileInputStream(dateinameReadString))){

int initvectorSize = dataIn.readInt();

initvectorByte = new byte[initvectorSize];

dataIn.read(initvectorByte, 0, initvectorSize);

int ciphertextSize = dataIn.readInt();

ciphertextByte = new byte[ciphertextSize];

dataIn.read(ciphertextByte, 0, ciphertextSize);

}

// 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("initvectorByte File (hex):" + DatatypeConverter.printHexBinary(initvectorByte));

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 {

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("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);

return ciphertextByte;

}

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

throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,

InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {

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("AES/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 Ausgabe auf der Konsole sieht nicht anders aus als in den Beispielen B09 und B09b, aber Ihr solltet Euch die verschlüsselten Dateien anschauen (die mit der Endung „.enc“) – sie enthalten am Anfang den iV.

B09c AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei und Infile-Initvector

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

keyByte (hex)            :3132333435363738393031323334353637383930313233343536373839303132
Dateiname Lesen          :b09c_test.enc
Dateiname Schreiben      :b09c_test.dec
initvectorByte (hex)     :28803D2E9C3B4745788E8349EB93706D
plaintextString          :Dieses ist eine Testdatei mit 84 Zeichen, die am 27.10.2018 gespeichert worden ist.
plaintextByte (hex)      :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E
= = = Verschlüsselung = = =
initvectorByte File (hex):28803D2E9C3B4745788E8349EB93706D
ciphertextByte (hex)     :1B5083DF3C76394108F408B9C2DAA8F3C0E9BB6C6F9984C83310575C63DF736D1C48F9C0BF816AFD4FA92FE8833169A2A205E664A64008CBA0BA8E42257639C836A13118E147D6AC84DD347FAC648096AD95203CD0BEDAF4A6053305DED3AE7C
= = = Entschlüsselung = = =
decryptedtextByte (hex)  :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E
decryptedtextString      :Dieses ist eine Testdatei mit 84 Zeichen, die am 27.10.2018 gespeichert worden ist.

B09c AES im Betriebsmodus CBC PKCS5Padding mit Zufalls-Initvektor mit einer Datei und Infile-Initvector

Klartextdaten einlesen und als verschlüsselte Datei speichern

keyByte (hex) :3132333435363738393031323334353637383930313233343536373839303132

initvectorByte (hex) :28803D2E9C3B4745788E8349EB93706D

Dateiname Lesen :b09_test.txt

Dateiname Schreiben :b09c_test.enc

plaintextByte (hex) :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E

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

= = = Verschlüsselung = = =

initvectorByte File (hex):28803D2E9C3B4745788E8349EB93706D

ciphertextByte (hex) :1B5083DF3C76394108F408B9C2DAA8F3C0E9BB6C6F9984C83310575C63DF736D1C48F9C0BF816AFD4FA92FE8833169A2A205E664A64008CBA0BA8E42257639C836A13118E147D6AC84DD347FAC648096AD95203CD0BEDAF4A6053305DED3AE7C

keyByte (hex) :3132333435363738393031323334353637383930313233343536373839303132

Dateiname Lesen :b09c_test.enc

Dateiname Schreiben :b09c_test.dec

initvectorByte (hex) :28803D2E9C3B4745788E8349EB93706D

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

plaintextByte (hex) :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E

= = = Verschlüsselung = = =

initvectorByte File (hex):28803D2E9C3B4745788E8349EB93706D

= = = Entschlüsselung = = =

decryptedtextByte (hex) :446965736573206973742065696E6520546573746461746569206D6974203834205A65696368656E2C2064696520616D2032372E31302E3230313820676573706569636865727420776F7264656E206973742E

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

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

Letzte Aktualisierung: 18.11.2018