Webhooks

// Node 18 ou mais novo, com Express 4. Arquivo completo, sem recorte.
//   npm install express
//   ADM_WEBHOOK_SEGREDO=... node webhook.mjs

import crypto from "node:crypto";
import express from "express";

const SEGREDO = process.env.ADM_WEBHOOK_SEGREDO;
const TOLERANCIA_SEGUNDOS = 300;

const app = express();

// express.raw guarda os BYTES do corpo em req.body. Com express.json()
// voce recebe um objeto e perde o texto original, que e justamente o
// que precisa ser assinado. Esta linha e a parte mais importante.
app.use("/webhooks/adigitalmax", express.raw({ type: "application/json", limit: "1mb" }));

/** Le "t=1786031051,v1=6f1c..." e devolve as partes. */
function lerAssinatura(cabecalho) {
  const partes = Object.fromEntries(
    String(cabecalho || "")
      .split(",")
      .map((p) => p.trim().split("=", 2))
      .filter((p) => p.length === 2)
  );
  return { t: partes.t, v1: partes.v1 };
}

function assinaturaConfere(corpoBruto, cabecalho) {
  const { t, v1 } = lerAssinatura(cabecalho);
  if (!t || !v1) return false;

  // 1. Janela de tempo: fecha o ataque de repeticao.
  const idade = Math.abs(Math.floor(Date.now() / 1000) - Number(t));
  if (Number.isNaN(idade) || idade > TOLERANCIA_SEGUNDOS) return false;

  // 2. Recalcula sobre o corpo bruto.
  const esperado = crypto
    .createHmac("sha256", SEGREDO)
    .update(`${t}.`)
    .update(corpoBruto)
    .digest("hex");

  // 3. Comparacao em tempo constante. timingSafeEqual exige mesmo
  // comprimento, por isso a checagem antes.
  if (v1.length !== esperado.length) return false;
  return crypto.timingSafeEqual(Buffer.from(v1), Buffer.from(esperado));
}

const eventosVistos = new Set(); // em produção, use Redis ou uma tabela.

app.post("/webhooks/adigitalmax", (req, res) => {
  if (!assinaturaConfere(req.body, req.headers["x-adigitalmax-signature"])) {
    // 401 e deliberado: nao devolva detalhe do que falhou.
    return res.status(401).send("assinatura invalida");
  }

  const evento = JSON.parse(req.body.toString("utf8"));

  // Idempotencia pelo eventoId, que se repete nas retentativas.
  if (eventosVistos.has(evento.eventoId)) {
    return res.status(200).send("ja processado");
  }
  eventosVistos.add(evento.eventoId);

  // Responda AGORA e processe depois. O limite e de 10 segundos, e
  // gerar PDF ou mandar e-mail aqui dentro estoura esse limite.
  res.status(200).send("ok");

  setImmediate(() => processar(evento).catch(console.error));
});

async function processar(evento) {
  switch (evento.evento) {
    case "document.completed":
      console.log("Concluido:", evento.dados.documento.id);
      // baixarPdfAssinado(evento.dados.documento.id)
      break;
    case "document.refused":
      console.log("Recusado:", evento.dados.signatario?.motivoRecusa);
      break;
    case "document.expired":
      console.log("Expirou:", evento.dados.documento.id);
      break;
    default:
      // Evento novo que voce ainda nao trata. Registre e siga; nunca
      // lance excecao, senao a plataforma passa a retentar a toa.
      console.log("Evento nao tratado:", evento.evento);
  }
}

app.listen(3000, () => console.log("Ouvindo na porta 3000"));

<?php
// PHP 8.1 ou mais novo, sem framework. Arquivo completo.
// Aponte o seu webhook para este arquivo e defina ADM_WEBHOOK_SEGREDO.

declare(strict_types=1);

const TOLERANCIA_SEGUNDOS = 300;

/**
 * php://input entrega os bytes exatos do corpo. Nunca use $_POST nem
 * json_encode(json_decode(...)) para recalcular: a reserializacao muda
 * a ordem das chaves e o escape, e a assinatura deixa de bater.
 */
$corpoBruto = file_get_contents('php://input');
$cabecalhos = array_change_key_case(getallheaders(), CASE_LOWER);

$segredo   = (string) getenv('ADM_WEBHOOK_SEGREDO');
$cabecalho = $cabecalhos['x-adigitalmax-signature'] ?? '';

/** Le "t=1786031051,v1=6f1c..." e devolve as partes. */
function lerAssinatura(string $cabecalho): array
{
    $partes = [];
    foreach (explode(',', $cabecalho) as $item) {
        $par = explode('=', trim($item), 2);
        if (count($par) === 2) {
            $partes[$par[0]] = $par[1];
        }
    }
    return $partes;
}

function assinaturaConfere(string $corpoBruto, string $cabecalho, string $segredo): bool
{
    $partes = lerAssinatura($cabecalho);
    $t  = $partes['t']  ?? '';
    $v1 = $partes['v1'] ?? '';

    if ($t === '' || $v1 === '') {
        return false;
    }

    // 1. Janela de tempo: fecha o ataque de repeticao.
    if (abs(time() - (int) $t) > TOLERANCIA_SEGUNDOS) {
        return false;
    }

    // 2. Recalcula sobre o corpo bruto.
    $esperado = hash_hmac('sha256', $t . '.' . $corpoBruto, $segredo);

    // 3. hash_equals compara em tempo constante. Nunca use ===.
    return hash_equals($esperado, $v1);
}

if (!assinaturaConfere($corpoBruto, $cabecalho, $segredo)) {
    http_response_code(401);
    echo 'assinatura invalida';
    exit;
}

$evento = json_decode($corpoBruto, true, 512, JSON_THROW_ON_ERROR);

// Idempotencia pelo eventoId, que se repete nas retentativas. Aqui em
// arquivo, para o exemplo caber sozinho; em producao, uma tabela com
// indice unico, porque SELECT antes de INSERT nao resolve concorrencia.
$marca = sys_get_temp_dir() . '/adx-' . preg_replace('/[^a-zA-Z0-9-]/', '', (string) $evento['eventoId']);
if (file_exists($marca)) {
    http_response_code(200);
    echo 'ja processado';
    exit;
}
touch($marca);

// Responda antes de processar. O limite e de 10 segundos.
http_response_code(200);
echo 'ok';

if (function_exists('fastcgi_finish_request')) {
    fastcgi_finish_request();
}

switch ($evento['evento']) {
    case 'document.completed':
        error_log('Concluido: ' . $evento['dados']['documento']['id']);
        // enfileirarDownload($evento['dados']['documento']['id']);
        break;
    case 'document.refused':
        error_log('Recusado: ' . ($evento['dados']['signatario']['motivoRecusa'] ?? ''));
        break;
    case 'document.expired':
        error_log('Expirou: ' . $evento['dados']['documento']['id']);
        break;
    default:
        // Evento novo. Registre e siga; nunca lance excecao aqui.
        error_log('Evento nao tratado: ' . $evento['evento']);
}

#!/usr/bin/env python3
"""Receptor de webhook do AdigitalMAX. Arquivo completo, com Flask.

    pip install flask
    ADM_WEBHOOK_SEGREDO=... python3 webhook.py
"""

import hashlib
import hmac
import json
import os
import threading
import time

from flask import Flask, request

SEGREDO = os.environ["ADM_WEBHOOK_SEGREDO"].encode("utf-8")
TOLERANCIA_SEGUNDOS = 300

app = Flask(__name__)
eventos_vistos = set()  # em producao, use Redis ou uma tabela.


def ler_assinatura(cabecalho: str) -> dict:
    """Le "t=1786031051,v1=6f1c..." e devolve as partes."""
    partes = {}
    for item in (cabecalho or "").split(","):
        par = item.strip().split("=", 1)
        if len(par) == 2:
            partes[par[0]] = par[1]
    return partes


def assinatura_confere(corpo_bruto: bytes, cabecalho: str) -> bool:
    partes = ler_assinatura(cabecalho)
    t = partes.get("t")
    v1 = partes.get("v1")
    if not t or not v1:
        return False

    # 1. Janela de tempo: fecha o ataque de repeticao.
    try:
        if abs(time.time() - int(t)) > TOLERANCIA_SEGUNDOS:
            return False
    except ValueError:
        return False

    # 2. Recalcula sobre o corpo bruto. request.get_data() devolve os
    # bytes originais; request.json ja perdeu o texto exato.
    base = t.encode("utf-8") + b"." + corpo_bruto
    esperado = hmac.new(SEGREDO, base, hashlib.sha256).hexdigest()

    # 3. compare_digest compara em tempo constante. Nunca use ==.
    return hmac.compare_digest(esperado, v1)


@app.post("/webhooks/adigitalmax")
def receber():
    corpo_bruto = request.get_data()

    if not assinatura_confere(corpo_bruto, request.headers.get("X-Adigitalmax-Signature", "")):
        # Sem detalhe do que falhou: a mensagem viraria pista.
        return "assinatura invalida", 401

    evento = json.loads(corpo_bruto)

    # Idempotencia pelo eventoId, que se repete nas retentativas.
    if evento["eventoId"] in eventos_vistos:
        return "ja processado", 200
    eventos_vistos.add(evento["eventoId"])

    # Responda agora, processe fora do ciclo. O limite e de 10 segundos.
    threading.Thread(target=processar, args=(evento,), daemon=True).start()
    return "ok", 200


def processar(evento: dict) -> None:
    nome = evento["evento"]
    dados = evento["dados"]

    if nome == "document.completed":
        print("Concluido:", dados["documento"]["id"])
        # baixar_pdf_assinado(dados["documento"]["id"])
    elif nome == "document.refused":
        print("Recusado:", dados.get("signatario", {}).get("motivoRecusa"))
    elif nome == "document.expired":
        print("Expirou:", dados["documento"]["id"])
    else:
        # Evento novo que voce ainda nao trata. Registre e siga.
        print("Evento nao tratado:", nome)


if __name__ == "__main__":
    app.run(port=3000)

#!/usr/bin/env bash
# Confere na mao a assinatura de uma entrega que voce salvou em disco.
# Serve para provar que a sua implementacao esta errada, e nao a nossa,
# quando a verificacao falha no seu servidor.
#
#   ADM_WEBHOOK_SEGREDO=... ./verificar.sh corpo.json "t=1786031051,v1=6f1c..."

set -euo pipefail

SEGREDO="${ADM_WEBHOOK_SEGREDO:?defina ADM_WEBHOOK_SEGREDO}"
CORPO_ARQUIVO="${1:?uso: verificar.sh corpo.json CABECALHO}"
CABECALHO="${2:?}"

T=$(echo "$CABECALHO" | tr ',' '\n' | grep '^t='  | cut -d= -f2)
V1=$(echo "$CABECALHO" | tr ',' '\n' | grep '^v1=' | cut -d= -f2)

# O printf junta t, ponto e o corpo BRUTO, sem passar por jq.
# Passar por jq reformata o JSON e a assinatura deixa de bater.
CALCULADA=$(
  { printf '%s.' "$T"; cat "$CORPO_ARQUIVO"; } \
    | openssl dgst -sha256 -hmac "$SEGREDO" -hex \
    | sed 's/^.*= //'
)

echo "recebida:  $V1"
echo "calculada: $CALCULADA"

if [ "$CALCULADA" = "$V1" ]; then
  echo "OK: a assinatura confere."
else
  echo "FALHOU: confira se o corpo foi salvo byte a byte, sem reformatar."
  exit 1
fi