Webhook Signature Verification

const crypto = require('crypto');
const express = require('express');
const app = express();

// Use raw body middleware — required to extract the exact data bytes
app.use(express.raw({ type: 'application/json' }));

function verifySignature(rawBody, secret) {
  // Parse the envelope fields but sign the raw data bytes from the original body
  const body = rawBody.toString('utf8');
  const payload = JSON.parse(body);
  const { sign, data } = payload;

  if (!sign || !data) return { valid: false, payload: null };

  // Extract the raw "data" value as it appears in the body — key order preserved
  const dataStart = body.indexOf('"data"');
  const dataJson = body.slice(body.indexOf('{', dataStart));
  // Simpler: re-stringify works in Node.js since V8 preserves key order after JSON.parse
  const rawData = JSON.stringify(data);

  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawData)
    .digest('hex');

  const valid = crypto.timingSafeEqual(
    Buffer.from(sign, 'hex'),
    Buffer.from(expected, 'hex')
  );

  return { valid, payload };
}

app.post('/webhooks/fyatu', (req, res) => {
  const secret = process.env.FYATU_WEBHOOK_SECRET;
  const { valid, payload } = verifySignature(req.body, secret);

  if (!valid) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const { event, data } = payload;

  switch (event) {
    case 'card.funded':
      // handle funded card
      break;
    case 'card.transaction.approved':
      // handle approved transaction
      break;
    // ... other events
  }

  res.status(200).json({ received: true });
});

<?php

function verifySignature(array $data, string $sign, string $secret): bool
{
    // JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES matches the server encoding
    $expected = hash_hmac(
        'sha256',
        json_encode($data, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
        $secret
    );

    // hash_equals performs constant-time comparison
    return hash_equals($expected, $sign);
}

$rawBody = file_get_contents('php://input');
$payload = json_decode($rawBody, true);

$sign   = $payload['sign'] ?? '';
$data   = $payload['data'] ?? null;
$event  = $payload['event'] ?? '';
$secret = getenv('FYATU_WEBHOOK_SECRET');

if (empty($sign) || !is_array($data)) {
    http_response_code(400);
    echo json_encode(['error' => 'Missing required fields']);
    exit;
}

if (!verifySignature($data, $sign, $secret)) {
    http_response_code(401);
    echo json_encode(['error' => 'Invalid signature']);
    exit;
}

// Signature valid — process the event
switch ($event) {
    case 'card.funded':
        // handle funded card
        break;
    case 'card.transaction.approved':
        // handle approved transaction
        break;
    // ... other events
}

http_response_code(200);
echo json_encode(['received' => true]);

import hashlib
import hmac
import json
import os
from flask import Flask, request, jsonify, abort

app = Flask(__name__)

def verify_signature(data: dict, sign: str, secret: str) -> bool:
    # ensure_ascii=False + separators with no spaces matches the server encoding
    # Python 3.7+ dict preserves insertion order — key order is kept after json.loads
    message = json.dumps(data, ensure_ascii=False, separators=(',', ':'))
    expected = hmac.new(
        secret.encode('utf-8'),
        message.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

    return hmac.compare_digest(expected, sign)

@app.route('/webhooks/fyatu', methods=['POST'])
def handle_webhook():
    payload = request.get_json()
    sign   = payload.get('sign', '')
    data   = payload.get('data')
    event  = payload.get('event', '')
    secret = os.environ['FYATU_WEBHOOK_SECRET']

    if not sign or not isinstance(data, dict):
        abort(400, description='Missing required fields')

    if not verify_signature(data, sign, secret):
        abort(401, description='Invalid signature')

    if event == 'card.funded':
        pass  # handle funded card
    elif event == 'card.transaction.approved':
        pass  # handle approved transaction
    # ... other events

    return jsonify({'received': True}), 200

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "io"
    "net/http"
    "os"
)

// WebhookPayload uses json.RawMessage for Data so the original bytes are preserved.
// Do NOT use map[string]interface{} here — json.Marshal on a map sorts keys
// alphabetically, producing different bytes than the original and breaking verification.
type WebhookPayload struct {
    Event   string          `json:"event"`
    Version string          `json:"version"`
    EventID string          `json:"eventId"`
    Sign    string          `json:"sign"`
    Data    json.RawMessage `json:"data"` // raw bytes — key order preserved
}

func verifySignature(rawData []byte, sign, secret string) bool {
    signBytes, err := hex.DecodeString(sign)
    if err != nil {
        return false
    }

    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(rawData)

    return hmac.Equal(mac.Sum(nil), signBytes)
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    body, err := io.ReadAll(r.Body)
    if err != nil {
        http.Error(w, `{"error":"Failed to read body"}`, http.StatusBadRequest)
        return
    }

    var payload WebhookPayload
    if err := json.Unmarshal(body, &payload); err != nil {
        http.Error(w, `{"error":"Invalid JSON"}`, http.StatusBadRequest)
        return
    }

    secret := os.Getenv("FYATU_WEBHOOK_SECRET")

    if payload.Sign == "" || payload.Data == nil {
        http.Error(w, `{"error":"Missing required fields"}`, http.StatusBadRequest)
        return
    }

    // payload.Data contains the exact bytes from the body — no re-serialization
    if !verifySignature(payload.Data, payload.Sign, secret) {
        http.Error(w, `{"error":"Invalid signature"}`, http.StatusUnauthorized)
        return
    }

    // Signature valid — process the event
    switch payload.Event {
    case "card.funded":
        // handle funded card
    case "card.transaction.approved":
        // handle approved transaction
    // ... other events
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"received":true}`))
}

func main() {
    http.HandleFunc("/webhooks/fyatu", webhookHandler)
    http.ListenAndServe(":8080", nil)
}

require 'sinatra'
require 'openssl'
require 'json'

def verify_signature(data, sign, secret)
  # Ruby Hash preserves insertion order — to_json keeps the original key order
  message  = data.to_json
  expected = OpenSSL::HMAC.hexdigest('sha256', secret, message)
  Rack::Utils.secure_compare(expected, sign)
end

post '/webhooks/fyatu' do
  payload = JSON.parse(request.body.read)
  sign    = payload['sign'] || ''
  data    = payload['data']
  event   = payload['event'] || ''
  secret  = ENV['FYATU_WEBHOOK_SECRET']

  halt 400, { error: 'Missing required fields' }.to_json if sign.empty? || !data.is_a?(Hash)
  halt 401, { error: 'Invalid signature' }.to_json unless verify_signature(data, sign, secret)

  case event
  when 'card.funded'
    # handle funded card
  when 'card.transaction.approved'
    # handle approved transaction
  end

  content_type :json
  { received: true }.to_json
end

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.*;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.MessageDigest;
import java.util.HexFormat;
import java.util.LinkedHashMap;
import java.util.Map;

@RestController
public class WebhookController {

    private final String webhookSecret = System.getenv("FYATU_WEBHOOK_SECRET");
    // Disable sorting — Jackson uses LinkedHashMap by default which preserves key order
    private final ObjectMapper mapper = new ObjectMapper();

    private boolean verifySignature(Map<String, Object> data, String sign) throws Exception {
        // Jackson preserves key order when deserializing into Map (uses LinkedHashMap)
        String message = mapper.writeValueAsString(data);

        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(webhookSecret.getBytes("UTF-8"), "HmacSHA256"));
        byte[] expected = mac.doFinal(message.getBytes("UTF-8"));
        byte[] received = HexFormat.of().parseHex(sign);

        return MessageDigest.isEqual(expected, received);
    }

    @PostMapping(value = "/webhooks/fyatu", consumes = "application/json")
    public ResponseEntity<String> handleWebhook(@RequestBody Map<String, Object> payload) {
        try {
            String sign = (String) payload.get("sign");
            @SuppressWarnings("unchecked")
            Map<String, Object> data = (Map<String, Object>) payload.get("data");
            String event = (String) payload.get("event");

            if (sign == null || data == null) {
                return ResponseEntity.badRequest().body("{\"error\":\"Missing required fields\"}");
            }

            if (!verifySignature(data, sign)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                    .body("{\"error\":\"Invalid signature\"}");
            }

            switch (event != null ? event : "") {
                case "card.funded":
                    // handle funded card
                    break;
                case "card.transaction.approved":
                    // handle approved transaction
                    break;
            }

            return ResponseEntity.ok("{\"received\":true}");

        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("{\"error\":\"Verification failed\"}");
        }
    }
}

using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("webhooks")]
public class WebhookController : ControllerBase
{
    private readonly string _webhookSecret = Environment.GetEnvironmentVariable("FYATU_WEBHOOK_SECRET")!;

    private bool VerifySignature(JsonElement data, string sign)
    {
        // JsonElement serializes with original key order preserved
        var message = JsonSerializer.Serialize(data);

        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(_webhookSecret));
        var expected = hmac.ComputeHash(Encoding.UTF8.GetBytes(message));
        var received = Convert.FromHexString(sign);

        return CryptographicOperations.FixedTimeEquals(expected, received);
    }

    [HttpPost("fyatu")]
    public IActionResult HandleWebhook([FromBody] JsonElement payload)
    {
        if (!payload.TryGetProperty("sign", out var signEl) ||
            !payload.TryGetProperty("data", out var dataEl) ||
            !payload.TryGetProperty("event", out var eventEl))
        {
            return BadRequest(new { error = "Missing required fields" });
        }

        var sign = signEl.GetString() ?? "";

        if (!VerifySignature(dataEl, sign))
            return Unauthorized(new { error = "Invalid signature" });

        var eventType = eventEl.GetString();
        switch (eventType)
        {
            case "card.funded":
                // handle funded card
                break;
            case "card.transaction.approved":
                // handle approved transaction
                break;
            // ... other events
        }

        return Ok(new { received = true });
    }
}