import crypto from 'node:crypto';

// Shared Secret aus .env des Client-Backends
const SIGNING_SECRET = process.env.LICENSE_SIGNING_SECRET || 'geheimes-shared-secret';
// Deployment-URL des Lizenz-Servers (HTTPS ohne Portnummer)
const LICENSE_SERVER_URL = process.env.LICENSE_SERVER_URL || 'https://';

/**
 * Überprüft den Lizenzschlüssel und validiert die kryptografische HMAC-Signatur
 */
async function verifyLicense(licenseKey, domain, instanceId) {
  const response = await fetch(`${LICENSE_SERVER_URL}/api/v1/licenses/verify`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      license_key: licenseKey,
      domain: domain,
      instance_id: instanceId,
      system_version: '2.4.0'
    })
  });

  const data = await response.json();
  if (!response.ok || !data.valid) {
    throw new Error(`Lizenzprüfung fehlgeschlagen: ${data.error || data.status}`);
  }

  // 1. Signaturprüfung (HMAC-SHA256 mit alphabetisch sortierten JSON-Keys)
  const { signature, ...payloadToVerify } = data;
  const normalized = JSON.stringify(payloadToVerify, Object.keys(payloadToVerify).sort());
  const expectedSignature = crypto
    .createHmac('sha256', SIGNING_SECRET)
    .update(normalized)
    .digest('hex');

  const bufReceived = Buffer.from(signature, 'hex');
  const bufExpected = Buffer.from(expectedSignature, 'hex');

  if (bufReceived.length !== bufExpected.length || !crypto.timingSafeEqual(bufReceived, bufExpected)) {
    throw new Error('Sicherheitsalarm: Ungültige HMAC-Signatur! Daten wurden manipuliert.');
  }

  // 2. Replay-Schutz: Zeitstempel überprüfen (max. 5 Minuten Abweichung)
  const responseTime = new Date(data.timestamp).getTime();
  if (Math.abs(Date.now() - responseTime) > 5 * 60 * 1000) {
    throw new Error('Replay-Angriff erkannt: Zeitstempel der Serverantwort ist abgelaufen!');
  }

  console.log(`✅ Lizenz aktiv für: ${data.customer} (Ablauf: ${data.expires_at || 'Unbegrenzt'})`);
  console.log('Freigeschaltete Module:', data.modules);
  return data;
}

import hmac
import hashlib
import json
import os
import requests
from datetime import datetime, timezone

SIGNING_SECRET = os.getenv("LICENSE_SIGNING_SECRET", "geheimes-shared-secret")
# Deployment-URL des Lizenz-Servers (HTTPS ohne Portnummer)
SERVER_URL = os.getenv("LICENSE_SERVER_URL", "https://")

def verify_license(license_key, domain="awareness.kunde.de", instance_id="server-node-01"):
    url = f"{SERVER_URL}/api/v1/licenses/verify"
    payload = {
        "license_key": license_key,
        "domain": domain,
        "instance_id": instance_id,
        "system_version": "2.4.0"
    }

    resp = requests.post(url, json=payload, timeout=10)
    data = resp.json()

    if resp.status_code != 200 or not data.get("valid"):
        raise PermissionError(f"Lizenz ungültig: {data.get('error', data.get('status'))}")

    # Signatur aus Antwort trennen
    server_sig = data.pop("signature", "")
    
    # Payload mit sortierten Schlüsseln normalisieren
    normalized = json.dumps(data, sort_keys=True, separators=(',', ':'))
    expected_sig = hmac.new(
        SIGNING_SECRET.encode('utf-8'),
        normalized.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

    # Constant-Time Signaturvergleich
    if not hmac.compare_digest(server_sig, expected_sig):
        raise SecurityError("Kryptografische Signatur ungültig! Daten wurden möglicherweise abgefangen.")

    print(f"✅ Lizenz bestätigt für Kunde: {data.get('customer')}")
    print(f"Modul-Berechtigungen: {data.get('modules')}")
    return data

';

$payload = json_encode([
    'license_key'    => 'SEC-ABCD-1234-EFGH-5678',
    'domain'         => 'awareness.kunde.de',
    'instance_id'    => 'server-node-01',
    'system_version' => '2.4.0'
]);

$ch = curl_init("$serverUrl/api/v1/licenses/verify");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_TIMEOUT, 10);

$rawResponse = curl_exec($ch);
$httpCode    = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$data = json_decode($rawResponse, true);

if ($httpCode !== 200 || empty($data['valid'])) {
    throw new Exception("Lizenz ungültig: " . ($data['error'] ?? 'HTTP ' . $httpCode));
}

// Signaturprüfung
$receivedSig = $data['signature'] ?? '';
unset($data['signature']);

// Normalisierung: Alphabetische Sortierung der Schlüssel
ksort($data);
$normalized  = json_encode($data, JSON_UNESCAPED_SLASHES);
$expectedSig = hash_hmac('sha256', $normalized, $signingSecret);

if (!hash_equals($receivedSig, $expectedSig)) {
    throw new SecurityException("Kritischer Fehler: HMAC-Signatur stimmt nicht überein!");
}

echo "✅ Lizenz verifiziert für: " . htmlspecialchars($data['customer']) . "\n";
print_r($data['modules']);
?>