Merge remote-tracking branch 'upstream/master'

Author: BlockBlazeDev

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust-crypto"
-version = "0.2.27"
+version = "0.2.29"
 authors = ["The Rust-Crypto Project Developers"]
 license = "MIT/Apache-2.0"
 homepage = "https://github.com/DaGenix/rust-crypto/"

src/aes_gcm.rs

@@ -33,7 +33,7 @@ impl<'a> AesGcm<'a> {
         // earlier preventing the use of generic CTR mode.
 
         let mut iv = [0u8; 16];
-        copy_memory(&mut iv, nonce);
+        copy_memory(nonce, &mut iv);
         iv[15] = 1u8;
         let mut cipher = ctr(key_size,key,&iv);
         let temp_block = [0u8; 16];

src/aessafe.rs

@@ -124,7 +124,6 @@ finite field which allows for efficient computation of the AES S-Boxes. See [7]
 */
 
 use std::ops::{BitAnd, BitXor, Not};
-use std::num::Int;
 use std::default::Default;
 
 use cryptoutil::{read_u32v_le, write_u32_le};

src/blake2b.rs

@@ -5,7 +5,6 @@
 // except according to those terms.
 
 use std::iter::repeat;
-use std::num::Int;
 use cryptoutil::{read_u64v_le, write_u64v_le};
 use std::slice::bytes::{copy_memory};
 use std::intrinsics::volatile_set_memory;
@@ -122,7 +121,7 @@ impl Blake2b {
             key: [0; BLAKE2B_KEYBYTES],
             key_length: key.len() as u8
         };
-        copy_memory(&mut b.key, key);
+        copy_memory(key, &mut b.key);
         b
     }
 
@@ -184,7 +183,7 @@ impl Blake2b {
 
     fn apply_key(&mut self) {
         let mut block : [u8; BLAKE2B_BLOCKBYTES] = [0; BLAKE2B_BLOCKBYTES];
-        copy_memory(&mut block, &self.key[..self.key_length as usize]);
+        copy_memory(&self.key[..self.key_length as usize], &mut block);
         self.update(&block);
         unsafe {
             volatile_set_memory(block.as_mut_ptr(), 0, block.len());
@@ -256,20 +255,20 @@ impl Blake2b {
             let fill = 2 * BLAKE2B_BLOCKBYTES - left;
 
             if input.len() > fill {
-                copy_memory( &mut self.buf[left..], &input[0..fill] ); // Fill buffer
+                copy_memory(&input[0..fill], &mut self.buf[left..]); // Fill buffer
                 self.buflen += fill;
                 self.increment_counter( BLAKE2B_BLOCKBYTES as u64);
                 self.compress();
 
                 let mut halves = self.buf.chunks_mut(BLAKE2B_BLOCKBYTES);
                 let first_half = halves.next().unwrap();
                 let second_half = halves.next().unwrap();
-                copy_memory(first_half, second_half);
+                copy_memory(second_half, first_half);
 
                 self.buflen -= BLAKE2B_BLOCKBYTES;
                 input = &input[fill..input.len()];
             } else { // inlen <= fill
-                copy_memory(&mut self.buf[left..], input);
+                copy_memory(input, &mut self.buf[left..]);
                 self.buflen += input.len();
                 break;
             }
@@ -287,7 +286,7 @@ impl Blake2b {
                 let mut halves = self.buf.chunks_mut(BLAKE2B_BLOCKBYTES);
                 let first_half = halves.next().unwrap();
                 let second_half = halves.next().unwrap();
-                copy_memory(first_half, second_half);
+                copy_memory(second_half, first_half);
             }
 
             let incby = self.buflen as u64;
@@ -304,7 +303,7 @@ impl Blake2b {
             self.computed = true;
         }
         let outlen = out.len();
-        copy_memory(out, &self.buf[0..outlen]);
+        copy_memory(&self.buf[0..outlen], out);
     }
 
     pub fn blake2b(out: &mut[u8], input: &[u8], key: &[u8]) {

src/blockmodes.rs

@@ -94,14 +94,14 @@ fn update_history(in_hist: &mut [u8], out_hist: &mut [u8], last_in: &[u8], last_
     let in_hist_len = in_hist.len();
     if in_hist_len > 0 {
         slice::bytes::copy_memory(
-            in_hist,
-            &last_in[last_in.len() - in_hist_len..]);
+            &last_in[last_in.len() - in_hist_len..],
+            in_hist);
     }
     let out_hist_len = out_hist.len();
     if out_hist_len > 0 {
         slice::bytes::copy_memory(
-            out_hist,
-            &last_out[last_out.len() - out_hist_len..]);
+            &last_out[last_out.len() - out_hist_len..],
+            out_hist);
     }
 }
 
@@ -412,8 +412,8 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
     }
     fn reset_with_history(&mut self, in_hist: &[u8], out_hist: &[u8]) {
         self.reset();
-        slice::bytes::copy_memory(&mut self.in_hist, in_hist);
-        slice::bytes::copy_memory(&mut self.out_hist, out_hist);
+        slice::bytes::copy_memory(in_hist, &mut self.in_hist);
+        slice::bytes::copy_memory(out_hist, &mut self.out_hist);
     }
 }
 
@@ -690,7 +690,7 @@ impl <A: BlockEncryptor> CtrMode<A> {
         }
     }
     pub fn reset(&mut self, ctr: &[u8]) {
-        slice::bytes::copy_memory(&mut self.ctr, ctr);
+        slice::bytes::copy_memory(ctr, &mut self.ctr);
         self.bytes.reset();
     }
     fn process(&mut self, input: &[u8], output: &mut [u8]) {
@@ -744,7 +744,7 @@ pub struct CtrModeX8<A> {
 
 fn construct_ctr_x8(in_ctr: &[u8], out_ctr_x8: &mut [u8]) {
     for (i, ctr_i) in out_ctr_x8.chunks_mut(in_ctr.len()).enumerate() {
-        slice::bytes::copy_memory(ctr_i, in_ctr);
+        slice::bytes::copy_memory(in_ctr, ctr_i);
         add_ctr(ctr_i, i as u8);
     }
 }

src/buffer.rs

@@ -37,7 +37,7 @@ pub trait ReadBuffer {
 
     fn push_to<W: WriteBuffer>(&mut self, output: &mut W) {
         let count = cmp::min(output.remaining(), self.remaining());
-        slice::bytes::copy_memory(output.take_next(count), self.take_next(count));
+        slice::bytes::copy_memory(self.take_next(count), output.take_next(count));
     }
 }