Verificação de Assinaturas de Webhook

import hashlib
import hmac
import time

TOLERANCE_SECONDS = 300  # 5 minutes


def verify_sphere_signature(raw_body: bytes, timestamp: str, signature: str, secret: str) -> bool:
    # Reject stale deliveries (possible replay attack)
    if abs(time.time() - int(timestamp)) > TOLERANCE_SECONDS:
        return False

    signed_content = f"{timestamp}.".encode() + raw_body
    expected = hmac.new(secret.encode(), signed_content, hashlib.sha256).hexdigest()

    # Constant-time comparison
    return hmac.compare_digest(expected, signature)


# Example (Flask): request.get_data() returns the raw body bytes
# is_valid = verify_sphere_signature(
#     raw_body=request.get_data(),
#     timestamp=request.headers["Sphere-Timestamp"],
#     signature=request.headers["Sphere-Signature"],
#     secret=os.environ["SPHERE_WEBHOOK_SECRET"],
# )

const crypto = require("crypto");

const TOLERANCE_SECONDS = 300; // 5 minutes

function verifySphereSignature(rawBody, timestamp, signature, secret) {
  // Reject stale deliveries (possible replay attack)
  const age = Math.abs(Date.now() / 1000 - Number(timestamp));
  if (!Number.isFinite(age) || age > TOLERANCE_SECONDS) {
    return false;
  }

  const signedContent = `${timestamp}.${rawBody}`;
  const expected = crypto
    .createHmac("sha256", secret)
    .update(signedContent)
    .digest("hex");

  // Constant-time comparison
  const expectedBuf = Buffer.from(expected, "hex");
  const receivedBuf = Buffer.from(signature, "hex");
  if (expectedBuf.length !== receivedBuf.length) {
    return false;
  }
  return crypto.timingSafeEqual(expectedBuf, receivedBuf);
}

// Example (Express): capture the raw body before JSON parsing
// app.use(express.json({ verify: (req, res, buf) => (req.rawBody = buf) }));
//
// const isValid = verifySphereSignature(
//   req.rawBody,
//   req.header("Sphere-Timestamp"),
//   req.header("Sphere-Signature"),
//   process.env.SPHERE_WEBHOOK_SECRET,
// );

package main

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

const toleranceSeconds = 300 // 5 minutes

func verifySphereSignature(rawBody []byte, timestamp, signature, secret string) bool {
	// Reject stale deliveries (possible replay attack)
	ts, err := strconv.ParseInt(timestamp, 10, 64)
	if err != nil || math.Abs(float64(time.Now().Unix()-ts)) > toleranceSeconds {
		return false
	}

	mac := hmac.New(sha256.New, []byte(secret))
	fmt.Fprintf(mac, "%s.", timestamp)
	mac.Write(rawBody)
	expected := hex.EncodeToString(mac.Sum(nil))

	// Constant-time comparison
	return hmac.Equal([]byte(expected), []byte(signature))
}

// Example (net/http): io.ReadAll(r.Body) returns the raw body bytes
// isValid := verifySphereSignature(
// 	rawBody,
// 	r.Header.Get("Sphere-Timestamp"),
// 	r.Header.Get("Sphere-Signature"),
// 	os.Getenv("SPHERE_WEBHOOK_SECRET"),
// )

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

public final class SphereWebhookVerifier {

    private static final long TOLERANCE_SECONDS = 300; // 5 minutes

    public static boolean verifySphereSignature(
            byte[] rawBody, String timestamp, String signature, String secret)
            throws Exception {
        // Reject stale deliveries (possible replay attack)
        long ts = Long.parseLong(timestamp);
        if (Math.abs(System.currentTimeMillis() / 1000 - ts) > TOLERANCE_SECONDS) {
            return false;
        }

        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        mac.update((timestamp + ".").getBytes(StandardCharsets.UTF_8));
        mac.update(rawBody);
        String expected = HexFormat.of().formatHex(mac.doFinal());

        // Constant-time comparison
        return MessageDigest.isEqual(
                expected.getBytes(StandardCharsets.UTF_8),
                signature.toLowerCase().getBytes(StandardCharsets.UTF_8));
    }

    // Example (Spring): bind the raw bytes before any JSON deserialization
    // @PostMapping("/sphere-webhook")
    // public ResponseEntity<Void> handle(@RequestBody byte[] rawBody,
    //         @RequestHeader("Sphere-Timestamp") String timestamp,
    //         @RequestHeader("Sphere-Signature") String signature) { ... }
}

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

public static class SphereWebhookVerifier
{
    private const int ToleranceSeconds = 300; // 5 minutes

    public static bool VerifySphereSignature(
        byte[] rawBody, string timestamp, string signature, string secret)
    {
        // Reject stale deliveries (possible replay attack)
        if (!long.TryParse(timestamp, out var ts) ||
            Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - ts) > ToleranceSeconds)
        {
            return false;
        }

        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
        var prefix = Encoding.UTF8.GetBytes($"{timestamp}.");
        var signedContent = new byte[prefix.Length + rawBody.Length];
        prefix.CopyTo(signedContent, 0);
        rawBody.CopyTo(signedContent, prefix.Length);

        var expected = Convert.ToHexString(hmac.ComputeHash(signedContent)).ToLowerInvariant();

        // Constant-time comparison
        return CryptographicOperations.FixedTimeEquals(
            Encoding.UTF8.GetBytes(expected),
            Encoding.UTF8.GetBytes(signature.ToLowerInvariant()));
    }

    // Example (ASP.NET Core): read the raw body before model binding runs
    // app.MapPost("/sphere-webhook", async (HttpRequest req) =>
    // {
    //     using var ms = new MemoryStream();
    //     await req.Body.CopyToAsync(ms);
    //     var isValid = SphereWebhookVerifier.VerifySphereSignature(
    //         ms.ToArray(),
    //         req.Headers["Sphere-Timestamp"]!,
    //         req.Headers["Sphere-Signature"]!,
    //         Environment.GetEnvironmentVariable("SPHERE_WEBHOOK_SECRET")!);
    //     return isValid ? Results.Ok() : Results.Unauthorized();
    // });
}