Verificação da assinatura

Toda requisição de webhook chega com:

X-Infi-Timestamp: unix timestamp em segundos.
X-Infi-Signature: sha256=<hex>, onde <hex> é o HMAC-SHA256 calculado sobre a concatenação "{timestamp}.{corpo bruto}" usando o segredo do webhook.

Algoritmo

Capture o corpo bruto da requisição (bytes, antes de qualquer parsing JSON).
Capture os headers X-Infi-Timestamp e X-Infi-Signature.
Concatene: payload = "{timestamp}.{rawBody}".
Compute expected = HMAC-SHA256(WEBHOOK_SECRET, payload) e codifique em hex.
Compare "sha256=" + expected com o cabeçalho recebido em tempo constante.

Use o corpo bruto, não JSON reserializado

A assinatura é sobre os bytes exatos enviados. Reserializar o JSON do seu lado pode mudar ordem de chaves ou espaçamento e quebrar a verificação. Configure seu framework para preservar o body bruto (ex.: em Express use express.raw({ type: 'application/json' })).

Onde obter o `WEBHOOK_SECRET`

O segredo é entregue junto com sua API key, pelo canal seguro combinado com a INFI (e-mail criptografado ou painel). Não exponha em código-fonte público nem em logs — armazene como variável de ambiente.

Mitigação de replay

Recomendado: rejeite webhooks com X-Infi-Timestamp muito antigo (ex.: > 5 minutos). Isso protege contra replay de webhooks legítimos capturados em trânsito.

Exemplos

# Validação shell — geralmente delega para a linguagem da aplicação.
# Conceito:
#   payload="${TIMESTAMP}.${RAW_BODY}"
#   expected=$(echo -n "$payload" | openssl dgst -sha256 -hmac "$INFI_WEBHOOK_SECRET" | awk '{print $2}')
#   [[ "sha256=$expected" == "$X_INFI_SIGNATURE" ]]

import crypto from 'node:crypto'
import express from 'express'
 
const app = express()
app.use('/webhooks/infi', express.raw({ type: 'application/json' }))
 
app.post('/webhooks/infi', (req, res) => {
  const ts        = req.header('X-Infi-Timestamp') || ''
  const sigHeader = req.header('X-Infi-Signature') || ''
  const sigHex    = sigHeader.startsWith('sha256=') ? sigHeader.slice(7) : ''
 
  // Anti-replay: rejeita timestamps com mais de 5 minutos
  const tsNum = Number(ts)
  if (!Number.isFinite(tsNum) || Math.abs(Date.now() / 1000 - tsNum) > 300) {
    return res.status(401).end()
  }
 
  const payload  = `${ts}.${req.body.toString('utf8')}`
  const expected = crypto
    .createHmac('sha256', process.env.INFI_WEBHOOK_SECRET)
    .update(payload)
    .digest('hex')
 
  if (
    sigHex.length !== expected.length ||
    !crypto.timingSafeEqual(Buffer.from(sigHex), Buffer.from(expected))
  ) {
    return res.status(401).end()
  }
 
  const event = JSON.parse(req.body.toString('utf8'))
  // Enfileira processamento idempotente. Responde rápido.
  res.status(200).end()
})
 
app.listen(3000)

import hmac, hashlib, os, time
from flask import Flask, request, abort
 
app = Flask(__name__)
 
@app.post("/webhooks/infi")
def infi_webhook():
    ts = request.headers.get("X-Infi-Timestamp", "")
    sig_header = request.headers.get("X-Infi-Signature", "")
    sig = sig_header[7:] if sig_header.startswith("sha256=") else ""
 
    try:
        ts_num = int(ts)
    except ValueError:
        abort(401)
    if abs(time.time() - ts_num) > 300:
        abort(401)
 
    raw = request.get_data()
    payload = f"{ts}.".encode() + raw
    expected = hmac.new(
        os.environ["INFI_WEBHOOK_SECRET"].encode(),
        payload,
        hashlib.sha256,
    ).hexdigest()
 
    if not hmac.compare_digest(expected, sig):
        abort(401)
 
    event = request.get_json()
    return "", 200

<?php
$ts        = $_SERVER['HTTP_X_INFI_TIMESTAMP']  ?? '';
$sigHeader = $_SERVER['HTTP_X_INFI_SIGNATURE'] ?? '';
$sig       = str_starts_with($sigHeader, 'sha256=') ? substr($sigHeader, 7) : '';
 
if (!ctype_digit($ts) || abs(time() - (int)$ts) > 300) {
  http_response_code(401);
  exit;
}
 
$raw      = file_get_contents('php://input');
$payload  = $ts . '.' . $raw;
$expected = hash_hmac('sha256', $payload, getenv('INFI_WEBHOOK_SECRET'));
 
if (!hash_equals($expected, $sig)) {
  http_response_code(401);
  exit;
}
 
$event = json_decode($raw, true);
http_response_code(200);

Eventos Retentativa e idempotência