Verificación de la firma

Toda solicitud de webhook llega con:

X-Infi-Timestamp: timestamp unix en segundos.
X-Infi-Signature: sha256=<hex>, donde <hex> es el HMAC-SHA256 calculado sobre la concatenación "{timestamp}.{cuerpo crudo}" usando el secreto del webhook.

Algoritmo

Captura el cuerpo crudo de la solicitud (bytes, antes de cualquier parsing JSON).
Captura los encabezados X-Infi-Timestamp y X-Infi-Signature.
Concatena: payload = "{timestamp}.{rawBody}".
Calcula expected = HMAC-SHA256(WEBHOOK_SECRET, payload) y codifica en hex.
Compara "sha256=" + expected con el encabezado recibido en tiempo constante.

Usa el cuerpo crudo, no JSON reserializado

La firma es sobre los bytes exactos enviados. Reserializar el JSON de tu lado puede cambiar el orden de claves o el espaciado y romper la verificación. Configura tu framework para preservar el body crudo (p.ej. en Express usa express.raw({ type: 'application/json' })).

Dónde obtener el `WEBHOOK_SECRET`

El secreto se entrega junto con tu API key, por el canal seguro acordado con INFI (correo cifrado o panel). No lo expongas en código fuente público ni en logs — guárdalo como variable de entorno.

Mitigación de replay

Recomendado: rechaza webhooks con X-Infi-Timestamp muy antiguo (p.ej. > 5 minutos). Esto protege contra replay de webhooks legítimos capturados en tránsito.

Ejemplos

# Validación shell — usualmente se delega al lenguaje de la aplicación.
# Concepto:
#   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: rechaza timestamps con más 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'))
  // Encola procesamiento 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 Reintento e idempotencia