import hmac
import hashlib
import time


def verify_webhook(
    secret: str,
    timestamp_header: str | None,
    signature_header: str | None,
    raw_body: bytes,
) -> bool:
    # 1. If you have issued a secret, the headers must be included
    if not timestamp_header or not signature_header:
        return False

    # 2. Check timestamp freshness (within 5 minutes)
    if abs(time.time() - int(timestamp_header)) > 300:
        return False

    # 3. Construct signed_payload
    signed_payload = timestamp_header.encode() + b"." + raw_body

    # 4. Compute HMAC-SHA256
    expected = hmac.new(
        key=secret.encode(),
        msg=signed_payload,
        digestmod=hashlib.sha256,
    ).hexdigest()

    # 5. Compare with the signatures in the header
    for sig in signature_header.split(","):
        version, value = sig.split("=", 1)
        if hmac.compare_digest(expected, value):
            return True

    return False

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

public final class WebhookVerifier {

    private static final long TOLERANCE_SECONDS = 300; // 5 minutes

    private WebhookVerifier() {}

    public static boolean verifyWebhook(
            String secret,
            String timestampHeader,
            String signatureHeader,
            byte[] rawBody) {

        // 1. If you have issued a secret, the headers must be included
        if (timestampHeader == null || timestampHeader.isEmpty()
                || signatureHeader == null || signatureHeader.isEmpty()) {
            return false;
        }

        // 2. Check timestamp freshness (within 5 minutes)
        final long timestamp;
        try {
            timestamp = Long.parseLong(timestampHeader);
        } catch (NumberFormatException e) {
            return false;
        }
        long now = System.currentTimeMillis() / 1000;
        if (Math.abs(now - timestamp) > TOLERANCE_SECONDS) {
            return false;
        }

        // 3. Construct signed_payload: timestamp + "." + raw_body
        byte[] prefix = (timestampHeader + ".").getBytes(StandardCharsets.UTF_8);
        byte[] signedPayload = new byte[prefix.length + rawBody.length];
        System.arraycopy(prefix, 0, signedPayload, 0, prefix.length);
        System.arraycopy(rawBody, 0, signedPayload, prefix.length, rawBody.length);

        // 4. Compute HMAC-SHA256
        String expected = hmacSha256Hex(secret, signedPayload);

        // 5. Compare with the signatures in the header
        for (String sig : signatureHeader.split(",")) {
            int idx = sig.indexOf('=');
            if (idx < 0) {
                continue; // skip if not in "version=value" format
            }
            String value = sig.substring(idx + 1);
            // constant-time comparison (equivalent to hmac.compare_digest)
            if (MessageDigest.isEqual(
                    expected.getBytes(StandardCharsets.UTF_8),
                    value.getBytes(StandardCharsets.UTF_8))) {
                return true;
            }
        }

        return false;
    }

    private static String hmacSha256Hex(String secret, byte[] message) {
        try {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(
                    secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
            return HexFormat.of().formatHex(mac.doFinal(message));
        } catch (Exception e) {
            throw new IllegalStateException("Failed to compute HMAC", e);
        }
    }
}

const crypto = require("crypto");

function verifyWebhook(secret, timestampHeader, signatureHeader, rawBody) {
  if (!timestampHeader || !signatureHeader) {
    return false;
  }

  const timestamp = Number(timestampHeader);
  if (!Number.isFinite(timestamp)) {
    return false;
  }

  if (Math.abs(Date.now() / 1000 - timestamp) > 300) {
    return false;
  }

  const signedPayload = Buffer.concat([
    Buffer.from(timestampHeader),
    Buffer.from("."),
    Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(rawBody),
  ]);

  const expected = crypto
    .createHmac("sha256", secret)
    .update(signedPayload)
    .digest("hex");

  return signatureHeader.split(",").some((sig) => {
    const [, value] = sig.split("=", 2);
    if (!value) return false;

    return crypto.timingSafeEqual(
      Buffer.from(expected),
      Buffer.from(value)
    );
  });
}