Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

3.3 KB
Raw Blame
package wif

import (
	"context"
	"strings"
	"time"

	"github.com/go-jose/go-jose/v4"
	"github.com/go-jose/go-jose/v4/jwt"
	"github.com/pkg/errors"

	storepb "github.com/bytebase/bytebase/backend/generated-go/store"
)

// TokenClaims represents the claims from an OIDC token.
type TokenClaims struct {
	Issuer   string   `json:"iss"`
	Subject  string   `json:"sub"`
	Audience []string `json:"aud"`
	Expiry   int64    `json:"exp"`
	IssuedAt int64    `json:"iat"`
}

// ValidateToken validates an OIDC token against a workload identity configuration.
func ValidateToken(ctx context.Context, tokenString string, config *storepb.WorkloadIdentityConfig) (*TokenClaims, error) {
	// Parse the token
	token, err := jwt.ParseSigned(tokenString, []jose.SignatureAlgorithm{jose.RS256, jose.ES256})
	if err != nil {
		return nil, errors.Wrap(err, "failed to parse token")
	}

	// Get JWKS from issuer
	jwks, err := FetchJWKS(ctx, config.IssuerUrl, config.JwksUrl)
	if err != nil {
		return nil, errors.Wrap(err, "failed to fetch JWKS")
	}

	// Use jwt.Claims which handles audience as both string and []string
	var registeredClaims jwt.Claims
	if err := token.Claims(jwks, &registeredClaims); err != nil {
		return nil, errors.Wrap(err, "failed to verify token signature")
	}

	// Convert to our TokenClaims format
	claims := &TokenClaims{
		Issuer:   registeredClaims.Issuer,
		Subject:  registeredClaims.Subject,
		Audience: registeredClaims.Audience,
	}
	if registeredClaims.Expiry != nil {
		claims.Expiry = registeredClaims.Expiry.Time().Unix()
	}
	if registeredClaims.IssuedAt != nil {
		claims.IssuedAt = registeredClaims.IssuedAt.Time().Unix()
	}

	// Validate issuer
	if claims.Issuer != config.IssuerUrl {
		return nil, errors.Errorf("issuer mismatch: expected %q, got %q", config.IssuerUrl, claims.Issuer)
	}

	// Validate audience
	if !validateAudience(claims.Audience, config.AllowedAudiences) {
		return nil, errors.Errorf("audience mismatch: token has %v, allowed %v", claims.Audience, config.AllowedAudiences)
	}

	// Validate subject pattern
	if !matchSubjectPattern(claims.Subject, config.SubjectPattern) {
		return nil, errors.Errorf("subject mismatch: expected pattern %q, got %q", config.SubjectPattern, claims.Subject)
	}

	// Validate expiry
	if time.Now().Unix() > claims.Expiry {
		return nil, errors.New("token has expired")
	}

	return claims, nil
}

func validateAudience(tokenAudience []string, allowedAudiences []string) bool {
	for _, allowed := range allowedAudiences {
		// A blank entry is not a binding. The write paths refuse one, but a row
		// stored before they did still holds it, and go-jose reads a token's
		// `"aud": ""` as one empty string, which would match it.
		if strings.TrimSpace(allowed) == "" {
			continue
		}
		for _, aud := range tokenAudience {
			if aud == allowed {
				return true
			}
		}
	}
	return false
}

func matchSubjectPattern(subject, pattern string) bool {
	// The write-time rule is the read-time rule: a pattern the write paths
	// would refuse matches nothing, so a row stored before that rule existed
	// fails closed instead of admitting every subject behind a broad prefix.
	if ValidateSubjectPattern(pattern) != nil {
		return false
	}
	if strings.HasSuffix(pattern, "*") {
		prefix := strings.TrimSuffix(pattern, "*")
		return strings.HasPrefix(subject, prefix)
	}
	return subject == pattern
}