cipher: integrate block-modes

cipher/Cargo.toml

@@ -14,9 +14,12 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.3", optional = true }
+block-padding = { verstion = "0.2", optional = true }
 
 [features]
+default = ["block-mode"]
 std = []
+block-mode = ["block-padding"]
 dev = ["blobby"]
 
 [package.metadata.docs.rs]

cipher/src/block.rs

@@ -9,21 +9,17 @@
 //! [1]: https://en.wikipedia.org/wiki/Block_cipher
 //! [2]: https://en.wikipedia.org/wiki/Symmetric-key_algorithm
 
-#[cfg(feature = "dev")]
-#[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-pub mod dev;
-
 use crate::errors::InvalidLength;
 use core::convert::TryInto;
 use generic_array::{typenum::Unsigned, ArrayLength, GenericArray};
 
 /// Key for an algorithm that implements [`NewBlockCipher`].
-pub type Key<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
+pub type BlockCipherKey<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
 
 /// Block on which a [`BlockCipher`] operates.
 pub type Block<B> = GenericArray<u8, <B as BlockCipher>::BlockSize>;
 
-/// Blocks being acted over in parallel.
+/// Block on which a [`BlockCipher`] operates in parallel.
 pub type ParBlocks<B> = GenericArray<Block<B>, <B as BlockCipher>::ParBlocks>;
 
 /// Instantiate a [`BlockCipher`] algorithm.
@@ -32,13 +28,13 @@ pub trait NewBlockCipher: Sized {
  type KeySize: ArrayLength<u8>;
 
  /// Create new block cipher instance from key with fixed size.
- fn new(key: &Key<Self>) -> Self;
+ fn new(key: &BlockCipherKey<Self>) -> Self;
 
  /// Create new block cipher instance from key with variable size.
  ///
  /// Default implementation will accept only keys with length equal to
  /// `KeySize`, but some ciphers can accept range of key lengths.
- fn new_varkey(key: &[u8]) -> Result<Self, InvalidLength> {
+ fn new_var(key: &[u8]) -> Result<Self, InvalidLength> {
  if key.len() != Self::KeySize::to_usize() {
  Err(InvalidLength)
  } else {
@@ -57,7 +53,7 @@ pub trait BlockCipher {
  type ParBlocks: ArrayLength<Block<Self>>;
 }
 
-/// Encrypt-only functionality for block ciphers
+/// Encrypt-only functionality for block ciphers.
 pub trait BlockEncrypt: BlockCipher {
  /// Encrypt block in-place
  fn encrypt_block(&self, block: &mut Block<Self>);
@@ -94,7 +90,7 @@ pub trait BlockEncrypt: BlockCipher {
  }
 }
 
-/// Decrypt-only functionality for block ciphers
+/// Decrypt-only functionality for block ciphers.
 pub trait BlockDecrypt: BlockCipher {
  /// Decrypt block in-place
  fn decrypt_block(&self, block: &mut Block<Self>);

cipher/src/common.rs

@@ -0,0 +1,79 @@
+use generic_array::{ArrayLength, GenericArray, typenum::Unsigned};
+use crate::{BlockCipher, NewBlockCipher, errors::InvalidLength};
+
+/// Key for an algorithm that implements [`NewCipher`].
+pub type CipherKey<C> = GenericArray<u8, <C as NewCipher>::KeySize>;
+
+/// Nonce for an algorithm that implements [`NewCipher`].
+pub type Nonce<C> = GenericArray<u8, <C as NewCipher>::NonceSize>;
+
+/// Cipher creation trait.
+///
+/// It can be used for creation of block modes, synchronous and asynchronous stream ciphers.
+pub trait NewCipher: Sized {
+ /// Key size in bytes
+ type KeySize: ArrayLength<u8>;
+
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> Self;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ #[inline]
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ let kl = Self::KeySize::to_usize();
+ let nl = Self::NonceSize::to_usize();
+ if key.len() != kl || nonce.len() != nl {
+ Err(InvalidLength)
+ } else {
+ let key = GenericArray::from_slice(key);
+ let nonce = GenericArray::from_slice(nonce);
+ Ok(Self::new(key, nonce))
+ }
+ }
+}
+
+/// Trait for types which can be initialized from a block cipher and nonce.
+pub trait FromBlockCipher {
+ /// Block cipher
+ type BlockCipher: BlockCipher;
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Instantiate a stream cipher from a block cipher
+ fn from_block_cipher(
+ cipher: Self::BlockCipher,
+ nonce: &GenericArray<u8, Self::NonceSize>,
+ ) -> Self;
+}
+
+impl<C> NewCipher for C
+where
+ C: FromBlockCipher,
+ C::BlockCipher: NewBlockCipher,
+{
+ type KeySize = <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::KeySize;
+ type NonceSize = <Self as FromBlockCipher>::NonceSize;
+
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> C {
+ C::from_block_cipher(
+ <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::new(key),
+ nonce,
+ )
+ }
+
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ if nonce.len() != Self::NonceSize::USIZE {
+ Err(InvalidLength)
+ } else {
+ C::BlockCipher::new_var(key)
+ .map_err(|_| InvalidLength)
+ .map(|cipher| {
+ let nonce = GenericArray::from_slice(nonce);
+ Self::from_block_cipher(cipher, nonce)
+ })
+ }
+ }
+}

cipher/src/dev.rs

@@ -0,0 +1,2 @@
+mod stream;
+mod block;

cipher/src/block/dev.rs → cipher/src/dev/block.rs

@@ -9,13 +9,13 @@ macro_rules! block_cipher_test {
  ($name:ident, $test_name:expr, $cipher:ty) => {
  #[test]
  fn $name() {
- use cipher::block::{
-dev::blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
+ use cipher::{
+ blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
  };
  use cipher::generic_array::{typenum::Unsigned, GenericArray};
 
  fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let mut block = GenericArray::clone_from_slice(pt);
  state.encrypt_block(&mut block);
@@ -37,7 +37,7 @@ macro_rules! block_cipher_test {
  type Block = GenericArray<u8, BlockSize>;
  type ParBlock = GenericArray<Block, ParBlocks>;
 
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let block = Block::clone_from_slice(pt);
  let mut blocks1 = ParBlock::default();
@@ -113,12 +113,12 @@ macro_rules! block_cipher_bench {
  ($cipher:path, $key_len:expr) => {
  extern crate test;
 
- use cipher::block::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
+ use cipher::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
  use test::Bencher;
 
  #[bench]
  pub fn encrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {
@@ -130,7 +130,7 @@ macro_rules! block_cipher_bench {
 
  #[bench]
  pub fn decrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {

cipher/src/stream/dev.rs → cipher/src/dev/stream.rs

@@ -3,12 +3,12 @@
 /// Test core functionality of synchronous stream cipher
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-macro_rules! stream_cipher_sync_test {
+macro_rules! stream_cipher_test {
  ($name:ident, $cipher:ty, $test_name:expr) => {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, SyncStreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, StreamCipher};
 
  let data = include_bytes!(concat!("data/", $test_name, ".blb"));
  for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
@@ -44,7 +44,7 @@ macro_rules! stream_cipher_seek_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
+ use cipher::{NewCipher, StreamCipher, StreamCipherSeek};
 
  fn get_cipher() -> $cipher {
  <$cipher>::new(&Default::default(), &Default::default())
@@ -97,7 +97,7 @@ macro_rules! stream_cipher_async_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, StreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, AsyncStreamCipher};
 
  fn run_test(
  key: &[u8],
@@ -172,8 +172,7 @@ macro_rules! stream_cipher_sync_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher};
+ use cipher::{NewCipher, StreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]
@@ -225,8 +224,7 @@ macro_rules! stream_cipher_async_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, StreamCipher};
+ use cipher::{NewCipher, AsyncStreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]

cipher/src/errors.rs

@@ -1,4 +1,4 @@
-//! Error types
+//! Error types.
 
 use core::fmt;
 
@@ -48,3 +48,16 @@ impl From<OverflowError> for LoopError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for OverflowError {}
+
+/// Block mode error.
+#[derive(Clone, Copy, Debug)]
+pub struct BlockModeError;
+
+impl fmt::Display for BlockModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+ f.write_str("BlockModeError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockModeError {}

cipher/src/lib.rs

@@ -15,15 +15,25 @@
 
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "block-mode")]
+pub extern crate block_padding;
+#[cfg(feature = "dev")]
+pub extern crate blobby;
 
-pub mod block;
 pub mod errors;
-pub mod stream;
+#[cfg(feature = "dev")]
+mod dev;
+mod block;
+mod common;
+#[cfg(feature = "block-padding")]
+mod mode;
+mod stream;
 
 pub use crate::{
- block::{
- BlockCipher, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, NewBlockCipher,
- },
- stream::{NewStreamCipher, StreamCipher, SyncStreamCipher, SyncStreamCipherSeek},
+ block::*,
+ common::*,
+ stream::*,
 };
+#[cfg(feature = "block-mode")]
+pub use crate::mode::BlockModeCore;
 pub use generic_array::{self, typenum::consts};

cipher/Cargo.toml

@@ -14,9 +14,12 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.3", optional = true }
+block-padding = { verstion = "0.2", optional = true }
 
 [features]
+default = ["block-mode"]
 std = []
+block-mode = ["block-padding"]
 dev = ["blobby"]
 
 [package.metadata.docs.rs]

cipher/src/block.rs

@@ -9,21 +9,17 @@
 //! [1]: https://en.wikipedia.org/wiki/Block_cipher
 //! [2]: https://en.wikipedia.org/wiki/Symmetric-key_algorithm
 
-#[cfg(feature = "dev")]
-#[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-pub mod dev;
-
 use crate::errors::InvalidLength;
 use core::convert::TryInto;
 use generic_array::{typenum::Unsigned, ArrayLength, GenericArray};
 
 /// Key for an algorithm that implements [`NewBlockCipher`].
-pub type Key<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
+pub type BlockCipherKey<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
 
 /// Block on which a [`BlockCipher`] operates.
 pub type Block<B> = GenericArray<u8, <B as BlockCipher>::BlockSize>;
 
-/// Blocks being acted over in parallel.
+/// Block on which a [`BlockCipher`] operates in parallel.
 pub type ParBlocks<B> = GenericArray<Block<B>, <B as BlockCipher>::ParBlocks>;
 
 /// Instantiate a [`BlockCipher`] algorithm.
@@ -32,13 +28,13 @@ pub trait NewBlockCipher: Sized {
  type KeySize: ArrayLength<u8>;
 
  /// Create new block cipher instance from key with fixed size.
- fn new(key: &Key<Self>) -> Self;
+ fn new(key: &BlockCipherKey<Self>) -> Self;
 
  /// Create new block cipher instance from key with variable size.
  ///
  /// Default implementation will accept only keys with length equal to
  /// `KeySize`, but some ciphers can accept range of key lengths.
- fn new_varkey(key: &[u8]) -> Result<Self, InvalidLength> {
+ fn new_var(key: &[u8]) -> Result<Self, InvalidLength> {
  if key.len() != Self::KeySize::to_usize() {
  Err(InvalidLength)
  } else {
@@ -57,7 +53,7 @@ pub trait BlockCipher {
  type ParBlocks: ArrayLength<Block<Self>>;
 }
 
-/// Encrypt-only functionality for block ciphers
+/// Encrypt-only functionality for block ciphers.
 pub trait BlockEncrypt: BlockCipher {
  /// Encrypt block in-place
  fn encrypt_block(&self, block: &mut Block<Self>);
@@ -94,7 +90,7 @@ pub trait BlockEncrypt: BlockCipher {
  }
 }
 
-/// Decrypt-only functionality for block ciphers
+/// Decrypt-only functionality for block ciphers.
 pub trait BlockDecrypt: BlockCipher {
  /// Decrypt block in-place
  fn decrypt_block(&self, block: &mut Block<Self>);

cipher/src/common.rs

@@ -0,0 +1,79 @@
+use generic_array::{ArrayLength, GenericArray, typenum::Unsigned};
+use crate::{BlockCipher, NewBlockCipher, errors::InvalidLength};
+
+/// Key for an algorithm that implements [`NewCipher`].
+pub type CipherKey<C> = GenericArray<u8, <C as NewCipher>::KeySize>;
+
+/// Nonce for an algorithm that implements [`NewCipher`].
+pub type Nonce<C> = GenericArray<u8, <C as NewCipher>::NonceSize>;
+
+/// Cipher creation trait.
+///
+/// It can be used for creation of block modes, synchronous and asynchronous stream ciphers.
+pub trait NewCipher: Sized {
+ /// Key size in bytes
+ type KeySize: ArrayLength<u8>;
+
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> Self;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ #[inline]
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ let kl = Self::KeySize::to_usize();
+ let nl = Self::NonceSize::to_usize();
+ if key.len() != kl || nonce.len() != nl {
+ Err(InvalidLength)
+ } else {
+ let key = GenericArray::from_slice(key);
+ let nonce = GenericArray::from_slice(nonce);
+ Ok(Self::new(key, nonce))
+ }
+ }
+}
+
+/// Trait for types which can be initialized from a block cipher and nonce.
+pub trait FromBlockCipher {
+ /// Block cipher
+ type BlockCipher: BlockCipher;
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Instantiate a stream cipher from a block cipher
+ fn from_block_cipher(
+ cipher: Self::BlockCipher,
+ nonce: &GenericArray<u8, Self::NonceSize>,
+ ) -> Self;
+}
+
+impl<C> NewCipher for C
+where
+ C: FromBlockCipher,
+ C::BlockCipher: NewBlockCipher,
+{
+ type KeySize = <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::KeySize;
+ type NonceSize = <Self as FromBlockCipher>::NonceSize;
+
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> C {
+ C::from_block_cipher(
+ <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::new(key),
+ nonce,
+ )
+ }
+
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ if nonce.len() != Self::NonceSize::USIZE {
+ Err(InvalidLength)
+ } else {
+ C::BlockCipher::new_var(key)
+ .map_err(|_| InvalidLength)
+ .map(|cipher| {
+ let nonce = GenericArray::from_slice(nonce);
+ Self::from_block_cipher(cipher, nonce)
+ })
+ }
+ }
+}

cipher/src/dev.rs

@@ -0,0 +1,2 @@
+mod stream;
+mod block;

cipher/src/block/dev.rs → cipher/src/dev/block.rs

@@ -9,13 +9,13 @@ macro_rules! block_cipher_test {
  ($name:ident, $test_name:expr, $cipher:ty) => {
  #[test]
  fn $name() {
- use cipher::block::{
-dev::blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
+ use cipher::{
+ blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
  };
  use cipher::generic_array::{typenum::Unsigned, GenericArray};
 
  fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let mut block = GenericArray::clone_from_slice(pt);
  state.encrypt_block(&mut block);
@@ -37,7 +37,7 @@ macro_rules! block_cipher_test {
  type Block = GenericArray<u8, BlockSize>;
  type ParBlock = GenericArray<Block, ParBlocks>;
 
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let block = Block::clone_from_slice(pt);
  let mut blocks1 = ParBlock::default();
@@ -113,12 +113,12 @@ macro_rules! block_cipher_bench {
  ($cipher:path, $key_len:expr) => {
  extern crate test;
 
- use cipher::block::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
+ use cipher::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
  use test::Bencher;
 
  #[bench]
  pub fn encrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {
@@ -130,7 +130,7 @@ macro_rules! block_cipher_bench {
 
  #[bench]
  pub fn decrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {

cipher/src/stream/dev.rs → cipher/src/dev/stream.rs

@@ -3,12 +3,12 @@
 /// Test core functionality of synchronous stream cipher
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-macro_rules! stream_cipher_sync_test {
+macro_rules! stream_cipher_test {
  ($name:ident, $cipher:ty, $test_name:expr) => {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, SyncStreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, StreamCipher};
 
  let data = include_bytes!(concat!("data/", $test_name, ".blb"));
  for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
@@ -44,7 +44,7 @@ macro_rules! stream_cipher_seek_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
+ use cipher::{NewCipher, StreamCipher, StreamCipherSeek};
 
  fn get_cipher() -> $cipher {
  <$cipher>::new(&Default::default(), &Default::default())
@@ -97,7 +97,7 @@ macro_rules! stream_cipher_async_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, StreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, AsyncStreamCipher};
 
  fn run_test(
  key: &[u8],
@@ -172,8 +172,7 @@ macro_rules! stream_cipher_sync_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher};
+ use cipher::{NewCipher, StreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]
@@ -225,8 +224,7 @@ macro_rules! stream_cipher_async_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, StreamCipher};
+ use cipher::{NewCipher, AsyncStreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]

cipher/src/errors.rs

@@ -1,4 +1,4 @@
-//! Error types
+//! Error types.
 
 use core::fmt;
 
@@ -48,3 +48,16 @@ impl From<OverflowError> for LoopError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for OverflowError {}
+
+/// Block mode error.
+#[derive(Clone, Copy, Debug)]
+pub struct BlockModeError;
+
+impl fmt::Display for BlockModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+ f.write_str("BlockModeError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockModeError {}

cipher/src/lib.rs

@@ -15,15 +15,25 @@
 
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "block-mode")]
+pub extern crate block_padding;
+#[cfg(feature = "dev")]
+pub extern crate blobby;
 
-pub mod block;
 pub mod errors;
-pub mod stream;
+#[cfg(feature = "dev")]
+mod dev;
+mod block;
+mod common;
+#[cfg(feature = "block-padding")]
+mod mode;
+mod stream;
 
 pub use crate::{
- block::{
- BlockCipher, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, NewBlockCipher,
- },
- stream::{NewStreamCipher, StreamCipher, SyncStreamCipher, SyncStreamCipherSeek},
+ block::*,
+ common::*,
+ stream::*,
 };
+#[cfg(feature = "block-mode")]
+pub use crate::mode::BlockModeCore;
 pub use generic_array::{self, typenum::consts};

cipher/Cargo.toml

@@ -14,9 +14,12 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.3", optional = true }
+block-padding = { verstion = "0.2", optional = true }
 
 [features]
+default = ["block-mode"]
 std = []
+block-mode = ["block-padding"]
 dev = ["blobby"]
 
 [package.metadata.docs.rs]

cipher/src/block.rs

@@ -9,21 +9,17 @@
 //! [1]: https://en.wikipedia.org/wiki/Block_cipher
 //! [2]: https://en.wikipedia.org/wiki/Symmetric-key_algorithm
 
-#[cfg(feature = "dev")]
-#[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-pub mod dev;
-
 use crate::errors::InvalidLength;
 use core::convert::TryInto;
 use generic_array::{typenum::Unsigned, ArrayLength, GenericArray};
 
 /// Key for an algorithm that implements [`NewBlockCipher`].
-pub type Key<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
+pub type BlockCipherKey<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
 
 /// Block on which a [`BlockCipher`] operates.
 pub type Block<B> = GenericArray<u8, <B as BlockCipher>::BlockSize>;
 
-/// Blocks being acted over in parallel.
+/// Block on which a [`BlockCipher`] operates in parallel.
 pub type ParBlocks<B> = GenericArray<Block<B>, <B as BlockCipher>::ParBlocks>;
 
 /// Instantiate a [`BlockCipher`] algorithm.
@@ -32,13 +28,13 @@ pub trait NewBlockCipher: Sized {
  type KeySize: ArrayLength<u8>;
 
  /// Create new block cipher instance from key with fixed size.
- fn new(key: &Key<Self>) -> Self;
+ fn new(key: &BlockCipherKey<Self>) -> Self;
 
  /// Create new block cipher instance from key with variable size.
  ///
  /// Default implementation will accept only keys with length equal to
  /// `KeySize`, but some ciphers can accept range of key lengths.
- fn new_varkey(key: &[u8]) -> Result<Self, InvalidLength> {
+ fn new_var(key: &[u8]) -> Result<Self, InvalidLength> {
  if key.len() != Self::KeySize::to_usize() {
  Err(InvalidLength)
  } else {
@@ -57,7 +53,7 @@ pub trait BlockCipher {
  type ParBlocks: ArrayLength<Block<Self>>;
 }
 
-/// Encrypt-only functionality for block ciphers
+/// Encrypt-only functionality for block ciphers.
 pub trait BlockEncrypt: BlockCipher {
  /// Encrypt block in-place
  fn encrypt_block(&self, block: &mut Block<Self>);
@@ -94,7 +90,7 @@ pub trait BlockEncrypt: BlockCipher {
  }
 }
 
-/// Decrypt-only functionality for block ciphers
+/// Decrypt-only functionality for block ciphers.
 pub trait BlockDecrypt: BlockCipher {
  /// Decrypt block in-place
  fn decrypt_block(&self, block: &mut Block<Self>);

cipher/src/common.rs

@@ -0,0 +1,79 @@
+use generic_array::{ArrayLength, GenericArray, typenum::Unsigned};
+use crate::{BlockCipher, NewBlockCipher, errors::InvalidLength};
+
+/// Key for an algorithm that implements [`NewCipher`].
+pub type CipherKey<C> = GenericArray<u8, <C as NewCipher>::KeySize>;
+
+/// Nonce for an algorithm that implements [`NewCipher`].
+pub type Nonce<C> = GenericArray<u8, <C as NewCipher>::NonceSize>;
+
+/// Cipher creation trait.
+///
+/// It can be used for creation of block modes, synchronous and asynchronous stream ciphers.
+pub trait NewCipher: Sized {
+ /// Key size in bytes
+ type KeySize: ArrayLength<u8>;
+
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> Self;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ #[inline]
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ let kl = Self::KeySize::to_usize();
+ let nl = Self::NonceSize::to_usize();
+ if key.len() != kl || nonce.len() != nl {
+ Err(InvalidLength)
+ } else {
+ let key = GenericArray::from_slice(key);
+ let nonce = GenericArray::from_slice(nonce);
+ Ok(Self::new(key, nonce))
+ }
+ }
+}
+
+/// Trait for types which can be initialized from a block cipher and nonce.
+pub trait FromBlockCipher {
+ /// Block cipher
+ type BlockCipher: BlockCipher;
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Instantiate a stream cipher from a block cipher
+ fn from_block_cipher(
+ cipher: Self::BlockCipher,
+ nonce: &GenericArray<u8, Self::NonceSize>,
+ ) -> Self;
+}
+
+impl<C> NewCipher for C
+where
+ C: FromBlockCipher,
+ C::BlockCipher: NewBlockCipher,
+{
+ type KeySize = <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::KeySize;
+ type NonceSize = <Self as FromBlockCipher>::NonceSize;
+
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> C {
+ C::from_block_cipher(
+ <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::new(key),
+ nonce,
+ )
+ }
+
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ if nonce.len() != Self::NonceSize::USIZE {
+ Err(InvalidLength)
+ } else {
+ C::BlockCipher::new_var(key)
+ .map_err(|_| InvalidLength)
+ .map(|cipher| {
+ let nonce = GenericArray::from_slice(nonce);
+ Self::from_block_cipher(cipher, nonce)
+ })
+ }
+ }
+}

cipher/src/dev.rs

@@ -0,0 +1,2 @@
+mod stream;
+mod block;

cipher/src/block/dev.rs → cipher/src/dev/block.rs

@@ -9,13 +9,13 @@ macro_rules! block_cipher_test {
  ($name:ident, $test_name:expr, $cipher:ty) => {
  #[test]
  fn $name() {
- use cipher::block::{
-dev::blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
+ use cipher::{
+ blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
  };
  use cipher::generic_array::{typenum::Unsigned, GenericArray};
 
  fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let mut block = GenericArray::clone_from_slice(pt);
  state.encrypt_block(&mut block);
@@ -37,7 +37,7 @@ macro_rules! block_cipher_test {
  type Block = GenericArray<u8, BlockSize>;
  type ParBlock = GenericArray<Block, ParBlocks>;
 
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let block = Block::clone_from_slice(pt);
  let mut blocks1 = ParBlock::default();
@@ -113,12 +113,12 @@ macro_rules! block_cipher_bench {
  ($cipher:path, $key_len:expr) => {
  extern crate test;
 
- use cipher::block::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
+ use cipher::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
  use test::Bencher;
 
  #[bench]
  pub fn encrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {
@@ -130,7 +130,7 @@ macro_rules! block_cipher_bench {
 
  #[bench]
  pub fn decrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {

cipher/src/stream/dev.rs → cipher/src/dev/stream.rs

@@ -3,12 +3,12 @@
 /// Test core functionality of synchronous stream cipher
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-macro_rules! stream_cipher_sync_test {
+macro_rules! stream_cipher_test {
  ($name:ident, $cipher:ty, $test_name:expr) => {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, SyncStreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, StreamCipher};
 
  let data = include_bytes!(concat!("data/", $test_name, ".blb"));
  for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
@@ -44,7 +44,7 @@ macro_rules! stream_cipher_seek_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
+ use cipher::{NewCipher, StreamCipher, StreamCipherSeek};
 
  fn get_cipher() -> $cipher {
  <$cipher>::new(&Default::default(), &Default::default())
@@ -97,7 +97,7 @@ macro_rules! stream_cipher_async_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, StreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, AsyncStreamCipher};
 
  fn run_test(
  key: &[u8],
@@ -172,8 +172,7 @@ macro_rules! stream_cipher_sync_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher};
+ use cipher::{NewCipher, StreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]
@@ -225,8 +224,7 @@ macro_rules! stream_cipher_async_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, StreamCipher};
+ use cipher::{NewCipher, AsyncStreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]

cipher/src/errors.rs

@@ -1,4 +1,4 @@
-//! Error types
+//! Error types.
 
 use core::fmt;
 
@@ -48,3 +48,16 @@ impl From<OverflowError> for LoopError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for OverflowError {}
+
+/// Block mode error.
+#[derive(Clone, Copy, Debug)]
+pub struct BlockModeError;
+
+impl fmt::Display for BlockModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+ f.write_str("BlockModeError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockModeError {}

cipher/src/lib.rs

@@ -15,15 +15,25 @@
 
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "block-mode")]
+pub extern crate block_padding;
+#[cfg(feature = "dev")]
+pub extern crate blobby;
 
-pub mod block;
 pub mod errors;
-pub mod stream;
+#[cfg(feature = "dev")]
+mod dev;
+mod block;
+mod common;
+#[cfg(feature = "block-padding")]
+mod mode;
+mod stream;
 
 pub use crate::{
- block::{
- BlockCipher, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, NewBlockCipher,
- },
- stream::{NewStreamCipher, StreamCipher, SyncStreamCipher, SyncStreamCipherSeek},
+ block::*,
+ common::*,
+ stream::*,
 };
+#[cfg(feature = "block-mode")]
+pub use crate::mode::BlockModeCore;
 pub use generic_array::{self, typenum::consts};

cipher/Cargo.toml

@@ -14,9 +14,12 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.3", optional = true }
+block-padding = { verstion = "0.2", optional = true }
 
 [features]
+default = ["block-mode"]
 std = []
+block-mode = ["block-padding"]
 dev = ["blobby"]
 
 [package.metadata.docs.rs]

cipher/src/block.rs

@@ -9,21 +9,17 @@
 //! [1]: https://en.wikipedia.org/wiki/Block_cipher
 //! [2]: https://en.wikipedia.org/wiki/Symmetric-key_algorithm
 
-#[cfg(feature = "dev")]
-#[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-pub mod dev;
-
 use crate::errors::InvalidLength;
 use core::convert::TryInto;
 use generic_array::{typenum::Unsigned, ArrayLength, GenericArray};
 
 /// Key for an algorithm that implements [`NewBlockCipher`].
-pub type Key<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
+pub type BlockCipherKey<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
 
 /// Block on which a [`BlockCipher`] operates.
 pub type Block<B> = GenericArray<u8, <B as BlockCipher>::BlockSize>;
 
-/// Blocks being acted over in parallel.
+/// Block on which a [`BlockCipher`] operates in parallel.
 pub type ParBlocks<B> = GenericArray<Block<B>, <B as BlockCipher>::ParBlocks>;
 
 /// Instantiate a [`BlockCipher`] algorithm.
@@ -32,13 +28,13 @@ pub trait NewBlockCipher: Sized {
  type KeySize: ArrayLength<u8>;
 
  /// Create new block cipher instance from key with fixed size.
- fn new(key: &Key<Self>) -> Self;
+ fn new(key: &BlockCipherKey<Self>) -> Self;
 
  /// Create new block cipher instance from key with variable size.
  ///
  /// Default implementation will accept only keys with length equal to
  /// `KeySize`, but some ciphers can accept range of key lengths.
- fn new_varkey(key: &[u8]) -> Result<Self, InvalidLength> {
+ fn new_var(key: &[u8]) -> Result<Self, InvalidLength> {
  if key.len() != Self::KeySize::to_usize() {
  Err(InvalidLength)
  } else {
@@ -57,7 +53,7 @@ pub trait BlockCipher {
  type ParBlocks: ArrayLength<Block<Self>>;
 }
 
-/// Encrypt-only functionality for block ciphers
+/// Encrypt-only functionality for block ciphers.
 pub trait BlockEncrypt: BlockCipher {
  /// Encrypt block in-place
  fn encrypt_block(&self, block: &mut Block<Self>);
@@ -94,7 +90,7 @@ pub trait BlockEncrypt: BlockCipher {
  }
 }
 
-/// Decrypt-only functionality for block ciphers
+/// Decrypt-only functionality for block ciphers.
 pub trait BlockDecrypt: BlockCipher {
  /// Decrypt block in-place
  fn decrypt_block(&self, block: &mut Block<Self>);

cipher/src/common.rs

@@ -0,0 +1,79 @@
+use generic_array::{ArrayLength, GenericArray, typenum::Unsigned};
+use crate::{BlockCipher, NewBlockCipher, errors::InvalidLength};
+
+/// Key for an algorithm that implements [`NewCipher`].
+pub type CipherKey<C> = GenericArray<u8, <C as NewCipher>::KeySize>;
+
+/// Nonce for an algorithm that implements [`NewCipher`].
+pub type Nonce<C> = GenericArray<u8, <C as NewCipher>::NonceSize>;
+
+/// Cipher creation trait.
+///
+/// It can be used for creation of block modes, synchronous and asynchronous stream ciphers.
+pub trait NewCipher: Sized {
+ /// Key size in bytes
+ type KeySize: ArrayLength<u8>;
+
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> Self;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ #[inline]
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ let kl = Self::KeySize::to_usize();
+ let nl = Self::NonceSize::to_usize();
+ if key.len() != kl || nonce.len() != nl {
+ Err(InvalidLength)
+ } else {
+ let key = GenericArray::from_slice(key);
+ let nonce = GenericArray::from_slice(nonce);
+ Ok(Self::new(key, nonce))
+ }
+ }
+}
+
+/// Trait for types which can be initialized from a block cipher and nonce.
+pub trait FromBlockCipher {
+ /// Block cipher
+ type BlockCipher: BlockCipher;
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Instantiate a stream cipher from a block cipher
+ fn from_block_cipher(
+ cipher: Self::BlockCipher,
+ nonce: &GenericArray<u8, Self::NonceSize>,
+ ) -> Self;
+}
+
+impl<C> NewCipher for C
+where
+ C: FromBlockCipher,
+ C::BlockCipher: NewBlockCipher,
+{
+ type KeySize = <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::KeySize;
+ type NonceSize = <Self as FromBlockCipher>::NonceSize;
+
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> C {
+ C::from_block_cipher(
+ <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::new(key),
+ nonce,
+ )
+ }
+
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ if nonce.len() != Self::NonceSize::USIZE {
+ Err(InvalidLength)
+ } else {
+ C::BlockCipher::new_var(key)
+ .map_err(|_| InvalidLength)
+ .map(|cipher| {
+ let nonce = GenericArray::from_slice(nonce);
+ Self::from_block_cipher(cipher, nonce)
+ })
+ }
+ }
+}

cipher/src/dev.rs

@@ -0,0 +1,2 @@
+mod stream;
+mod block;

cipher/src/block/dev.rs → cipher/src/dev/block.rs

@@ -9,13 +9,13 @@ macro_rules! block_cipher_test {
  ($name:ident, $test_name:expr, $cipher:ty) => {
  #[test]
  fn $name() {
- use cipher::block::{
-dev::blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
+ use cipher::{
+ blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
  };
  use cipher::generic_array::{typenum::Unsigned, GenericArray};
 
  fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let mut block = GenericArray::clone_from_slice(pt);
  state.encrypt_block(&mut block);
@@ -37,7 +37,7 @@ macro_rules! block_cipher_test {
  type Block = GenericArray<u8, BlockSize>;
  type ParBlock = GenericArray<Block, ParBlocks>;
 
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let block = Block::clone_from_slice(pt);
  let mut blocks1 = ParBlock::default();
@@ -113,12 +113,12 @@ macro_rules! block_cipher_bench {
  ($cipher:path, $key_len:expr) => {
  extern crate test;
 
- use cipher::block::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
+ use cipher::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
  use test::Bencher;
 
  #[bench]
  pub fn encrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {
@@ -130,7 +130,7 @@ macro_rules! block_cipher_bench {
 
  #[bench]
  pub fn decrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {

cipher/src/stream/dev.rs → cipher/src/dev/stream.rs

@@ -3,12 +3,12 @@
 /// Test core functionality of synchronous stream cipher
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-macro_rules! stream_cipher_sync_test {
+macro_rules! stream_cipher_test {
  ($name:ident, $cipher:ty, $test_name:expr) => {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, SyncStreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, StreamCipher};
 
  let data = include_bytes!(concat!("data/", $test_name, ".blb"));
  for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
@@ -44,7 +44,7 @@ macro_rules! stream_cipher_seek_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
+ use cipher::{NewCipher, StreamCipher, StreamCipherSeek};
 
  fn get_cipher() -> $cipher {
  <$cipher>::new(&Default::default(), &Default::default())
@@ -97,7 +97,7 @@ macro_rules! stream_cipher_async_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, StreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, AsyncStreamCipher};
 
  fn run_test(
  key: &[u8],
@@ -172,8 +172,7 @@ macro_rules! stream_cipher_sync_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher};
+ use cipher::{NewCipher, StreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]
@@ -225,8 +224,7 @@ macro_rules! stream_cipher_async_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, StreamCipher};
+ use cipher::{NewCipher, AsyncStreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]

cipher/src/errors.rs

@@ -1,4 +1,4 @@
-//! Error types
+//! Error types.
 
 use core::fmt;
 
@@ -48,3 +48,16 @@ impl From<OverflowError> for LoopError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for OverflowError {}
+
+/// Block mode error.
+#[derive(Clone, Copy, Debug)]
+pub struct BlockModeError;
+
+impl fmt::Display for BlockModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+ f.write_str("BlockModeError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockModeError {}

cipher/src/lib.rs

@@ -15,15 +15,25 @@
 
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "block-mode")]
+pub extern crate block_padding;
+#[cfg(feature = "dev")]
+pub extern crate blobby;
 
-pub mod block;
 pub mod errors;
-pub mod stream;
+#[cfg(feature = "dev")]
+mod dev;
+mod block;
+mod common;
+#[cfg(feature = "block-padding")]
+mod mode;
+mod stream;
 
 pub use crate::{
- block::{
- BlockCipher, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, NewBlockCipher,
- },
- stream::{NewStreamCipher, StreamCipher, SyncStreamCipher, SyncStreamCipherSeek},
+ block::*,
+ common::*,
+ stream::*,
 };
+#[cfg(feature = "block-mode")]
+pub use crate::mode::BlockModeCore;
 pub use generic_array::{self, typenum::consts};

cipher/Cargo.toml

@@ -14,9 +14,12 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.3", optional = true }
+block-padding = { verstion = "0.2", optional = true }
 
 [features]
+default = ["block-mode"]
 std = []
+block-mode = ["block-padding"]
 dev = ["blobby"]
 
 [package.metadata.docs.rs]

cipher/src/block.rs

@@ -9,21 +9,17 @@
 //! [1]: https://en.wikipedia.org/wiki/Block_cipher
 //! [2]: https://en.wikipedia.org/wiki/Symmetric-key_algorithm
 
-#[cfg(feature = "dev")]
-#[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-pub mod dev;
-
 use crate::errors::InvalidLength;
 use core::convert::TryInto;
 use generic_array::{typenum::Unsigned, ArrayLength, GenericArray};
 
 /// Key for an algorithm that implements [`NewBlockCipher`].
-pub type Key<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
+pub type BlockCipherKey<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
 
 /// Block on which a [`BlockCipher`] operates.
 pub type Block<B> = GenericArray<u8, <B as BlockCipher>::BlockSize>;
 
-/// Blocks being acted over in parallel.
+/// Block on which a [`BlockCipher`] operates in parallel.
 pub type ParBlocks<B> = GenericArray<Block<B>, <B as BlockCipher>::ParBlocks>;
 
 /// Instantiate a [`BlockCipher`] algorithm.
@@ -32,13 +28,13 @@ pub trait NewBlockCipher: Sized {
  type KeySize: ArrayLength<u8>;
 
  /// Create new block cipher instance from key with fixed size.
- fn new(key: &Key<Self>) -> Self;
+ fn new(key: &BlockCipherKey<Self>) -> Self;
 
  /// Create new block cipher instance from key with variable size.
  ///
  /// Default implementation will accept only keys with length equal to
  /// `KeySize`, but some ciphers can accept range of key lengths.
- fn new_varkey(key: &[u8]) -> Result<Self, InvalidLength> {
+ fn new_var(key: &[u8]) -> Result<Self, InvalidLength> {
  if key.len() != Self::KeySize::to_usize() {
  Err(InvalidLength)
  } else {
@@ -57,7 +53,7 @@ pub trait BlockCipher {
  type ParBlocks: ArrayLength<Block<Self>>;
 }
 
-/// Encrypt-only functionality for block ciphers
+/// Encrypt-only functionality for block ciphers.
 pub trait BlockEncrypt: BlockCipher {
  /// Encrypt block in-place
  fn encrypt_block(&self, block: &mut Block<Self>);
@@ -94,7 +90,7 @@ pub trait BlockEncrypt: BlockCipher {
  }
 }
 
-/// Decrypt-only functionality for block ciphers
+/// Decrypt-only functionality for block ciphers.
 pub trait BlockDecrypt: BlockCipher {
  /// Decrypt block in-place
  fn decrypt_block(&self, block: &mut Block<Self>);

cipher/src/common.rs

@@ -0,0 +1,79 @@
+use generic_array::{ArrayLength, GenericArray, typenum::Unsigned};
+use crate::{BlockCipher, NewBlockCipher, errors::InvalidLength};
+
+/// Key for an algorithm that implements [`NewCipher`].
+pub type CipherKey<C> = GenericArray<u8, <C as NewCipher>::KeySize>;
+
+/// Nonce for an algorithm that implements [`NewCipher`].
+pub type Nonce<C> = GenericArray<u8, <C as NewCipher>::NonceSize>;
+
+/// Cipher creation trait.
+///
+/// It can be used for creation of block modes, synchronous and asynchronous stream ciphers.
+pub trait NewCipher: Sized {
+ /// Key size in bytes
+ type KeySize: ArrayLength<u8>;
+
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> Self;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ #[inline]
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ let kl = Self::KeySize::to_usize();
+ let nl = Self::NonceSize::to_usize();
+ if key.len() != kl || nonce.len() != nl {
+ Err(InvalidLength)
+ } else {
+ let key = GenericArray::from_slice(key);
+ let nonce = GenericArray::from_slice(nonce);
+ Ok(Self::new(key, nonce))
+ }
+ }
+}
+
+/// Trait for types which can be initialized from a block cipher and nonce.
+pub trait FromBlockCipher {
+ /// Block cipher
+ type BlockCipher: BlockCipher;
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Instantiate a stream cipher from a block cipher
+ fn from_block_cipher(
+ cipher: Self::BlockCipher,
+ nonce: &GenericArray<u8, Self::NonceSize>,
+ ) -> Self;
+}
+
+impl<C> NewCipher for C
+where
+ C: FromBlockCipher,
+ C::BlockCipher: NewBlockCipher,
+{
+ type KeySize = <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::KeySize;
+ type NonceSize = <Self as FromBlockCipher>::NonceSize;
+
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> C {
+ C::from_block_cipher(
+ <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::new(key),
+ nonce,
+ )
+ }
+
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ if nonce.len() != Self::NonceSize::USIZE {
+ Err(InvalidLength)
+ } else {
+ C::BlockCipher::new_var(key)
+ .map_err(|_| InvalidLength)
+ .map(|cipher| {
+ let nonce = GenericArray::from_slice(nonce);
+ Self::from_block_cipher(cipher, nonce)
+ })
+ }
+ }
+}

cipher/src/dev.rs

@@ -0,0 +1,2 @@
+mod stream;
+mod block;

cipher/src/block/dev.rs → cipher/src/dev/block.rs

@@ -9,13 +9,13 @@ macro_rules! block_cipher_test {
  ($name:ident, $test_name:expr, $cipher:ty) => {
  #[test]
  fn $name() {
- use cipher::block::{
-dev::blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
+ use cipher::{
+ blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
  };
  use cipher::generic_array::{typenum::Unsigned, GenericArray};
 
  fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let mut block = GenericArray::clone_from_slice(pt);
  state.encrypt_block(&mut block);
@@ -37,7 +37,7 @@ macro_rules! block_cipher_test {
  type Block = GenericArray<u8, BlockSize>;
  type ParBlock = GenericArray<Block, ParBlocks>;
 
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let block = Block::clone_from_slice(pt);
  let mut blocks1 = ParBlock::default();
@@ -113,12 +113,12 @@ macro_rules! block_cipher_bench {
  ($cipher:path, $key_len:expr) => {
  extern crate test;
 
- use cipher::block::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
+ use cipher::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
  use test::Bencher;
 
  #[bench]
  pub fn encrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {
@@ -130,7 +130,7 @@ macro_rules! block_cipher_bench {
 
  #[bench]
  pub fn decrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {

cipher/src/stream/dev.rs → cipher/src/dev/stream.rs

@@ -3,12 +3,12 @@
 /// Test core functionality of synchronous stream cipher
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-macro_rules! stream_cipher_sync_test {
+macro_rules! stream_cipher_test {
  ($name:ident, $cipher:ty, $test_name:expr) => {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, SyncStreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, StreamCipher};
 
  let data = include_bytes!(concat!("data/", $test_name, ".blb"));
  for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
@@ -44,7 +44,7 @@ macro_rules! stream_cipher_seek_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
+ use cipher::{NewCipher, StreamCipher, StreamCipherSeek};
 
  fn get_cipher() -> $cipher {
  <$cipher>::new(&Default::default(), &Default::default())
@@ -97,7 +97,7 @@ macro_rules! stream_cipher_async_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, StreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, AsyncStreamCipher};
 
  fn run_test(
  key: &[u8],
@@ -172,8 +172,7 @@ macro_rules! stream_cipher_sync_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher};
+ use cipher::{NewCipher, StreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]
@@ -225,8 +224,7 @@ macro_rules! stream_cipher_async_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, StreamCipher};
+ use cipher::{NewCipher, AsyncStreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]

cipher/src/errors.rs

@@ -1,4 +1,4 @@
-//! Error types
+//! Error types.
 
 use core::fmt;
 
@@ -48,3 +48,16 @@ impl From<OverflowError> for LoopError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for OverflowError {}
+
+/// Block mode error.
+#[derive(Clone, Copy, Debug)]
+pub struct BlockModeError;
+
+impl fmt::Display for BlockModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+ f.write_str("BlockModeError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockModeError {}

cipher/src/lib.rs

@@ -15,15 +15,25 @@
 
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "block-mode")]
+pub extern crate block_padding;
+#[cfg(feature = "dev")]
+pub extern crate blobby;
 
-pub mod block;
 pub mod errors;
-pub mod stream;
+#[cfg(feature = "dev")]
+mod dev;
+mod block;
+mod common;
+#[cfg(feature = "block-padding")]
+mod mode;
+mod stream;
 
 pub use crate::{
- block::{
- BlockCipher, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, NewBlockCipher,
- },
- stream::{NewStreamCipher, StreamCipher, SyncStreamCipher, SyncStreamCipherSeek},
+ block::*,
+ common::*,
+ stream::*,
 };
+#[cfg(feature = "block-mode")]
+pub use crate::mode::BlockModeCore;
 pub use generic_array::{self, typenum::consts};

cipher/Cargo.toml

@@ -14,9 +14,12 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.3", optional = true }
+block-padding = { verstion = "0.2", optional = true }
 
 [features]
+default = ["block-mode"]
 std = []
+block-mode = ["block-padding"]
 dev = ["blobby"]
 
 [package.metadata.docs.rs]

cipher/src/block.rs

@@ -9,21 +9,17 @@
 //! [1]: https://en.wikipedia.org/wiki/Block_cipher
 //! [2]: https://en.wikipedia.org/wiki/Symmetric-key_algorithm
 
-#[cfg(feature = "dev")]
-#[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-pub mod dev;
-
 use crate::errors::InvalidLength;
 use core::convert::TryInto;
 use generic_array::{typenum::Unsigned, ArrayLength, GenericArray};
 
 /// Key for an algorithm that implements [`NewBlockCipher`].
-pub type Key<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
+pub type BlockCipherKey<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
 
 /// Block on which a [`BlockCipher`] operates.
 pub type Block<B> = GenericArray<u8, <B as BlockCipher>::BlockSize>;
 
-/// Blocks being acted over in parallel.
+/// Block on which a [`BlockCipher`] operates in parallel.
 pub type ParBlocks<B> = GenericArray<Block<B>, <B as BlockCipher>::ParBlocks>;
 
 /// Instantiate a [`BlockCipher`] algorithm.
@@ -32,13 +28,13 @@ pub trait NewBlockCipher: Sized {
  type KeySize: ArrayLength<u8>;
 
  /// Create new block cipher instance from key with fixed size.
- fn new(key: &Key<Self>) -> Self;
+ fn new(key: &BlockCipherKey<Self>) -> Self;
 
  /// Create new block cipher instance from key with variable size.
  ///
  /// Default implementation will accept only keys with length equal to
  /// `KeySize`, but some ciphers can accept range of key lengths.
- fn new_varkey(key: &[u8]) -> Result<Self, InvalidLength> {
+ fn new_var(key: &[u8]) -> Result<Self, InvalidLength> {
  if key.len() != Self::KeySize::to_usize() {
  Err(InvalidLength)
  } else {
@@ -57,7 +53,7 @@ pub trait BlockCipher {
  type ParBlocks: ArrayLength<Block<Self>>;
 }
 
-/// Encrypt-only functionality for block ciphers
+/// Encrypt-only functionality for block ciphers.
 pub trait BlockEncrypt: BlockCipher {
  /// Encrypt block in-place
  fn encrypt_block(&self, block: &mut Block<Self>);
@@ -94,7 +90,7 @@ pub trait BlockEncrypt: BlockCipher {
  }
 }
 
-/// Decrypt-only functionality for block ciphers
+/// Decrypt-only functionality for block ciphers.
 pub trait BlockDecrypt: BlockCipher {
  /// Decrypt block in-place
  fn decrypt_block(&self, block: &mut Block<Self>);

cipher/src/common.rs

@@ -0,0 +1,79 @@
+use generic_array::{ArrayLength, GenericArray, typenum::Unsigned};
+use crate::{BlockCipher, NewBlockCipher, errors::InvalidLength};
+
+/// Key for an algorithm that implements [`NewCipher`].
+pub type CipherKey<C> = GenericArray<u8, <C as NewCipher>::KeySize>;
+
+/// Nonce for an algorithm that implements [`NewCipher`].
+pub type Nonce<C> = GenericArray<u8, <C as NewCipher>::NonceSize>;
+
+/// Cipher creation trait.
+///
+/// It can be used for creation of block modes, synchronous and asynchronous stream ciphers.
+pub trait NewCipher: Sized {
+ /// Key size in bytes
+ type KeySize: ArrayLength<u8>;
+
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> Self;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ #[inline]
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ let kl = Self::KeySize::to_usize();
+ let nl = Self::NonceSize::to_usize();
+ if key.len() != kl || nonce.len() != nl {
+ Err(InvalidLength)
+ } else {
+ let key = GenericArray::from_slice(key);
+ let nonce = GenericArray::from_slice(nonce);
+ Ok(Self::new(key, nonce))
+ }
+ }
+}
+
+/// Trait for types which can be initialized from a block cipher and nonce.
+pub trait FromBlockCipher {
+ /// Block cipher
+ type BlockCipher: BlockCipher;
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Instantiate a stream cipher from a block cipher
+ fn from_block_cipher(
+ cipher: Self::BlockCipher,
+ nonce: &GenericArray<u8, Self::NonceSize>,
+ ) -> Self;
+}
+
+impl<C> NewCipher for C
+where
+ C: FromBlockCipher,
+ C::BlockCipher: NewBlockCipher,
+{
+ type KeySize = <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::KeySize;
+ type NonceSize = <Self as FromBlockCipher>::NonceSize;
+
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> C {
+ C::from_block_cipher(
+ <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::new(key),
+ nonce,
+ )
+ }
+
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ if nonce.len() != Self::NonceSize::USIZE {
+ Err(InvalidLength)
+ } else {
+ C::BlockCipher::new_var(key)
+ .map_err(|_| InvalidLength)
+ .map(|cipher| {
+ let nonce = GenericArray::from_slice(nonce);
+ Self::from_block_cipher(cipher, nonce)
+ })
+ }
+ }
+}

cipher/src/dev.rs

@@ -0,0 +1,2 @@
+mod stream;
+mod block;

cipher/src/block/dev.rs → cipher/src/dev/block.rs

@@ -9,13 +9,13 @@ macro_rules! block_cipher_test {
  ($name:ident, $test_name:expr, $cipher:ty) => {
  #[test]
  fn $name() {
- use cipher::block::{
-dev::blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
+ use cipher::{
+ blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
  };
  use cipher::generic_array::{typenum::Unsigned, GenericArray};
 
  fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let mut block = GenericArray::clone_from_slice(pt);
  state.encrypt_block(&mut block);
@@ -37,7 +37,7 @@ macro_rules! block_cipher_test {
  type Block = GenericArray<u8, BlockSize>;
  type ParBlock = GenericArray<Block, ParBlocks>;
 
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let block = Block::clone_from_slice(pt);
  let mut blocks1 = ParBlock::default();
@@ -113,12 +113,12 @@ macro_rules! block_cipher_bench {
  ($cipher:path, $key_len:expr) => {
  extern crate test;
 
- use cipher::block::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
+ use cipher::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
  use test::Bencher;
 
  #[bench]
  pub fn encrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {
@@ -130,7 +130,7 @@ macro_rules! block_cipher_bench {
 
  #[bench]
  pub fn decrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {

cipher/src/stream/dev.rs → cipher/src/dev/stream.rs

@@ -3,12 +3,12 @@
 /// Test core functionality of synchronous stream cipher
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-macro_rules! stream_cipher_sync_test {
+macro_rules! stream_cipher_test {
  ($name:ident, $cipher:ty, $test_name:expr) => {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, SyncStreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, StreamCipher};
 
  let data = include_bytes!(concat!("data/", $test_name, ".blb"));
  for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
@@ -44,7 +44,7 @@ macro_rules! stream_cipher_seek_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
+ use cipher::{NewCipher, StreamCipher, StreamCipherSeek};
 
  fn get_cipher() -> $cipher {
  <$cipher>::new(&Default::default(), &Default::default())
@@ -97,7 +97,7 @@ macro_rules! stream_cipher_async_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, StreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, AsyncStreamCipher};
 
  fn run_test(
  key: &[u8],
@@ -172,8 +172,7 @@ macro_rules! stream_cipher_sync_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher};
+ use cipher::{NewCipher, StreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]
@@ -225,8 +224,7 @@ macro_rules! stream_cipher_async_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, StreamCipher};
+ use cipher::{NewCipher, AsyncStreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]

cipher/src/errors.rs

@@ -1,4 +1,4 @@
-//! Error types
+//! Error types.
 
 use core::fmt;
 
@@ -48,3 +48,16 @@ impl From<OverflowError> for LoopError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for OverflowError {}
+
+/// Block mode error.
+#[derive(Clone, Copy, Debug)]
+pub struct BlockModeError;
+
+impl fmt::Display for BlockModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+ f.write_str("BlockModeError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockModeError {}

cipher/src/lib.rs

@@ -15,15 +15,25 @@
 
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "block-mode")]
+pub extern crate block_padding;
+#[cfg(feature = "dev")]
+pub extern crate blobby;
 
-pub mod block;
 pub mod errors;
-pub mod stream;
+#[cfg(feature = "dev")]
+mod dev;
+mod block;
+mod common;
+#[cfg(feature = "block-padding")]
+mod mode;
+mod stream;
 
 pub use crate::{
- block::{
- BlockCipher, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, NewBlockCipher,
- },
- stream::{NewStreamCipher, StreamCipher, SyncStreamCipher, SyncStreamCipherSeek},
+ block::*,
+ common::*,
+ stream::*,
 };
+#[cfg(feature = "block-mode")]
+pub use crate::mode::BlockModeCore;
 pub use generic_array::{self, typenum::consts};

cipher/Cargo.toml

@@ -14,9 +14,12 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.3", optional = true }
+block-padding = { verstion = "0.2", optional = true }
 
 [features]
+default = ["block-mode"]
 std = []
+block-mode = ["block-padding"]
 dev = ["blobby"]
 
 [package.metadata.docs.rs]

cipher/src/block.rs

@@ -9,21 +9,17 @@
 //! [1]: https://en.wikipedia.org/wiki/Block_cipher
 //! [2]: https://en.wikipedia.org/wiki/Symmetric-key_algorithm
 
-#[cfg(feature = "dev")]
-#[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-pub mod dev;
-
 use crate::errors::InvalidLength;
 use core::convert::TryInto;
 use generic_array::{typenum::Unsigned, ArrayLength, GenericArray};
 
 /// Key for an algorithm that implements [`NewBlockCipher`].
-pub type Key<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
+pub type BlockCipherKey<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
 
 /// Block on which a [`BlockCipher`] operates.
 pub type Block<B> = GenericArray<u8, <B as BlockCipher>::BlockSize>;
 
-/// Blocks being acted over in parallel.
+/// Block on which a [`BlockCipher`] operates in parallel.
 pub type ParBlocks<B> = GenericArray<Block<B>, <B as BlockCipher>::ParBlocks>;
 
 /// Instantiate a [`BlockCipher`] algorithm.
@@ -32,13 +28,13 @@ pub trait NewBlockCipher: Sized {
  type KeySize: ArrayLength<u8>;
 
  /// Create new block cipher instance from key with fixed size.
- fn new(key: &Key<Self>) -> Self;
+ fn new(key: &BlockCipherKey<Self>) -> Self;
 
  /// Create new block cipher instance from key with variable size.
  ///
  /// Default implementation will accept only keys with length equal to
  /// `KeySize`, but some ciphers can accept range of key lengths.
- fn new_varkey(key: &[u8]) -> Result<Self, InvalidLength> {
+ fn new_var(key: &[u8]) -> Result<Self, InvalidLength> {
  if key.len() != Self::KeySize::to_usize() {
  Err(InvalidLength)
  } else {
@@ -57,7 +53,7 @@ pub trait BlockCipher {
  type ParBlocks: ArrayLength<Block<Self>>;
 }
 
-/// Encrypt-only functionality for block ciphers
+/// Encrypt-only functionality for block ciphers.
 pub trait BlockEncrypt: BlockCipher {
  /// Encrypt block in-place
  fn encrypt_block(&self, block: &mut Block<Self>);
@@ -94,7 +90,7 @@ pub trait BlockEncrypt: BlockCipher {
  }
 }
 
-/// Decrypt-only functionality for block ciphers
+/// Decrypt-only functionality for block ciphers.
 pub trait BlockDecrypt: BlockCipher {
  /// Decrypt block in-place
  fn decrypt_block(&self, block: &mut Block<Self>);

cipher/src/common.rs

@@ -0,0 +1,79 @@
+use generic_array::{ArrayLength, GenericArray, typenum::Unsigned};
+use crate::{BlockCipher, NewBlockCipher, errors::InvalidLength};
+
+/// Key for an algorithm that implements [`NewCipher`].
+pub type CipherKey<C> = GenericArray<u8, <C as NewCipher>::KeySize>;
+
+/// Nonce for an algorithm that implements [`NewCipher`].
+pub type Nonce<C> = GenericArray<u8, <C as NewCipher>::NonceSize>;
+
+/// Cipher creation trait.
+///
+/// It can be used for creation of block modes, synchronous and asynchronous stream ciphers.
+pub trait NewCipher: Sized {
+ /// Key size in bytes
+ type KeySize: ArrayLength<u8>;
+
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> Self;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ #[inline]
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ let kl = Self::KeySize::to_usize();
+ let nl = Self::NonceSize::to_usize();
+ if key.len() != kl || nonce.len() != nl {
+ Err(InvalidLength)
+ } else {
+ let key = GenericArray::from_slice(key);
+ let nonce = GenericArray::from_slice(nonce);
+ Ok(Self::new(key, nonce))
+ }
+ }
+}
+
+/// Trait for types which can be initialized from a block cipher and nonce.
+pub trait FromBlockCipher {
+ /// Block cipher
+ type BlockCipher: BlockCipher;
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Instantiate a stream cipher from a block cipher
+ fn from_block_cipher(
+ cipher: Self::BlockCipher,
+ nonce: &GenericArray<u8, Self::NonceSize>,
+ ) -> Self;
+}
+
+impl<C> NewCipher for C
+where
+ C: FromBlockCipher,
+ C::BlockCipher: NewBlockCipher,
+{
+ type KeySize = <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::KeySize;
+ type NonceSize = <Self as FromBlockCipher>::NonceSize;
+
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> C {
+ C::from_block_cipher(
+ <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::new(key),
+ nonce,
+ )
+ }
+
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ if nonce.len() != Self::NonceSize::USIZE {
+ Err(InvalidLength)
+ } else {
+ C::BlockCipher::new_var(key)
+ .map_err(|_| InvalidLength)
+ .map(|cipher| {
+ let nonce = GenericArray::from_slice(nonce);
+ Self::from_block_cipher(cipher, nonce)
+ })
+ }
+ }
+}

cipher/src/dev.rs

@@ -0,0 +1,2 @@
+mod stream;
+mod block;

cipher/src/block/dev.rs → cipher/src/dev/block.rs

@@ -9,13 +9,13 @@ macro_rules! block_cipher_test {
  ($name:ident, $test_name:expr, $cipher:ty) => {
  #[test]
  fn $name() {
- use cipher::block::{
-dev::blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
+ use cipher::{
+ blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
  };
  use cipher::generic_array::{typenum::Unsigned, GenericArray};
 
  fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let mut block = GenericArray::clone_from_slice(pt);
  state.encrypt_block(&mut block);
@@ -37,7 +37,7 @@ macro_rules! block_cipher_test {
  type Block = GenericArray<u8, BlockSize>;
  type ParBlock = GenericArray<Block, ParBlocks>;
 
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let block = Block::clone_from_slice(pt);
  let mut blocks1 = ParBlock::default();
@@ -113,12 +113,12 @@ macro_rules! block_cipher_bench {
  ($cipher:path, $key_len:expr) => {
  extern crate test;
 
- use cipher::block::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
+ use cipher::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
  use test::Bencher;
 
  #[bench]
  pub fn encrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {
@@ -130,7 +130,7 @@ macro_rules! block_cipher_bench {
 
  #[bench]
  pub fn decrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {

cipher/src/stream/dev.rs → cipher/src/dev/stream.rs

@@ -3,12 +3,12 @@
 /// Test core functionality of synchronous stream cipher
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-macro_rules! stream_cipher_sync_test {
+macro_rules! stream_cipher_test {
  ($name:ident, $cipher:ty, $test_name:expr) => {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, SyncStreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, StreamCipher};
 
  let data = include_bytes!(concat!("data/", $test_name, ".blb"));
  for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
@@ -44,7 +44,7 @@ macro_rules! stream_cipher_seek_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
+ use cipher::{NewCipher, StreamCipher, StreamCipherSeek};
 
  fn get_cipher() -> $cipher {
  <$cipher>::new(&Default::default(), &Default::default())
@@ -97,7 +97,7 @@ macro_rules! stream_cipher_async_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, StreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, AsyncStreamCipher};
 
  fn run_test(
  key: &[u8],
@@ -172,8 +172,7 @@ macro_rules! stream_cipher_sync_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher};
+ use cipher::{NewCipher, StreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]
@@ -225,8 +224,7 @@ macro_rules! stream_cipher_async_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, StreamCipher};
+ use cipher::{NewCipher, AsyncStreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]

cipher/src/errors.rs

@@ -1,4 +1,4 @@
-//! Error types
+//! Error types.
 
 use core::fmt;
 
@@ -48,3 +48,16 @@ impl From<OverflowError> for LoopError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for OverflowError {}
+
+/// Block mode error.
+#[derive(Clone, Copy, Debug)]
+pub struct BlockModeError;
+
+impl fmt::Display for BlockModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+ f.write_str("BlockModeError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockModeError {}

cipher/src/lib.rs

@@ -15,15 +15,25 @@
 
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "block-mode")]
+pub extern crate block_padding;
+#[cfg(feature = "dev")]
+pub extern crate blobby;
 
-pub mod block;
 pub mod errors;
-pub mod stream;
+#[cfg(feature = "dev")]
+mod dev;
+mod block;
+mod common;
+#[cfg(feature = "block-padding")]
+mod mode;
+mod stream;
 
 pub use crate::{
- block::{
- BlockCipher, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, NewBlockCipher,
- },
- stream::{NewStreamCipher, StreamCipher, SyncStreamCipher, SyncStreamCipherSeek},
+ block::*,
+ common::*,
+ stream::*,
 };
+#[cfg(feature = "block-mode")]
+pub use crate::mode::BlockModeCore;
 pub use generic_array::{self, typenum::consts};

cipher/Cargo.toml

@@ -14,9 +14,12 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.3", optional = true }
+block-padding = { verstion = "0.2", optional = true }
 
 [features]
+default = ["block-mode"]
 std = []
+block-mode = ["block-padding"]
 dev = ["blobby"]
 
 [package.metadata.docs.rs]

cipher/src/block.rs

@@ -9,21 +9,17 @@
 //! [1]: https://en.wikipedia.org/wiki/Block_cipher
 //! [2]: https://en.wikipedia.org/wiki/Symmetric-key_algorithm
 
-#[cfg(feature = "dev")]
-#[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-pub mod dev;
-
 use crate::errors::InvalidLength;
 use core::convert::TryInto;
 use generic_array::{typenum::Unsigned, ArrayLength, GenericArray};
 
 /// Key for an algorithm that implements [`NewBlockCipher`].
-pub type Key<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
+pub type BlockCipherKey<B> = GenericArray<u8, <B as NewBlockCipher>::KeySize>;
 
 /// Block on which a [`BlockCipher`] operates.
 pub type Block<B> = GenericArray<u8, <B as BlockCipher>::BlockSize>;
 
-/// Blocks being acted over in parallel.
+/// Block on which a [`BlockCipher`] operates in parallel.
 pub type ParBlocks<B> = GenericArray<Block<B>, <B as BlockCipher>::ParBlocks>;
 
 /// Instantiate a [`BlockCipher`] algorithm.
@@ -32,13 +28,13 @@ pub trait NewBlockCipher: Sized {
  type KeySize: ArrayLength<u8>;
 
  /// Create new block cipher instance from key with fixed size.
- fn new(key: &Key<Self>) -> Self;
+ fn new(key: &BlockCipherKey<Self>) -> Self;
 
  /// Create new block cipher instance from key with variable size.
  ///
  /// Default implementation will accept only keys with length equal to
  /// `KeySize`, but some ciphers can accept range of key lengths.
- fn new_varkey(key: &[u8]) -> Result<Self, InvalidLength> {
+ fn new_var(key: &[u8]) -> Result<Self, InvalidLength> {
  if key.len() != Self::KeySize::to_usize() {
  Err(InvalidLength)
  } else {
@@ -57,7 +53,7 @@ pub trait BlockCipher {
  type ParBlocks: ArrayLength<Block<Self>>;
 }
 
-/// Encrypt-only functionality for block ciphers
+/// Encrypt-only functionality for block ciphers.
 pub trait BlockEncrypt: BlockCipher {
  /// Encrypt block in-place
  fn encrypt_block(&self, block: &mut Block<Self>);
@@ -94,7 +90,7 @@ pub trait BlockEncrypt: BlockCipher {
  }
 }
 
-/// Decrypt-only functionality for block ciphers
+/// Decrypt-only functionality for block ciphers.
 pub trait BlockDecrypt: BlockCipher {
  /// Decrypt block in-place
  fn decrypt_block(&self, block: &mut Block<Self>);

cipher/src/common.rs

@@ -0,0 +1,79 @@
+use generic_array::{ArrayLength, GenericArray, typenum::Unsigned};
+use crate::{BlockCipher, NewBlockCipher, errors::InvalidLength};
+
+/// Key for an algorithm that implements [`NewCipher`].
+pub type CipherKey<C> = GenericArray<u8, <C as NewCipher>::KeySize>;
+
+/// Nonce for an algorithm that implements [`NewCipher`].
+pub type Nonce<C> = GenericArray<u8, <C as NewCipher>::NonceSize>;
+
+/// Cipher creation trait.
+///
+/// It can be used for creation of block modes, synchronous and asynchronous stream ciphers.
+pub trait NewCipher: Sized {
+ /// Key size in bytes
+ type KeySize: ArrayLength<u8>;
+
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> Self;
+
+ /// Create new stream cipher instance from variable length key and nonce.
+ #[inline]
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ let kl = Self::KeySize::to_usize();
+ let nl = Self::NonceSize::to_usize();
+ if key.len() != kl || nonce.len() != nl {
+ Err(InvalidLength)
+ } else {
+ let key = GenericArray::from_slice(key);
+ let nonce = GenericArray::from_slice(nonce);
+ Ok(Self::new(key, nonce))
+ }
+ }
+}
+
+/// Trait for types which can be initialized from a block cipher and nonce.
+pub trait FromBlockCipher {
+ /// Block cipher
+ type BlockCipher: BlockCipher;
+ /// Nonce size in bytes
+ type NonceSize: ArrayLength<u8>;
+
+ /// Instantiate a stream cipher from a block cipher
+ fn from_block_cipher(
+ cipher: Self::BlockCipher,
+ nonce: &GenericArray<u8, Self::NonceSize>,
+ ) -> Self;
+}
+
+impl<C> NewCipher for C
+where
+ C: FromBlockCipher,
+ C::BlockCipher: NewBlockCipher,
+{
+ type KeySize = <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::KeySize;
+ type NonceSize = <Self as FromBlockCipher>::NonceSize;
+
+ fn new(key: &CipherKey<Self>, nonce: &Nonce<Self>) -> C {
+ C::from_block_cipher(
+ <<Self as FromBlockCipher>::BlockCipher as NewBlockCipher>::new(key),
+ nonce,
+ )
+ }
+
+ fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidLength> {
+ if nonce.len() != Self::NonceSize::USIZE {
+ Err(InvalidLength)
+ } else {
+ C::BlockCipher::new_var(key)
+ .map_err(|_| InvalidLength)
+ .map(|cipher| {
+ let nonce = GenericArray::from_slice(nonce);
+ Self::from_block_cipher(cipher, nonce)
+ })
+ }
+ }
+}

cipher/src/dev.rs

@@ -0,0 +1,2 @@
+mod stream;
+mod block;

cipher/src/block/dev.rs → cipher/src/dev/block.rs

@@ -9,13 +9,13 @@ macro_rules! block_cipher_test {
  ($name:ident, $test_name:expr, $cipher:ty) => {
  #[test]
  fn $name() {
- use cipher::block::{
-dev::blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
+ use cipher::{
+ blobby::Blob3Iterator, BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher,
  };
  use cipher::generic_array::{typenum::Unsigned, GenericArray};
 
  fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let mut block = GenericArray::clone_from_slice(pt);
  state.encrypt_block(&mut block);
@@ -37,7 +37,7 @@ macro_rules! block_cipher_test {
  type Block = GenericArray<u8, BlockSize>;
  type ParBlock = GenericArray<Block, ParBlocks>;
 
- let state = <$cipher as NewBlockCipher>::new_varkey(key).unwrap();
+ let state = <$cipher as NewBlockCipher>::new_var(key).unwrap();
 
  let block = Block::clone_from_slice(pt);
  let mut blocks1 = ParBlock::default();
@@ -113,12 +113,12 @@ macro_rules! block_cipher_bench {
  ($cipher:path, $key_len:expr) => {
  extern crate test;
 
- use cipher::block::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
+ use cipher::{BlockCipher, BlockDecrypt, BlockEncrypt, NewBlockCipher};
  use test::Bencher;
 
  #[bench]
  pub fn encrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {
@@ -130,7 +130,7 @@ macro_rules! block_cipher_bench {
 
  #[bench]
  pub fn decrypt(bh: &mut Bencher) {
- let state = <$cipher>::new_varkey(&[1u8; $key_len]).unwrap();
+ let state = <$cipher>::new_var(&[1u8; $key_len]).unwrap();
  let mut block = Default::default();
 
  bh.iter(|| {

cipher/src/stream/dev.rs → cipher/src/dev/stream.rs

@@ -3,12 +3,12 @@
 /// Test core functionality of synchronous stream cipher
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]
-macro_rules! stream_cipher_sync_test {
+macro_rules! stream_cipher_test {
  ($name:ident, $cipher:ty, $test_name:expr) => {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, SyncStreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, StreamCipher};
 
  let data = include_bytes!(concat!("data/", $test_name, ".blb"));
  for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
@@ -44,7 +44,7 @@ macro_rules! stream_cipher_seek_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
+ use cipher::{NewCipher, StreamCipher, StreamCipherSeek};
 
  fn get_cipher() -> $cipher {
  <$cipher>::new(&Default::default(), &Default::default())
@@ -97,7 +97,7 @@ macro_rules! stream_cipher_async_test {
  #[test]
  fn $name() {
  use cipher::generic_array::GenericArray;
- use cipher::stream::{blobby::Blob4Iterator, NewStreamCipher, StreamCipher};
+ use cipher::{blobby::Blob4Iterator, NewCipher, AsyncStreamCipher};
 
  fn run_test(
  key: &[u8],
@@ -172,8 +172,7 @@ macro_rules! stream_cipher_sync_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, SyncStreamCipher};
+ use cipher::{NewCipher, StreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]
@@ -225,8 +224,7 @@ macro_rules! stream_cipher_async_bench {
  ($cipher:path) => {
  extern crate test;
 
- use cipher::generic_array::GenericArray;
- use cipher::stream::{NewStreamCipher, StreamCipher};
+ use cipher::{NewCipher, AsyncStreamCipher, generic_array::GenericArray};
  use test::Bencher;
 
  #[inline(never)]

cipher/src/errors.rs

@@ -1,4 +1,4 @@
-//! Error types
+//! Error types.
 
 use core::fmt;
 
@@ -48,3 +48,16 @@ impl From<OverflowError> for LoopError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for OverflowError {}
+
+/// Block mode error.
+#[derive(Clone, Copy, Debug)]
+pub struct BlockModeError;
+
+impl fmt::Display for BlockModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+ f.write_str("BlockModeError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockModeError {}

cipher/src/lib.rs

@@ -15,15 +15,25 @@
 
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "block-mode")]
+pub extern crate block_padding;
+#[cfg(feature = "dev")]
+pub extern crate blobby;
 
-pub mod block;
 pub mod errors;
-pub mod stream;
+#[cfg(feature = "dev")]
+mod dev;
+mod block;
+mod common;
+#[cfg(feature = "block-padding")]
+mod mode;
+mod stream;
 
 pub use crate::{
- block::{
- BlockCipher, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, NewBlockCipher,
- },
- stream::{NewStreamCipher, StreamCipher, SyncStreamCipher, SyncStreamCipherSeek},
+ block::*,
+ common::*,
+ stream::*,
 };
+#[cfg(feature = "block-mode")]
+pub use crate::mode::BlockModeCore;
 pub use generic_array::{self, typenum::consts};