Verifi RDR Webhook Event

{
  "id": "event_ac7d19a7863bec06d7b1ae56",
  "object": "verifi.rdr",
  "data": {
    "case": {
      "date": "2024-01-01",
      "amount": 19.99,
      "currency": "USD",
    },
    "authorization_code": "12345D",
    "acquirer_reference_number": "78709066262500100248962",
    "refunded": true,
    "original_transaction": {
      "date": "2023-11-01",
      "amount": 19.99,
      "currency": "USD"
    },
    "card": {
      "bin": 424242,
      "last4": 4242
    },
    "network": {
      "merchant_id": 123456789,
      "scheme": "visa",
      "transaction_id": "103431687468834",
      "reason_code": "13.2",
      "merchant_order_id": "string",
      "merchant_category_code": 5411
    },
    "psp_transaction": {
      "type": "charge",
      "id": "ch_3MmlLrLkdIwHu7ix0snN0B15"
    }
  },
  "created_at": 1735689600
}

import json
import hashlib
import hmac
from time import time

def verify_webhook_signature(body: dict, headers: dict, signing_key: str) -> bool:
	payload = json.dumps(body, separators=(",", ":"))
	provided_signature = headers.get("X-Butter-Webhook-Signature")
	created_at = headers.get("X-Butter-Webhook-Created")
	message = f"{payload}+{created_at}".encode("utf-8")
	cacluated_signature = hmac.new(signing_key.encode("utf-8"), message, hashlib.sha256).hexdigest()
	return provided_signature == cacluated_signature

const crypto = require('crypto');

function verifyWebhookSignature(body, headers, signingKey) {
	const payload = JSON.stringify(body);
	const createdAt = headers["X-Butter-Webhook-Created"];
	const providedSignature = headers["X-Butter-Webhook-Signature"];
	const hmac = crypto.createHmac('SHA256', signingKey);
	const data = hmac.update(Buffer.from(`${JSON.stringify(body)}+${createdAt}`));
	const calculatedSignature = data.digest('hex');
	return (calculatedSignature == providedSignature) ? true : false;
}

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "strconv"
    "time"
)

func verifyWebhookSignature(headers map[string]string, body string, signingKey string) bool {
    createdAtStr := headers["X-Butter-Webhook-Expires"]
    createdAt, err := strconv.ParseInt(createdAtStr, 10, 64)
    if err != nil {
        fmt.Println("Error parsing createdAt timestamp:", err)
        return false
    }
    providedSignature := headers["X-Butter-Webhook-Signature"]

    hmacSha256 := hmac.New(sha256.New, []byte(signingKey))
    _, err = hmacSha256.Write([]byte(body + "+" + createdAtStr))
    if err != nil {
        fmt.Println("Error computing HMAC:", err)
        return false
    }
    calculatedSignature := hex.EncodeToString(hmacSha256.Sum(nil))

    if calculatedSignature != providedSignature {
        return false
    }

    return true
}

import java.nio.charset.StandardCharsets;
import java.util.Map;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import com.fasterxml.jackson.databind.ObjectMapper;

public class WebhookVerifier {
    public static boolean verifyWebhookSignature(Map<String, String> headers, Object body, String signingKey) {
        String createdAtStr = headers.get("X-Butter-Webhook-Created");
        long createdAt = Long.parseLong(createdAtStr);
        String providedSignature = headers.get("X-Butter-Webhook-Signature");

        try {
            ObjectMapper objectMapper = new ObjectMapper();
            String payload = objectMapper.writeValueAsString(body);

            Mac hmac = Mac.getInstance("HmacSHA256");
            SecretKeySpec secretKeySpec = new SecretKeySpec(signingKey.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
            hmac.init(secretKeySpec);

            byte[] payloadBytes = (payload + "+" + createdAtStr).getBytes(StandardCharsets.UTF_8);
            byte[] signatureBytes = hmac.doFinal(payloadBytes);
            String calculatedSignature = bytesToHex(signatureBytes);

            if (!calculatedSignature.equals(providedSignature)) {
                return false;
            }

            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }
}