Kryptographie in Node.js: Verschlüsselung und Hashing mit crypto

Kryptographie in Node.js: Das crypto-Modul für Verschlüsselung und Hashing

In der modernen Webentwicklung ist Datensicherheit ein kritisch wichtiger Aspekt. Node.js bietet das integrierte Modul crypto, das kryptographische Funktionen implementiert, darunter symmetrische und asymmetrische Verschlüsselung, Hashing sowie die Berechnung von Nachrichtenauthentifizierungscodes (HMAC). In diesem Artikel werden wir die wichtigsten Funktionen des crypto-Moduls anhand praktischer Beispiele detailliert erläutern.

Installation und Einbindung

Das Modul crypto ist Teil der Standardbibliothek von Node.js, daher ist keine zusätzliche Installation erforderlich. Zur Nutzung genügt der Import:

const crypto = require('crypto');

Hashing von Daten

Hashing ist eine einseitige Umwandlung von Daten in eine Zeichenkette fester Länge. Der gängigste Algorithmus ist SHA-256. Hashes werden zur Überprüfung der Datenintegrität und zur Speicherung von Passwörtern (in Kombination mit Salt) verwendet.

const data = "Geheime Nachricht";const hash = crypto.createHash('sha256')    .update(data)    .digest('hex');

console.log(`SHA-256 Hash: ${hash}`);// Ausgabe: 64-stellige Zeichenkette

Zur Erhöhung der Passwortsicherheit verwenden Sie unbedingt Salt und den Algorithmus PBKDF2 oder bcrypt. Beispiel mit PBKDF2:

const password = "benutzer_passwort";const salt = crypto.randomBytes(16).toString('hex');

crypto.pbkdf2(password, salt, 100000, 64, 'sha512', (err, derivedKey) => {    if (err) throw err;    console.log(`Passwort-Hash: ${derivedKey.toString('hex')}`);    console.log(`Salt: ${salt}`);});

Symmetrische Verschlüsselung (AES)

Symmetrische Verschlüsselung verwendet denselben Schlüssel zum Ver- und Entschlüsseln. Der am weitesten verbreitete Algorithmus ist AES (Advanced Encryption Standard). Betrachten wir die Ver- und Entschlüsselung mit AES-256-CBC.

const algorithm = 'aes-256-cbc';const key = crypto.randomBytes(32); // 256-Bit-Schlüsselconst iv = crypto.randomBytes(16);  // Initialisierungsvektor

// Verschlüsselungfunction encrypt(text) {    const cipher = crypto.createCipheriv(algorithm, key, iv);    let encrypted = cipher.update(text, 'utf8', 'hex');    encrypted += cipher.final('hex');    return { iv: iv.toString('hex'), encryptedData: encrypted };}

// Entschlüsselungfunction decrypt(encryptedData, ivHex) {    const decipher = crypto.createDecipheriv(algorithm, key, Buffer.from(ivHex, 'hex'));    let decrypted = decipher.update(encryptedData, 'hex', 'utf8');    decrypted += decipher.final('utf8');    return decrypted;}

// Beispiel zur Verwendungconst message = "Vertrauliche Daten";const encrypted = encrypt(message);console.log(`Verschlüsselt: ${encrypted.encryptedData}`);

const decrypted = decrypt(encrypted.encryptedData, encrypted.iv);console.log(`Entschlüsselt: ${decrypted}`);

Wichtig: Verwenden Sie niemals denselben IV für verschiedene Nachrichten. Generieren Sie für jede Verschlüsselungsoperation einen neuen zufälligen IV.

Asymmetrische Verschlüsselung (RSA)

Asymmetrische Verschlüsselung verwendet ein Schlüsselpaar: einen öffentlichen (public) Schlüssel zum Verschlüsseln und einen privaten (private) Schlüssel zum Entschlüsseln. RSA ist der gängigste Algorithmus.

const { generateKeyPairSync, publicEncrypt, privateDecrypt } = crypto;

// Schlüsselgenerierungconst { publicKey, privateKey } = generateKeyPairSync('rsa', {    modulusLength: 2048,    publicKeyEncoding: { type: 'spki', format: 'pem' },    privateKeyEncoding: { type: 'pkcs8', format: 'pem' }});

// Verschlüsselung mit öffentlichem Schlüsselconst dataToEncrypt = "Geheime Nachricht für RSA";const encryptedData = publicEncrypt(publicKey, Buffer.from(dataToEncrypt));console.log(`RSA-verschlüsselt: ${encryptedData.toString('base64')}`);

// Entschlüsselung mit privatem Schlüsselconst decryptedData = privateDecrypt(privateKey, encryptedData);co