const crypto = require('crypto');

// IMPORTANTE: capture o corpo BRUTO. Ex.:
// app.use('/webhook', express.raw({ type: 'application/json' }));

function verificarWebhook(req, apiSecret) {
  const header = req.headers['x-webhook-signature']; // "sha256=<hex>"
  const timestamp = req.headers['x-webhook-timestamp'];
  if (!header || !timestamp) return false;

  // 1. Anti-replay: rejeita timestamps fora de ±5 min
  const agora = Math.floor(Date.now() / 1000);
  if (Math.abs(agora - Number(timestamp)) > 300) return false;

  // 2. Recalcula o HMAC sobre `${timestamp}.${rawBody}`
  const rawBody = req.body.toString('utf8'); // Buffer -> string crua
  const signedPayload = `${timestamp}.${rawBody}`;
  const esperado = crypto
    .createHmac('sha256', apiSecret)
    .update(signedPayload)
    .digest('hex');

  // 3. Comparação em tempo constante
  const recebido = header.replace(/^sha256=/i, '');
  const a = Buffer.from(esperado, 'hex');
  const b = Buffer.from(recebido, 'hex');
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

app.post('/webhook', (req, res) => {
  if (!verificarWebhook(req, process.env.API_SECRET)) {
    return res.status(401).send('assinatura inválida');
  }
  const evento = JSON.parse(req.body.toString('utf8'));
  // ... idempotência via req.headers['x-webhook-event-id'] e processamento
  res.status(200).send('OK');
});

import hmac, hashlib, time
from flask import request, abort

def verificar_webhook(raw_body: bytes, headers, api_secret: str) -> bool:
    header = headers.get("X-Webhook-Signature", "")  # "sha256=<hex>"
    timestamp = headers.get("X-Webhook-Timestamp", "")
    if not header or not timestamp:
        return False

    # 1. Anti-replay: rejeita timestamps fora de ±5 min
    if abs(int(time.time()) - int(timestamp)) > 300:
        return False

    # 2. Recalcula o HMAC sobre f"{timestamp}.{raw_body}"
    signed_payload = timestamp.encode() + b"." + raw_body
    esperado = hmac.new(
        api_secret.encode(), signed_payload, hashlib.sha256
    ).hexdigest()

    # 3. Comparação em tempo constante
    recebido = header.replace("sha256=", "", 1)
    return hmac.compare_digest(esperado, recebido)

@app.post("/webhook")
def webhook():
    raw = request.get_data()  # corpo bruto, antes do parse
    if not verificar_webhook(raw, request.headers, API_SECRET):
        abort(401)
    evento = request.get_json()
    # ... idempotência via request.headers["X-Webhook-Event-Id"]
    return "OK", 200

<?php
function verificarWebhook(string $rawBody, array $headers, string $apiSecret): bool {
    $header = $headers['X-Webhook-Signature'] ?? '';   // "sha256=<hex>"
    $timestamp = $headers['X-Webhook-Timestamp'] ?? '';
    if ($header === '' || $timestamp === '') return false;

    // 1. Anti-replay: rejeita timestamps fora de ±5 min
    if (abs(time() - (int) $timestamp) > 300) return false;

    // 2. Recalcula o HMAC sobre "{timestamp}.{rawBody}"
    $signedPayload = $timestamp . '.' . $rawBody;
    $esperado = hash_hmac('sha256', $signedPayload, $apiSecret);

    // 3. Comparação em tempo constante
    $recebido = preg_replace('/^sha256=/i', '', $header);
    return hash_equals($esperado, $recebido);
}

$rawBody = file_get_contents('php://input'); // corpo bruto
$headers = getallheaders();
if (!verificarWebhook($rawBody, $headers, getenv('API_SECRET'))) {
    http_response_code(401);
    exit('assinatura inválida');
}
$evento = json_decode($rawBody, true);
// ... idempotência via $headers['X-Webhook-Event-Id']
http_response_code(200);
echo 'OK';