Wie bereits angekündigt werde ich in den nächsten Wochen einige Aspekte asymmetrischer Kryptographie beschreiben. Der vorliegende Artikel erläutert ein Konzept, das auch viele Anwendungsmöglichkeiten abseits asymmetrischer Kryptographie hat, allerdings auch zum Beispiel auf private Schlüssel angewendet werden kann... und demonstriert die Implementierung in Java.

Vor einigen Wochen überschlug sich die Presse weil einige Kryptographen das Ergebnis einer abgehaltenen Wahl nicht einsehen konnten, da sie den dafür notwendingen Schlüssel verschlampt hatten.

Ich möchte mich jetzt nicht über die persönlichen und/oder fachlichen Qualifikationen der geschätzten Kollegen auslassen - ich kann es mir aber nur so vorstellen, dass sie sehr stark auf ihr jeweiliges Fach spezialisiert waren und nicht über Risiken beziehungsweise passende Risikokontrollmaßnahmen nachgedacht haben.

Sonst wäre ihnen nämlich - so wie mir - zwangsläufig eingefallen, dass man ein wirklich wichtiges Asset so schützt, dass mehrere vertrauenswürdige Entitäten zusammenarbeiten müssen, um auf dieses geschützte Asset wieder zugreifen zu können, man aber gleichzeitig dafür sorgt, dass eine geringe Anzahl der Entities ausfallen können, dadurch aber dieser Zugriff nicht sofort verlorengeht.

Oder um es mal in der Sprache des konkreten Vorfalls zu formulieren: Teilt den Schlüssel in 5 Teile so auf, dass er noch wiederhergestellt werden kann, wenn ein oder zwei zerstreute Professoren ihren jeweiligen Teil davon verbummeln!

Dafür existiert ein etabliertes Verfahren, das - zunächst ganz abstrakt als Geheimnisse bezeichnete - beliebige Daten so in Fragmente aufteilt, dass bereits eine Untermenge dieser Fragmente ausreicht, um die originalen Daten wiederherzustellen. Dieses Verfahren heißt Shamir’s Secret Sharing und die Verbindung zur asymmetrischen Kryptographie besteht darin, dass ich mit dem hier gezeigten Beispielcode demonstrieren werde, dass man damit auch private Schlüssel auf mehrere Geheimnisträger aufteilen kann und mit dem zugehörigen öffentlichen Schlüssel verschlüsselte Botschaften immer noch in Klartext umwandeln kann, selbst wenn nicht mehr alle Geheimnisträger dafür zur Verfügung stehen sollten.

Dazu benötigen wir zunächst wieder die bereits bekannten Methoden zur Extraktion des öffentlichen und privaten Schlüssels aus einem PKCS#12-Container (Ich benutze auch hier wieder Code aus: meinen diversen online verfügbaren Bibliotheken, die wiederum auf der Implementierung des BouncyCastle-Projekts beruhen):

private static java.security.PublicKey readPublicKey(java.io.File p12File, char[] passphrase) throws KeyStoreException, CertificateException, IOException, NoSuchAlgorithmException, UnrecoverableKeyException
{
    KeyStore receiverDigIdent = de.elbosso.util.security.Utilities.loadDigitalIdentityFromPKCS12(p12File, passphrase);
    Enumeration aliases = receiverDigIdent.aliases();
    String keyAlias = "";
    while (aliases.hasMoreElements())
    {
        keyAlias = (String) aliases.nextElement();
        CLASS_LOGGER.debug(keyAlias);
    }
    return (java.security.PublicKey) receiverDigIdent.getCertificate(keyAlias).getPublicKey();
}
private static PrivateKey readPrivateKey(java.io.File p12File, char[] passphrase) throws KeyStoreException, CertificateException, IOException, NoSuchAlgorithmException, UnrecoverableKeyException
{
    KeyStore receiverDigIdent = de.elbosso.util.security.Utilities.loadDigitalIdentityFromPKCS12(p12File, passphrase);
    Enumeration aliases = receiverDigIdent.aliases();
    String keyAlias = "";
    while (aliases.hasMoreElements())
    {
        keyAlias = (String) aliases.nextElement();
        CLASS_LOGGER.debug(keyAlias);
    }
    return (PrivateKey) receiverDigIdent.getKey(keyAlias, passphrase);
}

Nun wird eine Methode benötigt, die den privaten Schlüssel in Fragmente teilt - diese Methode benötigt die Gesamtzahl aller Fragmente sowie die Minimalzahl an Fragmenten, mit denen es immer noch möglich sein soll, den Schlüssel wiederherzustellen:

public Map<Integer, byte[]> split(java.io.File p12File, char[] passwd, int totalParts,int minParts) throws InvalidKeyException, UnrecoverableKeyException, NoSuchPaddingException, NoSuchAlgorithmException, IllegalBlockSizeException, BadPaddingException, KeyStoreException, CertificateException, IOException, InvalidKeySpecException
{
    PrivateKey pk=readPrivateKey(p12File,passwd);

    byte[] pkEncoded=pk.getEncoded();

    Scheme scheme = new Scheme(new SecureRandom(), totalParts, minParts);
    Map<Integer, byte[]> parts = scheme.split(pkEncoded);
    return parts;
}

Zu Demonstrationszwecken erstellte ich eine Methode, in der ich eine Untermenge der Fragmente zusammenstelle, aus der dann der Schlüssel wieder rekonstruiert werden soll - sie bekommt die Anzahl der Fragmente übergeben, die aus der Gesamtmenge selektiert werden sollen:

public Map<Integer, byte[]> assemble(Map<Integer, byte[]> parts,int howMany)
{
    java.util.List<byte[]> l=new java.util.LinkedList(parts.values());
    Map<Integer, byte[]> damaged = new java.util.HashMap();

    CLASS_LOGGER.debug("parts: "+parts.size());
    for(int i=0;i<java.lang.Math.min(parts.size(),howMany);++i)
        damaged.put(i+1,l.get(i));
    CLASS_LOGGER.debug("damaged length: "+damaged.size());
    return damaged;
}

Mit dem Ergebnis dieser Methode lässt sich anschließend versuchen, die Informationen wieder zu rekonstruieren:

public java.lang.String joinAndDecrypt(de.netsysit.util.CryptoContainer container, Map<Integer, byte[]> damaged, int totalParts,int minParts) throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, NoSuchPaddingException
{
    Scheme scheme = new Scheme(new SecureRandom(), totalParts, minParts);

    byte[] recovered = scheme.join(damaged);

    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    KeySpec privateKeySpec = new PKCS8EncodedKeySpec(recovered);
    PrivateKey pk = keyFactory.generatePrivate(privateKeySpec);

    return de.elbosso.util.security.Utilities.decryptRsaAes(container,pk);
}

Der Aufruf der Methoden könnte beispielsweise so erfolgen:

de.netsysit.util.CryptoContainer container= de.elbosso.util.security.Utilities.encryptRsaAes("huhu",readPublicKey(p12File,passwd));

Map<Integer, byte[]> parts=split(p12File, passwd,5, 3);
Map<Integer, byte[]> damaged=assemble(parts,3);
CLASS_LOGGER.debug(joinAndDecrypt(container,damaged,5, 3));

Es sei abschließend noch erwähnt, dass ich mich zur Implementierung des Algorithmus einer weiteren OpenSource-Bibliothek namens Shamirs Secret Sharing bedient habe.