D05 EC Signatur mit einer Datei

Auch hier ändern wir das RSA-Beispiel D02 RSA Signatur mit einer Datei in Richtung EC (= Nutzung einer Elliptischen Kurve) als Rechenverfahren ab. Aus Darstellungsgründen habe ich als Schlüssellänge die 256 Bit-Kurve gewählt, entscheidet aber bitte selber welche Kurve Ihr verwenden möchtet. Die Kurve („secp256k1“) wird zum Beispiel bei der Krypto-Währung Bitcoin verwendet.

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 Signatur veröffentlicht der Absender seinen Public (öffentlichen) Schlüssel, z.B. auf seiner Webseite. Der Absender der Nachricht benutzt seinen Private Key für die Erzeugung der Signatur und sendet die Nachricht (ciphertext) zusammen mit der Signatur an den Empfänger. Der Empfänger prüft die Signatur mit dem Public Keys des Absenders.
Hier noch einmal die Kurzform: signieren mit dem Private Key des Absenders, prüfen der Signatur (Verifizierung) mit dem Public Key des Absenders.

Signatursteckbrief
Name des Verfahrens	EC
Langname	Elliptische Kurven Signatur
Art der Chiffre	Kompletter Plaintext
Blocklänge (Byte)	–
Schlüssellänge (Byte/Bit)	256/2048, 384/3072, 409/3272, 521/4168, 571/4568
Padding genutzt	Nein
Sicherheit	bitte benutzt nur Kurven, die zumindest „genormt“ sind.
Besonderes	–

Der Quellcode ist deutlich länger, dafür ist dieses Beispiel auch gleich in der Praxis einsetzbar, wenn der nachfolgende Sicherheitshinweis beachtet wird. Die erzeugten Schlüssel werden für eine spätere Benutzung in Form von Byte Arrays gespeichert und beim Einlesen mittels geeigneter Routinen wieder als Private und Public Key „regeneriert“. Die zu signierende Nachricht befindet sich in einer Datei und es wird nicht die komplette Nachricht zur Signaturerzeugung genutzt, sondern es wird ein Hashwert der Datei erzeugt und dieser Hashwert wird dann signiert – das verringert die Bearbeitungszeit bei den rechenintensiven Operationen. Die Signatur wird ebenfalls als Byte Array gespeichert und zur (späteren) Verifizierung beim Empfänger wieder eingelesen. Der Empfänger bildet ebenfalls den Hashwert der Nachrichten-Datei und überprüft den Hashwert mit dem Public Key anhand der Signatur.

Bitte wundert Euch nicht, das die Einlese Methoden der Private/Public Keys auf „loadEcdsa..“ lauten – das liegt einfach daran das die Erzeugung der Schlüsseln aus den Byte Arrays identisch zum ECDSA-Verfahren ist.

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

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

package net.bplaced.javacrypto.signature;

/*
* 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): 11.01.2019 
* Funktion: signiert und verifiziert eine Datei mittels EC (Asymmetrisch)
* Function: signs and verifies a file using EC (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.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.ECGenParameterSpec;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.xml.bind.DatatypeConverter;

public class D05_EcSignatureFile {

	public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException,
			IOException, InvalidKeySpecException, NoSuchProviderException, InvalidAlgorithmParameterException {
		System.out.println("D05 EC Signatur mit einer Datei");

		String messageFilenameString = "d02_message.txt";
		// KeyPair generieren
		// Kurvennamen: secp256r1, secp384r1, secp521r1
		String ecCurvenameString = "secp256r1";
		// ecHashverfahren: SHA256withECDSA, SHA384withECDSA, SHA512withECDSA
		String ecHashverfahrenString = "SHA256withECDSA";
		String ecPrivateKeyFilenameString = "ec_privateKey_" + ecCurvenameString + ".privatekey";
		String ecPublicKeyFilenameString = "ec_publicKey_" + ecCurvenameString + ".publickey";
		String ecSignatureFilenameString = "ec_Signature.dat";
		KeyPair keyPair = generateEcKeyPair(ecCurvenameString);
		PrivateKey privateKey = keyPair.getPrivate();
		PublicKey publicKey = keyPair.getPublic();
		// ausgabe der schlüsseldaten
		System.out.println("\nprivate Key  Länge:" + privateKey.getEncoded().length + " Data:\n"
				+ byteArrayPrint(privateKey.getEncoded(), 33));
		System.out.println("\npublic Key   Länge: " + publicKey.getEncoded().length + " Data:\n"
				+ byteArrayPrint(publicKey.getEncoded(), 33));
		System.out.println("Public Key: " + publicKey.toString());
		// speicherung der beiden keys
		savePrivateKeyAsBytearray(privateKey, ecPrivateKeyFilenameString);
		savePublicKeyAsBytearray(publicKey, ecPublicKeyFilenameString);
		System.out.println("Der privateKey und publicKey wurden gespeichert:" + ecPrivateKeyFilenameString + "/"
				+ ecPublicKeyFilenameString);
		// diese nachricht soll signiert werden
		// hier wird der hashwert der datei signiert um die datenmenge innerhalb der
		// signatur gering zu halten:
		byte[] messageByte = calcSHA256BufferedFile(messageFilenameString);
		System.out.println("\nDie Datei wurde gelesen:" + messageFilenameString + " und der SHA256-Hashwert erzeugt:"
				+ DatatypeConverter.printHexBinary(messageByte));
		// die signatur erfolgt mit dem privaten schlüssel, der jetzt geladen wird
		PrivateKey privateKeyLoad = loadEcdsaPrivateKeyAsBytearray(ecPrivateKeyFilenameString);
		System.out.println("\nDer privateKey wurde zur Signatur geladen:\"" + ecPrivateKeyFilenameString);
		byte[] signatureByte = signPrivateKey(privateKeyLoad, ecHashverfahrenString, messageByte);
		System.out.println(
				"\nsignatureByte Länge:" + signatureByte.length + " Data:\n" + byteArrayPrint(signatureByte, 33));
		// speicherung der signatur
		writeBytesToFileNio(signatureByte, ecSignatureFilenameString);
		System.out.println("Die ecSignatur wurde gespeichert:" + ecSignatureFilenameString);
		// die überprüfung der signatur erfolgt mit dem öffentlichen schlüssel, der
		// jetzt geladen wird
		PublicKey publicKeyLoad = loadEcdsaPublicKeyAsBytearray(ecPublicKeyFilenameString);
		System.out.println("\nDer publicKey wurde zur Verifizierung geladen:" + ecPublicKeyFilenameString);
		byte[] messageLoadByte = calcSHA256BufferedFile(messageFilenameString);
		System.out.println("Die message wurde gelesen:" + messageFilenameString + " und der SHA256-Hashwert erzeugt:" + DatatypeConverter.printHexBinary(messageLoadByte));
		byte[] signatureLoadByte = readBytesFromFileNio(ecSignatureFilenameString);
		System.out.println("Die Signature wurde gelesen:" + ecSignatureFilenameString);
		boolean signatureIsCorrectBoolean = verifyPublicKey(publicKeyLoad, ecHashverfahrenString, messageLoadByte,
				signatureLoadByte);
		System.out.println("\nÜberprüfung der Signatur mit dem publicKey: die Signatur ist korrekt:" + signatureIsCorrectBoolean);
		// veränderung der nachricht
		System.out.println("\nVeränderung der Nachricht");
		messageByte = "Nachricht fuer Signatur2".getBytes("utf-8");
		System.out.println("Veränderte-Nachricht hex   :" + byteArrayPrint(messageByte, 33));
		signatureIsCorrectBoolean = verifyPublicKey(publicKeyLoad, ecHashverfahrenString, messageByte, signatureByte);
		System.out.println("\nÜberprüfung der Signatur mit dem publicKey: die Signatur ist korrekt:" + signatureIsCorrectBoolean);
	}
	public static KeyPair generateEcKeyPair(String eccCurvenameString)
			throws NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException {
		KeyPairGenerator keypairGenerator = KeyPairGenerator.getInstance("EC", "SunEC");
		ECGenParameterSpec ecSpec = new ECGenParameterSpec(eccCurvenameString); 
		keypairGenerator.initialize(ecSpec, new SecureRandom());
		return keypairGenerator.genKeyPair();
	}
	public static byte[] signPrivateKey(PrivateKey privateKey, String rsaInstanceString, byte[] messageByte)
			throws SignatureException, NoSuchAlgorithmException, InvalidKeyException {
		Signature signature = Signature.getInstance(rsaInstanceString);
		signature.initSign(privateKey);
		signature.update(messageByte);
		return signature.sign();
	}
	public static Boolean verifyPublicKey(PublicKey publicKey, String rsaInstanceString, byte[] messageByte,
			byte[] signatureByte) throws SignatureException, NoSuchAlgorithmException, InvalidKeyException {
		Signature publicSignature = Signature.getInstance(rsaInstanceString);
		publicSignature.initVerify(publicKey);
		publicSignature.update(messageByte);
		return publicSignature.verify(signatureByte);
	}
	private static void savePrivateKeyAsBytearray(PrivateKey key, String filenameString) throws IOException {
		PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key.getEncoded());
		FileOutputStream fos = new FileOutputStream(filenameString);
		fos.write(pkcs8EncodedKeySpec.getEncoded());
		fos.close();
	}
	private static void savePublicKeyAsBytearray(PublicKey key, String filenameString) throws IOException {
		X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key.getEncoded());
		FileOutputStream fos = new FileOutputStream(filenameString);
		fos.write((x509EncodedKeySpec).getEncoded());
		fos.close();
	}
	private static PrivateKey loadEcdsaPrivateKeyAsBytearray(String filenameString)
			throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException {
		File filenameKeyString = new File(filenameString);
		FileInputStream fis = new FileInputStream(filenameKeyString);
		byte[] encodedPrivateKey = new byte[(int) filenameKeyString.length()];
		fis.read(encodedPrivateKey);
		fis.close();
		KeyFactory keyFactory = KeyFactory.getInstance("EC");
		PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(encodedPrivateKey);
		PrivateKey privateKeyRead = keyFactory.generatePrivate(privateKeySpec);
		return privateKeyRead;
	}
	private static PublicKey loadEcdsaPublicKeyAsBytearray(String filenameString)
			throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException {
		File filenameKeyString = new File(filenameString);
		FileInputStream fis = new FileInputStream(filenameKeyString);
		byte[] encodedPublicKey = new byte[(int) filenameKeyString.length()];
		fis.read(encodedPublicKey);
		fis.close();
		KeyFactory keyFactory = KeyFactory.getInstance("EC");
		X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedPublicKey);
		PublicKey publicKeyRead = keyFactory.generatePublic(publicKeySpec);
		return publicKeyRead;
	}
	private static byte[] readBytesFromFileNio(String filenameString) {
		byte[] byteFromFileByte = null;
		try {
			byteFromFileByte = Files.readAllBytes(Paths.get(filenameString));
		} catch (IOException e) {
			e.printStackTrace();
		}
		return byteFromFileByte;
	}
	public static byte[] calcSHA256BufferedFile(String filenameString) throws IOException, NoSuchAlgorithmException {
		// liest die datei über einen buffer ein - sehr viel geringere speichernutzung
		byte[] buffer = new byte[8192];
		int count;
		MessageDigest digest = MessageDigest.getInstance("SHA-256");
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filenameString));
		while ((count = bis.read(buffer)) > 0) {
			digest.update(buffer, 0, count);
		}
		bis.close();
		byte[] hash = digest.digest();
		return hash;
	}
	private static void writeBytesToFileNio(byte[] byteToFileByte, String filenameString) {
		try {
			Path path = Paths.get(filenameString);
			Files.write(path, byteToFileByte);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	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

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

package net.bplaced.javacrypto.signature;

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

* Funktion: signiert und verifiziert eine Datei mittels EC (Asymmetrisch)

* Function: signs and verifies a file using EC (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.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.security.InvalidAlgorithmParameterException;

import java.security.InvalidKeyException;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.security.NoSuchProviderException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.SecureRandom;

import java.security.Signature;

import java.security.SignatureException;

import java.security.spec.ECGenParameterSpec;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import javax.xml.bind.DatatypeConverter;

public class D05_EcSignatureFile {

public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException,

IOException, InvalidKeySpecException, NoSuchProviderException, InvalidAlgorithmParameterException {

System.out.println("D05 EC Signatur mit einer Datei");

String messageFilenameString = "d02_message.txt";

// KeyPair generieren

// Kurvennamen: secp256r1, secp384r1, secp521r1

String ecCurvenameString = "secp256r1";

// ecHashverfahren: SHA256withECDSA, SHA384withECDSA, SHA512withECDSA

String ecHashverfahrenString = "SHA256withECDSA";

String ecPrivateKeyFilenameString = "ec_privateKey_" + ecCurvenameString + ".privatekey";

String ecPublicKeyFilenameString = "ec_publicKey_" + ecCurvenameString + ".publickey";

String ecSignatureFilenameString = "ec_Signature.dat";

KeyPair keyPair = generateEcKeyPair(ecCurvenameString);

PrivateKey privateKey = keyPair.getPrivate();

PublicKey publicKey = keyPair.getPublic();

// ausgabe der schlüsseldaten

System.out.println("\nprivate Key Länge:" + privateKey.getEncoded().length + " Data:\n"

+ byteArrayPrint(privateKey.getEncoded(), 33));

System.out.println("\npublic Key Länge: " + publicKey.getEncoded().length + " Data:\n"

+ byteArrayPrint(publicKey.getEncoded(), 33));

System.out.println("Public Key: " + publicKey.toString());

// speicherung der beiden keys

savePrivateKeyAsBytearray(privateKey, ecPrivateKeyFilenameString);

savePublicKeyAsBytearray(publicKey, ecPublicKeyFilenameString);

System.out.println("Der privateKey und publicKey wurden gespeichert:" + ecPrivateKeyFilenameString + "/"

+ ecPublicKeyFilenameString);

// diese nachricht soll signiert werden

// hier wird der hashwert der datei signiert um die datenmenge innerhalb der

// signatur gering zu halten:

byte[] messageByte = calcSHA256BufferedFile(messageFilenameString);

System.out.println("\nDie Datei wurde gelesen:" + messageFilenameString + " und der SHA256-Hashwert erzeugt:"

+ DatatypeConverter.printHexBinary(messageByte));

// die signatur erfolgt mit dem privaten schlüssel, der jetzt geladen wird

PrivateKey privateKeyLoad = loadEcdsaPrivateKeyAsBytearray(ecPrivateKeyFilenameString);

System.out.println("\nDer privateKey wurde zur Signatur geladen:\"" + ecPrivateKeyFilenameString);

byte[] signatureByte = signPrivateKey(privateKeyLoad, ecHashverfahrenString, messageByte);

System.out.println(

"\nsignatureByte Länge:" + signatureByte.length + " Data:\n" + byteArrayPrint(signatureByte, 33));

// speicherung der signatur

writeBytesToFileNio(signatureByte, ecSignatureFilenameString);

System.out.println("Die ecSignatur wurde gespeichert:" + ecSignatureFilenameString);

// die überprüfung der signatur erfolgt mit dem öffentlichen schlüssel, der

// jetzt geladen wird

PublicKey publicKeyLoad = loadEcdsaPublicKeyAsBytearray(ecPublicKeyFilenameString);

System.out.println("\nDer publicKey wurde zur Verifizierung geladen:" + ecPublicKeyFilenameString);

byte[] messageLoadByte = calcSHA256BufferedFile(messageFilenameString);

System.out.println("Die message wurde gelesen:" + messageFilenameString + " und der SHA256-Hashwert erzeugt:" + DatatypeConverter.printHexBinary(messageLoadByte));

byte[] signatureLoadByte = readBytesFromFileNio(ecSignatureFilenameString);

System.out.println("Die Signature wurde gelesen:" + ecSignatureFilenameString);

boolean signatureIsCorrectBoolean = verifyPublicKey(publicKeyLoad, ecHashverfahrenString, messageLoadByte,

signatureLoadByte);

System.out.println("\nÜberprüfung der Signatur mit dem publicKey: die Signatur ist korrekt:" + signatureIsCorrectBoolean);

// veränderung der nachricht

System.out.println("\nVeränderung der Nachricht");

messageByte = "Nachricht fuer Signatur2".getBytes("utf-8");

System.out.println("Veränderte-Nachricht hex :" + byteArrayPrint(messageByte, 33));

signatureIsCorrectBoolean = verifyPublicKey(publicKeyLoad, ecHashverfahrenString, messageByte, signatureByte);

System.out.println("\nÜberprüfung der Signatur mit dem publicKey: die Signatur ist korrekt:" + signatureIsCorrectBoolean);

}

public static KeyPair generateEcKeyPair(String eccCurvenameString)

throws NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException {

KeyPairGenerator keypairGenerator = KeyPairGenerator.getInstance("EC", "SunEC");

ECGenParameterSpec ecSpec = new ECGenParameterSpec(eccCurvenameString);

keypairGenerator.initialize(ecSpec, new SecureRandom());

return keypairGenerator.genKeyPair();

}

public static byte[] signPrivateKey(PrivateKey privateKey, String rsaInstanceString, byte[] messageByte)

throws SignatureException, NoSuchAlgorithmException, InvalidKeyException {

Signature signature = Signature.getInstance(rsaInstanceString);

signature.initSign(privateKey);

signature.update(messageByte);

return signature.sign();

}

public static Boolean verifyPublicKey(PublicKey publicKey, String rsaInstanceString, byte[] messageByte,

byte[] signatureByte) throws SignatureException, NoSuchAlgorithmException, InvalidKeyException {

Signature publicSignature = Signature.getInstance(rsaInstanceString);

publicSignature.initVerify(publicKey);

publicSignature.update(messageByte);

return publicSignature.verify(signatureByte);

}

private static void savePrivateKeyAsBytearray(PrivateKey key, String filenameString) throws IOException {

PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key.getEncoded());

FileOutputStream fos = new FileOutputStream(filenameString);

fos.write(pkcs8EncodedKeySpec.getEncoded());

fos.close();

}

private static void savePublicKeyAsBytearray(PublicKey key, String filenameString) throws IOException {

X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key.getEncoded());

FileOutputStream fos = new FileOutputStream(filenameString);

fos.write((x509EncodedKeySpec).getEncoded());

fos.close();

}

private static PrivateKey loadEcdsaPrivateKeyAsBytearray(String filenameString)

throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException {

File filenameKeyString = new File(filenameString);

FileInputStream fis = new FileInputStream(filenameKeyString);

byte[] encodedPrivateKey = new byte[(int) filenameKeyString.length()];

fis.read(encodedPrivateKey);

fis.close();

KeyFactory keyFactory = KeyFactory.getInstance("EC");

PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(encodedPrivateKey);

PrivateKey privateKeyRead = keyFactory.generatePrivate(privateKeySpec);

return privateKeyRead;

}

private static PublicKey loadEcdsaPublicKeyAsBytearray(String filenameString)

throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException {

File filenameKeyString = new File(filenameString);

FileInputStream fis = new FileInputStream(filenameKeyString);

byte[] encodedPublicKey = new byte[(int) filenameKeyString.length()];

fis.read(encodedPublicKey);

fis.close();

KeyFactory keyFactory = KeyFactory.getInstance("EC");

X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedPublicKey);

PublicKey publicKeyRead = keyFactory.generatePublic(publicKeySpec);

return publicKeyRead;

}

private static byte[] readBytesFromFileNio(String filenameString) {

byte[] byteFromFileByte = null;

try {

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

} catch (IOException e) {

e.printStackTrace();

}

return byteFromFileByte;

}

public static byte[] calcSHA256BufferedFile(String filenameString) throws IOException, NoSuchAlgorithmException {

// liest die datei über einen buffer ein - sehr viel geringere speichernutzung

byte[] buffer = new byte[8192];

int count;

MessageDigest digest = MessageDigest.getInstance("SHA-256");

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filenameString));

while ((count = bis.read(buffer)) > 0) {

digest.update(buffer, 0, count);

}

bis.close();

byte[] hash = digest.digest();

return hash;

}

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

try {

Path path = Paths.get(filenameString);

Files.write(path, byteToFileByte);

} catch (IOException e) {

e.printStackTrace();

}

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;

}

So informiert Euch die Konsole:

D05 EC Signatur mit einer Datei

private Key  Länge:67 Data:
30 41 02 01 00 30 13 06 07 2A 86 48 CE 3D 02 01 06 08 2A 86 48 CE 3D 03 01 07 04 27 30 25 02 01 01 
04 20 50 0D 90 80 CC 1E BF F0 47 85 54 BE 28 F8 9D 1C 33 35 A3 A9 47 BF 68 A2 87 A8 74 D4 04 88 30 
D3 

public Key   Länge: 91 Data:
30 59 30 13 06 07 2A 86 48 CE 3D 02 01 06 08 2A 86 48 CE 3D 03 01 07 03 42 00 04 8F DC 9F 37 93 8A 
6A 3E 31 9C 3E 78 B2 E9 9C EA D2 C3 FF 55 4F A1 D7 D5 1D E2 9F 38 B9 EB F4 7D DA 51 BD D4 72 E6 9D 
1F 3E DA B3 EE 39 4F 3F 64 6E 09 D6 45 8C 9D 79 A1 13 FB 45 39 8F 6F 5A 5E 
Public Key: Sun EC public key, 256 bits
  public x coord: 65070542577662391991155999999137739823501859982423173695322437241587043660925
  public y coord: 98748625761067828896238149895031929362240900552070262893240675752660272372318
  parameters: secp256r1 [NIST P-256, X9.62 prime256v1] (1.2.840.10045.3.1.7)
Der privateKey und publicKey wurden gespeichert:ec_privateKey_secp256r1.privatekey/ec_publicKey_secp256r1.publickey

Die Datei wurde gelesen:d02_message.txt und der SHA256-Hashwert erzeugt:B11A0F35B132509FA779A5A1C87F69FDD75ADC635654C834CF3F686976732C52

Der privateKey wurde zur Signatur geladen:"ec_privateKey_secp256r1.privatekey

signatureByte Länge:71 Data:
30 45 02 21 00 D2 85 95 40 DB 5B B6 3F CB 04 E5 D7 C0 2E 91 E8 10 31 53 2F 40 F9 49 FE 0E 59 F9 19 
3E 85 0E 08 02 20 01 4C 10 DF 65 B2 F5 E9 FE D8 07 3A 48 7D 6A C1 1C 27 CD 2D DE E5 E6 22 C2 44 65 
42 BC 19 DE 75 
Die ecSignatur wurde gespeichert:ec_Signature.dat

Der publicKey wurde zur Verifizierung geladen:ec_publicKey_secp256r1.publickey
Die message wurde gelesen:d02_message.txt und der SHA256-Hashwert erzeugt:B11A0F35B132509FA779A5A1C87F69FDD75ADC635654C834CF3F686976732C52
Die Signature wurde gelesen:ec_Signature.dat

Überprüfung der Signatur mit dem publicKey: die Signatur ist korrekt:true

Veränderung der Nachricht
Veränderte-Nachricht hex   :4E 61 63 68 72 69 63 68 74 20 66 75 65 72 20 53 69 67 6E 61 74 75 72 32 

Überprüfung der Signatur mit dem publicKey: die Signatur ist korrekt:false

D05 EC Signatur mit einer Datei

private Key Länge:67 Data:

30 41 02 01 00 30 13 06 07 2A 86 48 CE 3D 02 01 06 08 2A 86 48 CE 3D 03 01 07 04 27 30 25 02 01 01

04 20 50 0D 90 80 CC 1E BF F0 47 85 54 BE 28 F8 9D 1C 33 35 A3 A9 47 BF 68 A2 87 A8 74 D4 04 88 30

public Key Länge: 91 Data:

30 59 30 13 06 07 2A 86 48 CE 3D 02 01 06 08 2A 86 48 CE 3D 03 01 07 03 42 00 04 8F DC 9F 37 93 8A

6A 3E 31 9C 3E 78 B2 E9 9C EA D2 C3 FF 55 4F A1 D7 D5 1D E2 9F 38 B9 EB F4 7D DA 51 BD D4 72 E6 9D

1F 3E DA B3 EE 39 4F 3F 64 6E 09 D6 45 8C 9D 79 A1 13 FB 45 39 8F 6F 5A 5E

Public Key: Sun EC public key, 256 bits

public x coord: 65070542577662391991155999999137739823501859982423173695322437241587043660925

public y coord: 98748625761067828896238149895031929362240900552070262893240675752660272372318

parameters: secp256r1 [NIST P-256, X9.62 prime256v1] (1.2.840.10045.3.1.7)

Der privateKey und publicKey wurden gespeichert:ec_privateKey_secp256r1.privatekey/ec_publicKey_secp256r1.publickey

Die Datei wurde gelesen:d02_message.txt und der SHA256-Hashwert erzeugt:B11A0F35B132509FA779A5A1C87F69FDD75ADC635654C834CF3F686976732C52

Der privateKey wurde zur Signatur geladen:"ec_privateKey_secp256r1.privatekey

signatureByte Länge:71 Data:

30 45 02 21 00 D2 85 95 40 DB 5B B6 3F CB 04 E5 D7 C0 2E 91 E8 10 31 53 2F 40 F9 49 FE 0E 59 F9 19

3E 85 0E 08 02 20 01 4C 10 DF 65 B2 F5 E9 FE D8 07 3A 48 7D 6A C1 1C 27 CD 2D DE E5 E6 22 C2 44 65

42 BC 19 DE 75

Die ecSignatur wurde gespeichert:ec_Signature.dat

Der publicKey wurde zur Verifizierung geladen:ec_publicKey_secp256r1.publickey

Die message wurde gelesen:d02_message.txt und der SHA256-Hashwert erzeugt:B11A0F35B132509FA779A5A1C87F69FDD75ADC635654C834CF3F686976732C52

Die Signature wurde gelesen:ec_Signature.dat

Überprüfung der Signatur mit dem publicKey: die Signatur ist korrekt:true

Veränderung der Nachricht

Veränderte-Nachricht hex :4E 61 63 68 72 69 63 68 74 20 66 75 65 72 20 53 69 67 6E 61 74 75 72 32

Überprüfung der Signatur mit dem publicKey: die Signatur ist korrekt:false

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

Letzte Aktualisierung: 11.01.2019