Assinatura HMAC

const crypto = require('crypto');
const zlib = require('zlib');

function verifyWebhookSignature({
  secret,
  rawBody,            // Buffer com o corpo exatamente como chegou
  signatureHeader,    // x-webhook-signature
  idempotencyHeader,  // x-idempotency-key
  contentEncoding,    // content-encoding, se houver
  toleranceSeconds = 300,
}) {
  // 1. Se o corpo chegou comprimido, descomprima antes de assinar.
  const body = contentEncoding === 'gzip' ? zlib.gunzipSync(rawBody) : rawBody;

  // 2. Separe t e v1 do header de assinatura.
  const parts = {};
  for (const pair of signatureHeader.split(',')) {
    const i = pair.indexOf('=');
    parts[pair.slice(0, i).trim()] = pair.slice(i + 1).trim();
  }
  const { t, v1 } = parts;

  // 3. Recupere topic, partition e offset do header de idempotência.
  const last = idempotencyHeader.lastIndexOf(':');
  const prev = idempotencyHeader.lastIndexOf(':', last - 1);
  const topic = idempotencyHeader.slice(0, prev);
  const partition = idempotencyHeader.slice(prev + 1, last);
  const offset = idempotencyHeader.slice(last + 1);

  // 4. Monte a string canônica e calcule o HMAC.
  const canonical = Buffer.concat([
    Buffer.from(`${t}\n${topic}\n${partition}\n${offset}\n`, 'utf8'),
    body,
  ]);
  const expected = crypto.createHmac('sha256', secret).update(canonical).digest();
  const received = Buffer.from(v1, 'hex');

  // 5. Compare em tempo constante e rejeite assinaturas antigas.
  const valid =
    expected.length === received.length && crypto.timingSafeEqual(expected, received);
  const fresh = Math.abs(Math.floor(Date.now() / 1000) - Number(t)) <= toleranceSeconds;

  return valid && fresh;
}

import gzip
import hashlib
import hmac
import time


def verify_webhook_signature(
    secret: str,
    raw_body: bytes,            # corpo exatamente como chegou
    signature_header: str,      # x-webhook-signature
    idempotency_header: str,    # x-idempotency-key
    content_encoding: str | None = None,
    tolerance_seconds: int = 300,
) -> bool:
    # 1. Se o corpo chegou comprimido, descomprima antes de assinar.
    body = gzip.decompress(raw_body) if content_encoding == "gzip" else raw_body

    # 2. Separe t e v1 do header de assinatura.
    parts = dict(p.strip().split("=", 1) for p in signature_header.split(","))
    t, v1 = parts["t"], parts["v1"]

    # 3. Recupere topic, partition e offset do header de idempotência.
    topic, partition, offset = idempotency_header.rsplit(":", 2)

    # 4. Monte a string canônica e calcule o HMAC.
    canonical = b"\n".join([
        t.encode(), topic.encode(), partition.encode(), offset.encode(), body,
    ])
    expected = hmac.new(secret.encode(), canonical, hashlib.sha256).hexdigest()

    # 5. Compare em tempo constante e rejeite assinaturas antigas.
    fresh = abs(int(time.time()) - int(t)) <= tolerance_seconds
    return hmac.compare_digest(expected, v1) and fresh