Go 언어로 웹 애플리케이션 방화벽(WAF) 구현하기

네트워크 보안의 신세계로 떠나는 Go 언어 여행 🚀

안녕! 오늘은 Go 언어(Golang)를 사용해서 웹 애플리케이션 방화벽(WAF)을 직접 구현하는 방법에 대해 함께 알아볼 거야. 🔥 보안에 관심 있거나 Go 언어를 배우고 있다면 정말 흥미로운 주제가 될 거라 확신해! 이 글을 통해 네트워크 보안의 핵심 개념부터 실제 코드 구현까지 친구처럼 쉽게 설명해 줄게.

웹 애플리케이션 방화벽(WAF)은 웹 서비스를 보호하는 중요한 보안 장치야. 요즘같이 사이버 공격이 늘어나는 시대에 WAF 구현 기술을 익히는 건 개발자로서 정말 가치 있는 스킬이지. 특히 Go 언어는 네트워크 프로그래밍과 동시성 처리에 강점이 있어서 WAF 구현에 아주 적합한 언어야!

이 글은 재능넷의 '지식인의 숲' 메뉴를 통해 여러분에게 공유되고 있어. 재능넷에서는 이런 프로그래밍 지식뿐만 아니라 다양한 분야의 재능을 거래할 수 있으니, 이 글을 읽고 Go 언어에 관심이 생겼다면 재능넷에서 관련 멘토를 찾아보는 것도 좋은 방법이 될 거야!

웹 애플리케이션 방화벽(WAF)은 HTTP 트래픽을 모니터링하고 필터링하여 웹 애플리케이션을 다양한 공격으로부터 보호하는 보안 솔루션이야. 일반 방화벽이 네트워크 계층에서 작동한다면, WAF는 애플리케이션 계층(OSI 7계층)에서 작동해서 더 세밀한 보안을 제공해.

WAF는 기본적으로 HTTP 요청과 응답을 검사하고, 악의적인 패턴이 발견되면 해당 트래픽을 차단하는 방식으로 작동해. 이런 보안 메커니즘은 현대 웹 서비스에서 필수적인 요소가 되었지.

WAF의 작동 방식 💡

WAF는 크게 두 가지 방식으로 작동해:

1. 블랙리스트 방식: 알려진 악의적인 패턴이나 시그니처를 데이터베이스화하여 이와 일치하는 트래픽을 차단하는 방식
2. 화이트리스트 방식: 허용된 패턴만 통과시키고 나머지는 모두 차단하는 방식

대부분의 WAF는 이 두 가지 방식을 혼합해서 사용하고, 최근에는 머신러닝을 활용한 지능형 WAF도 등장하고 있어. 우리가 Go로 구현할 WAF는 기본적인 블랙리스트 방식을 사용할 거야.

Go 언어(Golang)는 2009년 Google에서 개발한 프로그래밍 언어로, 네트워크 프로그래밍과 동시성 처리에 특화되어 있어. WAF 같은 네트워크 보안 솔루션을 구현하기에 정말 좋은 언어인데, 그 이유를 자세히 알아볼게!

Go 언어는 단순한 문법과 빠른 학습 곡선을 가지고 있어서, 이 글을 읽는 너도 금방 WAF 구현에 필요한 Go 코드를 이해하고 작성할 수 있을 거야. 재능넷에서도 Go 언어 관련 멘토링을 찾아볼 수 있으니, 더 깊이 배우고 싶다면 참고해봐!

Go로 WAF를 구현하기 전에, 몇 가지 준비가 필요해. 개발 환경을 세팅하고 필요한 기본 지식을 확인해보자!

3.1 개발 환경 설정 ⚙️

go version

3.2 필요한 패키지와 라이브러리 📦

Go의 강점 중 하나는 풍부한 표준 라이브러리야. WAF 구현에 필요한 대부분의 기능은 표준 라이브러리에서 제공하지만, 몇 가지 외부 패키지도 사용할 거야:

go get github.com/패키지명

3.3 WAF 설계 계획 📝

WAF를 구현하기 전에 전체적인 설계를 계획해보자. 우리가 만들 WAF는 다음과 같은 구조를 가질 거야:

이제 개발 환경과 설계 계획이 준비되었으니, 본격적으로 Go 언어로 WAF를 구현해볼 차례야! 각 컴포넌트를 하나씩 구현하면서 WAF의 작동 원리를 자세히 알아보자.

WAF의 첫 번째 핵심 컴포넌트는 HTTP 프록시 서버야. 이 프록시 서버는 클라이언트의 요청을 받아 필터링한 후, 정상적인 요청만 실제 웹 서버로 전달하는 역할을 해. Go 언어의 net/http 패키지를 사용하면 이런 프록시 서버를 쉽게 구현할 수 있어!

4.1 기본 HTTP 프록시 서버 구현 🔄

먼저 가장 기본적인 HTTP 프록시 서버를 구현해보자:

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
)

func main() {
    // 대상 서버 URL 설정
    targetURL, err := url.Parse("http://localhost:8080")
    if err != nil {
        log.Fatal("URL 파싱 오류:", err)
    }
    
    // 리버스 프록시 생성
    proxy := httputil.NewSingleHostReverseProxy(targetURL)
    
    // 기본 디렉터 함수 설정
    originalDirector := proxy.Director
    proxy.Director = func(req *http.Request) {
        originalDirector(req)
        log.Printf("프록시: %s %s", req.Method, req.URL.Path)
    }
    
    // 프록시 서버 시작
    log.Println("WAF 프록시 서버가 포트 3000에서 시작됩니다...")
    log.Fatal(http.ListenAndServe(":3000", proxy))
}

위 코드는 가장 기본적인 HTTP 프록시 서버를 구현한 거야. http://localhost:8080으로 들어오는 모든 요청을 프록시하고 있어. 하지만 아직 WAF 기능은 없지. 이제 이 코드를 확장해서 WAF 기능을 추가해보자!

4.2 WAF 기능이 추가된 프록시 서버 🛡️

이제 HTTP 요청을 가로채서 검사하는 WAF 기능을 추가해볼게:

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "regexp"
    "strings"
)

// 간단한 WAF 규칙 정의
var (
    sqlInjectionPattern = regexp.MustCompile(`(?i)(SELECT|INSERT|UPDATE|DELETE|DROP|UNION|OR|AND)\s+`)
    xssPattern          = regexp.MustCompile(`(?i)(

WAF의 핵심은 규칙 엔진이야. 이 엔진은 다양한 공격 패턴을 정의하고, 들어오는 요청이 이러한 패턴과 일치하는지 검사하는 역할을 해. 이번에는 더 체계적이고 확장 가능한 규칙 엔진을 구현해볼게!

5.1 규칙 구조 설계 🏗️

먼저 WAF 규칙을 표현할 수 있는 구조체를 정의해보자:

package main

import (
    "regexp"
)

// 규칙 유형 정의
const (
    SQLInjection = iota
    XSSAttack
    PathTraversal
    CommandInjection
    FileInclusion
)

// 규칙 구조체
type Rule struct {
    ID          int
    Name        string
    Description string
    Type        int
    Pattern     *regexp.Regexp
    Severity    int // 1-낮음, 2-중간, 3-높음
}

// 규칙 엔진 구조체
type RuleEngine struct {
    Rules []Rule
}

// 새 규칙 엔진 생성
func NewRuleEngine() *RuleEngine {
    engine := &RuleEngine{
        Rules: make([]Rule, 0),
    }
    
    // 기본 규칙 추가
    engine.AddDefaultRules()
    
    return engine
}

// 기본 규칙 추가
func (re *RuleEngine) AddDefaultRules() {
    // SQL 인젝션 규칙
    re.Rules = append(re.Rules, Rule{
        ID:          1001,
        Name:        "SQL Injection Detection",
        Description: "SQL 명령어를 포함한 요청을 감지합니다",
        Type:        SQLInjection,
        Pattern:     regexp.MustCompile(`(?i)(SELECT|INSERT|UPDATE|DELETE|DROP|UNION|OR|AND)\s+`),
        Severity:    3,
    })
    
    // XSS 공격 규칙
    re.Rules = append(re.Rules, Rule{
        ID:          2001,
        Name:        "XSS Attack Detection",
        Description: "자바스크립트 코드를 포함한 요청을 감지합니다",
        Type:        XSSAttack,
        Pattern:     regexp.MustCompile(`(?i)(

이제 이 규칙 엔진을 WAF 핸들러와 통합해보자:

// WAF 핸들러 업데이트
type WAFHandler struct {
    proxy      *httputil.ReverseProxy
    ruleEngine *RuleEngine
}

func (waf *WAFHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 요청 검사
    blocked, violations := waf.ruleEngine.CheckRequest(r)
    
    if blocked {
        // 위반 사항 로깅
        for _, violation := range violations {
            log.Printf("⚠️ 규칙 위반 감지: [%d] %s - %s에서 '%s' 발견",
                violation.Rule.ID,
                violation.Rule.Name,
                violation.Field,
                violation.Content)
        }
        
        // 응답 차단
        http.Error(w, "보안 정책에 의해 차단된 요청입니다.", http.StatusForbidden)
        return
    }
    
    // 정상 요청은 프록시로 전달
    log.Printf("✅ 정상 요청 통과: %s %s", r.Method, r.URL.Path)
    waf.proxy.ServeHTTP(w, r)
}

func main() {
    // 대상 서버 URL 설정
    targetURL, err := url.Parse("http://localhost:8080")
    if err != nil {
        log.Fatal("URL 파싱 오류:", err)
    }
    
    // 리버스 프록시 생성
    proxy := httputil.NewSingleHostReverseProxy(targetURL)
    
    // 규칙 엔진 생성
    ruleEngine := NewRuleEngine()
    
    // WAF 핸들러 생성
    wafHandler := &WAFHandler{
        proxy:      proxy,
        ruleEngine: ruleEngine,
    }
    
    // 프록시 서버 시작
    log.Println("🛡️ WAF 프록시 서버가 포트 3000에서 시작됩니다...")
    log.Fatal(http.ListenAndServe(":3000", wafHandler))
}

이제 우리의 WAF는 더 체계적이고 확장 가능한 규칙 엔진을 갖추게 되었어! 다음으로는 규칙을 외부 파일에서 로드하고 관리하는 기능을 추가해보자.

실제 WAF 시스템에서는 규칙을 코드에 하드코딩하지 않고, 외부 파일에서 로드하는 것이 일반적이야. 이렇게 하면 WAF를 재컴파일하지 않고도 규칙을 업데이트할 수 있지. 이제 JSON 파일에서 규칙을 로드하는 기능을 구현해보자!

6.1 JSON 규칙 파일 형식 정의 📄

먼저 규칙을 저장할 JSON 파일의 형식을 정의해보자:

// rules.json
{
  "rules": [
    {
      "id": 1001,
      "name": "SQL Injection Detection",
      "description": "SQL 명령어를 포함한 요청을 감지합니다",
      "type": "sql_injection",
      "pattern": "(?i)(SELECT|INSERT|UPDATE|DELETE|DROP|UNION|OR|AND)\\s+",
      "severity": 3
    },
    {
      "id": 2001,
      "name": "XSS Attack Detection",
      "description": "자바스크립트 코드를 포함한 요청을 감지합니다",
      "type": "xss_attack",
      "pattern": "(?i)(

이제 main 함수에서 규칙 파일을 로드하도록 수정해보자:

func main() {
    // 대상 서버 URL 설정
    targetURL, err := url.Parse("http://localhost:8080")
    if err != nil {
        log.Fatal("URL 파싱 오류:", err)
    }
    
    // 리버스 프록시 생성
    proxy := httputil.NewSingleHostReverseProxy(targetURL)
    
    // 규칙 엔진 생성
    ruleEngine := NewRuleEngine()
    
    // 규칙 파일 로드 (실패해도 기본 규칙은 유지)
    if err := ruleEngine.LoadRulesFromFile("rules.json"); err != nil {
        log.Printf("⚠️ 규칙 파일 로드 실패: %v - 기본 규칙을 사용합니다", err)
        ruleEngine.AddDefaultRules()
    }
    
    // WAF 핸들러 생성
    wafHandler := &WAFHandler{
        proxy:      proxy,
        ruleEngine: ruleEngine,
    }
    
    // 프록시 서버 시작
    log.Println("🛡️ WAF 프록시 서버가 포트 3000에서 시작됩니다...")
    log.Fatal(http.ListenAndServe(":3000", wafHandler))
}

// 규칙 주기적 리로드 함수
func (re *RuleEngine) StartPeriodicReload(filename string, interval time.Duration) {
    ticker := time.NewTicker(interval)
    go func() {
        for range ticker.C {
            log.Println("🔄 규칙 파일 리로드 시도 중...")
            
            // 임시 규칙 엔진에 로드 시도
            tempEngine := &RuleEngine{Rules: make([]Rule, 0)}
            if err := tempEngine.LoadRulesFromFile(filename); err != nil {
                log.Printf("⚠️ 규칙 파일 리로드 실패: %v", err)
                continue
            }
            
            // 성공 시 규칙 교체
            re.mu.Lock()
            re.Rules = tempEngine.Rules
            re.mu.Unlock()
            
            log.Printf("✅ 규칙 파일 리로드 성공: %d개 규칙 로드됨", len(tempEngine.Rules))
        }
    }()
}

// main 함수에 추가
ruleEngine.StartPeriodicReload("rules.json", 5 * time.Minute)

이제 우리의 WAF는 외부 JSON 파일에서 규칙을 로드하고 주기적으로 업데이트할 수 있게 되었어! 이렇게 하면 WAF를 재컴파일하거나 재시작하지 않고도 보안 규칙을 업데이트할 수 있지.

WAF의 중요한 기능 중 하나는 로깅과 모니터링이야. 어떤 요청이 차단되었는지, 어떤 규칙에 위반되었는지 등을 기록하고 분석할 수 있어야 해. 이번에는 구조화된 로깅 시스템을 구현해보자!

7.1 로그 구조체 정의 📝

먼저 로그 항목을 표현할 구조체를 정의해보자:

package main

import (
    "encoding/json"
    "os"
    "sync"
    "time"
)

// 로그 레벨 정의
const (
    LogLevelInfo = iota
    LogLevelWarning
    LogLevelError
)

// 로그 항목 구조체
type LogEntry struct {
    Timestamp   time.Time   `json:"timestamp"`
    Level       int         `json:"level"`
    ClientIP    string      `json:"client_ip"`
    Method      string      `json:"method"`
    URL         string      `json:"url"`
    UserAgent   string      `json:"user_agent"`
    Blocked     bool        `json:"blocked"`
    Violations  []Violation `json:"violations,omitempty"`
    ElapsedTime int64       `json:"elapsed_time_ms"`
}

// 규칙 위반 정보
type Violation struct {
    RuleID      int    `json:"rule_id"`
    RuleName    string `json:"rule_name"`
    Field       string `json:"field"`
    Content     string `json:"content"`
    Severity    int    `json:"severity"`
}

// 로거 구조체
type Logger struct {
    logFile    *os.File
    mu         sync.Mutex
    jsonLogger bool
}

// 새 로거 생성
func NewLogger(filename string, jsonFormat bool) (*Logger, error) {
    file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        return nil, err
    }
    
    return &Logger{
        logFile:    file,
        jsonLogger: jsonFormat,
    }, nil
}

// 로그 항목 기록
func (l *Logger) LogRequest(entry LogEntry) error {
    l.mu.Lock()
    defer l.mu.Unlock()
    
    if l.jsonLogger {
        // JSON 형식으로 로깅
        data, err := json.Marshal(entry)
        if err != nil {
            return err
        }
        
        if _, err := l.logFile.Write(append(data, '\n')); err != nil {
            return err
        }
    } else {
        // 텍스트 형식으로 로깅
        levelStr := "INFO"
        if entry.Level == LogLevelWarning {
            levelStr = "WARNING"
        } else if entry.Level == LogLevelError {
            levelStr = "ERROR"
        }
        
        statusStr := "허용"
        if entry.Blocked {
            statusStr = "차단"
        }
        
        logLine := fmt.Sprintf("[%s] %s - %s %s %s - %s - %dms\n",
            entry.Timestamp.Format(time.RFC3339),
            levelStr,
            entry.Method,
            entry.URL,
            statusStr,
            entry.ClientIP,
            entry.ElapsedTime)
            
        if _, err := l.logFile.WriteString(logLine); err != nil {
            return err
        }
        
        // 위반 사항 로깅
        for _, v := range entry.Violations {
            violationLine := fmt.Sprintf("  - 규칙 위반: [%d] %s (심각도: %d) - %s에서 '%s' 발견\n",
                v.RuleID,
                v.RuleName,
                v.Severity,
                v.Field,
                v.Content)
                
            if _, err := l.logFile.WriteString(violationLine); err != nil {
                return err
            }
        }
    }
    
    return nil
}

// 로거 종료
func (l *Logger) Close() error {
    l.mu.Lock()
    defer l.mu.Unlock()
    return l.logFile.Close()
}

7.2 WAF 핸들러에 로깅 통합 🔄

이제 WAF 핸들러에 로깅 시스템을 통합해보자:

// WAF 핸들러 업데이트
type WAFHandler struct {
    proxy      *httputil.ReverseProxy
    ruleEngine *RuleEngine
    logger     *Logger
}

func (waf *WAFHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    startTime := time.Now()
    
    // 요청 검사
    blocked, violations := waf.ruleEngine.CheckRequest(r)
    
    // 로그 항목 준비
    logViolations := make([]Violation, 0, len(violations))
    for _, v := range violations {
        logViolations = append(logViolations, Violation{
            RuleID:   v.Rule.ID,
            RuleName: v.Rule.Name,
            Field:    v.Field,
            Content:  v.Content,
            Severity: v.Rule.Severity,
        })
    }
    
    logLevel := LogLevelInfo
    if blocked {
        logLevel = LogLevelWarning
    }
    
    clientIP := r.RemoteAddr
    if forwardedFor := r.Header.Get("X-Forwarded-For"); forwardedFor != "" {
        clientIP = forwardedFor
    }
    
    logEntry := LogEntry{
        Timestamp:   time.Now(),
        Level:       logLevel,
        ClientIP:    clientIP,
        Method:      r.Method,
        URL:         r.URL.String(),
        UserAgent:   r.UserAgent(),
        Blocked:     blocked,
        Violations:  logViolations,
        ElapsedTime: time.Since(startTime).Milliseconds(),
    }
    
    // 로그 기록
    if err := waf.logger.LogRequest(logEntry); err != nil {
        log.Printf("로깅 오류: %v", err)
    }
    
    if blocked {
        // 위반 사항 콘솔 로깅
        for _, violation := range violations {
            log.Printf("⚠️ 규칙 위반 감지: [%d] %s - %s에서 '%s' 발견",
                violation.Rule.ID,
                violation.Rule.Name,
                violation.Field,
                violation.Content)
        }
        
        // 응답 차단
        http.Error(w, "보안 정책에 의해 차단된 요청입니다.", http.StatusForbidden)
        return
    }
    
    // 정상 요청은 프록시로 전달
    log.Printf("✅ 정상 요청 통과: %s %s", r.Method, r.URL.Path)
    waf.proxy.ServeHTTP(w, r)
}

func main() {
    // 대상 서버 URL 설정
    targetURL, err := url.Parse("http://localhost:8080")
    if err != nil {
        log.Fatal("URL 파싱 오류:", err)
    }
    
    // 리버스 프록시 생성
    proxy := httputil.NewSingleHostReverseProxy(targetURL)
    
    // 규칙 엔진 생성
    ruleEngine := NewRuleEngine()
    
    // 규칙 파일 로드
    if err := ruleEngine.LoadRulesFromFile("rules.json"); err != nil {
        log.Printf("⚠️ 규칙 파일 로드 실패: %v - 기본 규칙을 사용합니다", err)
        ruleEngine.AddDefaultRules()
    }
    
    // 로거 생성
    logger, err := NewLogger("waf.log", true)
    if err != nil {
        log.Fatal("로거 생성 실패:", err)
    }
    defer logger.Close()
    
    // WAF 핸들러 생성
    wafHandler := &WAFHandler{
        proxy:      proxy,
        ruleEngine: ruleEngine,
        logger:     logger,
    }
    
    // 규칙 주기적 리로드 시작
    ruleEngine.StartPeriodicReload("rules.json", 5 * time.Minute)
    
    // 프록시 서버 시작
    log.Println("🛡️ WAF 프록시 서버가 포트 3000에서 시작됩니다...")
    log.Fatal(http.ListenAndServe(":3000", wafHandler))
}

7.3 로그 분석 도구 구현 📈

로그를 수집하는 것도 중요하지만, 이를 분석하는 도구도 필요해. 간단한 로그 분석기를 구현해보자:

package main

import (
    "bufio"
    "encoding/json"
    "fmt"
    "os"
    "sort"
    "time"
)

// 로그 분석 결과
type LogAnalysis struct {
    TotalRequests      int
    BlockedRequests    int
    AllowedRequests    int
    UniqueIPs          int
    TopRules           []RuleCount
    TopIPs             []IPCount
    AverageResponseTime float64
    TimeDistribution   map[string]int
}

// 규칙 카운트
type RuleCount struct {
    RuleID   int
    RuleName string
    Count    int
}

// IP 카운트
type IPCount struct {
    IP    string
    Count int
}

// 로그 파일 분석
func AnalyzeLogFile(filename string) (*LogAnalysis, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    
    analysis := &LogAnalysis{
        TimeDistribution: make(map[string]int),
    }
    
    ipCounts := make(map[string]int)
    ruleCounts := make(map[int]RuleCount)
    totalTime := int64(0)
    
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        line := scanner.Text()
        
        var entry LogEntry
        if err := json.Unmarshal([]byte(line), &entry); err != nil {
            continue // 잘못된 JSON 라인은 건너뛰기
        }
        
        // 총 요청 수 증가
        analysis.TotalRequests++
        
        // 차단/허용 요청 카운트
        if entry.Blocked {
            analysis.BlockedRequests++
        } else {
            analysis.AllowedRequests++
        }
        
        // IP 카운트
        ipCounts[entry.ClientIP]++
        
        // 규칙 카운트
        for _, v := range entry.Violations {
            rule, exists := ruleCounts[v.RuleID]
            if !exists {
                rule = RuleCount{
                    RuleID:   v.RuleID,
                    RuleName: v.RuleName,
                    Count:    0,
                }
            }
            rule.Count++
            ruleCounts[v.RuleID] = rule
        }
        
        // 시간 분포
        hour := entry.Timestamp.Format("15")
        analysis.TimeDistribution[hour]++
        
        // 총 응답 시간
        totalTime += entry.ElapsedTime
    }
    
    if err := scanner.Err(); err != nil {
        return nil, err
    }
    
    // 고유 IP 수
    analysis.UniqueIPs = len(ipCounts)
    
    // 평균 응답 시간
    if analysis.TotalRequests > 0 {
        analysis.AverageResponseTime = float64(totalTime) / float64(analysis.TotalRequests)
    }
    
    // 상위 규칙 정렬
    topRules := make([]RuleCount, 0, len(ruleCounts))
    for _, rule := range ruleCounts {
        topRules = append(topRules, rule)
    }
    sort.Slice(topRules, func(i, j int) bool {
        return topRules[i].Count > topRules[j].Count
    })
    if len(topRules) > 10 {
        topRules = topRules[:10]
    }
    analysis.TopRules = topRules
    
    // 상위 IP 정렬
    topIPs := make([]IPCount, 0, len(ipCounts))
    for ip, count := range ipCounts {
        topIPs = append(topIPs, IPCount{IP: ip, Count: count})
    }
    sort.Slice(topIPs, func(i, j int) bool {
        return topIPs[i].Count > topIPs[j].Count
    })
    if len(topIPs) > 10 {
        topIPs = topIPs[:10]
    }
    analysis.TopIPs = topIPs
    
    return analysis, nil
}

// 분석 결과 출력
func PrintAnalysis(analysis *LogAnalysis) {
    fmt.Println("===== WAF 로그 분석 결과 =====")
    fmt.Printf("총 요청 수: %d\n", analysis.TotalRequests)
    fmt.Printf("차단된 요청: %d (%.2f%%)\n", analysis.BlockedRequests, float64(analysis.BlockedRequests)/float64(analysis.TotalRequests)*100)
    fmt.Printf("허용된 요청: %d (%.2f%%)\n", analysis.AllowedRequests, float64(analysis.AllowedRequests)/float64(analysis.TotalRequests)*100)
    fmt.Printf("고유 IP 수: %d\n", analysis.UniqueIPs)
    fmt.Printf("평균 응답 시간: %.2fms\n", analysis.AverageResponseTime)
    
    fmt.Println("\n상위 위반 규칙:")
    for i, rule := range analysis.TopRules {
        fmt.Printf("%d. [%d] %s - %d회\n", i+1, rule.RuleID, rule.RuleName, rule.Count)
    }
    
    fmt.Println("\n상위 IP 주소:")
    for i, ip := range analysis.TopIPs {
        fmt.Printf("%d. %s - %d회\n", i+1, ip.IP, ip.Count)
    }
    
    fmt.Println("\n시간대별 요청 분포:")
    for h := 0; h < 24; h++ {
        hour := fmt.Sprintf("%02d", h)
        count := analysis.TimeDistribution[hour]
        fmt.Printf("%s시: %d\n", hour, count)
    }
}

func main() {
    if len(os.Args) < 2 {
        fmt.Println("사용법: loganalyzer <로그파일>")
        os.Exit(1)
    }
    
    analysis, err := AnalyzeLogFile(os.Args[1])
    if err != nil {
        fmt.Printf("로그 분석 오류: %v\n", err)
        os.Exit(1)
    }
    
    PrintAnalysis(analysis)
}

로깅과 모니터링 시스템을 통해 WAF의 작동 상태를 실시간으로 확인하고, 과거 데이터를 분석하여 보안 정책을 개선할 수 있어! 이는 WAF의 효과를 극대화하는 데 매우 중요한 요소야.

WAF는 모든 HTTP 트래픽을 검사하기 때문에 성능이 매우 중요해. 트래픽이 많은 웹 서비스에서는 WAF가 병목 현상을 일으킬 수 있어. 이번에는 Go 언어의 강점을 활용하여 WAF의 성능을 최적화하는 방법을 알아보자!

8.1 동시성 처리로 성능 향상 ⚡

Go의 고루틴과 채널을 활용하여 요청 처리를 병렬화해보자:

// 워커 풀 구현
type WorkerPool struct {
    workerCount int
    jobQueue    chan *http.Request
    results     chan RequestCheckResult
    ruleEngine  *RuleEngine
}

// 요청 검사 결과
type RequestCheckResult struct {
    Request    *http.Request
    Blocked    bool
    Violations []RuleViolation
}

// 새 워커 풀 생성
func NewWorkerPool(workerCount int, queueSize int, ruleEngine *RuleEngine) *WorkerPool {
    pool := &WorkerPool{
        workerCount: workerCount,
        jobQueue:    make(chan *http.Request, queueSize),
        results:     make(chan RequestCheckResult, queueSize),
        ruleEngine:  ruleEngine,
    }
    
    // 워커 고루틴 시작
    for i := 0; i < workerCount; i++ {
        go pool.worker(i)
    }
    
    return pool
}

// 워커 고루틴
func (wp *WorkerPool) worker(id int) {
    log.Printf("워커 %d 시작", id)
    
    for req := range wp.jobQueue {
        // 요청 검사
        blocked, violations := wp.ruleEngine.CheckRequest(req)
        
        // 결과 전송
        wp.results <- RequestCheckResult{
            Request:    req,
            Blocked:    blocked,
            Violations: violations,
        }
    }
}

// 요청 제출
func (wp *WorkerPool) SubmitRequest(req *http.Request) {
    wp.jobQueue <- req
}

// 결과 가져오기
func (wp *WorkerPool) GetResult() RequestCheckResult {
    return <-wp.results
}

// WAF 핸들러 업데이트
type WAFHandler struct {
    proxy      *httputil.ReverseProxy
    workerPool *WorkerPool
    logger     *Logger
}

func (waf *WAFHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    startTime := time.Now()
    
    // 요청 복사 (워커에서 사용하기 위해)
    reqCopy := r.Clone(r.Context())
    
    // 워커 풀에 요청 제출
    waf.workerPool.SubmitRequest(reqCopy)
    
    // 결과 대기
    result := waf.workerPool.GetResult()
    
    // 로그 항목 준비
    logViolations := make([]Violation, 0, len(result.Violations))
    for _, v := range result.Violations {
        logViolations = append(logViolations, Violation{
            RuleID:   v.Rule.ID,
            RuleName: v.Rule.Name,
            Field:    v.Field,
            Content:  v.Content,
            Severity: v.Rule.Severity,
        })
    }
    
    // ... (나머지 로깅 코드는 동일)
    
    if result.Blocked {
        // 응답 차단
        http.Error(w, "보안 정책에 의해 차단된 요청입니다.", http.StatusForbidden)
        return
    }
    
    // 정상 요청은 프록시로 전달
    waf.proxy.ServeHTTP(w, r)
}

func main() {
    // ... (기존 코드)
    
    // 규칙 엔진 생성
    ruleEngine := NewRuleEngine()
    
    // 워커 풀 생성 (CPU 코어 수만큼 워커 생성)
    workerCount := runtime.NumCPU()
    workerPool := NewWorkerPool(workerCount, 100, ruleEngine)
    
    // WAF 핸들러 생성
    wafHandler := &WAFHandler{
        proxy:      proxy,
        workerPool: workerPool,
        logger:     logger,
    }
    
    // ... (나머지 코드)
}

8.2 규칙 엔진 최적화 ⚙️

규칙 엔진의 성능을 최적화하기 위한 몇 가지 기법을 적용해보자:

// 최적화된 규칙 엔진
type OptimizedRuleEngine struct {
    Rules       []Rule
    mu          sync.RWMutex
    rulesByType map[int][]Rule // 유형별 규칙 인덱싱
    cache       *lru.Cache     // 결과 캐싱
}

// 새 최적화 규칙 엔진 생성
func NewOptimizedRuleEngine() *OptimizedRuleEngine {
    cache, _ := lru.New(1000) // 최근 1000개 요청 결과 캐싱
    
    return &OptimizedRuleEngine{
        Rules:       make([]Rule, 0),
        rulesByType: make(map[int][]Rule),
        cache:       cache,
    }
}

// 규칙 추가 시 인덱싱
func (re *OptimizedRuleEngine) AddRule(rule Rule) {
    re.mu.Lock()
    defer re.mu.Unlock()
    
    re.Rules = append(re.Rules, rule)
    re.rulesByType[rule.Type] = append(re.rulesByType[rule.Type], rule)
}

// 요청 검사 최적화
func (re *OptimizedRuleEngine) CheckRequest(r *http.Request) (bool, []RuleViolation) {
    // 캐시 키 생성 (URL + 메서드 + 일부 헤더)
    cacheKey := r.Method + ":" + r.URL.String()
    
    // 캐시 확인
    re.mu.RLock()
    if cachedResult, found := re.cache.Get(cacheKey); found {
        re.mu.RUnlock()
        result := cachedResult.(struct {
            Blocked    bool
            Violations []RuleViolation
        })
        return result.Blocked, result.Violations
    }
    re.mu.RUnlock()
    
    violations := make([]RuleViolation, 0)
    
    // 경로 검사 - 경로 순회 규칙만 적용
    path := r.URL.Path
    for _, rule := range re.rulesByType[PathTraversal] {
        if rule.Pattern.MatchString(path) {
            violations = append(violations, RuleViolation{
                Rule:    rule,
                Content: path,
                Field:   "URL Path",
            })
        }
    }
    
    // 쿼리 파라미터 검사 - SQL 인젝션 및 XSS 규칙만 적용
    query := r.URL.RawQuery
    for _, ruleType := range []int{SQLInjection, XSSAttack} {
        for _, rule := range re.rulesByType[ruleType] {
            if rule.Pattern.MatchString(query) {
                violations = append(violations, RuleViolation{
                    Rule:    rule,
                    Content: query,
                    Field:   "Query Parameters",
                })
            }
        }
    }
    
    // ... (나머지 검사 로직)
    
    // 결과 캐싱
    blocked := len(violations) > 0
    re.mu.Lock()
    re.cache.Add(cacheKey, struct {
        Blocked    bool
        Violations []RuleViolation
    }{
        Blocked:    blocked,
        Violations: violations,
    })
    re.mu.Unlock()
    
    return blocked, violations
}

8.3 분산 WAF 아키텍처 🌐

대규모 트래픽을 처리하기 위해 WAF를 분산 아키텍처로 확장할 수 있어:

분산 WAF 아키텍처의 간단한 구현 예시:

// Redis를 사용한 공유 규칙 저장소
type RedisRuleStore struct {
    client *redis.Client
}

func NewRedisRuleStore(addr string) *RedisRuleStore {
    client := redis.NewClient(&redis.Options{
        Addr: addr,
    })
    
    return &RedisRuleStore{
        client: client,
    }
}

// 규칙 저장
func (rs *RedisRuleStore) SaveRules(rules []Rule) error {
    // 규칙을 JSON으로 직렬화
    data, err := json.Marshal(rules)
    if err != nil {
        return err
    }
    
    // Redis에 저장
    return rs.client.Set("waf:rules", data, 0).Err()
}

// 규칙 로드
func (rs *RedisRuleStore) LoadRules() ([]Rule, error) {
    // Redis에서 규칙 가져오기
    data, err := rs.client.Get("waf:rules").Bytes()
    if err != nil {
        return nil, err
    }
    
    // JSON 역직렬화
    var rulesJSON []RuleJSON
    if err := json.Unmarshal(data, &rulesJSON); err != nil {
        return nil, err
    }
    
    // 규칙 변환
    rules := make([]Rule, 0, len(rulesJSON))
    for _, ruleJSON := range rulesJSON {
        pattern, err := regexp.Compile(ruleJSON.Pattern)
        if err != nil {
            continue
        }
        
        rule := Rule{
            ID:          ruleJSON.ID,
            Name:        ruleJSON.Name,
            Description: ruleJSON.Description,
            Type:        ruleTypeFromString(ruleJSON.Type),
            Pattern:     pattern,
            Severity:    ruleJSON.Severity,
        }
        
        rules = append(rules, rule)
    }
    
    return rules, nil
}

// 규칙 변경 구독
func (rs *RedisRuleStore) SubscribeRuleChanges(callback func([]Rule)) {
    pubsub := rs.client.Subscribe("waf:rule_changes")
    
    go func() {
        for range pubsub.Channel() {
            // 규칙 변경 알림 수신 시 규칙 다시 로드
            rules, err := rs.LoadRules()
            if err != nil {
                log.Printf("규칙 로드 오류: %v", err)
                continue
            }
            
            // 콜백 호출
            callback(rules)
        }
    }()
}

// 규칙 변경 알림
func (rs *RedisRuleStore) NotifyRuleChanges() error {
    return rs.client.Publish("waf:rule_changes", "updated").Err()
}

성능 최적화와 분산 아키텍처를 통해 WAF는 대규모 트래픽에서도 안정적으로 작동할 수 있어! Go 언어의 동시성 모델과 효율적인 메모리 관리는 이러한 확장성을 가능하게 하는 핵심 요소야.

지금까지 WAF의 기본적인 기능을 구현했어. 이제 더 고급 기능을 추가해서 WAF의 보안 수준을 한 단계 더 높여보자!

9.1 레이트 리미팅(Rate Limiting) 구현 ⏱️

특정 IP나 사용자로부터 과도한 요청이 들어오는 것을 방지하기 위한 레이트 리미팅 기능을 구현해보자:

// 토큰 버킷 기반 레이트 리미터
type RateLimiter struct {
    buckets map[string]*TokenBucket
    mu      sync.RWMutex
    rate    float64 // 초당 토큰 리필 속도
    capacity int    // 버킷 최대 용량
}

// 토큰 버킷
type TokenBucket struct {
    tokens    float64
    lastRefill time.Time
    capacity  int
    rate      float64
}

// 새 레이트 리미터 생성
func NewRateLimiter(rate float64, capacity int) *RateLimiter {
    return &RateLimiter{
        buckets:  make(map[string]*TokenBucket),
        rate:     rate,
        capacity: capacity,
    }
}

// 요청 허용 여부 확인
func (rl *RateLimiter) Allow(key string) bool {
    rl.mu.Lock()
    defer rl.mu.Unlock()
    
    bucket, exists := rl.buckets[key]
    if !exists {
        // 새 버킷 생성
        bucket = &TokenBucket{
            tokens:    float64(rl.capacity),
            lastRefill: time.Now(),
            capacity:  rl.capacity,
            rate:      rl.rate,
        }
        rl.buckets[key] = bucket
    }
    
    // 토큰 리필
    now := time.Now()
    elapsed := now.Sub(bucket.lastRefill).Seconds()
    bucket.tokens = math.Min(float64(bucket.capacity), bucket.tokens + elapsed * bucket.rate)
    bucket.lastRefill = now
    
    // 토큰 사용 가능 여부 확인
    if bucket.tokens >= 1 {
        bucket.tokens--
        return true
    }
    
    return false
}

// WAF 핸들러에 레이트 리미팅 통합
type WAFHandler struct {
    proxy       *httputil.ReverseProxy
    workerPool  *WorkerPool
    logger      *Logger
    rateLimiter *RateLimiter
}

func (waf *WAFHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 클라이언트 IP 추출
    clientIP := r.RemoteAddr
    if forwardedFor := r.Header.Get("X-Forwarded-For"); forwardedFor != "" {
        clientIP = forwardedFor
    }
    
    // 레이트 리미팅 적용
    if !waf.rateLimiter.Allow(clientIP) {
        log.Printf("⚠️ 레이트 리밋 초과: %s", clientIP)
        http.Error(w, "너무 많은 요청을 보냈습니다. 잠시 후 다시 시도해주세요.", http.StatusTooManyRequests)
        return
    }
    
    // 기존 WAF 로직 계속 진행
    // ...
}

9.2 학습 모드(Learning Mode) 구현 🧠

WAF가 실제 트래픽 패턴을 학습하여 오탐(false positive)을 줄이는 학습 모드를 구현해보자:

// 학습 모드 구현
type LearningMode struct {
    enabled      bool
    patterns     map[string]int // 패턴별 발생 빈도
    threshold    int           // 학습 임계값
    whitelistSet map[string]bool // 화이트리스트 패턴
    mu           sync.RWMutex
}

// 새 학습 모드 생성
func NewLearningMode(threshold int) *LearningMode {
    return &LearningMode{
        enabled:      true,
        patterns:     make(map[string]int),
        threshold:    threshold,
        whitelistSet: make(map[string]bool),
    }
}

// 패턴 학습
func (lm *LearningMode) LearnPattern(pattern string) {
    if !lm.enabled {
        return
    }
    
    lm.mu.Lock()
    defer lm.mu.Unlock()
    
    // 이미 화이트리스트에 있으면 건너뛰기
    if lm.whitelistSet[pattern] {
        return
    }
    
    // 패턴 빈도 증가
    lm.patterns[pattern]++
    
    // 임계값 초과 시 화이트리스트에 추가
    if lm.patterns[pattern] >= lm.threshold {
        log.Printf("🧠 학습 모드: 패턴 '%s'을(를) 화이트리스트에 추가합니다", pattern)
        lm.whitelistSet[pattern] = true
    }
}

// 패턴이 화이트리스트에 있는지 확인
func (lm *LearningMode) IsWhitelisted(pattern string) bool {
    lm.mu.RLock()
    defer lm.mu.RUnlock()
    return lm.whitelistSet[pattern]
}

// 화이트리스트 저장
func (lm *LearningMode) SaveWhitelist(filename string) error {
    lm.mu.RLock()
    defer lm.mu.RUnlock()
    
    whitelist := make([]string, 0, len(lm.whitelistSet))
    for pattern := range lm.whitelistSet {
        whitelist = append(whitelist, pattern)
    }
    
    data, err := json.MarshalIndent(whitelist, "", "  ")
    if err != nil {
        return err
    }
    
    return ioutil.WriteFile(filename, data, 0644)
}

// 화이트리스트 로드
func (lm *LearningMode) LoadWhitelist(filename string) error {
    data, err := ioutil.ReadFile(filename)
    if err != nil {
        return err
    }
    
    var whitelist []string
    if err := json.Unmarshal(data, &whitelist); err != nil {
        return err
    }
    
    lm.mu.Lock()
    defer lm.mu.Unlock()
    
    for _, pattern := range whitelist {
        lm.whitelistSet[pattern] = true
    }
    
    return nil
}

// 규칙 엔진에 학습 모드 통합
func (re *RuleEngine) CheckRequestWithLearning(r *http.Request, learningMode *LearningMode) (bool, []RuleViolation) {
    violations := make([]RuleViolation, 0)
    
    // URL 검사
    path := r.URL.Path
    for _, rule := range re.Rules {
        if rule.Pattern.MatchString(path) {
            // 학습 모드에서 화이트리스트 확인
            patternKey := fmt.Sprintf("path:%s:%d", path, rule.ID)
            if learningMode.IsWhitelisted(patternKey) {
                continue
            }
            
            violations = append(violations, RuleViolation{
                Rule:    rule,
                Content: path,
                Field:   "URL Path",
            })
            
            // 학습 모드에서 패턴 학습
            if !rule.IsCritical() { // 중요 규칙은 학습하지 않음
                learningMode.LearnPattern(patternKey)
            }
        }
    }
    
    // ... (다른 필드 검사도 유사하게 구현)
    
    return len(violations) > 0, violations
}

9.3 지능형 봇 탐지(Bot Detection) 🤖

악성 봇을 탐지하고 차단하는 기능을 구현해보자:

// 봇 탐지 구현
type BotDetector struct {
    fingerprints   map[string]BotFingerprint
    mu             sync.RWMutex
    sessionTracker *SessionTracker
}

// 봇 지문
type BotFingerprint struct {
    UserAgent      string
    IPAddress      string
    RequestPattern []string
    LastSeen       time.Time
    RequestCount   int
    IsBot          bool
    Score          float64 // 봇 점수 (높을수록 봇일 가능성 높음)
}

// 세션 추적기
type SessionTracker struct {
    sessions map[string]*UserSession
    mu       sync.RWMutex
}

// 사용자 세션
type UserSession struct {
    SessionID    string
    IPAddress    string
    UserAgent    string
    FirstSeen    time.Time
    LastSeen     time.Time
    RequestCount int
    PathHistory  []string
}

// 새 봇 탐지기 생성
func NewBotDetector() *BotDetector {
    return &BotDetector{
        fingerprints:   make(map[string]BotFingerprint),
        sessionTracker: &SessionTracker{
            sessions: make(map[string]*UserSession),
        },
    }
}

// 요청 분석
func (bd *BotDetector) AnalyzeRequest(r *http.Request) (bool, float64) {
    // 클라이언트 정보 추출
    userAgent := r.UserAgent()
    ipAddress := r.RemoteAddr
    if forwardedFor := r.Header.Get("X-Forwarded-For"); forwardedFor != "" {
        ipAddress = forwardedFor
    }
    
    // 세션 ID 가져오기 (쿠키 또는 생성)
    sessionID := bd.getOrCreateSessionID(r)
    
    // 세션 업데이트
    bd.updateSession(sessionID, ipAddress, userAgent, r.URL.Path)
    
    // 봇 점수 계산
    score := bd.calculateBotScore(sessionID, r)
    
    // 봇 여부 판단 (점수가 0.7 이상이면 봇으로 간주)
    isBot := score >= 0.7
    
    // 지문 업데이트
    fingerprintKey := ipAddress + ":" + userAgent
    bd.mu.Lock()
    fingerprint, exists := bd.fingerprints[fingerprintKey]
    if !exists {
        fingerprint = BotFingerprint{
            UserAgent:      userAgent,
            IPAddress:      ipAddress,
            RequestPattern: make([]string, 0),
            LastSeen:       time.Now(),
            RequestCount:   1,
            IsBot:          isBot,
            Score:          score,
        }
    } else {
        fingerprint.LastSeen = time.Now()
        fingerprint.RequestCount++
        fingerprint.RequestPattern = append(fingerprint.RequestPattern, r.URL.Path)
        if len(fingerprint.RequestPattern) > 10 {
            fingerprint.RequestPattern = fingerprint.RequestPattern[1:]
        }
        fingerprint.IsBot = isBot
        fingerprint.Score = score
    }
    bd.fingerprints[fingerprintKey] = fingerprint
    bd.mu.Unlock()
    
    return isBot, score
}

// 세션 ID 가져오기 또는 생성
func (bd *BotDetector) getOrCreateSessionID(r *http.Request) string {
    // 쿠키에서 세션 ID 찾기
    cookie, err := r.Cookie("session_id")
    if err == nil && cookie.Value != "" {
        return cookie.Value
    }
    
    // 새 세션 ID 생성
    return uuid.New().String()
}

// 세션 업데이트
func (bd *BotDetector) updateSession(sessionID, ipAddress, userAgent, path string) {
    bd.sessionTracker.mu.Lock()
    defer bd.sessionTracker.mu.Unlock()
    
    session, exists := bd.sessionTracker.sessions[sessionID]
    if !exists {
        session = &UserSession{
            SessionID:    sessionID,
            IPAddress:    ipAddress,
            UserAgent:    userAgent,
            FirstSeen:    time.Now(),
            LastSeen:     time.Now(),
            RequestCount: 1,
            PathHistory:  []string{path},
        }
    } else {
        session.LastSeen = time.Now()
        session.RequestCount++
        session.PathHistory = append(session.PathHistory, path)
        if len(session.PathHistory) > 20 {
            session.PathHistory = session.PathHistory[1:]
        }
    }
    
    bd.sessionTracker.sessions[sessionID] = session
}

// 봇 점수 계산
func (bd *BotDetector) calculateBotScore(sessionID string, r *http.Request) float64 {
    score := 0.0
    
    // 세션 정보 가져오기
    bd.sessionTracker.mu.RLock()
    session, exists := bd.sessionTracker.sessions[sessionID]
    bd.sessionTracker.mu.RUnlock()
    
    if !exists {
        return 0.5 // 기본 점수
    }
    
    // 1. 요청 속도 분석
    requestInterval := time.Since(session.LastSeen).Seconds()
    if session.RequestCount > 1 && requestInterval < 0.5 {
        // 0.5초 이내에 여러 요청을 보내면 점수 증가
        score += 0.2
    }
    
    // 2. 사용자 에이전트 분석
    userAgent := r.UserAgent()
    if userAgent == "" {
        score += 0.3
    } else if strings.Contains(strings.ToLower(userAgent), "bot") ||
              strings.Contains(strings.ToLower(userAgent), "crawler") ||
              strings.Contains(strings.ToLower(userAgent), "spider") {
        score += 0.4
    }
    
    // 3. 요청 패턴 분석 (동일한 경로 반복 접근)
    if len(session.PathHistory) >= 3 {
        pathCounts := make(map[string]int)
        for _, p := range session.PathHistory {
            pathCounts[p]++
        }
        
        // 동일 경로 반복 접근 확인
        for _, count := range pathCounts {
            if count >= 3 {
                score += 0.2
                break
            }
        }
    }
    
    // 4. 헤더 분석
    if r.Header.Get("Accept-Language") == "" {
        score += 0.1
    }
    
    // 5. 쿠키 지원 확인
    if len(r.Cookies()) == 0 {
        score += 0.1
    }
    
    // 점수 정규화 (0~1 사이)
    if score > 1.0 {
        score = 1.0
    }
    
    return score
}

이러한 고급 기능들은 WAF의 보안 수준을 크게 향상시키고, 더 지능적인 방어 시스템을 구축할 수 있게 해줘! 특히 Go 언어의 동시성 모델은 이런 복잡한 기능들을 효율적으로 구현하는 데 큰 도움이 돼.

WAF를 효과적으로 관리하기 위해서는 관리자 인터페이스가 필요해. 이번에는 WAF 설정을 관리하고 로그를 모니터링할 수 있는 웹 기반 관리 인터페이스를 구현해보자!

10.1 RESTful API 구현 🔌

먼저 WAF 관리를 위한 RESTful API를 구현해보자:

package main

import (
    "encoding/json"
    "net/http"
    "strconv"

    "github.com/gorilla/mux"
)

// API 응답 구조체
type APIResponse struct {
    Success bool        `json:"success"`
    Message string      `json:"message,omitempty"`
    Data    interface{} `json:"data,omitempty"`
}

// WAF API 핸들러
type APIHandler struct {
    waf        *WAFHandler
    ruleEngine *RuleEngine
    logger     *Logger
}

// API 서버 시작
func StartAPIServer(waf *WAFHandler, ruleEngine *RuleEngine, logger *Logger, addr string) {
    apiHandler := &APIHandler{
        waf:        waf,
        ruleEngine: ruleEngine,
        logger:     logger,
    }
    
    router := mux.NewRouter()
    
    // 규칙 관련 API 엔드포인트
    router.HandleFunc("/api/rules", apiHandler.GetRules).Methods("GET")
    router.HandleFunc("/api/rules", apiHandler.AddRule).Methods("POST")
    router.HandleFunc("/api/rules/{id:[0-9]+}", apiHandler.GetRule).Methods("GET")
    router.HandleFunc("/api/rules/{id:[0-9]+}", apiHandler.UpdateRule).Methods("PUT")
    router.HandleFunc("/api/rules/{id:[0-9]+}", apiHandler.DeleteRule).Methods("DELETE")
    
    // 통계 관련 API 엔드포인트
    router.HandleFunc("/api/stats", apiHandler.GetStats).Methods("GET")
    
    // 로그 관련 API 엔드포인트
    router.HandleFunc("/api/logs", apiHandler.GetLogs).Methods("GET")
    
    // 설정 관련 API 엔드포인트
    router.HandleFunc("/api/config", apiHandler.GetConfig).Methods("GET")
    router.HandleFunc("/api/config", apiHandler.UpdateConfig).Methods("PUT")
    
    // 정적 파일 서빙 (관리 UI)
    router.PathPrefix("/").Handler(http.FileServer(http.Dir("./admin")))
    
    // API 서버 시작
    go func() {
        log.Printf("🖥️ WAF 관리 API 서버가 %s에서 시작됩니다...", addr)
        log.Fatal(http.ListenAndServe(addr, router))
    }()
}

// 모든 규칙 가져오기
func (api *APIHandler) GetRules(w http.ResponseWriter, r *http.Request) {
    api.ruleEngine.mu.RLock()
    defer api.ruleEngine.mu.RUnlock()
    
    // 규칙 목록 반환
    response := APIResponse{
        Success: true,
        Data:    api.ruleEngine.Rules,
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

// 특정 규칙 가져오기
func (api *APIHandler) GetRule(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, err := strconv.Atoi(vars["id"])
    if err != nil {
        http.Error(w, "Invalid rule ID", http.StatusBadRequest)
        return
    }
    
    api.ruleEngine.mu.RLock()
    defer api.ruleEngine.mu.RUnlock()
    
    // ID로 규칙 찾기
    for _, rule := range api.ruleEngine.Rules {
        if rule.ID == id {
            response := APIResponse{
                Success: true,
                Data:    rule,
            }
            
            w.Header().Set("Content-Type", "application/json")
            json.NewEncoder(w).Encode(response)
            return
        }
    }
    
    // 규칙을 찾지 못한 경우
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(APIResponse{
        Success: false,
        Message: "Rule not found",
    })
}

// 새 규칙 추가
func (api *APIHandler) AddRule(w http.ResponseWriter, r *http.Request) {
    var ruleJSON RuleJSON
    if err := json.NewDecoder(r.Body).Decode(&ruleJSON); err != nil {
        http.Error(w, "Invalid request body", http.StatusBadRequest)
        return
    }
    
    // 패턴 컴파일
    pattern, err := regexp.Compile(ruleJSON.Pattern)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(APIResponse{
            Success: false,
            Message: "Invalid pattern: " + err.Error(),
        })
        return
    }
    
    // 새 규칙 생성
    rule := Rule{
        ID:          ruleJSON.ID,
        Name:        ruleJSON.Name,
        Description: ruleJSON.Description,
        Type:        ruleTypeFromString(ruleJSON.Type),
        Pattern:     pattern,
        Severity:    ruleJSON.Severity,
    }
    
    // 규칙 추가
    api.ruleEngine.mu.Lock()
    api.ruleEngine.Rules = append(api.ruleEngine.Rules, rule)
    api.ruleEngine.mu.Unlock()
    
    // 성공 응답
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(APIResponse{
        Success: true,
        Message: "Rule added successfully",
        Data:    rule,
    })
}

// 규칙 업데이트
func (api *APIHandler) UpdateRule(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, err := strconv.Atoi(vars["id"])
    if err != nil {
        http.Error(w, "Invalid rule ID", http.StatusBadRequest)
        return
    }
    
    var ruleJSON RuleJSON
    if err := json.NewDecoder(r.Body).Decode(&ruleJSON); err != nil {
        http.Error(w, "Invalid request body", http.StatusBadRequest)
        return
    }
    
    // 패턴 컴파일
    pattern, err := regexp.Compile(ruleJSON.Pattern)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(APIResponse{
            Success: false,
            Message: "Invalid pattern: " + err.Error(),
        })
        return
    }
    
    api.ruleEngine.mu.Lock()
    defer api.ruleEngine.mu.Unlock()
    
    // ID로 규칙 찾기
    for i, rule := range api.ruleEngine.Rules {
        if rule.ID == id {
            // 규칙 업데이트
            api.ruleEngine.Rules[i] = Rule{
                ID:          id,
                Name:        ruleJSON.Name,
                Description: ruleJSON.Description,
                Type:        ruleTypeFromString(ruleJSON.Type),
                Pattern:     pattern,
                Severity:    ruleJSON.Severity,
            }
            
            // 성공 응답
            json.NewEncoder(w).Encode(APIResponse{
                Success: true,
                Message: "Rule updated successfully",
                Data:    api.ruleEngine.Rules[i],
            })
            return
        }
    }
    
    // 규칙을 찾지 못한 경우
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(APIResponse{
        Success: false,
        Message: "Rule not found",
    })
}

// 규칙 삭제
func (api *APIHandler) DeleteRule(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, err := strconv.Atoi(vars["id"])
    if err != nil {
        http.Error(w, "Invalid rule ID", http.StatusBadRequest)
        return
    }
    
    api.ruleEngine.mu.Lock()
    defer api.ruleEngine.mu.Unlock()
    
    // ID로 규칙 찾기
    for i, rule := range api.ruleEngine.Rules {
        if rule.ID == id {
            // 규칙 삭제
            api.ruleEngine.Rules = append(api.ruleEngine.Rules[:i], api.ruleEngine.Rules[i+1:]...)
            
            // 성공 응답
            json.NewEncoder(w).Encode(APIResponse{
                Success: true,
                Message: "Rule deleted successfully",
            })
            return
        }
    }
    
    // 규칙을 찾지 못한 경우
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(APIResponse{
        Success: false,
        Message: "Rule not found",
    })
}

// 통계 가져오기
func (api *APIHandler) GetStats(w http.ResponseWriter, r *http.Request) {
    // TODO: 통계 데이터 수집 및 반환
    // ...
}

// 로그 가져오기
func (api *APIHandler) GetLogs(w http.ResponseWriter, r *http.Request) {
    // TODO: 로그 데이터 수집 및 반환
    // ...
}

// 설정 가져오기
func (api *APIHandler) GetConfig(w http.ResponseWriter, r *http.Request) {
    // TODO: 설정 데이터 반환
    // ...
}

// 설정 업데이트
func (api *APIHandler) UpdateConfig(w http.ResponseWriter, r *http.Request) {
    // TODO: 설정 데이터 업데이트
    // ...
}

10.2 웹 기반 관리 UI 구현 🎨

이제 API를 사용하는 웹 기반 관리 UI를 구현해보자. 여기서는 간단한 HTML, CSS, JavaScript로 구현할게:

JavaScript 코드로 API와 통신하는 부분을 구현해보자:

// admin/js/app.js
document.addEventListener('DOMContentLoaded', function() {
    // 페이지 전환 처리
    const navLinks = document.querySelectorAll('nav a');
    const pages = document.querySelectorAll('.page');
    
    navLinks.forEach(link => {
        link.addEventListener('click', function(e) {
            e.preventDefault();
            
            // 활성 링크 변경
            navLinks.forEach(l => l.classList.remove('active'));
            this.classList.add('active');
            
            // 페이지 전환
            const targetPage = this.getAttribute('data-page');
            pages.forEach(page => {
                page.classList.remove('active');
                if (page.id === targetPage) {
                    page.classList.add('active');
                }
            });
            
            // 페이지별 초기화 함수 호출
            if (targetPage === 'dashboard') {
                loadDashboard();
            } else if (targetPage === 'rules') {
                loadRules();
            } else if (targetPage === 'logs') {
                loadLogs();
            } else if (targetPage === 'settings') {
                loadSettings();
            }
        });
    });
    
    // 대시보드 데이터 로드
    function loadDashboard() {
        fetch('/api/stats')
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    updateDashboardStats(data.data);
                    updateDashboardCharts(data.data);
                    updateRecentLogs(data.data.recentLogs);
                }
            })
            .catch(error => console.error('대시보드 데이터 로드 오류:', error));
    }
    
    // 대시보드 통계 업데이트
    function updateDashboardStats(stats) {
        document.getElementById('total-requests').textContent = stats.totalRequests.toLocaleString();
        document.getElementById('blocked-requests').textContent = stats.blockedRequests.toLocaleString();
        document.getElementById('allowed-requests').textContent = stats.allowedRequests.toLocaleString();
        
        const blockRate = (stats.blockedRequests / stats.totalRequests * 100).toFixed(2);
        document.getElementById('block-rate').textContent = blockRate + '%';
    }
    
    // 대시보드 차트 업데이트
    function updateDashboardCharts(stats) {
        // 요청 차트
        const requestsCtx = document.getElementById('requests-chart').getContext('2d');
        new Chart(requestsCtx, {
            type: 'line',
            data: {
                labels: stats.timeLabels,
                datasets: [
                    {
                        label: '총 요청',
                        data: stats.requestsData.total,
                        borderColor: '#3498db',
                        backgroundColor: 'rgba(52, 152, 219, 0.1)',
                        fill: true
                    },
                    {
                        label: '차단된 요청',
                        data: stats.requestsData.blocked,
                        borderColor: '#e74c3c',
                        backgroundColor: 'rgba(231, 76, 60, 0.1)',
                        fill: true
                    }
                ]
            },
            options: {
                responsive: true,
                maintainAspectRatio: false
            }
        });
        
        // 공격 유형 차트
        const attackTypesCtx = document.getElementById('attack-types-chart').getContext('2d');
        new Chart(attackTypesCtx, {
            type: 'pie',
            data: {
                labels: stats.attackTypes.map(type => type.name),
                datasets: [{
                    data: stats.attackTypes.map(type => type.count),
                    backgroundColor: [
                        '#3498db', '#e74c3c', '#2ecc71', '#f39c12', '#9b59b6',
                        '#1abc9c', '#d35400', '#34495e', '#16a085', '#c0392b'
                    ]
                }]
            },
            options: {
                responsive: true,
                maintainAspectRatio: false
            }
        });
    }
    
    // 최근 로그 업데이트
    function updateRecentLogs(logs) {
        const tbody = document.getElementById('recent-logs-body');
        tbody.innerHTML = '';
        
        logs.forEach(log => {
            const row = document.createElement('tr');
            
            const timeCell = document.createElement('td');
            timeCell.textContent = new Date(log.timestamp).toLocaleString();
            row.appendChild(timeCell);
            
            const ipCell = document.createElement('td');
            ipCell.textContent = log.clientIP;
            row.appendChild(ipCell);
            
            const urlCell = document.createElement('td');
            urlCell.textContent = log.url;
            row.appendChild(urlCell);
            
            const ruleCell = document.createElement('td');
            ruleCell.textContent = log.violations[0]?.ruleName || '-';
            row.appendChild(ruleCell);
            
            const severityCell = document.createElement('td');
            const severity = log.violations[0]?.severity || 0;
            severityCell.textContent = severity === 3 ? '높음' : severity === 2 ? '중간' : '낮음';
            severityCell.className = severity === 3 ? 'high' : severity === 2 ? 'medium' : 'low';
            row.appendChild(severityCell);
            
            tbody.appendChild(row);
        });
    }
    
    // 규칙 목록 로드
    function loadRules() {
        fetch('/api/rules')
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    updateRulesTable(data.data);
                }
            })
            .catch(error => console.error('규칙 데이터 로드 오류:', error));
    }
    
    // 규칙 테이블 업데이트
    function updateRulesTable(rules) {
        const tbody = document.getElementById('rules-body');
        tbody.innerHTML = '';
        
        rules.forEach(rule => {
            const row = document.createElement('tr');
            
            const idCell = document.createElement('td');
            idCell.textContent = rule.ID;
            row.appendChild(idCell);
            
            const nameCell = document.createElement('td');
            nameCell.textContent = rule.Name;
            row.appendChild(nameCell);
            
            const typeCell = document.createElement('td');
            typeCell.textContent = getRuleTypeName(rule.Type);
            row.appendChild(typeCell);
            
            const patternCell = document.createElement('td');
            patternCell.textContent = rule.Pattern.String;
            row.appendChild(patternCell);
            
            const severityCell = document.createElement('td');
            severityCell.textContent = rule.Severity === 3 ? '높음' : rule.Severity === 2 ? '중간' : '낮음';
            severityCell.className = rule.Severity === 3 ? 'high' : rule.Severity === 2 ? 'medium' : 'low';
            row.appendChild(severityCell);
            
            const actionsCell = document.createElement('td');
            
            const editBtn = document.createElement('button');
            editBtn.className = 'btn small';
            editBtn.textContent = '편집';
            editBtn.addEventListener('click', () => editRule(rule));
            actionsCell.appendChild(editBtn);
            
            const deleteBtn = document.createElement('button');
            deleteBtn.className = 'btn small danger';
            deleteBtn.textContent = '삭제';
            deleteBtn.addEventListener('click', () => deleteRule(rule.ID));
            actionsCell.appendChild(deleteBtn);
            
            row.appendChild(actionsCell);
            
            tbody.appendChild(row);
        });
    }
    
    // 규칙 유형 이름 가져오기
    function getRuleTypeName(type) {
        switch (type) {
            case 0: return 'SQL 인젝션';
            case 1: return 'XSS 공격';
            case 2: return '경로 순회';
            case 3: return '명령어 인젝션';
            case 4: return '파일 인클루전';
            default: return '알 수 없음';
        }
    }
    
    // 규칙 유형 값 가져오기
    function getRuleTypeValue(type) {
        switch (type) {
            case 0: return 'sql_injection';
            case 1: return 'xss_attack';
            case 2: return 'path_traversal';
            case 3: return 'command_injection';
            case 4: return 'file_inclusion';
            default: return '';
        }
    }
    
    // 규칙 편집 모달 표시
    function editRule(rule) {
        document.getElementById('modal-title').textContent = '규칙 편집';
        document.getElementById('rule-id').value = rule.ID;
        document.getElementById('rule-name').value = rule.Name;
        document.getElementById('rule-type').value = getRuleTypeValue(rule.Type);
        document.getElementById('rule-pattern').value = rule.Pattern.String;
        document.getElementById('rule-description').value = rule.Description;
        document.getElementById('rule-severity').value = rule.Severity;
        
        document.getElementById('rule-modal').style.display = 'block';
    }
    
    // 규칙 삭제
    function deleteRule(id) {
        if (confirm('정말 이 규칙을 삭제하시겠습니까?')) {
            fetch(`/api/rules/${id}`, {
                method: 'DELETE'
            })
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    alert('규칙이 삭제되었습니다.');
                    loadRules();
                } else {
                    alert('규칙 삭제 실패: ' + data.message);
                }
            })
            .catch(error => console.error('규칙 삭제 오류:', error));
        }
    }
    
    // 새 규칙 추가 버튼 이벤트
    document.getElementById('add-rule-btn').addEventListener('click', function() {
        document.getElementById('modal-title').textContent = '새 규칙 추가';
        document.getElementById('rule-form').reset();
        document.getElementById('rule-id').value = '';
        document.getElementById('rule-modal').style.display = 'block';
    });
    
    // 모달 닫기 버튼 이벤트
    document.querySelector('.close').addEventListener('click', function() {
        document.getElementById('rule-modal').style.display = 'none';
    });
    
    // 취소 버튼 이벤트
    document.getElementById('cancel-btn').addEventListener('click', function() {
        document.getElementById('rule-modal').style.display = 'none';
    });
    
    // 규칙 폼 제출 이벤트
    document.getElementById('rule-form').addEventListener('submit', function(e) {
        e.preventDefault();
        
        const ruleId = document.getElementById('rule-id').value;
        const isNewRule = !ruleId;
        
        const ruleData = {
            id: isNewRule ? Math.floor(Math.random() * 10000) + 5000 : parseInt(ruleId),
            name: document.getElementById('rule-name').value,
            type: document.getElementById('rule-type').value,
            pattern: document.getElementById('rule-pattern').value,
            description: document.getElementById('rule-description').value,
            severity: parseInt(document.getElementById('rule-severity').value)
        };
        
        const url = isNewRule ? '/api/rules' : `/api/rules/${ruleId}`;
        const method = isNewRule ? 'POST' : 'PUT';
        
        fetch(url, {
            method: method,
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(ruleData)
        })
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                alert(isNewRule ? '규칙이 추가되었습니다.' : '규칙이 업데이트되었습니다.');
                document.getElementById('rule-modal').style.display = 'none';
                loadRules();
            } else {
                alert('오류: ' + data.message);
            }
        })
        .catch(error => console.error('규칙 저장 오류:', error));
    });
    
    // 로그 데이터 로드
    function loadLogs() {
        const dateRange = document.getElementById('log-date-range').value;
        const logType = document.getElementById('log-type').value;
        const searchQuery = document.getElementById('log-search').value;
        
        fetch(`/api/logs?range=${dateRange}&type=${logType}&search=${searchQuery}`)
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    updateLogsTable(data.data);
                }
            })
            .catch(error => console.error('로그 데이터 로드 오류:', error));
    }
    
    // 로그 검색 버튼 이벤트
    document.getElementById('log-search-btn').addEventListener('click', loadLogs);
    
    // 설정 데이터 로드
    function loadSettings() {
        fetch('/api/config')
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    updateSettingsForm(data.data);
                }
            })
            .catch(error => console.error('설정 데이터 로드 오류:', error));
    }
    
    // 설정 폼 업데이트
    function updateSettingsForm(config) {
        document.getElementById('target-url').value = config.targetURL;
        document.getElementById('waf-mode').value = config.mode;
        document.getElementById('log-level').value = config.logLevel;
        document.getElementById('rate-limit').value = config.rateLimit;
        document.getElementById('worker-count').value = config.workerCount;
        document.getElementById('enable-bot-detection').checked = config.botDetection;
    }
    
    // 설정 폼 제출 이벤트
    document.getElementById('settings-form').addEventListener('submit', function(e) {
        e.preventDefault();
        
        const configData = {
            targetURL: document.getElementById('target-url').value,
            mode: document.getElementById('waf-mode').value,
            logLevel: document.getElementById('log-level').value,
            rateLimit: parseInt(document.getElementById('rate-limit').value),
            workerCount: parseInt(document.getElementById('worker-count').value),
            botDetection: document.getElementById('enable-bot-detection').checked
        };
        
        fetch('/api/config', {
            method: 'PUT',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(configData)
        })
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                alert('설정이 저장되었습니다.');
            } else {
                alert('설정 저장 실패: ' + data.message);
            }
        })
        .catch(error => console.error('설정 저장 오류:', error));
    });
    
    // 초기 페이지 로드
    loadDashboard();
});

관리 인터페이스를 통해 WAF를 쉽게 모니터링하고 관리할 수 있어! API와 웹 UI를 통합하면 보안 관리자가 WAF의 상태를 실시간으로 확인하고 규칙을 업데이트할 수 있지.

지금까지 Go 언어를 사용하여 웹 애플리케이션 방화벽(WAF)을 구현하는 방법에 대해 자세히 알아봤어. 이제 우리가 배운 내용을 정리하고, WAF의 향후 발전 방향에 대해 생각해보자!

11.1 구현 내용 요약 📋

이 모든 기능을 Go 언어로 구현하면서 Go의 강력한 동시성 모델, 효율적인 메모리 관리, 풍부한 표준 라이브러리 등의 장점을 활용했어. 재능넷에서도 이런 Go 언어의 강점을 활용한 프로젝트를 많이 찾아볼 수 있을 거야!

11.2 Go 언어의 강점 💪

11.3 향후 발전 방향 🚀

우리가 구현한 WAF는 기본적인 기능을 갖추고 있지만, 더 발전시킬 수 있는 여러 방향이 있어:

Go 언어의 생태계는 계속 성장하고 있어, 이러한 발전 방향을 구현하는 데 필요한 라이브러리와 도구도 점점 더 풍부해지고 있어! 특히 머신러닝과 클라우드 네이티브 기술과의 통합은 WAF의 미래에 중요한 역할을 할 거야.

11.4 마무리 🎁

이 글을 통해 Go 언어를 사용하여 웹 애플리케이션 방화벽을 구현하는 방법을 자세히 알아봤어. WAF는 현대 웹 서비스의 보안에 매우 중요한 요소이며, Go 언어는 이런 보안 솔루션을 구현하기에 아주 적합한 언어야.

네트워크 보안과 Go 프로그래밍에 관심이 있다면, 이 글에서 배운 내용을 바탕으로 직접 WAF를 구현해보는 것을 추천해! 실제로 구현하면서 더 많은 것을 배울 수 있을 거야.

재능넷에서는 이런 프로그래밍 지식뿐만 아니라 다양한 분야의 재능을 공유하고 거래할 수 있어. Go 언어나 네트워크 보안에 관심이 생겼다면, 재능넷에서 관련 멘토링이나 프로젝트 협업 기회를 찾아보는 것도 좋은 방법이 될 거야!