## Why An automation webhook must prove that a request comes from the holder of the automation's secret before Coder parses the JSON body. The approved RFC ([Automations for Coder Agents](https://app.notion.com/p/3ded579be59281e39950e686df02fa3d), Webhooks section) puts that check behind one `WebhookVerifier` interface with three schemes. This PR adds those verifiers as a pure Go package. The webhook route that calls them comes in a later PR. Part of CODAGT-1135. ## What changed New leaf package `coderd/x/chatd/chatwebhook`: - `WebhookVerifier`, with the three methods exactly as the RFC writes them, and three verifiers: `bearer` (constant-time token compare, one or more spaces after `Bearer` as in RFC 6750 section 2.1), `github` (HMAC-SHA256 of the raw body in `X-Hub-Signature-256`) and `standard_webhooks` (HMAC-SHA256 of `webhook-id.webhook-timestamp.body`, `v1,` entries in `webhook-signature`, five-minute timestamp window, `whsec_` secret). - `Scheme` with the three RFC enum strings, and `NewVerifier(Scheme)`. The package does not import `coderd/database`. - Every `Verify` failure wraps `ErrRejected`, so the route can answer `401`. Every `Verify` and `ValidateSecret` error is built from a fixed string: it never holds the secret, the received token or a signature. The package does not log. Only the `NewVerifier` error names the unknown scheme. - `GenerateSecret` reads 32 bytes from `crypto/rand` for `bearer` and `github`. For `standard_webhooks` it returns `ok=false`, and `ValidateSecret` checks the pasted `whsec_` secret. ## Scope - No database, no HTTP route, no wiring, no new Go module. Nothing imports the package yet, so `main` behaves as before with the `chat-automations` experiment off. - The map from the database enum to a verifier, and its "every enum value has a verifier" test, belong to the route PR. It can call `NewVerifier(chatwebhook.Scheme(automation.WebhookAuth))`. A `NewVerifier` error is a server error, not a `401`. - No deduplication by `webhook-id`, as in the RFC. The same valid request verifies every time. ## Tradeoffs - A pasted `whsec_` secret has no length bound. The spec describes sender secrets of 24 to 64 bytes, but it does not tell a receiver to reject others. A bound would lock out a sender that deviates, and it protects only the owner from the sender's own key. - The bearer verifier accepts one or more spaces between `Bearer` and the token, as RFC 6750 section 2.1 and the API key middleware do. It rejects a tab and an empty token. It also rejects trailing whitespace after the token when it receives it, but an HTTP request cannot deliver that: `net/http` strips trailing whitespace from the header value before the verifier runs, so such a request is accepted with the right token. - The signed Standard Webhooks content uses the `webhook-timestamp` text as received. The reference Go library signs the reformatted number instead. The two differ only for a timestamp with leading zeros, which a conforming sender does not send. - A `webhook-id` that contains `.` is rejected. The spec asks senders to avoid it, because it makes `id.timestamp.body` ambiguous. A repeated `Authorization`, `X-Hub-Signature-256`, `webhook-id` or `webhook-timestamp` line is rejected for the same reason. Several `webhook-signature` lines are read as one list. - `TestSecretComparisonsAreConstantTime` reads the package source and fails on `==`, `bytes.Equal` and similar on secrets. A correct early-exit compare gives the same answers as a constant-time one, so a request-level test cannot tell them apart. The scan is a guard against the likely mistake, not a proof. ## Verification - Test vectors come from the [GitHub docs](https://docs.github.com/en/webhooks/using-webhooks/validating-webhook-deliveries) and from `TestWebhookSign` in the [Standard Webhooks Go library](https://github.com/standard-webhooks/standard-webhooks/blob/main/libraries/go/webhook_test.go). The tests cite the URL beside each vector. - Live lane: none. No route, CLI or UI reaches this code yet, so there is no surface to exercise. --- _Generated with [`xum`](https://github.com/coder/xum) • Model: `anthropic:claude-sonnet-5-5` • Thinking: `xhigh`_
48 lines
1.2 KiB
Go
48 lines
1.2 KiB
Go
package chatwebhook
|
|
|
|
import (
|
|
"crypto/hmac"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// githubVerifier checks the HMAC-SHA256 of the raw body that GitHub sends
|
|
// in X-Hub-Signature-256.
|
|
type githubVerifier struct{}
|
|
|
|
func (githubVerifier) Verify(header http.Header, body []byte, secret string, _ time.Time) error {
|
|
// HMAC accepts an empty key, so a sender could sign with one.
|
|
if secret == "" {
|
|
return reject("secret is empty")
|
|
}
|
|
value, ok := singleHeader(header, "X-Hub-Signature-256")
|
|
if !ok {
|
|
return reject("signature header missing or repeated")
|
|
}
|
|
digest, ok := strings.CutPrefix(value, "sha256=")
|
|
if !ok {
|
|
return reject("signature header has no sha256= prefix")
|
|
}
|
|
received, err := hex.DecodeString(digest)
|
|
if err != nil {
|
|
return reject("signature is not hex")
|
|
}
|
|
mac := hmac.New(sha256.New, []byte(secret))
|
|
_, _ = mac.Write(body)
|
|
if !hmac.Equal(received, mac.Sum(nil)) {
|
|
return reject("signature does not match")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (githubVerifier) GenerateSecret() (string, bool, error) {
|
|
return generateSecret()
|
|
}
|
|
|
|
func (githubVerifier) ValidateSecret(string) error {
|
|
return invalidSecret("coder creates the secret for this scheme")
|
|
}
|