Go chi JWT 미들웨어 RS256 키 로테이션

package auth

import (
	"context"
	"crypto"
	"errors"
	"net/http"
	"sync"
	"time"

	"github.com/lestrrat-go/jwx/v2/jwk"
)

var (
	ErrKeyNotFound = errors.New("key not found")
)

type JWKSKeyProvider struct {
	URL           string
	HTTPClient    *http.Client
	CacheTTL      time.Duration
	StaleMaxAge   time.Duration

	mu           sync.RWMutex
	cachedSet    jwk.Set
	cachedAt     time.Time
	lastGoodAt   time.Time
	refreshMutex sync.Mutex
}

func (p *JWKSKeyProvider) getClient() *http.Client {
	if p.HTTPClient != nil {
		return p.HTTPClient
	}
	return &http.Client{Timeout: 3 * time.Second}
}

func (p *JWKSKeyProvider) isFresh(now time.Time) bool {
	return p.cachedSet != nil && now.Sub(p.cachedAt) <= p.CacheTTL
}

func (p *JWKSKeyProvider) isStaleAllowed(now time.Time) bool {
	if p.cachedSet == nil {
		return false
	}
	// 마지막으로 성공적으로 가져온 시점 기준으로 스테일 허용
	return now.Sub(p.lastGoodAt) <= p.StaleMaxAge
}

func (p *JWKSKeyProvider) refresh(ctx context.Context) error {
	p.refreshMutex.Lock()
	defer p.refreshMutex.Unlock()

	now := time.Now()
	if p.isFresh(now) {
		return nil
	}

	set, err := jwk.Fetch(ctx, p.URL, jwk.WithHTTPClient(p.getClient()))
	if err != nil {
		// JWKS 장애 시 스테일 허용 정책
		p.mu.RLock()
		staleOK := p.isStaleAllowed(now)
		p.mu.RUnlock()
		if staleOK {
			return nil
		}
		return err
	}

	p.mu.Lock()
	p.cachedSet = set
	p.cachedAt = now
	p.lastGoodAt = now
	p.mu.Unlock()
	return nil
}

func (p *JWKSKeyProvider) PublicKey(ctx context.Context, kid string) (crypto.PublicKey, error) {
	now := time.Now()

	p.mu.RLock()
	set := p.cachedSet
	fresh := p.isFresh(now)
	p.mu.RUnlock()

	if !fresh {
		_ = p.refresh(ctx)
		p.mu.RLock()
		set = p.cachedSet
		p.mu.RUnlock()
	}

	if set != nil {
		if key, ok := set.LookupKeyID(kid); ok {
			var pubkey crypto.PublicKey
			if err := key.Raw(&pubkey); err != nil {
				return nil, err
			}
			return pubkey, nil
		}
	}

	// 캐시에 없으면 강제 갱신 후 재시도 (로테이션 직후 대응)
	if err := p.refresh(ctx); err != nil {
		return nil, err
	}

	p.mu.RLock()
	set = p.cachedSet
	p.mu.RUnlock()

	if set != nil {
		if key, ok := set.LookupKeyID(kid); ok {
			var pubkey crypto.PublicKey
			if err := key.Raw(&pubkey); err != nil {
				return nil, err
			}
			return pubkey, nil
		}
	}

	return nil, ErrKeyNotFound
}

package auth

import (
	"context"
	"errors"
	"fmt"
	"strings"
	"time"

	"github.com/golang-jwt/jwt/v5"
)

type Verifier struct {
	Keys          *JWKSKeyProvider
	Issuer        string
	Audience      string
	ClockSkew     time.Duration
}

type Claims struct {
	jwt.RegisteredClaims
	Sub   string `json:"sub"`
	Email string `json:"email"`
	Role  string `json:"role"`
}

func (v *Verifier) Verify(ctx context.Context, tokenString string) (*Claims, error) {
	parser := jwt.NewParser(
		jwt.WithValidMethods([]string{jwt.SigningMethodRS256.Alg()}),
		jwt.WithAudience(v.Audience),
		jwt.WithIssuer(v.Issuer),
		jwt.WithLeeway(v.ClockSkew),
	)

	claims := &Claims{}

	keyFunc := func(t *jwt.Token) (any, error) {
		kid, _ := t.Header["kid"].(string)
		kid = strings.TrimSpace(kid)
		if kid == "" {
			return nil, errors.New("missing kid")
		}
		pub, err := v.Keys.PublicKey(ctx, kid)
		if err != nil {
			return nil, fmt.Errorf("public key: %w", err)
		}
		return pub, nil
	}

	tok, err := parser.ParseWithClaims(tokenString, claims, keyFunc)
	if err != nil {
		return nil, err
	}
	if !tok.Valid {
		return nil, errors.New("invalid token")
	}
	return claims, nil
}

package auth

import (
	"context"
	"net/http"
	"strings"
)

type ctxKey int

const claimsKey ctxKey = iota

func ClaimsFromContext(ctx context.Context) (*Claims, bool) {
	c, ok := ctx.Value(claimsKey).(*Claims)
	return c, ok
}

func JWTMiddleware(v *Verifier) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			authz := r.Header.Get("Authorization")
			if authz == "" {
				http.Error(w, "missing authorization", http.StatusUnauthorized)
				return
			}
			parts := strings.SplitN(authz, " ", 2)
			if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
				http.Error(w, "invalid authorization", http.StatusUnauthorized)
				return
			}

			claims, err := v.Verify(r.Context(), parts[1])
			if err != nil {
				http.Error(w, "unauthorized", http.StatusUnauthorized)
				return
			}

			ctx := context.WithValue(r.Context(), claimsKey, claims)
			next.ServeHTTP(w, r.WithContext(ctx))
		})
	}
}

package main

import (
	"net/http"
	"time"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"

	"example.com/myapp/auth"
)

func main() {
	r := chi.NewRouter()
	r.Use(middleware.RequestID)
	r.Use(middleware.RealIP)
	r.Use(middleware.Recoverer)

	kp := &auth.JWKSKeyProvider{
		URL:         "https://issuer.example.com/.well-known/jwks.json",
		CacheTTL:    5 * time.Minute,
		StaleMaxAge: 30 * time.Minute,
	}
	verifier := &auth.Verifier{
		Keys:      kp,
		Issuer:    "https://issuer.example.com/",
		Audience:  "my-api",
		ClockSkew: 30 * time.Second,
	}

	r.Group(func(pr chi.Router) {
		pr.Use(auth.JWTMiddleware(verifier))
		pr.Get("/me", func(w http.ResponseWriter, r *http.Request) {
			c, _ := auth.ClaimsFromContext(r.Context())
			w.Write([]byte("hello " + c.Sub))
		})
	})

	http.ListenAndServe(":8080", r)
}