citadel_proto 0.13.0

Networking library for the Citadel 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

/*!
# Pre-connection State Container Module

This module manages the state of pre-connection setup in the Citadel Protocol, handling initial handshakes and cryptographic setup.

## Features
- **Stage Tracking**: Manages pre-connection stages
- **Node Type Management**: Handles different node types
- **Cryptographic Setup**: Manages ratchet construction
- **UDP Channel Setup**: Handles UDP channel initialization
- **Ticket Management**: Tracks connection tickets

## Core Components
- `PreConnectState`: Main structure for pre-connection state
- `UdpChannelSender`: Manages UDP channel communication
- `StackedRatchetConstructor`: Handles cryptographic setup
- `NodeType`: Configures node behavior

## Important Notes
1. Pre-connection state is critical for secure setup
2. UDP channels are managed through oneshot channels
3. Ratchet construction must complete before connection
4. Node types affect connection behavior

## Related Components
- `connect_state_container`: Handles main connection
- `peer_kem_state_container`: Manages key exchange
- `packet_processor`: Uses pre-connection state
- `state_container`: Parent state management

*/

use crate::proto::packet_processor::includes::Instant;
use crate::proto::peer::channel::UdpChannel;
use crate::proto::remote::Ticket;
use citadel_crypt::ratchets::Ratchet;
use citadel_io::tokio::sync::oneshot::{channel, Receiver, Sender};
use citadel_wire::hypernode_type::NodeType;

/// For keeping track of the pre-connect state
pub struct PreConnectState<R: Ratchet> {
    pub(crate) last_stage: u8,
    #[allow(dead_code)]
    pub(crate) adjacent_node_type: Option<NodeType>,
    // This entropy_bank should be turned .into() the next toolset once the other side updated
    pub(crate) constructor: Option<R::Constructor>,
    pub(crate) ticket: Option<Ticket>,
    pub(crate) last_packet_time: Option<Instant>,
    pub(crate) udp_channel_oneshot_tx: UdpChannelSender<R>,
    pub(crate) success: bool,
    pub(crate) generated_ratchet: Option<R>,
}

impl<R: Ratchet> PreConnectState<R> {
    pub fn on_packet_received(&mut self) {
        self.last_packet_time = Some(Instant::now());
    }
}

impl<R: Ratchet> Default for PreConnectState<R> {
    fn default() -> Self {
        Self {
            generated_ratchet: None,
            udp_channel_oneshot_tx: UdpChannelSender::empty(),
            constructor: None,
            last_packet_time: None,
            last_stage: 0,
            adjacent_node_type: None,
            success: false,
            ticket: None,
        }
    }
}

pub struct UdpChannelSender<R: Ratchet> {
    pub tx: Option<Sender<UdpChannel<R>>>,
    pub rx: Option<Receiver<UdpChannel<R>>>,
}

impl<R: Ratchet> UdpChannelSender<R> {
    pub(crate) fn empty() -> Self {
        Self { tx: None, rx: None }
    }
}

impl<R: Ratchet> Default for UdpChannelSender<R> {
    fn default() -> Self {
        let (tx, rx) = channel();
        Self {
            tx: Some(tx),
            rx: Some(rx),
        }
    }
}