# /etc/ipsec.conf (StrongSwan 설정)
config setup
    charondebug="ike 1, knl 1, cfg 0"
    uniqueids=no

conn %default
    ikelifetime=60m
    keylife=20m
    rekeymargin=3m
    keyingtries=1
    keyexchange=ikev2
    authby=secret

conn site-to-site
    left=203.0.113.1          # 본사 공인 IP
    leftsubnet=192.168.1.0/24  # 본사 내부 네트워크
    right=203.0.113.2         # 지점 공인 IP
    rightsubnet=192.168.2.0/24 # 지점 내부 네트워크
    ike=aes256-sha256-modp2048!
    esp=aes256-sha256!
    auto=start

# /etc/openvpn/server.conf
port 1194
proto udp
dev tun

# 인증서 파일
ca ca.crt
cert server.crt
key server.key
dh dh.pem

# 가상 네트워크 설정
server 10.8.0.0 255.255.255.0
ifconfig-pool-persist ipp.txt

# 클라이언트에게 라우팅 정보 전달
push "route 192.168.1.0 255.255.255.0"
push "dhcp-option DNS 8.8.8.8"
push "dhcp-option DNS 8.8.4.4"

# 보안 설정
cipher AES-256-CBC
auth SHA256
tls-auth ta.key 0
key-direction 0

# 연결 유지
keepalive 10 120
comp-lzo
persist-key
persist-tun

# 권한 설정
user nobody
group nobody

# 로그 설정
status openvpn-status.log
log-append /var/log/openvpn.log
verb 3

# Python을 이용한 OpenVPN 클라이언트 관리
import subprocess
import os
import configparser

class OpenVPNClient:
    def __init__(self, config_file):
        self.config_file = config_file
        self.process = None
        self.is_connected = False
    
    def connect(self):
        """OpenVPN 연결 시작"""
        try:
            cmd = ['openvpn', '--config', self.config_file, '--daemon']
            self.process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE
            )
            self.is_connected = True
            return True
        except Exception as e:
            print(f"VPN 연결 실패: {e}")
            return False
    
    def disconnect(self):
        """VPN 연결 해제"""
        if self.process:
            self.process.terminate()
            self.process.wait()
            self.is_connected = False
    
    def get_status(self):
        """연결 상태 확인"""
        if not self.is_connected:
            return "Disconnected"
        
        try:
            # OpenVPN 상태 파일 읽기
            with open('/var/run/openvpn/openvpn-status.log', 'r') as f:
                lines = f.readlines()
                for line in lines:
                    if 'CLIENT_LIST' in line:
                        return "Connected"
            return "Connecting"
        except FileNotFoundError:
            return "Status Unknown"

# 사용 예제
vpn = OpenVPNClient('/etc/openvpn/client.conf')
vpn.connect()
print(f"VPN 상태: {vpn.get_status()}")

# IPSec VPN 자동 설정 스크립트
#!/bin/bash

# 변수 설정
LOCAL_IP="192.168.1.100"
REMOTE_IP="203.0.113.50"
SHARED_KEY="your-shared-key"
LOCAL_SUBNET="192.168.1.0/24"
REMOTE_SUBNET="192.168.2.0/24"

# IPSec 설정
cat > /etc/ipsec.conf << EOF
conn tunnel
    left=$LOCAL_IP
    leftsubnet=$LOCAL_SUBNET
    right=$REMOTE_IP
    rightsubnet=$REMOTE_SUBNET
    keyexchange=ikev2
    ike=aes256-sha256-modp2048!
    esp=aes256-sha256!
    authby=secret
    auto=start
EOF

# 공유키 설정
cat > /etc/ipsec.secrets << EOF
$LOCAL_IP $REMOTE_IP : PSK "$SHARED_KEY"
EOF

# 서비스 시작
systemctl enable ipsec
systemctl start ipsec

echo "IPSec VPN 설정이 완료되었습니다."

# WireGuard 설정 및 자동화
#!/bin/bash

# 서버 설정
cat > /etc/wireguard/wg0.conf << EOF
[Interface]
Address = 10.0.0.1/24
ListenPort = 51820
PrivateKey = $(wg genkey)
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.0.0.2/32
EOF

# 클라이언트 설정
cat > /etc/wireguard/client.conf << EOF
[Interface]
Address = 10.0.0.2/32
PrivateKey = $(wg genkey)
DNS = 8.8.8.8

[Peer]
PublicKey = SERVER_PUBLIC_KEY
Endpoint = SERVER_IP:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25
EOF

# 서비스 시작
systemctl enable wg-quick@wg0
systemctl start wg-quick@wg0

// Node.js를 이용한 VPN 연결 성능 모니터링
const { exec } = require('child_process');
const fs = require('fs');

class VPNMonitor {
    constructor() {
        this.metrics = {
            latency: [],
            throughput: [],
            packetLoss: []
        };
    }

    async measureLatency(target = '8.8.8.8') {
        return new Promise((resolve, reject) => {
            exec(`ping -c 4 ${target}`, (error, stdout, stderr) => {
                if (error) {
                    reject(error);
                    return;
                }
                
                const matches = stdout.match(/time=(\d+\.?\d*)/g);
                if (matches) {
                    const latencies = matches.map(m => parseFloat(m.split('=')[1]));
                    const avgLatency = latencies.reduce((a, b) => a + b) / latencies.length;
                    this.metrics.latency.push({
                        timestamp: new Date(),
                        value: avgLatency
                    });
                    resolve(avgLatency);
                } else {
                    reject(new Error('핑 결과 파싱 실패'));
                }
            });
        });
    }

    async measureThroughput(server = 'speedtest.net') {
        return new Promise((resolve, reject) => {
            exec('speedtest-cli --json', (error, stdout, stderr) => {
                if (error) {
                    reject(error);
                    return;
                }
                
                try {
                    const result = JSON.parse(stdout);
                    const throughput = {
                        download: result.download / 1000000, // Mbps
                        upload: result.upload / 1000000     // Mbps
                    };
                    
                    this.metrics.throughput.push({
                        timestamp: new Date(),
                        value: throughput
                    });
                    
                    resolve(throughput);
                } catch (e) {
                    reject(e);
                }
            });
        });
    }

    generateReport() {
        const report = {
            avgLatency: this.getAverageLatency(),
            avgThroughput: this.getAverageThroughput(),
            recommendedProtocol: this.getRecommendedProtocol()
        };
        
        fs.writeFileSync('vpn-performance-report.json', JSON.stringify(report, null, 2));
        return report;
    }

    getAverageLatency() {
        if (this.metrics.latency.length === 0) return 0;
        return this.metrics.latency.reduce((sum, m) => sum + m.value, 0) / this.metrics.latency.length;
    }

    getAverageThroughput() {
        if (this.metrics.throughput.length === 0) return { download: 0, upload: 0 };
        
        const totalDownload = this.metrics.throughput.reduce((sum, m) => sum + m.value.download, 0);
        const totalUpload = this.metrics.throughput.reduce((sum, m) => sum + m.value.upload, 0);
        
        return {
            download: totalDownload / this.metrics.throughput.length,
            upload: totalUpload / this.metrics.throughput.length
        };
    }

    getRecommendedProtocol() {
        const avgLatency = this.getAverageLatency();
        const avgThroughput = this.getAverageThroughput();
        
        if (avgLatency < 50 && avgThroughput.download > 100) {
            return 'WireGuard'; // 최고 성능
        } else if (avgLatency < 100) {
            return 'OpenVPN'; // 안정성과 성능의 균형
        } else {
            return 'IPSec'; // 보안 중시
        }
    }
}

// 사용 예제
const monitor = new VPNMonitor();

async function runPerformanceTest() {
    try {
        console.log('VPN 성능 테스트 시작...');
        
        const latency = await monitor.measureLatency();
        console.log(`평균 지연시간: ${latency.toFixed(2)}ms`);
        
        const throughput = await monitor.measureThroughput();
        console.log(`다운로드 속도: ${throughput.download.toFixed(2)} Mbps`);
        console.log(`업로드 속도: ${throughput.upload.toFixed(2)} Mbps`);
        
        const report = monitor.generateReport();
        console.log(`권장 프로토콜: ${report.recommendedProtocol}`);
        
    } catch (error) {
        console.error('성능 테스트 실패:', error);
    }
}

runPerformanceTest();

# VPN 네트워크 최적화 스크립트
import subprocess
import json
import time

class VPNOptimizer:
    def __init__(self):
        self.current_config = {}
        self.optimal_config = {}
    
    def optimize_tcp_settings(self):
        """TCP 설정 최적화"""
        tcp_optimizations = {
            'net.core.rmem_max': '16777216',
            'net.core.wmem_max': '16777216',
            'net.ipv4.tcp_rmem': '4096 87380 16777216',
            'net.ipv4.tcp_wmem': '4096 16384 16777216',
            'net.ipv4.tcp_congestion_control': 'bbr',
            'net.core.netdev_max_backlog': '5000',
            'net.ipv4.tcp_mtu_probing': '1'
        }
        
        for key, value in tcp_optimizations.items():
            cmd = f'sysctl -w {key}={value}'
            subprocess.run(cmd, shell=True)
            print(f"설정 적용: {key} = {value}")
    
    def optimize_vpn_mtu(self, interface='tun0'):
        """VPN MTU 최적화"""
        # MTU 탐지
        for mtu in range(1500, 1200, -50):
            cmd = f'ping -M do -s {mtu-28} -c 1 8.8.8.8'
            result = subprocess.run(cmd, shell=True, capture_output=True)
            if result.returncode == 0:
                # 최적 MTU 설정
                subprocess.run(f'ip link set dev {interface} mtu {mtu}', shell=True)
                print(f"최적 MTU 설정: {mtu}")
                return mtu
        
        print("MTU 최적화 실패")
        return None
    
    def setup_qos(self, interface='eth0'):
        """QoS 설정으로 VPN 트래픽 우선순위 조정"""
        qos_commands = [
            f'tc qdisc add dev {interface} root handle 1: htb default 30',
            f'tc class add dev {interface} parent 1: classid 1:1 htb rate 100mbit',
            f'tc class add dev {interface} parent 1:1 classid 1:10 htb rate 30mbit ceil 100mbit',
            f'tc class add dev {interface} parent 1:1 classid 1:20 htb rate 60mbit ceil 100mbit',
            f'tc class add dev {interface} parent 1:1 classid 1:30 htb rate 10mbit ceil 100mbit',
            
            # VPN 트래픽 우선순위 설정
            f'tc filter add dev {interface} protocol ip parent 1:0 prio 1 u32 match ip dport 1194 0xffff flowid 1:10',
            f'tc filter add dev {interface} protocol ip parent 1:0 prio 1 u32 match ip sport 1194 0xffff flowid 1:10'
        ]
        
        for cmd in qos_commands:
            subprocess.run(cmd, shell=True)
        
        print("QoS 설정 완료")
    
    def monitor_and_adjust(self):
        """실시간 모니터링 및 자동 조정"""
        while True:
            # 대역폭 사용량 체크
            bandwidth_usage = self.get_bandwidth_usage()
            
            if bandwidth_usage > 80:  # 80% 이상 사용 시
                self.adjust_compression()
                self.adjust_keepalive()
            
            time.sleep(30)  # 30초마다 체크
    
    def get_bandwidth_usage(self):
        """대역폭 사용량 조회"""
        cmd = "cat /proc/net/dev | grep tun0"
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        
        if result.returncode == 0:
            line = result.stdout.strip()
            fields = line.split()
            rx_bytes = int(fields[1])
            tx_bytes = int(fields[9])
            
            # 간단한 사용량 계산 (실제로는 더 복잡한 로직 필요)
            return min(100, (rx_bytes + tx_bytes) / 1000000)  # MB 단위
        
        return 0
    
    def adjust_compression(self):
        """압축 설정 조정"""
        print("높은 대역폭 사용량 감지 - 압축 설정 조정")
        # OpenVPN 설정 파일 수정
        with open('/etc/openvpn/server.conf', 'r') as f:
            config = f.read()
        
        if 'comp-lzo' not in config:
            config += '\ncomp-lzo\n'
            
        with open('/etc/openvpn/server.conf', 'w') as f:
            f.write(config)
    
    def adjust_keepalive(self):
        """keepalive 설정 조정"""
        print("keepalive 설정 최적화")
        # 네트워크 상태에 따라 keepalive 간격 조정

# 사용 예제
optimizer = VPNOptimizer()
optimizer.optimize_tcp_settings()
optimizer.optimize_vpn_mtu()
optimizer.setup_qos()

# PKI 인증서 자동 관리 스크립트
#!/bin/bash

# Easy-RSA를 이용한 PKI 구축
setup_pki() {
    echo "PKI 환경 설정 시작..."
    
    # Easy-RSA 초기화
    ./easyrsa init-pki
    
    # CA 인증서 생성
    ./easyrsa build-ca nopass
    
    # 서버 인증서 생성
    ./easyrsa gen-req server nopass
    ./easyrsa sign-req server server
    
    # DH 파라미터 생성
    ./easyrsa gen-dh
    
    # TLS 인증키 생성
    openvpn --genkey --secret ta.key
    
    echo "PKI 설정 완료"
}

# 클라이언트 인증서 생성
generate_client_cert() {
    CLIENT_NAME=$1
    
    if [ -z "$CLIENT_NAME" ]; then
        echo "사용법: generate_client_cert <client_name>"
        return 1
    fi
    
    echo "클라이언트 인증서 생성: $CLIENT_NAME"
    
    # 클라이언트 요청 생성
    ./easyrsa gen-req $CLIENT_NAME nopass
    
    # 클라이언트 인증서 서명
    ./easyrsa sign-req client $CLIENT_NAME
    
    # 클라이언트 설정 파일 생성
    create_client_config $CLIENT_NAME
    
    echo "클라이언트 인증서 생성 완료: $CLIENT_NAME"
}

# 클라이언트 설정 파일 생성
create_client_config() {
    CLIENT_NAME=$1
    
    cat > ${CLIENT_NAME}.ovpn << EOF
client
dev tun
proto udp
remote YOUR_SERVER_IP 1194
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
cipher AES-256-CBC
auth SHA256
key-direction 1
verb 3

<ca>
$(cat pki/ca.crt)
</ca>

<cert>
$(cat pki/issued/${CLIENT_NAME}.crt)
</cert>

<key>
$(cat pki/private/${CLIENT_NAME}.key)
</key>

<tls-auth>
$(cat ta.key)
</tls-auth>
EOF
}

# 인증서 만료 체크
check_cert_expiry() {
    CERT_FILE=$1
    DAYS_BEFORE_EXPIRY=30
    
    if [ -f "$CERT_FILE" ]; then
        EXPIRY_DATE=$(openssl x509 -enddate -noout -in "$CERT_FILE" | cut -d= -f2)
        EXPIRY_TIMESTAMP=$(date -d "$EXPIRY_DATE" +%s)
        CURRENT_TIMESTAMP=$(date +%s)
        DAYS_UNTIL_EXPIRY=$(( (EXPIRY_TIMESTAMP - CURRENT_TIMESTAMP) / 86400 ))
        
        if [ $DAYS_UNTIL_EXPIRY -lt $DAYS_BEFORE_EXPIRY ]; then
            echo "경고: 인증서 $CERT_FILE 이 $DAYS_UNTIL_EXPIRY 일 후 만료됩니다!"
            return 1
        else
            echo "인증서 $CERT_FILE 는 $DAYS_UNTIL_EXPIRY 일 후 만료됩니다."
            return 0
        fi
    else
        echo "오류: 인증서 파일 $CERT_FILE 을 찾을 수 없습니다."
        return 1
    fi
}

# 자동 인증서 갱신
auto_renew_certs() {
    echo "인증서 자동 갱신 시작..."
    
    for cert_file in pki/issued/*.crt; do
        if ! check_cert_expiry "$cert_file"; then
            client_name=$(basename "$cert_file" .crt)
            echo "인증서 갱신 중: $client_name"
            
            # 기존 인증서 백업
            cp "$cert_file" "${cert_file}.backup.$(date +%Y%m%d)"
            
            # 새 인증서 생성
            ./easyrsa revoke "$client_name"
            ./easyrsa gen-crl
            generate_client_cert "$client_name"
            
            echo "인증서 갱신 완료: $client_name"
        fi
    done
    
    echo "인증서 자동 갱신 완료"
}

# VPN 접근 제어 시스템
import ipaddress
import json
import sqlite3
from datetime import datetime, timedelta

class VPNAccessControl:
    def __init__(self, db_path='vpn_access.db'):
        self.db_path = db_path
        self.init_database()
    
    def init_database(self):
        """데이터베이스 초기화"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY,
                username TEXT UNIQUE NOT NULL,
                client_cert TEXT NOT NULL,
                allowed_ips TEXT,
                max_connections INTEGER DEFAULT 1,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                is_active BOOLEAN DEFAULT TRUE
            )
        ''')
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS access_logs (
                id INTEGER PRIMARY KEY,
                username TEXT NOT NULL,
                client_ip TEXT NOT NULL,
                action TEXT NOT NULL,
                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                details TEXT
            )
        ''')
        
        conn.commit()
        conn.close()
    
    def add_user(self, username, client_cert, allowed_ips=None, max_connections=1):
        """사용자 추가"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        try:
            cursor.execute(
                'INSERT INTO users (username, client_cert, allowed_ips, max_connections) VALUES (?, ?, ?, ?)',
                (username, client_cert, allowed_ips, max_connections)
            )
            conn.commit()
            return True
        except sqlite3.IntegrityError:
            return False
        finally:
            conn.close()
    
    def check_ip_access(self, username, client_ip):
        """IP 접근 권한 확인"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute(
            'SELECT allowed_ips FROM users WHERE username = ? AND is_active = TRUE',
            (username,)
        )
        result = cursor.fetchone()
        conn.close()
        
        if not result or not result[0]:
            return True  # 제한이 없으면 허용
        
        allowed_networks = result[0].split(',')
        client_ip_obj = ipaddress.ip_address(client_ip)
        
        for network in allowed_networks:
            if client_ip_obj in ipaddress.ip_network(network.strip()):
                return True
        
        return False
    
    def check_connection_limit(self, username):
        """동시 연결 제한 확인"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # 최대 연결 수 조회
        cursor.execute(
            'SELECT max_connections FROM users WHERE username = ?',
            (username,)
        )
        result = cursor.fetchone()
        
        if not result:
            conn.close()
            return False
        
        max_connections = result[0]
        
        # 현재 활성 연결 수 조회 (최근 5분 내)
        five_minutes_ago = datetime.now() - timedelta(minutes=5)
        cursor.execute(
            'SELECT COUNT(*) FROM access_logs WHERE username = ? AND action = "connect" AND timestamp > ?',
            (username, five_minutes_ago)
        )
        current_connections = cursor.fetchone()[0]
        
        conn.close()
        
        return current_connections < max_connections
    
    def log_access(self, username, client_ip, action, details=None):
        """접근 로그 기록"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute(
            'INSERT INTO access_logs (username, client_ip, action, details) VALUES (?, ?, ?, ?)',
            (username, client_ip, action, details)
        )
        conn.commit()
        conn.close()
    
    def get_user_activity(self, username, days=7):
        """사용자 활동 조회"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        since_date = datetime.now() - timedelta(days=days)
        cursor.execute(
            'SELECT * FROM access_logs WHERE username = ? AND timestamp > ? ORDER BY timestamp DESC',
            (username, since_date)
        )
        
        results = cursor.fetchall()
        conn.close()
        
        return results
    
    def generate_access_report(self):
        """접근 보고서 생성"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # 활성 사용자 수
        cursor.execute('SELECT COUNT(*) FROM users WHERE is_active = TRUE')
        active_users = cursor.fetchone()[0]
        
        # 최근 24시간 접근 수
        yesterday = datetime.now() - timedelta(days=1)
        cursor.execute(
            'SELECT COUNT(*) FROM access_logs WHERE timestamp > ? AND action = "connect"',
            (yesterday,)
        )
        recent_connections = cursor.fetchone()[0]
        
        # 상위 접근 IP
        cursor.execute('''
            SELECT client_ip, COUNT(*) as count 
            FROM access_logs 
            WHERE timestamp > ? 
            GROUP BY client_ip 
            ORDER BY count DESC 
            LIMIT 10
        ''', (yesterday,))
        top_ips = cursor.fetchall()
        
        conn.close()
        
        report = {
            'active_users': active_users,
            'recent_connections': recent_connections,
            'top_ips': top_ips,
            'generated_at': datetime.now().isoformat()
        }
        
        return report

# 사용 예제
access_control = VPNAccessControl()

# 사용자 추가
access_control.add_user(
    username='developer1',
    client_cert='dev1.crt',
    allowed_ips='192.168.1.0/24,10.0.0.0/8',
    max_connections=2
)

# 접근 권한 확인
if access_control.check_ip_access('developer1', '192.168.1.100'):
    if access_control.check_connection_limit('developer1'):
        access_control.log_access('developer1', '192.168.1.100', 'connect')
        print("접근 허용")
    else:
        print("연결 제한 초과")
else:
    print("IP 접근 거부")

# Docker Compose를 이용한 기업용 VPN 구축
version: '3.8'

services:
  openvpn:
    image: kylemanna/openvpn
    container_name: openvpn
    ports:
      - "1194:1194/udp"
    volumes:
      - ./openvpn-data:/etc/openvpn
    cap_add:
      - NET_ADMIN
    environment:
      - OVPN_SERVER_URL=udp://vpn.company.com:1194
      - OVPN_NETWORK=10.8.0.0
      - OVPN_SUBNET=255.255.255.0
    restart: unless-stopped

  vpn-monitor:
    image: nginx:alpine
    container_name: vpn-monitor
    ports:
      - "8080:80"
    volumes:
      - ./monitor:/usr/share/nginx/html
    depends_on:
      - openvpn
    restart: unless-stopped

  ldap-auth:
    image: openldap/openldap:latest
    container_name: ldap-auth
    environment:
      - LDAP_ORGANISATION=Company
      - LDAP_DOMAIN=company.com
      - LDAP_ADMIN_PASSWORD=admin_password
    volumes:
      - ./ldap-data:/var/lib/ldap
      - ./ldap-config:/etc/ldap/slapd.d
    restart: unless-stopped

  radius-server:
    image: freeradius/freeradius-server:latest
    container_name: radius-server
    ports:
      - "1812:1812/udp"
      - "1813:1813/udp"
    volumes:
      - ./radius-config:/etc/freeradius
    depends_on:
      - ldap-auth
    restart: unless-stopped

<!-- VPN 모니터링 대시보드 -->
<!DOCTYPE html>
<html>
<head>
    <title>VPN 모니터링 대시보드</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .dashboard { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
        .card { border: 1px solid #ddd; padding: 20px; border-radius: 8px; }
        .metric { font-size: 24px; font-weight: bold; color: #333; }
        .status-good { color: #28a745; }
        .status-warning { color: #ffc107; }
        .status-error { color: #dc3545; }
    </style>
</head>
<body>
    <h1>VPN 모니터링 대시보드</h1>
    
    <div class="dashboard">
        <div class="card">
            <h3>연결 상태</h3>
            <div class="metric" id="connectionStatus">확인 중...</div>
            <div>활성 연결: <span id="activeConnections">0</span></div>
        </div>
        
        <div class="card">
            <h3>서버 상태</h3>
            <div class="metric" id="serverStatus">확인 중...</div>
            <div>CPU 사용률: <span id="cpuUsage">0%</span></div>
            <div>메모리 사용률: <span id="memoryUsage">0%</span></div>
        </div>
        
        <div class="card">
            <h3>네트워크 트래픽</h3>
            <canvas id="trafficChart"></canvas>
        </div>
        
        <div class="card">
            <h3>최근 접속자</h3>
            <div id="recentUsers"></div>
        </div>
    </div>

    <script>
        // VPN 모니터링 JavaScript
        class VPNMonitor {
            constructor() {
                this.trafficChart = this.initTrafficChart();
                this.updateInterval = 5000; // 5초마다 업데이트
                this.startMonitoring();
            }
            
            initTrafficChart() {
                const ctx = document.getElementById('trafficChart').getContext('2d');
                return new Chart(ctx, {
                    type: 'line',
                    data: {
                        labels: [],
                        datasets: [{
                            label: '입력 트래픽 (MB/s)',
                            data: [],
                            borderColor: 'rgb(75, 192, 192)',
                            tension: 0.1
                        }, {
                            label: '출력 트래픽 (MB/s)',
                            data: [],
                            borderColor: 'rgb(255, 99, 132)',
                            tension: 0.1
                        }]
                    },
                    options: {
                        responsive: true,
                        scales: {
                            y: {
                                beginAtZero: true
                            }
                        }
                    }
                });
            }
            
            async fetchVPNStatus() {
                try {
                    const response = await fetch('/api/vpn/status');
                    const data = await response.json();
                    return data;
                } catch (error) {
                    console.error('VPN 상태 조회 실패:', error);
                    return null;
                }
            }
            
            updateUI(data) {
                if (!data) return;
                
                // 연결 상태 업데이트
                const connectionStatus = document.getElementById('connectionStatus');
                const activeConnections = document.getElementById('activeConnections');
                
                if (data.vpn_running) {
                    connectionStatus.textContent = '정상';
                    connectionStatus.className = 'metric status-good';
                } else {
                    connectionStatus.textContent = '중단';
                    connectionStatus.className = 'metric status-error';
                }
                
                activeConnections.textContent = data.active_connections || 0;
                
                // 서버 상태 업데이트
                const serverStatus = document.getElementById('serverStatus');
                const cpuUsage = document.getElementById('cpuUsage');
                const memoryUsage = document.getElementById('memoryUsage');
                
                serverStatus.textContent = data.server_healthy ? '정상' : '문제';
                serverStatus.className = `metric ${data.server_healthy ? 'status-good' : 'status-error'}`;
                
                cpuUsage.textContent = `${data.cpu_usage}%`;
                memoryUsage.textContent = `${data.memory_usage}%`;
                
                // 트래픽 차트 업데이트
                this.updateTrafficChart(data.traffic);
                
                // 최근 접속자 업데이트
                this.updateRecentUsers(data.recent_users);
            }
            
            updateTrafficChart(trafficData) {
                const now = new Date().toLocaleTimeString();
                
                this.trafficChart.data.labels.push(now);
                this.trafficChart.data.datasets[0].data.push(trafficData.inbound);
                this.trafficChart.data.datasets[1].data.push(trafficData.outbound);
                
                // 최근 20개 데이터만 유지
                if (this.trafficChart.data.labels.length > 20) {
                    this.trafficChart.data.labels.shift();
                    this.trafficChart.data.datasets[0].data.shift();
                    this.trafficChart.data.datasets[1].data.shift();
                }
                
                this.trafficChart.update();
            }
            
            updateRecentUsers(users) {
                const recentUsers = document.getElementById('recentUsers');
                recentUsers.innerHTML = '';
                
                users.forEach(user => {
                    const userDiv = document.createElement('div');
                    userDiv.innerHTML = `
                        <strong>${user.username}</strong><br>
                        IP: ${user.ip}<br>
                        연결 시간: ${user.connected_at}<br>
                        <hr>
                    `;
                    recentUsers.appendChild(userDiv);
                });
            }
            
            async startMonitoring() {
                while (true) {
                    const data = await this.fetchVPNStatus();
                    this.updateUI(data);
                    await new Promise(resolve => setTimeout(resolve, this.updateInterval));
                }
            }
        }
        
        // 대시보드 초기화
        document.addEventListener('DOMContentLoaded', () => {
            new VPNMonitor();
        });
    </script>
</body>
</html>