tyr 0.1.2

A high-performance, cross-platform and all-protocol network combat attack payload and policy library
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use std::{net::Ipv4Addr, os::unix::process::ExitStatusExt};

use pnet::datalink;

use crate::error;

/// Generates a random port number within the range of 1024 to 65535.
///
/// # Returns
///
/// A `u16` representing a random port number.
pub fn get_random_port() -> u16 {
    fastrand::u16(1024..65535)
}

/// Generates a random IPv4 address.
///
/// # Returns
///
/// An `Ipv4Addr` representing a random IPv4 address.
pub fn get_random_ip() -> Ipv4Addr {
    Ipv4Addr::new(
        fastrand::u8(0..255),
        fastrand::u8(0..255),
        fastrand::u8(0..255),
        fastrand::u8(0..255),
    )
}

/// Retrieves a network interface by its name.
///
/// # Arguments
///
/// * `name` - A string slice that holds the name of the network interface.
///
/// # Returns
///
/// * `Option<datalink::NetworkInterface>` - An option containing the network interface if found, or None if not found.
pub fn get_interface(name: &str) -> Option<datalink::NetworkInterface> {
    datalink::interfaces()
        .into_iter()
        .find(|interface| interface.name == name)
}

/// Retrieves all network interfaces available on the system.
///
/// # Returns
///
/// * `Vec<datalink::NetworkInterface>` - A vector containing all network interfaces.
pub fn get_interfaces() -> Vec<datalink::NetworkInterface> {
    datalink::interfaces()
}

/// Retrieves the network interface with the default gateway.
///
/// # Returns
///
/// * `Option<datalink::NetworkInterface>` - An option containing the network interface with the default gateway if found, or None if not found.
pub fn get_default_interface() -> Option<datalink::NetworkInterface> {
    datalink::interfaces().into_iter().find(|interface| {
        interface
            .ips
            .iter()
            .any(|ip| ip.is_ipv4() && ip.ip().is_loopback())
    })
}

#[inline(always)]
/// Checks if the current user is the root user.
///
/// Returns `true` if the current user is the root user, `false` otherwise.
fn is_root() -> bool {
    nix::unistd::Uid::current().is_root()
}

/// If the current user is not the root user, reruns the current program using sudo.
///
/// Returns `Ok(())` if the program was successfully rerun with sudo, or an `Err` if the rerun failed.
pub fn rerun_if_not_root() -> crate::Result<()> {
    if !is_root() {
        let args: Vec<String> = std::env::args().collect();
        let program = &args[0];
        let rest_args = &args[1..];

        let status = std::process::Command::new("sudo")
            .arg(program)
            .args(rest_args)
            .status()?;

        if !status.success() {
            match status.signal() {
                Some(nix::libc::SIGINT) => {
                    std::process::exit(130);
                }
                Some(signal) => {
                    return Err(error::Error::OsError(std::io::Error::new(
                        std::io::ErrorKind::PermissionDenied,
                        format!("Failed to grant root privileges: signal {}", signal),
                    )));
                }
                _ => {
                    return Err(error::Error::OsError(std::io::Error::new(
                        std::io::ErrorKind::PermissionDenied,
                        "Failed to grant root privileges",
                    )));
                }
            }
        }
    }
    Ok(())
}

/// Calculates the number of threads to use based on the rated power.
///
/// The rated power is a value from 1 to 4, which mean use a fraction
/// of the available threads.
///
/// # Arguments
///
/// * `rated_power` - The rated power value.
///
/// # Returns
///
/// The number of threads to use.
///
/// # Errors
///
/// Returns an error if the system fails to determine the available parallelism.
///
/// # Panics
///
/// Panics if the rated power is not in the range 1 to 4.
///
/// # Warning
///
/// 0 is also a legal power rating parameter. Using the zero rated power will
/// put the unit into a full load condition, which will definitely affect the
/// normal operation of the unit and may even cause unknown consequences.
///
/// **USE AT YOUR OWN RISK!**
pub fn get_num_threads(rated_power: u8) -> crate::Result<usize> {
    let available_parallelism = std::thread::available_parallelism()?.get();
    Ok(match rated_power {
        0 => available_parallelism,
        1 => available_parallelism / 10,
        2 => available_parallelism / 5,
        3 => available_parallelism / 2,
        4 => available_parallelism * 3 / 4,
        _ => panic!(
            "Invalid rated power {}, available ratings are 1 to 4",
            rated_power
        ),
    })
}