🍽️ 음식점 비유로 완벽 이해

🔐 RBAC (역할 기반 접근 제어) — 인가 패턴

RBAC(Role-Based Access Control)는 현업에서 가장 많이 쓰는 권한 제어 방식입니다. 사용자에게 역할(Role)을 부여하고, 역할에 따라 접근 가능한 리소스를 제한합니다.

// middleware/rbac.js — 역할 기반 접근 제어 미들웨어
const authorizeRoles = (...roles) => {
  return (req, res, next) => {
    // req.user는 authMiddleware에서 설정된 사용자 정보
    if (!req.user) {
      return res.status(401).json({ error: '로그인이 필요합니다.' });
    }
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ 
        error: '접근 권한이 없습니다.',
        required: roles,
        current: req.user.role
      });
    }
    next();
  };
};

// 사용 예시
// 관리자만 접근 가능
router.delete('/users/:id', authMiddleware, authorizeRoles('ADMIN'), deleteUser);

// 관리자 또는 매니저만 접근 가능
router.get('/dashboard/stats', authMiddleware, authorizeRoles('ADMIN', 'MANAGER'), getStats);

// 본인 또는 관리자만 수정 가능
router.put('/users/:id', authMiddleware, async (req, res) => {
  const isOwner = req.user.userId === Number(req.params.id);
  const isAdmin = req.user.role === 'ADMIN';
  if (!isOwner && !isAdmin) {
    return res.status(403).json({ error: '본인 또는 관리자만 수정 가능합니다.' });
  }
  // ... 수정 로직
});

💡 왜 bcrypt인가? — 해싱 알고리즘 비교

⏱ saltRounds 값에 따른 해싱 소요 시간

saltRounds가 높을수록 해킹이 어렵지만, 서버 응답도 느려집니다. 현업 권장: 12

💻 bcrypt 실전 구현 — 회원가입 + 로그인 완전 코드

// npm install bcryptjs
const bcrypt = require('bcryptjs');

// ===== 1. 비밀번호 해시화 (회원가입) =====
async function hashPassword(plainText) {
  const saltRounds = 12; // 현업 권장값
  const hash = await bcrypt.hash(plainText, saltRounds);
  return hash;
  // 결과: "$2b$12$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy"
  // $2b = bcrypt 버전 | $12 = saltRounds | 나머지 = salt(22자) + hash(31자)
}

// ===== 2. 비밀번호 검증 (로그인) =====
async function verifyPassword(plainText, hashedPassword) {
  const isMatch = await bcrypt.compare(plainText, hashedPassword);
  return isMatch; // true or false
}

// ===== 3. 실전 회원가입 API =====
router.post('/register', async (req, res) => {
  try {
    const { name, email, password } = req.body;

    // ① 입력값 검증
    if (!name || !email || !password) {
      return res.status(400).json({ error: '모든 필드를 입력해주세요.' });
    }
    if (password.length < 8) {
      return res.status(400).json({ error: '비밀번호는 8자 이상이어야 합니다.' });
    }

    // ② 이메일 중복 확인
    const existing = await prisma.user.findUnique({ where: { email } });
    if (existing) {
      return res.status(409).json({ error: '이미 사용 중인 이메일입니다.' });
    }

    // ③ 비밀번호 해시화 (절대 평문 저장 금지!)
    const hashedPassword = await bcrypt.hash(password, 12);

    // ④ DB 저장 (password 필드에 hash 저장)
    const user = await prisma.user.create({
      data: { name, email, password: hashedPassword },
      select: { id: true, name: true, email: true } // password 응답에서 제외!
    });

    res.status(201).json({ message: '회원가입 성공', user });
  } catch (err) {
    next(err);
  }
});

// ===== 4. 실전 로그인 API =====
router.post('/login', async (req, res) => {
  const { email, password } = req.body;

  // ⚠️ 보안 팁: "이메일이 없습니다" vs "비밀번호 틀림" 구분하지 말것
  // → 계정 존재 여부 노출 방지를 위해 동일한 에러 메시지 사용
  const user = await prisma.user.findUnique({ where: { email } });
  if (!user) {
    return res.status(401).json({ error: '이메일 또는 비밀번호가 올바르지 않습니다.' });
  }

  const isMatch = await bcrypt.compare(password, user.password);
  if (!isMatch) {
    return res.status(401).json({ error: '이메일 또는 비밀번호가 올바르지 않습니다.' });
  }

  // 로그인 성공 → JWT 발급 (다음 섹션에서 자세히)
  const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET, { expiresIn: '1h' });
  res.json({ token });
});

🔍 JWT 구조 완전 분석

JWT는 점(.)으로 구분된 3개의 Base64Url 인코딩 문자열입니다.

💻 Access Token + Refresh Token 전략 — 실전 구현

// npm install jsonwebtoken
const jwt = require('jsonwebtoken');

// ===== JWT 전략: Access(1시간) + Refresh(7일) =====
// - Access Token: API 인증에 사용, 짧은 수명
// - Refresh Token: Access Token 재발급에만 사용, 긴 수명 (DB 또는 Redis에 저장)

function generateTokens(userId, role) {
  const accessToken = jwt.sign(
    { userId, role },
    process.env.JWT_SECRET,
    { expiresIn: '1h' }   // 1시간 (현업 권장)
  );
  const refreshToken = jwt.sign(
    { userId },
    process.env.JWT_REFRESH_SECRET,
    { expiresIn: '7d' }  // 7일
  );
  return { accessToken, refreshToken };
}

// ===== 인증 미들웨어 =====
const authMiddleware = (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ error: '인증 토큰이 없습니다.' });
  }
  const token = authHeader.split(' ')[1];
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded; // { userId, role, iat, exp }
    next();
  } catch (err) {
    if (err.name === 'TokenExpiredError') {
      return res.status(401).json({ error: '토큰이 만료되었습니다.', code: 'TOKEN_EXPIRED' });
    }
    res.status(401).json({ error: '유효하지 않은 토큰입니다.' });
  }
};

// ===== Refresh Token으로 Access Token 재발급 =====
router.post('/refresh', async (req, res) => {
  const { refreshToken } = req.body;
  if (!refreshToken) return res.status(401).json({ error: 'Refresh Token이 없습니다.' });

  try {
    const decoded = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET);
    
    // DB에서 Refresh Token 유효성 확인 (로그아웃 처리 시 삭제됨)
    const user = await prisma.user.findFirst({
      where: { id: decoded.userId, refreshToken }
    });
    if (!user) return res.status(401).json({ error: '유효하지 않은 Refresh Token' });

    // 새 Access Token 발급
    const newAccessToken = jwt.sign(
      { userId: user.id, role: user.role },
      process.env.JWT_SECRET,
      { expiresIn: '1h' }
    );
    res.json({ accessToken: newAccessToken });
  } catch {
    res.status(401).json({ error: 'Refresh Token이 만료되었습니다. 다시 로그인해주세요.' });
  }
});

🔄 OAuth2 인증 흐름도

💻 Passport.js Google OAuth2 구현

// npm install passport passport-google-oauth20

// config/passport.js
const GoogleStrategy = require('passport-google-oauth20').Strategy;

passport.use(new GoogleStrategy({
  clientID: process.env.GOOGLE_CLIENT_ID,
  clientSecret: process.env.GOOGLE_CLIENT_SECRET,
  callbackURL: '/auth/google/callback'
}, async (accessToken, refreshToken, profile, done) => {
  try {
    // 기존 회원인지 확인 (Google ID로 조회)
    let user = await prisma.user.findFirst({
      where: { googleId: profile.id }
    });
    
    if (!user) {
      // 신규 회원 자동 생성
      user = await prisma.user.create({
        data: {
          googleId: profile.id,
          name: profile.displayName,
          email: profile.emails[0].value,
          profileImage: profile.photos[0]?.value,
          provider: 'google'
        }
      });
    }
    return done(null, user);
  } catch (err) {
    return done(err, null);
  }
}));

// routes/auth.js — OAuth 라우트
// 1. Google 로그인 시작
router.get('/google', passport.authenticate('google', { 
  scope: ['profile', 'email'] 
}));

// 2. Google 콜백 처리
router.get('/google/callback',
  passport.authenticate('google', { session: false }),
  (req, res) => {
    // Google 인증 성공 → 내 JWT 발급
    const token = jwt.sign(
      { userId: req.user.id, role: req.user.role },
      process.env.JWT_SECRET,
      { expiresIn: '1h' }
    );
    // 클라이언트로 리다이렉트 (토큰 전달)
    res.redirect(`http://localhost:3001/auth/callback?token=${token}`);
  }
);

🤝 TLS Handshake 흐름 (간단 버전)

💻 Let's Encrypt 무료 SSL 설치 (Ubuntu 서버)

# Certbot 설치 (무료 SSL 인증서 발급 도구)
sudo apt update
sudo apt install certbot python3-certbot-nginx

# SSL 인증서 발급 및 Nginx 자동 설정
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

# 자동 갱신 확인 (90일마다 자동 갱신됨)
sudo certbot renew --dry-run

# Nginx HTTPS 설정 (/etc/nginx/sites-available/default)
server {
  listen 443 ssl;
  server_name yourdomain.com;
  
  ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;
  ssl_protocols TLSv1.2 TLSv1.3;
  ssl_ciphers HIGH:!aNULL:!MD5;
  
  location / {
    proxy_pass http://localhost:3000;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
  }
}

# HTTP → HTTPS 자동 리다이렉트
server {
  listen 80;
  server_name yourdomain.com;
  return 301 https://$server_name$request_uri;
}

💻 SQL Injection 공격 vs 방어

// ❌ 위험한 코드 — SQL Injection 취약점
app.get('/users', async (req, res) => {
  const { email } = req.query;
  // 해커가 email=' OR '1'='1 입력 시 모든 사용자 조회됨!
  const query = `SELECT * FROM users WHERE email = '${email}'`;
  const [rows] = await db.execute(query); // 💀 절대 이렇게 하지 마세요
});

// ✅ 안전한 코드 방법 1 — Parameterized Query
app.get('/users', async (req, res) => {
  const { email } = req.query;
  // ? 자리표시자 사용 → DB 드라이버가 자동으로 이스케이프
  const [rows] = await db.execute('SELECT * FROM users WHERE email = ?', [email]);
  res.json(rows);
});

// ✅ 안전한 코드 방법 2 — Prisma ORM (자동으로 이스케이프)
app.get('/users', async (req, res) => {
  const { email } = req.query;
  const user = await prisma.user.findFirst({ where: { email } }); // ✅ 안전
  res.json(user);
});

💻 XSS 공격 vs 방어

// XSS (Cross-Site Scripting): 악성 스크립트를 페이지에 삽입
// 해커가 게시글에 <script>document.cookie를 훔쳐가는 코드</script> 입력

// ✅ 방어 1: DOMPurify로 HTML 태그 제거 (프론트엔드)
const DOMPurify = require('dompurify');
const clean = DOMPurify.sanitize(userInput); // 스크립트 태그 제거

// ✅ 방어 2: xss 라이브러리 (백엔드)
// npm install xss
const xss = require('xss');
router.post('/posts', async (req, res) => {
  const safeContent = xss(req.body.content); // XSS 필터링
  await prisma.post.create({ data: { content: safeContent, ... } });
});

// ✅ 방어 3: Helmet CSP 헤더 (Content-Security-Policy)
app.use(helmet.contentSecurityPolicy({
  directives: {
    defaultSrc: ["'self'"],          // 자신의 도메인만 허용
    scriptSrc: ["'self'"],            // 외부 스크립트 차단
    styleSrc: ["'self'", "'unsafe-inline'"],
    imgSrc: ["'self'", 'data:', 'https:'],
  }
}));

💻 CSRF 공격 vs 방어

// CSRF(Cross-Site Request Forgery): 사용자 모르게 요청 위조
// 피해자가 해커 사이트 방문 시, 피해자의 쿠키로 은행 송금 요청 발송됨

// npm install csurf (세션/쿠키 기반 인증 사용 시)
const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

app.get('/form', csrfProtection, (req, res) => {
  res.json({ csrfToken: req.csrfToken() }); // 폼에 CSRF 토큰 포함
});
app.post('/transfer', csrfProtection, (req, res) => {
  // CSRF 토큰 자동 검증됨
});

// ✅ JWT + Authorization 헤더 방식은 CSRF 자동 방어됨
// (쿠키 대신 헤더로 인증하므로 다른 사이트에서 자동 포함 불가)

// ✅ SameSite 쿠키 설정으로도 방어 가능
res.cookie('session', sessionId, {
  httpOnly: true,       // JS에서 접근 불가 (XSS 방어)
  secure: true,         // HTTPS에서만 전송
  sameSite: 'strict',  // 동일 출처에서만 쿠키 전송 (CSRF 방어)
  maxAge: 60 * 60 * 1000 // 1시간
});

💻 Helmet + CORS 실전 설정

// npm install helmet cors
const helmet = require('helmet');
const cors = require('cors');

// ===== CORS 화이트리스트 설정 =====
const allowedOrigins = [
  'http://localhost:3001',       // 개발 환경
  'https://myapp.com',           // 프로덕션
  'https://www.myapp.com'        // www 서브도메인
];

app.use(cors({
  origin: (origin, callback) => {
    // origin이 없는 경우 (Postman, 서버간 요청) 허용
    if (!origin) return callback(null, true);
    if (allowedOrigins.includes(origin)) {
      callback(null, true);
    } else {
      callback(new Error('CORS 정책에 의해 차단되었습니다.'));
    }
  },
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true,  // 쿠키/인증정보 포함 요청 허용
  maxAge: 86400        // Preflight 결과 캐시: 24시간
}));

// ===== Helmet 설정 =====
app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      styleSrc: ["'self'", 'https://fonts.googleapis.com'],
      fontSrc: ["'self'", 'https://fonts.gstatic.com'],
      imgSrc: ["'self'", 'data:', 'https:'],
      scriptSrc: ["'self'"],
    }
  },
  hsts: {
    maxAge: 31536000,  // 1년간 HTTPS 강제
    includeSubDomains: true,
    preload: true
  }
}));

💻 Rate Limiting — 엔드포인트별 제한 설정

// npm install express-rate-limit
const rateLimit = require('express-rate-limit');

// ① 일반 API: 15분에 100회
const generalLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100,
  standardHeaders: true,  // RateLimit 헤더 포함
  legacyHeaders: false,
  message: { error: '요청이 너무 많습니다. 15분 후 다시 시도해주세요.' }
});

// ② 로그인 API: 1분에 5회 (Brute Force 방지)
const loginLimiter = rateLimit({
  windowMs: 60 * 1000,
  max: 5,
  message: { error: '너무 많은 로그인 시도. 1분 후 다시 시도해주세요.' },
  skipSuccessfulRequests: true  // 성공한 요청은 카운트 제외
});

// ③ 비밀번호 재설정: 1시간에 3회
const passwordResetLimiter = rateLimit({
  windowMs: 60 * 60 * 1000,
  max: 3,
  message: { error: '비밀번호 재설정은 1시간에 3회만 가능합니다.' }
});

// 적용
app.use('/api', generalLimiter);
app.use('/api/auth/login', loginLimiter);
app.use('/api/auth/reset-password', passwordResetLimiter);

💻 Joi 입력 검증 — 스키마 기반 유효성 검사

// npm install joi
const Joi = require('joi');

// ===== 검증 스키마 정의 =====
const schemas = {
  register: Joi.object({
    name: Joi.string().min(2).max(50).required()
      .messages({ 'string.min': '이름은 2자 이상이어야 합니다.' }),
    email: Joi.string().email().required()
      .messages({ 'string.email': '올바른 이메일 형식이 아닙니다.' }),
    password: Joi.string()
      .min(8).max(128)
      .pattern(new RegExp('^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*])'))
      .required()
      .messages({ 
        'string.pattern.base': '비밀번호는 대소문자, 숫자, 특수문자를 포함해야 합니다.'
      })
  }),
  login: Joi.object({
    email: Joi.string().email().required(),
    password: Joi.string().required()
  })
};

// ===== 검증 미들웨어 팩토리 =====
const validate = (schema) => (req, res, next) => {
  const { error } = schema.validate(req.body, { abortEarly: false });
  if (error) {
    const details = error.details.map(d => d.message);
    return res.status(400).json({ errors: details });
  }
  next();
};

// 사용 예시
router.post('/register', validate(schemas.register), registerHandler);
router.post('/login', validate(schemas.login), loginHandler);

🤔 왜 문제가 되나요?

💻 Redis 블랙리스트 구현

// npm install ioredis
const Redis = require('ioredis');
const redis = new Redis(process.env.REDIS_URL);

// ===== 로그아웃 — 토큰 블랙리스트 등록 =====
router.post('/logout', authMiddleware, async (req, res) => {
  const token = req.headers.authorization.split(' ')[1];
  const decoded = jwt.decode(token);
  
  // 토큰 만료까지 남은 시간(초) 계산
  const ttl = decoded.exp - Math.floor(Date.now() / 1000);
  
  // Redis에 블랙리스트 등록 (TTL: 남은 만료 시간)
  await redis.setex(`blacklist:${token}`, ttl, 'logout');
  
  res.json({ message: '로그아웃 되었습니다.' });
});

// ===== 강화된 인증 미들웨어 (블랙리스트 확인) =====
const authMiddleware = async (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (!authHeader?.startsWith('Bearer ')) {
    return res.status(401).json({ error: '토큰이 없습니다.' });
  }
  
  const token = authHeader.split(' ')[1];
  
  // ① 블랙리스트 확인 (로그아웃된 토큰 거부)
  const isBlacklisted = await redis.get(`blacklist:${token}`);
  if (isBlacklisted) {
    return res.status(401).json({ error: '로그아웃된 토큰입니다.' });
  }
  
  // ② 서명 검증
  try {
    req.user = jwt.verify(token, process.env.JWT_SECRET);
    next();
  } catch (err) {
    res.status(401).json({ error: '유효하지 않은 토큰입니다.' });
  }
};

💻 이메일 인증 구현 (Nodemailer + Redis)

// npm install nodemailer
const nodemailer = require('nodemailer');

// ===== 이메일 전송 설정 =====
const transporter = nodemailer.createTransport({
  service: 'gmail',
  auth: {
    user: process.env.EMAIL_USER,
    pass: process.env.EMAIL_APP_PASSWORD  // Gmail 앱 비밀번호
  }
});

// ===== 회원가입 시 이메일 인증 요청 =====
router.post('/register', async (req, res) => {
  // ... 기본 회원가입 처리 후 ...
  
  // 6자리 인증 코드 생성
  const verifyCode = Math.random().toString().slice(2, 8); // "384920"
  
  // Redis에 10분간 저장
  await redis.setex(`email_verify:${email}`, 600, verifyCode);
  
  // 이메일 발송
  await transporter.sendMail({
    from: '"MyApp" <noreply@myapp.com>',
    to: email,
    subject: '[MyApp] 이메일 인증 코드',
    html: `
      <div style="background:#f3f4f6;padding:40px;">
        <h2>이메일 인증</h2>
        <p>인증 코드: <strong style="font-size:2em;color:#6366f1;">${verifyCode}</strong></p>
        <p>10분 내에 입력해주세요.</p>
      </div>
    `
  });
  
  res.status(201).json({ message: '이메일로 인증 코드를 전송했습니다.' });
});

// ===== 인증 코드 검증 =====
router.post('/verify-email', async (req, res) => {
  const { email, code } = req.body;
  const savedCode = await redis.get(`email_verify:${email}`);
  
  if (!savedCode || savedCode !== code) {
    return res.status(400).json({ error: '인증 코드가 올바르지 않거나 만료되었습니다.' });
  }
  
  // 인증 완료 처리
  await prisma.user.update({ 
    where: { email }, 
    data: { emailVerified: true } 
  });
  await redis.del(`email_verify:${email}`); // 사용한 코드 삭제
  
  res.json({ message: '이메일 인증이 완료되었습니다!' });
});

💻 2FA (이중 인증) — TOTP 방식 (Google Authenticator)

// npm install speakeasy qrcode
const speakeasy = require('speakeasy');
const QRCode = require('qrcode');

// ① 2FA 설정 시작 — QR코드 생성
router.post('/2fa/setup', authMiddleware, async (req, res) => {
  // 시크릿 키 생성
  const secret = speakeasy.generateSecret({ 
    name: `MyApp (${req.user.email})` 
  });
  
  // DB에 임시 저장 (검증 전)
  await prisma.user.update({
    where: { id: req.user.userId },
    data: { twoFactorSecret: secret.base32 }
  });
  
  // QR 코드 이미지 생성 (Google Authenticator로 스캔)
  const qrCodeUrl = await QRCode.toDataURL(secret.otpauth_url);
  
  res.json({ secret: secret.base32, qrCode: qrCodeUrl });
});

// ② 2FA 인증 코드 검증
router.post('/2fa/verify', authMiddleware, async (req, res) => {
  const { token } = req.body; // Google Authenticator에서 생성된 6자리 코드
  const user = await prisma.user.findUnique({ where: { id: req.user.userId } });
  
  const verified = speakeasy.totp.verify({
    secret: user.twoFactorSecret,
    encoding: 'base32',
    token,
    window: 2  // ±2 타임스텝 허용 (시계 오차 보정)
  });
  
  if (!verified) {
    return res.status(400).json({ error: '인증 코드가 올바르지 않습니다.' });
  }
  
  res.json({ message: '2FA 인증 성공!' });
});

🎉 BackendDevGuide0004 완료!

인증과 보안의 모든 핵심을 마스터했습니다. 이제 bcrypt, JWT, OAuth2, HTTPS, OWASP, Rate Limiting까지 현업에서 바로 사용할 수 있습니다!

다음: BackendDevGuide0005 — TypeScript + NestJS 완전 정복