Verifying webhook signatures

import {createPublicKey, verify} from 'node:crypto';

export function verifyWebhook(
  rawBody: Buffer,
  timestamp: string,
  webhookId: string,
  signatureHeader: string,
  trustedPublicKeys: string[],
  now = Math.floor(Date.now() / 1000)
): boolean {
  if (!/^[0-9]+$/.test(timestamp)) {
    return false;
  }
  if (!/^[0-9]+$/.test(webhookId)) {
    return false;
  }

  const sentAt = Number(timestamp);
  if (!Number.isSafeInteger(sentAt)) {
    return false;
  }
  const timeToleranceSeconds = 300;
  if (Math.abs(now - sentAt) > timeToleranceSeconds) {
    return false;
  }

  const messagePrefix = Buffer.from(`${webhookId}.${timestamp}.`);
  const message = Buffer.concat([messagePrefix, rawBody]);

  for (const encodedPublicKey of trustedPublicKeys) {
    if (!encodedPublicKey.startsWith('whpk_')) {
      throw new Error('Invalid configured public key');
    }
    const decodedPublicKey = Buffer.from(encodedPublicKey.slice(5), 'base64');
    if (decodedPublicKey.length !== 32) {
      throw new Error('Invalid configured public key');
    }

    // Node.js needs a key container rather than the raw public key bytes.
    const verificationKey = createPublicKey({
      key: {kty: 'OKP', crv: 'Ed25519', x: decodedPublicKey.toString('base64url')},
      format: 'jwk'
    });

    for (const signatureEntry of signatureHeader.split(' ')) {
      const parts = signatureEntry.split(',');
      if (parts.length !== 2) {
        continue;
      }
      const [version, encodedSignature] = parts;
      if (version !== 'v1a') {
        continue;
      }

      const decodedSignature = Buffer.from(encodedSignature, 'base64');
      if (decodedSignature.length !== 64) {
        continue;
      }
      // Buffer.from tolerates malformed Base64, so check the round trip too.
      if (decodedSignature.toString('base64') !== encodedSignature) {
        continue;
      }
      if (verify(null, message, verificationKey, decodedSignature)) {
        return true;
      }
    }
  }
  return false;
}

package webhooks

import (
	"crypto/ed25519"
	"encoding/base64"
	"regexp"
	"strconv"
	"strings"
	"time"
)

var decimalDigits = regexp.MustCompile(`^[0-9]+$`)

func VerifyWebhook(
	rawBody []byte,
	timestamp string,
	webhookID string,
	signatureHeader string,
	trustedPublicKeys []string,
	now time.Time,
) bool {
	if !decimalDigits.MatchString(timestamp) {
		return false
	}
	if !decimalDigits.MatchString(webhookID) {
		return false
	}

	sentAt, err := strconv.ParseInt(timestamp, 10, 64)
	if err != nil {
		return false
	}
	const timeToleranceSeconds = 300
	if sentAt < now.Unix()-timeToleranceSeconds {
		return false
	}
	if sentAt > now.Unix()+timeToleranceSeconds {
		return false
	}

	messagePrefix := []byte(webhookID + "." + timestamp + ".")
	message := append(messagePrefix, rawBody...)

	for _, encodedPublicKey := range trustedPublicKeys {
		if !strings.HasPrefix(encodedPublicKey, "whpk_") {
			panic("invalid configured public key")
		}
		decodedPublicKey, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(encodedPublicKey, "whpk_"))
		if err != nil {
			panic("invalid configured public key")
		}
		if len(decodedPublicKey) != ed25519.PublicKeySize {
			panic("invalid configured public key")
		}

		for _, signatureEntry := range strings.Split(signatureHeader, " ") {
			parts := strings.Split(signatureEntry, ",")
			if len(parts) != 2 {
				continue
			}
			version, encodedSignature := parts[0], parts[1]
			if version != "v1a" {
				continue
			}

			decodedSignature, err := base64.StdEncoding.DecodeString(encodedSignature)
			if err != nil {
				continue
			}
			if len(decodedSignature) != ed25519.SignatureSize {
				continue
			}
			if ed25519.Verify(ed25519.PublicKey(decodedPublicKey), message, decodedSignature) {
				return true
			}
		}
	}
	return false
}

<?php

declare(strict_types=1);

function verifyWebhook(
    string $rawBody,
    string $timestamp,
    string $webhookId,
    string $signatureHeader,
    array $trustedPublicKeys,
    ?int $now = null,
): bool {
    $now ??= time();
    if (!preg_match('/^[0-9]+$/D', $timestamp)) {
        return false;
    }
    if (!preg_match('/^[0-9]+$/D', $webhookId)) {
        return false;
    }

    $timeToleranceSeconds = 300;
    if (abs($now - (float) $timestamp) > $timeToleranceSeconds) {
        return false;
    }

    $message = $webhookId . '.' . $timestamp . '.' . $rawBody;

    foreach ($trustedPublicKeys as $encodedPublicKey) {
        if (!str_starts_with($encodedPublicKey, 'whpk_')) {
            throw new RuntimeException('Invalid configured public key');
        }
        $decodedPublicKey = base64_decode(substr($encodedPublicKey, 5), true);
        if ($decodedPublicKey === false) {
            throw new RuntimeException('Invalid configured public key');
        }
        if (strlen($decodedPublicKey) !== SODIUM_CRYPTO_SIGN_PUBLICKEYBYTES) {
            throw new RuntimeException('Invalid configured public key');
        }

        foreach (explode(' ', $signatureHeader) as $signatureEntry) {
            $parts = explode(',', $signatureEntry);
            if (count($parts) !== 2) {
                continue;
            }
            [$version, $encodedSignature] = $parts;
            if ($version !== 'v1a') {
                continue;
            }

            $decodedSignature = base64_decode($encodedSignature, true);
            if ($decodedSignature === false) {
                continue;
            }
            if (strlen($decodedSignature) !== SODIUM_CRYPTO_SIGN_BYTES) {
                continue;
            }
            if (sodium_crypto_sign_verify_detached($decodedSignature, $message, $decodedPublicKey)) {
                return true;
            }
        }
    }
    return false;
}

Webhook-Id + "." + Webhook-Timestamp + "." + rawBody