Discord Bot Token Security: Envelope Encryption (AES-256-GCM) & Secret Management

Ein kompromittierter Discord-Bot-Token verleiht Angreifern uneingeschränkten Zugriff auf die Bot-Identität, private Server, Chatverläufe und Administrator-Befehle. Wenn ein Bot auf Tausenden von Servern aktiv ist, kann ein Token-Leak zur Zerstörung von Communities (Raid-Attacken) und zum dauerhaften Bann der Applikation durch Discord führen.

In diesem Leitfaden stellen wir die kryptografische Sicherheitsarchitektur vor, wie sie auf KiroCloud zur Absicherung sensibler Anmeldedaten im Ruhezustand (Data at Rest) mit AES-256-GCM Envelope Encryption implementiert ist.

1. Warum Plaintext-Speicherung in Datenbanken inakzeptabel ist

Das Speichern von Bot-Tokens in Klartext in einer Datenbank (wie PostgreSQL oder MySQL) stellt ein extremes Sicherheitsrisiko dar:

• Datenbank-Dumps und Backups enthalten unverschlüsselte Tokens.
• SQL-Injection-Schwachstellen können direkt alle Tokens im System kompromittieren.
• Entwickler oder Administratoren mit Lesezugriff auf die Datenbank können fremde Bots kapern.

Warum einfaches Hashing (wie bcrypt oder Argon2) nicht funktioniert:

Passwörter werden gehasht, weil man sie nach dem Login nie wieder im Klartext benötigt. Ein Bot-Token muss jedoch von der Host-Plattform im Klartext verwendet werden, um sich am Discord Gateway anzumelden. Daher ist eine starke, authentifizierte symmetrische Verschlüsselung zwingend erforderlich.

2. Der Goldstandard: Authenticated Encryption mit AES-256-GCM

Wir verwenden den Algorithmus AES-256-GCM (Galois/Counter Mode). GCM bietet zwei entscheidende Vorteile:

1. Vertraulichkeit: Niemand ohne den Master-Schlüssel kann den Token entschlüsseln.
2. Integrität & Authentizität: Durch einen 128-Bit Authentifizierungs-Tag (authTag) wird jeder Manipulationsversuch an der verschlüsselten Zeichenkette sofort erkannt und führt zum Abbruch der Entschlüsselung.

                  ┌───────────────────────────────┐
                  │    Discord Bot Token (Plain)  │
                  └───────────────┬───────────────┘
                                  │
                  ┌───────────────▼───────────────┐
                  │     AES-256-GCM Verschlüssler  │ ◄─── Master Key (256-bit)
                  └───────┬───────────────┬───────┘ ◄─── Random IV (96-bit)
                          │               │
            ┌─────────────▼─────┐   ┌─────▼─────────────┐
            │ Verschlüsselter   │   │ Authentication    │
            │ Ciphertext        │   │ Tag (128-bit)     │
            └─────────────┬─────┘   └─────┬─────────────┘
                          │               │
                          ▼               ▼
                  ┌───────────────────────────────┐
                  │     PostgreSQL Datensatz      │
                  │ (token_enc, token_iv, token_tag)
                  └───────────────────────────────┘

3. Vollständige Node.js Krypto-Implementierung

Nutze das native node:crypto-Modul für kryptografisch sichere Ver- und Entschlüsselung:

import crypto from 'node:crypto';

const ALGORITHM = 'aes-256-gcm';
const IV_LENGTH = 12; // 96 Bit für GCM Standard

export interface EncryptedSecret {
  ciphertext: string;
  iv: string;
  authTag: string;
}

/**
 * Verschlüsselt ein Geheimnis mit AES-256-GCM
 */
export function encryptSecret(plaintext: string, masterKeyHex: string): EncryptedSecret {
  const key = Buffer.from(masterKeyHex, 'hex');
  if (key.length !== 32) {
    throw new Error('Master key must be 32 bytes (256 bits).');
  }

  // WICHTIG: Jeder Vorgang MUSS einen kryptografisch zufälligen IV verwenden!
  const iv = crypto.randomBytes(IV_LENGTH);
  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);

  let ciphertext = cipher.update(plaintext, 'utf8', 'hex');
  ciphertext += cipher.final('hex');

  const authTag = cipher.getAuthTag().toString('hex');

  return {
    ciphertext,
    iv: iv.toString('hex'),
    authTag,
  };
}

/**
 * Entschlüsselt ein Geheimnis und verifiziert dessen Integrität
 */
export function decryptSecret(encrypted: EncryptedSecret, masterKeyHex: string): string {
  const key = Buffer.from(masterKeyHex, 'hex');
  const iv = Buffer.from(encrypted.iv, 'hex');
  const authTag = Buffer.from(encrypted.authTag, 'hex');

  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
  decipher.setAuthTag(authTag);

  let plaintext = decipher.update(encrypted.ciphertext, 'hex', 'utf8');
  plaintext += decipher.final('utf8'); // Wirft Fehler bei manipuliertem Ciphertext!

  return plaintext;
}

!CAUTIONNiemals denselben IV wiederverwenden: In GCM führt die Wiederverwendung desselben Initialisierungsvektors mit demselben Schlüssel zum vollständigen Verlust der Authentizität und kann die Wiederherstellung des Klartexts ermöglichen. Erzeuge den IV ausnahmslos mit crypto.randomBytes(12).

4. Secret Management & Key Rotation

1. Master-Key niemals im Git-Repository speichern: Der AES-Schlüssel gehört ausschließlich in strikt geschützte Umgebungsvariablen (.env oder Vault-Systeme) mit restriktiven Dateirechten (chmod 600).
2. Schlüssel-Rotation (Re-Encryption): Wenn der Master-Schlüssel erneuert werden muss, führt ein Hintergrunddienst eine sequenzielle Re-Encryption durch:
   • Entschlüsseln mit altem Schlüssel
   • Verschlüsseln mit neuem Schlüssel
   • Transaktionales Update in der Datenbank

Auf KiroCloud geschieht diese Verschlüsselung vollautomatisch beim Eintragen von Discord-Tokens, wodurch selbst im Falle eines physischen Datenbankdiebstahls kein einziger Bot-Token kompromittiert werden kann.