Crypto-js für JavaScript (Node.js): Vollständige Anleitung mit Beispielen

In der modernen Webentwicklung ist Datensicherheit ein kritischer Aspekt. Ob es um die Speicherung von Benutzerpasswörtern, die Übertragung vertraulicher Informationen über das Netzwerk oder den Schutz von Dateien vor unbefugtem Zugriff geht – Kryptographie bildet die Grundlage dieser Prozesse. Die Bibliothek Crypto-js bietet einen leistungsstarken und benutzerfreundlichen Satz kryptografischer Algorithmen für das JavaScript-Ökosystem und funktioniert sowohl im Browser als auch in der Node.js-Umgebung.

Diese Bibliothek implementiert eine breite Palette standardmäßiger kryptografischer Funktionen: symmetrische Verschlüsselung (AES, DES, TripleDES), Hashing (MD5, SHA-1, SHA-256, SHA-512), HMAC-Berechnung sowie die Generierung von Zufallszahlen und die Arbeit mit Kodierungen (Base64, Hex, UTF-8). Crypto-js ist unabhängig von nativen Betriebssystemmodulen, was es zur idealen Wahl für isomorphe Anwendungen macht (Code, der sowohl auf dem Client als auch auf dem Server läuft).

In diesem Artikel gehen wir detailliert auf die Installation der Bibliothek, die wichtigsten Methoden mit Codebeispielen sowie ein praktisches Anwendungsbeispiel von Crypto-js zum Schutz von Daten in einer Webanwendung ein. Das Material ist sowohl für Anfänger als auch für erfahrene Entwickler geeignet, die ihr Wissen über Kryptographie in JavaScript systematisieren möchten.

Installation

Für die Installation von Crypto-js in einem Node.js-Projekt führen Sie den folgenden Befehl im Terminal aus:

npm install crypto-js

Nach der Installation können Sie die Bibliothek in Ihren Code importieren:

// Für Node.js (CommonJS)
const CryptoJS = require("crypto-js");

// Für ES Modules (falls "type": "module" in package.json verwendet wird)
import CryptoJS from "crypto-js";

Schnellstart: Minimales funktionsfähiges Beispiel

Beginnen wir mit einem einfachen Beispiel – der Ver- und Entschlüsselung eines Strings mit dem AES-Algorithmus:

const CryptoJS = require("crypto-js");

// Ursprüngliche Nachricht
const message = "Hallo, Crypto-js!";

// Geheimer Schlüssel (sollte in einer echten Anwendung sicher sein)
const secretKey = "mein-geheimer-schluessel-123";

// Verschlüsselung
const ciphertext = CryptoJS.AES.encrypt(message, secretKey).toString();
console.log("Verschlüsselte Nachricht:", ciphertext);

// Entschlüsselung
const bytes = CryptoJS.AES.decrypt(ciphertext, secretKey);
const decryptedMessage = bytes.toString(CryptoJS.enc.Utf8);
console.log("Entschlüsselte Nachricht:", decryptedMessage);

Dieses Beispiel zeigt den grundlegenden Ablauf der symmetrischen Verschlüsselung: Wir wandeln den ursprünglichen Text in einen verschlüsselten String (Base64) um und stellen dann die ursprüngliche Nachricht mit demselben Schlüssel wieder her.

Wichtige Methoden/Funktionen/Klassen

Betrachten wir die wichtigsten Funktionen von Crypto-js. Für jede Methode werden die Signatur, eine kurze Beschreibung und ein funktionsfähiges Beispiel angegeben.

1. CryptoJS.AES.encrypt() / CryptoJS.AES.decrypt()

Signatur: CryptoJS.AES.encrypt(message, key, [options]) und CryptoJS.AES.decrypt(ciphertext, key, [options])

Funktion: Implementiert die symmetrische Ver- und Entschlüsselung mit dem AES-Algorithmus (Advanced Encryption Standard). Unterstützt die Modi ECB, CBC, CFB, OFB, CTR und Schlüssellängen von 128/192/256 Bit.

const CryptoJS = require("crypto-js");

const message = "Geheime Daten";
const key = "supersecretkey123";

// Verschlüsselung mit Angabe von Modus und IV (Initialisierungsvektor)
const iv = CryptoJS.lib.WordArray.random(16); // 16 Bytes für AES-128
const encrypted = CryptoJS.AES.encrypt(message, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7
}).toString();

console.log("Verschlüsselt (CBC):", encrypted);

// Entschlüsselung
const decrypted = CryptoJS.AES.decrypt(encrypted, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7
}).toString(CryptoJS.enc.Utf8);

console.log("Entschlüsselt:", decrypted);

2. CryptoJS.SHA256()

Signatur: CryptoJS.SHA256(message)

Funktion: Erzeugt einen SHA-256-Hash (32 Byte) der Eingabe. SHA-256 ist Teil der SHA-2-Familie und wird häufig für die Integritätsprüfung von Daten und in der Blockchain-Technologie verwendet.

const CryptoJS = require("crypto-js");

const data = "Wichtige Daten";
const hash = CryptoJS.SHA256(data).toString();
console.log("SHA-256 Hash:", hash);
// Ausgabe: 64-stelliger Hexadezimal-String

3. CryptoJS.HmacSHA256()

Signatur: CryptoJS.HmacSHA256(message, key)

Funktion: Berechnet einen Hash-basierten Message Authentication Code (HMAC) mit dem SHA-256-Algorithmus. Wird verwendet, um sowohl die Integrität als auch die Authentizität einer Nachricht zu überprüfen.

const CryptoJS = require("crypto-js");

const message = "Authentifizierte Nachricht";
const secret = "geheimer-schluessel";

const hmac = CryptoJS.HmacSHA256(message, secret).toString();
console.log("HMAC-SHA256:", hmac);

4. CryptoJS.enc.Base64.stringify() / CryptoJS.enc.Base64.parse()

Signatur: CryptoJS.enc.Base64.stringify(wordArray) und CryptoJS.enc.Base64.parse(base64String)

Funktion: Ermöglicht die Konvertierung zwischen WordArray-Objekten (dem internen Datenformat von Crypto-js) und Base64-kodierten Strings. Nützlich für die Speicherung oder Übertragung von Binärdaten.

const CryptoJS = require("crypto-js");

// String zu Base64
const wordArray = CryptoJS.enc.Utf8.parse("Hallo Welt");
const base64 = CryptoJS.enc.Base64.stringify(wordArray);
console.log("Base64:", base64); // SGFsbG8gV2VsdA==

// Base64 zurück zu String
const parsedWordArray = CryptoJS.enc.Base64.parse(base64);
const originalString = parsedWordArray.toString(CryptoJS.enc.Utf8);
console.log("Original:", originalString); // Hallo Welt

Praktisches Beispiel: Sicheres Speichern von Benutzerpasswörtern

Ein häufiger Anwendungsfall ist das sichere Speichern von Passwörtern. Anstatt Passwörter im Klartext zu speichern, sollten Sie einen Hash mit einem Salt verwenden. Hier ist ein vollständiges Beispiel:

const CryptoJS = require("crypto-js");

function hashPassword(password) {
    // Generiere einen zufälligen Salt (16 Bytes)
    const salt = CryptoJS.lib.WordArray.random(16).toString();
    
    // Kombiniere Passwort und Salt und hashe mit SHA-256
    const hash = CryptoJS.SHA256(salt + password).toString();
    
    // Gib Salt und Hash zurück (getrennt durch Doppelpunkt)
    return salt + ":" + hash;
}

function verifyPassword(password, storedHash) {
    // Extrahiere Salt und Hash aus dem gespeicherten String
    const parts = storedHash.split(":");
    const salt = parts[0];
    const originalHash = parts[1];
    
    // Berechne den Hash des eingegebenen Passworts mit dem gespeicherten Salt
    const computedHash = CryptoJS.SHA256(salt + password).toString();
    
    // Vergleiche die Hashes
    return computedHash === originalHash;
}

// Beispiel
const userPassword = "MeinSicheresPasswort123!";
const stored = hashPassword(userPassword);
console.log("Gespeicherter Hash:", stored);

// Überprüfung
const isCorrect = verifyPassword("MeinSicheresPasswort123!", stored);
console.log("Passwort korrekt?", isCorrect); // true

const isWrong = verifyPassword("FalschesPasswort", stored);
console.log("Falsches Passwort?", isWrong); // false

Fehlerbehandlung und Best Practices

Bei der Arbeit mit Crypto-js sollten Sie folgende Punkte beachten:

• Schlüsselverwaltung: Verwenden Sie niemals fest codierte Schlüssel im Quellcode. Nutzen Sie Umgebungsvariablen oder einen sicheren Schlüsseldienst.
• Initialisierungsvektor (IV): Bei der Verwendung von Modi wie CBC muss ein zufälliger IV generiert und zusammen mit dem Chiffretext gespeichert werden.
• Fehlerbehandlung: Fangen Sie Fehler bei der Entschlüsselung ab, z. B. wenn ein falscher Schlüssel verwendet wird:

try {
    const decrypted = CryptoJS.AES.decrypt(encryptedData, wrongKey).toString(CryptoJS.enc.Utf8);
    if (!decrypted) {
        throw new Error("Entschlüsselung fehlgeschlagen: Ungültiger Schlüssel oder beschädigte Daten");
    }
    console.log("Entschlüsselt:", decrypted);
} catch (error) {
    console.error("Fehler bei der Entschlüsselung:", error.message);
}

Zusammenfassung

Crypto-js ist eine vielseitige und zuverlässige Bibliothek für die Kryptographie in JavaScript. Sie bietet eine breite Palette von Algorithmen, eine einfache API und funktioniert plattformunabhängig. In diesem Leitfaden haben Sie gelernt, wie Sie die Bibliothek installieren, grundlegende Verschlüsselungs- und Hash-Funktionen verwenden und ein praktisches Beispiel für die Passwortspeicherung umsetzen. Mit diesen Kenntnissen können Sie die Datensicherheit in Ihren JavaScript-Projekten erheblich verbessern.