Signature Verification

import hmac
import hashlib
import time
 
def verify_webhook(raw_body: str, signature_header: str, secret: str) -> bool:
    """
    Verify Webhook Signature
    :param raw_body: Raw unparsed HTTP request body string
    :param signature_header: Value of X-Webhook-Signature header
    :param secret: Outbound signing secret from your project dashboard
    :return: True if signature matches and request is authentic
    """
    # 1. Parse signature header
    parts = {}
    for part in signature_header.split(','):
        if '=' in part:
            k, v = part.split('=', 1)
            parts[k.strip()] = v.strip()
            
    timestamp = parts.get('t')
    signature = parts.get('v1')
    
    if not timestamp or not signature:
        raise ValueError("Missing timestamp or signature in header")
        
    # 2. Optional staleness bound. `t` is fixed at preparation and does NOT change
    #    across retries (which span ~3 days), so use a window wider than the full
    #    retry window and rely on the envelope `id` for replay protection.
    max_age = 3 * 24 * 60 * 60  # ~3 days (longest plausible retry window)
    now = int(time.time())
    if now - int(timestamp) > max_age:
        raise ValueError("Event older than the retry window")
        
    # 3. Construct payload string
    string_to_sign = f"{timestamp}.{raw_body}".encode('utf-8')
    
    # 4. Compute the expected HMAC-SHA256
    expected_signature = hmac.new(
        secret.encode('utf-8'),
        string_to_sign,
        hashlib.sha256
    ).hexdigest()
    
    # 5. Compare using constant-time safe comparison
    return hmac.compare_digest(signature, expected_signature)

<?php
 
/**
 * Verify Webhook Signature
 * @param string $rawBody Raw unparsed HTTP request body string
 * @param string $signatureHeader Value of X-Webhook-Signature header
 * @param string $secret Outbound signing secret from your project dashboard
 * @return bool True if signature matches and request is authentic
 */
function verifyWebhook($rawBody, $signatureHeader, $secret) {
    // 1. Parse signature header
    $parts = [];
    foreach (explode(',', $signatureHeader) as $part) {
        $keyValue = explode('=', $part, 2);
        if (count($keyValue) === 2) {
            $parts[trim($keyValue[0])] = trim($keyValue[1]);
        }
    }
 
    $timestamp = $parts['t'] ?? null;
    $signature = $parts['v1'] ?? null;
 
    if (!$timestamp || !$signature) {
        throw new Exception('Missing timestamp or signature');
    }
 
    // 2. Optional staleness bound. `t` is fixed at preparation and does NOT change
    //    across retries (which span ~3 days), so use a window wider than the full
    //    retry window and rely on the envelope `id` for replay protection.
    $maxAge = 3 * 24 * 60 * 60; // ~3 days (longest plausible retry window)
    $now = time();
    if ($now - (int)$timestamp > $maxAge) {
        throw new Exception('Event older than the retry window');
    }
 
    // 3. Construct string to sign
    $stringToSign = $timestamp . '.' . $rawBody;
 
    // 4. Compute expected signature
    $expectedSignature = hash_hmac('sha256', $stringToSign, $secret);
 
    // 5. Safe comparison
    return hash_equals($signature, $expectedSignature);
}

package main
 
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"fmt"
	"strings"
	"time"
)
 
// VerifyWebhook verifies the authenticity of BotSubscription webhook requests.
// rawBody: Raw unparsed HTTP request body bytes
// signatureHeader: Value of X-Webhook-Signature header
// secret: Outbound signing secret from your project dashboard
func VerifyWebhook(rawBody []byte, signatureHeader string, secret string) (bool, error) {
	// 1. Parse signature header
	parts := make(map[string]string)
	for _, part := range strings.Split(signatureHeader, ",") {
		kv := strings.SplitN(part, "=", 2)
		if len(kv) == 2 {
			parts[strings.TrimSpace(kv[0])] = strings.TrimSpace(kv[1])
		}
	}
 
	timestampStr, okt := parts["t"]
	signatureStr, okv := parts["v1"]
	if !okt || !okv {
		return false, errors.New("missing timestamp or signature")
	}
 
	// 2. Optional staleness bound. `t` is fixed at preparation and does NOT change
	//    across retries (which span ~3 days), so use a window wider than the full
	//    retry window and rely on the envelope `id` for replay protection.
	var timestamp int64
	_, err := fmt.Sscanf(timestampStr, "%d", &timestamp)
	if err != nil {
		return false, err
	}
 
	const maxAge = 3 * 24 * 60 * 60 // ~3 days (longest plausible retry window)
	now := time.Now().Unix()
	if now-timestamp > maxAge {
		return false, errors.New("event older than the retry window")
	}
 
	// 3. Construct string to sign
	stringToSign := fmt.Sprintf("%s.%s", timestampStr, string(rawBody))
 
	// 4. Compute the expected HMAC-SHA256
	h := hmac.New(sha256.New, []byte(secret))
	h.Write([]byte(stringToSign))
	expectedSignature := hex.EncodeToString(h.Sum(nil))
 
	// 5. Compare using constant-time comparison
	sigBytes := []byte(signatureStr)
	expectedBytes := []byte(expectedSignature)
 
	return hmac.Equal(sigBytes, expectedBytes), nil
}

require 'openssl'
 
# Verify Webhook Signature
# raw_body: Raw unparsed HTTP request body string
# signature_header: Value of X-Webhook-Signature header
# secret: Outbound signing secret from your project dashboard
def verify_webhook(raw_body, signature_header, secret)
  # 1. Parse signature header
  parts = signature_header.split(',').each_with_object({}) do |part, acc|
    key, val = part.split('=', 2)
    acc[key.strip] = val.strip if key && val
  end
 
  timestamp = parts['t']
  signature = parts['v1']
 
  if timestamp.nil? || signature.nil?
    raise "Missing timestamp or signature"
  end
 
  # 2. Optional staleness bound. `t` is fixed at preparation and does NOT change
  #    across retries (which span ~3 days), so use a window wider than the full
  #    retry window and rely on the envelope `id` for replay protection.
  max_age = 3 * 24 * 60 * 60 # ~3 days (longest plausible retry window)
  now = Time.now.to_i
  if now - timestamp.to_i > max_age
    raise "Event older than the retry window"
  end
 
  # 3. Construct payload string
  string_to_sign = "#{timestamp}.#{raw_body}"
 
  # 4. Compute expected signature
  expected_signature = OpenSSL::HMAC.hexdigest(
    OpenSSL::Digest.new('sha256'),
    secret,
    string_to_sign
  )
 
  # 5. Secure constant-time comparison (both values are equal-length hex strings)
  OpenSSL.fixed_length_secure_compare(signature, expected_signature)
end