mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-03-15 15:39:09 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #3315 from tnull/2024-09-rustfmt-crypto

Browse source 
`rustfmt`: Run on `crypto` module
This commit is contained in:
Matt Corallo 2024-09-16 15:02:46 +00:00 • committed by GitHub
commit 6662c5c7b9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 458 additions and 438 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

536
lightning/src/crypto/chacha20.rs
View file

@ -20,20 +20,24 @@ mod real_chacha {
type Output = u32x4; type Output = u32x4;
#[inline] #[inline]
fn add(self, rhs: u32x4) -> u32x4 { fn add(self, rhs: u32x4) -> u32x4 {
u32x4(self.0.wrapping_add(rhs.0), u32x4(
self.1.wrapping_add(rhs.1), self.0.wrapping_add(rhs.0),
self.2.wrapping_add(rhs.2), self.1.wrapping_add(rhs.1),
self.3.wrapping_add(rhs.3)) self.2.wrapping_add(rhs.2),
self.3.wrapping_add(rhs.3),
)
} }
} }
impl ::core::ops::Sub for u32x4 { impl ::core::ops::Sub for u32x4 {
type Output = u32x4; type Output = u32x4;
#[inline] #[inline]
fn sub(self, rhs: u32x4) -> u32x4 { fn sub(self, rhs: u32x4) -> u32x4 {
u32x4(self.0.wrapping_sub(rhs.0), u32x4(
self.1.wrapping_sub(rhs.1), self.0.wrapping_sub(rhs.0),
self.2.wrapping_sub(rhs.2), self.1.wrapping_sub(rhs.1),
self.3.wrapping_sub(rhs.3)) self.2.wrapping_sub(rhs.2),
self.3.wrapping_sub(rhs.3),
)
} }
} }
impl ::core::ops::BitXor for u32x4 { impl ::core::ops::BitXor for u32x4 {
@ -60,44 +64,48 @@ mod real_chacha {
impl u32x4 { impl u32x4 {
#[inline] #[inline]
fn from_bytes(bytes: &[u8]) -> Self { fn from_bytes(bytes: &[u8]) -> Self {
assert_eq!(bytes.len(), 4*4); assert_eq!(bytes.len(), 4 * 4);
Self ( Self(
u32::from_le_bytes(bytes[0*4..1*4].try_into().expect("len is 4")), u32::from_le_bytes(bytes[0 * 4..1 * 4].try_into().expect("len is 4")),
u32::from_le_bytes(bytes[1*4..2*4].try_into().expect("len is 4")), u32::from_le_bytes(bytes[1 * 4..2 * 4].try_into().expect("len is 4")),
u32::from_le_bytes(bytes[2*4..3*4].try_into().expect("len is 4")), u32::from_le_bytes(bytes[2 * 4..3 * 4].try_into().expect("len is 4")),
u32::from_le_bytes(bytes[3*4..4*4].try_into().expect("len is 4")), u32::from_le_bytes(bytes[3 * 4..4 * 4].try_into().expect("len is 4")),
) )
} }
} }
const BLOCK_SIZE: usize = 64; const BLOCK_SIZE: usize = 64;
#[derive(Clone,Copy)] #[derive(Clone, Copy)]
struct ChaChaState { struct ChaChaState {
a: u32x4, a: u32x4,
b: u32x4, b: u32x4,
c: u32x4, c: u32x4,
d: u32x4 d: u32x4,
} }
#[derive(Copy)] #[derive(Copy)]
pub struct ChaCha20 { pub struct ChaCha20 {
state : ChaChaState, state: ChaChaState,
output : [u8; BLOCK_SIZE], output: [u8; BLOCK_SIZE],
offset : usize, offset: usize,
} }
impl Clone for ChaCha20 { fn clone(&self) -> ChaCha20 { *self } } impl Clone for ChaCha20 {
fn clone(&self) -> ChaCha20 {
*self
}
}
macro_rules! swizzle { macro_rules! swizzle {
($b: expr, $c: expr, $d: expr) => {{ ($b: expr, $c: expr, $d: expr) => {{
let u32x4(b10, b11, b12, b13) = $b; let u32x4(b10, b11, b12, b13) = $b;
$b = u32x4(b11, b12, b13, b10); $b = u32x4(b11, b12, b13, b10);
let u32x4(c10, c11, c12, c13) = $c; let u32x4(c10, c11, c12, c13) = $c;
$c = u32x4(c12, c13,c10, c11); $c = u32x4(c12, c13, c10, c11);
let u32x4(d10, d11, d12, d13) = $d; let u32x4(d10, d11, d12, d13) = $d;
$d = u32x4(d13, d10, d11, d12); $d = u32x4(d13, d10, d11, d12);
}} }};
} }
macro_rules! state_to_buffer { macro_rules! state_to_buffer {
@ -106,19 +114,14 @@ mod real_chacha {
let u32x4(b1, b2, b3, b4) = $state.b; let u32x4(b1, b2, b3, b4) = $state.b;
let u32x4(c1, c2, c3, c4) = $state.c; let u32x4(c1, c2, c3, c4) = $state.c;
let u32x4(d1, d2, d3, d4) = $state.d; let u32x4(d1, d2, d3, d4) = $state.d;
let lens = [ let lens = [a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3, d4];
a1,a2,a3,a4,
b1,b2,b3,b4,
c1,c2,c3,c4,
d1,d2,d3,d4
];
for i in 0..lens.len() { for i in 0..lens.len() {
$output[i*4..(i+1)*4].copy_from_slice(&lens[i].to_le_bytes()); $output[i * 4..(i + 1) * 4].copy_from_slice(&lens[i].to_le_bytes());
} }
}} }};
} }
macro_rules! round{ macro_rules! round {
($state: expr) => {{ ($state: expr) => {{
$state.a = $state.a + $state.b; $state.a = $state.a + $state.b;
rotate!($state.d, $state.a, 16); rotate!($state.d, $state.a, 16);
@ -128,7 +131,7 @@ mod real_chacha {
rotate!($state.d, $state.a, 8); rotate!($state.d, $state.a, 8);
$state.c = $state.c + $state.d; $state.c = $state.c + $state.d;
rotate!($state.b, $state.c, 7); rotate!($state.b, $state.c, 7);
}} }};
} }
macro_rules! rotate { macro_rules! rotate {
@ -137,7 +140,7 @@ mod real_chacha {
let r = 32 - $rot; let r = 32 - $rot;
let right = v >> r; let right = v >> r;
$a = (v << $rot) ^ right $a = (v << $rot) ^ right
}} }};
} }
impl ChaCha20 { impl ChaCha20 {
@ -145,12 +148,16 @@ mod real_chacha {
assert!(key.len() == 16 || key.len() == 32); assert!(key.len() == 16 || key.len() == 32);
assert!(nonce.len() == 8 || nonce.len() == 12); assert!(nonce.len() == 8 || nonce.len() == 12);
ChaCha20{ state: ChaCha20::expand(key, nonce), output: [0u8; BLOCK_SIZE], offset: 64 } ChaCha20 { state: ChaCha20::expand(key, nonce), output: [0u8; BLOCK_SIZE], offset: 64 }
} }
/// Get one block from a ChaCha stream. /// Get one block from a ChaCha stream.
pub fn get_single_block(key: &[u8; 32], nonce: &[u8; 16]) -> [u8; 32] { pub fn get_single_block(key: &[u8; 32], nonce: &[u8; 16]) -> [u8; 32] {
let mut chacha = ChaCha20 { state: ChaCha20::expand(key, nonce), output: [0u8; BLOCK_SIZE], offset: 64 }; let mut chacha = ChaCha20 {
state: ChaCha20::expand(key, nonce),
output: [0u8; BLOCK_SIZE],
offset: 64,
};
let mut chacha_bytes = [0; 32]; let mut chacha_bytes = [0; 32];
chacha.process_in_place(&mut chacha_bytes); chacha.process_in_place(&mut chacha_bytes);
chacha_bytes chacha_bytes
@ -158,9 +165,7 @@ mod real_chacha {
/// Encrypts `src` into `dest` using a single block from a ChaCha stream. Passing `dest` as /// Encrypts `src` into `dest` using a single block from a ChaCha stream. Passing `dest` as
/// `src` in a second call will decrypt it. /// `src` in a second call will decrypt it.
pub fn encrypt_single_block( pub fn encrypt_single_block(key: &[u8; 32], nonce: &[u8; 16], dest: &mut [u8], src: &[u8]) {
key: &[u8; 32], nonce: &[u8; 16], dest: &mut [u8], src: &[u8]
) {
debug_assert_eq!(dest.len(), src.len()); debug_assert_eq!(dest.len(), src.len());
debug_assert!(dest.len() <= 32); debug_assert!(dest.len() <= 32);
@ -172,7 +177,7 @@ mod real_chacha {
/// Same as `encrypt_single_block` only operates on a fixed-size input in-place. /// Same as `encrypt_single_block` only operates on a fixed-size input in-place.
pub fn encrypt_single_block_in_place( pub fn encrypt_single_block_in_place(
key: &[u8; 32], nonce: &[u8; 16], bytes: &mut [u8; 32] key: &[u8; 32], nonce: &[u8; 16], bytes: &mut [u8; 32],
) { ) {
let block = ChaCha20::get_single_block(key, nonce); let block = ChaCha20::get_single_block(key, nonce);
for i in 0..bytes.len() { for i in 0..bytes.len() {
@ -184,7 +189,7 @@ mod real_chacha {
let constant = match key.len() { let constant = match key.len() {
16 => b"expand 16-byte k", 16 => b"expand 16-byte k",
32 => b"expand 32-byte k", 32 => b"expand 32-byte k",
_ => unreachable!(), _ => unreachable!(),
}; };
ChaChaState { ChaChaState {
a: u32x4::from_bytes(&constant[0..16]), a: u32x4::from_bytes(&constant[0..16]),
@ -197,14 +202,14 @@ mod real_chacha {
d: if nonce.len() == 16 { d: if nonce.len() == 16 {
u32x4::from_bytes(&nonce[0..16]) u32x4::from_bytes(&nonce[0..16])
} else if nonce.len() == 12 { } else if nonce.len() == 12 {
let mut nonce4 = [0; 4*4]; let mut nonce4 = [0; 4 * 4];
nonce4[4..].copy_from_slice(nonce); nonce4[4..].copy_from_slice(nonce);
u32x4::from_bytes(&nonce4) u32x4::from_bytes(&nonce4)
} else { } else {
let mut nonce4 = [0; 4*4]; let mut nonce4 = [0; 4 * 4];
nonce4[8..].copy_from_slice(nonce); nonce4[8..].copy_from_slice(nonce);
u32x4::from_bytes(&nonce4) u32x4::from_bytes(&nonce4)
} },
} }
} }
@ -312,15 +317,16 @@ mod fuzzy_chacha {
} }
pub fn encrypt_single_block( pub fn encrypt_single_block(
_key: &[u8; 32], _nonce: &[u8; 16], dest: &mut [u8], src: &[u8] _key: &[u8; 32], _nonce: &[u8; 16], dest: &mut [u8], src: &[u8],
) { ) {
debug_assert_eq!(dest.len(), src.len()); debug_assert_eq!(dest.len(), src.len());
debug_assert!(dest.len() <= 32); debug_assert!(dest.len() <= 32);
} }
pub fn encrypt_single_block_in_place( pub fn encrypt_single_block_in_place(
_key: &[u8; 32], _nonce: &[u8; 16], _bytes: &mut [u8; 32] _key: &[u8; 32], _nonce: &[u8; 16], _bytes: &mut [u8; 32],
) {} ) {
}
pub fn process(&mut self, input: &[u8], output: &mut [u8]) { pub fn process(&mut self, input: &[u8], output: &mut [u8]) {
output.copy_from_slice(input); output.copy_from_slice(input);
@ -343,128 +349,103 @@ mod test {
#[test] #[test]
fn test_chacha20_256_tls_vectors() { fn test_chacha20_256_tls_vectors() {
struct TestVector { struct TestVector {
key: [u8; 32], key: [u8; 32],
nonce: [u8; 8], nonce: [u8; 8],
keystream: Vec<u8>, keystream: Vec<u8>,
} }
// taken from http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04 // taken from http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04
let test_vectors = vec!( let test_vectors = vec![
TestVector{ TestVector {
key: [ key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
], ],
nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ], nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
keystream: vec!( keystream: vec![
0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53,
0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28, 0x86, 0xbd, 0x28, 0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36,
0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7, 0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48,
0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7, 0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37, 0x6a, 0x43, 0xb8, 0xf4,
0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d, 0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c,
0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
),
}, TestVector{
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
], ],
nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
keystream: vec!(
0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,
0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,
0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60,
0x4f, 0x45, 0x09, 0x52, 0xed, 0x43, 0x2d, 0x41,
0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66, 0xd2,
0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c,
0x53, 0xd7, 0x92, 0xb1, 0xc4, 0x3f, 0xea, 0x81,
0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
),
}, TestVector{
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ],
keystream: vec!(
0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,
0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,
0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13,
0x4f, 0xcb, 0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31,
0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08, 0x45,
0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b,
0x52, 0x77, 0x06, 0x2e, 0xb7, 0xa0, 0x43, 0x3e,
0x44, 0x5f, 0x41, 0xe3,
),
}, TestVector{
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
nonce: [ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
keystream: vec!(
0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,
0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,
0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac,
0x33, 0x96, 0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32,
0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5, 0x3c,
0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54,
0x5d, 0xdc, 0x49, 0x7a, 0x0b, 0x46, 0x6e, 0x7d,
0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
),
}, TestVector{
key: [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
],
nonce: [ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 ],
keystream: vec!(
0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,
0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,
0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93,
0xec, 0x01, 0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1,
0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46, 0x41,
0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69,
0x05, 0xd3, 0xbe, 0x59, 0xea, 0x1c, 0x53, 0xf1,
0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a,
0x38, 0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94,
0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a, 0xde, 0x66,
0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58,
0x89, 0xfb, 0x60, 0xe8, 0x46, 0x29, 0xc9, 0xbd,
0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e,
0x09, 0xa7, 0xe7, 0x78, 0x49, 0x2b, 0x56, 0x2e,
0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7,
0x9d, 0xb9, 0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15,
0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f, 0xc3,
0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a,
0x97, 0xa5, 0xf5, 0x76, 0xfe, 0x06, 0x40, 0x25,
0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5,
0x07, 0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69,
0x59, 0x66, 0x09, 0x96, 0x54, 0x6c, 0xc9, 0xc4,
0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7,
0x0e, 0xaf, 0x46, 0xf7, 0x6d, 0xad, 0x39, 0x79,
0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a,
0x94, 0xdf, 0x76, 0x28, 0xfe, 0x4e, 0xaa, 0xf2,
0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a,
0xd0, 0xf9, 0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09,
0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40, 0x7a,
0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
),
}, },
); TestVector {
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
],
nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
keystream: vec![
0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96, 0xd7, 0x73, 0x6e, 0x7b, 0x20,
0x8e, 0x3c, 0x96, 0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60, 0x4f, 0x45,
0x09, 0x52, 0xed, 0x43, 0x2d, 0x41, 0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66,
0xd2, 0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c, 0x53, 0xd7, 0x92, 0xb1,
0xc4, 0x3f, 0xea, 0x81, 0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
],
},
TestVector {
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01],
keystream: vec![
0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5, 0xe7, 0x86, 0xdc, 0x63, 0x97,
0x3f, 0x65, 0x3a, 0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13, 0x4f, 0xcb,
0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31, 0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08,
0x45, 0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b, 0x52, 0x77, 0x06, 0x2e,
0xb7, 0xa0, 0x43, 0x3e, 0x44, 0x5f, 0x41, 0xe3,
],
},
TestVector {
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
nonce: [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
keystream: vec![
0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb, 0xf5, 0xcf, 0x35, 0xbd, 0x3d,
0xd3, 0x3b, 0x80, 0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac, 0x33, 0x96,
0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32, 0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5,
0x3c, 0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54, 0x5d, 0xdc, 0x49, 0x7a,
0x0b, 0x46, 0x6e, 0x7d, 0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
],
},
TestVector {
key: [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
],
nonce: [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07],
keystream: vec![
0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69, 0x82, 0x10, 0x5f, 0xfb, 0x64,
0x0b, 0xb7, 0x75, 0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93, 0xec, 0x01,
0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1, 0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46,
0x41, 0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69, 0x05, 0xd3, 0xbe, 0x59,
0xea, 0x1c, 0x53, 0xf1, 0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a, 0x38,
0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94, 0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a,
0xde, 0x66, 0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58, 0x89, 0xfb, 0x60,
0xe8, 0x46, 0x29, 0xc9, 0xbd, 0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e, 0x09, 0xa7, 0xe7, 0x78, 0x49,
0x2b, 0x56, 0x2e, 0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7, 0x9d, 0xb9,
0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15, 0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f,
0xc3, 0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a, 0x97, 0xa5, 0xf5, 0x76,
0xfe, 0x06, 0x40, 0x25, 0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5, 0x07,
0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69, 0x59, 0x66, 0x09, 0x96, 0x54, 0x6c,
0xc9, 0xc4, 0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7, 0x0e, 0xaf, 0x46,
0xf7, 0x6d, 0xad, 0x39, 0x79, 0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a, 0x94, 0xdf, 0x76, 0x28, 0xfe,
0x4e, 0xaa, 0xf2, 0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a, 0xd0, 0xf9,
0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09, 0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40,
0x7a, 0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
],
},
];
for tv in test_vectors.iter() { for tv in test_vectors.iter() {
let mut c = ChaCha20::new(&tv.key, &tv.nonce); let mut c = ChaCha20::new(&tv.key, &tv.nonce);
@ -478,128 +459,103 @@ mod test {
#[test] #[test]
fn test_chacha20_256_tls_vectors_96_nonce() { fn test_chacha20_256_tls_vectors_96_nonce() {
struct TestVector { struct TestVector {
key: [u8; 32], key: [u8; 32],
nonce: [u8; 12], nonce: [u8; 12],
keystream: Vec<u8>, keystream: Vec<u8>,
} }
// taken from http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04 // taken from http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04
let test_vectors = vec!( let test_vectors = vec![
TestVector{ TestVector {
key: [ key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
], ],
nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ], nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
keystream: vec!( keystream: vec![
0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53,
0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28, 0x86, 0xbd, 0x28, 0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36,
0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7, 0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48,
0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7, 0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37, 0x6a, 0x43, 0xb8, 0xf4,
0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d, 0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c,
0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
),
}, TestVector{
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
], ],
nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
keystream: vec!(
0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,
0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,
0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60,
0x4f, 0x45, 0x09, 0x52, 0xed, 0x43, 0x2d, 0x41,
0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66, 0xd2,
0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c,
0x53, 0xd7, 0x92, 0xb1, 0xc4, 0x3f, 0xea, 0x81,
0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
),
}, TestVector{
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ],
keystream: vec!(
0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,
0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,
0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13,
0x4f, 0xcb, 0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31,
0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08, 0x45,
0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b,
0x52, 0x77, 0x06, 0x2e, 0xb7, 0xa0, 0x43, 0x3e,
0x44, 0x5f, 0x41, 0xe3,
),
}, TestVector{
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
nonce: [ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
keystream: vec!(
0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,
0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,
0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac,
0x33, 0x96, 0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32,
0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5, 0x3c,
0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54,
0x5d, 0xdc, 0x49, 0x7a, 0x0b, 0x46, 0x6e, 0x7d,
0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
),
}, TestVector{
key: [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
],
nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 ],
keystream: vec!(
0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,
0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,
0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93,
0xec, 0x01, 0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1,
0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46, 0x41,
0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69,
0x05, 0xd3, 0xbe, 0x59, 0xea, 0x1c, 0x53, 0xf1,
0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a,
0x38, 0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94,
0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a, 0xde, 0x66,
0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58,
0x89, 0xfb, 0x60, 0xe8, 0x46, 0x29, 0xc9, 0xbd,
0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e,
0x09, 0xa7, 0xe7, 0x78, 0x49, 0x2b, 0x56, 0x2e,
0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7,
0x9d, 0xb9, 0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15,
0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f, 0xc3,
0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a,
0x97, 0xa5, 0xf5, 0x76, 0xfe, 0x06, 0x40, 0x25,
0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5,
0x07, 0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69,
0x59, 0x66, 0x09, 0x96, 0x54, 0x6c, 0xc9, 0xc4,
0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7,
0x0e, 0xaf, 0x46, 0xf7, 0x6d, 0xad, 0x39, 0x79,
0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a,
0x94, 0xdf, 0x76, 0x28, 0xfe, 0x4e, 0xaa, 0xf2,
0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a,
0xd0, 0xf9, 0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09,
0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40, 0x7a,
0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
),
}, },
); TestVector {
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
],
nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
keystream: vec![
0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96, 0xd7, 0x73, 0x6e, 0x7b, 0x20,
0x8e, 0x3c, 0x96, 0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60, 0x4f, 0x45,
0x09, 0x52, 0xed, 0x43, 0x2d, 0x41, 0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66,
0xd2, 0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c, 0x53, 0xd7, 0x92, 0xb1,
0xc4, 0x3f, 0xea, 0x81, 0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
],
},
TestVector {
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01],
keystream: vec![
0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5, 0xe7, 0x86, 0xdc, 0x63, 0x97,
0x3f, 0x65, 0x3a, 0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13, 0x4f, 0xcb,
0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31, 0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08,
0x45, 0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b, 0x52, 0x77, 0x06, 0x2e,
0xb7, 0xa0, 0x43, 0x3e, 0x44, 0x5f, 0x41, 0xe3,
],
},
TestVector {
key: [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
],
nonce: [0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
keystream: vec![
0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb, 0xf5, 0xcf, 0x35, 0xbd, 0x3d,
0xd3, 0x3b, 0x80, 0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac, 0x33, 0x96,
0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32, 0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5,
0x3c, 0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54, 0x5d, 0xdc, 0x49, 0x7a,
0x0b, 0x46, 0x6e, 0x7d, 0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
],
},
TestVector {
key: [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
],
nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07],
keystream: vec![
0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69, 0x82, 0x10, 0x5f, 0xfb, 0x64,
0x0b, 0xb7, 0x75, 0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93, 0xec, 0x01,
0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1, 0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46,
0x41, 0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69, 0x05, 0xd3, 0xbe, 0x59,
0xea, 0x1c, 0x53, 0xf1, 0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a, 0x38,
0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94, 0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a,
0xde, 0x66, 0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58, 0x89, 0xfb, 0x60,
0xe8, 0x46, 0x29, 0xc9, 0xbd, 0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e, 0x09, 0xa7, 0xe7, 0x78, 0x49,
0x2b, 0x56, 0x2e, 0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7, 0x9d, 0xb9,
0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15, 0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f,
0xc3, 0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a, 0x97, 0xa5, 0xf5, 0x76,
0xfe, 0x06, 0x40, 0x25, 0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5, 0x07,
0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69, 0x59, 0x66, 0x09, 0x96, 0x54, 0x6c,
0xc9, 0xc4, 0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7, 0x0e, 0xaf, 0x46,
0xf7, 0x6d, 0xad, 0x39, 0x79, 0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a, 0x94, 0xdf, 0x76, 0x28, 0xfe,
0x4e, 0xaa, 0xf2, 0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a, 0xd0, 0xf9,
0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09, 0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40,
0x7a, 0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
],
},
];
for tv in test_vectors.iter() { for tv in test_vectors.iter() {
let mut c = ChaCha20::new(&tv.key, &tv.nonce); let mut c = ChaCha20::new(&tv.key, &tv.nonce);
@ -616,13 +572,13 @@ mod test {
// using a 12-byte nonce, with the block starting at the counter offset given by the remaining 4 // using a 12-byte nonce, with the block starting at the counter offset given by the remaining 4
// bytes. // bytes.
let key = [ let key = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1c, 0x1d, 0x1e, 0x1f,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
]; ];
let nonce_16bytes = [ let nonce_16bytes = [
0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
0x0a, 0x0b,
]; ];
let counter_pos = &nonce_16bytes[..4]; let counter_pos = &nonce_16bytes[..4];
let nonce_12bytes = &nonce_16bytes[4..]; let nonce_12bytes = &nonce_16bytes[4..];
@ -640,14 +596,13 @@ mod test {
#[test] #[test]
fn encrypt_single_block() { fn encrypt_single_block() {
let key = [ let key = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1c, 0x1d, 0x1e, 0x1f,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
]; ];
let nonce = [ let nonce = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0e, 0x0f,
]; ];
let bytes = [1; 32]; let bytes = [1; 32];
@ -663,14 +618,13 @@ mod test {
#[test] #[test]
fn encrypt_single_block_in_place() { fn encrypt_single_block_in_place() {
let key = [ let key = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1c, 0x1d, 0x1e, 0x1f,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
]; ];
let nonce = [ let nonce = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0e, 0x0f,
]; ];
let unencrypted_bytes = [1; 32]; let unencrypted_bytes = [1; 32];
let mut bytes = unencrypted_bytes; let mut bytes = unencrypted_bytes;

55
lightning/src/crypto/chacha20poly1305rfc.rs
View file

@ -13,8 +13,8 @@
#[cfg(not(fuzzing))] #[cfg(not(fuzzing))]
mod real_chachapoly { mod real_chachapoly {
use super::super::chacha20::ChaCha20; use super::super::chacha20::ChaCha20;
use super::super::poly1305::Poly1305;
use super::super::fixed_time_eq; use super::super::fixed_time_eq;
use super::super::poly1305::Poly1305;
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
pub struct ChaCha20Poly1305RFC { pub struct ChaCha20Poly1305RFC {
@ -70,7 +70,9 @@ mod real_chachapoly {
self.mac.raw_result(out_tag); self.mac.raw_result(out_tag);
} }
pub fn encrypt_full_message_in_place(&mut self, input_output: &mut [u8], out_tag: &mut [u8]) { pub fn encrypt_full_message_in_place(
&mut self, input_output: &mut [u8], out_tag: &mut [u8],
) {
self.encrypt_in_place(input_output); self.encrypt_in_place(input_output);
self.finish_and_get_tag(out_tag); self.finish_and_get_tag(out_tag);
} }
@ -98,7 +100,9 @@ mod real_chachapoly {
/// Decrypt the `input`, checking the given `tag` prior to writing the decrypted contents /// Decrypt the `input`, checking the given `tag` prior to writing the decrypted contents
/// into `output`. Note that, because `output` is not touched until the `tag` is checked, /// into `output`. Note that, because `output` is not touched until the `tag` is checked,
/// this decryption is *variable time*. /// this decryption is *variable time*.
pub fn variable_time_decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8]) -> Result<(), ()> { pub fn variable_time_decrypt(
&mut self, input: &[u8], output: &mut [u8], tag: &[u8],
) -> Result<(), ()> {
assert!(input.len() == output.len()); assert!(input.len() == output.len());
assert!(!self.finished); assert!(!self.finished);
@ -111,7 +115,7 @@ mod real_chachapoly {
self.mac.input(&self.aad_len.to_le_bytes()); self.mac.input(&self.aad_len.to_le_bytes());
self.mac.input(&(self.data_len as u64).to_le_bytes()); self.mac.input(&(self.data_len as u64).to_le_bytes());
let mut calc_tag = [0u8; 16]; let mut calc_tag = [0u8; 16];
self.mac.raw_result(&mut calc_tag); self.mac.raw_result(&mut calc_tag);
if fixed_time_eq(&calc_tag, tag) { if fixed_time_eq(&calc_tag, tag) {
self.cipher.process(input, output); self.cipher.process(input, output);
@ -121,9 +125,15 @@ mod real_chachapoly {
} }
} }
pub fn check_decrypt_in_place(&mut self, input_output: &mut [u8], tag: &[u8]) -> Result<(), ()> { pub fn check_decrypt_in_place(
&mut self, input_output: &mut [u8], tag: &[u8],
) -> Result<(), ()> {
self.decrypt_in_place(input_output); self.decrypt_in_place(input_output);
if self.finish_and_check_tag(tag) { Ok(()) } else { Err(()) } if self.finish_and_check_tag(tag) {
Ok(())
} else {
Err(())
}
} }
/// Decrypt in place, without checking the tag. Use `finish_and_check_tag` to check it /// Decrypt in place, without checking the tag. Use `finish_and_check_tag` to check it
@ -146,7 +156,7 @@ mod real_chachapoly {
self.mac.input(&self.aad_len.to_le_bytes()); self.mac.input(&self.aad_len.to_le_bytes());
self.mac.input(&(self.data_len as u64).to_le_bytes()); self.mac.input(&(self.data_len as u64).to_le_bytes());
let mut calc_tag = [0u8; 16]; let mut calc_tag = [0u8; 16];
self.mac.raw_result(&mut calc_tag); self.mac.raw_result(&mut calc_tag);
if fixed_time_eq(&calc_tag, tag) { if fixed_time_eq(&calc_tag, tag) {
true true
@ -177,10 +187,7 @@ mod fuzzy_chachapoly {
let mut tag = [0; 16]; let mut tag = [0; 16];
tag.copy_from_slice(&key[0..16]); tag.copy_from_slice(&key[0..16]);
ChaCha20Poly1305RFC { ChaCha20Poly1305RFC { tag, finished: false }
tag,
finished: false,
}
} }
pub fn encrypt(&mut self, input: &[u8], output: &mut [u8], out_tag: &mut [u8]) { pub fn encrypt(&mut self, input: &[u8], output: &mut [u8], out_tag: &mut [u8]) {
@ -192,7 +199,9 @@ mod fuzzy_chachapoly {
self.finished = true; self.finished = true;
} }
pub fn encrypt_full_message_in_place(&mut self, input_output: &mut [u8], out_tag: &mut [u8]) { pub fn encrypt_full_message_in_place(
&mut self, input_output: &mut [u8], out_tag: &mut [u8],
) {
self.encrypt_in_place(input_output); self.encrypt_in_place(input_output);
self.finish_and_get_tag(out_tag); self.finish_and_get_tag(out_tag);
} }
@ -207,19 +216,29 @@ mod fuzzy_chachapoly {
self.finished = true; self.finished = true;
} }
pub fn variable_time_decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8]) -> Result<(), ()> { pub fn variable_time_decrypt(
&mut self, input: &[u8], output: &mut [u8], tag: &[u8],
) -> Result<(), ()> {
assert!(input.len() == output.len()); assert!(input.len() == output.len());
assert!(self.finished == false); assert!(self.finished == false);
if tag[..] != self.tag[..] { return Err(()); } if tag[..] != self.tag[..] {
return Err(());
}
output.copy_from_slice(input); output.copy_from_slice(input);
self.finished = true; self.finished = true;
Ok(()) Ok(())
} }
pub fn check_decrypt_in_place(&mut self, input_output: &mut [u8], tag: &[u8]) -> Result<(), ()> { pub fn check_decrypt_in_place(
&mut self, input_output: &mut [u8], tag: &[u8],
) -> Result<(), ()> {
self.decrypt_in_place(input_output); self.decrypt_in_place(input_output);
if self.finish_and_check_tag(tag) { Ok(()) } else { Err(()) } if self.finish_and_check_tag(tag) {
Ok(())
} else {
Err(())
}
} }
pub(in super::super) fn decrypt_in_place(&mut self, _input: &mut [u8]) { pub(in super::super) fn decrypt_in_place(&mut self, _input: &mut [u8]) {
@ -227,7 +246,9 @@ mod fuzzy_chachapoly {
} }
pub(in super::super) fn finish_and_check_tag(&mut self, tag: &[u8]) -> bool { pub(in super::super) fn finish_and_check_tag(&mut self, tag: &[u8]) -> bool {
if tag[..] != self.tag[..] { return false; } if tag[..] != self.tag[..] {
return false;
}
self.finished = true; self.finished = true;
true true
} }

2
lightning/src/crypto/mod.rs
View file

@ -2,8 +2,8 @@
use bitcoin::hashes::cmp::fixed_time_eq; use bitcoin::hashes::cmp::fixed_time_eq;
pub(crate) mod chacha20; pub(crate) mod chacha20;
pub(crate) mod chacha20poly1305rfc;
#[cfg(not(fuzzing))] #[cfg(not(fuzzing))]
pub(crate) mod poly1305; pub(crate) mod poly1305;
pub(crate) mod chacha20poly1305rfc;
pub(crate) mod streams; pub(crate) mod streams;
pub(crate) mod utils; pub(crate) mod utils;

236
lightning/src/crypto/poly1305.rs
View file

@ -13,25 +13,33 @@ use crate::prelude::*;
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
pub struct Poly1305 { pub struct Poly1305 {
r : [u32; 5], r: [u32; 5],
h : [u32; 5], h: [u32; 5],
pad : [u32; 4], pad: [u32; 4],
leftover : usize, leftover: usize,
buffer : [u8; 16], buffer: [u8; 16],
finalized : bool, finalized: bool,
} }
impl Poly1305 { impl Poly1305 {
pub fn new(key: &[u8]) -> Poly1305 { pub fn new(key: &[u8]) -> Poly1305 {
assert!(key.len() == 32); assert!(key.len() == 32);
let mut poly = Poly1305{ r: [0u32; 5], h: [0u32; 5], pad: [0u32; 4], leftover: 0, buffer: [0u8; 16], finalized: false }; let mut poly = Poly1305 {
r: [0u32; 5],
h: [0u32; 5],
pad: [0u32; 4],
leftover: 0,
buffer: [0u8; 16],
finalized: false,
};
// r &= 0xffffffc0ffffffc0ffffffc0fffffff // r &= 0xffffffc0ffffffc0ffffffc0fffffff
poly.r[0] = (u32::from_le_bytes(key[ 0.. 4].try_into().expect("len is 4")) ) & 0x3ffffff; poly.r[0] = (u32::from_le_bytes(key[0..4].try_into().expect("len is 4"))) & 0x3ffffff;
poly.r[1] = (u32::from_le_bytes(key[ 3.. 7].try_into().expect("len is 4")) >> 2) & 0x3ffff03; poly.r[1] = (u32::from_le_bytes(key[3..7].try_into().expect("len is 4")) >> 2) & 0x3ffff03;
poly.r[2] = (u32::from_le_bytes(key[ 6..10].try_into().expect("len is 4")) >> 4) & 0x3ffc0ff; poly.r[2] = (u32::from_le_bytes(key[6..10].try_into().expect("len is 4")) >> 4) & 0x3ffc0ff;
poly.r[3] = (u32::from_le_bytes(key[ 9..13].try_into().expect("len is 4")) >> 6) & 0x3f03fff; poly.r[3] = (u32::from_le_bytes(key[9..13].try_into().expect("len is 4")) >> 6) & 0x3f03fff;
poly.r[4] = (u32::from_le_bytes(key[12..16].try_into().expect("len is 4")) >> 8) & 0x00fffff; poly.r[4] =
(u32::from_le_bytes(key[12..16].try_into().expect("len is 4")) >> 8) & 0x00fffff;
poly.pad[0] = u32::from_le_bytes(key[16..20].try_into().expect("len is 4")); poly.pad[0] = u32::from_le_bytes(key[16..20].try_into().expect("len is 4"));
poly.pad[1] = u32::from_le_bytes(key[20..24].try_into().expect("len is 4")); poly.pad[1] = u32::from_le_bytes(key[20..24].try_into().expect("len is 4"));
@ -42,7 +50,7 @@ impl Poly1305 {
} }
fn block(&mut self, m: &[u8]) { fn block(&mut self, m: &[u8]) {
let hibit : u32 = if self.finalized { 0 } else { 1 << 24 }; let hibit: u32 = if self.finalized { 0 } else { 1 << 24 };
let r0 = self.r[0]; let r0 = self.r[0];
let r1 = self.r[1]; let r1 = self.r[1];
@ -62,27 +70,58 @@ impl Poly1305 {
let mut h4 = self.h[4]; let mut h4 = self.h[4];
// h += m // h += m
h0 += (u32::from_le_bytes(m[ 0.. 4].try_into().expect("len is 4")) ) & 0x3ffffff; h0 += (u32::from_le_bytes(m[0..4].try_into().expect("len is 4"))) & 0x3ffffff;
h1 += (u32::from_le_bytes(m[ 3.. 7].try_into().expect("len is 4")) >> 2) & 0x3ffffff; h1 += (u32::from_le_bytes(m[3..7].try_into().expect("len is 4")) >> 2) & 0x3ffffff;
h2 += (u32::from_le_bytes(m[ 6..10].try_into().expect("len is 4")) >> 4) & 0x3ffffff; h2 += (u32::from_le_bytes(m[6..10].try_into().expect("len is 4")) >> 4) & 0x3ffffff;
h3 += (u32::from_le_bytes(m[ 9..13].try_into().expect("len is 4")) >> 6) & 0x3ffffff; h3 += (u32::from_le_bytes(m[9..13].try_into().expect("len is 4")) >> 6) & 0x3ffffff;
h4 += (u32::from_le_bytes(m[12..16].try_into().expect("len is 4")) >> 8) | hibit; h4 += (u32::from_le_bytes(m[12..16].try_into().expect("len is 4")) >> 8) | hibit;
// h *= r // h *= r
let d0 = (h0 as u64 * r0 as u64) + (h1 as u64 * s4 as u64) + (h2 as u64 * s3 as u64) + (h3 as u64 * s2 as u64) + (h4 as u64 * s1 as u64); let d0 = (h0 as u64 * r0 as u64)
let mut d1 = (h0 as u64 * r1 as u64) + (h1 as u64 * r0 as u64) + (h2 as u64 * s4 as u64) + (h3 as u64 * s3 as u64) + (h4 as u64 * s2 as u64); + (h1 as u64 * s4 as u64)
let mut d2 = (h0 as u64 * r2 as u64) + (h1 as u64 * r1 as u64) + (h2 as u64 * r0 as u64) + (h3 as u64 * s4 as u64) + (h4 as u64 * s3 as u64); + (h2 as u64 * s3 as u64)
let mut d3 = (h0 as u64 * r3 as u64) + (h1 as u64 * r2 as u64) + (h2 as u64 * r1 as u64) + (h3 as u64 * r0 as u64) + (h4 as u64 * s4 as u64); + (h3 as u64 * s2 as u64)
let mut d4 = (h0 as u64 * r4 as u64) + (h1 as u64 * r3 as u64) + (h2 as u64 * r2 as u64) + (h3 as u64 * r1 as u64) + (h4 as u64 * r0 as u64); + (h4 as u64 * s1 as u64);
let mut d1 = (h0 as u64 * r1 as u64)
+ (h1 as u64 * r0 as u64)
+ (h2 as u64 * s4 as u64)
+ (h3 as u64 * s3 as u64)
+ (h4 as u64 * s2 as u64);
let mut d2 = (h0 as u64 * r2 as u64)
+ (h1 as u64 * r1 as u64)
+ (h2 as u64 * r0 as u64)
+ (h3 as u64 * s4 as u64)
+ (h4 as u64 * s3 as u64);
let mut d3 = (h0 as u64 * r3 as u64)
+ (h1 as u64 * r2 as u64)
+ (h2 as u64 * r1 as u64)
+ (h3 as u64 * r0 as u64)
+ (h4 as u64 * s4 as u64);
let mut d4 = (h0 as u64 * r4 as u64)
+ (h1 as u64 * r3 as u64)
+ (h2 as u64 * r2 as u64)
+ (h3 as u64 * r1 as u64)
+ (h4 as u64 * r0 as u64);
// (partial) h %= p // (partial) h %= p
let mut c : u32; let mut c: u32;
c = (d0 >> 26) as u32; h0 = d0 as u32 & 0x3ffffff; c = (d0 >> 26) as u32;
d1 += c as u64; c = (d1 >> 26) as u32; h1 = d1 as u32 & 0x3ffffff; h0 = d0 as u32 & 0x3ffffff;
d2 += c as u64; c = (d2 >> 26) as u32; h2 = d2 as u32 & 0x3ffffff; d1 += c as u64;
d3 += c as u64; c = (d3 >> 26) as u32; h3 = d3 as u32 & 0x3ffffff; c = (d1 >> 26) as u32;
d4 += c as u64; c = (d4 >> 26) as u32; h4 = d4 as u32 & 0x3ffffff; h1 = d1 as u32 & 0x3ffffff;
h0 += c * 5; c = h0 >> 26; h0 &= 0x3ffffff; d2 += c as u64;
c = (d2 >> 26) as u32;
h2 = d2 as u32 & 0x3ffffff;
d3 += c as u64;
c = (d3 >> 26) as u32;
h3 = d3 as u32 & 0x3ffffff;
d4 += c as u64;
c = (d4 >> 26) as u32;
h4 = d4 as u32 & 0x3ffffff;
h0 += c * 5;
c = h0 >> 26;
h0 &= 0x3ffffff;
h1 += c; h1 += c;
self.h[0] = h0; self.h[0] = h0;
@ -95,7 +134,7 @@ impl Poly1305 {
pub fn finish(&mut self) { pub fn finish(&mut self) {
if self.leftover > 0 { if self.leftover > 0 {
self.buffer[self.leftover] = 1; self.buffer[self.leftover] = 1;
for i in self.leftover+1..16 { for i in self.leftover + 1..16 {
self.buffer[i] = 0; self.buffer[i] = 0;
} }
self.finalized = true; self.finalized = true;
@ -110,19 +149,36 @@ impl Poly1305 {
let mut h3 = self.h[3]; let mut h3 = self.h[3];
let mut h4 = self.h[4]; let mut h4 = self.h[4];
let mut c : u32; let mut c: u32;
c = h1 >> 26; h1 &= 0x3ffffff; c = h1 >> 26;
h2 += c; c = h2 >> 26; h2 &= 0x3ffffff; h1 &= 0x3ffffff;
h3 += c; c = h3 >> 26; h3 &= 0x3ffffff; h2 += c;
h4 += c; c = h4 >> 26; h4 &= 0x3ffffff; c = h2 >> 26;
h0 += c * 5; c = h0 >> 26; h0 &= 0x3ffffff; h2 &= 0x3ffffff;
h1 += c; h3 += c;
c = h3 >> 26;
h3 &= 0x3ffffff;
h4 += c;
c = h4 >> 26;
h4 &= 0x3ffffff;
h0 += c * 5;
c = h0 >> 26;
h0 &= 0x3ffffff;
h1 += c;
// compute h + -p // compute h + -p
let mut g0 = h0.wrapping_add(5); c = g0 >> 26; g0 &= 0x3ffffff; let mut g0 = h0.wrapping_add(5);
let mut g1 = h1.wrapping_add(c); c = g1 >> 26; g1 &= 0x3ffffff; c = g0 >> 26;
let mut g2 = h2.wrapping_add(c); c = g2 >> 26; g2 &= 0x3ffffff; g0 &= 0x3ffffff;
let mut g3 = h3.wrapping_add(c); c = g3 >> 26; g3 &= 0x3ffffff; let mut g1 = h1.wrapping_add(c);
c = g1 >> 26;
g1 &= 0x3ffffff;
let mut g2 = h2.wrapping_add(c);
c = g2 >> 26;
g2 &= 0x3ffffff;
let mut g3 = h3.wrapping_add(c);
c = g3 >> 26;
g3 &= 0x3ffffff;
let mut g4 = h4.wrapping_add(c).wrapping_sub(1 << 26); let mut g4 = h4.wrapping_add(c).wrapping_sub(1 << 26);
// select h if h < p, or h + -p if h >= p // select h if h < p, or h + -p if h >= p
@ -140,17 +196,21 @@ impl Poly1305 {
h4 = (h4 & mask) | g4; h4 = (h4 & mask) | g4;
// h = h % (2^128) // h = h % (2^128)
h0 = ((h0 ) | (h1 << 26)) & 0xffffffff; h0 = ((h0) | (h1 << 26)) & 0xffffffff;
h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff; h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff;
h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff; h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;
h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff; h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff;
// h = mac = (h + pad) % (2^128) // h = mac = (h + pad) % (2^128)
let mut f : u64; let mut f: u64;
f = h0 as u64 + self.pad[0] as u64 ; h0 = f as u32; f = h0 as u64 + self.pad[0] as u64;
f = h1 as u64 + self.pad[1] as u64 + (f >> 32); h1 = f as u32; h0 = f as u32;
f = h2 as u64 + self.pad[2] as u64 + (f >> 32); h2 = f as u32; f = h1 as u64 + self.pad[1] as u64 + (f >> 32);
f = h3 as u64 + self.pad[3] as u64 + (f >> 32); h3 = f as u32; h1 = f as u32;
f = h2 as u64 + self.pad[2] as u64 + (f >> 32);
h2 = f as u32;
f = h3 as u64 + self.pad[3] as u64 + (f >> 32);
h3 = f as u32;
self.h[0] = h0; self.h[0] = h0;
self.h[1] = h1; self.h[1] = h1;
@ -165,7 +225,7 @@ impl Poly1305 {
if self.leftover > 0 { if self.leftover > 0 {
let want = min(16 - self.leftover, m.len()); let want = min(16 - self.leftover, m.len());
for i in 0..want { for i in 0..want {
self.buffer[self.leftover+i] = m[i]; self.buffer[self.leftover + i] = m[i];
} }
m = &m[want..]; m = &m[want..];
self.leftover += want; self.leftover += want;
@ -194,7 +254,7 @@ impl Poly1305 {
pub fn raw_result(&mut self, output: &mut [u8]) { pub fn raw_result(&mut self, output: &mut [u8]) {
assert!(output.len() >= 16); assert!(output.len() >= 16);
if !self.finalized{ if !self.finalized {
self.finish(); self.finish();
} }
output[0..4].copy_from_slice(&self.h[0].to_le_bytes()); output[0..4].copy_from_slice(&self.h[0].to_le_bytes());
@ -219,35 +279,27 @@ mod test {
#[test] #[test]
fn test_nacl_vector() { fn test_nacl_vector() {
let key = [ let key = [
0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91, 0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2, 0xcb, 0x21, 0x4d,
0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23, 0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4,
0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65, 0xc8, 0xcf, 0xf8, 0x80,
0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80,
]; ];
let msg = [ let msg = [
0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73, 0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba, 0x32, 0xfc,
0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce, 0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4, 0x47, 0x6f, 0xb8, 0xc5,
0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4, 0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c, 0x98, 0xdc, 0xe8, 0x7b, 0x4d, 0xa7,
0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a, 0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72, 0x71, 0xd2, 0xc2, 0x0f, 0x9b, 0x92, 0x8f, 0xe2,
0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b, 0x27, 0x0d, 0x6f, 0xb8, 0x63, 0xd5, 0x17, 0x38, 0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7,
0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72, 0xcc, 0x8a, 0xb9, 0x32, 0x16, 0x45, 0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68,
0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2, 0x51, 0x7a, 0xcf, 0xea, 0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda, 0x99, 0x83,
0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38, 0x2b, 0x61, 0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e, 0x88, 0xd5, 0xf9, 0xb3,
0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a, 0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6, 0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4,
0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae, 0x5a, 0x74, 0xe3, 0x55, 0xa5,
0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea,
0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda,
0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde,
0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3,
0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6,
0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74,
0xe3,0x55,0xa5,
]; ];
let expected = [ let expected = [
0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5, 0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5, 0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33,
0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9, 0x05, 0xd9,
]; ];
let mut mac = [0u8; 16]; let mut mac = [0u8; 16];
@ -273,20 +325,19 @@ mod test {
#[test] #[test]
fn donna_self_test() { fn donna_self_test() {
let wrap_key = [ let wrap_key = [
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]; ];
let wrap_msg = [ let wrap_msg = [
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
]; ];
let wrap_mac = [ let wrap_mac = [
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]; ];
let mut mac = [0u8; 16]; let mut mac = [0u8; 16];
@ -294,15 +345,14 @@ mod test {
assert_eq!(&mac[..], &wrap_mac[..]); assert_eq!(&mac[..], &wrap_mac[..]);
let total_key = [ let total_key = [
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9,
0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
]; ];
let total_mac = [ let total_mac = [
0x64, 0xaf, 0xe2, 0xe8, 0xd6, 0xad, 0x7b, 0xbd, 0x64, 0xaf, 0xe2, 0xe8, 0xd6, 0xad, 0x7b, 0xbd, 0xd2, 0x87, 0xf9, 0x7c, 0x44, 0x62,
0xd2, 0x87, 0xf9, 0x7c, 0x44, 0x62, 0x3d, 0x39, 0x3d, 0x39,
]; ];
let mut tpoly = Poly1305::new(&total_key); let mut tpoly = Poly1305::new(&total_key);
@ -323,17 +373,17 @@ mod test {
let key = b"this is 32-byte key for Poly1305"; let key = b"this is 32-byte key for Poly1305";
let msg = [0u8; 32]; let msg = [0u8; 32];
let expected = [ let expected = [
0x49, 0xec, 0x78, 0x09, 0x0e, 0x48, 0x1e, 0xc6, 0x49, 0xec, 0x78, 0x09, 0x0e, 0x48, 0x1e, 0xc6, 0xc2, 0x6b, 0x33, 0xb9, 0x1c, 0xcc,
0xc2, 0x6b, 0x33, 0xb9, 0x1c, 0xcc, 0x03, 0x07, 0x03, 0x07,
]; ];
let mut mac = [0u8; 16]; let mut mac = [0u8; 16];
poly1305(key, &msg, &mut mac); poly1305(key, &msg, &mut mac);
assert_eq!(&mac[..], &expected[..]); assert_eq!(&mac[..], &expected[..]);
let msg = b"Hello world!"; let msg = b"Hello world!";
let expected= [ let expected = [
0xa6, 0xf7, 0x45, 0x00, 0x8f, 0x81, 0xc9, 0x16, 0xa6, 0xf7, 0x45, 0x00, 0x8f, 0x81, 0xc9, 0x16, 0xa2, 0x0d, 0xcc, 0x74, 0xee, 0xf2,
0xa2, 0x0d, 0xcc, 0x74, 0xee, 0xf2, 0xb2, 0xf0, 0xb2, 0xf0,
]; ];
poly1305(key, msg, &mut mac); poly1305(key, msg, &mut mac);
assert_eq!(&mac[..], &expected[..]); assert_eq!(&mac[..], &expected[..]);

44
lightning/src/crypto/streams.rs
View file

@ -1,9 +1,11 @@
use crate::crypto::chacha20::ChaCha20; use crate::crypto::chacha20::ChaCha20;
use crate::crypto::chacha20poly1305rfc::ChaCha20Poly1305RFC; use crate::crypto::chacha20poly1305rfc::ChaCha20Poly1305RFC;
use crate::ln::msgs::DecodeError;
use crate::util::ser::{FixedLengthReader, LengthRead, LengthReadableArgs, Readable, Writeable, Writer};
use crate::io::{self, Read, Write}; use crate::io::{self, Read, Write};
use crate::ln::msgs::DecodeError;
use crate::util::ser::{
FixedLengthReader, LengthRead, LengthReadableArgs, Readable, Writeable, Writer,
};
pub(crate) struct ChaChaReader<'a, R: io::Read> { pub(crate) struct ChaChaReader<'a, R: io::Read> {
pub chacha: &'a mut ChaCha20, pub chacha: &'a mut ChaCha20,
@ -58,7 +60,9 @@ impl<T: Readable> LengthReadableArgs<[u8; 32]> for ChaChaPolyReadAdapter<T> {
// LengthRead must be used instead of std::io::Read because we need the total length to separate // LengthRead must be used instead of std::io::Read because we need the total length to separate
// out the tag at the end. // out the tag at the end.
fn read<R: LengthRead>(r: &mut R, secret: [u8; 32]) -> Result<Self, DecodeError> { fn read<R: LengthRead>(r: &mut R, secret: [u8; 32]) -> Result<Self, DecodeError> {
if r.total_bytes() < 16 { return Err(DecodeError::InvalidValue) } if r.total_bytes() < 16 {
return Err(DecodeError::InvalidValue);
}
let mut chacha = ChaCha20Poly1305RFC::new(&secret, &[0; 12], &[]); let mut chacha = ChaCha20Poly1305RFC::new(&secret, &[0; 12], &[]);
let decrypted_len = r.total_bytes() - 16; let decrypted_len = r.total_bytes() - 16;
@ -70,14 +74,13 @@ impl<T: Readable> LengthReadableArgs<[u8; 32]> for ChaChaPolyReadAdapter<T> {
let mut tag = [0 as u8; 16]; let mut tag = [0 as u8; 16];
r.read_exact(&mut tag)?; r.read_exact(&mut tag)?;
if !chacha.finish_and_check_tag(&tag) { if !chacha.finish_and_check_tag(&tag) {
return Err(DecodeError::InvalidValue) return Err(DecodeError::InvalidValue);
} }
Ok(Self { readable }) Ok(Self { readable })
} }
} }
/// Enables simultaneously reading and decrypting a ChaCha20Poly1305RFC stream from a std::io::Read. /// Enables simultaneously reading and decrypting a ChaCha20Poly1305RFC stream from a std::io::Read.
struct ChaChaPolyReader<'a, R: Read> { struct ChaChaPolyReader<'a, R: Read> {
pub chacha: &'a mut ChaCha20Poly1305RFC, pub chacha: &'a mut ChaCha20Poly1305RFC,
@ -111,7 +114,9 @@ impl<'a, W: Writer> Writer for ChaChaPolyWriter<'a, W> {
let mut src_idx = 0; let mut src_idx = 0;
while src_idx < src.len() { while src_idx < src.len() {
let mut write_buffer = [0; 8192]; let mut write_buffer = [0; 8192];
let bytes_written = (&mut write_buffer[..]).write(&src[src_idx..]).expect("In-memory writes can't fail"); let bytes_written = (&mut write_buffer[..])
.write(&src[src_idx..])
.expect("In-memory writes can't fail");
self.chacha.encrypt_in_place(&mut write_buffer[..bytes_written]); self.chacha.encrypt_in_place(&mut write_buffer[..bytes_written]);
self.write.write_all(&write_buffer[..bytes_written])?; self.write.write_all(&write_buffer[..bytes_written])?;
src_idx += bytes_written; src_idx += bytes_written;
@ -120,11 +125,10 @@ impl<'a, W: Writer> Writer for ChaChaPolyWriter<'a, W> {
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::ln::msgs::DecodeError;
use super::{ChaChaPolyReadAdapter, ChaChaPolyWriteAdapter}; use super::{ChaChaPolyReadAdapter, ChaChaPolyWriteAdapter};
use crate::ln::msgs::DecodeError;
use crate::util::ser::{self, FixedLengthReader, LengthReadableArgs, Writeable}; use crate::util::ser::{self, FixedLengthReader, LengthReadableArgs, Writeable};
// Used for for testing various lengths of serialization. // Used for for testing various lengths of serialization.
@ -155,34 +159,26 @@ mod tests {
// Now deserialize the object back and make sure it matches the original. // Now deserialize the object back and make sure it matches the original.
let mut rd = FixedLengthReader::new(encrypted_writeable, writeable_len); let mut rd = FixedLengthReader::new(encrypted_writeable, writeable_len);
let read_adapter = <ChaChaPolyReadAdapter<TestWriteable>>::read(&mut rd, rho).unwrap(); let read_adapter =
<ChaChaPolyReadAdapter<TestWriteable>>::read(&mut rd, rho).unwrap();
assert_eq!($obj, read_adapter.readable); assert_eq!($obj, read_adapter.readable);
}; };
} }
// Try a big object that will require multiple write buffers. // Try a big object that will require multiple write buffers.
let big_writeable = TestWriteable { let big_writeable =
field1: vec![43], TestWriteable { field1: vec![43], field2: vec![44; 4192], field3: vec![45; 4192 + 1] };
field2: vec![44; 4192],
field3: vec![45; 4192 + 1],
};
check_object_read_write!(big_writeable); check_object_read_write!(big_writeable);
// Try a small object that fits into one write buffer. // Try a small object that fits into one write buffer.
let small_writeable = TestWriteable { let small_writeable =
field1: vec![43], TestWriteable { field1: vec![43], field2: vec![44], field3: vec![45] };
field2: vec![44],
field3: vec![45],
};
check_object_read_write!(small_writeable); check_object_read_write!(small_writeable);
} }
fn do_chacha_stream_adapters_ser_macros() -> Result<(), DecodeError> { fn do_chacha_stream_adapters_ser_macros() -> Result<(), DecodeError> {
let writeable = TestWriteable { let writeable =
field1: vec![43], TestWriteable { field1: vec![43], field2: vec![44; 4192], field3: vec![45; 4192 + 1] };
field2: vec![44; 4192],
field3: vec![45; 4192 + 1],
};
// First, serialize the object into a TLV stream, encrypted with ChaCha20Poly1305. // First, serialize the object into a TLV stream, encrypted with ChaCha20Poly1305.
let rho = [42; 32]; let rho = [42; 32];

17
lightning/src/crypto/utils.rs
View file

@ -1,7 +1,7 @@
use bitcoin::hashes::{Hash, HashEngine};
use bitcoin::hashes::hmac::{Hmac, HmacEngine}; use bitcoin::hashes::hmac::{Hmac, HmacEngine};
use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::hashes::sha256::Hash as Sha256;
use bitcoin::secp256k1::{Message, Secp256k1, SecretKey, ecdsa::Signature, Signing}; use bitcoin::hashes::{Hash, HashEngine};
use bitcoin::secp256k1::{ecdsa::Signature, Message, Secp256k1, SecretKey, Signing};
use crate::sign::EntropySource; use crate::sign::EntropySource;
@ -43,14 +43,16 @@ macro_rules! hkdf_extract_expand {
let k5 = Hmac::from_engine(hmac).to_byte_array(); let k5 = Hmac::from_engine(hmac).to_byte_array();
(k1, k2, k3, k4, k5) (k1, k2, k3, k4, k5)
}} }};
} }
pub fn hkdf_extract_expand_twice(salt: &[u8], ikm: &[u8]) -> ([u8; 32], [u8; 32]) { pub fn hkdf_extract_expand_twice(salt: &[u8], ikm: &[u8]) -> ([u8; 32], [u8; 32]) {
hkdf_extract_expand!(salt, ikm, 2) hkdf_extract_expand!(salt, ikm, 2)
} }
pub fn hkdf_extract_expand_5x(salt: &[u8], ikm: &[u8]) -> ([u8; 32], [u8; 32], [u8; 32], [u8; 32], [u8; 32]) { pub fn hkdf_extract_expand_5x(
salt: &[u8], ikm: &[u8],
) -> ([u8; 32], [u8; 32], [u8; 32], [u8; 32], [u8; 32]) {
hkdf_extract_expand!(salt, ikm, 5) hkdf_extract_expand!(salt, ikm, 5)
} }
@ -66,8 +68,11 @@ pub fn sign<C: Signing>(ctx: &Secp256k1<C>, msg: &Message, sk: &SecretKey) -> Si
#[inline] #[inline]
#[allow(unused_variables)] #[allow(unused_variables)]
pub fn sign_with_aux_rand<C: Signing, ES: Deref>( pub fn sign_with_aux_rand<C: Signing, ES: Deref>(
ctx: &Secp256k1<C>, msg: &Message, sk: &SecretKey, entropy_source: &ES ctx: &Secp256k1<C>, msg: &Message, sk: &SecretKey, entropy_source: &ES,
) -> Signature where ES::Target: EntropySource { ) -> Signature
where
ES::Target: EntropySource,
{
#[cfg(feature = "grind_signatures")] #[cfg(feature = "grind_signatures")]
let sig = loop { let sig = loop {
let sig = ctx.sign_ecdsa_with_noncedata(msg, sk, &entropy_source.get_secure_random_bytes()); let sig = ctx.sign_ecdsa_with_noncedata(msg, sk, &entropy_source.get_secure_random_bytes());

6
rustfmt_excluded_files
View file

@ -17,12 +17,6 @@
./lightning/src/chain/onchaintx.rs ./lightning/src/chain/onchaintx.rs
./lightning/src/chain/package.rs ./lightning/src/chain/package.rs
./lightning/src/chain/transaction.rs ./lightning/src/chain/transaction.rs
./lightning/src/crypto/chacha20.rs
./lightning/src/crypto/chacha20poly1305rfc.rs
./lightning/src/crypto/mod.rs
./lightning/src/crypto/poly1305.rs
./lightning/src/crypto/streams.rs
./lightning/src/crypto/utils.rs
./lightning/src/events/bump_transaction.rs ./lightning/src/events/bump_transaction.rs
./lightning/src/events/mod.rs ./lightning/src/events/mod.rs
./lightning/src/lib.rs ./lightning/src/lib.rs