Callbacks and signature verification

{
  "uuid": "9ab63121-41f8-4c56-9c28-c78e9b44b487",
  "address_in": "0x2222222222222222222222222222222222222222",
  "address_out": "0x1111111111111111111111111111111111111111",
  "txid_in": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  "txid_out": null,
  "confirmations": 0,
  "value": "100.000000000000000000",
  "value_coin": "100.000000000000000000",
  "value_forwarded": "0.000000000000000000",
  "value_forwarded_coin": "0.000000000000000000",
  "fee": "0.00",
  "fee_coin": "0.000000000000000000",
  "coin": "bep20_usdt",
  "result": "pending",
  "pending": 1
}

{
  "uuid": "9ab63121-41f8-4c56-9c28-c78e9b44b487",
  "address_in": "0x2222222222222222222222222222222222222222",
  "address_out": "0x1111111111111111111111111111111111111111",
  "txid_in": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  "txid_out": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "confirmations": 12,
  "value": "100.000000000000000000",
  "value_coin": "100.000000000000000000",
  "value_forwarded": "98.300000000000000000",
  "value_forwarded_coin": "98.300000000000000000",
  "fee": "1.50",
  "fee_coin": "1.700000000000000000",
  "price": "1.00000000",
  "coin": "bep20_usdt",
  "result": "sent",
  "pending": 0
}

v1
1720000000
POST
merchant.example
/payments/callback?order_id=123
{"uuid":"9ab63121-41f8-4c56-9c28-c78e9b44b487","result":"sent","pending":0}

<?php

function callbackHeader(string $name): ?string
{
    foreach (getallheaders() as $headerName => $value) {
        if (strcasecmp($headerName, $name) === 0) {
            return trim((string) $value);
        }
    }

    return null;
}

function rejectCallback(int $status = 401): never
{
    http_response_code($status);
    exit;
}

$timestamp = callbackHeader('X-CryptPay-Timestamp');
$signatureBase64 = callbackHeader('X-CryptPay-Signature');

if ($timestamp === null || !ctype_digit($timestamp) ||
    abs(time() - (int) $timestamp) > 300 || $signatureBase64 === null) {
    rejectCallback();
}

$method = strtoupper($_SERVER['REQUEST_METHOD'] ?? '');
$hostHeader = $_SERVER['HTTP_HOST'] ?? '';
$host = parse_url('http://' . $hostHeader, PHP_URL_HOST);
$requestTarget = $_SERVER['REQUEST_URI'] ?? '';
$input = file_get_contents('php://input');

if (!is_string($host) || $host === '' || $requestTarget === '' || $input === false) {
    rejectCallback(400);
}

$host = strtolower($host); // hostname only; parse_url removes the port
$rawBody = $method === 'GET' ? '' : $input;
$canonical = implode("\n", [
    'v1', $timestamp, $method, $host, $requestTarget, $rawBody,
]);

$signature = base64_decode($signatureBase64, true);
$publicKeyPem = file_get_contents(__DIR__ . '/cryptpay-public.pem');
$publicKey = is_string($publicKeyPem)
    ? openssl_pkey_get_public($publicKeyPem)
    : false;

if ($signature === false || $publicKey === false ||
    openssl_verify($canonical, $signature, $publicKey, OPENSSL_ALGO_SHA256) !== 1) {
    rejectCallback();
}

// Parse only after verification.
$contentType = strtolower($_SERVER['CONTENT_TYPE'] ?? '');
if ($method === 'GET') {
    $payload = $_GET;
} elseif (str_contains($contentType, 'application/json')) {
    $payload = json_decode($rawBody, true, 512, JSON_THROW_ON_ERROR);
} else {
    parse_str($rawBody, $payload);
}

// Transactionally validate order/reference + coin, allow pending -> sent,
// and fulfill a confirmed UUID only once before acknowledging it.
processVerifiedCallbackIdempotently($payload);

http_response_code(200); // Body is optional and ignored by CryptPays.

import express from 'express';
import { readFileSync } from 'node:fs';
import { verify } from 'node:crypto';

const app = express();
const publicKeyPem = readFileSync('./cryptpay-public.pem', 'utf8');

// Register before express.json() or express.urlencoded().
app.all('/payments/callback', express.raw({ type: () => true }), async (req, res) => {
  const timestamp = req.get('X-CryptPay-Timestamp') ?? '';
  const signatureBase64 = req.get('X-CryptPay-Signature') ?? '';

  if (!/^\d+$/.test(timestamp) ||
      Math.abs(Math.floor(Date.now() / 1000) - Number(timestamp)) > 300 ||
      !/^[A-Za-z0-9+/]+={0,2}$/.test(signatureBase64) ||
      signatureBase64.length % 4 !== 0) {
    return res.sendStatus(401);
  }

  const method = req.method.toUpperCase();
  const hostHeader = req.get('host') ?? '';
  let host;
  try {
    host = new URL(`http://${hostHeader}`).hostname.toLowerCase();
  } catch {
    return res.sendStatus(400);
  }

  const requestTarget = req.originalUrl; // exact path + query
  const rawBody = method === 'GET'
    ? Buffer.alloc(0)
    : (Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0));
  const canonical = Buffer.concat([
    Buffer.from(`v1\n${timestamp}\n${method}\n${host}\n${requestTarget}\n`, 'utf8'),
    rawBody,
  ]);

  const signature = Buffer.from(signatureBase64, 'base64');
  if (!verify('RSA-SHA256', canonical, publicKeyPem, signature)) {
    return res.sendStatus(401);
  }

  // Parse only after verification.
  const contentType = (req.get('content-type') ?? '').toLowerCase();
  let payload;
  if (method === 'GET') {
    payload = Object.fromEntries(
      new URL(requestTarget, `http://${hostHeader}`).searchParams,
    );
  } else if (contentType.includes('application/json')) {
    payload = JSON.parse(rawBody.toString('utf8'));
  } else {
    payload = Object.fromEntries(new URLSearchParams(rawBody.toString('utf8')));
  }

  // Persist lifecycle/idempotency transactionally; do not use an in-memory Set.
  await processVerifiedCallbackIdempotently(payload);
  return res.sendStatus(200);
});

{
  "price": "150.00000000",
  "value_coin_convert": "{\"USDT\":\"300.00\"}",
  "value_forwarded_coin_convert": "{\"USDT\":\"295.50\"}"
}