Verifying signatures

import crypto from 'node:crypto';
import express from 'express';

const app = express();
const CLIENT_SECRET = process.env.MG_CLIENT_SECRET;

// Keep the raw bytes: verification must run on exactly what was sent.
app.post('/webhooks/multigate', express.raw({ type: 'application/json' }), (req, res) => {
  const raw = req.body.toString('utf8');
  const marker = raw.indexOf('"body":');
  const signedPart = marker === -1 ? raw : raw.slice(marker + '"body":'.length, raw.lastIndexOf('}'));
  const event = JSON.parse(raw);
  const received = event.header?.hash ?? req.get('hash') ?? '';

  const expected = Buffer.from(crypto.createHmac('sha256', CLIENT_SECRET).update(signedPart, 'utf8').digest('hex'));
  const given = Buffer.from(String(received), 'utf8');
  // Compare lengths first: timingSafeEqual throws on buffers of different lengths.
  const valid = given.length === expected.length && crypto.timingSafeEqual(given, expected);
  if (!valid) return res.status(401).end();

  res.status(200).end(); // acknowledge fast, then process asynchronously
  queueForProcessing(req.get('Idempotency-Key'), event); // your code: see "Build your receiver"
});

import hashlib
import hmac
import json
import os

from flask import Flask, request, abort

app = Flask(__name__)
CLIENT_SECRET = os.environ["MG_CLIENT_SECRET"].encode("utf-8")


@app.post("/webhooks/multigate")
def multigate_webhook():
    raw = request.get_data(as_text=True)  # raw text, not request.json
    marker = raw.find('"body":')
    signed_part = raw if marker == -1 else raw[marker + len('"body":'):raw.rfind("}")]
    event = json.loads(raw)
    received = (event.get("header") or {}).get("hash") or request.headers.get("hash", "")

    expected = hmac.new(CLIENT_SECRET, signed_part.encode("utf-8"), hashlib.sha256).hexdigest()
    # Compare bytes: compare_digest raises TypeError on non-ASCII str input.
    if not hmac.compare_digest(str(received).encode("utf-8"), expected.encode("utf-8")):
        abort(401)

    queue_for_processing(request.headers.get("Idempotency-Key"), event)  # your code: see "Build your receiver"
    return "", 200

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

public final class MultigateSignature {
    private MultigateSignature() {}

    /** Returns true when {@code receivedHash} matches the signature of the raw webhook body. */
    public static boolean isValid(String rawBody, String receivedHash, String clientSecret) throws Exception {
        int marker = rawBody.indexOf("\"body\":");
        String signedPart = marker == -1
            ? rawBody
            : rawBody.substring(marker + "\"body\":".length(), rawBody.lastIndexOf('}'));

        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(clientSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        String expected = HexFormat.of().formatHex(mac.doFinal(signedPart.getBytes(StandardCharsets.UTF_8)));

        return receivedHash != null && MessageDigest.isEqual(
            expected.getBytes(StandardCharsets.UTF_8), receivedHash.getBytes(StandardCharsets.UTF_8));
    }
}

<?php
function multigate_signature_is_valid(string $rawBody, string $receivedHash, string $clientSecret): bool
{
    $marker = strpos($rawBody, '"body":');
    $signedPart = $marker === false
        ? $rawBody
        : substr($rawBody, $marker + strlen('"body":'), strrpos($rawBody, '}') - $marker - strlen('"body":'));

    $expected = hash_hmac('sha256', $signedPart, $clientSecret);
    return hash_equals($expected, $receivedHash);
}

$raw = file_get_contents('php://input');          // raw body, before json_decode
$event = json_decode($raw, true);
$received = $event['header']['hash'] ?? ($_SERVER['HTTP_HASH'] ?? '');

if (!is_string($received) || !multigate_signature_is_valid($raw, $received, getenv('MG_CLIENT_SECRET'))) {
    http_response_code(401);
    exit;
}
http_response_code(200);

using System;
using System.Security.Cryptography;
using System.Text;

public static class MultigateSignature
{
    /// <summary>True when receivedHash matches the signature of the raw webhook body.</summary>
    public static bool IsValid(string rawBody, string receivedHash, string clientSecret)
    {
        const string marker = "\"body\":";
        var start = rawBody.IndexOf(marker, StringComparison.Ordinal);
        var signedPart = start == -1
            ? rawBody
            : rawBody.Substring(start + marker.Length, rawBody.LastIndexOf('}') - start - marker.Length);

        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(clientSecret));
        var expected = Convert.ToHexString(hmac.ComputeHash(Encoding.UTF8.GetBytes(signedPart))).ToLowerInvariant();

        return receivedHash is not null && CryptographicOperations.FixedTimeEquals(
            Encoding.UTF8.GetBytes(expected), Encoding.UTF8.GetBytes(receivedHash));
    }
}