tf-types 0.1.6

Core semantic types, traits, and schemas powering the TrustForge 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

//! Rust session-migration tests — mirror of TS suite.

use ed25519_dalek::SigningKey;
use rand::rngs::OsRng;
use tf_types::session_migration::{
    migrate_session, verify_session_migration, Ratchet, TransportBinding,
};

fn keypair() -> (SigningKey, [u8; 32]) {
    let s = SigningKey::generate(&mut OsRng);
    let pk = s.verifying_key().to_bytes();
    (s, pk)
}

fn from_binding() -> TransportBinding {
    TransportBinding {
        binding_version: "1".into(),
        kind: "websocket".into(),
        endpoint: Some("wss://daemon.example.com/tf".into()),
        exporter_key: None,
        peer_cert_fingerprint: None,
        tls_alpn: None,
        established_at: Some("2026-04-24T12:00:00Z".into()),
        metadata: None,
    }
}

fn to_binding() -> TransportBinding {
    TransportBinding {
        binding_version: "1".into(),
        kind: "quic".into(),
        endpoint: Some("quic://daemon.example.com:7443".into()),
        exporter_key: None,
        peer_cert_fingerprint: None,
        tls_alpn: None,
        established_at: Some("2026-04-24T12:05:00Z".into()),
        metadata: None,
    }
}

#[test]
fn round_trip_signed_migration_verifies() {
    let (signing, public) = keypair();
    let priv_bytes = signing.to_bytes();
    let m = migrate_session(
        "AAECAwQFBgcICQoLDA0ODw==",
        1,
        from_binding(),
        to_binding(),
        true,
        Some("client roamed; upgrade to QUIC"),
        "tf:actor:agent:example.com/code-helper",
        &priv_bytes,
        None,
    );
    assert_eq!(m.generation, 1);
    assert_eq!(m.rotated_keys, Some(true));
    let v = verify_session_migration(&m, &public, None, Some("AAECAwQFBgcICQoLDA0ODw=="));
    assert!(v.ok, "expected ok, got {:?}", v.reason);
}

#[test]
fn verify_rejects_tampered_to_binding() {
    let (signing, public) = keypair();
    let priv_bytes = signing.to_bytes();
    let mut m = migrate_session(
        "AAECAwQFBgcICQoLDA0ODw==",
        1,
        from_binding(),
        to_binding(),
        false,
        None,
        "tf:actor:agent:example.com/x",
        &priv_bytes,
        None,
    );
    m.to_binding.endpoint = Some("quic://attacker.example.com".into());
    let v = verify_session_migration(&m, &public, None, None);
    assert!(!v.ok);
}

#[test]
fn verify_rejects_replay() {
    let (signing, public) = keypair();
    let priv_bytes = signing.to_bytes();
    let m = migrate_session(
        "AAECAwQFBgcICQoLDA0ODw==",
        1,
        from_binding(),
        to_binding(),
        false,
        None,
        "tf:actor:agent:example.com/x",
        &priv_bytes,
        None,
    );
    let v = verify_session_migration(&m, &public, Some(1), None);
    assert!(!v.ok);
    assert!(v.reason.unwrap_or_default().contains("replay"));
}

#[test]
fn ratchet_rotates_after_max_messages() {
    let mut r = Ratchet::new([1u8; 32], Some(3));
    assert_eq!(r.generation(), 0);
    assert!(!r.observe_message());
    assert!(!r.observe_message());
    assert!(r.observe_message());
    assert_eq!(r.generation(), 1);
}

#[test]
fn two_ratchets_with_same_seed_produce_same_sequence() {
    let mut a = Ratchet::new([7u8; 32], None);
    let mut b = Ratchet::new([7u8; 32], None);
    a.rotate();
    b.rotate();
    assert_eq!(a.key(), b.key());
}