fixed nmap lists

Author: cryptexctl

Cargo.lock

@@ -24,3 +24,4 @@ base64 = "0.21"
 chrono = "0.4"
 ipnetwork = "0.20"
 trust-dns-resolver = { version = "0.22", features = ["tokio-runtime"] }
+lazy_static = "1.4"

Cargo.toml

@@ -18,41 +18,36 @@ use base64::Engine;
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
 struct Args {
-    #[arg(short, long)]
-    target: String,
+    #[arg(short, long, required = true)]
+    targets: Vec<String>,
+
+    #[arg(short, long, default_value = "1000-2000")]
+    ports: String,
 
     #[arg(short, long, default_value = "1000")]
     concurrency: usize,
 
     #[arg(short, long, default_value = "1000")]
     timeout: u64,
 
-    #[arg(short, long, default_value = "1-1024")]
-    ports: String,
-
-    #[arg(short, long)]
+    #[arg(long)]
     service_detection: bool,
-
-    #[arg(short, long)]
-    subnet: bool,
 }
 
-fn parse_port_range(ports: &str) -> Result<(u16, u16)> {
+fn parse_port_range(ports: &str) -> Result<std::ops::RangeInclusive<u16>> {
     let parts: Vec<&str> = ports.split('-').collect();
     if parts.len() != 2 {
-        return Err(anyhow::anyhow!("Invalid port range format. Use start-end"));
+        return Err(anyhow::anyhow!("Invalid port range format"));
     }
 
-    let start = parts[0].parse::<u16>()
-        .with_context(|| format!("Invalid start port: {}", parts[0]))?;
-    let end = parts[1].parse::<u16>()
-        .with_context(|| format!("Invalid end port: {}", parts[1]))?;
+    let start = parts[0].parse::<u16>()?;
+    let end = parts[1].parse::<u16>()?;
 
     if start > end {
-        return Err(anyhow::anyhow!("Start port cannot be greater than end port"));
+        return Err(anyhow::anyhow!("Start port must be less than or equal to end port"));
     }
 
-    Ok((start, end))
+    Ok(start..=end)
 }
 
 fn resolve_target(target: &str, subnet: bool) -> Result<Vec<IpAddr>> {
@@ -125,50 +120,37 @@ fn generate_issue_template(result: &ScanResult) -> String {
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = Args::parse();
-    let (start_port, end_port) = parse_port_range(&args.ports)?;
-    let targets = resolve_target(&args.target, args.subnet)?;
-
-    println!("Starting scan on {} targets...", targets.len());
+    let port_range = parse_port_range(&args.ports)?;
 
     let scanner = Scanner::new(
-        targets,
-        start_port..=end_port,
+        args.targets,
+        port_range,
         args.concurrency,
         args.timeout,
         args.service_detection,
     );
 
-    let results = scanner.run().await;
-    let mut service_stats: HashMap<String, u32> = HashMap::new();
+    let results = scanner.run().await?;
 
-    for result in &results {
-        if let Some(service) = &result.service {
-            *service_stats.entry(service.name.clone()).or_insert(0) += 1;
+    if !results.is_empty() {
+        println!("\nScan Results:");
+        for result in &results {
+            println!("{}", format_scan_result(result));
         }
-    }
 
-    println!("\nScan Results:");
-    for result in results {
-        if let Some(service) = result.service {
-            println!("[+] {}:{} is open", result.ip, result.port);
-            println!("    Service: {}", service.name);
-            if let Some(version) = service.version {
-                println!("    Version: {}", version);
-            }
-            if let Some(product) = service.product {
-                println!("    Product: {}", product);
-            }
-            if let Some(os) = service.os_type {
-                println!("    OS: {}", os);
+        let mut service_stats: HashMap<String, u32> = HashMap::new();
+        for result in &results {
+            if let Some(service) = &result.service {
+                *service_stats.entry(service.name.clone()).or_insert(0) += 1;
             }
-        } else {
-            println!("[+] {}:{} is open", result.ip, result.port);
         }
-    }
 
-    println!("\nService Statistics:");
-    for (service, count) in service_stats {
-        println!("  {}: {}", service, count);
+        println!("\nService Statistics:");
+        for (service, count) in service_stats {
+            println!("  {}: {}", service, count);
+        }
+    } else {
+        println!("No open ports found");
     }
 
     Ok(())

src/main.rs

@@ -2,7 +2,108 @@ use regex::Regex;
 use std::fs;
 use std::path::Path;
 use anyhow::Result;
-use crate::types::{ServicePattern, NmapService, NmapProbe, NmapMatch};
+use std::collections::HashMap;
+use crate::types::{ServicePattern, NmapService, NmapProbe, NmapMatch, Protocol, MacPrefix, RpcInfo};
+
+lazy_static::lazy_static! {
+    static ref PROTOCOLS: HashMap<String, Protocol> = {
+        let mut map = HashMap::new();
+        if let Ok(protocols) = load_protocols("src/assets/nmap-protocols") {
+            for protocol in protocols {
+                map.insert(protocol.name.clone(), protocol);
+            }
+        }
+        map
+    };
+
+    static ref MAC_PREFIXES: HashMap<String, String> = {
+        let mut map = HashMap::new();
+        if let Ok(prefixes) = load_mac_prefixes("src/assets/nmap-mac-prefixes") {
+            for prefix in prefixes {
+                map.insert(prefix.prefix, prefix.vendor);
+            }
+        }
+        map
+    };
+
+    static ref RPC_INFO: HashMap<(String, String), RpcInfo> = {
+        let mut map = HashMap::new();
+        if let Ok(info) = load_rpc_info("src/assets/nmap-rpc") {
+            for rpc in info {
+                map.insert((rpc.program.clone(), rpc.version.clone()), rpc);
+            }
+        }
+        map
+    };
+
+    static ref NMAP_SERVICES: HashMap<u16, Vec<NmapService>> = {
+        let mut map = HashMap::new();
+        if let Ok(services) = load_nmap_services("src/assets/nmap-services") {
+            for service in services {
+                map.entry(service.port).or_insert_with(Vec::new).push(service);
+            }
+        }
+        map
+    };
+
+    static ref SERVICE_PATTERNS: Vec<ServicePattern> = {
+        let mut patterns = Vec::with_capacity(1000);
+        
+        patterns.extend(get_ssh_patterns());
+        patterns.extend(get_http_patterns());
+        patterns.extend(get_ftp_patterns());
+        patterns.extend(get_mysql_patterns());
+        patterns.extend(get_redis_patterns());
+        
+        if let Ok(probes) = load_nmap_probes("src/assets/nmap-service-probes") {
+            for probe in probes {
+                for nmap_match in probe.matches {
+                    if nmap_match.pattern.contains("**") || nmap_match.pattern.contains("\\") || nmap_match.pattern.contains("^") {
+                        continue;
+                    }
+
+                    if let Ok(regex) = Regex::new(&nmap_match.pattern) {
+                        let pattern = ServicePattern {
+                            name: nmap_match.service.clone(),
+                            regex,
+                            probe: probe.probe_string.clone(),
+                            version_regex: nmap_match.version_info.as_ref().and_then(|v| Regex::new(v).ok()),
+                            product_regex: nmap_match.product_info.as_ref().and_then(|p| Regex::new(p).ok()),
+                            os_regex: nmap_match.os_info.as_ref().and_then(|o| Regex::new(o).ok()),
+                            extra_info_regex: nmap_match.extra_info.as_ref().and_then(|i| Regex::new(i).ok()),
+                            cpe_regex: nmap_match.cpe.as_ref().and_then(|c| Regex::new(c).ok()),
+                            vulnerability_patterns: vec![],
+                            total_wait_ms: probe.total_wait_ms,
+                            tcp_wrapped_ms: probe.tcp_wrapped_ms,
+                        };
+                        patterns.push(pattern);
+                    }
+                }
+            }
+        }
+        patterns
+    };
+}
+
+pub fn get_all_patterns() -> Vec<ServicePattern> {
+    SERVICE_PATTERNS.clone()
+}
+
+pub fn get_protocol(name: &str) -> Option<&Protocol> {
+    PROTOCOLS.get(name)
+}
+
+pub fn get_mac_vendor(prefix: &str) -> Option<&String> {
+    MAC_PREFIXES.get(prefix)
+}
+
+pub fn get_rpc_info<'a>(program: &'a str, version: &'a str) -> Option<&'static RpcInfo> {
+    RPC_INFO.get(&(program.to_string(), version.to_string()))
+}
+
+pub fn get_services_by_port(port: u16) -> Option<&'static Vec<NmapService>> {
+    NMAP_SERVICES.get(&port)
+}
 
 pub fn get_ssh_patterns() -> Vec<ServicePattern> {
     vec![
@@ -230,41 +331,106 @@ pub fn load_nmap_probes(file_path: &str) -> Result<Vec<NmapProbe>> {
     Ok(probes)
 }
 
-pub fn get_all_patterns() -> Vec<ServicePattern> {
-    let mut patterns = Vec::new();
-    
-    patterns.extend(get_ssh_patterns());
-    patterns.extend(get_http_patterns());
-    patterns.extend(get_ftp_patterns());
-    patterns.extend(get_mysql_patterns());
-    patterns.extend(get_redis_patterns());
-    
-    if let Ok(probes) = load_nmap_probes("src/assets/nmap-service-probes") {
-        for probe in probes {
-            for nmap_match in probe.matches {
-                if nmap_match.pattern.contains("**") || nmap_match.pattern.contains("\\") || nmap_match.pattern.contains("^") {
-                    continue;
-                }
+pub fn load_protocols(file_path: &str) -> Result<Vec<Protocol>> {
+    let path = Path::new(file_path);
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
 
-                if let Ok(regex) = Regex::new(&nmap_match.pattern) {
-                    let pattern = ServicePattern {
-                        name: nmap_match.service.clone(),
-                        regex,
-                        probe: probe.probe_string.clone(),
-                        version_regex: nmap_match.version_info.as_ref().and_then(|v| Regex::new(v).ok()),
-                        product_regex: nmap_match.product_info.as_ref().and_then(|p| Regex::new(p).ok()),
-                        os_regex: nmap_match.os_info.as_ref().and_then(|o| Regex::new(o).ok()),
-                        extra_info_regex: nmap_match.extra_info.as_ref().and_then(|i| Regex::new(i).ok()),
-                        cpe_regex: nmap_match.cpe.as_ref().and_then(|c| Regex::new(c).ok()),
-                        vulnerability_patterns: vec![],
-                        total_wait_ms: probe.total_wait_ms,
-                        tcp_wrapped_ms: probe.tcp_wrapped_ms,
-                    };
-                    patterns.push(pattern);
-                }
+    let content = fs::read_to_string(path)?;
+    let mut protocols = Vec::new();
+
+    for line in content.lines() {
+        if line.starts_with('#') || line.trim().is_empty() {
+            continue;
+        }
+
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        if parts.len() >= 2 {
+            let name = parts[0].to_string();
+            if let Ok(number) = parts[1].parse::<u8>() {
+                let aliases = if parts.len() > 2 {
+                    parts[2..].iter().map(|&s| s.to_string()).collect()
+                } else {
+                    Vec::new()
+                };
+
+                protocols.push(Protocol {
+                    name,
+                    number,
+                    aliases,
+                });
             }
         }
     }
-    
-    patterns
+
+    Ok(protocols)
+}
+
+pub fn load_mac_prefixes(file_path: &str) -> Result<Vec<MacPrefix>> {
+    let path = Path::new(file_path);
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
+
+    let content = fs::read_to_string(path)?;
+    let mut prefixes = Vec::new();
+
+    for line in content.lines() {
+        if line.starts_with('#') || line.trim().is_empty() {
+            continue;
+        }
+
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        if parts.len() >= 2 {
+            let prefix = parts[0].to_string();
+            let vendor = parts[1..].join(" ");
+
+            prefixes.push(MacPrefix {
+                prefix,
+                vendor,
+            });
+        }
+    }
+
+    Ok(prefixes)
+}
+
+pub fn load_rpc_info(file_path: &str) -> Result<Vec<RpcInfo>> {
+    let path = Path::new(file_path);
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
+
+    let content = fs::read_to_string(path)?;
+    let mut rpc_info = Vec::new();
+
+    for line in content.lines() {
+        if line.starts_with('#') || line.trim().is_empty() {
+            continue;
+        }
+
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        if parts.len() >= 3 {
+            let program = parts[0].to_string();
+            let version = parts[1].to_string();
+            let protocol = parts[2].to_string();
+            let port = parts.get(3).and_then(|p| p.parse::<u16>().ok());
+            let description = if parts.len() > 4 {
+                Some(parts[4..].join(" "))
+            } else {
+                None
+            };
+
+            rpc_info.push(RpcInfo {
+                program,
+                version,
+                protocol,
+                port,
+                description,
+            });
+        }
+    }
+
+    Ok(rpc_info)
 }