Merge branch 'master' into bee-add-template-se

.github/FUNDING.yml

@@ -1 +1,4 @@
 github: bee-san
+patreon: brandonskerritt
+ko_fi: hacker
+custom: ["https://monzo.me/bee", "https://paypal.me/brandonskerritt"]

.github/workflows/bump.yml

@@ -1,19 +0,0 @@
-name: Bump
-
-on:
-    push:
-      tags:
-        - '*'
-
-jobs:
-  bump:
-    runs-on: macos-latest
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v2
-      - name: Bump formulae
-        uses: dawidd6/action-homebrew-bump-formula@v3
-        continue-on-error: true
-        with:
-          token: ${{secrets.brew}}
-          formula: rustscan

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustscan"
-version = "1.10.0"
+version = "1.9.0"
 authors = ["Bee <[email protected]>"]
 edition = "2018"
 description = "Faster Nmap Scanning with Rust"
@@ -18,7 +18,7 @@ exclude = [
 
 [dependencies]
 colored = "2.0.0"
-structopt = "0.3.18"
+structopt = "0.3.17"
 async-std = "1.6.4"
 futures = "0.3"
 rlimit = "0.4.0"
@@ -35,7 +35,6 @@ serde = "1.0.116"
 serde_derive = "1.0.116"
 cidr-utils = "0.5.0"
 itertools = "0.9.0"
-trust-dns-resolver = { version = "0.19.5", features = ["dns-over-rustls"] }
 
 [package.metadata.deb]
 depends = "$auto, nmap"

fixtures/hosts.txt

@@ -1,6 +0,0 @@
-127.0.0.1
-google.com
-example.com
-66666666666666.666666666666666666.66666666666666666.6666666666
-....
-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855.radiatorFixtures

src/main.rs

@@ -26,9 +26,8 @@ use std::io::prelude::*;
 use std::io::BufReader;
 use std::net::ToSocketAddrs;
 use std::process::Command;
+use std::str::FromStr;
 use std::{net::IpAddr, time::Duration};
-use trust_dns_resolver::config::*;
-use trust_dns_resolver::Resolver;
 
 extern crate colorful;
 extern crate dirs;
@@ -209,55 +208,9 @@ fn build_nmap_arguments<'a>(
     arguments
 }
 
-/// Goes through all possible IP inputs (files or via argparsing)
-/// Parses the string(s) into IPs
-fn parse_addresses(opts: &Opts) -> Vec<IpAddr> {
-    let mut ips: Vec<IpAddr> = Vec::new();
-    let resolver =
-        &Resolver::new(ResolverConfig::cloudflare_tls(), ResolverOpts::default()).unwrap();
-
-    for ip_or_host in &opts.addresses {
-        match read_ips_from_file(ip_or_host.to_owned(), &resolver) {
-            Ok(x) => ips.extend(x),
-            _ => match parse_to_ip(ip_or_host.to_owned(), &resolver) {
-                Ok(x) => ips.extend(x),
-                _ => {
-                    warning!(
-                        format!("Host {:?} could not be resolved.", ip_or_host),
-                        opts.greppable,
-                        opts.accessible
-                    );
-                }
-            },
-        }
-    }
-    ips
-}
-
-/// Uses DNS to get the IPS assiocated with host
-fn resolve_ips_from_host(
-    source: &String,
-    resolver: &Resolver,
-) -> Result<Vec<IpAddr>, std::io::Error> {
-    let mut ips: Vec<std::net::IpAddr> = Vec::new();
-
-    match resolver.lookup_ip(&source) {
-        Ok(x) => {
-            for ip in x.iter() {
-                ips.push(ip);
-            }
-        }
-        _ => (),
-    };
-    return Ok(ips);
-}
-
 #[cfg(not(tarpaulin_include))]
 /// Parses an input file of IPs and uses those
-fn read_ips_from_file(
-    ips: String,
-    resolver: &Resolver,
-) -> Result<Vec<std::net::IpAddr>, std::io::Error> {
+fn read_ips_from_file(ips: String) -> Result<Vec<std::net::IpAddr>, std::io::Error> {
     // if we cannot open it as a file, it is not a file so move on
     let file = File::open(ips)?;
     let reader = BufReader::new(file);
@@ -265,39 +218,37 @@ fn read_ips_from_file(
     let mut ips: Vec<std::net::IpAddr> = Vec::new();
 
     for str_ip in reader.lines() {
-        match str_ip {
-            Ok(x) => match parse_to_ip(x, resolver) {
-                Ok(result) => ips.extend(result),
-                Err(e) => {
-                    debug!("{} is not a valid IP or host", e);
-                }
-            },
-            Err(_) => {
-                debug!("Line in file is not valid");
-            }
+        match IpAddr::from_str(&str_ip.unwrap()) {
+            Ok(x) => ips.push(x),
+            Err(y) => panic!("File does not contain valid IP address. Error at {}", y),
         }
     }
     Ok(ips)
 }
 
-/// Given a string, parse it as an host, IP address, or CIDR.
-/// This allows us to pass files as hosts or cidr or IPs easily
-/// Call this everytime you have a possible IP_or_host
-fn parse_to_ip(address: String, resolver: &Resolver) -> Result<Vec<IpAddr>, std::io::Error> {
+fn parse_addresses(opts: &Opts) -> Vec<IpAddr> {
     let mut ips: Vec<IpAddr> = Vec::new();
 
-    match IpCidr::from_str(&address) {
-        Ok(cidr) => cidr.iter().for_each(|ip| ips.push(ip)),
-        _ => match format!("{}:{}", &address, 80).to_socket_addrs() {
-            Ok(mut iter) => ips.push(iter.nth(0).unwrap().ip()),
-            _ => match resolve_ips_from_host(&address, resolver) {
-                Ok(hosts) => ips.extend(hosts),
-                _ => (),
+    for ip_or_host in &opts.addresses {
+        match IpCidr::from_str(ip_or_host) {
+            Ok(cidr) => cidr.iter().for_each(|ip| ips.push(ip)),
+            _ => match format!("{}:{}", &ip_or_host, 80).to_socket_addrs() {
+                Ok(mut iter) => ips.push(iter.nth(0).unwrap().ip()),
+                _ => match read_ips_from_file(ip_or_host.to_owned()) {
+                    Ok(x) => ips.extend(x),
+                    _ => {
+                        warning!(
+                            format!("Host {:?} could not be resolved.", ip_or_host),
+                            opts.greppable,
+                            opts.accessible
+                        );
+                    }
+                },
             },
-        },
-    };
+        }
+    }
 
-    Ok(ips)
+    ips
 }
 
 fn adjust_ulimit_size(opts: &Opts) -> rlimit::rlim {
@@ -468,12 +419,4 @@ mod tests {
 
         assert_eq!(ips.is_empty(), true);
     }
-    #[test]
-    fn parse_hosts_file_and_incorrect_hosts() {
-        // Host file contains IP, Hosts, incorrect IPs, incorrect hosts
-        let mut opts = Opts::default();
-        opts.addresses = vec!["fixtures/hosts.txt".to_owned()];
-        let ips = parse_addresses(&opts);
-        assert_eq!(ips.len(), 3);
-    }
 }