Fixes for rust-lang/rust#23860

src/aes.rs

@@ -14,7 +14,7 @@ use symmetriccipher::{Encryptor, Decryptor, SynchronousStreamCipher};
 use util;
 
 /// AES key size
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub enum KeySize {
     KeySize128,
     KeySize192,

src/aesni.rs

@@ -14,12 +14,16 @@ pub struct AesNiEncryptor {
     round_keys: [u8; 240]
 }
 
+impl Clone for AesNiEncryptor { fn clone(&self) -> AesNiEncryptor { *self } }
+
 #[derive(Copy)]
 pub struct AesNiDecryptor {
     rounds: u8,
     round_keys: [u8; 240]
 }
 
+impl Clone for AesNiDecryptor { fn clone(&self) -> AesNiDecryptor { *self } }
+
 /// The number of rounds as well as a function to setup an appropriately sized key.
 type RoundSetupInfo = (u8, fn(&[u8], KeyType, &mut [u8]));
 

src/aessafe.rs

@@ -139,7 +139,7 @@ macro_rules! define_aes_struct(
         $name:ident,
         $rounds:expr
     ) => (
-        #[derive(Copy)]
+        #[derive(Clone, Copy)]
         pub struct $name {
             sk: [Bs8State<u16>; ($rounds + 1)]
         }
@@ -227,7 +227,7 @@ macro_rules! define_aes_struct_x8(
         $name:ident,
         $rounds:expr
     ) => (
-        #[derive(Copy)]
+        #[derive(Clone, Copy)]
         pub struct $name {
             sk: [Bs8State<u32x4>; ($rounds + 1)]
         }
@@ -453,7 +453,7 @@ fn decrypt_core<S: AesOps + Copy>(state: &S, sk: &[S]) -> S {
     tmp
 }
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 struct Bs8State<T>(T, T, T, T, T, T, T, T);
 
 impl <T: Copy> Bs8State<T> {
@@ -634,7 +634,7 @@ impl <T: Not<Output = T> + Copy> Bs8State<T> {
     }
 }
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 struct Bs4State<T>(T, T, T, T);
 
 impl <T: Copy> Bs4State<T> {
@@ -658,7 +658,7 @@ impl <T: BitXor<Output = T> + Copy> Bs4State<T> {
     }
 }
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 struct Bs2State<T>(T, T);
 
 impl <T> Bs2State<T> {

src/blake2b.rs

@@ -52,6 +52,8 @@ pub struct Blake2b {
     computed: bool, // whether the final digest has been computed
 }
 
+impl Clone for Blake2b { fn clone(&self) -> Blake2b { *self } }
+
 struct Blake2bParam {
     digest_length: u8,
     key_length: u8,

src/blockmodes.rs

@@ -42,7 +42,7 @@ pub trait PaddingProcessor {
 
 /// The BlockEngine is implemented as a state machine with the following states. See comments in the
 /// BlockEngine code for more information on the states.
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 enum BlockEngineState {
     FastMode,
     NeedInput,
@@ -417,7 +417,7 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
 }
 
 /// No padding mode for ECB and CBC encryption
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct NoPadding;
 
 impl PaddingProcessor for NoPadding {
@@ -426,7 +426,7 @@ impl PaddingProcessor for NoPadding {
 }
 
 /// PKCS padding mode for ECB and CBC encryption
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct PkcsPadding;
 
 // This class implements both encryption padding, where padding is added, and decryption padding,

src/blowfish.rs

@@ -8,7 +8,7 @@ use cryptoutil::{read_u32v_be, write_u32_be};
 use symmetriccipher::{BlockEncryptor, BlockDecryptor};
 use step_by::RangeExt;
 
-#[derive(Copy)]
+#[derive(Clone,Copy)]
 pub struct Blowfish {
     s: [[u32; 256]; 4],
     p: [u32; 18]
@@ -240,7 +240,7 @@ impl Blowfish {
             }
         }
     }
-    
+
     // Bcrypt key schedule.
     pub fn salted_expand_key(&mut self, salt: &[u8], key: &[u8]) {
         let mut key_pos = 0;
@@ -264,7 +264,7 @@ impl Blowfish {
                 r = new_r;
                 self.s[i][j] = l;
                 self.s[i][j+1] = r;
-                
+
                 let (new_l, new_r) = self.encrypt(l ^ next_u32_wrap(salt, &mut salt_pos), r ^ next_u32_wrap(salt, &mut salt_pos));
                 l = new_l;
                 r = new_r;
@@ -533,7 +533,7 @@ mod test {
             assert!(test.ciphertext[..] == output[..]);
         }
     }
-    
+
     #[test]
     fn decrypt_eay_test_vectors() {
         let tests = eay_test_vectors();
@@ -558,7 +558,7 @@ mod bench {
         let plaintext = [1u8; 8];
         let state = Blowfish::new(&key);
         let mut ciphertext = [0u8; 8];
-        
+
         bh.iter(|| {
             state.encrypt_block(&plaintext, &mut ciphertext);
         });

src/buffer.rs

@@ -8,7 +8,7 @@ use std::cmp;
 
 use cryptoutil;
 
-#[derive(Copy)]
+#[derive(Clone,Copy)]
 pub enum BufferResult {
     BufferUnderflow,
     BufferOverflow

src/chacha20.rs

@@ -10,7 +10,7 @@ use symmetriccipher::{Encryptor, Decryptor, SynchronousStreamCipher, SymmetricCi
 use cryptoutil::{read_u32_le, symm_enc_or_dec, write_u32_le, xor_keystream};
 use simd::u32x4;
 
-#[derive(Copy)]
+#[derive(Clone,Copy)]
 struct ChaChaState {
   a: u32x4,
   b: u32x4,
@@ -25,6 +25,8 @@ pub struct ChaCha20 {
     offset : usize,
 }
 
+impl Clone for ChaCha20 { fn clone(&self) -> ChaCha20 { *self } }
+
 macro_rules! swizzle{
     ($b: expr, $c: expr, $d: expr) => {{
         let u32x4(b10, b11, b12, b13) = $b;
@@ -69,7 +71,7 @@ macro_rules! round{
 
 macro_rules! rotate {
     ($a: expr, $b: expr, $c:expr) => {{
-      let v = $a ^ $b; 
+      let v = $a ^ $b;
       let r = S32 - $c;
       let right = v >> r;
       $a = (v << $c) ^ right
@@ -112,7 +114,7 @@ impl ChaCha20 {
     }
 
     fn expand(key: &[u8], nonce: &[u8]) -> ChaChaState {
-        
+
         let constant = match key.len() {
             16 => b"expand 16-byte k",
             32 => b"expand 32-byte k",

src/chacha20poly1305.rs

@@ -12,7 +12,7 @@ use poly1305::Poly1305;
 use mac::Mac;
 use cryptoutil::{write_u64_le};
 use util::fixed_time_eq;
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct ChaCha20Poly1305 {
     cipher  : ChaCha20,
     mac: Poly1305,
@@ -99,7 +99,7 @@ mod test {
     aad: Vec<u8>,
     tag: Vec<u8>
   }
-  
+
   #[test]
   fn test_chacha20_256_poly1305_boringssl_vectors_encrypt() {
 
@@ -748,17 +748,17 @@ mod bench {
       bh.iter( || {
           let mut cipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
           let mut decipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-          
+
           let mut output = [0u8; 10];
           let mut tag = [0u8; 16];
           let mut output2 = [0u8; 10];
           cipher.encrypt(&input, &mut output, &mut tag);
           decipher.decrypt(&output, &mut output2, &tag);
-            
+
         });
         bh.bytes = 10u64;
     }
-        
+
 
     #[bench]
     pub fn chacha20poly1305_1k(bh: & mut Bencher) {
@@ -767,16 +767,16 @@ mod bench {
       bh.iter( || {
         let mut cipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
         let mut decipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-        
+
         let mut output = [0u8; 1024];
         let mut tag = [0u8; 16];
         let mut output2 = [0u8; 1024];
-        
+
         cipher.encrypt(&input, &mut output, &mut tag);
         decipher.decrypt(&output, &mut output2, &tag);
         });
       bh.bytes = 1024u64;
-        
+
     }
 
     #[bench]
@@ -786,16 +786,16 @@ mod bench {
         bh.iter( || {
           let mut cipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
           let mut decipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-        
+
           let mut output = [0u8; 65536];
           let mut tag = [0u8; 16];
           let mut output2 = [0u8; 65536];
-      
+
           cipher.encrypt(&input, &mut output, &mut tag);
           decipher.decrypt(&output, &mut output2, &tag);
 
         });
          bh.bytes = 65536u64;
-        
+
     }
-}
+}

src/cryptoutil.rs

@@ -446,6 +446,8 @@ pub struct FixedBuffer64 {
     buffer_idx: usize,
 }
 
+impl Clone for FixedBuffer64 { fn clone(&self) -> FixedBuffer64 { *self } }
+
 impl FixedBuffer64 {
     /// Create a new buffer
     pub fn new() -> FixedBuffer64 {

src/curve25519.rs

@@ -11,7 +11,7 @@ t[0]+2^26 t[1]+2^51 t[2]+2^77 t[3]+2^102 t[4]+...+2^230 t[9].
 Bounds on each t[i] vary depending on context.
 */
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct Fe(pub [i32; 10]);
 
 impl PartialEq for Fe {
@@ -1062,37 +1062,37 @@ impl Fe {
     }
 }
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct GeP2 {
     x: Fe,
     y: Fe,
     z: Fe,
 }
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct GeP3 {
     x: Fe,
     y: Fe,
     z: Fe,
     t: Fe,
 }
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct GeP1P1 {
     x: Fe,
     y: Fe,
     z: Fe,
     t: Fe,
 }
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct GePrecomp {
     y_plus_x: Fe,
     y_minus_x: Fe,
     xy2d: Fe,
 }
 
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 pub struct GeCached {
     y_plus_x: Fe,
     y_minus_x: Fe,

src/fortuna.rs

@@ -20,7 +20,7 @@
  * is designed to be timing-attack resistant. The speed hit from this
  * is in line with a "safety first" API, but be aware of it.
  *
- * Fortuna was originally described in 
+ * Fortuna was originally described in
  *   Practical Cryptography, Niels Ferguson and Bruce Schneier.
  *   John Wiley & Sons, 2003.
  *
@@ -147,7 +147,7 @@ impl FortunaGenerator {
 
 
 /// A single entropy pool (not public)
-#[derive(Copy)]
+#[derive(Clone, Copy)]
 struct Pool {
     state: Sha256,
     count: usize
@@ -194,7 +194,7 @@ impl Fortuna {
         }
     }
 
-    /// Adds a random event `e` from source `s` to entropy pool `i` (PC 9.5.6) 
+    /// Adds a random event `e` from source `s` to entropy pool `i` (PC 9.5.6)
     pub fn add_random_event(&mut self, s: u8, i: usize, e: &[u8]) {
         assert!(i <= NUM_POOLS);
         // These restrictions (and `s` in [0, 255]) are part of the Fortuna spec.
@@ -352,7 +352,7 @@ mod tests {
                          50,  68, 236, 107, 133,  18, 217, 219,  46, 134,
                         169, 156, 211,  74, 163,  17, 100, 173,  26,  70,
                         246, 193,  57, 164, 167, 175, 233, 220, 160, 114,
-                          2, 200, 215,  80, 207, 218,  85,  58, 235, 117, 
+                          2, 200, 215,  80, 207, 218,  85,  58, 235, 117,
                         177, 223,  87, 192,  50, 251,  61,  65, 141, 100,
                          59, 228,  23, 215,  58, 107, 248, 248, 103,  57,
                         127,  31, 241,  91, 230,  33,   0, 164,  77, 46];
@@ -411,7 +411,7 @@ mod tests {
 
         // from Crypto.Random.Fortuna import FortunaAccumulator
         // x = FortunaAccumulator.FortunaAccumulator()
-        // x.add_random_event(0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")  
+        // x.add_random_event(0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
         // x.add_random_event(0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
         // x.add_random_event(1, 0, "\1\2")
         // x.add_random_event(1, 1, "\1\2")
@@ -433,7 +433,7 @@ mod tests {
         f.add_random_event(0, 0, &[0; 32]);
         f.add_random_event(0, 0, &[0; 32]);
 
-        // x.add_random_event(0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")  
+        // x.add_random_event(0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
         // x.add_random_event(0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
         // print list(bytearray(x.random_data(100)))
         let expected = [101, 123, 175, 157, 142, 202, 211,  47, 149, 214,
@@ -513,4 +513,3 @@ mod bench {
         bh.bytes = bytes.len() as u64;
     }
 }
-