Signature Verification

from standardwebhooks import Webhook
import os

wh = Webhook(os.environ["SURGE_WEBHOOK_SECRET"])

try:
    payload = wh.verify(request.body, request.headers)
    # payload is the parsed event dict
except Exception:
    return Response(status=400)

import { Webhook } from "standardwebhooks";

const wh = new Webhook(process.env.SURGE_WEBHOOK_SECRET!);

try {
  const payload = wh.verify(rawBody, req.headers);
  // payload is the parsed event object
} catch {
  res.status(400).end();
  return;
}

require "standardwebhooks"

wh = StandardWebhooks::Webhook.new(ENV["SURGE_WEBHOOK_SECRET"])

begin
  payload = wh.verify(request.raw_post, request.headers)
rescue StandardWebhooks::WebhookVerificationError
  head :bad_request and return
end

# The `standardwebhooks` library isn't available for Elixir yet.
# Verify the HMAC manually:
<<<<<<< CURRENT
defp verify_surge_signature(conn, secret) do
  webhook_id    = List.first(get_req_header(conn, "webhook-id"))
  timestamp     = List.first(get_req_header(conn, "webhook-timestamp"))
  signature     = List.first(get_req_header(conn, "webhook-signature"))
  body          = conn.assigns[:raw_body]

  # Strip the "whsec_" prefix and base64-decode the secret
  "whsec_" <> encoded = secret
  decoded_secret = Base.decode64!(encoded, padding: false)

  # Build the signed payload: "{webhook-id}.{webhook-timestamp}.{body}"
  payload  = "#{webhook_id}.#{timestamp}.#{body}"
  expected = :crypto.mac(:hmac, :sha256, decoded_secret, payload) |> Base.encode64()

  # Plug.Crypto.secure_compare/2 is a constant-time comparison.
  Plug.Crypto.secure_compare(signature, "v1,#{expected}")
end
=======
@tolerance_seconds 300

defp verify_surge_signature(conn, secret) do
  webhook_id    = List.first(get_req_header(conn, "webhook-id"))
  timestamp     = List.first(get_req_header(conn, "webhook-timestamp"))
  signature_hdr = List.first(get_req_header(conn, "webhook-signature"))
  body          = conn.assigns[:raw_body]

  # Reject stale timestamps to prevent replay attacks (codex P1)
  with {ts, ""} <- Integer.parse(timestamp || ""),
       true <- abs(System.system_time(:second) - ts) <= @tolerance_seconds do
    # Strip the "whsec_" prefix and base64-decode the secret
    "whsec_" <> encoded = secret
    decoded_secret = Base.decode64!(encoded, padding: false)

    # Build the signed payload: "{webhook-id}.{webhook-timestamp}.{body}"
    payload  = "#{webhook_id}.#{timestamp}.#{body}"
    expected = :crypto.mac(:hmac, :sha256, decoded_secret, payload) |> Base.encode64()

    # The header may hold several space-separated "v1,<sig>" entries
    # during key rotation — accept if any matches (codex P2).
    signature_hdr
    |> String.split(" ", trim: true)
    |> Enum.any?(&Plug.Crypto.secure_compare(&1, "v1,#{expected}"))
  else
    _ -> false
  end
end
>>>>>>> SUGGESTED (#11 codex P1 replay-protection + #12 codex P2 key-rotation multi-sig, 2026-07-17 — DRAFTED, one block fixes both)