Merge pull request #280 from marcusklaas/rustup

Replace x.as_mut_ref() by &mut

Author: cosmycoder

src/bcrypt_pbkdf.rs

@@ -47,13 +47,13 @@ pub fn bcrypt_pbkdf(password: &[u8], salt: &[u8], rounds: u32, output: &mut [u8]
 
     let mut h = Sha512::new();
     h.input(password);
-    h.result(hpass.as_mut_slice());
+    h.result(&mut hpass);
 
     for block in (1..(nblocks+1)) {
         let mut count = [0u8; 4];
         let mut hsalt = [0u8; 64];
         let mut out   = [0u8; 32];
-        write_u32_be(count.as_mut_slice(), block as u32);
+        write_u32_be(&mut count, block as u32);
 
         h.reset();
         h.input(salt);
@@ -276,7 +276,7 @@ mod bench {
         let mut out  = [0u8; 32];
 
         b.iter(|| {
-            bcrypt_pbkdf(&pass, &salt, 5, out.as_mut_slice());
+            bcrypt_pbkdf(&pass, &salt, 5, &mut out);
         });
     }
 }

src/blake2b.rs

@@ -383,7 +383,7 @@ impl Mac for Blake2b {
      */
     fn result(&mut self) -> MacResult {
         let mut mac: Vec<u8> = repeat(0).take(self.digest_length as usize).collect();
-        self.raw_result(mac.as_mut_slice());
+        self.raw_result(&mut mac);
         MacResult::new_from_owned(mac)
     }
 

src/blockmodes.rs

@@ -200,8 +200,8 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
             output.rewind(self.out_hist.len());
             let last_out = output.take_next(self.out_hist.len());
             update_history(
-                self.in_hist.as_mut_slice(),
-                self.out_hist.as_mut_slice(),
+                &mut self.in_hist,
+                &mut self.out_hist,
                 last_in,
                 last_out);
         }
@@ -233,8 +233,8 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
                     next_in,
                     next_out);
                 update_history(
-                    me.in_hist.as_mut_slice(),
-                    me.out_hist.as_mut_slice(),
+                    &mut me.in_hist,
+                    &mut me.out_hist,
                     next_in,
                     next_out);
             }
@@ -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(self.in_hist.as_mut_slice(), in_hist);
-        slice::bytes::copy_memory(self.out_hist.as_mut_slice(), out_hist);
+        slice::bytes::copy_memory(&mut self.in_hist, in_hist);
+        slice::bytes::copy_memory(&mut self.out_hist, out_hist);
     }
 }
 
@@ -575,7 +575,7 @@ impl <T: BlockEncryptor> BlockProcessor for CbcEncryptorProcessor<T> {
         for ((&x, &y), o) in input.iter().zip(out_hist.iter()).zip(self.temp.iter_mut()) {
             *o = x ^ y;
         }
-        self.algo.encrypt_block(&self.temp[..], output.as_mut_slice());
+        self.algo.encrypt_block(&self.temp[..], output);
     }
 }
 
@@ -620,7 +620,7 @@ struct CbcDecryptorProcessor<T> {
 
 impl <T: BlockDecryptor> BlockProcessor for CbcDecryptorProcessor<T> {
     fn process_block(&mut self, in_hist: &[u8], _: &[u8], input: &[u8], output: &mut [u8]) {
-        self.algo.decrypt_block(input, self.temp.as_mut_slice());
+        self.algo.decrypt_block(input, &mut self.temp);
         for ((&x, &y), o) in self.temp.iter().zip(in_hist.iter()).zip(output.iter_mut()) {
             *o = x ^ y;
         }
@@ -690,7 +690,7 @@ impl <A: BlockEncryptor> CtrMode<A> {
         }
     }
     pub fn reset(&mut self, ctr: &[u8]) {
-        slice::bytes::copy_memory(self.ctr.as_mut_slice(), ctr);
+        slice::bytes::copy_memory(&mut self.ctr, ctr);
         self.bytes.reset();
     }
     fn process(&mut self, input: &[u8], output: &mut [u8]) {
@@ -701,7 +701,7 @@ impl <A: BlockEncryptor> CtrMode<A> {
             if self.bytes.is_empty() {
                 let mut wb = self.bytes.borrow_write_buffer();
                 self.algo.encrypt_block(&self.ctr[..], wb.take_remaining());
-                add_ctr(self.ctr.as_mut_slice(), 1);
+                add_ctr(&mut self.ctr, 1);
             }
             let count = cmp::min(self.bytes.remaining(), len - i);
             let bytes_it = self.bytes.take_next(count).iter();
@@ -754,15 +754,15 @@ impl <A: BlockEncryptorX8> CtrModeX8<A> {
     pub fn new(algo: A, ctr: &[u8]) -> CtrModeX8<A> {
         let block_size = algo.block_size();
         let mut ctr_x8: Vec<u8> = repeat(0).take(block_size * 8).collect();
-        construct_ctr_x8(ctr, ctr_x8.as_mut_slice());
+        construct_ctr_x8(ctr, &mut ctr_x8);
         CtrModeX8 {
             algo: algo,
             ctr_x8: ctr_x8,
             bytes: OwnedReadBuffer::new_with_len(repeat(0).take(block_size * 8).collect(), 0)
         }
     }
     pub fn reset(&mut self, ctr: &[u8]) {
-        construct_ctr_x8(ctr, self.ctr_x8.as_mut_slice());
+        construct_ctr_x8(ctr, &mut self.ctr_x8);
         self.bytes.reset();
     }
     fn process(&mut self, input: &[u8], output: &mut [u8]) {
@@ -774,7 +774,7 @@ impl <A: BlockEncryptorX8> CtrModeX8<A> {
             if self.bytes.is_empty() {
                 let mut wb = self.bytes.borrow_write_buffer();
                 self.algo.encrypt_block_x8(&self.ctr_x8[..], wb.take_remaining());
-                for ctr_i in self.ctr_x8.as_mut_slice().chunks_mut(self.algo.block_size()) {
+                for ctr_i in &mut self.ctr_x8.chunks_mut(self.algo.block_size()) {
                     add_ctr(ctr_i, 8);
                 }
             }
@@ -986,7 +986,7 @@ mod test {
         let mut cipher_out: Vec<u8> = repeat(0).take(test.get_cipher().len()).collect();
         {
             let mut buff_in = RefReadBuffer::new(test.get_plain());
-            let mut buff_out = RefWriteBuffer::new(cipher_out.as_mut_slice());
+            let mut buff_out = RefWriteBuffer::new(&mut cipher_out);
             match enc.encrypt(&mut buff_in, &mut buff_out, true) {
                 Ok(BufferUnderflow) => {}
                 Ok(BufferOverflow) => panic!("Encryption not completed"),
@@ -998,7 +998,7 @@ mod test {
         let mut plain_out: Vec<u8> = repeat(0).take(test.get_plain().len()).collect();
         {
             let mut buff_in = RefReadBuffer::new(test.get_cipher());
-            let mut buff_out = RefWriteBuffer::new(plain_out.as_mut_slice());
+            let mut buff_out = RefWriteBuffer::new(&mut plain_out);
             match dec.decrypt(&mut buff_in, &mut buff_out, true) {
                 Ok(BufferUnderflow) => {}
                 Ok(BufferOverflow) => panic!("Decryption not completed"),
@@ -1127,7 +1127,7 @@ mod test {
         let mut cipher_out: Vec<u8> = repeat(0).take(test.get_cipher().len()).collect();
         run_inc(
             test.get_plain(),
-            cipher_out.as_mut_slice(),
+            &mut cipher_out,
             |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
                 enc.encrypt(in_buff, out_buff, eof)
             },
@@ -1139,7 +1139,7 @@ mod test {
         let mut plain_out: Vec<u8> = repeat(0).take(test.get_plain().len()).collect();
         run_inc(
             test.get_cipher(),
-            plain_out.as_mut_slice(),
+            &mut plain_out,
             |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
                 dec.decrypt(in_buff, out_buff, eof)
             },
@@ -1182,7 +1182,7 @@ mod test {
             let mut cipher_out: Vec<u8> = repeat(0).take(test.get_cipher().len()).collect();
             run_inc(
                 test.get_plain(),
-                cipher_out.as_mut_slice(),
+                &mut cipher_out,
                 |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
                     enc.encrypt(in_buff, out_buff, eof)
                 },
@@ -1194,7 +1194,7 @@ mod test {
             let mut plain_out: Vec<u8> = repeat(0).take(test.get_plain().len()).collect();
             run_inc(
                 test.get_cipher(),
-                plain_out.as_mut_slice(),
+                &mut plain_out,
                 |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
                     dec.decrypt(in_buff, out_buff, eof)
                 },

src/blowfish.rs

@@ -314,7 +314,7 @@ impl BlockEncryptor for Blowfish {
         assert!(input.len() == 8);
         assert!(output.len() == 8);
         let mut block = [0u32, 0u32];
-        read_u32v_be(block.as_mut_slice(), input);
+        read_u32v_be(&mut block, input);
         let (l, r) = self.encrypt(block[0], block[1]);
         write_u32_be(&mut output[0..4], l);
         write_u32_be(&mut output[4..8], r);
@@ -330,7 +330,7 @@ impl BlockDecryptor for Blowfish {
         assert!(input.len() == 8);
         assert!(output.len() == 8);
         let mut block = [0u32, 0u32];
-        read_u32v_be(block.as_mut_slice(), input);
+        read_u32v_be(&mut block, input);
         let (l, r) = self.decrypt(block[0], block[1]);
         write_u32_be(&mut output[0..4], l);
         write_u32_be(&mut output[4..8], r);

src/curve25519.rs

@@ -2168,9 +2168,9 @@ mod tests {
     fn from_to_bytes_preserves() {
         for i in (0..50) {
             let mut e: Vec<u8> = (0u32..32).map(|idx| (idx*(1289+i*761)) as u8).collect();
-            e.as_mut_slice()[0] &= 248;
-            e.as_mut_slice()[31] &= 127;
-            e.as_mut_slice()[31] |= 64;
+            e[0] &= 248;
+            e[31] &= 127;
+            e[31] |= 64;
             let fe = Fe::from_bytes(e.as_ref());
             let e_preserved = fe.to_bytes();
             assert!(e == e_preserved.to_vec());
@@ -2205,9 +2205,9 @@ mod tests {
 
         fn next(&mut self) -> Option<Fe> {
             let mut e: Vec<u8> = (0..32).map(|idx| (idx*(1289+self.which*761)) as u8).collect();
-            e.as_mut_slice()[0] &= 248;
-            e.as_mut_slice()[31] &= 127;
-            e.as_mut_slice()[31] |= 64;
+            e[0] &= 248;
+            e[31] &= 127;
+            e[31] |= 64;
             Some(Fe::from_bytes(e.as_ref()))
         }
     }

src/digest.rs

@@ -75,7 +75,7 @@ pub trait Digest {
         use serialize::hex::ToHex;
 
         let mut buf: Vec<u8> = repeat(0).take((self.output_bits()+7)/8).collect();
-        self.result(buf.as_mut_slice());
+        self.result(&mut buf);
         buf[..].to_hex()
     }
 }

src/ed25519.rs

@@ -9,7 +9,7 @@ pub fn keypair(seed: &[u8]) -> ([u8; 64], [u8; 32]) {
         let mut hash_output: [u8; 64] = [0; 64];
         let mut hasher = Sha512::new();
         hasher.input(seed);
-        hasher.result(hash_output.as_mut_slice());
+        hasher.result(&mut hash_output);
         hash_output[0] &= 248;
         hash_output[31] &= 63;
         hash_output[31] |= 64;
@@ -34,7 +34,7 @@ pub fn signature(message: &[u8], secret_key: &[u8]) -> [u8; 64] {
         let mut hash_output: [u8; 64] = [0; 64];
         let mut hasher = Sha512::new();
         hasher.input(seed);
-        hasher.result(hash_output.as_mut_slice());
+        hasher.result(&mut hash_output);
         hash_output[0] &= 248;
         hash_output[31] &= 63;
         hash_output[31] |= 64;
@@ -46,7 +46,7 @@ pub fn signature(message: &[u8], secret_key: &[u8]) -> [u8; 64] {
         let mut hasher = Sha512::new();
         hasher.input(&az[32..64]);
         hasher.input(message);
-        hasher.result(hash_output.as_mut_slice());
+        hasher.result(&mut hash_output);
         sc_reduce(&mut hash_output[0..64]);
         hash_output
     };
@@ -65,8 +65,8 @@ pub fn signature(message: &[u8], secret_key: &[u8]) -> [u8; 64] {
         hasher.input(signature.as_ref());
         hasher.input(message);
         let mut hram: [u8; 64] = [0; 64];
-        hasher.result(hram.as_mut_slice());
-        sc_reduce(hram.as_mut_slice());
+        hasher.result(&mut hram);
+        sc_reduce(&mut hram);
         sc_muladd(&mut signature[32..64], &hram[0..32], &az[0..32], &nonce[0..32]);
     }
 
@@ -112,8 +112,8 @@ pub fn verify(message: &[u8], public_key: &[u8], signature: &[u8]) -> bool {
     hasher.input(public_key);
     hasher.input(message);
     let mut hash: [u8; 64] = [0; 64];
-    hasher.result(hash.as_mut_slice());
-    sc_reduce(hash.as_mut_slice());
+    hasher.result(&mut hash);
+    sc_reduce(&mut hash);
 
     let r = GeP2::double_scalarmult_vartime(hash.as_ref(), a, &signature[32..64]);
     let rcheck = r.to_bytes();

src/fortuna.rs

@@ -102,7 +102,7 @@ impl FortunaGenerator {
         let mut hasher = Sha256::new();
         hasher.input(&self.key[..]);
         hasher.input(s);
-        hasher.result(self.key.as_mut_slice());
+        hasher.result(&mut self.key);
         hasher = Sha256::new();
         hasher.input(&self.key[..]);
         hasher.result(&mut self.key[..]);
@@ -134,13 +134,13 @@ impl FortunaGenerator {
         self.generate_blocks(n, &mut out[..(n * AES_BLOCK_SIZE)]);
         if rem > 0 {
             let mut buf = [0; AES_BLOCK_SIZE];
-            self.generate_blocks(1, buf.as_mut_slice());
+            self.generate_blocks(1, &mut buf);
             copy_memory(&mut out[(n * AES_BLOCK_SIZE)..], &buf[..rem]);
         }
 
         // Rekey
         let mut new_key = [0; KEY_LEN];
-        self.generate_blocks(KEY_LEN / AES_BLOCK_SIZE, new_key.as_mut_slice());
+        self.generate_blocks(KEY_LEN / AES_BLOCK_SIZE, &mut new_key);
         self.key = new_key;
     }
 }
@@ -244,7 +244,7 @@ impl Rng for Fortuna {
 
     fn next_u32(&mut self) -> u32 {
         let mut ret = [0; 4];
-        self.fill_bytes(ret.as_mut_slice());
+        self.fill_bytes(&mut ret);
         read_u32_le(&ret[..])
     }
 }
@@ -357,11 +357,11 @@ mod tests {
                          59, 228,  23, 215,  58, 107, 248, 248, 103,  57,
                         127,  31, 241,  91, 230,  33,   0, 164,  77, 46];
         let mut f: Fortuna = SeedableRng::from_seed(&[1, 2, 3, 4][..]);
-        f.fill_bytes(output.as_mut_slice());
+        f.fill_bytes(&mut output);
         assert_eq!(&expected[..], &output[..]);
 
         let mut scratch = [0; (1 << 20)];
-        f.generator.generate_random_data(scratch.as_mut_slice());
+        f.generator.generate_random_data(&mut scratch);
 
         let expected = [122, 164,  26,  67, 102,  65,  30, 217, 219, 113,
                          14,  86, 214, 146, 185,  17, 107, 135, 183,   7,
@@ -373,7 +373,7 @@ mod tests {
                         171, 115, 157, 109, 248, 198, 227,  18, 204, 211,
                          42, 184,  92,  42, 171, 222, 198, 117, 162, 134,
                         116, 109,  77, 195, 187, 139,  37,  78, 224,  63];
-        f.fill_bytes(output.as_mut_slice());
+        f.fill_bytes(&mut output);
         assert_eq!(&expected[..], &output[..]);
 
         f.reseed(&[5]);
@@ -389,7 +389,7 @@ mod tests {
                         101,  10,  29,  33, 133,  87, 189,  36, 229,  56,
                          17, 100, 138,  49,  79, 239, 210, 189, 141,  46];
 
-        f.fill_bytes(output.as_mut_slice());
+        f.fill_bytes(&mut output);
         assert_eq!(&expected[..], &output[..]);
     }
 
@@ -426,7 +426,7 @@ mod tests {
                         226, 168, 179, 246,  82,  42, 223, 239, 201,  23,
                          28,  30, 195, 195,   9, 154,  31, 172, 209, 232,
                         238, 111,  75, 251, 196,  43, 217, 241,  93, 237];
-        f.fill_bytes(output.as_mut_slice());
+        f.fill_bytes(&mut output);
         assert_eq!(&expected[..], &output[..]);
 
         // Immediately (less than 100ms)
@@ -446,7 +446,7 @@ mod tests {
                          19, 167,  56, 192, 140,  93, 132,  78,  22,  16,
                         114,  68, 123, 200,  37, 183, 163, 224, 201, 155,
                         233,  71, 111,  26,   8, 114, 232, 181,  13,  51];
-        f.fill_bytes(output.as_mut_slice());
+        f.fill_bytes(&mut output);
         assert_eq!(&expected[..], &output[..]);
 
         // Simulate more than 100 ms passing
@@ -463,7 +463,7 @@ mod tests {
                          67, 148, 192,  52, 147, 216,  79, 204, 106, 112,
                         238,   0, 239,  99, 159,  96, 184,  90,  54, 122,
                         184, 241, 221, 151, 169,  29, 197,  45,  80,   6];
-        f.fill_bytes(output.as_mut_slice());
+        f.fill_bytes(&mut output);
         assert_eq!(&expected[..], &output[..]);
     }
 }