std.crypto.sha1

SHA-1 (Secure Hash Algorithm 1, NIST FIPS 180-4) erzeugt einen 160-Bit-Hashwert (20 Byte) aus beliebigen Eingabedaten. Obwohl SHA-1 für kryptographische Signaturen als veraltet gilt (kollisionsanfällig seit 2017), ist es in Legacy-Systemen, Checksummen und der MySQL-Authentifizierung (mysql_native_password) weiterhin im Einsatz.

Die Unit enthält neben der reinen SHA-1-Funktion auch SHA1MySQLNativePassword, die das MySQL-spezifische Doppel-Hash-Verfahren (SHA1(SHA1(password))) implementiert.

→ Standard Library · std.crypto.md5 · std.crypto.aes

Funktionen

Signatur	Beschreibung
`SHA1(data: int64, len: int64, out: int64): void`	Berechnet SHA-1-Hash der `len` Bytes ab `data` und schreibt 20 Roh-Bytes in `out` (`alloc(20)`)
`SHA1MySQLNativePassword(password: int64, passLen: int64, scramble: int64, out: int64): void`	MySQL-Authentifizierung: SHA1(SHA1(password)) XOR mit `scramble`; schreibt 20 Bytes in `out`

Verwendung

Zeichenkette hashen

import std.crypto.sha1;
import std.alloc;
import std.string;
import std.io;

fn PrintSHA1Hex(data: int64, len: int64): void {
    var digest: int64 := alloc(20);
    SHA1(data, len, digest);

    // 20 Bytes als Hex ausgeben
    var i: int64 := 0;
    while (i < 20) limit(20) {
        var b: int64 := peek8(digest + i);
        // Hohe Nibble
        var hi: int64 := (b >> 4) & 0xF;
        PrintChar(hi < 10 ? (hi + 48) : (hi + 87));
        // Niedrige Nibble
        var lo: int64 := b & 0xF;
        PrintChar(lo < 10 ? (lo + 48) : (lo + 87));
        i := i + 1;
    }
    PrintLn("");
    free(digest, 20);
}

fn main(): int64 {
    var msg: pchar := "Hello, World!";
    PrintSHA1Hex(msg as int64, StrLen(msg));
    // 0a0a9f2a6772942557ab5355d76af442f8f65e01
    return 0;
}

Rohdigest für weitere Verarbeitung

import std.crypto.sha1;
import std.alloc;

// Gibt alloc'd 20-Byte-Puffer zurück — Aufrufer muss free(digest, 20) aufrufen
fn ComputeSHA1(data: int64, len: int64): int64 {
    var digest: int64 := alloc(20);
    if (digest == 0) { return 0; }
    SHA1(data, len, digest);
    return digest;
}

MySQL-Authentifizierung

SHA-1 wird intern von std.db.mysql für den mysql_native_password-Handshake verwendet. Das Verfahren:

import std.crypto.sha1;
import std.alloc;

// MySQL-Auth-Response berechnen:
//   SHA1(SHA1(password)) XOR SHA1(scramble + SHA1(SHA1(password)))
// Lyx-Wrapper SHA1MySQLNativePassword kapselt das vollständig.
fn BuildMySQLAuthResponse(password: pchar, passLen: int64, scramble: int64): int64 {
    var response: int64 := alloc(20);
    SHA1MySQLNativePassword(password as int64, passLen, scramble, response);
    return response;   // Aufrufer: free(response, 20)
}

Hinweise

SHA-1 ist kollisionsanfällig seit dem SHAttered-Angriff (2017). Nicht für digitale Signaturen, Zertifikate oder Passwort-Hashing verwenden.
Für neue Projekte std.crypto.aes (symmetrische Verschlüsselung) oder einen SHA-256-Wrapper verwenden.
SHA1 schreibt exakt 20 Bytes in out — der Puffer muss mindestens 20 Bytes groß sein.
Für leere Eingaben (len=0) liefert SHA-1 da39a3ee5e6b4b0d3255bfef95601890afd80709.
Legitime Einsatzfälle heute: Git-Objektidentifikatoren, MySQL-Protokoll, HMAC-SHA1 in älteren Protokollen, Legacy-Checksummen.

Inhaltsverzeichnis