aha-misc 0.0.2

Aha's Mischief Maker
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
86
87
88
89
90
91
92
93
94

//! Some options

use std::path::PathBuf;

use clap::Args;

/// Network protocol types supported by the client.
#[derive(Debug, Clone, Copy)]
pub enum Protocol {
    /// TCP protocol
    Tcp,
    /// UDP protocol
    Udp,
}

/// Options for configuring network client fuzzing.
///
/// This struct defines parameters needed for fuzzing network clients,
/// including protocol type, host, port, and timing configurations.
#[derive(Args, Debug)]
pub struct NetworkClientOptions {
    /// Network protocol (tcp/udp)
    #[arg(long, default_value = "tcp")]
    pub protocol: String,

    /// Target host
    #[arg(long, default_value = "127.0.0.1")]
    pub host: String,

    /// Target port
    #[arg(long, default_value = "13337")]
    pub port: u16,

    /// Sleep time in microseconds
    #[arg(long, default_value = "100000")]
    pub sleep: u64,

    /// Restart try time if connection fails
    #[arg(long, default_value = "10")]
    pub try_time: u64,
}

impl NetworkClientOptions {
    /// Get the protocol enum from the string configuration.
    ///
    /// # Returns
    /// A `Protocol` enum value corresponding to the configured protocol string.
    ///
    /// # Panics
    /// Panics if an invalid protocol is specified.
    pub fn protocol(&self) -> Protocol {
        match self.protocol.as_str() {
            "tcp" => Protocol::Tcp,
            "udp" => Protocol::Udp,
            _ => panic!("Invalid protocol specified"),
        }
    }

    /// Get target address as a string.
    pub fn address(&self) -> String {
        format!("{}:{}", self.host, self.port)
    }
}

/// SSL configuration options.
///
/// This struct defines the parameters needed for SSL connections,
/// including certificate and key file paths.
#[derive(Args, Debug)]
pub struct SSLOptions {
    /// SSL cert file
    #[arg(long = "cert-file")]
    pub cert_file: Option<PathBuf>,

    /// SSL key file
    #[arg(long = "key-file")]
    pub key_file: Option<PathBuf>,
}

impl SSLOptions {
    /// 
    pub fn cert_file(&self) -> Option<String> {
        self.cert_file
            .clone()
            .map(|p| p.to_str().unwrap().to_string())
    }

    /// 
    pub fn key_file(&self) -> Option<String> {
        self.key_file
            .clone()
            .map(|p| p.to_str().unwrap().to_string())
    }
}