jwx

var (
	ErrInvalidJwxToken   = errors.New("invalid jwt/jwe token")
	ErrNoVerificationKey = errors.New("failed to resolve key to verify signature")
	ErrNoDecryptionKey   = errors.New("failed to resolve decryption key")
)

var (
	ErrNoSigningKey    = errors.New("failed to resolve signing key")
	ErrNoEncryptionKey = errors.New("failed to resolve encryption key")
)

var (
	// SignatureKeyById returns a KeySource which find a signature Key by its key id.
	SignatureKeyById = func(kid string, jwks *KeySet) KeySource {
		return func() (*Key, Algs, bool) {
			key, ok := jwks.KeyById(kid)
			if !ok || key.Use() != UseSig {
				return nil, Algs{}, false
			}
			return key, Algs{Sig: key.Alg()}, true
		}
	}
	// SignatureKeyByAlg returns a KeySource which finds a signature Key by algorithm.
	SignatureKeyByAlg = func(alg string, jwks *KeySet) KeySource {
		if IsNone(alg) {
			return SkipKeySource
		}
		return func() (*Key, Algs, bool) {
			key, ok := jwks.KeyForSigning(alg)
			if !ok {
				return nil, Algs{}, false
			}
			return key, Algs{Sig: alg}, true
		}
	}
	// EncryptionKeyByAlg returns a KeySource which finds a encryption Key by algorithm.
	EncryptionKeyByAlg = func(encryptAlg, encodeAlg string, jwks *KeySet) KeySource {
		if IsNone(encryptAlg) || IsNone(encodeAlg) {
			return SkipKeySource
		}
		return func() (*Key, Algs, bool) {
			key, ok := jwks.KeyForEncryption(encryptAlg)
			if !ok {
				return nil, Algs{}, false
			}
			return key, Algs{Encrypt: encryptAlg, Encode: encodeAlg}, true
		}
	}
	// SkipKeySource returns a KeySource that whose Algs return value IsNone, and shall be skipped.
	SkipKeySource KeySource = func() (*Key, Algs, bool) {
		return nil, Algs{}, true
	}
)

var (
	ErrAbsentJti   = errors.New("jti claim is absent")
	ErrInvalidSub  = errors.New("sub claim is invalid")
	ErrInvalidIss  = errors.New("iss claim is invalid")
	ErrInvalidAud  = errors.New("aud claim is invalid")
	ErrExpExpired  = errors.New("exp claim is invalid because token has expired")
	ErrIatInFuture = errors.New("iat claim is invalid because token is issued in future")
	ErrNbfTooSoon  = errors.New("nbf claim is invalid because token is used too soon")
)

var (
	// ExpectJti expects the "jti" claim is present and non-empty. If "jti"
	// is not present, ErrAbsentJti is returned.
	ExpectJti Expect = func(c Claims) error {
		if v, ok := c.Get(ClaimJti); ok {
			if jti, ok := v.(string); ok && len(jti) > 0 {
				return nil
			}
		}
		return ErrAbsentJti
	}
	// ExpectIss expects the "iss" claim to be the same as issuer. If invalid,
	// ErrInvalidIss is returned.
	ExpectIss = func(issuer string) Expect {
		return func(c Claims) error {
			if v, ok := c.Get(ClaimIss); ok {
				if iss, ok := v.(string); ok && iss == issuer {
					return nil
				}
			}
			return ErrInvalidIss
		}
	}
	// ExpectSub returns an Expect rule to check if the subject is present
	// and is one of the expected subject values. If "sub" is not present, or
	// is not one of the legal values, ErrInvalidSub is returned.
	ExpectSub = func(subjects ...string) Expect {
		return func(c Claims) error {
			if v, ok := c.Get(ClaimSub); ok {
				if sub, ok := v.(string); ok {
					for _, each := range subjects {
						if each == sub {
							return nil
						}
					}
				}
			}
			return ErrInvalidSub
		}
	}
	// ExpectAud returns an Expect rule to check if the audience is present and that
	// one of the audience values is among the expected audiences. If condition is not
	// met, ErrInvalidAud is returned.
	ExpectAud = func(audiences ...string) Expect {
		expected := internal.NewSet(audiences...)
		return func(c Claims) error {
			if v, ok := c.Get(ClaimAud); ok && v != nil {
				if aud, ok := v.([]string); ok {
					if internal.NewSet(aud...).ContainsAll(expected) {
						return nil
					}
				}
			}
			return ErrInvalidAud
		}
	}
	// ExpectTime returns an Expect rule to check the time related claims "exp", "iat" and "nbf", if
	// they are available as time.Time. The rule considers a leeway in order to slack the clock. The
	// leeway must be a positive time.Duration, otherwise its absolute value is used.
	//
	// For "exp" claim, if current time is beyond the indicated expiry plus leeway, ErrExpExpired is returned;
	// For "iat" claim, if issued at time is beyond current time plus leeway, ErrIatInFuture is returned;
	// For "nbf" claim, if not before time is beyond current time plus leeway, ErrNbfTooSoon is returned.
	//
	// When time related claim is not present, or is not returned as time.Time by Claims, the validation is skipped.
	ExpectTime = func(leeway time.Duration) Expect {
		if leeway < 0 {
			leeway = -leeway
		}

		now := time.Now()

		return func(c Claims) error {
			if v, ok := c.Get(ClaimExp); ok {
				if exp, ok := v.(time.Time); ok && !exp.IsZero() {
					if now.After(exp.Add(leeway)) {
						return ErrExpExpired
					}
				}
			}

			if v, ok := c.Get(ClaimIat); ok {
				if iat, ok := v.(time.Time); ok && !iat.IsZero() {
					if iat.After(now.Add(leeway)) {
						return ErrIatInFuture
					}
				}
			}

			if v, ok := c.Get(ClaimNbf); ok {
				if nbf, ok := v.(time.Time); ok && !nbf.IsZero() {
					if nbf.After(now.Add(leeway)) {
						return ErrNbfTooSoon
					}
				}
			}

			return nil
		}
	}
)

var (
	// ErrInvalidSignatureAlg indicates the used signature algorithm is invalid.
	ErrInvalidSignatureAlg = errors.New("signature algorithm is invalid")
	// ErrInvalidEncryptionAlg indicates the used encryption algorithm is invalid.
	ErrInvalidEncryptionAlg = errors.New("encryption algorithm is invalid")
	// ErrInvalidEncryptionEnc indicates the used encryption encoding is invalid.
	ErrInvalidEncryptionEnc = errors.New("encryption encoding is invalid")

	// ValidSignatureAlg is a validation function that checks if the given string is a valid JWA
	// signature algorithm. This function rejects empty string or "none".
	ValidSignatureAlg = func(s string) error {
		switch s {
		case HS256, HS384, HS512,
			RS256, RS384, RS512,
			PS256, PS384, PS512,
			ES256, ES384, ES512:
			return nil
		default:
			return ErrInvalidSignatureAlg
		}
	}
	// ValidOptionalSignatureAlg is a validation function that checks if the given string is a valid JWA
	// signature algorithm. This function accepts empty string or "none".
	ValidOptionalSignatureAlg = func(s string) error {
		if IsNone(s) {
			return nil
		}
		return ValidSignatureAlg(s)
	}
	// ValidEncryptionAlg is a validation function that checks if the given string is a valid JWA
	// encryption algorithm. This function rejects empty string or "none".
	ValidEncryptionAlg = func(s string) error {
		switch s {
		case ED25519,
			RSA1_5, RSA_OAEP, RSA_OAEP_256,
			A128KW, A192KW, A256KW,
			DIRECT,
			ECDH_ES, ECDH_ES_A128KW, ECDH_ES_A192KW, ECDH_ES_A256KW,
			A128GCMKW, A192GCMKW, A256GCMKW,
			PBES2_HS256_A128KW, PBES2_HS384_A192KW, PBES2_HS512_A256KW:
			return nil
		default:
			return ErrInvalidEncryptionAlg
		}
	}
	// ValidEncryptionAlgOptional is a validation function that checks if the given string is a valid JWA
	// encryption algorithm. This function accepts empty string or "none".
	ValidOptionalEncryptionAlg = func(s string) error {
		if IsNone(s) {
			return nil
		}
		return ValidEncryptionAlg(s)
	}
	// ValidEncryptionEnc is a validation function that checks if the given string is a valid JWA
	// encryption encoding. This function rejects empty string or "none".
	ValidEncryptionEnc = func(s string) error {
		switch s {
		case A128CBC_HS256, A192CBC_HS384, A256CBC_HS512,
			A128GCM, A192GCM, A256GCM:
			return nil
		default:
			return ErrInvalidEncryptionEnc
		}
	}
	// ValidEncryptionEncOptional is a validation function that checks if the given string is a valid JWA
	// encryption encoding. This function accepts empty string or "none".
	ValidOptionalEncryptionEnc = func(s string) error {
		if IsNone(s) {
			return nil
		}
		return ValidEncryptionEnc(s)
	}
)