mirror of
https://github.com/hanzoai/pki.git
synced 2026-11-03 18:08:14 +00:00
385 lines
14 KiB
Go
385 lines
14 KiB
Go
package jwt_test
|
|
|
|
import (
|
|
"context"
|
|
"crypto/ecdsa"
|
|
"crypto/elliptic"
|
|
"crypto/hmac"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"crypto/sha512"
|
|
"encoding/json"
|
|
"fmt"
|
|
"hash"
|
|
"maps"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/effective-security/xpki/jwt"
|
|
jose "github.com/go-jose/go-jose/v4"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestParserConfigurationFiles(t *testing.T) {
|
|
cfg, err := jwt.LoadParserConfig("")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, &jwt.ParserConfig{}, cfg)
|
|
dir := t.TempDir()
|
|
_, err = jwt.LoadParserConfig(filepath.Join(dir, "missing"))
|
|
require.ErrorIs(t, err, os.ErrNotExist)
|
|
file := filepath.Join(dir, "parser.json")
|
|
require.NoError(t, os.WriteFile(file, []byte(`{"issuer":"https://issuer.example.test","jwks":{"keys":[]}}`), 0600))
|
|
cfg, err = jwt.LoadParserConfig(file)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "https://issuer.example.test", cfg.Issuer)
|
|
require.NotNil(t, cfg.JWKeySet)
|
|
assert.Empty(t, cfg.JWKeySet.Keys)
|
|
require.NoError(t, os.WriteFile(file, []byte(`{`), 0600))
|
|
_, err = jwt.LoadParserConfig(file)
|
|
require.Error(t, err)
|
|
parser, err := jwt.NewParser(&jwt.ParserConfig{})
|
|
require.NoError(t, err)
|
|
parser.SetRevocation(nil)
|
|
assert.Nil(t, parser.GetRevocation())
|
|
_, err = parser.ParseToken(context.Background(), "token", nil)
|
|
require.EqualError(t, err, "verifier not configured")
|
|
}
|
|
|
|
func TestTokenParserMalformedSegments(t *testing.T) {
|
|
header := jwt.EncodeSegment([]byte(`{"alg":"HS256"}`))
|
|
claims := jwt.EncodeSegment([]byte(`{"sub":"subject"}`))
|
|
for _, tc := range []struct{ name, token, want string }{
|
|
{"segments", "one.two", "malformed token"},
|
|
{"header base64", "%." + claims + ".sig", "failed to decode token"},
|
|
{"header JSON", jwt.EncodeSegment([]byte("{")) + "." + claims + ".sig", "failed to unmarshal header"},
|
|
{"claims base64", header + ".%.sig", "failed to decode token"},
|
|
{"claims JSON", header + "." + jwt.EncodeSegment([]byte("{")) + ".sig", "failed to decode token"},
|
|
{"missing algorithm", jwt.EncodeSegment([]byte(`{}`)) + "." + claims + ".sig", "invalid token: no alg specified"},
|
|
{"numeric algorithm", jwt.EncodeSegment([]byte(`{"alg":1}`)) + "." + claims + ".sig", "invalid token: no alg specified"},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
parser := jwt.TokenParser{}
|
|
token, _, err := parser.ParseUnverified(tc.token, jwt.MapClaims{})
|
|
require.ErrorContains(t, err, tc.want)
|
|
assert.Nil(t, token)
|
|
})
|
|
}
|
|
}
|
|
|
|
// tokenHeader returns the decoded JOSE header of a compact token.
|
|
func tokenHeader(t *testing.T, token string) map[string]any {
|
|
t.Helper()
|
|
parts := strings.Split(token, ".")
|
|
require.Len(t, parts, 3)
|
|
raw, err := jwt.DecodeSegment(parts[0])
|
|
require.NoError(t, err)
|
|
header := map[string]any{}
|
|
require.NoError(t, json.Unmarshal(raw, &header))
|
|
return header
|
|
}
|
|
|
|
// signHMAC returns a compact token with the given header, signed with key
|
|
// by the HMAC hash of alg, independent of the provider under test.
|
|
func signHMAC(t *testing.T, alg string, key []byte, header map[string]any) string {
|
|
t.Helper()
|
|
hashes := map[string]func() hash.Hash{
|
|
"HS256": sha256.New,
|
|
"HS384": sha512.New384,
|
|
"HS512": sha512.New,
|
|
}
|
|
newHash, ok := hashes[alg]
|
|
require.True(t, ok, alg)
|
|
h := map[string]any{"alg": alg}
|
|
maps.Copy(h, header)
|
|
rawHeader, err := json.Marshal(h)
|
|
require.NoError(t, err)
|
|
signing := jwt.EncodeSegment(rawHeader) + "." + jwt.EncodeSegment([]byte(`{"sub":"subject"}`))
|
|
mac := hmac.New(newHash, key)
|
|
mac.Write([]byte(signing))
|
|
return signing + "." + jwt.EncodeSegment(mac.Sum(nil))
|
|
}
|
|
|
|
func newSymmetricKey(t *testing.T) []byte {
|
|
t.Helper()
|
|
key := make([]byte, 32)
|
|
_, err := rand.Read(key)
|
|
require.NoError(t, err)
|
|
return key
|
|
}
|
|
|
|
func TestStandaloneSymmetricProvider(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
key := newSymmetricKey(t)
|
|
provider, err := jwt.NewProviderWithSymmetricKey(key)
|
|
require.NoError(t, err)
|
|
token, err := provider.Sign(ctx, jwt.MapClaims{"sub": "subject"})
|
|
require.NoError(t, err)
|
|
|
|
// the header is unchanged for external HS256 verifiers: no kid
|
|
header := tokenHeader(t, token)
|
|
assert.Equal(t, "HS256", header["alg"])
|
|
assert.Equal(t, "JWT", header["typ"])
|
|
assert.NotContains(t, header, "kid")
|
|
|
|
// XPKI-066: the provider verifies its own kid-less tokens
|
|
claims, err := provider.ParseToken(ctx, token, nil)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "subject", claims.String("sub"))
|
|
|
|
// independent verification with the raw key
|
|
parser := jwt.TokenParser{ValidMethods: []string{"HS256"}}
|
|
parsed, err := parser.Parse(token, nil, func(*jwt.Token) (any, error) { return key, nil })
|
|
require.NoError(t, err)
|
|
assert.True(t, parsed.Valid)
|
|
parser.ValidMethods = []string{"RS256"}
|
|
_, err = parser.Parse(token, nil, func(*jwt.Token) (any, error) {
|
|
t.Fatal("disallowed methods must not reach key lookup")
|
|
return nil, nil
|
|
})
|
|
require.EqualError(t, err, "unsupported signing method: HS256")
|
|
|
|
// a different key does not verify
|
|
other, err := jwt.NewProviderWithSymmetricKey(newSymmetricKey(t))
|
|
require.NoError(t, err)
|
|
_, err = other.ParseToken(ctx, token, nil)
|
|
require.EqualError(t, err, "unable to verify token: invalid signature")
|
|
|
|
// tampered claims do not verify
|
|
parts := strings.Split(token, ".")
|
|
parts[1] = jwt.EncodeSegment([]byte(`{"sub":"admin"}`))
|
|
_, err = provider.ParseToken(ctx, strings.Join(parts, "."), nil)
|
|
require.EqualError(t, err, "unable to verify token: invalid signature")
|
|
|
|
// an asymmetric token is not verified with the symmetric key
|
|
ecKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
|
require.NoError(t, err)
|
|
ecProvider, err := jwt.NewProviderFromCryptoSigner(ecKey)
|
|
require.NoError(t, err)
|
|
ecToken, err := ecProvider.Sign(ctx, jwt.MapClaims{"sub": "subject"})
|
|
require.NoError(t, err)
|
|
_, err = provider.ParseToken(ctx, ecToken, nil)
|
|
require.EqualError(t, err, "unable to verify token: unsupported signing method: ES256")
|
|
|
|
// only HS256 is accepted, even with the right key (PR #543)
|
|
for _, alg := range []string{"HS384", "HS512"} {
|
|
_, err = provider.ParseToken(ctx, signHMAC(t, alg, key, nil), nil)
|
|
require.EqualError(t, err, "unable to verify token: unsupported signing method: "+alg, alg)
|
|
}
|
|
claims, err = provider.ParseToken(ctx, signHMAC(t, "HS256", key, nil), nil)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "subject", claims.String("sub"))
|
|
|
|
// the provider keeps its own copy of the key
|
|
key[0] ^= 0xff
|
|
_, err = provider.ParseToken(ctx, token, nil)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestStandaloneSymmetricProviderKeyID(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
key := newSymmetricKey(t)
|
|
sign := func(t *testing.T, ops ...jwt.Option) string {
|
|
t.Helper()
|
|
p, err := jwt.NewProviderWithSymmetricKey(key, ops...)
|
|
require.NoError(t, err)
|
|
token, err := p.Sign(ctx, jwt.MapClaims{"sub": "subject"})
|
|
require.NoError(t, err)
|
|
return token
|
|
}
|
|
noKid := sign(t)
|
|
k1 := sign(t, jwt.WithHeaders(map[string]any{"kid": "k1"}))
|
|
k2 := sign(t, jwt.WithHeaders(map[string]any{"kid": "k2"}))
|
|
assert.Equal(t, "k1", tokenHeader(t, k1)["kid"])
|
|
|
|
// XPKI-104: a custom kid no longer panics, and the provider verifies it
|
|
withKid, err := jwt.NewProviderWithSymmetricKey(key, jwt.WithHeaders(map[string]any{"kid": "k1"}))
|
|
require.NoError(t, err)
|
|
plain, err := jwt.NewProviderWithSymmetricKey(key)
|
|
require.NoError(t, err)
|
|
|
|
tcs := []struct {
|
|
name string
|
|
provider jwt.Provider
|
|
token string
|
|
expErr string
|
|
}{
|
|
{name: "kid provider, own kid", provider: withKid, token: k1},
|
|
{name: "kid provider, no kid", provider: withKid, token: noKid},
|
|
{name: "kid provider, other kid", provider: withKid, token: k2, expErr: "unable to verify token: unexpected kid"},
|
|
{name: "plain provider, no kid", provider: plain, token: noKid},
|
|
{name: "plain provider, kid", provider: plain, token: k1, expErr: "unable to verify token: unexpected kid"},
|
|
{name: "kid provider, hand-signed kid", provider: withKid, token: signHMAC(t, "HS256", key, map[string]any{"kid": "k1"})},
|
|
}
|
|
// a present kid that is empty or not a string never selects the key of a
|
|
// provider without a kid (PR #543)
|
|
for _, kid := range []any{"", nil, true, false, 0, 42, 1.5} {
|
|
tcs = append(tcs, struct {
|
|
name string
|
|
provider jwt.Provider
|
|
token string
|
|
expErr string
|
|
}{
|
|
name: fmt.Sprintf("plain provider, kid %#v", kid),
|
|
provider: plain,
|
|
token: signHMAC(t, "HS256", key, map[string]any{"kid": kid}),
|
|
expErr: "unable to verify token: unexpected kid",
|
|
}, struct {
|
|
name string
|
|
provider jwt.Provider
|
|
token string
|
|
expErr string
|
|
}{
|
|
name: fmt.Sprintf("kid provider, kid %#v", kid),
|
|
provider: withKid,
|
|
token: signHMAC(t, "HS256", key, map[string]any{"kid": kid}),
|
|
expErr: "unable to verify token: unexpected kid",
|
|
})
|
|
}
|
|
for _, tc := range tcs {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
claims, err := tc.provider.ParseToken(ctx, tc.token, nil)
|
|
if tc.expErr != "" {
|
|
require.EqualError(t, err, tc.expErr)
|
|
assert.Nil(t, claims)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "subject", claims.String("sub"))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStandaloneSymmetricProviderOptions(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
key := newSymmetricKey(t)
|
|
|
|
tcs := []struct {
|
|
name string
|
|
ops []jwt.Option
|
|
expHeader map[string]any
|
|
expErr string
|
|
}{
|
|
{name: "nil headers", ops: []jwt.Option{jwt.WithHeaders(nil)}, expHeader: map[string]any{"alg": "HS256", "typ": "JWT"}},
|
|
{name: "empty headers", ops: []jwt.Option{jwt.WithHeaders(map[string]any{})}, expHeader: map[string]any{"alg": "HS256", "typ": "JWT"}},
|
|
{
|
|
name: "custom headers",
|
|
ops: []jwt.Option{jwt.WithHeaders(map[string]any{"typ": "at+jwt", "x5t": "abc"})},
|
|
expHeader: map[string]any{"alg": "HS256", "typ": "at+jwt", "x5t": "abc"},
|
|
},
|
|
{
|
|
name: "last option wins",
|
|
ops: []jwt.Option{
|
|
jwt.WithHeaders(map[string]any{"kid": "a", "typ": "one"}),
|
|
jwt.WithHeaders(map[string]any{"kid": "b"}),
|
|
},
|
|
expHeader: map[string]any{"alg": "HS256", "typ": "one", "kid": "b"},
|
|
},
|
|
{name: "same alg", ops: []jwt.Option{jwt.WithHeaders(map[string]any{"alg": "HS256"})}, expHeader: map[string]any{"alg": "HS256", "typ": "JWT"}},
|
|
{name: "other alg", ops: []jwt.Option{jwt.WithHeaders(map[string]any{"alg": "HS512"})}, expErr: "alg header HS512 does not match the signing algorithm HS256"},
|
|
{name: "none alg", ops: []jwt.Option{jwt.WithHeaders(map[string]any{"alg": "none"})}, expErr: "alg header none does not match the signing algorithm HS256"},
|
|
{name: "empty kid", ops: []jwt.Option{jwt.WithHeaders(map[string]any{"kid": ""})}, expErr: "kid header must be a nonempty string: "},
|
|
{name: "numeric kid", ops: []jwt.Option{jwt.WithHeaders(map[string]any{"kid": 42})}, expErr: "kid header must be a nonempty string: 42"},
|
|
{name: "nil kid", ops: []jwt.Option{jwt.WithHeaders(map[string]any{"kid": nil})}, expErr: "kid header must be a nonempty string: <nil>"},
|
|
}
|
|
for _, tc := range tcs {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
p, err := jwt.NewProviderWithSymmetricKey(key, tc.ops...)
|
|
if tc.expErr != "" {
|
|
require.EqualError(t, err, tc.expErr)
|
|
assert.Nil(t, p)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
token, err := p.Sign(ctx, jwt.MapClaims{"sub": "subject"})
|
|
require.NoError(t, err)
|
|
// the header carries no token identifier (XPKI-073)
|
|
assert.Equal(t, tc.expHeader, tokenHeader(t, token))
|
|
|
|
_, err = p.ParseToken(ctx, token, nil)
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
|
|
for _, k := range [][]byte{nil, {}} {
|
|
p, err := jwt.NewProviderWithSymmetricKey(k)
|
|
require.EqualError(t, err, "symmetric key is empty")
|
|
assert.Nil(t, p)
|
|
}
|
|
}
|
|
|
|
func TestParserKeyIDTypes(t *testing.T) {
|
|
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
|
require.NoError(t, err)
|
|
for _, tc := range []struct {
|
|
name string
|
|
kid any
|
|
want string
|
|
}{
|
|
{"string", "42", ""}, {"numeric", 42, ""}, {"invalid", true, "invalid kid header type: bool"}, {"unknown", "missing", `kid="missing": key not found`},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
provider, err := jwt.NewProviderFromCryptoSigner(key, jwt.WithHeaders(map[string]any{"kid": tc.kid}))
|
|
require.NoError(t, err)
|
|
token, err := provider.Sign(context.Background(), jwt.MapClaims{"sub": "subject"})
|
|
require.NoError(t, err)
|
|
parser, err := jwt.NewParser(&jwt.ParserConfig{JWKeySet: &jose.JSONWebKeySet{Keys: []jose.JSONWebKey{{
|
|
Key: key.Public(),
|
|
KeyID: "42",
|
|
}}}})
|
|
require.NoError(t, err)
|
|
claims, err := parser.ParseToken(context.Background(), token, nil)
|
|
if tc.want != "" {
|
|
require.ErrorContains(t, err, tc.want)
|
|
assert.Nil(t, claims)
|
|
} else {
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "subject", claims.String("sub"))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClaimStringConversions(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
value any
|
|
want []string
|
|
}{
|
|
{"nil", nil, nil}, {"scalar", "scope", []string{"scope"}}, {"typed slice", []string{"a", "b"}, []string{"a", "b"}},
|
|
{"mixed", []any{"a", 42, true, nil}, []string{"a", "42", "true", "<nil>"}}, {"unsupported", 42, nil},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
claims := jwt.MapClaims{"value": tc.value}
|
|
assert.Equal(t, tc.want, claims.Strings("value"))
|
|
})
|
|
}
|
|
var missing jwt.MapClaims
|
|
assert.Nil(t, missing.Strings("missing"))
|
|
assert.Nil(t, (jwt.MapClaims{}).Strings("missing"))
|
|
for _, tc := range []struct {
|
|
value any
|
|
want string
|
|
}{{uint64(42), "42"}, {int64(-42), "-42"}, {json.Number("1.5"), "1.5"}, {true, "true"}, {false, "false"}} {
|
|
assert.Equal(t, tc.want, (jwt.MapClaims{"value": tc.value}).String("value"))
|
|
}
|
|
assert.Nil(t, (jwt.MapClaims{"value": 42}).StringsMap("value"))
|
|
assert.Equal(t, map[string]string{
|
|
"a": "42",
|
|
"b": "true",
|
|
}, (jwt.MapClaims{"value": map[string]any{
|
|
"a": 42,
|
|
"b": true,
|
|
}}).StringsMap("value"))
|
|
// Claims with non-JSON values must surface serialization failures.
|
|
err := jwt.MapClaims{"value": make(chan int)}.To(&struct{}{})
|
|
require.Error(t, err)
|
|
}
|