]> git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/crypto/chacha20poly1305rfc.rs
Adapt intro node process_pending_htlcs test for non-intro nodes
[rust-lightning] / lightning / src / crypto / chacha20poly1305rfc.rs
1 // ring has a garbage API so its use is avoided, but rust-crypto doesn't have RFC-variant poly1305
2 // Instead, we steal rust-crypto's implementation and tweak it to match the RFC.
3 //
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
8 // licenses.
9 //
10 // This is a port of Andrew Moons poly1305-donna
11 // https://github.com/floodyberry/poly1305-donna
12
13 #[cfg(not(fuzzing))]
14 mod real_chachapoly {
15         use super::super::chacha20::ChaCha20;
16         use super::super::poly1305::Poly1305;
17         use super::super::fixed_time_eq;
18
19         #[derive(Clone, Copy)]
20         pub struct ChaCha20Poly1305RFC {
21                 cipher: ChaCha20,
22                 mac: Poly1305,
23                 finished: bool,
24                 data_len: usize,
25                 aad_len: u64,
26         }
27
28         impl ChaCha20Poly1305RFC {
29                 #[inline]
30                 fn pad_mac_16(mac: &mut Poly1305, len: usize) {
31                         if len % 16 != 0 {
32                                 mac.input(&[0; 16][0..16 - (len % 16)]);
33                         }
34                 }
35                 pub fn new(key: &[u8], nonce: &[u8], aad: &[u8]) -> ChaCha20Poly1305RFC {
36                         assert!(key.len() == 16 || key.len() == 32);
37                         assert!(nonce.len() == 12);
38
39                         // Ehh, I'm too lazy to *also* tweak ChaCha20 to make it RFC-compliant
40                         assert!(nonce[0] == 0 && nonce[1] == 0 && nonce[2] == 0 && nonce[3] == 0);
41
42                         let mut cipher = ChaCha20::new(key, &nonce[4..]);
43                         let mut mac_key = [0u8; 64];
44                         let zero_key = [0u8; 64];
45                         cipher.process(&zero_key, &mut mac_key);
46
47                         let mut mac = Poly1305::new(&mac_key[..32]);
48                         mac.input(aad);
49                         ChaCha20Poly1305RFC::pad_mac_16(&mut mac, aad.len());
50
51                         ChaCha20Poly1305RFC {
52                                 cipher,
53                                 mac,
54                                 finished: false,
55                                 data_len: 0,
56                                 aad_len: aad.len() as u64,
57                         }
58                 }
59
60                 pub fn encrypt(&mut self, input: &[u8], output: &mut [u8], out_tag: &mut [u8]) {
61                         assert!(input.len() == output.len());
62                         assert!(self.finished == false);
63                         self.cipher.process(input, output);
64                         self.data_len += input.len();
65                         self.mac.input(output);
66                         ChaCha20Poly1305RFC::pad_mac_16(&mut self.mac, self.data_len);
67                         self.finished = true;
68                         self.mac.input(&self.aad_len.to_le_bytes());
69                         self.mac.input(&(self.data_len as u64).to_le_bytes());
70                         self.mac.raw_result(out_tag);
71                 }
72
73                 pub fn encrypt_full_message_in_place(&mut self, input_output: &mut [u8], out_tag: &mut [u8]) {
74                         self.encrypt_in_place(input_output);
75                         self.finish_and_get_tag(out_tag);
76                 }
77
78                 // Encrypt `input_output` in-place. To finish and calculate the tag, use `finish_and_get_tag`
79                 // below.
80                 pub(in super::super) fn encrypt_in_place(&mut self, input_output: &mut [u8]) {
81                         debug_assert!(self.finished == false);
82                         self.cipher.process_in_place(input_output);
83                         self.data_len += input_output.len();
84                         self.mac.input(input_output);
85                 }
86
87                 // If we were previously encrypting with `encrypt_in_place`, this method can be used to finish
88                 // encrypting and calculate the tag.
89                 pub(in super::super) fn finish_and_get_tag(&mut self, out_tag: &mut [u8]) {
90                         debug_assert!(self.finished == false);
91                         ChaCha20Poly1305RFC::pad_mac_16(&mut self.mac, self.data_len);
92                         self.finished = true;
93                         self.mac.input(&self.aad_len.to_le_bytes());
94                         self.mac.input(&(self.data_len as u64).to_le_bytes());
95                         self.mac.raw_result(out_tag);
96                 }
97
98                 /// Decrypt the `input`, checking the given `tag` prior to writing the decrypted contents
99                 /// into `output`. Note that, because `output` is not touched until the `tag` is checked,
100                 /// this decryption is *variable time*.
101                 pub fn variable_time_decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8]) -> Result<(), ()> {
102                         assert!(input.len() == output.len());
103                         assert!(self.finished == false);
104
105                         self.finished = true;
106
107                         self.mac.input(input);
108
109                         self.data_len += input.len();
110                         ChaCha20Poly1305RFC::pad_mac_16(&mut self.mac, self.data_len);
111                         self.mac.input(&self.aad_len.to_le_bytes());
112                         self.mac.input(&(self.data_len as u64).to_le_bytes());
113
114                         let mut calc_tag =  [0u8; 16];
115                         self.mac.raw_result(&mut calc_tag);
116                         if fixed_time_eq(&calc_tag, tag) {
117                                 self.cipher.process(input, output);
118                                 Ok(())
119                         } else {
120                                 Err(())
121                         }
122                 }
123
124                 pub fn check_decrypt_in_place(&mut self, input_output: &mut [u8], tag: &[u8]) -> Result<(), ()> {
125                         self.decrypt_in_place(input_output);
126                         if self.finish_and_check_tag(tag) { Ok(()) } else { Err(()) }
127                 }
128
129                 /// Decrypt in place, without checking the tag. Use `finish_and_check_tag` to check it
130                 /// later when decryption finishes.
131                 ///
132                 /// Should never be `pub` because the public API should always enforce tag checking.
133                 pub(in super::super) fn decrypt_in_place(&mut self, input_output: &mut [u8]) {
134                         debug_assert!(self.finished == false);
135                         self.mac.input(input_output);
136                         self.data_len += input_output.len();
137                         self.cipher.process_in_place(input_output);
138                 }
139
140                 /// If we were previously decrypting with `just_decrypt_in_place`, this method must be used
141                 /// to check the tag. Returns whether or not the tag is valid.
142                 pub(in super::super) fn finish_and_check_tag(&mut self, tag: &[u8]) -> bool {
143                         debug_assert!(self.finished == false);
144                         self.finished = true;
145                         ChaCha20Poly1305RFC::pad_mac_16(&mut self.mac, self.data_len);
146                         self.mac.input(&self.aad_len.to_le_bytes());
147                         self.mac.input(&(self.data_len as u64).to_le_bytes());
148
149                         let mut calc_tag =  [0u8; 16];
150                         self.mac.raw_result(&mut calc_tag);
151                         if fixed_time_eq(&calc_tag, tag) {
152                                 true
153                         } else {
154                                 false
155                         }
156                 }
157         }
158 }
159 #[cfg(not(fuzzing))]
160 pub use self::real_chachapoly::ChaCha20Poly1305RFC;
161
162 #[cfg(fuzzing)]
163 mod fuzzy_chachapoly {
164         #[derive(Clone, Copy)]
165         pub struct ChaCha20Poly1305RFC {
166                 tag: [u8; 16],
167                 finished: bool,
168         }
169         impl ChaCha20Poly1305RFC {
170                 pub fn new(key: &[u8], nonce: &[u8], _aad: &[u8]) -> ChaCha20Poly1305RFC {
171                         assert!(key.len() == 16 || key.len() == 32);
172                         assert!(nonce.len() == 12);
173
174                         // Ehh, I'm too lazy to *also* tweak ChaCha20 to make it RFC-compliant
175                         assert!(nonce[0] == 0 && nonce[1] == 0 && nonce[2] == 0 && nonce[3] == 0);
176
177                         let mut tag = [0; 16];
178                         tag.copy_from_slice(&key[0..16]);
179
180                         ChaCha20Poly1305RFC {
181                                 tag,
182                                 finished: false,
183                         }
184                 }
185
186                 pub fn encrypt(&mut self, input: &[u8], output: &mut [u8], out_tag: &mut [u8]) {
187                         assert!(input.len() == output.len());
188                         assert!(self.finished == false);
189
190                         output.copy_from_slice(&input);
191                         out_tag.copy_from_slice(&self.tag);
192                         self.finished = true;
193                 }
194
195                 pub fn encrypt_full_message_in_place(&mut self, input_output: &mut [u8], out_tag: &mut [u8]) {
196                         self.encrypt_in_place(input_output);
197                         self.finish_and_get_tag(out_tag);
198                 }
199
200                 pub(in super::super) fn encrypt_in_place(&mut self, _input_output: &mut [u8]) {
201                         assert!(self.finished == false);
202                 }
203
204                 pub(in super::super) fn finish_and_get_tag(&mut self, out_tag: &mut [u8]) {
205                         assert!(self.finished == false);
206                         out_tag.copy_from_slice(&self.tag);
207                         self.finished = true;
208                 }
209
210                 pub fn variable_time_decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8]) -> Result<(), ()> {
211                         assert!(input.len() == output.len());
212                         assert!(self.finished == false);
213
214                         if tag[..] != self.tag[..] { return Err(()); }
215                         output.copy_from_slice(input);
216                         self.finished = true;
217                         Ok(())
218                 }
219
220                 pub fn check_decrypt_in_place(&mut self, input_output: &mut [u8], tag: &[u8]) -> Result<(), ()> {
221                         self.decrypt_in_place(input_output);
222                         if self.finish_and_check_tag(tag) { Ok(()) } else { Err(()) }
223                 }
224
225                 pub(in super::super) fn decrypt_in_place(&mut self, _input: &mut [u8]) {
226                         assert!(self.finished == false);
227                 }
228
229                 pub(in super::super) fn finish_and_check_tag(&mut self, tag: &[u8]) -> bool {
230                         if tag[..] != self.tag[..] { return false; }
231                         self.finished = true;
232                         true
233                 }
234         }
235 }
236 #[cfg(fuzzing)]
237 pub use self::fuzzy_chachapoly::ChaCha20Poly1305RFC;