From 8fafc8679ec16da4184fb723dacdea9055f393e9 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Mon, 19 Oct 2026 08:12:31 +0200 Subject: [PATCH 1/5] signature parameters renamed to signature input to better reflect the meaning --- signature_base.go | 2 +- signature_base_test.go | 2 +- signature_parameters.go => signature_input.go | 12 ++--- ...ameters_test.go => signature_input_test.go | 50 +++++++++---------- signer.go | 4 +- verifier.go | 14 +++--- verifier_test.go | 2 +- 7 files changed, 43 insertions(+), 43 deletions(-) rename signature_parameters.go => signature_input.go (91%) rename signature_parameters_test.go => signature_input_test.go (88%) diff --git a/signature_base.go b/signature_base.go index b6271e7..6482863 100644 --- a/signature_base.go +++ b/signature_base.go @@ -10,7 +10,7 @@ import ( type signatureBase []component -func newSignatureBase(params *signatureParameters, msg *Message) (signatureBase, error) { +func newSignatureBase(params *signatureInput, msg *Message) (signatureBase, error) { marshalledSigParams, err := httpsfv.Marshal(params.InnerList) if err != nil { return nil, err diff --git a/signature_base_test.go b/signature_base_test.go index a668623..a0a718e 100644 --- a/signature_base_test.go +++ b/signature_base_test.go @@ -132,7 +132,7 @@ func TestNewSignatureBase(t *testing.T) { identifiers, err := toComponentIdentifiers(tc.components) require.NoError(t, err) - params := newSignatureParameters(created, time.Time{}, "", keyID, "", "", identifiers) + params := newSignatureInput(created, time.Time{}, "", keyID, "", "", identifiers) sigBase, err := newSignatureBase(params, msg) diff --git a/signature_parameters.go b/signature_input.go similarity index 91% rename from signature_parameters.go rename to signature_input.go index 2198f9b..0a2474c 100644 --- a/signature_parameters.go +++ b/signature_input.go @@ -8,7 +8,7 @@ import ( "github.com/dunglas/httpsfv" ) -type signatureParameters struct { +type signatureInput struct { httpsfv.InnerList created time.Time @@ -20,12 +20,12 @@ type signatureParameters struct { identifiers []*componentIdentifier } -func newSignatureParameters( +func newSignatureInput( created, expires time.Time, nonce, keyID, signatureTag string, algorithm SignatureAlgorithm, identifiers []*componentIdentifier, -) *signatureParameters { +) *signatureInput { // https://www.rfc-editor.org/rfc/rfc9421.html#name-signature-parameters params := httpsfv.NewParams() @@ -58,7 +58,7 @@ func newSignatureParameters( items[i] = id.Item } - return &signatureParameters{ + return &signatureInput{ InnerList: httpsfv.InnerList{Params: params, Items: items}, created: created, expires: expires, @@ -71,7 +71,7 @@ func newSignatureParameters( } //nolint:funlen, cyclop -func (p *signatureParameters) fromInnerList(list httpsfv.InnerList) error { +func (p *signatureInput) fromInnerList(list httpsfv.InnerList) error { for _, item := range list.Items { ci, err := newComponentIdentifier(item) if err != nil { @@ -138,7 +138,7 @@ func (p *signatureParameters) fromInnerList(list httpsfv.InnerList) error { return nil } -func (p *signatureParameters) hasIdentifier(id *componentIdentifier) bool { +func (p *signatureInput) hasIdentifier(id *componentIdentifier) bool { for _, identifier := range p.identifiers { if identifier.Value == id.Value && slices.Equal(identifier.Params.Names(), id.Params.Names()) { return true diff --git a/signature_parameters_test.go b/signature_input_test.go similarity index 88% rename from signature_parameters_test.go rename to signature_input_test.go index 0b36da2..03e3a50 100644 --- a/signature_parameters_test.go +++ b/signature_input_test.go @@ -9,7 +9,7 @@ import ( "github.com/stretchr/testify/require" ) -func TestNewSignatureParameters(t *testing.T) { +func TestNewSignatureInput(t *testing.T) { t.Parallel() for _, tc := range []struct { @@ -21,11 +21,11 @@ func TestNewSignatureParameters(t *testing.T) { tag string algorithm SignatureAlgorithm identifiers []*componentIdentifier - assert func(t *testing.T, params *signatureParameters) + assert func(t *testing.T, params *signatureInput) }{ { uc: "without any parameters", - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() require.NotNil(t, params) @@ -44,7 +44,7 @@ func TestNewSignatureParameters(t *testing.T) { { uc: "with created only", created: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() expCreated := time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC) @@ -68,7 +68,7 @@ func TestNewSignatureParameters(t *testing.T) { { uc: "with expires only", expires: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() expExpires := time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC) @@ -92,7 +92,7 @@ func TestNewSignatureParameters(t *testing.T) { { uc: "with nonce only", nonce: "test", - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() require.NotNil(t, params) @@ -114,7 +114,7 @@ func TestNewSignatureParameters(t *testing.T) { { uc: "with keyid only", keyID: "test", - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() require.NotNil(t, params) @@ -136,7 +136,7 @@ func TestNewSignatureParameters(t *testing.T) { { uc: "with tag only", tag: "test", - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() require.NotNil(t, params) @@ -158,7 +158,7 @@ func TestNewSignatureParameters(t *testing.T) { { uc: "with algorithm only", algorithm: RsaPssSha384, - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() require.NotNil(t, params) @@ -182,7 +182,7 @@ func TestNewSignatureParameters(t *testing.T) { identifiers: []*componentIdentifier{{ Item: httpsfv.Item{Value: "test"}, }}, - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() require.NotNil(t, params) @@ -210,7 +210,7 @@ func TestNewSignatureParameters(t *testing.T) { identifiers: []*componentIdentifier{{ Item: httpsfv.Item{Value: "test"}, }}, - assert: func(t *testing.T, params *signatureParameters) { + assert: func(t *testing.T, params *signatureInput) { t.Helper() expCreated := time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC) @@ -260,27 +260,27 @@ func TestNewSignatureParameters(t *testing.T) { }, } { t.Run(tc.uc, func(t *testing.T) { - params := newSignatureParameters(tc.created, tc.expires, tc.nonce, tc.keyID, tc.tag, tc.algorithm, tc.identifiers) + params := newSignatureInput(tc.created, tc.expires, tc.nonce, tc.keyID, tc.tag, tc.algorithm, tc.identifiers) tc.assert(t, params) }) } } -func TestSignatureParametersFromInnerList(t *testing.T) { +func TestSignatureInputFromInnerList(t *testing.T) { t.Parallel() for _, tc := range []struct { uc string list httpsfv.InnerList - assert func(t *testing.T, err error, params *signatureParameters) + assert func(t *testing.T, err error, params *signatureInput) }{ { uc: "failing create component identifier", list: httpsfv.InnerList{ Items: []httpsfv.Item{{Value: "@test"}}, }, - assert: func(t *testing.T, err error, _ *signatureParameters) { + assert: func(t *testing.T, err error, _ *signatureInput) { t.Helper() require.Error(t, err) @@ -298,7 +298,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { return params }(), }, - assert: func(t *testing.T, err error, _ *signatureParameters) { + assert: func(t *testing.T, err error, _ *signatureInput) { t.Helper() require.Error(t, err) @@ -316,7 +316,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { return params }(), }, - assert: func(t *testing.T, err error, _ *signatureParameters) { + assert: func(t *testing.T, err error, _ *signatureInput) { t.Helper() require.Error(t, err) @@ -334,7 +334,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { return params }(), }, - assert: func(t *testing.T, err error, _ *signatureParameters) { + assert: func(t *testing.T, err error, _ *signatureInput) { t.Helper() require.Error(t, err) @@ -352,7 +352,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { return params }(), }, - assert: func(t *testing.T, err error, _ *signatureParameters) { + assert: func(t *testing.T, err error, _ *signatureInput) { t.Helper() require.Error(t, err) @@ -370,7 +370,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { return params }(), }, - assert: func(t *testing.T, err error, _ *signatureParameters) { + assert: func(t *testing.T, err error, _ *signatureInput) { t.Helper() require.Error(t, err) @@ -388,7 +388,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { return params }(), }, - assert: func(t *testing.T, err error, _ *signatureParameters) { + assert: func(t *testing.T, err error, _ *signatureInput) { t.Helper() require.Error(t, err) @@ -406,7 +406,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { return params }(), }, - assert: func(t *testing.T, err error, params *signatureParameters) { + assert: func(t *testing.T, err error, params *signatureInput) { t.Helper() require.NoError(t, err) @@ -422,7 +422,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { Items: []httpsfv.Item{{Value: "test", Params: httpsfv.NewParams()}}, Params: httpsfv.NewParams(), }, - assert: func(t *testing.T, err error, params *signatureParameters) { + assert: func(t *testing.T, err error, params *signatureInput) { t.Helper() require.NoError(t, err) @@ -453,7 +453,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { return params }(), }, - assert: func(t *testing.T, err error, params *signatureParameters) { + assert: func(t *testing.T, err error, params *signatureInput) { t.Helper() require.NoError(t, err) @@ -473,7 +473,7 @@ func TestSignatureParametersFromInnerList(t *testing.T) { }, } { t.Run(tc.uc, func(t *testing.T) { - var params signatureParameters + var params signatureInput err := params.fromInnerList(tc.list) diff --git a/signer.go b/signer.go index 381730b..3a4bdb6 100644 --- a/signer.go +++ b/signer.go @@ -176,7 +176,7 @@ func (s *signer) Sign(msg *Message) (http.Header, error) { return msg.addSignature(s.label, signature, params.InnerList) } -func (s *signer) signatureParameters(ctx context.Context) (*signatureParameters, error) { +func (s *signer) signatureParameters(ctx context.Context) (*signatureInput, error) { var ( created time.Time expires time.Time @@ -194,7 +194,7 @@ func (s *signer) signatureParameters(ctx context.Context) (*signatureParameters, return nil, err } - return newSignatureParameters( + return newSignatureInput( created, expires, nonce, diff --git a/verifier.go b/verifier.go index 9a1560f..70d1c0d 100644 --- a/verifier.go +++ b/verifier.go @@ -280,7 +280,7 @@ type expectations struct { //nolint:cyclop func (e *expectations) assert( - params *signatureParameters, + params *signatureInput, msg *Message, keyAlg SignatureAlgorithm, nc NonceChecker, @@ -415,7 +415,7 @@ func (v *verifier) Verify(msg *Message) error { return nil } -func (v *verifier) applicableSignatures(refs map[string]*signatureParameters) (map[string]*signatureParameters, error) { +func (v *verifier) applicableSignatures(refs map[string]*signatureInput) (map[string]*signatureInput, error) { for name, params := range refs { if !v.isApplicable(params.tag) { delete(refs, name) @@ -446,7 +446,7 @@ func (v *verifier) negotiateSignatureParameters(msg *Message) error { return &NoApplicableSignatureError{headerToAdd: hdr} } -func (v *verifier) hasMissingSignatures(sigRefs map[string]*signatureParameters) bool { +func (v *verifier) hasMissingSignatures(sigRefs map[string]*signatureInput) bool { for sigTag := range v.tagExpectations { if len(sigTag) == 0 { // empty tag is used for expectations for all signatures @@ -475,7 +475,7 @@ func (v *verifier) hasMissingSignatures(sigRefs map[string]*signatureParameters) func (v *verifier) verifySignature( msg *Message, signature []byte, - params *signatureParameters, + params *signatureInput, exp *expectations, ) error { base, err := newSignatureBase(params, msg) @@ -505,16 +505,16 @@ func (v *verifier) verifySignature( return verifier.verifyPayload(sb, signature) } -func getSignatureReferences(values []string) (map[string]*signatureParameters, error) { +func getSignatureReferences(values []string) (map[string]*signatureInput, error) { inputDict, err := httpsfv.UnmarshalDictionary(values) if err != nil { return nil, fmt.Errorf("%w: %w", ErrMalformedData, err) } - sigRefs := make(map[string]*signatureParameters, len(inputDict.Names())) + sigRefs := make(map[string]*signatureInput, len(inputDict.Names())) for _, label := range inputDict.Names() { - var sp signatureParameters + var sp signatureInput m, _ := inputDict.Get(label) diff --git a/verifier_test.go b/verifier_test.go index 8cf155c..11bfb14 100644 --- a/verifier_test.go +++ b/verifier_test.go @@ -411,7 +411,7 @@ func TestExpectationsAssertParameters(t *testing.T) { }, } { t.Run(tc.uc, func(t *testing.T) { - var params signatureParameters + var params signatureInput msg := &Message{Context: context.TODO()} From a0cccad9e73801d92eda6d24b0fc7ae2c552300e Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Tue, 20 Oct 2026 10:34:09 +0200 Subject: [PATCH 2/5] signature input refactored to better support the existing needs --- signature_base.go | 10 +- signature_base_test.go | 8 +- signature_input.go | 169 +++---- signature_input_test.go | 1025 +++++++++++++++++++++++++-------------- signer.go | 53 +- verifier.go | 56 ++- verifier_test.go | 6 +- 7 files changed, 812 insertions(+), 515 deletions(-) diff --git a/signature_base.go b/signature_base.go index 6482863..23afc74 100644 --- a/signature_base.go +++ b/signature_base.go @@ -10,16 +10,16 @@ import ( type signatureBase []component -func newSignatureBase(params *signatureInput, msg *Message) (signatureBase, error) { - marshalledSigParams, err := httpsfv.Marshal(params.InnerList) +func newSignatureBase(si *signatureInput, msg *Message) (signatureBase, error) { + marshalledSigParams, err := httpsfv.Marshal(si.value) if err != nil { return nil, err } - sigBase := make(signatureBase, 0, len(params.identifiers)+1) - seen := make(map[string]struct{}, len(params.identifiers)) + sigBase := make(signatureBase, 0, len(si.identifiers)+1) + seen := make(map[string]struct{}, len(si.identifiers)) - for _, ci := range params.identifiers { + for _, ci := range si.identifiers { identifier, err := httpsfv.Marshal(ci.Item) if err != nil { return nil, err diff --git a/signature_base_test.go b/signature_base_test.go index a0a718e..3078f49 100644 --- a/signature_base_test.go +++ b/signature_base_test.go @@ -132,9 +132,13 @@ func TestNewSignatureBase(t *testing.T) { identifiers, err := toComponentIdentifiers(tc.components) require.NoError(t, err) - params := newSignatureInput(created, time.Time{}, "", keyID, "", "", identifiers) + params := httpsfv.NewParams() + params.Add(string(Created), created.Unix()) + params.Add(string(KeyID), keyID) - sigBase, err := newSignatureBase(params, msg) + si := newSignatureInput(identifiers, params) + + sigBase, err := newSignatureBase(si, msg) tc.assert(t, err, sigBase) }) diff --git a/signature_input.go b/signature_input.go index 0a2474c..4a42beb 100644 --- a/signature_input.go +++ b/signature_input.go @@ -9,48 +9,17 @@ import ( ) type signatureInput struct { - httpsfv.InnerList - - created time.Time - expires time.Time - nonce string - alg SignatureAlgorithm - keyID string - tag string + value httpsfv.InnerList identifiers []*componentIdentifier } func newSignatureInput( - created, expires time.Time, - nonce, keyID, signatureTag string, - algorithm SignatureAlgorithm, identifiers []*componentIdentifier, + params *httpsfv.Params, ) *signatureInput { // https://www.rfc-editor.org/rfc/rfc9421.html#name-signature-parameters - params := httpsfv.NewParams() - - if !created.Equal(time.Time{}) { - params.Add(string(Created), created.Unix()) - } - - if !expires.Equal(time.Time{}) { - params.Add(string(Expires), expires.Unix()) - } - - if len(keyID) != 0 { - params.Add(string(KeyID), keyID) - } - - if len(algorithm) != 0 { - params.Add(string(Alg), string(algorithm)) - } - - if len(nonce) != 0 { - params.Add(string(Nonce), nonce) - } - - if len(signatureTag) != 0 { - params.Add(string(Tag), signatureTag) + if params == nil { + params = httpsfv.NewParams() } items := make([]httpsfv.Item, len(identifiers)) @@ -59,87 +28,61 @@ func newSignatureInput( } return &signatureInput{ - InnerList: httpsfv.InnerList{Params: params, Items: items}, - created: created, - expires: expires, - nonce: nonce, - alg: algorithm, - keyID: keyID, - tag: signatureTag, + value: httpsfv.InnerList{ + Items: items, + Params: params, + }, identifiers: identifiers, } } -//nolint:funlen, cyclop -func (p *signatureInput) fromInnerList(list httpsfv.InnerList) error { +func parseSignatureInput(list httpsfv.InnerList) (*signatureInput, error) { + identifiers := make([]*componentIdentifier, 0, len(list.Items)) + for _, item := range list.Items { - ci, err := newComponentIdentifier(item) + identifier, err := newComponentIdentifier(item) if err != nil { - return err + return nil, err } - p.identifiers = append(p.identifiers, ci) + identifiers = append(identifiers, identifier) } - for _, name := range list.Params.Names() { - param, _ := list.Params.Get(name) + if err := validateSignatureInputParameters(list.Params); err != nil { + return nil, err + } - switch SignatureParameter(name) { - case Created: - value, ok := param.(int64) - if !ok { - return fmt.Errorf("%w: created", ErrMalformedSignatureParameter) - } + return &signatureInput{ + value: list, + identifiers: identifiers, + }, nil +} - p.created = time.Unix(value, 0).UTC() - case Expires: - value, ok := param.(int64) - if !ok { - return fmt.Errorf("%w: expires", ErrMalformedSignatureParameter) - } +func validateSignatureInputParameters(params *httpsfv.Params) error { + if params == nil { + return nil + } - p.expires = time.Unix(value, 0).UTC() - case KeyID: - value, ok := param.(string) - if !ok { - return fmt.Errorf("%w: keyid", ErrMalformedSignatureParameter) - } + for _, name := range params.Names() { + value, _ := params.Get(name) - p.keyID = value - case Alg: - value, ok := param.(string) - if !ok { - return fmt.Errorf("%w: alg", ErrMalformedSignatureParameter) - } - - p.alg = SignatureAlgorithm(value) - case Nonce: - value, ok := param.(string) - if !ok { - return fmt.Errorf("%w: nonce", ErrMalformedSignatureParameter) + switch SignatureParameter(name) { + case Created, Expires: + if _, ok := value.(int64); !ok { + return fmt.Errorf("%w: %s", ErrMalformedSignatureParameter, name) } - - p.nonce = value - case Tag: - value, ok := param.(string) - if !ok { - return fmt.Errorf("%w: tag", ErrMalformedSignatureParameter) + case KeyID, Alg, Nonce, Tag: + if _, ok := value.(string); !ok { + return fmt.Errorf("%w: %s", ErrMalformedSignatureParameter, name) } - - p.tag = value - default: - // ignoring unknown parameter } } - p.Params = list.Params - p.Items = list.Items - return nil } -func (p *signatureInput) hasIdentifier(id *componentIdentifier) bool { - for _, identifier := range p.identifiers { +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 } @@ -147,3 +90,41 @@ func (p *signatureInput) hasIdentifier(id *componentIdentifier) bool { return false } + +func (si *signatureInput) parameter(name SignatureParameter) (any, bool) { + if si.value.Params == nil { + return nil, false + } + + return si.value.Params.Get(string(name)) +} + +func (si *signatureInput) stringParameter(name SignatureParameter) (string, bool) { + value, present := si.parameter(name) + if !present { + return "", false + } + + return value.(string), true +} + +func (si *signatureInput) timestamp(name SignatureParameter) (time.Time, bool) { + value, present := si.parameter(name) + if !present { + return time.Time{}, false + } + + return time.Unix(value.(int64), 0).UTC(), true +} + +func (si *signatureInput) algorithm() (SignatureAlgorithm, bool) { + value, present := si.stringParameter(Alg) + + return SignatureAlgorithm(value), present +} + +func (si *signatureInput) created() (time.Time, bool) { return si.timestamp(Created) } +func (si *signatureInput) expires() (time.Time, bool) { return si.timestamp(Expires) } +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) } diff --git a/signature_input_test.go b/signature_input_test.go index 03e3a50..5279d6b 100644 --- a/signature_input_test.go +++ b/signature_input_test.go @@ -12,472 +12,771 @@ import ( func TestNewSignatureInput(t *testing.T) { t.Parallel() - for _, tc := range []struct { - uc string - created time.Time - expires time.Time - nonce string - keyID string - tag string - algorithm SignatureAlgorithm + for uc, tc := range map[string]struct { identifiers []*componentIdentifier - assert func(t *testing.T, params *signatureInput) + params *httpsfv.Params + assert func(t *testing.T, input *signatureInput) }{ - { - uc: "without any parameters", - assert: func(t *testing.T, params *signatureInput) { + "without parameters or identifiers": { + assert: func(t *testing.T, input *signatureInput) { t.Helper() - require.NotNil(t, params) - assert.Equal(t, time.Time{}, params.created) - assert.Equal(t, time.Time{}, params.expires) - assert.Empty(t, params.nonce) - assert.Empty(t, params.keyID) - assert.Empty(t, params.tag) - assert.Empty(t, params.alg) - assert.Empty(t, params.identifiers) - require.NotNil(t, params.Params) - assert.Empty(t, params.Params.Names()) - assert.Empty(t, params.Items) + require.NotNil(t, input) + require.NotNil(t, input.value.Params) + assert.Empty(t, input.value.Params.Names()) + assert.Empty(t, input.value.Items) + assert.Empty(t, input.identifiers) }, }, - { - uc: "with created only", - created: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - assert: func(t *testing.T, params *signatureInput) { + "with parameters only": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), int64(1577836800)) + params.Add("wimse-aud", "https://api.example.com") + + return params + }(), + assert: func(t *testing.T, input *signatureInput) { t.Helper() - expCreated := time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC) - - require.NotNil(t, params) - assert.Equal(t, expCreated, params.created) - assert.Equal(t, time.Time{}, params.expires) - assert.Empty(t, params.nonce) - assert.Empty(t, params.keyID) - assert.Empty(t, params.tag) - assert.Empty(t, params.alg) - assert.Empty(t, params.identifiers) - require.NotNil(t, params.Params) - assert.ElementsMatch(t, params.Params.Names(), []string{string(Created)}) - created, ok := params.Params.Get(string(Created)) - require.True(t, ok) - assert.Equal(t, expCreated.Unix(), created) - assert.Empty(t, params.Items) + require.NotNil(t, input) + assert.Equal(t, []string{string(Created), "wimse-aud"}, input.value.Params.Names()) + assert.Empty(t, input.value.Items) + assert.Empty(t, input.identifiers) }, }, - { - uc: "with expires only", - expires: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - assert: func(t *testing.T, params *signatureInput) { - t.Helper() - - expExpires := time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC) - - require.NotNil(t, params) - assert.Equal(t, time.Time{}, params.created) - assert.Equal(t, expExpires, params.expires) - assert.Empty(t, params.nonce) - assert.Empty(t, params.keyID) - assert.Empty(t, params.tag) - assert.Empty(t, params.alg) - assert.Empty(t, params.identifiers) - require.NotNil(t, params.Params) - assert.ElementsMatch(t, params.Params.Names(), []string{string(Expires)}) - expires, ok := params.Params.Get(string(Expires)) - require.True(t, ok) - assert.Equal(t, expExpires.Unix(), expires) - assert.Empty(t, params.Items) + "with identifiers and parameters": { + identifiers: []*componentIdentifier{ + {Item: httpsfv.Item{Value: "@method", Params: httpsfv.NewParams()}}, + {Item: httpsfv.Item{Value: "user-agent", Params: httpsfv.NewParams()}}, }, - }, - { - uc: "with nonce only", - nonce: "test", - assert: func(t *testing.T, params *signatureInput) { - t.Helper() + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Tag), "web-bot-auth") - require.NotNil(t, params) - assert.Equal(t, time.Time{}, params.created) - assert.Equal(t, time.Time{}, params.expires) - assert.Equal(t, "test", params.nonce) - assert.Empty(t, params.keyID) - assert.Empty(t, params.tag) - assert.Empty(t, params.alg) - assert.Empty(t, params.identifiers) - require.NotNil(t, params.Params) - assert.ElementsMatch(t, params.Params.Names(), []string{string(Nonce)}) - nonce, ok := params.Params.Get(string(Nonce)) - require.True(t, ok) - assert.Equal(t, "test", nonce) - assert.Empty(t, params.Items) - }, - }, - { - uc: "with keyid only", - keyID: "test", - assert: func(t *testing.T, params *signatureInput) { + return params + }(), + assert: func(t *testing.T, input *signatureInput) { t.Helper() - require.NotNil(t, params) - assert.Equal(t, time.Time{}, params.created) - assert.Equal(t, time.Time{}, params.expires) - assert.Empty(t, params.nonce) - assert.Equal(t, "test", params.keyID) - assert.Empty(t, params.tag) - assert.Empty(t, params.alg) - assert.Empty(t, params.identifiers) - require.NotNil(t, params.Params) - assert.ElementsMatch(t, params.Params.Names(), []string{string(KeyID)}) - keyID, ok := params.Params.Get(string(KeyID)) - require.True(t, ok) - assert.Equal(t, "test", keyID) - assert.Empty(t, params.Items) - }, - }, - { - uc: "with tag only", - tag: "test", - assert: func(t *testing.T, params *signatureInput) { - t.Helper() - - require.NotNil(t, params) - assert.Equal(t, time.Time{}, params.created) - assert.Equal(t, time.Time{}, params.expires) - assert.Empty(t, params.nonce) - assert.Empty(t, params.keyID) - assert.Equal(t, "test", params.tag) - assert.Empty(t, params.alg) - assert.Empty(t, params.identifiers) - require.NotNil(t, params.Params) - assert.ElementsMatch(t, params.Params.Names(), []string{string(Tag)}) - tag, ok := params.Params.Get(string(Tag)) - require.True(t, ok) - assert.Equal(t, "test", tag) - assert.Empty(t, params.Items) - }, - }, - { - uc: "with algorithm only", - algorithm: RsaPssSha384, - assert: func(t *testing.T, params *signatureInput) { - t.Helper() - - require.NotNil(t, params) - assert.Equal(t, time.Time{}, params.created) - assert.Equal(t, time.Time{}, params.expires) - assert.Empty(t, params.nonce) - assert.Empty(t, params.keyID) - assert.Empty(t, params.tag) - assert.Equal(t, RsaPssSha384, params.alg) - assert.Empty(t, params.identifiers) - require.NotNil(t, params.Params) - assert.ElementsMatch(t, params.Params.Names(), []string{string(Alg)}) - alg, ok := params.Params.Get(string(Alg)) - require.True(t, ok) - assert.Equal(t, string(RsaPssSha384), alg) - assert.Empty(t, params.Items) - }, - }, - { - uc: "with identifiers only", - identifiers: []*componentIdentifier{{ - Item: httpsfv.Item{Value: "test"}, - }}, - assert: func(t *testing.T, params *signatureInput) { - t.Helper() - - require.NotNil(t, params) - assert.Equal(t, time.Time{}, params.created) - assert.Equal(t, time.Time{}, params.expires) - assert.Empty(t, params.nonce) - assert.Empty(t, params.keyID) - assert.Empty(t, params.tag) - assert.Empty(t, params.alg) - assert.Len(t, params.identifiers, 1) - require.NotNil(t, params.Params) - assert.Empty(t, params.Params.Names()) - require.Len(t, params.Items, 1) - assert.Equal(t, "test", params.Items[0].Value) - }, - }, - { - uc: "with everything specified", - created: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - expires: time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC), - nonce: "nonce", - keyID: "key-id", - tag: "tag", - algorithm: RsaPkcs1v15Sha512, - identifiers: []*componentIdentifier{{ - Item: httpsfv.Item{Value: "test"}, - }}, - assert: func(t *testing.T, params *signatureInput) { - t.Helper() - - expCreated := time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC) - expExpires := time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC) - - require.NotNil(t, params) - assert.Equal(t, expCreated, params.created) - assert.Equal(t, expExpires, params.expires) - assert.Equal(t, "nonce", params.nonce) - assert.Equal(t, "key-id", params.keyID) - assert.Equal(t, "tag", params.tag) - assert.Equal(t, RsaPkcs1v15Sha512, params.alg) - assert.Len(t, params.identifiers, 1) - require.NotNil(t, params.Params) - assert.Len(t, params.Params.Names(), 6) - assert.ElementsMatch(t, params.Params.Names(), []string{ - string(Created), string(Expires), string(Nonce), string(KeyID), string(Tag), string(Alg), - }) - - created, ok := params.Params.Get(string(Created)) - require.True(t, ok) - assert.Equal(t, expCreated.Unix(), created) - - expires, ok := params.Params.Get(string(Expires)) - require.True(t, ok) - assert.Equal(t, expExpires.Unix(), expires) - - nonce, ok := params.Params.Get(string(Nonce)) - require.True(t, ok) - assert.Equal(t, "nonce", nonce) - - keyID, ok := params.Params.Get(string(KeyID)) - require.True(t, ok) - assert.Equal(t, "key-id", keyID) - - tag, ok := params.Params.Get(string(Tag)) - require.True(t, ok) - assert.Equal(t, "tag", tag) - - alg, ok := params.Params.Get(string(Alg)) - require.True(t, ok) - assert.Equal(t, string(RsaPkcs1v15Sha512), alg) - - require.Len(t, params.Items, 1) - assert.Equal(t, "test", params.Items[0].Value) + require.NotNil(t, input) + assert.Equal(t, []string{string(Tag)}, input.value.Params.Names()) + require.Len(t, input.identifiers, 2) + assert.Equal(t, "@method", input.identifiers[0].Value) + assert.Equal(t, "user-agent", input.identifiers[1].Value) + require.Len(t, input.value.Items, 2) + assert.Equal(t, "@method", input.value.Items[0].Value) + assert.Equal(t, "user-agent", input.value.Items[1].Value) }, }, } { - t.Run(tc.uc, func(t *testing.T) { - params := newSignatureInput(tc.created, tc.expires, tc.nonce, tc.keyID, tc.tag, tc.algorithm, tc.identifiers) + t.Run(uc, func(t *testing.T) { + input := newSignatureInput(tc.identifiers, tc.params) - tc.assert(t, params) + tc.assert(t, input) }) } } -func TestSignatureInputFromInnerList(t *testing.T) { +func TestParseSignatureInput(t *testing.T) { t.Parallel() - for _, tc := range []struct { - uc string + for uc, tc := range map[string]struct { list httpsfv.InnerList - assert func(t *testing.T, err error, params *signatureInput) + assert func(t *testing.T, err error, input *signatureInput) }{ - { - uc: "failing create component identifier", + "empty list": { + assert: func(t *testing.T, err error, input *signatureInput) { + t.Helper() + + require.NoError(t, err) + require.NotNil(t, input) + assert.Empty(t, input.value.Items) + assert.Nil(t, input.value.Params) + assert.Empty(t, input.identifiers) + }, + }, + "invalid component identifier": { list: httpsfv.InnerList{ - Items: []httpsfv.Item{{Value: "@test"}}, + Items: []httpsfv.Item{{Value: "@unsupported", Params: httpsfv.NewParams()}}, }, - assert: func(t *testing.T, err error, _ *signatureInput) { + assert: func(t *testing.T, err error, input *signatureInput) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrUnsupportedComponentIdentifier) - require.ErrorContains(t, err, "@test") + assert.Nil(t, input) }, }, - { - uc: "failing parsing created parameter", + "invalid signature parameter": { list: httpsfv.InnerList{ + Items: []httpsfv.Item{{Value: "@method", Params: httpsfv.NewParams()}}, Params: func() *httpsfv.Params { params := httpsfv.NewParams() - params.Add(string(Created), "foo") + params.Add(string(Created), "not-an-integer") return params }(), }, - assert: func(t *testing.T, err error, _ *signatureInput) { + assert: func(t *testing.T, err error, input *signatureInput) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrMalformedSignatureParameter) - require.ErrorContains(t, err, "created") + require.ErrorContains(t, err, string(Created)) + assert.Nil(t, input) }, }, - { - uc: "failing parsing expires parameter", + "valid list with standard and unknown parameters": { list: httpsfv.InnerList{ + Items: []httpsfv.Item{ + {Value: "@method", Params: httpsfv.NewParams()}, + {Value: "user-agent", Params: httpsfv.NewParams()}, + }, Params: func() *httpsfv.Params { params := httpsfv.NewParams() - params.Add(string(Expires), "foo") + params.Add(string(Created), int64(1577836800)) + params.Add(string(Tag), "wimse-workload-to-workload") + params.Add("wimse-sign-response", true) return params }(), }, - assert: func(t *testing.T, err error, _ *signatureInput) { + assert: func(t *testing.T, err error, input *signatureInput) { t.Helper() - require.Error(t, err) - require.ErrorIs(t, err, ErrMalformedSignatureParameter) - require.ErrorContains(t, err, "expires") + require.NoError(t, err) + require.NotNil(t, input) + assert.Equal(t, []string{ + string(Created), string(Tag), "wimse-sign-response", + }, input.value.Params.Names()) + + value, present := input.value.Params.Get("wimse-sign-response") + require.True(t, present) + assert.Equal(t, true, value) + require.Len(t, input.identifiers, 2) + assert.Equal(t, "@method", input.identifiers[0].Value) + assert.Equal(t, "user-agent", input.identifiers[1].Value) + require.Len(t, input.value.Items, 2) + assert.Equal(t, "@method", input.value.Items[0].Value) + assert.Equal(t, "user-agent", input.value.Items[1].Value) }, }, - { - uc: "failing parsing keyid parameter", - list: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(KeyID), 1) + } { + t.Run(uc, func(t *testing.T) { + input, err := parseSignatureInput(tc.list) - return params - }(), + tc.assert(t, err, input) + }) + } +} + +func TestValidateSignatureInputParameters(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + assert func(t *testing.T, err error) + }{ + "nil parameters": { + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) }, - assert: func(t *testing.T, err error, _ *signatureInput) { + }, + "empty parameters": { + params: httpsfv.NewParams(), + assert: func(t *testing.T, err error) { t.Helper() - require.Error(t, err) - require.ErrorIs(t, err, ErrMalformedSignatureParameter) - require.ErrorContains(t, err, "keyid") + require.NoError(t, err) }, }, - { - uc: "failing parsing alg parameter", - list: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Alg), 1) + "valid timestamp parameters": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), int64(0)) + params.Add(string(Expires), int64(1577836800)) + + return params + }(), + assert: func(t *testing.T, err error) { + t.Helper() - return params - }(), + require.NoError(t, err) }, - assert: func(t *testing.T, err error, _ *signatureInput) { + }, + "invalid created parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), "0") + + return params + }(), + assert: func(t *testing.T, err error) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrMalformedSignatureParameter) - require.ErrorContains(t, err, "alg") + require.ErrorContains(t, err, string(Created)) }, }, - { - uc: "failing parsing nonce parameter", - list: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Nonce), 1) + "invalid expires parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Expires), "0") + + return params + }(), + assert: func(t *testing.T, err error) { + t.Helper() - return params - }(), + require.ErrorIs(t, err, ErrMalformedSignatureParameter) + require.ErrorContains(t, err, string(Expires)) }, - assert: func(t *testing.T, err error, _ *signatureInput) { + }, + "valid string parameters": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(KeyID), "") + params.Add(string(Alg), string(RsaPssSha384)) + params.Add(string(Nonce), "n-123") + params.Add(string(Tag), "") + + return params + }(), + assert: func(t *testing.T, err error) { t.Helper() - require.Error(t, err) - require.ErrorIs(t, err, ErrMalformedSignatureParameter) - require.ErrorContains(t, err, "nonce") + require.NoError(t, err) }, }, - { - uc: "failing parsing tag parameter", - list: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Tag), 1) + "invalid keyid parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(KeyID), int64(1)) + + return params + }(), + assert: func(t *testing.T, err error) { + t.Helper() - return params - }(), + require.ErrorIs(t, err, ErrMalformedSignatureParameter) + require.ErrorContains(t, err, string(KeyID)) }, - assert: func(t *testing.T, err error, _ *signatureInput) { + }, + "invalid alg parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Alg), int64(1)) + + return params + }(), + assert: func(t *testing.T, err error) { t.Helper() - require.Error(t, err) require.ErrorIs(t, err, ErrMalformedSignatureParameter) - require.ErrorContains(t, err, "tag") + require.ErrorContains(t, err, string(Alg)) }, }, - { - uc: "preserving unknown signature parameter", - list: httpsfv.InnerList{ - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add("foo", 1) + "invalid nonce parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Nonce), int64(1)) + + return params + }(), + assert: func(t *testing.T, err error) { + t.Helper() - return params - }(), + require.ErrorIs(t, err, ErrMalformedSignatureParameter) + require.ErrorContains(t, err, string(Nonce)) }, - assert: func(t *testing.T, err error, params *signatureInput) { + }, + "invalid tag parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Tag), int64(1)) + + return params + }(), + assert: func(t *testing.T, err error) { t.Helper() + require.ErrorIs(t, err, ErrMalformedSignatureParameter) + require.ErrorContains(t, err, string(Tag)) + }, + }, + "unknown parameters are allowed": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add("wimse-aud", "https://api.example.com") + params.Add("wimse-sign-response", true) + + return params + }(), + assert: func(t *testing.T, err error) { + t.Helper() require.NoError(t, err) - - value, ok := params.Params.Get("foo") - require.True(t, ok) - assert.Equal(t, 1, value) }, }, - { - uc: "with identifiers only", - list: httpsfv.InnerList{ - Items: []httpsfv.Item{{Value: "test", Params: httpsfv.NewParams()}}, - Params: httpsfv.NewParams(), + } { + t.Run(uc, func(t *testing.T) { + err := validateSignatureInputParameters(tc.params) + + tc.assert(t, err) + }) + } +} + +func TestSignatureInputParameter(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + name SignatureParameter + assert func(t *testing.T, value any, present bool) + }{ + "nil parameters": { + name: KeyID, + assert: func(t *testing.T, value any, present bool) { + t.Helper() + + assert.False(t, present) + assert.Nil(t, value) }, - assert: func(t *testing.T, err error, params *signatureInput) { + }, + "missing parameter": { + params: httpsfv.NewParams(), + name: Created, + assert: func(t *testing.T, value any, present bool) { t.Helper() - require.NoError(t, err) - require.NotNil(t, params) - assert.Equal(t, time.Time{}, params.created) - assert.Equal(t, time.Time{}, params.expires) - assert.Empty(t, params.nonce) - assert.Empty(t, params.keyID) - assert.Empty(t, params.tag) - assert.Empty(t, params.alg) - assert.Len(t, params.identifiers, 1) - assert.Equal(t, "test", params.identifiers[0].Value) + assert.False(t, present) + assert.Nil(t, value) }, }, - { - uc: "with everything specified", - list: httpsfv.InnerList{ - Items: []httpsfv.Item{{Value: "test", Params: httpsfv.NewParams()}}, - Params: func() *httpsfv.Params { - params := httpsfv.NewParams() - params.Add(string(Created), time.Now().Unix()) - params.Add(string(Expires), time.Now().Add(5*time.Second).Unix()) - params.Add(string(Nonce), "nonce") - params.Add(string(Tag), "tag") - params.Add(string(Alg), string(RsaPssSha384)) - params.Add(string(KeyID), "test") + "present parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), int64(1577836800)) + + return params + }(), + name: Created, + assert: func(t *testing.T, value any, present bool) { + t.Helper() - return params - }(), + require.True(t, present) + assert.Equal(t, int64(1577836800), value) }, - assert: func(t *testing.T, err error, params *signatureInput) { + }, + "present zero value": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), int64(0)) + + return params + }(), + name: Created, + assert: func(t *testing.T, value any, present bool) { t.Helper() - require.NoError(t, err) - require.NotNil(t, params) - - assert.GreaterOrEqual(t, time.Now(), params.created) - assert.Equal(t, time.UTC, params.created.Location()) - assert.GreaterOrEqual(t, time.Now().Add(5*time.Second), params.expires) - assert.Equal(t, time.UTC, params.expires.Location()) - assert.Equal(t, "nonce", params.nonce) - assert.Equal(t, "tag", params.tag) - assert.Equal(t, RsaPssSha384, params.alg) - assert.Equal(t, "test", params.keyID) - assert.Len(t, params.identifiers, 1) - assert.Equal(t, "test", params.identifiers[0].Value) + require.True(t, present) + assert.Equal(t, int64(0), value) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.parameter(tc.name) + + tc.assert(t, value, present) + }) + } +} + +func TestSignatureInputStringParameter(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + name SignatureParameter + expected string + }{ + "missing parameter": { + name: KeyID, + }, + "present parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Nonce), "nonce-123") + + return params + }(), + name: Nonce, + expected: "nonce-123", + }, + "present empty parameter": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(KeyID), "") + + return params + }(), + name: KeyID, + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.stringParameter(tc.name) + + if tc.params == nil { + require.False(t, present) + } else { + require.True(t, present) + assert.Equal(t, tc.expected, value) + } + }) + } +} + +func TestSignatureInputTimestamp(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + name SignatureParameter + expected time.Time + }{ + "missing": { + name: Created, + }, + "present": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), int64(1577836800)) + + return params + }(), + name: Created, + expected: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), + }, + "present zero timestamp": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Expires), int64(0)) + + return params + }(), + name: Expires, + expected: time.Unix(0, 0).UTC(), + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.timestamp(tc.name) + + if tc.params == nil { + require.False(t, present) + assert.True(t, value.IsZero()) + } else { + require.True(t, present) + assert.Equal(t, tc.expected, value) + } + }) + } +} + +func TestSignatureInputCreated(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + expected time.Time + }{ + "missing": {}, + "present": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), int64(1577836800)) + + return params + }(), + expected: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), + }, + "present zero created": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Created), int64(0)) + + return params + }(), + expected: time.Unix(0, 0).UTC(), + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.created() + + if tc.params == nil { + require.False(t, present) + assert.True(t, value.IsZero()) + } else { + require.True(t, present) + assert.Equal(t, tc.expected, value) + } + }) + } +} + +func TestSignatureInputExpires(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + expected time.Time + }{ + "missing": {}, + "present": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Expires), int64(1609459200)) + + return params + }(), + expected: time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC), + }, + "present zero expires": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Expires), int64(0)) + + return params + }(), + expected: time.Unix(0, 0).UTC(), + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.expires() + + if tc.params == nil { + require.False(t, present) + assert.True(t, value.IsZero()) + } else { + require.True(t, present) + assert.Equal(t, tc.expected, value) + } + }) + } +} + +func TestSignatureInputNonce(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + expected string + }{ + "missing": {}, + "present": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Nonce), "nonce-123") + + return params + }(), + expected: "nonce-123", + }, + "present but empty": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Nonce), "") + + return params + }(), + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.nonce() + + if tc.params == nil { + require.False(t, present) + } else { + require.True(t, present) + assert.Equal(t, tc.expected, value) + } + }) + } +} + +func TestSignatureInputKeyID(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + expected string + }{ + "missing": {}, + "present": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(KeyID), "key-123") + + return params + }(), + expected: "key-123", + }, + "present but empty": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(KeyID), "") + + return params + }(), + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.keyID() + + if tc.params == nil { + require.False(t, present) + } else { + require.True(t, present) + assert.Equal(t, tc.expected, value) + } + }) + } +} + +func TestSignatureInputAlgorithm(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + expected SignatureAlgorithm + }{ + "missing": {}, + "present": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Alg), string(RsaPssSha384)) + + return params + }(), + expected: RsaPssSha384, + }, + "present but empty": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Alg), "") + + return params + }(), + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.algorithm() + + if tc.params == nil { + require.False(t, present) + } else { + require.True(t, present) + assert.Equal(t, tc.expected, value) + } + }) + } +} + +func TestSignatureInputTag(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + params *httpsfv.Params + expected string + }{ + "missing tag": {}, + "present tag": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Tag), "web-bot-auth") + return params + }(), + expected: "web-bot-auth", + }, + "present empty tag": { + params: func() *httpsfv.Params { + params := httpsfv.NewParams() + params.Add(string(Tag), "") + + return params + }(), + }, + } { + t.Run(uc, func(t *testing.T) { + input := &signatureInput{value: httpsfv.InnerList{Params: tc.params}} + + value, present := input.tag() + + if tc.params == nil { + require.False(t, present) + } else { + require.True(t, present) + assert.Equal(t, tc.expected, value) + } + }) + } +} + +func TestSignatureInputHasIdentifier(t *testing.T) { + t.Parallel() + + for uc, tc := range map[string]struct { + given []*componentIdentifier + identifier *componentIdentifier + expected bool + }{ + "no identifiers": { + identifier: &componentIdentifier{ + Item: httpsfv.Item{Value: "@method", Params: httpsfv.NewParams()}, + }, + expected: false, + }, + "matching identifier": { + given: []*componentIdentifier{{ + Item: httpsfv.Item{Value: "@method", Params: httpsfv.NewParams()}, + }}, + identifier: &componentIdentifier{ + Item: httpsfv.Item{Value: "@method", Params: httpsfv.NewParams()}, + }, + expected: true, + }, + "different identifier name": { + given: []*componentIdentifier{{ + Item: httpsfv.Item{Value: "@method", Params: httpsfv.NewParams()}, + }}, + identifier: &componentIdentifier{ + Item: httpsfv.Item{Value: "@authority", Params: httpsfv.NewParams()}, }, + expected: false, }, } { - t.Run(tc.uc, func(t *testing.T) { - var params signatureInput + t.Run(uc, func(t *testing.T) { + input := &signatureInput{identifiers: tc.given} - err := params.fromInnerList(tc.list) + found := input.hasIdentifier(tc.identifier) - tc.assert(t, err, ¶ms) + require.Equal(t, tc.expected, found) }) } } diff --git a/signer.go b/signer.go index 3a4bdb6..ab14538 100644 --- a/signer.go +++ b/signer.go @@ -8,6 +8,8 @@ import ( "fmt" "net/http" "time" + + "github.com/dunglas/httpsfv" ) type Signer interface { @@ -149,7 +151,7 @@ type signer struct { } func (s *signer) Sign(msg *Message) (http.Header, error) { - params, err := s.signatureParameters(msg.Context) + params, err := s.signatureInput(msg.Context) if err != nil { return nil, err } @@ -173,34 +175,39 @@ func (s *signer) Sign(msg *Message) (http.Header, error) { return nil, err } - return msg.addSignature(s.label, signature, params.InnerList) + return msg.addSignature(s.label, signature, params.value) } -func (s *signer) signatureParameters(ctx context.Context) (*signatureInput, error) { - var ( - created time.Time - expires time.Time - nonce string - err error - ) +func (s *signer) signatureInput(ctx context.Context) (*signatureInput, error) { + created := currentTime().UTC() + + nonce, err := s.ng.GetNonce(ctx) + if err != nil { + return nil, err + } + + params := httpsfv.NewParams() + params.Add(string(Created), created.Unix()) - created = currentTime().UTC() if s.ttl > 0 { - expires = created.Add(s.ttl) + params.Add(string(Expires), created.Add(s.ttl).Unix()) } - nonce, err = s.ng.GetNonce(ctx) - if err != nil { - return nil, err + if keyID := s.ps.keyID(); keyID != "" { + params.Add(string(KeyID), keyID) + } + + if alg := filterAlgorithm(s.ps.algorithm()); alg != "" { + params.Add(string(Alg), string(alg)) + } + + if len(nonce) != 0 { + params.Add(string(Nonce), nonce) + } + + if len(s.tag) != 0 { + params.Add(string(Tag), s.tag) } - return newSignatureInput( - created, - expires, - nonce, - s.ps.keyID(), - s.tag, - filterAlgorithm(s.ps.algorithm()), - s.ids, - ), nil + return newSignatureInput(s.ids, params), nil } diff --git a/verifier.go b/verifier.go index 70d1c0d..47658fc 100644 --- a/verifier.go +++ b/verifier.go @@ -278,9 +278,9 @@ type expectations struct { reqExpiresTS *bool } -//nolint:cyclop +// nolint: funlen, cyclop func (e *expectations) assert( - params *signatureInput, + si *signatureInput, msg *Message, keyAlg SignatureAlgorithm, nc NonceChecker, @@ -293,9 +293,9 @@ func (e *expectations) assert( nonce := NonceValue{} - nonceValue, noncePresent := params.Params.Get(string(Nonce)) + nonceValue, noncePresent := si.nonce() if noncePresent { - nonce.Value = nonceValue.(string) //nolint: forcetypeassert + nonce.Value = nonceValue nonce.Present = true } @@ -303,37 +303,40 @@ func (e *expectations) assert( return fmt.Errorf("%w: nonce validation failed: %w", ErrParameter, err) } - if len(params.alg) != 0 && params.alg != keyAlg { + algorithm, algPresent := si.algorithm() + if algPresent && algorithm != keyAlg { return fmt.Errorf("%w: key algorithm %s does not match signature algorithm %s", - ErrParameter, params.alg, keyAlg) + ErrParameter, algorithm, keyAlg) } now := currentTime().UTC() - if params.expires.Equal(time.Time{}) { + expires, expiresPresent := si.expires() + if !expiresPresent { if *e.reqExpiresTS { return fmt.Errorf("%w: expected expires parameter not present", ErrMissingParameter) } - } else if now.After(params.expires.Add(e.tolerance)) { + } else if now.After(expires.Add(e.tolerance)) { return fmt.Errorf("%w: signature expired", ErrValidity) } - if params.created.Equal(time.Time{}) { + created, createdPresent := si.created() + if !createdPresent { if *e.reqCreatedTS { return fmt.Errorf("%w: expected created parameter not present", ErrMissingParameter) } } else { - if now.Before(params.created.Add(-1 * e.tolerance)) { + if now.Before(created.Add(-1 * e.tolerance)) { return fmt.Errorf("%w: signature not yet valid", ErrValidity) } - if params.created.Add(e.maxAge).Before(now) { + if created.Add(e.maxAge).Before(now) { return fmt.Errorf("%w: signature too old", ErrValidity) } } for _, expIdentifier := range e.identifiers { - if !params.hasIdentifier(expIdentifier) { + if !si.hasIdentifier(expIdentifier) { res, _ := httpsfv.Marshal(expIdentifier) missingComponents = append(missingComponents, res) } @@ -344,7 +347,7 @@ func (e *expectations) assert( ErrMissingParameter, strings.Join(missingComponents, ", ")) } - for _, id := range params.identifiers { + for _, id := range si.identifiers { if id.Value == "content-digest" { _, fromReq := id.Params.Get("req") @@ -392,7 +395,9 @@ func (v *verifier) Verify(msg *Message) error { // do the actual verification for name, params := range applicableSignatures { - exp, exists := v.tagExpectations[params.tag] + tag, _ := params.tag() + + exp, exists := v.tagExpectations[tag] if !exists { exp = v.tagExpectations[""] } @@ -417,7 +422,8 @@ func (v *verifier) Verify(msg *Message) error { func (v *verifier) applicableSignatures(refs map[string]*signatureInput) (map[string]*signatureInput, error) { for name, params := range refs { - if !v.isApplicable(params.tag) { + tag, tagPresent := params.tag() + if tagPresent && !v.isApplicable(tag) { delete(refs, name) } } @@ -457,7 +463,8 @@ func (v *verifier) hasMissingSignatures(sigRefs map[string]*signatureInput) bool var present bool for _, sigRef := range sigRefs { - if sigRef.tag == sigTag { + tag, tagPresent := sigRef.tag() + if tagPresent && tag == sigTag { present = true break @@ -475,20 +482,22 @@ func (v *verifier) hasMissingSignatures(sigRefs map[string]*signatureInput) bool func (v *verifier) verifySignature( msg *Message, signature []byte, - params *signatureInput, + si *signatureInput, exp *expectations, ) error { - base, err := newSignatureBase(params, msg) + base, err := newSignatureBase(si, msg) if err != nil { return err } - key, err := v.keyResolver.ResolveKey(msg.Context, params.keyID) + keyID, _ := si.keyID() + + key, err := v.keyResolver.ResolveKey(msg.Context, keyID) if err != nil { return err } - if err = exp.assert(params, msg, key.Algorithm, v.nonceChecker); err != nil { + if err = exp.assert(si, msg, key.Algorithm, v.nonceChecker); err != nil { return err } @@ -514,8 +523,6 @@ func getSignatureReferences(values []string) (map[string]*signatureInput, error) sigRefs := make(map[string]*signatureInput, len(inputDict.Names())) for _, label := range inputDict.Names() { - var sp signatureInput - m, _ := inputDict.Get(label) sigParams, ok := m.(httpsfv.InnerList) @@ -523,11 +530,12 @@ func getSignatureReferences(values []string) (map[string]*signatureInput, error) return nil, fmt.Errorf("%w: unexpected signature parameters format", ErrMalformedData) } - if err := sp.fromInnerList(sigParams); err != nil { + si, err := parseSignatureInput(sigParams) + if err != nil { return nil, fmt.Errorf("%w: %w", ErrMalformedData, err) } - sigRefs[label] = &sp + sigRefs[label] = si } return sigRefs, nil diff --git a/verifier_test.go b/verifier_test.go index 11bfb14..8b561c1 100644 --- a/verifier_test.go +++ b/verifier_test.go @@ -411,17 +411,15 @@ func TestExpectationsAssertParameters(t *testing.T) { }, } { t.Run(tc.uc, func(t *testing.T) { - var params signatureInput - msg := &Message{Context: context.TODO()} - err := params.fromInnerList(tc.params) + si, err := parseSignatureInput(tc.params) require.NoError(t, err) nc := NewNonceCheckerMock(t) tc.configure(t, nc) - err = tc.exp.assert(¶ms, msg, tc.expAlg, nc) + err = tc.exp.assert(si, msg, tc.expAlg, nc) tc.assert(t, err) }) From 5c76a4aa2b9a44c2dd949c16baed61048901eb94 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Tue, 20 Oct 2026 11:47:27 +0200 Subject: [PATCH 3/5] lookup of applicable signatures refactored --- verifier.go | 22 +++++---- verifier_test.go | 122 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 134 insertions(+), 10 deletions(-) diff --git a/verifier.go b/verifier.go index 47658fc..d7d6f70 100644 --- a/verifier.go +++ b/verifier.go @@ -421,10 +421,18 @@ func (v *verifier) Verify(msg *Message) error { } func (v *verifier) applicableSignatures(refs map[string]*signatureInput) (map[string]*signatureInput, error) { - for name, params := range refs { - tag, tagPresent := params.tag() - if tagPresent && !v.isApplicable(tag) { - delete(refs, name) + if !v.validateAllSigs { + for name, input := range refs { + tag, present := input.tag() + if !present { + delete(refs, name) + + continue + } + + if _, required := v.tagExpectations[tag]; !required { + delete(refs, name) + } } } @@ -559,9 +567,3 @@ func (v *verifier) extractSignature(dict *httpsfv.Dictionary, name string) ([]by return signatureBytes, nil } - -func (v *verifier) isApplicable(tag string) bool { - _, hasKey := v.tagExpectations[tag] - - return v.validateAllSigs || hasKey -} diff --git a/verifier_test.go b/verifier_test.go index 8b561c1..9a37a2b 100644 --- a/verifier_test.go +++ b/verifier_test.go @@ -1566,3 +1566,125 @@ func TestVerifierVerify(t *testing.T) { }) } } + +func TestVerifierApplicableSignatures(t *testing.T) { + t.Parallel() + + withTag := func(tag string) *signatureInput { + params := httpsfv.NewParams() + params.Add(string(Tag), tag) + + return newSignatureInput(nil, params) + } + + for uc, tc := range map[string]struct { + verifier verifier + refs map[string]*signatureInput + assert func(t *testing.T, err error, refs map[string]*signatureInput) + }{ + "only required signatures are applicable": { + verifier: verifier{ + tagExpectations: map[string]*expectations{"foo": {}}, + }, + refs: map[string]*signatureInput{ + "matching": withTag("foo"), + "other": withTag("bar"), + "empty": withTag(""), + "untagged": newSignatureInput(nil, nil), + }, + assert: func(t *testing.T, err error, refs map[string]*signatureInput) { + t.Helper() + + require.NoError(t, err) + require.Len(t, refs, 1) + assert.Contains(t, refs, "matching") + }, + }, + "no matching signature": { + verifier: verifier{ + tagExpectations: map[string]*expectations{"foo": {}}, + }, + refs: map[string]*signatureInput{ + "other": withTag("bar"), + }, + assert: func(t *testing.T, err error, refs map[string]*signatureInput) { + t.Helper() + + require.ErrorIs(t, err, &NoApplicableSignatureError{}) + assert.Nil(t, refs) + }, + }, + "missing tag": { + verifier: verifier{ + tagExpectations: map[string]*expectations{"foo": {}}, + }, + refs: map[string]*signatureInput{ + "untagged": newSignatureInput(nil, nil), + }, + assert: func(t *testing.T, err error, refs map[string]*signatureInput) { + t.Helper() + + require.ErrorIs(t, err, &NoApplicableSignatureError{}) + assert.Nil(t, refs) + }, + }, + "all signatures are applicable": { + verifier: verifier{ + validateAllSigs: true, + }, + refs: map[string]*signatureInput{ + "tagged": withTag("foo"), + "empty": withTag(""), + "untagged": newSignatureInput(nil, nil), + }, + assert: func(t *testing.T, err error, refs map[string]*signatureInput) { + t.Helper() + + require.NoError(t, err) + assert.Len(t, refs, 3) + assert.Contains(t, refs, "tagged") + assert.Contains(t, refs, "empty") + assert.Contains(t, refs, "untagged") + }, + }, + "validate all with required tag": { + verifier: verifier{ + validateAllSigs: true, + tagExpectations: map[string]*expectations{"foo": {}}, + }, + refs: map[string]*signatureInput{ + "matching": withTag("foo"), + "other": withTag("bar"), + "untagged": newSignatureInput(nil, nil), + }, + assert: func(t *testing.T, err error, refs map[string]*signatureInput) { + t.Helper() + + require.NoError(t, err) + assert.Len(t, refs, 3) + assert.Contains(t, refs, "matching") + assert.Contains(t, refs, "other") + assert.Contains(t, refs, "untagged") + }, + }, + "no signatures": { + verifier: verifier{ + validateAllSigs: true, + }, + assert: func(t *testing.T, err error, refs map[string]*signatureInput) { + t.Helper() + + require.ErrorIs(t, err, &NoApplicableSignatureError{}) + assert.Nil(t, refs) + }, + }, + } { + t.Run(uc, func(t *testing.T) { + v := tc.verifier + + refs, err := v.applicableSignatures(tc.refs) + + tc.assert(t, err, refs) + }) + } +} From 71b6d4130c4efea315f307aa4d503d4158859ae9 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Tue, 20 Oct 2026 11:49:51 +0200 Subject: [PATCH 4/5] more tests --- verifier_test.go | 63 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/verifier_test.go b/verifier_test.go index 9a37a2b..94e0600 100644 --- a/verifier_test.go +++ b/verifier_test.go @@ -1553,6 +1553,69 @@ func TestVerifierVerify(t *testing.T) { require.NoError(t, err) }, }, + { + uc: "invalid untagged signature is ignored", + opts: []VerifierOption{ + WithRequiredTag("foo"), + WithExpiredTimestampRequired(false), + }, + msg: &Message{ + Header: http.Header{ + "Signature-Input": []string{ + `valid=();created=1618884473;keyid="test-shared-secret";tag="foo", ` + + `invalid=();created=1618884473;keyid="test-shared-secret"`, + }, + "Signature": []string{ + `valid=:VhBIZ0nP4o+r4bSKCvC+gc0VI1yVhhN1PECWW8ZF2Dg=:, ` + + `invalid=:dGVzdA==:`, + }, + }, + }, + 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() + }, + assert: func(t *testing.T, err error) { + t.Helper() + + require.NoError(t, err) + }, + }, + { + uc: "invalid untagged signature fails when validating all", + opts: []VerifierOption{ + WithValidateAllSignatures(), + WithExpiredTimestampRequired(false), + }, + msg: &Message{ + Header: http.Header{ + "Signature-Input": []string{ + `valid=();created=1618884473;keyid="test-shared-secret";tag="foo", ` + + `invalid=();created=1618884473;keyid="test-shared-secret"`, + }, + "Signature": []string{ + `valid=:VhBIZ0nP4o+r4bSKCvC+gc0VI1yVhhN1PECWW8ZF2Dg=:, ` + + `invalid=:dGVzdA==:`, + }, + }, + }, + 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, + ) + }, + assert: func(t *testing.T, err error) { + t.Helper() + + require.ErrorIs(t, err, ErrVerificationFailed) + require.ErrorIs(t, err, ErrInvalidSignature) + }, + }, } { t.Run(tc.uc, func(t *testing.T) { kr := NewKeyResolverMock(t) From db72bcc12e2344e19968e6b9f28a423916ff8cf7 Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Tue, 20 Oct 2026 11:54:02 +0200 Subject: [PATCH 5/5] linter warnings resolved --- signature_input.go | 4 ++-- signature_input_test.go | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/signature_input.go b/signature_input.go index 4a42beb..3209d55 100644 --- a/signature_input.go +++ b/signature_input.go @@ -105,7 +105,7 @@ func (si *signatureInput) stringParameter(name SignatureParameter) (string, bool return "", false } - return value.(string), true + return value.(string), true //nolint: forcetypeassert } func (si *signatureInput) timestamp(name SignatureParameter) (time.Time, bool) { @@ -114,7 +114,7 @@ func (si *signatureInput) timestamp(name SignatureParameter) (time.Time, bool) { return time.Time{}, false } - return time.Unix(value.(int64), 0).UTC(), true + return time.Unix(value.(int64), 0).UTC(), true //nolint: forcetypeassert } func (si *signatureInput) algorithm() (SignatureAlgorithm, bool) { diff --git a/signature_input_test.go b/signature_input_test.go index 5279d6b..fcbf896 100644 --- a/signature_input_test.go +++ b/signature_input_test.go @@ -710,6 +710,7 @@ func TestSignatureInputTag(t *testing.T) { params: func() *httpsfv.Params { params := httpsfv.NewParams() params.Add(string(Tag), "web-bot-auth") + return params }(), expected: "web-bot-auth",