2026년 모던 인증: JWT, 세션, OAuth, 그리고 Passkey

// 간략화된 세션 생성
import { randomBytes } from "crypto";
import { cookies } from "next/headers";
 
interface Session {
  userId: string;
  createdAt: Date;
  expiresAt: Date;
  ipAddress: string;
  userAgent: string;
}
 
async function createSession(userId: string, request: Request): Promise<string> {
  const sessionId = randomBytes(32).toString("hex");
 
  const session: Session = {
    userId,
    createdAt: new Date(),
    expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24시간
    ipAddress: request.headers.get("x-forwarded-for") ?? "unknown",
    userAgent: request.headers.get("user-agent") ?? "unknown",
  };
 
  // 데이터베이스 또는 Redis에 저장
  await redis.set(`session:${sessionId}`, JSON.stringify(session), "EX", 86400);
 
  const cookieStore = await cookies();
  cookieStore.set("session_id", sessionId, {
    httpOnly: true,
    secure: true,
    sameSite: "lax",
    maxAge: 86400,
    path: "/",
  });
 
  return sessionId;
}

import { SignJWT, jwtVerify } from "jose";
 
const secret = new TextEncoder().encode(process.env.JWT_SECRET);
 
async function createAccessToken(userId: string, role: string): Promise<string> {
  return new SignJWT({ sub: userId, role })
    .setProtectedHeader({ alg: "HS256" })
    .setIssuedAt()
    .setExpirationTime("15m")
    .setIssuer("https://akousa.net")
    .setAudience("https://akousa.net")
    .sign(secret);
}
 
async function verifyAccessToken(token: string) {
  try {
    const { payload } = await jwtVerify(token, secret, {
      issuer: "https://akousa.net",
      audience: "https://akousa.net",
    });
    return payload;
  } catch {
    return null;
  }
}

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

{
  "sub": "user_123",       // Subject (누구에 대한 것인가)
  "iss": "https://auth.example.com",  // Issuer (누가 생성했는가)
  "aud": "https://api.example.com",   // Audience (누가 수락해야 하는가)
  "iat": 1709312000,       // Issued At (Unix 타임스탬프)
  "exp": 1709312900,       // Expiration (Unix 타임스탬프)
  "role": "admin"          // 커스텀 클레임
}

import { SignJWT, jwtVerify, importPKCS8, importSPKI } from "jose";
 
// RS256 — 여러 서비스가 토큰을 검증할 때 사용
const privateKeyPem = process.env.JWT_PRIVATE_KEY!;
const publicKeyPem = process.env.JWT_PUBLIC_KEY!;
 
async function signWithRS256(payload: Record<string, unknown>) {
  const privateKey = await importPKCS8(privateKeyPem, "RS256");
 
  return new SignJWT(payload)
    .setProtectedHeader({ alg: "RS256", typ: "JWT" })
    .setIssuedAt()
    .setExpirationTime("15m")
    .sign(privateKey);
}
 
async function verifyWithRS256(token: string) {
  const publicKey = await importSPKI(publicKeyPem, "RS256");
 
  const { payload } = await jwtVerify(token, publicKey, {
    algorithms: ["RS256"], // 핵심: 항상 알고리즘을 제한하라
  });
 
  return payload;
}

// 취약 — 절대 이렇게 하지 마라
function verifyJwt(token: string) {
  const [headerB64, payloadB64, signature] = token.split(".");
  const header = JSON.parse(atob(headerB64));
 
  if (header.alg === "none") {
    // "서명이 필요 없다" — 치명적
    return JSON.parse(atob(payloadB64));
  }
 
  // ... 서명 검증
}

// 안전 — 알고리즘이 하드코딩되어 있고, 토큰에서 읽지 않는다
const { payload } = await jwtVerify(token, key, {
  algorithms: ["RS256"], // RS256만 수락 — 헤더를 무시
});

import { randomBytes } from "crypto";
 
interface RefreshTokenRecord {
  tokenHash: string;
  userId: string;
  familyId: string;  // 관련 토큰을 그룹화
  used: boolean;
  expiresAt: Date;
  createdAt: Date;
}
 
async function issueTokenPair(userId: string) {
  const familyId = randomBytes(16).toString("hex");
 
  const accessToken = await createAccessToken(userId);
  const refreshToken = randomBytes(64).toString("hex");
  const refreshTokenHash = await hashToken(refreshToken);
 
  // 리프레시 토큰 레코드 저장
  await db.refreshToken.create({
    data: {
      tokenHash: refreshTokenHash,
      userId,
      familyId,
      used: false,
      expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
      createdAt: new Date(),
    },
  });
 
  return { accessToken, refreshToken };
}

async function rotateTokens(incomingRefreshToken: string) {
  const tokenHash = await hashToken(incomingRefreshToken);
  const record = await db.refreshToken.findUnique({
    where: { tokenHash },
  });
 
  if (!record) {
    // 토큰이 존재하지 않음 — 탈취 가능성
    return null;
  }
 
  if (record.expiresAt < new Date()) {
    // 토큰 만료
    await db.refreshToken.delete({ where: { tokenHash } });
    return null;
  }
 
  if (record.used) {
    // 이 토큰은 이미 사용되었다.
    // 누군가 리플레이하고 있다 — 합법적인 사용자이거나
    // 공격자이거나. 어느 쪽이든 전체 패밀리를 죽인다.
    await db.refreshToken.deleteMany({
      where: { familyId: record.familyId },
    });
 
    console.error(
      `사용자 ${record.userId}, 패밀리 ${record.familyId}에서 리프레시 토큰 재사용 감지. 패밀리의 모든 토큰 무효화.`
    );
 
    return null;
  }
 
  // 현재 토큰을 사용됨으로 표시 (삭제하지 마라 — 재사용 감지에 필요)
  await db.refreshToken.update({
    where: { tokenHash },
    data: { used: true },
  });
 
  // 같은 패밀리 ID로 새 쌍 발급
  const newRefreshToken = randomBytes(64).toString("hex");
  const newRefreshTokenHash = await hashToken(newRefreshToken);
 
  await db.refreshToken.create({
    data: {
      tokenHash: newRefreshTokenHash,
      userId: record.userId,
      familyId: record.familyId,  // 같은 패밀리
      used: false,
      expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
      createdAt: new Date(),
    },
  });
 
  const newAccessToken = await createAccessToken(record.userId);
 
  return { accessToken: newAccessToken, refreshToken: newRefreshToken };
}

import { randomBytes, createHash } from "crypto";
 
// 1단계: PKCE 값을 생성하고 사용자를 리다이렉트
function initiateOAuthFlow() {
  // 코드 검증자: 43-128자의 랜덤 문자열
  const codeVerifier = randomBytes(32)
    .toString("base64url")
    .slice(0, 43);
 
  // 코드 챌린지: 검증자의 SHA256 해시, base64url 인코딩
  const codeChallenge = createHash("sha256")
    .update(codeVerifier)
    .digest("base64url");
 
  // 상태: CSRF 보호를 위한 랜덤 값
  const state = randomBytes(16).toString("hex");
 
  // 리다이렉트하기 전에 둘 다 세션에 저장 (서버 측!)
  // 절대 code_verifier를 쿠키나 URL 파라미터에 넣지 마라
  session.codeVerifier = codeVerifier;
  session.oauthState = state;
 
  const authUrl = new URL("https://accounts.google.com/o/oauth2/v2/auth");
  authUrl.searchParams.set("client_id", process.env.GOOGLE_CLIENT_ID!);
  authUrl.searchParams.set("redirect_uri", "https://example.com/api/auth/callback/google");
  authUrl.searchParams.set("response_type", "code");
  authUrl.searchParams.set("scope", "openid email profile");
  authUrl.searchParams.set("state", state);
  authUrl.searchParams.set("code_challenge", codeChallenge);
  authUrl.searchParams.set("code_challenge_method", "S256");
 
  return authUrl.toString();
}

// 2단계: 콜백 처리
async function handleOAuthCallback(request: Request) {
  const url = new URL(request.url);
  const code = url.searchParams.get("code");
  const state = url.searchParams.get("state");
  const error = url.searchParams.get("error");
 
  // 프로바이더의 에러 확인
  if (error) {
    throw new Error(`OAuth 에러: ${error}`);
  }
 
  // 상태 일치 확인 (CSRF 보호)
  if (state !== session.oauthState) {
    throw new Error("상태 불일치 — CSRF 공격 가능성");
  }
 
  // 인가 코드를 토큰으로 교환
  const tokenResponse = await fetch("https://oauth2.googleapis.com/token", {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      grant_type: "authorization_code",
      code: code!,
      redirect_uri: "https://example.com/api/auth/callback/google",
      client_id: process.env.GOOGLE_CLIENT_ID!,
      client_secret: process.env.GOOGLE_CLIENT_SECRET!,
      code_verifier: session.codeVerifier, // PKCE: 이 플로우를 시작한 것이 우리임을 증명
    }),
  });
 
  const tokens = await tokenResponse.json();
  // tokens.access_token — Google API 호출용
  // tokens.id_token — 사용자 신원이 담긴 JWT (OIDC)
  // tokens.refresh_token — 새 액세스 토큰 발급용
 
  // 3단계: ID 토큰을 검증하고 사용자 정보 추출
  const idTokenPayload = await verifyGoogleIdToken(tokens.id_token);
 
  return {
    googleId: idTokenPayload.sub,
    email: idTokenPayload.email,
    name: idTokenPayload.name,
    picture: idTokenPayload.picture,
  };
}

// src/lib/auth.ts
import NextAuth from "next-auth";
import Google from "next-auth/providers/google";
import GitHub from "next-auth/providers/github";
import Credentials from "next-auth/providers/credentials";
import { PrismaAdapter } from "@auth/prisma-adapter";
import { prisma } from "@/lib/prisma";
import { verifyPassword } from "@/lib/password";
 
export const { handlers, auth, signIn, signOut } = NextAuth({
  adapter: PrismaAdapter(prisma),
 
  // 더 나은 보안을 위해 데이터베이스 세션 사용 (JWT가 아님)
  session: {
    strategy: "database",
    maxAge: 30 * 24 * 60 * 60, // 30일
    updateAge: 24 * 60 * 60,   // 24시간마다 세션 연장
  },
 
  providers: [
    Google({
      clientId: process.env.GOOGLE_CLIENT_ID!,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
      // 특정 스코프 요청
      authorization: {
        params: {
          scope: "openid email profile",
          prompt: "consent",
          access_type: "offline", // 리프레시 토큰 받기
        },
      },
    }),
 
    GitHub({
      clientId: process.env.GITHUB_CLIENT_ID!,
      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
    }),
 
    // 이메일/비밀번호 로그인 (주의해서 사용)
    Credentials({
      credentials: {
        email: { label: "이메일", type: "email" },
        password: { label: "비밀번호", type: "password" },
      },
      authorize: async (credentials) => {
        if (!credentials?.email || !credentials?.password) {
          return null;
        }
 
        const user = await prisma.user.findUnique({
          where: { email: credentials.email as string },
        });
 
        if (!user || !user.passwordHash) {
          return null;
        }
 
        const isValid = await verifyPassword(
          credentials.password as string,
          user.passwordHash
        );
 
        if (!isValid) {
          return null;
        }
 
        return {
          id: user.id,
          email: user.email,
          name: user.name,
          image: user.image,
        };
      },
    }),
  ],
 
  callbacks: {
    // 로그인 허용 여부 제어
    async signIn({ user, account }) {
      // 차단된 사용자의 로그인 거부
      if (user.id) {
        const dbUser = await prisma.user.findUnique({
          where: { id: user.id },
          select: { banned: true },
        });
        if (dbUser?.banned) return false;
      }
      return true;
    },
 
    // 세션에 커스텀 필드 추가
    async session({ session, user }) {
      if (session.user) {
        session.user.id = user.id;
        // 데이터베이스에서 역할 가져오기
        const dbUser = await prisma.user.findUnique({
          where: { id: user.id },
          select: { role: true },
        });
        session.user.role = dbUser?.role ?? "user";
      }
      return session;
    },
  },
 
  pages: {
    signIn: "/login",
    error: "/auth/error",
    verifyRequest: "/auth/verify",
  },
});

// src/app/api/auth/[...nextauth]/route.ts
import { handlers } from "@/lib/auth";
 
export const { GET, POST } = handlers;

// src/middleware.ts
import { auth } from "@/lib/auth";
import { NextResponse } from "next/server";
 
export default auth((req) => {
  const isLoggedIn = !!req.auth;
  const isAuthPage = req.nextUrl.pathname.startsWith("/login")
    || req.nextUrl.pathname.startsWith("/register");
  const isProtectedRoute = req.nextUrl.pathname.startsWith("/dashboard")
    || req.nextUrl.pathname.startsWith("/settings")
    || req.nextUrl.pathname.startsWith("/admin");
  const isAdminRoute = req.nextUrl.pathname.startsWith("/admin");
 
  // 로그인된 사용자를 인증 페이지에서 리다이렉트
  if (isLoggedIn && isAuthPage) {
    return NextResponse.redirect(new URL("/dashboard", req.nextUrl));
  }
 
  // 인증되지 않은 사용자를 로그인으로 리다이렉트
  if (!isLoggedIn && isProtectedRoute) {
    const callbackUrl = encodeURIComponent(req.nextUrl.pathname);
    return NextResponse.redirect(
      new URL(`/login?callbackUrl=${callbackUrl}`, req.nextUrl)
    );
  }
 
  // 관리자 역할 확인
  if (isAdminRoute && req.auth?.user?.role !== "admin") {
    return NextResponse.redirect(new URL("/dashboard", req.nextUrl));
  }
 
  return NextResponse.next();
});
 
export const config = {
  matcher: [
    "/dashboard/:path*",
    "/settings/:path*",
    "/admin/:path*",
    "/login",
    "/register",
  ],
};

// src/app/dashboard/page.tsx
import { auth } from "@/lib/auth";
import { redirect } from "next/navigation";
 
export default async function DashboardPage() {
  const session = await auth();
 
  if (!session?.user) {
    redirect("/login");
  }
 
  return (
    <div>
      <h1>환영합니다, {session.user.name}</h1>
      <p>역할: {session.user.role}</p>
    </div>
  );
}

"use client";
 
import { useSession } from "next-auth/react";
 
export function UserMenu() {
  const { data: session, status } = useSession();
 
  if (status === "loading") {
    return <div>로딩 중...</div>;
  }
 
  if (status === "unauthenticated") {
    return <a href="/login">로그인</a>;
  }
 
  return (
    <div>
      <img
        src={session?.user?.image ?? "/default-avatar.png"}
        alt={session?.user?.name ?? "사용자"}
      />
      <span>{session?.user?.name}</span>
    </div>
  );
}

// 서버 측: 등록
import {
  generateRegistrationOptions,
  verifyRegistrationResponse,
} from "@simplewebauthn/server";
import type {
  GenerateRegistrationOptionsOpts,
  VerifiedRegistrationResponse,
} from "@simplewebauthn/server";
 
const rpName = "akousa.net";
const rpID = "akousa.net";
const origin = "https://akousa.net";
 
async function startRegistration(userId: string, userEmail: string) {
  // 사용자의 기존 Passkey를 가져와 제외
  const existingCredentials = await db.credential.findMany({
    where: { userId },
    select: { credentialId: true, transports: true },
  });
 
  const options: GenerateRegistrationOptionsOpts = {
    rpName,
    rpID,
    userID: new TextEncoder().encode(userId),
    userName: userEmail,
    attestationType: "none", // 대부분의 앱에 증명서는 필요 없다
    excludeCredentials: existingCredentials.map((cred) => ({
      id: cred.credentialId,
      transports: cred.transports,
    })),
    authenticatorSelection: {
      residentKey: "preferred",
      userVerification: "preferred",
    },
  };
 
  const registrationOptions = await generateRegistrationOptions(options);
 
  // 챌린지를 임시로 저장 — 검증에 필요
  await redis.set(
    `webauthn:challenge:${userId}`,
    registrationOptions.challenge,
    "EX",
    300 // 5분 만료
  );
 
  return registrationOptions;
}
 
async function finishRegistration(userId: string, response: unknown) {
  const expectedChallenge = await redis.get(`webauthn:challenge:${userId}`);
 
  if (!expectedChallenge) {
    throw new Error("챌린지가 만료되었거나 찾을 수 없음");
  }
 
  let verification: VerifiedRegistrationResponse;
  try {
    verification = await verifyRegistrationResponse({
      response: response as any,
      expectedChallenge,
      expectedOrigin: origin,
      expectedRPID: rpID,
    });
  } catch (error) {
    throw new Error(`등록 검증 실패: ${error}`);
  }
 
  if (!verification.verified || !verification.registrationInfo) {
    throw new Error("등록 검증 실패");
  }
 
  const { credential } = verification.registrationInfo;
 
  // 자격 증명을 데이터베이스에 저장
  await db.credential.create({
    data: {
      userId,
      credentialId: credential.id,
      publicKey: Buffer.from(credential.publicKey),
      counter: credential.counter,
      transports: credential.transports ?? [],
    },
  });
 
  // 정리
  await redis.del(`webauthn:challenge:${userId}`);
 
  return { verified: true };
}

// 서버 측: 인증
import {
  generateAuthenticationOptions,
  verifyAuthenticationResponse,
} from "@simplewebauthn/server";
 
async function startAuthentication(userId?: string) {
  let allowCredentials;
 
  // 사용자를 알고 있으면(예: 이메일을 입력한 경우), 그들의 Passkey로 제한
  if (userId) {
    const credentials = await db.credential.findMany({
      where: { userId },
      select: { credentialId: true, transports: true },
    });
    allowCredentials = credentials.map((cred) => ({
      id: cred.credentialId,
      transports: cred.transports,
    }));
  }
 
  const options = await generateAuthenticationOptions({
    rpID,
    allowCredentials,
    userVerification: "preferred",
  });
 
  // 검증을 위해 챌린지 저장
  const challengeKey = userId
    ? `webauthn:auth:${userId}`
    : `webauthn:auth:${options.challenge}`;
 
  await redis.set(challengeKey, options.challenge, "EX", 300);
 
  return options;
}
 
async function finishAuthentication(
  response: any,
  expectedChallenge: string,
  userId: string
) {
  const credential = await db.credential.findUnique({
    where: { credentialId: response.id },
  });
 
  if (!credential) {
    throw new Error("자격 증명을 찾을 수 없음");
  }
 
  const verification = await verifyAuthenticationResponse({
    response,
    expectedChallenge,
    expectedOrigin: origin,
    expectedRPID: rpID,
    credential: {
      id: credential.credentialId,
      publicKey: credential.publicKey,
      counter: credential.counter,
      transports: credential.transports,
    },
  });
 
  if (!verification.verified) {
    throw new Error("인증 검증 실패");
  }
 
  // 중요: 리플레이 공격 방지를 위해 카운터 업데이트
  await db.credential.update({
    where: { credentialId: response.id },
    data: {
      counter: verification.authenticationInfo.newCounter,
    },
  });
 
  return { verified: true, userId: credential.userId };
}

// 클라이언트 측: 등록
import { startRegistration as webAuthnRegister } from "@simplewebauthn/browser";
 
async function registerPasskey() {
  // 서버에서 옵션 가져오기
  const optionsResponse = await fetch("/api/auth/webauthn/register", {
    method: "POST",
  });
  const options = await optionsResponse.json();
 
  try {
    // 브라우저의 Passkey UI 트리거 (생체인식 프롬프트)
    const credential = await webAuthnRegister(options);
 
    // 검증을 위해 서버에 자격 증명 전송
    const verifyResponse = await fetch("/api/auth/webauthn/register/verify", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(credential),
    });
 
    const result = await verifyResponse.json();
    if (result.verified) {
      console.log("Passkey가 성공적으로 등록되었습니다!");
    }
  } catch (error) {
    if ((error as Error).name === "NotAllowedError") {
      console.log("사용자가 Passkey 등록을 취소했습니다");
    }
  }
}

import { createHmac, randomBytes } from "crypto";
 
// 사용자를 위한 TOTP 시크릿 생성
function generateTOTPSecret(): string {
  const buffer = randomBytes(20);
  return base32Encode(buffer);
}
 
function base32Encode(buffer: Buffer): string {
  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
  let result = "";
  let bits = 0;
  let value = 0;
 
  for (const byte of buffer) {
    value = (value << 8) | byte;
    bits += 8;
    while (bits >= 5) {
      result += alphabet[(value >>> (bits - 5)) & 0x1f];
      bits -= 5;
    }
  }
 
  if (bits > 0) {
    result += alphabet[(value << (5 - bits)) & 0x1f];
  }
 
  return result;
}
 
// QR 코드를 위한 TOTP URI 생성
function generateTOTPUri(
  secret: string,
  userEmail: string,
  issuer: string = "akousa.net"
): string {
  const encodedIssuer = encodeURIComponent(issuer);
  const encodedEmail = encodeURIComponent(userEmail);
  return `otpauth://totp/${encodedIssuer}:${encodedEmail}?secret=${secret}&issuer=${encodedIssuer}&algorithm=SHA1&digits=6&period=30`;
}

// TOTP 코드 검증
function verifyTOTP(secret: string, code: string, window: number = 1): boolean {
  const secretBuffer = base32Decode(secret);
  const now = Math.floor(Date.now() / 1000);
 
  // 현재 시간 단계와 인접한 단계 확인 (시계 오차 허용)
  for (let i = -window; i <= window; i++) {
    const timeStep = Math.floor(now / 30) + i;
    const expectedCode = generateTOTPCode(secretBuffer, timeStep);
 
    // 타이밍 공격 방지를 위한 상수 시간 비교
    if (timingSafeEqual(code, expectedCode)) {
      return true;
    }
  }
 
  return false;
}
 
function generateTOTPCode(secret: Buffer, timeStep: number): string {
  // 시간 단계를 8바이트 빅엔디안 버퍼로 변환
  const timeBuffer = Buffer.alloc(8);
  timeBuffer.writeBigInt64BE(BigInt(timeStep));
 
  // HMAC-SHA1
  const hmac = createHmac("sha1", secret).update(timeBuffer).digest();
 
  // 동적 자르기
  const offset = hmac[hmac.length - 1] & 0x0f;
  const code =
    ((hmac[offset] & 0x7f) << 24) |
    ((hmac[offset + 1] & 0xff) << 16) |
    ((hmac[offset + 2] & 0xff) << 8) |
    (hmac[offset + 3] & 0xff);
 
  return (code % 1_000_000).toString().padStart(6, "0");
}
 
function timingSafeEqual(a: string, b: string): boolean {
  if (a.length !== b.length) return false;
  const bufA = Buffer.from(a);
  const bufB = Buffer.from(b);
  return createHmac("sha256", "key").update(bufA).digest()
    .equals(createHmac("sha256", "key").update(bufB).digest());
}

import { randomBytes, createHash } from "crypto";
 
function generateBackupCodes(count: number = 10): string[] {
  return Array.from({ length: count }, () =>
    randomBytes(4).toString("hex").toUpperCase() // 8자리 hex 코드
  );
}
 
async function storeBackupCodes(userId: string, codes: string[]) {
  // 저장 전에 코드를 해시 — 비밀번호처럼 취급
  const hashedCodes = codes.map((code) =>
    createHash("sha256").update(code).digest("hex")
  );
 
  await db.backupCode.createMany({
    data: hashedCodes.map((hash) => ({
      userId,
      codeHash: hash,
      used: false,
    })),
  });
 
  // 사용자가 저장하도록 평문 코드를 한 번만 반환
  // 이후에는 해시만 가지고 있다
  return codes;
}
 
async function verifyBackupCode(userId: string, code: string): Promise<boolean> {
  const codeHash = createHash("sha256")
    .update(code.toUpperCase().replace(/\s/g, ""))
    .digest("hex");
 
  const backupCode = await db.backupCode.findFirst({
    where: {
      userId,
      codeHash,
      used: false,
    },
  });
 
  if (!backupCode) return false;
 
  // 사용됨으로 표시 — 각 백업 코드는 정확히 한 번만 동작
  await db.backupCode.update({
    where: { id: backupCode.id },
    data: { used: true, usedAt: new Date() },
  });
 
  return true;
}

async function initiateAccountRecovery(email: string) {
  const user = await db.user.findUnique({ where: { email } });
  if (!user) {
    // 계정 존재 여부를 노출하지 마라
    return { message: "해당 이메일이 존재하면 복구 안내를 보냈습니다." };
  }
 
  const recoveryToken = randomBytes(32).toString("hex");
  const tokenHash = createHash("sha256").update(recoveryToken).digest("hex");
 
  await db.recoveryRequest.create({
    data: {
      userId: user.id,
      tokenHash,
      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24시간
      status: "pending",
    },
  });
 
  // 복구 링크가 포함된 이메일 전송
  await sendEmail(email, {
    subject: "계정 복구 요청",
    body: `
      계정의 MFA를 비활성화하는 요청이 있었습니다.
      본인이라면 24시간 후 아래 링크를 클릭하세요: ...
      본인이 아니라면 즉시 비밀번호를 변경하세요.
    `,
  });
 
  return { message: "해당 이메일이 존재하면 복구 안내를 보냈습니다." };
}

// RBAC — 직관적인 역할 확인
type Role = "user" | "editor" | "admin" | "super_admin";
 
const ROLE_PERMISSIONS: Record<Role, string[]> = {
  user: ["read:own_profile", "update:own_profile", "read:posts"],
  editor: ["read:own_profile", "update:own_profile", "read:posts", "create:posts", "update:posts"],
  admin: [
    "read:own_profile", "update:own_profile",
    "read:posts", "create:posts", "update:posts", "delete:posts",
    "read:users", "update:users",
  ],
  super_admin: ["*"], // 와일드카드에 주의
};
 
function hasPermission(role: Role, permission: string): boolean {
  const permissions = ROLE_PERMISSIONS[role];
  return permissions.includes("*") || permissions.includes(permission);
}
 
// API 라우트에서 사용
export async function DELETE(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  const session = await auth();
  if (!session?.user) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  if (!hasPermission(session.user.role as Role, "delete:posts")) {
    return Response.json({ error: "Forbidden" }, { status: 403 });
  }
 
  const { id } = await params;
  await db.post.delete({ where: { id } });
  return Response.json({ success: true });
}

// ABAC — RBAC가 부족할 때
interface PolicyContext {
  user: {
    id: string;
    role: string;
    department: string;
    clearanceLevel: number;
  };
  resource: {
    type: string;
    ownerId: string;
    classification: string;
    department: string;
  };
  action: string;
  environment: {
    ipAddress: string;
    time: Date;
    mfaVerified: boolean;
  };
}
 
function evaluatePolicy(context: PolicyContext): boolean {
  const { user, resource, action, environment } = context;
 
  // 사용자는 항상 자기 리소스를 읽을 수 있다
  if (action === "read" && resource.ownerId === user.id) {
    return true;
  }
 
  // 관리자는 자기 부서의 모든 리소스를 읽을 수 있다
  if (
    action === "read" &&
    user.role === "admin" &&
    user.department === resource.department
  ) {
    return true;
  }
 
  // 기밀 리소스는 MFA와 최소 보안등급이 필요
  if (resource.classification === "confidential") {
    if (!environment.mfaVerified) return false;
    if (user.clearanceLevel < 3) return false;
  }
 
  // 파괴적 작업은 업무 시간 외 차단
  if (action === "delete") {
    const hour = environment.time.getHours();
    if (hour < 9 || hour > 17) return false;
  }
 
  return false; // 기본 거부
}

// 나쁜 예 — 컴포넌트에서만 확인
function DeleteButton({ post }: { post: Post }) {
  const { data: session } = useSession();
 
  // 버튼을 숨기지만 삭제를 방지하지는 않는다
  if (session?.user?.role !== "admin") return null;
 
  return <button onClick={() => deletePost(post.id)}>삭제</button>;
}
 
// 역시 나쁜 예 — 서버 액션에서 확인하지만 API 라우트에서는 안 함
async function deletePostAction(postId: string) {
  const session = await auth();
  if (session?.user?.role !== "admin") throw new Error("Forbidden");
  await db.post.delete({ where: { id: postId } });
}
// 공격자가 여전히 POST /api/posts/123을 직접 호출할 수 있다
 
// 좋은 예 — 모든 경계에서 확인
// 1. UI에서 버튼 숨기기 (UX, 보안이 아님)
// 2. 서버 액션에서 확인 (심층 방어)
// 3. API 라우트에서 확인 (실제 보안 경계)
// 4. 선택적으로 미들웨어에서 확인 (라우트 수준 보호)

// "이 사용자가 이 섹션에 접근할 수 있는가?"
// 세분화된 확인("이 사용자가 이 게시물을 편집할 수 있는가?")은 라우트 핸들러에 속한다
// 미들웨어는 요청 본문이나 라우트 파라미터에 쉽게 접근할 수 없기 때문이다.
 
export default auth((req) => {
  const path = req.nextUrl.pathname;
  const role = req.auth?.user?.role;
 
  // 라우트 수준 접근 제어
  const routeAccess: Record<string, Role[]> = {
    "/admin": ["admin", "super_admin"],
    "/editor": ["editor", "admin", "super_admin"],
    "/dashboard": ["user", "editor", "admin", "super_admin"],
  };
 
  for (const [route, allowedRoles] of Object.entries(routeAccess)) {
    if (path.startsWith(route)) {
      if (!role || !allowedRoles.includes(role as Role)) {
        return NextResponse.redirect(new URL("/unauthorized", req.nextUrl));
      }
    }
  }
 
  return NextResponse.next();
});

async function login(credentials: { email: string; password: string }, request: Request) {
  const user = await verifyCredentials(credentials);
  if (!user) throw new Error("잘못된 자격 증명");
 
  // 핵심: 이전 세션을 삭제하고 새 것을 만든다
  const oldSessionId = getSessionIdFromCookie(request);
  if (oldSessionId) {
    await redis.del(`session:${oldSessionId}`);
  }
 
  // 새 ID로 완전히 새로운 세션 생성
  const newSessionId = await createSession(user.id, request);
  return newSessionId;
}

// SameSite=Lax는 대부분의 CSRF 시나리오를 커버:
// - 크로스 오리진 POST, PUT, DELETE에서 쿠키 차단
// - 크로스 오리진 GET에서 쿠키 허용 (최상위 탐색)
//   GET 요청은 부작용이 없어야 하므로 괜찮다
 
cookieStore.set("session_id", sessionId, {
  httpOnly: true,
  secure: true,
  sameSite: "lax",  // 이것이 CSRF 보호
  maxAge: 86400,
  path: "/",
});

// 취약
async function handleCallback(request: Request) {
  const url = new URL(request.url);
  const redirectTo = url.searchParams.get("redirect_to") ?? "/";
  // ... 사용자 인증 ...
  return Response.redirect(redirectTo); // https://evil.com일 수 있다!
}
 
// 안전
async function handleCallback(request: Request) {
  const url = new URL(request.url);
  const redirectTo = url.searchParams.get("redirect_to") ?? "/";
 
  // 리다이렉트 URL 유효성 검사
  const safeRedirect = sanitizeRedirectUrl(redirectTo, request.url);
  // ... 사용자 인증 ...
  return Response.redirect(safeRedirect);
}
 
function sanitizeRedirectUrl(redirect: string, baseUrl: string): string {
  try {
    const url = new URL(redirect, baseUrl);
    const base = new URL(baseUrl);
 
    // 같은 오리진으로의 리다이렉트만 허용
    if (url.origin !== base.origin) {
      return "/";
    }
 
    // 경로 리다이렉트만 허용 (javascript:이나 data: URI 불가)
    if (!url.pathname.startsWith("/")) {
      return "/";
    }
 
    return url.pathname + url.search;
  } catch {
    return "/";
  }
}

// Next.js 미들웨어 또는 레이아웃에서
const headers = new Headers();
headers.set("Referrer-Policy", "strict-origin-when-cross-origin");

// 새 프로젝트의 전형적인 auth.ts
import NextAuth from "next-auth";
import Google from "next-auth/providers/google";
import GitHub from "next-auth/providers/github";
import Passkey from "next-auth/providers/passkey";
import { PrismaAdapter } from "@auth/prisma-adapter";
import { prisma } from "@/lib/prisma";
 
export const { handlers, auth, signIn, signOut } = NextAuth({
  adapter: PrismaAdapter(prisma),
  session: { strategy: "database" },
  providers: [
    Google,
    GitHub,
    Passkey({
      // Auth.js v5에는 내장 Passkey 지원이 있다
      // 내부적으로 SimpleWebAuthn을 사용한다
    }),
  ],
  experimental: {
    enableWebAuthn: true,
  },
});

import { hash, verify } from "@node-rs/argon2";
 
// Argon2id가 권장 알고리즘
// 웹 애플리케이션에 합리적인 기본값
async function hashPassword(password: string): Promise<string> {
  return hash(password, {
    memoryCost: 65536,  // 64 MB
    timeCost: 3,        // 3회 반복
    parallelism: 4,     // 4 스레드
  });
}
 
async function verifyPassword(
  password: string,
  hashedPassword: string
): Promise<boolean> {
  try {
    return await verify(hashedPassword, password);
  } catch {
    return false;
  }
}