fips-core 0.4.64

Reusable FIPS mesh, endpoint, transport, and protocol library
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

use super::*;

#[tokio::test]
async fn test_handle_mtu_exceeded_writes_path_mtu_lookup_when_empty() {
    use crate::node::tests::spanning_tree::make_test_node;

    let mut tn = make_test_node().await;

    let remote = Identity::generate();
    let dest = *remote.node_addr();
    let reporter = NodeAddr::from_bytes([0xBB; 16]);
    let dest_fips = crate::FipsAddress::from_node_addr(&dest);
    install_established_session_with_mmp(&mut tn.node, &remote);
    note_sent_wire_len(&mut tn.node, dest, 1400);

    assert!(
        tn.node.path_mtu_lookup_get(&dest_fips).is_none(),
        "lookup should start empty for this destination"
    );

    let inner = build_mtu_exceeded_inner(&dest, &reporter, 1280);
    tn.node.handle_mtu_exceeded(&reporter, &inner).await;

    assert_eq!(
        tn.node.path_mtu_lookup_get(&dest_fips),
        Some(1280),
        "MtuExceeded should populate path_mtu_lookup with the bottleneck MTU"
    );
}

#[tokio::test]
async fn test_handle_mtu_exceeded_tightens_existing_path_mtu_lookup() {
    use crate::node::tests::spanning_tree::make_test_node;

    let mut tn = make_test_node().await;

    let remote = Identity::generate();
    let dest = *remote.node_addr();
    let reporter = NodeAddr::from_bytes([0xBB; 16]);
    let dest_fips = crate::FipsAddress::from_node_addr(&dest);
    install_established_session_with_mmp(&mut tn.node, &remote);
    note_sent_wire_len(&mut tn.node, dest, 1400);

    // Pre-seed with a generous value (e.g., from a discovery reverse-path
    // response that didn't reflect the forward-path bottleneck).
    tn.node.path_mtu_lookup_insert(dest_fips, 1500);

    let inner = build_mtu_exceeded_inner(&dest, &reporter, 1280);
    tn.node.handle_mtu_exceeded(&reporter, &inner).await;

    assert_eq!(
        tn.node.path_mtu_lookup_get(&dest_fips),
        Some(1280),
        "MtuExceeded with smaller bottleneck must tighten the lookup"
    );
}

#[tokio::test]
async fn test_handle_mtu_exceeded_keeps_tighter_existing_path_mtu_lookup() {
    use crate::node::tests::spanning_tree::make_test_node;

    let mut tn = make_test_node().await;

    let remote = Identity::generate();
    let dest = *remote.node_addr();
    let reporter = NodeAddr::from_bytes([0xBB; 16]);
    let dest_fips = crate::FipsAddress::from_node_addr(&dest);
    install_established_session_with_mmp(&mut tn.node, &remote);
    note_sent_wire_len(&mut tn.node, dest, 1600);

    // Pre-seed with a tighter value than the incoming signal (e.g., from
    // a prior reactive event on a narrower hop). The clamp must never
    // loosen — keep the existing value.
    tn.node.path_mtu_lookup_insert(dest_fips, 1280);

    let inner = build_mtu_exceeded_inner(&dest, &reporter, 1500);
    tn.node.handle_mtu_exceeded(&reporter, &inner).await;

    assert_eq!(
        tn.node.path_mtu_lookup_get(&dest_fips),
        Some(1280),
        "MtuExceeded with looser bottleneck must not loosen a tighter existing value"
    );
}

#[tokio::test]
async fn test_handle_mtu_exceeded_ignores_unbound_destination() {
    use crate::node::tests::spanning_tree::make_test_node;

    let mut tn = make_test_node().await;
    let dest = NodeAddr::from_bytes([0xCC; 16]);
    let reporter = NodeAddr::from_bytes([0xBB; 16]);
    let dest_fips = crate::FipsAddress::from_node_addr(&dest);

    let inner = build_mtu_exceeded_inner(&dest, &reporter, 1280);
    tn.node.handle_mtu_exceeded(&reporter, &inner).await;

    assert_eq!(tn.node.path_mtu_lookup_get(&dest_fips), None);
    assert_eq!(tn.node.stats().errors.mtu_exceeded_unbound, 1);
}

#[tokio::test]
async fn test_handle_mtu_exceeded_ignores_sub_floor_value() {
    use crate::node::tests::spanning_tree::make_test_node;

    let mut tn = make_test_node().await;
    let remote = Identity::generate();
    let dest = *remote.node_addr();
    let reporter = NodeAddr::from_bytes([0xBB; 16]);
    let dest_fips = crate::FipsAddress::from_node_addr(&dest);
    install_established_session_with_mmp(&mut tn.node, &remote);
    note_sent_wire_len(&mut tn.node, dest, 1400);

    let inner = build_mtu_exceeded_inner(&dest, &reporter, 128);
    tn.node.handle_mtu_exceeded(&reporter, &inner).await;

    assert_eq!(tn.node.path_mtu_lookup_get(&dest_fips), None);
    assert_eq!(tn.node.stats().errors.mtu_exceeded_below_floor, 1);
}

#[tokio::test]
async fn test_handle_mtu_exceeded_requires_fresh_sent_size_evidence() {
    use crate::node::tests::spanning_tree::make_test_node;

    let mut tn = make_test_node().await;
    let remote = Identity::generate();
    let dest = *remote.node_addr();
    let reporter = NodeAddr::from_bytes([0xBB; 16]);
    let dest_fips = crate::FipsAddress::from_node_addr(&dest);
    install_established_session_with_mmp(&mut tn.node, &remote);
    let inner = build_mtu_exceeded_inner(&dest, &reporter, 1280);

    tn.node.handle_mtu_exceeded(&reporter, &inner).await;
    assert_eq!(tn.node.path_mtu_lookup_get(&dest_fips), None);
    assert_eq!(tn.node.stats().errors.mtu_exceeded_uncorroborated, 1);

    note_sent_wire_len(&mut tn.node, dest, 1400);
    tn.node.handle_mtu_exceeded(&reporter, &inner).await;
    assert_eq!(tn.node.path_mtu_lookup_get(&dest_fips), Some(1280));

    tn.node.handle_mtu_exceeded(&reporter, &inner).await;
    assert_eq!(tn.node.stats().errors.mtu_exceeded_uncorroborated, 2);
}

// ============================================================================
// Proactive PathMtuNotification → path_mtu_lookup focused unit tests
//
// These exercise the receive-side write path that mirrors the proactive
// end-to-end echo into `path_mtu_lookup`. Without this mirror, new TCP
// flows opened on a path the proactive notification has tightened keep
// getting clamped by the staler discovery-time value until a reactive
// MtuExceeded fires for those flows — long-lived stable paths can sit
// in the gap indefinitely.
// ============================================================================