ntrace 0.1.4

A fast and secure network port scanner and protocol analyzer
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

use std::time::Duration;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum NtraceError {
    #[error("Network error: {0}")]
    Network(#[from] std::io::Error),

    #[error("Invalid IP address: {0}")]
    InvalidIp(String),

    #[error("Protocol analysis failed: {0}")]
    Protocol(String),

    #[error("Timeout occurred while scanning port {0}")]
    Timeout(u16),

    #[error("Connection refused on port {0}")]
    ConnectionRefused(u16),

    #[error("Connection reset on port {0}")]
    ConnectionReset(u16),

    #[error("Permission denied when accessing port {0}")]
    PermissionDenied(u16),

    #[error("DNS resolution failed: {0}")]
    DnsResolutionFailed(String),

    #[error("DNS error: {0}")]
    DnsError(String),

    #[error("Rate limit exceeded")]
    RateLimitExceeded,

    #[error("Maximum retries ({0}) exceeded")]
    MaxRetriesExceeded(usize),

    #[error("Invalid port range: {0}")]
    InvalidPortRange(String),

    #[error("UDP scan error on port {0}: {1}")]
    UdpScanError(u16, String),

    #[error("Service detection failed: {0}")]
    ServiceDetectionFailed(String),

    #[error("Scan interrupted")]
    ScanInterrupted,

    #[error("Failed to parse response from port {0}: {1}")]
    ResponseParseError(u16, String),

    #[error("TLS error: {0}")]
    TlsError(String),

    #[error("ICMP error: {0}")]
    IcmpError(String),

    #[error("Permission denied: {0}")]
    PermissionDenied2(String),

    #[error("Socket configuration error: {0}")]
    SocketConfigError(String),

    #[error("Network congestion detected")]
    NetworkCongestion,

    #[error("Malformed packet received: {0}")]
    MalformedPacket(String),
}

/// Determines if an error is recoverable and worth retrying
pub fn is_recoverable_error(err: &NtraceError) -> bool {
    match err {
        NtraceError::Network(io_err) => {
            // Check if the IO error is recoverable
            matches!(
                io_err.kind(),
                std::io::ErrorKind::TimedOut
                    | std::io::ErrorKind::Interrupted
                    | std::io::ErrorKind::WouldBlock
            )
        }
        NtraceError::Timeout(_) => true,
        NtraceError::RateLimitExceeded => true,
        NtraceError::NetworkCongestion => true,
        // Some ICMP errors are transient
        NtraceError::IcmpError(_) => true,
        // Might be a temporary issue
        NtraceError::MalformedPacket(_) => true,
        _ => false,
    }
}

/// Calculates backoff duration for retries
pub fn calculate_backoff(attempt: usize, base_delay: Duration) -> Duration {
    // Exponential backoff with jitter
    let max_delay = Duration::from_secs(30);
    let exp_backoff = base_delay.mul_f64(1.5f64.powi(attempt as i32));

    // Add jitter (±20%)
    let jitter_factor = 0.8 + (rand::random::<f64>() * 0.4);
    let with_jitter = exp_backoff.mul_f64(jitter_factor);

    // Cap at max delay
    std::cmp::min(with_jitter, max_delay)
}