asphyxia 0.10.0

A fast and efficient network scanner written in Rust
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

//! Asphyxia - A fast and efficient network scanner
//!
//! This library provides high-performance network scanning capabilities for both port scanning
//! and address scanning operations. It's designed to be efficient, reliable, and easy to use.
//!
//! ## Features
//!
//! - **Port Scanning**: Scan individual ports or ranges of ports on target hosts
//! - **Address Scanning**: Check host availability and scan IP ranges
//! - **Subnet Scanning**: Scan entire subnets for available hosts
//! - **Utility Functions**: Helper functions for parsing ports, IPs, and subnets
//!
//! ## Module Organization
//!
//! - `scanner::port`: Port scanning functionality
//! - `scanner::address`: Address and subnet scanning functionality
//! - `utils`: Utility functions for parsing and validation
//! - `cli`: Command-line interface implementation
//!
//! ## Examples
//!
//! ### Basic Port Scanning
//! ```no_run
//! use asphyxia::scan_port;
//!
//! // Scan a single port (default timeout)
//! if let Some(hit) = scan_port("example.com".to_string(), 80, None) {
//!     println!("Port {} is open ({} ms)", hit.port, hit.latency.as_millis());
//! }
//!
//! // Scan multiple ports
//! let ports = vec![80, 443, 8080];
//! for port in ports {
//!     if let Some(hit) = scan_port("example.com".to_string(), port, None) {
//!         println!("Port {} is open", hit.port);
//!     }
//! }
//! ```
//!
//! ### Address and Subnet Scanning
//! ```no_run
//! use asphyxia::{scan_address, scan_subnet, scan_ip_range};
//! use std::net::IpAddr;
//! use std::time::Duration;
//!
//! // Check if a host is available (IPv4 or IPv6)
//! let ip: IpAddr = "192.168.1.1".parse().unwrap();
//! let timeout = Duration::from_secs(1);
//! if let Some(_) = scan_address(ip, Some(timeout)) {
//!     println!("Host is available");
//! }
//!
//! // Scan a subnet
//! let subnet = "192.168.1.0/24".parse().unwrap();
//! let available_hosts = scan_subnet(subnet, None);
//! println!("Found {} available hosts", available_hosts.len());
//!
//! // Scan an IP range
//! let start: IpAddr = "192.168.1.1".parse().unwrap();
//! let end: IpAddr = "192.168.1.10".parse().unwrap();
//! let hosts = scan_ip_range(start, end, None);
//! println!("Found {} hosts in range", hosts.len());
//! ```
//!
//! ### Using Utility Functions
//! ```rust
//! use asphyxia::{parse_ports, parse_ip, parse_subnet};
//!
//! // Parse port ranges
//! let ports = parse_ports("80,443,8000,8080").unwrap();
//! println!("Ports to scan: {:?}", ports);
//!
//! // Parse IP address (IPv4 or IPv6)
//! let ip = parse_ip("2001:db8::1").unwrap();
//! println!("IP address: {}", ip);
//!
//! // Parse subnet
//! let subnet = parse_subnet("192.168.1.0/24").unwrap();
//! println!("Subnet: {}", subnet);
//! ```
//!
//! ## Error Handling
//!
//! Most functions return `Option<T>` or `Result<T, E>` to handle potential errors
//! gracefully. Always check the return values to ensure proper error handling.
//!
//! ## Performance Considerations
//!
//! The library is designed for performance and uses asynchronous operations where
//! appropriate. For large-scale scanning operations, consider using the subnet
//! scanning functions which are optimized for scanning multiple hosts.

pub mod cli;
pub mod config;
pub mod iface;
pub mod output;
pub mod rate;
pub mod resume;
pub mod scanner;
pub mod timing;
pub mod utils;

pub use config::Config;
pub use output::{OutputFormat, ScanRecord, emit, render};
pub use resume::{ScanState, StateFinding};
pub use scanner::address::{
    HostHit, range_addresses, scan_address, scan_address_with_retries, scan_hosts, scan_ip_range,
    scan_ip_range_with_retries, scan_subnet, scan_subnet_with_retries, subnet_addresses,
};
pub use scanner::exclude::ExcludeSet;
pub use scanner::nmap::{nmap_args, run_nmap, split_extra_args};
/// Re-export commonly used types and functions
pub use scanner::port::{
    PortHit, UdpHit, is_resolvable, resolve_host, scan_port, scan_port_with_retries, scan_udp_port,
};
pub use scanner::service::{detect as detect_service, match_service, service_by_port};
pub use scanner::syn::{
    ProbeMode, ProbeOutcome, SynOutcome, build_ipv4_probe, build_ipv4_syn, build_tcp_probe,
    classify_flags, classify_reply, parse_ipv4_tcp,
};
pub use utils::{
    init_scan_pool, parse_ip, parse_ports, parse_subnet, progress_bar, read_targets,
    read_targets_from_file, read_targets_from_stdin,
};