인증 아키텍처: Session vs JWT vs OAuth2

Session (서버 저장)
- 쿠키에 sessionId
- 서버 메모리/Redis에 매핑
- 로그아웃 즉시 무효화 가능
- 서버 부하 ↑

JWT (클라이언트 저장)
- 서명된 토큰 (stateless)
- 서버 부하 0
- 만료 시까지 무효화 어려움
- 토큰 도난 시 위험

OAuth2 (위임)
- Google/GitHub/Kakao 로그인
- 비밀번호 관리 안 함
- 외부 의존

서버가 1대?
├─ Yes
│   └─ Session (가장 단순)
└─ No (분산)
    ├─ Redis 사용 가능?
    │   ├─ Yes → Session + Redis
    │   └─ No → JWT
    │
    ├─ 마이크로서비스?
    │   └─ JWT (서비스 간 검증 쉬움)
    │
    └─ 외부 ID 공급자?
        └─ OAuth2 + JWT

import session from 'express-session';
import RedisStore from 'connect-redis';

app.use(session({
  store: new RedisStore({ client: redis, prefix: 'sess:' }),
  secret: process.env.SESSION_SECRET!,
  resave: false,
  saveUninitialized: false,
  cookie: {
    httpOnly: true,
    secure: true,           // HTTPS만
    sameSite: 'lax',        // CSRF 보호
    maxAge: 1000 * 60 * 60 * 24 * 7,
  },
}));


// 로그인
app.post('/login', async (req, res) => {
  const user = await authenticate(req.body);
  req.session.userId = user.id;
  res.json({ ok: true });
});


// 로그아웃 (서버에서 즉시 무효화 가능)
app.post('/logout', (req, res) => {
  req.session.destroy(() => res.json({ ok: true }));
});

import jwt from 'jsonwebtoken';

const ACCESS_TTL = '15m';
const REFRESH_TTL = '7d';

async function login(email: string, password: string) {
  const user = await authenticate(email, password);

  const accessToken = jwt.sign(
    { sub: user.id, role: user.role, type: 'access' },
    process.env.JWT_ACCESS_SECRET!,
    { expiresIn: ACCESS_TTL },
  );

  const refreshToken = jwt.sign(
    { sub: user.id, type: 'refresh', jti: crypto.randomUUID() },
    process.env.JWT_REFRESH_SECRET!,
    { expiresIn: REFRESH_TTL },
  );

  // refresh는 DB 저장 (revoke 가능)
  await db.refreshToken.create({
    data: {
      userId: user.id,
      tokenHash: hash(refreshToken),
      expiresAt: new Date(Date.now() + 7 * 86400 * 1000),
    },
  });

  return { accessToken, refreshToken };
}


// 갱신
async function refresh(refreshToken: string) {
  const payload = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET!) as any;

  // DB에서 유효성 확인 (revoke 가능)
  const stored = await db.refreshToken.findUnique({
    where: { tokenHash: hash(refreshToken) },
  });
  if (!stored || stored.revokedAt) throw new UnauthorizedError();

  // 회전 (rotation) — 옛 토큰 revoke + 새 토큰 발급
  await db.refreshToken.update({
    where: { id: stored.id },
    data: { revokedAt: new Date() },
  });

  return issueTokens(payload.sub);
}

[보안 우선]
- accessToken: JS 메모리 (페이지 새로고침 시 refresh로 재발급)
- refreshToken: httpOnly Secure SameSite=Strict 쿠키


[구현 단순]
- 모두 localStorage (XSS 위험)


[모바일 앱]
- Secure Storage (Keychain·Keystore)

// Google OAuth → 우리 JWT 발급
app.get('/auth/google/callback', async (req, res) => {
  // 1. Google에서 access token 받음
  const googleToken = await exchangeCodeForToken(req.query.code);

  // 2. Google 사용자 정보 조회
  const profile = await fetchGoogleProfile(googleToken);

  // 3. 우리 DB에서 사용자 찾거나 생성
  let user = await db.user.findUnique({ where: { googleId: profile.id } });
  if (!user) {
    user = await db.user.create({
      data: {
        email: profile.email,
        name: profile.name,
        googleId: profile.id,
      },
    });
  }

  // 4. 우리 JWT 발급
  const tokens = await issueTokens(user.id);

  res.cookie('refreshToken', tokens.refreshToken, {
    httpOnly: true, secure: true, sameSite: 'lax',
  });
  res.redirect(`/?token=${tokens.accessToken}`);
});

[OIDC (OpenID Connect)]
- OAuth2 위에 ID 레이어
- Google·Microsoft·Okta·Auth0


[SAML]
- 기업용 (legacy)
- Okta·OneLogin


[구현 — Clerk·Auth0·Workos]
- 자체 구현 대신 SaaS
- 시간 90% 절감