Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 5 additions & 5 deletions signature_base.go
Original file line number Diff line number Diff line change
Expand Up @@ -10,16 +10,16 @@ import (

type signatureBase []component

func newSignatureBase(params *signatureParameters, 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
Expand Down
8 changes: 6 additions & 2 deletions signature_base_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -132,9 +132,13 @@ func TestNewSignatureBase(t *testing.T) {
identifiers, err := toComponentIdentifiers(tc.components)
require.NoError(t, err)

params := newSignatureParameters(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)
})
Expand Down
130 changes: 130 additions & 0 deletions signature_input.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,130 @@
package httpsig

import (
"fmt"
"slices"
"time"

"github.com/dunglas/httpsfv"
)

type signatureInput struct {
value httpsfv.InnerList
identifiers []*componentIdentifier
}

func newSignatureInput(
identifiers []*componentIdentifier,
params *httpsfv.Params,
) *signatureInput {
// https://www.rfc-editor.org/rfc/rfc9421.html#name-signature-parameters
if params == nil {
params = httpsfv.NewParams()
}

items := make([]httpsfv.Item, len(identifiers))
for i, id := range identifiers {
items[i] = id.Item
}

return &signatureInput{
value: httpsfv.InnerList{
Items: items,
Params: params,
},
identifiers: identifiers,
}
}

func parseSignatureInput(list httpsfv.InnerList) (*signatureInput, error) {
identifiers := make([]*componentIdentifier, 0, len(list.Items))

for _, item := range list.Items {
identifier, err := newComponentIdentifier(item)
if err != nil {
return nil, err
}

identifiers = append(identifiers, identifier)
}

if err := validateSignatureInputParameters(list.Params); err != nil {
return nil, err
}

return &signatureInput{
value: list,
identifiers: identifiers,
}, nil
}

func validateSignatureInputParameters(params *httpsfv.Params) error {
if params == nil {
return nil
}

for _, name := range params.Names() {
value, _ := params.Get(name)

switch SignatureParameter(name) {
case Created, Expires:
if _, ok := value.(int64); !ok {
return fmt.Errorf("%w: %s", ErrMalformedSignatureParameter, name)
}
case KeyID, Alg, Nonce, Tag:
if _, ok := value.(string); !ok {
return fmt.Errorf("%w: %s", ErrMalformedSignatureParameter, name)
}
}
}

return nil
}

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
}
}

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 //nolint: forcetypeassert
}

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 //nolint: forcetypeassert
}

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) }
Loading
Loading