🎯 OAuth 2.0, 너 누구냐?

요즘 웹사이트나 앱에 가입할 때 "구글로 로그인", "카카오로 시작하기" 같은 버튼 많이 보지? 🤔
이게 바로 OAuth 2.0이 작동하는 순간이야. 비밀번호를 직접 입력하지 않고도 다른 서비스의 인증을 빌려서 로그인할 수 있게 해주는 마법 같은 프로토콜이지.

2012년에 정식으로 표준화된 OAuth 2.0은 이전 버전인 OAuth 1.0의 복잡함을 대폭 개선했어. 인증(Authentication)과 인가(Authorization)를 분리해서 처리하는 게 핵심이야.

쉽게 말하면, "너 누구야?"를 확인하는 게 인증이고, "너 이거 해도 돼?"를 확인하는 게 인가야. OAuth 2.0은 주로 인가에 집중하는 프레임워크지만, 실제로는 인증 용도로도 광범위하게 사용되고 있어. 🎭

🛡️ OAuth 2.0 보안 모범 사례

지금까지 다양한 위협을 살펴봤으니, 이제 이를 종합해서 실전에서 적용할 수 있는 보안 가이드를 정리해볼게. 📋

💻 실전 구현 예제

이론만 알아서는 부족하지. 실제로 어떻게 구현하는지 코드로 살펴보자! 👨‍💻
여기서는 Node.js/Express를 사용한 예제를 보여줄게.

// 필요한 패키지 설치
// npm install express express-session crypto axios

const express = require('express');
const session = require('express-session');
const crypto = require('crypto');
const axios = require('axios');

const app = express();

// 세션 설정
app.use(session({
    secret: 'your-session-secret',
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: true, // HTTPS에서만 전송
        httpOnly: true, // JavaScript 접근 차단
        sameSite: 'lax', // CSRF 방어
        maxAge: 3600000 // 1시간
    }
}));

// OAuth 설정
const OAUTH_CONFIG = {
    clientId: 'your-client-id',
    clientSecret: 'your-client-secret',
    authorizationUrl: 'https://oauth-provider.com/authorize',
    tokenUrl: 'https://oauth-provider.com/token',
    redirectUri: 'https://your-app.com/callback',
    scope: 'read_profile read_email'
};

// PKCE 헬퍼 함수
function generateCodeVerifier() {
    return crypto.randomBytes(32).toString('base64url');
}

function generateCodeChallenge(verifier) {
    return crypto
        .createHash('sha256')
        .update(verifier)
        .digest('base64url');
}

// State 생성 함수
function generateState() {
    return crypto.randomBytes(32).toString('hex');
}

// 1. 로그인 시작 - 인가 요청
app.get('/login', (req, res) => {
    // PKCE 파라미터 생성
    const codeVerifier = generateCodeVerifier();
    const codeChallenge = generateCodeChallenge(codeVerifier);
    
    // State 생성
    const state = generateState();
    
    // 세션에 저장 (검증용)
    req.session.oauthState = state;
    req.session.codeVerifier = codeVerifier;
    
    // 인가 URL 생성
    const params = new URLSearchParams({
        response_type: 'code',
        client_id: OAUTH_CONFIG.clientId,
        redirect_uri: OAUTH_CONFIG.redirectUri,
        scope: OAUTH_CONFIG.scope,
        state: state,
        code_challenge: codeChallenge,
        code_challenge_method: 'S256'
    });
    
    const authUrl = `${OAUTH_CONFIG.authorizationUrl}?${params}`;
    
    // 사용자를 인증 서버로 리다이렉트
    res.redirect(authUrl);
});

// 2. 콜백 처리 - 토큰 교환
app.get('/callback', async (req, res) => {
    try {
        const { code, state } = req.query;
        
        // State 검증 (CSRF 방어)
        if (!state || state !== req.session.oauthState) {
            throw new Error('Invalid state parameter');
        }
        
        // State 일회용으로 만들기
        delete req.session.oauthState;
        
        // 인가 코드 확인
        if (!code) {
            throw new Error('Authorization code not received');
        }
        
        // 토큰 교환 요청
        const tokenResponse = await axios.post(
            OAUTH_CONFIG.tokenUrl,
            new URLSearchParams({
                grant_type: 'authorization_code',
                code: code,
                redirect_uri: OAUTH_CONFIG.redirectUri,
                client_id: OAUTH_CONFIG.clientId,
                client_secret: OAUTH_CONFIG.clientSecret,
                code_verifier: req.session.codeVerifier
            }),
            {
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                }
            }
        );
        
        // Code verifier 삭제
        delete req.session.codeVerifier;
        
        const { access_token, refresh_token, expires_in } = tokenResponse.data;
        
        // 토큰을 안전하게 저장
        // 실제 프로덕션에서는 암호화된 데이터베이스에 저장
        req.session.accessToken = access_token;
        req.session.refreshToken = refresh_token;
        req.session.tokenExpiry = Date.now() + (expires_in * 1000);
        
        // 사용자 정보 가져오기
        const userInfo = await getUserInfo(access_token);
        req.session.user = userInfo;
        
        res.redirect('/dashboard');
        
    } catch (error) {
        console.error('OAuth callback error:', error.message);
        res.status(500).send('Authentication failed');
    }
});

// 3. 사용자 정보 조회
async function getUserInfo(accessToken) {
    try {
        const response = await axios.get(
            'https://oauth-provider.com/userinfo',
            {
                headers: {
                    'Authorization': `Bearer ${accessToken}`
                }
            }
        );
        return response.data;
    } catch (error) {
        throw new Error('Failed to fetch user info');
    }
}

// 4. 토큰 갱신
async function refreshAccessToken(refreshToken) {
    try {
        const response = await axios.post(
            OAUTH_CONFIG.tokenUrl,
            new URLSearchParams({
                grant_type: 'refresh_token',
                refresh_token: refreshToken,
                client_id: OAUTH_CONFIG.clientId,
                client_secret: OAUTH_CONFIG.clientSecret
            }),
            {
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                }
            }
        );
        
        return response.data;
    } catch (error) {
        throw new Error('Token refresh failed');
    }
}

// 5. 인증 미들웨어
async function requireAuth(req, res, next) {
    if (!req.session.accessToken) {
        return res.redirect('/login');
    }
    
    // 토큰 만료 확인
    if (Date.now() >= req.session.tokenExpiry) {
        try {
            // 토큰 갱신 시도
            const newTokens = await refreshAccessToken(req.session.refreshToken);
            req.session.accessToken = newTokens.access_token;
            req.session.tokenExpiry = Date.now() + (newTokens.expires_in * 1000);
            
            if (newTokens.refresh_token) {
                req.session.refreshToken = newTokens.refresh_token;
            }
        } catch (error) {
            // 갱신 실패 시 재로그인 필요
            delete req.session.accessToken;
            delete req.session.refreshToken;
            return res.redirect('/login');
        }
    }
    
    next();
}

// 6. 보호된 라우트
app.get('/dashboard', requireAuth, (req, res) => {
    res.send(`
        <h1>Welcome, ${req.session.user.name}!</h1>
        <p>Email: ${req.session.user.email}</p>
        <a href="/logout">Logout</a>
    `);
});

// 7. 로그아웃
app.get('/logout', async (req, res) => {
    // 토큰 취소 (OAuth 제공자가 지원하는 경우)
    if (req.session.accessToken) {
        try {
            await axios.post(
                'https://oauth-provider.com/revoke',
                new URLSearchParams({
                    token: req.session.accessToken,
                    client_id: OAUTH_CONFIG.clientId,
                    client_secret: OAUTH_CONFIG.clientSecret
                })
            );
        } catch (error) {
            console.error('Token revocation failed:', error.message);
        }
    }
    
    // 세션 삭제
    req.session.destroy();
    res.redirect('/');
});

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

// JWT 검증 예제
const jwt = require('jsonwebtoken');
const jwksClient = require('jwks-rsa');

// JWKS 클라이언트 설정 (공개키 가져오기)
const client = jwksClient({
    jwksUri: 'https://oauth-provider.com/.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);
        }
    });
}

// JWT 검증 미들웨어
function verifyJWT(req, res, next) {
    const authHeader = req.headers.authorization;
    
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
        return res.status(401).json({ error: 'No token provided' });
    }
    
    const token = authHeader.substring(7);
    
    // JWT 검증
    jwt.verify(
        token,
        getKey,
        {
            algorithms: ['RS256'],
            issuer: 'https://oauth-provider.com',
            audience: 'your-api-identifier'
        },
        (err, decoded) => {
            if (err) {
                if (err.name === 'TokenExpiredError') {
                    return res.status(401).json({ error: 'Token expired' });
                }
                return res.status(401).json({ error: 'Invalid token' });
            }
            
            // 스코프 검증
            const requiredScope = 'read:data';
            const tokenScopes = decoded.scope ? decoded.scope.split(' ') : [];
            
            if (!tokenScopes.includes(requiredScope)) {
                return res.status(403).json({ error: 'Insufficient permissions' });
            }
            
            // 추가 보안 검증
            // 1. 토큰 취소 목록 확인
            if (isTokenRevoked(decoded.jti)) {
                return res.status(401).json({ error: 'Token revoked' });
            }
            
            // 2. 클라이언트 검증
            if (!isValidClient(decoded.client_id)) {
                return res.status(401).json({ error: 'Invalid client' });
            }
            
            // 검증 성공 - 사용자 정보 저장
            req.user = {
                id: decoded.sub,
                clientId: decoded.client_id,
                scopes: tokenScopes
            };
            
            next();
        }
    );
}

// 토큰 취소 목록 확인 (Redis 등 사용)
function isTokenRevoked(jti) {
    // 실제 구현에서는 Redis나 데이터베이스 조회
    // return redisClient.exists(`revoked:${jti}`);
    return false;
}

// 클라이언트 검증
function isValidClient(clientId) {
    // 등록된 클라이언트인지 확인
    const validClients = ['client-1', 'client-2'];
    return validClients.includes(clientId);
}

// 보호된 API 엔드포인트
app.get('/api/data', verifyJWT, (req, res) => {
    // 사용자별 데이터 조회
    const data = getUserData(req.user.id);
    res.json(data);
});

// 스코프별 권한 검증 미들웨어
function requireScope(scope) {
    return (req, res, next) => {
        if (!req.user || !req.user.scopes.includes(scope)) {
            return res.status(403).json({ error: 'Insufficient permissions' });
        }
        next();
    };
}

// 쓰기 권한이 필요한 엔드포인트
app.post('/api/data', verifyJWT, requireScope('write:data'), (req, res) => {
    // 데이터 생성
    const result = createData(req.user.id, req.body);
    res.json(result);
});

🔍 OAuth 2.0 vs OpenID Connect

많은 사람들이 OAuth 2.0과 OpenID Connect(OIDC)를 헷갈려 해. 🤷
간단히 말하면, OAuth 2.0은 인가(Authorization) 프레임워크이고, OpenID Connect는 인증(Authentication) 프로토콜이야.

OpenID Connect는 OAuth 2.0을 확장해서 만들어졌어. 🏗️
OAuth 2.0의 인가 흐름에 openid 스코프를 추가하고, ID 토큰이라는 새로운 토큰 타입을 도입했지.

// OpenID Connect 인가 요청
https://authorization-server.com/auth?
  response_type=code&
  client_id=YOUR_CLIENT_ID&
  redirect_uri=https://your-app.com/callback&
  scope=openid profile email&  // openid 스코프 필수
  state=random_string&
  nonce=random_nonce  // OIDC 추가 파라미터

// 토큰 응답 (OIDC)
{
  "access_token": "eyJhbGc...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "tGzv3JOk...",
  "id_token": "eyJhbGciOiJSUzI1NiIs..."  // ID 토큰 추가
}

// ID 토큰 디코딩 결과
{
  "iss": "https://oauth-provider.com",
  "sub": "user-12345",
  "aud": "your-client-id",
  "exp": 1234567890,
  "iat": 1234564290,
  "nonce": "random_nonce",
  "name": "홍길동",
  "email": "hong@example.com",
  "picture": "https://example.com/photo.jpg"
}

🧪 OAuth 2.0 보안 테스트 방법

구현이 끝났다고 안심하면 안 돼. 🔬
실제로 보안이 제대로 적용되었는지 테스트하는 것이 매우 중요해.

// 보안 테스트 스크립트 예시 (Python)
import requests
import time

# 1. 리다이렉트 URI 조작 테스트
def test_redirect_uri_manipulation():
    malicious_uris = [
        'https://attacker.com/steal',
        'https://legitimate-app.com/../attacker',
        'https://legitimate-app.com?redirect=https://attacker.com',
        'http://legitimate-app.com/callback'  # HTTP 시도
    ]
    
    for uri in malicious_uris:
        params = {
            'response_type': 'code',
            'client_id': 'test-client',
            'redirect_uri': uri,
            'scope': 'read_profile',
            'state': 'random_state'
        }
        
        response = requests.get(
            'https://auth-server.com/authorize',
            params=params,
            allow_redirects=False
        )
        
        # 리다이렉트가 허용되면 취약점
        if response.status_code == 302:
            print(f"⚠️  취약점 발견: {uri}")
        else:
            print(f"✅ 안전: {uri}")

# 2. State 파라미터 테스트
def test_state_parameter():
    # State 없이 요청
    params_no_state = {
        'response_type': 'code',
        'client_id': 'test-client',
        'redirect_uri': 'https://app.com/callback',
        'scope': 'read_profile'
    }
    
    response = requests.get(
        'https://auth-server.com/authorize',
        params=params_no_state
    )
    
    if 'error' not in response.url:
        print("⚠️  State 파라미터 검증 없음")
    else:
        print("✅ State 파라미터 검증 정상")

# 3. 토큰 만료 테스트
def test_token_expiration():
    # 토큰 발급
    token = get_access_token()
    
    # 즉시 사용 (정상)
    response1 = requests.get(
        'https://api.example.com/data',
        headers={'Authorization': f'Bearer {token}'}
    )
    print(f"즉시 사용: {response1.status_code}")
    
    # 만료 시간 대기
    time.sleep(3700)  # 1시간 후
    
    # 만료 후 사용 시도
    response2 = requests.get(
        'https://api.example.com/data',
        headers={'Authorization': f'Bearer {token}'}
    )
    
    if response2.status_code == 401:
        print("✅ 토큰 만료 처리 정상")
    else:
        print("⚠️  만료된 토큰이 여전히 유효함")

# 4. 스코프 권한 테스트
def test_scope_enforcement():
    # read 권한만 있는 토큰
    read_token = get_token_with_scope('read_profile')
    
    # write 작업 시도
    response = requests.post(
        'https://api.example.com/profile',
        headers={'Authorization': f'Bearer {read_token}'},
        json={'name': 'New Name'}
    )
    
    if response.status_code == 403:
        print("✅ 스코프 검증 정상")
    else:
        print("⚠️  스코프 검증 실패")

# 테스트 실행
if __name__ == '__main__':
    print("OAuth 2.0 보안 테스트 시작...\n")
    test_redirect_uri_manipulation()
    test_state_parameter()
    test_token_expiration()
    test_scope_enforcement()

📊 OAuth 2.0 보안 사고 사례 분석

실제로 발생한 보안 사고를 통해 배우는 게 가장 효과적이야. 📚
몇 가지 유명한 사례를 살펴보자.

🚀 OAuth 2.0의 미래: OAuth 2.1

OAuth 2.0이 완벽한 건 아니야. 그래서 OAuth 2.1이 개발 중이야! 🔮
2020년부터 작업이 시작되었고, 현재 드래프트 단계에 있어.

OAuth 2.1은 기존 OAuth 2.0의 보안 취약점을 해결하고 모범 사례를 표준화하는 게 목표야. 🎯
하위 호환성을 유지하면서도 더 안전한 구현을 강제하는 거지.

🎓 OAuth 2.0 학습 리소스

더 깊이 공부하고 싶다면 이 리소스들을 추천해! 📖