Vérifier la signature HMAC d'un webhook

import crypto from 'node:crypto';
import { createServer } from 'node:http';
 
const WEBHOOK_SECRET = process.env.COFFRIFY_WEBHOOK_SECRET; // whsec_...
const TOLERANCE_SECONDS = 300;
 
/**
 * Vérifie la signature HMAC-SHA256 au format legacy Coffrify.
 * En-tête : X-Coffrify-Signature: t=<ts>,v1=<hex>
 */
function verifyCoffrifySignature(rawBody, signatureHeader, secret) {
  if (!signatureHeader) return { valid: false, reason: 'missing_signature' };
 
  const parts = Object.fromEntries(
    signatureHeader.split(',').map((p) => p.split('='))
  );
  const ts = parseInt(parts['t'], 10);
  const provided = parts['v1'];
 
  if (!ts || !provided) return { valid: false, reason: 'malformed' };
  if (Math.abs(Date.now() / 1000 - ts) > TOLERANCE_SECONDS) {
    return { valid: false, reason: 'expired' };
  }
 
  // Les octets bruts de la clé : décoder whsec_<hex>
  const hexKey = secret.startsWith('whsec_') ? secret.slice(6) : null;
  const keyBuf = hexKey
    ? Buffer.from(hexKey, 'hex')
    : Buffer.from(secret);
 
  const expected = crypto
    .createHmac('sha256', keyBuf)
    .update(`${ts}.${rawBody}`)
    .digest('hex');
 
  if (provided.length !== expected.length) {
    return { valid: false, reason: 'length_mismatch' };
  }
 
  const valid = crypto.timingSafeEqual(
    Buffer.from(provided, 'hex'),
    Buffer.from(expected, 'hex')
  );
  return valid ? { valid: true } : { valid: false, reason: 'mismatch' };
}
 
createServer((req, res) => {
  if (req.method !== 'POST') {
    res.writeHead(405).end();
    return;
  }
 
  let rawBody = '';
  req.on('data', (chunk) => { rawBody += chunk; });
  req.on('end', () => {
    const sig = req.headers['x-coffrify-signature'];
    const result = verifyCoffrifySignature(rawBody, sig, WEBHOOK_SECRET);
 
    if (!result.valid) {
      console.warn('Signature invalide :', result.reason);
      res.writeHead(401, { 'Content-Type': 'application/json' })
         .end(JSON.stringify({ error: result.reason }));
      return;
    }
 
    const event = JSON.parse(rawBody);
    console.log('Événement reçu :', event.type, event.id);
    // Traitez l'événement ici...
    res.writeHead(200).end('ok');
  });
}).listen(3000);

{
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "type": "transfer.downloaded",
  "created_at": "2026-06-06T10:23:00.000Z",
  "workspace_id": "ws_9f8e7d6c-5b4a-3c2d-1e0f-a1b2c3d4e5f6",
  "data": {
    "transfer_id": "tr_aabbccdd-1122-3344-5566-778899aabbcc",
    "title": "Rapport Q2 2026",
    "recipient_email": "destinataire@example.com",
    "files_count": 3,
    "encryption_mode": "server",
    "status": "downloaded"
  }
}

// Vérification Standard Webhooks (Node)
import crypto from 'node:crypto';
 
function verifyStandardWebhooks(rawBody, headers, secret) {
  const webhookId  = headers['webhook-id'];
  const timestamp  = headers['webhook-timestamp'];
  const sigHeader  = headers['webhook-signature'];
 
  if (!webhookId || !timestamp || !sigHeader) {
    return { valid: false, reason: 'missing_id_or_timestamp_for_standard' };
  }
 
  const ts = parseInt(timestamp, 10);
  if (Math.abs(Date.now() / 1000 - ts) > 300) {
    return { valid: false, reason: 'expired' };
  }
 
  const hexKey = secret.startsWith('whsec_') ? secret.slice(6) : null;
  const keyBuf = hexKey ? Buffer.from(hexKey, 'hex') : Buffer.from(secret);
 
  const message = `${webhookId}.${timestamp}.${rawBody}`;
  const expected = crypto
    .createHmac('sha256', keyBuf)
    .update(message)
    .digest('base64');
 
  // Plusieurs signatures possibles séparées par un espace (rotation)
  const candidates = sigHeader.split(' ')
    .filter((s) => s.startsWith('v1,'))
    .map((s) => s.slice(3));
 
  const valid = candidates.some((c) => {
    try {
      return crypto.timingSafeEqual(
        Buffer.from(c, 'base64'),
        Buffer.from(expected, 'base64')
      );
    } catch { return false; }
  });
 
  return valid ? { valid: true } : { valid: false, reason: 'mismatch' };
}

// Rotation de secret : accepter les deux pendant la transition
const NEW_SECRET = process.env.COFFRIFY_WEBHOOK_SECRET;
const OLD_SECRET = process.env.COFFRIFY_WEBHOOK_SECRET_OLD; // garde l'ancien
 
function verifyWithRotation(rawBody, signatureHeader) {
  for (const [index, secret] of [NEW_SECRET, OLD_SECRET].entries()) {
    if (!secret) continue;
    const result = verifyCoffrifySignature(rawBody, signatureHeader, secret);
    if (result.valid) {
      if (index === 1) console.warn('Livraison signée avec l ancien secret - planifiez la migration');
      return result;
    }
  }
  return { valid: false, reason: 'mismatch' };
}