9장: 보안, 인증, 권한 관리

import jwt from "jsonwebtoken";
 
interface TokenPayload {
  sub: string;        // 사용자 ID
  aud: string;        // 대상 (이 MCP 서버)
  scope: string;      // 허용된 범위
  exp: number;        // 만료 시간
}
 
function validateToken(token: string): TokenPayload {
  // 1. 토큰 디코딩 및 서명 검증
  const payload = jwt.verify(token, PUBLIC_KEY, {
    algorithms: ["RS256"],
    audience: "mcp-server.example.com",  // 이 서버의 식별자
    issuer: "https://auth.example.com",  // 인증 서버
  }) as TokenPayload;
 
  // 2. 만료 여부 확인
  if (payload.exp < Date.now() / 1000) {
    throw new Error("토큰이 만료되었습니다.");
  }
 
  // 3. 대상(audience) 확인
  if (payload.aud !== "mcp-server.example.com") {
    throw new Error("이 서버를 대상으로 발급된 토큰이 아닙니다.");
  }
 
  return payload;
}

import crypto from "crypto";
 
class SessionManager {
  private sessions: Map<string, SessionData> = new Map();
 
  createSession(userId: string): string {
    // 1. 암호학적으로 안전한 랜덤 세션 ID 생성
    const sessionId = crypto.randomUUID();
 
    // 2. 사용자 ID와 세션 ID를 결합하여 키 생성
    const sessionKey = userId + ":" + sessionId;
 
    // 3. 세션 데이터 저장 (TTL 포함)
    this.sessions.set(sessionKey, {
      userId: userId,
      createdAt: Date.now(),
      expiresAt: Date.now() + 3600000,  // 1시간
    });
 
    return sessionId;
  }
 
  validateSession(sessionId: string, userId: string): boolean {
    const sessionKey = userId + ":" + sessionId;
    const session = this.sessions.get(sessionKey);
 
    if (!session) return false;
    if (session.expiresAt < Date.now()) {
      this.sessions.delete(sessionKey);
      return false;
    }
 
    return true;
  }
}

const TOOL_PERMISSIONS: Record<string, string[]> = {
  query: ["db:read"],
  execute: ["db:write"],
  create_issue: ["github:write"],
  list_issues: ["github:read"],
  delete_file: ["fs:write", "fs:delete"],
};
 
function checkPermission(
  toolName: string,
  userScopes: string[]
): boolean {
  const required = TOOL_PERMISSIONS[toolName];
  if (!required) return false;
 
  return required.every((scope) => userScopes.includes(scope));
}
 
// 도구 핸들러에서 권한 검증
server.tool("execute", "SQL을 실행합니다", {
  sql: z.string(),
}, async (params, extra) => {
  const token = extractToken(extra);
  const payload = validateToken(token);
 
  if (!checkPermission("execute", payload.scope.split(" "))) {
    return {
      content: [{
        type: "text" as const,
        text: "이 작업에 대한 권한이 없습니다. 필요한 권한: db:write",
      }],
      isError: true,
    };
  }
 
  // 쿼리 실행...
});

// 위험: 사용자 입력을 셸 명령에 직접 삽입
server.tool("list_dir", "디렉토리를 조회합니다", {
  path: z.string(),
}, async (params) => {
  // 공격자가 path에 "; rm -rf /"를 전달하면?
  const { stdout } = await execAsync("ls -la " + params.path);
  return { content: [{ type: "text", text: stdout }] };
});

import { execFile } from "child_process";
import { promisify } from "util";
import path from "path";
 
const execFileAsync = promisify(execFile);
 
server.tool("list_dir", "디렉토리를 조회합니다", {
  path: z.string(),
}, async (params) => {
  // 1. 경로 정규화 (경로 탈출 방지)
  const normalizedPath = path.resolve("/allowed/base", params.path);
 
  // 2. 허용된 경로 내인지 확인
  if (!normalizedPath.startsWith("/allowed/base")) {
    return {
      content: [{ type: "text" as const, text: "허용되지 않은 경로입니다." }],
      isError: true,
    };
  }
 
  // 3. execFile 사용 (셸을 거치지 않으므로 명령 주입 불가)
  const { stdout } = await execFileAsync("ls", ["-la", normalizedPath]);
  return { content: [{ type: "text" as const, text: stdout }] };
});

// 위험: 문자열 연결
const result = await pool.query(
  "SELECT * FROM users WHERE id = '" + params.userId + "'"
);
 
// 안전: 매개변수화된 쿼리
const result = await pool.query(
  "SELECT * FROM users WHERE id = $1",
  [params.userId]
);

function sanitizePath(basePath: string, userPath: string): string {
  // 1. 경로 정규화
  const resolved = path.resolve(basePath, userPath);
 
  // 2. 기본 경로 내인지 확인
  if (!resolved.startsWith(path.resolve(basePath))) {
    throw new Error("허용된 경로 범위를 벗어났습니다.");
  }
 
  // 3. 심볼릭 링크 확인 (옵션)
  const real = fs.realpathSync(resolved);
  if (!real.startsWith(path.resolve(basePath))) {
    throw new Error("심볼릭 링크가 허용된 범위를 벗어납니다.");
  }
 
  return resolved;
}

server.tool(
  "delete_file",
  "파일을 삭제합니다. 되돌릴 수 없는 작업입니다.",
  {
    path: z.string(),
    confirm: z.literal(true).describe("삭제를 확인합니다. 반드시 true여야 합니다."),
  },
  async (params) => {
    // 추가 안전장치: 보호된 파일 목록
    const protectedFiles = [".env", "config.json", "database.sqlite"];
    const filename = path.basename(params.path);
 
    if (protectedFiles.includes(filename)) {
      return {
        content: [{
          type: "text" as const,
          text: "보호된 파일은 삭제할 수 없습니다: " + filename,
        }],
        isError: true,
      };
    }
 
    await fs.promises.unlink(sanitizePath(WORKSPACE, params.path));
    return {
      content: [{ type: "text" as const, text: "파일이 삭제되었습니다." }],
    };
  }
);

function sanitizeOutput(text: string): string {
  // LLM에 대한 지시로 해석될 수 있는 패턴 제거
  return text
    .replace(/\[SYSTEM\].*?\[\/SYSTEM\]/gi, "[내용 제거됨]")
    .replace(/\[INST\].*?\[\/INST\]/gi, "[내용 제거됨]");
}

class RateLimiter {
  private counts: Map<string, { count: number; resetAt: number }> = new Map();
 
  check(userId: string, limit: number, windowMs: number): boolean {
    const now = Date.now();
    const entry = this.counts.get(userId);
 
    if (!entry || entry.resetAt < now) {
      this.counts.set(userId, { count: 1, resetAt: now + windowMs });
      return true;
    }
 
    if (entry.count >= limit) {
      return false;
    }
 
    entry.count += 1;
    return true;
  }
}
 
const rateLimiter = new RateLimiter();
 
// 도구 핸들러 내에서
if (!rateLimiter.check(userId, 60, 60000)) {
  return {
    content: [{ type: "text" as const, text: "요청이 너무 많습니다. 잠시 후 다시 시도하세요." }],
    isError: true,
  };
}

import { URL } from "url";
import dns from "dns/promises";
 
async function validateUrl(urlString: string): Promise<boolean> {
  const url = new URL(urlString);
 
  // 1. 허용된 프로토콜만 허용
  if (!["http:", "https:"].includes(url.protocol)) {
    return false;
  }
 
  // 2. 내부 IP 대역 차단
  const addresses = await dns.resolve4(url.hostname);
  for (const addr of addresses) {
    if (
      addr.startsWith("10.") ||
      addr.startsWith("172.16.") ||
      addr.startsWith("192.168.") ||
      addr.startsWith("127.") ||
      addr === "0.0.0.0" ||
      addr.startsWith("169.254.")  // 클라우드 메타데이터
    ) {
      return false;
    }
  }
 
  // 3. 허용된 도메인 화이트리스트
  const allowedDomains = ["api.github.com", "api.example.com"];
  if (!allowedDomains.includes(url.hostname)) {
    return false;
  }
 
  return true;
}

interface AuditLog {
  timestamp: string;
  userId: string;
  action: string;
  toolName: string;
  params: Record<string, unknown>;
  result: "success" | "error" | "denied";
  duration: number;
  ip?: string;
}
 
function logAudit(entry: AuditLog) {
  // 민감한 정보는 마스킹
  const sanitized = {
    ...entry,
    params: maskSensitiveFields(entry.params),
  };
 
  console.error(JSON.stringify(sanitized));
  // 실제 구현에서는 외부 로깅 시스템에 전송
}
 
function maskSensitiveFields(
  params: Record<string, unknown>
): Record<string, unknown> {
  const sensitiveKeys = ["password", "token", "secret", "key", "credential"];
  const masked = { ...params };
 
  for (const key of Object.keys(masked)) {
    if (sensitiveKeys.some((s) => key.toLowerCase().includes(s))) {
      masked[key] = "[MASKED]";
    }
  }
 
  return masked;
}