H08 Signatur einer Datei mit Tink

Die Erstellung und spätere Überprüfung einer digitalen Signatur ist mit Google Tink fast ein Kinderspiel. Ganz besonders freut es mich, dass die sehr beliebte Elliptische Kurve ED25519 mit im Angebot der möglichen Unterschrifts-Verfahren ist.

Bitte beachtet, dass dieses Beispiel nur für Dateien bis zu einer Größe von 1 Megabyte genutzt werden sollte, da die gesamte (komplette) Datei in den Programmspeicher geladen wird, was insbesondere bei der späteren Verifizierung für Probleme und Kummer sorgen kann.

Bitte die nachfolgende Routine nur nach einer gründlichen Überprüfung für den Echteinsatz nutzen. Aus kryptographischer Sicht dürfte sie für viele Einsatzgebiete nutzbar sein.

package net.bplaced.javacrypto.tink;

/*
* 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.
* Lizenztext/Licence: <http://unlicense.org>
* getestet mit/tested with: Java Runtime Environment 8 Update 191 x64
* getestet mit/tested with: Java Runtime Environment 11.0.1 x64
* Datum/Date (dd.mm.jjjj): 28.01.2019
* Funktion: signiert eine Datei mit Google Tink ED25519
* Function: signs a file using Google Tink ED25519
*
* 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 !
* 
* Das Programm benötigt die nachfolgende Bibliotheken:
* The programm uses these external libraries:
* jar-Datei: https://mvnrepository.com/artifact/com.google.crypto.tink/tink 
* jar-Datei: https://mvnrepository.com/artifact/com.google.protobuf/protobuf-java
* jar-Datei: https://mvnrepository.com/artifact/org.json/json
*/

import java.io.ByteArrayOutputStream;
import java.io.File;
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.GeneralSecurityException;
import java.util.Base64;
import com.google.crypto.tink.CleartextKeysetHandle;
import com.google.crypto.tink.JsonKeysetReader;
import com.google.crypto.tink.JsonKeysetWriter;
import com.google.crypto.tink.KeysetHandle;
import com.google.crypto.tink.PublicKeySign;
import com.google.crypto.tink.PublicKeyVerify;
import com.google.crypto.tink.config.TinkConfig;
import com.google.crypto.tink.signature.PublicKeySignFactory;
import com.google.crypto.tink.signature.PublicKeyVerifyFactory;
import com.google.crypto.tink.signature.SignatureKeyTemplates;

public final class H08_SignatureTinkFile {

	public static void main(String[] args) throws Exception {
		System.out.println("H08 Signatur via Tink, Schlüssel Speicherung für eine Datei");
		System.out.println("\nHinweis: Bitte benutzen Sie dieses Programm nur bei kleineren Dateien bis"
				+ "\nzu einer Größe von 1 Megabyte, da die gesamte Datei in den Speicher geladen "
				+ "\nund dort signiert bzw. verifiziert wird.");
		
		TinkConfig.register();

		String filenamePrivateKeyString = "h08_private_ed25519.txt";
		String filenamePublicKeyString = "h08_public_ed25519.txt";
		String filenamePlainString = "a11_test_1mb.dat";
		String filenameSignatureString = "h08_signature.txt";

		// schlüssel erzeugen
		System.out.println("\nSchlüsselerzeugung und Speicherung");
		KeysetHandle privateKeysetHandle = KeysetHandle.generateNew(SignatureKeyTemplates.ED25519);
		// SignatureKeyTemplates. ECDSA_P256, ECDSA_P384, ECDSA_P521,
		// ECDSA_P256_IEEE_P1363, ECDSA_P384_IEEE_P1363, ECDSA_P521_IEEE_P1363, ED25519

		// öffentlichen schlüssel erzeugen
		KeysetHandle publicKeysetHandle = privateKeysetHandle.getPublicKeysetHandle();

		// schlüssel speichern
		// private key
		saveKeyJsonFormat(privateKeysetHandle, filenamePrivateKeyString);
		System.out.println("Der erzeugte private Schlüssel wurde gespeichert:" + filenamePrivateKeyString);
		System.out.println(
				"Der Schlüssel ist im Format:" + privateKeysetHandle.getKeysetInfo().getKeyInfo(0).getTypeUrl());
		// public key
		saveKeyJsonFormat(publicKeysetHandle, filenamePublicKeyString);
		System.out.println("Der erzeugte öffentliche Schlüssel wurde gespeichert:" + filenamePublicKeyString);
		System.out.println(
				"Der Schlüssel ist im Format:" + publicKeysetHandle.getKeysetInfo().getKeyInfo(0).getTypeUrl());
		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
		CleartextKeysetHandle.write(privateKeysetHandle, JsonKeysetWriter.withOutputStream(outputStream));
		System.out.println("\nPubKey:\t" + new String(outputStream.toByteArray()));

		// falls ein schlüssel bereits vorhanden ist wird er so geladen:
		// KeysetHandle keysetHandle = loadKeyJsonFormat(filenameKeyString);

		// ist die datei filenamePlainString existent ?
		if (FileExistsCheck(filenamePlainString) == false) {
			System.out.println("Die Datei " + filenamePlainString + " existiert nicht. Das Programm wird beendet.");
			System.exit(0);
		}
		;

		// signatur
		System.out.println("\n# # # Signatur einer Datei # # #");
		byte[] signatureByte = generateSignatureTink(privateKeysetHandle, filenamePlainString);
		System.out.println("Die Datei " + filenamePlainString + " hat diese Signatur:" + printHexBinary(signatureByte));
		// signatur speichern
		writeBytesToFileNio(signatureByte, filenameSignatureString);
		// signatur als base64-string
		System.out.println(
				"Die Datei hat diese Signatur als Base64String:" + Base64.getEncoder().encodeToString(signatureByte));

		// verifizierung, einlesen des schlüssels und der signatur datei
		System.out.println("\n# # # Signatur Verifizierung einer Datei # # #");
		if (FileExistsCheck(filenamePublicKeyString) == false) {
			System.out.println("Die Datei " + filenamePublicKeyString + " existiert nicht. Das Programm wird beendet.");
			System.exit(0);
		}
		;
		if (FileExistsCheck(filenameSignatureString) == false) {
			System.out.println("Die Datei " + filenameSignatureString + " existiert nicht. Das Programm wird beendet.");
			System.exit(0);
		}
		;
		// lesen der schlüsseldatei
		KeysetHandle publicKeysetHandleRead = loadKeyJsonFormat(filenamePublicKeyString);
		System.out.println("Der Schlüssel wurde gelesen:" + filenamePublicKeyString);
		// verifizierung der datei filenamePlainString
		Boolean verifiedBool = verifySignatureTink(publicKeysetHandleRead, filenamePlainString,
				filenameSignatureString);
		System.out.println("Die Signatur für die Datei " + filenamePlainString + " ist korrekt:" + verifiedBool);
	}

	public static void saveKeyJsonFormat(KeysetHandle keysetHandle, String filenameString) throws IOException {
		CleartextKeysetHandle.write(keysetHandle, JsonKeysetWriter.withFile(new File(filenameString)));
	}

	public static KeysetHandle loadKeyJsonFormat(String filenameString) throws GeneralSecurityException, IOException {
		return CleartextKeysetHandle.read(JsonKeysetReader.withFile(new File(filenameString)));
	}

	public static byte[] generateSignatureTink(KeysetHandle privateKeysetHandle, String filenamePlainString)
			throws GeneralSecurityException {
		// einlesen des plaintextes
		byte[] plaintextByte = readBytesFromFileNio(filenamePlainString);
		// signatur
		PublicKeySign signer = PublicKeySignFactory.getPrimitive(privateKeysetHandle);
		return signer.sign(plaintextByte);
	}

	public static Boolean verifySignatureTink(KeysetHandle publicKeysetHandle, String filenamePlainString,
			String filenameSignatureString) throws GeneralSecurityException {
		// einlesen des plaintextes
		byte[] plaintextByte = readBytesFromFileNio(filenamePlainString);
		// einlesen des hmac
		byte[] signatureByte = readBytesFromFileNio(filenameSignatureString);
		Boolean verifiedBool = false;
		PublicKeyVerify verifier = PublicKeyVerifyFactory.getPrimitive(publicKeysetHandle);
		try {
			verifier.verify(signatureByte, plaintextByte);
			verifiedBool = true;
		} catch (GeneralSecurityException e) {
			verifiedBool = false;
		}
		return verifiedBool;
	}

	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;
	}

	public static String toHexString(byte[] bytes) {
		StringBuffer sb = new StringBuffer(bytes.length * 2);
		for (int i = 0; i < bytes.length; i++) {
			sb.append(toHex(bytes[i] >> 4));
			sb.append(toHex(bytes[i]));
		}

		return sb.toString();
	}

	private static char toHex(int nibble) {
		final char[] hexDigit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
		return hexDigit[nibble & 0xF];
	}

	public static String printHexBinary(byte[] bytes) {
		final char[] hexArray = "0123456789ABCDEF".toCharArray();
		char[] hexChars = new char[bytes.length * 2];
		for (int j = 0; j < bytes.length; j++) {
			int v = bytes[j] & 0xFF;
			hexChars[j * 2] = hexArray[v >>> 4];
			hexChars[j * 2 + 1] = hexArray[v & 0x0F];
		}
		return new String(hexChars);
	}
}

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

package net.bplaced.javacrypto.tink;

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

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

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

* getestet mit/tested with: Java Runtime Environment 11.0.1 x64

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

* Funktion: signiert eine Datei mit Google Tink ED25519

* Function: signs a file using Google Tink ED25519

* 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 !

* Das Programm benötigt die nachfolgende Bibliotheken:

* The programm uses these external libraries:

* jar-Datei: https://mvnrepository.com/artifact/com.google.crypto.tink/tink

* jar-Datei: https://mvnrepository.com/artifact/com.google.protobuf/protobuf-java

* jar-Datei: https://mvnrepository.com/artifact/org.json/json

import java.io.ByteArrayOutputStream;

import java.io.File;

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.GeneralSecurityException;

import java.util.Base64;

import com.google.crypto.tink.CleartextKeysetHandle;

import com.google.crypto.tink.JsonKeysetReader;

import com.google.crypto.tink.JsonKeysetWriter;

import com.google.crypto.tink.KeysetHandle;

import com.google.crypto.tink.PublicKeySign;

import com.google.crypto.tink.PublicKeyVerify;

import com.google.crypto.tink.config.TinkConfig;

import com.google.crypto.tink.signature.PublicKeySignFactory;

import com.google.crypto.tink.signature.PublicKeyVerifyFactory;

import com.google.crypto.tink.signature.SignatureKeyTemplates;

public final class H08_SignatureTinkFile {

public static void main(String[] args) throws Exception {

System.out.println("H08 Signatur via Tink, Schlüssel Speicherung für eine Datei");

System.out.println("\nHinweis: Bitte benutzen Sie dieses Programm nur bei kleineren Dateien bis"

+ "\nzu einer Größe von 1 Megabyte, da die gesamte Datei in den Speicher geladen "

+ "\nund dort signiert bzw. verifiziert wird.");

TinkConfig.register();

String filenamePrivateKeyString = "h08_private_ed25519.txt";

String filenamePublicKeyString = "h08_public_ed25519.txt";

String filenamePlainString = "a11_test_1mb.dat";

String filenameSignatureString = "h08_signature.txt";

// schlüssel erzeugen

System.out.println("\nSchlüsselerzeugung und Speicherung");

KeysetHandle privateKeysetHandle = KeysetHandle.generateNew(SignatureKeyTemplates.ED25519);

// SignatureKeyTemplates. ECDSA_P256, ECDSA_P384, ECDSA_P521,

// ECDSA_P256_IEEE_P1363, ECDSA_P384_IEEE_P1363, ECDSA_P521_IEEE_P1363, ED25519

// öffentlichen schlüssel erzeugen

KeysetHandle publicKeysetHandle = privateKeysetHandle.getPublicKeysetHandle();

// schlüssel speichern

// private key

saveKeyJsonFormat(privateKeysetHandle, filenamePrivateKeyString);

System.out.println("Der erzeugte private Schlüssel wurde gespeichert:" + filenamePrivateKeyString);

System.out.println(

"Der Schlüssel ist im Format:" + privateKeysetHandle.getKeysetInfo().getKeyInfo(0).getTypeUrl());

// public key

saveKeyJsonFormat(publicKeysetHandle, filenamePublicKeyString);

System.out.println("Der erzeugte öffentliche Schlüssel wurde gespeichert:" + filenamePublicKeyString);

System.out.println(

"Der Schlüssel ist im Format:" + publicKeysetHandle.getKeysetInfo().getKeyInfo(0).getTypeUrl());

ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

CleartextKeysetHandle.write(privateKeysetHandle, JsonKeysetWriter.withOutputStream(outputStream));

System.out.println("\nPubKey:\t" + new String(outputStream.toByteArray()));

// falls ein schlüssel bereits vorhanden ist wird er so geladen:

// KeysetHandle keysetHandle = loadKeyJsonFormat(filenameKeyString);

// ist die datei filenamePlainString existent ?

if (FileExistsCheck(filenamePlainString) == false) {

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

System.exit(0);

}

;

// signatur

System.out.println("\n# # # Signatur einer Datei # # #");

byte[] signatureByte = generateSignatureTink(privateKeysetHandle, filenamePlainString);

System.out.println("Die Datei " + filenamePlainString + " hat diese Signatur:" + printHexBinary(signatureByte));

// signatur speichern

writeBytesToFileNio(signatureByte, filenameSignatureString);

// signatur als base64-string

System.out.println(

"Die Datei hat diese Signatur als Base64String:" + Base64.getEncoder().encodeToString(signatureByte));

// verifizierung, einlesen des schlüssels und der signatur datei

System.out.println("\n# # # Signatur Verifizierung einer Datei # # #");

if (FileExistsCheck(filenamePublicKeyString) == false) {

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

System.exit(0);

}

;

if (FileExistsCheck(filenameSignatureString) == false) {

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

System.exit(0);

}

;

// lesen der schlüsseldatei

KeysetHandle publicKeysetHandleRead = loadKeyJsonFormat(filenamePublicKeyString);

System.out.println("Der Schlüssel wurde gelesen:" + filenamePublicKeyString);

// verifizierung der datei filenamePlainString

Boolean verifiedBool = verifySignatureTink(publicKeysetHandleRead, filenamePlainString,

filenameSignatureString);

System.out.println("Die Signatur für die Datei " + filenamePlainString + " ist korrekt:" + verifiedBool);

}

public static void saveKeyJsonFormat(KeysetHandle keysetHandle, String filenameString) throws IOException {

CleartextKeysetHandle.write(keysetHandle, JsonKeysetWriter.withFile(new File(filenameString)));

}

public static KeysetHandle loadKeyJsonFormat(String filenameString) throws GeneralSecurityException, IOException {

return CleartextKeysetHandle.read(JsonKeysetReader.withFile(new File(filenameString)));

}

public static byte[] generateSignatureTink(KeysetHandle privateKeysetHandle, String filenamePlainString)

throws GeneralSecurityException {

// einlesen des plaintextes

byte[] plaintextByte = readBytesFromFileNio(filenamePlainString);

// signatur

PublicKeySign signer = PublicKeySignFactory.getPrimitive(privateKeysetHandle);

return signer.sign(plaintextByte);

}

public static Boolean verifySignatureTink(KeysetHandle publicKeysetHandle, String filenamePlainString,

String filenameSignatureString) throws GeneralSecurityException {

// einlesen des plaintextes

byte[] plaintextByte = readBytesFromFileNio(filenamePlainString);

// einlesen des hmac

byte[] signatureByte = readBytesFromFileNio(filenameSignatureString);

Boolean verifiedBool = false;

PublicKeyVerify verifier = PublicKeyVerifyFactory.getPrimitive(publicKeysetHandle);

try {

verifier.verify(signatureByte, plaintextByte);

verifiedBool = true;

} catch (GeneralSecurityException e) {

verifiedBool = false;

}

return verifiedBool;

}

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;

}

public static String toHexString(byte[] bytes) {

StringBuffer sb = new StringBuffer(bytes.length * 2);

for (int i = 0; i < bytes.length; i++) {

sb.append(toHex(bytes[i] >> 4));

sb.append(toHex(bytes[i]));

}

return sb.toString();

}

private static char toHex(int nibble) {

final char[] hexDigit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

return hexDigit[nibble & 0xF];

}

public static String printHexBinary(byte[] bytes) {

final char[] hexArray = "0123456789ABCDEF".toCharArray();

char[] hexChars = new char[bytes.length * 2];

for (int j = 0; j < bytes.length; j++) {

int v = bytes[j] & 0xFF;

hexChars[j * 2] = hexArray[v >>> 4];

hexChars[j * 2 + 1] = hexArray[v & 0x0F];

}

return new String(hexChars);

}

Die Ausgabe auf der Konsole ähnelt den anderen Verfahren sehr:

H08 Signatur via Tink, Schlüssel Speicherung für eine Datei

Hinweis: Bitte benutzen Sie dieses Programm nur bei kleineren Dateien bis
zu einer Größe von 1 Megabyte, da die gesamte Datei in den Speicher geladen 
und dort signiert bzw. verifiziert wird.

Schlüsselerzeugung und Speicherung
Der erzeugte private Schlüssel wurde gespeichert:h08_private_ed25519.txt
Der Schlüssel ist im Format:type.googleapis.com/google.crypto.tink.Ed25519PrivateKey
Der erzeugte öffentliche Schlüssel wurde gespeichert:h08_public_ed25519.txt
Der Schlüssel ist im Format:type.googleapis.com/google.crypto.tink.Ed25519PublicKey

PubKey:	{
    "primaryKeyId": 1343443983,
    "key": [{
        "keyData": {
            "typeUrl": "type.googleapis.com/google.crypto.tink.Ed25519PrivateKey",
            "keyMaterialType": "ASYMMETRIC_PRIVATE",
            "value": "EiAhDqCUd1w+cBLeWeLzhpSQXw7ftyNYEjOwUHeGBfXONBoiEiCr53S9nfWgtJ4NohDSuKUKdaxCIF8QKZs2EB1A6G0K4Q=="
        },
        "outputPrefixType": "TINK",
        "keyId": 1343443983,
        "status": "ENABLED"
    }]
}

# # # Signatur einer Datei # # #
Die Datei a11_test_1mb.dat hat diese Signatur:015013540FFCB872878FFEC97B1CBE483F1A06A233EE088BE784F9E5A39364A6A84B06FA4A68B0F5E85330561419294AF67758A6D630E9822922BC81CAB5C6F04E5086580D
Die Datei hat diese Signatur als Base64String:AVATVA/8uHKHj/7Jexy+SD8aBqIz7giL54T55aOTZKaoSwb6Smiw9ehTMFYUGSlK9ndYptYw6YIpIryByrXG8E5QhlgN

# # # Signatur Verifizierung einer Datei # # #
Der Schlüssel wurde gelesen:h08_public_ed25519.txt
Die Signatur für die Datei a11_test_1mb.dat ist korrekt:true

H08 Signatur via Tink, Schlüssel Speicherung für eine Datei

Hinweis: Bitte benutzen Sie dieses Programm nur bei kleineren Dateien bis

zu einer Größe von 1 Megabyte, da die gesamte Datei in den Speicher geladen

und dort signiert bzw. verifiziert wird.

Schlüsselerzeugung und Speicherung

Der erzeugte private Schlüssel wurde gespeichert:h08_private_ed25519.txt

Der Schlüssel ist im Format:type.googleapis.com/google.crypto.tink.Ed25519PrivateKey

Der erzeugte öffentliche Schlüssel wurde gespeichert:h08_public_ed25519.txt

Der Schlüssel ist im Format:type.googleapis.com/google.crypto.tink.Ed25519PublicKey

PubKey: {

"primaryKeyId": 1343443983,

"key": [{

"keyData": {

"typeUrl": "type.googleapis.com/google.crypto.tink.Ed25519PrivateKey",

"keyMaterialType": "ASYMMETRIC_PRIVATE",

"value": "EiAhDqCUd1w+cBLeWeLzhpSQXw7ftyNYEjOwUHeGBfXONBoiEiCr53S9nfWgtJ4NohDSuKUKdaxCIF8QKZs2EB1A6G0K4Q=="

"outputPrefixType": "TINK",

"keyId": 1343443983,

"status": "ENABLED"

}]

}

# # # Signatur einer Datei # # #

Die Datei a11_test_1mb.dat hat diese Signatur:015013540FFCB872878FFEC97B1CBE483F1A06A233EE088BE784F9E5A39364A6A84B06FA4A68B0F5E85330561419294AF67758A6D630E9822922BC81CAB5C6F04E5086580D

Die Datei hat diese Signatur als Base64String:AVATVA/8uHKHj/7Jexy+SD8aBqIz7giL54T55aOTZKaoSwb6Smiw9ehTMFYUGSlK9ndYptYw6YIpIryByrXG8E5QhlgN

# # # Signatur Verifizierung einer Datei # # #

Der Schlüssel wurde gelesen:h08_public_ed25519.txt

Die Signatur für die Datei a11_test_1mb.dat ist korrekt:true

Alle Quellcodes zu Google Tink findet Ihr zum Download in meinem Github-Repository, welches Ihr über diesen Link erreicht: https://github.com/java-crypto/H-Google-Tink. Alle Programme sind sowohl unter Java 8 als auch unter Java 11 lauffähig.

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

Letzte Aktualisierung: 28.01.2019