typhoon-protocol 0.1.0

A sample implementation of TYPHOON protocol
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

//! Static setting keys and protocol constants.

pub mod keys {
    use super::super::override_map::Key;

    // RTT settings
    pub const RTT_ALPHA: Key<f64> = Key::new("TYPHOON_RTT_ALPHA", 0.125);
    pub const RTT_BETA: Key<f64> = Key::new("TYPHOON_RTT_BETA", 0.25);
    pub const RTT_DEFAULT: Key<u64> = Key::new("TYPHOON_RTT_DEFAULT", 5000);
    pub const RTT_MIN: Key<u64> = Key::new("TYPHOON_RTT_MIN", 200);
    pub const RTT_MAX: Key<u64> = Key::new("TYPHOON_RTT_MAX", 8000);

    // Timeout settings
    pub const TIMEOUT_DEFAULT: Key<u64> = Key::new("TYPHOON_TIMEOUT_DEFAULT", 30000);
    pub const TIMEOUT_MIN: Key<u64> = Key::new("TYPHOON_TIMEOUT_MIN", 4000);
    pub const TIMEOUT_MAX: Key<u64> = Key::new("TYPHOON_TIMEOUT_MAX", 32000);
    pub const TIMEOUT_RTT_FACTOR: Key<f64> = Key::new("TYPHOON_TIMEOUT_RTT_FACTOR", 5.0);

    // Health check settings
    pub const HEALTH_CHECK_NEXT_IN_MIN: Key<u64> = Key::new("TYPHOON_HEALTH_CHECK_NEXT_IN_MIN", 64_000);
    pub const HEALTH_CHECK_NEXT_IN_MAX: Key<u64> = Key::new("TYPHOON_HEALTH_CHECK_NEXT_IN_MAX", 256_000);
    pub const HANDSHAKE_NEXT_IN_FACTOR: Key<f64> = Key::new("TYPHOON_HANDSHAKE_NEXT_IN_FACTOR", 0.02);
    pub const MAX_RETRIES: Key<u64> = Key::new("TYPHOON_MAX_RETRIES", 12);
    pub const RECEIVE_BUFFER_SIZE: Key<u64> = Key::new("TYPHOON_RECEIVE_BUFFER_SIZE", 512);

    // Send-bytes chunking jitter
    pub const SEND_BYTES_JITTER: Key<f64> = Key::new("TYPHOON_SEND_BYTES_JITTER", 0.2);
    // Send-bytes target chunk size. `0` means "use `max_user_payload`".
    pub const SEND_BYTES_CHUNK: Key<u64> = Key::new("TYPHOON_SEND_BYTES_CHUNK", 0);

    // Fake body/header settings
    pub const FAKE_BODY_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_FAKE_BODY_LENGTH_MIN", 32);
    pub const FAKE_BODY_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_FAKE_BODY_LENGTH_MAX", 512);
    pub const FAKE_BODY_CONSTANT_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_FAKE_BODY_CONSTANT_LENGTH_MIN", 256);
    pub const FAKE_BODY_CONSTANT_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_FAKE_BODY_CONSTANT_LENGTH_MAX", 1400);
    pub const FAKE_HEADER_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_LENGTH_MIN", 4);
    pub const FAKE_HEADER_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_LENGTH_MAX", 32);
    pub const FAKE_HEADER_PROBABILITY: Key<f64> = Key::new("TYPHOON_FAKE_HEADER_PROBABILITY", 0.60);

    // Per-flow probability that a generated decoy packet bypasses the tailer step
    pub const DECOY_FALLTHROUGH_PACKETS_MIN: Key<f64> = Key::new("TYPHOON_DECOY_FALLTHROUGH_PACKETS_MIN", 0.0);
    pub const DECOY_FALLTHROUGH_PACKETS_MAX: Key<f64> = Key::new("TYPHOON_DECOY_FALLTHROUGH_PACKETS_MAX", 0.25);

    // Fake body mode selection weights.
    pub const FAKE_BODY_WEIGHT_EMPTY: Key<u64> = Key::new("TYPHOON_FAKE_BODY_WEIGHT_EMPTY", 1);
    pub const FAKE_BODY_WEIGHT_RANDOM: Key<u64> = Key::new("TYPHOON_FAKE_BODY_WEIGHT_RANDOM", 5);
    pub const FAKE_BODY_WEIGHT_CONSTANT: Key<u64> = Key::new("TYPHOON_FAKE_BODY_WEIGHT_CONSTANT", 1);
    pub const FAKE_BODY_WEIGHT_SERVICE: Key<u64> = Key::new("TYPHOON_FAKE_BODY_WEIGHT_SERVICE", 1);

    // Fake header field type selection weights
    pub const FAKE_HEADER_FIELD_WEIGHT_RANDOM: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_FIELD_WEIGHT_RANDOM", 1);
    pub const FAKE_HEADER_FIELD_WEIGHT_CONSTANT: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_FIELD_WEIGHT_CONSTANT", 1);
    pub const FAKE_HEADER_FIELD_WEIGHT_VOLATILE: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_FIELD_WEIGHT_VOLATILE", 1);
    pub const FAKE_HEADER_FIELD_WEIGHT_SWITCHING: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_FIELD_WEIGHT_SWITCHING", 1);
    pub const FAKE_HEADER_FIELD_WEIGHT_INCREMENTAL: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_FIELD_WEIGHT_INCREMENTAL", 1);

    // Volatile field-type change probability range (per-field draw at flow init).
    pub const FAKE_HEADER_VOLATILE_CHANGE_PROB_MIN: Key<f64> = Key::new("TYPHOON_FAKE_HEADER_VOLATILE_CHANGE_PROB_MIN", 0.01);
    pub const FAKE_HEADER_VOLATILE_CHANGE_PROB_MAX: Key<f64> = Key::new("TYPHOON_FAKE_HEADER_VOLATILE_CHANGE_PROB_MAX", 0.20);
    // Switching field-type timeout range in milliseconds (per-field draw at flow init).
    pub const FAKE_HEADER_SWITCHING_TIMEOUT_MIN_MS: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_SWITCHING_TIMEOUT_MIN_MS", 1000);
    pub const FAKE_HEADER_SWITCHING_TIMEOUT_MAX_MS: Key<u64> = Key::new("TYPHOON_FAKE_HEADER_SWITCHING_TIMEOUT_MAX_MS", 30000);

    // Decoy general settings
    pub const DECOY_REFERENCE_PACKET_RATE_DEFAULT: Key<f64> = Key::new("TYPHOON_DECOY_REFERENCE_PACKET_RATE_DEFAULT", 200.0);
    pub const DECOY_CURRENT_PACKET_RATE_DEFAULT: Key<f64> = Key::new("TYPHOON_DECOY_CURRENT_PACKET_RATE_DEFAULT", 1.0);
    pub const DECOY_CURRENT_BYTE_RATE_DEFAULT: Key<f64> = Key::new("TYPHOON_DECOY_CURRENT_BYTE_RATE_DEFAULT", 5000.0);
    pub const DECOY_BYTE_RATE_CAP: Key<f64> = Key::new("TYPHOON_DECOY_BYTE_RATE_CAP", 1_000_000.0);
    pub const DECOY_BYTE_RATE_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_BYTE_RATE_FACTOR", 3.0);
    pub const DECOY_CURRENT_ALPHA: Key<f64> = Key::new("TYPHOON_DECOY_CURRENT_ALPHA", 0.05);
    pub const DECOY_REFERENCE_ALPHA: Key<f64> = Key::new("TYPHOON_DECOY_REFERENCE_ALPHA", 0.001);
    pub const DECOY_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_DECOY_LENGTH_MAX", 1400);
    pub const DECOY_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_DECOY_LENGTH_MIN", 64);
    pub const DECOY_BASE_RATE_RND: Key<f64> = Key::new("TYPHOON_DECOY_BASE_RATE_RND", 0.25);

    // Decoy heavy settings
    pub const DECOY_HEAVY_BASE_RATE: Key<f64> = Key::new("TYPHOON_DECOY_HEAVY_BASE_RATE", 0.1);
    pub const DECOY_HEAVY_QUIETNESS_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_HEAVY_QUIETNESS_FACTOR", 3.0);
    pub const DECOY_HEAVY_DELAY_MIN: Key<u64> = Key::new("TYPHOON_DECOY_HEAVY_DELAY_MIN", 5000);
    pub const DECOY_HEAVY_DELAY_MAX: Key<u64> = Key::new("TYPHOON_DECOY_HEAVY_DELAY_MAX", 300_000);
    pub const DECOY_HEAVY_DELAY_DEFAULT: Key<u64> = Key::new("TYPHOON_DECOY_HEAVY_DELAY_DEFAULT", 64000);
    pub const DECOY_HEAVY_BASE_LENGTH: Key<f64> = Key::new("TYPHOON_DECOY_HEAVY_BASE_LENGTH", 0.7);
    pub const DECOY_HEAVY_QUIETNESS_LENGTH: Key<f64> = Key::new("TYPHOON_DECOY_HEAVY_QUIETNESS_LENGTH", 0.3);
    pub const DECOY_HEAVY_DECOY_LENGTH_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_HEAVY_DECOY_LENGTH_FACTOR", 0.8);
    pub const DECOY_HEAVY_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_DECOY_HEAVY_LENGTH_MIN", 560);

    // Decoy noisy settings
    pub const DECOY_NOISY_BASE_RATE: Key<f64> = Key::new("TYPHOON_DECOY_NOISY_BASE_RATE", 5.0);
    pub const DECOY_NOISY_DELAY_MIN: Key<u64> = Key::new("TYPHOON_DECOY_NOISY_DELAY_MIN", 30);
    pub const DECOY_NOISY_DELAY_MAX: Key<u64> = Key::new("TYPHOON_DECOY_NOISY_DELAY_MAX", 2000);
    pub const DECOY_NOISY_DELAY_DEFAULT: Key<u64> = Key::new("TYPHOON_DECOY_NOISY_DELAY_DEFAULT", 500);
    pub const DECOY_NOISY_DECOY_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_DECOY_NOISY_DECOY_LENGTH_MIN", 64);
    pub const DECOY_NOISY_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_DECOY_NOISY_LENGTH_MAX", 800);
    pub const DECOY_NOISY_DECOY_LENGTH_JITTER: Key<f64> = Key::new("TYPHOON_DECOY_NOISY_DECOY_LENGTH_JITTER", 0.3);

    // Decoy sparse settings
    pub const DECOY_SPARSE_BASE_RATE: Key<f64> = Key::new("TYPHOON_DECOY_SPARSE_BASE_RATE", 20.0);
    pub const DECOY_SPARSE_RATE_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_SPARSE_RATE_FACTOR", 3.0);
    pub const DECOY_SPARSE_JITTER: Key<f64> = Key::new("TYPHOON_DECOY_SPARSE_JITTER", 0.15);
    pub const DECOY_SPARSE_DELAY_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_SPARSE_DELAY_FACTOR", 3.0);
    pub const DECOY_SPARSE_DELAY_MIN: Key<u64> = Key::new("TYPHOON_DECOY_SPARSE_DELAY_MIN", 30);
    pub const DECOY_SPARSE_DELAY_MAX: Key<u64> = Key::new("TYPHOON_DECOY_SPARSE_DELAY_MAX", 2000);
    pub const DECOY_SPARSE_DELAY_DEFAULT: Key<u64> = Key::new("TYPHOON_DECOY_SPARSE_DELAY_DEFAULT", 100);
    pub const DECOY_SPARSE_LENGTH_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_SPARSE_LENGTH_FACTOR", 700.0);
    pub const DECOY_SPARSE_LENGTH_SIGMA: Key<f64> = Key::new("TYPHOON_DECOY_SPARSE_LENGTH_SIGMA", 250.0);
    pub const DECOY_SPARSE_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_DECOY_SPARSE_LENGTH_MIN", 64);
    pub const DECOY_SPARSE_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_DECOY_SPARSE_LENGTH_MAX", 1400);

    // Decoy smooth settings
    pub const DECOY_SMOOTH_BASE_RATE: Key<f64> = Key::new("TYPHOON_DECOY_SMOOTH_BASE_RATE", 0.3);
    pub const DECOY_SMOOTH_QUIETNESS_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_SMOOTH_QUIETNESS_FACTOR", 2.0);
    pub const DECOY_SMOOTH_RATE_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_SMOOTH_RATE_FACTOR", 3.0);
    pub const DECOY_SMOOTH_JITTER: Key<f64> = Key::new("TYPHOON_DECOY_SMOOTH_JITTER", 0.2);
    pub const DECOY_SMOOTH_DELAY_FACTOR: Key<f64> = Key::new("TYPHOON_DECOY_SMOOTH_DELAY_FACTOR", 2.0);
    pub const DECOY_SMOOTH_DELAY_MIN: Key<u64> = Key::new("TYPHOON_DECOY_SMOOTH_DELAY_MIN", 300);
    pub const DECOY_SMOOTH_DELAY_MAX: Key<u64> = Key::new("TYPHOON_DECOY_SMOOTH_DELAY_MAX", 300_000);
    pub const DECOY_SMOOTH_DELAY_DEFAULT: Key<u64> = Key::new("TYPHOON_DECOY_SMOOTH_DELAY_DEFAULT", 5000);
    pub const DECOY_SMOOTH_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_DECOY_SMOOTH_LENGTH_MIN", 48);
    pub const DECOY_SMOOTH_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_DECOY_SMOOTH_LENGTH_MAX", 1100);

    // Decoy maintenance settings
    pub const DECOY_MAINTENANCE_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_LENGTH_MIN", 250);
    pub const DECOY_MAINTENANCE_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_LENGTH_MAX", 250);
    pub const DECOY_MAINTENANCE_DELAY_MIN: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_DELAY_MIN", 3000);
    pub const DECOY_MAINTENANCE_DELAY_MAX: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_DELAY_MAX", 720_000);

    // Decoy maintenance mode selection weights
    pub const DECOY_MAINTENANCE_WEIGHT_NONE: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_WEIGHT_NONE", 3);
    pub const DECOY_MAINTENANCE_WEIGHT_RANDOM: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_WEIGHT_RANDOM", 1);
    pub const DECOY_MAINTENANCE_WEIGHT_TIMED: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_WEIGHT_TIMED", 1);
    pub const DECOY_MAINTENANCE_WEIGHT_SIZED: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_WEIGHT_SIZED", 1);
    pub const DECOY_MAINTENANCE_WEIGHT_BOTH: Key<u64> = Key::new("TYPHOON_DECOY_MAINTENANCE_WEIGHT_BOTH", 1);

    // Decoy replication settings
    pub const DECOY_REPLICATION_PROBABILITY_MIN: Key<f64> = Key::new("TYPHOON_DECOY_REPLICATION_PROBABILITY_MIN", 0.01);
    pub const DECOY_REPLICATION_PROBABILITY_MAX: Key<f64> = Key::new("TYPHOON_DECOY_REPLICATION_PROBABILITY_MAX", 0.1);
    pub const DECOY_REPLICATION_PROBABILITY_REDUCE: Key<f64> = Key::new("TYPHOON_DECOY_REPLICATION_PROBABILITY_REDUCE", 3.0);
    pub const DECOY_REPLICATION_DELAY_MIN: Key<u64> = Key::new("TYPHOON_DECOY_REPLICATION_DELAY_MIN", 2500);
    pub const DECOY_REPLICATION_DELAY_MAX: Key<u64> = Key::new("TYPHOON_DECOY_REPLICATION_DELAY_MAX", 10000);

    // Decoy replication mode selection weights
    pub const DECOY_REPLICATION_WEIGHT_NONE: Key<u64> = Key::new("TYPHOON_DECOY_REPLICATION_WEIGHT_NONE", 3);
    pub const DECOY_REPLICATION_WEIGHT_MAINTENANCE: Key<u64> = Key::new("TYPHOON_DECOY_REPLICATION_WEIGHT_MAINTENANCE", 1);
    pub const DECOY_REPLICATION_WEIGHT_ALL: Key<u64> = Key::new("TYPHOON_DECOY_REPLICATION_WEIGHT_ALL", 1);

    // Decoy subheader settings
    pub const DECOY_SUBHEADER_LENGTH_MIN: Key<u64> = Key::new("TYPHOON_DECOY_SUBHEADER_LENGTH_MIN", 4);
    pub const DECOY_SUBHEADER_LENGTH_MAX: Key<u64> = Key::new("TYPHOON_DECOY_SUBHEADER_LENGTH_MAX", 16);

    // Decoy subheader mode selection weights
    pub const DECOY_SUBHEADER_WEIGHT_NONE: Key<u64> = Key::new("TYPHOON_DECOY_SUBHEADER_WEIGHT_NONE", 1);
    pub const DECOY_SUBHEADER_WEIGHT_MAINTENANCE: Key<u64> = Key::new("TYPHOON_DECOY_SUBHEADER_WEIGHT_MAINTENANCE", 1);
    pub const DECOY_SUBHEADER_WEIGHT_ALL: Key<u64> = Key::new("TYPHOON_DECOY_SUBHEADER_WEIGHT_ALL", 1);

    // Decoy provider (communication mode) selection weights
    pub const DECOY_PROVIDER_WEIGHT_SIMPLE: Key<u64> = Key::new("TYPHOON_DECOY_PROVIDER_WEIGHT_SIMPLE", 2);
    pub const DECOY_PROVIDER_WEIGHT_SPARSE: Key<u64> = Key::new("TYPHOON_DECOY_PROVIDER_WEIGHT_SPARSE", 2);
    pub const DECOY_PROVIDER_WEIGHT_NOISY: Key<u64> = Key::new("TYPHOON_DECOY_PROVIDER_WEIGHT_NOISY", 1);
    pub const DECOY_PROVIDER_WEIGHT_SMOOTH: Key<u64> = Key::new("TYPHOON_DECOY_PROVIDER_WEIGHT_SMOOTH", 3);
    pub const DECOY_PROVIDER_WEIGHT_HEAVY: Key<u64> = Key::new("TYPHOON_DECOY_PROVIDER_WEIGHT_HEAVY", 1);

    // Channel capacity settings
    /// Capacity of the per-flow drain channel (packets buffered between drain task and route task).
    /// Excess packets are dropped by the drain task to keep the socket buffer empty.
    pub const DRAIN_CHANNEL_CAPACITY: Key<u64> = Key::new("TYPHOON_DRAIN_CHANNEL_CAPACITY", 8192);

    // Debug settings
    /// Number of probes sent during the throughput phase.
    pub const DEBUG_PROBE_COUNT: Key<u64> = Key::new("TYPHOON_DEBUG_PROBE_COUNT", 10);
    /// Payload size in bytes of each throughput probe.
    pub const DEBUG_PROBE_SIZE: Key<u64> = Key::new("TYPHOON_DEBUG_PROBE_SIZE", 65000);
    /// Per-probe receive timeout in milliseconds.
    pub const DEBUG_PROBE_TIMEOUT: Key<u64> = Key::new("TYPHOON_DEBUG_PROBE_TIMEOUT", 5000);
}

pub mod consts {
    pub const DEFAULT_POOL_INITIAL_SIZE: usize = 128;
    pub const DEFAULT_POOL_CAPACITY: usize = 2 << 15;
    pub const DEFAULT_TYPHOON_MTU_LENGTH: usize = 1500;
    pub const DEFAULT_TYPHOON_ID_LENGTH: usize = 16;
    pub const TAILER_LENGTH: usize = 16;
    pub const FG_OFFSET: usize = 0;
    pub const CD_OFFSET: usize = 1;
    pub const TM_OFFSET: usize = 2;
    pub const PN_OFFSET: usize = 6;
    pub const PL_OFFSET: usize = 14;
    pub const ID_OFFSET: usize = 16;
}