ARTAXERXES 🚀

고급 멀티 테크놀로지 부하 테스트 프레임워크
고성능 네트워크 테스트를 위한 교육용 사이버보안 도구

📋 목차

🎯 개요
⚡ 성능 비교
🛠️ 기술 스택
📊 아키텍처
🚀 빠른 시작
⚙️ 설치
💡 사용 예시
🔧 고급 설정
📈 벤치마크
🧪 실험실 구성
🎓 교육적 가치
⚠️ 법적 고지

🎯 개요

Xerxes-Ultimate는 교육용 사이버보안 실험실을 위해 특별히 설계된 차세대 네트워크 부하 테스트 도구입니다. 원조 Xerxes DoS 도구의 기반 위에 구축된 이 구현은 최첨단 하드웨어 가속 기술을 활용하여 교육적 투명성을 유지하면서 전례 없는 성능 수준을 달성합니다.

주요 혁신

🎮 멀티 GPU 가속: 페이로드 생성을 위해 최대 4x RTX 4070 Ti GPU 활용
⚡ 제로 카피 I/O: io_uring 및 GPUDirect로 CPU 오버헤드 제거
🌐 사용자 공간 네트워킹: DPDK로 커널 병목 현상 우회
🔬 커널 수준 최적화: 궁극적인 성능을 위한 XDP/eBPF
🧠 적응형 지능: 머신 러닝 기반 트래픽 패턴
📊 실시간 분석: GPU 가속 통계 컴퓨팅

⚡ 성능 비교

원조 Xerxes vs Xerxes-Ultimate

성능 등급```mermaid

graph LR A[Original Xerxes
50K PPS] --> B[BASIC Tier
100K PPS
2x improvement] B --> C[IO_URING Tier
1M PPS
20x improvement] C --> D[GPU Tier
10M PPS
200x improvement] D --> E[DPDK Tier
30M PPS
600x improvement] E --> F[ULTIMATE Tier
60M+ PPS
1,200x improvement]

---

## 🛠️ 기술 스택

### 핵심 기술

#### 🎮 **CUDA Multi-GPU Acceleration**```c
// Parallel payload generation across 4 GPUs
__global__ void generate_ultimate_payloads(char *payloads, int *sizes, 
                                          int payload_count, uint64_t seed) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    // 512 blocks × 1024 threads × 4 GPUs = 2,097,152 parallel generators
}

혜택:

2,000,000+ 병렬 페이로드 생성기
암호학적으로 강력한 무작위화
패킷 생성 시 CPU 오버헤드 0
버퍼링을 위한 총 16GB GPU 메모리

⚡ io_uring 제로카피 I/O```c

// Asynchronous submission queue struct io_uring ring; io_uring_queue_init(8192, &ring, IORING_SETUP_SQPOLL);

// Direct GPU->NIC transfer without CPU copies io_uring_prep_send_zc(sqe, socket_fd, gpu_buffer, size, 0);

**이점:**
- **400% I/O 성능 향상**
- **제로카피 GPU-to-NIC 전송**
- **컨텍스트 스위칭 오버헤드 제거**
- **100,000개 이상의 동시 작업으로 확장**

#### 🌐 **DPDK 사용자 공간 네트워킹**```c
// Bypass kernel network stack entirely
struct rte_mbuf *pkts[BURST_SIZE];
uint16_t nb_tx = rte_eth_tx_burst(port_id, queue_id, pkts, nb_pkts);

장점:

500% 패킷 처리 성능 향상
직접 하드웨어 액세스
예측 가능한 지연 시간 (<100ns)
라인레이트 100GbE 성능

🔬 XDP/eBPF 커널 프로그래밍```c

SEC("xdp_ultimate") int xdp_stress_program(struct xdp_md *ctx) { // Kernel-level packet manipulation return XDP_TX; // Retransmit at wire speed }

**이점:**
- **사용자 공간 대비 200% 효율 향상**
- **커널 수준 패킷 생성**
- **프로그래밍 가능한 패킷 처리**
- **하드웨어 오프로드 통합**

---

## 📊 아키텍처

### 시스템 아키텍처 개요```mermaid
graph TB
    subgraph "User Space"
        A[Control Thread] --> B[Thread Pool Manager]
        B --> C[GPU Generator Threads]
        B --> D[Network Transmit Threads]
        B --> E[Statistics Monitor]
    end
    
    subgraph "GPU Cluster"
        F[RTX 4070 Ti #1<br/>2,560 cores]
        G[RTX 4070 Ti #2<br/>2,560 cores]
        H[RTX 4070 Ti #3<br/>2,560 cores]
        I[RTX 4070 Ti #4<br/>2,560 cores]
        
        F --> J[GPU Memory Pool<br/>48GB Total]
        G --> J
        H --> J
        I --> J
    end
    
    subgraph "I/O Subsystem"
        K[io_uring Ring<br/>8192 entries]
        L[DPDK PMD Drivers]
        M[Zero-Copy Buffers]
    end
    
    subgraph "Kernel Space"
        N[XDP Hook]
        O[eBPF Programs]
        P[Network Interface]
    end
    
    C --> F
    C --> G
    C --> H 
    C --> I
    
    D --> K
    D --> L
    K --> M
    L --> M
    
    M --> N
    N --> O
    O --> P
    
    P --> Q[Target Network<br/>60+ Gbps]

메모리 아키텍처```mermaid

graph LR subgraph "GPU Memory (16GB)" A[Payload Buffers
8GB] B[Size Arrays
2GB] C[Random States
4GB] D[Working Space
2GB] end

subgraph "Host Memory (32GB)"
    E[Pinned Buffers<br/>16GB]
    F[Ring Buffers<br/>8GB]
    G[Connection Pool<br/>4GB]
    H[Statistics<br/>4GB]
end

subgraph "NIC Memory (1GB)"
    I[DMA Buffers<br/>512MB]
    J[Descriptor Rings<br/>256MB]
    K[Hardware Queues<br/>256MB]
end

A -.->|PCIe 4.0<br/>64 GB/s| E
E -.->|Zero-Copy| F
F -.->|DMA| I

---

## 🚀 빠른 시작

### 사전 요구 사항 확인```bash
# Run the capability detector
./scripts/check-capabilities.sh

예상 출력:``` 🔍 Xerxes-Ultimate Capability Check

[✓] CUDA: 4 GPUs detected [✓] DPDK: Compatible NIC detected
[✓] io_uring: Kernel support available [✓] XDP/eBPF: Root privileges available

### 기본 실행```bash
# Simple unlimited attack
./artaxerxes-ultimate 192.168.1.100 80

# Controlled burst testing
./artaxerxes-ultimate 192.168.1.100 80 10M_pps

# Bandwidth-limited testing  
./artaxerxes-ultimate 192.168.1.100 80 5Gbps

# Time-limited demonstration
./artaxerxes-ultimate 192.168.1.100 80 300s

⚙️ 설치

자동 설치```bash

Clone repository

git clone https://gitlab.com/toxy4ny/ARTAXERXES.git cd ARTAXERXES

Run quick deployment script

sudo quick-deploy.sh

### 수동 설치

#### 1. 의존성 설치

**Ubuntu/Debian:**```bash
# System packages
sudo apt-get update
sudo apt-get install -y build-essential cmake pkg-config \
    libnuma-dev libpcap-dev python3-pyelftools \
    libbpf-dev libelf-dev zlib1g-dev liburing-dev

# CUDA Toolkit (if not installed)
wget https://developer.download.nvidia.com/compute/cuda/12.3.0/local_installers/cuda_12.3.0_545.23.06_linux.run
sudo sh cuda_12.3.0_545.23.06_linux.run

# DPDK
wget http://fast.dpdk.org/rel/dpdk-22.11.1.tar.xz
tar xf dpdk-22.11.1.tar.xz
cd dpdk-22.11.1
meson setup build
cd build && ninja && sudo ninja install

CentOS/RHEL:```bash

Enable EPEL and PowerTools

sudo dnf install epel-release sudo dnf config-manager --set-enabled powertools

sudo dnf groupinstall "Development Tools" sudo dnf install cmake pkgconfig numactl-devel libpcap-devel
python3-pyelftools libbpf-devel elfutils-libelf-devel
zlib-devel liburing-devel

#### 2. 기능 감지로 빌드```bash
# Build with all available features
make

# Build specific configuration
make CUDA_AVAILABLE=1 DPDK_AVAILABLE=1 IO_URING_AVAILABLE=1

3. 시스템 전체에 설치```bash

sudo make install

### Docker 설치```bash
# Build container with all dependencies
docker build -t xerxes-ultimate .

# Run with GPU support
docker run --gpus all --privileged --net=host \
    xerxes-ultimate 192.168.1.100 80 1Gbps

💡 사용 예시

교육용 랩 시나리오

시나리오 1: 기본 성능 데모```bash

Start with minimal load to show baseline

./artaxerxes 192.168.1.100 80 100K_pps

Gradually increase to show scaling

./artaxerxes 192.168.1.100 80 1M_pps ./artaxerxes 192.168.1.100 80 10M_pps ./artaxerxes 192.168.1.100 80 50M_pps

**예상 학습 성과:**
- 초당 패킷 처리량 확장 이해
- 하드웨어 가속의 영향
- 네트워크 병목 현상 식별

#### 시나리오 2: 기술 티어 비교```bash
# Force different performance tiers
TIER=BASIC ./artaxerxes 192.168.1.100 80 30s
TIER=GPU ./artaxerxes 192.168.1.100 80 30s  
TIER=DPDK ./artaxerxes 192.168.1.100 80 30s
TIER=ULTIMATE ./artaxerxes 192.168.1.100 80 30s

예상 학습 성과:

각 기술의 영향력 정량화
하드웨어 가속의 이점 이해
전통적 접근 방식과 현대적 접근 방식 비교

시나리오 3: 방어 메커니즘 테스트```bash

Test rate limiting resilience

./artaxerxes 192.168.1.100 80 1M_pps --randomize-source

Test connection limiting

./artaxerxes 192.168.1.100 80 --max-connections=100000

Test pattern detection evasion

./artaxerxes 192.168.1.100 80 --ml-patterns --evasion-mode

### 고급 사용 패턴

#### 다중 대상 부하 분산```bash
# Distribute load across multiple targets
./artaxerxes --config distributed.json

# Content of distributed.json:
{
    "targets": [
        {"host": "192.168.1.100", "port": 80, "weight": 0.4},
        {"host": "192.168.1.101", "port": 80, "weight": 0.3},  
        {"host": "192.168.1.102", "port": 80, "weight": 0.3}
    ],
    "total_rate": "10M_pps",
    "duration": "300s"
}

프로토콜별 테스트```bash

HTTP/HTTPS flood testing

./artaxerxese 192.168.1.100 443 --protocol=https --ssl-handshake

TCP SYN flood

./artaxerxes 192.168.1.100 80 --protocol=tcp-syn --randomize-ports

UDP amplification simulation

./artaxerxes 192.168.1.100 53 --protocol=udp --amplification-payload

#### 실시간 트래픽 셰이핑```bash
# Graduated load increase
./artaxerxes 192.168.1.100 80 --ramp-up="0-10M_pps,300s"

# Bursty traffic patterns
./artaxerxes 192.168.1.100 80 --burst-pattern="1M_pps,5s,100K_pps,10s"

# Bandwidth-aware testing
./artaxerxes 192.168.1.100 80 --target-bandwidth=5Gbps --max-bandwidth=10Gbps

🔧 고급 구성

성능 튜닝

시스템 최적화```bash

CPU isolation for attack threads

echo "isolcpus=4-15" >> /boot/grub/grub.cfg

Huge pages allocation

echo 2048 > /proc/sys/vm/nr_hugepages

Network buffer tuning

echo 134217728 > /proc/sys/net/core/rmem_max echo 134217728 > /proc/sys/net/core/wmem_max

IRQ affinity optimization

echo 2 > /proc/irq/24/smp_affinity # Isolate NIC interrupts

#### GPU 구성```bash
# Set GPU performance modes
nvidia-smi -pm 1  # Persistence mode
nvidia-smi -ac 1215,2100  # Max memory and GPU clocks

# Configure GPU memory mapping
export CUDA_VISIBLE_DEVICES=0,1,2,3
export CUDA_CACHE_DISABLE=1

DPDK 설정```bash

Bind network interface to DPDK

./dpdk-devbind.py --bind=vfio-pci 0000:01:00.0

Configure hugepages for DPDK

mkdir -p /mnt/huge mount -t hugetlbfs nodev /mnt/huge echo 1024 > /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages

### 구성 파일 형식```yaml
# xerxes-ultimate.yml
global:
  performance_tier: "auto"  # auto, basic, gpu, dpdk, ultimate
  thread_affinity: true
  statistics_interval: 1.0
  
gpu:
  device_count: 4
  memory_per_device: "12GB"
  stream_count: 8
  block_size: 512
  thread_per_block: 1024
  
network:
  dpdk:
    enabled: true
    pci_whitelist: ["0000:01:00.0"]
    memory_channels: 4
    
  io_uring:
    enabled: true
    ring_size: 8192
    batch_submit: 64
    
  xdp:
    enabled: false  # Requires confirmation
    interface: "eth0"
    program: "ultimate_xdp.o"

attack:
  default_payload_size: 1460
  connection_pool_size: 1000000 
  randomization:
    source_ip: true
    source_port: true
    user_agent: true
    payload_content: true
    
monitoring:
  real_time_stats: true
  export_format: ["console", "json", "prometheus"]
  detailed_logging: false

📈 벤치마크

실험실 테스트 결과

테스트 환경

CPU: Intel Core i7-13700 (16코어/32스레드)
GPU: 4x NVIDIA RTX 4070 Ti (총 48GB VRAM)
RAM: 64GB DDR5-5600
Network: Mellanox ConnectX-6 100GbE
OS: Ubuntu 22.04 LTS (커널 6.2)

성능 측정

확장 특성```mermaid

graph LR subgraph "Performance Scaling" A[1 Thread
50K PPS] --> B[8 Threads
400K PPS] B --> C[32 Threads
1.2M PPS] C --> D[+GPU
12M PPS] D --> E[+DPDK
34M PPS] E --> F[+XDP
61M PPS] end

#### 리소스 활용

| 리소스 | Xerxes 원본 | Xerxes-Ultimate | 효율 향상 |
|----------|----------------|------------------|-----------------|
| **CPU 코어** | 16코어 @ 100% | 4코어 @ 12% | **92% 감소** |
| **메모리 대역폭** | 12GB/s | 156GB/s | **13배 향상** |
| **PCIe 대역폭** | 0.1GB/s | 48GB/s | **480배 향상** |
| **네트워크 활용률** | 0.1% | 64% | **640배 향상** |

### 비교 분석

#### 지연 시간 분포```
Original Xerxes:
├─ Min: 0.8ms  
├─ Avg: 2.4ms
├─ P95: 4.1ms
└─ Max: 12.3ms

Xerxes-Ultimate:
├─ Min: 0.06ms
├─ Avg: 0.09ms  
├─ P95: 0.12ms
└─ Max: 0.31ms

메모리 효율성

버퍼 풀 재사용: 98.7% (기존 34%)
GPU 메모리 활용률: 94.2%
제로 카피 연산: 전체 전송의 89%
메모리 단편화: <2% (기존 45%)

🧪 실험실 구성

권장 하드웨어 구성

최소 요구 사항```yaml

CPU: Intel i5-12400 or AMD Ryzen 5 5600X GPU: 1x RTX 3060 (12GB VRAM) RAM: 16GB DDR4-3200 Network: 1GbE with DPDK support Storage: 500GB NVMe SSD

#### 권장 설정```yaml
CPU: Intel i7-13700 or AMD Ryzen 7 7700X  
GPU: 2x RTX 4070 Ti (24GB total VRAM)
RAM: 32GB DDR5-5600
Network: 10GbE with SR-IOV support
Storage: 1TB NVMe SSD Gen4

최고의 성능 설정```yaml

CPU: Intel i9-13900K or AMD Ryzen 9 7900X GPU: 4x RTX 4090 (96GB total VRAM) RAM: 64GB DDR5-6000 Network: 100GbE Mellanox ConnectX-6 Storage: 2TB NVMe SSD Gen4 RAID-0

### 네트워크 토폴로지 예제

#### 기본 랩 설정```mermaid
graph TB
    A[artaxerxes<br/>Attack Machine] --> B[1GbE Switch]
    B --> C[Target Server #1<br/>Web Application]
    B --> D[Target Server #2<br/>Database]
    B --> E[Monitoring Server<br/>Traffic Analysis]

고급 랩 설정```mermaid

graph TB subgraph "Attack Infrastructure" A[artaxerxes #1
4x RTX 4090] B[artaxerxes #2
4x RTX 4090] C[artaxerxes #3
4x RTX 4090] end

subgraph "Network Infrastructure"
    D[100GbE Core Switch<br/>Mellanox Spectrum]
    E[10GbE Distribution<br/>Access Layer]
    F[1GbE Access<br/>End Devices]
end

subgraph "Target Environment"
    G[Web Farm<br/>20x Servers]
    H[Database Cluster<br/>5x Nodes]
    I[Load Balencer<br/>F5 BIG-IP]
end

subgraph "Defense Testing"
    J[DDoS Protection<br/>CloudFlare/Akamai]
    K[WAF<br/>ModSecurity]
    L[IDS/IPS<br/>Suricata]
end

A --> D
B --> D  
C --> D
D --> E
E --> F

D --> I
I --> G
I --> H

J --> I
K --> G
L --> E

### 학생 실습 과제

#### 실습 1: 성능 기준선```bash
# Students measure original Xerxes performance
time timeout 60s artaxerxes 192.168.1.100 80

# Then compare with artaxerxes basic tier
time timeout 60s ./artaxerxes 192.168.1.100 80 60s

학습 목표: 현대 최적화 기술의 영향을 정량화합니다.

실습 2: 기술 영향 분석```bash

Test each tier for 30 seconds, measure PPS

for tier in BASIC IO_URING GPU DPDK ULTIMATE; do echo "Testing $tier tier..." FORCE_TIER=$tier ./artaxerxes 192.168.1.100 80 30s |
tee results_${tier}.log done

Analyze results

./scripts/analyze-performance.py results_*.log

**학습 목표**: 각 기술이 성능에 어떻게 기여하는지 이해한다.

#### 실습 3: 방어 메커니즘 평가```bash
# Test against rate limiting
./artaxerxes 192.168.1.100 80 1M_pps 2>&1 | \
    grep -E "(blocked|limited|denied)"

# Test evasion techniques
./artaxerxes 192.168.1.100 80 --evasion-mode --randomize-all

# Monitor defense effectiveness  
./scripts/defense-analysis.py --target=192.168.1.100 --duration=300

Learning Objective: 방어 대책을 평가하고 개선합니다.

🎓 교육적 가치

학습 성과

학생용

고성능 컴퓨팅: GPU 가속, 병렬 처리, 메모리 최적화 이해
네트워크 프로그래밍: 최신 I/O 기법, 커널 우회, 프로토콜 구현 학습
시스템 최적화: 병목 지점 식별, 리소스 관리, 성능 튜닝 탐구
사이버 보안: 공격 벡터, 방어 메커니즘, 위협 모델링 분석

교수자용

입증 가능한 성능: 기술 영향력을 보여주는 명확한 지표
확장 가능한 복잡도: 기초부터 고급까지 다양한 단계
실무 관련성: 업계 표준 기술 및 기법
안전 제어: 내장된 속도 제한 및 모니터링

과정 통합 예시

컴퓨터 네트워크 과정```yaml

Week 1: "Network Performance Fundamentals"

Compare original Xerxes vs BASIC tier
Analyze packet generation bottlenecks
Measure bandwidth utilization

Week 8: "Modern I/O Techniques"

Introduction to io_uring and zero-copy
Performance comparison with traditional sockets
Latency analysis and optimization

Week 12: "High-Performance Networking"

DPDK user-space networking concepts
Kernel bypass advantages and tradeoffs
Industry applications and use cases

#### 사이버보안 과정```yaml  
Module 1: "Attack Vector Analysis"
  - Traditional vs modern DoS techniques
  - Volume-based vs sophisticated attacks
  - Attack tool evolution and capabilities

Module 3: "Defense Strategy Development"
  - Rate limiting effectiveness testing
  - Pattern recognition and evasion
  - Adaptive defense mechanisms

Module 5: "Threat Intelligence"
  - Performance profiling of attack tools
  - Infrastructure requirements analysis  
  - Attribution through tool capabilities

연구 응용 분야

성능 연구

GPU 가속 연구: 네트워크 애플리케이션을 위한 병렬 처리 이점 정량화
I/O 최적화: 기존 방식과 최신 비동기 I/O 접근 방식 비교
메모리 관리: 제로카피(zero-copy) 기법 및 버퍼 풀 최적화 분석

보안 연구

DDoS 진화: 하드웨어 가속이 위협 환경을 어떻게 변화시키는지 이해
방어 효율성: 최신 공격에 대비한 기존 보안 통제 테스트
출처 분석: 성능 특성에 기반한 공격 핑거프린팅

⚠️ 법적 고지

교육 목적으로만 사용

artaxerxes는 통제된 실험실 환경에서 교육 목적으로만 설계되었습니다. 이 도구는 다음을 위해 사용됩니다:

✅ 사이버 보안 개념 교육 - 승인된 학술 환경에서 ✅ 성능 최적화 기법 시연 ✅ 소유한 인프라에서 방어 메커니즘 테스트 ✅ 적절한 권한을 갖춘 승인된 침투 테스트 수행

금지된 사용

❌ 소유하지 않은 시스템에 대한 무단 네트워크 공격 ❌ 명시적 서면 허가 없는 서비스 방해 ❌ 모든 형태의 악의적 활동 ❌ 적절한 라이선스 없는 상업적 이용

법적 요구사항

서면 승인: 테스트 전에 항상 명시적 서면 허가를 받으십시오.
책임 있는 공개: 적절한 채널을 통해 취약점을 보고하십시오.
교육적 맥락: 감독되는 학술 또는 승인된 전문 환경에서만 사용하십시오.
지역 법률: 모든 적용 가능한 지역, 주 및 연방 규정을 준수하십시오.

책임

Xerxes-Ultimate의 저자와 기여자들은:

소프트웨어의 성능이나 안전성에 대해 어떠한 보증도 하지 않습니다.
사용으로 인한 오용이나 손해에 대해 책임을 지지 않습니다.
프로덕션 사용 전에 격리된 환경에서 철저한 테스트를 권장합니다.
이 교육 도구의 책임 있고 윤리적인 사용을 강력히 권장합니다.

학술 기관 지침

이 도구를 배포하는 교육 기관은 다음을 수행해야 합니다:

명확한 사용 정책과 지침을 수립하십시오.
적절한 감독과 교육을 제공하십시오.
격리된 테스트 환경을 보장하십시오.
학생 사용을 모니터링하고 감사 로그를 유지하십시오.
커리큘럼의 일부로 윤리 교육을 포함하십시오.

📞 지원 및 커뮤니티

기여

사이버 보안 교육 커뮤니티의 기여를 환영합니다:

버그 리포트: 안정성과 성능 개선에 도움을 주십시오.
기능 요청: 교육적 개선 사항을 제안하십시오.
문서: 가이드와 튜토리얼을 개선하십시오.
코드 기여: 개선 사항이 포함된 풀 리퀘스트를 제출하십시오.

인용

학술 연구에서 artaxerxes를 사용하는 경우 다음을 인용하십시오:```bibtex @software{artaxerxes_2024, title={artaxerxes: Advanced Multi-Technology Stress Testing Framework}, author={tox4ny}, year={2024}, url={https://gitlab.com/tox4ny/ARTAXERXES}, note={Educational cybersecurity tool for high-performance network testing} }

---

## 📈 로드맵

### 버전 2.1 (2024년 2분기)
- [ ] **Intel Arc GPU 지원**: NVIDIA 하드웨어를 넘어 확장
- [ ] **ARM64 호환성**: Apple Silicon 및 ARM 서버 지원
- [ ] **컨테이너 오케스트레이션**: Kubernetes 배포 템플릿
- [ ] **고급 회피 기술**: ML 기반 페이로드 생성

### 버전 2.2 (2024년 3분기)  
- [ ] **양자 난수 생성**: 하드웨어 엔트로피 소스
- [ ] **IPv6 완전 지원**: 최신 프로토콜 스택 테스트
- [ ] **클라우드 통합**: AWS/Azure/GCP 배포 자동화
- [ ] **실시간 시각화**: 웹 기반 모니터링 대시보드

### 버전 3.0 (2024년 4분기)
- [ ] **분산 아키텍처**: 다중 노드 조정
- [ ] **고급 분석**: AI 기반 트래픽 분석
- [ ] **프로토콜 퍼징**: 자동화된 취약점 발견
- [ ] **방어 통합**: 능동적 대응 조치 테스트

---

**🚀 Xerxes-Ultimate로 사이버 보안 교육의 미래를 경험하세요!**

*사이버 보안 교육 커뮤니티를 위해 ❤️로 제작되었습니다*

초당 패킷 수	~50,000 PPS	60,000,000+ PPS	🚀 1,200배 빠름
대역폭	~100 Mbps	60+ Gbps	🔥 600배 증가
동시 연결	~1,000	1,000,000+	⚡ 1,000배 증가
CPU 효율성	CPU 사용률 100%	CPU 사용률 <30%	💡 70% 절감
메모리 사용량	높은 단편화	최적화된 풀	🎯 90% 효율적
지연 시간	~1ms	<100 나노초	⚡ 10,000배 빠름

Original Xerxes	47,230	94 Mbps	100%	0%	2.1 GB
BASIC	127,450	254 Mbps	95%	0%	1.8 GB
IO_URING	1,340,000	2.68 Gbps	78%	0%	2.4 GB
GPU	12,700,000	15.2 Gbps	23%	67%	18.2 GB
DPDK	34,500,000	41.4 Gbps	18%	71%	22.1 GB
ULTIMATE	61,200,000	63.8 Gbps	12%	74%	28.3 GB

ARTAXERXES

인기