jws: added JWS validation and Parsing + tests
diff --git a/.tags b/.tags
new file mode 100644
index 0000000..d01d39b
--- /dev/null
+++ b/.tags
@@ -0,0 +1,6 @@
+!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME Exuberant Ctags //
+!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/
+!_TAG_PROGRAM_VERSION 5.8 //
diff --git a/base64.go b/base64.go
index 1956791..6be62b8 100644
--- a/base64.go
+++ b/base64.go
@@ -5,7 +5,7 @@
// Encoder is satisfied if the type can marshal itself into a valid
// structure for a JWS.
type Encoder interface {
- // Base64 implies -> JSON -> Base64
+ // Base64 implies T -> JSON -> Base64
Base64() ([]byte, error)
}
diff --git a/header.go b/header.go
index ef58feb..b5fc9e8 100644
--- a/header.go
+++ b/header.go
@@ -47,6 +47,30 @@
return h.MarshalJSON()
}
+// UnmarshalJSON implements json.Unmarshaler for Header.
+func (h *Header) UnmarshalJSON(b []byte) error {
+ if b == nil {
+ return nil
+ }
+
+ b, err := DecodeEscaped(b)
+ if err != nil {
+ return err
+ }
+
+ // Since json.Unmarshal calls UnmarshalJSON,
+ // calling json.Unmarshal on *p would be infinitely recursive
+ // A temp variable is needed because &map[string]interface{}(*p) is
+ // invalid Go.
+
+ tmp := map[string]interface{}(*h)
+ if err = json.Unmarshal(b, &tmp); err != nil {
+ return err
+ }
+ *h = Header(tmp)
+ return nil
+}
+
// Protected Headers are base64-encoded after they're marshaled into
// JSON.
type Protected Header
@@ -96,20 +120,9 @@
// UnmarshalJSON implements json.Unmarshaler for Protected.
func (p *Protected) UnmarshalJSON(b []byte) error {
- b, err := DecodeEscaped(b)
- if err != nil {
- return err
- }
-
- // Since json.Unmarshal calls UnmarshalJSON,
- // calling json.Unmarshal on *p would be infinitely recursive
- // A temp variable is needed because &Header(*p) is invalid Go.
-
- tmp := map[string]interface{}(*p)
- if err = json.Unmarshal(b, &tmp); err != nil {
- return err
- }
- *p = Protected(tmp)
+ var h Header
+ h.UnmarshalJSON(b)
+ *p = Protected(h)
return nil
}
diff --git a/jws/ecdsa.go b/jws/ecdsa.go
index 21a6328..ce46b47 100644
--- a/jws/ecdsa.go
+++ b/jws/ecdsa.go
@@ -104,8 +104,10 @@
func (m *SigningMethodECDSA) Hasher() crypto.Hash { return m.Hash }
// MarshalJSON is in case somebody decides to place SigningMethodECDSA
-// inside the Claims in the "alg" portion. In order to keep things sane,
-// marshalling this will do the same thing as jws.SetProtected("alg", m.Alg())
+// inside the Header, presumably because they (wrongly) decided it was a good
+// idea to use the SigningMethod itself instead of the SigningMethod's Alg
+// method. In order to keep things sane, marshalling this will simply
+// return the JSON-compatible representation of m.Alg().
func (m *SigningMethodECDSA) MarshalJSON() ([]byte, error) {
return []byte(`"` + m.Alg() + `"`), nil
}
diff --git a/jws/errors.go b/jws/errors.go
index 6c792a2..2d48368 100644
--- a/jws/errors.go
+++ b/jws/errors.go
@@ -14,4 +14,39 @@
// ErrCouldNotUnmarshal is returned when Parse's json.Unmarshaler
// parameter returns an error.
ErrCouldNotUnmarshal = errors.New("custom unmarshal failed")
+
+ // ErrNotCompact signals that the provided potential JWS is not
+ // in its compact representation.
+ ErrNotCompact = errors.New("not a compact JWS")
+
+ // ErrDuplicateHeaderParameter signals that there are duplicate parameters
+ // in the provided Headers.
+ ErrDuplicateHeaderParameter = errors.New("duplicate parameters in the JOSE Header")
+
+ // ErrTwoEmptyHeaders is returned if both Headers are empty.
+ ErrTwoEmptyHeaders = errors.New("both headers cannot be empty")
+
+ // ErrNotEnoughKeys is returned when not enough keys are provided for
+ // the given SigningMethods.
+ ErrNotEnoughKeys = errors.New("not enough keys (for given methods)")
+
+ // ErrDidNotValidate means the given JWT did not properly validate
+ ErrDidNotValidate = errors.New("did not validate")
+
+ // ErrNoAlgorithm means no algorithm ("alg") was found in the Protected
+ // Header.
+ ErrNoAlgorithm = errors.New("no algorithm found")
+
+ // ErrAlgorithmDoesntExist means the algorithm asked for cannot be
+ // found inside the signingMethod cache.
+ ErrAlgorithmDoesntExist = errors.New("algorithm doesn't exist")
+
+ // ErrMismatchedAlgorithms means the algorithm inside the JWT was
+ // different than the algorithm the caller wanted to use.
+ ErrMismatchedAlgorithms = errors.New("mismatched algorithms")
+
+ // ErrCannotValidate means the JWS cannot be validated for various
+ // reasons. For example, if there aren't any signatures/payloads/headers
+ // to actually validate.
+ ErrCannotValidate = errors.New("cannot validate")
)
diff --git a/jws/jws.go b/jws/jws.go
index de0f355..4147d37 100644
--- a/jws/jws.go
+++ b/jws/jws.go
@@ -1,8 +1,9 @@
package jws
import (
+ "bytes"
"encoding/json"
- "fmt"
+ "sort"
"github.com/SermoDigital/jose"
)
@@ -13,8 +14,7 @@
plcache rawBase64
clean bool
- sb []sigHead
- methods []SigningMethod
+ sb []sigHead
}
// sigHead represents the 'signatures' member of the JWS' "general"
@@ -31,6 +31,18 @@
protected jose.Protected `json:"-"`
unprotected jose.Header `json:"-"`
clean bool `json:"-"`
+
+ method SigningMethod
+}
+
+func (s *sigHead) unmarshal() error {
+ if err := s.protected.UnmarshalJSON(s.Protected); err != nil {
+ return err
+ }
+ if err := s.unprotected.UnmarshalJSON(s.Unprotected); err != nil {
+ return err
+ }
+ return nil
}
// New creates a new JWS with the provided SigningMethods.
@@ -41,16 +53,31 @@
protected: jose.Protected{
"alg": methods[i].Alg(),
},
- unprotected: make(jose.Header),
+ unprotected: jose.Header{},
+ method: methods[i],
}
}
return &JWS{
payload: &payload{v: content},
sb: sb,
- methods: methods,
}
}
+func (s *sigHead) assignMethod(p jose.Protected) error {
+ alg, ok := p.Get("alg").(string)
+ if !ok {
+ return ErrNoAlgorithm
+ }
+
+ sm := GetSigningMethod(alg)
+ if sm == nil {
+ return ErrNoAlgorithm
+ }
+
+ s.method = sm
+ return nil
+}
+
type generic struct {
Payload rawBase64 `json:"payload"`
sigHead
@@ -61,13 +88,9 @@
// JWS per https://tools.ietf.org/html/rfc7515#section-5.2
//
// It accepts a json.Unmarshaler in order to properly parse
-// the payload. The reason for this is sometimes the payload
-// might implement the json.Marshaler interface, and since
-// the JWS' payload member is an interface{}, a simple
-// json.Unmarshal call cannot magically identify the original
-// type. So, in order to keep the caller from having to do extra
-// parsing of the payload, the a json.Unmarshaler can be passed
-// which will be called to unmarshal the payload however the caller
+// the payload. In order to keep the caller from having to do extra
+// parsing of the payload, a json.Unmarshaler can be passed
+// which will be then to unmarshal the payload however the caller
// wishes. Do note that if json.Unmarshal returns an error the
// original payload will be used as if no json.Unmarshaler was
// passed.
@@ -109,29 +132,36 @@
func (g *generic) parseGeneral(u ...json.Unmarshaler) (*JWS, error) {
- var (
- p payload
- err error
- )
-
+ var p payload
if len(u) > 0 {
- if k := u[0]; k.UnmarshalJSON(g.Payload) != nil {
- p.v = u
- err = ErrCouldNotUnmarshal
- }
+ p.u = u[0]
}
- if err != nil {
- fmt.Println(string(g.Payload))
- if err := json.Unmarshal(g.Payload, &p); err != nil {
+ if err := p.UnmarshalJSON(g.Payload); err != nil {
+ return nil, err
+ }
+
+ for i := range g.Signatures {
+ if err := g.Signatures[i].unmarshal(); err != nil {
return nil, err
}
+ if err := checkHeaders(jose.Header(g.Signatures[i].protected), g.Signatures[i].unprotected); err != nil {
+ return nil, err
+ }
+
+ if err := g.Signatures[i].assignMethod(g.Signatures[i].protected); err != nil {
+ return nil, err
+ }
+
+ g.clean = true
}
return &JWS{
payload: &p,
+ plcache: g.Payload,
+ clean: true,
sb: g.Signatures,
- }, err
+ }, nil
}
// ParseFlat parses a JWS serialized into its "flat" form per
@@ -159,8 +189,23 @@
return nil, err
}
+ if err := g.sigHead.unmarshal(); err != nil {
+ return nil, err
+ }
+ g.sigHead.clean = true
+
+ if err := checkHeaders(jose.Header(g.sigHead.protected), g.sigHead.unprotected); err != nil {
+ return nil, err
+ }
+
+ if err := g.sigHead.assignMethod(g.sigHead.protected); err != nil {
+ return nil, err
+ }
+
return &JWS{
payload: &p,
+ plcache: g.Payload,
+ clean: true,
sb: []sigHead{g.sigHead},
}, nil
}
@@ -168,8 +213,136 @@
// ParseCompact parses a JWS serialized into its "compact" form per
// https://tools.ietf.org/html/rfc7515#section-7.1
// into a physical JWS per
-// https://tools.ietf.org/html/rfc7515#section-5.2//
+// https://tools.ietf.org/html/rfc7515#section-5.2
+//
// For information on the json.Unmarshaler parameter, see Parse.
func ParseCompact(encoded []byte, u ...json.Unmarshaler) (*JWS, error) {
- return nil, nil
+
+ parts := bytes.Split(encoded, []byte{'.'})
+ if len(parts) != 3 {
+ return nil, ErrNotCompact
+ }
+
+ var p jose.Protected
+ if err := p.UnmarshalJSON(parts[0]); err != nil {
+ return nil, err
+ }
+
+ s := sigHead{
+ protected: p,
+ clean: true,
+ }
+
+ if err := s.assignMethod(p); err != nil {
+ return nil, err
+ }
+
+ j := JWS{
+ payload: &payload{},
+ sb: []sigHead{s},
+ }
+
+ if err := j.payload.UnmarshalJSON(parts[1]); err != nil {
+ return nil, err
+ }
+
+ j.clean = true
+
+ if err := j.sb[0].Signature.UnmarshalJSON(parts[2]); err != nil {
+ return nil, err
+ }
+
+ return &j, nil
+}
+
+// IgnoreDupes should be set to true if the internal duplicate header key check
+// should ignore duplicate Header keys instead of reporting an error when
+// duplicate Header keys are found.
+//
+// Note: Duplicate Header keys are defined in
+// https://tools.ietf.org/html/rfc7515#section-5.2
+// meaning keys that both the protected and unprotected
+// Headers possess.
+var IgnoreDupes bool
+
+// checkHeaders returns an error per the constraints described in
+// IgnoreDupes' comment.
+func checkHeaders(a, b jose.Header) error {
+ if len(a)+len(b) == 0 {
+ return ErrTwoEmptyHeaders
+ }
+ for key := range a {
+ if b.Has(key) && !IgnoreDupes {
+ return ErrDuplicateHeaderParameter
+ }
+ }
+ return nil
+}
+
+const Any int = -1
+
+// ValidateMulti validates the current JWS as-is. Since it's meant to be
+// called after parsing a stream of bytes into a JWS, it doesn't do any
+// internal parsing like the Sign, Flat, Compact, or General methods do.
+// idx represents which signatures need to validate
+// in order for the JWS to be considered valid.
+// Use the constant `Any` (-1) if _any_ should validate the JWS. Otherwise,
+// use the indexes of the signatures that need to validate in order
+// for the JWS to be considered valid.
+// Note: if idx is omitted it defaults to requiring _all_
+// signatures validate, and the JWS spec required _at least_ one
+// signature to validate in order for the JWS to be considered
+// valid.
+func (j *JWS) ValidateMulti(keys []interface{}, methods []SigningMethod, idx ...int) error {
+
+ if len(j.sb) != len(methods) {
+ return ErrNotEnoughMethods
+ }
+
+ if len(keys) < 1 ||
+ len(keys) > 1 && len(keys) != len(j.sb) {
+ return ErrNotEnoughKeys
+ }
+
+ if len(keys) == 1 {
+ k := keys[0]
+ keys = make([]interface{}, len(methods))
+ for i := range keys {
+ keys[i] = k
+ }
+ }
+
+ any := len(idx) == 1 && idx[0] == Any
+ if !any {
+ sort.Ints(idx)
+ }
+
+ rp := 0
+ for i := range j.sb {
+ if j.sb[i].validate(j.plcache, keys[i], methods[i]) == nil &&
+ any || (rp < len(idx) && idx[rp] == i) {
+ rp++
+ }
+ }
+
+ if rp < len(idx) {
+ return ErrDidNotValidate
+ }
+ return nil
+}
+
+// Validate validates the current JWS as-is. Refer to ValidateMulti
+// for more information.
+func (j *JWS) Validate(key interface{}, method SigningMethod) error {
+ if len(j.sb) < 1 {
+ return ErrCannotValidate
+ }
+ return j.sb[0].validate(j.plcache, key, method)
+}
+
+func (s *sigHead) validate(pl []byte, key interface{}, method SigningMethod) error {
+ if s.method != method {
+ return ErrMismatchedAlgorithms
+ }
+ return method.Verify(format(s.Protected, pl), s.Signature, key)
}
diff --git a/jws/jws_serialize.go b/jws/jws_serialize.go
index a79c59c..46ecd38 100644
--- a/jws/jws_serialize.go
+++ b/jws/jws_serialize.go
@@ -11,7 +11,6 @@
if len(j.sb) < 1 {
return nil, ErrNotEnoughMethods
}
-
if err := j.sign(key); err != nil {
return nil, err
}
@@ -26,6 +25,10 @@
// General serializes the JWS into its "general" form per
// https://tools.ietf.org/html/rfc7515#section-7.2.1
+//
+// If only one key is passed it's used for all the provided
+// SigningMethods. Otherwise, len(keys) must equal the number
+// of SigningMethods added.
func (j *JWS) General(keys ...interface{}) ([]byte, error) {
if err := j.sign(keys...); err != nil {
return nil, err
@@ -67,13 +70,26 @@
return err
}
+ if len(keys) < 1 ||
+ len(keys) > 1 && len(keys) != len(j.sb) {
+ return ErrNotEnoughKeys
+ }
+
+ if len(keys) == 1 {
+ k := keys[0]
+ keys = make([]interface{}, len(j.sb))
+ for i := range keys {
+ keys[i] = k
+ }
+ }
+
for i := range j.sb {
if err := j.sb[i].cache(); err != nil {
return err
}
raw := format(j.sb[i].Protected, j.plcache)
- sig, err := j.methods[i].Sign(raw, keys[i])
+ sig, err := j.sb[i].method.Sign(raw, keys[i])
if err != nil {
return err
}
diff --git a/jws/jws_serialize_test.go b/jws/jws_serialize_test.go
index 61a828e..124a3b4 100644
--- a/jws/jws_serialize_test.go
+++ b/jws/jws_serialize_test.go
@@ -9,11 +9,15 @@
)
var dataRaw = struct {
+ H jose.Protected
Name string
Scopes []string
Admin bool
Data struct{ Foo, Bar int }
}{
+ H: jose.Protected{
+ "1234": "5678",
+ },
Name: "Eric",
Scopes: []string{
"user.account.info",
diff --git a/jws/jws_test.go b/jws/jws_test.go
index 8afb931..ebd7cf0 100644
--- a/jws/jws_test.go
+++ b/jws/jws_test.go
@@ -10,10 +10,13 @@
type easy []byte
func (e *easy) UnmarshalJSON(b []byte) error {
+ if len(b) > 1 && b[0] == '"' && b[len(b)-1] == '"' {
+ b = b[1 : len(b)-1]
+ }
// json.Marshal encodes easy as it would a []byte, so in
// `"base64"` format.
- dst := make([]byte, base64.StdEncoding.DecodedLen(len(b)-2))
- n, err := base64.StdEncoding.Decode(dst, b[1:len(b)-1])
+ dst := make([]byte, base64.StdEncoding.DecodedLen(len(b)))
+ n, err := base64.StdEncoding.Decode(dst, b)
if err != nil {
return err
}
@@ -23,7 +26,7 @@
var _ json.Unmarshaler = (*easy)(nil)
-var easyData = easy(`"easy data!"`)
+var easyData = easy("easy data!")
func TestParseWithUnmarshaler(t *testing.T) {
j := New(easyData, SigningMethodRS512)
@@ -42,3 +45,144 @@
Error(t, easyData, *j2.payload.v.(*easy))
}
}
+
+func TestParseCompact(t *testing.T) {
+ j := New(easyData, SigningMethodRS512)
+ b, err := j.Compact(rsaPriv)
+ if err != nil {
+ t.Error(err)
+ }
+
+ j2, err := ParseCompact(b)
+ if err != nil {
+ t.Error(err)
+ }
+
+ var k easy
+ if err := k.UnmarshalJSON([]byte(j2.payload.v.(string))); err != nil {
+ t.Error(err)
+ }
+
+ if !bytes.Equal(k, easyData) {
+ Error(t, easyData, k)
+ }
+}
+
+func TestParseGeneral(t *testing.T) {
+ sm := []SigningMethod{SigningMethodRS512, SigningMethodPS384, SigningMethodPS256}
+ j := New(easyData, sm...)
+ b, err := j.General(rsaPriv)
+ if err != nil {
+ t.Error(err)
+ }
+
+ j2, err := ParseGeneral(b)
+ if err != nil {
+ t.Error(err)
+ }
+
+ for i, v := range j2.sb {
+ k := v.protected.Get("alg").(string)
+ if k != sm[i].Alg() {
+ Error(t, sm[i].Alg(), k)
+ }
+ }
+}
+
+func TestValidateMulti(t *testing.T) {
+ sm := []SigningMethod{SigningMethodRS512, SigningMethodPS384, SigningMethodPS256}
+ j := New(easyData, sm...)
+ b, err := j.General(rsaPriv)
+ if err != nil {
+ t.Error(err)
+ }
+
+ j2, err := ParseGeneral(b)
+ if err != nil {
+ t.Error(err)
+ }
+
+ keys := []interface{}{rsaPub, rsaPub, rsaPub}
+ if err := j2.ValidateMulti(keys, sm, Any); err != nil {
+ t.Error(err)
+ }
+}
+
+func TestValidateMultiMismatchedAlgs(t *testing.T) {
+ sm := []SigningMethod{SigningMethodRS256, SigningMethodPS384, SigningMethodPS512}
+ j := New(easyData, sm...)
+ b, err := j.General(rsaPriv)
+ if err != nil {
+ t.Error(err)
+ }
+
+ j2, err := ParseGeneral(b)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // Shuffle it.
+ sm = []SigningMethod{SigningMethodRS512, SigningMethodPS256, SigningMethodPS384}
+
+ keys := []interface{}{rsaPub, rsaPub, rsaPub}
+ if err := j2.ValidateMulti(keys, sm, Any); err == nil {
+ t.Error("Should NOT be nil")
+ }
+}
+
+func TestValidateMultiNotEnoughMethods(t *testing.T) {
+ sm := []SigningMethod{SigningMethodRS256, SigningMethodPS384, SigningMethodPS512}
+ j := New(easyData, sm...)
+ b, err := j.General(rsaPriv)
+ if err != nil {
+ t.Error(err)
+ }
+
+ j2, err := ParseGeneral(b)
+ if err != nil {
+ t.Error(err)
+ }
+
+ sm = sm[0 : len(sm)-1]
+
+ keys := []interface{}{rsaPub, rsaPub, rsaPub}
+ if err := j2.ValidateMulti(keys, sm, Any); err == nil {
+ t.Error("Should NOT be nil")
+ }
+}
+
+func TestValidateMultiNotEnoughKeys(t *testing.T) {
+ sm := []SigningMethod{SigningMethodRS256, SigningMethodPS384, SigningMethodPS512}
+ j := New(easyData, sm...)
+ b, err := j.General(rsaPriv)
+ if err != nil {
+ t.Error(err)
+ }
+
+ j2, err := ParseGeneral(b)
+ if err != nil {
+ t.Error(err)
+ }
+
+ keys := []interface{}{rsaPub, rsaPub}
+ if err := j2.ValidateMulti(keys, sm, Any); err == nil {
+ t.Error("Should NOT be nil")
+ }
+}
+
+func TestValidate(t *testing.T) {
+ j := New(easyData, SigningMethodPS512)
+ b, err := j.Flat(rsaPriv)
+ if err != nil {
+ t.Error(err)
+ }
+
+ j2, err := ParseFlat(b)
+ if err != nil {
+ t.Error(err)
+ }
+
+ if err := j2.Validate(rsaPub, SigningMethodPS512); err != nil {
+ t.Error(err)
+ }
+}
diff --git a/jws/none.go b/jws/none.go
index a1b66b2..5d0a4bf 100644
--- a/jws/none.go
+++ b/jws/none.go
@@ -8,12 +8,12 @@
)
func init() {
- crypto.RegisterHash(crypto.Hash(0), H)
+ crypto.RegisterHash(crypto.Hash(0), h)
RegisterSigningMethod(Unsecured)
}
-// H is passed to crypto.RegisterHash.
-func H() hash.Hash { return &f{Writer: nil} }
+// h is passed to crypto.RegisterHash.
+func h() hash.Hash { return &f{Writer: nil} }
type f struct{ io.Writer }
diff --git a/jws/payload.go b/jws/payload.go
index 3cc203c..34ba6d8 100644
--- a/jws/payload.go
+++ b/jws/payload.go
@@ -43,6 +43,7 @@
p.v = p.u
return err
}
+
return json.Unmarshal(b2, &p.v)
}
