SELECT * FROM users WHERE username = 'admin' AND password = 'mypassword';

SELECT * FROM users WHERE username = 'admin' -- ' AND password = 'anything';

import re

def detect_sql_injection(user_input):
    """
    SQL Injection 공격 패턴을 탐지하는 함수
    
    Args:
        user_input (str): 사용자로부터 받은 입력값
        
    Returns:
        tuple: (is_malicious, detected_patterns)
    """
    
    # SQL Injection 공격에 자주 사용되는 패턴들
    sql_patterns = [
        r"(\b(SELECT|UNION|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|EXEC|EXECUTE)\b)",
        r"(--|\#|\/\*|\*\/)",  # SQL 주석
        r"(\bOR\b.*=.*)",  # OR 1=1 같은 패턴
        r"(\bAND\b.*=.*)",  # AND 1=1 같은 패턴
        r"('|\"|;|\\)",  # 특수문자
        r"(\bxp_cmdshell\b)",  # 시스템 명령 실행
        r"(\bSLEEP\b|\bBENCHMARK\b)",  # Time-based 공격
        r"(\bINFORMATION_SCHEMA\b)",  # 스키마 정보 조회
        r"(\bLOAD_FILE\b|\bINTO\s+OUTFILE\b)",  # 파일 조작
        r"(\bCHAR\b|\bCONCAT\b|\bSUBSTRING\b)",  # 문자열 함수 악용
    ]
    
    detected_patterns = []
    
    # 대소문자 구분 없이 검사
    input_upper = user_input.upper()
    
    for pattern in sql_patterns:
        if re.search(pattern, input_upper, re.IGNORECASE):
            detected_patterns.append(pattern)
    
    is_malicious = len(detected_patterns) > 0
    
    return is_malicious, detected_patterns


# 사용 예제
test_inputs = [
    "admin",  # 정상 입력
    "admin' OR '1'='1",  # SQL Injection 시도
    "admin'; DROP TABLE users; --",  # 위험한 공격
    "user123",  # 정상 입력
    "' UNION SELECT * FROM passwords --",  # UNION 공격
]

print("🔍 SQL Injection 탐지 테스트\n")
for test_input in test_inputs:
    is_malicious, patterns = detect_sql_injection(test_input)
    status = "🚨 위험" if is_malicious else "✅ 안전"
    print(f"{status} | 입력: {test_input}")
    if patterns:
        print(f"   탐지된 패턴: {len(patterns)}개\n")

/**
 * SQL Injection 패턴 탐지 (JavaScript)
 * @param {string} userInput - 사용자 입력값
 * @returns {Object} - {isMalicious, detectedPatterns}
 */
function detectSQLInjection(userInput) {
    const sqlPatterns = [
        /\b(SELECT|UNION|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|EXEC|EXECUTE)\b/gi,
        /(--|#|\/\*|\*\/)/g,
        /\bOR\b.*=/gi,
        /\bAND\b.*=/gi,
        /['";\\]/g,
        /\bxp_cmdshell\b/gi,
        /\b(SLEEP|BENCHMARK)\b/gi,
        /\bINFORMATION_SCHEMA\b/gi,
        /\b(LOAD_FILE|INTO\s+OUTFILE)\b/gi,
        /\b(CHAR|CONCAT|SUBSTRING)\b/gi,
    ];
    
    const detectedPatterns = [];
    
    sqlPatterns.forEach((pattern, index) => {
        if (pattern.test(userInput)) {
            detectedPatterns.push(index);
        }
    });
    
    return {
        isMalicious: detectedPatterns.length > 0,
        detectedPatterns: detectedPatterns,
        riskLevel: detectedPatterns.length > 2 ? 'HIGH' : 
                   detectedPatterns.length > 0 ? 'MEDIUM' : 'LOW'
    };
}

// 사용 예제
const testInput = "admin' OR '1'='1";
const result = detectSQLInjection(testInput);

if (result.isMalicious) {
    console.log('🚨 SQL Injection 공격 탐지!');
    console.log(`위험도: ${result.riskLevel}`);
    console.log(`탐지된 패턴 수: ${result.detectedPatterns.length}`);
}

import mysql.connector
from mysql.connector import Error

class SecureDatabase:
    def __init__(self, host, database, user, password):
        """안전한 데이터베이스 연결 클래스"""
        try:
            self.connection = mysql.connector.connect(
                host=host,
                database=database,
                user=user,
                password=password
            )
            if self.connection.is_connected():
                print("✅ 데이터베이스 연결 성공!")
        except Error as e:
            print(f"❌ 연결 실패: {e}")
            self.connection = None
    
    def safe_login(self, username, password):
        """
        Prepared Statement를 사용한 안전한 로그인
        
        Args:
            username (str): 사용자명
            password (str): 비밀번호
            
        Returns:
            dict: 사용자 정보 또는 None
        """
        if not self.connection:
            return None
        
        try:
            cursor = self.connection.cursor(dictionary=True)
            
            # ❌ 위험한 방법 (절대 사용하지 말 것!)
            # query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
            
            # ✅ 안전한 방법 (Prepared Statement)
            query = "SELECT * FROM users WHERE username = %s AND password = %s"
            
            # 파라미터를 별도로 전달
            cursor.execute(query, (username, password))
            
            result = cursor.fetchone()
            cursor.close()
            
            if result:
                print(f"✅ 로그인 성공: {result['username']}")
                return result
            else:
                print("❌ 로그인 실패: 잘못된 인증 정보")
                return None
                
        except Error as e:
            print(f"❌ 쿼리 실행 오류: {e}")
            return None
    
    def safe_search(self, search_term):
        """
        Prepared Statement를 사용한 안전한 검색
        
        Args:
            search_term (str): 검색어
            
        Returns:
            list: 검색 결과
        """
        if not self.connection:
            return []
        
        try:
            cursor = self.connection.cursor(dictionary=True)
            
            # LIKE 쿼리도 안전하게 처리
            query = "SELECT * FROM products WHERE name LIKE %s"
            
            # % 와일드카드는 파라미터 값에 포함
            search_pattern = f"%{search_term}%"
            cursor.execute(query, (search_pattern,))
            
            results = cursor.fetchall()
            cursor.close()
            
            print(f"✅ 검색 완료: {len(results)}개 결과")
            return results
            
        except Error as e:
            print(f"❌ 검색 오류: {e}")
            return []
    
    def safe_insert(self, username, email, password):
        """
        Prepared Statement를 사용한 안전한 데이터 삽입
        
        Args:
            username (str): 사용자명
            email (str): 이메일
            password (str): 비밀번호
            
        Returns:
            bool: 성공 여부
        """
        if not self.connection:
            return False
        
        try:
            cursor = self.connection.cursor()
            
            query = "INSERT INTO users (username, email, password) VALUES (%s, %s, %s)"
            cursor.execute(query, (username, email, password))
            
            self.connection.commit()
            cursor.close()
            
            print(f"✅ 사용자 '{username}' 등록 완료")
            return True
            
        except Error as e:
            print(f"❌ 등록 실패: {e}")
            self.connection.rollback()
            return False
    
    def close(self):
        """데이터베이스 연결 종료"""
        if self.connection and self.connection.is_connected():
            self.connection.close()
            print("✅ 데이터베이스 연결 종료")


# 사용 예제
if __name__ == "__main__":
    db = SecureDatabase(
        host="localhost",
        database="myapp",
        user="dbuser",
        password="dbpassword"
    )
    
    # 공격 시도를 막아내는 테스트
    malicious_input = "admin' OR '1'='1"
    db.safe_login(malicious_input, "anything")
    # 결과: Prepared Statement가 이것을 단순 문자열로 처리하므로 공격 실패!
    
    # 정상 로그인
    db.safe_login("john_doe", "correct_password")
    
    # 안전한 검색
    db.safe_search("laptop")
    
    db.close()

<?php
class SecureDatabasePHP {
    private $pdo;
    
    public function __construct($host, $dbname, $username, $password) {
        try {
            $dsn = "mysql:host=$host;dbname=$dbname;charset=utf8mb4";
            $options = [
                PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
                PDO::ATTR_EMULATE_PREPARES => false, // 진짜 Prepared Statement 사용
            ];
            
            $this->pdo = new PDO($dsn, $username, $password, $options);
            echo "✅ 데이터베이스 연결 성공!\n";
            
        } catch (PDOException $e) {
            die("❌ 연결 실패: " . $e->getMessage());
        }
    }
    
    /**
     * 안전한 로그인 함수
     */
    public function safeLogin($username, $password) {
        try {
            // Prepared Statement 사용
            $stmt = $this->pdo->prepare(
                "SELECT * FROM users WHERE username = :username AND password = :password"
            );
            
            // 파라미터 바인딩 (Named Parameters)
            $stmt->execute([
                ':username' => $username,
                ':password' => $password
            ]);
            
            $user = $stmt->fetch();
            
            if ($user) {
                echo "✅ 로그인 성공: {$user['username']}\n";
                return $user;
            } else {
                echo "❌ 로그인 실패\n";
                return null;
            }
            
        } catch (PDOException $e) {
            echo "❌ 쿼리 오류: " . $e->getMessage() . "\n";
            return null;
        }
    }
    
    /**
     * 안전한 검색 함수
     */
    public function safeSearch($searchTerm) {
        try {
            $stmt = $this->pdo->prepare(
                "SELECT * FROM products WHERE name LIKE :search"
            );
            
            // LIKE 패턴도 안전하게 처리
            $stmt->execute([
                ':search' => "%$searchTerm%"
            ]);
            
            $results = $stmt->fetchAll();
            echo "✅ 검색 완료: " . count($results) . "개 결과\n";
            
            return $results;
            
        } catch (PDOException $e) {
            echo "❌ 검색 오류: " . $e->getMessage() . "\n";
            return [];
        }
    }
    
    /**
     * 안전한 데이터 삽입
     */
    public function safeInsert($username, $email, $password) {
        try {
            $stmt = $this->pdo->prepare(
                "INSERT INTO users (username, email, password) VALUES (:username, :email, :password)"
            );
            
            $result = $stmt->execute([
                ':username' => $username,
                ':email' => $email,
                ':password' => password_hash($password, PASSWORD_DEFAULT) // 비밀번호 해싱!
            ]);
            
            if ($result) {
                echo "✅ 사용자 '$username' 등록 완료\n";
                return true;
            }
            
            return false;
            
        } catch (PDOException $e) {
            echo "❌ 등록 실패: " . $e->getMessage() . "\n";
            return false;
        }
    }
}

// 사용 예제
$db = new SecureDatabasePHP('localhost', 'myapp', 'dbuser', 'dbpassword');

// SQL Injection 공격 시도 (실패함!)
$db->safeLogin("admin' OR '1'='1", "anything");

// 정상 사용
$db->safeLogin("john_doe", "correct_password");
$db->safeSearch("laptop");
$db->safeInsert("new_user", "user@example.com", "securepass123");
?>

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

/**
 * SQL Injection 방어 WAF 미들웨어
 */
class SQLInjectionWAF {
    constructor(options = {}) {
        this.options = {
            logAttacks: options.logAttacks !== false,
            blockMode: options.blockMode !== false,
            maxRiskScore: options.maxRiskScore || 5,
            ...options
        };
        
        // 위험 패턴과 점수
        this.riskPatterns = [
            { pattern: /(\bSELECT\b.*\bFROM\b)/gi, score: 3, name: 'SELECT_FROM' },
            { pattern: /(\bUNION\b.*\bSELECT\b)/gi, score: 5, name: 'UNION_SELECT' },
            { pattern: /(\bINSERT\b.*\bINTO\b)/gi, score: 4, name: 'INSERT_INTO' },
            { pattern: /(\bDELETE\b.*\bFROM\b)/gi, score: 5, name: 'DELETE_FROM' },
            { pattern: /(\bDROP\b.*\bTABLE\b)/gi, score: 10, name: 'DROP_TABLE' },
            { pattern: /(\bUPDATE\b.*\bSET\b)/gi, score: 4, name: 'UPDATE_SET' },
            { pattern: /(--|#|\/\*|\*\/)/g, score: 2, name: 'SQL_COMMENT' },
            { pattern: /(\bOR\b\s*['"]?\d+['"]?\s*=\s*['"]?\d+)/gi, score: 5, name: 'OR_EQUALS' },
            { pattern: /(\bAND\b\s*['"]?\d+['"]?\s*=\s*['"]?\d+)/gi, score: 5, name: 'AND_EQUALS' },
            { pattern: /('|\"|;|\\)/g, score: 1, name: 'SPECIAL_CHAR' },
            { pattern: /(\bxp_cmdshell\b)/gi, score: 10, name: 'XP_CMDSHELL' },
            { pattern: /(\bEXEC\b|\bEXECUTE\b)/gi, score: 4, name: 'EXEC' },
            { pattern: /(\bSLEEP\b|\bBENCHMARK\b)/gi, score: 3, name: 'TIME_BASED' },
            { pattern: /(\bINFORMATION_SCHEMA\b)/gi, score: 4, name: 'INFO_SCHEMA' },
        ];
        
        this.attackLog = [];
    }
    
    /**
     * 입력값 검사
     */
    analyzeInput(input) {
        let totalScore = 0;
        const detectedPatterns = [];
        
        if (typeof input !== 'string') {
            input = String(input);
        }
        
        this.riskPatterns.forEach(({ pattern, score, name }) => {
            const matches = input.match(pattern);
            if (matches) {
                totalScore += score * matches.length;
                detectedPatterns.push({
                    name,
                    score,
                    matches: matches.length
                });
            }
        });
        
        return {
            isMalicious: totalScore >= this.options.maxRiskScore,
            riskScore: totalScore,
            detectedPatterns
        };
    }
    
    /**
     * 요청 전체 검사
     */
    scanRequest(req) {
        const results = {
            isMalicious: false,
            totalRiskScore: 0,
            findings: []
        };
        
        // Query Parameters 검사
        if (req.query && Object.keys(req.query).length > 0) {
            Object.entries(req.query).forEach(([key, value]) => {
                const analysis = this.analyzeInput(value);
                if (analysis.isMalicious) {
                    results.isMalicious = true;
                    results.findings.push({
                        location: 'query',
                        parameter: key,
                        value,
                        ...analysis
                    });
                }
                results.totalRiskScore += analysis.riskScore;
            });
        }
        
        // Body Parameters 검사
        if (req.body && Object.keys(req.body).length > 0) {
            Object.entries(req.body).forEach(([key, value]) => {
                const analysis = this.analyzeInput(value);
                if (analysis.isMalicious) {
                    results.isMalicious = true;
                    results.findings.push({
                        location: 'body',
                        parameter: key,
                        value,
                        ...analysis
                    });
                }
                results.totalRiskScore += analysis.riskScore;
            });
        }
        
        // URL Path 검사
        const pathAnalysis = this.analyzeInput(req.path);
        if (pathAnalysis.isMalicious) {
            results.isMalicious = true;
            results.findings.push({
                location: 'path',
                value: req.path,
                ...pathAnalysis
            });
        }
        results.totalRiskScore += pathAnalysis.riskScore;
        
        return results;
    }
    
    /**
     * 공격 로깅
     */
    logAttack(req, scanResults) {
        const logEntry = {
            timestamp: new Date().toISOString(),
            ip: req.ip || req.connection.remoteAddress,
            method: req.method,
            url: req.originalUrl,
            userAgent: req.get('user-agent'),
            ...scanResults
        };
        
        this.attackLog.push(logEntry);
        
        console.log('🚨 SQL Injection 공격 탐지!');
        console.log(`   IP: ${logEntry.ip}`);
        console.log(`   URL: ${logEntry.method} ${logEntry.url}`);
        console.log(`   위험 점수: ${logEntry.totalRiskScore}`);
        console.log(`   탐지 항목: ${logEntry.findings.length}개\n`);
    }
    
    /**
     * Express 미들웨어
     */
    middleware() {
        return (req, res, next) => {
            const scanResults = this.scanRequest(req);
            
            if (scanResults.isMalicious) {
                if (this.options.logAttacks) {
                    this.logAttack(req, scanResults);
                }
                
                if (this.options.blockMode) {
                    return res.status(403).json({
                        error: 'Forbidden',
                        message: 'SQL Injection 공격이 탐지되었습니다.',
                        requestId: Date.now()
                    });
                }
            }
            
            // 요청 객체에 스캔 결과 추가
            req.sqlInjectionScan = scanResults;
            next();
        };
    }
    
    /**
     * 공격 로그 조회
     */
    getAttackLog(limit = 10) {
        return this.attackLog.slice(-limit);
    }
}

// WAF 인스턴스 생성
const waf = new SQLInjectionWAF({
    logAttacks: true,
    blockMode: true,
    maxRiskScore: 5
});

// Express 설정
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// WAF 미들웨어 적용
app.use(waf.middleware());

// 테스트 라우트
app.get('/search', (req, res) => {
    const searchTerm = req.query.q;
    res.json({
        message: '검색 완료',
        query: searchTerm,
        securityScan: req.sqlInjectionScan
    });
});

app.post('/login', (req, res) => {
    const { username, password } = req.body;
    res.json({
        message: '로그인 처리',
        username,
        securityScan: req.sqlInjectionScan
    });
});

// 공격 로그 조회 엔드포인트
app.get('/admin/attack-log', (req, res) => {
    res.json({
        attacks: waf.getAttackLog(20)
    });
});

// 서버 시작
const PORT = 3000;
app.listen(PORT, () => {
    console.log(`✅ WAF 서버 실행 중: http://localhost:${PORT}`);
    console.log('🛡️ SQL Injection 방어 활성화\n');
});

// 테스트 예제
console.log('📝 테스트 방법:');
console.log('정상 요청: curl "http://localhost:3000/search?q=laptop"');
console.log('공격 시도: curl "http://localhost:3000/search?q=admin%27%20OR%20%271%27=%271"');
console.log('로그 확인: curl "http://localhost:3000/admin/attack-log"\n');