Verify webhook signatures

import hashlib
import hmac
import time


def verify_webhook(secret, event_id, header, raw_body, tolerance_seconds=300):
    """raw_body must be the exact, unparsed request body (bytes)."""
    if not (secret and event_id and header):
        return False

    fields = {}
    for part in header.split(","):
        key, sep, value = part.partition("=")
        if sep:
            fields[key] = value

    timestamp, signature = fields.get("t"), fields.get("v1")
    if not timestamp or not signature or not timestamp.isdigit():
        return False

    if abs(int(time.time()) - int(timestamp)) > tolerance_seconds:
        return False

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

    try:
        received = bytes.fromhex(signature)
    except ValueError:
        return False

    return hmac.compare_digest(expected, received)

const crypto = require('node:crypto');

function verifyWebhook({ secret, eventId, header, rawBody, toleranceSeconds = 300 }) {
  if (!secret || !eventId || !header) return false;

  const fields = {};
  for (const part of String(header).split(',')) {
    const i = part.indexOf('=');
    if (i > 0) fields[part.slice(0, i)] = part.slice(i + 1);
  }

  const { t, v1 } = fields;
  if (!t || !v1 || !/^\d+$/.test(t)) return false;
  if (Math.abs(Math.floor(Date.now() / 1000) - Number(t)) > toleranceSeconds) return false;

  const body = Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(rawBody, 'utf8');
  const signedContent = Buffer.concat([Buffer.from(`${eventId}.${t}.`, 'utf8'), body]);
  const expected = crypto.createHmac('sha256', secret).update(signedContent).digest();

  const received = Buffer.from(v1, 'hex');
  return received.length === expected.length && crypto.timingSafeEqual(expected, received);
}

package webhook

import (
  "crypto/hmac"
  "crypto/sha256"
  "crypto/subtle"
  "encoding/hex"
  "strconv"
  "strings"
  "time"
)

const toleranceSeconds = 300

// VerifyWebhook checks a Salesforce webhook delivery. rawBody must be
// the exact, unparsed request body.
func VerifyWebhook(secret, eventID, header string, rawBody []byte) bool {
  if secret == "" || eventID == "" || header == "" {
    return false
  }

  fields := map[string]string{}
  for _, part := range strings.Split(header, ",") {
    key, value, found := strings.Cut(part, "=")
    if found {
      fields[key] = value
    }
  }

  timestamp, signature := fields["t"], fields["v1"]
  if timestamp == "" || signature == "" {
    return false
  }

  ts, err := strconv.ParseInt(timestamp, 10, 64)
  if err != nil {
    return false
  }
  if age := time.Now().Unix() - ts; age > toleranceSeconds || age < -toleranceSeconds {
    return false
  }

  mac := hmac.New(sha256.New, []byte(secret))
  mac.Write([]byte(eventID + "." + timestamp + "."))
  mac.Write(rawBody)
  expected := mac.Sum(nil)

  received, err := hex.DecodeString(signature)
  if err != nil {
    return false
  }

  return subtle.ConstantTimeCompare(expected, received) == 1
}

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

public final class WebhookVerifier {

    private static final int TOLERANCE_SECONDS = 300;

    // rawBody must be the exact, unparsed request body.
    public static boolean verify(String secret, String eventId, String header, byte[] rawBody) {
        if (secret == null || secret.isEmpty() || eventId == null || eventId.isEmpty()
                || header == null || header.isEmpty()) {
            return false;
        }

        Map<String, String> fields = new HashMap<>();
        for (String part : header.split(",")) {
            int i = part.indexOf('=');
            if (i > 0) {
                fields.put(part.substring(0, i), part.substring(i + 1));
            }
        }

        String timestamp = fields.get("t");
        String signature = fields.get("v1");
        if (timestamp == null || signature == null || !timestamp.chars().allMatch(Character::isDigit)) {
            return false;
        }

        long now = System.currentTimeMillis() / 1000;
        if (Math.abs(now - Long.parseLong(timestamp)) > TOLERANCE_SECONDS) {
            return false;
        }

        try {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
            mac.update((eventId + "." + timestamp + ".").getBytes(StandardCharsets.UTF_8));
            byte[] expected = mac.doFinal(rawBody);

            byte[] received = hexToBytes(signature);
            return received.length == expected.length && MessageDigest.isEqual(expected, received);
        } catch (Exception e) {
            return false;
        }
    }

    private static byte[] hexToBytes(String hex) {
        byte[] bytes = new byte[hex.length() / 2];
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) ((Character.digit(hex.charAt(i * 2), 16) << 4)
                    + Character.digit(hex.charAt(i * 2 + 1), 16));
        }
        return bytes;
    }
}