Signature Verification

const crypto = require("crypto");

function verifyWebhook(publicKeyStr, webhookId, webhookTimestamp, webhookSignature, rawBody) {
  // 1. Strip the whpk_ prefix and decode the public key
  const rawKey = publicKeyStr.replace(/^whpk_/, "");
  const keyBuffer = Buffer.from(rawKey, "base64");
  const publicKey = crypto.createPublicKey({
    key: keyBuffer,
    format: "der",
    type: "spki",
  });

  // 2. Strip the v1a, prefix and decode the signature
  if (!webhookSignature.startsWith("v1a,")) {
    throw new Error("Unsupported signature version");
  }
  const sigBuffer = Buffer.from(webhookSignature.slice(4), "base64");

  // 3. Reconstruct the signed message
  const message = Buffer.from(`${webhookId}.${webhookTimestamp}.${rawBody}`);

  // 4. Verify
  return crypto.verify(null, message, publicKey, sigBuffer);
}

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

const STARBRIDGE_PUBLIC_KEY =
  "whpk_MCowBQYDK2VwAyEA3pXFbrxQWyCihnqd8eQ7B0CVyB9BXRMes8oluz6YkA8=";

// Important: use raw body parser so the body isn't re-serialized
app.post("/webhook", express.raw({ type: "application/json" }), (req, res) => {
  const isValid = verifyWebhook(
    STARBRIDGE_PUBLIC_KEY,
    req.headers["webhook-id"],
    req.headers["webhook-timestamp"],
    req.headers["webhook-signature"],
    req.body.toString()
  );

  if (!isValid) {
    return res.status(401).send("Invalid signature");
  }

  const payload = JSON.parse(req.body);
  // Process the webhook...
  res.status(200).send("OK");
});

import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.Signature;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class WebhookVerifier {

    public static boolean verifyWebhook(
            String publicKeyStr,
            String webhookId,
            String webhookTimestamp,
            String webhookSignature,
            String rawBody
    ) throws Exception {
        // 1. Strip the whpk_ prefix and decode the public key
        String rawKey = publicKeyStr.replaceFirst("^whpk_", "");
        byte[] keyBytes = Base64.getDecoder().decode(rawKey);
        PublicKey publicKey = KeyFactory.getInstance("Ed25519")
                .generatePublic(new X509EncodedKeySpec(keyBytes));

        // 2. Strip the v1a, prefix and decode the signature
        if (!webhookSignature.startsWith("v1a,")) {
            throw new IllegalArgumentException("Unsupported signature version");
        }
        byte[] sigBytes = Base64.getDecoder().decode(webhookSignature.substring(4));

        // 3. Reconstruct the signed message
        String message = webhookId + "." + webhookTimestamp + "." + rawBody;

        // 4. Verify
        Signature verifier = Signature.getInstance("Ed25519");
        verifier.initVerify(publicKey);
        verifier.update(message.getBytes());
        return verifier.verify(sigBytes);
    }
}

package main

import (
	"crypto/ed25519"
	"crypto/x509"
	"encoding/base64"
	"errors"
	"fmt"
	"strings"
)

func verifyWebhook(publicKeyStr, webhookId, webhookTimestamp, webhookSignature, rawBody string) (bool, error) {
	// 1. Strip the whpk_ prefix and decode the public key
	rawKey := strings.TrimPrefix(publicKeyStr, "whpk_")
	keyBytes, err := base64.StdEncoding.DecodeString(rawKey)
	if err != nil {
		return false, fmt.Errorf("failed to decode public key: %w", err)
	}
	parsed, err := x509.ParsePKIXPublicKey(keyBytes)
	if err != nil {
		return false, fmt.Errorf("failed to parse public key: %w", err)
	}
	publicKey, ok := parsed.(ed25519.PublicKey)
	if !ok {
		return false, errors.New("key is not Ed25519")
	}

	// 2. Strip the v1a, prefix and decode the signature
	if !strings.HasPrefix(webhookSignature, "v1a,") {
		return false, errors.New("unsupported signature version")
	}
	sigBytes, err := base64.StdEncoding.DecodeString(webhookSignature[4:])
	if err != nil {
		return false, fmt.Errorf("failed to decode signature: %w", err)
	}

	// 3. Reconstruct the signed message
	message := []byte(webhookId + "." + webhookTimestamp + "." + rawBody)

	// 4. Verify
	return ed25519.Verify(publicKey, message, sigBytes), nil
}

require "openssl"
require "base64"

def verify_webhook(public_key_str, webhook_id, webhook_timestamp, webhook_signature, raw_body)
  # 1. Strip the whpk_ prefix and decode the public key
  raw_key = public_key_str.sub(/\Awhpk_/, "")
  key_bytes = Base64.decode64(raw_key)
  public_key = OpenSSL::PKey.read(
    OpenSSL::ASN1.decode(key_bytes).to_der
  )

  # 2. Strip the v1a, prefix and decode the signature
  raise "Unsupported signature version" unless webhook_signature.start_with?("v1a,")
  sig_bytes = Base64.decode64(webhook_signature[4..])

  # 3. Reconstruct the signed message
  message = "#{webhook_id}.#{webhook_timestamp}.#{raw_body}"

  # 4. Verify
  public_key.verify(nil, sig_bytes, message)
end

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

public static class WebhookVerifier
{
    public static bool VerifyWebhook(
        string publicKeyStr,
        string webhookId,
        string webhookTimestamp,
        string webhookSignature,
        string rawBody)
    {
        // 1. Strip the whpk_ prefix and decode the public key
        var rawKey = publicKeyStr.StartsWith("whpk_") ? publicKeyStr[5..] : publicKeyStr;
        var keyBytes = Convert.FromBase64String(rawKey);
        using var ed25519 = new Ed25519();
        ed25519.ImportSubjectPublicKeyInfo(keyBytes, out _);

        // 2. Strip the v1a, prefix and decode the signature
        if (!webhookSignature.StartsWith("v1a,"))
            throw new ArgumentException("Unsupported signature version");
        var sigBytes = Convert.FromBase64String(webhookSignature[4..]);

        // 3. Reconstruct the signed message
        var message = Encoding.UTF8.GetBytes($"{webhookId}.{webhookTimestamp}.{rawBody}");

        // 4. Verify
        return ed25519.VerifyData(message, sigBytes);
    }
}