Verificar la firma

# Flask — pip install compense-sdk-python flask
import os
import queue
import threading

from flask import Flask, request
from compense_gateway.webhooks import WebhookEvent, WebhookVerificationError, verify_webhook

app = Flask(__name__)

# El secreto vigente y, solo mientras rotas, el anterior.
SECRETOS = [s for s in (os.environ.get("COMPENSE_WEBHOOK_SECRET"),
                        os.environ.get("COMPENSE_WEBHOOK_SECRET_OLD")) if s]

procesados: set[str] = set()                 # en producción: tu BD o Redis (con TTL de días)
cola: "queue.Queue[WebhookEvent]" = queue.Queue()


def manejar(event: WebhookEvent) -> None:
    print(event.event, event.event_id, event.resource)   # tu lógica de negocio


def trabajador() -> None:
    while True:
        manejar(cola.get())


threading.Thread(target=trabajador, daemon=True).start()


@app.post("/compense/webhooks")
def recibir():
    try:
        # request.get_data(): los bytes crudos, ANTES de cualquier parseo
        event = verify_webhook(request.get_data(), request.headers, secret=SECRETOS)
    except WebhookVerificationError:
        return "", 401                       # firma o timestamp inválidos

    if event.is_test:                        # send_test: confirma y no lo proceses
        return "", 200
    if event.event_id in procesados:         # entrega repetida (at-least-once)
        return "", 200
    procesados.add(event.event_id)

    cola.put(event)                          # el trabajo pesado, fuera del request
    return "", 200

// Express — npm i @compense/sdk express
import express from "express";
import { verifyWebhook, WebhookVerificationError, type WebhookEvent } from "@compense/sdk/webhooks";

const app = express();

// El secreto vigente y, solo mientras rotas, el anterior.
const secretos = [process.env.COMPENSE_WEBHOOK_SECRET, process.env.COMPENSE_WEBHOOK_SECRET_OLD].filter(
  (s): s is string => Boolean(s),
);
const procesados = new Set<string>(); // en producción: tu BD o Redis (con TTL de días)

function manejar(event: WebhookEvent): void {
  console.log(event.event, event.eventId, event.resource); // tu lógica de negocio
}

// express.raw en ESTA ruta: req.body llega como Buffer con los bytes crudos.
// No pongas express.json() antes de esta ruta.
app.post("/compense/webhooks", express.raw({ type: "*/*" }), (req, res) => {
  let event: WebhookEvent;
  try {
    event = verifyWebhook(req.body, req.headers, secretos);
  } catch (err) {
    if (err instanceof WebhookVerificationError) return res.sendStatus(401);
    throw err;
  }

  if (event.isTest) return res.sendStatus(200);                 // sendTest: no lo proceses
  if (procesados.has(event.eventId)) return res.sendStatus(200); // repetido (at-least-once)
  procesados.add(event.eventId);

  setImmediate(() => manejar(event)); // en producción: encola (BullMQ, SQS…)
  return res.sendStatus(200);
});

app.listen(8000, () => console.log("http://localhost:8000/compense/webhooks"));

<?php
// Laravel — composer require compense/sdk
//
// routes/api.php (sin middleware CSRF):
//   Route::post('/compense/webhooks', \App\Http\Controllers\CompenseWebhookController::class);
//
// config/services.php:
//   'compense' => [
//       'webhook_secrets' => array_values(array_filter([
//           env('COMPENSE_WEBHOOK_SECRET'), env('COMPENSE_WEBHOOK_SECRET_OLD'),
//       ])),
//   ],

declare(strict_types=1);

namespace App\Http\Controllers;

use App\Jobs\HandleCompenseEvent;
use Compense\Sdk\Webhook\Webhook;
use Compense\Sdk\Webhook\WebhookVerificationException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Log;

final class CompenseWebhookController
{
    public function __invoke(Request $request): JsonResponse
    {
        try {
            $event = Webhook::verify(
                $request->getContent(),          // cuerpo CRUDO, no $request->all() ni json()
                $request->headers->all(),        // HeaderBag de Symfony
                config('services.compense.webhook_secrets'),
            );
        } catch (WebhookVerificationException $e) {
            Log::warning('Webhook de Compense rechazado', ['motivo' => $e->getMessage()]);

            return response()->json(['error' => 'firma inválida'], 401);
        }

        if ($event->isTest()) {                  // sendTest: confirma y no lo proceses
            return response()->json(['received' => true, 'test' => true]);
        }

        // At-least-once: Cache::add solo escribe si la clave no existe (7 días cubre los reintentos).
        if (Cache::add('compense:webhook:' . $event->eventId, true, now()->addDays(7))) {
            HandleCompenseEvent::dispatch($event->event(), $event->payload);   // a la cola
        }

        return response()->json(['received' => true]);
    }
}

// ASP.NET Core minimal API (.NET 8) — dotnet add package Compense.Sdk
//   Compense__WebhookSecrets__0=whsec_...   (vigente)
//   Compense__WebhookSecrets__1=whsec_...   (anterior, solo mientras rotas)
using System.Collections.Concurrent;
using System.Threading.Channels;
using Compense.Sdk.Webhooks;

var builder = WebApplication.CreateBuilder(args);

string[] secretos = builder.Configuration.GetSection("Compense:WebhookSecrets").Get<string[]>()
    ?? Array.Empty<string>();

var procesados = new ConcurrentDictionary<string, bool>();   // en producción: tu BD
var cola = Channel.CreateUnbounded<WebhookEvent>();

var app = builder.Build();

// Consumidor en segundo plano: el trabajo pesado no bloquea la respuesta.
_ = Task.Run(async () =>
{
    await foreach (WebhookEvent e in cola.Reader.ReadAllAsync())
    {
        app.Logger.LogInformation("{Event} {EventId} {Resource}", e.Event, e.EventId, e.Resource);
    }
});

app.MapPost("/compense/webhooks", async (HttpRequest request) =>
{
    // Los bytes crudos, exactamente como llegaron.
    using var buffer = new MemoryStream();
    await request.Body.CopyToAsync(buffer);

    WebhookEvent evt;
    try
    {
        evt = CompenseWebhooks.Verify(buffer.ToArray(), request.Headers, secretos);
    }
    catch (WebhookVerificationException ex)
    {
        app.Logger.LogWarning("Webhook rechazado: {Motivo}", ex.Message);
        return Results.Unauthorized();
    }

    if (evt.IsTest) return Results.Ok();                         // SendTestAsync: no lo proceses
    if (!procesados.TryAdd(evt.EventId, true)) return Results.Ok(); // repetido (at-least-once)

    await cola.Writer.WriteAsync(evt);
    return Results.Ok();
});

app.Run();

// net/http — go get github.com/Appiasoft/compense-saas-sdk-go
package main

import (
	"context"
	"log"
	"net/http"
	"os"
	"sync"
	"time"

	"github.com/Appiasoft/compense-saas-sdk-go/webhook"
)

func main() {
	// El secreto vigente y, solo mientras rotas, el anterior (los vacíos se ignoran).
	secretos := []string{os.Getenv("COMPENSE_WEBHOOK_SECRET"), os.Getenv("COMPENSE_WEBHOOK_SECRET_OLD")}

	var mu sync.Mutex
	procesados := map[string]bool{} // en producción: tu BD o Redis
	cola := make(chan *webhook.Event, 1000)

	go func() { // consumidor en segundo plano
		for ev := range cola {
			log.Printf("%s %s %v", ev.Event(), ev.ID, ev.Resource())
		}
	}()

	// webhook.Handler verifica (401 si falla), y responde 200 si fn devuelve nil
	// o 500 si devuelve error (Compense reintentará la entrega).
	h := webhook.Handler(secretos, func(ctx context.Context, ev *webhook.Event) error {
		if ev.IsTest() { // SendTest: confirma y no lo proceses
			return nil
		}
		mu.Lock()
		defer mu.Unlock()
		if procesados[ev.ID] { // repetido (at-least-once)
			return nil
		}
		procesados[ev.ID] = true
		cola <- ev
		return nil
	})

	mux := http.NewServeMux()
	mux.Handle("/compense/webhooks", h)
	srv := &http.Server{Addr: ":8000", Handler: mux, ReadHeaderTimeout: 10 * time.Second}
	log.Fatal(srv.ListenAndServe())
}

# Simula una entrega firmada contra tu receptor local (útil en pruebas unitarias o de humo).
SECRET="whsec_..."                       # el mismo que configuraste en el receptor
BODY='{"event":"test.ping","version":"1","tenant_id":"horizonte","test":true}'
SIG=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "$SECRET" | sed 's/^.* //')

curl -i -X POST http://localhost:8000/compense/webhooks \
  -H "Content-Type: application/json" \
  -H "X-Webhook-Signature: sha256=$SIG" \
  -H "X-Webhook-Event: test.ping" \
  -H "X-Webhook-Id: test-local-0001" \
  -H "X-Webhook-Timestamp: $(date +%s)" \
  --data-binary "$BODY"
# → 200. Cambia un carácter de $BODY sin recalcular la firma → 401.

import hashlib
import hmac
import time


def firma_valida(cuerpo: bytes, cabeceras, secretos: list[str], tolerancia: int = 300) -> bool:
    ts = cabeceras.get("X-Webhook-Timestamp")
    if ts is None or abs(time.time() - int(float(ts))) > tolerancia:
        return False
    firma = (cabeceras.get("X-Webhook-Signature") or "").strip()
    if not firma.startswith("sha256="):
        return False
    recibida = firma[len("sha256="):]
    valida = False
    for secreto in secretos:                 # sin cortocircuito: mismo tiempo con cualquier secreto
        esperada = hmac.new(secreto.encode("utf-8"), cuerpo, hashlib.sha256).hexdigest()
        valida |= hmac.compare_digest(esperada, recibida)
    return valida

import { createHmac, timingSafeEqual } from "node:crypto";

export function firmaValida(
  cuerpo: Buffer,
  cabeceras: Record<string, string | string[] | undefined>,
  secretos: string[],
  tolerancia = 300,
): boolean {
  const ts = Number(cabeceras["x-webhook-timestamp"]);
  if (!Number.isFinite(ts) || Math.abs(Date.now() / 1000 - ts) > tolerancia) return false;
  const firma = String(cabeceras["x-webhook-signature"] ?? "").trim();
  if (!firma.startsWith("sha256=")) return false;
  const recibida = Buffer.from(firma.slice("sha256=".length), "utf8");
  let valida = false;
  for (const secreto of secretos) {
    const esperada = Buffer.from(createHmac("sha256", secreto).update(cuerpo).digest("hex"), "utf8");
    valida = (esperada.length === recibida.length && timingSafeEqual(esperada, recibida)) || valida;
  }
  return valida;
}

<?php
/** @param string[] $secretos */
function firmaValida(string $cuerpo, ?string $firma, ?string $timestamp, array $secretos, int $tolerancia = 300): bool
{
    if ($timestamp === null || !is_numeric($timestamp) || abs(time() - (int) $timestamp) > $tolerancia) {
        return false;
    }
    $firma = trim((string) $firma);
    if (!str_starts_with($firma, 'sha256=')) {
        return false;
    }
    $recibida = substr($firma, strlen('sha256='));
    $valida = false;
    foreach ($secretos as $secreto) {
        $valida = hash_equals(hash_hmac('sha256', $cuerpo, $secreto), $recibida) || $valida;
    }

    return $valida;
}

$ok = firmaValida(
    (string) file_get_contents('php://input'),
    $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? null,
    $_SERVER['HTTP_X_WEBHOOK_TIMESTAMP'] ?? null,
    [(string) getenv('COMPENSE_WEBHOOK_SECRET')],
);

using System.Security.Cryptography;
using System.Text;

static bool FirmaValida(byte[] cuerpo, string? firma, string? timestamp, IEnumerable<string> secretos, int tolerancia = 300)
{
    if (!long.TryParse(timestamp, out long ts)
        || Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - ts) > tolerancia)
    {
        return false;
    }

    firma = firma?.Trim();
    if (firma is null || !firma.StartsWith("sha256=", StringComparison.Ordinal))
    {
        return false;
    }

    byte[] recibida = Encoding.ASCII.GetBytes(firma.Substring("sha256=".Length));
    bool valida = false;
    foreach (string secreto in secretos)
    {
        byte[] hmac = HMACSHA256.HashData(Encoding.UTF8.GetBytes(secreto), cuerpo);
        byte[] esperada = Encoding.ASCII.GetBytes(Convert.ToHexString(hmac).ToLowerInvariant());
        valida |= CryptographicOperations.FixedTimeEquals(esperada, recibida);
    }

    return valida;
}

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"math"
	"net/http"
	"strconv"
	"strings"
	"time"
)

func firmaValida(cuerpo []byte, h http.Header, secretos []string) bool {
	ts, err := strconv.ParseInt(h.Get("X-Webhook-Timestamp"), 10, 64)
	if err != nil || math.Abs(float64(time.Now().Unix()-ts)) > 300 {
		return false
	}
	recibida, ok := strings.CutPrefix(strings.TrimSpace(h.Get("X-Webhook-Signature")), "sha256=")
	if !ok {
		return false
	}
	valida := false
	for _, secreto := range secretos {
		mac := hmac.New(sha256.New, []byte(secreto))
		mac.Write(cuerpo)
		esperada := hex.EncodeToString(mac.Sum(nil))
		if hmac.Equal([]byte(esperada), []byte(recibida)) {
			valida = true
		}
	}
	return valida
}

# Verifica a mano una entrega guardada: cuerpo.json (bytes exactos) y la cabecera recibida.
SECRET="whsec_..."
RECIBIDA="sha256=3b0c…"                  # valor de X-Webhook-Signature
ESPERADA="sha256=$(openssl dgst -sha256 -hmac "$SECRET" < cuerpo.json | sed 's/^.* //')"
[ "$ESPERADA" = "$RECIBIDA" ] && echo "firma válida" || echo "firma inválida"