Eine Anwendung des SHA-512

Motivation

Für eine Webseite benötigte ich eine Verschlüsselungsmöglichkeit des Lokalteils von E-Mail Adressen. Dieselbe Technik lässt sich aber auch für andere Zeichenketten einsetzen.

E-Mail-Adressen wie Max.Mustermann@example.com bestehen prinzipiell aus drei Teilen: dem Lokalteil, dem Zeichen @ und dem Domänenteil. Über den Domänenteil wird der Dienstleister des zugehörigen E-Mail-Postfachs ermittelt. Der Lokalteil gibt an, welches Postfach bei diesem Dienstleister gemeint ist – oft benennt es den Empfänger sogar mit Namen. Der Lokalteil einer E-Mail-Adresse ist also spezifischer und privater als der Domänenteil – ebenso, wie Straße und Hausnummer privater als die Postleitzahl oder die Teilnehmerrufnummer privater als die Telefonvorwahl ist. Vorwahl oder Postleitzahl wird man beispielsweise für statistische Zwecke eher preisgeben als die zugehörigen persönlichen Angaben. Entsprechend ist es für bestimmte Anwendungen sinnvoll, den Lokalteil einer E-Mail-Adresse getrennt vom Domänenteil besonders zu schützen.

Ziele

Folgende Erwartungen stellte ich an die Verschlüsselung:

Nutzung eines symmetrischen Verschlüsselungsverfahrens für Folgen von bis zu 64 ASCII-Zeichen – der Lokalteil einer E-Mail-Adresse besteht ausschließlich aus ASCII-Zeichen (weitere Einschränkungen gelten) und umfasst höchstens 64 Bytes.¹ ²
Der Geheimtext soll keine Rückschlüsse auf die Länge des Klartextes bieten.
Die Verschlüsselung identischer Klartexte mit identischen Passwörtern soll in der Regel zu unterschiedlichen Geheimtexten führen. Sind weitere Informationen mit der verschlüsselten Information verknüpft, zum Beispiel in einer Datenbank, könnten diese einander sonst auch ohne Kenntnis des Schlüssels zugeordnet werden. Das soll verhindert werden.

Umsetzung

Verfahren

Als Verschlüsselungsverfahren setze ich eine bitweise XOR-Verknüpfung von Schlüssel und erweitertem Klartext ein. Dabei wird ein Geheimtextbit genau dann „eingeschaltet“, wenn die entsprechenden Klartext- und Schlüsselbits unterschiedliche Werte haben.

Länge des Geheimtexts

Alle Klartexte werden vor ihrer Verschlüsselung auf die maximale Klartextlänge von 64 Bytes erweitert. So ergeben sich stets gleich lange Geheimtexte. Fürs Auffüllen der Klartexte werden ASCII-fremde Zeichen ergänzt – nach der Entschlüsselung lassen sich diese von den ASCII-Zeichen des Klartextes leicht trennen.

Identische Eingaben, unterschiedliche Ausgaben

Um selbst bei identischen Klartexten und identischen Passwörtern verschiedene Geheimtexte zu erzeugen, werden mehrere Maßnahmen getroffen:

In den Schlüssel fließt außer dem Passwort als Salz in der Suppe zusätzlich ein zufälliger 24-Bit-Wert ein. Aus demselben Passwort können so mehr als 16 Millionen verschiedene Schlüssel entstehen.
Bei Klartexten mit einer Länge von weniger als 64 Zeichen werden die Klartextzeichen unter Beibehaltung ihrer Reihenfolge³ zufällig über den erweiterten Klartext verteilt.
Der Klartext wird mit aus dem ASCII-fremden Bereich zufällig ausgewählten Bytes zum erweiterten Klartext aufgefüllt.

Schlüsselwahl

Der Schlüssel wird gewonnen, indem die SHA-512-Funktion auf die Kombination aus Passwort und zufälligem 24-Bit-Wert angewendet wird. SHA ist ein englisches Akronym, dass für sicherer Hash-Algorithmus steht. Ein SHA-512-Hashwert besitzt eine länge von 512 Bits, also 64 Bytes – ideal für die Verknüpfung mit einem erweiterten Klartext derselben Länge.

Implementierung

Der folgende Quelltext zeigt eine mögliche Implementierung in PHP. Der Geheimtext wird für eine bessere Handhabung nicht in binärer Form, sondern zur Basis 64 kodiert ausgegeben und eingelesen, der zufällige 24-Bit-Wert auch in dieser Form verarbeitet. Dadurch ergibt sich eine Geheimtextlänge von 90 Bytes.

PHP-Quelltext

<?php

/* prlbr_64x7
*  is a class that en- and decrypts strings of up to 64 octets in the code range
*  0..127, e.g. the local parts of e-mail addresses. It uses a symmetric key
*  algorithm. Special characteristics are that all ciphertexts are equally long
*  and that same plaintexts encrypted using the same password still produce
*  different ciphertexts usually.
*/

class prlbr_64x7 {

    /* base64_rand
    *  returns a string of a given $number of random characters from the base64
    *  alphabet.
    */
    private static function base64_rand ($number) {
        static $base64 = array (
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
            'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
            'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
            'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
            'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
            'w', 'x', 'y', 'z', '0', '1', '2', '3',
            '4', '5', '6', '7', '8', '9', '+', '/'
        );

        for ($return = ''; $number > 0; --$number):
            $return .= $base64[mt_rand (0, 63)];
        endfor;

        return $return;
    } // private static function base64_rand


    /* encrypt
    *  encrypts a $plaintext string of up to 64 octects in the code range 0..127
    *  using an arbitrary $password string and returns a string of 90 characters
    *  from the base64 alphabet.
    */
    public static function encrypt ($plaintext, $password) {
        $textlen = strlen ($plaintext);
        if ($textlen > 64):
            return false;
        endif;
        // generate a 24-bit salt
        $salt = self::base64_rand (4);
        // calculate the key as a hash from the salt and the password
        $key = hash ('sha512', $salt . $password, true);
        // mix the plaintext octets with octects in the code range 128..255
        for ($mixed = '', $i = 63; $i >= 0; --$i):
            if (mt_rand (0, $i) < $textlen):
                $mixed .= $plaintext[--$textlen];
            else:
                $mixed .= chr (mt_rand (128, 255));
            endif;
        endfor;
        // XOR mixed and key for encryption, base64-encode it, prepend the salt
        return $salt . substr (base64_encode ($mixed ^ $key), 0, -2);
    } // public static function encrypt


    /* decrypt
    *  returns the plaintext after decrypting a given $ciphertext string of 90
    *  characters from the base64 alphabet using the provided $password string.
    */
    public static function decrypt ($ciphertext, $password) {
        // extract the salt
        $salt = substr ($ciphertext, 0, 4);
        // base64-decode the ciphertext
        $ciphertext = base64_decode (substr ($ciphertext, 4) . '==');
        // calculate the key as a hash from the salt and the password
        $key = hash ('sha512', $salt . $password, true);
        // XOR ciphertext and key for decryption
        $mixed = $ciphertext ^ $key;
        // extract the octects in the code range 0..127 from the result
        for ($plaintext = '', $i = strlen ($mixed) - 1; $i >= 0; --$i):
            if (ord ($mixed[$i]) < 128):
                $plaintext .= $mixed[$i];
            endif;
        endfor;
        return $plaintext;
    } // public static function decrypt

} // class prlbr_64x7

?>

Tipp zur Passwortwahl

Bei Einsatz in einer Datenbank kann es sich anbieten, den $password-Parameter zusätzlich zu variieren, beispielsweise durch Anhängen einer den Datensatz identifizierenden Nummer an das eigentliche Passwort.

Nicht-ASCII-Texte verschlüsseln

Beschrieben wurde, wie man bis zu 64 ASCII-Zeichen verschlüsseln kann. Das ist beispielsweise sinnvoll für die Sicherung von Lokalteilen von E-Mail-Adressen. In anderen Fällen mag es nützlich sein, auch Zeichen außerhalb des ASCII-Bereiches zu verschlüsseln, etwa in einer Passwortverwaltung, die auch Kennworte mit Umlauten speichert.

Für eine solche Anwendung kann ebenfalls der hier vorgestellte Algorithmus verwendet werden, wenn der Text vor der Übergabe an die Verschlüsselungsfunktion sowie nach der Entschlüsselung entsprechend umgewandelt wird. Erledigt man dies mit der Base64-Kodierung, lassen sich immerhin 48 völlig beliebige Klartext-Bytes verschlüsseln. Verwendet man eine effizientere Kodierung, die nicht nur ein Alphabet aus 64 Zeichen, sondern den gesamten ASCII-Bereich nutzt, lassen sich bis zu 56 beliebige Bytes verschlüsseln. In einem Folgeartikel beschreibe ich eine solche 8-Bit-7-Bit-Umwandlung.

RFC 2822, Abschnitt 3.4.1, Abrufdatum 2011-02-10
RFC 5321, Abschnitt 4.5.3.1.1, Abrufdatum 2011-02-10
In der als Quelltext zur Verfügung gestellten PHP-Implementierung wird die Reihenfolge der Klartextzeichen im erweiterten Klartext umgedreht, aber nicht unnachvollziehbar durcheinandergewürfelt.