Verify signatures

import crypto from 'node:crypto';

export function verifyRailbedSignature(
  rawBody,
  header,
  secret,
  toleranceSeconds = 300,
) {
  const match = /^t=(\d+),v1=([0-9a-f]{64})$/.exec(header ?? '');
  if (!match) return false;
  const [, timestamp, signature] = match;
  const age = Math.abs(Date.now() / 1000 - Number(timestamp));
  if (age > toleranceSeconds) return false;
  const expected = crypto
    .createHmac('sha256', secret)
    .update(`${timestamp}.${rawBody}`)
    .digest('hex');
  return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}

Cloudflare Workers, Deno, Bun, Next.js route handlers

export async function verifyRailbedSignature(
  rawBody: string,
  header: string | null,
  secret: string,
  toleranceSeconds = 300,
) {
  const match = /^t=(\d+),v1=([0-9a-f]{64})$/.exec(header ?? '');
  if (!match) return false;
  const [, timestamp, signature] = match;
  const age = Math.abs(Date.now() / 1000 - Number(timestamp));
  if (age > toleranceSeconds) return false;
  const enc = new TextEncoder();
  const key = await crypto.subtle.importKey(
    'raw',
    enc.encode(secret),
    { name: 'HMAC', hash: 'SHA-256' },
    false,
    ['verify'],
  );
  const bytes = new Uint8Array(
    signature.match(/../g)!.map((h) => parseInt(h, 16)),
  );
  const signedPayload = enc.encode(`${timestamp}.${rawBody}`);
  // subtle.verify compares in constant time
  return crypto.subtle.verify('HMAC', key, bytes, signedPayload);
}

import hashlib, hmac, re, time

def verify_railbed_signature(
    raw_body: bytes,
    header: str,
    secret: str,
    tolerance_seconds: int = 300,
) -> bool:
    match = re.fullmatch(r"t=(\d+),v1=([0-9a-f]{64})", header or "")
    if not match:
        return False
    timestamp, signature = match.groups()
    if abs(time.time() - int(timestamp)) > tolerance_seconds:
        return False
    expected = hmac.new(
        secret.encode(), timestamp.encode() + b"." + raw_body, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

<?php
function verify_railbed_signature(
  string $rawBody,
  string $header,
  string $secret,
  int $toleranceSeconds = 300
): bool {
  if (!preg_match('/^t=(\d+),v1=([0-9a-f]{64})$/', $header, $match)) return false;
  [, $timestamp, $signature] = $match;
  if (abs(time() - (int) $timestamp) > $toleranceSeconds) return false;
  $expected = hash_hmac('sha256', $timestamp . '.' . $rawBody, $secret);
  return hash_equals($expected, $signature);
}

require 'openssl'
require 'rack/utils' # secure_compare; Rails and Sinatra already load it

def verify_railbed_signature(raw_body, header, secret, tolerance_seconds = 300)
  match = /\At=(\d+),v1=([0-9a-f]{64})\z/.match(header.to_s)
  return false unless match
  timestamp, signature = match.captures
  return false if (Time.now.to_i - timestamp.to_i).abs > tolerance_seconds
  expected = OpenSSL::HMAC.hexdigest('SHA256', secret, "#{timestamp}.#{raw_body}")
  Rack::Utils.secure_compare(expected, signature)
end

package railbed

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

var signatureHeader = regexp.MustCompile(`^t=(\d+),v1=([0-9a-f]{64})$`)

func VerifySignature(
	rawBody []byte,
	header, secret string,
	tolerance time.Duration,
) bool {
	m := signatureHeader.FindStringSubmatch(header)
	if m == nil {
		return false
	}
	ts, err := strconv.ParseInt(m[1], 10, 64)
	if err != nil {
		return false
	}
	if age := time.Since(time.Unix(ts, 0)); age > tolerance || age < -tolerance {
		return false
	}
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(m[1] + "."))
	mac.Write(rawBody)
	expected := hex.EncodeToString(mac.Sum(nil))
	return hmac.Equal([]byte(expected), []byte(m[2]))
}