Webhook Signatures

import crypto from "node:crypto";

export function verifyTabsWebhook(rawBody, signatureHeader, secret, tolerance = 300) {
  if (!signatureHeader) {
    throw new Error("Missing Tabs-Signature header");
  }

  const elements = signatureHeader.split(",");
  const timestamp = elements.find((e) => e.startsWith("t="))?.split("=")[1];
  const signature = elements.find((e) => e.startsWith("v1="))?.split("=")[1];

  if (!timestamp || !signature) {
    throw new Error("Invalid signature format");
  }

  // Prevent replay attacks
  const now = Math.floor(Date.now() / 1000);
  if (Math.abs(now - parseInt(timestamp, 10)) > tolerance) {
    throw new Error("Webhook timestamp expired or out of tolerance");
  }

  // Compute expected HMAC
  const signedPayload = `${timestamp}.${rawBody}`;
  const expectedSignature = crypto
    .createHmac("sha256", secret)
    .update(signedPayload)
    .digest("hex");

  // Constant-time comparison
  const isValid = crypto.timingSafeEqual(
    Buffer.from(signature, "hex"),
    Buffer.from(expectedSignature, "hex")
  );

  if (!isValid) {
    throw new Error("Signature verification failed");
  }

  return true;
}

import hmac
import hashlib
import time

def verify_tabs_webhook(raw_body: bytes, signature_header: str, secret: str, tolerance: int = 300) -> bool:
    if not signature_header:
        raise ValueError("Missing Tabs-Signature header")

    pairs = dict(item.split("=") for item in signature_header.split(","))
    timestamp = pairs.get("t")
    signature = pairs.get("v1")

    if not timestamp or not signature:
        raise ValueError("Malformed signature header")

    # Prevent replay attacks
    if abs(time.time() - int(timestamp)) > tolerance:
        raise ValueError("Webhook timestamp expired")

    # Compute HMAC SHA-256
    signed_payload = f"{timestamp}.".encode("utf-8") + raw_body
    expected_signature = hmac.new(
        secret.encode("utf-8"),
        signed_payload,
        hashlib.sha256
    ).hexdigest()

    # Constant-time comparison
    if not hmac.compare_digest(signature, expected_signature):
        raise ValueError("Signature mismatch")

    return True

package main

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

func VerifyTabsWebhook(rawBody []byte, signatureHeader, secret string, tolerance float64) error {
	var timestampStr, signatureStr string
	parts := strings.Split(signatureHeader, ",")
	for _, part := range parts {
		kv := strings.SplitN(part, "=", 2)
		if len(kv) == 2 {
			switch kv[0] {
			case "t":
				timestampStr = kv[1]
			case "v1":
				signatureStr = kv[1]
			}
		}
	}

	ts, err := strconv.ParseInt(timestampStr, 10, 64)
	if err != nil {
		return errors.New("invalid timestamp in signature")
	}

	if math.Abs(float64(time.Now().Unix()-ts)) > tolerance {
		return errors.New("timestamp outside of tolerance window")
	}

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

	if !hmac.Equal([]byte(signatureStr), []byte(expectedSignature)) {
		return errors.New("signature mismatch")
	}

	return nil
}