Method VerifyToken

internal/agentauth/tokens.go:108–146

VerifyToken validates an e2a-minted JWT: RS256 signature against the local public key, iss == issuer, aud contains issuer, not expired (with skew), and typ == expectedType. On success returns the typed claims; every failure wraps ErrTokenInvalid. assertion_version freshness is the caller's job (it n

(token, expectedType, issuer string)

// ErrTokenInvalid. assertion_version freshness is the caller's job (it needs the
// live agent row).
func (s *Signer) VerifyToken(token, expectedType, issuer string) (*VerifiedClaims, error) {
	if !s.Enabled() {
		return nil, ErrSigningDisabled
	}
	parsed, err := jwt.ParseSigned(token)
	if err != nil {
		return nil, fmt.Errorf("%w: parse: %v", ErrTokenInvalid, err)
	}
	var std jwt.Claims
	var priv tokenPrivateClaims
	if err := parsed.Claims(s.priv.Public(), &std, &priv); err != nil {
		// Signature mismatch or malformed — invalid.
		return nil, fmt.Errorf("%w: signature: %v", ErrTokenInvalid, err)
	}
	if err := std.ValidateWithLeeway(jwt.Expected{
		Issuer:   issuer,
		Audience: jwt.Audience{issuer},
		Time:     time.Now(),
	}, clockSkew); err != nil {
		return nil, fmt.Errorf("%w: claims: %v", ErrTokenInvalid, err)
	}
	if priv.Type != expectedType {
		return nil, fmt.Errorf("%w: typ %q, want %q", ErrTokenInvalid, priv.Type, expectedType)
	}
	if std.Subject == "" {
		return nil, fmt.Errorf("%w: missing sub", ErrTokenInvalid)
	}
	var exp time.Time
	if std.Expiry != nil {
		exp = std.Expiry.Time()
	}
	return &VerifiedClaims{
		Subject:          std.Subject,
		Scope:            priv.Scope,
		AssertionVersion: priv.AssertionVersion,
		Type:             priv.Type,
		Expiry:           exp,
	}, nil
}

// generateJTI returns a unique token id. crypto/rand failure panics (an
// all-zero jti would collide across tokens) — same posture as the key RNG.