rtcps 1.0.2

Rust TCP Scanner
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
155
156
157
158
159
160

use dashmap::DashMap;
use smol::net::TcpStream;
use std::{
    net::{IpAddr, Ipv4Addr, SocketAddr},
    sync::Arc,
};

use crate::cli::Cli;

#[derive(Clone)]
pub struct PortScanner {
    /// IP addr to eventually scan
    addr: IpAddr,
    /// Port map to store port data
    pub port_map: Arc<DashMap<u16, bool>>,
}

impl PortScanner {
    ///
    /// returns a new Port Scanner bound to an address.
    ///
    /// # Arguments
    ///
    /// * `address` - An `IpAddr` to scan
    ///
    /// # Examples
    ///
    /// ```
    /// use rtcps::port_scanner::PortScanner;
    /// use std::net::{IpAddr, Ipv4Addr};
    ///
    /// let port_scanner = PortScanner::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
    /// ```
    ///
    pub fn new(address: IpAddr) -> Self {
        Self {
            addr: address,
            port_map: Arc::new(DashMap::new()),
        }
    }

    ///
    /// Really is only called internally except for in a unit test
    /// returns true if the port number supplied is open when checked.
    /// Optionally takes a Cli in order to test for flags.
    ///
    /// # Arguments
    ///
    /// * `port_num` - Port to scan
    /// * `cli` - Optional Cli arg to test for verbose flag
    ///
    /// # Example
    ///
    /// Example code that checks if a Postgresql server is running
    /// (Postgres servers are usually bound to port 5432)
    ///
    /// ```
    /// use rtcps::port_scanner::PortScanner;
    ///
    /// let port_scanner = PortScanner::default();
    /// let postgres_is_open = port_scanner.check_port_open(&5432, None);
    /// ```
    ///
    pub async fn check_port_open(&self, port_num: &u16, cli: Option<&Cli>) -> bool {
        let socket_address = SocketAddr::new(self.addr, *port_num);

        match TcpStream::connect(socket_address).await {
            Ok(_) => {
                if let Some(c) = cli {
                    if c.verbose {
                        log::info!("port {port_num} open!");
                    }

                    if c.greppable {
                        log::info!("{port_num}");
                    }
                }
                true
            }
            Err(_) => false,
        }
    }

    ///
    /// Performs a port scan and mutates the structs inner `port_map`
    ///
    /// # Arguments
    ///
    /// * `ports` - a reference to a vec holding a list of port numbers to scan
    /// * `cli` - an optional cli arg for passing scan flags
    ///
    /// # Examples
    ///
    /// ```
    /// use rtcps::port_scanner::PortScanner;
    ///
    /// let ports: Vec<u16> = (0..=65535).collect();
    /// let mut port_scanner = PortScanner::default();
    /// port_scanner.scan_ports(&ports, None);
    /// ```
    ///
    pub async fn scan_ports(&mut self, ports: &Vec<u16>, cli: Option<&Cli>) {
        for x in ports {
            if self.check_port_open(x, cli).await {
                self.port_map.insert(*x, true);
            } else {
                self.port_map.insert(*x, false);
            }
        }
    }
}

impl Default for PortScanner {
    ///
    /// Returns a Port Scanner bound to localhost
    ///
    /// # Examples
    ///
    /// ```
    /// use rtcps::port_scanner::PortScanner;
    ///
    /// let port_scanner = PortScanner::default();
    /// ```
    ///
    fn default() -> Self {
        Self {
            addr: IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
            port_map: Arc::default(),
        }
    }
}

impl From<&Cli> for PortScanner {
    ///
    /// Returns a Port Scanner that inherits fields from a Cli struct
    ///
    /// # Arguments
    ///
    /// * `cli` - reference to a Cli struct
    ///
    /// # Examples
    ///
    /// ```
    /// use rtcps::{port_scanner::PortScanner, cli::Cli};
    /// use clap::Parser;
    ///
    /// let cli = Cli::parse_from(["", "127.0.0.1"]);
    /// let port_scanner = PortScanner::from(&cli);
    /// ```
    ///
    fn from(cli: &Cli) -> Self {
        // cli.get_ports.1 will always be higher than cli.get_ports.0 because the parser rejects ranges with a higher starting number
        let cap = cli.get_ports().1 - cli.get_ports().0;

        Self {
            addr: cli.addr,
            port_map: Arc::new(DashMap::with_capacity(cap as usize)),
        }
    }
}