// Header: 알고리즘과 토큰 유형
interface JwtHeader {
  alg: "RS256" | "ES256" | "EdDSA"; // 서명 알고리즘
  typ: "JWT";                        // 토큰 유형
  kid?: string;                      // 서명 키 ID (키 로테이션용)
}
 
// Payload: 등록 클레임 + 커스텀 클레임
interface JwtPayload {
  // 등록 클레임 (RFC 7519)
  iss: string;  // 발행자 (Issuer)
  sub: string;  // 주체 (Subject) - 사용자 ID
  aud: string;  // 수신자 (Audience)
  exp: number;  // 만료 시간 (UNIX timestamp)
  nbf: number;  // 유효 시작 시간 (Not Before)
  iat: number;  // 발행 시간 (Issued At)
  jti: string;  // 토큰 고유 ID (JWT ID)
 
  // 커스텀 클레임
  roles?: string[];
  permissions?: string[];
  tenant_id?: string;
}

import { createRemoteJWKSet, jwtVerify } from "jose";
import type { JWTPayload, JWTVerifyResult } from "jose";
 
// JWKS(JSON Web Key Set) 원격 키 세트 생성
// 인가 서버의 공개키를 자동으로 가져오고 캐싱합니다
const jwks = createRemoteJWKSet(
  new URL("https://auth.example.com/.well-known/jwks.json")
);
 
interface VerifiedToken extends JWTPayload {
  sub: string;
  roles: string[];
  tenant_id: string;
}
 
async function verifyAccessToken(
  token: string,
): Promise<VerifiedToken> {
  try {
    const result: JWTVerifyResult = await jwtVerify(token, jwks, {
      issuer: "https://auth.example.com",
      audience: "https://api.example.com",
      algorithms: ["RS256", "ES256"],
      // 시계 오차 허용 (초 단위)
      clockTolerance: 30,
    });
 
    const payload = result.payload as VerifiedToken;
 
    // 필수 클레임 검증
    if (!payload.sub) {
      throw new Error("sub 클레임이 없습니다.");
    }
 
    return payload;
  } catch (error) {
    if (error instanceof Error) {
      if (error.message.includes("expired")) {
        throw new TokenExpiredError("토큰이 만료되었습니다.");
      }
      if (error.message.includes("signature")) {
        throw new InvalidTokenError("토큰 서명이 유효하지 않습니다.");
      }
    }
    throw new InvalidTokenError("토큰 검증에 실패했습니다.");
  }
}

interface RefreshTokenRecord {
  tokenHash: string;       // 토큰 해시값
  familyId: string;        // 토큰 패밀리 ID
  userId: string;
  clientId: string;
  isUsed: boolean;         // 사용 여부
  expiresAt: Date;
  createdAt: Date;
}
 
async function rotateRefreshToken(
  currentToken: string,
): Promise<TokenPair> {
  const tokenHash = hashToken(currentToken);
  const record = await findRefreshToken(tokenHash);
 
  if (!record) {
    throw new InvalidTokenError("유효하지 않은 리프레시 토큰입니다.");
  }
 
  // 이미 사용된 토큰이 다시 사용됨 = 탈취 의심
  if (record.isUsed) {
    // 해당 토큰 패밀리 전체 무효화
    await invalidateTokenFamily(record.familyId);
    throw new TokenReuseDetectedError(
      "리프레시 토큰 재사용이 감지되었습니다. 모든 세션이 무효화됩니다."
    );
  }
 
  // 기존 토큰을 사용됨으로 표시
  await markTokenAsUsed(tokenHash);
 
  // 새 토큰 쌍 생성
  const newAccessToken = await generateAccessToken(record.userId);
  const newRefreshToken = await generateRefreshToken();
 
  // 새 리프레시 토큰 저장 (같은 패밀리)
  await saveRefreshToken({
    tokenHash: hashToken(newRefreshToken),
    familyId: record.familyId,
    userId: record.userId,
    clientId: record.clientId,
    isUsed: false,
    expiresAt: addDays(new Date(), 30),
    createdAt: new Date(),
  });
 
  return {
    accessToken: newAccessToken,
    refreshToken: newRefreshToken,
  };
}

import { serialize } from "cookie";
 
function setTokenCookies(
  accessToken: string,
  refreshToken: string,
): string[] {
  const accessCookie = serialize("access_token", accessToken, {
    httpOnly: true,    // JavaScript에서 접근 불가
    secure: true,      // HTTPS에서만 전송
    sameSite: "lax",   // CSRF 기본 방어
    path: "/api",      // API 경로에만 전송
    maxAge: 300,       // 5분 (액세스 토큰 수명)
  });
 
  const refreshCookie = serialize("refresh_token", refreshToken, {
    httpOnly: true,
    secure: true,
    sameSite: "strict", // 더 엄격한 CSRF 방어
    path: "/api/auth/refresh", // 갱신 엔드포인트에만 전송
    maxAge: 30 * 24 * 60 * 60, // 30일
  });
 
  return [accessCookie, refreshCookie];
}

// 모듈 스코프 변수 - 클로저로 보호
let accessToken: string | null = null;
 
// 토큰 설정 (로그인 또는 갱신 후)
export function setAccessToken(token: string): void {
  accessToken = token;
  // 만료 전 자동 갱신 스케줄링
  scheduleTokenRefresh(token);
}
 
// 토큰 가져오기 (API 요청 시)
export function getAccessToken(): string | null {
  return accessToken;
}
 
// 토큰 삭제 (로그아웃 시)
export function clearAccessToken(): void {
  accessToken = null;
}
 
// 만료 전 자동 갱신
function scheduleTokenRefresh(token: string): void {
  const payload = parseJwtPayload(token);
  const expiresIn = payload.exp * 1000 - Date.now();
  // 만료 1분 전에 갱신
  const refreshAt = expiresIn - 60 * 1000;
 
  if (refreshAt > 0) {
    setTimeout(async () => {
      try {
        const response = await fetch("/api/auth/refresh", {
          method: "POST",
          credentials: "include", // httpOnly 쿠키 포함
        });
        const data = await response.json();
        setAccessToken(data.access_token);
      } catch {
        // 갱신 실패 시 로그아웃 처리
        clearAccessToken();
        window.location.href = "/login";
      }
    }, refreshAt);
  }
}

import { Router } from "express";
import session from "express-session";
 
const router = Router();
 
// 로그인 시작 - 인가 서버로 리다이렉트
router.get("/auth/login", (req, res) => {
  const codeVerifier = generateCodeVerifier();
  const codeChallenge = generateCodeChallenge(codeVerifier);
  const state = generateState();
 
  // PKCE verifier와 state를 세션에 저장
  req.session.codeVerifier = codeVerifier;
  req.session.state = state;
 
  const authUrl = buildAuthorizationUrl({
    authorizationEndpoint: AUTH_SERVER_URL + "/authorize",
    clientId: CLIENT_ID,
    redirectUri: BFF_URL + "/auth/callback",
    scopes: ["openid", "profile", "email"],
    codeChallenge,
    state,
  });
 
  res.redirect(authUrl);
});
 
// 콜백 처리 - 토큰 교환
router.get("/auth/callback", async (req, res) => {
  const { code, state } = req.query;
 
  if (state !== req.session.state) {
    return res.status(403).json({ error: "State mismatch" });
  }
 
  const tokens = await exchangeCodeForTokens({
    tokenEndpoint: AUTH_SERVER_URL + "/token",
    clientId: CLIENT_ID,
    clientSecret: CLIENT_SECRET, // BFF는 Confidential Client
    code: code as string,
    redirectUri: BFF_URL + "/auth/callback",
    codeVerifier: req.session.codeVerifier,
  });
 
  // 토큰을 서버 세션에 저장 (브라우저에는 전달하지 않음)
  req.session.accessToken = tokens.access_token;
  req.session.refreshToken = tokens.refresh_token;
  req.session.tokenExpiresAt = Date.now() + tokens.expires_in * 1000;
 
  // SPA 메인 페이지로 리다이렉트
  res.redirect("/");
});
 
// API 프록시 - 토큰을 붙여서 백엔드 API 호출
router.all("/api/*", async (req, res) => {
  // 세션에서 토큰 가져오기
  let accessToken = req.session.accessToken;
 
  // 토큰 만료 체크 및 갱신
  if (Date.now() >= (req.session.tokenExpiresAt ?? 0)) {
    const newTokens = await refreshTokens(req.session.refreshToken);
    req.session.accessToken = newTokens.access_token;
    req.session.refreshToken = newTokens.refresh_token;
    req.session.tokenExpiresAt =
      Date.now() + newTokens.expires_in * 1000;
    accessToken = newTokens.access_token;
  }
 
  // 백엔드 API로 프록시
  const apiPath = req.path.replace(/^\/api/, "");
  const apiResponse = await fetch(`${API_SERVER_URL}${apiPath}`, {
    method: req.method,
    headers: {
      ...req.headers,
      Authorization: `Bearer ${accessToken}`,
      host: new URL(API_SERVER_URL).host,
    },
    body: req.method !== "GET" ? JSON.stringify(req.body) : undefined,
  });
 
  res.status(apiResponse.status);
  const data = await apiResponse.json();
  res.json(data);
});
 
export default router;

import { Redis } from "ioredis";
 
const redis = new Redis(process.env.REDIS_URL);
 
// 토큰 차단 목록에 추가
async function revokeToken(jti: string, expiresAt: number): Promise<void> {
  const ttl = expiresAt - Math.floor(Date.now() / 1000);
  if (ttl > 0) {
    // 토큰의 남은 수명만큼만 차단 목록에 유지
    await redis.setex(`revoked:${jti}`, ttl, "1");
  }
}
 
// 토큰이 폐기되었는지 확인
async function isTokenRevoked(jti: string): Promise<boolean> {
  const result = await redis.get(`revoked:${jti}`);
  return result !== null;
}
 
// 미들웨어에서 사용
async function authMiddleware(req: Request, res: Response, next: NextFunction) {
  const token = extractBearerToken(req);
  const payload = await verifyAccessToken(token);
 
  // 차단 목록 확인
  if (payload.jti && await isTokenRevoked(payload.jti)) {
    return res.status(401).json({ error: "토큰이 폐기되었습니다." });
  }
 
  req.user = payload;
  next();
}