Verify Signature

const crypto = require("crypto");
const express = require("express");

const app = express();
const SECRET_KEY = process.env.CREPTAPAY_SECRET_KEY;
const TOLERANCE_MS = 5 * 60 * 1000;

// Keep the raw bytes. express.json() alone would discard them.
app.use(
  "/webhook",
  express.json({
    verify: (req, _res, buf) => {
      req.rawBody = buf;
    },
  }),
);

function verify(header, rawBody) {
  if (!header) return false;

  const parts = Object.fromEntries(
    header.split(",").map((part) => part.split("=")),
  );
  const { t, v1 } = parts;
  if (!t || !v1) return false;

  if (Math.abs(Date.now() - Number(t)) > TOLERANCE_MS) return false;

  const expected = crypto
    .createHmac("sha256", SECRET_KEY)
    .update(`${t}.${rawBody}`)
    .digest("hex");

  const a = Buffer.from(v1, "utf8");
  const b = Buffer.from(expected, "utf8");
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

app.post("/webhook", (req, res) => {
  if (!verify(req.headers["x-creptapay-signature"], req.rawBody)) {
    return res.status(401).send("Invalid signature");
  }

  // Acknowledge first, then do the slow work — we time out after 10 seconds.
  res.status(200).send("OK");

  const { event, data, environment } = req.body;
  handle(event, data, environment);
});

app.listen(3000);

import hmac
import hashlib
import os
import time
from flask import Flask, request

app = Flask(__name__)

SECRET_KEY = os.environ["CREPTAPAY_SECRET_KEY"].encode()
TOLERANCE_MS = 5 * 60 * 1000


def verify(header: str | None, raw_body: bytes) -> bool:
    if not header:
        return False

    try:
        parts = dict(part.split("=", 1) for part in header.split(","))
        timestamp, received = parts["t"], parts["v1"]
    except (ValueError, KeyError):
        return False

    if abs(time.time() * 1000 - int(timestamp)) > TOLERANCE_MS:
        return False

    signed = f"{timestamp}.".encode() + raw_body
    expected = hmac.new(SECRET_KEY, signed, hashlib.sha256).hexdigest()
    return hmac.compare_digest(received, expected)


@app.post("/webhook")
def webhook():
    # request.get_data() is the raw body; request.json would lose it.
    if not verify(request.headers.get("X-Creptapay-Signature"), request.get_data()):
        return "Invalid signature", 401

    payload = request.get_json()
    handle(payload["event"], payload["data"], payload["environment"])
    return "OK", 200

<?php

$secretKey = getenv('CREPTAPAY_SECRET_KEY');
$toleranceMs = 5 * 60 * 1000;

$header = $_SERVER['HTTP_X_CREPTAPAY_SIGNATURE'] ?? '';
$rawBody = file_get_contents('php://input');

parse_str(strtr($header, ',', '&'), $parts);
$timestamp = $parts['t'] ?? null;
$received  = $parts['v1'] ?? null;

if (!$timestamp || !$received) {
    http_response_code(400);
    exit('Missing signature');
}

if (abs(round(microtime(true) * 1000) - (int) $timestamp) > $toleranceMs) {
    http_response_code(401);
    exit('Signature too old');
}

$expected = hash_hmac('sha256', $timestamp . '.' . $rawBody, $secretKey);

if (!hash_equals($expected, $received)) {
    http_response_code(401);
    exit('Invalid signature');
}

$payload = json_decode($rawBody, true);
handle($payload['event'], $payload['data'], $payload['environment']);

http_response_code(200);
echo 'OK';

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import org.springframework.http.*;
import org.springframework.web.bind.annotation.*;

@RestController
public class WebhookController {

    private static final String SECRET_KEY = System.getenv("CREPTAPAY_SECRET_KEY");
    private static final long TOLERANCE_MS = 5 * 60 * 1000L;

    @PostMapping("/webhook")
    public ResponseEntity<String> handle(
            // Binding the body as String keeps the exact bytes we signed.
            @RequestBody String rawBody,
            @RequestHeader(value = "X-Creptapay-Signature", required = false) String header) {

        if (header == null) {
            return ResponseEntity.badRequest().body("Missing signature");
        }

        String timestamp = null, received = null;
        for (String part : header.split(",")) {
            String[] kv = part.split("=", 2);
            if (kv.length != 2) continue;
            if (kv[0].equals("t")) timestamp = kv[1];
            if (kv[0].equals("v1")) received = kv[1];
        }
        if (timestamp == null || received == null) {
            return ResponseEntity.badRequest().body("Malformed signature");
        }

        if (Math.abs(System.currentTimeMillis() - Long.parseLong(timestamp)) > TOLERANCE_MS) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Signature too old");
        }

        try {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(SECRET_KEY.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
            byte[] hash = mac.doFinal((timestamp + "." + rawBody).getBytes(StandardCharsets.UTF_8));

            StringBuilder hex = new StringBuilder(hash.length * 2);
            for (byte b : hash) hex.append(String.format("%02x", b));

            boolean valid = MessageDigest.isEqual(
                hex.toString().getBytes(StandardCharsets.UTF_8),
                received.getBytes(StandardCharsets.UTF_8));

            if (!valid) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid signature");
            }

            return ResponseEntity.ok("OK");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Error");
        }
    }
}