NOTE

Bun implementiert die Funktionen `createHash` und `createHmac` aus [`node:crypto`](https://nodejs.org/api/crypto.html) zusätzlich zu den unten dokumentierten Bun-nativen APIs.

---

Bun.password

Bun.password ist eine Sammlung von Hilfsfunktionen zum Hashen und Verifizieren von Passwörtern mit verschiedenen kryptografisch sicheren Algorithmen.

const password = "super-secure-pa$$word";

const hash = await Bun.password.hash(password);
// => $argon2id$v=19$m=65536,t=2,p=1$tFq+9AVr1bfPxQdh6E8DQRhEXg/M/SqYCNu6gVdRRNs$GzJ8PuBi+K+BVojzPfS5mjnC8OpLGtv8KJqF99eP6a4

const isMatch = await Bun.password.verify(password, hash);
// => true

Das zweite Argument von Bun.password.hash akzeptiert ein Parameterobjekt, mit dem Sie den Hashing-Algorithmus auswählen und konfigurieren können.

const password = "super-secure-pa$$word";

// argon2 verwenden (Standard)
const argonHash = await Bun.password.hash(password, {
  algorithm: "argon2id", // "argon2id" | "argon2i" | "argon2d"
  memoryCost: 4, // Speichernutzung in Kibibytes
  timeCost: 3, // Anzahl der Iterationen
});

// bcrypt verwenden
const bcryptHash = await Bun.password.hash(password, {
  algorithm: "bcrypt",
  cost: 4, // Zahl zwischen 4-31
});

Der Algorithmus, der zum Erstellen des Hashs verwendet wurde, wird im Hash selbst gespeichert. Bei Verwendung von bcrypt wird der zurückgegebene Hash im Modular Crypt Format kodiert, um Kompatibilität mit den meisten bestehenden bcrypt-Implementierungen zu gewährleisten; bei argon2 wird das Ergebnis im neueren PHC-Format kodiert.

Die verify-Funktion erkennt den Algorithmus automatisch basierend auf dem Eingabe-Hash und verwendet die richtige Verifizierungsmethode. Sie kann den Algorithmus sowohl aus PHC- als auch aus MCF-kodierten Hashes korrekt ableiten.

const password = "super-secure-pa$$word";

const hash = await Bun.password.hash(password, {
  /* config */
});

const isMatch = await Bun.password.verify(password, hash);
// => true

Synchrone Versionen aller Funktionen sind ebenfalls verfügbar. Beachten Sie, dass diese Funktionen rechenintensiv sind, sodass die Verwendung einer blockierenden API die Anwendungsleistung beeinträchtigen kann.

const password = "super-secure-pa$$word";

const hash = Bun.password.hashSync(password, {
  /* config */
});

const isMatch = Bun.password.verifySync(password, hash);
// => true

Salt

Wenn Sie Bun.password.hash verwenden, wird automatisch ein Salt generiert und in den Hash aufgenommen.

bcrypt - Modular Crypt Format

Im folgenden Modular Crypt Format Hash (verwendet von bcrypt):

Eingabe:

await Bun.password.hash("hello", {
  algorithm: "bcrypt",
});

Ausgabe:

$2b$10$Lyj9kHYZtiyfxh2G60TEfeqs7xkkGiEFFDi3iJGc50ZG/XJ1sxIFi;

Das Format besteht aus:

• bcrypt: $2b
• rounds: $10 - Runden (log10 der tatsächlichen Anzahl von Runden)
• salt: $Lyj9kHYZtiyfxh2G60TEfeqs7xkkGiEFFDi3iJGc50ZG/XJ1sxIFi
• hash: $GzJ8PuBi+K+BVojzPfS5mjnC8OpLGtv8KJqF99eP6a4

Standardmäßig kürzt die bcrypt-Bibliothek Passwörter, die länger als 72 Bytes sind. In Bun wird, wenn Sie Bun.password.hash ein Passwort übergeben, das länger als 72 Bytes ist, und den bcrypt-Algorithmus verwenden, das Passwort vor der Übergabe an bcrypt über SHA-512 gehasht.

await Bun.password.hash("hello".repeat(100), {
  algorithm: "bcrypt",
});

Anstatt bcrypt ein 500-Byte-Passwort zu senden, das stillschweigend auf 72 Bytes gekürzt wird, hasht Bun das Passwort mit SHA-512 und sendet das gehashte Passwort an bcrypt (nur wenn es 72 Bytes überschreitet). Dies ist ein sichereres Standardverhalten.

argon2 - PHC-Format

Im folgenden PHC-Format Hash (verwendet von argon2):

Eingabe:

await Bun.password.hash("hello", {
  algorithm: "argon2id",
});

Ausgabe:

$argon2id$v=19$m=65536,t=2,p=1$xXnlSvPh4ym5KYmxKAuuHVlDvy2QGHBNuI6bJJrRDOs$2YY6M48XmHn+s5NoBaL+ficzXajq2Yj8wut3r0vnrwI

Das Format besteht aus:

• algorithm: $argon2id
• version: $v=19
• memory cost: 65536
• iterations: t=2
• parallelism: p=1
• salt: $xXnlSvPh4ym5KYmxKAuuHVlDvy2QGHBNuI6bJJrRDOs
• hash: $2YY6M48XmHn+s5NoBaL+ficzXajq2Yj8wut3r0vnrwI

---

Bun.hash

Bun.hash ist eine Sammlung von Hilfsfunktionen für nicht-kryptografisches Hashing. Nicht-kryptografische Hashing-Algorithmen sind auf Rechengeschwindigkeit optimiert, nicht auf Kollisionsresistenz oder Sicherheit.

Die Standardfunktion Bun.hash verwendet Wyhash, um einen 64-Bit-Hash aus einer Eingabe beliebiger Größe zu generieren.

Bun.hash("some data here");
// 11562320457524636935n

Die Eingabe kann ein String, TypedArray, DataView, ArrayBuffer oder SharedArrayBuffer sein.

const arr = new Uint8Array([1, 2, 3, 4]);

Bun.hash("some data here");
Bun.hash(arr);
Bun.hash(arr.buffer);
Bun.hash(new DataView(arr.buffer));

Optional kann ein Integer-Seed als zweiter Parameter angegeben werden. Für 64-Bit-Hashes sollten Seeds über Number.MAX_SAFE_INTEGER als BigInt angegeben werden, um Präzisionsverlust zu vermeiden.

Bun.hash("some data here", 1234);
// 15724820720172937558n

Zusätzliche Hashing-Algorithmen sind als Eigenschaften von Bun.hash verfügbar. Die API ist für alle gleich, nur der Rückgabetyp ändert sich von number für 32-Bit-Hashes zu bigint für 64-Bit-Hashes.

Bun.hash.wyhash("data", 1234); // entspricht Bun.hash()
Bun.hash.crc32("data", 1234);
Bun.hash.adler32("data", 1234);
Bun.hash.cityHash32("data", 1234);
Bun.hash.cityHash64("data", 1234);
Bun.hash.xxHash32("data", 1234);
Bun.hash.xxHash64("data", 1234);
Bun.hash.xxHash3("data", 1234);
Bun.hash.murmur32v3("data", 1234);
Bun.hash.murmur32v2("data", 1234);
Bun.hash.murmur64v2("data", 1234);
Bun.hash.rapidhash("data", 1234);

---

Bun.CryptoHasher

Bun.CryptoHasher ist eine allgemeine Hilfsklasse, mit der Sie inkrementell einen Hash von String- oder Binärdaten unter Verwendung einer Reihe von kryptografischen Hash-Algorithmen berechnen können. Die folgenden Algorithmen werden unterstützt:

• "blake2b256"
• "blake2b512"
• "md4"
• "md5"
• "ripemd160"
• "sha1"
• "sha224"
• "sha256"
• "sha384"
• "sha512"
• "sha512-224"
• "sha512-256"
• "sha3-224"
• "sha3-256"
• "sha3-384"
• "sha3-512"
• "shake128"
• "shake256"

const hasher = new Bun.CryptoHasher("sha256");
hasher.update("hello world");
hasher.digest();
// Uint8Array(32) [ <byte>, <byte>, ... ]

Nach der Initialisierung können Daten inkrementell mit .update() an den Hasher übergeben werden. Diese Methode akzeptiert string, TypedArray und ArrayBuffer.

const hasher = new Bun.CryptoHasher("sha256");

hasher.update("hello world");
hasher.update(new Uint8Array([1, 2, 3]));
hasher.update(new ArrayBuffer(10));

Wenn ein string übergeben wird, kann ein optionaler zweiter Parameter verwendet werden, um die Kodierung anzugeben (Standard 'utf-8'). Die folgenden Kodierungen werden unterstützt:

Kategorie	Kodierungen
Binärkodierungen	"base64" "base64url" "hex" "binary"
Zeichenkodierungen	"utf8" "utf-8" "utf16le" "latin1"
Legacy-Zeichenkodierungen	"ascii" "binary" "ucs2" "ucs-2"

hasher.update("hello world"); // Standard ist utf8
hasher.update("hello world", "hex");
hasher.update("hello world", "base64");
hasher.update("hello world", "latin1");

Nachdem die Daten in den Hasher eingegeben wurden, kann ein finaler Hash mit .digest() berechnet werden. Standardmäßig gibt diese Methode ein Uint8Array zurück, das den Hash enthält.

const hasher = new Bun.CryptoHasher("sha256");
hasher.update("hello world");

hasher.digest();
// => Uint8Array(32) [ 185, 77, 39, 185, 147, ... ]

Die .digest()-Methode kann optional den Hash als String zurückgeben. Geben Sie dazu eine Kodierung an:

hasher.digest("base64");
// => "uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="

hasher.digest("hex");
// => "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

Alternativ kann die Methode den Hash in eine bestehende TypedArray-Instanz schreiben. Dies kann in einigen leistungsempfindlichen Anwendungen wünschenswert sein.

const arr = new Uint8Array(32);

hasher.digest(arr);

console.log(arr);
// => Uint8Array(32) [ 185, 77, 39, 185, 147, ... ]

HMAC in Bun.CryptoHasher

Bun.CryptoHasher kann zur Berechnung von HMAC-Digests verwendet werden. Übergeben Sie dazu den Schlüssel an den Konstruktor.

const hasher = new Bun.CryptoHasher("sha256", "secret-key");
hasher.update("hello world");
console.log(hasher.digest("hex"));
// => "095d5a21fe6d0646db223fdf3de6436bb8dfb2fab0b51677ecf6441fcf5f2a67"

Bei Verwendung von HMAC wird eine eingeschränktere Reihe von Algorithmen unterstützt:

• "blake2b512"
• "md5"
• "sha1"
• "sha224"
• "sha256"
• "sha384"
• "sha512-224"
• "sha512-256"
• "sha512"

Im Gegensatz zum nicht-HMAC Bun.CryptoHasher wird die HMAC Bun.CryptoHasher-Instanz nach Aufruf von .digest() nicht zurückgesetzt, und der Versuch, dieselbe Instanz erneut zu verwenden, löst einen Fehler aus.

Andere Methoden wie .copy() und .update() werden unterstützt (solange es vor .digest() ist), aber Methoden wie .digest(), die den Hasher finalisieren, werden nicht unterstützt.

const hasher = new Bun.CryptoHasher("sha256", "secret-key");
hasher.update("hello world");

const copy = hasher.copy();
copy.update("!");
console.log(copy.digest("hex"));
// => "3840176c3d8923f59ac402b7550404b28ab11cb0ef1fa199130a5c37864b5497"

console.log(hasher.digest("hex"));
// => "095d5a21fe6d0646db223fdf3de6436bb8dfb2fab0b51677ecf6441fcf5f2a67"