Verify signatures

import { createHmac, timingSafeEqual } from 'node:crypto';

export function verifyFloKit(
  rawBody: Uint8Array,
  header: string | null | undefined,
  secrets: readonly string[],
  nowMilliseconds = Date.now(),
): boolean {
  if (rawBody.byteLength > 262144 || !header || header.length > 1024
    || !Number.isSafeInteger(nowMilliseconds) || nowMilliseconds < 0
    || secrets.length < 1 || secrets.length > 2
    || secrets.some((secret) => !secret || secret.length > 4096)) return false;
  let timestamp: number | undefined;
  const signatures: Buffer[] = [];
  for (const part of header.split(',')) {
    const field = /^(t|v1)=([^\s,]+)$/.exec(part.trim());
    if (!field) return false;
    const value = field[2]!;
    if (field[1] === 't') {
      if (timestamp !== undefined || !/^(0|[1-9][0-9]{0,15})$/.test(value)) return false;
      timestamp = Number(value);
      if (!Number.isSafeInteger(timestamp)) return false;
    } else {
      if (!/^[0-9a-f]{64}$/.test(value) || signatures.length >= 8) return false;
      signatures.push(Buffer.from(value, 'hex'));
    }
  }
  if (timestamp === undefined || signatures.length === 0 || Math.abs(nowMilliseconds - timestamp) > 300000) return false;
  let matched = 0;
  for (const secret of secrets) {
    const expected = createHmac('sha256', secret).update(`${timestamp}.`).update(rawBody).digest();
    for (const signature of signatures) matched |= Number(timingSafeEqual(expected, signature));
  }
  return matched === 1;
}

import hashlib
import hmac
import re
import time


def verify_flokit(raw_body: bytes, header: str, secrets: list[str], now_milliseconds=None) -> bool:
    now = int(time.time() * 1000) if now_milliseconds is None else now_milliseconds
    if (len(raw_body) > 262144 or not header or len(header) > 1024
            or type(now) is not int or now < 0 or now > 9007199254740991
            or not 1 <= len(secrets) <= 2
            or any(not secret or len(secret) > 4096 for secret in secrets)):
        return False
    timestamp = None
    signatures = []
    for part in header.split(','):
        field = re.fullmatch(r'(t|v1)=([^\s,]+)', part.strip())
        if field is None:
            return False
        key, value = field.groups()
        if key == 't':
            if timestamp is not None or re.fullmatch(r'(0|[1-9][0-9]{0,15})', value) is None:
                return False
            timestamp = int(value)
            if timestamp > 9007199254740991:
                return False
        else:
            if re.fullmatch(r'[0-9a-f]{64}', value) is None or len(signatures) >= 8:
                return False
            signatures.append(bytes.fromhex(value))
    if timestamp is None or not signatures or abs(now - timestamp) > 300000:
        return False
    signed = str(timestamp).encode('ascii') + b'.' + raw_body
    matched = False
    for secret in secrets:
        expected = hmac.new(secret.encode('utf-8'), signed, hashlib.sha256).digest()
        for signature in signatures:
            matched = bool(matched | hmac.compare_digest(expected, signature))
    return matched