add new_var method

stream-cipher/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "stream-cipher"
-version = "0.2.1"
+version = "0.2.2"
 authors = ["RustCrypto Developers"]
 license = "MIT OR Apache-2.0"
 description = "Stream cipher traits"

stream-cipher/src/dev.rs

@@ -11,13 +11,13 @@ macro_rules! new_core_test {
 
             let data = include_bytes!(concat!("data/", $test_name, ".blb"));
             for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
-                let key = GenericArray::from_slice(row[0]);
-                let iv = GenericArray::from_slice(row[1]);
+                let key = row[0];
+                let iv = row[1];
                 let plaintext = row[2];
                 let ciphertext = row[3];
 
                 for chunk_n in 1..256 {
-                    let mut mode = <$cipher>::new(key, iv);
+                    let mut mode = <$cipher>::new_var(key, iv).unwrap();
                     let mut pt = plaintext.to_vec();
                     for chunk in pt.chunks_mut(chunk_n) {
                         mode.apply_keystream(chunk);
@@ -52,12 +52,12 @@ macro_rules! new_seek_test {
 
             let data = include_bytes!(concat!("data/", $test_name, ".blb"));
             for (i, row) in Blob4Iterator::new(data).unwrap().enumerate() {
-                let key =  GenericArray::from_slice(row[0]);
-                let iv =  GenericArray::from_slice(row[1]);
+                let key = row[0];
+                let iv = row[1];
                 let plaintext = row[2];
                 let ciphertext = row[3];
 
-                let mut mode = <$cipher>::new(key, iv);
+                let mut mode = <$cipher>::new_var(key, iv).unwrap();
                 for seek_n in 0..512 {
                     let mut pt = plaintext[seek_n..].to_vec();
                     mode.seek(seek_n as u64);

stream-cipher/src/errors.rs

@@ -0,0 +1,38 @@
+use core::fmt;
+#[cfg(feature = "std")]
+use std::error;
+
+/// Error which notifies that stream cipher has reached the end of a keystream.
+#[derive(Copy, Clone, Debug)]
+pub struct LoopError;
+
+impl fmt::Display for LoopError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        f.write_str("Loop Error")
+    }
+}
+
+#[cfg(feature = "std")]
+impl error::Error for LoopError {
+    fn description(&self) -> &str {
+        "stream cipher loop detected"
+    }
+}
+
+/// Error which notifies that key or/and nonce used in stream cipher
+/// initialization had an invalid length.
+#[derive(Copy, Clone, Debug)]
+pub struct InvalidKeyNonceLength;
+
+impl fmt::Display for InvalidKeyNonceLength {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        f.write_str("Loop Error")
+    }
+}
+
+#[cfg(feature = "std")]
+impl error::Error for InvalidKeyNonceLength {
+    fn description(&self) -> &str {
+        "stream cipher loop detected"
+    }
+}

stream-cipher/src/lib.rs

@@ -4,34 +4,22 @@
 //! See [RustCrypto/stream-ciphers](https://github.com/RustCrypto/stream-ciphers)
 //! for ciphers implementation.
 #![no_std]
+#![doc(html_logo_url =
+    "https://raw.githubusercontent.com/RustCrypto/meta/master/logo_small.png")]
 pub extern crate generic_array;
 #[cfg(feature = "dev")]
 pub extern crate blobby;
 #[cfg(feature = "std")]
 extern crate std;
 
 use generic_array::{GenericArray, ArrayLength};
-use core::fmt;
+use generic_array::typenum::Unsigned;
 
 #[cfg(feature = "dev")]
 pub mod dev;
+mod errors;
 
-/// Error which notifies that stream cipher has reached the end of a keystream.
-#[derive(Copy, Clone, Debug)]
-pub struct LoopError;
-
-impl fmt::Display for LoopError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        f.write_str("Loop Error")
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for LoopError {
-    fn description(&self) -> &str {
-        "stream cipher loop detected"
-    }
-}
+pub use errors::{LoopError, InvalidKeyNonceLength};
 
 /// Synchronous stream cipher core trait
 pub trait StreamCipherCore {
@@ -65,16 +53,30 @@ pub trait StreamCipherSeek {
     fn seek(&mut self, pos: u64);
 }
 
+//TODO: rename to NewStreamCipher in next minor release
 /// Synchronous stream cipher creation trait
-pub trait NewFixStreamCipher {
+pub trait NewFixStreamCipher: Sized {
     /// Key size in bytes
     type KeySize: ArrayLength<u8>;
     /// Nonce size in bytes
     type NonceSize: ArrayLength<u8>;
 
-    /// Create new stream cipher instance
+    /// Create new stream cipher instance from variable length key and nonce.
     fn new(
         key: &GenericArray<u8, Self::KeySize>,
         nonce: &GenericArray<u8, Self::NonceSize>,
     ) -> Self;
+
+    /// Create new stream cipher instance from variable length key and nonce.
+    fn new_var(key: &[u8], nonce: &[u8]) -> Result<Self, InvalidKeyNonceLength> {
+        let kl = Self::KeySize::to_usize();
+        let nl = Self::NonceSize::to_usize();
+        if key.len() != kl || nonce.len() != nl {
+            Err(InvalidKeyNonceLength)
+        } else {
+            let key = GenericArray::from_slice(key);
+            let nonce = GenericArray::from_slice(nonce);
+            Ok(Self::new(key, nonce))
+        }
+    }
 }