From 12bb6afa702c16fc37d3a274781fb6ab0bd45fb4 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Sat, 7 Nov 2026 19:27:14 +0100 Subject: [PATCH 1/8] new DisplayString type introduced --- httpsig.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/httpsig.go b/httpsig.go index c4bff40..354bcd7 100644 --- a/httpsig.go +++ b/httpsig.go @@ -189,8 +189,8 @@ const ( // 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. +// example string, Token, DisplayString, time.Time, int64, float64, bool, or +// []byte). type SignatureParameters map[SignatureParameter]any // KeyID returns the keyid parameter if present and of the expected type. @@ -240,6 +240,10 @@ func (p SignatureParameters) Tag() (string, bool) { // strings when validating profile-specific signature parameters. type Token string +// DisplayString represents an RFC 9651 Structured Fields Display String. +// Unlike an ordinary Structured Fields string, it may contain Unicode. +type DisplayString string + // MessageSigner signs the complete HTTP signature base using an // application-provided implementation. The implementation is responsible for // all cryptographic processing and must return signature bytes in the format From 4c917c66136c14eb34b94ca741a2c0a2a35c6581 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Sat, 7 Nov 2026 19:33:28 +0100 Subject: [PATCH 2/8] support of the new DisplayString in signatureInput --- signature_input.go | 2 +- signature_input_test.go | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/signature_input.go b/signature_input.go index fd4b6d9..7d2e255 100644 --- a/signature_input.go +++ b/signature_input.go @@ -61,7 +61,7 @@ func decodeParameter(value any) any { case httpsfv.Token: return Token(v) case httpsfv.DisplayString: - return string(v) + return DisplayString(v) default: return value } diff --git a/signature_input_test.go b/signature_input_test.go index ee7e987..497f61c 100644 --- a/signature_input_test.go +++ b/signature_input_test.go @@ -371,7 +371,8 @@ func TestDecodeParameter(t *testing.T) { want any }{ "token": {value: httpsfv.Token("foo"), want: Token("foo")}, - "display string": {value: httpsfv.DisplayString("café"), want: "café"}, + "display string": {value: httpsfv.DisplayString("café"), want: DisplayString("café")}, + "date": {value: time.Unix(1794000000, 0), want: time.Unix(1794000000, 0)}, "string": {value: "foo", want: "foo"}, "integer": {value: int64(42), want: int64(42)}, "byte sequence": {value: []byte{1, 2, 3}, want: []byte{1, 2, 3}}, From ec9898332b6e05e7f99ff22c1edf996eb3154fc7 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Sat, 7 Nov 2026 19:38:13 +0100 Subject: [PATCH 3/8] supporting DisplayString and time.Time in WithParameter options --- options.go | 17 +++++- options_test.go | 159 +++++++++++++++++++++++++----------------------- 2 files changed, 96 insertions(+), 80 deletions(-) diff --git a/options.go b/options.go index eca5909..3ef8a6d 100644 --- a/options.go +++ b/options.go @@ -4,6 +4,7 @@ import ( "bytes" "fmt" "time" + "unicode/utf8" "github.com/dunglas/httpsfv" ) @@ -238,12 +239,13 @@ func WithAlg() SignerOption { // 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 +// string, Token, DisplayString, time.Time (RFC 9651 Date), bool, int, int64, +// float64, or []byte. DisplayString must contain valid UTF-8, and Date values +// are transmitted with second precision. 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. +// builder parameters are rejected. func WithParameter(name SignatureParameter, value any) parameterOption { return parameterOption{name: name, value: value} } @@ -632,6 +634,15 @@ func normalizeParameter(option parameterOption) (parameterOption, error) { switch v := option.value.(type) { case Token: option.value = httpsfv.Token(v) + case DisplayString: + if !utf8.ValidString(string(v)) { + return option, fmt.Errorf("%w: invalid UTF-8 in signature parameter %q", ErrParameter, option.name) + } + + option.value = httpsfv.DisplayString(v) + case time.Time: + // RFC 9651 Date values have Unix-second precision. + option.value = time.Unix(v.Unix(), 0).UTC() case int: option.value = int64(v) case string, bool, int64, float64, []byte, httpsfv.Token: diff --git a/options_test.go b/options_test.go index e5f2bb0..aa88edd 100644 --- a/options_test.go +++ b/options_test.go @@ -334,30 +334,15 @@ func TestWithAlgForSigner(t *testing.T) { 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) + t.Run("extension parameter", func(t *testing.T) { + s := &signer{} - 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) - }) - } + err := WithParameter("example", "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, "value", s.parameters[0].value) }) t.Run("static byte sequence is copied", func(t *testing.T) { @@ -371,22 +356,14 @@ func TestWithParameterForSigner(t *testing.T) { 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{} + t.Run("invalid parameter", func(t *testing.T) { + s := &signer{} - err := param.applySignerOption(s) + err := WithParameter("example", struct{}{}).applySignerOption(s) - require.ErrorIs(t, err, ErrParameter) - assert.Empty(t, s.parameters) - }) - } + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, s.parameters) + }) t.Run("duplicate parameter", func(t *testing.T) { s := &signer{} @@ -417,19 +394,19 @@ func TestWithParameterForSign(t *testing.T) { t.Run("additional parameter", func(t *testing.T) { opts := &signOptions{} - err := WithParameter("extension", Token("value")).applySignOption(opts) + err := WithParameter("extension", "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) + assert.Equal(t, "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)), + "invalid extension": WithParameter("extension", struct{}{}), } { t.Run(uc, func(t *testing.T) { opts := &signOptions{} @@ -478,28 +455,16 @@ func TestWithParameterForSign(t *testing.T) { 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{} + t.Run("extension parameter", func(t *testing.T) { + asb := &AcceptSignatureBuilder{} - err := WithParameter("example", tc.value).applyAcceptSignatureOption(asb) + err := WithParameter("example", "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) - }) - } + require.NoError(t, err) + require.Len(t, asb.parameters, 1) + assert.Equal(t, SignatureParameter("example"), asb.parameters[0].name) + assert.Equal(t, "value", asb.parameters[0].value) + }) t.Run("static byte sequence is copied", func(t *testing.T) { value := []byte("before") @@ -512,22 +477,14 @@ func TestWithParameterForAcceptSignature(t *testing.T) { 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{} + t.Run("invalid parameter", func(t *testing.T) { + asb := &AcceptSignatureBuilder{} - err := param.applyAcceptSignatureOption(asb) + err := WithParameter("example", struct{}{}).applyAcceptSignatureOption(asb) - require.ErrorIs(t, err, ErrParameter) - assert.Empty(t, asb.parameters) - }) - } + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, asb.parameters) + }) t.Run("duplicate parameter", func(t *testing.T) { asb := &AcceptSignatureBuilder{} @@ -550,12 +507,11 @@ func TestWithParameterForAcceptSignatureBuild(t *testing.T) { wantErr bool }{ "nonce": {param: WithParameter("nonce", "request-nonce"), want: "request-nonce"}, - "extension": {param: WithParameter("extension", Token("value")), want: httpsfv.Token("value")}, + "extension": {param: WithParameter("extension", "value"), want: "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}, + "invalid extension": {param: WithParameter("extension", struct{}{}), wantErr: true}, } { t.Run(uc, func(t *testing.T) { opts := &acceptSignatureBuildOptions{} @@ -615,6 +571,55 @@ func TestWithParameterForAcceptSignatureBuild(t *testing.T) { }) } +func TestNormalizeParameter(t *testing.T) { + t.Parallel() + + date := time.Unix(1794000000, 750000000).In(time.FixedZone("UTC+2", 2*60*60)) + + for uc, tc := range map[string]struct { + option parameterOption + want any + invalid bool + }{ + "string": {option: WithParameter("example", "value"), want: "value"}, + "token": {option: WithParameter("example", Token("value")), want: httpsfv.Token("value")}, + "structured fields token": {option: WithParameter("example", httpsfv.Token("value")), want: httpsfv.Token("value")}, + "display string": {option: WithParameter("example", DisplayString("Grüße")), want: httpsfv.DisplayString("Grüße")}, + "empty display string": {option: WithParameter("example", DisplayString("")), want: httpsfv.DisplayString("")}, + "date": {option: WithParameter("example", date), want: time.Unix(date.Unix(), 0).UTC()}, + "integer": {option: WithParameter("example", 42), want: int64(42)}, + "int64": {option: WithParameter("example", int64(42)), want: int64(42)}, + "decimal": {option: WithParameter("example", 1.5), want: 1.5}, + "boolean": {option: WithParameter("example", true), want: true}, + "byte sequence": {option: WithParameter("example", []byte("value")), want: []byte("value")}, + "reserved created": {option: WithParameter(Created, int64(1)), invalid: true}, + "reserved expires": {option: WithParameter(Expires, int64(1)), invalid: true}, + "reserved keyid": {option: WithParameter(KeyID, "key1"), invalid: true}, + "reserved alg": {option: WithParameter(Alg, "algorithm"), invalid: true}, + "reserved nonce": {option: WithParameter(Nonce, "fixed"), invalid: true}, + "reserved tag": {option: WithParameter(Tag, "app"), invalid: true}, + "invalid name": {option: WithParameter("invalid name", "value"), invalid: true}, + "invalid string": {option: WithParameter("example", "bad\nvalue"), invalid: true}, + "invalid token": {option: WithParameter("example", Token("bad token")), invalid: true}, + "invalid display string": {option: WithParameter("example", DisplayString("bad\xffvalue")), invalid: true}, + "date out of range": {option: WithParameter("example", time.Unix(1000000000000000, 0)), invalid: true}, + "unsupported type": {option: WithParameter("example", struct{}{}), invalid: true}, + } { + t.Run(uc, func(t *testing.T) { + option, err := normalizeParameter(tc.option) + if tc.invalid { + require.ErrorIs(t, err, ErrParameter) + + return + } + + require.NoError(t, err) + assert.Equal(t, tc.option.name, option.name) + assert.Equal(t, tc.want, option.value) + }) + } +} + func TestWithValidityTolerance(t *testing.T) { t.Parallel() From 6c5002454a7b77db02cca38d751d12d6a49c2283 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Sat, 7 Nov 2026 19:47:06 +0100 Subject: [PATCH 4/8] some tests reorganized --- options_test.go | 472 +++++++++++++++++++++++++++++------------------- 1 file changed, 288 insertions(+), 184 deletions(-) diff --git a/options_test.go b/options_test.go index aa88edd..2b3ccc2 100644 --- a/options_test.go +++ b/options_test.go @@ -334,241 +334,345 @@ func TestWithAlgForSigner(t *testing.T) { func TestWithParameterForSigner(t *testing.T) { t.Parallel() - t.Run("extension parameter", func(t *testing.T) { - s := &signer{} + value := []byte("before") - err := WithParameter("example", "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, "value", 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, tc := range map[string]struct { + option parameterOption + previous []parameterOption + assert func(t *testing.T, err error, s *signer) + }{ + "extension parameter": { + option: WithParameter("example", "value"), + assert: func(t *testing.T, err error, s *signer) { + t.Helper() - t.Run("invalid parameter", func(t *testing.T) { - s := &signer{} + require.NoError(t, err) + require.Len(t, s.parameters, 1) + assert.Equal(t, SignatureParameter("example"), s.parameters[0].name) + assert.Equal(t, "value", s.parameters[0].value) + }, + }, + "static byte sequence is copied": { + option: WithParameter("example", value), + assert: func(t *testing.T, err error, s *signer) { + t.Helper() - err := WithParameter("example", struct{}{}).applySignerOption(s) + require.NoError(t, err) + require.Len(t, s.parameters, 1) - require.ErrorIs(t, err, ErrParameter) - assert.Empty(t, s.parameters) - }) + value[0] = 'X' + assert.Equal(t, []byte("before"), s.parameters[0].value) + }, + }, + "invalid parameter": { + option: WithParameter("example", struct{}{}), + assert: func(t *testing.T, err error, s *signer) { + t.Helper() - t.Run("duplicate parameter", func(t *testing.T) { - s := &signer{} - require.NoError(t, WithParameter("example", "first").applySignerOption(s)) + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, s.parameters) + }, + }, + "duplicate parameter": { + option: WithParameter("example", "second"), + previous: []parameterOption{WithParameter("example", "first")}, + assert: func(t *testing.T, err error, s *signer) { + t.Helper() - 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) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + s := &signer{} + for _, previous := range tc.previous { + require.NoError(t, previous.applySignerOption(s)) + } - require.ErrorIs(t, err, ErrParameter) - require.Len(t, s.parameters, 1) - assert.Equal(t, "first", s.parameters[0].value) - }) + err := tc.option.applySignerOption(s) + tc.assert(t, err, s) + }) + } } 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", "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, "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"), - "invalid extension": WithParameter("extension", struct{}{}), - } { - t.Run(uc, func(t *testing.T) { - opts := &signOptions{} - - err := param.applySignOption(opts) + for uc, tc := range map[string]struct { + option parameterOption + previous []parameterOption + staticParameters []parameterOption + assert func(t *testing.T, err error, opts *signOptions) + }{ + "per-call nonce": { + option: WithParameter("nonce", "request-nonce"), + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - require.ErrorIs(t, err, ErrParameter) - assert.False(t, opts.nonceSet) - assert.Empty(t, opts.parameters) - }) - } + require.NoError(t, err) + assert.True(t, opts.nonceSet) + assert.Equal(t, "request-nonce", opts.nonce) + assert.Empty(t, opts.parameters) + }, + }, + "additional parameter": { + option: WithParameter("extension", "value"), + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - t.Run("duplicate nonce", func(t *testing.T) { - opts := &signOptions{} - require.NoError(t, WithParameter("nonce", "first").applySignOption(opts)) + require.NoError(t, err) + require.Len(t, opts.parameters, 1) + assert.Equal(t, SignatureParameter("extension"), opts.parameters[0].name) + assert.Equal(t, "value", opts.parameters[0].value) + }, + }, + "empty nonce": { + option: WithParameter("nonce", ""), + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - err := WithParameter("nonce", "second").applySignOption(opts) + require.ErrorIs(t, err, ErrParameter) + assert.False(t, opts.nonceSet) + assert.Empty(t, opts.parameters) + }, + }, + "nonce with incorrect type": { + option: WithParameter("nonce", Token("value")), + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - require.ErrorIs(t, err, ErrParameter) - assert.Equal(t, "first", opts.nonce) - }) + require.ErrorIs(t, err, ErrParameter) + assert.False(t, opts.nonceSet) + assert.Empty(t, opts.parameters) + }, + }, + "invalid nonce string": { + option: WithParameter("nonce", "bad\nvalue"), + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - t.Run("duplicate additional parameter", func(t *testing.T) { - opts := &signOptions{} - require.NoError(t, WithParameter("extension", "first").applySignOption(opts)) + require.ErrorIs(t, err, ErrParameter) + assert.False(t, opts.nonceSet) + assert.Empty(t, opts.parameters) + }, + }, + "invalid extension": { + option: WithParameter("extension", struct{}{}), + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - err := WithParameter("extension", "second").applySignOption(opts) + require.ErrorIs(t, err, ErrParameter) + assert.False(t, opts.nonceSet) + assert.Empty(t, opts.parameters) + }, + }, + "duplicate nonce": { + option: WithParameter("nonce", "second"), + previous: []parameterOption{WithParameter("nonce", "first")}, + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - require.ErrorIs(t, err, ErrParameter) - require.Len(t, opts.parameters, 1) - assert.Equal(t, "first", opts.parameters[0].value) - }) + require.ErrorIs(t, err, ErrParameter) + assert.Equal(t, "first", opts.nonce) + }, + }, + "duplicate additional parameter": { + option: WithParameter("extension", "second"), + previous: []parameterOption{WithParameter("extension", "first")}, + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - t.Run("collision with a static parameter", func(t *testing.T) { - opts := &signOptions{ + require.ErrorIs(t, err, ErrParameter) + require.Len(t, opts.parameters, 1) + assert.Equal(t, "first", opts.parameters[0].value) + }, + }, + "collision with a static parameter": { + option: WithParameter("extension", "per-call"), staticParameters: []parameterOption{{name: "extension", value: "static"}}, - } + assert: func(t *testing.T, err error, opts *signOptions) { + t.Helper() - err := WithParameter("extension", "per-call").applySignOption(opts) + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, opts.parameters) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + opts := &signOptions{staticParameters: tc.staticParameters} + for _, previous := range tc.previous { + require.NoError(t, previous.applySignOption(opts)) + } - require.ErrorIs(t, err, ErrParameter) - assert.Empty(t, opts.parameters) - }) + err := tc.option.applySignOption(opts) + tc.assert(t, err, opts) + }) + } } func TestWithParameterForAcceptSignature(t *testing.T) { t.Parallel() - t.Run("extension parameter", func(t *testing.T) { - asb := &AcceptSignatureBuilder{} - - err := WithParameter("example", "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, "value", 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 := []byte("before") - value[0] = 'X' - assert.Equal(t, []byte("before"), asb.parameters[0].value) - }) - - t.Run("invalid parameter", func(t *testing.T) { - asb := &AcceptSignatureBuilder{} - - err := WithParameter("example", struct{}{}).applyAcceptSignatureOption(asb) - - require.ErrorIs(t, err, ErrParameter) - assert.Empty(t, asb.parameters) - }) + for uc, tc := range map[string]struct { + option parameterOption + previous []parameterOption + assert func(t *testing.T, err error, asb *AcceptSignatureBuilder) + }{ + "extension parameter": { + option: WithParameter("example", "value"), + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() - t.Run("duplicate parameter", func(t *testing.T) { - asb := &AcceptSignatureBuilder{} - require.NoError(t, WithParameter("example", "first").applyAcceptSignatureOption(asb)) + require.NoError(t, err) + require.Len(t, asb.parameters, 1) + assert.Equal(t, SignatureParameter("example"), asb.parameters[0].name) + assert.Equal(t, "value", asb.parameters[0].value) + }, + }, + "static byte sequence is copied": { + option: WithParameter("example", value), + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() - err := WithParameter("example", "second").applyAcceptSignatureOption(asb) + require.NoError(t, err) + require.Len(t, asb.parameters, 1) - require.ErrorIs(t, err, ErrParameter) - require.Len(t, asb.parameters, 1) - assert.Equal(t, "first", asb.parameters[0].value) - }) -} + value[0] = 'X' + assert.Equal(t, []byte("before"), asb.parameters[0].value) + }, + }, + "invalid parameter": { + option: WithParameter("example", struct{}{}), + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() -func TestWithParameterForAcceptSignatureBuild(t *testing.T) { - t.Parallel() + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, asb.parameters) + }, + }, + "duplicate parameter": { + option: WithParameter("example", "second"), + previous: []parameterOption{WithParameter("example", "first")}, + assert: func(t *testing.T, err error, asb *AcceptSignatureBuilder) { + t.Helper() - 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", "value"), want: "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}, - "invalid extension": {param: WithParameter("extension", struct{}{}), wantErr: true}, + require.ErrorIs(t, err, ErrParameter) + require.Len(t, asb.parameters, 1) + assert.Equal(t, "first", asb.parameters[0].value) + }, + }, } { 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 + asb := &AcceptSignatureBuilder{} + for _, previous := range tc.previous { + require.NoError(t, previous.applyAcceptSignatureOption(asb)) } - 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) - } + err := tc.option.applyAcceptSignatureOption(asb) + tc.assert(t, err, asb) }) } +} - t.Run("duplicate nonce", func(t *testing.T) { - opts := &acceptSignatureBuildOptions{} - require.NoError(t, WithParameter("nonce", "first").applyAcceptSignatureBuildOption(opts)) +func TestWithParameterForAcceptSignatureBuild(t *testing.T) { + t.Parallel() - err := WithParameter("nonce", "second").applyAcceptSignatureBuildOption(opts) + assertInvalid := func(t *testing.T, err error, opts *acceptSignatureBuildOptions) { + t.Helper() require.ErrorIs(t, err, ErrParameter) - assert.Equal(t, "first", opts.nonce) - }) + assert.False(t, opts.nonceSet) + assert.Empty(t, opts.parameters) + } - t.Run("duplicate extension", func(t *testing.T) { - opts := &acceptSignatureBuildOptions{} - require.NoError(t, WithParameter("extension", "first").applyAcceptSignatureBuildOption(opts)) + for uc, tc := range map[string]struct { + option parameterOption + previous []parameterOption + staticParameters []parameterOption + assert func(t *testing.T, err error, opts *acceptSignatureBuildOptions) + }{ + "nonce": { + option: WithParameter("nonce", "request-nonce"), + assert: func(t *testing.T, err error, opts *acceptSignatureBuildOptions) { + t.Helper() - err := WithParameter("extension", "second").applyAcceptSignatureBuildOption(opts) + require.NoError(t, err) + assert.True(t, opts.nonceSet) + assert.Equal(t, "request-nonce", opts.nonce) + }, + }, + "extension": { + option: WithParameter("extension", "value"), + assert: func(t *testing.T, err error, opts *acceptSignatureBuildOptions) { + t.Helper() - require.ErrorIs(t, err, ErrParameter) - require.Len(t, opts.parameters, 1) - assert.Equal(t, "first", opts.parameters[0].value) - }) + require.NoError(t, err) + require.Len(t, opts.parameters, 1) + assert.Equal(t, "value", opts.parameters[0].value) + }, + }, + "empty nonce": { + option: WithParameter("nonce", ""), + assert: assertInvalid, + }, + "nonce with incorrect type": { + option: WithParameter("nonce", Token("value")), + assert: assertInvalid, + }, + "invalid nonce string": { + option: WithParameter("nonce", "bad\nvalue"), + assert: assertInvalid, + }, + "invalid extension": { + option: WithParameter("extension", struct{}{}), + assert: assertInvalid, + }, + "duplicate nonce": { + option: WithParameter("nonce", "second"), + previous: []parameterOption{WithParameter("nonce", "first")}, + assert: func(t *testing.T, err error, opts *acceptSignatureBuildOptions) { + t.Helper() + + require.ErrorIs(t, err, ErrParameter) + assert.Equal(t, "first", opts.nonce) + }, + }, + "duplicate extension": { + option: WithParameter("extension", "second"), + previous: []parameterOption{WithParameter("extension", "first")}, + assert: func(t *testing.T, err error, opts *acceptSignatureBuildOptions) { + t.Helper() - t.Run("extension conflicts with static parameter", func(t *testing.T) { - opts := &acceptSignatureBuildOptions{ + require.ErrorIs(t, err, ErrParameter) + require.Len(t, opts.parameters, 1) + assert.Equal(t, "first", opts.parameters[0].value) + }, + }, + "extension conflicts with static parameter": { + option: WithParameter("extension", "per-call"), staticParameters: []parameterOption{{name: "extension", value: "static"}}, - } + assert: func(t *testing.T, err error, opts *acceptSignatureBuildOptions) { + t.Helper() - err := WithParameter("extension", "per-call").applyAcceptSignatureBuildOption(opts) + require.ErrorIs(t, err, ErrParameter) + assert.Empty(t, opts.parameters) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + opts := &acceptSignatureBuildOptions{staticParameters: tc.staticParameters} + for _, previous := range tc.previous { + require.NoError(t, previous.applyAcceptSignatureBuildOption(opts)) + } - require.ErrorIs(t, err, ErrParameter) - assert.Empty(t, opts.parameters) - }) + err := tc.option.applyAcceptSignatureBuildOption(opts) + tc.assert(t, err, opts) + }) + } } func TestNormalizeParameter(t *testing.T) { From 8d337e73a2ec0a1c9316b8a5640c130191516997 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Sat, 7 Nov 2026 19:48:13 +0100 Subject: [PATCH 5/8] linter warnings resolved --- options.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/options.go b/options.go index 3ef8a6d..79f07cc 100644 --- a/options.go +++ b/options.go @@ -631,20 +631,20 @@ func normalizeParameter(option parameterOption) (parameterOption, error) { return option, fmt.Errorf("%w: %q is a reserved signature parameter", ErrParameter, option.name) } - switch v := option.value.(type) { + switch val := option.value.(type) { case Token: - option.value = httpsfv.Token(v) + option.value = httpsfv.Token(val) case DisplayString: - if !utf8.ValidString(string(v)) { + if !utf8.ValidString(string(val)) { return option, fmt.Errorf("%w: invalid UTF-8 in signature parameter %q", ErrParameter, option.name) } - option.value = httpsfv.DisplayString(v) + option.value = httpsfv.DisplayString(val) case time.Time: // RFC 9651 Date values have Unix-second precision. - option.value = time.Unix(v.Unix(), 0).UTC() + option.value = time.Unix(val.Unix(), 0).UTC() case int: - option.value = int64(v) + option.value = int64(val) case string, bool, int64, float64, []byte, httpsfv.Token: default: return option, fmt.Errorf("%w: unsupported value type %T for signature parameter %q", From 5293a784f40683c73d56d218853278974dd39bbe Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Sat, 7 Nov 2026 19:51:01 +0100 Subject: [PATCH 6/8] supporting new types in verification policy --- verification_policy.go | 22 +++++++-- verification_policy_test.go | 91 +++++++++++++++++++++++++++++++++++++ 2 files changed, 110 insertions(+), 3 deletions(-) diff --git a/verification_policy.go b/verification_policy.go index d5e77a3..319adff 100644 --- a/verification_policy.go +++ b/verification_policy.go @@ -3,7 +3,6 @@ package httpsig import ( "bytes" "fmt" - "reflect" "slices" "strings" "time" @@ -221,7 +220,7 @@ func (e *verificationPolicy) expectParameter(option parameterOption) error { for _, existing := range e.expectedParameters { if existing.name == option.name { - if reflect.DeepEqual(existing.value, option.value) { + if areEqual(existing.value, option.value) { return nil } @@ -315,7 +314,7 @@ func (e *verificationPolicy) assertMetadata(si *signatureInput, msg *Message) er return fmt.Errorf("%w: expected signature parameter %q is missing", ErrMissingParameter, param.name) } - if !reflect.DeepEqual(value, param.value) { + if !areEqual(value, param.value) { return fmt.Errorf("%w: unexpected value for signature parameter %q", ErrParameter, param.name) } } @@ -346,3 +345,20 @@ func (e *verificationPolicy) assertKeyAlgorithm(si *signatureInput, keyAlg Signa return nil } + +func areEqual(expected, actual any) bool { + switch value := expected.(type) { + case string, httpsfv.Token, httpsfv.DisplayString, bool, int64, float64: + return expected == actual + case []byte: + other, ok := actual.([]byte) + + return ok && bytes.Equal(value, other) + case time.Time: + other, ok := actual.(time.Time) + + return ok && value.Unix() == other.Unix() + default: + return false + } +} diff --git a/verification_policy_test.go b/verification_policy_test.go index 8d51c37..50497a4 100644 --- a/verification_policy_test.go +++ b/verification_policy_test.go @@ -31,6 +31,52 @@ func TestVerificationPolicyClone(t *testing.T) { assert.Equal(t, []parameterOption{{name: "audience", value: "service-a"}}, original.expectedParameters) } +func TestAreEqual(t *testing.T) { + t.Parallel() + + date := time.Unix(1794000000, 0) + for name, tc := range map[string]struct { + a, b any + equal bool + }{ + "equal strings": {a: "hello", b: "hello", equal: true}, + "different strings": {a: "hello", b: "world"}, + "equal tokens": {a: httpsfv.Token("test"), b: httpsfv.Token("test"), equal: true}, + "equal display strings": {a: httpsfv.DisplayString("Grüße"), b: httpsfv.DisplayString("Grüße"), equal: true}, + "different string types": {a: "hello", b: httpsfv.DisplayString("hello")}, + "string and token differ": {a: "hello", b: httpsfv.Token("hello")}, + "string and bytes differ": {a: "hello", b: []byte("hello")}, + "equal booleans": {a: true, b: true, equal: true}, + "equal integers": {a: int64(123), b: int64(123), equal: true}, + "equal decimals": {a: 1.234, b: 1.234, equal: true}, + "equal byte sequences": {a: []byte("abc"), b: []byte("abc"), equal: true}, + "different byte sequences": {a: []byte("abc"), b: []byte("abd")}, + "empty byte sequences": {a: []byte(nil), b: []byte{}, equal: true}, + "same date with other zone": {a: date.UTC(), b: date.In(time.FixedZone("UTC+2", 2*60*60)).Add(500 * time.Millisecond), equal: true}, + "different date seconds": {a: date, b: date.Add(time.Second)}, + "date is not an integer": {a: date, b: date.Unix()}, + } { + t.Run(name, func(t *testing.T) { + assert.Equal(t, tc.equal, areEqual(tc.a, tc.b)) + }) + } +} + +func TestVerificationPolicyExpectParameter(t *testing.T) { + t.Parallel() + + date := time.Unix(1794000000, 0) + policy := &verificationPolicy{} + require.NoError(t, policy.expectParameter(parameterOption{name: "reviewed", value: date.UTC()})) + require.NoError(t, policy.expectParameter(parameterOption{ + name: "reviewed", value: date.In(time.FixedZone("UTC+2", 2*60*60)), + })) + require.Len(t, policy.expectedParameters, 1) + require.ErrorIs(t, policy.expectParameter(parameterOption{ + name: "reviewed", value: date.Add(time.Second), + }), ErrParameter) +} + func TestVerificationPolicyWithOptions(t *testing.T) { t.Parallel() @@ -445,6 +491,51 @@ func TestVerificationPolicyAssertMetadata(t *testing.T) { require.ErrorContains(t, err, `expires parameter`) }, }, + "date parameter matches across time zones": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add("reviewed", time.Unix(1794000000, 0)) + + return params + }(), + }, + exp: verificationPolicy{ + reqCreatedTS: &falseVal, + reqExpiresTS: &falseVal, + expectedParameters: []parameterOption{{ + name: "reviewed", value: time.Unix(1794000000, 500000000).UTC(), + }}, + }, + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + "date parameter does not match an integer": { + params: httpsfv.InnerList{ + Params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add("reviewed", int64(1794000000)) + + return params + }(), + }, + exp: verificationPolicy{ + reqCreatedTS: &falseVal, + reqExpiresTS: &falseVal, + expectedParameters: []parameterOption{{ + name: "reviewed", value: time.Unix(1794000000, 0), + }}, + }, + assert: func(t *testing.T, err error) { + t.Helper() + + require.ErrorIs(t, err, ErrParameter) + require.ErrorContains(t, err, `unexpected value for signature parameter "reviewed"`) + }, + }, "successful assertion with all possible parameters": { params: httpsfv.InnerList{ Params: func() *httpsfv.Params { From 15bc065ab09f0eb78b138ba96b66d393f1e94827 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Sat, 7 Nov 2026 19:51:53 +0100 Subject: [PATCH 7/8] integration test extended --- integration_test.go | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/integration_test.go b/integration_test.go index 698f887..c0bf0fb 100644 --- a/integration_test.go +++ b/integration_test.go @@ -7,6 +7,7 @@ import ( "crypto/rand" "net/http" "testing" + "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -19,12 +20,14 @@ func TestSignAndVerifyParsedSignatureRequest(t *testing.T) { require.NoError(t, err) requests, err := ParseAcceptSignature(http.Header{headerAcceptSignature: { - `sig1=("@method" "@authority");keyid="key1";nonce="abc";tag="app";created;audience="service-a"`, + `sig1=("@method" "@authority");keyid="key1";nonce="abc";tag="app";created;audience="service-a";nickname=%"Gr%c3%bc%c3%9fe";reviewed=@1794000000`, }}) require.NoError(t, err) require.Len(t, requests, 1) request := requests[0] + require.Equal(t, DisplayString("Grüße"), request.Extensions["nickname"]) + require.Equal(t, time.Unix(1794000000, 0), request.Extensions["reviewed"]) signer, err := NewSigner( Key{Material: privKey, Algorithm: EcdsaP256Sha256}, @@ -33,6 +36,8 @@ func TestSignAndVerifyParsedSignatureRequest(t *testing.T) { WithComponents(request.Components...), WithTag(request.Tag), WithParameter("audience", request.Extensions["audience"]), + WithParameter("nickname", request.Extensions["nickname"]), + WithParameter("reviewed", request.Extensions["reviewed"]), ) require.NoError(t, err) @@ -46,7 +51,12 @@ func TestSignAndVerifyParsedSignatureRequest(t *testing.T) { verifier, err := NewVerifier( Key{Material: privKey.Public(), Algorithm: EcdsaP256Sha256}, - WithRequiredTag(request.Tag, WithComponents(request.Components...), WithParameter("audience", "service-a")), + WithRequiredTag(request.Tag, + WithComponents(request.Components...), + WithParameter("audience", "service-a"), + WithParameter("nickname", DisplayString("Grüße")), + WithParameter("reviewed", time.Unix(1794000000, 750000000).In(time.FixedZone("UTC+2", 2*60*60))), + ), ) require.NoError(t, err) @@ -58,6 +68,8 @@ func TestSignAndVerifyParsedSignatureRequest(t *testing.T) { require.True(t, ok) assert.Equal(t, request.Nonce, nonce) assert.Equal(t, request.Label, verified[0].Label) + assert.Equal(t, DisplayString("Grüße"), verified[0].Parameters["nickname"]) + assert.Equal(t, time.Unix(1794000000, 0), verified[0].Parameters["reviewed"]) } func TestParseAcceptSignatureBuilderOutput(t *testing.T) { @@ -70,12 +82,16 @@ func TestParseAcceptSignatureBuilderOutput(t *testing.T) { WithComponents("@status", "content-digest;req", `@query-param;name="Pet"`), WithTag("awesome-app"), WithParameter("audience", "service-a"), + WithParameter("nickname", DisplayString("Grüße")), + WithParameter("reviewed", time.Unix(1794000000, 0)), WithExpiresTimestamp(false), ) require.NoError(t, err) header := http.Header{} require.NoError(t, builder.Build(context.Background(), header, WithParameter(Nonce, "abc"))) + assert.Contains(t, header.Get(headerAcceptSignature), `;nickname=%"Gr%c3%bc%c3%9fe"`) + assert.Contains(t, header.Get(headerAcceptSignature), `;reviewed=@1794000000`) requests, err := ParseAcceptSignature(header) @@ -88,7 +104,11 @@ func TestParseAcceptSignatureBuilderOutput(t *testing.T) { Tag: "awesome-app", Nonce: "abc", Created: true, - Extensions: SignatureParameters{"audience": "service-a"}, + Extensions: SignatureParameters{ + "audience": "service-a", + "nickname": DisplayString("Grüße"), + "reviewed": time.Unix(1794000000, 0), + }, }}, requests) } From 636c0a6c6ee36bba56ba78e66648c987e9cb7270 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Sat, 7 Nov 2026 20:11:34 +0100 Subject: [PATCH 8/8] readme updated --- README.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 873b7b6..8a5eab4 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ ## Introduction and Scope -`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). +`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). In addition to the Structured Fields types defined by [RFC 8941](https://www.rfc-editor.org/rfc/rfc8941.html?utm_source=chatgpt.com), it also supports the `Date` and `Display String` types introduced by [RFC 9651](https://www.rfc-editor.org/rfc/rfc9651.html?utm_source=chatgpt.com). Its key features include: @@ -48,6 +48,12 @@ signer, err := httpsig.NewSigner( httpsig.WithComponents("@authority", "@method", "x-my-fancy-header"), // a tag for your specific application httpsig.WithTag("myapp"), + // custom parameter + httpsig.WithParameter("first", "value 1"), + // custom parameter + httpsig.WithParameter("second", httpsig.DisplayString("öäü")), + // custom parameter + httpsig.WithParameter("third", httpsig.Date(time.Now())), ) // error handling goes here