std.crypto.sha256 — SHA-256 Hash

import std.crypto.sha256;

SHA-256-Implementierung nach FIPS PUB 180-4 / RFC 6234. Gibt einen 32-Byte-Digest zurück. Keine externe Abhängigkeit, kein AES-NI oder SHA-NI — reine Lyx-Implementierung.

→ std.crypto Paket · std.crypto.rand · std.hash

Konstanten

Keine öffentlichen Konstanten. Der Digest ist immer 32 Bytes, der Hex-String immer 64 Zeichen + NUL (65 Bytes).

Funktionen

Funktion	Signatur	Beschreibung
`SHA256`	`(data: int64, len: int64, out: int64): void`	Berechnet 32-Byte-Digest; schreibt ihn in `out`
`SHA256Hex`	`(data: int64, len: int64, out: int64): void`	Wie SHA256, aber als 64-Zeichen Hex + NUL in `out` (65 Bytes)
`SHA256Str`	`(data: pchar, len: int64, out: int64): void`	Convenience-Wrapper: `pchar`-Eingabe statt `int64`

Alle drei Funktionen allozieren intern und geben keinen Fehlercode zurück — sie setzen voraus, dass out groß genug ist.

Verwendung

Einfacher Hash

import std.crypto.sha256;
import std.alloc;
import std.io;

fn main(): int64 {
    var msg: pchar := "Hallo Welt";
    var digest: int64 := alloc(32);
    SHA256(msg as int64, 10, digest);

    // Ausgabe als Hex
    var hex: int64 := alloc(65);
    SHA256Hex(msg as int64, 10, hex);
    PrintLn(hex as pchar);

    free(hex, 65);
    free(digest, 32);
    return 0;
}

pchar-Wrapper

import std.crypto.sha256;
import std.alloc;

fn HashPassword(pw: pchar, pwLen: int64, outDigest: int64): void {
    SHA256Str(pw, pwLen, outDigest);
}

Datei hashen (blockweise)

// SHA256 über mehrere Puffer: zweimal aufrufen geht NICHT direkt —
// SHA256 ist ein One-Shot-Aufruf ohne Streaming-API.
// Für große Daten: gesamten Inhalt in einen alloc-Puffer laden, dann SHA256 aufrufen.
import std.crypto.sha256;
import std.alloc;
import std.fs;

fn HashFile(path: pchar, outDigest: int64): int64 {
    var fd: int64 := OpenFile(path, 0);
    if (fd < 0) { return fd; }
    var size: int64 := FileSize(fd);
    if (size < 0) { CloseFile(fd); return size; }

    var buf: int64 := alloc(size);
    var r: int64 := ReadFile(fd, buf as pchar, size);
    CloseFile(fd);
    if (r < 0) { free(buf, size); return r; }

    SHA256(buf, size, outDigest);
    free(buf, size);
    return 0;
}

Hinweise

Kein Streaming: SHA256 ist ein One-Shot-Aufruf. Für inkrementelle Verarbeitung muss der gesamte Input vorab im Speicher liegen.
Puffergröße: out muss mindestens 32 Bytes haben (SHA256), bzw. 65 Bytes (SHA256Hex inkl. NUL).
Keine Hardware-Beschleunigung: Diese Implementierung verwendet keine SHA-NI-Instruktionen. Für maximalen Durchsatz: externe optimierte Bibliothek via @extern.
Kryptografische Eignung: SHA-256 ist kollisionsresistent und für digitale Signaturen geeignet. Für Passwort-Hashing → std.hash (Argon2id).
Vergleich: Digests immer mit konstantzeitlichem Vergleich prüfen, nicht mit direktem Byte-Vergleich (Timing-Angriffe).

Letzte Aktualisierung: 2026-06-05