====== 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.

→ [[lyx_-_programmiersprache:units:crypto|std.crypto Paket]] · [[lyx_-_programmiersprache:units:crypto:rand|std.crypto.rand]] · [[lyx_-_programmiersprache:units:hash|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 ====

<code lyx>
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;
}
</code>

==== pchar-Wrapper ====

<code lyx>
import std.crypto.sha256;
import std.alloc;

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

==== Datei hashen (blockweise) ====

<code lyx>
// 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;
}
</code>

----

===== 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 → [[lyx_-_programmiersprache:units:hash|std.hash]] (Argon2id).
  * **Vergleich**: Digests immer mit konstantzeitlichem Vergleich prüfen, nicht mit direktem Byte-Vergleich (Timing-Angriffe).

----

Letzte Aktualisierung: 2026-06-05