Miku Miku Beam 💥⚡ (Network Stresser)

A fun and visually appealing stress testing server with a Miku-themed frontend, where you can configure and run attacks while enjoying a banger song in the background! 🎤✨

Features 🎉

• 🐳 Docker Ready: MMB is ready to be built and run in a Docker container.
• 🌐 Real-time Attack Visualization: View your attack's progress and statistics in real-time as it runs. 🔥
• 🎶 Miku-themed UI: A cute and vibrant design with Miku's vibe to make the process more fun. Includes a banger song to keep you pumped! 🎧
• 🧑‍💻 Configurable Attack Parameters: Easily set the attack method, packet size, duration, and packet delay via the frontend interface.
• 🛠️ Multi-threaded Attack Handling: The server processes attacks using multiple goroutines for optimal performance and scalability.
• 📊 Live Stats: Track the success and failure of each attack in real-time. See how many packets are sent and whether they succeed or fail.
• 🖼️ Aesthetic Design: A visually cute interface to make your experience enjoyable. 🌸
• 📡 Attack Methods::
  • HTTP Flood - Send random HTTP requests
  • HTTP Bypass - Send HTTP requests that mimics real requests (Redirects, cookies, headers, resources...)
  • HTTP Slowloris - Send slow HTTP requests and keep the connection open
  • Minecraft Ping - Send Minecraft ping/motd requests
  • TCP Flood - Send random TCP packets
• 🚀 CLI Support: Run attacks from the command line with colored output and real-time stats
• 🔄 Multi-client Support: Multiple web clients can run attacks simultaneously
• 🎯 Per-client Attack Management: Each client has its own isolated attack instance

Project Structure 🏗️

The project is divided into four main components:

📱 CLI (cmd/mmb-cli/)

Command-line interface for running attacks from terminal:

• Colored output with real-time statistics
• --verbose flag for detailed attack logs
• --no-proxy flag to run without proxies
• --threads flag to control concurrency

⚙️ Core (internal/)

The engine and attack implementations:

• engine/ - Attack coordination and management
• attacks/ - Individual attack method implementations
  • http/ - HTTP-based attacks (flood, bypass, slowloris)
  • tcp/ - TCP-based attacks (flood)
  • game/ - Game-specific attacks (minecraft ping)
• config/ - Configuration management
• proxy/ - Proxy loading and filtering
• netutil/ - Network utilities (HTTP/TCP clients with proxy support)

🌐 Server (cmd/mmb-server/)

Web server with Socket.IO support:

• REST API endpoints (/attacks, /configuration)
• Real-time communication via Socket.IO
• Static file serving for web client
• Multi-client attack management

🎨 Web Client (web-client/)

React-based frontend:

• Modern UI with Miku theme
• Real-time attack visualization
• Socket.IO integration for live updates
• Configuration management interface

Quick Start 🚀

# 1. Clone and setup
git clone https://github.com/sammwyy/mikumikubeam.git
cd mikumikubeam

# 2. Install dependencies
make prepare

# 3. Create required files
echo "http://proxy1:8080" > data/proxies.txt
echo "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" > data/uas.txt

# 4. Build and run
make all && make run-server

# 5. Open http://localhost:3000 in your browser

Setup 🛠️

Prerequisites 📦

Make sure you have the following installed:

• Go (v1.21 or above) 🐹
• Node.js (v18 or above) 🌱
• npm (Node Package Manager) 📦

Development Mode 🔧

1. Clone this repository:

   git clone https://github.com/sammwyy/mikumikubeam.git
   cd mikumikubeam
   

2. Install dependencies:

   make prepare
   

3. Create the necessary files:

   • data/proxies.txt - List of proxies (one per line).
   • data/uas.txt - List of user agents (one per line).

4. Build everything (web client + binaries):

   make all
   

5. Run the server:

   make run-server
   

   • The web interface runs on http://localhost:3000.
   • The API runs on http://localhost:3000/api.

---

Production Mode 💥

1. Clone the repository and navigate to the project directory:

   git clone https://github.com/sammwyy/mikumikubeam.git
   cd mikumikubeam
   

2. Install dependencies:

   make prepare
   

3. Build everything:

   make all
   

4. Start the server in production mode:

   ./bin/mmb-server
   

   In production mode, both the frontend and backend are served on the same port (http://localhost:3000).

Don't forget to add the necessary files data/proxies.txt and data/uas.txt.

Usage ⚙️

Web Interface 🌐

Once the server is up and running, you can interact with it via the web interface:

1. Start Attack:

   • Set up the attack parameters: target URL, attack method (HTTP Flood, Slowloris, TCP, etc...), packet size, duration, and delay.
   • Press "Start Attack" to initiate the stress test.

2. Stop Attack:

   • Press "Stop Attack" to terminate the ongoing attack.

3. Multiple Clients:

   • Open multiple browser tabs/windows to run different attacks simultaneously
   • Each client maintains its own attack instance

CLI Interface 💻

Run attacks directly from the command line:

# Basic attack
./bin/mmb-cli attack http_flood http://example.com

# With custom parameters
./bin/mmb-cli attack http_bypass http://example.com --duration 120 --delay 100 --packet-size 1024 --threads 8

# Verbose mode (shows detailed logs)
./bin/mmb-cli attack tcp_flood http://example.com --verbose

# Without proxies
./bin/mmb-cli attack minecraft_ping minecraft.example.com:25565 --no-proxy

Example Request

{
  "target": "http://example.com",
  "attackMethod": "http_flood",
  "packetSize": 512,
  "duration": 60,
  "packetDelay": 500,
  "threads": 4
}

Adding Proxies and User-Agents

Access to the data/proxies.txt and data/uas.txt can now be done fully in the web interface. Click the text button to the right of the beam button to open up the editor.

Multi-threaded Attack Handling 🔧💡

Each attack runs in multiple goroutines (threads), ensuring optimal performance and scalability. The attack workers are dynamically loaded based on the selected attack method (HTTP, TCP, etc...).

Attack Methods Implementation:

• HTTP Flood: Random GET/POST requests with configurable payloads
• HTTP Bypass: Browser-mimicking requests with realistic headers and cookies
• HTTP Slowloris: Slow HTTP requests that keep connections open
• TCP Flood: Raw TCP packet flooding with random data
• Minecraft Ping: Minecraft server status requests

Makefile Commands 🛠️

make prepare      # Install all dependencies (go mod tidy + npm install)
make all          # Build everything (web client + CLI + server)
make webclient    # Build React frontend only
make cli          # Build CLI binary only
make server       # Build server binary only
make run-cli      # Run CLI with example attack
make run-server   # Run web server
make clean        # Clean build artifacts

Quick Start Commands:

# Complete setup (recommended)
make prepare && make all && make run-server

# Or step by step
make prepare      # Install dependencies
make webclient    # Build frontend
make cli          # Build CLI
make server       # Build server
make run-server   # Start server

To-Do 📝

• Add more attack methods:

  • UDP 🌐
  • DNS 📡
  • And more! 🔥

• Enhance attack statistics and reporting for better real-time monitoring. 📊

Contributing 💖

Feel free to fork the repo and open pull requests with new attack protocols, bug fixes, or improvements. If you have an idea for a new feature, please share it! 😄

Adding New Attack Methods ⚡

To extend the server with new attack methods, you can create new worker files and add them to the attack registry.

For example:

1. Create a new attack worker in internal/attacks/your_protocol/:

package yourprotocol

import (
    "context"
    core "github.com/sammwyy/mikumikubeam/internal/engine"
)

type yourWorker struct{}

func NewYourWorker() *yourWorker { return &yourWorker{} }

func (w *yourWorker) Fire(ctx context.Context, params core.AttackParams, p core.Proxy, ua string, logCh chan<- core.AttackStats) error {
    // Your attack implementation here
    core.SendAttackLogIfVerbose(logCh, p, params.Target, params.Verbose)
    return nil
}

2. Register the attack in internal/engine/registry.go:

func NewRegistry() Registry {
    return &registry{
        workers: map[AttackKind]AttackWorker{
            AttackHTTPFlood:     http.NewFloodWorker(),
            AttackHTTPBypass:    http.NewBypassWorker(),
            AttackHTTPSlowloris: http.NewSlowlorisWorker(),
            AttackTCPFlood:      tcp.NewFloodWorker(),
            AttackMinecraftPing: game.NewPingWorker(),
            AttackYourProtocol:  yourprotocol.NewYourWorker(), // Add your attack
        },
    }
}

3. Add the attack method to the web client's attack list.

---

FAQs ❓

1. What operating system does MMB support?

Windows, Linux, Mac and Android (untested)

2. It crashes on startup, giving a "concurrently" error

This is a Node.js/React issue. Make sure you have Node.js v18+ installed and run npm install in the web-client directory.

3. I go to "http://localhost:3000" and nothing appears.

Make sure you've built the web client with make build-webclient and the server is running with ./bin/mmb-server.

4. Requests fail to be sent to the target server (Read timeout and variations)

You must put the corresponding proxies in the file data/proxies.txt. On each line, put a different proxy that will be used to perform the attack. The