🔍 JWT의 기본 구조 이해하기

JWT를 제대로 보안하려면 먼저 구조를 정확히 알아야 해. JWT는 점(.)으로 구분된 세 부분으로 이루어져 있어:

Header.Payload.Signature

이렇게 생긴 거지. 각 부분을 자세히 살펴볼까? 🧐

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

여기서 alg는 서명에 사용될 알고리즘을 지정하는데, 이게 바로 첫 번째 보안 포인트야! 많은 공격이 이 알고리즘 부분을 노리거든. 😱

{
  "sub": "1234567890",
  "name": "홍길동",
  "role": "admin",
  "iat": 1516239022,
  "exp": 1516242622
}

여기서 중요한 건, 페이로드는 암호화되지 않고 단순히 Base64로 인코딩만 된다는 거야! 누구나 디코딩해서 내용을 볼 수 있다는 뜻이지. 그래서 민감한 정보를 넣으면 절대 안 돼! 🚫

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret
)

서명 덕분에 누군가 토큰 내용을 조작하면 바로 알 수 있어. 하지만 비밀키가 노출되면? 게임 오버야! 🎮

⚠️ 가장 흔한 JWT 보안 취약점들

자, 이제 본격적으로 JWT 사용할 때 조심해야 할 보안 취약점들을 알아보자. 실제 프로젝트에서 정말 자주 발생하는 문제들이니까 꼭 체크해! ✅

이건 정말 유명한 공격 방법이야. JWT 라이브러리들이 헤더의 alg 필드를 신뢰해서 발생하는 문제지.

공격자가 알고리즘을 HS256에서 none으로 바꾸면 어떻게 될까?

{
  "alg": "none",
  "typ": "JWT"
}
{
  "sub": "1234567890",
  "role": "admin"  // 권한 상승!
}
// 서명 부분 없음!

// Node.js + jsonwebtoken 라이브러리 예시
jwt.verify(token, secretKey, {
  algorithms: ['HS256']  // 명시적으로 알고리즘 지정!
});

앞서 말했듯이 JWT의 페이로드는 암호화되지 않아. 그냥 Base64 인코딩만 되어 있어서 누구나 디코딩할 수 있지. 그런데도 많은 개발자들이 실수로 민감한 정보를 넣는 경우가 있어. 😰

JWT는 브라우저의 로컬 스토리지나 쿠키에 저장되는 경우가 많은데, XSS 공격에 노출되면 이 정보들이 그대로 탈취될 수 있어. 재능넷 같은 플랫폼에서 사용자 정보를 다룰 때는 특히 조심해야 해! 🛡️

JWT 서명에 사용되는 비밀키가 약하면 브루트포스 공격으로 뚫릴 수 있어. 실제로 "secret", "password", "123456" 같은 키를 쓰는 경우도 있다니까! 😱

// Node.js에서 안전한 비밀키 생성
const crypto = require('crypto');
const secretKey = crypto.randomBytes(64).toString('hex');

// 환경 변수로 관리
process.env.JWT_SECRET = secretKey;

토큰에 만료 시간을 설정하지 않거나, 너무 긴 만료 시간을 설정하는 것도 큰 보안 위험이야. 토큰이 탈취되면 만료될 때까지 계속 악용될 수 있거든! 😨

// JWT 생성 시 만료 시간 설정
const token = jwt.sign(
  { userId: user.id, role: user.role },
  secretKey,
  { 
    expiresIn: '15m',  // 15분 후 만료
    issuer: 'jaenung.net',
    audience: 'api.jaenung.net'
  }
);

🛡️ JWT를 안전하게 저장하는 방법

JWT를 생성하고 검증하는 것도 중요하지만, 클라이언트에서 어떻게 저장하느냐도 엄청 중요해! 저장 방식에 따라 보안 수준이 완전히 달라지거든. 🔐

각 저장 방식의 장단점을 비교해볼게:

// Express.js 서버에서 안전한 쿠키 설정
res.cookie('accessToken', token, {
  httpOnly: true,      // JavaScript 접근 차단
  secure: true,        // HTTPS에서만 전송
  sameSite: 'strict',  // CSRF 공격 방어
  maxAge: 900000,      // 15분 (밀리초)
  path: '/'
});

// 리프레시 토큰은 더 긴 시간으로
res.cookie('refreshToken', refreshToken, {
  httpOnly: true,
  secure: true,
  sameSite: 'strict',
  maxAge: 604800000,   // 7일
  path: '/api/refresh'  // 특정 경로에만 전송
});

XSS(Cross-Site Scripting)는 JWT를 노리는 가장 흔한 공격이야. 악성 스크립트를 주입해서 토큰을 훔쳐가는 거지. 방어 방법을 알아보자! 🛡️

// CSP 헤더 설정 예시
app.use((req, res, next) => {
  res.setHeader(
    'Content-Security-Policy',
    "default-src 'self'; " +
    "script-src 'self' 'unsafe-inline' https://trusted-cdn.com; " +
    "style-src 'self' 'unsafe-inline';"
  );
  next();
});

// 입력값 이스케이핑 (DOMPurify 라이브러리 사용)
import DOMPurify from 'dompurify';

const cleanInput = DOMPurify.sanitize(userInput, {
  ALLOWED_TAGS: ['b', 'i', 'em', 'strong'],
  ALLOWED_ATTR: []
});

CSRF(Cross-Site Request Forgery)는 사용자가 의도하지 않은 요청을 보내도록 하는 공격이야. JWT를 쿠키에 저장할 때 특히 조심해야 해! 🎯

// SameSite 쿠키 설정
res.cookie('token', jwt, {
  httpOnly: true,
  secure: true,
  sameSite: 'strict'  // 가장 강력한 보호
});

// CSRF 토큰 미들웨어 (csurf 라이브러리)
const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

app.post('/api/transfer', csrfProtection, (req, res) => {
  // CSRF 토큰 자동 검증됨
  // 비즈니스 로직 실행
});

// 클라이언트에서 CSRF 토큰 포함
fetch('/api/transfer', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-CSRF-Token': csrfToken
  },
  body: JSON.stringify(data)
});

🔄 리프레시 토큰 전략

액세스 토큰의 만료 시간을 짧게 하면 보안은 좋아지지만, 사용자가 자주 로그인해야 해서 불편하잖아? 이 문제를 해결하는 게 바로 리프레시 토큰이야! 🎫

리프레시 토큰을 더 안전하게 사용하는 방법이 바로 로테이션이야. 한 번 사용한 리프레시 토큰은 폐기하고 새로운 리프레시 토큰을 발급하는 거지! 🔐

// 리프레시 토큰 로테이션 구현 예시
app.post('/api/refresh', async (req, res) => {
  const { refreshToken } = req.cookies;
  
  try {
    // 1. 리프레시 토큰 검증
    const decoded = jwt.verify(refreshToken, REFRESH_SECRET);
    
    // 2. DB에서 토큰 확인 (이미 사용되었는지)
    const storedToken = await db.getRefreshToken(decoded.userId);
    
    if (!storedToken || storedToken !== refreshToken) {
      // 재사용 시도 감지! 모든 토큰 무효화
      await db.revokeAllTokens(decoded.userId);
      return res.status(401).json({ error: '의심스러운 활동 감지' });
    }
    
    // 3. 기존 리프레시 토큰 폐기
    await db.revokeRefreshToken(refreshToken);
    
    // 4. 새로운 액세스 토큰 생성
    const newAccessToken = jwt.sign(
      { userId: decoded.userId, role: decoded.role },
      ACCESS_SECRET,
      { expiresIn: '15m' }
    );
    
    // 5. 새로운 리프레시 토큰 생성
    const newRefreshToken = jwt.sign(
      { userId: decoded.userId },
      REFRESH_SECRET,
      { expiresIn: '7d' }
    );
    
    // 6. 새 리프레시 토큰 DB에 저장
    await db.saveRefreshToken(decoded.userId, newRefreshToken);
    
    // 7. 쿠키로 전송
    res.cookie('accessToken', newAccessToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 900000
    });
    
    res.cookie('refreshToken', newRefreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 604800000
    });
    
    res.json({ success: true });
    
  } catch (error) {
    res.status(401).json({ error: '토큰 갱신 실패' });
  }
});

리프레시 토큰은 서버 측에서도 관리해야 해. 단순히 검증만 하는 게 아니라, 발급된 토큰을 추적하고 필요시 무효화할 수 있어야 하거든! 📊

// Redis를 사용한 리프레시 토큰 관리
const redis = require('redis');
const client = redis.createClient();

// 리프레시 토큰 저장 (7일 TTL)
async function saveRefreshToken(userId, token) {
  const key = `refresh:${userId}`;
  await client.setEx(key, 604800, token);  // 7일
}

// 리프레시 토큰 조회
async function getRefreshToken(userId) {
  const key = `refresh:${userId}`;
  return await client.get(key);
}

// 리프레시 토큰 폐기
async function revokeRefreshToken(userId) {
  const key = `refresh:${userId}`;
  await client.del(key);
}

// 사용자의 모든 토큰 무효화 (보안 사고 시)
async function revokeAllTokens(userId) {
  const keys = await client.keys(`refresh:${userId}*`);
  if (keys.length > 0) {
    await client.del(keys);
  }
}

🔐 JWT 암호화 알고리즘 선택

JWT에서 사용하는 암호화 알고리즘 선택은 정말 중요해! 잘못 선택하면 보안이 완전히 무너질 수 있거든. 주요 알고리즘들을 비교해보자! 🎯

// HS256 (대칭키) 사용 예시
const jwt = require('jsonwebtoken');
const secretKey = process.env.JWT_SECRET;

const token = jwt.sign(
  { userId: 123, role: 'user' },
  secretKey,
  { algorithm: 'HS256', expiresIn: '15m' }
);

// RS256 (비대칭키) 사용 예시
const fs = require('fs');
const privateKey = fs.readFileSync('private.key');
const publicKey = fs.readFileSync('public.key');

// 토큰 생성 (개인키 사용)
const token = jwt.sign(
  { userId: 123, role: 'user' },
  privateKey,
  { algorithm: 'RS256', expiresIn: '15m' }
);

// 토큰 검증 (공개키 사용)
jwt.verify(token, publicKey, { algorithms: ['RS256'] }, (err, decoded) => {
  if (err) {
    console.error('검증 실패:', err);
  } else {
    console.log('검증 성공:', decoded);
  }
});

// ❌ 절대 하지 말아야 할 것들
// 1. none 알고리즘 허용
jwt.verify(token, secretKey, {
  algorithms: ['HS256', 'none']  // 위험!
});

// 2. 알고리즘 자동 감지
jwt.verify(token, secretKey);  // 위험! 알고리즘 명시 안 함

// 3. 약한 비밀키
const secretKey = 'secret';  // 위험!

// ✅ 올바른 방법
// 1. 알고리즘 명시적 지정
jwt.verify(token, secretKey, {
  algorithms: ['HS256']  // 안전!
});

// 2. 강력한 비밀키 생성
const crypto = require('crypto');
const secretKey = crypto.randomBytes(64).toString('hex');

// 3. 환경 변수로 관리
const secretKey = process.env.JWT_SECRET;

🛠️ JWT 검증 체크리스트

JWT를 검증할 때는 단순히 서명만 확인하면 안 돼. 여러 가지를 체크해야 안전해! 실무에서 꼭 확인해야 할 항목들을 정리해봤어. ✅

// 완벽한 JWT 검증 예시
const jwt = require('jsonwebtoken');
const redis = require('redis');
const client = redis.createClient();

async function verifyToken(token) {
  try {
    // 1. 기본 검증 (서명, 만료시간 등)
    const decoded = jwt.verify(token, process.env.JWT_SECRET, {
      algorithms: ['HS256'],           // 알고리즘 명시
      issuer: 'jaenung.net',           // 발급자 확인
      audience: 'api.jaenung.net',     // 대상 확인
      clockTolerance: 30               // 30초 클럭 스큐 허용
    });
    
    // 2. 토큰 블랙리스트 확인
    const isBlacklisted = await client.get(`blacklist:${decoded.jti}`);
    if (isBlacklisted) {
      throw new Error('토큰이 무효화되었습니다');
    }
    
    // 3. 사용자 상태 확인 (선택적)
    const user = await db.getUser(decoded.userId);
    if (!user || !user.isActive) {
      throw new Error('사용자 계정이 비활성화되었습니다');
    }
    
    // 4. 권한 확인
    if (decoded.role !== 'admin' && decoded.role !== 'user') {
      throw new Error('유효하지 않은 권한입니다');
    }
    
    // 5. 추가 보안 검증
    // IP 주소 확인, 디바이스 확인 등
    
    return decoded;
    
  } catch (error) {
    if (error.name === 'TokenExpiredError') {
      throw new Error('토큰이 만료되었습니다');
    } else if (error.name === 'JsonWebTokenError') {
      throw new Error('유효하지 않은 토큰입니다');
    } else if (error.name === 'NotBeforeError') {
      throw new Error('토큰이 아직 유효하지 않습니다');
    }
    throw error;
  }
}

// Express 미들웨어로 사용
async function authMiddleware(req, res, next) {
  try {
    const token = req.cookies.accessToken || 
                  req.headers.authorization?.split(' ')[1];
    
    if (!token) {
      return res.status(401).json({ error: '토큰이 없습니다' });
    }
    
    const decoded = await verifyToken(token);
    req.user = decoded;
    next();
    
  } catch (error) {
    res.status(401).json({ error: error.message });
  }
}

JWT는 기본적으로 Stateless라서 한 번 발급되면 만료 전까지 무효화하기 어려워. 하지만 보안 사고가 발생하면 즉시 토큰을 무효화해야 하잖아? 이럴 때 사용하는 전략들이야! 🔒

// 블랙리스트 구현
async function revokeToken(token) {
  const decoded = jwt.decode(token);
  const ttl = decoded.exp - Math.floor(Date.now() / 1000);
  
  // 만료 시간까지만 블랙리스트에 유지
  await client.setEx(`blacklist:${decoded.jti}`, ttl, 'revoked');
}

// 로그아웃 시 토큰 무효화
app.post('/api/logout', authMiddleware, async (req, res) => {
  const token = req.cookies.accessToken;
  await revokeToken(token);
  
  res.clearCookie('accessToken');
  res.clearCookie('refreshToken');
  res.json({ message: '로그아웃 성공' });
});

// 화이트리스트 구현
async function issueToken(userId, role) {
  const jti = crypto.randomBytes(16).toString('hex');
  
  const token = jwt.sign(
    { userId, role, jti },
    process.env.JWT_SECRET,
    { expiresIn: '15m' }
  );
  
  // 화이트리스트에 추가
  await client.setEx(`whitelist:${jti}`, 900, userId);
  
  return token;
}

// 검증 시 화이트리스트 확인
async function verifyWhitelistedToken(token) {
  const decoded = jwt.verify(token, process.env.JWT_SECRET);
  
  const userId = await client.get(`whitelist:${decoded.jti}`);
  if (!userId || userId !== decoded.userId.toString()) {
    throw new Error('유효하지 않은 토큰입니다');
  }
  
  return decoded;
}

// 버전 관리 구현
// 토큰 발급 시 버전 포함
async function issueVersionedToken(userId, role) {
  const version = await db.getUserTokenVersion(userId);
  
  const token = jwt.sign(
    { userId, role, version },
    process.env.JWT_SECRET,
    { expiresIn: '15m' }
  );
  
  return token;
}

// 검증 시 버전 확인
async function verifyVersionedToken(token) {
  const decoded = jwt.verify(token, process.env.JWT_SECRET);
  
  const currentVersion = await db.getUserTokenVersion(decoded.userId);
  if (decoded.version !== currentVersion) {
    throw new Error('토큰 버전이 일치하지 않습니다');
  }
  
  return decoded;
}

// 모든 토큰 무효화 (비밀번호 변경 시 등)
async function invalidateAllUserTokens(userId) {
  await db.incrementUserTokenVersion(userId);
}

🌐 실전 시나리오별 보안 가이드

이론은 충분히 배웠으니, 이제 실제 상황에서 어떻게 적용하는지 알아보자! 재능넷 같은 실제 서비스에서 마주칠 수 있는 시나리오들이야. 💼

React, Vue, Angular 같은 SPA에서 JWT를 사용할 때의 보안 전략이야. 가장 흔한 케이스지! 🚀

// React에서 안전한 JWT 관리
import axios from 'axios';

// 액세스 토큰을 메모리에 저장
let accessToken = null;

// Axios 인터셉터 설정
axios.interceptors.request.use(
  (config) => {
    if (accessToken) {
      config.headers.Authorization = `Bearer ${accessToken}`;
    }
    return config;
  },
  (error) => Promise.reject(error)
);

// 응답 인터셉터 (토큰 갱신)
axios.interceptors.response.use(
  (response) => response,
  async (error) => {
    const originalRequest = error.config;
    
    // 401 에러이고 재시도가 아닌 경우
    if (error.response?.status === 401 && !originalRequest._retry) {
      originalRequest._retry = true;
      
      try {
        // 리프레시 토큰으로 새 액세스 토큰 발급
        const response = await axios.post('/api/refresh', {}, {
          withCredentials: true  // 쿠키 포함
        });
        
        accessToken = response.data.accessToken;
        
        // 원래 요청 재시도
        originalRequest.headers.Authorization = `Bearer ${accessToken}`;
        return axios(originalRequest);
        
      } catch (refreshError) {
        // 리프레시 실패 시 로그아웃
        accessToken = null;
        window.location.href = '/login';
        return Promise.reject(refreshError);
      }
    }
    
    return Promise.reject(error);
  }
);

// 로그인 함수
async function login(email, password) {
  try {
    const response = await axios.post('/api/login', 
      { email, password },
      { withCredentials: true }  // 쿠키 받기
    );
    
    // 액세스 토큰만 메모리에 저장
    accessToken = response.data.accessToken;
    // 리프레시 토큰은 HTTP-Only 쿠키로 자동 저장됨
    
    return response.data;
  } catch (error) {
    console.error('로그인 실패:', error);
    throw error;
  }
}

// 로그아웃 함수
async function logout() {
  try {
    await axios.post('/api/logout', {}, {
      withCredentials: true
    });
    
    accessToken = null;
    window.location.href = '/login';
  } catch (error) {
    console.error('로그아웃 실패:', error);
  }
}

iOS, Android 네이티브 앱에서는 웹과 다른 보안 전략이 필요해! 📲

// React Native에서 안전한 토큰 저장
import * as Keychain from 'react-native-keychain';
import * as LocalAuthentication from 'expo-local-authentication';

// 토큰 저장 (생체 인증 필요)
async function saveTokens(accessToken, refreshToken) {
  try {
    // 생체 인증 확인
    const hasHardware = await LocalAuthentication.hasHardwareAsync();
    const isEnrolled = await LocalAuthentication.isEnrolledAsync();
    
    if (hasHardware && isEnrolled) {
      const result = await LocalAuthentication.authenticateAsync({
        promptMessage: '토큰을 안전하게 저장하기 위해 인증이 필요합니다',
      });
      
      if (!result.success) {
        throw new Error('인증 실패');
      }
    }
    
    // Keychain에 저장
    await Keychain.setGenericPassword(
      'tokens',
      JSON.stringify({ accessToken, refreshToken }),
      {
        accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
        securityLevel: Keychain.SECURITY_LEVEL.SECURE_HARDWARE,
      }
    );
    
  } catch (error) {
    console.error('토큰 저장 실패:', error);
    throw error;
  }
}

// 토큰 불러오기
async function loadTokens() {
  try {
    const credentials = await Keychain.getGenericPassword();
    
    if (credentials) {
      const tokens = JSON.parse(credentials.password);
      return tokens;
    }
    
    return null;
  } catch (error) {
    console.error('토큰 불러오기 실패:', error);
    return null;
  }
}

// 토큰 삭제
async function deleteTokens() {
  try {
    await Keychain.resetGenericPassword();
  } catch (error) {
    console.error('토큰 삭제 실패:', error);
  }
}

여러 서비스가 JWT를 공유해야 할 때는 어떻게 해야 할까? 복잡하지만 중요한 주제야! 🏗️

// 인증 서비스 (토큰 발급)
const fs = require('fs');
const jwt = require('jsonwebtoken');

const privateKey = fs.readFileSync('private.key');

function issueToken(user) {
  return jwt.sign(
    {
      userId: user.id,
      email: user.email,
      role: user.role,
      permissions: user.permissions,
      tenantId: user.tenantId
    },
    privateKey,
    {
      algorithm: 'RS256',
      expiresIn: '15m',
      issuer: 'auth.jaenung.net',
      audience: ['api.jaenung.net', 'admin.jaenung.net']
    }
  );
}

// 다른 마이크로서비스 (토큰 검증)
const publicKey = fs.readFileSync('public.key');

function verifyToken(token, requiredPermission) {
  try {
    const decoded = jwt.verify(token, publicKey, {
      algorithms: ['RS256'],
      issuer: 'auth.jaenung.net',
      audience: 'api.jaenung.net'
    });
    
    // 권한 확인
    if (!decoded.permissions.includes(requiredPermission)) {
      throw new Error('권한이 없습니다');
    }
    
    return decoded;
  } catch (error) {
    throw error;
  }
}

// API Gateway 미들웨어
async function gatewayAuthMiddleware(req, res, next) {
  try {
    const token = req.headers.authorization?.split(' ')[1];
    
    if (!token) {
      return res.status(401).json({ error: '토큰이 없습니다' });
    }
    
    const decoded = jwt.verify(token, publicKey, {
      algorithms: ['RS256']
    });
    
    // 검증된 사용자 정보를 헤더에 추가
    req.headers['X-User-Id'] = decoded.userId;
    req.headers['X-User-Role'] = decoded.role;
    req.headers['X-Tenant-Id'] = decoded.tenantId;
    
    next();
  } catch (error) {
    res.status(401).json({ error: '인증 실패' });
  }
}

소셜 로그인이나 제3자 인증을 구현할 때는 표준 프로토콜을 따라야 해! 🌍

// OpenID Connect ID 토큰 검증
const jwksClient = require('jwks-rsa');

const client = jwksClient({
  jwksUri: 'https://auth.jaenung.net/.well-known/jwks.json',
  cache: true,
  cacheMaxAge: 86400000  // 24시간
});

function getKey(header, callback) {
  client.getSigningKey(header.kid, (err, key) => {
    if (err) {
      callback(err);
    } else {
      const signingKey = key.publicKey || key.rsaPublicKey;
      callback(null, signingKey);
    }
  });
}

function verifyIdToken(idToken) {
  return new Promise((resolve, reject) => {
    jwt.verify(idToken, getKey, {
      algorithms: ['RS256'],
      issuer: 'https://auth.jaenung.net',
      audience: 'your-client-id'
    }, (err, decoded) => {
      if (err) {
        reject(err);
      } else {
        // ID 토큰 클레임 검증
        if (!decoded.sub || !decoded.email) {
          reject(new Error('필수 클레임이 없습니다'));
        }
        resolve(decoded);
      }
    });
  });
}

🔍 보안 모니터링과 로깅

아무리 보안을 잘 구현해도 모니터링하지 않으면 공격을 놓칠 수 있어. 실시간으로 의심스러운 활동을 감지하는 방법을 알아보자! 👀

// Winston을 사용한 보안 로깅
const winston = require('winston');

const securityLogger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({ 
      filename: 'security.log',
      level: 'warn'
    }),
    new winston.transports.File({ 
      filename: 'auth.log'
    })
  ]
});

// 로그인 시도 로깅
function logLoginAttempt(req, success, userId = null) {
  const logData = {
    event: 'login_attempt',
    success,
    userId,
    ip: req.ip,
    userAgent: req.headers['user-agent'],
    timestamp: new Date().toISOString()
  };
  
  if (success) {
    securityLogger.info('로그인 성공', logData);
  } else {
    securityLogger.warn('로그인 실패', logData);
  }
}

// 토큰 검증 실패 로깅
function logTokenVerificationFailure(req, error) {
  securityLogger.warn('토큰 검증 실패', {
    event: 'token_verification_failed',
    error: error.message,
    ip: req.ip,
    userAgent: req.headers['user-agent'],
    timestamp: new Date().toISOString()
  });
}

// 의심스러운 활동 로깅
function logSuspiciousActivity(req, reason, userId = null) {
  securityLogger.error('의심스러운 활동 감지', {
    event: 'suspicious_activity',
    reason,
    userId,
    ip: req.ip,
    userAgent: req.headers['user-agent'],
    timestamp: new Date().toISOString()
  });
  
  // 알림 전송 (Slack, 이메일 등)
  sendSecurityAlert(reason, userId, req.ip);
}

로그를 쌓는 것만으로는 부족해. 실시간으로 분석해서 공격을 막아야 해! 🛡️

// Redis를 사용한 브루트포스 방어
const redis = require('redis');
const client = redis.createClient();

async function checkBruteForce(identifier) {
  const key = `login_attempts:${identifier}`;
  const attempts = await client.get(key);
  
  if (attempts && parseInt(attempts) >= 5) {
    const ttl = await client.ttl(key);
    throw new Error(`너무 많은 로그인 시도. ${ttl}초 후 다시 시도하세요.`);
  }
}

async function recordLoginAttempt(identifier, success) {
  const key = `login_attempts:${identifier}`;
  
  if (success) {
    // 성공 시 카운터 리셋
    await client.del(key);
  } else {
    // 실패 시 카운터 증가
    const attempts = await client.incr(key);
    
    if (attempts === 1) {
      // 첫 실패 시 15분 TTL 설정
      await client.expire(key, 900);
    }
    
    if (attempts >= 5) {
      // 5회 실패 시 알림
      logSuspiciousActivity({ ip: identifier }, 'brute_force_detected');
    }
  }
}

// 로그인 엔드포인트에 적용
app.post('/api/login', async (req, res) => {
  const { email, password } = req.body;
  const identifier = req.ip;  // 또는 email
  
  try {
    // 브루트포스 체크
    await checkBruteForce(identifier);
    
    // 인증 시도
    const user = await authenticateUser(email, password);
    
    if (user) {
      await recordLoginAttempt(identifier, true);
      
      const accessToken = issueToken(user);
      const refreshToken = issueRefreshToken(user);
      
      res.cookie('accessToken', accessToken, cookieOptions);
      res.cookie('refreshToken', refreshToken, cookieOptions);
      
      logLoginAttempt(req, true, user.id);
      res.json({ success: true });
      
    } else {
      await recordLoginAttempt(identifier, false);
      logLoginAttempt(req, false);
      res.status(401).json({ error: '인증 실패' });
    }
    
  } catch (error) {
    res.status(429).json({ error: error.message });
  }
});

주요 보안 지표들을 대시보드로 모니터링하면 문제를 빠르게 파악할 수 있어! 📊

// Prometheus를 사용한 메트릭 수집
const promClient = require('prom-client');

// 메트릭 정의
const loginAttempts = new promClient.Counter({
  name: 'login_attempts_total',
  help: '총 로그인 시도 횟수',
  labelNames: ['status']
});

const tokenVerifications = new promClient.Counter({
  name: 'token_verifications_total',
  help: '총 토큰 검증 횟수',
  labelNames: ['result']
});

const activeTokens = new promClient.Gauge({
  name: 'active_tokens',
  help: '현재 활성 토큰 수'
});

// 메트릭 기록
function recordLoginMetric(success) {
  loginAttempts.inc({ status: success ? 'success' : 'failure' });
}

function recordTokenVerificationMetric(result) {
  tokenVerifications.inc({ result });
}

// 메트릭 엔드포인트
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', promClient.register.contentType);
  res.end(await promClient.register.metrics());
});

🎓 보안 체크리스트 총정리

자, 이제 마지막으로 JWT 보안을 위한 완벽한 체크리스트를 정리해볼게! 프로젝트에 적용할 때 하나씩 체크하면서 사용하면 좋아. ✅