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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
// Copyright (c) 2026 Erik Lening (hollowpointer) and Contributors
//
// This file is part of Zond Engine, licensed under the GNU Affero General
// Public License, version 3 or later. See the LICENSE file for details, or
// <https://www.gnu.org/licenses/agpl-3.0.html>.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
//! # What the unprivileged paths cannot measure for themselves
//!
//! The timeouts and concurrency ceilings every TCP-connect path runs against.
//! The connect port scanner, the connect discovery sweep, the service-detection
//! pass and the detection tiers all open the same kind of connection for the
//! same purpose, so they share one set of numbers. Spelled separately in each,
//! a budget gets tuned in one place and left behind in the others, and nothing
//! reports the disagreement.
//!
//! Only the connect paths need constants at all. A raw scanner measures the
//! round trips it is getting and sizes its own patience from them, through
//! [`AdaptiveDeadline`](crate::scanner::pacing::deadline::AdaptiveDeadline). A
//! connect probe cannot: it sends one SYN, the kernel owns the retransmission,
//! and the scanner never sees a round trip it could learn from. Its numbers come
//! from what the protocol guarantees instead, and each one below says which
//! guarantee.
use Duration;
/// How long a single TCP connect probe waits before treating silence as a drop.
/// Shared by the connect port and host scanners and by the service-detection
/// connect, which all open the same kind of connection for the same purpose.
///
/// The value is set against **the host stack's first SYN retransmission**, and
/// that is the only thing that decides it. A connect probe sends one SYN and has
/// no retransmission of its own: the operating system's is the only second
/// attempt it gets, and RFC 6298 puts the initial retransmission timeout at one
/// second, which is what Linux and the BSDs both use. A budget at or below a
/// second therefore expires while that retransmission is still in flight, and
/// every host that ignores a first SYN - a rate limiter, a busy embedded stack,
/// any of the SYN-flood mitigations common in consumer routers - is reported
/// `Filtered` when it is merely slow to answer the first time. That failure is
/// silent, total, and looks exactly like a firewall.
///
/// So it sits above one second by enough to cover a round trip on top, and well
/// below three, where the *second* retransmission would arrive: one extra
/// attempt is worth waiting for, a third is a scan that has stopped being a
/// scan. What it costs is half a second per genuinely filtered port, paid only
/// on the unprivileged path, which is the right way round - the raw scanners
/// retransmit for themselves and size their own patience from measured round
/// trips.
///
/// A refusal has to arrive inside the same budget. Unix stacks report one at
/// the first reset. Windows resends a refused SYN until its SYN retransmissions
/// run out, which at its default count outlasts this budget, so there every
/// connection the engine makes keeps only the one retransmission this value
/// waits for.
pub const CONNECT_PROBE_TIMEOUT: Duration = from_millis;
/// The initial retransmission timeout a host TCP stack uses for a SYN
/// (RFC 6298 §2.1), which [`CONNECT_PROBE_TIMEOUT`] has to outlive.
const HOST_SYN_RETRANSMIT: Duration = from_secs;
/// How many targets the connect port scan and the passes after it (service
/// detection, detections, TLS enumeration) work on at once.
///
/// A pace, not a guard on the socket table. What keeps the process's table
/// from filling is its descriptor budget, what the soft file limit leaves
/// once a reserve for the rest of the process is set aside, which every
/// connection a scan opens takes a share of before its socket and waits
/// for when there is none; a table full for other reasons is waited out
/// rather than read as the target's answer. This is how many conversations a
/// pass keeps going, enough that a wide scan is not queued one port deep and
/// few enough that one host is not asked fifty things at the same instant.
pub const CONNECT_CONCURRENCY: usize = 50;
/// How many of one port's detection flows run at once.
///
/// A port's flows are independent conversations that happen to share an address,
/// and an HTTP port attracts dozens of them: forty-seven against the built-in
/// corpus, forty-three of them asking a different question, so a shared reply
/// cache collapses almost none of it. Run one after another that is forty-seven
/// round trips in a row, and a host 140ms away spends ten seconds on detections
/// for a scan whose ports were settled in one.
///
/// It does not raise what a scan opens at once. [`CONNECT_CONCURRENCY`] is still
/// the ceiling on sockets in flight, held by the gate the detection phase
/// acquires a probe through, so this changes how that budget is spent rather
/// than how large it is: it keeps a scan of one host with four web ports from
/// queueing its work one deep, and leaves a scan of two hundred doing the same
/// total work it would one flow at a time.
pub const DETECTION_FLOW_CONCURRENCY: usize = 8;
/// How many connect probes the unprivileged discovery sweep keeps in flight.
/// Far higher than [`CONNECT_CONCURRENCY`] because each probe is a bare liveness
/// check against a handful of ports, not a full fingerprint conversation.
///
/// A ceiling, and not always the one that binds. Each probe in flight holds a
/// socket, and the process may hold only so many: every connect probe takes its
/// socket from a budget of half the process's descriptor limit, less under a
/// very small one, shared by every scan the process runs, so a shell's default
/// of 256 or 1,024 holds a sweep below this and slows it rather than letting
/// it lose the addresses it has no socket for.
pub const DISCOVERY_CONCURRENCY: usize = 2048;
// ╔════════════════════════════════════════════╗
// ║ ████████╗███████╗███████╗████████╗███████╗ ║
// ║ ╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝██╔════╝ ║
// ║ ██║ █████╗ ███████╗ ██║ ███████╗ ║
// ║ ██║ ██╔══╝ ╚════██║ ██║ ╚════██║ ║
// ║ ██║ ███████╗███████║ ██║ ███████║ ║
// ║ ╚═╝ ╚══════╝╚══════╝ ╚═╝ ╚══════╝ ║
// ╚════════════════════════════════════════════╝