Webhooks

curl -s https://api.winal.com.mx/v1/webhook_endpoints \
  -H "Authorization: Bearer $SK" \
  -H "Content-Type: application/json" \
  -d '{ "url": "https://tu-servidor.mx/webhooks/winal" }'
# → { "id": "...", "object": "webhook_endpoint", "url": "...", "secret": "whsec_..." }

v1 = hex( HMAC-SHA256( secret, "{t}.{cuerpo_crudo}" ) )

static bool VerificarFirma(string header, string cuerpoCrudo, string secreto, TimeSpan tolerancia)
{
    var partes = header.Split(',')
        .Select(p => p.Split('=', 2))
        .ToDictionary(p => p[0].Trim(), p => p[1]);

    var t = long.Parse(partes["t"]);
    if (Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - t) > tolerancia.TotalSeconds)
        return false; // fuera de la ventana anti-repetición

    var payloadFirmado = $"{t}.{cuerpoCrudo}";
    var firmaEsperada = Convert.ToHexStringLower(
        HMACSHA256.HashData(Encoding.UTF8.GetBytes(secreto), Encoding.UTF8.GetBytes(payloadFirmado)));

    return CryptographicOperations.FixedTimeEquals(
        Encoding.UTF8.GetBytes(firmaEsperada), Encoding.UTF8.GetBytes(partes["v1"]));
}

const crypto = require("crypto");

function verificarFirma(header, cuerpoCrudo, secreto, toleranciaSegundos = 300) {
  const partes = Object.fromEntries(
    header.split(",").map((p) => { const [k, v] = p.split("="); return [k.trim(), v]; })
  );

  const t = Number(partes.t);
  if (Math.abs(Date.now() / 1000 - t) > toleranciaSegundos) return false;

  const payloadFirmado = `${t}.${cuerpoCrudo}`;
  const firmaEsperada = crypto.createHmac("sha256", secreto).update(payloadFirmado).digest("hex");

  const recibida = Buffer.from(partes.v1);
  const esperada = Buffer.from(firmaEsperada);
  return recibida.length === esperada.length && crypto.timingSafeEqual(recibida, esperada);
}

<?php
function verificarFirma(string $header, string $cuerpoCrudo, string $secreto, int $tolerancia = 300): bool
{
    $partes = [];
    foreach (explode(',', $header) as $p) {
        [$k, $v] = array_pad(explode('=', $p, 2), 2, '');
        $partes[trim($k)] = $v;
    }
    if (!isset($partes['t'], $partes['v1'])) {
        return false;
    }

    $t = (int) $partes['t'];
    if (abs(time() - $t) > $tolerancia) {
        return false; // fuera de la ventana anti-repetición
    }

    $payloadFirmado = $t . '.' . $cuerpoCrudo;
    $esperada = hash_hmac('sha256', $payloadFirmado, $secreto);

    return hash_equals($esperada, $partes['v1']); // comparación en tiempo constante
}

// El cuerpo CRUDO, ANTES de cualquier json_decode():
$cuerpoCrudo = file_get_contents('php://input');
$ok = verificarFirma($_SERVER['HTTP_GATEWAY_SIGNATURE'] ?? '', $cuerpoCrudo, getenv('WINAL_WHSEC'));

import hashlib, hmac, time

def verificar_firma(header: str, cuerpo_crudo: bytes, secreto: str, tolerancia: int = 300) -> bool:
    partes = {}
    for p in header.split(","):
        k, _, v = p.partition("=")
        partes[k.strip()] = v
    if "t" not in partes or "v1" not in partes:
        return False

    t = int(partes["t"])
    if abs(int(time.time()) - t) > tolerancia:
        return False  # fuera de la ventana anti-repetición

    payload_firmado = f"{t}.".encode() + cuerpo_crudo
    esperada = hmac.new(secreto.encode(), payload_firmado, hashlib.sha256).hexdigest()

    return hmac.compare_digest(esperada, partes["v1"])  # comparación en tiempo constante

# En Flask: request.get_data() es el cuerpo CRUDO (antes de request.get_json()).
# En Django:  request.body    ·  En FastAPI:  await request.body()

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

func VerificarFirma(header string, cuerpoCrudo []byte, secreto string, toleranciaSeg float64) bool {
    partes := map[string]string{}
    for _, p := range strings.Split(header, ",") {
        kv := strings.SplitN(p, "=", 2)
        if len(kv) == 2 {
            partes[strings.TrimSpace(kv[0])] = kv[1]
        }
    }
    t, err := strconv.ParseInt(partes["t"], 10, 64)
    if err != nil {
        return false
    }
    if math.Abs(float64(time.Now().Unix()-t)) > toleranciaSeg {
        return false // fuera de la ventana anti-repetición
    }

    mac := hmac.New(sha256.New, []byte(secreto))
    mac.Write([]byte(strconv.FormatInt(t, 10) + "."))
    mac.Write(cuerpoCrudo) // el cuerpo CRUDO, sin re-serializar
    esperada := hex.EncodeToString(mac.Sum(nil))

    return hmac.Equal([]byte(esperada), []byte(partes["v1"])) // tiempo constante
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.HashMap;
import java.util.Map;

static boolean verificarFirma(String header, byte[] cuerpoCrudo, String secreto, long toleranciaSeg)
        throws Exception {
    Map<String, String> partes = new HashMap<>();
    for (String p : header.split(",")) {
        String[] kv = p.split("=", 2);
        if (kv.length == 2) partes.put(kv[0].trim(), kv[1]);
    }
    if (!partes.containsKey("t") || !partes.containsKey("v1")) return false;

    long t = Long.parseLong(partes.get("t"));
    if (Math.abs(System.currentTimeMillis() / 1000 - t) > toleranciaSeg) {
        return false; // fuera de la ventana anti-repetición
    }

    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(secreto.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
    mac.update((t + ".").getBytes(StandardCharsets.UTF_8));
    mac.update(cuerpoCrudo); // el cuerpo CRUDO, sin re-serializar

    StringBuilder esperada = new StringBuilder();
    for (byte b : mac.doFinal()) esperada.append(String.format("%02x", b));

    return MessageDigest.isEqual(
        esperada.toString().getBytes(StandardCharsets.UTF_8),
        partes.get("v1").getBytes(StandardCharsets.UTF_8)); // tiempo constante
}

{
  "event_id": "8f2a1c3e-...",
  "event_type": "payment_intent.succeeded",
  "created_at": "2026-07-05T18:30:04Z",
  "api_version": "2026-07-01",
  "livemode": false,
  "data": {
    "id": "5b6b8b3e-1e4b-4c8a-9b2e-6f6a2c9d41a2",
    "object": "payment_intent",
    "status": "succeeded",
    "amount_minor": 84900,
    "tip_minor": 0,
    "total_minor": 84900,
    "currency": "MXN",
    "metadata": { "payment_link_id": "plink_9fZ3..." }
  }
}