diff --git a/.golangci.yaml b/.golangci.yaml index 2acd902..1b13fdf 100644 --- a/.golangci.yaml +++ b/.golangci.yaml @@ -21,6 +21,7 @@ linters: # deprecated - wsl - depguard + - gomodguard settings: cyclop: max-complexity: 11 @@ -75,6 +76,7 @@ linters: - mnd - goconst - varnamelen + - gocyclo path: (.+)_test\.go formatters: diff --git a/.mockery.yaml b/.mockery.yaml index 6bc26c1..5554283 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -9,5 +9,4 @@ packages: github.com/dadrus/httpsig: interfaces: NonceGetter: {} - NonceChecker: {} KeyResolver: {} diff --git a/README.md b/README.md index 423fb96..c815f63 100644 --- a/README.md +++ b/README.md @@ -1,26 +1,33 @@ [![CI](https://github.com/dadrus/httpsig/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/dadrus/httpsig/actions/workflows/ci.yml) [![Codecov](https://codecov.io/gh/dadrus/httpsig/branch/main/graph/badge.svg)](https://codecov.io/gh/dadrus/httpsig) -[![Go Report Card](https://goreportcard.com/badge/github.com/dadrus/httpsig)](https://goreportcard.com/report/github.com/dadrus/httpsig) [![Go Reference](https://pkg.go.dev/badge/github.com/dadrus/httpsig.svg)](https://pkg.go.dev/github.com/dadrus/httpsig) -## Introduction +## Introduction and Scope -`httpsig` is a library that facilitates the signing and verification of HTTP requests in compliance with the [RFC 9421 HTTP Message Signatures](https://www.rfc-editor.org/rfc/rfc9421.html) standard. +`httpsig` is a library for signing and verifying HTTP requests and responses according to [RFC 9421 (HTTP Message Signatures)](https://www.rfc-editor.org/rfc/rfc9421.html). It combines reusable signing and verification policies with support for application-specific signature requirements and signature negotiation using `Accept-Signature`. -## Standalone Signing and Verification +The `Message` abstraction keeps these capabilities independent of any particular HTTP framework. For API details and option semantics, see the [Go reference](https://pkg.go.dev/github.com/dadrus/httpsig). -To sign an HTTP request, first, create a `Signer` instance using your preferred key and signing algorithm: +## Usage + +### Standalone Signing and Verification + +The following snippets show two independent flows: signing an outgoing request and verifying a received response. They assume application-provided keys and other values; routine error handling is abbreviated. + +To sign a request, configure a `Signer` with the signing key and the HTTP components to protect: ```go -// Create a signer. -signer, err := httpsig.NewSigner( +// Configure the signing policy. +signer, err := httpsig.NewSigner( // specify a key - httpsig.Key{KeyID: "key1", Key: privKey, Algorithm: httpsig.EcdsaP256Sha256}, + httpsig.Key{Material: privKey, Algorithm: httpsig.EcdsaP256Sha256}, + // the keyid parameter for the above key + httpsig.WithKeyID("key1"), // specify the required options // duration for which the signature should be valid - httpsig.WithTTL(5 * time.Second), + httpsig.WithTTL(5 * time.Second), // which components should be protected by a signature - httpsig.WithComponents("@authority", "@method", "x-my-fancy-header"), + httpsig.WithComponents("@authority", "@method", "x-my-fancy-header"), // a tag for your specific application httpsig.WithTag("myapp"), ) @@ -29,16 +36,24 @@ signer, err := httpsig.NewSigner( // Create a request req, err := http.NewRequestWithContext(context.Background(), "GET", "https://some-url.com", nil) // error handling goes here +req.Header.Set("X-My-Fancy-Header", "example-value") + +nonce := ... // generate a nonce // Sign the request -header, err := signer.Sign(httpsig.MessageFromRequest(req)) +header, err := signer.Sign( + httpsig.MessageFromRequest(req), + // add a nonce if required + httpsig.WithParameter(httpsig.Nonce, nonce), +) // error handling goes here -// Add the signature to the request +// MessageFromRequest clones the headers; use the headers returned by Sign. req.Header = header +// send the request ``` -To verify a response, create a `Verifier` using your preferred key and signing algorithm: +To verify a response, create a `Verifier` with a `KeyResolver` that supplies trusted verification keys (see [Key Resolution](#key-resolution)). `WithValidateAllSignatures` checks every signature present in the message; use `WithRequiredTag` instead when your protocol expects particular signed tags. ```go // Receive a response from the server @@ -47,13 +62,11 @@ resp, err := client.Post("https://some-url.com", "application/json", &buf) // Create a verifier verifier, err := httpsig.NewVerifier( - // specify a key resolver to resolve the key used by the client + // specify a key resolver to resolve the key keyResolver, // specify the required options - // to detect and mitigate replay attacks - httpsig.WithNonceChecker(nonceChecker), - // which components are expected to be protected by a signature - httpsig.WithRequiredComponents("@authority", "@method", "x-my-fancy-header"), + // which response components are expected to be protected + httpsig.WithComponents("@status", "content-type"), // validity time skew httpsig.WithValidityTolerance(5 * time.Second), // how old a signature is allowed to be @@ -63,26 +76,29 @@ verifier, err := httpsig.NewVerifier( ) // error handling -// Verify the response -err := verifier.Verify(httpsig.MessageFromResponse(resp)) +// Verify the response. No partial result is returned on failure. +verified, err := verifier.Verify(httpsig.MessageFromResponse(resp)) +// Each entry in verified contains the covered components, transmitted +// signature parameters, and any metadata returned by the key resolver. + // error handling ``` -If you need to validate a signature created by a specific application (identified by a tag), use the `WithRequiredTag` option when creating the verifier. This option allows you to specify a tag along with the same options as the `NewVerifier` function. Here’s an example: +Once `Verify` succeeds, your application can inspect the `verified` object and enforce protocol-specific rules, such as nonce correlation, replay protection, and authorization. + +If a protocol requires a signature with a particular `tag`, use `WithRequiredTag`. Unlike `WithValidateAllSignatures`, tag-based verification selects signatures carrying the required tag; unrelated signatures are not verified unless all-signature verification is also enabled. For example: ```go verifier, err := httpsig.NewVerifier( // specify a key resolver to resolve the key used by the client keyResolver, // specify the required options - // to detect and mitigate replay attacks - httpsig.WithNonceChecker(nonceChecker), httpsig.WithRequiredTag( // tag of the signature "myapp", // which components are expected to be protected by a signature - httpsig.WithRequiredComponents("@authority", "@method", "x-my-fancy-header"), + httpsig.WithComponents("@authority", "@method", "x-my-fancy-header"), // validity time skew httpsig.WithValidityTolerance(5 * time.Second), // how old a signature is allowed to be @@ -91,93 +107,123 @@ verifier, err := httpsig.NewVerifier( ) // error handling goes here -err = verifier.Verify(msg) +verified, err := verifier.Verify(msg) // error handling goes here ``` -While the examples demonstrate signing a request and verifying a response, you can also verify requests and sign responses. Both the `Verifier.Verify()` and `Signer.Sign()` methods require a `Message` object, which can be created for requests and responses on both client and server sides using the following functions: +Global verifier options act as defaults for required tags. Tag-specific options take precedence (for example, `WithComponents` replaces the global component list), while required, forbidden, and expected signature-parameter constraints are additive. Automatic signature negotiation uses these effective per-tag requirements. + +The same APIs also verify incoming requests and sign outgoing responses. Both `Signer.Sign` and `Verifier.Verify` operate on a `Message`, created for the corresponding HTTP direction: -* `MessageFromRequest` - creates a `Message` from an `http.Request`. Can be used for outbound (client-side) and inbound (server-side) requests. -* `MessageFromResponse` - creates a `Message` from an `http.Response`. Can be used for inbound (client-side) responses from a server. -* `MessageForResponse` - creates a Message from an outbound (server-side) response. +* `MessageFromRequest` — outbound client requests or inbound server requests. +* `MessageFromResponse` — responses received by clients. +* `MessageForResponse` — responses produced by servers. -Both the `Signer` and `Verifier` respect the `"content-digest"` component identifier as highlighted in the [Security Considerations](https://www.rfc-editor.org/rfc/rfc9421.html#name-message-content) of the RFC. This is handled as follows: +For middleware integration, see [HTTP Frameworks](#http-frameworks). -* On the `Signer` side, if `"content-digest"` is configured to be included via the `WithComponents` option and the `WithContentDigestAlgorithm` option is not used, the implementation will calculate a message digest over the body using the `sha-256` and `sha-512` algorithms (the only supported algorithms according to [RFC 9530](https://www.rfc-editor.org/rfc/rfc9530.html)). It will then create or replace the `"Content-Digest"` header with the calculated values in addition to the signature-related headers. If the `WithContentDigestAlgorithm` option is used, the message digest will be calculated using the specified algorithm and the `"Content-Digest"` header will be created or replaced with that value. +To protect a message body, include `"content-digest"` among the covered components (see [RFC 9421's discussion of message content](https://www.rfc-editor.org/rfc/rfc9421.html#name-message-content)): -* On the `Verifier` side, verification of the corresponding hash values is done by default with no additional configuration required. If the `"Signature-Input"` header value contains a `"content-digest"` component, the implementation expects the `"Content-Digest"` header to be present and uses the supplied algorithm names and values to calculate the digest over the body and compare these values to the received ones. If the `"Content-Digest"` header is missing, references unsupported hash algorithms (only `sha-256` and `sha-512` are supported), or there is a mismatch between the calculated and provided values, the message verification will fail with an error. +* **Signing:** The `Signer` calculates the digest and creates or replaces `Content-Digest` before signing. By default, it uses both `sha-256` and `sha-512` (as defined in [RFC 9530](https://www.rfc-editor.org/rfc/rfc9530.html)); `WithContentDigestAlgorithm` selects a single algorithm. +* **Verification:** If the signature covers `content-digest`, the `Verifier` also checks the digest against the body. Verification fails if the header is missing, no supported digest is present, or any supported digest mismatches. Only `sha-256` and `sha-512` are checked. > [!IMPORTANT] > Signing or verifying `"content-digest"` requires reading the message body. Since request and response bodies may be attacker-controlled input, callers are responsible for enforcing appropriate body size limits before passing messages to this library. > > For server-side request handling, consider using `http.MaxBytesReader`; for other contexts, use `io.LimitedReader` or an equivalent mechanism. The library restores the body after reading it, so it can still be consumed by subsequent handlers, but it does not impose global body size limits on behalf of the application. -## Signature Negotiation +### Key Resolution -The library not only supports signing and verifying HTTP messages but also facilitates signature negotiation, as defined in the [RFC 9421 HTTP Message Signatures - Requesting Signatures](https://www.rfc-editor.org/rfc/rfc9421.html#name-requesting-signatures), by utilizing the `"Accept-Signature"` header. +A `Verifier` uses a `KeyResolver` to select the key for each signature. `ResolveKey` receives `SignatureInfo` before cryptographic verification, so its parameters, components, and message are still unverified. -> [!NOTE] -> While [Chapter 5.2 - Processing an Accept-Signature](https://www.rfc-editor.org/rfc/rfc9421.html#name-processing-an-accept-signat) of the RFC mandates that -> -> > ... a target message MUST have the same label ... -> -> this requirement conflicts with [Chapter 7.2.5 - Signature Labels](https://www.rfc-editor.org/rfc/rfc9421.html#name-signature-labels), which clearly states: -> -> > An intermediary is allowed to relabel an existing signature when processing the message. -> > Therefore, applications **should not** rely on specific labels being present, and applications **should not** put semantic meaning on the labels themselves. Instead, additional signature parameters can be used to convey whatever additional meaning is required to be attached to, and covered by, the signature. In particular, the `tag` parameter can be used to define an application-specific value. -> -> As a result, the current implementation does not enforce label consistency, even though you can specify them. The only reliable method to ensure effective signature negotiation is by utilizing the `tag` parameter, as also recommended in the statement above. +```go +type trustedKeys map[string]httpsig.Key + +func (keys trustedKeys) ResolveKey(_ context.Context, info httpsig.SignatureInfo) (httpsig.KeyInfo, error) { + keyID, ok := info.Parameters.KeyID() + if !ok { + return httpsig.KeyInfo{}, errors.New("missing keyid") + } + + key, ok := keys[keyID] + if !ok { + return httpsig.KeyInfo{}, errors.New("unknown key") + } -### Requesting Signatures on the Client-Side from the Server + return httpsig.KeyInfo{Key: key}, nil +} +``` + +This example looks up a previously trusted key by `keyid`. A fixed `httpsig.Key` can also serve directly as a `KeyResolver`. `KeyInfo` can carry optional application-specific `Metadata`. + +### Identity + +After `Verify` succeeds, `VerifiedSignature` provides the verified signature parameters and covered component values. The application uses these values according to its protocol to establish a principal and make authorization decisions. Signature labels are not signed and must not be used as identities. + +### Signature Negotiation + +Signature negotiation uses the `Accept-Signature` header defined in [RFC 9421](https://www.rfc-editor.org/rfc/rfc9421.html#name-requesting-signatures). A client can explicitly request a signed response; a server can derive a request for missing client signatures from its verification policy. -On the client side, you can request the server to sign the response by using the `AcceptSignatureBuilder`. This builder can be created with the `NewAcceptSignature` function, which accepts several options to specify parameters and components that you want the server to include in the response. Here’s an example: +> [!NOTE] +> [RFC 9421 §5.2](https://www.rfc-editor.org/rfc/rfc9421.html#name-processing-an-accept-signat) requires a negotiated signature to use the requested label, but [§7.2.5](https://www.rfc-editor.org/rfc/rfc9421.html#name-signature-labels) permits intermediaries to relabel signatures and warns against assigning labels application semantics. `httpsig` therefore does not enforce label consistency. Use the signed `tag` parameter to identify application-specific signatures instead. + +#### Requesting Signatures on the Client-Side from the Server + +Use `AcceptSignatureBuilder` when a client needs to request a signed response. It constructs the `Accept-Signature` header independently of any verifier policy, so the client can specify the components and parameters it expects the server to sign: ```go // create a builder (all options are optional) builder, err := httpsig.NewAcceptSignature( - // specify which key and key algorithm the server should use for signing the response - httpsig.WithExpectedKey(Key{KeyID: "foo", Algorithm: httpsig.EcdsaP256Sha256}), - // specify the NonceSource for the nonce to be added - httpsig.WithExpectedNonce(nonceSource), - // specify which label should the server use when creating the response - httpsig.WithExpectedLabel("bar"), + // request a key identifier and signing algorithm + httpsig.WithKeyID("foo"), + // specify which signature algorithm the peer should use + httpsig.WithSignatureAlgorithm(httpsig.EcdsaP256Sha256), + // request the label and covered components + httpsig.WithLabel("bar"), // specify which components should be covered by the signature - httpsig.WithExpectedComponents("@status", "content-digest;req", "content-digest"), + httpsig.WithComponents("@status", "content-digest;req", "content-digest"), // specify your content digest algorithm references httpsig.WithContentDigestAlgorithmPreferences(httpsig.AlgorithmPreference{Algorithm: httpsig.Sha256, Preference: 2}), // specify which tag the server should use - httpsig.WithExpectedTag("awesome-app"), + httpsig.WithTag("awesome-app"), // specify whether you want the created time stamp to be included - httpsig.WithExpectedCreatedTimestamp(true), + httpsig.WithCreatedTimestamp(true), // specify whether you want the expires time stamp to be included - httpsig.WithExpectedExpiresTimestamp(true), + httpsig.WithExpiresTimestamp(true), ) // error handling goes here req := ... // create your request +nonce := ... // application-generated nonce for this request -err = builder.Build(req.Context(), req.Header) +err = builder.Build(req.Context(), req.Header, httpsig.WithParameter("nonce", nonce)) // error handling goes here ``` -When the above code executes, it will add an `"Accept-Signature"` header to the request with a value like: `bar=("@status", "content-digest";req, "content-digest");keyid="foo";alg="ecdsa-p256-sha256";nonce="...";tag="awesome-app";created;expires`. +This adds an `Accept-Signature` header with a value such as: + +```http +Accept-Signature: bar=("@status" "content-digest";req "content-digest");created;expires;keyid="foo";alg="ecdsa-p256-sha256";nonce="...";tag="awesome-app" +Want-Content-Digest: sha-256=2 +``` + +The `Want-Content-Digest` header is also added because the requested signature covers `content-digest`. + +#### Requesting Signatures on the Server-Side from the Client -### Requesting Signatures on the Server-Side from the Client +On the server side, the `Verifier` can derive `Accept-Signature` requirements from its configured policy. This avoids defining component and parameter requirements separately for verification and negotiation. If a required signature, component, or parameter is missing, `Verify` returns an error wrapping `NoApplicableSignatureError`; use `errors.As` to retrieve it and call `Negotiate` to add the prepared headers to the response. An invalid cryptographic signature is still a verification failure, not a negotiation request. -Signature negotiation on the server side works differently from the client-side. Instead of using the `AcceptSignatureBuilder`, you specify the corresponding options when creating the `Verifier`. This ensures that there are no discrepancies between what the `Verifier` expects and what is included in the `"Accept-Signature"` response header if an expected signature is not present or required parameters/components are missing. Here’s an example, building on the earlier `Verifier` creation example: +For example, extending the earlier tag-based verifier: ```go verifier, err := httpsig.NewVerifier( // specify a key resolver keyResolver, // specify the required options - // to detect and mitigate replay attacks - httpsig.WithNonceChecker(nonceChecker), httpsig.WithRequiredTag( // tag of the signature "myapp", // which components are expected to be protected by a signature - httpsig.WithRequiredComponents("@authority", "@method", "x-my-fancy-header"), + httpsig.WithComponents("@authority", "@method", "x-my-fancy-header"), // validity time skew httpsig.WithValidityTolerance(5 * time.Second), // how old a signature is allowed to be @@ -185,18 +231,20 @@ verifier, err := httpsig.NewVerifier( // if there is no signature tagged "myapp", or some of the required components or parameters // are not present, request a signature from the client httpsig.WithSignatureNegotiation( - // specify which key and algorithm the client should use - httpsig.WithRequestedKey(httpsig.Key{KeyID: "key1", Algorithm: httpsig.EcdsaP256Sha256}), - // specify the source for the nonce, the client should use - httpsig.WithRequestedNonce(nonceGetter), - // specify the label for the signature, the client should use - httpsig.WithRequestedLabel("bar"), + // request a key ID and signature algorithm + httpsig.WithKeyID("key1"), + // request a signature algorithm the peer should use + httpsig.WithSignatureAlgorithm(httpsig.EcdsaP256Sha256), + // specify the source for the nonce + httpsig.WithNonceGetter(nonceGetter), + // specify the label for the signature + httpsig.WithLabel("bar"), ), ), ) // error handling goes here -err = verifier.Verify(msg) +_, err = verifier.Verify(msg) var missingSigErr *httpsig.NoApplicableSignatureError if errors.As(err, &missingSigErr) { @@ -207,5 +255,223 @@ if errors.As(err, &missingSigErr) { // further error handling ``` +For automatic negotiation, the configured `NonceGetter` runs while `Verify` prepares the `Accept-Signature` headers, before `NoApplicableSignatureError` is returned. + > [!NOTE] > The `WithSignatureNegotiation` option at the top level (outside the `WithRequiredTag` option) is mutually exclusive with the `WithValidateAllSignatures` option. However, you can still use `WithSignatureNegotiation` at the top level if you want to apply the same configuration for all expected tagged signatures, thereby simplifying your code. + +### Reusing Signers and Verifiers + +A `Signer` or `Verifier` represents a reusable signing or verification policy. Create an instance once per policy and reuse it across messages. This allows most of the configuration work to happen upfront, keeping the per-message overhead low. Message-specific values can be supplied through per-call options. + +## Protocols and Profiles + +### WIMSE Workload-to-Workload HTTP Signatures + +The [WIMSE HTTP Signatures draft](https://datatracker.ietf.org/doc/html/draft-ietf-wimse-http-signature-08) binds signed requests to Workload Identity Tokens (WITs). For an ordinary request carrying a `Workload-Identity-Token` header: + +```go +// Sender +signer, err := httpsig.NewSigner( + httpsig.Key{Material: privateKey, Algorithm: httpsig.Ed25519}, + httpsig.WithTag("wimse-workload-to-workload"), + httpsig.WithComponents("@method", "@path", "@query", "workload-identity-token"), +) + +req.Header, err = signer.Sign(httpsig.MessageFromRequest(req), + httpsig.WithParameter(httpsig.Nonce, nonce), + httpsig.WithParameter("wimse-aud", audience), +) + +// Recipient +verifier, err := httpsig.NewVerifier(witKeyResolver, + httpsig.WithRequiredTag("wimse-workload-to-workload", + httpsig.WithComponents("@method", "@path", "@query", "workload-identity-token"), + httpsig.WithRequiredParameters(httpsig.Nonce), + httpsig.WithForbiddenParameters(httpsig.KeyID, httpsig.Alg), + httpsig.WithParameter("wimse-aud", expectedAudience), + ), +) + +result, err = verifier.Verify(httpsig.MessageFromRequest(req)) +``` + +Include `content-digest` for requests with a body and cover any other headers required by the draft when present. The application validates the WIT and enforces replay rules. + +### Web Bot Auth + +The [Web Bot Auth draft](https://datatracker.ietf.org/doc/html/draft-ietf-webbotauth-httpsig-protocol-01) uses a signed `Signature-Agent` dictionary member to advertise the signer's key directory. + +```go +// Sender: the dictionary member matches the signature label. +req.Header.Set("Signature-Agent", `sig1="https://agent.example/keys.jwks"`) +signer, err := httpsig.NewSigner( + httpsig.Key{Material: privateKey, Algorithm: httpsig.Ed25519}, + httpsig.WithLabel("sig1"), + httpsig.WithTag("web-bot-auth"), + httpsig.WithKeyID(jwkThumbprint), + httpsig.WithComponents("@authority", `signature-agent;key="sig1"`), +) + +req.Header, err = signer.Sign(httpsig.MessageFromRequest(req)) + +// Recipient: resolve the covered Signature-Agent member dynamically. +verifier, err := httpsig.NewVerifier(webBotKeyResolver, + httpsig.WithRequiredTag("web-bot-auth", + httpsig.WithComponents("@authority", `signature-agent;key="sig1"`), + httpsig.WithRequiredParameters(httpsig.KeyID), + ), +) + +verified, err := verifier.Verify(httpsig.MessageFromRequest(req)) +``` + +`webBotKeyResolver` implementation needs to resolve the signing key using the `Signature-Agent` member covered by the signature. + +### AAuth + +The [AAuth Protocol draft](https://datatracker.ietf.org/doc/html/draft-hardt-oauth-aauth-protocol-11) authenticates agents using HTTP Message Signatures and a signed `Signature-Key` header containing key information. + +```go +// Agent +req.Header.Set("Signature-Key", `sig=jwt;jwt="`+agentToken+`"`) +signer, err := httpsig.NewSigner( + httpsig.Key{Material: privateKey, Algorithm: httpsig.Ed25519}, + httpsig.WithLabel("sig"), + httpsig.WithTTL(0), + httpsig.WithComponents("@method", "@authority", "@path", "signature-key"), +) +req.Header, err = signer.Sign(httpsig.MessageFromRequest(req)) + +// Resource server +verifier, err := httpsig.NewVerifier(aauthKeyResolver, + httpsig.WithValidateAllSignatures(), + httpsig.WithComponents("@method", "@authority", "@path", "signature-key"), + httpsig.WithExpiresTimestamp(false), + httpsig.WithMaxAge(time.Minute), +) +_, err = verifier.Verify(httpsig.MessageFromRequest(req)) +``` + +`aauthKeyResolver` validates the agent token and resolves its signing key via `Signature-Key`. For requests with bodies to person or access servers and revocation endpoints, also cover `content-digest` and `content-type`. + +### OAuth Proof-of-Possession Tokens + +The [OAuth HTTP Signature PoP draft](https://datatracker.ietf.org/doc/html/draft-richer-oauth-httpsig-03) binds access tokens to signing keys. For a resource request carrying an `Authorization` header: + +```go +// Client +signer, err := httpsig.NewSigner( + httpsig.Key{Material: privateKey, Algorithm: httpsig.Ed25519}, + httpsig.WithTag("httpsig-oauth"), + httpsig.WithTTL(0), + httpsig.WithComponents("@method", "@target-uri", "authorization"), +) + +req.Header, err = signer.Sign(httpsig.MessageFromRequest(req), + httpsig.WithParameter(httpsig.Nonce, nonce), +) + +// Resource server +verifier, err := httpsig.NewVerifier(tokenBoundKeyResolver, + httpsig.WithRequiredTag("httpsig-oauth", + httpsig.WithComponents("@method", "@target-uri", "authorization"), + httpsig.WithExpiresTimestamp(false), + httpsig.WithRequiredParameters(httpsig.Nonce), + httpsig.WithForbiddenParameters(httpsig.KeyID, httpsig.Alg, "pub"), + ), +) + +_, err = verifier.Verify(httpsig.MessageFromRequest(req)) +``` + +The resource server validates the access token, supplies its bound key through `KeyResolver`, and checks nonce reuse. For requests with bodies, also cover `content-digest`. When verifying `@target-uri` on incoming requests, use the externally visible absolute URL, reconstructed from trusted server or proxy configuration. + +## HTTP Frameworks + +The examples below verify incoming requests. The same signing, verification, and signature negotiation APIs can be used in client middleware and for responses as well. + +**net/http** + +```go +http.Handle("/api", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + result, err := verifier.Verify(httpsig.MessageFromRequest(r)) + if err != nil { + http.Error(w, "Unauthorized", http.StatusUnauthorized) + + return + } + + // establish a principal from the result object + // and propagate it downstream + + handler.ServeHTTP(w, r) +})) +``` + +**Gin** + +```go +router.Use(func(c *gin.Context) { + result, err := verifier.Verify(httpsig.MessageFromRequest(c.Request)) + if err != nil { + c.AbortWithStatus(http.StatusUnauthorized) + + return + } + + // establish a principal from the result object + // and propagate it downstream + + c.Next() +}) +``` + +**Fiber v3 (`fasthttp`)** + +```go +app.Use(func(c fiber.Ctx) error { + targetURL, err := url.Parse(c.FullURL()) + if err != nil { + return err + } + + headers := make(http.Header) + for name, values := range c.GetReqHeaders() { + for _, value := range values { + headers.Add(name, value) + } + } + + msg := &httpsig.Message{ + Context: c.Context(), + Method: c.Method(), + Authority: c.Host(), + URL: targetURL, + Header: headers, + Body: func() (io.ReadCloser, error) { + return io.NopCloser(bytes.NewReader(c.BodyRaw())), nil + }, + IsRequest: true, + } + + result, err := verifier.Verify(msg) + if err != nil { + return c.SendStatus(fiber.StatusUnauthorized) + } + + // establish a principal from the result object + // and propagate it downstream + + return c.Next() +}) +``` + +## Security Considerations + +* **Coverage:** Require the components your application relies on. For messages with bodies, sign and verify `content-digest` when body integrity matters. +* **Key trust:** `KeyResolver` receives unverified message data. Select and validate keys according to your application protocol. +* **Replay:** Enforce the required nonce checks after successful signature verification. +* **Multiple signatures:** Labels are not signed, and `VerificationResult` has no defined order. Choose the required tags or validate all signatures as appropriate. + +See [RFC 9421 Security Considerations](https://www.rfc-editor.org/rfc/rfc9421.html#section-7). diff --git a/accept_signature_builder.go b/accept_signature_builder.go index 2028032..c1376eb 100644 --- a/accept_signature_builder.go +++ b/accept_signature_builder.go @@ -8,123 +8,45 @@ import ( "github.com/dunglas/httpsfv" ) -type AcceptSignatureOption func(*AcceptSignatureBuilder) error - -func WithExpectedKey(key Key) AcceptSignatureOption { - return func(asb *AcceptSignatureBuilder) error { - asb.keyID = key.KeyID - asb.keyAlgorithm = key.Algorithm - - return nil - } -} - -func WithExpectedNonce(ng NonceGetter) AcceptSignatureOption { - return func(asb *AcceptSignatureBuilder) error { - if ng != nil { - asb.nonceGetter = ng - } - - return nil - } -} - -func WithExpectedLabel(label string) AcceptSignatureOption { - return func(asb *AcceptSignatureBuilder) error { - if len(label) != 0 { - asb.label = label - } - - return nil - } -} - -func WithExpectedComponents(identifiers ...string) AcceptSignatureOption { - return func(asb *AcceptSignatureBuilder) error { - identifiers, err := toComponentIdentifiers(identifiers) - if err != nil { - return err - } - - asb.setIdentifiers(identifiers) - - return nil - } -} - -func WithContentDigestAlgorithmPreferences(prefs ...AlgorithmPreference) AcceptSignatureOption { - return func(asb *AcceptSignatureBuilder) error { - if len(prefs) == 0 { - return nil - } - - algPrefs := make([]string, len(prefs)) - - for i, pref := range prefs { - if pref.Algorithm == "" { - return fmt.Errorf("%w: digest algorithm preference requires a non-empty algorithm", ErrParameter) - } - - algPrefs[i] = pref.String() - } - - asb.cdAlgPrefs = algPrefs - - return nil - } -} - -func WithExpectedTag(tag string) AcceptSignatureOption { - return func(asb *AcceptSignatureBuilder) error { - asb.tag = tag - - return nil - } -} - -func WithExpectedCreatedTimestamp(flag bool) AcceptSignatureOption { - return func(asb *AcceptSignatureBuilder) error { - asb.addCreatedTS = flag - - return nil - } -} - -func WithExpectedExpiresTimestamp(flag bool) AcceptSignatureOption { - return func(asb *AcceptSignatureBuilder) error { - asb.addExpiresTS = flag - - return nil - } -} - +// AlgorithmPreference associates a Content-Digest algorithm with a numeric +// preference value for the Want-Content-Digest header. type AlgorithmPreference struct { - Algorithm DigestAlgorithm + // Algorithm is the desired digest algorithm. + Algorithm DigestAlgorithm + // Preference is the preference value serialized alongside the algorithm. Preference int } +// String formats the preference as "algorithm=preference". func (p AlgorithmPreference) String() string { return fmt.Sprintf("%s=%d", p.Algorithm, p.Preference) } +// AcceptSignatureBuilder constructs an Accept-Signature request from the +// configured parameters and component requirements. Use NewAcceptSignature +// to create a builder with defaults, then call Build to add headers. type AcceptSignatureBuilder struct { - keyAlgorithm SignatureAlgorithm - keyID string - nonceGetter NonceGetter - label string - identifiers []*componentIdentifier - cdAlgPrefs []string - tag string - addCreatedTS bool - addExpiresTS bool - wantContentDigest bool + signatureAlgorithm SignatureAlgorithm + keyID string + nonceGetter NonceGetter + label string + identifiers []*componentIdentifier + parameters []parameterOption + cdAlgPrefs []string + tag string + addCreatedTS bool + addExpiresTS bool + wantContentDigest bool } +// NewAcceptSignature creates an AcceptSignatureBuilder for requesting a +// signature from a peer. By default, it uses label "sig", requests created +// and expires parameters, and does not request a nonce. If Content-Digest +// is requested, the default digest preferences are SHA-256 and SHA-512. func NewAcceptSignature(opts ...AcceptSignatureOption) (*AcceptSignatureBuilder, error) { asb := &AcceptSignatureBuilder{ addCreatedTS: true, addExpiresTS: true, - nonceGetter: nonceGetter{}, label: "sig", cdAlgPrefs: []string{ AlgorithmPreference{Algorithm: Sha256, Preference: 5}.String(), //nolint: mnd @@ -133,7 +55,7 @@ func NewAcceptSignature(opts ...AcceptSignatureOption) (*AcceptSignatureBuilder, } for _, opt := range opts { - if err := opt(asb); err != nil { + if err := opt.applyAcceptSignatureOption(asb); err != nil { return nil, err } } @@ -141,10 +63,35 @@ func NewAcceptSignature(opts ...AcceptSignatureOption) (*AcceptSignatureBuilder, return asb, nil } -func (asb *AcceptSignatureBuilder) Build(ctx context.Context, header http.Header) error { - nonce, err := asb.nonceGetter.GetNonce(ctx) - if err != nil { - return err +// Build appends an Accept-Signature header to header using the configured +// signature requirements. If Content-Digest is requested, it also appends +// Want-Content-Digest preferences. Additional extension parameters can be +// supplied with WithParameter. A non-empty nonce may be provided for this +// call with WithParameter("nonce", value), overriding a configured +// WithNonceGetter without invoking it. Otherwise, the configured getter is +// used if present; if neither is provided, no nonce is requested. Options +// do not modify the builder. The caller must provide a writable, non-nil +// http.Header. +func (asb *AcceptSignatureBuilder) Build( + ctx context.Context, + header http.Header, + opts ...AcceptSignatureBuildOption, +) error { + callOptions := acceptSignatureBuildOptions{staticParameters: asb.parameters} + for _, opt := range opts { + if err := opt.applyAcceptSignatureBuildOption(&callOptions); err != nil { + return err + } + } + + nonce := callOptions.nonce + if !callOptions.nonceSet && asb.nonceGetter != nil { + var err error + + nonce, err = asb.nonceGetter.GetNonce(ctx) + if err != nil { + return err + } } sigReqs := newSignatureRequirements( @@ -153,9 +100,17 @@ func (asb *AcceptSignatureBuilder) Build(ctx context.Context, header http.Header asb.tag, nonce, asb.keyID, - asb.keyAlgorithm, + asb.signatureAlgorithm, asb.identifiers) + for _, param := range asb.parameters { + sigReqs.Params.Add(string(param.name), param.value) + } + + for _, param := range callOptions.parameters { + sigReqs.Params.Add(string(param.name), param.value) + } + dict := httpsfv.NewDictionary() dict.Add(asb.label, sigReqs.InnerList) diff --git a/accept_signature_builder_test.go b/accept_signature_builder_test.go index 5f14625..5e01022 100644 --- a/accept_signature_builder_test.go +++ b/accept_signature_builder_test.go @@ -10,243 +10,14 @@ import ( "github.com/stretchr/testify/require" ) -func TestWithExpectedKey(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - key Key - expKeyID string - expKeyAlg SignatureAlgorithm - }{ - {uc: "no actual data provided"}, - {uc: "only KeyID provided", key: Key{KeyID: "test"}, expKeyID: "test"}, - {uc: "only KeyAlg provided", key: Key{Algorithm: RsaPssSha512}, expKeyAlg: RsaPssSha512}, - {uc: "KeyID and KeyAlg provided", key: Key{KeyID: "foo", Algorithm: EcdsaP256Sha256}, expKeyID: "foo", expKeyAlg: EcdsaP256Sha256}, - } { - t.Run(tc.uc, func(t *testing.T) { - asb := &AcceptSignatureBuilder{} - - err := WithExpectedKey(tc.key)(asb) - - require.NoError(t, err) - assert.Equal(t, tc.expKeyID, asb.keyID) - assert.Equal(t, tc.expKeyAlg, asb.keyAlgorithm) - }) - } -} - -func TestWithExpectedNonce(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - ng NonceGetter - exp NonceGetter - }{ - {uc: "nil NonceGetter", exp: nonceGetter{}}, - {uc: "custom NonceGetter", ng: &NonceGetterMock{}, exp: &NonceGetterMock{}}, - } { - t.Run(tc.uc, func(t *testing.T) { - asb := &AcceptSignatureBuilder{nonceGetter: nonceGetter{}} - - err := WithExpectedNonce(tc.ng)(asb) - - require.NoError(t, err) - assert.Equal(t, tc.exp, asb.nonceGetter) - }) - } -} - -func TestWithExpectedLabel(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - label string - exp string - }{ - {uc: "empty label", exp: "foo"}, - {uc: "custom label", label: "bar", exp: "bar"}, - } { - t.Run(tc.uc, func(t *testing.T) { - asb := &AcceptSignatureBuilder{label: "foo"} - - err := WithExpectedLabel(tc.label)(asb) - - require.NoError(t, err) - assert.Equal(t, tc.exp, asb.label) - }) - } -} - -func TestWithExpectedComponents(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - identifiers []string - assert func(t *testing.T, err error, asb *AcceptSignatureBuilder) - }{ - { - uc: "no identifiers provided", - assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { - t.Helper() - - require.NoError(t, err) - assert.False(t, asb.wantContentDigest) - assert.Empty(t, asb.identifiers) - }, - }, - { - uc: "invalid identifiers provided", - identifiers: []string{"@foo"}, - assert: func(t *testing.T, err error, _ *AcceptSignatureBuilder) { - t.Helper() - - require.Error(t, err) - require.ErrorIs(t, err, ErrUnsupportedComponentIdentifier) - }, - }, - { - uc: "valid identifiers without content-digest", - identifiers: []string{"@status", "x-foo-bar"}, - assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { - t.Helper() - - require.NoError(t, err) - assert.False(t, asb.wantContentDigest) - assert.Len(t, asb.identifiers, 2) - assert.Equal(t, "@status", asb.identifiers[0].Value) - assert.Equal(t, "x-foo-bar", asb.identifiers[1].Value) - }, - }, - { - uc: "valid identifiers with content-digest", - identifiers: []string{"@status", "content-digest", "x-foo-bar"}, - assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { - t.Helper() - - require.NoError(t, err) - assert.True(t, asb.wantContentDigest) - assert.Len(t, asb.identifiers, 3) - assert.Equal(t, "@status", asb.identifiers[0].Value) - assert.Equal(t, "content-digest", asb.identifiers[1].Value) - assert.Equal(t, "x-foo-bar", asb.identifiers[2].Value) - }, - }, - } { - t.Run(tc.uc, func(t *testing.T) { - asb := &AcceptSignatureBuilder{label: "foo"} - - err := WithExpectedComponents(tc.identifiers...)(asb) - - tc.assert(t, err, asb) - }) - } -} - -func TestWithContentDigestAlgorithmPreferences(t *testing.T) { - t.Parallel() - - defaultPreference := AlgorithmPreference{Algorithm: Sha256, Preference: 2}.String() - - for _, tc := range []struct { - uc string - prefs []AlgorithmPreference - expErr error - expPrefs []string - }{ - { - uc: "no preferences provided", - expPrefs: []string{defaultPreference}, - }, - { - uc: "no algorithm provided in a preference", - prefs: []AlgorithmPreference{{Sha256, 0}, {DigestAlgorithm(""), 0}}, - expErr: ErrParameter, - expPrefs: []string{defaultPreference}, - }, - { - uc: "valid options provided", - prefs: []AlgorithmPreference{{Sha512, 0}, {Sha256, 1}}, - expPrefs: []string{ - AlgorithmPreference{Sha512, 0}.String(), - AlgorithmPreference{Sha256, 1}.String(), - }, - }, - } { - t.Run(tc.uc, func(t *testing.T) { - asb := &AcceptSignatureBuilder{ - cdAlgPrefs: []string{defaultPreference}, - } - - err := WithContentDigestAlgorithmPreferences(tc.prefs...)(asb) - - if tc.expErr != nil { - require.Error(t, err) - require.ErrorIs(t, err, tc.expErr) - } else { - require.NoError(t, err) - require.ElementsMatch(t, asb.cdAlgPrefs, tc.expPrefs) - } - }) - } -} - -func TestWithExpectedTag(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - tag string - }{ - {uc: "empty tag"}, - {uc: "custom tag", tag: "foo"}, - } { - t.Run(tc.uc, func(t *testing.T) { - asb := &AcceptSignatureBuilder{} - - err := WithExpectedTag(tc.tag)(asb) - - require.NoError(t, err) - assert.Equal(t, tc.tag, asb.tag) - }) - } -} - -func TestWithExpectedCreatedTimestamp(t *testing.T) { - t.Parallel() - - asb := &AcceptSignatureBuilder{addCreatedTS: true} - - err := WithExpectedCreatedTimestamp(false)(asb) - - require.NoError(t, err) - assert.False(t, asb.addCreatedTS) -} - -func TestWithExpectedExpiresTimestamp(t *testing.T) { - t.Parallel() - - asb := &AcceptSignatureBuilder{addExpiresTS: true} - - err := WithExpectedExpiresTimestamp(false)(asb) - - require.NoError(t, err) - assert.False(t, asb.addExpiresTS) -} - func TestNewAcceptedSignature(t *testing.T) { t.Parallel() - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { opts []AcceptSignatureOption assert func(t *testing.T, err error, asb *AcceptSignatureBuilder) }{ - { - uc: "no options provided", + "no options provided": { assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { t.Helper() @@ -255,10 +26,11 @@ func TestNewAcceptedSignature(t *testing.T) { assert.Empty(t, asb.identifiers) assert.Empty(t, asb.tag) assert.Empty(t, asb.keyID) - assert.Empty(t, asb.keyAlgorithm) + assert.Empty(t, asb.signatureAlgorithm) assert.True(t, asb.addCreatedTS) assert.True(t, asb.addExpiresTS) - assert.Equal(t, nonceGetter{}, asb.nonceGetter) + assert.Nil(t, asb.nonceGetter) + assert.Empty(t, asb.parameters) assert.Equal(t, "sig", asb.label) assert.ElementsMatch(t, asb.cdAlgPrefs, []string{ AlgorithmPreference{Algorithm: Sha256, Preference: 5}.String(), @@ -266,17 +38,18 @@ func TestNewAcceptedSignature(t *testing.T) { }) }, }, - { - uc: "all possible options provided", + "all possible options provided": { opts: []AcceptSignatureOption{ - WithExpectedKey(Key{KeyID: "test", Algorithm: EcdsaP256Sha256}), - WithExpectedNonce(&NonceGetterMock{}), - WithExpectedLabel("foo"), - WithExpectedComponents("@status", "content-digest;req"), + WithSignatureAlgorithm(EcdsaP256Sha256), + WithKeyID("test"), + WithNonceGetter(&NonceGetterMock{}), + WithLabel("foo"), + WithComponents("@status", "content-digest;req"), WithContentDigestAlgorithmPreferences(AlgorithmPreference{Sha512, 10}), - WithExpectedTag("bar"), - WithExpectedCreatedTimestamp(false), - WithExpectedExpiresTimestamp(false), + WithTag("bar"), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), + WithParameter("audience", "service-a"), }, assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { t.Helper() @@ -288,20 +61,31 @@ func TestNewAcceptedSignature(t *testing.T) { assert.Equal(t, "content-digest", asb.identifiers[1].Value) assert.Equal(t, "bar", asb.tag) assert.Equal(t, "test", asb.keyID) - assert.Equal(t, EcdsaP256Sha256, asb.keyAlgorithm) + assert.Equal(t, EcdsaP256Sha256, asb.signatureAlgorithm) assert.False(t, asb.addCreatedTS) assert.False(t, asb.addExpiresTS) assert.Equal(t, &NonceGetterMock{}, asb.nonceGetter) assert.Equal(t, "foo", asb.label) + assert.Equal(t, []parameterOption{{name: "audience", value: "service-a"}}, asb.parameters) assert.ElementsMatch(t, asb.cdAlgPrefs, []string{ AlgorithmPreference{Algorithm: Sha512, Preference: 10}.String(), }) }, }, - { - uc: "option raises error", + "invalid extension parameter": { + opts: []AcceptSignatureOption{ + WithParameter("keyid", "reserved"), + }, + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() + + require.ErrorIs(t, err, ErrParameter) + assert.Nil(t, asb) + }, + }, + "option raises error": { opts: []AcceptSignatureOption{ - WithExpectedComponents("@foo"), + WithComponents("@foo"), }, assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { t.Helper() @@ -312,7 +96,7 @@ func TestNewAcceptedSignature(t *testing.T) { }, }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { builder, err := NewAcceptSignature(tc.opts...) tc.assert(t, err, builder) @@ -323,15 +107,161 @@ func TestNewAcceptedSignature(t *testing.T) { func TestAcceptSignatureBuilderBuild(t *testing.T) { t.Parallel() - for _, tc := range []struct { - uc string - opts []AcceptSignatureOption - assert func(t *testing.T, err error, hdr http.Header) + for uc, tc := range map[string]struct { + opts []AcceptSignatureOption + buildOpts []AcceptSignatureBuildOption + assert func(t *testing.T, err error, hdr http.Header) }{ - { - uc: "failing getting the nonce", + "no nonce by default": { + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires`, hdr.Get(headerAcceptSignature)) + }, + }, + "explicit nonce at Build": { + buildOpts: []AcceptSignatureBuildOption{ + WithParameter("nonce", "request-nonce"), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;nonce="request-nonce"`, hdr.Get(headerAcceptSignature)) + }, + }, + "explicit nonce overrides getter": { + opts: []AcceptSignatureOption{ + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { + return "", errors.New("getter must not be called") + })), + }, + buildOpts: []AcceptSignatureBuildOption{WithParameter("nonce", "requested")}, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;nonce="requested"`, hdr.Get(headerAcceptSignature)) + }, + }, + "empty nonce returned by getter is omitted": { opts: []AcceptSignatureOption{ - WithExpectedNonce(NonceGetterFunc(func(_ context.Context) (string, error) { + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "", nil })), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires`, hdr.Get(headerAcceptSignature)) + }, + }, + "non-string nonce in Build": { + buildOpts: []AcceptSignatureBuildOption{WithParameter("nonce", Token("wrong-type"))}, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, hdr) + }, + }, + "empty nonce in Build": { + buildOpts: []AcceptSignatureBuildOption{ + WithParameter("nonce", ""), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, hdr) + }, + }, + "invalid structured field string for nonce": { + buildOpts: []AcceptSignatureBuildOption{ + WithParameter("nonce", "bad\nvalue"), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, hdr) + }, + }, + "duplicate nonce in Build": { + buildOpts: []AcceptSignatureBuildOption{ + WithParameter("nonce", "first"), + WithParameter("nonce", "second"), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, hdr) + }, + }, + "additional extension at Build": { + buildOpts: []AcceptSignatureBuildOption{ + WithParameter("other", "value"), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;other="value"`, hdr.Get(headerAcceptSignature)) + }, + }, + "static and dynamic extensions": { + opts: []AcceptSignatureOption{ + WithParameter("audience", "service-a"), + WithParameter("flag", true), + }, + buildOpts: []AcceptSignatureBuildOption{WithParameter("challenge", Token("example"))}, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;audience="service-a";flag;challenge=example`, hdr.Get(headerAcceptSignature)) + }, + }, + "extension types": { + opts: []AcceptSignatureOption{ + WithParameter("integer", 42), + WithParameter("decimal", 1.5), + WithParameter("bytes", []byte("hello")), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;integer=42;decimal=1.5;bytes=:aGVsbG8=:`, hdr.Get(headerAcceptSignature)) + }, + }, + "conflicting static and dynamic extension": { + opts: []AcceptSignatureOption{ + WithParameter("audience", "static"), + }, + buildOpts: []AcceptSignatureBuildOption{ + WithParameter("audience", "dynamic"), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, hdr) + }, + }, + "duplicate extension at Build": { + buildOpts: []AcceptSignatureBuildOption{ + WithParameter("audience", "first"), + WithParameter("audience", "second"), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, hdr) + }, + }, + "invalid extension at Build": { + buildOpts: []AcceptSignatureBuildOption{ + WithParameter("other", "bad\nvalue"), + }, + assert: func(t *testing.T, err error, hdr http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, hdr) + }, + }, + "failing getting the nonce": { + opts: []AcceptSignatureOption{ + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "", errors.New("test error") })), }, @@ -342,14 +272,14 @@ func TestAcceptSignatureBuilderBuild(t *testing.T) { require.Contains(t, err.Error(), "test error") }, }, - { - uc: "Accept-Signature only is added", + "Accept-Signature only is added": { opts: []AcceptSignatureOption{ - WithExpectedKey(Key{KeyID: "test", Algorithm: EcdsaP256Sha256}), - WithExpectedComponents("@status", "x-foo-bar;req", "@method"), - WithExpectedLabel("foo"), - WithExpectedTag("bar"), - WithExpectedNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), + WithSignatureAlgorithm(EcdsaP256Sha256), + WithKeyID("test"), + WithComponents("@status", "x-foo-bar;req", "@method"), + WithLabel("foo"), + WithTag("bar"), + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), }, assert: func(t *testing.T, err error, hdr http.Header) { t.Helper() @@ -363,14 +293,14 @@ func TestAcceptSignatureBuilderBuild(t *testing.T) { assert.Empty(t, hdr.Values(headerWantContentDigest)) }, }, - { - uc: "Accept-Signature and Want-Content-Digest headers are added with default algorithms", + "Accept-Signature and Want-Content-Digest headers are added with default algorithms": { opts: []AcceptSignatureOption{ - WithExpectedKey(Key{KeyID: "test", Algorithm: EcdsaP256Sha256}), - WithExpectedComponents("@status", "content-digest", "@method"), - WithExpectedLabel("foo"), - WithExpectedTag("bar"), - WithExpectedNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), + WithSignatureAlgorithm(EcdsaP256Sha256), + WithKeyID("test"), + WithComponents("@status", "content-digest", "@method"), + WithLabel("foo"), + WithTag("bar"), + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), }, assert: func(t *testing.T, err error, hdr http.Header) { t.Helper() @@ -386,14 +316,14 @@ func TestAcceptSignatureBuilderBuild(t *testing.T) { assert.ElementsMatch(t, values, []string{"sha-256=5", "sha-512=10"}) }, }, - { - uc: "Accept-Signature and Want-Content-Digest headers are added with supplied algorithms", + "Accept-Signature and Want-Content-Digest headers are added with supplied algorithms": { opts: []AcceptSignatureOption{ - WithExpectedKey(Key{KeyID: "test", Algorithm: EcdsaP256Sha256}), - WithExpectedComponents("@status", "content-digest", "@method"), - WithExpectedLabel("foo"), - WithExpectedTag("bar"), - WithExpectedNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), + WithSignatureAlgorithm(EcdsaP256Sha256), + WithKeyID("test"), + WithComponents("@status", "content-digest", "@method"), + WithLabel("foo"), + WithTag("bar"), + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), WithContentDigestAlgorithmPreferences(AlgorithmPreference{Sha512, 1}), }, assert: func(t *testing.T, err error, hdr http.Header) { @@ -411,15 +341,69 @@ func TestAcceptSignatureBuilderBuild(t *testing.T) { }, }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { hdr := make(http.Header) builder, err := NewAcceptSignature(tc.opts...) require.NoError(t, err) - err = builder.Build(context.TODO(), hdr) + err = builder.Build(context.TODO(), hdr, tc.buildOpts...) tc.assert(t, err, hdr) }) } + + t.Run("per-call nonce is not retained", func(t *testing.T) { + calls := 0 + builder, err := NewAcceptSignature(WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { + calls++ + + return "generated", nil + }))) + require.NoError(t, err) + + first := make(http.Header) + err = builder.Build(context.TODO(), first, WithParameter("nonce", "explicit")) + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;nonce="explicit"`, first.Get(headerAcceptSignature)) + assert.Zero(t, calls) + + second := make(http.Header) + err = builder.Build(context.TODO(), second) + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;nonce="generated"`, second.Get(headerAcceptSignature)) + assert.Equal(t, 1, calls) + }) + + t.Run("per-call extension is not retained", func(t *testing.T) { + builder, err := NewAcceptSignature(WithParameter("audience", "service-a")) + require.NoError(t, err) + + first := make(http.Header) + err = builder.Build(context.TODO(), first, WithParameter("challenge", "first")) + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;audience="service-a";challenge="first"`, first.Get(headerAcceptSignature)) + + second := make(http.Header) + err = builder.Build(context.TODO(), second, WithParameter("challenge", "second")) + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;audience="service-a";challenge="second"`, second.Get(headerAcceptSignature)) + + third := make(http.Header) + err = builder.Build(context.TODO(), third) + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;audience="service-a"`, third.Get(headerAcceptSignature)) + }) + + t.Run("static byte sequence is not affected by caller mutation", func(t *testing.T) { + value := []byte("before") + builder, err := NewAcceptSignature(WithParameter("bytes", value)) + require.NoError(t, err) + + value[0] = 'X' + hdr := make(http.Header) + err = builder.Build(context.TODO(), hdr) + require.NoError(t, err) + assert.Equal(t, `sig=();created;expires;bytes=:YmVmb3Jl:`, hdr.Get(headerAcceptSignature)) + }) } diff --git a/asymmetric.go b/asymmetric.go index c6aa4d6..9b82b7c 100644 --- a/asymmetric.go +++ b/asymmetric.go @@ -1,6 +1,7 @@ package httpsig import ( + "context" "crypto" "crypto/ecdsa" "crypto/ed25519" @@ -8,10 +9,9 @@ import ( "crypto/rsa" "fmt" "math/big" - "slices" ) -func newECDSASigner(privateKey *ecdsa.PrivateKey, kid string, alg SignatureAlgorithm) (*ecdsaSigner, error) { +func newECDSASigner(privateKey *ecdsa.PrivateKey, alg SignatureAlgorithm) (*ecdsaSigner, error) { var ( expectedBitSize int hash crypto.Hash @@ -42,25 +42,17 @@ func newECDSASigner(privateKey *ecdsa.PrivateKey, kid string, alg SignatureAlgor } return &ecdsaSigner{ - alg: alg, privateKey: privateKey, - kid: kid, hash: hash, }, nil } type ecdsaSigner struct { - alg SignatureAlgorithm privateKey *ecdsa.PrivateKey - kid string hash crypto.Hash } -func (ecs *ecdsaSigner) keyID() string { return ecs.kid } - -func (ecs *ecdsaSigner) algorithm() SignatureAlgorithm { return ecs.alg } - -func (ecs *ecdsaSigner) signPayload(payload []byte) ([]byte, error) { +func (ecs *ecdsaSigner) sign(_ context.Context, payload []byte) ([]byte, error) { hasher := ecs.hash.New() // According to documentation, Write() on hash never fails _, _ = hasher.Write(payload) @@ -78,21 +70,15 @@ func (ecs *ecdsaSigner) signPayload(payload []byte) ([]byte, error) { keyBytes++ } - // We serialize the outputs (r and s) into big-endian byte arrays and pad - // them with zeros on the left to make sure the sizes work out. Both arrays - // must be keyBytes long, and the output must be 2*keyBytes long. - rBytes := r.Bytes() - rBytesPadded := make([]byte, keyBytes) - copy(rBytesPadded[keyBytes-len(rBytes):], rBytes) - - sBytes := s.Bytes() - sBytesPadded := make([]byte, keyBytes) - copy(sBytesPadded[keyBytes-len(sBytes):], sBytes) + // Encode r and s as fixed-width, zero-padded, big-endian integers. + signature := make([]byte, 2*keyBytes) //nolint:mnd + r.FillBytes(signature[:keyBytes]) + s.FillBytes(signature[keyBytes:]) - return slices.Concat(rBytesPadded, sBytesPadded), nil + return signature, nil } -func newRSASigner(privateKey *rsa.PrivateKey, kid string, alg SignatureAlgorithm) (*rsaSigner, error) { +func newRSASigner(privateKey *rsa.PrivateKey, alg SignatureAlgorithm) (*rsaSigner, error) { var hash crypto.Hash switch alg { @@ -114,22 +100,16 @@ func newRSASigner(privateKey *rsa.PrivateKey, kid string, alg SignatureAlgorithm alg: alg, hash: hash, privateKey: privateKey, - kid: kid, }, nil } type rsaSigner struct { alg SignatureAlgorithm privateKey *rsa.PrivateKey - kid string hash crypto.Hash } -func (s *rsaSigner) keyID() string { return s.kid } - -func (s *rsaSigner) algorithm() SignatureAlgorithm { return s.alg } - -func (s *rsaSigner) signPayload(payload []byte) ([]byte, error) { +func (s *rsaSigner) sign(_ context.Context, payload []byte) ([]byte, error) { var ( out []byte err error @@ -158,7 +138,7 @@ func (s *rsaSigner) signPayload(payload []byte) ([]byte, error) { return out, nil } -func newEd25519Signer(privateKey ed25519.PrivateKey, kid string, alg SignatureAlgorithm) (*ed25519Signer, error) { +func newEd25519Signer(privateKey ed25519.PrivateKey, alg SignatureAlgorithm) (*ed25519Signer, error) { if alg != Ed25519 { return nil, fmt.Errorf("%w: %s", ErrUnsupportedAlgorithm, alg) } @@ -172,27 +152,19 @@ func newEd25519Signer(privateKey ed25519.PrivateKey, kid string, alg SignatureAl } return &ed25519Signer{ - alg: alg, privateKey: privateKey, - kid: kid, }, nil } type ed25519Signer struct { - alg SignatureAlgorithm privateKey ed25519.PrivateKey - kid string } -func (s *ed25519Signer) keyID() string { return s.kid } - -func (s *ed25519Signer) algorithm() SignatureAlgorithm { return s.alg } - -func (s *ed25519Signer) signPayload(payload []byte) ([]byte, error) { +func (s *ed25519Signer) sign(_ context.Context, payload []byte) ([]byte, error) { return ed25519.Sign(s.privateKey, payload), nil } -func newECDSAVerifier(publicKey *ecdsa.PublicKey, keyID string, alg SignatureAlgorithm) (*ecdsaVerifier, error) { +func newECDSAVerifier(publicKey *ecdsa.PublicKey, alg SignatureAlgorithm) (*ecdsaVerifier, error) { var ( expectedBitSize int hash crypto.Hash @@ -223,25 +195,17 @@ func newECDSAVerifier(publicKey *ecdsa.PublicKey, keyID string, alg SignatureAlg } return &ecdsaVerifier{ - alg: alg, publicKey: publicKey, - kid: keyID, hash: hash, }, nil } type ecdsaVerifier struct { publicKey *ecdsa.PublicKey - alg SignatureAlgorithm - kid string hash crypto.Hash } -func (v *ecdsaVerifier) keyID() string { return v.kid } - -func (v *ecdsaVerifier) algorithm() SignatureAlgorithm { return v.alg } - -func (v *ecdsaVerifier) verifyPayload(payload []byte, signature []byte) error { +func (v *ecdsaVerifier) verify(_ context.Context, payload []byte, signature []byte) error { hasher := v.hash.New() // According to documentation, Write() on hash never fails _, _ = hasher.Write(payload) @@ -269,7 +233,7 @@ func (v *ecdsaVerifier) verifyPayload(payload []byte, signature []byte) error { return nil } -func newRSAVerifier(publicKey *rsa.PublicKey, kid string, alg SignatureAlgorithm) (*rsaVerifier, error) { +func newRSAVerifier(publicKey *rsa.PublicKey, alg SignatureAlgorithm) (*rsaVerifier, error) { var hash crypto.Hash switch alg { @@ -291,22 +255,16 @@ func newRSAVerifier(publicKey *rsa.PublicKey, kid string, alg SignatureAlgorithm alg: alg, hash: hash, publicKey: publicKey, - kid: kid, }, nil } type rsaVerifier struct { publicKey *rsa.PublicKey alg SignatureAlgorithm - kid string hash crypto.Hash } -func (v *rsaVerifier) keyID() string { return v.kid } - -func (v *rsaVerifier) algorithm() SignatureAlgorithm { return v.alg } - -func (v *rsaVerifier) verifyPayload(payload []byte, signature []byte) error { +func (v *rsaVerifier) verify(_ context.Context, payload []byte, signature []byte) error { hasher := v.hash.New() // According to documentation, Write() on hash never fails @@ -329,7 +287,7 @@ func (v *rsaVerifier) verifyPayload(payload []byte, signature []byte) error { return nil } -func newEd25519Verifier(publicKey ed25519.PublicKey, keyID string, alg SignatureAlgorithm) (*ed25519Verifier, error) { +func newEd25519Verifier(publicKey ed25519.PublicKey, alg SignatureAlgorithm) (*ed25519Verifier, error) { if alg != Ed25519 { return nil, fmt.Errorf("%w: %s", ErrUnsupportedAlgorithm, alg) } @@ -344,22 +302,14 @@ func newEd25519Verifier(publicKey ed25519.PublicKey, keyID string, alg Signature return &ed25519Verifier{ publicKey: publicKey, - alg: alg, - kid: keyID, }, nil } type ed25519Verifier struct { - alg SignatureAlgorithm publicKey ed25519.PublicKey - kid string } -func (v *ed25519Verifier) keyID() string { return v.kid } - -func (v *ed25519Verifier) algorithm() SignatureAlgorithm { return v.alg } - -func (v *ed25519Verifier) verifyPayload(payload []byte, signature []byte) error { +func (v *ed25519Verifier) verify(_ context.Context, payload []byte, signature []byte) error { if ok := ed25519.Verify(v.publicKey, payload, signature); !ok { return ErrInvalidSignature } diff --git a/asymmetric_test.go b/asymmetric_test.go index b80a28e..9145b17 100644 --- a/asymmetric_test.go +++ b/asymmetric_test.go @@ -39,7 +39,7 @@ func TestNewECDSASigner(t *testing.T) { {uc: string(EcdsaP521Sha512), alg: EcdsaP521Sha512, key: pkp521}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newECDSASigner(tc.key, "test", tc.alg) + sig, err := newECDSASigner(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -47,9 +47,7 @@ func TestNewECDSASigner(t *testing.T) { } else { require.NoError(t, err) require.NotNil(t, sig) - assert.Equal(t, "test", sig.keyID()) assert.Equal(t, tc.key, sig.privateKey) - assert.Equal(t, tc.alg, sig.algorithm()) } }) } @@ -78,10 +76,10 @@ func TestECDSASignerSignPayload(t *testing.T) { {alg: EcdsaP521Sha512, key: pkp521}, } { t.Run(string(tc.alg), func(t *testing.T) { - sig, err := newECDSASigner(tc.key, "test", tc.alg) + sig, err := newECDSASigner(tc.key, tc.alg) require.NoError(t, err) - res, err := sig.signPayload(message) + res, err := sig.sign(t.Context(), message) require.NoError(t, err) require.NotEmpty(t, res) @@ -133,7 +131,7 @@ func TestNewRSASigner(t *testing.T) { {uc: string(RsaPssSha512), alg: RsaPssSha512, key: pk4096}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newRSASigner(tc.key, "test", tc.alg) + sig, err := newRSASigner(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -141,9 +139,7 @@ func TestNewRSASigner(t *testing.T) { } else { require.NoError(t, err) require.NotNil(t, sig) - assert.Equal(t, "test", sig.keyID()) assert.Equal(t, tc.key, sig.privateKey) - assert.Equal(t, tc.alg, sig.algorithm()) } }) } @@ -177,10 +173,10 @@ func TestRSASignerSignPayload(t *testing.T) { {uc: "4096 key with RsaPssSha512", key: pk4096, alg: RsaPssSha512}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newRSASigner(tc.key, "test", tc.alg) + sig, err := newRSASigner(tc.key, tc.alg) require.NoError(t, err) - res, err := sig.signPayload(message) + res, err := sig.sign(t.Context(), message) if tc.err != nil { require.Error(t, err) require.ErrorIs(t, err, tc.err) @@ -227,7 +223,7 @@ func TestNewEd25519Signer(t *testing.T) { {uc: "success", alg: Ed25519, key: privKey}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newEd25519Signer(tc.key, "test", tc.alg) + sig, err := newEd25519Signer(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -235,9 +231,7 @@ func TestNewEd25519Signer(t *testing.T) { } else { require.NoError(t, err) require.NotNil(t, sig) - assert.Equal(t, "test", sig.keyID()) assert.Equal(t, tc.key, sig.privateKey) - assert.Equal(t, tc.alg, sig.algorithm()) } }) } @@ -251,10 +245,10 @@ func TestEd25519SignerSignPayload(t *testing.T) { pubKey, privKey, err := ed25519.GenerateKey(rand.Reader) require.NoError(t, err) - sig, err := newEd25519Signer(privKey, "test", Ed25519) + sig, err := newEd25519Signer(privKey, Ed25519) require.NoError(t, err) - res, err := sig.signPayload(message) + res, err := sig.sign(t.Context(), message) require.NoError(t, err) ok := ed25519.Verify(pubKey, message, res) @@ -287,7 +281,7 @@ func TestNewECDSAVerifier(t *testing.T) { {uc: string(EcdsaP521Sha512), alg: EcdsaP521Sha512, key: &pkp521.PublicKey}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newECDSAVerifier(tc.key, "test", tc.alg) + sig, err := newECDSAVerifier(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -295,9 +289,7 @@ func TestNewECDSAVerifier(t *testing.T) { } else { require.NoError(t, err) require.NotNil(t, sig) - assert.Equal(t, "test", sig.keyID()) assert.Equal(t, tc.key, sig.publicKey) - assert.Equal(t, tc.alg, sig.algorithm()) } }) } @@ -391,17 +383,17 @@ func TestECDSAverifierVerifyPayload(t *testing.T) { } } - sig, err := newECDSASigner(tc.key, "test", tc.alg) + sig, err := newECDSASigner(tc.key, tc.alg) require.NoError(t, err) - res, err := sig.signPayload(message) + res, err := sig.sign(t.Context(), message) require.NoError(t, err) require.NotEmpty(t, res) - ver, err := newECDSAVerifier(&tc.key.PublicKey, "test", tc.alg) + ver, err := newECDSAVerifier(&tc.key.PublicKey, tc.alg) require.NoError(t, err) - err = ver.verifyPayload(mutateMessage(t, message), mutateSignature(t, res)) + err = ver.verify(t.Context(), mutateMessage(t, message), mutateSignature(t, res)) if tc.shouldError { require.Error(t, err) @@ -443,7 +435,7 @@ func TestNewRSAVerifier(t *testing.T) { {uc: string(RsaPssSha512), alg: RsaPssSha512, key: &pk4096.PublicKey}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newRSAVerifier(tc.key, "test", tc.alg) + sig, err := newRSAVerifier(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -451,9 +443,7 @@ func TestNewRSAVerifier(t *testing.T) { } else { require.NoError(t, err) require.NotNil(t, sig) - assert.Equal(t, "test", sig.keyID()) assert.Equal(t, tc.key, sig.publicKey) - assert.Equal(t, tc.alg, sig.algorithm()) } }) } @@ -559,17 +549,17 @@ func TestRSAVerifierVerifyPayload(t *testing.T) { } } - sig, err := newRSASigner(tc.key, "test", tc.alg) + sig, err := newRSASigner(tc.key, tc.alg) require.NoError(t, err) - res, err := sig.signPayload(message) + res, err := sig.sign(t.Context(), message) require.NoError(t, err) require.NotEmpty(t, res) - ver, err := newRSAVerifier(&tc.key.PublicKey, "test", tc.alg) + ver, err := newRSAVerifier(&tc.key.PublicKey, tc.alg) require.NoError(t, err) - err = ver.verifyPayload(mutateMessage(t, message), mutateSignature(t, res)) + err = ver.verify(t.Context(), mutateMessage(t, message), mutateSignature(t, res)) if tc.shouldError { require.Error(t, err) @@ -601,7 +591,7 @@ func TestNewEd25519Verifier(t *testing.T) { {uc: "success", alg: Ed25519, key: pubKey}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newEd25519Verifier(tc.key, "test", tc.alg) + sig, err := newEd25519Verifier(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -609,9 +599,7 @@ func TestNewEd25519Verifier(t *testing.T) { } else { require.NoError(t, err) require.NotNil(t, sig) - assert.Equal(t, "test", sig.keyID()) assert.Equal(t, tc.key, sig.publicKey) - assert.Equal(t, tc.alg, sig.algorithm()) } }) } @@ -625,31 +613,31 @@ func TestEd25519VerifierVerifyPayload(t *testing.T) { pubKey, privKey, err := ed25519.GenerateKey(rand.Reader) require.NoError(t, err) - sig, err := newEd25519Signer(privKey, "test", Ed25519) + sig, err := newEd25519Signer(privKey, Ed25519) require.NoError(t, err) - res, err := sig.signPayload(message) + res, err := sig.sign(t.Context(), message) require.NoError(t, err) - ver, err := newEd25519Verifier(pubKey, "test", sig.alg) + ver, err := newEd25519Verifier(pubKey, Ed25519) require.NoError(t, err) // valid signature - err = ver.verifyPayload(message, res) + err = ver.verify(t.Context(), message, res) require.NoError(t, err) // invalid signature for the given message - err = ver.verifyPayload([]byte("test"), res) + err = ver.verify(t.Context(), []byte("test"), res) require.Error(t, err) require.ErrorIs(t, err, ErrInvalidSignature) // too short signature - err = ver.verifyPayload(message, res[0:len(res)-1]) + err = ver.verify(t.Context(), message, res[0:len(res)-1]) require.Error(t, err) require.ErrorIs(t, err, ErrInvalidSignature) // too long signature - err = ver.verifyPayload(message, append(res, 0x00)) + err = ver.verify(t.Context(), message, append(res, 0x00)) require.Error(t, err) require.ErrorIs(t, err, ErrInvalidSignature) } diff --git a/canonicalizer.go b/canonicalizer.go index b1ad905..7b92ef8 100644 --- a/canonicalizer.go +++ b/canonicalizer.go @@ -186,7 +186,7 @@ func canonicalizeQueryParam(msg *Message, params *httpsfv.Params) ([]string, err ErrCanonicalization, ErrInvalidComponentIdentifier) } - query := msg.URL.Query() + query := msg.queryParams() if !query.Has(name) { return nil, fmt.Errorf("%w: expected query parameter '%s' not found", ErrCanonicalization, name) } diff --git a/httpsig.go b/httpsig.go index d2f98c6..fa500a8 100644 --- a/httpsig.go +++ b/httpsig.go @@ -8,38 +8,82 @@ import ( ) var ( - ErrUnsupportedKeyType = errors.New("unsupported key type/format") - ErrUnsupportedAlgorithm = errors.New("unknown/unsupported algorithm") - ErrInvalidKeySize = errors.New("invalid key size") - ErrNoKeyProvided = errors.New("no key provided") - ErrInvalidSignature = errors.New("invalid signature") - ErrVerificationFailed = errors.New("verification failed") - ErrContentDigestMismatch = errors.New("content digest mismatch") - ErrMalformedData = errors.New("malformed data") + // ErrUnsupportedKeyType indicates that the supplied key material has an unsupported Go type. + ErrUnsupportedKeyType = errors.New("unsupported key type/format") + + // ErrUnsupportedAlgorithm indicates that the requested signature or digest algorithm is unsupported. + ErrUnsupportedAlgorithm = errors.New("unknown/unsupported algorithm") + + // ErrInvalidKeySize indicates that a key has an incompatible size or curve for its algorithm. + ErrInvalidKeySize = errors.New("invalid key size") + + // ErrNoKeyProvided indicates that required key material was not supplied. + ErrNoKeyProvided = errors.New("no key provided") + + // ErrInvalidSignature indicates that cryptographic signature verification failed. + ErrInvalidSignature = errors.New("invalid signature") + + // ErrVerificationFailed indicates that verifying the selected signatures failed; it wraps the underlying error. + ErrVerificationFailed = errors.New("verification failed") + + // ErrContentDigestMismatch indicates that a covered Content-Digest does not match the message body. + ErrContentDigestMismatch = errors.New("content digest mismatch") + + // ErrMalformedData indicates malformed signature or other structured HTTP message data. + ErrMalformedData = errors.New("malformed data") + + // ErrUnsupportedComponentIdentifier indicates that a covered component identifier is unsupported. ErrUnsupportedComponentIdentifier = errors.New("unsupported component identifier") - ErrInvalidComponentIdentifier = errors.New("invalid component identifier") - ErrCanonicalization = errors.New("failed to canonicalize component") - ErrMalformedSignatureParameter = errors.New("malformed signature parameter") - ErrNoApplicableDigestFound = errors.New("no applicable digest found") - ErrVerifierCreation = errors.New("verifier creation failed") - ErrParameter = errors.New("parameter error") - ErrValidity = errors.New("validity error") - ErrMissingParameter = errors.New("missing parameter error") - ErrSignatureNegotiationError = errors.New("signature negotiation error") + + // ErrInvalidComponentIdentifier indicates malformed or invalid parameters on a component identifier. + ErrInvalidComponentIdentifier = errors.New("invalid component identifier") + + // ErrCanonicalization indicates that a covered HTTP message component could not be canonicalized. + ErrCanonicalization = errors.New("failed to canonicalize component") + + // ErrMalformedSignatureParameter indicates a signature parameter with an invalid type or value. + ErrMalformedSignatureParameter = errors.New("malformed signature parameter") + + // ErrNoApplicableDigestFound indicates that no supported digest could be checked in Content-Digest. + ErrNoApplicableDigestFound = errors.New("no applicable digest found") + + // ErrVerifierCreation indicates that the verifier configuration could not be constructed. + ErrVerifierCreation = errors.New("verifier creation failed") + + // ErrParameter indicates a failed signature parameter check or invalid option. + ErrParameter = errors.New("parameter error") + + // ErrValidity indicates that a signature failed its time validity checks. + ErrValidity = errors.New("validity error") + + // ErrMissingParameter indicates that a required signature parameter or covered component is missing. + ErrMissingParameter = errors.New("missing parameter error") + + // ErrSignatureNegotiationError indicates a failure while preparing signature negotiation. + ErrSignatureNegotiationError = errors.New("signature negotiation error") ) +// NoApplicableSignatureError indicates that a message does not contain all +// required signatures or any signature selected by the verifier. If signature +// negotiation was configured, Negotiate can add the requested headers to a +// response. It can be recognized with errors.As or errors.Is. type NoApplicableSignatureError struct { headerToAdd http.Header } +// Error returns a description of the missing applicable signature. func (e *NoApplicableSignatureError) Error() string { return "no applicable signature found" } +// Is matches another NoApplicableSignatureError for use with errors.Is. func (e *NoApplicableSignatureError) Is(err error) bool { _, ok := err.(*NoApplicableSignatureError) return ok } +// Negotiate appends any prepared Accept-Signature and related negotiation +// headers to header. If no negotiation was configured, it adds nothing. +// The caller must supply a writable, non-nil http.Header. func (e *NoApplicableSignatureError) Negotiate(header http.Header) { for name, values := range e.headerToAdd { for _, value := range values { @@ -58,64 +102,208 @@ const ( componentIdentifierContentDigest = "content-digest" ) -// SignatureAlgorithm is the signature algorithm to use. -// Available algorithms are: -// - RSASSA-PKCS1-v1_5 using SHA-256 (rsa-v1_5-sha256). -// - RSASSA-PSS using SHA-512 (rsa-pss-sha512). -// - ECDSA using curve P-256 DSS and SHA-256 (ecdsa-p256-sha256). -// - ECDSA using curve P-384 DSS and SHA-384 (ecdsa-p384-sha384). -// - EdDSA using curve edwards25519 (ed25519). -// - HMAC using SHA-256 (hmac-sha256). +// SignatureAlgorithm identifies the concrete cryptographic algorithm used +// to create or verify an HTTP message signature. The supported algorithms +// are the constants below; the selected algorithm must be compatible with +// the supplied Key.Material. type SignatureAlgorithm string const ( + // RsaPkcs1v15Sha256 selects RSA PKCS#1 v1.5 with SHA-256. RsaPkcs1v15Sha256 SignatureAlgorithm = "rsa-v1_5-sha256" + + // RsaPkcs1v15Sha384 selects RSA PKCS#1 v1.5 with SHA-384. RsaPkcs1v15Sha384 SignatureAlgorithm = "rsa-v1_5-sha384" + + // RsaPkcs1v15Sha512 selects RSA PKCS#1 v1.5 with SHA-512. RsaPkcs1v15Sha512 SignatureAlgorithm = "rsa-v1_5-sha512" - RsaPssSha256 SignatureAlgorithm = "rsa-pss-sha256" - RsaPssSha384 SignatureAlgorithm = "rsa-pss-sha384" - RsaPssSha512 SignatureAlgorithm = "rsa-pss-sha512" - EcdsaP256Sha256 SignatureAlgorithm = "ecdsa-p256-sha256" - EcdsaP384Sha384 SignatureAlgorithm = "ecdsa-p384-sha384" - EcdsaP521Sha512 SignatureAlgorithm = "ecdsa-p521-sha512" - Ed25519 SignatureAlgorithm = "ed25519" - HmacSha256 SignatureAlgorithm = "hmac-sha256" - HmacSha384 SignatureAlgorithm = "hmac-sha384" - HmacSha512 SignatureAlgorithm = "hmac-sha512" + + // RsaPssSha256 selects RSA-PSS with SHA-256. + RsaPssSha256 SignatureAlgorithm = "rsa-pss-sha256" + + // RsaPssSha384 selects RSA-PSS with SHA-384. + RsaPssSha384 SignatureAlgorithm = "rsa-pss-sha384" + + // RsaPssSha512 selects RSA-PSS with SHA-512. + RsaPssSha512 SignatureAlgorithm = "rsa-pss-sha512" + + // EcdsaP256Sha256 selects ECDSA using P-256 and SHA-256. + EcdsaP256Sha256 SignatureAlgorithm = "ecdsa-p256-sha256" + + // EcdsaP384Sha384 selects ECDSA using P-384 and SHA-384. + EcdsaP384Sha384 SignatureAlgorithm = "ecdsa-p384-sha384" + + // EcdsaP521Sha512 selects ECDSA using P-521 and SHA-512. + EcdsaP521Sha512 SignatureAlgorithm = "ecdsa-p521-sha512" + + // Ed25519 selects Ed25519 signatures. + Ed25519 SignatureAlgorithm = "ed25519" + + // HmacSha256 selects HMAC with SHA-256. + HmacSha256 SignatureAlgorithm = "hmac-sha256" + + // HmacSha384 selects HMAC with SHA-384. + HmacSha384 SignatureAlgorithm = "hmac-sha384" + + // HmacSha512 selects HMAC with SHA-512. + HmacSha512 SignatureAlgorithm = "hmac-sha512" ) -// DigestAlgorithm is the digest algorithm to use. Available algorithms are: -// - SHA-256 (sha-256). -// - SHA-512 (sha-512). +// DigestAlgorithm identifies a hash algorithm supported for HTTP Content-Digest +// generation and verification. type DigestAlgorithm string const ( + // Sha256 selects SHA-256. Sha256 DigestAlgorithm = "sha-256" + + // Sha512 selects SHA-512. Sha512 DigestAlgorithm = "sha-512" ) +// SignatureParameter names an RFC 9421 signature parameter or a +// profile-specific extension parameter. type SignatureParameter string const ( - KeyID SignatureParameter = "keyid" - Alg SignatureParameter = "alg" + // KeyID names the keyid signature parameter. + KeyID SignatureParameter = "keyid" + + // Alg names the alg signature parameter. + Alg SignatureParameter = "alg" + + // Created names the created timestamp parameter. Created SignatureParameter = "created" + + // Expires names the expires timestamp parameter. Expires SignatureParameter = "expires" - Nonce SignatureParameter = "nonce" - Tag SignatureParameter = "tag" + + // Nonce names the nonce signature parameter. + Nonce SignatureParameter = "nonce" + + // Tag names the tag signature parameter. + Tag SignatureParameter = "tag" ) -// Key is the key to use for signing or verifying. +// SignatureParameters contains all signature parameters transmitted in a +// Signature-Input entry, including profile-specific extensions. Keys are the +// parameter names; values are decoded Structured Fields bare items (for +// example string, Token, int64, float64, bool, or []byte). +// Display Strings are exposed as ordinary strings. +type SignatureParameters map[SignatureParameter]any + +// KeyID returns the keyid parameter if present and of the expected type. +func (p SignatureParameters) KeyID() (string, bool) { + value, ok := p[KeyID].(string) + + return value, ok +} + +// Alg returns the alg parameter if present and of the expected type. +func (p SignatureParameters) Alg() (SignatureAlgorithm, bool) { + value, ok := p[Alg].(string) + + return SignatureAlgorithm(value), ok +} + +// Created returns the created parameter as a Unix timestamp if it has the expected type. +func (p SignatureParameters) Created() (int64, bool) { + value, ok := p[Created].(int64) + + return value, ok +} + +// Expires returns the expires parameter as a Unix timestamp if it has the expected type. +func (p SignatureParameters) Expires() (int64, bool) { + value, ok := p[Expires].(int64) + + return value, ok +} + +// Nonce returns the nonce parameter if present and of the expected type. +func (p SignatureParameters) Nonce() (string, bool) { + value, ok := p[Nonce].(string) + + return value, ok +} + +// Tag returns the tag parameter if present and of the expected type. +func (p SignatureParameters) Tag() (string, bool) { + value, ok := p[Tag].(string) + + return value, ok +} + +// Token represents a Structured Fields token. It is distinct from string so +// applications can distinguish token values from quoted Structured Fields +// strings when validating profile-specific signature parameters. +type Token string + +// Key combines cryptographic key material with the concrete signature +// algorithm to use. Signing requires private or symmetric key material; +// verification requires public or symmetric key material. type Key struct { - // KeyID is the identifier of the key. - KeyID string - // Algorithm is the cryptographic algorithm to use with the key. + // Algorithm is the signature algorithm to use with Material. + // It must be compatible with the supplied key material. Algorithm SignatureAlgorithm - // Key is the actual key material, like public, private or a secret key. - Key any + + // Material is the private, public, or symmetric key material used by the + // chosen algorithm. The currently supported implementations accept the + // corresponding Go crypto key types or []byte for HMAC. + Material any +} + +// ResolveKey makes a statically configured Key usable as a KeyResolver. +func (k Key) ResolveKey(_ context.Context, _ SignatureInfo) (KeyInfo, error) { + return KeyInfo{Key: k}, nil } -func (k Key) ResolveKey(_ context.Context, _ string) (Key, error) { return k, nil } +// KeyInfo is returned by a KeyResolver and contains the accepted verification +// key and optional application-defined information about its resolution. +type KeyInfo struct { + // Key is the trusted key and algorithm selected for this signature. + Key Key + // Metadata is application-specific information returned alongside the key. + // It is passed through to VerifiedSignature only on successful verification. + Metadata any +} + +// SignatureInfo describes one signature being considered for verification. +// All its values are unverified and may be sender-controlled. The +// resolver implementation must treat them as untrusted input when selecting +// key material. The message and maps are shared with the verification process +// and must not be modified by the resolver (including mutable values within +// the maps). +type SignatureInfo struct { + // Label is the current Signature-Input dictionary member name. It is not + // signed and can be changed by intermediaries; it is only a technical + // reference. + Label string + + // Message is the HTTP message being verified. Not all of its fields are + // necessarily covered by the signature, and it must not be modified. + Message *Message + + // Components maps covered component identifiers to the canonicalized + // values used to construct the signature base. It excludes the synthetic + // @signature-params component. Identifier parameters are retained in keys. + Components map[string]string + + // Parameters contains the transmitted, decoded signature parameters. + Parameters SignatureParameters +} + +// KeyResolver resolves a trusted verification key for a specific HTTP message +// signature. +type KeyResolver interface { + // ResolveKey returns the trusted key and optional metadata for info. + // It is called before cryptographic verification. SignatureInfo and its + // Message contain unverified, sender-controlled data. The implementation + // must not mutate SignatureInfo.Message, Components, Parameters, or their + // mutable contents: these are shared with the verification process and, on + // success, with VerifiedSignature. + ResolveKey(ctx context.Context, info SignatureInfo) (KeyInfo, error) +} // nolint: gochecknoglobals var supportedAlgs = map[DigestAlgorithm]crypto.Hash{ diff --git a/httpsig_test.go b/httpsig_test.go new file mode 100644 index 0000000..3709ffa --- /dev/null +++ b/httpsig_test.go @@ -0,0 +1,221 @@ +package httpsig + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestSignatureParametersKeyID(t *testing.T) { + t.Parallel() + + for name, tc := range map[string]struct { + params SignatureParameters + want string + wantOK bool + }{ + "present": { + params: SignatureParameters{KeyID: "test-key"}, + want: "test-key", + wantOK: true, + }, + "empty string": { + params: SignatureParameters{KeyID: ""}, + wantOK: true, + }, + "missing": { + params: SignatureParameters{}, + }, + "nil map": {}, + "wrong type": { + params: SignatureParameters{KeyID: int64(1234)}, + }, + } { + t.Run(name, func(t *testing.T) { + got, ok := tc.params.KeyID() + + assert.Equal(t, tc.want, got) + assert.Equal(t, tc.wantOK, ok) + }) + } +} + +func TestSignatureParametersAlg(t *testing.T) { + t.Parallel() + + for name, tc := range map[string]struct { + params SignatureParameters + want SignatureAlgorithm + wantOK bool + }{ + "present": { + params: SignatureParameters{Alg: "ed25519"}, + want: Ed25519, + wantOK: true, + }, + "empty string": { + params: SignatureParameters{Alg: ""}, + wantOK: true, + }, + "missing": { + params: SignatureParameters{}, + }, + "nil map": {}, + "wrong type": { + params: SignatureParameters{Alg: int64(1234)}, + }, + } { + t.Run(name, func(t *testing.T) { + got, ok := tc.params.Alg() + + assert.Equal(t, tc.want, got) + assert.Equal(t, tc.wantOK, ok) + }) + } +} + +func TestSignatureParametersCreated(t *testing.T) { + t.Parallel() + + for name, tc := range map[string]struct { + params SignatureParameters + want int64 + wantOK bool + }{ + "present": { + params: SignatureParameters{Created: int64(1234)}, + want: 1234, + wantOK: true, + }, + "zero value": { + params: SignatureParameters{Created: int64(0)}, + wantOK: true, + }, + "missing": { + params: SignatureParameters{}, + }, + "nil map": {}, + "wrong type": { + params: SignatureParameters{Created: "1234"}, + }, + } { + t.Run(name, func(t *testing.T) { + got, ok := tc.params.Created() + + assert.Equal(t, tc.want, got) + assert.Equal(t, tc.wantOK, ok) + }) + } +} + +func TestSignatureParametersExpires(t *testing.T) { + t.Parallel() + + for name, tc := range map[string]struct { + params SignatureParameters + want int64 + wantOK bool + }{ + "present": { + params: SignatureParameters{Expires: int64(5678)}, + want: 5678, + wantOK: true, + }, + "zero value": { + params: SignatureParameters{Expires: int64(0)}, + wantOK: true, + }, + "missing": { + params: SignatureParameters{}, + }, + "nil map": {}, + "wrong type": { + params: SignatureParameters{Expires: "5678"}, + }, + } { + t.Run(name, func(t *testing.T) { + got, ok := tc.params.Expires() + + assert.Equal(t, tc.want, got) + assert.Equal(t, tc.wantOK, ok) + }) + } +} + +func TestSignatureParametersNonce(t *testing.T) { + t.Parallel() + + for name, tc := range map[string]struct { + params SignatureParameters + want string + wantOK bool + }{ + "present": { + params: SignatureParameters{Nonce: "request-nonce"}, + want: "request-nonce", + wantOK: true, + }, + "empty string": { + params: SignatureParameters{Nonce: ""}, + wantOK: true, + }, + "missing": { + params: SignatureParameters{}, + }, + "nil map": {}, + "wrong type": { + params: SignatureParameters{Nonce: int64(1234)}, + }, + } { + t.Run(name, func(t *testing.T) { + got, ok := tc.params.Nonce() + + assert.Equal(t, tc.want, got) + assert.Equal(t, tc.wantOK, ok) + }) + } +} + +func TestSignatureParametersTag(t *testing.T) { + t.Parallel() + + for name, tc := range map[string]struct { + params SignatureParameters + want string + wantOK bool + }{ + "present": { + params: SignatureParameters{Tag: "profile"}, + want: "profile", + wantOK: true, + }, + "empty string": { + params: SignatureParameters{Tag: ""}, + wantOK: true, + }, + "missing": { + params: SignatureParameters{}, + }, + "nil map": {}, + "wrong type": { + params: SignatureParameters{Tag: int64(1234)}, + }, + } { + t.Run(name, func(t *testing.T) { + got, ok := tc.params.Tag() + + assert.Equal(t, tc.want, got) + assert.Equal(t, tc.wantOK, ok) + }) + } +} + +func TestSignatureParametersExtension(t *testing.T) { + t.Parallel() + + name := SignatureParameter("wimse-aud") + params := SignatureParameters{name: "service-a"} + + assert.Equal(t, "service-a", params[name]) + assert.Equal(t, "service-a", params["wimse-aud"]) +} diff --git a/message.go b/message.go index 72a9111..8536ec4 100644 --- a/message.go +++ b/message.go @@ -7,10 +7,15 @@ import ( "io" "net/http" "net/url" + "sync" "github.com/dunglas/httpsfv" ) +// MessageFromRequest creates a Message for signing or verifying an HTTP +// request. Request headers are cloned. If the body must be read and req.GetBody +// is unavailable, the original body is buffered and replaced so it remains +// readable. Callers must enforce size limits for untrusted request bodies. func MessageFromRequest(req *http.Request) *Message { var ( getBody func() (io.ReadCloser, error) @@ -52,6 +57,11 @@ func MessageFromRequest(req *http.Request) *Message { } } +// MessageFromResponse creates a Message from a received HTTP response and +// its associated request. Response and request headers are cloned. The +// response body may be buffered and restored when a covered component needs +// it. The request body is available for ;req components only when the +// associated request has a GetBody function. func MessageFromResponse(rw *http.Response) *Message { var bodySnapshot []byte @@ -93,6 +103,10 @@ func MessageFromResponse(rw *http.Response) *Message { } } +// MessageForResponse creates a Message for signing a response to req. +// It clones the response and request headers and makes the supplied body +// available for Content-Digest and other covered components. The request +// body may be buffered and restored when a ;req component requires it. func MessageForResponse(req *http.Request, respHeader http.Header, body []byte, respCode int) *Message { var bodySnapshot []byte @@ -126,19 +140,56 @@ func MessageForResponse(req *http.Request, respHeader http.Header, body []byte, } } -// Message is a representation of an HTTP request or response, containing the values -// needed to construct or validate a signature. +// Message represents the HTTP request or response data needed to construct +// and verify an HTTP message signature. For a response, request-related +// fields supply data used by component identifiers with the ;req parameter. +// Not every field is necessarily covered by the signature. +// Message data must remain stable after it is prepared for signing or +// verification, apart from headers added by signing. A Message must not be +// copied after its first use. type Message struct { - Context context.Context //nolint: containedctx - Method string - Authority string - URL *url.URL - Header http.Header - Body func() (io.ReadCloser, error) + // Context is passed to key resolution and Accept-Signature nonce generation. + Context context.Context //nolint: containedctx + + // Method is the associated HTTP request method. + Method string + + // Authority is the authority (host and optional port) of the request. + Authority string + + // URL is the associated HTTP request URL. + URL *url.URL + + // Header contains the headers of the request or response being processed. + // The signer may update this map with signatures and a Content-Digest. + Header http.Header + + // Body opens the body of the request or response being processed. + Body func() (io.ReadCloser, error) + + // RequestHeader contains the associated request headers for a response. RequestHeader http.Header - RequestBody func() (io.ReadCloser, error) - StatusCode int - IsRequest bool + + // RequestBody opens the associated request body for response ;req components. + RequestBody func() (io.ReadCloser, error) + + // StatusCode is the HTTP response status code (unused for requests). + StatusCode int + + // IsRequest distinguishes requests from responses for canonicalization. + IsRequest bool + + queryOnce sync.Once + queryValues url.Values +} + +// queryParams parses the associated request query at most once per Message. +func (m *Message) queryParams() url.Values { + m.queryOnce.Do(func() { + m.queryValues = m.URL.Query() + }) + + return m.queryValues } func (m *Message) addSignature(label string, signature []byte, signatureInput httpsfv.InnerList) (http.Header, error) { @@ -157,6 +208,10 @@ func (m *Message) addSignature(label string, signature []byte, signatureInput ht signatureHeaderDict = httpsfv.NewDictionary() } + if err != nil { + return nil, err + } + if inputHeader := m.Header.Values(headerSignatureInput); len(inputHeader) != 0 { inputHeaderDict, err = httpsfv.UnmarshalDictionary(inputHeader) } else { diff --git a/message_test.go b/message_test.go index 44ee571..e476a41 100644 --- a/message_test.go +++ b/message_test.go @@ -17,20 +17,17 @@ import ( func TestCreateUniqueLabel(t *testing.T) { t.Parallel() - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { label string dict *httpsfv.Dictionary expectedLabel string }{ - { - uc: "given label not already taken", + "given label not already taken": { label: "foo", dict: httpsfv.NewDictionary(), expectedLabel: "foo", }, - { - uc: "given label already taken #1", + "given label already taken #1": { label: "foo", dict: func() *httpsfv.Dictionary { dict := httpsfv.NewDictionary() @@ -40,8 +37,7 @@ func TestCreateUniqueLabel(t *testing.T) { }(), expectedLabel: "foo1", }, - { - uc: "given label already taken #2", + "given label already taken #2": { label: "foo", dict: func() *httpsfv.Dictionary { dict := httpsfv.NewDictionary() @@ -53,7 +49,7 @@ func TestCreateUniqueLabel(t *testing.T) { expectedLabel: "foo2", }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { label := createUniqueLabel(tc.label, tc.dict) assert.Equal(t, tc.expectedLabel, label) @@ -61,19 +57,229 @@ func TestCreateUniqueLabel(t *testing.T) { } } +func TestMessageAddSignature(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + label string + message *Message + signatureInput httpsfv.InnerList + assert func(t *testing.T, msg *Message, header http.Header, err error) + }{ + "without existing signatures": { + label: "new", + message: &Message{Header: make(http.Header)}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.NoError(t, err) + assert.Equal(t, http.Header{ + headerSignature: {`new=:c2lnbmF0dXJl:`}, + headerSignatureInput: {`new=("@method")`}, + }, header) + assert.Equal(t, header, msg.Header) + }, + }, + "with existing signatures": { + label: "new", + message: &Message{Header: http.Header{ + headerSignature: {`previous=:c2ln:`}, + headerSignatureInput: {`previous=("@path")`}, + "X-Test": {"value"}, + }}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.NoError(t, err) + assert.Equal(t, http.Header{ + headerSignature: {`previous=:c2ln:, new=:c2lnbmF0dXJl:`}, + headerSignatureInput: {`previous=("@path"), new=("@method")`}, + "X-Test": {"value"}, + }, header) + assert.Equal(t, header, msg.Header) + }, + }, + "with Signature only": { + label: "new", + message: &Message{Header: http.Header{ + headerSignature: {`previous=:c2ln:`}, + }}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.NoError(t, err) + assert.Equal(t, http.Header{ + headerSignature: {`previous=:c2ln:, new=:c2lnbmF0dXJl:`}, + headerSignatureInput: {`new=("@method")`}, + }, header) + assert.Equal(t, header, msg.Header) + }, + }, + "with Signature-Input only": { + label: "new", + message: &Message{Header: http.Header{ + headerSignatureInput: {`previous=("@path")`}, + }}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.NoError(t, err) + assert.Equal(t, http.Header{ + headerSignature: {`new=:c2lnbmF0dXJl:`}, + headerSignatureInput: {`previous=("@path"), new=("@method")`}, + }, header) + assert.Equal(t, header, msg.Header) + }, + }, + "with duplicate label": { + label: "new", + message: &Message{Header: http.Header{ + headerSignature: {`new=:c2ln:`}, + headerSignatureInput: {`new=("@path")`}, + }}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.NoError(t, err) + assert.Equal(t, http.Header{ + headerSignature: {`new=:c2ln:, new1=:c2lnbmF0dXJl:`}, + headerSignatureInput: {`new=("@path"), new1=("@method")`}, + }, header) + assert.Equal(t, header, msg.Header) + }, + }, + "with multiple duplicate labels": { + label: "new", + message: &Message{Header: http.Header{ + headerSignature: {`new=:c2ln:, new1=:c2ln:`}, + headerSignatureInput: {`new=("@path"), new1=("@query")`}, + }}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.NoError(t, err) + assert.Equal(t, http.Header{ + headerSignature: {`new=:c2ln:, new1=:c2ln:, new2=:c2lnbmF0dXJl:`}, + headerSignatureInput: {`new=("@path"), new1=("@query"), new2=("@method")`}, + }, header) + assert.Equal(t, header, msg.Header) + }, + }, + "malformed Signature with valid Signature-Input": { + label: "new", + message: &Message{Header: http.Header{ + headerSignature: {"not a dictionary"}, + headerSignatureInput: {"previous=()"}, + }}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.Error(t, err) + assert.Nil(t, header) + assert.Equal(t, http.Header{ + headerSignature: {"not a dictionary"}, + headerSignatureInput: {"previous=()"}, + }, msg.Header) + }, + }, + "valid Signature with malformed Signature-Input": { + label: "new", + message: &Message{Header: http.Header{ + headerSignature: {"previous=:c2ln:"}, + headerSignatureInput: {"not a dictionary"}, + }}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.Error(t, err) + assert.Nil(t, header) + assert.Equal(t, http.Header{ + headerSignature: {"previous=:c2ln:"}, + headerSignatureInput: {"not a dictionary"}, + }, msg.Header) + }, + }, + "invalid label": { + label: "Invalid", + message: &Message{Header: make(http.Header)}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + Params: httpsfv.NewParams(), + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.Error(t, err) + assert.Nil(t, header) + assert.Empty(t, msg.Header) + }, + }, + "invalid signature input": { + label: "new", + message: &Message{Header: make(http.Header)}, + signatureInput: httpsfv.InnerList{ + Items: []httpsfv.Item{httpsfv.NewItem("@method")}, + }, + assert: func(t *testing.T, msg *Message, header http.Header, err error) { + t.Helper() + + require.Error(t, err) + assert.Nil(t, header) + assert.Empty(t, msg.Header) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + header, err := tc.message.addSignature(tc.label, []byte("signature"), tc.signatureInput) + + tc.assert(t, tc.message, header, err) + }) + } +} + func TestMessageFromRequest(t *testing.T) { t.Parallel() expURL, err := url.Parse("http://example.com?foo=bar") require.NoError(t, err) - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { req *http.Request assert func(t *testing.T, msg *Message) }{ - { - uc: "outbound request without body", + "outbound request without body": { req: func() *http.Request { req, err := http.NewRequestWithContext( t.Context(), @@ -118,8 +324,7 @@ func TestMessageFromRequest(t *testing.T) { assert.Empty(t, data1) }, }, - { - uc: "inbound request without body", + "inbound request without body": { req: func() *http.Request { req := httptest.NewRequestWithContext( t.Context(), @@ -162,8 +367,7 @@ func TestMessageFromRequest(t *testing.T) { assert.Empty(t, data1) }, }, - { - uc: "outbound request with body", + "outbound request with body": { req: func() *http.Request { req, err := http.NewRequestWithContext( t.Context(), @@ -208,8 +412,7 @@ func TestMessageFromRequest(t *testing.T) { assert.JSONEq(t, `{"hello": "world"}`, string(data1)) }, }, - { - uc: "inbound request with body", + "inbound request with body": { req: func() *http.Request { req := httptest.NewRequestWithContext( t.Context(), @@ -251,7 +454,7 @@ func TestMessageFromRequest(t *testing.T) { }, }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { msg := MessageFromRequest(tc.req) tc.assert(t, msg) @@ -282,13 +485,11 @@ Content-Length: 23 expURL, err := url.Parse("http://example.com?foo=bar") require.NoError(t, err) - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { resp *http.Response assert func(t *testing.T, msg *Message) }{ - { - uc: "response without body", + "response without body": { resp: func() *http.Response { req, err := http.NewRequestWithContext( t.Context(), @@ -351,8 +552,7 @@ Content-Length: 23 assert.Empty(t, data1) }, }, - { - uc: "response with body", + "response with body": { resp: func() *http.Response { req, err := http.NewRequestWithContext( t.Context(), @@ -416,7 +616,7 @@ Content-Length: 23 }, }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { msg := MessageFromResponse(tc.resp) tc.assert(t, msg) @@ -430,15 +630,13 @@ func TestMessageForResponse(t *testing.T) { expURL, err := url.Parse("http://example.com?foo=bar") require.NoError(t, err) - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { req *http.Request respHeader http.Header respBody []byte assert func(t *testing.T, msg *Message) }{ - { - uc: "response without body", + "response without body": { req: func() *http.Request { req, err := http.NewRequestWithContext( t.Context(), @@ -502,8 +700,7 @@ func TestMessageForResponse(t *testing.T) { assert.Empty(t, data1) }, }, - { - uc: "response with body", + "response with body": { req: func() *http.Request { req, err := http.NewRequestWithContext( t.Context(), @@ -569,7 +766,7 @@ func TestMessageForResponse(t *testing.T) { }, }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { msg := MessageForResponse(tc.req, tc.respHeader, tc.respBody, http.StatusOK) tc.assert(t, msg) diff --git a/mock_key_resolver_test.go b/mock_key_resolver_test.go index 70503d3..efbba93 100644 --- a/mock_key_resolver_test.go +++ b/mock_key_resolver_test.go @@ -47,25 +47,25 @@ func (_m *KeyResolverMock) EXPECT() *KeyResolverMock_Expecter { } // ResolveKey provides a mock function for the type KeyResolverMock -func (_mock *KeyResolverMock) ResolveKey(ctx context.Context, keyID string) (Key, error) { - ret := _mock.Called(ctx, keyID) +func (_mock *KeyResolverMock) ResolveKey(ctx context.Context, info SignatureInfo) (KeyInfo, error) { + ret := _mock.Called(ctx, info) if len(ret) == 0 { panic("no return value specified for ResolveKey") } - var r0 Key + var r0 KeyInfo var r1 error - if returnFunc, ok := ret.Get(0).(func(context.Context, string) (Key, error)); ok { - return returnFunc(ctx, keyID) + if returnFunc, ok := ret.Get(0).(func(context.Context, SignatureInfo) (KeyInfo, error)); ok { + return returnFunc(ctx, info) } - if returnFunc, ok := ret.Get(0).(func(context.Context, string) Key); ok { - r0 = returnFunc(ctx, keyID) + if returnFunc, ok := ret.Get(0).(func(context.Context, SignatureInfo) KeyInfo); ok { + r0 = returnFunc(ctx, info) } else { - r0 = ret.Get(0).(Key) + r0 = ret.Get(0).(KeyInfo) } - if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok { - r1 = returnFunc(ctx, keyID) + if returnFunc, ok := ret.Get(1).(func(context.Context, SignatureInfo) error); ok { + r1 = returnFunc(ctx, info) } else { r1 = ret.Error(1) } @@ -79,20 +79,20 @@ type KeyResolverMock_ResolveKey_Call struct { // ResolveKey is a helper method to define mock.On call // - ctx context.Context -// - keyID string -func (_e *KeyResolverMock_Expecter) ResolveKey(ctx any, keyID any) *KeyResolverMock_ResolveKey_Call { - return &KeyResolverMock_ResolveKey_Call{Call: _e.mock.On("ResolveKey", ctx, keyID)} +// - info SignatureInfo +func (_e *KeyResolverMock_Expecter) ResolveKey(ctx any, info any) *KeyResolverMock_ResolveKey_Call { + return &KeyResolverMock_ResolveKey_Call{Call: _e.mock.On("ResolveKey", ctx, info)} } -func (_c *KeyResolverMock_ResolveKey_Call) Run(run func(ctx context.Context, keyID string)) *KeyResolverMock_ResolveKey_Call { +func (_c *KeyResolverMock_ResolveKey_Call) Run(run func(ctx context.Context, info SignatureInfo)) *KeyResolverMock_ResolveKey_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 context.Context if args[0] != nil { arg0 = args[0].(context.Context) } - var arg1 string + var arg1 SignatureInfo if args[1] != nil { - arg1 = args[1].(string) + arg1 = args[1].(SignatureInfo) } run( arg0, @@ -102,12 +102,12 @@ func (_c *KeyResolverMock_ResolveKey_Call) Run(run func(ctx context.Context, key return _c } -func (_c *KeyResolverMock_ResolveKey_Call) Return(key Key, err error) *KeyResolverMock_ResolveKey_Call { - _c.Call.Return(key, err) +func (_c *KeyResolverMock_ResolveKey_Call) Return(keyInfo KeyInfo, err error) *KeyResolverMock_ResolveKey_Call { + _c.Call.Return(keyInfo, err) return _c } -func (_c *KeyResolverMock_ResolveKey_Call) RunAndReturn(run func(ctx context.Context, keyID string) (Key, error)) *KeyResolverMock_ResolveKey_Call { +func (_c *KeyResolverMock_ResolveKey_Call) RunAndReturn(run func(ctx context.Context, info SignatureInfo) (KeyInfo, error)) *KeyResolverMock_ResolveKey_Call { _c.Call.Return(run) return _c } diff --git a/mock_nonce_checker_test.go b/mock_nonce_checker_test.go deleted file mode 100644 index 73e1a44..0000000 --- a/mock_nonce_checker_test.go +++ /dev/null @@ -1,104 +0,0 @@ -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery -// template: testify - -package httpsig - -import ( - "context" - - mock "github.com/stretchr/testify/mock" -) - -// NewNonceCheckerMock creates a new instance of NonceCheckerMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewNonceCheckerMock(t interface { - mock.TestingT - Cleanup(func()) -}) *NonceCheckerMock { - if helper, ok := t.(interface{ Helper() }); ok { - helper.Helper() - } - - mock := &NonceCheckerMock{} - mock.Mock.Test(t) - - t.Cleanup(func() { - if helper, ok := t.(interface{ Helper() }); ok { - helper.Helper() - } - mock.AssertExpectations(t) - }) - - return mock -} - -// NonceCheckerMock is an autogenerated mock type for the NonceChecker type -type NonceCheckerMock struct { - mock.Mock -} - -type NonceCheckerMock_Expecter struct { - mock *mock.Mock -} - -func (_m *NonceCheckerMock) EXPECT() *NonceCheckerMock_Expecter { - return &NonceCheckerMock_Expecter{mock: &_m.Mock} -} - -// CheckNonce provides a mock function for the type NonceCheckerMock -func (_mock *NonceCheckerMock) CheckNonce(ctx context.Context, nonce NonceValue) error { - ret := _mock.Called(ctx, nonce) - - if len(ret) == 0 { - panic("no return value specified for CheckNonce") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(context.Context, NonceValue) error); ok { - r0 = returnFunc(ctx, nonce) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// NonceCheckerMock_CheckNonce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckNonce' -type NonceCheckerMock_CheckNonce_Call struct { - *mock.Call -} - -// CheckNonce is a helper method to define mock.On call -// - ctx context.Context -// - nonce NonceValue -func (_e *NonceCheckerMock_Expecter) CheckNonce(ctx any, nonce any) *NonceCheckerMock_CheckNonce_Call { - return &NonceCheckerMock_CheckNonce_Call{Call: _e.mock.On("CheckNonce", ctx, nonce)} -} - -func (_c *NonceCheckerMock_CheckNonce_Call) Run(run func(ctx context.Context, nonce NonceValue)) *NonceCheckerMock_CheckNonce_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 NonceValue - if args[1] != nil { - arg1 = args[1].(NonceValue) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *NonceCheckerMock_CheckNonce_Call) Return(err error) *NonceCheckerMock_CheckNonce_Call { - _c.Call.Return(err) - return _c -} - -func (_c *NonceCheckerMock_CheckNonce_Call) RunAndReturn(run func(ctx context.Context, nonce NonceValue) error) *NonceCheckerMock_CheckNonce_Call { - _c.Call.Return(run) - return _c -} diff --git a/nonce.go b/nonce.go index 060c008..aceec9c 100644 --- a/nonce.go +++ b/nonce.go @@ -1,49 +1,17 @@ package httpsig -import ( - "context" - "crypto/rand" - "encoding/base64" -) +import "context" -// NonceGetter represents a source of random nonces to go into resulting objects. +// NonceGetter supplies a nonce for an Accept-Signature request. An empty +// result omits the nonce parameter. Generating and correlating nonce values +// is the responsibility of the calling application. type NonceGetter interface { + // GetNonce returns a nonce or an error for the given context. GetNonce(ctx context.Context) (string, error) } +// NonceGetterFunc adapts a function to the NonceGetter interface. type NonceGetterFunc func(ctx context.Context) (string, error) +// GetNonce calls the wrapped function. func (ng NonceGetterFunc) GetNonce(ctx context.Context) (string, error) { return ng(ctx) } - -// NonceChecker is responsible for the verification of the nonce received in a signature, -// e.g. to prevent replay attacks, or to verify that the nonce is the expected one, like -// if requested using the Accept-Signature header. -type NonceChecker interface { - CheckNonce(ctx context.Context, nonce NonceValue) error -} - -type NonceValue struct { - Present bool - Value string -} - -type NonceCheckerFunc func(ctx context.Context, nonce NonceValue) error - -func (f NonceCheckerFunc) CheckNonce(ctx context.Context, nonce NonceValue) error { - return f(ctx, nonce) -} - -type noopNonceChecker struct{} - -func (n noopNonceChecker) CheckNonce(_ context.Context, _ NonceValue) error { return nil } - -type nonceGetter struct{} - -func (n nonceGetter) GetNonce(_ context.Context) (string, error) { - b := make([]byte, 16) - if _, err := rand.Read(b); err != nil { - return "", err - } - - return base64.URLEncoding.EncodeToString(b), nil -} diff --git a/nonce_test.go b/nonce_test.go deleted file mode 100644 index 77eeda7..0000000 --- a/nonce_test.go +++ /dev/null @@ -1,23 +0,0 @@ -package httpsig - -import ( - "context" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestNonceCheckerFuncImplementsNonceChecker(t *testing.T) { - t.Parallel() - - var checker NonceChecker = NonceCheckerFunc(func(_ context.Context, nonce NonceValue) error { - assert.True(t, nonce.Present) - assert.Equal(t, "foo", nonce.Value) - - return nil - }) - - err := checker.CheckNonce(context.Background(), NonceValue{Present: true, Value: "foo"}) - require.NoError(t, err) -} diff --git a/options.go b/options.go new file mode 100644 index 0000000..31cebb4 --- /dev/null +++ b/options.go @@ -0,0 +1,638 @@ +package httpsig + +import ( + "bytes" + "fmt" + "time" + + "github.com/dunglas/httpsfv" +) + +type signOptions struct { + label string + nonce string + nonceSet bool + staticParameters []parameterOption + parameters []parameterOption +} + +type acceptSignatureBuildOptions struct { + nonce string + nonceSet bool + staticParameters []parameterOption + parameters []parameterOption +} + +type sigNegotiationOptions struct { + opts []AcceptSignatureOption +} + +// SignerOption configures the signing policy of a Signer. +type SignerOption interface { + applySignerOption(s *signer) error +} + +// SignOption configures a single Sign call. +type SignOption interface { + applySignOption(opts *signOptions) error +} + +// SignatureNegotiationOption configures requests additional to the verifier's +// signature requirements. +type SignatureNegotiationOption interface { + applySignatureNegotiationOption(opts *sigNegotiationOptions) +} + +// VerifierOption configures signature selection or verification requirements. +// It can also be used within WithRequiredTag for per-tag requirements. +type VerifierOption interface { + applyVerifierOption(v *verifier, e *verificationPolicy, inTag bool) error +} + +// VerifyOption adds requirements for a single Verify call. +type VerifyOption interface { + applyVerifyOption(e *verificationPolicy) error +} + +// AcceptSignatureOption configures an AcceptSignatureBuilder. +type AcceptSignatureOption interface { + applyAcceptSignatureOption(builder *AcceptSignatureBuilder) error +} + +// AcceptSignatureBuildOption configures a single AcceptSignatureBuilder.Build call. +type AcceptSignatureBuildOption interface { + applyAcceptSignatureBuildOption(opts *acceptSignatureBuildOptions) error +} + +type signerOptionFunc func(*signer) error + +func (f signerOptionFunc) applySignerOption(s *signer) error { + return f(s) +} + +type verifierOptionFunc func(*verifier, *verificationPolicy, bool) error + +func (f verifierOptionFunc) applyVerifierOption(v *verifier, e *verificationPolicy, inTag bool) error { + return f(v, e, inTag) +} + +// WithLabel specifies the technical label for a signature or an +// Accept-Signature request. An empty label leaves the current label unchanged. +func WithLabel(label string) labelOption { + return labelOption(label) +} + +type labelOption string + +func (o labelOption) applySignerOption(s *signer) error { + if len(o) != 0 { + s.label = string(o) + } + + return nil +} + +func (o labelOption) applySignOption(opts *signOptions) error { + if len(o) != 0 { + opts.label = string(o) + } + + return nil +} + +func (o labelOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + if len(o) != 0 { + asb.label = string(o) + } + + return nil +} + +func (o labelOption) applySignatureNegotiationOption(opts *sigNegotiationOptions) { + opts.opts = append(opts.opts, o) +} + +// WithTTL specifies the interval between the created and expires signature +// parameters. A non-positive duration omits expires. +func WithTTL(ttl time.Duration) SignerOption { + return signerOptionFunc(func(s *signer) error { + s.ttl = ttl + + return nil + }) +} + +// WithComponents specifies component identifiers to cover when signing, +// require during verification, or request in Accept-Signature. +func WithComponents(identifiers ...string) componentsOption { + return componentsOption{identifiers: identifiers} +} + +type componentsOption struct { + identifiers []string +} + +func (o componentsOption) applySignerOption(s *signer) error { + var err error + + s.ids, err = toComponentIdentifiers(o.identifiers) + + return err +} + +func (o componentsOption) applyVerifierOption(_ *verifier, policy *verificationPolicy, _ bool) error { + var err error + + policy.identifiers, err = toComponentIdentifiers(o.identifiers) + + return err +} + +func (o componentsOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + ids, err := toComponentIdentifiers(o.identifiers) + if err != nil { + return err + } + + asb.setIdentifiers(ids) + + return nil +} + +// WithTag specifies an application-defined tag for signing or +// Accept-Signature requests. +func WithTag(tag string) tagOption { + return tagOption(tag) +} + +type tagOption string + +func (o tagOption) applySignerOption(s *signer) error { + if len(o) != 0 { + s.tag = string(o) + } + + return nil +} + +func (o tagOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + asb.tag = string(o) + + return nil +} + +// WithContentDigestAlgorithm selects the algorithm for generating a covered +// Content-Digest. An unsupported algorithm causes ErrUnsupportedAlgorithm. +func WithContentDigestAlgorithm(alg DigestAlgorithm) SignerOption { + return signerOptionFunc(func(s *signer) error { + if _, known := supportedAlgs[alg]; !known { + return fmt.Errorf("%w: %s", ErrUnsupportedAlgorithm, alg) + } + + s.cdAlg = alg + + return nil + }) +} + +// WithKeyID specifies the keyid parameter for signing or Accept-Signature. +// An empty value is ignored when signing and omitted from Accept-Signature. +func WithKeyID(keyID string) keyIDOption { + return keyIDOption(keyID) +} + +type keyIDOption string + +func (o keyIDOption) applySignerOption(s *signer) error { + if len(o) != 0 { + s.keyID = string(o) + } + + return nil +} + +func (o keyIDOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + asb.keyID = string(o) + + return nil +} + +func (o keyIDOption) applySignatureNegotiationOption(opts *sigNegotiationOptions) { + opts.opts = append(opts.opts, o) +} + +// WithAlg includes the selected Key.Algorithm as the alg signature parameter. +// It does not select or change the signing algorithm. +func WithAlg() SignerOption { + return signerOptionFunc(func(s *signer) error { + s.includeAlg = true + + return nil + }) +} + +// WithParameter specifies an extension parameter for signing, verifying, or +// requesting a signature, either statically or for a single call. It can also +// be used in WithSignatureNegotiation. Extension values may be +// string, Token, bool, int, int64, float64, or []byte. Standard RFC 9421 +// parameter names are reserved, except for a non-empty string nonce on Verify, +// Sign, or AcceptSignatureBuilder.Build. Verification requirements are additive; +// an invocation cannot override static requirements. Duplicate signing or +// builder parameters are rejected. Do not use secret expected values: verification +// compares them before the signature has been authenticated. +func WithParameter(name SignatureParameter, value any) parameterOption { + return parameterOption{name: name, value: value} +} + +type parameterOption struct { + name SignatureParameter + value any +} + +func (o parameterOption) applySignerOption(s *signer) error { + return addParameter(&s.parameters, nil, o, true) +} + +func (o parameterOption) applySignOption(opts *signOptions) error { + if o.name == Nonce { + if opts.nonceSet { + return fmt.Errorf("%w: duplicate signature parameter %q", ErrParameter, o.name) + } + + nonce, err := validateNonceOption(o.value) + if err != nil { + return err + } + + opts.nonce = nonce + opts.nonceSet = true + + return nil + } + + return addParameter(&opts.parameters, opts.staticParameters, o, false) +} + +func (o parameterOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + return addParameter(&asb.parameters, nil, o, true) +} + +func (o parameterOption) applySignatureNegotiationOption(opts *sigNegotiationOptions) { + opts.opts = append(opts.opts, o) +} + +func (o parameterOption) applyVerifierOption(_ *verifier, policy *verificationPolicy, _ bool) error { + return o.applyVerifyOption(policy) +} + +func (o parameterOption) applyVerifyOption(policy *verificationPolicy) error { + return policy.addExpectedParameter(o) +} + +// WithRequiredParameters requires the named signature parameters to be present. +// It does not check their application-specific semantics. +func WithRequiredParameters(names ...SignatureParameter) requiredParametersOption { + return names +} + +type requiredParametersOption []SignatureParameter + +func (o requiredParametersOption) applyVerifierOption(_ *verifier, policy *verificationPolicy, _ bool) error { + return o.applyVerifyOption(policy) +} + +func (o requiredParametersOption) applyVerifyOption(policy *verificationPolicy) error { + for _, name := range o { + if err := policy.addRequiredParameter(name); err != nil { + return err + } + } + + return nil +} + +// WithForbiddenParameters rejects signatures containing any named parameter. +func WithForbiddenParameters(names ...SignatureParameter) forbiddenParametersOption { + return names +} + +type forbiddenParametersOption []SignatureParameter + +func (o forbiddenParametersOption) applyVerifierOption(_ *verifier, policy *verificationPolicy, _ bool) error { + return o.applyVerifyOption(policy) +} + +func (o forbiddenParametersOption) applyVerifyOption(policy *verificationPolicy) error { + for _, name := range o { + if err := policy.addForbiddenParameter(name); err != nil { + return err + } + } + + return nil +} + +func (o parameterOption) applyAcceptSignatureBuildOption(opts *acceptSignatureBuildOptions) error { + if o.name == Nonce { + if opts.nonceSet { + return fmt.Errorf("%w: duplicate signature parameter %q", ErrParameter, o.name) + } + + nonce, err := validateNonceOption(o.value) + if err != nil { + return err + } + + opts.nonce = nonce + opts.nonceSet = true + + return nil + } + + return addParameter(&opts.parameters, opts.staticParameters, o, false) +} + +func validateNonceOption(value any) (string, error) { + nonce, ok := value.(string) + if !ok || nonce == "" { + return "", fmt.Errorf("%w: nonce must be a non-empty string", ErrParameter) + } + + if err := validateParameter(Nonce, nonce); err != nil { + return "", err + } + + return nonce, nil +} + +// WithValidityTolerance specifies the allowed clock skew for created and +// expires timestamp checks. +func WithValidityTolerance(d time.Duration) VerifierOption { + return verifierOptionFunc(func(_ *verifier, e *verificationPolicy, _ bool) error { + e.tolerance = d + + return nil + }) +} + +// WithMaxAge specifies the maximum allowed age of a signature with a +// created timestamp. +func WithMaxAge(d time.Duration) VerifierOption { + return verifierOptionFunc(func(_ *verifier, e *verificationPolicy, _ bool) error { + e.maxAge = d + + return nil + }) +} + +// WithRequiredTag specifies a required application-defined tag and its +// per-tag verifier options. Each non-empty tag may be configured only once. +func WithRequiredTag(tag string, opts ...VerifierOption) VerifierOption { + return verifierOptionFunc(func(ver *verifier, _ *verificationPolicy, f bool) error { + if f { + panic("WithRequiredTag cannot be used as option for itself") + } + + if len(tag) == 0 { + return fmt.Errorf("%w: required tag must not be empty", ErrParameter) + } + + if _, configured := ver.tagPolicies[tag]; configured { + return fmt.Errorf("%w: requirements for tag %s are already configured", ErrParameter, tag) + } + + policy := &verificationPolicy{ + tolerance: -1, + maxAge: -1, + } + + for _, opt := range opts { + if err := opt.applyVerifierOption(ver, policy, true); err != nil { + return err + } + } + + ver.tagPolicies[tag] = policy + + return nil + }) +} + +// WithValidateAllSignatures selects all signatures for verification, rather +// than only those with required tags. +func WithValidateAllSignatures() VerifierOption { + return verifierOptionFunc(func(v *verifier, _ *verificationPolicy, _ bool) error { + v.validateAllSigs = true + + return nil + }) +} + +// WithCreatedTimestamp specifies whether the created parameter is required +// during verification or requested in Accept-Signature. False makes it +// optional during verification and omits it from Accept-Signature. +func WithCreatedTimestamp(flag bool) createdTimestampOption { + return createdTimestampOption(flag) +} + +type createdTimestampOption bool + +func (o createdTimestampOption) applyVerifierOption(_ *verifier, policy *verificationPolicy, _ bool) error { + flag := bool(o) + policy.reqCreatedTS = &flag + + return nil +} + +func (o createdTimestampOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + asb.addCreatedTS = bool(o) + + return nil +} + +// WithExpiresTimestamp specifies whether the expires parameter is required +// during verification or requested in Accept-Signature. False makes it +// optional during verification and omits it from Accept-Signature. +func WithExpiresTimestamp(flag bool) expiredTimestampOption { + return expiredTimestampOption(flag) +} + +type expiredTimestampOption bool + +func (o expiredTimestampOption) applyVerifierOption(_ *verifier, policy *verificationPolicy, _ bool) error { + flag := bool(o) + policy.reqExpiresTS = &flag + + return nil +} + +func (o expiredTimestampOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + asb.addExpiresTS = bool(o) + + return nil +} + +// WithSignatureNegotiation enables Accept-Signature negotiation based on the +// verifier's requirements. Its options specify additional requests that cannot +// be derived from those requirements. +func WithSignatureNegotiation(opts ...SignatureNegotiationOption) VerifierOption { + no := &sigNegotiationOptions{opts: make([]AcceptSignatureOption, 0, len(opts))} + for _, opt := range opts { + opt.applySignatureNegotiationOption(no) + } + + return verifierOptionFunc(func(_ *verifier, policy *verificationPolicy, _ bool) error { + builder, err := NewAcceptSignature(no.opts...) + if err != nil { + return err + } + + policy.asb = builder + + return nil + }) +} + +// WithSignatureAlgorithm specifies an alg parameter to request in +// Accept-Signature. It does not select a signing algorithm. +func WithSignatureAlgorithm(alg SignatureAlgorithm) signatureAlgorithmOption { + return signatureAlgorithmOption(alg) +} + +type signatureAlgorithmOption SignatureAlgorithm + +func (o signatureAlgorithmOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + asb.signatureAlgorithm = SignatureAlgorithm(o) + + return nil +} + +func (o signatureAlgorithmOption) applySignatureNegotiationOption(opts *sigNegotiationOptions) { + opts.opts = append(opts.opts, o) +} + +// WithNonceGetter configures a nonce source for Accept-Signature, including +// verifier-based negotiation. A nil getter leaves the source unchanged. +func WithNonceGetter(ng NonceGetter) nonceGetterOption { + return nonceGetterOption{getter: ng} +} + +type nonceGetterOption struct { + getter NonceGetter +} + +func (o nonceGetterOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + if o.getter != nil { + asb.nonceGetter = o.getter + } + + return nil +} + +func (o nonceGetterOption) applySignatureNegotiationOption(opts *sigNegotiationOptions) { + opts.opts = append(opts.opts, o) +} + +// WithContentDigestAlgorithmPreferences specifies the algorithms and +// preferences to request in Want-Content-Digest. +func WithContentDigestAlgorithmPreferences(prefs ...AlgorithmPreference) contentDigestAlgorithmPreferencesOption { + return prefs +} + +type contentDigestAlgorithmPreferencesOption []AlgorithmPreference + +func (o contentDigestAlgorithmPreferencesOption) applyAcceptSignatureOption(asb *AcceptSignatureBuilder) error { + if len(o) == 0 { + return nil + } + + algPrefs := make([]string, len(o)) + + for i, pref := range o { + if pref.Algorithm == "" { + return fmt.Errorf("%w: digest algorithm preference requires a non-empty algorithm", ErrParameter) + } + + algPrefs[i] = pref.String() + } + + asb.cdAlgPrefs = algPrefs + + return nil +} + +func (o contentDigestAlgorithmPreferencesOption) applySignatureNegotiationOption(opts *sigNegotiationOptions) { + opts.opts = append(opts.opts, o) +} + +//nolint:cyclop +func addParameter( + parameters *[]parameterOption, + existing []parameterOption, + option parameterOption, + copyBytes bool, +) error { + var err error + + option, err = normalizeParameter(option) + if err != nil { + return err + } + + for _, param := range existing { + if param.name == option.name { + return fmt.Errorf("%w: duplicate signature parameter %q", ErrParameter, option.name) + } + } + + for _, param := range *parameters { + if param.name == option.name { + return fmt.Errorf("%w: duplicate signature parameter %q", ErrParameter, option.name) + } + } + + if copyBytes { + if v, ok := option.value.([]byte); ok { + option.value = bytes.Clone(v) + } + } + + *parameters = append(*parameters, option) + + return nil +} + +func normalizeParameter(option parameterOption) (parameterOption, error) { + switch option.name { + case Created, Expires, KeyID, Alg, Nonce, Tag: + return option, fmt.Errorf("%w: %q is a reserved signature parameter", ErrParameter, option.name) + } + + switch v := option.value.(type) { + case Token: + option.value = httpsfv.Token(v) + case int: + option.value = int64(v) + case string, bool, int64, float64, []byte, httpsfv.Token: + default: + return option, fmt.Errorf("%w: unsupported value type %T for signature parameter %q", + ErrParameter, option.value, option.name) + } + + if err := validateParameter(option.name, option.value); err != nil { + return option, err + } + + return option, nil +} + +func validateParameter(name SignatureParameter, value any) error { + validationParams := httpsfv.NewParams() + validationParams.Add(string(name), value) + + if _, err := httpsfv.Marshal(httpsfv.Item{Value: true, Params: validationParams}); err != nil { + return fmt.Errorf("%w: invalid signature parameter %q: %w", ErrParameter, name, err) + } + + return nil +} diff --git a/options_test.go b/options_test.go new file mode 100644 index 0000000..f2d8523 --- /dev/null +++ b/options_test.go @@ -0,0 +1,1046 @@ +package httpsig + +import ( + "context" + "fmt" + "strings" + "testing" + "time" + + "github.com/dunglas/httpsfv" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestWithLabelForSigner(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + label string + shouldUpdate bool + }{ + "empty label": {shouldUpdate: false}, + "not empty label": {label: "foo", shouldUpdate: true}, + } { + t.Run(uc, func(t *testing.T) { + s := &signer{label: "test"} + + err := WithLabel(tc.label).applySignerOption(s) + require.NoError(t, err) + + if tc.shouldUpdate { + require.Equal(t, tc.label, s.label) + } else { + require.Equal(t, "test", s.label) + } + }) + } +} + +func TestWithLabelForSign(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + label string + want string + }{ + "empty label leaves per-call label unchanged": {want: "initial"}, + "per-call label": {label: "request", want: "request"}, + } { + t.Run(uc, func(t *testing.T) { + opts := &signOptions{label: "initial"} + + err := WithLabel(tc.label).applySignOption(opts) + + require.NoError(t, err) + assert.Equal(t, tc.want, opts.label) + }) + } +} + +func TestWithLabelForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + label string + exp string + }{ + "empty label": {exp: "foo"}, + "custom label": {label: "bar", exp: "bar"}, + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{label: "foo"} + + err := WithLabel(tc.label).applyAcceptSignatureOption(asb) + + require.NoError(t, err) + assert.Equal(t, tc.exp, asb.label) + }) + } +} + +func TestWithTTL(t *testing.T) { + t.Parallel() + + ttl := 1 * time.Second + s := &signer{ttl: 30 * time.Second} + + err := WithTTL(ttl).applySignerOption(s) + + require.NoError(t, err) + require.Equal(t, ttl, s.ttl) +} + +func TestWithComponentsForSigner(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + identifiers []string + err error + }{ + "multiple valid identifier": {identifiers: []string{"@status;req", "@method"}}, + "invalid identifier": {identifiers: []string{"@foo"}, err: ErrUnsupportedComponentIdentifier}, + } { + t.Run(uc, func(t *testing.T) { + s := &signer{} + + err := WithComponents(tc.identifiers...).applySignerOption(s) + + if tc.err != nil { + require.Error(t, err) + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + require.Len(t, s.ids, len(tc.identifiers)) + + for i, id := range s.ids { + vals := strings.Split(tc.identifiers[i], ";") + assert.Equal(t, vals[0], id.Value) + } + } + }) + } +} + +func TestWithComponentsForVerifier(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + identifiers []string + err error + }{ + "multiple valid identifier": {identifiers: []string{"@status;req", "@method"}}, + "invalid identifier": {identifiers: []string{"@foo"}, err: ErrUnsupportedComponentIdentifier}, + } { + t.Run(uc, func(t *testing.T) { + v := &verifier{} + exp := &verificationPolicy{} + + err := WithComponents(tc.identifiers...).applyVerifierOption(v, exp, false) + + if tc.err != nil { + require.Error(t, err) + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + assert.Empty(t, v.tagPolicies) + require.Len(t, exp.identifiers, len(tc.identifiers)) + + for i, id := range exp.identifiers { + vals := strings.Split(tc.identifiers[i], ";") + assert.Equal(t, vals[0], id.Value) + } + } + }) + } +} + +func TestWithComponentsForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + identifiers []string + assert func(t *testing.T, err error, asb *AcceptSignatureBuilder) + }{ + "no identifiers provided": { + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() + + require.NoError(t, err) + assert.False(t, asb.wantContentDigest) + assert.Empty(t, asb.identifiers) + }, + }, + "invalid identifiers provided": { + identifiers: []string{"@foo"}, + assert: func(t *testing.T, err error, _ *AcceptSignatureBuilder) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrUnsupportedComponentIdentifier) + }, + }, + "valid identifiers without content-digest": { + identifiers: []string{"@status", "x-foo-bar"}, + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() + + require.NoError(t, err) + assert.False(t, asb.wantContentDigest) + assert.Len(t, asb.identifiers, 2) + assert.Equal(t, "@status", asb.identifiers[0].Value) + assert.Equal(t, "x-foo-bar", asb.identifiers[1].Value) + }, + }, + "valid identifiers with content-digest": { + identifiers: []string{"@status", "content-digest", "x-foo-bar"}, + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() + + require.NoError(t, err) + assert.True(t, asb.wantContentDigest) + assert.Len(t, asb.identifiers, 3) + assert.Equal(t, "@status", asb.identifiers[0].Value) + assert.Equal(t, "content-digest", asb.identifiers[1].Value) + assert.Equal(t, "x-foo-bar", asb.identifiers[2].Value) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{label: "foo"} + + err := WithComponents(tc.identifiers...).applyAcceptSignatureOption(asb) + + tc.assert(t, err, asb) + }) + } +} + +func TestWithTagForSigner(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + tag string + want string + }{ + "empty tag leaves current tag unchanged": {want: "initial"}, + "custom tag": {tag: "custom", want: "custom"}, + } { + t.Run(uc, func(t *testing.T) { + s := &signer{tag: "initial"} + + err := WithTag(tc.tag).applySignerOption(s) + + require.NoError(t, err) + assert.Equal(t, tc.want, s.tag) + }) + } +} + +func TestWithTagForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, tag := range map[string]string{ + "empty tag": "", + "custom tag": "foo", + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{} + + err := WithTag(tag).applyAcceptSignatureOption(asb) + + require.NoError(t, err) + assert.Equal(t, tag, asb.tag) + }) + } +} + +func TestWithContentDigestAlgorithm(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + alg DigestAlgorithm + err error + }{ + "valid algorithm": {alg: Sha512}, + "invalid algorithm": {alg: DigestAlgorithm("md4"), err: ErrUnsupportedAlgorithm}, + } { + t.Run(uc, func(t *testing.T) { + s := &signer{} + + err := WithContentDigestAlgorithm(tc.alg).applySignerOption(s) + + if tc.err != nil { + require.Error(t, err) + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + assert.Equal(t, tc.alg, s.cdAlg) + } + }) + } +} + +func TestWithKeyIDForSigner(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + keyID string + want string + }{ + "empty key ID": {want: "initial"}, + "key ID set": {keyID: "new-id", want: "new-id"}, + } { + t.Run(uc, func(t *testing.T) { + s := &signer{keyID: "initial"} + + err := WithKeyID(tc.keyID).applySignerOption(s) + + require.NoError(t, err) + assert.Equal(t, tc.want, s.keyID) + }) + } +} + +func TestWithKeyIDForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, keyID := range map[string]string{ + "no actual data provided": "", + "KeyAlg provided": "test", + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{} + + err := WithKeyID(keyID).applyAcceptSignatureOption(asb) + + require.NoError(t, err) + assert.Equal(t, keyID, asb.keyID) + }) + } +} + +func TestWithAlgForSigner(t *testing.T) { + t.Parallel() + + s := &signer{} + + err := WithAlg().applySignerOption(s) + + require.NoError(t, err) + assert.True(t, s.includeAlg) +} + +func TestWithParameterForSigner(t *testing.T) { + t.Parallel() + + t.Run("supported parameter types", func(t *testing.T) { + for uc, tc := range map[string]struct { + value any + want any + }{ + "string": {value: "value", want: "value"}, + "token": {value: Token("value"), want: httpsfv.Token("value")}, + "integer": {value: 42, want: int64(42)}, + "int64": {value: int64(42), want: int64(42)}, + "decimal": {value: 1.5, want: 1.5}, + "boolean": {value: true, want: true}, + "byte sequence": {value: []byte("value"), want: []byte("value")}, + } { + t.Run(uc, func(t *testing.T) { + s := &signer{} + + err := WithParameter("example", tc.value).applySignerOption(s) + + require.NoError(t, err) + require.Len(t, s.parameters, 1) + assert.Equal(t, SignatureParameter("example"), s.parameters[0].name) + assert.Equal(t, tc.want, s.parameters[0].value) + }) + } + }) + + t.Run("static byte sequence is copied", func(t *testing.T) { + value := []byte("before") + s := &signer{} + + err := WithParameter("example", value).applySignerOption(s) + require.NoError(t, err) + + value[0] = 'X' + assert.Equal(t, []byte("before"), s.parameters[0].value) + }) + + for uc, param := range map[string]parameterOption{ + "reserved parameter": WithParameter("created", int64(1)), + "static nonce": WithParameter("nonce", "fixed"), + "invalid name": WithParameter("invalid name", "value"), + "invalid string": WithParameter("example", "bad\nvalue"), + "unsupported type": WithParameter("example", struct{}{}), + } { + t.Run(uc, func(t *testing.T) { + s := &signer{} + + err := param.applySignerOption(s) + + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, s.parameters) + }) + } + + t.Run("duplicate parameter", func(t *testing.T) { + s := &signer{} + require.NoError(t, WithParameter("example", "first").applySignerOption(s)) + + err := WithParameter("example", "second").applySignerOption(s) + + require.ErrorIs(t, err, ErrParameter) + require.Len(t, s.parameters, 1) + assert.Equal(t, "first", s.parameters[0].value) + }) +} + +func TestWithParameterForSign(t *testing.T) { + t.Parallel() + + t.Run("per-call nonce", func(t *testing.T) { + opts := &signOptions{} + + err := WithParameter("nonce", "request-nonce").applySignOption(opts) + + require.NoError(t, err) + assert.True(t, opts.nonceSet) + assert.Equal(t, "request-nonce", opts.nonce) + assert.Empty(t, opts.parameters) + }) + + t.Run("additional parameter", func(t *testing.T) { + opts := &signOptions{} + + err := WithParameter("extension", Token("value")).applySignOption(opts) + + require.NoError(t, err) + require.Len(t, opts.parameters, 1) + assert.Equal(t, SignatureParameter("extension"), opts.parameters[0].name) + assert.Equal(t, httpsfv.Token("value"), opts.parameters[0].value) + }) + + for uc, param := range map[string]parameterOption{ + "empty nonce": WithParameter("nonce", ""), + "nonce with incorrect type": WithParameter("nonce", Token("value")), + "invalid nonce string": WithParameter("nonce", "bad\nvalue"), + "reserved parameter": WithParameter("expires", int64(1)), + } { + t.Run(uc, func(t *testing.T) { + opts := &signOptions{} + + err := param.applySignOption(opts) + + require.ErrorIs(t, err, ErrParameter) + assert.False(t, opts.nonceSet) + assert.Empty(t, opts.parameters) + }) + } + + t.Run("duplicate nonce", func(t *testing.T) { + opts := &signOptions{} + require.NoError(t, WithParameter("nonce", "first").applySignOption(opts)) + + err := WithParameter("nonce", "second").applySignOption(opts) + + require.ErrorIs(t, err, ErrParameter) + assert.Equal(t, "first", opts.nonce) + }) + + t.Run("duplicate additional parameter", func(t *testing.T) { + opts := &signOptions{} + require.NoError(t, WithParameter("extension", "first").applySignOption(opts)) + + err := WithParameter("extension", "second").applySignOption(opts) + + require.ErrorIs(t, err, ErrParameter) + require.Len(t, opts.parameters, 1) + assert.Equal(t, "first", opts.parameters[0].value) + }) + + t.Run("collision with a static parameter", func(t *testing.T) { + opts := &signOptions{ + staticParameters: []parameterOption{{name: "extension", value: "static"}}, + } + + err := WithParameter("extension", "per-call").applySignOption(opts) + + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, opts.parameters) + }) +} + +func TestWithParameterForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + value any + want any + }{ + "string": {value: "value", want: "value"}, + "token": {value: Token("value"), want: httpsfv.Token("value")}, + "integer": {value: 42, want: int64(42)}, + "decimal": {value: 1.5, want: 1.5}, + "boolean": {value: true, want: true}, + "byte sequence": {value: []byte("value"), want: []byte("value")}, + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{} + + err := WithParameter("example", tc.value).applyAcceptSignatureOption(asb) + + require.NoError(t, err) + require.Len(t, asb.parameters, 1) + assert.Equal(t, SignatureParameter("example"), asb.parameters[0].name) + assert.Equal(t, tc.want, asb.parameters[0].value) + }) + } + + t.Run("static byte sequence is copied", func(t *testing.T) { + value := []byte("before") + asb := &AcceptSignatureBuilder{} + + err := WithParameter("example", value).applyAcceptSignatureOption(asb) + require.NoError(t, err) + + value[0] = 'X' + assert.Equal(t, []byte("before"), asb.parameters[0].value) + }) + + for uc, param := range map[string]parameterOption{ + "reserved parameter": WithParameter("created", int64(1)), + "static nonce": WithParameter("nonce", "fixed"), + "invalid name": WithParameter("invalid name", "value"), + "invalid string": WithParameter("example", "bad\nvalue"), + "unsupported type": WithParameter("example", struct{}{}), + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{} + + err := param.applyAcceptSignatureOption(asb) + + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, asb.parameters) + }) + } + + t.Run("duplicate parameter", func(t *testing.T) { + asb := &AcceptSignatureBuilder{} + require.NoError(t, WithParameter("example", "first").applyAcceptSignatureOption(asb)) + + err := WithParameter("example", "second").applyAcceptSignatureOption(asb) + + require.ErrorIs(t, err, ErrParameter) + require.Len(t, asb.parameters, 1) + assert.Equal(t, "first", asb.parameters[0].value) + }) +} + +func TestWithParameterForAcceptSignatureBuild(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + param parameterOption + want any + wantErr bool + }{ + "nonce": {param: WithParameter("nonce", "request-nonce"), want: "request-nonce"}, + "extension": {param: WithParameter("extension", Token("value")), want: httpsfv.Token("value")}, + "empty nonce": {param: WithParameter("nonce", ""), wantErr: true}, + "nonce with incorrect type": {param: WithParameter("nonce", Token("value")), wantErr: true}, + "invalid nonce string": {param: WithParameter("nonce", "bad\nvalue"), wantErr: true}, + "reserved parameter": {param: WithParameter("created", true), wantErr: true}, + "invalid extension": {param: WithParameter("extension", "bad\nvalue"), wantErr: true}, + } { + t.Run(uc, func(t *testing.T) { + opts := &acceptSignatureBuildOptions{} + + err := tc.param.applyAcceptSignatureBuildOption(opts) + + if tc.wantErr { + require.ErrorIs(t, err, ErrParameter) + assert.False(t, opts.nonceSet) + assert.Empty(t, opts.parameters) + + return + } + + require.NoError(t, err) + + if tc.param.name == "nonce" { + assert.True(t, opts.nonceSet) + assert.Equal(t, tc.want, opts.nonce) + } else { + require.Len(t, opts.parameters, 1) + assert.Equal(t, tc.want, opts.parameters[0].value) + } + }) + } + + t.Run("duplicate nonce", func(t *testing.T) { + opts := &acceptSignatureBuildOptions{} + require.NoError(t, WithParameter("nonce", "first").applyAcceptSignatureBuildOption(opts)) + + err := WithParameter("nonce", "second").applyAcceptSignatureBuildOption(opts) + + require.ErrorIs(t, err, ErrParameter) + assert.Equal(t, "first", opts.nonce) + }) + + t.Run("duplicate extension", func(t *testing.T) { + opts := &acceptSignatureBuildOptions{} + require.NoError(t, WithParameter("extension", "first").applyAcceptSignatureBuildOption(opts)) + + err := WithParameter("extension", "second").applyAcceptSignatureBuildOption(opts) + + require.ErrorIs(t, err, ErrParameter) + require.Len(t, opts.parameters, 1) + assert.Equal(t, "first", opts.parameters[0].value) + }) + + t.Run("extension conflicts with static parameter", func(t *testing.T) { + opts := &acceptSignatureBuildOptions{ + staticParameters: []parameterOption{{name: "extension", value: "static"}}, + } + + err := WithParameter("extension", "per-call").applyAcceptSignatureBuildOption(opts) + + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, opts.parameters) + }) +} + +func TestWithValidityTolerance(t *testing.T) { + t.Parallel() + + v := &verifier{} + exp := &verificationPolicy{} + + err := WithValidityTolerance(1*time.Minute).applyVerifierOption(v, exp, false) + require.NoError(t, err) + + assert.Empty(t, v.tagPolicies) + assert.Equal(t, 1*time.Minute, exp.tolerance) +} + +func TestWithMaxAge(t *testing.T) { + t.Parallel() + + v := &verifier{} + exp := &verificationPolicy{} + + err := WithMaxAge(15*time.Minute).applyVerifierOption(v, exp, false) + require.NoError(t, err) + + assert.Equal(t, 15*time.Minute, exp.maxAge) +} + +func TestWithRequiredTag(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + opts []VerifierOption + assert func(t *testing.T, err error, exp *verificationPolicy) + }{ + "without options": { + assert: func(t *testing.T, err error, exp *verificationPolicy) { + t.Helper() + + require.NoError(t, err) + require.NotNil(t, exp) + assert.Empty(t, exp.identifiers) + assert.Equal(t, time.Duration(-1), exp.tolerance) //nolint:testifylint + }, + }, + "with identifiers only": { + opts: []VerifierOption{ + WithComponents("@status"), + }, + assert: func(t *testing.T, err error, exp *verificationPolicy) { + t.Helper() + + require.NoError(t, err) + require.NotNil(t, exp) + assert.Len(t, exp.identifiers, 1) + assert.Equal(t, "@status", exp.identifiers[0].Value) + assert.Equal(t, time.Duration(-1), exp.tolerance) //nolint:testifylint + }, + }, + "with tolerance only": { + opts: []VerifierOption{ + WithValidityTolerance(5 * time.Minute), + }, + assert: func(t *testing.T, err error, exp *verificationPolicy) { + t.Helper() + + require.NoError(t, err) + require.NotNil(t, exp) + assert.Empty(t, exp.identifiers) + assert.Equal(t, 5*time.Minute, exp.tolerance) + }, + }, + "with all possible options": { + opts: []VerifierOption{ + WithComponents("@status"), + WithValidityTolerance(5 * time.Minute), + }, + assert: func(t *testing.T, err error, exp *verificationPolicy) { + t.Helper() + + require.NoError(t, err) + require.NotNil(t, exp) + assert.Len(t, exp.identifiers, 1) + assert.Equal(t, "@status", exp.identifiers[0].Value) + assert.Equal(t, 5*time.Minute, exp.tolerance) + }, + }, + "with unsupported identifier": { + opts: []VerifierOption{ + WithComponents("@foo"), + }, + assert: func(t *testing.T, err error, exp *verificationPolicy) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrUnsupportedComponentIdentifier) + require.Nil(t, exp) + }, + }, + "with nested WithRequiredTag": { + opts: []VerifierOption{ + WithRequiredTag("foo"), + }, + assert: func(t *testing.T, err error, _ *verificationPolicy) { + t.Helper() + + require.Error(t, err) + require.ErrorContains(t, err, "WithRequiredTag") + }, + }, + } { + t.Run(uc, func(t *testing.T) { + v := &verifier{tagPolicies: make(map[string]*verificationPolicy)} + + recoverIfPanics := func(t *testing.T, f func() error) (err error) { + t.Helper() + + defer func() { + var ok bool + + if res := recover(); res != nil { + if err, ok = res.(error); !ok { + err = fmt.Errorf("%v", res) + } + } + }() + + err = f() + + return + } + + err := recoverIfPanics(t, func() error { + return WithRequiredTag("test", tc.opts...).applyVerifierOption(v, nil, false) + }) + if err == nil { + require.Len(t, v.tagPolicies, 1) + } + + tc.assert(t, err, v.tagPolicies["test"]) + }) + } + + t.Run("empty required tag", func(t *testing.T) { + v := &verifier{tagPolicies: make(map[string]*verificationPolicy)} + + err := WithRequiredTag("").applyVerifierOption(v, nil, false) + + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, v.tagPolicies) + }) + + t.Run("with duplicate WithRequiredTag", func(t *testing.T) { + v := &verifier{tagPolicies: map[string]*verificationPolicy{"foo": {}}} + + err := WithRequiredTag("foo", nil).applyVerifierOption(v, nil, false) + require.Error(t, err) + require.ErrorIs(t, err, ErrParameter) + require.ErrorContains(t, err, "already configured") + }) +} + +func TestWithValidateAllSignatures(t *testing.T) { + t.Parallel() + + v := &verifier{} + + err := WithValidateAllSignatures().applyVerifierOption(v, &verificationPolicy{}, false) + + require.NoError(t, err) + assert.True(t, v.validateAllSigs) +} + +func TestWithCreatedTimestampForVerifier(t *testing.T) { + t.Parallel() + + for uc, required := range map[string]bool{ + "timestamp required": true, + "timestamp optional": false, + } { + t.Run(uc, func(t *testing.T) { + exp := &verificationPolicy{} + + err := WithCreatedTimestamp(required).applyVerifierOption(&verifier{}, exp, false) + + require.NoError(t, err) + require.NotNil(t, exp.reqCreatedTS) + assert.Equal(t, *exp.reqCreatedTS, required) + }) + } +} + +func TestWithCreatedTimestampForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, requested := range map[string]bool{ + "timestamp requested": true, + "timestamp not requested": false, + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{addCreatedTS: !requested} + + err := WithCreatedTimestamp(requested).applyAcceptSignatureOption(asb) + + require.NoError(t, err) + assert.Equal(t, requested, asb.addCreatedTS) + }) + } +} + +func TestWithExpiresTimestampForVerifier(t *testing.T) { + t.Parallel() + + for uc, required := range map[string]bool{ + "timestamp required": true, + "timestamp optional": false, + } { + t.Run(uc, func(t *testing.T) { + exp := &verificationPolicy{} + + err := WithExpiresTimestamp(required).applyVerifierOption(&verifier{}, exp, false) + + require.NoError(t, err) + require.NotNil(t, exp.reqExpiresTS) + assert.Equal(t, *exp.reqExpiresTS, required) + }) + } +} + +func TestWithExpiresTimestampForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, requested := range map[string]bool{ + "timestamp requested": true, + "timestamp not requested": false, + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{addExpiresTS: !requested} + + err := WithExpiresTimestamp(requested).applyAcceptSignatureOption(asb) + + require.NoError(t, err) + assert.Equal(t, requested, asb.addExpiresTS) + }) + } +} + +func TestWithSignatureNegotiation(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + opts []SignatureNegotiationOption + assert func(t *testing.T, err error, asb *AcceptSignatureBuilder) + }{ + "without options": { + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() + + require.NoError(t, err) + + require.NotNil(t, asb) + assert.Nil(t, asb.nonceGetter) + assert.Equal(t, "sig", asb.label) + assert.ElementsMatch(t, asb.cdAlgPrefs, []string{"sha-256=5", "sha-512=10"}) + assert.Empty(t, asb.signatureAlgorithm) + assert.Empty(t, asb.keyID) + // not set by any of the options + assert.True(t, asb.addCreatedTS) + assert.True(t, asb.addExpiresTS) + assert.False(t, asb.wantContentDigest) + assert.Empty(t, asb.tag) + assert.Empty(t, asb.identifiers) + }, + }, + "with all possible options": { + opts: []SignatureNegotiationOption{ + WithLabel("foo"), + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), + WithSignatureAlgorithm(RsaPssSha512), + WithKeyID("bar"), + WithParameter("audience", "service-a"), + WithContentDigestAlgorithmPreferences(AlgorithmPreference{Sha512, 2}), + }, + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() + + require.NoError(t, err) + + require.NotNil(t, asb) + require.NotNil(t, asb.nonceGetter) + nonce, err := asb.nonceGetter.GetNonce(context.TODO()) + require.NoError(t, err) + require.Equal(t, "abc", nonce) + assert.Equal(t, "foo", asb.label) + assert.ElementsMatch(t, asb.cdAlgPrefs, []string{"sha-512=2"}) + assert.Equal(t, RsaPssSha512, asb.signatureAlgorithm) + assert.Equal(t, "bar", asb.keyID) + require.Len(t, asb.parameters, 1) + assert.Equal(t, parameterOption{name: "audience", value: "service-a"}, asb.parameters[0]) + // not set by any of the options + assert.True(t, asb.addCreatedTS) + assert.True(t, asb.addExpiresTS) + assert.False(t, asb.wantContentDigest) + assert.Empty(t, asb.tag) + assert.Empty(t, asb.identifiers) + }, + }, + "with invalid custom parameter": { + opts: []SignatureNegotiationOption{WithParameter("created", true)}, + assert: func(t *testing.T, err error, _ *AcceptSignatureBuilder) { + t.Helper() + + require.ErrorIs(t, err, ErrParameter) + }, + }, + "with error while applying the option": { + opts: []SignatureNegotiationOption{ + WithContentDigestAlgorithmPreferences(AlgorithmPreference{}), + }, + assert: func(t *testing.T, err error, _ *AcceptSignatureBuilder) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrParameter) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + v := &verifier{} + exp := &verificationPolicy{} + + err := WithSignatureNegotiation(tc.opts...).applyVerifierOption(v, exp, false) + + tc.assert(t, err, exp.asb) + }) + } +} + +func TestWithSignatureAlgorithmForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, alg := range map[string]SignatureAlgorithm{ + "no actual data provided": SignatureAlgorithm(""), + "KeyAlg provided": RsaPssSha512, + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{} + + err := WithSignatureAlgorithm(alg).applyAcceptSignatureOption(asb) + + require.NoError(t, err) + assert.Equal(t, alg, asb.signatureAlgorithm) + }) + } +} + +func TestWithNonceGetterForAcceptSignature(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + ng NonceGetter + exp NonceGetter + }{ + "nil NonceGetter": {}, + "custom NonceGetter": {ng: &NonceGetterMock{}, exp: &NonceGetterMock{}}, + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{} + + err := WithNonceGetter(tc.ng).applyAcceptSignatureOption(asb) + + require.NoError(t, err) + assert.Equal(t, tc.exp, asb.nonceGetter) + }) + } +} + +func TestWithNonceGetterNilDoesNotReplaceExisting(t *testing.T) { + t.Parallel() + + getter := &NonceGetterMock{} + builder := &AcceptSignatureBuilder{nonceGetter: getter} + + err := WithNonceGetter(nil).applyAcceptSignatureOption(builder) + + require.NoError(t, err) + assert.Same(t, getter, builder.nonceGetter) +} + +func TestWithContentDigestAlgorithmPreferences(t *testing.T) { + t.Parallel() + + defaultPreference := AlgorithmPreference{Algorithm: Sha256, Preference: 2}.String() + + for uc, tc := range map[string]struct { + prefs []AlgorithmPreference + expErr error + expPrefs []string + }{ + "no preferences provided": { + expPrefs: []string{defaultPreference}, + }, + "no algorithm provided in a preference": { + prefs: []AlgorithmPreference{{Sha256, 0}, {DigestAlgorithm(""), 0}}, + expErr: ErrParameter, + expPrefs: []string{defaultPreference}, + }, + "valid options provided": { + prefs: []AlgorithmPreference{{Sha512, 0}, {Sha256, 1}}, + expPrefs: []string{ + AlgorithmPreference{Sha512, 0}.String(), + AlgorithmPreference{Sha256, 1}.String(), + }, + }, + } { + t.Run(uc, func(t *testing.T) { + asb := &AcceptSignatureBuilder{ + cdAlgPrefs: []string{defaultPreference}, + } + + err := WithContentDigestAlgorithmPreferences(tc.prefs...).applyAcceptSignatureOption(asb) + + if tc.expErr != nil { + require.Error(t, err) + require.ErrorIs(t, err, tc.expErr) + } else { + require.NoError(t, err) + require.ElementsMatch(t, asb.cdAlgPrefs, tc.expPrefs) + } + }) + } +} diff --git a/patch.go b/patch.go index 196782e..b4290dc 100644 --- a/patch.go +++ b/patch.go @@ -2,11 +2,7 @@ package httpsig import "time" -// replaced in tests to have the behavior required to use/verify -// vectors data provided in RFC9421 +// replaced in tests to use the timestamps from the RFC 9421 test vectors. // //nolint:gochecknoglobals -var ( - currentTime = time.Now - filterAlgorithm = func(alg SignatureAlgorithm) SignatureAlgorithm { return alg } -) +var currentTime = time.Now diff --git a/serializer.go b/serializer.go index fb73a6a..fb224e7 100644 --- a/serializer.go +++ b/serializer.go @@ -11,6 +11,9 @@ import ( var errSerialization = errors.New("serialization error") +//nolint:gochecknoglobals +var byteSequenceWhitespace = regexp.MustCompile(`\s+`) + type serializer interface { serialize(v []string) ([]string, error) } @@ -51,7 +54,7 @@ func newSerializer(params *httpsfv.Params, isRequest bool) (serializer, error) { case isSf || isKey: return &strictSerializer{key: key}, nil case isBs: - return &byteSequenceSerializer{regex: regexp.MustCompile(`\s+`)}, nil + return &byteSequenceSerializer{}, nil default: return &rawSerializer{}, nil } @@ -63,9 +66,7 @@ func (s *rawSerializer) serialize(v []string) ([]string, error) { return v, nil } -type byteSequenceSerializer struct { - regex *regexp.Regexp -} +type byteSequenceSerializer struct{} func (s *byteSequenceSerializer) serialize(v []string) ([]string, error) { encoded := make([]string, len(v)) @@ -73,7 +74,7 @@ func (s *byteSequenceSerializer) serialize(v []string) ([]string, error) { for i, sv := range v { values := strings.Split(sv, ",") for j, v := range values { - values[j] = s.regex.ReplaceAllString(strings.TrimSpace(v), " ") + values[j] = byteSequenceWhitespace.ReplaceAllString(strings.TrimSpace(v), " ") } item := httpsfv.NewItem([]byte(strings.Join(values, ", "))) diff --git a/signature_base.go b/signature_base.go index 23afc74..db60b2f 100644 --- a/signature_base.go +++ b/signature_base.go @@ -1,95 +1,131 @@ package httpsig import ( - "bytes" "fmt" "strings" "github.com/dunglas/httpsfv" ) -type signatureBase []component +type serializedComponent struct { + identifier string + value string +} + +// The entries correspond to input.identifiers by index. Signature parameters are separate. +type signatureBase struct { + input *signatureInput + entries []serializedComponent + signatureParams string +} + +func newSignatureBase(msg *Message, si *signatureInput, prepared []string) (signatureBase, error) { + if prepared != nil && len(prepared) != len(si.identifiers) { + return signatureBase{}, fmt.Errorf("%w: mismatched serialized component identifiers", ErrMalformedData) + } -func newSignatureBase(si *signatureInput, msg *Message) (signatureBase, error) { marshalledSigParams, err := httpsfv.Marshal(si.value) if err != nil { - return nil, err + return signatureBase{}, err } - sigBase := make(signatureBase, 0, len(si.identifiers)+1) + sigBase := signatureBase{ + input: si, + entries: make([]serializedComponent, 0, len(si.identifiers)), + signatureParams: marshalledSigParams, + } seen := make(map[string]struct{}, len(si.identifiers)) - for _, ci := range si.identifiers { - identifier, err := httpsfv.Marshal(ci.Item) - if err != nil { - return nil, err + for i, ci := range si.identifiers { + var identifier string + if prepared == nil { + identifier, err = httpsfv.Marshal(ci.Item) + if err != nil { + return signatureBase{}, err + } + } else { + identifier = prepared[i] } if _, ok := seen[identifier]; ok { - return nil, fmt.Errorf("%w: duplicate component identifier %s", ErrMalformedData, identifier) + return signatureBase{}, fmt.Errorf("%w: duplicate component identifier %s", ErrMalformedData, identifier) } seen[identifier] = struct{}{} comp, err := ci.createComponent(msg) if err != nil { - return nil, err + return signatureBase{}, err } - sigBase = append(sigBase, comp) + sigBase.entries = append(sigBase.entries, serializedComponent{ + identifier: identifier, + value: comp.canonicalValue(), + }) } - sigBase = append(sigBase, component{ - key: &componentIdentifier{Item: httpsfv.NewItem("@signature-params")}, - value: []string{marshalledSigParams}, - }) - return sigBase, nil } -func (s signatureBase) marshal() ([]byte, error) { - var buf bytes.Buffer +func (s signatureBase) marshal() []byte { + // calculate size + size := 0 + for i, item := range s.entries { + size += len(item.identifier) + len(": ") + len(item.value) + if i > 0 { + size++ + } + } - for i, item := range s { - marshalledKey, err := httpsfv.Marshal(item.key.Item) - if err != nil { - return nil, err + if s.signatureParams != "" { + size += len(`"@signature-params": `) + len(s.signatureParams) + if len(s.entries) > 0 { + size++ } + } + + if size == 0 { + return nil + } + // do the actual marshalling + buf := make([]byte, 0, size) + + for i, item := range s.entries { if i > 0 { - buf.WriteByte('\n') + buf = append(buf, '\n') } - buf.WriteString(marshalledKey) - buf.WriteString(": ") - buf.WriteString(item.canonicalValue()) + buf = append(buf, item.identifier...) + buf = append(buf, ':', ' ') + buf = append(buf, item.value...) } - return buf.Bytes(), nil -} + if s.signatureParams != "" { + if len(s.entries) > 0 { + buf = append(buf, '\n') + } -func (s signatureBase) components() (map[string]string, error) { - result := make(map[string]string, len(s)) + buf = append(buf, `"@signature-params": `...) + buf = append(buf, s.signatureParams...) + } - for _, component := range s { - name := component.key.Value.(string) // nolint: forcetypeassert + return buf +} - if name == "@signature-params" { - continue - } +func (s signatureBase) components() map[string]string { + result := make(map[string]string, len(s.entries)) - identifier, err := httpsfv.Marshal(component.key.Item) - if err != nil { - return nil, err - } + for i, item := range s.entries { + name := s.input.identifiers[i].Value.(string) // nolint: forcetypeassert // Remove quotes around the component name, // preserving identifier parameters. prefix := `"` + name + `"` - key := name + strings.TrimPrefix(identifier, prefix) + key := name + strings.TrimPrefix(item.identifier, prefix) - result[key] = component.canonicalValue() + result[key] = item.value } - return result, nil + return result } diff --git a/signature_base_test.go b/signature_base_test.go index 3078f49..dfd1b19 100644 --- a/signature_base_test.go +++ b/signature_base_test.go @@ -39,13 +39,11 @@ func TestNewSignatureBase(t *testing.T) { created, err := time.Parse(time.RFC1123, "Tue, 20 Apr 2021 02:07:53 GMT") require.NoError(t, err) - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { components []string assert func(t *testing.T, err error, base signatureBase) }{ - { - uc: "successful signature base creation", + "successful signature base creation": { components: []string{ "@method", "@authority", "@path", "content-digest", "content-length", "content-type", }, @@ -62,14 +60,12 @@ func TestNewSignatureBase(t *testing.T) { "content-type": application/json "@signature-params": ("@method" "@authority" "@path" "content-digest" "content-length" "content-type");created=1618884473;keyid="test-key-rsa-pss"` - sigBase, err := base.marshal() - require.NoError(t, err) + sigBase := base.marshal() assert.Equal(t, expected, string(sigBase)) }, }, - { - uc: "failing for duplicate component identifier", + "failing for duplicate component identifier": { components: []string{ "@method", "@method", }, @@ -81,8 +77,7 @@ func TestNewSignatureBase(t *testing.T) { require.ErrorContains(t, err, "duplicate component identifier") }, }, - { - uc: "failing for duplicate parameterized component identifier", + "failing for duplicate parameterized component identifier": { components: []string{ `@query-param;name="Pet"`, `@query-param;name="Pet"`, @@ -95,8 +90,7 @@ func TestNewSignatureBase(t *testing.T) { require.ErrorContains(t, err, "duplicate component identifier") }, }, - { - uc: "failing for unknown component identifier", + "failing for unknown component identifier": { components: []string{"@status"}, assert: func(t *testing.T, err error, _ signatureBase) { t.Helper() @@ -106,8 +100,7 @@ func TestNewSignatureBase(t *testing.T) { require.ErrorContains(t, err, "@status") }, }, - { - uc: "allowing same component identifier with different parameters", + "allowing same component identifier with different parameters": { components: []string{ `@query-param;name="Pet"`, `@query-param;name="Cat"`, @@ -121,14 +114,13 @@ func TestNewSignatureBase(t *testing.T) { "@query-param";name="Cat": meow "@signature-params": ("@query-param";name="Pet" "@query-param";name="Cat");created=1618884473;keyid="test-key-rsa-pss"` - sigBase, err := base.marshal() - require.NoError(t, err) + sigBase := base.marshal() assert.Equal(t, expected, string(sigBase)) }, }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { identifiers, err := toComponentIdentifiers(tc.components) require.NoError(t, err) @@ -138,99 +130,147 @@ func TestNewSignatureBase(t *testing.T) { si := newSignatureInput(identifiers, params) - sigBase, err := newSignatureBase(si, msg) + sigBase, err := newSignatureBase(msg, si, nil) tc.assert(t, err, sigBase) }) } } -func TestSignatureBaseMarshal(t *testing.T) { +func TestNewSignatureBaseWithPreparedIdentifiers(t *testing.T) { t.Parallel() - msg := &Message{Method: "GET", Authority: "foo.bar", IsRequest: true} + for name, identifiers := range map[string][]string{ + "no covered components": {}, + "simple component": {"@method"}, + "several components": {"@method", "@authority", "x-example"}, + "parameterized components": {"@method", `@query-param;name="Pet"`, `@query-param;name="Cat"`}, + "duplicate component": {"@method", "@method"}, + "duplicate parameterized item": {`@query-param;name="Pet"`, `@query-param;name="Pet"`}, + } { + t.Run(name, func(t *testing.T) { + t.Parallel() - ci, err := toComponentIdentifiers([]string{"@authority", "@method"}) - require.NoError(t, err) + sgnr, err := NewSigner( + Key{Algorithm: HmacSha256, Material: []byte("test-hmac-key")}, + WithComponents(identifiers...), + ) + require.NoError(t, err) + + s := sgnr.(*signer) + + require.Len(t, s.serializedIdentifiers, len(s.ids)) + + for i, id := range s.ids { + want, marshalErr := httpsfv.Marshal(id.Item) + require.NoError(t, marshalErr) + assert.Equal(t, want, s.serializedIdentifiers[i]) + } - list := make(signatureBase, len(ci)) + msg := &Message{ + Method: "GET", Authority: "example.com", + URL: &url.URL{Path: "/foo", RawQuery: "Pet=dog&Cat=meow"}, + Header: http.Header{"X-Example": []string{"value"}}, + IsRequest: true, + } + input := s.signatureInput(signOptions{}) + uncached, uncachedErr := newSignatureBase(msg, input, nil) + prepared, preparedErr := newSignatureBase(msg, input, s.serializedIdentifiers) - for i, id := range ci { - c, err := id.createComponent(msg) - require.NoError(t, err) + if uncachedErr != nil { + require.ErrorIs(t, preparedErr, ErrMalformedData) + require.ErrorIs(t, uncachedErr, ErrMalformedData) - list[i] = c + return + } + + require.NoError(t, preparedErr) + assert.Equal(t, uncached.marshal(), prepared.marshal()) + assert.Equal(t, uncached.components(), prepared.components()) + }) } +} - res, err := list.marshal() +func TestNewSignatureBaseWithInvalidPreparedIdentifierCount(t *testing.T) { + t.Parallel() + + ids, err := toComponentIdentifiers([]string{"@method"}) require.NoError(t, err) - assert.Equal(t, "\"@authority\": foo.bar\n\"@method\": GET", string(res)) + input := newSignatureInput(ids, httpsfv.NewParams()) + msg := &Message{Method: "GET", IsRequest: true} + + _, err = newSignatureBase(msg, input, []string{"one", "two"}) + + require.ErrorIs(t, err, ErrMalformedData) } -func TestSignatureBaseComponents(t *testing.T) { +func TestSignatureBaseMarshal(t *testing.T) { t.Parallel() - petParams := httpsfv.NewParams() - petParams.Add("name", "Pet") - - catParams := httpsfv.NewParams() - catParams.Add("name", "Cat") + for name, tc := range map[string]struct { + base signatureBase + want string + }{ + "empty": {}, + "signature parameters only": { + base: signatureBase{signatureParams: `("@method");created=123`}, + want: `"@signature-params": ("@method");created=123`, + }, + "single component without parameters": { + base: signatureBase{entries: []serializedComponent{{identifier: `"@method"`, value: "GET"}}}, + want: `"@method": GET`, + }, + "multiple components without parameters": { + base: signatureBase{entries: []serializedComponent{ + {identifier: `"@authority"`, value: "foo.bar"}, + {identifier: `"@method"`, value: "GET"}, + }}, + want: "\"@authority\": foo.bar\n\"@method\": GET", + }, + "empty and UTF-8 component values with parameters": { + base: signatureBase{ + entries: []serializedComponent{ + {identifier: `"x-empty"`, value: ""}, + {identifier: `"x-name"`, value: "Grüße"}, + }, + signatureParams: `("x-empty" "x-name");created=123`, + }, + want: "\"x-empty\": \n\"x-name\": Grüße\n\"@signature-params\": (\"x-empty\" \"x-name\");created=123", + }, + } { + t.Run(name, func(t *testing.T) { + t.Parallel() - agentParams := httpsfv.NewParams() - agentParams.Add("key", "sig1") + assert.Equal(t, tc.want, string(tc.base.marshal())) + }) + } +} - sfParams := httpsfv.NewParams() - sfParams.Add("sf", true) +func TestSignatureBaseComponents(t *testing.T) { + t.Parallel() for uc, tc := range map[string]struct { - base signatureBase - expected map[string]string + names []string + entries []serializedComponent + signatureParams string + expected map[string]string }{ "empty signature base": { - base: signatureBase{}, expected: map[string]string{}, }, "excluding signature parameters": { - base: signatureBase{ - { - key: &componentIdentifier{ - Item: httpsfv.NewItem("@signature-params"), - }, - value: []string{`("@method");created=123`}, - }, - }, - expected: map[string]string{}, + signatureParams: `("@method");created=123`, + expected: map[string]string{}, }, "simple component identifiers": { - base: signatureBase{ - { - key: &componentIdentifier{ - Item: httpsfv.NewItem("@method"), - }, - value: []string{"GET"}, - }, - { - key: &componentIdentifier{ - Item: httpsfv.NewItem("@authority"), - }, - value: []string{"example.com"}, - }, - { - key: &componentIdentifier{ - Item: httpsfv.NewItem("user-agent"), - }, - value: []string{"ExampleBot/1.0"}, - }, - { - key: &componentIdentifier{ - Item: httpsfv.NewItem("@signature-params"), - }, - value: []string{ - `("@method" "@authority" "user-agent")`, - }, - }, + names: []string{"@method", "@authority", "user-agent"}, + entries: []serializedComponent{ + {identifier: `"@method"`, value: "GET"}, + {identifier: `"@authority"`, value: "example.com"}, + {identifier: `"user-agent"`, value: "ExampleBot/1.0"}, }, + signatureParams: `("@method" "@authority" "user-agent")`, expected: map[string]string{ "@method": "GET", "@authority": "example.com", @@ -238,36 +278,11 @@ func TestSignatureBaseComponents(t *testing.T) { }, }, "parameterized component identifiers": { - base: signatureBase{ - { - key: &componentIdentifier{ - Item: httpsfv.Item{ - Value: "@query-param", - Params: petParams, - }, - }, - value: []string{"dog"}, - }, - { - key: &componentIdentifier{ - Item: httpsfv.Item{ - Value: "@query-param", - Params: catParams, - }, - }, - value: []string{"meow"}, - }, - { - key: &componentIdentifier{ - Item: httpsfv.Item{ - Value: "signature-agent", - Params: agentParams, - }, - }, - value: []string{ - `"https://bots.example.com";type=cimd`, - }, - }, + names: []string{"@query-param", "@query-param", "signature-agent"}, + entries: []serializedComponent{ + {identifier: `"@query-param";name="Pet"`, value: "dog"}, + {identifier: `"@query-param";name="Cat"`, value: "meow"}, + {identifier: `"signature-agent";key="sig1"`, value: `"https://bots.example.com";type=cimd`}, }, expected: map[string]string{ `@query-param;name="Pet"`: "dog", @@ -276,46 +291,27 @@ func TestSignatureBaseComponents(t *testing.T) { }, }, "boolean identifier parameter": { - base: signatureBase{ - { - key: &componentIdentifier{ - Item: httpsfv.Item{ - Value: "content-type", - Params: sfParams, - }, - }, - value: []string{"application/json"}, - }, + names: []string{"content-type"}, + entries: []serializedComponent{ + {identifier: `"content-type";sf`, value: "application/json"}, }, expected: map[string]string{ "content-type;sf": "application/json", }, }, "multiple canonicalized values": { - base: signatureBase{ - { - key: &componentIdentifier{ - Item: httpsfv.NewItem("x-example"), - }, - value: []string{ - "first", - "second", - "third", - }, - }, + names: []string{"x-example"}, + entries: []serializedComponent{ + {identifier: `"x-example"`, value: "first, second, third"}, }, expected: map[string]string{ "x-example": "first, second, third", }, }, "empty canonicalized value": { - base: signatureBase{ - { - key: &componentIdentifier{ - Item: httpsfv.NewItem("x-empty"), - }, - value: []string{""}, - }, + names: []string{"x-empty"}, + entries: []serializedComponent{ + {identifier: `"x-empty"`, value: ""}, }, expected: map[string]string{ "x-empty": "", @@ -325,8 +321,18 @@ func TestSignatureBaseComponents(t *testing.T) { t.Run(uc, func(t *testing.T) { t.Parallel() - components, err := tc.base.components() - require.NoError(t, err) + identifiers := make([]*componentIdentifier, len(tc.names)) + for i, name := range tc.names { + identifiers[i] = &componentIdentifier{Item: httpsfv.NewItem(name)} + } + + base := signatureBase{ + input: &signatureInput{identifiers: identifiers}, + entries: tc.entries, + signatureParams: tc.signatureParams, + } + + components := base.components() assert.Equal(t, tc.expected, components) }) diff --git a/signature_input.go b/signature_input.go index 3209d55..030a9db 100644 --- a/signature_input.go +++ b/signature_input.go @@ -36,59 +36,37 @@ func newSignatureInput( } } -func parseSignatureInput(list httpsfv.InnerList) (*signatureInput, error) { - identifiers := make([]*componentIdentifier, 0, len(list.Items)) - - for _, item := range list.Items { - identifier, err := newComponentIdentifier(item) - if err != nil { - return nil, err +func (si *signatureInput) hasIdentifier(id *componentIdentifier) bool { + for _, identifier := range si.identifiers { + if identifier.Value == id.Value && slices.Equal(identifier.Params.Names(), id.Params.Names()) { + return true } - - identifiers = append(identifiers, identifier) - } - - if err := validateSignatureInputParameters(list.Params); err != nil { - return nil, err } - return &signatureInput{ - value: list, - identifiers: identifiers, - }, nil + return false } -func validateSignatureInputParameters(params *httpsfv.Params) error { - if params == nil { - return nil +func (si *signatureInput) parameters() SignatureParameters { + if si.value.Params == nil { + return SignatureParameters{} } - for _, name := range params.Names() { - value, _ := params.Get(name) + result := make(SignatureParameters, len(si.value.Params.Names())) - switch SignatureParameter(name) { - case Created, Expires: - if _, ok := value.(int64); !ok { - return fmt.Errorf("%w: %s", ErrMalformedSignatureParameter, name) - } - case KeyID, Alg, Nonce, Tag: - if _, ok := value.(string); !ok { - return fmt.Errorf("%w: %s", ErrMalformedSignatureParameter, name) - } - } - } - - return nil -} + for _, name := range si.value.Params.Names() { + value, _ := si.value.Params.Get(name) -func (si *signatureInput) hasIdentifier(id *componentIdentifier) bool { - for _, identifier := range si.identifiers { - if identifier.Value == id.Value && slices.Equal(identifier.Params.Names(), id.Params.Names()) { - return true + switch v := value.(type) { + case httpsfv.Token: + value = Token(v) + case httpsfv.DisplayString: + value = string(v) } + + result[SignatureParameter(name)] = value } - return false + return result } func (si *signatureInput) parameter(name SignatureParameter) (any, bool) { @@ -128,3 +106,48 @@ func (si *signatureInput) expires() (time.Time, bool) { return si.timestamp(Expi func (si *signatureInput) nonce() (string, bool) { return si.stringParameter(Nonce) } func (si *signatureInput) keyID() (string, bool) { return si.stringParameter(KeyID) } func (si *signatureInput) tag() (string, bool) { return si.stringParameter(Tag) } + +func parseSignatureInput(list httpsfv.InnerList) (*signatureInput, error) { + identifiers := make([]*componentIdentifier, 0, len(list.Items)) + + for _, item := range list.Items { + identifier, err := newComponentIdentifier(item) + if err != nil { + return nil, err + } + + identifiers = append(identifiers, identifier) + } + + if err := validateSignatureInputParameters(list.Params); err != nil { + return nil, err + } + + return &signatureInput{ + value: list, + identifiers: identifiers, + }, nil +} + +func validateSignatureInputParameters(params *httpsfv.Params) error { + if params == nil { + return nil + } + + for _, name := range params.Names() { + value, _ := params.Get(name) + + switch SignatureParameter(name) { + case Created, Expires: + if _, ok := value.(int64); !ok { + return fmt.Errorf("%w: %s", ErrMalformedSignatureParameter, name) + } + case KeyID, Alg, Nonce, Tag: + if _, ok := value.(string); !ok { + return fmt.Errorf("%w: %s", ErrMalformedSignatureParameter, name) + } + } + } + + return nil +} diff --git a/signature_input_test.go b/signature_input_test.go index fcbf896..befbd86 100644 --- a/signature_input_test.go +++ b/signature_input_test.go @@ -327,6 +327,44 @@ func TestValidateSignatureInputParameters(t *testing.T) { } } +func TestSignatureInputParameters(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + want SignatureParameters + }{ + "nil parameters": { + want: SignatureParameters{}, + }, + "empty parameters": { + params: httpsfv.NewParams(), + want: SignatureParameters{}, + }, + "with multiple parameters": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), int64(1577836800)) + params.Add("foo", httpsfv.Token("hello")) + params.Add("bar", httpsfv.DisplayString("hello")) + + return params + }(), + want: SignatureParameters{ + Created: int64(1577836800), + "foo": Token("hello"), + "bar": "hello", + }, + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + assert.Equal(t, tc.want, input.parameters()) + }) + } +} + func TestSignatureInputParameter(t *testing.T) { t.Parallel() diff --git a/signer.go b/signer.go index ab14538..ed8ac20 100644 --- a/signer.go +++ b/signer.go @@ -12,116 +12,72 @@ import ( "github.com/dunglas/httpsfv" ) -type Signer interface { - Sign(msg *Message) (http.Header, error) -} - type payloadSigner interface { - signPayload(data []byte) ([]byte, error) - algorithm() SignatureAlgorithm - keyID() string + sign(ctx context.Context, data []byte) ([]byte, error) } -func newPayloadSigner(signingKey any, keyID string, alg SignatureAlgorithm) (payloadSigner, error) { +func newPayloadSigner(signingKey any, alg SignatureAlgorithm) (payloadSigner, error) { switch key := signingKey.(type) { case ed25519.PrivateKey: - return newEd25519Signer(key, keyID, alg) + return newEd25519Signer(key, alg) case *rsa.PrivateKey: - return newRSASigner(key, keyID, alg) + return newRSASigner(key, alg) case *ecdsa.PrivateKey: - return newECDSASigner(key, keyID, alg) + return newECDSASigner(key, alg) case []byte: - return newSymmetricSigner(key, keyID, alg) + return newSymmetricSigner(key, alg) default: return nil, ErrUnsupportedKeyType } } -type SignerOption func(s *signer) error - -// WithLabel sets the label of the signature in the Signature-Input and Signature headers. -func WithLabel(label string) SignerOption { - return func(s *signer) error { - if len(label) != 0 { - s.label = label - } - - return nil - } -} - -func WithTTL(ttl time.Duration) SignerOption { - return func(s *signer) error { - s.ttl = ttl - - return nil - } -} - -// WithComponents sets the HTTP fields / derived component names to be included in signing. -func WithComponents(identifiers ...string) SignerOption { - return func(s *signer) error { - var err error - - s.ids, err = toComponentIdentifiers(identifiers) - - return err - } -} - -func WithTag(tag string) SignerOption { - return func(s *signer) error { - if len(tag) != 0 { - s.tag = tag - } - - return nil - } -} - -func WithNonce(ng NonceGetter) SignerOption { - return func(s *signer) error { - if ng != nil { - s.ng = ng - } - - return nil - } -} - -func WithContentDigestAlgorithm(alg DigestAlgorithm) SignerOption { - return func(s *signer) error { - if _, known := supportedAlgs[alg]; !known { - return fmt.Errorf("%w: %s", ErrUnsupportedAlgorithm, alg) - } - - s.cdAlg = alg - - return nil - } +// Signer creates HTTP message signatures using a configured key, set of +// covered components, and signature parameters. +type Signer interface { + // Sign signs msg and returns its updated HTTP headers, including the + // Signature and Signature-Input fields. It also updates msg.Header and + // may update Content-Digest when that component is covered. + // Options apply only to this invocation and do not modify the Signer. + Sign(msg *Message, opts ...SignOption) (http.Header, error) } -// NewSigner creates a new signer with the given options. +// NewSigner creates a Signer using key for cryptographic signing. The key +// must contain private or symmetric material compatible with its algorithm. +// By default, signatures use label "sig", include created, and expire +// after 30 seconds. The alg, keyid, tag, and nonce parameters are omitted. +// When generating Content-Digest, the signer uses both SHA-256 and SHA-512 +// unless WithContentDigestAlgorithm selects one. +// +//nolint:cyclop func NewSigner(key Key, opts ...SignerOption) (Signer, error) { - ps, err := newPayloadSigner(key.Key, key.KeyID, key.Algorithm) + ps, err := newPayloadSigner(key.Material, key.Algorithm) if err != nil { return nil, err } sig := &signer{ - label: "sig", - ttl: 30 * time.Second, //nolint:mnd - ng: nonceGetter{}, - ps: ps, - mu: noopMessageUpdater{}, + label: "sig", + ttl: 30 * time.Second, //nolint:mnd + ps: ps, + mu: noopMessageUpdater{}, + sigAlg: key.Algorithm, } for _, opt := range opts { - if err = opt(sig); err != nil { + if err = opt.applySignerOption(sig); err != nil { return nil, err } } + if sig.includeAlg { + switch key.Algorithm { + case RsaPssSha512, RsaPkcs1v15Sha256, HmacSha256, EcdsaP256Sha256, EcdsaP384Sha384, Ed25519: + default: + return nil, fmt.Errorf("%w: %s is not registered for HTTP Message Signatures", + ErrUnsupportedAlgorithm, key.Algorithm) + } + } + var cmv compositeMessageUpdater for _, id := range sig.ids { @@ -136,56 +92,69 @@ func NewSigner(key Key, opts ...SignerOption) (Signer, error) { sig.mu = cmv } + // Covered components are fixed for the lifetime of this Signer. + // Prepare their Structured-Fields identifiers once for the signature base. + sig.serializedIdentifiers = make([]string, len(sig.ids)) + for i, id := range sig.ids { + sig.serializedIdentifiers[i], err = httpsfv.Marshal(id.Item) + if err != nil { + return nil, err + } + } + return sig, nil } type signer struct { - label string - ids []*componentIdentifier - ttl time.Duration - tag string - ng NonceGetter - ps payloadSigner - cdAlg DigestAlgorithm - mu messageUpdater + label string + ids []*componentIdentifier + serializedIdentifiers []string + ttl time.Duration + tag string + keyID string + includeAlg bool + ps payloadSigner + sigAlg SignatureAlgorithm + cdAlg DigestAlgorithm + parameters []parameterOption + mu messageUpdater } -func (s *signer) Sign(msg *Message) (http.Header, error) { - params, err := s.signatureInput(msg.Context) - if err != nil { - return nil, err +func (s *signer) Sign(msg *Message, opts ...SignOption) (http.Header, error) { + callOptions := signOptions{staticParameters: s.parameters} + for _, opt := range opts { + if err := opt.applySignOption(&callOptions); err != nil { + return nil, err + } } - if err = s.mu.update(msg); err != nil { + params := s.signatureInput(callOptions) + + if err := s.mu.update(msg); err != nil { return nil, err } - base, err := newSignatureBase(params, msg) + base, err := newSignatureBase(msg, params, s.serializedIdentifiers) if err != nil { return nil, err } - sb, err := base.marshal() + signature, err := s.ps.sign(msg.Context, base.marshal()) if err != nil { return nil, err } - signature, err := s.ps.signPayload(sb) - if err != nil { - return nil, err + label := s.label + if callOptions.label != "" { + label = callOptions.label } - return msg.addSignature(s.label, signature, params.value) + return msg.addSignature(label, signature, params.value) } -func (s *signer) signatureInput(ctx context.Context) (*signatureInput, error) { +func (s *signer) signatureInput(opts signOptions) *signatureInput { created := currentTime().UTC() - nonce, err := s.ng.GetNonce(ctx) - if err != nil { - return nil, err - } - params := httpsfv.NewParams() params.Add(string(Created), created.Unix()) @@ -193,21 +162,29 @@ func (s *signer) signatureInput(ctx context.Context) (*signatureInput, error) { params.Add(string(Expires), created.Add(s.ttl).Unix()) } - if keyID := s.ps.keyID(); keyID != "" { + if keyID := s.keyID; keyID != "" { params.Add(string(KeyID), keyID) } - if alg := filterAlgorithm(s.ps.algorithm()); alg != "" { - params.Add(string(Alg), string(alg)) + if s.includeAlg { + params.Add(string(Alg), string(s.sigAlg)) } - if len(nonce) != 0 { - params.Add(string(Nonce), nonce) + if opts.nonceSet { + params.Add(string(Nonce), opts.nonce) } if len(s.tag) != 0 { params.Add(string(Tag), s.tag) } - return newSignatureInput(s.ids, params), nil + for _, param := range s.parameters { + params.Add(string(param.name), param.value) + } + + for _, param := range opts.parameters { + params.Add(string(param.name), param.value) + } + + return newSignatureInput(s.ids, params) } diff --git a/signer_test.go b/signer_test.go index 2cd6c47..c0ce3b9 100644 --- a/signer_test.go +++ b/signer_test.go @@ -1,7 +1,6 @@ package httpsig import ( - "context" "crypto/ecdsa" "crypto/ed25519" "crypto/elliptic" @@ -55,7 +54,7 @@ func TestNewPayloadSigner(t *testing.T) { {uc: "hmac signer", key: k256, alg: HmacSha256, typ: &symmetricSigner{}}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newPayloadSigner(tc.key, "test", tc.alg) + sig, err := newPayloadSigner(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -69,130 +68,6 @@ func TestNewPayloadSigner(t *testing.T) { } } -func TestWithLabel(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - label string - shouldUpdate bool - }{ - {uc: "empty label", label: "", shouldUpdate: false}, - {uc: "not empty label", label: "foo", shouldUpdate: true}, - } { - t.Run(tc.uc, func(t *testing.T) { - s := &signer{label: "test"} - - err := WithLabel(tc.label)(s) - require.NoError(t, err) - - if tc.shouldUpdate { - require.Equal(t, tc.label, s.label) - } else { - require.Equal(t, "test", s.label) - } - }) - } -} - -func TestWithTTL(t *testing.T) { - t.Parallel() - - ttl := 1 * time.Second - s := &signer{ttl: 30 * time.Second} - - err := WithTTL(ttl)(s) - - require.NoError(t, err) - require.Equal(t, ttl, s.ttl) -} - -func TestWithComponentsForSigner(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - identifiers []string - err error - }{ - {uc: "multiple valid identifier", identifiers: []string{"@status;req", "@method"}}, - {uc: "invalid identifier", identifiers: []string{"@foo"}, err: ErrUnsupportedComponentIdentifier}, - } { - t.Run(tc.uc, func(t *testing.T) { - s := &signer{} - - err := WithComponents(tc.identifiers...)(s) - - if tc.err != nil { - require.Error(t, err) - require.ErrorIs(t, err, tc.err) - } else { - require.NoError(t, err) - require.Len(t, s.ids, len(tc.identifiers)) - - for i, id := range s.ids { - vals := strings.Split(tc.identifiers[i], ";") - assert.Equal(t, vals[0], id.Value) - } - } - }) - } -} - -func TestWithTag(t *testing.T) { - t.Parallel() - - s := &signer{} - - err := WithTag("test")(s) - require.NoError(t, err) - - assert.Equal(t, "test", s.tag) -} - -func TestWithNonceGetter(t *testing.T) { - t.Parallel() - - s := &signer{} - - err := WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { - return "foo", nil - }))(s) - require.NoError(t, err) - - nonce, err := s.ng.GetNonce(context.TODO()) - require.NoError(t, err) - - assert.Equal(t, "foo", nonce) -} - -func TestWithContentDigestAlgorithm(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - alg DigestAlgorithm - err error - }{ - {uc: "valid algorithm", alg: Sha512}, - {uc: "invalid algorithm", alg: DigestAlgorithm("md4"), err: ErrUnsupportedAlgorithm}, - } { - t.Run(tc.uc, func(t *testing.T) { - s := &signer{} - - err := WithContentDigestAlgorithm(tc.alg)(s) - - if tc.err != nil { - require.Error(t, err) - require.ErrorIs(t, err, tc.err) - } else { - require.NoError(t, err) - assert.Equal(t, tc.alg, s.cdAlg) - } - }) - } -} - func TestNewSigner(t *testing.T) { t.Parallel() @@ -216,7 +91,7 @@ func TestNewSigner(t *testing.T) { }, { uc: "error while applying configuration options", - key: Key{KeyID: "test", Algorithm: EcdsaP384Sha384, Key: pkp384}, + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, opts: []SignerOption{WithComponents("@test")}, assert: func(t *testing.T, err error, _ Signer) { t.Helper() @@ -225,9 +100,67 @@ func TestNewSigner(t *testing.T) { require.ErrorIs(t, err, ErrUnsupportedComponentIdentifier) }, }, + { + uc: "alg parameter requires a registered algorithm", + key: Key{Algorithm: HmacSha384, Material: []byte("secret")}, + opts: []SignerOption{WithAlg()}, + assert: func(t *testing.T, err error, _ Signer) { + t.Helper() + + require.ErrorIs(t, err, ErrUnsupportedAlgorithm) + }, + }, + { + uc: "reserved signature parameter", + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, + opts: []SignerOption{WithParameter("created", int64(1))}, + assert: func(t *testing.T, err error, _ Signer) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "static nonce parameter is not allowed", + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, + opts: []SignerOption{WithParameter("nonce", "fixed-nonce")}, + assert: func(t *testing.T, err error, _ Signer) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "invalid signature parameter name", + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, + opts: []SignerOption{WithParameter("Invalid Name", "value")}, + assert: func(t *testing.T, err error, _ Signer) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "invalid signature parameter value", + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, + opts: []SignerOption{WithParameter("example", struct{}{})}, + assert: func(t *testing.T, err error, _ Signer) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "duplicate signature parameter", + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, + opts: []SignerOption{ + WithParameter("example", "a"), + WithParameter("example", "b"), + }, + assert: func(t *testing.T, err error, _ Signer) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, { uc: "successful without configuration", - key: Key{KeyID: "test", Algorithm: EcdsaP384Sha384, Key: pkp384}, + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, assert: func(t *testing.T, err error, sgnr Signer) { t.Helper() @@ -239,19 +172,19 @@ func TestNewSigner(t *testing.T) { assert.Equal(t, "sig", s.label) assert.Equal(t, 30*time.Second, s.ttl) assert.IsType(t, &ecdsaSigner{}, s.ps) - assert.NotNil(t, s.ng) assert.Empty(t, s.tag) assert.Empty(t, s.ids) }, }, { uc: "successful with configuration", - key: Key{KeyID: "test", Algorithm: EcdsaP384Sha384, Key: pkp384}, + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, opts: []SignerOption{ WithComponents("@status"), WithTag("foo"), WithTTL(1 * time.Second), WithLabel("bar"), + WithKeyID("test"), }, assert: func(t *testing.T, err error, sgnr Signer) { t.Helper() @@ -264,7 +197,6 @@ func TestNewSigner(t *testing.T) { assert.Equal(t, "bar", s.label) assert.Equal(t, 1*time.Second, s.ttl) assert.IsType(t, &ecdsaSigner{}, s.ps) - assert.NotNil(t, s.ng) assert.Equal(t, "foo", s.tag) assert.NotEmpty(t, s.ids) }, @@ -281,11 +213,9 @@ func TestNewSigner(t *testing.T) { func TestSignerSign(t *testing.T) { // used by RFC9421 in test vectors currentTime = func() time.Time { return time.Unix(1618884473, 0) } - filterAlgorithm = func(_ SignatureAlgorithm) SignatureAlgorithm { return "" } t.Cleanup(func() { currentTime = time.Now - filterAlgorithm = func(alg SignatureAlgorithm) SignatureAlgorithm { return alg } }) pkp384, err := ecdsa.GenerateKey(elliptic.P384(), rand.Reader) @@ -331,39 +261,27 @@ func TestSignerSign(t *testing.T) { tkEd25519 := rawKey.(ed25519.PrivateKey) for _, tc := range []struct { - uc string - key Key - opts []SignerOption - msg *Message - assert func(t *testing.T, err error, header http.Header) + uc string + key Key + opts []SignerOption + signOpts []SignOption + msg *Message + assert func(t *testing.T, err error, header http.Header) }{ { - uc: "failed creating signature parameters", - key: Key{KeyID: "test", Algorithm: EcdsaP384Sha384, Key: pkp384}, - opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", errors.New("test error") })), - }, - msg: &Message{ - Method: http.MethodPost, - Authority: "example.com", - URL: testURL, - Header: http.Header{ - "Host": []string{"example.com"}, - "Date": []string{"Tue, 20 Apr 2021 02:07:55 GMT"}, - "Content-Type": []string{"application/json"}, - "Content-Length": []string{"18"}, - }, - IsRequest: true, - }, - assert: func(t *testing.T, err error, _ http.Header) { + uc: "signer omits nonce unless supplied per call", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + opts: []SignerOption{WithTTL(0)}, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, header http.Header) { t.Helper() - - require.Error(t, err) + require.NoError(t, err) + assert.Equal(t, `sig=();created=1618884473`, header.Get("Signature-Input")) }, }, { uc: "failed updating message (adding content-digest)", - key: Key{KeyID: "test", Algorithm: EcdsaP384Sha384, Key: pkp384}, + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, opts: []SignerOption{ WithComponents("content-digest"), }, @@ -390,7 +308,7 @@ func TestSignerSign(t *testing.T) { }, { uc: "failed creating signature base", - key: Key{KeyID: "test", Algorithm: EcdsaP384Sha384, Key: pkp384}, + key: Key{Algorithm: EcdsaP384Sha384, Material: pkp384}, opts: []SignerOption{ WithComponents("@status"), }, @@ -412,15 +330,162 @@ func TestSignerSign(t *testing.T) { require.Error(t, err) }, }, + { + uc: "static extension parameters", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + opts: []SignerOption{ + WithTTL(0), + WithParameter("example-token", Token("hello")), + WithParameter("example-bytes", []byte("data")), + }, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, header http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created=1618884473;example-token=hello;example-bytes=:ZGF0YQ==:`, header.Get("Signature-Input")) + }, + }, + { + uc: "per-call label overrides configured label", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + opts: []SignerOption{ + WithTTL(0), + WithLabel("static"), + }, + signOpts: []SignOption{WithLabel("dynamic")}, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, header http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `dynamic=();created=1618884473`, header.Get("Signature-Input")) + }, + }, + { + uc: "per-call nonce is included", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + opts: []SignerOption{ + WithTTL(0), + }, + signOpts: []SignOption{WithParameter("nonce", "requested-nonce")}, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, header http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created=1618884473;nonce="requested-nonce"`, header.Get("Signature-Input")) + }, + }, + { + uc: "additional parameters for a single signature", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + opts: []SignerOption{ + WithTTL(0), + WithParameter("static", Token("hello")), + }, + signOpts: []SignOption{ + WithParameter("wimse-req-nonce", "request-nonce"), + WithParameter("dynamic-flag", true), + }, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, header http.Header) { + t.Helper() + require.NoError(t, err) + assert.Equal(t, `sig=();created=1618884473;static=hello;wimse-req-nonce="request-nonce";dynamic-flag`, header.Get("Signature-Input")) + }, + }, + { + uc: "reserved per-call parameter", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + signOpts: []SignOption{WithParameter("created", int64(1))}, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, _ http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "nonce parameter requires a string", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + signOpts: []SignOption{WithParameter("nonce", Token("not-a-string"))}, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, _ http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "nonce parameter cannot be empty", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + signOpts: []SignOption{WithParameter("nonce", "")}, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, _ http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "duplicate per-call nonce", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + signOpts: []SignOption{ + WithParameter("nonce", "one"), + WithParameter("nonce", "two"), + }, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, _ http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "duplicate per-call parameter", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + signOpts: []SignOption{ + WithParameter("example", "a"), + WithParameter("example", "b"), + }, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, _ http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "static and per-call parameter collision", + key: Key{Algorithm: HmacSha256, Material: []byte("secret")}, + opts: []SignerOption{ + WithParameter("example", "static"), + }, + signOpts: []SignOption{WithParameter("example", "dynamic")}, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, _ http.Header) { + t.Helper() + require.ErrorIs(t, err, ErrParameter) + }, + }, + { + uc: "include alg parameter when requested", + key: Key{Algorithm: HmacSha256, Material: tkMAC}, + opts: []SignerOption{ + WithAlg(), + WithTTL(0), + }, + msg: &Message{Header: http.Header{}, IsRequest: true}, + assert: func(t *testing.T, err error, header http.Header) { + t.Helper() + + require.NoError(t, err) + assert.Equal(t, `sig=();created=1618884473;alg="hmac-sha256"`, header.Get("Signature-Input")) + }, + }, { // https://www.rfc-editor.org/rfc/rfc9421.html#name-minimal-signature-using-rsa uc: "B.2.1. minimal signature using rsa-pss-sha512", - key: Key{KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512, Key: tkRSAPSS}, + key: Key{Algorithm: RsaPssSha512, Material: tkRSAPSS}, opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "b3k2pp5k7z-50gnwp.yemd", nil })), WithLabel("sig-b21"), WithTTL(0), + WithKeyID("test-key-rsa-pss"), }, + signOpts: []SignOption{WithParameter("nonce", "b3k2pp5k7z-50gnwp.yemd")}, msg: &Message{ Method: http.MethodPost, Authority: "example.com", @@ -450,14 +515,14 @@ func TestSignerSign(t *testing.T) { { // https://www.rfc-editor.org/rfc/rfc9421.html#name-selective-covered-component uc: "B.2.2. selective covered components using rsa-pss-sha512", - key: Key{KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512, Key: tkRSAPSS}, + key: Key{Algorithm: RsaPssSha512, Material: tkRSAPSS}, opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", nil })), WithLabel("sig-b22"), WithTTL(0), WithComponents("@authority", "content-digest", "@query-param;name=\"Pet\""), WithTag("header-example"), WithContentDigestAlgorithm(Sha512), + WithKeyID("test-key-rsa-pss"), }, msg: &Message{ Method: http.MethodPost, @@ -491,15 +556,15 @@ func TestSignerSign(t *testing.T) { { // https://www.rfc-editor.org/rfc/rfc9421.html#name-full-coverage-using-rsa-pss uc: "B.2.3. full coverage using rsa-pss-sha512", - key: Key{KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512, Key: tkRSAPSS}, + key: Key{Algorithm: RsaPssSha512, Material: tkRSAPSS}, opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", nil })), WithLabel("sig-b23"), WithTTL(0), WithComponents( "date", "@method", "@path", "@query", "@authority", "content-type", "content-digest", "content-length", ), WithContentDigestAlgorithm(Sha512), + WithKeyID("test-key-rsa-pss"), }, msg: &Message{ Method: http.MethodPost, @@ -533,13 +598,13 @@ func TestSignerSign(t *testing.T) { { // https://www.rfc-editor.org/rfc/rfc9421.html#name-signing-a-response-using-ec uc: "B.2.4. signing a response using ecdsa-p256-sha256", - key: Key{KeyID: "test-key-ecc-p256", Algorithm: EcdsaP256Sha256, Key: tkECCP256}, + key: Key{Algorithm: EcdsaP256Sha256, Material: tkECCP256}, opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", nil })), WithLabel("sig-b24"), WithTTL(0), WithComponents("@status", "content-type", "content-digest", "content-length"), WithContentDigestAlgorithm(Sha512), + WithKeyID("test-key-ecc-p256"), }, msg: &Message{ Method: http.MethodPost, @@ -571,12 +636,12 @@ func TestSignerSign(t *testing.T) { { // https://www.rfc-editor.org/rfc/rfc9421.html#name-signing-a-request-using-hma uc: "B.2.5. signing a request using hmac-sha256", - key: Key{KeyID: "test-shared-secret", Algorithm: HmacSha256, Key: tkMAC}, + key: Key{Algorithm: HmacSha256, Material: tkMAC}, opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", nil })), WithLabel("sig-b25"), WithTTL(0), WithComponents("date", "@authority", "content-type"), + WithKeyID("test-shared-secret"), }, msg: &Message{ Method: http.MethodPost, @@ -606,12 +671,12 @@ func TestSignerSign(t *testing.T) { { // https://www.rfc-editor.org/rfc/rfc9421.html#name-signing-a-request-using-ed2 uc: "B.2.6. signing a request using ed25519", - key: Key{KeyID: "test-key-ed25519", Algorithm: Ed25519, Key: tkEd25519}, + key: Key{Algorithm: Ed25519, Material: tkEd25519}, opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", nil })), WithLabel("sig-b26"), WithTTL(0), WithComponents("date", "@method", "@path", "@authority", "content-type", "content-length"), + WithKeyID("test-key-ed25519"), }, msg: &Message{ Method: http.MethodPost, @@ -640,13 +705,13 @@ func TestSignerSign(t *testing.T) { }, { uc: "overwrites stale content-digest when signing content-digest component", - key: Key{KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512, Key: tkRSAPSS}, + key: Key{Algorithm: RsaPssSha512, Material: tkRSAPSS}, opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", nil })), WithLabel("sig-content-digest"), WithTTL(0), WithComponents("content-digest"), WithContentDigestAlgorithm(Sha256), + WithKeyID("test-key-rsa-pss"), }, msg: &Message{ Method: http.MethodPost, @@ -684,13 +749,13 @@ func TestSignerSign(t *testing.T) { }, { uc: "preserves existing content-digest when content-digest component is not signed", - key: Key{KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512, Key: tkRSAPSS}, + key: Key{Algorithm: RsaPssSha512, Material: tkRSAPSS}, opts: []SignerOption{ - WithNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", nil })), WithLabel("sig-no-content-digest"), WithTTL(0), WithComponents("date", "@method"), WithContentDigestAlgorithm(Sha256), + WithKeyID("test-key-rsa-pss"), }, msg: &Message{ Method: http.MethodPost, @@ -727,9 +792,55 @@ func TestSignerSign(t *testing.T) { s, err := NewSigner(tc.key, tc.opts...) require.NoError(t, err) - res, err := s.Sign(tc.msg) + res, err := s.Sign(tc.msg, tc.signOpts...) tc.assert(t, err, res) }) } + + t.Run("per-call label does not persist", func(t *testing.T) { + s, err := NewSigner(Key{Algorithm: HmacSha256, Material: []byte("secret")}, + WithTTL(0), + WithLabel("static"), + ) + require.NoError(t, err) + + first, err := s.Sign(&Message{Header: http.Header{}, IsRequest: true}, WithLabel("dynamic")) + require.NoError(t, err) + assert.Equal(t, `dynamic=();created=1618884473`, first.Get("Signature-Input")) + + second, err := s.Sign(&Message{Header: http.Header{}, IsRequest: true}) + require.NoError(t, err) + assert.Equal(t, `static=();created=1618884473`, second.Get("Signature-Input")) + }) + + t.Run("per-call nonce does not persist", func(t *testing.T) { + s, err := NewSigner(Key{Algorithm: HmacSha256, Material: []byte("secret")}, WithTTL(0)) + require.NoError(t, err) + + first, err := s.Sign(&Message{Header: http.Header{}, IsRequest: true}, + WithParameter("nonce", "requested-nonce")) + require.NoError(t, err) + assert.Equal(t, `sig=();created=1618884473;nonce="requested-nonce"`, first.Get("Signature-Input")) + + second, err := s.Sign(&Message{Header: http.Header{}, IsRequest: true}) + require.NoError(t, err) + assert.Equal(t, `sig=();created=1618884473`, second.Get("Signature-Input")) + }) + + t.Run("per-call parameters do not persist", func(t *testing.T) { + s, err := NewSigner(Key{Algorithm: HmacSha256, Material: []byte("secret")}, + WithTTL(0), + ) + require.NoError(t, err) + + first, err := s.Sign(&Message{Header: http.Header{}, IsRequest: true}, + WithParameter("wimse-req-nonce", "request-nonce")) + require.NoError(t, err) + assert.Contains(t, first.Get("Signature-Input"), `;wimse-req-nonce="request-nonce"`) + + second, err := s.Sign(&Message{Header: http.Header{}, IsRequest: true}) + require.NoError(t, err) + assert.Equal(t, `sig=();created=1618884473`, second.Get("Signature-Input")) + }) } diff --git a/symmetric.go b/symmetric.go index 8f2db0a..613befd 100644 --- a/symmetric.go +++ b/symmetric.go @@ -1,13 +1,14 @@ package httpsig import ( + "context" "crypto" "crypto/hmac" "crypto/subtle" "fmt" ) -func newSymmetricSigner(key []byte, kid string, alg SignatureAlgorithm) (*symmetricSigner, error) { +func newSymmetricSigner(key []byte, alg SignatureAlgorithm) (*symmetricSigner, error) { var hash crypto.Hash switch alg { @@ -22,27 +23,21 @@ func newSymmetricSigner(key []byte, kid string, alg SignatureAlgorithm) (*symmet } return &symmetricSigner{ - alg: alg, key: key, - kid: kid, hash: hash, }, nil } type symmetricSigner struct { - alg SignatureAlgorithm key []byte - kid string hash crypto.Hash } -func (ms *symmetricSigner) keyID() string { return ms.kid } - -func (ms *symmetricSigner) algorithm() SignatureAlgorithm { return ms.alg } - -func (ms *symmetricSigner) signPayload(data []byte) ([]byte, error) { return ms.hmac(data), nil } +func (ms *symmetricSigner) sign(_ context.Context, data []byte) ([]byte, error) { + return ms.hmac(data), nil +} -func (ms *symmetricSigner) verifyPayload(data []byte, mac []byte) error { +func (ms *symmetricSigner) verify(_ context.Context, data []byte, mac []byte) error { if match := subtle.ConstantTimeCompare(mac, ms.hmac(data)); match != 1 { return ErrInvalidSignature } diff --git a/symmetric_test.go b/symmetric_test.go index 88ab982..eeda942 100644 --- a/symmetric_test.go +++ b/symmetric_test.go @@ -40,7 +40,7 @@ func TestNewSymmetricSigner(t *testing.T) { {uc: string(HmacSha512), alg: HmacSha512, key: k512}, } { t.Run(tc.uc, func(t *testing.T) { - sig, err := newSymmetricSigner(tc.key, "test", tc.alg) + sig, err := newSymmetricSigner(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -48,9 +48,7 @@ func TestNewSymmetricSigner(t *testing.T) { } else { require.NoError(t, err) require.NotNil(t, sig) - assert.Equal(t, "test", sig.keyID()) assert.Equal(t, tc.key, sig.key) - assert.Equal(t, tc.alg, sig.algorithm()) } }) } @@ -86,10 +84,10 @@ func TestSymmetricSignerSignPayload(t *testing.T) { {alg: HmacSha512, key: k512}, } { t.Run(string(tc.alg), func(t *testing.T) { - sig, err := newSymmetricSigner(tc.key, "test", tc.alg) + sig, err := newSymmetricSigner(tc.key, tc.alg) require.NoError(t, err) - res, err := sig.signPayload(message) + res, err := sig.sign(t.Context(), message) require.NoError(t, err) require.NotEmpty(t, res) @@ -113,16 +111,16 @@ func TestSymmetricSignerVerifyPayload(t *testing.T) { require.NoError(t, err) require.Equal(t, len(key), n) - sig, err := newSymmetricSigner(key, "test", HmacSha256) + sig, err := newSymmetricSigner(key, HmacSha256) require.NoError(t, err) - res, err := sig.signPayload(message) + res, err := sig.sign(t.Context(), message) require.NoError(t, err) - err = sig.verifyPayload(message, res) + err = sig.verify(t.Context(), message, res) require.NoError(t, err) - err = sig.verifyPayload([]byte("test"), res) + err = sig.verify(t.Context(), []byte("test"), res) require.Error(t, err) require.ErrorIs(t, err, ErrInvalidSignature) } diff --git a/verification_policy.go b/verification_policy.go new file mode 100644 index 0000000..5ee8956 --- /dev/null +++ b/verification_policy.go @@ -0,0 +1,343 @@ +package httpsig + +import ( + "bytes" + "fmt" + "reflect" + "slices" + "strings" + "time" + + "github.com/dunglas/httpsfv" +) + +type verificationPolicy struct { + tolerance time.Duration + maxAge time.Duration + identifiers []*componentIdentifier + asb *AcceptSignatureBuilder + reqCreatedTS *bool + reqExpiresTS *bool + requiredParameters []SignatureParameter + forbiddenParameters []SignatureParameter + expectedParameters []parameterOption +} + +// clone copies the parameter slices for per-call options. Other fields are +// shared because VerifyOption does not modify them. +func (e *verificationPolicy) clone() *verificationPolicy { + clone := *e + clone.requiredParameters = slices.Clone(e.requiredParameters) + clone.forbiddenParameters = slices.Clone(e.forbiddenParameters) + clone.expectedParameters = slices.Clone(e.expectedParameters) + + return &clone +} + +// withOptions applies per-call options without changing the configured policy. +func (e *verificationPolicy) withOptions(tag string, opts []VerifyOption) (*verificationPolicy, error) { + if len(opts) == 0 { + return e, nil + } + + effective := e.clone() + for _, opt := range opts { + if err := opt.applyVerifyOption(effective); err != nil { + return nil, err + } + } + + if err := effective.validateParameters(tag); err != nil { + return nil, err + } + + return effective, nil +} + +// inherit applies global requirements to a tag-specific configuration. +// Tag-specific values take precedence, while parameter requirements remain additive. +func (e *verificationPolicy) inherit(globalPolicy *verificationPolicy, tag string) error { + if e.tolerance == -1 { + e.tolerance = globalPolicy.tolerance + } + + if e.maxAge == -1 { + e.maxAge = globalPolicy.maxAge + } + + if len(globalPolicy.identifiers) != 0 && len(e.identifiers) == 0 { + e.identifiers = globalPolicy.identifiers + } + + if e.reqExpiresTS == nil { + e.reqExpiresTS = globalPolicy.reqExpiresTS + } + + if e.reqCreatedTS == nil { + e.reqCreatedTS = globalPolicy.reqCreatedTS + } + + if globalPolicy.asb != nil && e.asb == nil { + // Keep negotiation configuration independent for each required tag. + tmp := *globalPolicy.asb + e.asb = &tmp + } + + if err := e.inheritParameters(globalPolicy); err != nil { + return err + } + + return e.prepare(tag) +} + +func (e *verificationPolicy) prepare(tag string) error { + if err := e.validateParameters(tag); err != nil { + return err + } + + if e.asb != nil { + e.asb.setIdentifiers(e.identifiers) + e.asb.tag = tag + e.asb.addCreatedTS = *e.reqCreatedTS + e.asb.addExpiresTS = *e.reqExpiresTS + } + + return nil +} + +func (e *verificationPolicy) inheritParameters(globalPolicy *verificationPolicy) error { + for _, name := range globalPolicy.requiredParameters { + if err := e.requireParameter(name); err != nil { + return err + } + } + + for _, name := range globalPolicy.forbiddenParameters { + if err := e.forbidParameter(name); err != nil { + return err + } + } + + for _, param := range globalPolicy.expectedParameters { + if err := e.expectParameter(param); err != nil { + return err + } + } + + return nil +} + +func (e *verificationPolicy) addRequiredParameter(name SignatureParameter) error { + if err := validateParameter(name, true); err != nil { + return err + } + + return e.requireParameter(name) +} + +func (e *verificationPolicy) requireParameter(name SignatureParameter) error { + if slices.Contains(e.forbiddenParameters, name) { + return fmt.Errorf("%w: required parameter %q is forbidden", ErrParameter, name) + } + + if !slices.Contains(e.requiredParameters, name) { + e.requiredParameters = append(e.requiredParameters, name) + } + + return nil +} + +func (e *verificationPolicy) addForbiddenParameter(name SignatureParameter) error { + if err := validateParameter(name, true); err != nil { + return err + } + + return e.forbidParameter(name) +} + +func (e *verificationPolicy) forbidParameter(name SignatureParameter) error { + if slices.Contains(e.requiredParameters, name) { + return fmt.Errorf("%w: required parameter %q is forbidden", ErrParameter, name) + } + + for _, param := range e.expectedParameters { + if param.name == name { + return fmt.Errorf("%w: expected parameter %q is forbidden", ErrParameter, name) + } + } + + if !slices.Contains(e.forbiddenParameters, name) { + e.forbiddenParameters = append(e.forbiddenParameters, name) + } + + return nil +} + +func (e *verificationPolicy) addExpectedParameter(option parameterOption) error { + if slices.Contains(e.forbiddenParameters, option.name) { + return fmt.Errorf("%w: expected parameter %q is forbidden", ErrParameter, option.name) + } + + if option.name == Nonce { + if _, err := validateNonceOption(option.value); err != nil { + return err + } + } else { + var err error + + option, err = normalizeParameter(option) + if err != nil { + return err + } + } + + // Structured Fields sends decimal values rounded to three places. Compare + // the parsed wire value, not the caller's higher-precision float64. + if _, isDecimal := option.value.(float64); isDecimal { + encoded, err := httpsfv.Marshal(httpsfv.Item{Value: option.value, Params: httpsfv.NewParams()}) + if err != nil { + return fmt.Errorf("%w: %w", ErrParameter, err) + } + + parsed, err := httpsfv.UnmarshalItem([]string{encoded}) + if err != nil { + return fmt.Errorf("%w: %w", ErrParameter, err) + } + + option.value = parsed.Value + } + + if v, ok := option.value.([]byte); ok { + option.value = bytes.Clone(v) + } + + return e.expectParameter(option) +} + +func (e *verificationPolicy) expectParameter(option parameterOption) error { + if slices.Contains(e.forbiddenParameters, option.name) { + return fmt.Errorf("%w: expected parameter %q is forbidden", ErrParameter, option.name) + } + + for _, existing := range e.expectedParameters { + if existing.name == option.name { + if reflect.DeepEqual(existing.value, option.value) { + return nil + } + + return fmt.Errorf("%w: conflicting expectations for parameter %q", ErrParameter, option.name) + } + } + + e.expectedParameters = append(e.expectedParameters, option) + + return nil +} + +func (e *verificationPolicy) validateParameters(tag string) error { + for _, name := range e.forbiddenParameters { + if name == Tag && tag != "" || + name == Created && *e.reqCreatedTS || + name == Expires && *e.reqExpiresTS { + return fmt.Errorf("%w: required signature parameter %q is forbidden", ErrParameter, name) + } + } + + return nil +} + +// nolint: funlen, cyclop, gocognit +func (e *verificationPolicy) assertMetadata(si *signatureInput, msg *Message) error { + var ( + missingComponents []string + cmv compositeMessageVerifier + mv messageVerifier + ) + + now := currentTime().UTC() + + expires, expiresPresent := si.expires() + if !expiresPresent { + if *e.reqExpiresTS { + return fmt.Errorf("%w: expected expires parameter not present", ErrMissingParameter) + } + } else if now.After(expires.Add(e.tolerance)) { + return fmt.Errorf("%w: signature expired", ErrValidity) + } + + created, createdPresent := si.created() + if !createdPresent { + if *e.reqCreatedTS { + return fmt.Errorf("%w: expected created parameter not present", ErrMissingParameter) + } + } else { + if now.Before(created.Add(-1 * e.tolerance)) { + return fmt.Errorf("%w: signature not yet valid", ErrValidity) + } + + if created.Add(e.maxAge).Before(now) { + return fmt.Errorf("%w: signature too old", ErrValidity) + } + } + + for _, expIdentifier := range e.identifiers { + if !si.hasIdentifier(expIdentifier) { + res, _ := httpsfv.Marshal(expIdentifier) + missingComponents = append(missingComponents, res) + } + } + + if len(missingComponents) > 0 { + return fmt.Errorf("%w: missing component identifiers: %s", + ErrMissingParameter, strings.Join(missingComponents, ", ")) + } + + for _, name := range e.requiredParameters { + if _, present := si.parameter(name); !present { + return fmt.Errorf("%w: required signature parameter %q is missing", ErrParameter, name) + } + } + + for _, name := range e.forbiddenParameters { + if _, present := si.parameter(name); present { + return fmt.Errorf("%w: forbidden signature parameter %q is present", ErrParameter, name) + } + } + + for _, param := range e.expectedParameters { + value, present := si.parameter(param.name) + if !present { + return fmt.Errorf("%w: expected signature parameter %q is missing", ErrMissingParameter, param.name) + } + + if !reflect.DeepEqual(value, param.value) { + return fmt.Errorf("%w: unexpected value for signature parameter %q", ErrParameter, param.name) + } + } + + for _, id := range si.identifiers { + if id.Value == "content-digest" { + _, fromReq := id.Params.Get("req") + + cmv = append(cmv, contentDigester{fromRequest: fromReq}) + } + } + + if len(cmv) == 0 { + mv = noopMessageVerifier{} + } else { + mv = cmv + } + + return mv.verify(msg) +} + +func (e *verificationPolicy) assertKeyAlgorithm(si *signatureInput, keyAlg SignatureAlgorithm) error { + algorithm, algPresent := si.algorithm() + if algPresent && algorithm != keyAlg { + return fmt.Errorf("%w: key algorithm %s does not match signature algorithm %s", + ErrParameter, algorithm, keyAlg) + } + + return nil +} diff --git a/verification_policy_test.go b/verification_policy_test.go new file mode 100644 index 0000000..869b4cf --- /dev/null +++ b/verification_policy_test.go @@ -0,0 +1,427 @@ +package httpsig + +import ( + "context" + "testing" + "time" + + "github.com/dunglas/httpsfv" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestVerificationPolicyClone(t *testing.T) { + t.Parallel() + + original := &verificationPolicy{ + requiredParameters: []SignatureParameter{Nonce}, + forbiddenParameters: []SignatureParameter{Alg}, + expectedParameters: []parameterOption{{name: "audience", value: "service-a"}}, + } + + clone := original.clone() + require.NotSame(t, original, clone) + + clone.requiredParameters[0] = "created" + clone.forbiddenParameters[0] = "keyid" + clone.expectedParameters[0] = parameterOption{name: "audience", value: "service-b"} + + assert.Equal(t, []SignatureParameter{Nonce}, original.requiredParameters) + assert.Equal(t, []SignatureParameter{Alg}, original.forbiddenParameters) + assert.Equal(t, []parameterOption{{name: "audience", value: "service-a"}}, original.expectedParameters) +} + +func TestVerificationPolicyWithOptions(t *testing.T) { + t.Parallel() + + required := true + original := &verificationPolicy{reqCreatedTS: &required, reqExpiresTS: &required} + + unchanged, err := original.withOptions("profile", nil) + require.NoError(t, err) + assert.Same(t, original, unchanged) + + effective, err := original.withOptions("profile", []VerifyOption{WithRequiredParameters("nonce")}) + require.NoError(t, err) + require.NotSame(t, original, effective) + assert.Equal(t, []SignatureParameter{Nonce}, effective.requiredParameters) + assert.Empty(t, original.requiredParameters) + + _, err = original.withOptions("profile", []VerifyOption{WithForbiddenParameters("tag")}) + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, original.forbiddenParameters) +} + +func TestVerificationPolicyInherit(t *testing.T) { + t.Parallel() + + globalIDs, err := toComponentIdentifiers([]string{"@method", "content-digest"}) + require.NoError(t, err) + + required := true + global := &verificationPolicy{ + tolerance: 2 * time.Second, + maxAge: 30 * time.Second, + identifiers: globalIDs, + reqCreatedTS: &required, + reqExpiresTS: &required, + asb: &AcceptSignatureBuilder{label: "sig"}, + requiredParameters: []SignatureParameter{Nonce}, + forbiddenParameters: []SignatureParameter{Alg}, + expectedParameters: []parameterOption{{name: "audience", value: "service-a"}}, + } + + t.Run("inherits global configuration", func(t *testing.T) { + t.Parallel() + + local := &verificationPolicy{tolerance: -1, maxAge: -1} + require.NoError(t, local.inherit(global, "profile")) + + assert.Equal(t, global.tolerance, local.tolerance) + assert.Equal(t, global.maxAge, local.maxAge) + assert.Equal(t, global.identifiers, local.identifiers) + assert.Equal(t, global.reqCreatedTS, local.reqCreatedTS) + assert.Equal(t, global.reqExpiresTS, local.reqExpiresTS) + assert.Equal(t, global.requiredParameters, local.requiredParameters) + assert.Equal(t, global.forbiddenParameters, local.forbiddenParameters) + assert.Equal(t, global.expectedParameters, local.expectedParameters) + + require.NotSame(t, global.asb, local.asb) + assert.Equal(t, "profile", local.asb.tag) + assert.Empty(t, global.asb.tag) + assert.True(t, local.asb.wantContentDigest) + assert.True(t, local.asb.addCreatedTS) + assert.True(t, local.asb.addExpiresTS) + }) + + t.Run("keeps local overrides", func(t *testing.T) { + t.Parallel() + + created := false + expires := false + localIDs, err := toComponentIdentifiers([]string{"@status"}) + require.NoError(t, err) + + localBuilder := &AcceptSignatureBuilder{label: "custom"} + local := &verificationPolicy{ + tolerance: time.Second, + maxAge: 5 * time.Second, + identifiers: localIDs, + reqCreatedTS: &created, + reqExpiresTS: &expires, + asb: localBuilder, + } + require.NoError(t, local.inherit(global, "profile")) + + assert.Equal(t, time.Second, local.tolerance) + assert.Equal(t, 5*time.Second, local.maxAge) + assert.Equal(t, localIDs, local.identifiers) + assert.False(t, *local.reqCreatedTS) + assert.False(t, *local.reqExpiresTS) + assert.Same(t, localBuilder, local.asb) + assert.Equal(t, "custom", local.asb.label) + assert.False(t, local.asb.wantContentDigest) + assert.False(t, local.asb.addCreatedTS) + assert.False(t, local.asb.addExpiresTS) + }) + + for uc, local := range map[string]verificationPolicy{ + "local requirement conflicts with global prohibition": { + requiredParameters: []SignatureParameter{Alg}, + }, + "local prohibition conflicts with global required parameter": { + forbiddenParameters: []SignatureParameter{Nonce}, + }, + "local value conflicts with global expectation": { + expectedParameters: []parameterOption{{name: "audience", value: "other"}}, + }, + } { + t.Run(uc, func(t *testing.T) { + t.Parallel() + + local.tolerance = -1 + local.maxAge = -1 + require.ErrorIs(t, local.inherit(global, "profile"), ErrParameter) + }) + } +} + +func TestVerificationPolicyAssertMetadata(t *testing.T) { + now := time.Now().UTC() + falseVal := false + trueVal := true + + for uc, tc := range map[string]struct { + params httpsfv.InnerList + exp verificationPolicy + assert func(t *testing.T, err error) + }{ + "signature expired, no tolerance specified": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Expires), now.Add(-2*time.Second).Unix()) + + return params + }(), + }, + exp: verificationPolicy{reqExpiresTS: &falseVal, reqCreatedTS: &falseVal}, + assert: func(t *testing.T, err error) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrValidity) + require.ErrorContains(t, err, "expired") + }, + }, + "signature is still valid with specified tolerance": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Expires), now.Add(-2*time.Second).Unix()) + + return params + }(), + }, + exp: verificationPolicy{ + tolerance: 3 * time.Second, + reqCreatedTS: &falseVal, + reqExpiresTS: &falseVal, + }, + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + "signature is valid if expires in the future": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Expires), now.Add(2*time.Second).Unix()) + + return params + }(), + }, + exp: verificationPolicy{ + tolerance: 2 * time.Second, + reqCreatedTS: &falseVal, + reqExpiresTS: &falseVal, + }, + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + "signature not yet valid, no tolerance specified": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), now.Add(2*time.Second).Unix()) + + return params + }(), + }, + exp: verificationPolicy{reqCreatedTS: &falseVal, reqExpiresTS: &falseVal}, + assert: func(t *testing.T, err error) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrValidity) + require.ErrorContains(t, err, "not yet valid") + }, + }, + "signature already valid with specified tolerance": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), now.Add(2*time.Second).Unix()) + + return params + }(), + }, + exp: verificationPolicy{ + tolerance: 3 * time.Second, + reqCreatedTS: &falseVal, + reqExpiresTS: &falseVal, + }, + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + "signature is valid if created in the past": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), now.Add(-2*time.Second).Unix()) + + return params + }(), + }, + exp: verificationPolicy{ + maxAge: 30 * time.Second, + reqCreatedTS: &falseVal, + reqExpiresTS: &falseVal, + }, + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + "signature too old": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), now.Add(-2*time.Second).Unix()) + + return params + }(), + }, + exp: verificationPolicy{reqCreatedTS: &falseVal, reqExpiresTS: &falseVal}, + assert: func(t *testing.T, err error) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrValidity) + require.ErrorContains(t, err, "too old") + }, + }, + "expected component identifier missing": { + params: httpsfv.InnerList{Params: httpsfv.NewParams()}, + exp: func() verificationPolicy { + ids, err := toComponentIdentifiers([]string{"@method;req", "@authority"}) + require.NoError(t, err) + + return verificationPolicy{identifiers: ids, reqCreatedTS: &falseVal, reqExpiresTS: &falseVal} + }(), + assert: func(t *testing.T, err error) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrMissingParameter) + require.ErrorContains(t, err, `"@method";req, "@authority"`) + }, + }, + "expected created parameter is missing": { + params: httpsfv.InnerList{Params: httpsfv.NewParams()}, + exp: verificationPolicy{reqCreatedTS: &trueVal, reqExpiresTS: &falseVal}, + assert: func(t *testing.T, err error) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrMissingParameter) + require.ErrorContains(t, err, `created parameter`) + }, + }, + "expected expires parameter is missing": { + params: httpsfv.InnerList{Params: httpsfv.NewParams()}, + exp: verificationPolicy{reqCreatedTS: &falseVal, reqExpiresTS: &trueVal}, + assert: func(t *testing.T, err error) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrMissingParameter) + require.ErrorContains(t, err, `expires parameter`) + }, + }, + "successful assertion with all possible parameters": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), now.Add(-3*time.Second).Unix()) + params.Add(string(Expires), now.Add(3*time.Second).Unix()) + params.Add(string(Alg), string(EcdsaP256Sha256)) + params.Add(string(KeyID), "test") + params.Add(string(Nonce), "foo") + params.Add(string(Tag), "test") + + return params + }(), + Items: []httpsfv.Item{ + httpsfv.NewItem("@method"), + httpsfv.NewItem("@authority"), + }, + }, + exp: func() verificationPolicy { + ids, err := toComponentIdentifiers([]string{"@authority", "@method"}) + require.NoError(t, err) + + return verificationPolicy{ + identifiers: ids, + maxAge: 5 * time.Second, + } + }(), + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + msg := &Message{Context: context.TODO()} + + si, err := parseSignatureInput(tc.params) + require.NoError(t, err) + + err = tc.exp.assertMetadata(si, msg) + + tc.assert(t, err) + }) + } +} + +func TestVerificationPolicyAssertKeyAlgorithm(t *testing.T) { + for uc, tc := range map[string]struct { + parameterAlg SignatureAlgorithm + keyAlg SignatureAlgorithm + assert func(t *testing.T, err error) + }{ + "signature algorithm mismatch": { + parameterAlg: RsaPssSha512, + keyAlg: EcdsaP256Sha256, + assert: func(t *testing.T, err error) { + t.Helper() + + require.ErrorIs(t, err, ErrParameter) + require.ErrorContains(t, err, "key algorithm rsa-pss-sha512 does not match signature algorithm ecdsa-p256-sha256") + }, + }, + "signature algorithm matches": { + parameterAlg: RsaPssSha512, + keyAlg: RsaPssSha512, + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + "signature algorithm absent": { + keyAlg: EcdsaP256Sha256, + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + params := httpsfv.NewParams() + if tc.parameterAlg != "" { + params.Add(string(Alg), string(tc.parameterAlg)) + } + + si, err := parseSignatureInput(httpsfv.InnerList{Params: params}) + require.NoError(t, err) + + exp := &verificationPolicy{} + err = exp.assertKeyAlgorithm(si, tc.keyAlg) + + tc.assert(t, err) + }) + } +} diff --git a/verifier.go b/verifier.go index b61dfcd..dad0abd 100644 --- a/verifier.go +++ b/verifier.go @@ -8,182 +8,50 @@ import ( "errors" "fmt" "net/http" - "strings" "time" "github.com/dunglas/httpsfv" ) -type Verifier interface { - Verify(msg *Message) error -} - -// KeyResolver is used to resolve a key id to a verifying key. -type KeyResolver interface { - ResolveKey(ctx context.Context, keyID string) (Key, error) -} - -type payloadVerifier interface { - verifyPayload(data []byte, signature []byte) error - algorithm() SignatureAlgorithm - keyID() string -} - -func newPayloadVerifier(verificationKey any, keyID string, alg SignatureAlgorithm) (payloadVerifier, error) { - switch publicKey := verificationKey.(type) { - case ed25519.PublicKey: - return newEd25519Verifier(publicKey, keyID, alg) - case *rsa.PublicKey: - return newRSAVerifier(publicKey, keyID, alg) - case *ecdsa.PublicKey: - return newECDSAVerifier(publicKey, keyID, alg) - case []byte: - return newSymmetricSigner(publicKey, keyID, alg) - default: - return nil, ErrUnsupportedKeyType - } -} - -type VerifierOption func(v *verifier, e *expectations, f bool) error +// VerifiedSignature contains the attributes of a successfully verified HTTP +// message signature and the metadata returned by the KeyResolver. +type VerifiedSignature struct { + // Label is the received signature label. It is not cryptographically + // protected and must not be used as an identity or authorization claim. + Label string -// WithRequiredComponents sets the HTTP fields / derived component names to be included in signing. -func WithRequiredComponents(identifiers ...string) VerifierOption { - return func(_ *verifier, exp *expectations, _ bool) error { - var err error + // Components contains the canonicalized values of the covered HTTP + // message components, without the synthetic @signature-params component. + Components map[string]string - exp.identifiers, err = toComponentIdentifiers(identifiers) + // Parameters contains the actual transmitted signature parameters, + // including extensions, without synthetic defaults. + Parameters SignatureParameters - return err - } + // Metadata is the application-defined metadata provided by the KeyResolver + // for this signature. + Metadata any } -// WithValidityTolerance sets the clock tolerance for verifying created and expires times. -func WithValidityTolerance(d time.Duration) VerifierOption { - return func(_ *verifier, e *expectations, _ bool) error { - e.tolerance = d - - return nil - } -} - -func WithMaxAge(d time.Duration) VerifierOption { - return func(_ *verifier, e *expectations, _ bool) error { - e.maxAge = d - - return nil - } -} - -func WithNonceChecker(checker NonceChecker) VerifierOption { - return func(v *verifier, _ *expectations, _ bool) error { - if checker != nil { - v.nonceChecker = checker - } - - return nil - } -} - -func WithRequiredTag(tag string, opts ...VerifierOption) VerifierOption { - return func(ver *verifier, _ *expectations, f bool) error { - if f { - panic("WithRequiredTag cannot be used as option for itself") - } - - if _, configured := ver.tagExpectations[tag]; configured { - return fmt.Errorf("%w: requirements for tag %s are already configured", ErrParameter, tag) - } - - exp := &expectations{ - tolerance: -1, - maxAge: -1, - } - - for _, opt := range opts { - if err := opt(ver, exp, true); err != nil { - return err - } - } - - ver.tagExpectations[tag] = exp - - return nil - } -} - -func WithValidateAllSignatures() VerifierOption { - return func(v *verifier, _ *expectations, _ bool) error { - v.validateAllSigs = true - - return nil - } -} - -func WithCreatedTimestampRequired(flag bool) VerifierOption { - return func(_ *verifier, exp *expectations, _ bool) error { - exp.reqCreatedTS = &flag - - return nil - } -} - -func WithExpiredTimestampRequired(flag bool) VerifierOption { - return func(_ *verifier, exp *expectations, _ bool) error { - exp.reqExpiresTS = &flag - - return nil - } -} - -func WithSignatureNegotiation(opts ...SignatureNegotiationOption) VerifierOption { - no := &sigNegotiationOpts{opts: make([]AcceptSignatureOption, 0, len(opts))} - for _, opt := range opts { - opt(no) - } - - return func(_ *verifier, exp *expectations, _ bool) error { - builder, err := NewAcceptSignature(no.opts...) - if err != nil { - return err - } - - exp.asb = builder - - return nil - } -} - -type sigNegotiationOpts struct { - opts []AcceptSignatureOption -} - -type SignatureNegotiationOption func(sno *sigNegotiationOpts) - -func WithRequestedKey(key Key) SignatureNegotiationOption { - return func(sno *sigNegotiationOpts) { - sno.opts = append(sno.opts, WithExpectedKey(key)) - } -} - -func WithRequestedNonce(ng NonceGetter) SignatureNegotiationOption { - return func(sno *sigNegotiationOpts) { - sno.opts = append(sno.opts, WithExpectedNonce(ng)) - } -} - -func WithRequestedContentDigestAlgorithmPreferences(prefs ...AlgorithmPreference) SignatureNegotiationOption { - return func(sno *sigNegotiationOpts) { - sno.opts = append(sno.opts, WithContentDigestAlgorithmPreferences(prefs...)) - } -} +// VerificationResult contains the signatures selected and successfully +// verified during one call to Verifier.Verify. +// The order of the signatures is not guaranteed. +type VerificationResult []VerifiedSignature -func WithRequestedLabel(label string) SignatureNegotiationOption { - return func(sno *sigNegotiationOpts) { - sno.opts = append(sno.opts, WithExpectedLabel(label)) - } +// Verifier verifies HTTP message signatures according to its configured +// requirements. A call succeeds only if all selected signatures pass. +type Verifier interface { + // Verify returns information about the successfully verified signatures + // or an error. Per-call requirements do not change the Verifier. + Verify(msg *Message, opts ...VerifyOption) (VerificationResult, error) } -// NewVerifier creates a new verifier with the given options. +// NewVerifier creates a Verifier instance. +// Without WithValidateAllSignatures, at least one WithRequiredTag is necessary. +// By default, created and expires are required and signatures may be at most +// 30 seconds old. Optional created or expires parameters are still checked +// when present. Global WithSignatureNegotiation cannot be combined with +// WithValidateAllSignatures. More specific requirements can be set through opts. // //nolint:cyclop func NewVerifier(resolver KeyResolver, opts ...VerifierOption) (Verifier, error) { @@ -191,231 +59,148 @@ func NewVerifier(resolver KeyResolver, opts ...VerifierOption) (Verifier, error) return nil, fmt.Errorf("%w: no key resolver provided", ErrVerifierCreation) } - trueValue := true - ver := &verifier{ - keyResolver: resolver, - tagExpectations: make(map[string]*expectations), - nonceChecker: noopNonceChecker{}, + keyResolver: resolver, + tagPolicies: make(map[string]*verificationPolicy), } - global := &expectations{ + globalPolicy := &verificationPolicy{ maxAge: 30 * time.Second, //nolint:mnd - reqExpiresTS: &trueValue, - reqCreatedTS: &trueValue, + reqExpiresTS: new(true), + reqCreatedTS: new(true), } for _, opt := range opts { - if err := opt(ver, global, false); err != nil { + if err := opt.applyVerifierOption(ver, globalPolicy, false); err != nil { return nil, fmt.Errorf("%w: %w", ErrVerifierCreation, err) } } - if !ver.validateAllSigs && len(ver.tagExpectations) == 0 { + if !ver.validateAllSigs && len(ver.tagPolicies) == 0 { return nil, fmt.Errorf("%w: validation of all signatures disabled, but no signature tags specified", ErrVerifierCreation) } - if global.asb != nil && ver.validateAllSigs { + if globalPolicy.asb != nil && ver.validateAllSigs { return nil, fmt.Errorf("%w: verification and negotiation of all posible signature is not possible", ErrVerifierCreation) } - if global.asb != nil { - global.asb.setIdentifiers(global.identifiers) - } - - for tag, exp := range ver.tagExpectations { - if exp.tolerance == -1 { - exp.tolerance = global.tolerance - } - - if exp.maxAge == -1 { - exp.maxAge = global.maxAge - } - - if len(global.identifiers) != 0 && len(exp.identifiers) == 0 { - exp.identifiers = global.identifiers - } - - if exp.reqExpiresTS == nil { - exp.reqExpiresTS = global.reqExpiresTS - } - - if exp.reqCreatedTS == nil { - exp.reqCreatedTS = global.reqCreatedTS - } - - if global.asb != nil && exp.asb == nil { - // create a copy - tmp := *global.asb - exp.asb = &tmp - } - - if exp.asb != nil { - exp.asb.setIdentifiers(exp.identifiers) - exp.asb.tag = tag - exp.asb.addCreatedTS = *exp.reqCreatedTS - exp.asb.addExpiresTS = *exp.reqExpiresTS + for tag, policy := range ver.tagPolicies { + if err := policy.inherit(globalPolicy, tag); err != nil { + return nil, fmt.Errorf("%w: %w", ErrVerifierCreation, err) } } if ver.validateAllSigs { - ver.tagExpectations[""] = global + if err := globalPolicy.prepare(""); err != nil { + return nil, fmt.Errorf("%w: %w", ErrVerifierCreation, err) + } + + ver.tagPolicies[""] = globalPolicy } return ver, nil } -type expectations struct { - tolerance time.Duration - maxAge time.Duration - identifiers []*componentIdentifier - asb *AcceptSignatureBuilder - reqCreatedTS *bool - reqExpiresTS *bool +type payloadVerifier interface { + verify(ctx context.Context, data []byte, signature []byte) error } -// nolint: funlen, cyclop -func (e *expectations) assert( - si *signatureInput, - msg *Message, - keyAlg SignatureAlgorithm, - nc NonceChecker, -) error { - var ( - missingComponents []string - cmv compositeMessageVerifier - mv messageVerifier - ) - - nonce := NonceValue{} - - nonceValue, noncePresent := si.nonce() - if noncePresent { - nonce.Value = nonceValue - nonce.Present = true - } - - if err := nc.CheckNonce(msg.Context, nonce); err != nil { - return fmt.Errorf("%w: nonce validation failed: %w", ErrParameter, err) - } - - algorithm, algPresent := si.algorithm() - if algPresent && algorithm != keyAlg { - return fmt.Errorf("%w: key algorithm %s does not match signature algorithm %s", - ErrParameter, algorithm, keyAlg) - } - - now := currentTime().UTC() - - expires, expiresPresent := si.expires() - if !expiresPresent { - if *e.reqExpiresTS { - return fmt.Errorf("%w: expected expires parameter not present", ErrMissingParameter) - } - } else if now.After(expires.Add(e.tolerance)) { - return fmt.Errorf("%w: signature expired", ErrValidity) - } - - created, createdPresent := si.created() - if !createdPresent { - if *e.reqCreatedTS { - return fmt.Errorf("%w: expected created parameter not present", ErrMissingParameter) - } - } else { - if now.Before(created.Add(-1 * e.tolerance)) { - return fmt.Errorf("%w: signature not yet valid", ErrValidity) - } - - if created.Add(e.maxAge).Before(now) { - return fmt.Errorf("%w: signature too old", ErrValidity) - } - } - - for _, expIdentifier := range e.identifiers { - if !si.hasIdentifier(expIdentifier) { - res, _ := httpsfv.Marshal(expIdentifier) - missingComponents = append(missingComponents, res) - } - } - - if len(missingComponents) > 0 { - return fmt.Errorf("%w: missing component identifiers: %s", - ErrMissingParameter, strings.Join(missingComponents, ", ")) - } - - for _, id := range si.identifiers { - if id.Value == "content-digest" { - _, fromReq := id.Params.Get("req") - - cmv = append(cmv, contentDigester{fromRequest: fromReq}) - } - } - - if len(cmv) == 0 { - mv = noopMessageVerifier{} - } else { - mv = cmv +func newPayloadVerifier(verificationKey any, alg SignatureAlgorithm) (payloadVerifier, error) { + switch publicKey := verificationKey.(type) { + case ed25519.PublicKey: + return newEd25519Verifier(publicKey, alg) + case *rsa.PublicKey: + return newRSAVerifier(publicKey, alg) + case *ecdsa.PublicKey: + return newECDSAVerifier(publicKey, alg) + case []byte: + return newSymmetricSigner(publicKey, alg) + default: + return nil, ErrUnsupportedKeyType } - - return mv.verify(msg) } type verifier struct { keyResolver KeyResolver - tagExpectations map[string]*expectations + tagPolicies map[string]*verificationPolicy validateAllSigs bool - nonceChecker NonceChecker } -func (v *verifier) Verify(msg *Message) error { +func (v *verifier) Verify(msg *Message, opts ...VerifyOption) (VerificationResult, error) { + policiesByTag, err := v.policiesForCall(opts) + if err != nil { + return nil, fmt.Errorf("%w: %w", ErrVerificationFailed, err) + } + sigRefs, err := getSignatureReferences(msg.Header.Values(headerSignatureInput)) if err != nil { - return fmt.Errorf("%w: %w", ErrVerificationFailed, err) + return nil, fmt.Errorf("%w: %w", ErrVerificationFailed, err) } signatureDict, err := httpsfv.UnmarshalDictionary(msg.Header.Values(headerSignature)) if err != nil { - return fmt.Errorf("%w: %w", ErrVerificationFailed, err) + return nil, fmt.Errorf("%w: %w", ErrVerificationFailed, err) } // look if we miss any signatures for configured tags if v.hasMissingSignatures(sigRefs) { - return fmt.Errorf("%w: %w", ErrVerificationFailed, v.negotiateSignatureParameters(msg)) + return nil, fmt.Errorf("%w: %w", ErrVerificationFailed, v.negotiateSignatureParameters(msg, policiesByTag)) } // collect those signatures, which we can verify applicableSignatures, err := v.applicableSignatures(sigRefs) if err != nil { - return fmt.Errorf("%w: %w", ErrVerificationFailed, err) + return nil, fmt.Errorf("%w: %w", ErrVerificationFailed, err) } // do the actual verification + results := make([]VerifiedSignature, 0, len(applicableSignatures)) for name, params := range applicableSignatures { tag, _ := params.tag() - exp, exists := v.tagExpectations[tag] + policy, exists := policiesByTag[tag] if !exists { - exp = v.tagExpectations[""] + policy = policiesByTag[""] } signature, err := v.extractSignature(signatureDict, name) if err != nil { - return fmt.Errorf("%w: %w", ErrVerificationFailed, err) + return nil, fmt.Errorf("%w: %w", ErrVerificationFailed, err) } - err = v.verifySignature(msg, signature, params, exp) + result, err := v.verifySignature(msg, name, signature, params, policy) if err != nil { if errors.Is(err, ErrMissingParameter) { - return fmt.Errorf("%w: %w", ErrVerificationFailed, v.negotiateSignatureParameters(msg)) + return nil, fmt.Errorf("%w: %w", ErrVerificationFailed, v.negotiateSignatureParameters(msg, policiesByTag)) } - return fmt.Errorf("%w: %w", ErrVerificationFailed, err) + return nil, fmt.Errorf("%w: %w", ErrVerificationFailed, err) } + + results = append(results, result) } - return nil + return results, nil +} + +func (v *verifier) policiesForCall(opts []VerifyOption) (map[string]*verificationPolicy, error) { + if len(opts) == 0 { + return v.tagPolicies, nil + } + + result := make(map[string]*verificationPolicy, len(v.tagPolicies)) + for tag, original := range v.tagPolicies { + effective, err := original.withOptions(tag, opts) + if err != nil { + return nil, err + } + + result[tag] = effective + } + + return result, nil } func (v *verifier) applicableSignatures(refs map[string]*signatureInput) (map[string]*signatureInput, error) { @@ -428,7 +213,7 @@ func (v *verifier) applicableSignatures(refs map[string]*signatureInput) (map[st continue } - if _, required := v.tagExpectations[tag]; !required { + if _, required := v.tagPolicies[tag]; !required { delete(refs, name) } } @@ -441,15 +226,20 @@ func (v *verifier) applicableSignatures(refs map[string]*signatureInput) (map[st return refs, nil } -func (v *verifier) negotiateSignatureParameters(msg *Message) error { +func (v *verifier) negotiateSignatureParameters(msg *Message, policiesByTag map[string]*verificationPolicy) error { hdr := http.Header{} - for sigTag, exp := range v.tagExpectations { - if exp.asb == nil || len(sigTag) == 0 { + for sigTag, policy := range policiesByTag { + if policy.asb == nil || len(sigTag) == 0 { continue } - err := exp.asb.Build(msg.Context, hdr) + buildOpts := make([]AcceptSignatureBuildOption, len(policy.expectedParameters)) + for i, param := range policy.expectedParameters { + buildOpts[i] = param + } + + err := policy.asb.Build(msg.Context, hdr, buildOpts...) if err != nil { return fmt.Errorf("%w: failed to negotiate signature for tag %s: %w", ErrSignatureNegotiationError, sigTag, err) } @@ -459,9 +249,9 @@ func (v *verifier) negotiateSignatureParameters(msg *Message) error { } func (v *verifier) hasMissingSignatures(sigRefs map[string]*signatureInput) bool { - for sigTag := range v.tagExpectations { + for sigTag := range v.tagPolicies { if len(sigTag) == 0 { - // empty tag is used for expectations for all signatures + // empty tag is used for a policy applying to all signatures // ignoring it continue } @@ -487,37 +277,53 @@ func (v *verifier) hasMissingSignatures(sigRefs map[string]*signatureInput) bool func (v *verifier) verifySignature( msg *Message, + label string, signature []byte, si *signatureInput, - exp *expectations, -) error { - base, err := newSignatureBase(si, msg) + policy *verificationPolicy, +) (VerifiedSignature, error) { + if err := policy.assertMetadata(si, msg); err != nil { + return VerifiedSignature{}, err + } + + base, err := newSignatureBase(msg, si, nil) if err != nil { - return err + return VerifiedSignature{}, err } - keyID, _ := si.keyID() + components := base.components() + params := si.parameters() - key, err := v.keyResolver.ResolveKey(msg.Context, keyID) + keyInfo, err := v.keyResolver.ResolveKey(msg.Context, SignatureInfo{ + Label: label, + Message: msg, + Components: components, + Parameters: params, + }) if err != nil { - return err + return VerifiedSignature{}, err } - if err = exp.assert(si, msg, key.Algorithm, v.nonceChecker); err != nil { - return err + if err = policy.assertKeyAlgorithm(si, keyInfo.Key.Algorithm); err != nil { + return VerifiedSignature{}, err } - verifier, err := newPayloadVerifier(key.Key, key.KeyID, key.Algorithm) + verifier, err := newPayloadVerifier(keyInfo.Key.Material, keyInfo.Key.Algorithm) if err != nil { - return err + return VerifiedSignature{}, err } - sb, err := base.marshal() + err = verifier.verify(msg.Context, base.marshal(), signature) if err != nil { - return err + return VerifiedSignature{}, err } - return verifier.verifyPayload(sb, signature) + return VerifiedSignature{ + Label: label, + Components: components, + Parameters: params, + Metadata: keyInfo.Metadata, + }, nil } func getSignatureReferences(values []string) (map[string]*signatureInput, error) { diff --git a/verifier_test.go b/verifier_test.go index 94e0600..05649a7 100644 --- a/verifier_test.go +++ b/verifier_test.go @@ -11,11 +11,12 @@ import ( "encoding/base64" "encoding/pem" "errors" - "fmt" "io" "net/http" "net/url" + "slices" "strings" + "sync" "testing" "time" @@ -42,21 +43,20 @@ func TestNewPayloadVerifier(t *testing.T) { require.NoError(t, err) require.Equal(t, len(k256), n) - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { key any alg SignatureAlgorithm typ any err error }{ - {uc: "unsupported algorithm", key: "foo", err: ErrUnsupportedKeyType}, - {uc: "ed25519 verifier", key: ek25519, alg: Ed25519, typ: &ed25519Verifier{}}, - {uc: "rsa verifier", key: &pk2048.PublicKey, alg: RsaPssSha256, typ: &rsaVerifier{}}, - {uc: "ecdsa verifier", key: &pkp256.PublicKey, alg: EcdsaP256Sha256, typ: &ecdsaVerifier{}}, - {uc: "hmac verifier", key: k256, alg: HmacSha256, typ: &symmetricSigner{}}, + "unsupported algorithm": {key: "foo", err: ErrUnsupportedKeyType}, + "ed25519 verifier": {key: ek25519, alg: Ed25519, typ: &ed25519Verifier{}}, + "rsa verifier": {key: &pk2048.PublicKey, alg: RsaPssSha256, typ: &rsaVerifier{}}, + "ecdsa verifier": {key: &pkp256.PublicKey, alg: EcdsaP256Sha256, typ: &ecdsaVerifier{}}, + "hmac verifier": {key: k256, alg: HmacSha256, typ: &symmetricSigner{}}, } { - t.Run(tc.uc, func(t *testing.T) { - sig, err := newPayloadVerifier(tc.key, "test", tc.alg) + t.Run(uc, func(t *testing.T) { + sig, err := newPayloadVerifier(tc.key, tc.alg) if tc.err != nil { require.Error(t, err) @@ -70,848 +70,388 @@ func TestNewPayloadVerifier(t *testing.T) { } } -func TestExpectationsAssertParameters(t *testing.T) { - now := time.Now().UTC() - falseVal := false - trueVal := true - noNonce := NonceValue{Present: false, Value: ""} - - for _, tc := range []struct { - uc string - params httpsfv.InnerList - exp expectations - expAlg SignatureAlgorithm - configure func(t *testing.T, nc *NonceCheckerMock) - assert func(t *testing.T, err error) - }{ - { - uc: "replay attack", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Nonce), "test") - - return params - }(), - }, - exp: expectations{reqExpiresTS: &falseVal, reqCreatedTS: &falseVal}, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() +func TestNewVerifier(t *testing.T) { + t.Parallel() - nonce := NonceValue{ - Present: true, - Value: "test", - } - nc.EXPECT().CheckNonce(mock.Anything, nonce).Return(errors.New("test error")) - }, - assert: func(t *testing.T, err error) { + for uc, tc := range map[string]struct { + resolver KeyResolver + opts []VerifierOption + assert func(t *testing.T, err error, v *verifier) + }{ + "without key resolver": { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() require.Error(t, err) - require.ErrorIs(t, err, ErrParameter) - require.ErrorContains(t, err, "nonce validation failed") + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorContains(t, err, "no key resolver") }, }, - { - uc: "signature algorithm mismatch", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Alg), string(RsaPssSha512)) - - return params - }(), - }, - expAlg: EcdsaP256Sha256, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) - }, - assert: func(t *testing.T, err error) { + "with key resolver only": { + resolver: &KeyResolverMock{}, + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() require.Error(t, err) - require.ErrorIs(t, err, ErrParameter) - require.ErrorContains(t, err, "key algorithm rsa-pss-sha512 does not match signature algorithm ecdsa-p256-sha256") + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorContains(t, err, "validation of all signatures disabled, but no signature tags specified") }, }, - { - uc: "signature expired, no tolerance specified", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Expires), now.Add(-2*time.Second).Unix()) - - return params - }(), - }, - exp: expectations{reqExpiresTS: &falseVal, reqCreatedTS: &falseVal}, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) + "with component identifiers configuration error": { + resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithComponents("@foo"), }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() require.Error(t, err) - require.ErrorIs(t, err, ErrValidity) - require.ErrorContains(t, err, "expired") - }, - }, - { - uc: "signature is still valid with specified tolerance", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Expires), now.Add(-2*time.Second).Unix()) - - return params - }(), - }, - exp: expectations{ - tolerance: 3 * time.Second, - reqCreatedTS: &falseVal, - reqExpiresTS: &falseVal, - }, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) - }, - assert: func(t *testing.T, err error) { - t.Helper() - - require.NoError(t, err) + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorContains(t, err, "unsupported component identifier: @foo") }, }, - { - uc: "signature is valid if expires in the future", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Expires), now.Add(2*time.Second).Unix()) - - return params - }(), - }, - exp: expectations{ - tolerance: 2 * time.Second, - reqCreatedTS: &falseVal, - reqExpiresTS: &falseVal, - }, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) + "with empty required tag": { + resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithRequiredTag(""), }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.NoError(t, err) + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorIs(t, err, ErrParameter) + require.ErrorContains(t, err, "required tag must not be empty") }, }, - { - uc: "signature not yet valid, no tolerance specified", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Created), now.Add(2*time.Second).Unix()) - - return params - }(), - }, - exp: expectations{reqCreatedTS: &falseVal, reqExpiresTS: &falseVal}, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) + "cannot verify and negotiate any possible signature": { + resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithValidateAllSignatures(), + WithSignatureNegotiation(), }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() require.Error(t, err) - require.ErrorIs(t, err, ErrValidity) - require.ErrorContains(t, err, "not yet valid") - }, - }, - { - uc: "signature already valid with specified tolerance", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Created), now.Add(2*time.Second).Unix()) - - return params - }(), - }, - exp: expectations{ - tolerance: 3 * time.Second, - reqCreatedTS: &falseVal, - reqExpiresTS: &falseVal, - }, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) - }, - assert: func(t *testing.T, err error) { - t.Helper() - - require.NoError(t, err) + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorContains(t, err, "verification and negotiation") }, }, - { - uc: "signature is valid if created in the past", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Created), now.Add(-2*time.Second).Unix()) - - return params - }(), - }, - exp: expectations{ - maxAge: 30 * time.Second, - reqCreatedTS: &falseVal, - reqExpiresTS: &falseVal, - }, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) + "global parameter conflict with validation of all signatures": { + resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithValidateAllSignatures(), + WithForbiddenParameters("created"), }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.NoError(t, err) + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorIs(t, err, ErrParameter) }, }, - { - uc: "signature too old", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Created), now.Add(-2*time.Second).Unix()) - - return params - }(), - }, - exp: expectations{reqCreatedTS: &falseVal, reqExpiresTS: &falseVal}, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) + "with verification of all signatures enabled": { + resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithValidateAllSignatures(), }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, v *verifier) { t.Helper() - require.Error(t, err) - require.ErrorIs(t, err, ErrValidity) - require.ErrorContains(t, err, "too old") - }, - }, - { - uc: "expected component identifier missing", - params: httpsfv.InnerList{Params: httpsfv.NewParams()}, - exp: func() expectations { - ids, err := toComponentIdentifiers([]string{"@method;req", "@authority"}) require.NoError(t, err) - - return expectations{identifiers: ids, reqCreatedTS: &falseVal, reqExpiresTS: &falseVal} - }(), - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) - }, - assert: func(t *testing.T, err error) { - t.Helper() - - require.Error(t, err) - require.ErrorIs(t, err, ErrMissingParameter) - require.ErrorContains(t, err, `"@method";req, "@authority"`) - }, - }, - { - uc: "expected created parameter is missing", - params: httpsfv.InnerList{Params: httpsfv.NewParams()}, - exp: expectations{reqCreatedTS: &trueVal, reqExpiresTS: &falseVal}, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) - }, - assert: func(t *testing.T, err error) { - t.Helper() - - require.Error(t, err) - require.ErrorIs(t, err, ErrMissingParameter) - require.ErrorContains(t, err, `created parameter`) + assert.True(t, v.validateAllSigs) + assert.Len(t, v.tagPolicies, 1) + assert.Contains(t, v.tagPolicies, "") + assert.IsType(t, &KeyResolverMock{}, v.keyResolver) }, }, - { - uc: "expected expires parameter is missing", - params: httpsfv.InnerList{Params: httpsfv.NewParams()}, - exp: expectations{reqCreatedTS: &falseVal, reqExpiresTS: &trueVal}, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nc.EXPECT().CheckNonce(mock.Anything, noNonce).Return(nil) - }, - assert: func(t *testing.T, err error) { - t.Helper() - - require.Error(t, err) - require.ErrorIs(t, err, ErrMissingParameter) - require.ErrorContains(t, err, `expires parameter`) - }, - }, - { - uc: "successful assertion with all possible parameters", - params: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Created), now.Add(-3*time.Second).Unix()) - params.Add(string(Expires), now.Add(3*time.Second).Unix()) - params.Add(string(Alg), string(EcdsaP256Sha256)) - params.Add(string(KeyID), "test") - params.Add(string(Nonce), "foo") - params.Add(string(Tag), "test") - - return params - }(), - Items: []httpsfv.Item{ - httpsfv.NewItem("@method"), - httpsfv.NewItem("@authority"), - }, - }, - exp: func() expectations { - ids, err := toComponentIdentifiers([]string{"@authority", "@method"}) - require.NoError(t, err) - - return expectations{ - identifiers: ids, - maxAge: 5 * time.Second, - } - }(), - expAlg: EcdsaP256Sha256, - configure: func(t *testing.T, nc *NonceCheckerMock) { - t.Helper() - - nonce := NonceValue{Present: true, Value: "foo"} - nc.EXPECT().CheckNonce(mock.Anything, nonce).Return(nil) + "with tag specific options only": { + resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithRequiredTag("test", + WithValidityTolerance(1*time.Second), + WithComponents("@status"), + ), }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, v *verifier) { t.Helper() require.NoError(t, err) - }, - }, - } { - t.Run(tc.uc, func(t *testing.T) { - msg := &Message{Context: context.TODO()} - - si, err := parseSignatureInput(tc.params) - require.NoError(t, err) - - nc := NewNonceCheckerMock(t) - tc.configure(t, nc) - - err = tc.exp.assert(si, msg, tc.expAlg, nc) - - tc.assert(t, err) - }) - } -} - -func TestWithRequiredComponents(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - identifiers []string - err error - }{ - {uc: "multiple valid identifier", identifiers: []string{"@status;req", "@method"}}, - {uc: "invalid identifier", identifiers: []string{"@foo"}, err: ErrUnsupportedComponentIdentifier}, - } { - t.Run(tc.uc, func(t *testing.T) { - v := &verifier{} - exp := &expectations{} - - err := WithRequiredComponents(tc.identifiers...)(v, exp, false) - - if tc.err != nil { - require.Error(t, err) - require.ErrorIs(t, err, tc.err) - } else { - require.NoError(t, err) - assert.Empty(t, v.tagExpectations) - require.Len(t, exp.identifiers, len(tc.identifiers)) - - for i, id := range exp.identifiers { - vals := strings.Split(tc.identifiers[i], ";") - assert.Equal(t, vals[0], id.Value) - } - } - }) - } -} - -func TestWithValidityTolerance(t *testing.T) { - t.Parallel() - - v := &verifier{} - exp := &expectations{} - - err := WithValidityTolerance(1*time.Minute)(v, exp, false) - require.NoError(t, err) - - assert.Empty(t, v.tagExpectations) - assert.Equal(t, 1*time.Minute, exp.tolerance) -} - -func TestWithRequiredTag(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - opts []VerifierOption - assert func(t *testing.T, err error, exp *expectations) - }{ - { - uc: "without options", - assert: func(t *testing.T, err error, exp *expectations) { - t.Helper() + assert.False(t, v.validateAllSigs) + assert.IsType(t, &KeyResolverMock{}, v.keyResolver) + assert.Len(t, v.tagPolicies, 1) + assert.NotContains(t, v.tagPolicies, "") + require.Contains(t, v.tagPolicies, "test") - require.NoError(t, err) - require.NotNil(t, exp) - assert.Empty(t, exp.identifiers) - assert.Equal(t, time.Duration(-1), exp.tolerance) //nolint:testifylint + exp := v.tagPolicies["test"] + assert.Len(t, exp.identifiers, 1) + assert.Equal(t, "@status", exp.identifiers[0].Value) + assert.Equal(t, 1*time.Second, exp.tolerance) }, }, - { - uc: "with identifiers only", + "with global defaults without signature negotiation": { + resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithRequiredComponents("@status"), + WithRequiredTag("test"), + WithValidityTolerance(1 * time.Second), + WithComponents("@status"), }, - assert: func(t *testing.T, err error, exp *expectations) { + assert: func(t *testing.T, err error, v *verifier) { t.Helper() require.NoError(t, err) - require.NotNil(t, exp) + assert.False(t, v.validateAllSigs) + assert.IsType(t, &KeyResolverMock{}, v.keyResolver) + assert.Len(t, v.tagPolicies, 1) + assert.NotContains(t, v.tagPolicies, "") + require.Contains(t, v.tagPolicies, "test") + + exp := v.tagPolicies["test"] assert.Len(t, exp.identifiers, 1) assert.Equal(t, "@status", exp.identifiers[0].Value) - assert.Equal(t, time.Duration(-1), exp.tolerance) //nolint:testifylint + assert.Equal(t, 1*time.Second, exp.tolerance) + assert.Nil(t, exp.asb) }, }, - { - uc: "with tolerance only", + "with global defaults with signature negotiation": { + resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithValidityTolerance(5 * time.Minute), + WithRequiredTag("test"), + WithValidityTolerance(1 * time.Second), + WithComponents("@status", "content-digest"), + WithSignatureNegotiation( + WithSignatureAlgorithm(RsaPssSha512), + WithKeyID("bar"), + ), }, - assert: func(t *testing.T, err error, exp *expectations) { + assert: func(t *testing.T, err error, v *verifier) { t.Helper() require.NoError(t, err) - require.NotNil(t, exp) - assert.Empty(t, exp.identifiers) - assert.Equal(t, 5*time.Minute, exp.tolerance) + assert.False(t, v.validateAllSigs) + assert.IsType(t, &KeyResolverMock{}, v.keyResolver) + assert.Len(t, v.tagPolicies, 1) + assert.NotContains(t, v.tagPolicies, "") + require.Contains(t, v.tagPolicies, "test") + + exp := v.tagPolicies["test"] + assert.Len(t, exp.identifiers, 2) + assert.Equal(t, "@status", exp.identifiers[0].Value) + assert.Equal(t, "content-digest", exp.identifiers[1].Value) + assert.Equal(t, 1*time.Second, exp.tolerance) + require.NotNil(t, exp.asb) + assert.Nil(t, exp.asb.nonceGetter) + assert.Equal(t, "sig", exp.asb.label) + assert.ElementsMatch(t, exp.asb.cdAlgPrefs, []string{"sha-256=5", "sha-512=10"}) + assert.Equal(t, RsaPssSha512, exp.asb.signatureAlgorithm) + assert.Equal(t, "bar", exp.asb.keyID) + assert.True(t, exp.asb.addCreatedTS) + assert.True(t, exp.asb.addExpiresTS) + assert.True(t, exp.asb.wantContentDigest) + assert.Equal(t, "test", exp.asb.tag) + assert.Equal(t, exp.identifiers, exp.asb.identifiers) }, }, - { - uc: "with all possible options", + "with all possible options": { + resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithRequiredComponents("@status"), - WithValidityTolerance(5 * time.Minute), + WithRequiredTag("test", + WithValidityTolerance(1*time.Second), + WithComponents("@status"), + ), + WithValidityTolerance(1 * time.Minute), + WithComponents("@method"), + WithValidateAllSignatures(), }, - assert: func(t *testing.T, err error, exp *expectations) { + assert: func(t *testing.T, err error, v *verifier) { t.Helper() require.NoError(t, err) - require.NotNil(t, exp) + assert.True(t, v.validateAllSigs) + assert.IsType(t, &KeyResolverMock{}, v.keyResolver) + assert.Len(t, v.tagPolicies, 2) + + require.Contains(t, v.tagPolicies, "") + exp := v.tagPolicies[""] assert.Len(t, exp.identifiers, 1) - assert.Equal(t, "@status", exp.identifiers[0].Value) - assert.Equal(t, 5*time.Minute, exp.tolerance) - }, - }, - { - uc: "with unsupported identifier", - opts: []VerifierOption{ - WithRequiredComponents("@foo"), - }, - assert: func(t *testing.T, err error, exp *expectations) { - t.Helper() + assert.Equal(t, "@method", exp.identifiers[0].Value) + assert.Equal(t, 1*time.Minute, exp.tolerance) - require.Error(t, err) - require.ErrorIs(t, err, ErrUnsupportedComponentIdentifier) - require.Nil(t, exp) + require.Contains(t, v.tagPolicies, "test") + exp = v.tagPolicies["test"] + assert.Len(t, exp.identifiers, 1) + assert.Equal(t, "@status", exp.identifiers[0].Value) + assert.Equal(t, 1*time.Second, exp.tolerance) }, }, - { - uc: "with nested WithRequiredTag", + "parameter rules inherited from global configuration": { + resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithRequiredTag("foo"), - }, - assert: func(t *testing.T, err error, _ *expectations) { - t.Helper() - - require.Error(t, err) - require.ErrorContains(t, err, "WithRequiredTag") + WithRequiredTag("profile", + WithRequiredParameters("nonce"), + WithParameter("audience", "service-a"), + ), + WithForbiddenParameters("alg", "keyid"), }, - }, - } { - t.Run(tc.uc, func(t *testing.T) { - v := &verifier{tagExpectations: make(map[string]*expectations)} - - recoverIfPanics := func(t *testing.T, f func() error) (err error) { - t.Helper() - - defer func() { - var ok bool - - if res := recover(); res != nil { - if err, ok = res.(error); !ok { - err = fmt.Errorf("%v", res) - } - } - }() - - err = f() - - return - } - - err := recoverIfPanics(t, func() error { - return WithRequiredTag("test", tc.opts...)(v, nil, false) - }) - if err == nil { - require.Len(t, v.tagExpectations, 1) - } - - tc.assert(t, err, v.tagExpectations["test"]) - }) - } - - t.Run("with duplicate WithRequiredTag", func(t *testing.T) { - v := &verifier{tagExpectations: map[string]*expectations{"foo": {}}} - - err := WithRequiredTag("foo", nil)(v, nil, false) - require.Error(t, err) - require.ErrorIs(t, err, ErrParameter) - require.ErrorContains(t, err, "already configured") - }) -} - -func TestWithMaxAge(t *testing.T) { - t.Parallel() - - v := &verifier{} - exp := &expectations{} - - err := WithMaxAge(15*time.Minute)(v, exp, false) - require.NoError(t, err) - - assert.Equal(t, 15*time.Minute, exp.maxAge) -} - -func TestWithNonceChecker(t *testing.T) { - t.Parallel() - - v := &verifier{} - exp := &expectations{} - storage := &NonceCheckerMock{} - - err := WithNonceChecker(storage)(v, exp, false) - require.NoError(t, err) - - assert.Equal(t, storage, v.nonceChecker) -} - -func TestWithSignatureNegotiation(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - opts []SignatureNegotiationOption - assert func(t *testing.T, err error, asb *AcceptSignatureBuilder) - }{ - { - uc: "without options", - assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + assert: func(t *testing.T, err error, v *verifier) { t.Helper() require.NoError(t, err) - require.NotNil(t, asb) - assert.IsType(t, nonceGetter{}, asb.nonceGetter) - assert.Equal(t, "sig", asb.label) - assert.ElementsMatch(t, asb.cdAlgPrefs, []string{"sha-256=5", "sha-512=10"}) - assert.Empty(t, asb.keyAlgorithm) - assert.Empty(t, asb.keyID) - // not set by any of the options - assert.True(t, asb.addCreatedTS) - assert.True(t, asb.addExpiresTS) - assert.False(t, asb.wantContentDigest) - assert.Empty(t, asb.tag) - assert.Empty(t, asb.identifiers) + exp := v.tagPolicies["profile"] + assert.Equal(t, []SignatureParameter{Nonce}, exp.requiredParameters) + assert.Equal(t, []SignatureParameter{Alg, KeyID}, exp.forbiddenParameters) + assert.Equal(t, []parameterOption{{name: "audience", value: "service-a"}}, exp.expectedParameters) }, }, - { - uc: "with all possible options", - opts: []SignatureNegotiationOption{ - WithRequestedLabel("foo"), - WithRequestedNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), - WithRequestedKey(Key{KeyID: "bar", Algorithm: RsaPssSha512}), - WithRequestedContentDigestAlgorithmPreferences(AlgorithmPreference{Sha512, 2}), + "identical global and tag-specific expectations are compatible": { + resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithParameter("audience", "service-a"), + WithRequiredTag("profile", + WithParameter("audience", "service-a"), + WithRequiredParameters("audience"), + ), }, - assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + assert: func(t *testing.T, err error, v *verifier) { t.Helper() require.NoError(t, err) - - require.NotNil(t, asb) - require.NotNil(t, asb.nonceGetter) - nonce, err := asb.nonceGetter.GetNonce(context.TODO()) - require.NoError(t, err) - require.Equal(t, "abc", nonce) - assert.Equal(t, "foo", asb.label) - assert.ElementsMatch(t, asb.cdAlgPrefs, []string{"sha-512=2"}) - assert.Equal(t, RsaPssSha512, asb.keyAlgorithm) - assert.Equal(t, "bar", asb.keyID) - // not set by any of the options - assert.True(t, asb.addCreatedTS) - assert.True(t, asb.addExpiresTS) - assert.False(t, asb.wantContentDigest) - assert.Empty(t, asb.tag) - assert.Empty(t, asb.identifiers) + assert.Len(t, v.tagPolicies["profile"].expectedParameters, 1) }, }, - { - uc: "with error while applying the option", - opts: []SignatureNegotiationOption{ - WithRequestedContentDigestAlgorithmPreferences(AlgorithmPreference{}), - }, - assert: func(t *testing.T, err error, _ *AcceptSignatureBuilder) { - t.Helper() - - require.Error(t, err) - require.ErrorIs(t, err, ErrParameter) + "global and tag-specific parameter conflict": { + resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithRequiredTag("profile", + WithRequiredParameters("nonce"), + ), + WithForbiddenParameters("nonce"), }, - }, - } { - t.Run(tc.uc, func(t *testing.T) { - v := &verifier{} - exp := &expectations{} - - err := WithSignatureNegotiation(tc.opts...)(v, exp, false) - - tc.assert(t, err, exp.asb) - }) - } -} - -func TestNewVerifier(t *testing.T) { - t.Parallel() - - for _, tc := range []struct { - uc string - resolver KeyResolver - opts []VerifierOption - assert func(t *testing.T, err error, v *verifier) - }{ - { - uc: "without key resolver", assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrVerifierCreation) - require.ErrorContains(t, err, "no key resolver") + require.ErrorIs(t, err, ErrParameter) }, }, - { - uc: "with key resolver only", + "conflicting expected values": { resolver: &KeyResolverMock{}, + opts: []VerifierOption{ + WithRequiredTag("profile", + WithParameter("audience", "first"), + ), + WithParameter("audience", "second"), + }, assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrVerifierCreation) - require.ErrorContains(t, err, "validation of all signatures disabled, but no signature tags specified") + require.ErrorIs(t, err, ErrParameter) }, }, - { - uc: "with component identifiers configuration error", + "required tag cannot be forbidden": { resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithRequiredComponents("@foo"), + WithRequiredTag("profile", + WithForbiddenParameters("tag"), + ), }, assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrVerifierCreation) - require.ErrorContains(t, err, "unsupported component identifier: @foo") + require.ErrorIs(t, err, ErrParameter) }, }, - { - uc: "cannot verify and negotiate any possible signature", + "required timestamp cannot be forbidden": { resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithValidateAllSignatures(), - WithSignatureNegotiation(), + WithRequiredTag("profile"), + WithForbiddenParameters("created"), }, assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrVerifierCreation) - require.ErrorContains(t, err, "verification and negotiation") + require.ErrorIs(t, err, ErrParameter) }, }, - { - uc: "with verification of all signatures enabled", + "optional timestamp may be forbidden": { resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithValidateAllSignatures(), + WithRequiredTag("profile"), + WithForbiddenParameters("created"), + WithCreatedTimestamp(false), }, assert: func(t *testing.T, err error, v *verifier) { t.Helper() require.NoError(t, err) - assert.True(t, v.validateAllSigs) - assert.Len(t, v.tagExpectations, 1) - assert.Contains(t, v.tagExpectations, "") - assert.IsType(t, &KeyResolverMock{}, v.keyResolver) + assert.Equal(t, []SignatureParameter{Created}, v.tagPolicies["profile"].forbiddenParameters) }, }, - { - uc: "with tag specific options only", + "invalid parameter name": { resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithRequiredTag("test", - WithValidityTolerance(1*time.Second), - WithRequiredComponents("@status"), + WithRequiredTag("profile", + WithRequiredParameters("not a name"), ), }, - assert: func(t *testing.T, err error, v *verifier) { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.NoError(t, err) - assert.False(t, v.validateAllSigs) - assert.IsType(t, &KeyResolverMock{}, v.keyResolver) - assert.Len(t, v.tagExpectations, 1) - assert.NotContains(t, v.tagExpectations, "") - require.Contains(t, v.tagExpectations, "test") - - exp := v.tagExpectations["test"] - assert.Len(t, exp.identifiers, 1) - assert.Equal(t, "@status", exp.identifiers[0].Value) - assert.Equal(t, 1*time.Second, exp.tolerance) + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorIs(t, err, ErrParameter) }, }, - { - uc: "with global defaults without signature negotiation", + "unsupported expected standard parameter": { resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithRequiredTag("test"), - WithValidityTolerance(1 * time.Second), - WithRequiredComponents("@status"), + WithRequiredTag("profile", + WithParameter("alg", "ed25519"), + ), }, - assert: func(t *testing.T, err error, v *verifier) { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.NoError(t, err) - assert.False(t, v.validateAllSigs) - assert.IsType(t, &KeyResolverMock{}, v.keyResolver) - assert.Len(t, v.tagExpectations, 1) - assert.NotContains(t, v.tagExpectations, "") - require.Contains(t, v.tagExpectations, "test") - - exp := v.tagExpectations["test"] - assert.Len(t, exp.identifiers, 1) - assert.Equal(t, "@status", exp.identifiers[0].Value) - assert.Equal(t, 1*time.Second, exp.tolerance) - assert.Nil(t, exp.asb) + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorIs(t, err, ErrParameter) }, }, - { - uc: "with global defaults with signature negotiation", + "invalid expected nonce": { resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithRequiredTag("test"), - WithValidityTolerance(1 * time.Second), - WithRequiredComponents("@status", "content-digest"), - WithSignatureNegotiation( - WithRequestedKey(Key{KeyID: "bar", Algorithm: RsaPssSha512}), + WithRequiredTag("profile", + WithParameter("nonce", ""), ), }, - assert: func(t *testing.T, err error, v *verifier) { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.NoError(t, err) - assert.False(t, v.validateAllSigs) - assert.IsType(t, &KeyResolverMock{}, v.keyResolver) - assert.Len(t, v.tagExpectations, 1) - assert.NotContains(t, v.tagExpectations, "") - require.Contains(t, v.tagExpectations, "test") - - exp := v.tagExpectations["test"] - assert.Len(t, exp.identifiers, 2) - assert.Equal(t, "@status", exp.identifiers[0].Value) - assert.Equal(t, "content-digest", exp.identifiers[1].Value) - assert.Equal(t, 1*time.Second, exp.tolerance) - require.NotNil(t, exp.asb) - assert.IsType(t, nonceGetter{}, exp.asb.nonceGetter) - assert.Equal(t, "sig", exp.asb.label) - assert.ElementsMatch(t, exp.asb.cdAlgPrefs, []string{"sha-256=5", "sha-512=10"}) - assert.Equal(t, RsaPssSha512, exp.asb.keyAlgorithm) - assert.Equal(t, "bar", exp.asb.keyID) - assert.True(t, exp.asb.addCreatedTS) - assert.True(t, exp.asb.addExpiresTS) - assert.True(t, exp.asb.wantContentDigest) - assert.Equal(t, "test", exp.asb.tag) - assert.Equal(t, exp.identifiers, exp.asb.identifiers) + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorIs(t, err, ErrParameter) }, }, - { - uc: "with all possible options", + "duplicate negotiation parameter rejected": { resolver: &KeyResolverMock{}, opts: []VerifierOption{ - WithRequiredTag("test", - WithValidityTolerance(1*time.Second), - WithRequiredComponents("@status"), + WithRequiredTag("profile", + WithSignatureNegotiation( + WithParameter("audience", "first"), + WithParameter("audience", "second"), + ), ), - WithValidityTolerance(1 * time.Minute), - WithRequiredComponents("@method"), - WithValidateAllSignatures(), }, - assert: func(t *testing.T, err error, v *verifier) { + assert: func(t *testing.T, err error, _ *verifier) { t.Helper() - require.NoError(t, err) - assert.True(t, v.validateAllSigs) - assert.IsType(t, &KeyResolverMock{}, v.keyResolver) - assert.Len(t, v.tagExpectations, 2) - - require.Contains(t, v.tagExpectations, "") - exp := v.tagExpectations[""] - assert.Len(t, exp.identifiers, 1) - assert.Equal(t, "@method", exp.identifiers[0].Value) - assert.Equal(t, 1*time.Minute, exp.tolerance) - - require.Contains(t, v.tagExpectations, "test") - exp = v.tagExpectations["test"] - assert.Len(t, exp.identifiers, 1) - assert.Equal(t, "@status", exp.identifiers[0].Value) - assert.Equal(t, 1*time.Second, exp.tolerance) + require.ErrorIs(t, err, ErrVerifierCreation) + require.ErrorIs(t, err, ErrParameter) }, }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { res, err := NewVerifier(tc.resolver, tc.opts...) var v *verifier @@ -961,19 +501,20 @@ func TestVerifierVerify(t *testing.T) { tkEd25519, ok := key.(ed25519.PublicKey) require.True(t, ok) - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { opts []VerifierOption + verifyOpts []VerifyOption msg *Message configureResolver func(t *testing.T, kr *KeyResolverMock) - assert func(t *testing.T, err error) + assert func(t *testing.T, err error, results VerificationResult) }{ - { - uc: "without signature-input header", - opts: []VerifierOption{WithValidateAllSignatures()}, + "without signature-input header": { + opts: []VerifierOption{ + WithValidateAllSignatures(), + }, msg: &Message{Header: make(http.Header)}, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() require.Error(t, err) @@ -981,16 +522,17 @@ func TestVerifierVerify(t *testing.T) { require.ErrorIs(t, err, &NoApplicableSignatureError{}) }, }, - { - uc: "malformed signature-input header items definition", - opts: []VerifierOption{WithValidateAllSignatures()}, + "malformed signature-input header items definition": { + opts: []VerifierOption{ + WithValidateAllSignatures(), + }, msg: &Message{ Header: http.Header{ "Signature-Input": []string{`sig=(,);created=1618884473;keyid="test"`}, }, }, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() require.Error(t, err) @@ -999,16 +541,17 @@ func TestVerifierVerify(t *testing.T) { require.ErrorContains(t, err, "unrecognized character") }, }, - { - uc: "malformed signature-input header parameter", - opts: []VerifierOption{WithValidateAllSignatures()}, + "malformed signature-input header parameter": { + opts: []VerifierOption{ + WithValidateAllSignatures(), + }, msg: &Message{ Header: http.Header{ "Signature-Input": []string{`sig=();created=1618884473;keyid=test`}, }, }, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() require.Error(t, err) @@ -1017,16 +560,17 @@ func TestVerifierVerify(t *testing.T) { require.ErrorContains(t, err, "keyid") }, }, - { - uc: "without signature header", - opts: []VerifierOption{WithValidateAllSignatures()}, + "without signature header": { + opts: []VerifierOption{ + WithValidateAllSignatures(), + }, msg: &Message{ Header: http.Header{ "Signature-Input": []string{`sig=();created=1618884473;keyid="test"`}, }, }, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() require.Error(t, err) @@ -1035,9 +579,10 @@ func TestVerifierVerify(t *testing.T) { require.ErrorContains(t, err, "no signature present") }, }, - { - uc: "malformed signature header", - opts: []VerifierOption{WithRequiredTag("foo")}, + "malformed signature header": { + opts: []VerifierOption{ + WithRequiredTag("foo"), + }, msg: &Message{ Header: http.Header{ "Signature-Input": []string{`sig=();created=1618884473;keyid="test"`}, @@ -1045,107 +590,389 @@ func TestVerifierVerify(t *testing.T) { }, }, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorContains(t, err, "format") + }, + }, + "no applicable signature present": { + opts: []VerifierOption{ + WithRequiredTag("foo"), + }, + msg: &Message{ + Header: http.Header{ + "Signature-Input": []string{`sig=();created=1618884473;keyid="test"`}, + "Signature": []string{"sig=:dGVzdA==:"}, + }, + }, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrVerificationFailed) + + var noSigErr *NoApplicableSignatureError + require.ErrorAs(t, err, &noSigErr) + + hdr := make(http.Header) + noSigErr.Negotiate(hdr) + require.Empty(t, hdr) + }, + }, + "signature base creation error": { + opts: []VerifierOption{ + WithValidateAllSignatures(), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), + }, + msg: &Message{ + Header: http.Header{ + "Signature-Input": []string{`sig=("@status");created=1618884473;keyid="test"`}, + "Signature": []string{"sig=:dGVzdA==:"}, + }, + IsRequest: true, + }, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorContains(t, err, "@status not valid for requests") + }, + }, + "key resolver error": { + opts: []VerifierOption{ + WithValidateAllSignatures(), + WithExpiresTimestamp(false), + }, + msg: &Message{ + Header: http.Header{ + "Signature-Input": []string{`sig=();created=1618884473;keyid="test"`}, + "Signature": []string{"sig=:dGVzdA==:"}, + }, + }, + configureResolver: func(t *testing.T, kr *KeyResolverMock) { + t.Helper() + + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig" && + si.Message != nil && + len(si.Components) == 0 && + si.Parameters["keyid"] == "test" && + si.Parameters["created"] == int64(1618884473) + })). + Return(KeyInfo{}, errors.New("test error")) + }, + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorContains(t, err, "test error") + }, + }, + "expired signature rejected before key resolution": { + opts: []VerifierOption{ + WithRequiredTag("foo"), + WithValidityTolerance(1 * time.Second), + }, + msg: &Message{ + Header: http.Header{ + "Signature-Input": []string{`sig=();expires=1618884470;keyid="test";tag="foo"`}, + "Signature": []string{"sig=:dGVzdA==:"}, + }, + }, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + require.Error(t, err) + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorContains(t, err, "expired") + }, + }, + "missing required component rejected before key resolution": { + opts: []VerifierOption{ + WithRequiredTag("foo", + WithComponents("@method"), + ), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), + }, + msg: &Message{ + Header: http.Header{ + "Signature-Input": []string{`sig=();tag="foo"`}, + "Signature": []string{"sig=:dGVzdA==:"}, + }, + IsRequest: true, + }, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { + t.Helper() + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorIs(t, err, &NoApplicableSignatureError{}) + require.Empty(t, results) + }, + }, + "required extension missing before key resolution": { + opts: []VerifierOption{ + WithRequiredTag("profile", + WithRequiredParameters("nonce"), + ), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), + }, + msg: &Message{Header: http.Header{ + "Signature-Input": {`sig=();tag="profile"`}, + "Signature": {"sig=:dGVzdA==:"}, + }}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { + t.Helper() + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorIs(t, err, ErrParameter) + require.NotErrorIs(t, err, &NoApplicableSignatureError{}) + require.Empty(t, results) + }, + }, + "forbidden parameter rejected before key resolution": { + opts: []VerifierOption{ + WithRequiredTag("profile", + WithForbiddenParameters("keyid", "alg"), + ), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), + }, + msg: &Message{Header: http.Header{ + "Signature-Input": {`sig=();keyid="key";tag="profile"`}, + "Signature": {"sig=:dGVzdA==:"}, + }}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { + t.Helper() + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorIs(t, err, ErrParameter) + require.Empty(t, results) + }, + }, + "dynamic parameter expectation checked before key resolution": { + opts: []VerifierOption{ + WithRequiredTag("profile"), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), + }, + verifyOpts: []VerifyOption{WithParameter("audience", "expected")}, + msg: &Message{Header: http.Header{ + "Signature-Input": {`sig=();tag="profile";audience="other"`}, + "Signature": {"sig=:dGVzdA==:"}, + }}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { + t.Helper() + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorIs(t, err, ErrParameter) + require.Empty(t, results) + }, + }, + "dynamic expectations cannot override static values": { + opts: []VerifierOption{ + WithRequiredTag("profile", + WithParameter("audience", "static"), + ), + }, + verifyOpts: []VerifyOption{WithParameter("audience", "dynamic")}, + msg: &Message{Header: make(http.Header)}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { + t.Helper() + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorIs(t, err, ErrParameter) + require.Empty(t, results) + }, + }, + "dynamic rules cannot forbid required timestamps": { + opts: []VerifierOption{ + WithRequiredTag("profile"), + }, + verifyOpts: []VerifyOption{ + WithForbiddenParameters("created"), + }, + msg: &Message{Header: make(http.Header)}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrVerificationFailed) - require.ErrorContains(t, err, "format") + require.ErrorIs(t, err, ErrParameter) + require.Empty(t, results) }, }, - { - uc: "no applicable signature present", - opts: []VerifierOption{WithRequiredTag("foo")}, - msg: &Message{ - Header: http.Header{ - "Signature-Input": []string{`sig=();created=1618884473;keyid="test"`}, - "Signature": []string{"sig=:dGVzdA==:"}, - }, + "dynamic audience requested in negotiation": { + opts: []VerifierOption{ + WithRequiredTag("profile", + WithSignatureNegotiation(), + ), + }, + verifyOpts: []VerifyOption{ + WithParameter("audience", "service-a"), }, + msg: &Message{Header: http.Header{ + "Signature-Input": {`sig=();created=1618884473;expires=1618884600;tag="profile"`}, + "Signature": {"sig=:dGVzdA==:"}, + }}, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() - require.Error(t, err) - require.ErrorIs(t, err, ErrVerificationFailed) + var negotiation *NoApplicableSignatureError + require.ErrorAs(t, err, &negotiation) + require.Empty(t, results) - var noSigErr *NoApplicableSignatureError - require.ErrorAs(t, err, &noSigErr) + hdr := make(http.Header) + negotiation.Negotiate(hdr) + assert.Equal(t, `sig=();created;expires;tag="profile";audience="service-a"`, hdr.Get(headerAcceptSignature)) + }, + }, + "static audience requested for missing signature": { + opts: []VerifierOption{ + WithParameter("audience", "service-a"), + WithRequiredTag("profile", + WithSignatureNegotiation(), + ), + }, + msg: &Message{Header: make(http.Header)}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { + t.Helper() + + var negotiation *NoApplicableSignatureError + require.ErrorAs(t, err, &negotiation) + require.Empty(t, results) hdr := make(http.Header) - noSigErr.Negotiate(hdr) - require.Empty(t, hdr) + negotiation.Negotiate(hdr) + assert.Equal(t, `sig=();created;expires;tag="profile";audience="service-a"`, hdr.Get(headerAcceptSignature)) }, }, - { - uc: "signature base creation error", - opts: []VerifierOption{WithValidateAllSignatures()}, - msg: &Message{ - Header: http.Header{ - "Signature-Input": []string{`sig=("@status");created=1618884473;keyid="test"`}, - "Signature": []string{"sig=:dGVzdA==:"}, - }, - IsRequest: true, + "expected nonce overrides negotiation getter": { + opts: []VerifierOption{ + WithRequiredTag("profile", + WithSignatureNegotiation( + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { + return "getter", errors.New("getter must not be called") + })), + ), + ), }, + verifyOpts: []VerifyOption{ + WithParameter("nonce", "expected-nonce"), + }, + msg: &Message{Header: make(http.Header)}, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() - require.Error(t, err) - require.ErrorIs(t, err, ErrVerificationFailed) - require.ErrorContains(t, err, "@status not valid for requests") + var negotiation *NoApplicableSignatureError + require.ErrorAs(t, err, &negotiation) + require.Empty(t, results) + + hdr := make(http.Header) + negotiation.Negotiate(hdr) + assert.Equal(t, `sig=();created;expires;nonce="expected-nonce";tag="profile"`, hdr.Get(headerAcceptSignature)) }, }, - { - uc: "key resolver error", - opts: []VerifierOption{WithValidateAllSignatures()}, - msg: &Message{ - Header: http.Header{ - "Signature-Input": []string{`sig=();created=1618884473;keyid="test"`}, - "Signature": []string{"sig=:dGVzdA==:"}, - }, + "dynamic expectations projected for all required tags": { + opts: []VerifierOption{ + WithRequiredTag("first", + WithSignatureNegotiation(), + ), + WithRequiredTag("second", + WithSignatureNegotiation(), + ), }, - configureResolver: func(t *testing.T, kr *KeyResolverMock) { + verifyOpts: []VerifyOption{ + WithParameter("audience", "service-a"), + }, + msg: &Message{Header: make(http.Header)}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test").Return(Key{}, errors.New("test error")) + var negotiation *NoApplicableSignatureError + require.ErrorAs(t, err, &negotiation) + require.Empty(t, results) + + hdr := make(http.Header) + negotiation.Negotiate(hdr) + assert.ElementsMatch(t, []string{ + `sig=();created;expires;tag="first";audience="service-a"`, + `sig=();created;expires;tag="second";audience="service-a"`, + }, hdr.Values(headerAcceptSignature)) + }, + }, + "conflicting explicit negotiation parameter is rejected": { + opts: []VerifierOption{ + WithRequiredTag("profile", + WithParameter("audience", "expected"), + WithSignatureNegotiation( + WithParameter("audience", "builder"), + ), + ), }, - assert: func(t *testing.T, err error) { + msg: &Message{Header: make(http.Header)}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() - require.Error(t, err) - require.ErrorIs(t, err, ErrVerificationFailed) - require.ErrorContains(t, err, "test error") + require.ErrorIs(t, err, ErrSignatureNegotiationError) + require.ErrorIs(t, err, ErrParameter) + require.Empty(t, results) }, }, - { - uc: "signature parameters assertion error", - opts: []VerifierOption{WithRequiredTag("foo"), WithValidityTolerance(1 * time.Second)}, + "signature algorithm mismatch after key resolution": { + opts: []VerifierOption{ + WithValidateAllSignatures(), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), + }, msg: &Message{ Header: http.Header{ - "Signature-Input": []string{`sig=();expires=1618884470;keyid="test";tag="foo"`}, + "Signature-Input": []string{`sig=();alg="ed25519"`}, "Signature": []string{"sig=:dGVzdA==:"}, }, }, configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test").Return(Key{}, nil) + kr.EXPECT().ResolveKey(mock.Anything, mock.Anything). + Return(KeyInfo{Key: Key{Algorithm: HmacSha256, Material: []byte("test")}}, nil). + Once() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrVerificationFailed) - require.ErrorContains(t, err, "expired") + require.ErrorIs(t, err, ErrParameter) + require.ErrorContains(t, err, "key algorithm ed25519 does not match signature algorithm hmac-sha256") + require.Empty(t, results) }, }, - { - uc: "unsupported signature key", + "unsupported signature key": { opts: []VerifierOption{ WithRequiredTag("foo"), - WithExpiredTimestampRequired(false), - WithCreatedTimestampRequired(false), + WithExpiresTimestamp(false), + WithCreatedTimestamp(false), }, msg: &Message{ Header: http.Header{ @@ -1156,9 +983,17 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test").Return(Key{Key: &rsa.PrivateKey{}}, nil) + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig" && + si.Message != nil && + len(si.Components) == 0 && + si.Parameters["keyid"] == "test" && + si.Parameters["tag"] == "foo" + })). + Return(KeyInfo{Key: Key{Material: &rsa.PrivateKey{}}}, nil) }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() require.Error(t, err) @@ -1166,12 +1001,11 @@ func TestVerifierVerify(t *testing.T) { require.ErrorContains(t, err, "unsupported key") }, }, - { - uc: "invalid signature", + "invalid signature": { opts: []VerifierOption{ WithRequiredTag("foo"), - WithExpiredTimestampRequired(false), - WithCreatedTimestampRequired(false), + WithExpiresTimestamp(false), + WithCreatedTimestamp(false), }, msg: &Message{ Header: http.Header{ @@ -1185,10 +1019,22 @@ func TestVerifierVerify(t *testing.T) { pk2048, err := rsa.GenerateKey(rand.Reader, 2048) require.NoError(t, err) - kr.EXPECT().ResolveKey(mock.Anything, "test").Return( - Key{Key: &pk2048.PublicKey, KeyID: "test", Algorithm: RsaPkcs1v15Sha512}, nil) + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig" && + si.Message != nil && + len(si.Components) == 0 && + si.Parameters["keyid"] == "test" && + si.Parameters["tag"] == "foo" + })). + Return( + KeyInfo{ + Key: Key{Material: &pk2048.PublicKey, Algorithm: RsaPkcs1v15Sha512}, + }, + nil, + ) }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() require.Error(t, err) @@ -1196,22 +1042,22 @@ func TestVerifierVerify(t *testing.T) { require.ErrorContains(t, err, "invalid signature") }, }, - { - uc: "signature parameters negotiation for not present tagged signature", + "signature parameters negotiation for not present tagged signature": { opts: []VerifierOption{ WithRequiredTag("foo", - WithRequiredComponents("@method", "content-digest"), + WithComponents("@method", "content-digest"), WithSignatureNegotiation( - WithRequestedKey(Key{KeyID: "test-key", Algorithm: RsaPssSha512}), - WithRequestedLabel("bar"), - WithRequestedNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), - WithRequestedContentDigestAlgorithmPreferences(AlgorithmPreference{Sha256, 1}), + WithSignatureAlgorithm(RsaPssSha512), + WithKeyID("test-key"), + WithLabel("bar"), + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), + WithContentDigestAlgorithmPreferences(AlgorithmPreference{Sha256, 1}), ), ), }, msg: &Message{Header: http.Header{}}, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() var targetErr *NoApplicableSignatureError @@ -1228,15 +1074,65 @@ func TestVerifierVerify(t *testing.T) { assert.ElementsMatch(t, hdr.Values("Want-Content-Digest"), []string{"sha-256=1"}) }, }, - { - uc: "signature parameters negotiation for present signature with missing expires parameters", + "global content-digest requirement overridden for negotiated tag": { + opts: []VerifierOption{ + WithComponents("content-digest"), + WithSignatureNegotiation(), + WithRequiredTag("foo", + WithComponents("@method"), + ), + }, + msg: &Message{Header: http.Header{}}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + var negotiation *NoApplicableSignatureError + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorAs(t, err, &negotiation) + + hdr := make(http.Header) + negotiation.Negotiate(hdr) + + assert.Equal(t, `sig=("@method");created;expires;tag="foo"`, hdr.Get(headerAcceptSignature)) + assert.Empty(t, hdr.Values(headerWantContentDigest)) + }, + }, + "signature negotiation without nonce getter omits nonce": { + opts: []VerifierOption{ + WithRequiredTag("foo", + WithComponents("@method"), + WithSignatureNegotiation( + WithLabel("foo-sig"), + ), + ), + }, + msg: &Message{Header: http.Header{}}, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + var targetErr *NoApplicableSignatureError + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorAs(t, err, &targetErr) + + hdr := make(http.Header) + targetErr.Negotiate(hdr) + + assert.Equal(t, `foo-sig=("@method");created;expires;tag="foo"`, hdr.Get(headerAcceptSignature)) + }, + }, + "signature parameters negotiation for present signature with missing expires parameters": { opts: []VerifierOption{ WithRequiredTag("foo", WithSignatureNegotiation( - WithRequestedKey(Key{KeyID: "test-key", Algorithm: RsaPssSha512}), - WithRequestedLabel("bar"), - WithRequestedNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), - WithRequestedContentDigestAlgorithmPreferences(AlgorithmPreference{Sha256, 1}), + WithSignatureAlgorithm(RsaPssSha512), + WithKeyID("test-key"), + WithLabel("bar"), + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "abc", nil })), + WithContentDigestAlgorithmPreferences(AlgorithmPreference{Sha256, 1}), ), ), }, @@ -1252,13 +1148,8 @@ func TestVerifierVerify(t *testing.T) { }, IsRequest: true, }, - configureResolver: func(t *testing.T, kr *KeyResolverMock) { - t.Helper() - - kr.EXPECT().ResolveKey(mock.Anything, "test-key").Return( - Key{Key: tkRSAPSS, KeyID: "test-key", Algorithm: RsaPssSha512}, nil) - }, - assert: func(t *testing.T, err error) { + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() var targetErr *NoApplicableSignatureError @@ -1274,20 +1165,20 @@ func TestVerifierVerify(t *testing.T) { assert.Equal(t, `bar=();created;expires;keyid="test-key";alg="rsa-pss-sha512";nonce="abc";tag="foo"`, hdr.Get("Accept-Signature")) }, }, - { - uc: "signature parameters negotiation fails because of nonce error", + "signature parameters negotiation fails because of nonce error": { opts: []VerifierOption{ WithRequiredTag("foo", - WithRequiredComponents("@method"), + WithComponents("@method"), WithSignatureNegotiation( - WithRequestedKey(Key{KeyID: "test-key", Algorithm: RsaPssSha512}), - WithRequestedNonce(NonceGetterFunc(func(_ context.Context) (string, error) { return "", errors.New("test error") })), + WithSignatureAlgorithm(RsaPssSha512), + WithKeyID("test-key"), + WithNonceGetter(NonceGetterFunc(func(_ context.Context) (string, error) { return "", errors.New("test error") })), ), ), }, msg: &Message{Header: http.Header{}}, configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() require.Error(t, err) @@ -1296,12 +1187,11 @@ func TestVerifierVerify(t *testing.T) { require.ErrorContains(t, err, "test error") }, }, - { - uc: "signature verification fails due to invalid second content digest", + "signature verification fails due to invalid second content digest": { opts: []VerifierOption{ WithValidateAllSignatures(), - WithCreatedTimestampRequired(false), - WithExpiredTimestampRequired(false), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), }, msg: &Message{ Method: http.MethodPost, @@ -1321,13 +1211,8 @@ func TestVerifierVerify(t *testing.T) { return io.NopCloser(strings.NewReader(`{"hello": "world"}`)), nil }, }, - configureResolver: func(t *testing.T, kr *KeyResolverMock) { - t.Helper() - - kr.EXPECT().ResolveKey(mock.Anything, "test-key-rsa-pss").Return( - Key{Key: tkRSAPSS, KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512}, nil) - }, - assert: func(t *testing.T, err error) { + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { t.Helper() require.Error(t, err) @@ -1335,13 +1220,12 @@ func TestVerifierVerify(t *testing.T) { require.ErrorIs(t, err, ErrContentDigestMismatch) }, }, - { + "B.2.1. minimal signature using rsa-pss-sha512": { // https://www.rfc-editor.org/rfc/rfc9421.html#name-minimal-signature-using-rsa - uc: "B.2.1. minimal signature using rsa-pss-sha512", opts: []VerifierOption{ WithValidateAllSignatures(), - WithCreatedTimestampRequired(false), - WithExpiredTimestampRequired(false), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), }, msg: &Message{ Method: http.MethodPost, @@ -1361,22 +1245,50 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test-key-rsa-pss").Return( - Key{Key: tkRSAPSS, KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512}, nil) + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig-b21" && + si.Message != nil && + si.Message.Header.Get("Content-Length") == "18" && + len(si.Components) == 0 && + si.Parameters["created"] == int64(1618884473) && + si.Parameters["keyid"] == "test-key-rsa-pss" && + si.Parameters["nonce"] == "b3k2pp5k7z-50gnwp.yemd" + })). + Return( + KeyInfo{ + Key: Key{Material: tkRSAPSS, Algorithm: RsaPssSha512}, + Metadata: "foo", + }, + nil, + ) }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() require.NoError(t, err) + + require.Len(t, results, 1) + + sig := results[0] + assert.Equal(t, "sig-b21", sig.Label) + + assert.Empty(t, sig.Components) + + assert.Len(t, sig.Parameters, 3) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-key-rsa-pss", sig.Parameters["keyid"]) + assert.Equal(t, "b3k2pp5k7z-50gnwp.yemd", sig.Parameters["nonce"]) + + assert.Equal(t, "foo", sig.Metadata) }, }, - { + "B.2.2. selective covered components using rsa-pss-sha512": { // https://www.rfc-editor.org/rfc/rfc9421.html#name-selective-covered-component - uc: "B.2.2. selective covered components using rsa-pss-sha512", opts: []VerifierOption{ WithValidateAllSignatures(), - WithCreatedTimestampRequired(false), - WithExpiredTimestampRequired(false), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), }, msg: &Message{ Method: http.MethodPost, @@ -1399,22 +1311,54 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test-key-rsa-pss").Return( - Key{Key: tkRSAPSS, KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512}, nil) - }, - assert: func(t *testing.T, err error) { + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig-b22" && + si.Message != nil && + si.Message.Header.Get("Content-Length") == "18" && + len(si.Components) == 3 && + si.Components["@authority"] == "example.com" && + si.Components["@query-param;name=\"Pet\""] == "dog" && + si.Parameters["created"] == int64(1618884473) && + si.Parameters["keyid"] == "test-key-rsa-pss" && + si.Parameters["tag"] == "header-example" + })). + Return( + KeyInfo{ + Key: Key{Material: tkRSAPSS, Algorithm: RsaPssSha512}, + Metadata: []string{"foo"}, + }, + nil, + ) + }, + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() require.NoError(t, err) + + require.Len(t, results, 1) + + sig := results[0] + assert.Equal(t, "sig-b22", sig.Label) + + assert.Len(t, sig.Components, 3) + assert.Equal(t, "example.com", sig.Components["@authority"]) + assert.Equal(t, "dog", sig.Components["@query-param;name=\"Pet\""]) + + assert.Len(t, sig.Parameters, 3) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-key-rsa-pss", sig.Parameters["keyid"]) + assert.Equal(t, "header-example", sig.Parameters["tag"]) + + assert.Equal(t, []string{"foo"}, sig.Metadata) }, }, - { + "B.2.3. full coverage using rsa-pss-sha512": { // https://www.rfc-editor.org/rfc/rfc9421.html#name-full-coverage-using-rsa-pss - uc: "B.2.3. full coverage using rsa-pss-sha512", opts: []VerifierOption{ WithValidateAllSignatures(), - WithCreatedTimestampRequired(false), - WithExpiredTimestampRequired(false), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), }, msg: &Message{ Method: http.MethodPost, @@ -1437,22 +1381,63 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test-key-rsa-pss").Return( - Key{Key: tkRSAPSS, KeyID: "test-key-rsa-pss", Algorithm: RsaPssSha512}, nil) - }, - assert: func(t *testing.T, err error) { + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig-b23" && + si.Message != nil && + si.Message.Header.Get("Content-Length") == "18" && + len(si.Components) == 8 && + si.Components["date"] == "Tue, 20 Apr 2021 02:07:55 GMT" && + si.Components["@method"] == "POST" && + si.Components["@path"] == "/foo" && + si.Components["@query"] == "?param=Value&Pet=dog" && + si.Components["@authority"] == "example.com" && + si.Components["content-type"] == "application/json" && + si.Components["content-digest"] == "sha-512=:WZDPaVn/7XgHaAy8pmojAkGWoRx2UFChF41A2svX+TaPm+AbwAgBWnrIiYllu7BNNyealdVLvRwEmTHWXvJwew==:" && + si.Components["content-length"] == "18" && + si.Parameters["created"] == int64(1618884473) && + si.Parameters["keyid"] == "test-key-rsa-pss" + })). + Return( + KeyInfo{ + Key: Key{Material: tkRSAPSS, Algorithm: RsaPssSha512}, + }, + nil, + ) + }, + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() require.NoError(t, err) + + require.Len(t, results, 1) + + sig := results[0] + assert.Equal(t, "sig-b23", sig.Label) + + assert.Len(t, sig.Components, 8) + assert.Equal(t, "Tue, 20 Apr 2021 02:07:55 GMT", sig.Components["date"]) + assert.Equal(t, "POST", sig.Components["@method"]) + assert.Equal(t, "/foo", sig.Components["@path"]) + assert.Equal(t, "?param=Value&Pet=dog", sig.Components["@query"]) + assert.Equal(t, "example.com", sig.Components["@authority"]) + assert.Equal(t, "application/json", sig.Components["content-type"]) + assert.Equal(t, "sha-512=:WZDPaVn/7XgHaAy8pmojAkGWoRx2UFChF41A2svX+TaPm+AbwAgBWnrIiYllu7BNNyealdVLvRwEmTHWXvJwew==:", sig.Components["content-digest"]) + assert.Equal(t, "18", sig.Components["content-length"]) + + assert.Len(t, sig.Parameters, 2) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-key-rsa-pss", sig.Parameters["keyid"]) + + assert.Nil(t, sig.Metadata) }, }, - { + "B.2.4. signing a response using ecdsa-p256-sha256": { // https://www.rfc-editor.org/rfc/rfc9421.html#name-signing-a-response-using-ec - uc: "B.2.4. signing a response using ecdsa-p256-sha256 ", opts: []VerifierOption{ WithValidateAllSignatures(), - WithCreatedTimestampRequired(false), - WithExpiredTimestampRequired(false), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), }, msg: &Message{ Method: http.MethodPost, @@ -1473,22 +1458,55 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test-key-ecc-p256").Return( - Key{KeyID: "test-key-ecc-p256", Algorithm: EcdsaP256Sha256, Key: tkECCP256}, nil) - }, - assert: func(t *testing.T, err error) { + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig-b24" && + si.Message != nil && + len(si.Components) == 4 && + si.Components["@status"] == "200" && + si.Components["content-type"] == "application/json" && + si.Components["content-digest"] == "sha-512=:mEWXIS7MaLRuGgxOBdODa3xqM1XdEvxoYhvlCFJ41QJgJc4GTsPp29l5oGX69wWdXymyU0rjJuahq4l5aGgfLQ==:" && + si.Components["content-length"] == "23" && + si.Parameters["created"] == int64(1618884473) && + si.Parameters["keyid"] == "test-key-ecc-p256" + })). + Return( + KeyInfo{ + Key: Key{Material: tkECCP256, Algorithm: EcdsaP256Sha256}, + Metadata: map[string]int{"foo": 1}, + }, + nil, + ) + }, + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() require.NoError(t, err) + + require.Len(t, results, 1) + + sig := results[0] + assert.Equal(t, "sig-b24", sig.Label) + + assert.Len(t, sig.Components, 4) + assert.Equal(t, "200", sig.Components["@status"]) + assert.Equal(t, "application/json", sig.Components["content-type"]) + assert.Equal(t, "sha-512=:mEWXIS7MaLRuGgxOBdODa3xqM1XdEvxoYhvlCFJ41QJgJc4GTsPp29l5oGX69wWdXymyU0rjJuahq4l5aGgfLQ==:", sig.Components["content-digest"]) + assert.Equal(t, "23", sig.Components["content-length"]) + + assert.Len(t, sig.Parameters, 2) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-key-ecc-p256", sig.Parameters["keyid"]) + + assert.Equal(t, map[string]int{"foo": 1}, sig.Metadata) }, }, - { + "B.2.5. signing a request using hmac-sha256": { // https://www.rfc-editor.org/rfc/rfc9421.html#name-signing-a-request-using-hma - uc: "B.2.5. signing a request using hmac-sha256", opts: []VerifierOption{ WithValidateAllSignatures(), - WithCreatedTimestampRequired(false), - WithExpiredTimestampRequired(false), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), }, msg: &Message{ Method: http.MethodPost, @@ -1508,22 +1526,52 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test-shared-secret").Return( - Key{KeyID: "test-shared-secret", Algorithm: HmacSha256, Key: tkMAC}, nil) + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig-b25" && + si.Message != nil && + len(si.Components) == 3 && + si.Components["date"] == "Tue, 20 Apr 2021 02:07:55 GMT" && + si.Components["@authority"] == "example.com" && + si.Components["content-type"] == "application/json" && + si.Parameters["created"] == int64(1618884473) && + si.Parameters["keyid"] == "test-shared-secret" + })). + Return( + KeyInfo{ + Key: Key{Material: tkMAC, Algorithm: HmacSha256}, + }, + nil, + ) }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() require.NoError(t, err) + + require.Len(t, results, 1) + + sig := results[0] + assert.Equal(t, "sig-b25", sig.Label) + + assert.Len(t, sig.Components, 3) + assert.Equal(t, "Tue, 20 Apr 2021 02:07:55 GMT", sig.Components["date"]) + assert.Equal(t, "example.com", sig.Components["@authority"]) + assert.Equal(t, "application/json", sig.Components["content-type"]) + + assert.Len(t, sig.Parameters, 2) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-shared-secret", sig.Parameters["keyid"]) + + assert.Empty(t, sig.Metadata) }, }, - { + "B.2.6. signing a request using ed25519": { // https://www.rfc-editor.org/rfc/rfc9421.html#name-signing-a-request-using-ed2 - uc: "B.2.6. signing a request using ed25519", opts: []VerifierOption{ WithValidateAllSignatures(), - WithCreatedTimestampRequired(false), - WithExpiredTimestampRequired(false), + WithCreatedTimestamp(false), + WithExpiresTimestamp(false), }, msg: &Message{ Method: http.MethodPost, @@ -1544,20 +1592,56 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test-key-ed25519").Return( - Key{KeyID: "test-key-ed25519", Algorithm: Ed25519, Key: tkEd25519}, nil) - }, - assert: func(t *testing.T, err error) { + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "sig-b26" && + si.Message != nil && + len(si.Components) == 6 && + si.Components["date"] == "Tue, 20 Apr 2021 02:07:55 GMT" && + si.Components["@method"] == "POST" && + si.Components["@path"] == "/foo" && + si.Components["@authority"] == "example.com" && + si.Components["content-type"] == "application/json" && + si.Components["content-length"] == "18" && + si.Parameters["created"] == int64(1618884473) && + si.Parameters["keyid"] == "test-key-ed25519" + })). + Return( + KeyInfo{ + Key: Key{Material: tkEd25519, Algorithm: Ed25519}, + }, + nil, + ) + }, + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() require.NoError(t, err) + + require.Len(t, results, 1) + + sig := results[0] + assert.Equal(t, "sig-b26", sig.Label) + + assert.Len(t, sig.Components, 6) + assert.Equal(t, "Tue, 20 Apr 2021 02:07:55 GMT", sig.Components["date"]) + assert.Equal(t, "POST", sig.Components["@method"]) + assert.Equal(t, "/foo", sig.Components["@path"]) + assert.Equal(t, "example.com", sig.Components["@authority"]) + assert.Equal(t, "application/json", sig.Components["content-type"]) + assert.Equal(t, "18", sig.Components["content-length"]) + + assert.Len(t, sig.Parameters, 2) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-key-ed25519", sig.Parameters["keyid"]) + + assert.Empty(t, sig.Metadata) }, }, - { - uc: "invalid untagged signature is ignored", + "invalid untagged signature is ignored": { opts: []VerifierOption{ WithRequiredTag("foo"), - WithExpiredTimestampRequired(false), + WithExpiresTimestamp(false), }, msg: &Message{ Header: http.Header{ @@ -1574,21 +1658,39 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test-shared-secret").Return( - Key{KeyID: "test-shared-secret", Algorithm: HmacSha256, Key: tkMAC}, nil, - ).Once() + kr.EXPECT().ResolveKey(mock.Anything, mock.Anything). + Return( + KeyInfo{ + Key: Key{Material: tkMAC, Algorithm: HmacSha256}, + Metadata: map[string]string{"foo": "bar"}, + }, + nil, + ).Once() }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() require.NoError(t, err) + + require.Len(t, results, 1) + + sig := results[0] + assert.Equal(t, "valid", sig.Label) + + assert.Empty(t, sig.Components) + + assert.Len(t, sig.Parameters, 3) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-shared-secret", sig.Parameters["keyid"]) + assert.Equal(t, "foo", sig.Parameters["tag"]) + + assert.Equal(t, map[string]string{"foo": "bar"}, sig.Metadata) }, }, - { - uc: "invalid untagged signature fails when validating all", + "invalid untagged signature fails when validating all": { opts: []VerifierOption{ WithValidateAllSignatures(), - WithExpiredTimestampRequired(false), + WithExpiresTimestamp(false), }, msg: &Message{ Header: http.Header{ @@ -1605,29 +1707,293 @@ func TestVerifierVerify(t *testing.T) { configureResolver: func(t *testing.T, kr *KeyResolverMock) { t.Helper() - kr.EXPECT().ResolveKey(mock.Anything, "test-shared-secret").Return( - Key{KeyID: "test-shared-secret", Algorithm: HmacSha256, Key: tkMAC}, nil, - ) + kr.EXPECT().ResolveKey(mock.Anything, mock.Anything). + Return( + KeyInfo{ + Key: Key{Material: tkMAC, Algorithm: HmacSha256}, + }, + nil, + ) }, - assert: func(t *testing.T, err error) { + assert: func(t *testing.T, err error, results VerificationResult) { t.Helper() require.ErrorIs(t, err, ErrVerificationFailed) require.ErrorIs(t, err, ErrInvalidSignature) + + require.Empty(t, results) + }, + }, + "multiple valid signatures with different keys and metadata": { + opts: []VerifierOption{ + WithValidateAllSignatures(), + WithExpiresTimestamp(false), + }, + msg: &Message{ + Method: http.MethodPost, + Authority: "example.com", + URL: testURL, + Header: http.Header{ + "Date": []string{"Tue, 20 Apr 2021 02:07:55 GMT"}, + "Content-Type": []string{"application/json"}, + "Content-Length": []string{"18"}, + "Signature-Input": []string{ + `first=("date" "@authority" "content-type");created=1618884473;keyid="test-shared-secret", ` + + `second=("date" "@method" "@path" "@authority" "content-type" "content-length");created=1618884473;keyid="test-key-ed25519"`, + }, + "Signature": []string{ + `first=:pxcQw6G3AjtMBQjwo8XzkZf/bws5LelbaMk5rGIGtE8=:, ` + + `second=:wqcAqbmYJ2ji2glfAMaRy4gruYYnx2nEFN2HN6jrnDnQCK1u02Gb04v9EDgwUPiu4A0w6vuQv5lIp5WPpBKRCw==:`, + }, + }, + IsRequest: true, + }, + configureResolver: func(t *testing.T, kr *KeyResolverMock) { + t.Helper() + + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "first" && + si.Parameters["keyid"] == "test-shared-secret" && + si.Components["date"] == "Tue, 20 Apr 2021 02:07:55 GMT" && + si.Components["@authority"] == "example.com" && + si.Components["content-type"] == "application/json" + })). + Return(KeyInfo{ + Key: Key{Material: tkMAC, Algorithm: HmacSha256}, + Metadata: "hmac", + }, nil). + Once() + + kr.EXPECT().ResolveKey(mock.Anything, + mock.MatchedBy(func(si SignatureInfo) bool { + return si.Label == "second" && + si.Parameters["keyid"] == "test-key-ed25519" && + si.Components["@method"] == "POST" && + si.Components["@path"] == "/foo" && + si.Components["@authority"] == "example.com" + })). + Return(KeyInfo{ + Key: Key{Material: tkEd25519, Algorithm: Ed25519}, + Metadata: "ed25519", + }, nil). + Once() + }, + assert: func(t *testing.T, err error, results VerificationResult) { + t.Helper() + + require.NoError(t, err) + require.Len(t, results, 2) + + idx := slices.IndexFunc(results, func(sig VerifiedSignature) bool { + return sig.Label == "first" + }) + require.NotEqual(t, -1, idx, "signature with label first not found") + + sig := results[idx] + assert.Equal(t, "first", sig.Label) + + assert.Len(t, sig.Components, 3) + assert.Equal(t, "Tue, 20 Apr 2021 02:07:55 GMT", sig.Components["date"]) + assert.Equal(t, "example.com", sig.Components["@authority"]) + assert.Equal(t, "application/json", sig.Components["content-type"]) + + assert.Len(t, sig.Parameters, 2) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-shared-secret", sig.Parameters["keyid"]) + + assert.Equal(t, "hmac", sig.Metadata) + + idx = slices.IndexFunc(results, func(sig VerifiedSignature) bool { + return sig.Label == "second" + }) + require.NotEqual(t, -1, idx, "signature with label second not found") + + sig = results[idx] + assert.Equal(t, "second", sig.Label) + + assert.Len(t, sig.Components, 6) + assert.Equal(t, "Tue, 20 Apr 2021 02:07:55 GMT", sig.Components["date"]) + assert.Equal(t, "POST", sig.Components["@method"]) + assert.Equal(t, "/foo", sig.Components["@path"]) + assert.Equal(t, "example.com", sig.Components["@authority"]) + assert.Equal(t, "application/json", sig.Components["content-type"]) + assert.Equal(t, "18", sig.Components["content-length"]) + + assert.Len(t, sig.Parameters, 2) + assert.Equal(t, int64(1618884473), sig.Parameters["created"]) + assert.Equal(t, "test-key-ed25519", sig.Parameters["keyid"]) + + assert.Equal(t, "ed25519", sig.Metadata) + }, + }, + "tag-specific negotiation": { + opts: []VerifierOption{ + WithRequiredTag("profile", + WithSignatureNegotiation( + WithParameter("audience", "service-a"), + WithParameter("challenge", Token("example")), + ), + ), + }, + msg: &Message{ + Method: http.MethodPost, + Authority: "example.com", + URL: testURL, + Header: http.Header{}, + }, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + require.Error(t, err) + + var negotiation *NoApplicableSignatureError + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorAs(t, err, &negotiation) + + hdr := make(http.Header) + negotiation.Negotiate(hdr) + assert.Equal(t, `sig=();created;expires;tag="profile";audience="service-a";challenge=example`, hdr.Get(headerAcceptSignature)) + }, + }, + "inherited global negotiation": { + opts: []VerifierOption{ + WithSignatureNegotiation( + WithParameter("audience", "service-a"), + ), + WithRequiredTag("profile"), + }, + msg: &Message{ + Method: http.MethodPost, + Authority: "example.com", + URL: testURL, + Header: http.Header{}, + }, + configureResolver: func(t *testing.T, _ *KeyResolverMock) { t.Helper() }, + assert: func(t *testing.T, err error, _ VerificationResult) { + t.Helper() + + require.Error(t, err) + + var negotiation *NoApplicableSignatureError + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorAs(t, err, &negotiation) + + hdr := make(http.Header) + negotiation.Negotiate(hdr) + assert.Equal(t, `sig=();created;expires;tag="profile";audience="service-a"`, hdr.Get(headerAcceptSignature)) }, }, } { - t.Run(tc.uc, func(t *testing.T) { + t.Run(uc, func(t *testing.T) { kr := NewKeyResolverMock(t) tc.configureResolver(t, kr) v, err := NewVerifier(kr, tc.opts...) require.NoError(t, err) - err = v.Verify(tc.msg) - tc.assert(t, err) + results, err := v.Verify(tc.msg, tc.verifyOpts...) + tc.assert(t, err, results) }) } + + t.Run("signed extensions with static and dynamic requirements", func(t *testing.T) { + key := Key{Algorithm: HmacSha256, Material: []byte("secret")} + inputBytes := []byte("data") + signer, err := NewSigner(key, + WithTag("profile"), + WithComponents("@method"), + WithParameter("audience", "service-a"), + WithParameter("score", 1.2349), + WithParameter("mode", Token("example")), + WithParameter("flag", true), + WithParameter("opaque", inputBytes), + ) + require.NoError(t, err) + + msg := &Message{ + Context: context.Background(), + Header: make(http.Header), + Method: http.MethodGet, + Authority: "example.com", + URL: testURL, + IsRequest: true, + } + _, err = signer.Sign(msg, WithParameter("nonce", "request-nonce")) + require.NoError(t, err) + + ver, err := NewVerifier(key, + WithRequiredTag("profile", + WithComponents("@method"), + WithRequiredParameters("nonce"), + WithForbiddenParameters("keyid", "alg"), + WithParameter("score", 1.2349), + WithParameter("mode", Token("example")), + WithParameter("flag", true), + WithParameter("opaque", inputBytes), + ), + ) + require.NoError(t, err) + + inputBytes[0] = 'X' // Neither signer nor verifier may retain this mutable input. + + for _, opts := range [][]VerifyOption{ + { + WithParameter("audience", "service-a"), + }, + { + WithParameter("audience", "service-a"), + WithRequiredParameters("mode"), + }, + nil, + } { + results, err := ver.Verify(msg, opts...) + require.NoError(t, err) + require.Len(t, results, 1) + assert.Equal(t, "service-a", results[0].Parameters["audience"]) + } + + _, err = ver.Verify(msg, WithParameter("audience", "other")) + require.ErrorIs(t, err, ErrParameter) + + results, err := ver.Verify(msg) + require.NoError(t, err) + require.Len(t, results, 1) // A failed per-call override did not mutate the verifier. + + _, err = ver.Verify(msg, WithForbiddenParameters("nonce")) + require.ErrorIs(t, err, ErrParameter) + + // A Structured-Fields Token is not interchangeable with a String. + withString, err := NewVerifier(key, + WithRequiredTag("profile", + WithParameter("mode", "example"), + ), + ) + require.NoError(t, err) + _, err = withString.Verify(msg) + require.ErrorIs(t, err, ErrParameter) + + var wg sync.WaitGroup + + errors := make(chan error, 16) + + for range 16 { + wg.Go(func() { + _, err := ver.Verify(msg, WithParameter("audience", "service-a")) + errors <- err + }) + } + + wg.Wait() + close(errors) + + for err := range errors { + require.NoError(t, err) + } + }) } func TestVerifierApplicableSignatures(t *testing.T) { @@ -1647,7 +2013,7 @@ func TestVerifierApplicableSignatures(t *testing.T) { }{ "only required signatures are applicable": { verifier: verifier{ - tagExpectations: map[string]*expectations{"foo": {}}, + tagPolicies: map[string]*verificationPolicy{"foo": {}}, }, refs: map[string]*signatureInput{ "matching": withTag("foo"), @@ -1665,7 +2031,7 @@ func TestVerifierApplicableSignatures(t *testing.T) { }, "no matching signature": { verifier: verifier{ - tagExpectations: map[string]*expectations{"foo": {}}, + tagPolicies: map[string]*verificationPolicy{"foo": {}}, }, refs: map[string]*signatureInput{ "other": withTag("bar"), @@ -1679,7 +2045,7 @@ func TestVerifierApplicableSignatures(t *testing.T) { }, "missing tag": { verifier: verifier{ - tagExpectations: map[string]*expectations{"foo": {}}, + tagPolicies: map[string]*verificationPolicy{"foo": {}}, }, refs: map[string]*signatureInput{ "untagged": newSignatureInput(nil, nil), @@ -1713,7 +2079,7 @@ func TestVerifierApplicableSignatures(t *testing.T) { "validate all with required tag": { verifier: verifier{ validateAllSigs: true, - tagExpectations: map[string]*expectations{"foo": {}}, + tagPolicies: map[string]*verificationPolicy{"foo": {}}, }, refs: map[string]*signatureInput{ "matching": withTag("foo"),