No alg parameter for JWS, and verify Date header

Author: yaronf

config.go

@@ -79,6 +79,7 @@ type VerifyConfig struct {
 	rejectExpired   bool
 	requestResponse *requestResponse
 	verifyKeyID     bool
+	dateWithin      time.Duration
 }
 
 // SetNotNewerThan sets the window for messages that appear to be newer than the current time,
@@ -136,6 +137,15 @@ func (v *VerifyConfig) SetVerifyKeyID(verify bool) *VerifyConfig {
 	return v
 }
 
+// SetVerifyDateWithin indicates that the Date header should be verified if it exists, and its value
+// must be within a certain time duration (positive or negative) of the Created signature parameter.
+// This verification is only available if the Created field itself is verified.
+// Default: 0, meaning no verification of the Date header.
+func (v *VerifyConfig) SetVerifyDateWithin(d time.Duration) *VerifyConfig {
+	v.dateWithin = d
+	return v
+}
+
 // NewVerifyConfig generates a default configuration.
 func NewVerifyConfig() *VerifyConfig {
 	return &VerifyConfig{
@@ -145,6 +155,7 @@ func NewVerifyConfig() *VerifyConfig {
 		rejectExpired: true,
 		allowedAlgs:   []string{},
 		verifyKeyID:   true,
+		dateWithin:    0, // meaning no constraint
 	}
 }
 

crypto.go

@@ -149,7 +149,7 @@ func NewJWSSigner(alg jwa.SignatureAlgorithm, keyID string, key interface{}, con
 	return &Signer{
 		keyID:         keyID,
 		key:           key,
-		alg:           string(alg),
+		alg:           "",
 		config:        config,
 		fields:        fields,
 		foreignSigner: jwsSigner,
@@ -332,7 +332,7 @@ func NewJWSVerifier(alg jwa.SignatureAlgorithm, key interface{}, keyID string, c
 	return &Verifier{
 		keyID:           keyID,
 		key:             key,
-		alg:             string(alg),
+		alg:             "",
 		config:          config,
 		fields:          fields,
 		foreignVerifier: verifier,

crypto_test.go

@@ -279,7 +279,7 @@ func TestNewJWSVerifier(t *testing.T) {
 			want: &Verifier{
 				keyID:           "key200",
 				key:             "1234",
-				alg:             "HS256",
+				alg:             "",
 				config:          NewVerifyConfig(),
 				fields:          *NewFields(),
 				foreignVerifier: verifier,

go.mod

@@ -6,9 +6,11 @@ require (
 	github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883
 	github.com/dunglas/httpsfv v0.1.1
 	github.com/lestrrat-go/jwx v1.2.18
+	github.com/stretchr/testify v1.7.0
 )
 
 require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.0-20210816181553-5444fa50b93d // indirect
 	github.com/goccy/go-json v0.9.4 // indirect
 	github.com/lestrrat-go/backoff/v2 v2.0.8 // indirect
@@ -17,6 +19,8 @@ require (
 	github.com/lestrrat-go/iter v1.0.1 // indirect
 	github.com/lestrrat-go/option v1.0.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/sergi/go-diff v1.2.0 // indirect
 	golang.org/x/crypto v0.0.0-20201217014255-9d1352758620 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
 )

go.sum

@@ -10,8 +10,10 @@ github.com/dunglas/httpsfv v0.1.1 h1:iV2PWNlj9Qbk+5I3fxPDJPTh9eM0rskrI1qdUVUNK1E
 github.com/dunglas/httpsfv v0.1.1/go.mod h1:zID2mqw9mFsnt7YC3vYQ9/cjq30q41W+1AnDwH8TiMg=
 github.com/goccy/go-json v0.9.4 h1:L8MLKG2mvVXiQu07qB6hmfqeSYQdOnqPot2GhsIwIaI=
 github.com/goccy/go-json v0.9.4/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/lestrrat-go/backoff/v2 v2.0.8 h1:oNb5E5isby2kiro9AgdHLv5N5tint1AnDVVf2E2un5A=
 github.com/lestrrat-go/backoff/v2 v2.0.8/go.mod h1:rHP/q/r9aT27n24JQLa7JhSQZCKBBOiM/uP402WwN8Y=
@@ -46,6 +48,7 @@ golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

handler_test.go

@@ -3,6 +3,7 @@ package httpsign
 import (
 	"bytes"
 	"fmt"
+	"github.com/stretchr/testify/assert"
 	"io"
 	"log"
 	"net/http"
@@ -38,29 +39,19 @@ func Test_WrapHandler(t *testing.T) {
 
 	signer, err := NewHMACSHA256Signer("key", bytes.Repeat([]byte{1}, 64), nil,
 		Headers("@method"))
-	if err != nil {
-		t.Errorf("%v", err)
-	}
+	assert.NoError(t, err)
 
 	verifier, err := NewHMACSHA256Verifier("key", bytes.Repeat([]byte{0}, 64), NewVerifyConfig(), *NewFields())
-	if err != nil {
-		t.Errorf("%v", err)
-	}
+	assert.NoError(t, err)
 	client := NewDefaultClient("sig1", signer, verifier, nil)
 	res, err := client.Get(ts.URL)
-	if err != nil {
-		t.Errorf("%v", err)
-	}
+	assert.NoError(t, err)
 	if res != nil {
 		_, err = io.ReadAll(res.Body)
 		_ = res.Body.Close()
-		if err != nil {
-			t.Errorf("%v", err)
-		}
+		assert.NoError(t, err)
 
-		if res.Status != "200 OK" {
-			t.Errorf("Bad status returned")
-		}
+		assert.Equal(t, res.Status, "200 OK", "Bad status returned")
 	}
 }
 
@@ -199,11 +190,7 @@ func TestWrapHandlerServerFails(t *testing.T) { // non-default verify handler
 
 	// Send an HTTP GET, get response -- signing and verification happen behind the scenes
 	res, err := client.Get(ts.URL)
-	if err != nil {
-		t.Errorf("Get failed: %s", err)
-	}
+	assert.NoError(t, err, "Get failed")
 
-	if res.StatusCode != 599 {
-		t.Errorf("Verification did not fail?")
-	}
+	assert.Equal(t, res.StatusCode, 599, "Verification did not fail?")
 }

httpparse.go

@@ -55,7 +55,8 @@ func parseResponse(res *http.Response) (*parsedMessage, error) {
 		return nil, err
 	}
 
-	return &parsedMessage{derived: generateResDerivedComponents(res), url: nil, headers: normalizeHeaderNames(res.Header)}, nil
+	return &parsedMessage{derived: generateResDerivedComponents(res), url: nil,
+		headers: normalizeHeaderNames(res.Header)}, nil
 }
 
 func validateMessageHeaders(header http.Header) error {

signatures.go

@@ -389,7 +389,7 @@ func verifyMessage(config VerifyConfig, name string, verifier Verifier, message
 	if !(psiSig.fields.contains(&fields)) {
 		return "", fmt.Errorf("actual signature does not cover all required fields")
 	}
-	err = applyVerificationPolicy(verifier, psiSig, config)
+	err = applyVerificationPolicy(verifier, message, psiSig, config)
 	if err != nil {
 		return "", err
 	}
@@ -400,8 +400,8 @@ func verifyMessage(config VerifyConfig, name string, verifier Verifier, message
 	return signatureInput, verifySignature(verifier, signatureInput, wantSigRaw)
 }
 
-func applyVerificationPolicy(verifier Verifier, psi *psiSignature, config VerifyConfig) error {
-	err := applyPolicyCreated(psi, config)
+func applyVerificationPolicy(verifier Verifier, message parsedMessage, psi *psiSignature, config VerifyConfig) error {
+	err := applyPolicyCreated(psi, message, config)
 	if err != nil {
 		return err
 	}
@@ -477,7 +477,10 @@ func applyPolicyAlgs(psi *psiSignature, config VerifyConfig) error {
 	return nil
 }
 
-func applyPolicyCreated(psi *psiSignature, config VerifyConfig) error {
+func applyPolicyCreated(psi *psiSignature, message parsedMessage, config VerifyConfig) error {
+	if !config.verifyCreated && config.dateWithin != 0 {
+		return fmt.Errorf("cannot verify Date header if Created parameter is not verified")
+	}
 	if config.verifyCreated {
 		now := time.Now()
 		createdParam, ok := psi.params["created"]
@@ -495,6 +498,23 @@ func applyPolicyCreated(psi *psiSignature, config VerifyConfig) error {
 		if createdTime.Add(config.notOlderThan).Before(now) {
 			return fmt.Errorf("message is too old, check for replay")
 		}
+
+		if config.dateWithin != 0 {
+			dateHdr, ok := message.headers["date"]
+			if ok {
+				if len(dateHdr) > 1 {
+					return fmt.Errorf("multiple Date headers?")
+				}
+				date, err := http.ParseTime(dateHdr[0])
+				if err != nil {
+					return fmt.Errorf("cannot parse Date header: %w", err)
+				}
+				if createdTime.After(date.Add(config.dateWithin)) ||
+					date.After(createdTime.Add(config.dateWithin)) {
+					return fmt.Errorf("the Date header is not within time window of Created parameter")
+				}
+			}
+		}
 	}
 	return nil
 }

signatures_test.go

@@ -14,6 +14,7 @@ import (
 	"encoding/base64"
 	"encoding/pem"
 	"fmt"
+	"github.com/stretchr/testify/assert"
 	"net/http"
 	"strings"
 	"testing"
@@ -549,9 +550,7 @@ func TestSignRequest(t *testing.T) {
 
 func makeRSAPSSSigner(t *testing.T, config SignConfig, fields Fields) Signer {
 	prvKey, err := loadRSAPSSPrivateKey(rsaPSSPrvKey)
-	if err != nil {
-		t.Errorf("cannot parse private key: %v", err)
-	}
+	assert.NoError(t, err, "cannot parse private key")
 	signer, _ := NewRSAPSSSigner("test-key-rsa-pss", *prvKey, &config, fields)
 	return *signer
 }
@@ -637,13 +636,9 @@ func TestSignAndVerifyHMAC(t *testing.T) {
 	req.Header.Add("Signature", sig)
 	req.Header.Add("Signature-Input", sigInput)
 	verifier, err := NewHMACSHA256Verifier("test-shared-secret", key, NewVerifyConfig().SetVerifyCreated(false), fields)
-	if err != nil {
-		t.Errorf("could not generate Verifier: %s", err)
-	}
+	assert.NoError(t, err, "could not generate Verifier")
 	err = VerifyRequest(signatureName, *verifier, req)
-	if err != nil {
-		t.Errorf("verification error: %s", err)
-	}
+	assert.NoError(t, err, "verification error")
 }
 
 func TestSignAndVerifyHMACBad(t *testing.T) {
@@ -658,13 +653,9 @@ func TestSignAndVerifyHMACBad(t *testing.T) {
 	req.Header.Add("Signature-Input", sigInput)
 	badkey := append(key, byte(0x77))
 	verifier, err := NewHMACSHA256Verifier("test-shared-secret", badkey, NewVerifyConfig().SetVerifyCreated(false), fields)
-	if err != nil {
-		t.Errorf("could not generate Verifier: %s", err)
-	}
+	assert.NoError(t, err, "could not generate Verifier")
 	err = VerifyRequest(signatureName, *verifier, req)
-	if err == nil {
-		t.Errorf("verification should have failed")
-	}
+	assert.Error(t, err, "verification should have failed")
 }
 
 func TestCreated(t *testing.T) {
@@ -675,16 +666,20 @@ func TestCreated(t *testing.T) {
 		signConfig := NewSignConfig().SignCreated(true).setFakeCreated(createdTime)
 		signer, _ := NewHMACSHA256Signer("test-shared-secret", key, signConfig, fields)
 		res := readResponse(httpres2)
+		nowStr := time.Now().UTC().Format(http.TimeFormat)
+		res.Header.Set("Date", nowStr)
 		sigInput, sig, _ := SignResponse(signatureName, *signer, res)
 
 		res2 := readResponse(httpres2)
+		res2.Header.Set("Date", nowStr)
 		res2.Header.Add("Signature", sig)
 		res2.Header.Add("Signature-Input", sigInput)
 		verifier, err := NewHMACSHA256Verifier("test-shared-secret", key, verifyConfig, fields)
 		if err != nil {
 			t.Errorf("could not generate Verifier: %s", err)
 		}
 		err = VerifyResponse(signatureName, *verifier, res2)
+
 		if wantSuccess && err != nil {
 			t.Errorf("verification error: %s", err)
 		}
@@ -711,13 +706,21 @@ func TestCreated(t *testing.T) {
 	testNewWindow2 := func(t *testing.T) {
 		testOnceWithConfig(t, now+15_000, NewVerifyConfig().SetNotNewerThan(14_000*time.Second), false)
 	}
+	testDate := func(t *testing.T) {
+		testOnceWithConfig(t, now, NewVerifyConfig().SetVerifyDateWithin(100*time.Millisecond), true)
+	}
+	testDateFail := func(t *testing.T) {
+		testOnceWithConfig(t, now, NewVerifyConfig().SetVerifyCreated(false).SetVerifyDateWithin(100*time.Millisecond), false)
+	}
 	t.Run("in window", testInWindow)
 	t.Run("older", testOlder)
 	t.Run("newer", testNewer)
 	t.Run("older, smaller than window", testOldWindow1)
 	t.Run("older, larger than window", testOldWindow2)
 	t.Run("newer, smaller than window", testNewWindow1)
 	t.Run("newer, larger than window", testNewWindow2)
+	t.Run("verify Date header within window", testDate)
+	t.Run("verify logic requires to verify Created", testDateFail)
 }
 
 func TestSignAndVerifyResponseHMAC(t *testing.T) {