zrtp 0.1.0

RFC 6189 ZRTP protocol core, crypto helpers, and embeddable engine
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

use std::collections::VecDeque;
use zrtp::*;

#[derive(Default)]
struct MemoryLink {
    queue: VecDeque<QueuedPacket>,
}

enum QueuedPacket {
    ToA(Vec<u8>),
    ToB(Vec<u8>),
}

impl MemoryLink {
    fn send(&mut self, from_a: bool, packet: Packet) {
        let bytes = packet.encode();
        if from_a {
            self.queue.push_back(QueuedPacket::ToB(bytes));
        } else {
            self.queue.push_back(QueuedPacket::ToA(bytes));
        }
    }

    fn pop(&mut self) -> Option<(bool, Packet)> {
        match self.queue.pop_front()? {
            QueuedPacket::ToA(bytes) => {
                Some((false, Packet::decode(&bytes).expect("valid ZRTP packet")))
            }
            QueuedPacket::ToB(bytes) => {
                Some((true, Packet::decode(&bytes).expect("valid ZRTP packet")))
            }
        }
    }
}

struct Peer {
    is_a: bool,
    sequence: u16,
    ssrc: u32,
    engine: ZrtpEngine<MemorySharedSecretStore>,
}

impl Peer {
    fn new(is_a: bool, role: Role, hello: Hello) -> Self {
        Self {
            is_a,
            sequence: if is_a { 1 } else { 100 },
            ssrc: if is_a { 0x1111_2222 } else { 0x3333_4444 },
            engine: ZrtpEngine::new(role, hello, MemorySharedSecretStore::default()),
        }
    }

    fn emit(&mut self, message: Message, link: &mut MemoryLink) {
        let packet = Packet {
            sequence: self.sequence,
            ssrc: self.ssrc,
            message,
        };
        self.sequence = self.sequence.wrapping_add(1);
        link.send(self.is_a, packet);
    }

    fn handle_packet(&mut self, packet: Packet, link: &mut MemoryLink) {
        let events = self
            .engine
            .receive(&packet.message)
            .expect("ZRTP state transition should succeed");
        for event in events {
            match event {
                EngineEvent::Send(message) => self.emit(message, link),
                EngineEvent::Negotiated(algos) => println!("negotiated: {:?}", algos),
                EngineEvent::SasReady(sas) => println!("SAS ready: {sas}"),
                EngineEvent::SecureOn => println!("secure channel established"),
                EngineEvent::SecureOff => println!("secure channel cleared"),
                EngineEvent::Error(code) => println!("error: {:?}", code),
            }
        }
    }
}

fn hello(zid: [u8; 12], client_id: [u8; 16]) -> Hello {
    Hello {
        version: VERSION_1_10,
        client_id,
        hash_image_h3: [0; 32],
        zid,
        signature_capable: false,
        mitm_capable: false,
        passive_capable: false,
        hashes: vec![algos::HASH_S256],
        ciphers: vec![algos::CIPHER_AES1],
        auth_tags: vec![algos::AUTH_HS32],
        key_agreements: vec![algos::KEYAGREE_EC25],
        sas_types: vec![algos::SAS_B32],
        mac: [0; 8],
    }
}

fn main() {
    let mut link = MemoryLink::default();
    let mut initiator = Peer::new(true, Role::Initiator, hello([1; 12], *b"zrtr-init-demo  "));
    let mut responder = Peer::new(false, Role::Responder, hello([2; 12], *b"zrtr-rsp-demo   "));

    for event in initiator.engine.start() {
        if let EngineEvent::Send(message) = event {
            initiator.emit(message, &mut link);
        }
    }
    for event in responder.engine.start() {
        if let EngineEvent::Send(message) = event {
            responder.emit(message, &mut link);
        }
    }

    while let Some((to_b, packet)) = link.pop() {
        if to_b {
            responder.handle_packet(packet, &mut link);
        } else {
            initiator.handle_packet(packet, &mut link);
        }
    }

    println!("initiator SAS: {:?}", initiator.engine.last_sas());
    println!("responder SAS: {:?}", responder.engine.last_sas());
    println!("initiator state: {:?}", initiator.engine.state());
    println!("responder state: {:?}", responder.engine.state());
}