added first basic port scanning for non-root

Author: hollowpointer

cli/src/commands.rs

@@ -113,7 +113,6 @@ impl From<&CommandLine> for ZondConfig {
         Self {
             no_banner: cmd.no_banner,
             no_dns: cmd.no_dns,
-            ports: cmd.ports.clone(),
             redact: cmd.redact,
             quiet: cmd.quiet,
             disable_input: false,

cli/src/commands/scan.rs

@@ -4,12 +4,56 @@
 // If a copy of the MPL was not distributed with this file, You can obtain one at
 // https://mozilla.org/MPL/2.0/.
 
-use zond_common::{config::ZondConfig, parse};
+use std::time::Instant;
 
+use colored::*;
+use tracing::info_span;
+
+use crate::terminal::colors;
 use crate::terminal::print::Print;
+use crate::terminal::spinner::SpinnerGuard;
+
+use zond_common::{config::ZondConfig, models::port::PortSet, parse};
 
-pub async fn scan(targets: &[String], _cfg: &ZondConfig) -> anyhow::Result<()> {
-    let _ips = parse::to_ipset(targets)?;
+pub async fn scan(
+    targets: &[String],
+    global_ports: PortSet,
+    cfg: &ZondConfig,
+) -> anyhow::Result<()> {
     Print::header("starting scanner");
-    anyhow::bail!("'scan' subcommand not implemented yet");
+
+    let _guard: SpinnerGuard = run_spinner();
+
+    let target_map = parse::to_target_map(targets, global_ports)?;
+    let start_time = Instant::now();
+
+    let mut hosts = zond_core::scanner::scan(target_map, cfg).await?;
+
+    if hosts.is_empty() {
+        Print::no_results();
+        return Ok(());
+    }
+
+    Print::header("Network Scanner");
+
+    hosts.sort_by_key(|host| *host.ips.iter().next().unwrap_or(&host.primary_ip));
+
+    Print::hosts(&hosts)?;
+    Print::discovery_summary(hosts.len(), start_time.elapsed());
+
+    Ok(())
+}
+
+fn run_spinner() -> SpinnerGuard {
+    let span = info_span!("scan", indicatif.pb_show = true);
+    let _enter = span.enter();
+
+    SpinnerGuard::with_status(span.clone(), || {
+        let count = zond_core::scanner::get_host_count();
+        let count_str = count.to_string().green().bold();
+        let label = if count == 1 { "host" } else { "hosts" };
+        format!("Scanned {} {} so far...", count_str, label)
+            .color(colors::TEXT_DEFAULT)
+            .italic()
+    })
 }

cli/src/main.rs

@@ -50,7 +50,7 @@ async fn main() -> ExitCode {
         Commands::Info => info::info(&cfg),
         Commands::Listen => listen::listen(&cfg),
         Commands::Discover { targets } => discover::discover(targets, &cfg).await,
-        Commands::Scan { targets } => scan::scan(targets, &cfg).await,
+        Commands::Scan { targets } => scan::scan(targets, commands.ports.clone(), &cfg).await,
     };
 
     let exit_code = match result {

cli/src/terminal/host.rs

@@ -9,6 +9,7 @@ use std::{net::IpAddr, time::Duration};
 use colored::*;
 use unicode_width::UnicodeWidthStr;
 use zond_common::models::host::Host;
+use zond_common::models::port::{Port, PortState, Protocol};
 
 use crate::{
     terminal::{
@@ -54,6 +55,10 @@ impl PrintableHost for Host {
         }
 
         print::as_tree(details);
+
+        if !self.ports().is_empty() {
+            print_services(self.ports());
+        }
     }
 }
 
@@ -119,3 +124,75 @@ fn rtt_to_string(host: &Host) -> String {
 
     format!("⌛ {}ms - {}ms", min_rtt.as_millis(), max_rtt.as_millis())
 }
+
+fn print_services(ports: &[Port]) {
+    let mut open_c = 0;
+    let mut ghosted_c = 0;
+    let mut blocked_c = 0;
+    for p in ports {
+        match p.state {
+            PortState::Open => open_c += 1,
+            PortState::Ghosted => ghosted_c += 1,
+            PortState::Blocked => blocked_c += 1,
+            PortState::Closed => (),
+            _ => (),
+        }
+    }
+
+    let mut stats = Vec::new();
+    if open_c > 0 {
+        stats.push(format!("{} OPEN", open_c).green().bold().to_string());
+    }
+    if ghosted_c > 0 {
+        stats.push(format!("{} GHOSTED", ghosted_c).cyan().bold().to_string());
+    }
+    if blocked_c > 0 {
+        stats.push(format!("{} BLOCKED", blocked_c).yellow().bold().to_string());
+    }
+
+    let stats_str = if stats.is_empty() {
+        "ALL CHECKS CLOSED".dimmed().to_string()
+    } else {
+        stats.join(&format!("{}", "  /  ".bright_black().bold()))
+    };
+
+    zprint!(
+        " {} {}{}{} {}",
+        "└─".bright_black(),
+        "SERVICES".color(colors::TEXT_DEFAULT),
+        ".".repeat(2).color(colors::SEPARATOR),
+        ":".color(colors::SEPARATOR),
+        stats_str
+    );
+
+    for (i, p) in ports.iter().enumerate() {
+        let last = i + 1 == ports.len();
+        let branch = if !last { "├─" } else { "└─" }.bright_black();
+
+        let proto_str = match p.protocol {
+            Protocol::Tcp => "tcp",
+            Protocol::Udp => "udp",
+        };
+        let port_spec = format!("{}/{}", p.number, proto_str);
+        let port_spec_padded = format!("{:width$}", port_spec, width = 9);
+
+        let (state_str, state_color) = match p.state {
+            PortState::Open => ("OPEN   ", colored::Color::Green),
+            PortState::Ghosted => ("GHOSTED", colored::Color::Cyan),
+            PortState::Blocked => ("BLOCKED", colored::Color::Yellow),
+            PortState::Closed => ("CLOSED ", colored::Color::Red),
+            _ => ("UNKNOWN", colored::Color::White),
+        };
+
+        let state_fmt = format!("[ {} ]", state_str.color(state_color));
+        let svc_name = p.service_info.as_deref().unwrap_or("???");
+
+        zprint!(
+            "      {} {} {}  {}",
+            branch,
+            port_spec_padded.color(colors::PRIMARY),
+            state_fmt,
+            svc_name.color(colors::TEXT_DEFAULT)
+        );
+    }
+}

common/src/config.rs

@@ -4,7 +4,7 @@
 // If a copy of the MPL was not distributed with this file, You can obtain one at
 // https://mozilla.org/MPL/2.0/.
 
-use crate::models::port::PortSet;
+
 
 /// Global configuration options for the scanner execution.
 ///
@@ -30,24 +30,7 @@ pub struct ZondConfig {
     /// processing incoming DNS packets if they were initiated elsewhere.
     pub no_dns: bool,
 
-    /// The collection of network ports targeted during discovery and scanning.
-    ///
-    /// This field defines the breadth of the reconnaissance. It supports complex
-    /// specifications including individual ports, inclusive ranges, and
-    /// transport-layer protocol overrides.
-    ///
-    /// # Protocol Handling
-    /// * **TCP** (Default): Ports are assigned to TCP unless prefixed.
-    /// * **UDP**: Ports prefixed with `u:` (e.g., `u:53`) are assigned to UDP.
-    ///
-    /// # Default Behavior
-    /// If not explicitly provided via the CLI, this defaults to a "Greatest Hits"
-    /// list of common TCP services (**22, 80, 443, 445, 3389**). This ensures
-    /// high-probability discovery with minimal network noise.
-    ///
-    /// # Example Syntax
-    /// Input string: `"22, 80-443, u:53, u:67-68"`
-    pub ports: PortSet,
+
 
     /// Enables privacy mode for sensitive data in the output.
     ///

common/src/models/target.rs

@@ -17,7 +17,7 @@ use std::net::IpAddr;
 /// Represents a single, atomic connection attempt.
 ///
 /// This is the pixel of the scan. Scanners (TCP, SYN, UDP) ingest these
-/// objects to perform individual probes.
+/// objects to perform individual targets.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Target {
     pub ip: IpAddr,
@@ -27,7 +27,7 @@ pub struct Target {
 
 /// A blueprint pairing a set of IP addresses with a set of ports.
 ///
-/// `TargetSet` does not store individual probes in memory; instead, it
+/// `TargetSet` does not store individual targets in memory; instead, it
 /// defines the boundaries of a Scan Area. This allows Zond to handle
 /// massive ranges without significant RAM overhead.
 #[derive(Debug, Clone, Default)]
@@ -42,10 +42,10 @@ impl TargetSet {
         Self { ips, ports }
     }
 
-    /// Returns the total number of probes defined by this set.
+    /// Returns the total number of targets defined by this set.
     ///
     /// Calculated as (Number of IPs) × (Number of Ports).
-    pub fn total_probes(&self) -> u128 {
+    pub fn total_targets(&self) -> u128 {
         (self.ips.len() * (self.ports.len()) as u64) as u128
     }
 
@@ -83,7 +83,7 @@ impl TargetMap {
 
     /// Returns the total targets across all defined units.
     pub fn total_targets(&self) -> u128 {
-        self.units.iter().map(|u| u.total_probes()).sum()
+        self.units.iter().map(|u| u.total_targets()).sum()
     }
 
     /// Returns the total number of unique IP addresses targeted.
@@ -111,12 +111,10 @@ mod tests {
     use super::*;
     use crate::models::port::Protocol;
 
-    // Helper to build a simple IpSet from a string
     fn mock_ip_set(input: &str) -> IpSet {
         IpSet::try_from(input).expect("Valid IP input for tests")
     }
 
-    // Helper to build a simple PortSet from a string
     fn mock_port_set(input: &str) -> PortSet {
         PortSet::try_from(input).expect("Valid Port input for tests")
     }
@@ -127,7 +125,7 @@ mod tests {
         let ports = mock_port_set("80, 443, 1000-1007"); // 10 Ports
         let ts = TargetSet::new(ips, ports);
 
-        assert_eq!(ts.total_probes(), 2560);
+        assert_eq!(ts.total_targets(), 2560);
     }
 
     #[test]
@@ -158,13 +156,13 @@ mod tests {
     fn test_target_map_aggregation() {
         let mut map = TargetMap::new();
 
-        // Unit 1: 5 IPs, 2 Ports = 10 Probes
+        // Unit 1: 5 IPs, 2 Ports = 10 targets
         map.add_unit(TargetSet::new(
             mock_ip_set("10.0.0.1-10.0.0.5"),
             mock_port_set("80, 443"),
         ));
 
-        // Unit 2: 1 IP, 5 Ports = 5 Probes
+        // Unit 2: 1 IP, 5 Ports = 5 targets
         map.add_unit(TargetSet::new(
             mock_ip_set("1.1.1.1"),
             mock_port_set("22, 80, 443, 8080, 8443"),
@@ -181,7 +179,7 @@ mod tests {
         assert!(map.is_empty());
 
         let ts_empty = TargetSet::new(mock_ip_set(""), mock_port_set(""));
-        assert_eq!(ts_empty.total_probes(), 0);
+        assert_eq!(ts_empty.total_targets(), 0);
     }
 
     #[test]

common/src/parse.rs

@@ -17,6 +17,35 @@ pub mod ip;
 
 pub use ip::{IS_LAN_SCAN, IpParseError, to_set as to_ipset};
 
+use crate::models::ip::set::IpSet;
+use crate::models::port::PortSet;
+use crate::models::target::{TargetMap, TargetSet};
+
+/// Parses a list of target strings (e.g. `["1.1.1.1:80,443", "8.8.8.8"]`) into a `TargetMap`.
+/// Combines per-target specified ports, or falls back to `global_ports`.
+pub fn to_target_map(
+    targets: &[String],
+    global_ports: PortSet,
+) -> Result<TargetMap, anyhow::Error> {
+    let mut map = TargetMap::new();
+
+    for target in targets {
+        if let Some((ip_str, port_str)) = target.split_once(':') {
+            let ip_set = IpSet::try_from(ip_str)
+                .map_err(|e| anyhow::anyhow!("Invalid IP in '{}': {}", ip_str, e))?;
+            let port_set = PortSet::try_from(port_str)
+                .map_err(|e| anyhow::anyhow!("Invalid Port in '{}': {}", port_str, e))?;
+            map.add_unit(TargetSet::new(ip_set, port_set));
+        } else {
+            let ip_set = IpSet::try_from(target.as_str())
+                .map_err(|e| anyhow::anyhow!("Invalid IP '{}': {}", target, e))?;
+            map.add_unit(TargetSet::new(ip_set, global_ports.clone()));
+        }
+    }
+
+    Ok(map)
+}
+
 // ╔════════════════════════════════════════════╗
 // ║ ████████╗███████╗███████╗████████╗███████╗ ║
 // ║ ╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝██╔════╝ ║

core/src/scanner.rs

@@ -21,13 +21,15 @@ use std::time::Duration;
 use async_trait::async_trait;
 use is_root::is_root;
 use zond_common::config::ZondConfig;
-use zond_common::net::interface;
 use zond_common::models::host::Host;
 use zond_common::models::ip::set::IpSet;
+use zond_common::models::target::TargetMap;
+use zond_common::net::interface;
 use zond_common::utils::input::InputHandle;
 use zond_common::{error, info, success, warn};
 
 mod connect;
+pub mod dispatcher;
 mod local;
 mod resolver;
 mod routed;
@@ -57,9 +59,18 @@ trait NetworkExplorer {
     async fn discover_hosts(&mut self) -> anyhow::Result<Vec<Host>>;
 }
 
-pub async fn scan(cfg: &ZondConfig) {
+pub async fn scan(target_map: TargetMap, cfg: &ZondConfig) -> anyhow::Result<Vec<Host>> {
     let use_raw_sockets = preflight_check(cfg);
-    if !use_raw_sockets {}
+
+    // Non-root TCP connect scan
+    if !use_raw_sockets {
+        let dispatcher = dispatcher::Dispatcher::new(target_map);
+        let rx = dispatcher.run_shuffled();
+        return connect::scan(rx, 50).await;
+    }
+
+    // Root privileged scan logic not implemented yet
+    Ok(Vec::new())
 }
 
 /// The primary entry point for network discovery.
@@ -75,7 +86,7 @@ pub async fn scan(cfg: &ZondConfig) {
 pub async fn discover(targets: IpSet, cfg: &ZondConfig) -> anyhow::Result<Vec<Host>> {
     let use_raw_sockets = preflight_check(cfg);
     if !use_raw_sockets {
-        return connect::range_discovery(targets, connect::prober).await;
+        return connect::discover(targets).await;
     }
 
     let (dns_tx, resolver_task) = if !cfg.no_dns {
@@ -149,10 +160,7 @@ async fn spawn_explorers(
             verbosity = 1,
             "Spawning FALLBACK scanner for unmapped targets"
         );
-        let handle =
-            tokio::spawn(
-                async move { connect::range_discovery(unmapped_ips, connect::prober).await },
-            );
+        let handle = tokio::spawn(async move { connect::discover(unmapped_ips).await });
         handles.push(handle);
     }