Wie bereits angekündigt werde ich in den nächsten Wochen einige Aspekte asymmetrischer Kryptographie beschreiben. Der vorliegende Artikel erläutert nochmals Blind Sigatures und demonstriert die Implementierung in Java.

Zunächst nochmals eine kurze Zusammenfassung, was man unter Blindsignaturen versteht und warum sie wann nützlich sein können: Bei einer traditionellen Signatur, die als Notarsiegel eingesetzt wird lässt man sich von einer driten Partei den Inhalt einer Message beglaubigen und gleichzeitig stellt man so sicher, dass der Inhalt - auch vom Verfasser - nicht mehr geändert werden kann.

Dies bedingt aber, dass der Signierende den Inhalt der Nachricht kennt. Außerdem kann er - wenn ihm die Nachricht präsentiert wird - genau darüber Auskunft geben, wann und von wem ihm diese Nachricht zum Signieren übergeben wurde.

Möchte man all dies nicht, kann man im Digitalen Blindsignaturen einsetzen. Auf der Seite des Signierenden ändert sich nichts: Er bekommt nach wie vor eine Botschaft, die er signiert. Jedoch ist das nicht die Originalnachricht: die zu signierende Botschaft wurde vor der Übergabe an den Signaturdienstleister so verändert, dass keine Beziehung zur eigentlichen Nachricht herstellbar ist: Das klassische Beispiel ist ein Briefumschlag aus Kohlepapier, in dem ein - zum Beispiel - Wahlzettel - steckt: Der Mitarbeiter des Wahlbüros prüft meine Identität und bestätigt diese Prüfung anschließend dadurch, dass er außen auf dem Umschlag signiert, was die Signatur durch das Kohlepapier auf den Wahlschein überträgt. Anschließend werfe ich lediglich den Schein in die Urne. Er ist trotzdem signiert, aber der die Signatur leistende hat keine Möglichkeit, zu wissen, was er signiert hat.

Ich werde auch bei den Beispielen für diesen Artikel in der Sprache Java auf meine diversen online verfügbaren Bibliotheken zurückgreifen, die wiederum auf der Implementierung des BouncyCastle-Projekts beruhen.

Ich benutze für die Demonstration hier die Zertifikate aus meinem Projekt zur Erzeugung von Zertifikaten zum Testen von Implementierungen speziell der korrekten Validierung.

Sehen wir uns zunächst die Seite dessen an, der seine Message beglaubigt haben möchte - derjenige benötigt den Public Key der digitalen Identität, deren Inhaber die Signatur erstellen wird. Mit diesem und einer Implementierung des zu nutzenden Digest und dem eigentlichen zu signierenden Text wird eine Instanz der Hilfsklasse Client erstellt, die die notwendigen Operationen zusammenfasst:

static class Client extends java.lang.Object
{
    private final java.security.PublicKey pubKey;
    private final java.lang.String payload;
    org.bouncycastle.crypto.ExtendedDigest digest;

    Client(java.security.PublicKey pk, org.bouncycastle.crypto.ExtendedDigest digest, java.lang.String payload) throws NoSuchAlgorithmException, IOException, InvalidKeySpecException
    {
        super();
        this.payload=payload;
        this.digest=digest;

        pubKey=pk;
    }
    BlindedSignatureIntermediary blindDataForSigning() throws CryptoException, IOException
    {
        return de.elbosso.util.security.Utilities.blindDataForSigning(payload.getBytes(),digest, pubKey);
    }
    byte[] unblindSignature(byte[] blindedsignature,BlindedSignatureIntermediary blindedSignatureIntermediary) throws CryptoException, IOException
    {
        return de.elbosso.util.security.Utilities.unblindSignature(blindedsignature,blindedSignatureIntermediary);
    }
}

Die korrespondierende Klasse, die die Operationen auf Seiten des Signaturerstellers zusammenfasst wird mit dem entsprechenden KeyPair instantiiert:

static class Authority extends java.lang.Object
{
    private final KeyPair kp;
    Authority(KeyPair kp) throws KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, IOException, CertificateException
    {
        super();
        this.kp = kp;
    }
    byte[] sign(BlindedSignatureIntermediary blindedSignatureIntermediary) throws IOException, InvalidKeyException, NoSuchAlgorithmException, NoSuchProviderException, SignatureException
    {
        return de.elbosso.util.security.Utilities.blindSignInMemory(blindedSignatureIntermediary.getBlindedSigningRequest(),kp);
    }
}

Nun kann zunächst das Objekt erzeugt werden, das dem Signaturersteller zum Signieren übergeben werden kann - das geschieht mittels Aufrufen der Methode blindDataForSigning der Klasse Client - dieser Aufruf erzeugt eine Instanz der Klasse BlindedSignatureIntermediary die wiederum die Schnittstelle zwischen Client und Authority darstellt:

public class BlindedSignatureIntermediary extends java.lang.Object
{
	private final byte[] blindedSigningRequest;
	private final RSABlindingParameters blindingParams;

	BlindedSignatureIntermediary(byte[] blindedSigningRequest, RSABlindingParameters blindingParams)
	{
		super();
		this.blindedSigningRequest = blindedSigningRequest;
		this.blindingParams = blindingParams;
	}

	public byte[] getBlindedSigningRequest()
	{
		return blindedSigningRequest;
	}

	public RSABlindingParameters getBlindingParams()
	{
		return blindingParams;
	}
}

Der darin enthaltene blindedSigningRequest kann dann an die signierende Stelle übermittelt werden, die durch Aufruf der Methode sign der Klasse Authority die erzeugte Signatur zurückgibt, die dann wiederum auf Seite des Client über die Methode unblindSignature in eine standardkonforme, ganz normale Signatur zurückverwandelt wird, die ganz normal über die bekannten Validierungen für elektronische Signaturen verifiziert werden kann:

private static boolean verify(java.security.PublicKey pubKey, org.bouncycastle.crypto.ExtendedDigest digest) throws Exception
{
    FileInputStream sigfis = new FileInputStream(SIGNATUREFILENAME);
    FileInputStream datfis = new FileInputStream(PAYLOADNAME);

    PSSParameterSpec spec=new PSSParameterSpec(digest.getAlgorithmName(), "MGF1",new MGF1ParameterSpec(digest.getAlgorithmName()), digest.getByteLength(), 1);
    boolean verifies = de.elbosso.util.security.Utilities.checkSignatureValue(ALGORITHM,pubKey,sigfis,datfis,spec);
    datfis.close();
    sigfis.close();
    return verifies;
}

Artikel, die hierher verlinken