Verify Webhook Signatures

Node.js, with Express and the standardwebhooks package:

import express from "express";
import { Webhook } from "standardwebhooks";

const app = express();
const webhook = new Webhook(process.env.DNSCHECK_SIGNING_SECRET);

// The signature covers the body exactly as sent, so read it raw
app.post("/dnscheck/webhook", express.raw({ type: "*/*" }), (req, res) => {
  let event;
  try {
    event = webhook.verify(req.body, req.headers);
  } catch (err) {
    return res.status(400).send("Invalid signature");
  }

  console.log(event.type, event.text);
  res.sendStatus(204);
});

app.listen(3000);

With net/http (Go 1.22 or later) and the standardwebhooks module, which you install with go get github.com/standard-webhooks/standard-webhooks/libraries/go:

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"

	standardwebhooks "github.com/standard-webhooks/standard-webhooks/libraries/go"
)

func main() {
	webhook, err := standardwebhooks.NewWebhook(os.Getenv("DNSCHECK_SIGNING_SECRET"))
	if err != nil {
		log.Fatal(err)
	}

	http.HandleFunc("POST /dnscheck/webhook", func(w http.ResponseWriter, r *http.Request) {
		// The signature covers the body exactly as sent, so read it raw
		body, err := io.ReadAll(r.Body)
		if err != nil || webhook.Verify(body, r.Header) != nil {
			http.Error(w, "Invalid signature", http.StatusBadRequest)
			return
		}

		var event struct {
			Type string `json:"type"`
			Text string `json:"text"`
		}
		if err := json.Unmarshal(body, &event); err != nil {
			http.Error(w, "Invalid JSON", http.StatusBadRequest)
			return
		}
		fmt.Println(event.Type, event.Text)
		w.WriteHeader(http.StatusNoContent)
	})

	log.Fatal(http.ListenAndServe(":3000", nil))
}

Using only Node.js's built-in crypto module:

import { createHmac, timingSafeEqual } from "node:crypto";

const TOLERANCE_SECONDS = 5 * 60;

// headers: the request's headers; body: the raw request body, as a Buffer
function validSignature(secret, headers, body) {
  const eventId = headers["webhook-id"];
  const timestamp = headers["webhook-timestamp"];
  const signatures = headers["webhook-signature"];
  if (!eventId || !timestamp || !signatures) return false;
  if (!/^\d+$/.test(timestamp)) return false;
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > TOLERANCE_SECONDS) {
    return false;
  }

  const key = Buffer.from(secret.replace(/^whsec_/, ""), "base64");
  const signedContent = Buffer.concat([Buffer.from(`${eventId}.${timestamp}.`), body]);
  const digest = createHmac("sha256", key).update(signedContent).digest("base64");
  const expected = Buffer.from(`v1,${digest}`);

  return signatures.split(" ").some((signature) => {
    const given = Buffer.from(signature);
    // timingSafeEqual throws on buffers of different lengths
    return given.length === expected.length && timingSafeEqual(given, expected);
  });
}

Using only the standard library:

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"time"
)

const toleranceSeconds = 5 * 60

// headers: the request's headers; body: the raw request body
func validSignature(secret string, headers http.Header, body []byte) bool {
	eventID := headers.Get("webhook-id")
	timestamp := headers.Get("webhook-timestamp")
	signatures := headers.Get("webhook-signature")
	if eventID == "" || timestamp == "" || signatures == "" {
		return false
	}
	sentAt, err := strconv.ParseInt(timestamp, 10, 64)
	if err != nil {
		return false
	}
	if age := time.Now().Unix() - sentAt; age > toleranceSeconds || age < -toleranceSeconds {
		return false
	}

	key, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(secret, "whsec_"))
	if err != nil {
		return false
	}
	mac := hmac.New(sha256.New, key)
	fmt.Fprintf(mac, "%s.%s.", eventID, timestamp)
	mac.Write(body)
	expected := []byte("v1," + base64.StdEncoding.EncodeToString(mac.Sum(nil)))

	for _, signature := range strings.Split(signatures, " ") {
		if hmac.Equal([]byte(signature), expected) {
			return true
		}
	}
	return false
}