mirror of
https://github.com/hanzoai/pki.git
synced 2026-11-03 18:08:14 +00:00
558 lines
14 KiB
Go
558 lines
14 KiB
Go
package jwt
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/effective-security/xlog"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
xlog.SetGlobalLogLevel(xlog.DEBUG)
|
|
retCode := m.Run()
|
|
os.Exit(retCode)
|
|
}
|
|
|
|
func TestClaims(t *testing.T) {
|
|
now := time.Now()
|
|
c := &Claims{
|
|
ID: "123",
|
|
Cnf: &Cnf{
|
|
Jkt: "1234",
|
|
},
|
|
}
|
|
assert.Equal(t, `{"jti":"123","cnf":{"jkt":"1234"}}`, c.Marshal())
|
|
|
|
c = &Claims{
|
|
ID: "123",
|
|
}
|
|
assert.Equal(t, `{"jti":"123"}`, c.Marshal())
|
|
assert.EqualError(t, c.VerifyExpiresAt(now, true), "exp claim not found")
|
|
assert.EqualError(t, c.VerifyIssuedAt(now, true), "iat claim not found")
|
|
assert.EqualError(t, c.VerifyNotBefore(now, true), "nbf claim not found")
|
|
assert.EqualError(t, c.VerifyAudience([]string{"t2"}), "aud claim not found")
|
|
assert.EqualError(t, c.VerifyIssuer("iss"), "iss claim not found")
|
|
assert.EqualError(t, c.VerifySubject("sub"), "sub claim not found")
|
|
|
|
assert.NoError(t, c.VerifyExpiresAt(now, false))
|
|
assert.NoError(t, c.VerifyIssuedAt(now, false))
|
|
assert.NoError(t, c.VerifyNotBefore(now, false))
|
|
|
|
c.Issuer = "iss1"
|
|
c.Audience = []string{"aud1"}
|
|
c.Subject = "sub1"
|
|
|
|
assert.EqualError(t, c.VerifyAudience([]string{"t2"}), "token missing audience: t2")
|
|
assert.EqualError(t, c.VerifyIssuer("iss"), "invalid issuer: iss1, expected: iss")
|
|
assert.EqualError(t, c.VerifySubject("sub"), "invalid subject: sub1, expected: sub")
|
|
|
|
cfg := VerifyConfig{
|
|
ExpectedIssuer: c.Issuer,
|
|
ExpectedAudience: c.Audience,
|
|
ExpectedSubject: c.Subject,
|
|
}
|
|
assert.NoError(t, c.Valid(cfg))
|
|
cfg = VerifyConfig{}
|
|
assert.NoError(t, c.Valid(cfg))
|
|
|
|
c.IssuedAt = NewNumericDate(now.Add(time.Hour))
|
|
err := c.Valid(cfg)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "token issued after now:")
|
|
|
|
c.IssuedAt = NewNumericDate(now.Add(-time.Hour))
|
|
c.NotBefore = NewNumericDate(now.Add(time.Hour))
|
|
err = c.Valid(cfg)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "token not valid yet, not before:")
|
|
|
|
c.NotBefore = NewNumericDate(now.Add(-time.Hour))
|
|
c.Expiry = NewNumericDate(now.Add(-time.Hour))
|
|
err = c.Valid(cfg)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "token expired at:")
|
|
|
|
c.Expiry = NewNumericDate(now.Add(time.Hour))
|
|
assert.NoError(t, c.Valid(cfg))
|
|
}
|
|
|
|
func TestAudience(t *testing.T) {
|
|
var a Audience
|
|
require.NoError(t, a.UnmarshalJSON([]byte(`"123"`)))
|
|
assert.Equal(t, Audience{"123"}, a)
|
|
require.NoError(t, a.UnmarshalJSON([]byte(`["123", "aaa"]`)))
|
|
assert.Equal(t, Audience{"123", "aaa"}, a)
|
|
assert.EqualError(t, a.UnmarshalJSON([]byte(`{"aud":"123"}`)), "audience: unsupported type: 'map[string]interface {}'")
|
|
assert.EqualError(t, a.UnmarshalJSON([]byte(`["1", 0.1]`)), "audience: expected string or array value")
|
|
assert.EqualError(t, a.UnmarshalJSON([]byte(`[}`)), "invalid character '}' looking for beginning of value")
|
|
}
|
|
|
|
func TestNumericDate(t *testing.T) {
|
|
var tim time.Time
|
|
assert.Nil(t, NewNumericDate(tim))
|
|
var val NumericDate
|
|
assert.EqualError(t, val.UnmarshalJSON([]byte(`"abc"`)), "expected number value to unmarshal NumericDate: abc")
|
|
assert.NoError(t, val.UnmarshalJSON([]byte(`"123"`)))
|
|
assert.NoError(t, val.UnmarshalJSON([]byte(`123`)))
|
|
|
|
var nn *NumericDate
|
|
assert.True(t, nn.Time().IsZero())
|
|
}
|
|
|
|
func TestMapClaims(t *testing.T) {
|
|
now := time.Now()
|
|
cfg := VerifyConfig{}
|
|
c := MapClaims{}
|
|
assert.EqualError(t, c.VerifyExpiresAt(now, true), "exp claim not found")
|
|
assert.EqualError(t, c.VerifyIssuedAt(now, true), "iat claim not found")
|
|
assert.EqualError(t, c.VerifyNotBefore(now, true), "nbf claim not found")
|
|
assert.EqualError(t, c.VerifyAudience([]string{"t2"}), "aud claim not found")
|
|
assert.EqualError(t, c.VerifyIssuer("iss"), "iss claim not found")
|
|
assert.EqualError(t, c.VerifySubject("sub"), "sub claim not found")
|
|
|
|
assert.NoError(t, c.VerifyExpiresAt(now, false))
|
|
assert.NoError(t, c.VerifyIssuedAt(now, false))
|
|
assert.NoError(t, c.VerifyNotBefore(now, false))
|
|
|
|
c = MapClaims{
|
|
"jti": "123",
|
|
"aud": []string{"t1"},
|
|
}
|
|
assert.Equal(t, `{"aud":["t1"],"jti":"123"}`, c.Marshal())
|
|
|
|
err := c.VerifyAudience([]string{"t2"})
|
|
assert.EqualError(t, err, "token missing audience: t2")
|
|
err = c.VerifyIssuer("iss")
|
|
assert.EqualError(t, err, "iss claim not found")
|
|
err = c.VerifyExpiresAt(now, true)
|
|
assert.EqualError(t, err, "exp claim not found")
|
|
err = c.VerifyIssuedAt(now, true)
|
|
assert.EqualError(t, err, "iat claim not found")
|
|
err = c.VerifyNotBefore(now, true)
|
|
assert.EqualError(t, err, "nbf claim not found")
|
|
|
|
c2 := MapClaims{
|
|
"jti": "2",
|
|
"iss": "123",
|
|
"sub": "sFX",
|
|
"aud": "t1",
|
|
"nbf": time.Now().Add(time.Hour).Unix(),
|
|
"iat": time.Now().Add(time.Hour).Unix(),
|
|
}
|
|
c2c := MapClaims{}
|
|
CopyUserInfoClaims(c2, c2c)
|
|
assert.NotEqual(t, c2, c2c)
|
|
|
|
err = c2.VerifySubject("s")
|
|
assert.EqualError(t, err, "invalid subject: sFX, expected: s")
|
|
err = c2.VerifyIssuer("iss")
|
|
assert.EqualError(t, err, "invalid issuer: 123, expected: iss")
|
|
err = c2.VerifyAudience([]string{"t2"})
|
|
assert.EqualError(t, err, "token missing audience: t2")
|
|
err = c2.VerifyIssuedAt(now, true)
|
|
assert.Contains(t, err.Error(), "token issued after now")
|
|
err = c2.VerifyNotBefore(now, true)
|
|
assert.Contains(t, err.Error(), "token not valid yet")
|
|
|
|
cfg = VerifyConfig{
|
|
ExpectedIssuer: "123",
|
|
ExpectedAudience: []string{"t1"},
|
|
ExpectedSubject: "sFX",
|
|
}
|
|
assert.Error(t, c2.Valid(cfg))
|
|
c2["nbf"] = time.Now().Add(-2 * time.Hour).Unix()
|
|
c2["iat"] = time.Now().Add(-2 * time.Hour).Unix()
|
|
c2["exp"] = time.Now().Add(time.Hour).Unix()
|
|
assert.NoError(t, c2.Valid(cfg))
|
|
|
|
c4 := map[string]interface{}{
|
|
"c4": "444",
|
|
"aud": []string{"t1", "t2"},
|
|
"exp": time.Now().Add(-time.Hour).Unix(),
|
|
}
|
|
err = c.Add(c2, nil)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "2", c["jti"])
|
|
|
|
err = c.Add(nil, c4)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "444", c["c4"])
|
|
err = c.VerifyExpiresAt(now, true)
|
|
assert.Contains(t, err.Error(), "token expired at:")
|
|
|
|
std := Claims{
|
|
IssuedAt: NewNumericDate(time.Now()),
|
|
}
|
|
err = c.Add(std)
|
|
require.NoError(t, err)
|
|
assert.Len(t, c, 8)
|
|
SetClaimsExpiration(c, 60*time.Minute)
|
|
|
|
err = c.Add(3)
|
|
assert.EqualError(t, err, "unsupported claims interface")
|
|
|
|
c["exp"] = time.Now().Add(time.Hour).Unix()
|
|
c["nbf"] = time.Now().Add(time.Hour).Unix()
|
|
err = c.Valid(cfg)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "token not valid yet, not before")
|
|
|
|
c["nbf"] = time.Now().Add(-2 * time.Hour).Unix()
|
|
c["exp"] = time.Now().Add(-time.Hour).Unix()
|
|
err = c.Valid(cfg)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "token expired at")
|
|
|
|
var std2 Claims
|
|
err = c.To(&std2)
|
|
require.NoError(t, err)
|
|
err = c.Valid(cfg)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "token expired at")
|
|
|
|
c3 := MapClaims{
|
|
"aud": []interface{}{time.Now()},
|
|
}
|
|
assert.EqualError(t, c3.VerifyAudience([]string{"t2"}), "invalid aud claim with unsupported value")
|
|
}
|
|
|
|
func TestClaims_String(t *testing.T) {
|
|
c := func(o MapClaims, k, exp string) {
|
|
act := o.String(k)
|
|
assert.Equal(t, act, exp)
|
|
}
|
|
|
|
stru := struct {
|
|
Foo string
|
|
B bool
|
|
I int
|
|
}{Foo: "foo", B: true, I: -1}
|
|
|
|
o := MapClaims{
|
|
"foo": "bar",
|
|
"blank": "",
|
|
"count": uint64(1),
|
|
"sub": uint64(112365491768253),
|
|
"int64": int64(112365491768253),
|
|
"jsonn": json.Number("112365491768253"),
|
|
"struct": stru,
|
|
}
|
|
c(o, "foo", "bar")
|
|
c(o, "blank", "")
|
|
c(o, "unknown", "")
|
|
c(o, "count", "1")
|
|
c(o, "sub", "112365491768253")
|
|
c(o, "int64", "112365491768253")
|
|
c(o, "jsonn", "112365491768253")
|
|
c(o, "struct", `{"Foo":"foo","B":true,"I":-1}`)
|
|
}
|
|
|
|
func TestClaims_Int(t *testing.T) {
|
|
c := func(o MapClaims, k string, exp int) {
|
|
act := o.Int(k)
|
|
assert.Equal(t, exp, act)
|
|
}
|
|
|
|
o := MapClaims{
|
|
"nil": nil,
|
|
"struct": struct{}{},
|
|
"z": "123",
|
|
"ze": "abc",
|
|
"n": int(-1),
|
|
"int": int(1),
|
|
"int32": int32(32),
|
|
"int64": int64(64),
|
|
"uint": uint(123),
|
|
"uint32": uint32(132),
|
|
"uint64": uint64(164),
|
|
}
|
|
c(o, "nil", 0)
|
|
c(o, "struct", 0)
|
|
c(o, "z", 123)
|
|
c(o, "ze", 0)
|
|
c(o, "n", -1)
|
|
c(o, "int", 1)
|
|
c(o, "int32", 32)
|
|
c(o, "int64", 64)
|
|
c(o, "uint", 123)
|
|
c(o, "uint32", 132)
|
|
c(o, "uint64", 164)
|
|
}
|
|
|
|
func TestClaims_UInt64(t *testing.T) {
|
|
c := func(o MapClaims, k string, exp uint64) {
|
|
act := o.UInt64(k)
|
|
assert.Equal(t, exp, act)
|
|
}
|
|
|
|
o := MapClaims{
|
|
"nil": nil,
|
|
"struct": struct{}{},
|
|
"z": "123",
|
|
"ze": "abc",
|
|
"n": int(-1),
|
|
"int": int(1),
|
|
"int32": int32(32),
|
|
"int64": int64(64),
|
|
"uint": uint(123),
|
|
"uint32": uint32(132),
|
|
"uint64": uint64(164),
|
|
}
|
|
c(o, "nil", uint64(0))
|
|
c(o, "struct", uint64(0))
|
|
c(o, "z", uint64(123))
|
|
c(o, "ze", uint64(0))
|
|
c(o, "n", uint64(0xffffffffffffffff))
|
|
c(o, "int", uint64(1))
|
|
c(o, "int32", uint64(32))
|
|
c(o, "int64", uint64(64))
|
|
c(o, "uint", uint64(123))
|
|
c(o, "uint32", uint64(132))
|
|
c(o, "uint64", uint64(164))
|
|
}
|
|
|
|
func TestClaims_Int64(t *testing.T) {
|
|
c := func(o MapClaims, k string, exp int64) {
|
|
act := o.Int64(k)
|
|
assert.Equal(t, exp, act)
|
|
}
|
|
|
|
o := MapClaims{
|
|
"nil": nil,
|
|
"struct": struct{}{},
|
|
"z": "123",
|
|
"ze": "abc",
|
|
"n": int(-1),
|
|
"int": int(1),
|
|
"int32": int32(32),
|
|
"int64": int64(64),
|
|
"uint": uint(123),
|
|
"uint32": uint32(132),
|
|
"uint64": uint64(164),
|
|
}
|
|
c(o, "nil", int64(0))
|
|
c(o, "struct", int64(0))
|
|
c(o, "z", int64(123))
|
|
c(o, "ze", int64(0))
|
|
c(o, "n", int64(-1))
|
|
c(o, "int", int64(1))
|
|
c(o, "int32", int64(32))
|
|
c(o, "int64", int64(64))
|
|
c(o, "uint", int64(123))
|
|
c(o, "uint32", int64(132))
|
|
c(o, "uint64", int64(164))
|
|
}
|
|
|
|
func TestClaims_Bool(t *testing.T) {
|
|
c := func(o MapClaims, k string, exp bool) {
|
|
act := o.Bool(k)
|
|
assert.Equal(t, act, exp)
|
|
}
|
|
|
|
o := MapClaims{
|
|
"nil": nil,
|
|
"struct": struct{}{},
|
|
"true": true,
|
|
"false": false,
|
|
"strue": "true",
|
|
}
|
|
c(o, "nil", false)
|
|
c(o, "struct", false)
|
|
c(o, "true", true)
|
|
c(o, "strue", true)
|
|
c(o, "false", false)
|
|
}
|
|
|
|
func TestCreateClaims(t *testing.T) {
|
|
extraClaims := MapClaims{
|
|
"cnf": Cnf{
|
|
Jkt: "123123",
|
|
},
|
|
"orgs": map[string]string{
|
|
"1": "admin",
|
|
"2": "user",
|
|
},
|
|
}
|
|
cl := CreateClaims("123", "subj", "issuer", []string{"aud"}, 60*time.Minute, extraClaims)
|
|
assert.NotNil(t, cl.Time("iat"))
|
|
assert.False(t, cl.TimeVal("iat").IsZero())
|
|
assert.True(t, cl.TimeVal("iat2").IsZero())
|
|
assert.NotNil(t, cl.Time("nbf"))
|
|
assert.NotNil(t, cl.Time("exp"))
|
|
assert.Equal(t, "123123", cl.CNF().Jkt)
|
|
assert.Len(t, cl.StringsMap("orgs"), 2)
|
|
}
|
|
|
|
func TestClaims_Time(t *testing.T) {
|
|
c := func(o MapClaims, k string, exp *time.Time) {
|
|
act := o.Time(k)
|
|
if exp != nil {
|
|
require.NotNil(t, act)
|
|
assert.Equal(t, *act, *exp)
|
|
} else {
|
|
assert.Nil(t, act)
|
|
}
|
|
}
|
|
t2, err := time.Parse("2006-01-02T15:04:05.000-0700", "2007-02-03T15:05:06.123-0701")
|
|
require.NoError(t, err)
|
|
|
|
t3 := time.Unix(1645187555, 0)
|
|
|
|
o := MapClaims{
|
|
"t1": "2007-02-03T15:05:06.123-0701",
|
|
"t2": t2,
|
|
"t3": &t2,
|
|
"err": "11111111111111111111111111111",
|
|
"struct": struct{}{},
|
|
"tnil": 1,
|
|
"tnil2": "notime",
|
|
"unix": 1645187555,
|
|
"float64": float64(1645187555),
|
|
"unixs": "1645187555",
|
|
"json": json.Number("1645187555"),
|
|
"uint64": uint64(1645187555),
|
|
"int64": int64(1645187555),
|
|
}
|
|
c(o, "t1", &t2)
|
|
c(o, "t2", &t2)
|
|
c(o, "t3", &t2)
|
|
c(o, "err", nil)
|
|
c(o, "tnil2", nil)
|
|
c(o, "struct", nil)
|
|
c(o, "unix", &t3)
|
|
c(o, "unixs", &t3)
|
|
c(o, "float64", &t3)
|
|
c(o, "uint64", &t3)
|
|
c(o, "int64", &t3)
|
|
c(o, "json", &t3)
|
|
}
|
|
|
|
func TestExpired(t *testing.T) {
|
|
auth := `eyJhbGciOiJFUzI1NiIsImp3ayI6eyJrdHkiOiJFQyIsImNydiI6IlAtMjU2IiwieCI6Il9TRVdHR0hLVGY2YmFvYWRZdEMycmdBVGJZUGh6Yjd1eWt0c3FIeHZ4YmciLCJ5IjoieExfMFktdXFsU0lsZm1Md3NwbXpiSTJmRWxYcF9YS0Q1Tm1xd2c5aXZFUSJ9LCJ0eXAiOiJKV1QifQ.eyJjbmYiOnsiamt0IjoidTJBa1VNQjFzaHBfYTVtSldFODFrMFdGSEhGLVlJNTJWajByQUl5dmdHRSJ9LCJlbWFpbCI6ImRlbmlzQGVrc3BhbmQuY29tIiwiZW1haWxfdmVyaWZpZWQiOnRydWUsImV4cCI6MTY0NzExMDU3OCwiaWF0IjoxNjQ3MTA2OTc5LCJuYW1lIjoiRGVuaXMgSXNzb3Vwb3YiLCJuYmYiOjE2NDcxMDY4NTksInByb3ZpZGVyIjoiZ29vZ2xlIiwic3ViIjoiMTE1MTgyMzI4NjQzNjY2MDAyMDExIn0.dp42oVGjbAoPb8WiRqWLHU9p_sW0kgjK0NktfunIbm_FJAGdoEsxkeigs3wvWdCNxXrgAuujK9jJhfBwvrjC7g`
|
|
|
|
parser := TokenParser{
|
|
UseJSONNumber: true,
|
|
}
|
|
|
|
claims := MapClaims{}
|
|
token, _, err := parser.ParseUnverified(auth, claims)
|
|
require.NoError(t, err)
|
|
assert.False(t, token.Valid)
|
|
err = claims.VerifyExpiresAt(time.Now(), true)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "token expired at:")
|
|
}
|
|
|
|
func TestNil(t *testing.T) {
|
|
var c MapClaims
|
|
assert.Empty(t, c.String("123"))
|
|
assert.Equal(t, 0, c.Int("123"))
|
|
assert.Nil(t, c.Time("123"))
|
|
assert.False(t, c.Bool("123"))
|
|
}
|
|
|
|
func TestDPoP(t *testing.T) {
|
|
js := `{
|
|
"aud": "secdi",
|
|
"cnf": {
|
|
"jkt": "4k3pN8RezZr_O0xJ4bJtlliw85Xg0TxVouHWvD4TVYg"
|
|
},
|
|
"email": "[email protected]",
|
|
"email_verified": false,
|
|
"exp": "1671113793",
|
|
"iat": 1670508993,
|
|
"iss": "https://localhost:18443",
|
|
"name": "Denis Issoupov",
|
|
"nbf": "1670508873",
|
|
"nonce": "o_VhzPAT",
|
|
"org": "255672613685166359",
|
|
"org_role": "owner",
|
|
"orgs": {
|
|
"255672613685166359": "owner",
|
|
"255679584895238423": "owner"
|
|
},
|
|
"provider": "google",
|
|
"sub": "254312925823500567"
|
|
}
|
|
`
|
|
var c Claims
|
|
err := json.Unmarshal([]byte(js), &c)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "4k3pN8RezZr_O0xJ4bJtlliw85Xg0TxVouHWvD4TVYg", c.Cnf.Jkt)
|
|
assert.Len(t, c.Orgs, 2)
|
|
assert.Equal(t, "owner", c.OrgRole)
|
|
|
|
mc := MapClaims{}
|
|
err = json.Unmarshal([]byte(js), &mc)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "4k3pN8RezZr_O0xJ4bJtlliw85Xg0TxVouHWvD4TVYg", mc.CNF().Jkt)
|
|
}
|
|
|
|
func TestCnf(t *testing.T) {
|
|
mc := MapClaims{
|
|
"cnf": &Cnf{
|
|
Jkt: "1234",
|
|
},
|
|
}
|
|
assert.Equal(t, "1234", mc.CNF().Jkt)
|
|
|
|
mc = MapClaims{
|
|
"cnf": Cnf{
|
|
Jkt: "1234",
|
|
},
|
|
}
|
|
assert.Equal(t, "1234", mc.CNF().Jkt)
|
|
mc = MapClaims{
|
|
"cnf": map[string]string{
|
|
"jkt": "1234",
|
|
},
|
|
}
|
|
assert.Equal(t, "1234", mc.CNF().Jkt)
|
|
mc = MapClaims{
|
|
"cnf": map[string]any{
|
|
"jkt": "1234",
|
|
},
|
|
}
|
|
assert.Equal(t, "1234", mc.CNF().Jkt)
|
|
mc = MapClaims{}
|
|
assert.Nil(t, mc.CNF())
|
|
mc = MapClaims{
|
|
"cnf": 1,
|
|
}
|
|
assert.Nil(t, mc.CNF())
|
|
}
|
|
|
|
func TestStringsMap(t *testing.T) {
|
|
mc := MapClaims{
|
|
"orgs": map[string]string{
|
|
"jkt": "1234",
|
|
},
|
|
}
|
|
assert.Len(t, mc.StringsMap("orgs"), 1)
|
|
|
|
mc = MapClaims{
|
|
"orgs": map[string]any{
|
|
"jkt": "1234",
|
|
"jkt2": 1234,
|
|
},
|
|
}
|
|
assert.Len(t, mc.StringsMap("orgs"), 2)
|
|
|
|
mc = MapClaims{
|
|
"orgs": map[string]int{
|
|
"jkt": 1234,
|
|
},
|
|
}
|
|
assert.Len(t, mc.StringsMap("orgs"), 0)
|
|
|
|
mc = MapClaims{
|
|
"orgs": 1,
|
|
}
|
|
assert.Nil(t, mc.StringsMap("orgs"))
|
|
assert.Nil(t, mc.StringsMap("orgs2"))
|
|
}
|