Verificacion de firma

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

static bool Verificar(string secreto, string cabecera, string cuerpoCrudo, TimeSpan tolerancia)
{
    // cabecera: "t=1757341445,v1=6a7f..."
    Dictionary<string, string> partes = cabecera
        .Split(',')
        .Select(p => p.Split('=', 2))
        .Where(p => p.Length == 2)
        .ToDictionary(p => p[0], p => p[1]);

    if (!partes.TryGetValue("t", out string? t) || !partes.TryGetValue("v1", out string? v1))
    {
        return false;
    }

    if (!long.TryParse(t, out long unix))
    {
        return false;
    }

    long ahora = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
    if (Math.Abs(ahora - unix) > (long)tolerancia.TotalSeconds)
    {
        return false;
    }

    string firmado = t + "." + cuerpoCrudo;
    using HMACSHA256 hmac = new(Encoding.UTF8.GetBytes(secreto));
    byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(firmado));
    string esperado = Convert.ToHexString(hash).ToLowerInvariant();

    return CryptographicOperations.FixedTimeEquals(
        Encoding.ASCII.GetBytes(esperado),
        Encoding.ASCII.GetBytes(v1.ToLowerInvariant()));
}

import hashlib, hmac, time

def verificar(secreto: str, cabecera: str, cuerpo_crudo: str, tolerancia: int = 300) -> bool:
    partes = dict(p.split('=', 1) for p in cabecera.split(',') if '=' in p)
    t, v1 = partes.get('t'), partes.get('v1')
    if not t or not v1:
        return False
    if abs(int(time.time()) - int(t)) > tolerancia:
        return False
    firmado = f"{t}.{cuerpo_crudo}".encode('utf-8')
    esperado = hmac.new(secreto.encode('utf-8'), firmado, hashlib.sha256).hexdigest()
    return hmac.compare_digest(esperado, v1)

const crypto = require('crypto');

function verificar(secreto, cabecera, cuerpoCrudo, toleranciaSegundos) {
  const partes = Object.fromEntries(
    cabecera.split(',').map((p) => p.split('='))
  );
  const t = partes.t;
  const v1 = partes.v1;
  if (!t || !v1) return false;

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

  const esperado = crypto
    .createHmac('sha256', secreto)
    .update(`${t}.${cuerpoCrudo}`, 'utf8')
    .digest('hex');

  const a = Buffer.from(esperado);
  const b = Buffer.from(v1);
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

<?php
function verificar(string $secreto, string $cabecera, string $cuerpoCrudo, int $tolerancia = 300): bool
{
    $partes = [];
    foreach (explode(',', $cabecera) as $p) {
        $kv = explode('=', $p, 2);
        if (count($kv) === 2) { $partes[$kv[0]] = $kv[1]; }
    }
    $t = $partes['t'] ?? null;
    $v1 = $partes['v1'] ?? null;
    if ($t === null || $v1 === null) { return false; }
    if (abs(time() - (int)$t) > $tolerancia) { return false; }

    $esperado = hash_hmac('sha256', $t . '.' . $cuerpoCrudo, $secreto);
    return hash_equals($esperado, strtolower($v1));
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;

static boolean verificar(String secreto, String cabecera, String cuerpoCrudo, long tolerancia) throws Exception {
    Map<String, String> partes = new HashMap<>();
    for (String p : cabecera.split(",")) {
        String[] kv = p.split("=", 2);
        if (kv.length == 2) { partes.put(kv[0], kv[1]); }
    }
    String t = partes.get("t");
    String v1 = partes.get("v1");
    if (t == null || v1 == null) { return false; }
    if (Math.abs(Instant.now().getEpochSecond() - Long.parseLong(t)) > tolerancia) { return false; }

    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(secreto.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
    byte[] hash = mac.doFinal((t + "." + cuerpoCrudo).getBytes(StandardCharsets.UTF_8));
    StringBuilder hex = new StringBuilder();
    for (byte b : hash) { hex.append(String.format("%02x", b)); }
    return java.security.MessageDigest.isEqual(
        hex.toString().getBytes(StandardCharsets.US_ASCII),
        v1.toLowerCase().getBytes(StandardCharsets.US_ASCII));
}