Split View: OAuth 2.0 & 인증 완전 가이드 2025: JWT, 세션, SSO, OIDC, Passkey까지

Authentication (인증) - "당신은 누구인가?"
- 사용자의 신원을 확인하는 과정
- 로그인 과정 자체
- 예: 아이디/비밀번호, 생체 인식, OTP

Authorization (인가) - "당신은 무엇을 할 수 있는가?"
- 인증된 사용자의 권한을 확인하는 과정
- 리소스 접근 제어
- 예: 관리자만 삭제 가능, 본인 데이터만 조회 가능

1. 사용자가 로그인 요청 (Authentication)
   POST /auth/login
   Body: { "email": "user@example.com", "password": "..." }

2. 서버가 자격 증명 검증 (Authentication)
   - DB에서 사용자 조회
   - 비밀번호 해시 비교
   - 인증 성공시 토큰/세션 발급

3. API 요청시 토큰/세션 첨부
   GET /admin/users
   Authorization: Bearer eyJhbGci...

4. 서버가 권한 확인 (Authorization)
   - 토큰에서 역할(role) 추출
   - 해당 엔드포인트 접근 권한 확인
   - 권한 있음 -> 200 OK
   - 권한 없음 -> 403 Forbidden

401 Unauthorized = 인증(Authentication) 실패
- "당신이 누군지 모릅니다. 로그인하세요."
- 토큰 없음, 토큰 만료, 잘못된 자격 증명

403 Forbidden = 인가(Authorization) 실패
- "당신이 누군지는 알지만, 이 리소스에 접근 권한이 없습니다."
- 일반 사용자가 관리자 API 호출

1. 클라이언트: POST /login (이메일, 비밀번호)
2. 서버: 자격 증명 검증
3. 서버: 세션 생성 (서버 메모리/Redis에 저장)
   Session ID: "sess_abc123"
   Data: { userId: 42, role: "admin", createdAt: "..." }
4. 서버: Set-Cookie 헤더로 세션 ID 반환
   Set-Cookie: session_id=sess_abc123; HttpOnly; Secure; SameSite=Strict
5. 클라이언트: 이후 요청마다 쿠키 자동 전송
   Cookie: session_id=sess_abc123
6. 서버: 세션 ID로 사용자 정보 조회

const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const redis = require('redis');

const app = express();
const redisClient = redis.createClient({ url: 'redis://localhost:6379' });

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: process.env.SESSION_SECRET,
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: true,        // HTTPS에서만 전송
    httpOnly: true,      // JavaScript 접근 차단 (XSS 방지)
    sameSite: 'strict',  // CSRF 방지
    maxAge: 24 * 60 * 60 * 1000  // 24시간
  }
}));

// 로그인
app.post('/login', async (req, res) => {
  const { email, password } = req.body;
  const user = await db.findUserByEmail(email);

  if (!user || !await bcrypt.compare(password, user.passwordHash)) {
    return res.status(401).json({ error: '잘못된 자격 증명' });
  }

  req.session.userId = user.id;
  req.session.role = user.role;
  res.json({ message: '로그인 성공' });
});

// 인증 미들웨어
function requireAuth(req, res, next) {
  if (!req.session.userId) {
    return res.status(401).json({ error: '인증이 필요합니다' });
  }
  next();
}

// 인가 미들웨어
function requireRole(role) {
  return (req, res, next) => {
    if (req.session.role !== role) {
      return res.status(403).json({ error: '권한이 없습니다' });
    }
    next();
  };
}

// 로그아웃
app.post('/logout', (req, res) => {
  req.session.destroy((err) => {
    res.clearCookie('connect.sid');
    res.json({ message: '로그아웃 성공' });
  });
});

JWT = Header.Payload.Signature (Base64URL 인코딩, 점으로 구분)

Header (헤더):
{
  "alg": "RS256",    // 서명 알고리즘
  "typ": "JWT",      // 토큰 타입
  "kid": "key-id-1"  // 키 식별자 (Key Rotation용)
}

Payload (페이로드 - Claims):
{
  "iss": "https://auth.example.com",   // Issuer (발급자)
  "sub": "user-123",                    // Subject (주체)
  "aud": "https://api.example.com",    // Audience (대상)
  "exp": 1711356600,                    // Expiration (만료)
  "iat": 1711353000,                    // Issued At (발급)
  "nbf": 1711353000,                    // Not Before (이전 사용 불가)
  "jti": "unique-token-id",             // JWT ID (고유 ID)
  "email": "user@example.com",          // 커스텀 클레임
  "roles": ["admin", "user"]            // 커스텀 클레임
}

Signature (서명):
RS256(
  base64url(header) + "." + base64url(payload),
  privateKey
)

// HS256 - 같은 키로 서명하고 검증
const jwt = require('jsonwebtoken');
const SECRET = process.env.JWT_SECRET;

// 서명
const token = jwt.sign({ sub: 'user-123' }, SECRET, { algorithm: 'HS256' });

// 검증 (같은 키 필요)
const decoded = jwt.verify(token, SECRET);

// RS256 - 개인키로 서명, 공개키로 검증
const fs = require('fs');
const privateKey = fs.readFileSync('private.pem');
const publicKey = fs.readFileSync('public.pem');

// 서명 (인증 서버)
const token = jwt.sign(
  { sub: 'user-123', roles: ['admin'] },
  privateKey,
  { algorithm: 'RS256', expiresIn: '15m' }
);

// 검증 (API 서버 - 공개키만 필요)
const decoded = jwt.verify(token, publicKey);

1. 서명 검증 (Signature Verification)
   - 올바른 알고리즘으로 서명되었는지 확인
   - alg: "none" 공격 방지 (반드시 알고리즘 명시)

2. 만료 시간 확인 (exp)
   - 현재 시간이 exp보다 이전인지 확인
   - 클럭 스큐를 고려한 약간의 여유 (leeway)

3. 발급자 확인 (iss)
   - 신뢰할 수 있는 발급자인지 확인

4. 대상 확인 (aud)
   - 이 토큰이 내 서비스를 위한 것인지 확인

5. Not Before 확인 (nbf)
   - 토큰 사용 시작 시간 이후인지 확인

6. 추가 보안 검증
   - 토큰이 블랙리스트에 있는지 확인
   - 사용자가 비활성화되었는지 확인

Access Token:
- 짧은 유효 기간 (15분 ~ 1시간)
- API 요청시 Authorization 헤더에 포함
- 탈취되어도 피해 기간이 제한적
- 서버에 저장하지 않음 (Stateless)

Refresh Token:
- 긴 유효 기간 (7일 ~ 30일)
- Access Token 갱신에만 사용
- 서버 DB/Redis에 저장 (Stateful)
- HttpOnly 쿠키에 저장 (XSS 방지)

1. 최초 로그인
   POST /auth/login -> Access Token + Refresh Token 발급

2. API 요청
   GET /api/data
   Authorization: Bearer [access_token]
   -> 200 OK (정상)

3. Access Token 만료
   GET /api/data
   Authorization: Bearer [expired_access_token]
   -> 401 Unauthorized

4. 토큰 갱신
   POST /auth/refresh
   Cookie: refresh_token=...
   -> 새 Access Token + 새 Refresh Token 발급

5. Refresh Token 만료
   POST /auth/refresh
   -> 401 Unauthorized -> 재로그인 필요

// Refresh Token Rotation 구현
async function refreshTokens(refreshToken) {
  // 1. DB에서 Refresh Token 조회
  const storedToken = await db.findRefreshToken(refreshToken);

  if (!storedToken) {
    // 이미 사용된 Refresh Token -> 모든 토큰 무효화 (탈취 감지)
    await db.revokeAllTokensForUser(storedToken.userId);
    throw new Error('Refresh Token reuse detected');
  }

  // 2. 유효성 확인
  if (storedToken.expiresAt < Date.now()) {
    throw new Error('Refresh Token expired');
  }

  // 3. 이전 Refresh Token 무효화
  await db.revokeRefreshToken(refreshToken);

  // 4. 새 토큰 쌍 발급
  const newAccessToken = jwt.sign(
    { sub: storedToken.userId, roles: storedToken.roles },
    privateKey,
    { algorithm: 'RS256', expiresIn: '15m' }
  );

  const newRefreshToken = crypto.randomUUID();
  await db.saveRefreshToken({
    token: newRefreshToken,
    userId: storedToken.userId,
    expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000
  });

  return { accessToken: newAccessToken, refreshToken: newRefreshToken };
}

// Redis 기반 블랙리스트
const redis = require('redis');
const client = redis.createClient();

// 토큰 블랙리스트에 추가 (로그아웃시)
async function blacklistToken(token) {
  const decoded = jwt.decode(token);
  const ttl = decoded.exp - Math.floor(Date.now() / 1000);

  if (ttl > 0) {
    await client.set(`blacklist:${decoded.jti}`, '1', { EX: ttl });
  }
}

// 토큰 검증시 블랙리스트 확인
async function verifyToken(token) {
  const decoded = jwt.verify(token, publicKey);
  const isBlacklisted = await client.get(`blacklist:${decoded.jti}`);

  if (isBlacklisted) {
    throw new Error('Token has been revoked');
  }

  return decoded;
}

DO (해야 할 것):
- Access Token 유효 기간을 짧게 (15분)
- RS256 또는 ES256 사용 (비대칭 키)
- jti 클레임으로 토큰 고유 식별
- Refresh Token은 서버 측에서 관리
- 민감한 정보는 Payload에 넣지 않기

DON'T (하지 말 것):
- JWT를 localStorage에 저장 (XSS에 취약)
- HS256으로 마이크로서비스 간 사용
- 토큰에 비밀번호/카드번호 포함
- alg: "none"을 허용
- 유효 기간 없이 토큰 발급

Resource Owner (리소스 소유자):
  - 최종 사용자 (예: Google 계정 소유자)

Client (클라이언트):
  - 리소스 접근을 요청하는 애플리케이션 (예: 내 웹앱)

Authorization Server (인가 서버):
  - 토큰을 발급하는 서버 (예: Google OAuth 서버)

Resource Server (리소스 서버):
  - 보호된 리소스를 호스팅하는 서버 (예: Google API)

가장 권장되는 플로우. 웹앱, SPA, 모바일 앱 모두에서 사용.
PKCE (Proof Key for Code Exchange)는 SPA/모바일에서 필수.

1. 클라이언트가 PKCE 파라미터 생성
   code_verifier = random(43-128 chars)
   code_challenge = BASE64URL(SHA256(code_verifier))

2. 인가 요청
   GET /authorize?
     response_type=code&
     client_id=my-app&
     redirect_uri=https://myapp.com/callback&
     scope=openid profile email&
     state=random-csrf-token&
     code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM&
     code_challenge_method=S256

3. 사용자가 로그인 + 동의

4. 인가 서버가 Authorization Code 반환
   302 Redirect: https://myapp.com/callback?code=AUTH_CODE&state=random-csrf-token

5. Authorization Code를 Access Token으로 교환
   POST /token
   Content-Type: application/x-www-form-urlencoded

   grant_type=authorization_code&
   code=AUTH_CODE&
   redirect_uri=https://myapp.com/callback&
   client_id=my-app&
   code_verifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk

6. 토큰 응답
   {
     "access_token": "eyJhbGci...",
     "token_type": "Bearer",
     "expires_in": 3600,
     "refresh_token": "dGhpcyBpcyBhIH...",
     "id_token": "eyJhbGci...",
     "scope": "openid profile email"
   }

서버 간 통신 (Machine-to-Machine). 사용자 개입 없음.

POST /token
Content-Type: application/x-www-form-urlencoded

grant_type=client_credentials&
client_id=service-a&
client_secret=secret-value&
scope=read:data write:data

응답:
{
  "access_token": "eyJhbGci...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "scope": "read:data write:data"
}

사용 사례:
- 마이크로서비스 간 API 호출
- 배치 처리 시스템
- CI/CD 파이프라인에서의 API 접근

입력이 제한된 디바이스용 (스마트 TV, CLI 도구, IoT)

1. 디바이스가 코드 요청
   POST /device/code
   client_id=tv-app

   응답:
   {
     "device_code": "GmRhmhcxhwAzkoEqiMEg_DnyEysNkuNhszIySk9eS",
     "user_code": "WDJB-MJHT",
     "verification_uri": "https://auth.example.com/device",
     "interval": 5,
     "expires_in": 1800
   }

2. 사용자에게 표시
   "https://auth.example.com/device 에서 코드 WDJB-MJHT를 입력하세요"

3. 사용자가 다른 디바이스(폰/PC)에서 코드 입력 + 로그인

4. 디바이스가 폴링
   POST /token
   grant_type=urn:ietf:params:oauth:grant-type:device_code&
   device_code=GmRhmhcxhwAzkoEqiMEg_DnyEysNkuNhszIySk9eS&
   client_id=tv-app

   (사용자가 아직 인증 안함 -> "authorization_pending")
   (사용자가 인증 완료 -> Access Token 반환)

더 이상 권장되지 않음! PKCE가 포함된 Authorization Code Flow를 사용하세요.

비권장 이유:
1. Access Token이 URL Fragment에 노출 (#access_token=...)
2. 브라우저 히스토리에 토큰 기록
3. Refresh Token을 발급할 수 없음
4. Token 교체 공격(Token Substitution Attack)에 취약

대안: Authorization Code + PKCE
- SPA에서도 안전하게 사용 가능
- Refresh Token 지원
- code_verifier로 코드 가로채기 방지

OAuth 2.0 위에 구축된 인증 레이어.
OAuth 2.0 = 인가(Authorization)만 담당
OIDC = 인증(Authentication)을 추가

OAuth 2.0: "이 앱이 당신의 Google Drive에 접근해도 됩니까?"
OIDC: "이 사용자가 실제로 alice@gmail.com인지 확인"

핵심 추가 사항:
1. ID Token (JWT 형식의 사용자 정보)
2. UserInfo 엔드포인트
3. 표준화된 클레임 (name, email, picture 등)
4. Discovery 문서 (/.well-known/openid-configuration)

{
  "iss": "https://accounts.google.com",
  "sub": "110169484474386276334",
  "aud": "my-app-client-id",
  "exp": 1711356600,
  "iat": 1711353000,
  "nonce": "n-0S6_WzA2Mj",
  "email": "alice@gmail.com",
  "email_verified": true,
  "name": "Alice Kim",
  "picture": "https://lh3.googleusercontent.com/a/..."
}

GET https://accounts.google.com/.well-known/openid-configuration

응답 (주요 필드):
{
  "issuer": "https://accounts.google.com",
  "authorization_endpoint": "https://accounts.google.com/o/oauth2/v2/auth",
  "token_endpoint": "https://oauth2.googleapis.com/token",
  "userinfo_endpoint": "https://openidconnect.googleapis.com/v1/userinfo",
  "jwks_uri": "https://www.googleapis.com/oauth2/v3/certs",
  "scopes_supported": ["openid", "email", "profile"],
  "response_types_supported": ["code", "token", "id_token"],
  "subject_types_supported": ["public"],
  "id_token_signing_alg_values_supported": ["RS256"]
}

한 번의 로그인으로 여러 서비스에 접근하는 메커니즘.

예시:
Google 계정으로 로그인하면 Gmail, Drive, YouTube, Calendar 모두 접근 가능.

장점:
- 사용자 경험 향상 (로그인 한 번)
- 비밀번호 피로도 감소
- 중앙화된 사용자 관리
- 보안 정책 일관성

단점:
- 단일 장애점 (IdP 장애시 모든 서비스 영향)
- 구현 복잡성
- IdP에 대한 의존성

SAML 2.0 흐름:
1. 사용자가 SP(Service Provider) 접근
2. SP가 SAML Request 생성 -> IdP로 리다이렉트
3. 사용자가 IdP에서 인증
4. IdP가 SAML Assertion(XML) 생성 -> SP로 POST
5. SP가 Assertion 검증 -> 세션 생성

OIDC 흐름:
1. 사용자가 앱 접근
2. 앱이 IdP로 Authorization 요청 리다이렉트
3. 사용자가 IdP에서 인증
4. IdP가 Authorization Code 반환
5. 앱이 Code를 ID Token + Access Token으로 교환

// app/api/auth/[...nextauth]/route.js
import NextAuth from 'next-auth';
import GoogleProvider from 'next-auth/providers/google';
import GitHubProvider from 'next-auth/providers/github';

const handler = NextAuth({
  providers: [
    GoogleProvider({
      clientId: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
    }),
    GitHubProvider({
      clientId: process.env.GITHUB_CLIENT_ID,
      clientSecret: process.env.GITHUB_CLIENT_SECRET,
    }),
  ],
  callbacks: {
    async jwt({ token, account, profile }) {
      if (account) {
        token.accessToken = account.access_token;
        token.provider = account.provider;
      }
      return token;
    },
    async session({ session, token }) {
      session.accessToken = token.accessToken;
      session.provider = token.provider;
      return session;
    },
  },
  pages: {
    signIn: '/auth/signin',
    error: '/auth/error',
  },
});

export { handler as GET, handler as POST };

const passport = require('passport');
const GitHubStrategy = require('passport-github2').Strategy;

passport.use(new GitHubStrategy({
    clientID: process.env.GITHUB_CLIENT_ID,
    clientSecret: process.env.GITHUB_CLIENT_SECRET,
    callbackURL: 'https://myapp.com/auth/github/callback'
  },
  async (accessToken, refreshToken, profile, done) => {
    let user = await db.findUserByGitHubId(profile.id);

    if (!user) {
      user = await db.createUser({
        githubId: profile.id,
        name: profile.displayName,
        email: profile.emails[0].value,
        avatar: profile.photos[0].value,
      });
    }

    return done(null, user);
  }
));

// 라우트
app.get('/auth/github',
  passport.authenticate('github', { scope: ['user:email'] })
);

app.get('/auth/github/callback',
  passport.authenticate('github', { failureRedirect: '/login' }),
  (req, res) => {
    res.redirect('/dashboard');
  }
);

Apple 로그인은 다른 소셜 로그인과 차이가 있음:

1. 이메일 숨기기 (Private Email Relay)
   - 사용자가 실제 이메일 대신 고유 릴레이 주소 제공 가능
   - 예: abc123@privaterelay.appleid.com

2. 사용자 정보 최초 1회만 제공
   - 이름, 이메일은 첫 로그인시에만 반환
   - 반드시 첫 응답에서 저장해야 함!

3. client_secret이 JWT
   - 다른 프로바이더와 달리 client_secret을 직접 JWT로 생성
   - Apple 개발자 포털의 키로 서명

4. 웹에서 Form POST 방식
   - callback이 POST 방식으로 전달

비밀번호 없는 인증의 미래.
생체 인식(지문/얼굴), 디바이스 PIN, 보안 키로 로그인.

Passkey = WebAuthn + FIDO2 + 클라우드 동기화

장점:
- 피싱 불가능 (도메인에 바인딩)
- 비밀번호 유출 없음
- 사용자 경험 향상 (터치/얼굴만으로 로그인)
- 크로스 디바이스 지원 (iCloud Keychain, Google Password Manager)

브라우저 지원:
- Chrome 108+ (2022.12)
- Safari 16+ (2022.09)
- Firefox 122+ (2024.01)
- Edge 108+ (2022.12)

// 서버: Registration Options 생성
app.post('/webauthn/register/options', async (req, res) => {
  const user = req.user;

  const options = {
    challenge: crypto.randomBytes(32),
    rp: {
      name: 'My App',
      id: 'myapp.com'
    },
    user: {
      id: Buffer.from(user.id),
      name: user.email,
      displayName: user.name
    },
    pubKeyCredParams: [
      { alg: -7, type: 'public-key' },   // ES256
      { alg: -257, type: 'public-key' }  // RS256
    ],
    authenticatorSelection: {
      authenticatorAttachment: 'platform',
      userVerification: 'preferred',
      residentKey: 'required'
    },
    timeout: 60000
  };

  req.session.challenge = options.challenge;
  res.json(options);
});

// 클라이언트: Passkey 생성
const credential = await navigator.credentials.create({
  publicKey: registrationOptions
});

// 서버: 등록 완료
app.post('/webauthn/register/verify', async (req, res) => {
  const { credential } = req.body;

  // challenge 검증, origin 검증, 공개키 추출 및 저장
  const verified = await verifyRegistration(credential, req.session.challenge);

  if (verified) {
    await db.saveCredential({
      credentialId: credential.id,
      publicKey: verified.publicKey,
      userId: req.user.id,
      counter: verified.counter
    });
    res.json({ success: true });
  }
});

// 서버: Authentication Options 생성
app.post('/webauthn/login/options', async (req, res) => {
  const options = {
    challenge: crypto.randomBytes(32),
    rpId: 'myapp.com',
    userVerification: 'preferred',
    timeout: 60000
  };

  req.session.challenge = options.challenge;
  res.json(options);
});

// 클라이언트: Passkey로 인증
const assertion = await navigator.credentials.get({
  publicKey: authenticationOptions
});

// 서버: 인증 검증
app.post('/webauthn/login/verify', async (req, res) => {
  const { assertion } = req.body;

  const credential = await db.findCredential(assertion.id);
  const verified = await verifyAuthentication(
    assertion,
    credential.publicKey,
    req.session.challenge,
    credential.counter
  );

  if (verified) {
    // 카운터 업데이트 (리플레이 공격 방지)
    await db.updateCounter(assertion.id, verified.newCounter);

    // 세션/토큰 발급
    const token = jwt.sign({ sub: credential.userId }, privateKey);
    res.json({ token });
  }
});

const speakeasy = require('speakeasy');
const QRCode = require('qrcode');

// MFA 설정 - 시크릿 생성
app.post('/mfa/setup', async (req, res) => {
  const secret = speakeasy.generateSecret({
    name: `MyApp (${req.user.email})`,
    issuer: 'MyApp'
  });

  // QR 코드 생성
  const qrCodeUrl = await QRCode.toDataURL(secret.otpauth_url);

  // 시크릿을 임시 저장 (검증 전)
  await db.saveTempMfaSecret(req.user.id, secret.base32);

  res.json({
    qrCode: qrCodeUrl,
    manualEntry: secret.base32
  });
});

// MFA 설정 - 코드 검증 후 활성화
app.post('/mfa/verify-setup', async (req, res) => {
  const { code } = req.body;
  const secret = await db.getTempMfaSecret(req.user.id);

  const verified = speakeasy.totp.verify({
    secret: secret,
    encoding: 'base32',
    token: code,
    window: 1  // 30초 전후 허용
  });

  if (verified) {
    await db.enableMfa(req.user.id, secret);
    // 백업 코드 생성
    const backupCodes = Array.from({ length: 10 }, () =>
      crypto.randomBytes(4).toString('hex')
    );
    await db.saveBackupCodes(req.user.id, backupCodes);
    res.json({ success: true, backupCodes });
  } else {
    res.status(400).json({ error: '잘못된 코드' });
  }
});

// 로그인시 MFA 검증
app.post('/auth/mfa-verify', async (req, res) => {
  const { code, userId } = req.body;
  const user = await db.getUser(userId);

  const verified = speakeasy.totp.verify({
    secret: user.mfaSecret,
    encoding: 'base32',
    token: code,
    window: 1
  });

  if (verified) {
    const token = jwt.sign({ sub: user.id, mfa: true }, privateKey);
    res.json({ token });
  } else {
    res.status(401).json({ error: '잘못된 MFA 코드' });
  }
});

CSRF (Cross-Site Request Forgery):
악성 사이트가 인증된 사용자의 권한으로 요청을 위조.

방어 방법:
1. SameSite 쿠키 속성
   Set-Cookie: session=abc; SameSite=Strict

2. CSRF 토큰
   - 서버가 폼과 함께 고유 토큰 발급
   - 폼 제출시 토큰 포함
   - 서버가 토큰 검증

3. Double Submit Cookie
   - CSRF 토큰을 쿠키와 요청 본문 모두에 포함
   - 두 값이 일치하는지 확인

4. Origin/Referer 검증
   - 요청의 Origin 헤더가 허용된 도메인인지 확인

토큰 저장 위치별 보안 비교:

localStorage:
- XSS에 취약 (JavaScript로 접근 가능)
- CSRF에는 안전
- 사용하지 않는 것을 강력히 권장

sessionStorage:
- XSS에 취약
- 탭 간 공유 안됨
- localStorage보다 약간 나음

HttpOnly Cookie:
- XSS에 안전 (JavaScript 접근 불가)
- CSRF 보호 필요 (SameSite=Strict)
- 가장 권장되는 방법

메모리 (변수):
- XSS/CSRF 모두에 가장 안전
- 페이지 새로고침시 소실
- SPA에서 사용 가능, Refresh Token은 HttpOnly 쿠키

// Express.js CORS 설정
const cors = require('cors');

// Bad: 모든 도메인 허용
app.use(cors());

// Good: 특정 도메인만 허용
app.use(cors({
  origin: ['https://myapp.com', 'https://admin.myapp.com'],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true,  // 쿠키 포함 허용
  maxAge: 86400       // Preflight 캐시 24시간
}));

# 필수 보안 헤더
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 0
Content-Security-Policy: default-src 'self'; script-src 'self'
Referrer-Policy: strict-origin-when-cross-origin
Permissions-Policy: camera=(), microphone=(), geolocation=()

// bcrypt으로 비밀번호 해싱
const bcrypt = require('bcrypt');
const SALT_ROUNDS = 12;

// 비밀번호 해싱
async function hashPassword(plainPassword) {
  return await bcrypt.hash(plainPassword, SALT_ROUNDS);
}

// 비밀번호 검증
async function verifyPassword(plainPassword, hashedPassword) {
  return await bcrypt.compare(plainPassword, hashedPassword);
}

// 비밀번호 강도 검증
function validatePasswordStrength(password) {
  const rules = [
    { test: /.{8,}/, message: '최소 8자 이상' },
    { test: /[A-Z]/, message: '대문자 1개 이상' },
    { test: /[a-z]/, message: '소문자 1개 이상' },
    { test: /[0-9]/, message: '숫자 1개 이상' },
    { test: /[^A-Za-z0-9]/, message: '특수문자 1개 이상' },
  ];

  const failures = rules.filter(r => !r.test.test(password));
  return { valid: failures.length === 0, failures };
}

소규모 프로젝트 + 빠른 구현:
  -> NextAuth.js / Clerk / Supabase Auth

직접 제어 + 커스텀 요구:
  -> Lucia / Passport.js

엔터프라이즈 SSO + SAML:
  -> Auth0 / Keycloak

마이크로서비스 + 자체 호스팅:
  -> Keycloak

서버리스 + Google 생태계:
  -> Firebase Auth