X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fchacha20.rs;h=f46b344f2ce144c235e40e041743e707570e43a5;hb=ab2117796dc8702c1572b703ebd69c51d2926d0b;hp=85c0a47d4a5064f2fabe22e51829a7d1b60ed052;hpb=86d5944b0d4b85577d9eede80843dda445ad28e9;p=rust-lightning

diff --git a/lightning/src/util/chacha20.rs b/lightning/src/util/chacha20.rs
index 85c0a47d..f46b344f 100644
--- a/lightning/src/util/chacha20.rs
+++ b/lightning/src/util/chacha20.rs
@@ -9,9 +9,9 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
-use io;
+use crate::io;
 
-#[cfg(not(feature = "fuzztarget"))]
+#[cfg(not(fuzzing))]
 mod real_chacha {
 	use core::cmp;
 	use core::convert::TryInto;
@@ -159,6 +159,30 @@ mod real_chacha {
 			chacha_bytes
 		}
 
+		/// Encrypts `src` into `dest` using a single block from a ChaCha stream. Passing `dest` as
+		/// `src` in a second call will decrypt it.
+		pub fn encrypt_single_block(
+			key: &[u8; 32], nonce: &[u8; 16], dest: &mut [u8], src: &[u8]
+		) {
+			debug_assert_eq!(dest.len(), src.len());
+			debug_assert!(dest.len() <= 32);
+
+			let block = ChaCha20::get_single_block(key, nonce);
+			for i in 0..dest.len() {
+				dest[i] = block[i] ^ src[i];
+			}
+		}
+
+		/// Same as `encrypt_single_block` only operates on a fixed-size input in-place.
+		pub fn encrypt_single_block_in_place(
+			key: &[u8; 32], nonce: &[u8; 16], bytes: &mut [u8; 32]
+		) {
+			let block = ChaCha20::get_single_block(key, nonce);
+			for i in 0..bytes.len() {
+				bytes[i] = block[i] ^ bytes[i];
+			}
+		}
+
 		fn expand(key: &[u8], nonce: &[u8]) -> ChaChaState {
 			let constant = match key.len() {
 				16 => b"expand 16-byte k",
@@ -272,10 +296,10 @@ mod real_chacha {
 		}
 	}
 }
-#[cfg(not(feature = "fuzztarget"))]
+#[cfg(not(fuzzing))]
 pub use self::real_chacha::ChaCha20;
 
-#[cfg(feature = "fuzztarget")]
+#[cfg(fuzzing)]
 mod fuzzy_chacha {
 	pub struct ChaCha20 {}
 
@@ -290,6 +314,17 @@ mod fuzzy_chacha {
 			[0; 32]
 		}
 
+		pub fn encrypt_single_block(
+			_key: &[u8; 32], _nonce: &[u8; 16], dest: &mut [u8], src: &[u8]
+		) {
+			debug_assert_eq!(dest.len(), src.len());
+			debug_assert!(dest.len() <= 32);
+		}
+
+		pub fn encrypt_single_block_in_place(
+			_key: &[u8; 32], _nonce: &[u8; 16], _bytes: &mut [u8; 32]
+		) {}
+
 		pub fn process(&mut self, input: &[u8], output: &mut [u8]) {
 			output.copy_from_slice(input);
 		}
@@ -297,7 +332,7 @@ mod fuzzy_chacha {
 		pub fn process_in_place(&mut self, _input_output: &mut [u8]) {}
 	}
 }
-#[cfg(feature = "fuzztarget")]
+#[cfg(fuzzing)]
 pub use self::fuzzy_chacha::ChaCha20;
 
 pub(crate) struct ChaChaReader<'a, R: io::Read> {
@@ -316,7 +351,7 @@ impl<'a, R: io::Read> io::Read for ChaChaReader<'a, R> {
 
 #[cfg(test)]
 mod test {
-	use prelude::*;
+	use crate::prelude::*;
 	use core::iter::repeat;
 
 	use super::ChaCha20;
@@ -618,4 +653,49 @@ mod test {
 
 		assert_eq!(ChaCha20::get_single_block(&key, &nonce_16bytes), block_bytes);
 	}
+
+	#[test]
+	fn encrypt_single_block() {
+		let 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,
+		];
+		let nonce = [
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+			0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+		];
+		let bytes = [1; 32];
+
+		let mut encrypted_bytes = [0; 32];
+		ChaCha20::encrypt_single_block(&key, &nonce, &mut encrypted_bytes, &bytes);
+
+		let mut decrypted_bytes = [0; 32];
+		ChaCha20::encrypt_single_block(&key, &nonce, &mut decrypted_bytes, &encrypted_bytes);
+
+		assert_eq!(bytes, decrypted_bytes);
+	}
+
+	#[test]
+	fn encrypt_single_block_in_place() {
+		let 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,
+		];
+		let nonce = [
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+			0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+		];
+		let unencrypted_bytes = [1; 32];
+		let mut bytes = unencrypted_bytes;
+
+		ChaCha20::encrypt_single_block_in_place(&key, &nonce, &mut bytes);
+		assert_ne!(bytes, unencrypted_bytes);
+
+		ChaCha20::encrypt_single_block_in_place(&key, &nonce, &mut bytes);
+		assert_eq!(bytes, unencrypted_bytes);
+	}
 }