====== std.hash ======
Umfangreiche Hash-Bibliothek mit nicht-kryptografischen Funktionen (FNV1a-32/64, DJB2, Murmur2/3, xxHash-32/64, CRC32, CityHash-32/64, FarmHash-32/64) für Hash-Tables und Datenintegrität sowie kryptografischen Algorithmen: SHA-256, SHA-3 (224/256/512), BLAKE3, SHAKE-128/256. Für Passwort-Speicherung: bcrypt (cost 10), Argon2d/i/id, scrypt und PBKDF2-HMAC-SHA256 mit 100.000 Iterationen.
Einsatzbereiche: Hash-Table-Index-Berechnung, Datenintegrität, Passwort-Hashing (bcrypt/Argon2 empfohlen), Checksummen für Dateiübertragungen.
→ [[lyx_-_programmiersprache:units|Standard Library]] · [[lyx_-_programmiersprache:units:crypto|std.crypto]] · [[lyx_-_programmiersprache:units:crypto:md5|std.crypto.md5]] · [[lyx_-_programmiersprache:units:crypto:sha1|std.crypto.sha1]]
----
===== Nicht-kryptografische Hash-Funktionen =====
Schnelle Hash-Funktionen für Hash-Tables, Caches und Datenintegrität — nicht für kryptografische Zwecke:
^ Signatur ^ Beschreibung ^
| ''HashFNV1a32(data: pchar): int64'' | FNV1a-32-Hash aus Zeichenkette |
| ''HashFNV1a32Bytes(data: pchar, len: int64): int64'' | FNV1a-32-Hash aus Byte-Array |
| ''HashFNV1a64(data: pchar): int64'' | FNV1a-64-Hash aus Zeichenkette |
| ''HashFNV1a64Bytes(data: pchar, len: int64): int64'' | FNV1a-64-Hash aus Byte-Array |
| ''HashDJB2(data: pchar): int64'' | DJB2-Hash aus Zeichenkette |
| ''HashMurmur2(data: pchar, seed: int64): int64'' | Murmur2-Hash mit Seed |
| ''HashMurmur2Default(data: pchar): int64'' | Murmur2-Hash mit Standard-Seed |
| ''HashMurmur3_32(data: pchar, seed: int64): int64'' | Murmur3-32-Hash mit Seed |
| ''HashMurmur3_32Default(data: pchar): int64'' | Murmur3-32-Hash mit Standard-Seed |
| ''HashCRC32(data: pchar): int64'' | CRC32-Prüfsumme (IEEE 802.3) |
| ''HashCity32(data: pchar): int64'' | CityHash-32-Hash |
| ''HashCity64(data: pchar): int64'' | CityHash-64-Hash |
| ''HashCity64WithSeed(data: pchar, seed: int64): int64'' | CityHash-64 mit Seed |
| ''HashCity64Hex(data: pchar): pchar'' | CityHash-64 als Hex-Zeichenkette |
| ''HashFarm32(data: pchar): int64'' | FarmHash-32-Hash |
| ''HashFarm64(data: pchar): int64'' | FarmHash-64-Hash |
| ''HashFarm64WithSeed(data: pchar, seed: int64): int64'' | FarmHash-64 mit Seed |
| ''HashFarm64Hex(data: pchar): pchar'' | FarmHash-64 als Hex-Zeichenkette |
| ''HashxxHash32(data: pchar): int64'' | xxHash-32-Hash |
| ''HashxxHash64(data: pchar): int64'' | xxHash-64-Hash |
| ''HashTableIndex(key: pchar, table_size: int64): int64'' | Hash-Table-Index aus Schlüssel (modulo table_size) |
| ''HashBytes(data: pchar, len: int64): int64'' | Generischer Hash aus Byte-Array |
| ''HashInt64(key: int64): int64'' | 64-Bit-Integer hashen |
| ''HashInt32(key: int64): int64'' | 32-Bit-Integer hashen |
| ''VerifyHash(data: pchar, algorithm: int64, expected_hex: pchar): bool'' | Hash gegen Erwartungswert prüfen |
----
===== Kryptografische Hash-Funktionen =====
Kollisionsresistente Hash-Funktionen für Signaturen, Integritätsprüfungen und MACs:
^ Signatur ^ Ausgabe ^ Beschreibung ^
| ''HashSHA256(data: pchar): int64'' | 32 Bytes | SHA-256-Hash (NIST FIPS 180-4) |
| ''HashBLAKE3(data: pchar): int64'' | 32 Bytes | BLAKE3-Hash (schneller als SHA-256, sicher) |
| ''HashBLAKE3Bytes(data: pchar, len: int64): int64'' | 32 Bytes | BLAKE3-Hash aus Byte-Array |
| ''HashBLAKE3Hex(data: pchar): pchar'' | 64 Zeichen | BLAKE3-Hash als Hex-Zeichenkette |
| ''HashSHA3_224(data: pchar): int64'' | 28 Bytes | SHA-3-224-Hash |
| ''HashSHA3_256(data: pchar): int64'' | 32 Bytes | SHA-3-256-Hash |
| ''HashSHA3_512(data: pchar): int64'' | 64 Bytes | SHA-3-512-Hash |
| ''HashSHA3_256Hex(data: pchar): pchar'' | 64 Zeichen | SHA-3-256-Hash als Hex-Zeichenkette |
| ''HashKeccak(data: pchar): int64'' | 32 Bytes | Keccak-256-Hash (Basis von SHA-3) |
| ''HashSHAKE128(data: pchar, output_bits: int64): int64'' | variabel | SHAKE-128-XOF mit variabler Ausgabelänge |
| ''HashSHAKE256(data: pchar, output_bits: int64): int64'' | variabel | SHAKE-256-XOF mit variabler Ausgabelänge |
MD5 in std.hash (für Datei-Chunking; für Protokoll-MD5 → ''std.crypto.md5''):
^ Signatur ^ Beschreibung ^
| ''HashMD5String(data: pchar): int64'' | MD5-Hash aus Zeichenkette als raw int64 |
| ''HashMD5StringHex(data: pchar): pchar'' | MD5-Hash als 32-Zeichen-Hex |
| ''HashMD5Bytes(data: pchar, len: int64): int64'' | MD5-Hash aus Byte-Array |
| ''HashMD5FileInit(): int64'' | MD5-Streaming-Zustand initialisieren |
| ''HashMD5FileChunk(chunk: pchar, chunk_len: int64, state: int64): int64'' | Einen weiteren Datei-Chunk in den MD5-Zustand einmischen |
| ''HashMD5Quick(data: pchar): int64'' | MD5-Hash ohne Zustandsobjekt (kurze Daten) |
| ''MD5Verify(data: pchar, expected_hex: pchar): bool'' | Daten gegen erwarteten MD5-Hex prüfen |
----
===== Passwort-Hashing =====
Spezialisierte langsame Hash-Funktionen, die Brute-Force-Angriffe durch Rechenaufwand erschweren. Für neue Projekte Argon2id empfohlen:
^ Signatur ^ Beschreibung ^
| ''HashBCrypt(password: pchar, cost: int64): int64'' | bcrypt-Hash mit Kostenfaktor (Standard: 10) |
| ''HashBCryptWithSalt(password: pchar, salt: pchar, cost: int64): int64'' | bcrypt mit eigenem Salt |
| ''HashBCryptHex(password: pchar, cost: int64): pchar'' | bcrypt-Hash als Hex-Zeichenkette |
| ''HashBCryptFormatted(password: pchar, cost: int64): pchar'' | bcrypt-Hash im ''$2b$''-Format |
| ''BCryptVerify(password: pchar, hash: int64): bool'' | Passwort gegen bcrypt-Hash prüfen |
| ''HashArgon2(password: pchar, salt: pchar): int64'' | Argon2id-Hash mit Standardparametern |
| ''HashArgon2d(password: pchar, salt: pchar, mem: int64, iter: int64, par: int64): int64'' | Argon2d (datenabhängig, GPU-resistent) |
| ''HashArgon2i(password: pchar, salt: pchar, mem: int64, iter: int64, par: int64): int64'' | Argon2i (datenunabhängig, Side-Channel-resistent) |
| ''HashArgon2id(password: pchar, salt: pchar, mem: int64, iter: int64, par: int64): int64'' | Argon2id (Hybrid, OWASP-empfohlen) |
| ''HashArgon2Hex(password: pchar, salt: pchar): pchar'' | Argon2-Hash als Hex-Zeichenkette |
| ''HashArgon2Formatted(password: pchar, salt: pchar): pchar'' | Argon2-Hash im PHC-Stringformat |
| ''Argon2Verify(password: pchar, hash: int64): bool'' | Passwort gegen Argon2-Hash prüfen |
| ''HashScrypt(password: pchar, salt: pchar, n: int64, r: int64, p: int64): int64'' | scrypt mit Parametern (N, r, p) |
| ''HashScryptDefault(password: pchar, salt: pchar): int64'' | scrypt mit Standardparametern (N=16384, r=8, p=1) |
| ''HashScryptHex(password: pchar, salt: pchar): pchar'' | scrypt-Hash als Hex-Zeichenkette |
| ''HashPBKDF2(password: pchar, salt: pchar, iterations: int64): int64'' | PBKDF2-HMAC-SHA256 mit Iterationsanzahl |
| ''HashPBKDF2Default(password: pchar, salt: pchar): int64'' | PBKDF2 mit 100.000 Iterationen |
| ''HashPBKDF2Hex(password: pchar, salt: pchar, iterations: int64): pchar'' | PBKDF2-Hash als Hex-Zeichenkette |
| ''HashPassword(password: pchar, salt: pchar): int64'' | Allgemeiner Passwort-Hash (intern: Argon2id) |
| ''HashPasswordSimple(password: pchar, salt: int64): int64'' | Passwort-Hash mit Integer-Salt |
| ''ComparePasswordHashes(hash1: int64, hash2: int64): bool'' | Zwei Hashes timing-sicher vergleichen |
| ''GenerateSalt(len: int64): int64'' | Kryptografisches Salt via /dev/urandom |
| ''PasswordStrength(password: pchar): int64'' | Passwortstärke: 0 (schwach) bis 100 (stark) |
----
===== Verwendung =====
==== Hash-Table-Index ====
import std.hash;
fn LookupSlot(key: pchar, table_size: int64): int64 {
return HashTableIndex(key, table_size);
}
fn main(): int64 {
var slot: int64 := LookupSlot("user:42", 1024);
// slot ist 0..1023
return 0;
}
==== Datei-Checksumme (CRC32) ====
import std.hash;
import std.fs;
import std.io;
fn ChecksumFile(path: pchar): int64 {
var content: int64 := FsReadAll(path);
if (content == 0) { return 0; }
var crc: int64 := HashCRC32(content as pchar);
free(content, FsFileSize(path));
return crc;
}
==== Passwort hashen und prüfen (Argon2id) ====
import std.hash;
import std.alloc;
import std.io;
fn RegisterUser(password: pchar): int64 {
var salt: int64 := GenerateSalt(16);
var hash: int64 := HashArgon2(password, salt as pchar);
// hash in Datenbank speichern; salt ebenfalls (im PHC-Format enthalten)
free(salt, 16);
return hash;
}
fn LoginUser(password: pchar, stored_hash: int64): bool {
return Argon2Verify(password, stored_hash);
}
==== Kryptografischer Hash (BLAKE3) ====
import std.hash;
import std.io;
fn main(): int64 {
var hex: pchar := HashBLAKE3Hex("Hello, World!");
PrintLn(hex);
// Ausgabe: 64 Hex-Zeichen
return 0;
}
----
===== Hinweise =====
* **Passwort-Hashing**: Argon2id ist die OWASP-Empfehlung für neue Projekte. bcrypt ist bewährt; scrypt und PBKDF2 für Kompatibilität mit bestehenden Systemen.
* **Kryptografische Integrität**: BLAKE3 ist schneller als SHA-256 bei gleicher Sicherheit und für neue Projekte bevorzugt. SHA-3 für Anforderungen, die explizit NIST FIPS 202 verlangen.
* **Nicht-kryptografisch**: FNV1a und xxHash eignen sich am besten für Hash-Tables; CRC32 für Dateiübertragungen und Protokoll-Prüfsummen (IEEE 802.3).
* **MD5 und SHA-1** (Legacy) → [[lyx_-_programmiersprache:units:crypto:md5|std.crypto.md5]] bzw. [[lyx_-_programmiersprache:units:crypto:sha1|std.crypto.sha1]] für protokollspezifische Nutzung.
* ''ComparePasswordHashes'' nutzt **Constant-Time-Vergleich** — immer statt direktem ''=='' verwenden, um Timing-Angriffe zu vermeiden.
* ''GenerateSalt'' liest aus ''/dev/urandom'' — auf Bare-Metal ohne Linux-Kernel muss der Aufrufer ein eigenes CSPRNG bereitstellen.
----
===== Verwandte Units =====
* ''[[lyx_-_programmiersprache:units:crypto:aes|std.crypto.aes]]'' — AES-128/256-CBC-Verschlüsselung
* ''[[lyx_-_programmiersprache:units:crypto:md5|std.crypto.md5]]'' — MD5 für Protokolle (HTTP Digest, Dateiprüfung)
* ''[[lyx_-_programmiersprache:units:crypto:sha1|std.crypto.sha1]]'' — SHA-1 für MySQL-Auth, Git-Objekte
* ''[[lyx_-_programmiersprache:units:net:tls|std.net.tls]]'' — TLS/HTTPS (OpenSSL-basiert)
Letzte Aktualisierung: 2026-06-05