Verify webhook signatures

import crypto from "crypto";

function verify(rawBody, header, secret) {
  const parts = Object.fromEntries(header.split(",").map((kv) => kv.split("=")));
  const expected = crypto
    .createHmac("sha256", secret)
    .update(`${parts.t}.${rawBody}`, "utf8")
    .digest("hex");
  const digest = Buffer.from(expected, "hex");
  const provided = Buffer.from(parts.signature ?? "", "hex");

  // timingSafeEqual throws unless both buffers are the same length, so compare
  // lengths first. Without this a malformed or absent signature is an exception
  // rather than a rejection.
  return provided.length === digest.length && crypto.timingSafeEqual(digest, provided);
}

import hashlib
import hmac

def verify(raw_body: bytes, header: str, secret: str) -> bool:
    parts = dict(kv.split("=", 1) for kv in header.split(","))
    expected = hmac.new(
        secret.encode(), f"{parts['t']}.".encode() + raw_body, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, parts["signature"])

require "openssl"

def verify(raw_body, header, secret)
  parts = header.split(",").map { |kv| kv.split("=", 2) }.to_h
  expected = OpenSSL::HMAC.hexdigest("SHA256", secret, "#{parts['t']}.#{raw_body}")
  OpenSSL.secure_compare(expected, parts["signature"])
end

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

func verify(rawBody []byte, header, secret string) bool {
	parts := map[string]string{}
	for _, kv := range strings.Split(header, ",") {
		if key, value, ok := strings.Cut(kv, "="); ok {
			parts[key] = value
		}
	}
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(parts["t"] + "."))
	mac.Write(rawBody)
	expected := hex.EncodeToString(mac.Sum(nil))
	return hmac.Equal([]byte(expected), []byte(parts["signature"]))
}

import java.security.MessageDigest;
import java.util.Arrays;
import java.util.HexFormat;
import java.util.Map;
import java.util.stream.Collectors;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

boolean verify(byte[] rawBody, String header, String secret) throws Exception {
    Map<String, String> parts = Arrays.stream(header.split(","))
        .map(kv -> kv.split("=", 2))
        .collect(Collectors.toMap(kv -> kv[0], kv -> kv[1]));
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(secret.getBytes(), "HmacSHA256"));
    mac.update((parts.get("t") + ".").getBytes());
    String expected = HexFormat.of().formatHex(mac.doFinal(rawBody));
    return MessageDigest.isEqual(expected.getBytes(), parts.get("signature").getBytes());
}

function verify(string $rawBody, string $header, string $secret): bool
{
    parse_str(strtr($header, ',', '&'), $parts);
    $expected = hash_hmac('sha256', "{$parts['t']}.{$rawBody}", $secret);
    return hash_equals($expected, $parts['signature']);
}

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

static bool Verify(byte[] rawBody, string header, string secret)
{
    var parts = header.Split(',')
        .Select(kv => kv.Split('=', 2))
        .ToDictionary(kv => kv[0], kv => kv[1]);
    using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
    var signed = Encoding.UTF8.GetBytes(parts["t"] + ".").Concat(rawBody).ToArray();
    var expected = Convert.ToHexString(hmac.ComputeHash(signed)).ToLowerInvariant();
    return CryptographicOperations.FixedTimeEquals(
        Encoding.UTF8.GetBytes(expected), Encoding.UTF8.GetBytes(parts["signature"]));
}