How codesparadox/dos-c works
Project type and purpose
• This is a network-attack tool suite written primarily in Python (with a small Node.js “browserd0s” sub-module). Its goal is to perform DoS/DDoS attacks via multiple methods: raw TCP floods, UDP floods, pps floods, and browser-driven attacks using Playwright and proxy lists. It exposes both “basic” single-script entry points (DoS_C.py, Converstion_v7_0.py) and an “advanced” orchestrator (DosRunner.py).
File structure
• Top-level Python modules:
• DoS_C.py – basic TCP/UDP/pps flood with Public class and thread pool.
• DosRunner.py – feature-rich CLI orchestrator launching multiple worker threads/connections.
• Converstion_v7_0.py – raw-socket-based TCP flood with manual IP/TCP header crafting.
• skills.py – shared utility functions (e.g., random payload generation, IP spoofing stubs).
• browserd0s/ – Node.js submodule for browser-based DDoS:
• index.js & playwright.js – spin up Playwright headless browsers and flood via HTTP.
• fixedtls, proxy.txt – configuration files for proxy lists or custom TLS handshake code.
• about.txt, install.txt, usage.txt, wget-log – documentation and logs.
• README.md at root & in browserd0s/ describe methods, usage, dependencies.
README for insights
• The attack methods live in three Python scripts, each taking target IP, port, duration, threads/connections.
• browserd0s uses Playwright for browser-side flooding, likely via repeated page loads.
• No external databases; state is ephemeral.
• Emphasis on threading, raw sockets, and potential IP/MAC spoofing in future.
Main components & interactions
• Attacker CLI Layer (User)
– Inputs: method, target IP/port, duration, threads, connections.
– Entry points: DoS_C.py, DosRunner.py, Converstion_v7_0.py, browserd0s/index.js
• Orchestration Layer
– DosRunner.py: parses CLI flags, configures thread pool & worker parameters.
– Public class in DoS_C.py: wraps individual attack functions.
• Attack Engine Modules
a. TCP Flood Engine (socket.connect loop – stream sockets)
b. UDP Flood Engine (DatagramSocket)
c. PPS Flood Engine (packet-per-second – small UDP bursts)
d. Raw-Socket Flood Engine (Converstion_v7_0.py – IP/TCP header crafting)
e. Browser-based Flood Engine (Node.js + Playwright – HTTP requests via headless browsers, optional proxies)
• Shared Utility Module
– skills.py: random data generation, timing, status checks (check_target_status).
• Thread / Worker Pool
– Each engine spawns N threads or headless browsers.
• File-based Config & Logs
– proxy.txt, fixedtls (TLS override), usage/install docs, wget-log.
• Network Layer / Target
– Attacks travel over raw sockets / TCP / UDP / HTTP to the Target IP:Port.
Relationships and data flow
• User → CLI Entry Point → Orchestrator → selects Attack Engine
• Orchestrator → spawns Worker Threads or Browser Instances
• Each Worker → uses Utility functions → sends packets/requests → onto the Internet
• Feedback: Optional check_target_status calls pre- and post-attack
• Logs: Workers write minimal status to stdout or wget-log
Architectural patterns & design principles
• Modular Engines: each flood method encapsulated in its own function/script.
• Orchestrator pattern: DosRunner.py centralizes thread and connection management.
• Thread pool concurrency for high throughput.
• Separation of concerns: utility functions in skills.py, config files in browserd0s folder.
• Future extensibility: planned IP/MAC spoofing modules can attach to skills.py or raw-socket engine.
Relevant technologies & libraries
• Python 3.6+ standard library: socket, threading, argparse.
• Raw sockets for manual packet crafting.
• Node.js + Playwright for browser-side floods.
• Plain text config files for proxies and TLS tweaks.
Essential architectural elements
• Don’t just list scripts—show grouping by function (CLI vs. engines vs. utils).
• Concurrency: illustrate thread pools or browser instances spawning.
• External dependencies: OS raw-socket privileges, Node runtime.