JWT kid 헤더 공격 막기 - JWK 캐시·검증 실전

import java.time.Duration;
import java.time.Instant;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

// 개념 예시: issuer별 JWKS 캐시
public final class JwksCache {

  public static final class Entry {
    public final String jwksJson;
    public final Instant fetchedAt;

    public Entry(String jwksJson, Instant fetchedAt) {
      this.jwksJson = jwksJson;
      this.fetchedAt = fetchedAt;
    }
  }

  private final Map<String, Entry> cache = new ConcurrentHashMap<>();
  private final Map<String, ReentrantLock> locks = new ConcurrentHashMap<>();

  private final Duration ttl = Duration.ofMinutes(10);
  private final Duration staleTtl = Duration.ofHours(6); // SWR: 최대 허용 stale

  public Entry getOrFetch(String issuer, JwksFetcher fetcher) {
    Entry e = cache.get(issuer);
    if (e != null && !isExpired(e)) {
      return e;
    }

    // singleflight: issuer별 갱신은 1개만
    ReentrantLock lock = locks.computeIfAbsent(issuer, k -> new ReentrantLock());
    lock.lock();
    try {
      Entry again = cache.get(issuer);
      if (again != null && !isExpired(again)) {
        return again;
      }

      // 만료됐더라도 stale 허용 범위면 우선 반환 + 백그라운드 갱신 같은 패턴도 가능
      // 여기서는 단순화를 위해 동기 갱신
      String jwksJson = fetcher.fetch(issuer);
      Entry fresh = new Entry(jwksJson, Instant.now());
      cache.put(issuer, fresh);
      return fresh;

    } finally {
      lock.unlock();
    }
  }

  public Optional<Entry> getStaleIfAllowed(String issuer) {
    Entry e = cache.get(issuer);
    if (e == null) return Optional.empty();

    Instant now = Instant.now();
    if (now.isBefore(e.fetchedAt.plus(staleTtl))) {
      return Optional.of(e);
    }
    return Optional.empty();
  }

  public void forceRefresh(String issuer, JwksFetcher fetcher) {
    String jwksJson = fetcher.fetch(issuer);
    cache.put(issuer, new Entry(jwksJson, Instant.now()));
  }

  private boolean isExpired(Entry e) {
    return Instant.now().isAfter(e.fetchedAt.plus(ttl));
  }

  public interface JwksFetcher {
    String fetch(String issuer);
  }
}

public final class JwtVerifier {

  private final JwksCache jwksCache;
  private final Map<String, String> issuerToJwksUri; // issuer별 고정 매핑

  public JwtVerifier(JwksCache jwksCache, Map<String, String> issuerToJwksUri) {
    this.jwksCache = jwksCache;
    this.issuerToJwksUri = issuerToJwksUri;
  }

  public VerifiedClaims verify(String jwt) {
    ParsedJwt p = ParsedJwt.parse(jwt);

    // 1) alg allowlist
    if (!p.alg().equals("RS256")) {
      throw new Unauthorized("alg not allowed");
    }

    // 2) issuer allowlist
    String iss = p.issuer();
    String jwksUri = issuerToJwksUri.get(iss);
    if (jwksUri == null) {
      throw new Unauthorized("unknown issuer");
    }

    // 3) 캐시로 검증 시도
    JwksCache.Entry entry = jwksCache.getOrFetch(iss, (issuer) -> HttpJwksFetcher.fetch(jwksUri));

    boolean ok = Crypto.verifyWithJwks(entry.jwksJson, p);
    if (ok) {
      return ClaimsValidator.validate(p);
    }

    // 4) 키 회전 대응: 1회 강제 갱신 후 재검증
    jwksCache.forceRefresh(iss, (issuer) -> HttpJwksFetcher.fetch(jwksUri));
    JwksCache.Entry refreshed = jwksCache.getOrFetch(iss, (issuer) -> HttpJwksFetcher.fetch(jwksUri));

    boolean ok2 = Crypto.verifyWithJwks(refreshed.jwksJson, p);
    if (!ok2) {
      throw new Unauthorized("signature invalid");
    }

    return ClaimsValidator.validate(p);
  }

  // 아래 타입들은 예시용
  public record VerifiedClaims(String sub, String aud) {}
  public static final class Unauthorized extends RuntimeException {
    public Unauthorized(String m) { super(m); }
  }
}

import { jwtVerify, createRemoteJWKSet } from 'jose'

// issuer allowlist + jwksUri 고정
const issuers = new Map([
  ['https://idp.example.com', 'https://idp.example.com/.well-known/jwks.json'],
])

// issuer별 RemoteJWKSet 캐시
const jwkSetByIssuer = new Map()

function getJwks(iss) {
  const jwksUri = issuers.get(iss)
  if (!jwksUri) throw new Error('unknown issuer')

  let jwks = jwkSetByIssuer.get(iss)
  if (!jwks) {
    jwks = createRemoteJWKSet(new URL(jwksUri))
    jwkSetByIssuer.set(iss, jwks)
  }
  return jwks
}

export async function verifyAccessToken(token) {
  // 헤더/페이로드에서 iss를 먼저 읽고 싶은 유혹이 있지만,
  // 실제로는 라이브러리의 안전한 파싱/검증 흐름을 따르는 편이 낫습니다.
  // 여기서는 예시로 "issuer는 검증 결과의 payload.iss로 확인" 패턴을 사용합니다.

  // 1차 검증은 임시로 모든 issuer를 허용할 수 없으니,
  // 보통은 라우팅 레벨에서 issuer를 결정하거나, 테넌트별 엔드포인트를 분리합니다.

  // 예시: 단일 issuer만 쓴다는 가정
  const iss = 'https://idp.example.com'
  const JWKS = getJwks(iss)

  const { payload, protectedHeader } = await jwtVerify(token, JWKS, {
    issuer: iss,
    audience: 'api://my-service',
    algorithms: ['RS256'],
  })

  // 추가 정책 검증
  if (typeof payload.sub !== 'string') throw new Error('invalid sub')

  return { sub: payload.sub, kid: protectedHeader.kid }
}