Hash-Generator: Kryptografisches Hashing im großen Maßstab

Best Practices:

• • Generieren Sie Schlüssel mit kryptografisch sicherem Zufallsgenerator (mindestens 256 Bits)
• • Niemals Schlüssel im Quellcode hartcodieren - verwenden Sie Umgebungsvariablen oder Secret-Manager
• • Rotieren Sie Schlüssel regelmäßig (alle 90-180 Tage für hochsichere Anwendungen)
• • Verwenden Sie verschiedene Schlüssel für verschiedene Zwecke (Authentifizierung, Webhooks usw.)
• • Speichern Sie Schlüssel verschlüsselt im Ruhezustand und während der Übertragung

Example:

// Sicheren Schlüssel generieren
const crypto = require(''crypto'');
const secretKey = crypto.randomBytes(32).toString(''hex'');
// In Umgebungsvariable oder Secret-Manager speichern

Features:

• • Streaming-Verarbeitung - keine vollständige Datei-Pufferung
• • Konstante Speichernutzung (~10MB unabhängig von der Dateigröße)
• • Parallele Chunk-Verarbeitung für verbesserte Leistung
• • Fortschrittsverfolgung für große Dateien

Workflow:

1. 1. Hash der Originaldatei vor Verteilung generieren
2. 2. Hash an sicherem Ort speichern oder öffentlich veröffentlichen
3. 3. Empfänger laden Datei herunter und generieren Hash
4. 4. Hash der heruntergeladenen Datei mit Original-Hash vergleichen
5. 5. Wenn Hashes übereinstimmen, ist die Datei authentisch und unverändert

Use Cases:

• • Software-Verteilung (Downloads auf Änderungen überprüfen)
• • Cloud-Speicher-Integrität (Bit-Rot und Korruption erkennen)
• • Backup-Verifizierung (Backups auf Vollständigkeit und Gültigkeit bestätigen)
• • Datei-Deduplizierung (identische Dateien per Hash identifizieren)

Implementation:

1. 1. Kryptografisch zufälligen Salt generieren (mindestens 128 Bits)
2. 2. Salt mit Daten vor dem Hashen verketten: hash(salt + daten)
3. 3. Salt neben Hash speichern (Salt muss nicht geheim sein)
4. 4. Bei Verifizierung neue Eingabe mit demselben Salt hashen und vergleichen

Example:

// Hashing mit Salt
const salt = crypto.randomBytes(16).toString(''hex'');
const dataWithSalt = salt + data;
const hash = await generateHash(dataWithSalt, ''sha256'');
// Speichern: salt + '':'' + hash

How they work:

Angreifer berechnen Hashes häufiger Passwörter/Daten vor und suchen gestohlene Hashes, um den Originalwert zu finden.

Protection:

• • Verwenden Sie eindeutige Salts für jeden Hash (macht Rainbow-Tables wirkungslos)
• • Verwenden Sie langsame Hash-Funktionen für Passwörter (bcrypt, Argon2)
• • Verwenden Sie lange, zufällige Salts (mindestens 128 Bits)
• • Niemals Salts über verschiedene Daten hinweg wiederverwenden

Code:

import axios from 'axios';

const generateTextHash = async (text: string, algorithm = 'sha256') => {
  try {
    const response = await axios.post(
      'https://apphighway.com/api/v1/hash/generate',
      {
        input: text,
        algorithm: algorithm, // 'md5', 'sha1', 'sha256', 'sha512', 'blake2'
        outputFormat: 'hex' // oder 'base64'
      },
      {
        headers: {
          'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );

    console.log(`${algorithm.toUpperCase()} Hash:`, response.data.hash);
    // Ausgabe: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"

    return response.data.hash;
  } catch (error) {
    console.error('Hash-Generierungsfehler:', error.response?.data);
    throw error;
  }
};

// Verwendung
const hash = await generateTextHash('Hallo Welt', 'sha256');
console.log('Datei-Fingerabdruck:', hash);

Code:

import axios from 'axios';
import crypto from 'crypto';

const signWebhookPayload = async (payload: object, secretKey: string) => {
  try {
    // Payload in JSON-String konvertieren
    const payloadString = JSON.stringify(payload);

    const response = await axios.post(
      'https://apphighway.com/api/v1/hash/hmac',
      {
        input: payloadString,
        algorithm: 'sha256',
        secretKey: secretKey,
        outputFormat: 'hex'
      },
      {
        headers: {
          'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );

    const signature = response.data.hmac;
    console.log('HMAC-Signatur:', signature);

    return signature;
  } catch (error) {
    console.error('HMAC-Generierungsfehler:', error.response?.data);
    throw error;
  }
};

// Webhook mit Signatur senden
const sendWebhook = async (url: string, payload: object) => {
  const secretKey = process.env.WEBHOOK_SECRET;
  const signature = await signWebhookPayload(payload, secretKey);

  await axios.post(url, payload, {
    headers: {
      'X-Webhook-Signature': signature,
      'Content-Type': 'application/json'
    }
  });
};

// Webhook verifizieren
const verifyWebhook = async (payload: object, receivedSignature: string) => {
  const secretKey = process.env.WEBHOOK_SECRET;
  const computedSignature = await signWebhookPayload(payload, secretKey);

  if (computedSignature !== receivedSignature) {
    throw new Error('Ungültige Webhook-Signatur');
  }

  console.log('Webhook-Signatur verifiziert');
  return true;
};

Code:

import axios from 'axios';
import FormData from 'form-data';
import fs from 'fs';
import path from 'path';

const hashLargeFile = async (filePath: string, algorithm = 'sha256') => {
  try {
    const formData = new FormData();
    const fileStream = fs.createReadStream(filePath);
    const fileName = path.basename(filePath);

    formData.append('file', fileStream, fileName);
    formData.append('algorithm', algorithm);
    formData.append('outputFormat', 'hex');

    console.log(`Hashe Datei: ${fileName}`);
    const startTime = Date.now();

    const response = await axios.post(
      'https://apphighway.com/api/v1/hash/file',
      formData,
      {
        headers: {
          ...formData.getHeaders(),
          'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`
        },
        maxBodyLength: Infinity,
        maxContentLength: Infinity
      }
    );

    const duration = Date.now() - startTime;
    const fileSize = fs.statSync(filePath).size;
    const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);

    console.log(`Datei gehasht in ${duration}ms`);
    console.log(`Dateigröße: ${fileSizeMB} MB`);
    console.log(`${algorithm.toUpperCase()} Hash:`, response.data.hash);

    return {
      hash: response.data.hash,
      algorithm: algorithm,
      fileName: fileName,
      fileSize: fileSize,
      duration: duration
    };
  } catch (error) {
    console.error('Datei-Hashing-Fehler:', error.response?.data);
    throw error;
  }
};

// Verwendung - Datei hashen und Prüfsumme speichern
const verifyFileIntegrity = async (filePath: string, expectedHash: string) => {
  const result = await hashLargeFile(filePath, 'sha256');

  if (result.hash === expectedHash) {
    console.log('✓ Dateiintegrität verifiziert');
    return true;
  } else {
    console.error('✗ Dateiintegritätsprüfung FEHLGESCHLAGEN');
    console.error(`Erwartet: ${expectedHash}`);
    console.error(`Erhalten:  ${result.hash}`);
    return false;
  }
};

// Beispiel: Software-Download verifizieren
await hashLargeFile('./downloads/software-v1.2.3.exe', 'sha256');
await verifyFileIntegrity(
  './downloads/software-v1.2.3.exe',
  'a3c5f2e8b1d4c9a7f6e8d2b5c9a1f4e7d8b2c5a9f1e4d7b8c2a5f9e1d4c7b8a2'
);

Implementation Steps:

1. 1. Client berechnet SHA-256-Hash vor Upload (Browser-JavaScript)
2. 2. Client lädt Datei + Hash auf Server hoch
3. 3. Server verwendet AppHighway-API zum Hashen der empfangenen Datei
4. 4. Server vergleicht Client-Hash vs. Server-Hash
5. 5. Bei Nichtübereinstimmung: Upload ablehnen, Wiederholung anfordern. Bei Übereinstimmung: Akzeptieren und Hash speichern
6. 6. Hintergrundjob hasht regelmäßig gespeicherte Dateien erneut, um Bit-Rot zu erkennen

Serverseitiger Upload-Handler (Node.js)

import { hashLargeFile } from './apphighway';
import { saveFile, storeFileMetadata } from './storage';

const handleFileUpload = async (req, res) => {
  const { file } = req.files;
  const { clientHash, userId, fileName } = req.body;

  try {
    // Hochgeladene Datei auf Server hashen
    const result = await hashLargeFile(file.path, 'sha256');
    const serverHash = result.hash;

    // Hashes vergleichen
    if (serverHash !== clientHash) {
      console.error('Hash-Nichtübereinstimmung - Datei während Upload beschädigt');
      return res.status(400).json({
        error: 'Dateiintegritätsprüfung fehlgeschlagen',
        message: 'Datei möglicherweise beschädigt. Bitte versuchen Sie erneut hochzuladen.'
      });
    }

    // Datei und Metadaten speichern
    const fileUrl = await saveFile(file.path, fileName);
    await storeFileMetadata({
      userId,
      fileName,
      fileUrl,
      hash: serverHash,
      algorithm: 'sha256',
      uploadedAt: new Date(),
      fileSize: file.size
    });

    console.log(`Datei erfolgreich hochgeladen: ${fileName}`);
    res.json({
      success: true,
      fileUrl,
      hash: serverHash
    });
  } catch (error) {
    console.error('Upload-Fehler:', error);
    res.status(500).json({ error: 'Upload fehlgeschlagen' });
  }
};

// Hintergrundjob: Gespeicherte Dateiintegrität verifizieren
const verifyStoredFiles = async () => {
  const files = await getRecentlyUploadedFiles(100);

  for (const file of files) {
    try {
      const result = await hashLargeFile(file.path, 'sha256');

      if (result.hash !== file.storedHash) {
        console.error(`Datei beschädigt: ${file.fileName}`);
        await alertUser(file.userId, file.fileName);
        await markFileAsCorrupted(file.id);
      }
    } catch (error) {
      console.error(`Verifizierung fehlgeschlagen für ${file.fileName}:`, error);
    }
  }
};

// Täglich ausführen
setInterval(verifyStoredFiles, 24 * 60 * 60 * 1000);