tlspuffin/tls/rustls/
record_layer.rs1use crate::tls::rustls::cipher::{MessageDecrypter, MessageEncrypter};
2use crate::tls::rustls::error::Error;
3use crate::tls::rustls::msgs::message::{BorrowedPlainMessage, OpaqueMessage, PlainMessage};
4
5static SEQ_SOFT_LIMIT: u64 = 0xffff_ffff_ffff_0000u64;
6static SEQ_HARD_LIMIT: u64 = 0xffff_ffff_ffff_fffeu64;
7
8#[derive(PartialEq)]
9enum DirectionState {
10 Invalid,
12
13 Prepared,
15
16 Active,
18}
19
20pub struct RecordLayer {
21 message_encrypter: Box<dyn MessageEncrypter>,
22 message_decrypter: Box<dyn MessageDecrypter>,
23 write_seq: u64,
24 read_seq: u64,
25 encrypt_state: DirectionState,
26 decrypt_state: DirectionState,
27
28 trial_decryption_len: Option<usize>,
32}
33
34impl RecordLayer {
35 pub fn new() -> Self {
36 Self {
37 message_encrypter: <dyn MessageEncrypter>::invalid(),
38 message_decrypter: <dyn MessageDecrypter>::invalid(),
39 write_seq: 0,
40 read_seq: 0,
41 encrypt_state: DirectionState::Invalid,
42 decrypt_state: DirectionState::Invalid,
43 trial_decryption_len: None,
44 }
45 }
46
47 pub fn is_encrypting(&self) -> bool {
48 self.encrypt_state == DirectionState::Active
49 }
50
51 pub fn is_decrypting(&self) -> bool {
52 self.decrypt_state == DirectionState::Active
53 }
54
55 pub fn doing_trial_decryption(&mut self, requested: usize) -> bool {
56 match self
57 .trial_decryption_len
58 .and_then(|value| value.checked_sub(requested))
59 {
60 Some(remaining) => {
61 self.trial_decryption_len = Some(remaining);
62 true
63 }
64 _ => false,
65 }
66 }
67
68 pub fn prepare_message_encrypter(&mut self, cipher: Box<dyn MessageEncrypter>) {
71 self.message_encrypter = cipher;
72 self.write_seq = 0;
73 self.encrypt_state = DirectionState::Prepared;
74 }
75
76 pub fn prepare_message_decrypter(&mut self, cipher: Box<dyn MessageDecrypter>) {
79 self.message_decrypter = cipher;
80 self.read_seq = 0;
81 self.decrypt_state = DirectionState::Prepared;
82 }
83
84 pub fn start_encrypting(&mut self) {
87 debug_assert!(self.encrypt_state == DirectionState::Prepared);
88 self.encrypt_state = DirectionState::Active;
89 }
90
91 pub fn start_decrypting(&mut self) {
94 debug_assert!(self.decrypt_state == DirectionState::Prepared);
95 self.decrypt_state = DirectionState::Active;
96 }
97
98 pub fn set_message_encrypter(&mut self, cipher: Box<dyn MessageEncrypter>) {
101 self.prepare_message_encrypter(cipher);
102 self.start_encrypting();
103 }
104
105 pub fn set_message_decrypter(&mut self, cipher: Box<dyn MessageDecrypter>) {
108 self.prepare_message_decrypter(cipher);
109 self.start_decrypting();
110 self.trial_decryption_len = None;
111 }
112
113 pub fn set_message_decrypter_with_trial_decryption(
117 &mut self,
118 cipher: Box<dyn MessageDecrypter>,
119 max_length: usize,
120 ) {
121 self.prepare_message_decrypter(cipher);
122 self.start_decrypting();
123 self.trial_decryption_len = Some(max_length);
124 }
125
126 pub fn finish_trial_decryption(&mut self) {
127 self.trial_decryption_len = None;
128 }
129
130 pub fn wants_close_before_decrypt(&self) -> bool {
139 self.read_seq == SEQ_SOFT_LIMIT
140 }
141
142 pub fn wants_close_before_encrypt(&self) -> bool {
145 self.write_seq == SEQ_SOFT_LIMIT
146 }
147
148 pub fn encrypt_exhausted(&self) -> bool {
151 self.write_seq >= SEQ_HARD_LIMIT
152 }
153
154 pub fn decrypt_incoming(&mut self, encr: OpaqueMessage) -> Result<PlainMessage, Error> {
160 debug_assert!(self.is_decrypting());
161 let seq = self.read_seq;
162 let msg = self.message_decrypter.decrypt(encr, seq)?;
163 self.read_seq += 1;
164 Ok(msg)
165 }
166
167 pub fn encrypt_outgoing(&mut self, plain: BorrowedPlainMessage) -> OpaqueMessage {
172 debug_assert!(self.encrypt_state == DirectionState::Active);
173 assert!(!self.encrypt_exhausted());
174 let seq = self.write_seq;
175 self.write_seq += 1;
176 self.message_encrypter.encrypt(plain, seq).unwrap()
177 }
178}
179
180impl Default for RecordLayer {
181 fn default() -> Self {
182 Self::new()
183 }
184}