Merge branch 'dev'

Author: 0xor0ne

Cargo.lock

@@ -36,7 +36,7 @@ For using `qscan` library put this dependency in your `Cargo.toml`:
 
 ```bash
 [dependencies]
-qscan = "0.4.1"
+qscan = "0.5.0"
 ```
 
 for more details and examples see [qscan README](./qscan/README.md).

README.md

@@ -1,6 +1,6 @@
 [package]
 name = "qsc"
-version = "0.2.1"
+version = "0.3.0"
 description = "Quick async network scanner CLI"
 documentation = "https://github.com/0xor0ne/qscan"
 readme = "README.md"
@@ -17,7 +17,7 @@ exclude = [
 ]
 
 [dependencies]
-qscan = { path = "../qscan", version = "0.4.1" }
+qscan = { path = "../qscan", version = "0.5.0" , features = ["serialize"] }
 tokio = { version = "1", features = ["rt"] }
 clap = { version = "3.1.18", features = ["derive"] }
 

qsc/Cargo.toml

@@ -37,7 +37,7 @@ Print the help message using `-h` option:
 
 ```bash
 >>> qsc -h
-qsc 0.2.1
+qsc 0.3.0
 0xor0ne
 Quick async network scanner CLI
 
@@ -47,6 +47,7 @@ USAGE:
 OPTIONS:
         --batch <BATCH>              Parallel scan [default: 5000]
     -h, --help                       Print help information
+        --json <JSON>                Path to file whre to save results in json format
         --ports <PORTS>              Comma separate list of ports (or port ranges) to scan for each
                                      target. E.g., '80', '22,443', '1-1024,8080'
         --printlevel <PRINTLEVEL>    Console output mode:
@@ -82,6 +83,9 @@ qsc --targets "www.google.com" --ports "80,443"
 # Use a file as target, the file must contain a target (IP, cidr or domain name)
 # for each line
 qsc --targets "/tmp/ips.txt" --ports "1-1024"
+# Print all the ports with OPEN/CLOSED indication and save results in json
+# format in file /tmp/res.json
+qsc --targets "8.8.8.8" --ports 80,443,111 --tries 1 --json /tmp/xxx.json --printlevel 4
 ```
 
 ## Docker Image

qsc/README.md

@@ -24,8 +24,10 @@
 //!
 //! ## OPTIONS:
 //!
+//! ```text
 //!       --batch <BATCH>              Parallel scan [default: 5000]
 //!       -h, --help                   Print help information
+//!       --json <JSON>                Path to file whre to save results in json format
 //!       --ports <PORTS>              Comma separate list of ports (or port ranges) to scan for each
 //!                                    target. E.g., '80', '22,443', '1-1024,8080'
 //!       --printlevel <PRINTLEVEL>    Console output mode:
@@ -45,6 +47,11 @@
 //!       --tries <TRIES>              Number of maximum retries for each target:port pair [default:
 //!                                    1]
 //!       -V, --version                    Print version information
+//! ```
+
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
 
 use qscan::{QSPrintMode, QScanTcpConnectResult, QScanTcpConnectState, QScanType, QScanner};
 
@@ -101,6 +108,9 @@ struct Args {
         "
     )]
     printlevel: u8,
+
+    #[clap(long, help = "Path to file whre to save results in json format")]
+    json: Option<PathBuf>,
 }
 
 /// Simple async tcp connect scanner
@@ -112,6 +122,18 @@ pub fn main() {
     let batch = args.batch;
     let timeout = args.timeout;
     let tries = args.tries;
+    let mut jf: Option<File> = None;
+
+    if args.json.is_some() {
+        jf = if let Ok(f) = File::create(&args.json.as_ref().unwrap().as_path()) {
+            Some(f)
+        } else {
+            panic!(
+                "Cannot create file {}",
+                args.json.unwrap().to_str().unwrap()
+            );
+        }
+    }
 
     let mut scanner = QScanner::new(&addresses, &ports);
     scanner.set_scan_type(QScanType::TcpConnect);
@@ -132,11 +154,11 @@ pub fn main() {
         }
     }
 
-    let res: Vec<QScanTcpConnectResult> =
+    let res: &Vec<QScanTcpConnectResult> =
         Runtime::new().unwrap().block_on(scanner.scan_tcp_connect());
 
     if !no_output && (args.printlevel == 1 || args.printlevel == 2) {
-        for sa in &res {
+        for sa in res {
             if sa.state == QScanTcpConnectState::Open {
                 if args.printlevel == 1 {
                     println!("{}", sa.target);
@@ -148,4 +170,15 @@ pub fn main() {
             }
         }
     }
+
+    if let Some(mut f) = jf {
+        let j = scanner.get_last_results_as_json_string().unwrap();
+        if let Err(e) = f.write_all(j.as_bytes()) {
+            eprintln!(
+                "Error writing json results in {}: {}",
+                args.json.unwrap().to_str().unwrap(),
+                e
+            );
+        }
+    }
 }

qsc/src/main.rs

@@ -1,6 +1,6 @@
 [package]
 name = "qscan"
-version = "0.4.1"
+version = "0.5.0"
 description = "Quick async network scan library"
 documentation = "https://docs.rs/qscan"
 readme = "README.md"
@@ -18,4 +18,10 @@ cidr-utils = "0.5.6"
 futures = "0.3"
 itertools = "0.10.3"
 trust-dns-resolver = { version = "0.21.2", features = ["dns-over-rustls"] }
+serde = { version = "1.0", optional = true }
+serde_json = { version = "1.0", optional = true }
+# serde = { version = "1.0" }
+# serde_json = { version = "1.0" }
 
+[features]
+serialize = ["serde", "serde_json" ]

qscan/Cargo.toml

@@ -19,14 +19,23 @@ Dependencies (`Cargo.toml`):
 
 ```bash
 [dependencies]
-qscan = "0.4.1"
+qscan = "0.5.0"
+tokio = { version = "1", features = ["rt-multi-thread"] }
+```
+
+Alternatively, in order enable `qscan::QScanTcpConnectResult` serialization,
+activate `serialize` feature:
+
+```bash
+[dependencies]
+qscan = { version = "0.5.0" , features = ["serialize"] }
 tokio = { version = "1", features = ["rt-multi-thread"] }
 ```
 
 and then (`src/main.rs`):
 
 ```rust
-use qscan::qscanner::{QSPrintMode, QScanTcpConnectState, QScanType, QScanner};
+use qscan::{QSPrintMode, QScanTcpConnectState, QScanType, QScanner};
 use tokio::runtime::Runtime;
 
 pub fn main() {
@@ -39,12 +48,12 @@ pub fn main() {
 
     let res = Runtime::new().unwrap().block_on(scanner.scan_tcp_connect());
 
-    for sa in &res {
+    for sa in res {
         if sa.state == QScanTcpConnectState::Open {
             println!("{}", sa.target);
         }
     }
 }
 ```
 
-See also the [provided example](./examples/scan.rs).
+See also the [provided example](./examples/scan.rs) and [qsc utility](../qsc/).

qscan/README.md

@@ -27,7 +27,7 @@ pub fn main() {
 
     let res = Runtime::new().unwrap().block_on(scanner.scan_tcp_connect());
 
-    for sa in &res {
+    for sa in res {
         if sa.state == QScanTcpConnectState::Open {
             println!("{}", sa.target);
         }

qscan/examples/scan.rs

@@ -14,7 +14,16 @@
 // this program. If not, see <https://www.gnu.org/licenses/>.
 //
 
+//! # QSCAN
+//!
 //! Asynchronous network ports scanning library
+//!
+//! To enable `qscan::QScanTcpConnectResult` serialization:
+//!
+//! ```text
+//! [dependencies]
+//! qscan = { path = "../qscan", version = "0.5.0" , features = ["serialize"] }
+//! ```
 
 pub use crate::qscanner::QSPrintMode;
 pub use crate::qscanner::QScanTcpConnectResult;

qscan/src/lib.rs

@@ -16,6 +16,11 @@
 
 use std::fmt;
 
+#[cfg(feature = "serialize")]
+use serde::ser::{Serialize, SerializeStruct, Serializer};
+#[cfg(feature = "serialize")]
+use serde_json;
+
 use std::net::IpAddr;
 use std::net::SocketAddr;
 use std::net::ToSocketAddrs;
@@ -104,6 +109,27 @@ impl fmt::Display for QScanError {
     }
 }
 
+#[cfg(feature = "serialize")]
+impl Serialize for QScanTcpConnectResult {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut s = serializer.serialize_struct("QScanTcpConnectResult", 3)?;
+        s.serialize_field("IP", &self.target.ip())?;
+        s.serialize_field("port", &self.target.port())?;
+        match self.state {
+            QScanTcpConnectState::Open => {
+                s.serialize_field("state", "OPEN")?;
+            }
+            QScanTcpConnectState::Close => {
+                s.serialize_field("state", "CLOSED")?;
+            }
+        }
+        s.end()
+    }
+}
+
 /// Defaults
 const SCAN_TYPE: QScanType = QScanType::TcpConnect;
 const PRINT_MODE: QSPrintMode = QSPrintMode::NonRealTime;
@@ -283,6 +309,11 @@ impl QScanner {
             .collect::<Vec<u16>>();
     }
 
+    #[cfg(feature = "serialize")]
+    pub fn get_last_results_as_json_string(&self) -> serde_json::Result<String> {
+        serde_json::to_string(&self.last_results)
+    }
+
     /// Async TCP connect scan
     ///
     /// # Return
@@ -298,8 +329,8 @@ impl QScanner {
     /// let res = Runtime::new().unwrap().block_on(scanner.scan_tcp_connect());
     /// ```
     ///
-    pub async fn scan_tcp_connect(&self) -> Vec<QScanTcpConnectResult> {
-        let mut open_soc: Vec<QScanTcpConnectResult> = Vec::new();
+    pub async fn scan_tcp_connect(&mut self) -> &Vec<QScanTcpConnectResult> {
+        let mut sock_res: Vec<QScanTcpConnectResult> = Vec::new();
         let mut sock_it: sockiter::SockIter = sockiter::SockIter::new(&self.ips, &self.ports);
         let mut ftrs = FuturesUnordered::new();
 
@@ -328,7 +359,7 @@ impl QScanner {
                         _ => {}
                     }
 
-                    open_soc.push(QScanTcpConnectResult {
+                    sock_res.push(QScanTcpConnectResult {
                         target: socket,
                         state: QScanTcpConnectState::Open,
                     });
@@ -338,15 +369,17 @@ impl QScanner {
                         println!("{}:{}:CLOSED", error.sock.ip(), error.sock.port());
                     }
 
-                    open_soc.push(QScanTcpConnectResult {
+                    sock_res.push(QScanTcpConnectResult {
                         target: error.sock,
                         state: QScanTcpConnectState::Close,
                     });
                 }
             }
         }
 
-        open_soc
+        drop(ftrs);
+        self.last_results = Some(sock_res);
+        self.last_results.as_ref().unwrap()
     }
 
     async fn scan_socket_tcp_connect(&self, socket: SocketAddr) -> Result<SocketAddr, QScanError> {