Notifications

import crypto from "crypto";

const TOLERANCE_SECONDS = 300; // 5 minutes

function verifySignature(
  secret: string,
  timestamp: string,
  rawBody: Buffer,
  signatureHeader: string,
): boolean {
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > TOLERANCE_SECONDS) {
    return false;
  }

  const signedPayload = Buffer.concat([Buffer.from(`${timestamp}.`), rawBody]);
  const expected = crypto.createHmac("sha256", secret).update(signedPayload).digest("hex");
  const expectedBuf = Buffer.from(expected, "hex");

  // One v1=<hex> term per active secret — two during a rotation grace
  // window. Accept if ANY term matches.
  const candidates = signatureHeader
    .split(",")
    .filter((term) => term.startsWith("v1="))
    .map((term) => term.slice(3));

  return candidates.some((candidate) => {
    const candidateBuf = Buffer.from(candidate, "hex");
    return (
      candidateBuf.length === expectedBuf.length &&
      crypto.timingSafeEqual(expectedBuf, candidateBuf)
    );
  });
}

// Example: Express handler — mount with express.raw() so req.body is a Buffer,
// not a parsed object.
app.post(
  "/webhooks/mesh",
  express.raw({ type: "application/json" }),
  (req, res) => {
    const timestamp = req.header("Mesh-Webhook-Timestamp")!;
    const signature = req.header("Mesh-Webhook-Signature")!;

    if (!verifySignature(WEBHOOK_SECRET, timestamp, req.body, signature)) {
      return res.status(400).json({ error: "Invalid signature" });
    }

    const event = JSON.parse(req.body.toString("utf8"));
    // handle event.type, dedupe on event.id
    res.json({ received: true });
  },
);

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"io"
	"math"
	"net/http"
	"strconv"
	"strings"
	"time"
)

const toleranceSeconds = 300 // 5 minutes

func verifySignature(secret, timestamp string, rawBody []byte, signatureHeader string) bool {
	ts, err := strconv.ParseInt(timestamp, 10, 64)
	if err != nil || math.Abs(float64(time.Now().Unix()-ts)) > toleranceSeconds {
		return false
	}

	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(timestamp + "."))
	mac.Write(rawBody)
	expected := hex.EncodeToString(mac.Sum(nil))

	// One v1=<hex> term per active secret — two during a rotation grace
	// window. Accept if ANY term matches.
	for _, term := range strings.Split(signatureHeader, ",") {
		term = strings.TrimSpace(term)
		if !strings.HasPrefix(term, "v1=") {
			continue
		}
		candidate := strings.TrimPrefix(term, "v1=")
		if hmac.Equal([]byte(expected), []byte(candidate)) {
			return true
		}
	}
	return false
}

func handleMeshWebhook(w http.ResponseWriter, r *http.Request) {
	rawBody, _ := io.ReadAll(r.Body) // raw bytes, not json.Decode straight from r.Body
	timestamp := r.Header.Get("Mesh-Webhook-Timestamp")
	signature := r.Header.Get("Mesh-Webhook-Signature")

	if !verifySignature(webhookSecret, timestamp, rawBody, signature) {
		http.Error(w, "invalid signature", http.StatusBadRequest)
		return
	}

	// unmarshal rawBody, handle event.Type, dedupe on event.ID
	w.WriteHeader(http.StatusOK)
}