phantom-protocol 0.1.1

Post-quantum-secure L4/L6 universal transport framework — hybrid X25519+ML-KEM-768 / Ed25519+ML-DSA-65, multi-path, UniFFI bindings
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

//! Integration tests for `phantom_protocol::observability` under the
//! `telemetry-otel` feature. These tests verify that the labeled recording
//! API compiles, runs, and exercises the OTel instrument call graph
//! without crashing. They do NOT spin up a real exporter; that's covered
//! end-to-end in `examples/observability-demo`.
//!
//! Compile-time gated — skipped on default-feature builds.

#![cfg(feature = "telemetry-otel")]

use phantom_protocol::observability::{
    AeadAlgorithm, CookieOutcome, Direction, EarlyDataOutcome, FallbackReason, HandshakeOutcome,
    Observability, ObservabilityConfig, PathValidationOutcome, PowOutcome, ProtocolVersion,
    ReplayReason, ResumptionMode,
};
use phantom_protocol::transport::types::LegType;
use std::time::Duration;

#[test]
fn full_labeled_event_surface_does_not_panic() {
    let obs = Observability::new(ObservabilityConfig::default());

    obs.record_handshake(
        Duration::from_millis(15),
        HandshakeOutcome::Success,
        LegType::Tcp,
        AeadAlgorithm::Aes256Gcm,
        ProtocolVersion::Current,
    );
    obs.record_handshake(
        Duration::from_millis(35),
        HandshakeOutcome::Failure,
        LegType::Kcp,
        AeadAlgorithm::ChaCha20Poly1305,
        ProtocolVersion::Current,
    );

    obs.record_resumption(ResumptionMode::ZeroRtt, true);
    obs.record_resumption(ResumptionMode::OneRtt, false);

    obs.record_replay_rejected(ReplayReason::Duplicate);
    obs.record_replay_rejected(ReplayReason::Old);

    obs.record_aead_failure(LegType::Tcp, AeadAlgorithm::Aes256Gcm);
    obs.record_unencrypted_dropped(LegType::FakeTls);
    obs.record_path_migration(0, 1);
    obs.record_path_validation(Duration::from_millis(8), 1, PathValidationOutcome::Success);

    obs.record_cookie(CookieOutcome::Issued);
    obs.record_cookie(CookieOutcome::ValidatedOk);
    obs.record_cookie(CookieOutcome::ValidatedMismatch);

    obs.record_pow(PowOutcome::Solved, 20);
    obs.record_pow(PowOutcome::Rejected, 22);

    obs.record_early_data(EarlyDataOutcome::Accepted);
    obs.record_early_data(EarlyDataOutcome::RejectedReplay);
    obs.record_early_data(EarlyDataOutcome::RejectedOversized);

    obs.record_rekey(Direction::Send);
    obs.record_rekey(Direction::Recv);

    obs.record_fallback(LegType::Tcp, LegType::Kcp, FallbackReason::RttThreshold);

    obs.session_opened(LegType::Tcp);
    obs.session_closed(LegType::Tcp);
    obs.stream_opened();
    obs.stream_closed();

    // Snapshot still works and reflects atomics drives.
    let s = obs.snapshot();
    assert_eq!(s.handshakes_success, 1);
    assert_eq!(s.handshakes_failure, 1);
    assert_eq!(s.active_sessions, 0);
    assert_eq!(s.active_streams, 0);
}

#[test]
fn observability_handles_are_cheap_to_clone() {
    let obs = Observability::new(ObservabilityConfig::default());
    let a = obs.clone();
    let b = obs.clone();
    a.record_send(1024, LegType::Tcp);
    b.record_send(2048, LegType::Tcp);
    assert_eq!(obs.snapshot().bytes_sent, 3072);
}