cmr-core 0.2.0

Core protocol/parser/router primitives for Competitive Message Routing (CMR).
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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

//! Router security and routing policy.

use serde::{Deserialize, Serialize};

/// Global security posture.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum SecurityLevel {
    /// Strict defaults for untrusted internet peers.
    #[default]
    Strict,
    /// Balanced defaults for mixed deployments.
    Balanced,
    /// Trusted peers where performance matters most.
    Trusted,
}

/// Throughput and anti-flood policy.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ThroughputPolicy {
    /// Max inbound messages per peer per minute.
    pub per_peer_messages_per_minute: u32,
    /// Max inbound bytes per peer per minute.
    pub per_peer_bytes_per_minute: u64,
    /// Max total inbound messages per minute.
    pub global_messages_per_minute: u32,
    /// Max total inbound bytes per minute.
    pub global_bytes_per_minute: u64,
    /// Max forwarding fanout produced by one accepted message.
    pub max_forward_actions: usize,
}

/// Spam and semantic match policy.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SpamPolicy {
    /// Minimum intrinsic dependence accepted for untrusted payloads.
    pub min_intrinsic_dependence: f64,
    /// Maximum raw Section 3.2 match distance for forwarding gates.
    pub max_match_distance: f64,
    /// Estimator order for intrinsic-dependence checks.
    pub intrinsic_dependence_order: i64,
}

/// Identity/trust and reputation policy.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TrustPolicy {
    /// Minimum score required to accept traffic from a peer.
    pub min_reputation_score: f64,
    /// Require signatures from known peers that already have a shared key.
    pub require_signatures_from_known_peers: bool,
    /// Reject signed messages when no key exists for the immediate sender.
    pub reject_signed_without_known_key: bool,
    /// Allow unsigned messages from unknown peers.
    pub allow_unsigned_from_unknown_peers: bool,
    /// Max outbound/inbound byte ratio before throttling peer.
    pub max_outbound_inbound_ratio: f64,
    /// Automatic key-exchange method for unknown peers.
    #[serde(default)]
    pub auto_key_exchange_mode: AutoKeyExchangeMode,
}

/// Automatic first-contact key-exchange method.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum AutoKeyExchangeMode {
    /// Initiate RSA key exchange.
    #[default]
    Rsa,
    /// Initiate Diffie-Hellman key exchange.
    Dh,
}

/// Content safety policy.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ContentPolicy {
    /// Max full message size.
    pub max_message_bytes: usize,
    /// Max body size.
    pub max_body_bytes: usize,
    /// Max header hop count.
    pub max_header_ids: usize,
    /// Allow non-text/binary payloads.
    pub allow_binary_payloads: bool,
    /// Drop likely executable payloads unless peer is trusted.
    pub block_executable_magic: bool,
}

/// Full router policy.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RoutingPolicy {
    /// High-level security posture.
    pub security_level: SecurityLevel,
    /// Throughput controls.
    pub throughput: ThroughputPolicy,
    /// Spam controls.
    pub spam: SpamPolicy,
    /// Trust controls.
    pub trust: TrustPolicy,
    /// Content controls.
    pub content: ContentPolicy,
    /// Max messages retained in cache.
    pub cache_max_messages: usize,
    /// Max bytes retained in cache.
    pub cache_max_bytes: usize,
}

impl RoutingPolicy {
    /// Default policy for a chosen security level.
    #[must_use]
    pub fn for_level(level: SecurityLevel) -> Self {
        match level {
            SecurityLevel::Strict => Self {
                security_level: level,
                throughput: ThroughputPolicy {
                    per_peer_messages_per_minute: 240,
                    per_peer_bytes_per_minute: 8 * 1024 * 1024,
                    global_messages_per_minute: 20_000,
                    global_bytes_per_minute: 512 * 1024 * 1024,
                    max_forward_actions: 64,
                },
                spam: SpamPolicy {
                    min_intrinsic_dependence: 0.02,
                    max_match_distance: 500.0,
                    intrinsic_dependence_order: 8,
                },
                trust: TrustPolicy {
                    min_reputation_score: -20.0,
                    require_signatures_from_known_peers: true,
                    reject_signed_without_known_key: true,
                    allow_unsigned_from_unknown_peers: true,
                    max_outbound_inbound_ratio: 1.8,
                    auto_key_exchange_mode: AutoKeyExchangeMode::Rsa,
                },
                content: ContentPolicy {
                    max_message_bytes: 4 * 1024 * 1024,
                    max_body_bytes: 2 * 1024 * 1024,
                    max_header_ids: 1024,
                    allow_binary_payloads: true,
                    block_executable_magic: true,
                },
                cache_max_messages: 200_000,
                cache_max_bytes: 2 * 1024 * 1024 * 1024,
            },
            SecurityLevel::Balanced => Self {
                security_level: level,
                throughput: ThroughputPolicy {
                    per_peer_messages_per_minute: 600,
                    per_peer_bytes_per_minute: 16 * 1024 * 1024,
                    global_messages_per_minute: 40_000,
                    global_bytes_per_minute: 1024 * 1024 * 1024,
                    max_forward_actions: 128,
                },
                spam: SpamPolicy {
                    min_intrinsic_dependence: 0.01,
                    max_match_distance: 700.0,
                    intrinsic_dependence_order: 8,
                },
                trust: TrustPolicy {
                    min_reputation_score: -40.0,
                    require_signatures_from_known_peers: true,
                    reject_signed_without_known_key: false,
                    allow_unsigned_from_unknown_peers: true,
                    max_outbound_inbound_ratio: 2.5,
                    auto_key_exchange_mode: AutoKeyExchangeMode::Rsa,
                },
                content: ContentPolicy {
                    max_message_bytes: 8 * 1024 * 1024,
                    max_body_bytes: 4 * 1024 * 1024,
                    max_header_ids: 2048,
                    allow_binary_payloads: true,
                    block_executable_magic: true,
                },
                cache_max_messages: 400_000,
                cache_max_bytes: 4 * 1024 * 1024 * 1024,
            },
            SecurityLevel::Trusted => Self {
                security_level: level,
                throughput: ThroughputPolicy {
                    per_peer_messages_per_minute: 6_000,
                    per_peer_bytes_per_minute: 128 * 1024 * 1024,
                    global_messages_per_minute: 200_000,
                    global_bytes_per_minute: 8 * 1024 * 1024 * 1024,
                    max_forward_actions: 512,
                },
                spam: SpamPolicy {
                    min_intrinsic_dependence: 0.0,
                    max_match_distance: 800.0,
                    intrinsic_dependence_order: 8,
                },
                trust: TrustPolicy {
                    min_reputation_score: -80.0,
                    require_signatures_from_known_peers: false,
                    reject_signed_without_known_key: false,
                    allow_unsigned_from_unknown_peers: true,
                    max_outbound_inbound_ratio: 4.0,
                    auto_key_exchange_mode: AutoKeyExchangeMode::Rsa,
                },
                content: ContentPolicy {
                    max_message_bytes: 16 * 1024 * 1024,
                    max_body_bytes: 12 * 1024 * 1024,
                    max_header_ids: 4096,
                    allow_binary_payloads: true,
                    block_executable_magic: false,
                },
                cache_max_messages: 1_000_000,
                cache_max_bytes: 16 * 1024 * 1024 * 1024,
            },
        }
    }
}

impl Default for RoutingPolicy {
    fn default() -> Self {
        Self::for_level(SecurityLevel::Strict)
    }
}