Webhooks e verificação de assinatura

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

/** Assina uma requisição: retorna o valor do cabeçalho X-Signature. */
export function signRequest(secret, method, pathWithQuery, timestamp, body = "") {
  const canonical = [
    method.toUpperCase(),
    pathWithQuery, // exatamente como enviado, com /api/v1 e a query string
    timestamp, // epoch em segundos (string)
    createHash("sha256").update(body).digest("hex"),
  ].join("\n");
  return createHmac("sha256", secret).update(canonical).digest("hex");
}

/** Verifica um webhook recebido (use o corpo BRUTO, antes de parsear o JSON). */
export function verifyWebhook(secret, timestamp, rawBody, signature) {
  const expected = createHmac("sha256", secret).update(`${timestamp}.${rawBody}`).digest("hex");
  const a = Buffer.from(expected);
  const b = Buffer.from(signature);
  return a.length === b.length && timingSafeEqual(a, b);
}

import hashlib
import hmac


def sign_request(secret, method, path_with_query, timestamp, body=""):
    """Assina uma requisição: retorna o valor do cabeçalho X-Signature."""
    canonical = "\n".join([
        method.upper(),
        path_with_query,  # exatamente como enviado, com /api/v1 e a query string
        timestamp,        # epoch em segundos (string)
        hashlib.sha256(body.encode()).hexdigest(),
    ])
    return hmac.new(secret.encode(), canonical.encode(), hashlib.sha256).hexdigest()


def verify_webhook(secret, timestamp, raw_body, signature):
    """Verifica um webhook recebido (use o corpo BRUTO, antes de parsear o JSON)."""
    expected = hmac.new(secret.encode(), f"{timestamp}.{raw_body}".encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, signature)

<?php
/** Assina uma requisição: retorna o valor do cabeçalho X-Signature. */
function sign_request(string $secret, string $method, string $pathWithQuery, string $timestamp, string $body = ""): string {
    $canonical = implode("\n", [
        strtoupper($method),
        $pathWithQuery, // exatamente como enviado, com /api/v1 e a query string
        $timestamp,     // epoch em segundos (string)
        hash("sha256", $body),
    ]);
    return hash_hmac("sha256", $canonical, $secret);
}

/** Verifica um webhook recebido (use o corpo BRUTO: file_get_contents("php://input")). */
function verify_webhook(string $secret, string $timestamp, string $rawBody, string $signature): bool {
    return hash_equals(hash_hmac("sha256", $timestamp . "." . $rawBody, $secret), $signature);
}

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"strings"
)

// signRequest assina uma requisição: retorna o valor do cabeçalho X-Signature.
func signRequest(secret, method, pathWithQuery, timestamp, body string) string {
	sum := sha256.Sum256([]byte(body))
	canonical := strings.ToUpper(method) + "\n" +
		pathWithQuery + "\n" + // exatamente como enviado, com /api/v1 e a query string
		timestamp + "\n" + // epoch em segundos (string)
		hex.EncodeToString(sum[:])
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(canonical))
	return hex.EncodeToString(mac.Sum(nil))
}

// verifyWebhook verifica um webhook recebido (use o corpo BRUTO).
func verifyWebhook(secret, timestamp, rawBody, signature string) bool {
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(timestamp + "." + rawBody))
	return hmac.Equal([]byte(hex.EncodeToString(mac.Sum(nil))), []byte(signature))
}

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

public class BetSigner {
    static String hmacHex(String secret, String message) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        return HexFormat.of().formatHex(mac.doFinal(message.getBytes(StandardCharsets.UTF_8)));
    }

    /** Assina uma requisição: retorna o valor do cabeçalho X-Signature. */
    public static String signRequest(String secret, String method, String pathWithQuery, String timestamp, String body) throws Exception {
        String bodyHash = HexFormat.of().formatHex(
            MessageDigest.getInstance("SHA-256").digest(body.getBytes(StandardCharsets.UTF_8)));
        // pathWithQuery: exatamente como enviado, com /api/v1 e a query string; timestamp: epoch em segundos
        return hmacHex(secret, String.join("\n", method.toUpperCase(), pathWithQuery, timestamp, bodyHash));
    }

    /** Verifica um webhook recebido (use o corpo BRUTO). */
    public static boolean verifyWebhook(String secret, String timestamp, String rawBody, String signature) throws Exception {
        String expected = hmacHex(secret, timestamp + "." + rawBody);
        return MessageDigest.isEqual(expected.getBytes(StandardCharsets.UTF_8), signature.getBytes(StandardCharsets.UTF_8));
    }

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

public static class BetSigner
{
    static string HmacHex(string secret, string message)
    {
        using var h = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
        return Convert.ToHexString(h.ComputeHash(Encoding.UTF8.GetBytes(message))).ToLowerInvariant();
    }

    /// <summary>Assina uma requisição: retorna o valor do cabeçalho X-Signature.</summary>
    public static string SignRequest(string secret, string method, string pathWithQuery, string timestamp, string body = "")
    {
        var bodyHash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(body))).ToLowerInvariant();
        // pathWithQuery: exatamente como enviado, com /api/v1 e a query string; timestamp: epoch em segundos
        return HmacHex(secret, string.Join("\n", method.ToUpperInvariant(), pathWithQuery, timestamp, bodyHash));
    }

    /// <summary>Verifica um webhook recebido (use o corpo BRUTO).</summary>
    public static bool VerifyWebhook(string secret, string timestamp, string rawBody, string signature) =>
        CryptographicOperations.FixedTimeEquals(
            Encoding.UTF8.GetBytes(HmacHex(secret, $"{timestamp}.{rawBody}")),
            Encoding.UTF8.GetBytes(signature));

#!/usr/bin/env bash
# Assina uma requisição: imprime o valor do cabeçalho X-Signature.
# uso: sign_request SECRET METODO CAMINHO_COM_QUERY TIMESTAMP [CORPO]
sign_request() {
  local secret="$1" method="$2" path="$3" ts="$4" body="${5:-}"
  local body_hash
  body_hash=$(printf '%s' "$body" | openssl dgst -sha256 -hex | sed 's/^.* //')
  printf '%s\n%s\n%s\n%s' "$method" "$path" "$ts" "$body_hash" \
    | openssl dgst -sha256 -hmac "$secret" -hex | sed 's/^.* //'
}

# Assinatura de um webhook: HMAC-SHA256 de "TIMESTAMP.CORPO_BRUTO" com o segredo whsec_...
webhook_signature() {
  printf '%s.%s' "$2" "$3" | openssl dgst -sha256 -hmac "$1" -hex | sed 's/^.* //'
}