GET /api/v1/data HTTP/1.1
Host: api.example.com
X-API-Key: sk_live_a1b2c3d4e5f6g7h8i9j0

import crypto from "crypto";
 
interface ApiKey {
  id: string;
  hashedKey: string;       // 키의 해시값만 저장
  prefix: string;          // 식별용 접두어 (sk_live_a1b2)
  name: string;            // 키 이름 (사용처 설명)
  clientId: string;        // 소유자
  scopes: string[];        // 허용 범위
  rateLimit: number;       // 분당 요청 제한
  expiresAt: Date | null;  // 만료일 (null이면 무기한)
  lastUsedAt: Date | null;
  createdAt: Date;
}
 
function generateApiKey(): { key: string; prefix: string; hash: string } {
  // 32바이트 랜덤 키 생성
  const rawKey = crypto.randomBytes(32).toString("base64url");
  const key = `sk_live_${rawKey}`;
  const prefix = key.substring(0, 12);
  const hash = crypto
    .createHash("sha256")
    .update(key)
    .digest("hex");
 
  return { key, prefix, hash };
}
 
async function validateApiKey(
  providedKey: string,
): Promise<ApiKey | null> {
  const hash = crypto
    .createHash("sha256")
    .update(providedKey)
    .digest("hex");
 
  const apiKey = await findApiKeyByHash(hash);
 
  if (!apiKey) return null;
 
  // 만료 확인
  if (apiKey.expiresAt && apiKey.expiresAt < new Date()) {
    return null;
  }
 
  // 사용 시간 업데이트
  await updateLastUsed(apiKey.id);
 
  return apiKey;
}

interface ServiceTokenCache {
  token: string;
  expiresAt: number;
}
 
// 서비스 토큰 캐시 (토큰 재사용)
const tokenCache = new Map<string, ServiceTokenCache>();
 
async function getServiceToken(
  targetService: string,
  scopes: string[],
): Promise<string> {
  const cacheKey = `${targetService}:${scopes.join(",")}`;
  const cached = tokenCache.get(cacheKey);
 
  // 만료 1분 전까지 캐시된 토큰 재사용
  if (cached && cached.expiresAt > Date.now() + 60000) {
    return cached.token;
  }
 
  const response = await fetch(AUTH_SERVER_TOKEN_URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/x-www-form-urlencoded",
      Authorization: `Basic ${btoa(`${CLIENT_ID}:${CLIENT_SECRET}`)}`,
    },
    body: new URLSearchParams({
      grant_type: "client_credentials",
      scope: scopes.join(" "),
      audience: `https://${targetService}.internal`,
    }),
  });
 
  const data = await response.json();
 
  tokenCache.set(cacheKey, {
    token: data.access_token,
    expiresAt: Date.now() + data.expires_in * 1000,
  });
 
  return data.access_token;
}
 
// 서비스 간 호출 시 사용
async function callOrderService(orderId: string) {
  const token = await getServiceToken("order-service", ["orders:read"]);
 
  return fetch(`https://order-service.internal/api/orders/${orderId}`, {
    headers: {
      Authorization: `Bearer ${token}`,
    },
  });
}

import https from "https";
import fs from "fs";
 
// 서버 측 설정
const serverOptions: https.ServerOptions = {
  // 서버 인증서
  key: fs.readFileSync("/certs/server-key.pem"),
  cert: fs.readFileSync("/certs/server-cert.pem"),
 
  // CA 인증서 (클라이언트 인증서 검증용)
  ca: fs.readFileSync("/certs/ca-cert.pem"),
 
  // 클라이언트 인증서 요구
  requestCert: true,
  rejectUnauthorized: true,
};
 
const server = https.createServer(serverOptions, (req, res) => {
  // 클라이언트 인증서 정보 추출
  const clientCert = req.socket.getPeerCertificate();
 
  if (!clientCert || !clientCert.subject) {
    res.writeHead(403);
    res.end("클라이언트 인증서가 필요합니다.");
    return;
  }
 
  // 인증서의 CN(Common Name)으로 서비스 식별
  const serviceName = clientCert.subject.CN;
  console.log(`인증된 서비스: ${serviceName}`);
 
  // 서비스별 권한 확인
  if (!isAuthorized(serviceName, req.url ?? "", req.method ?? "")) {
    res.writeHead(403);
    res.end("해당 작업에 대한 권한이 없습니다.");
    return;
  }
 
  // 요청 처리
  handleRequest(req, res);
});

import https from "https";
import fs from "fs";
 
// 클라이언트 측 설정
const clientOptions: https.RequestOptions = {
  hostname: "order-service.internal",
  port: 443,
  path: "/api/orders",
  method: "GET",
 
  // 클라이언트 인증서
  key: fs.readFileSync("/certs/client-key.pem"),
  cert: fs.readFileSync("/certs/client-cert.pem"),
 
  // 서버 CA 인증서
  ca: fs.readFileSync("/certs/ca-cert.pem"),
};
 
const req = https.request(clientOptions, (res) => {
  let data = "";
  res.on("data", (chunk) => { data += chunk; });
  res.on("end", () => {
    console.log("응답:", JSON.parse(data));
  });
});
req.end();

async function exchangeToken(config: {
  subjectToken: string;       // 현재 가진 토큰
  targetAudience: string;     // 대상 서비스
  requestedScopes: string[];  // 필요한 범위
}): Promise<string> {
  const response = await fetch(AUTH_SERVER_TOKEN_URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/x-www-form-urlencoded",
      Authorization: `Basic ${btoa(`${CLIENT_ID}:${CLIENT_SECRET}`)}`,
    },
    body: new URLSearchParams({
      grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
      subject_token: config.subjectToken,
      subject_token_type: "urn:ietf:params:oauth:token-type:access_token",
      audience: config.targetAudience,
      scope: config.requestedScopes.join(" "),
    }),
  });
 
  const data = await response.json();
  return data.access_token;
}
 
// 서비스 A에서 서비스 B 호출 시
async function callServiceB(userToken: string, orderId: string) {
  // 사용자 토큰을 서비스 B 전용 토큰으로 교환
  const serviceBToken = await exchangeToken({
    subjectToken: userToken,
    targetAudience: "https://service-b.internal",
    requestedScopes: ["orders:read"],
  });
 
  return fetch(`https://service-b.internal/api/orders/${orderId}`, {
    headers: { Authorization: `Bearer ${serviceBToken}` },
  });
}

import { SignJWT, jwtVerify } from "jose";
 
// API 게이트웨이: 사용자 컨텍스트 생성
async function createUserContext(
  userToken: JwtPayload,
): Promise<string> {
  // 필요한 최소 정보만 포함
  const context = await new SignJWT({
    sub: userToken.sub,
    roles: userToken.roles,
    tenant_id: userToken.tenant_id,
    // 원본 토큰의 만료 시간을 유지
    original_exp: userToken.exp,
  })
    .setProtectedHeader({ alg: "ES256" })
    .setIssuedAt()
    .setExpirationTime("5m") // 짧은 수명
    .setIssuer("api-gateway")
    .sign(GATEWAY_PRIVATE_KEY);
 
  return context;
}
 
// 내부 서비스: 사용자 컨텍스트 검증
async function verifyUserContext(
  contextHeader: string,
): Promise<UserContext> {
  const { payload } = await jwtVerify(
    contextHeader,
    GATEWAY_PUBLIC_KEY,
    {
      issuer: "api-gateway",
      algorithms: ["ES256"],
    }
  );
 
  return {
    userId: payload.sub as string,
    roles: payload.roles as string[],
    tenantId: payload.tenant_id as string,
  };
}

import type { Request, Response, NextFunction } from "express";
 
interface AuthConfig {
  publicPaths: string[];     // 인증 불필요 경로
  apiKeyPaths: string[];     // API 키 인증 경로
  oauthPaths: string[];      // OAuth 인증 경로
}
 
function gatewayAuthMiddleware(config: AuthConfig) {
  return async (req: Request, res: Response, next: NextFunction) => {
    const path = req.path;
 
    // 1. 공개 경로 확인
    if (config.publicPaths.some((p) => path.startsWith(p))) {
      return next();
    }
 
    // 2. API 키 인증 경로
    if (config.apiKeyPaths.some((p) => path.startsWith(p))) {
      const apiKey = req.headers["x-api-key"] as string;
      if (!apiKey) {
        return res.status(401).json({ error: "API 키가 필요합니다." });
      }
 
      const keyData = await validateApiKey(apiKey);
      if (!keyData) {
        return res.status(401).json({ error: "유효하지 않은 API 키입니다." });
      }
 
      // 스코프 확인
      const requiredScope = getRequiredScope(req.method, path);
      if (!keyData.scopes.includes(requiredScope)) {
        return res.status(403).json({ error: "해당 API에 대한 권한이 없습니다." });
      }
 
      req.headers["x-client-id"] = keyData.clientId;
      req.headers["x-auth-method"] = "api-key";
      return next();
    }
 
    // 3. OAuth 토큰 인증
    const authHeader = req.headers.authorization;
    if (!authHeader?.startsWith("Bearer ")) {
      return res.status(401).json({ error: "Bearer 토큰이 필요합니다." });
    }
 
    const token = authHeader.substring(7);
 
    try {
      const payload = await verifyAccessToken(token);
 
      // 사용자 정보를 헤더로 전달
      req.headers["x-user-id"] = payload.sub;
      req.headers["x-user-roles"] = JSON.stringify(payload.roles);
      req.headers["x-tenant-id"] = payload.tenant_id;
      req.headers["x-auth-method"] = "oauth";
 
      // Authorization 헤더 제거 (내부 서비스에 원본 토큰 전달 안 함)
      delete req.headers.authorization;
 
      next();
    } catch (error) {
      if (error instanceof TokenExpiredError) {
        return res.status(401).json({ error: "토큰이 만료되었습니다." });
      }
      return res.status(401).json({ error: "유효하지 않은 토큰입니다." });
    }
  };
}