JWT 검증 실패 - kid 불일치와 JWK 캐시 갱신법

{
  "alg": "RS256",
  "typ": "JWT",
  "kid": "a1b2c3d4"
}

# JWT 헤더만 디코드 (서명 검증 X)
python - <<'PY'
import base64, json, sys
jwt = sys.stdin.read().strip()
header = jwt.split('.')[0]
pad = '=' * (-len(header) % 4)
print(json.dumps(json.loads(base64.urlsafe_b64decode(header+pad)), indent=2))
PY <<<'eyJhbGciOiJSUzI1NiIsImtpZCI6ImExYjJjM2Q0In0.XXX.YYY'

JWKS_URI='https://idp.example.com/.well-known/jwks.json'
KID='a1b2c3d4'

curl -s "$JWKS_URI" | jq -r --arg kid "$KID" '.keys[] | select(.kid==$kid) | {kid,kty,alg,use,n,e,crv,x,y}'

// build.gradle: com.nimbusds:nimbus-jose-jwt

import com.nimbusds.jose.JWSAlgorithm;
import com.nimbusds.jose.JWSHeader;
import com.nimbusds.jose.crypto.RSASSAVerifier;
import com.nimbusds.jose.jwk.JWK;
import com.nimbusds.jose.jwk.JWKSet;
import com.nimbusds.jose.jwk.RSAKey;
import com.nimbusds.jwt.SignedJWT;

import java.net.URL;
import java.time.Duration;
import java.time.Instant;
import java.util.Optional;
import java.util.concurrent.locks.ReentrantLock;

public class JwksCachingVerifier {
    private final URL jwksUrl;
    private final Duration ttl;

    private volatile JWKSet cached;
    private volatile Instant cachedAt = Instant.EPOCH;

    private final ReentrantLock refreshLock = new ReentrantLock();

    public JwksCachingVerifier(URL jwksUrl, Duration ttl) {
        this.jwksUrl = jwksUrl;
        this.ttl = ttl;
    }

    public boolean verify(String jwtString) throws Exception {
        SignedJWT jwt = SignedJWT.parse(jwtString);
        JWSHeader header = jwt.getHeader();
        String kid = header.getKeyID();

        // 1) TTL 만료면 백그라운드/동기 갱신
        if (isExpired()) {
            refreshJwksIfNeeded();
        }

        // 2) 현재 캐시에서 kid 찾기
        Optional<RSAKey> key = findRsaKeyByKid(kid);

        // 3) kid 미스면 강제 갱신 후 1회 재시도
        if (key.isEmpty()) {
            forceRefresh();
            key = findRsaKeyByKid(kid);
        }

        if (key.isEmpty()) {
            throw new IllegalStateException("No matching JWK for kid=" + kid);
        }

        // 4) 알고리즘 검증(alg 혼동 공격 방지)
        if (!JWSAlgorithm.RS256.equals(header.getAlgorithm())) {
            throw new IllegalStateException("Unexpected alg=" + header.getAlgorithm());
        }

        return jwt.verify(new RSASSAVerifier(key.get().toRSAPublicKey()));
    }

    private boolean isExpired() {
        return Instant.now().isAfter(cachedAt.plus(ttl));
    }

    private Optional<RSAKey> findRsaKeyByKid(String kid) {
        JWKSet local = cached;
        if (local == null) return Optional.empty();
        for (JWK jwk : local.getKeys()) {
            if (kid != null && kid.equals(jwk.getKeyID()) && jwk instanceof RSAKey rsa) {
                return Optional.of(rsa);
            }
        }
        return Optional.empty();
    }

    private void refreshJwksIfNeeded() throws Exception {
        if (!refreshLock.tryLock()) return; // single-flight
        try {
            if (!isExpired()) return;
            cached = JWKSet.load(jwksUrl);
            cachedAt = Instant.now();
        } finally {
            refreshLock.unlock();
        }
    }

    private void forceRefresh() throws Exception {
        refreshLock.lock();
        try {
            cached = JWKSet.load(jwksUrl);
            cachedAt = Instant.now();
        } finally {
            refreshLock.unlock();
        }
    }
}

import express from "express";
import jwt from "jsonwebtoken";
import fetch from "node-fetch";
import jwkToPem from "jwk-to-pem";

const app = express();

const JWKS_URI = process.env.JWKS_URI;
const ISSUER = process.env.ISSUER;
const AUDIENCE = process.env.AUDIENCE;

const TTL_MS = 5 * 60 * 1000;
let cache = { jwks: null, fetchedAt: 0 };
let refreshing = null; // Promise for single-flight

async function loadJwks() {
  const res = await fetch(JWKS_URI, { timeout: 2000 });
  if (!res.ok) throw new Error(`JWKS fetch failed: ${res.status}`);
  return await res.json();
}

async function refreshIfNeeded(force = false) {
  const now = Date.now();
  const expired = now - cache.fetchedAt > TTL_MS;
  if (!force && cache.jwks && !expired) return;

  if (!refreshing) {
    refreshing = (async () => {
      const jwks = await loadJwks();
      cache = { jwks, fetchedAt: Date.now() };
    })().finally(() => {
      refreshing = null;
    });
  }
  await refreshing;
}

function findJwkByKid(jwks, kid) {
  return jwks?.keys?.find((k) => k.kid === kid);
}

async function verifyJwt(token) {
  const decodedHeader = JSON.parse(Buffer.from(token.split(".")[0], "base64").toString("utf8"));
  const kid = decodedHeader.kid;

  await refreshIfNeeded(false);
  let jwk = findJwkByKid(cache.jwks, kid);

  // kid 미스면 강제 갱신 후 1회 재시도
  if (!jwk) {
    await refreshIfNeeded(true);
    jwk = findJwkByKid(cache.jwks, kid);
  }
  if (!jwk) throw new Error(`No matching JWK for kid=${kid}`);

  const pem = jwkToPem(jwk);
  return jwt.verify(token, pem, {
    algorithms: ["RS256"],
    issuer: ISSUER,
    audience: AUDIENCE,
    clockTolerance: 5,
  });
}

app.get("/private", async (req, res) => {
  try {
    const token = (req.headers.authorization || "").replace("Bearer ", "");
    const claims = await verifyJwt(token);
    res.json({ ok: true, sub: claims.sub });
  } catch (e) {
    res.status(401).json({ ok: false, error: String(e.message || e) });
  }
});

app.listen(3000);