Merge pull request #277 from devigned/bug/rustup

Update to build against the Rust nightly

Author: cosmycoder

src/aes.rs

@@ -699,7 +699,8 @@ mod test {
             let mut aes_enc = aes::ctr(aes::KeySize::KeySize128, &test.key[..], &test.ctr[..]);
             let mut result: Vec<u8> = repeat(0).take(test.plain.len()).collect();
             aes_enc.process(&test.plain[..], &mut result[..]);
-            assert!(result.as_slice() == test.cipher);
+            let res: &[u8] = result.as_ref();
+            assert!(res == test.cipher);
         }
     }
 }

src/curve25519.rs

@@ -1020,7 +1020,7 @@ impl Fe {
     fn is_nonzero(&self) -> bool {
         let bs = self.to_bytes();
         let zero = [0; 32];
-        !fixed_time_eq(bs.as_slice(), zero.as_slice())
+        !fixed_time_eq(bs.as_ref(), zero.as_ref())
     }
 
     fn is_negative(&self) -> bool {
@@ -2157,7 +2157,7 @@ pub fn curve25519(n: &[u8], p: &[u8]) -> [u8; 32] {
 pub fn curve25519_base(x: &[u8]) -> [u8; 32] {
     let mut base : [u8; 32] = [0; 32];
     base[0] = 9;
-    curve25519(x, base.as_slice())
+    curve25519(x, base.as_ref())
 }
 
 #[cfg(test)]
@@ -2171,7 +2171,7 @@ mod tests {
             e.as_mut_slice()[0] &= 248;
             e.as_mut_slice()[31] &= 127;
             e.as_mut_slice()[31] |= 64;
-            let fe = Fe::from_bytes(e.as_slice());
+            let fe = Fe::from_bytes(e.as_ref());
             let e_preserved = fe.to_bytes();
             assert!(e == e_preserved.to_vec());
         }
@@ -2208,7 +2208,7 @@ mod tests {
             e.as_mut_slice()[0] &= 248;
             e.as_mut_slice()[31] &= 127;
             e.as_mut_slice()[31] |= 64;
-            Some(Fe::from_bytes(e.as_slice()))
+            Some(Fe::from_bytes(e.as_ref()))
         }
     }
 
@@ -2246,7 +2246,7 @@ mod tests {
             0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
             0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
             0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a ];
-        let pk = curve25519_base(sk.as_slice());
+        let pk = curve25519_base(sk.as_ref());
         let correct : [u8; 32] = [
              0x85,0x20,0xf0,0x09,0x89,0x30,0xa7,0x54
             ,0x74,0x8b,0x7d,0xdc,0xb4,0x3e,0xf7,0x5a

src/ed25519.rs

@@ -62,7 +62,7 @@ pub fn signature(message: &[u8], secret_key: &[u8]) -> [u8; 64] {
 
     {
         let mut hasher = Sha512::new();
-        hasher.input(signature.as_slice());
+        hasher.input(signature.as_ref());
         hasher.input(message);
         let mut hram: [u8; 64] = [0; 64];
         hasher.result(hram.as_mut_slice());
@@ -115,18 +115,18 @@ pub fn verify(message: &[u8], public_key: &[u8], signature: &[u8]) -> bool {
     hasher.result(hash.as_mut_slice());
     sc_reduce(hash.as_mut_slice());
 
-    let r = GeP2::double_scalarmult_vartime(hash.as_slice(), a, &signature[32..64]);
+    let r = GeP2::double_scalarmult_vartime(hash.as_ref(), a, &signature[32..64]);
     let rcheck = r.to_bytes();
 
-    fixed_time_eq(rcheck.as_slice(), &signature[0..32])
+    fixed_time_eq(rcheck.as_ref(), &signature[0..32])
 }
 
 pub fn exchange(public_key: &[u8], private_key: &[u8]) -> [u8; 32] {
     let ed_y = Fe::from_bytes(&public_key);
     // Produce public key in Montgomery form.
     let mont_x = edwards_to_montgomery_x(ed_y);
 
-    // Produce private key from seed component (bytes 0 to 32) 
+    // Produce private key from seed component (bytes 0 to 32)
     // of the Ed25519 extended private key (64 bytes).
     let mut hasher = Sha512::new();
     hasher.input(&private_key[0..32]);
@@ -138,7 +138,7 @@ pub fn exchange(public_key: &[u8], private_key: &[u8]) -> [u8; 32] {
     hash[31] |= 64;
 
     let shared_mont_x : [u8; 32] = curve25519(&hash, &mont_x.to_bytes()); // priv., pub.
-    
+
     shared_mont_x
 }
 
@@ -161,7 +161,7 @@ mod tests {
     use sha2::{Sha512};
 
     fn do_keypair_case(seed: [u8; 32], expected_secret: [u8; 64], expected_public: [u8; 32]) {
-        let (actual_secret, actual_public) = keypair(seed.as_slice());
+        let (actual_secret, actual_public) = keypair(seed.as_ref());
         assert_eq!(actual_secret.to_vec(), expected_secret.to_vec());
         assert_eq!(actual_public.to_vec(), expected_public.to_vec());
     }
@@ -192,7 +192,7 @@ mod tests {
     fn keypair_matches_mont() {
         let seed = [0x26, 0x27, 0xf6, 0x85, 0x97, 0x15, 0xad, 0x1d, 0xd2, 0x94, 0xdd, 0xc4, 0x76, 0x19, 0x39, 0x31,
                     0xf1, 0xad, 0xb5, 0x58, 0xf0, 0x93, 0x97, 0x32, 0x19, 0x2b, 0xd1, 0xc0, 0xfd, 0x16, 0x8e, 0x4e];
-        let (ed_private, ed_public) = keypair(seed.as_slice());
+        let (ed_private, ed_public) = keypair(seed.as_ref());
 
         let mut hasher = Sha512::new();
         hasher.input(&ed_private[0..32]);
@@ -211,20 +211,20 @@ mod tests {
     }
 
     fn do_sign_verify_case(seed: [u8; 32], message: &[u8], expected_signature: [u8; 64]) {
-        let (secret_key, public_key) = keypair(seed.as_slice());
-        let mut actual_signature = signature(message, secret_key.as_slice());
+        let (secret_key, public_key) = keypair(seed.as_ref());
+        let mut actual_signature = signature(message, secret_key.as_ref());
         assert_eq!(expected_signature.to_vec(), actual_signature.to_vec());
-        assert!(verify(message, public_key.as_slice(), actual_signature.as_slice()));
+        assert!(verify(message, public_key.as_ref(), actual_signature.as_ref()));
 
         for &(index, flip) in [(0, 1), (31, 0x80), (20, 0xff)].iter() {
             actual_signature[index] ^= flip;
-            assert!(!verify(message, public_key.as_slice(), actual_signature.as_slice()));
+            assert!(!verify(message, public_key.as_ref(), actual_signature.as_ref()));
             actual_signature[index] ^= flip;
         }
 
         let mut public_key_corrupt = public_key;
         public_key_corrupt[0] ^= 1;
-        assert!(!verify(message, public_key_corrupt.as_slice(), actual_signature.as_slice()));
+        assert!(!verify(message, public_key_corrupt.as_ref(), actual_signature.as_ref()));
     }
 
     #[test]
@@ -244,7 +244,7 @@ mod tests {
              0x37, 0x31, 0xb0, 0x1c, 0x8e, 0xc7, 0x5d, 0x08, 0x2e, 0xf7, 0xdc, 0x9d, 0x7f, 0x1b, 0x73, 0x15,
              0x9f, 0x63, 0xdb, 0x56, 0xaa, 0x12, 0xa2, 0xca, 0x39, 0xea, 0xce, 0x6b, 0x28, 0xe4, 0xc3, 0x1d,
              0x9d, 0x25, 0x67, 0x41, 0x45, 0x2e, 0x83, 0x87, 0xe1, 0x53, 0x6d, 0x03, 0x02, 0x6e, 0xe4, 0x84,
-             0x10, 0xd4, 0x3b, 0x21, 0x91, 0x88, 0xba, 0x14, 0xa8, 0xaf].as_slice(),
+             0x10, 0xd4, 0x3b, 0x21, 0x91, 0x88, 0xba, 0x14, 0xa8, 0xaf].as_ref(),
             [0x91, 0x20, 0x91, 0x66, 0x1e, 0xed, 0x18, 0xa4, 0x03, 0x4b, 0xc7, 0xdb, 0x4b, 0xd6, 0x0f, 0xe2,
              0xde, 0xeb, 0xf3, 0xff, 0x3b, 0x6b, 0x99, 0x8d, 0xae, 0x20, 0x94, 0xb6, 0x09, 0x86, 0x5c, 0x20,
              0x19, 0xec, 0x67, 0x22, 0xbf, 0xdc, 0x87, 0xbd, 0xa5, 0x40, 0x91, 0x92, 0x2e, 0x11, 0xe3, 0x93,
@@ -258,7 +258,7 @@ mod tests {
              0xec, 0x0e, 0x48, 0x67, 0x93, 0xa5, 0x1c, 0x67, 0x66, 0xf7, 0x06, 0x48, 0x26, 0xd0, 0x74, 0x51,
              0x4d, 0xd0, 0x57, 0x41, 0xf3, 0xbe, 0x27, 0x3e, 0xf2, 0x1f, 0x28, 0x0e, 0x49, 0x07, 0xed, 0x89,
              0xbe, 0x30, 0x1a, 0x4e, 0xc8, 0x49, 0x6e, 0xb6, 0xab, 0x90, 0x00, 0x06, 0xe5, 0xa3, 0xc8, 0xe9,
-             0xc9, 0x93, 0x62, 0x1d, 0x6a, 0x3b, 0x0f, 0x6c, 0xba, 0xd0, 0xfd, 0xde, 0xf3, 0xb9, 0xc8, 0x2d].as_slice(),
+             0xc9, 0x93, 0x62, 0x1d, 0x6a, 0x3b, 0x0f, 0x6c, 0xba, 0xd0, 0xfd, 0xde, 0xf3, 0xb9, 0xc8, 0x2d].as_ref(),
             [0x4b, 0x8d, 0x9b, 0x1e, 0xca, 0x54, 0x00, 0xea, 0xc6, 0xf5, 0xcc, 0x0c, 0x94, 0x39, 0x63, 0x00,
              0x52, 0xf7, 0x34, 0xce, 0x45, 0x3e, 0x94, 0x26, 0xf3, 0x19, 0xdd, 0x96, 0x03, 0xb6, 0xae, 0xae,
              0xb9, 0xd2, 0x3a, 0x5f, 0x93, 0xf0, 0x6a, 0x46, 0x00, 0x18, 0xf0, 0x69, 0xdf, 0x19, 0x44, 0x48,

src/hc128.rs

@@ -195,11 +195,12 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut hc128 = Hc128::new(key.as_slice(), nonce.as_slice());
+
+        let mut hc128 = Hc128::new(key.as_ref(), nonce.as_ref());
         hc128.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
-    }
+        let result: &[u8] = output.as_ref();
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(result == expected);    }
 
     #[test]
     fn test_hc128_ecrypt_set_6_vector_1() {
@@ -211,10 +212,12 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut hc128 = Hc128::new(key.as_slice(), nonce.as_slice());
+
+        let mut hc128 = Hc128::new(key.as_ref(), nonce.as_ref());
         hc128.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let result: &[u8] = output.as_ref();
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(result == expected);
     }
 
     #[test]
@@ -227,10 +230,12 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut hc128 = Hc128::new(key.as_slice(), nonce.as_slice());
+
+        let mut hc128 = Hc128::new(key.as_ref(), nonce.as_ref());
         hc128.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let result: &[u8] = output.as_ref();
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(result == expected);
     }
 
     #[test]

src/lib.rs

@@ -8,10 +8,11 @@
 #![feature(core)]
 #![feature(simd)]
 #![feature(step_by)]
+#![feature(convert)]
 #![cfg_attr(test, feature(test))]
 
 extern crate rand;
-extern crate "rustc-serialize" as serialize;
+extern crate rustc_serialize as serialize;
 extern crate time;
 #[cfg(test)] extern crate test;
 

src/salsa20.rs

@@ -320,10 +320,10 @@ mod test {
         let output_str = "662b9d0e3463029156069b12f918691a98f7dfb2ca0393c96bbfc6b1fbd630a2";
 
         let mut salsa20 = Salsa20::new(&key, &nonce);
-        salsa20.process(input.as_slice(), stream.as_mut_slice());
+        salsa20.process(input.as_ref(), stream.as_mut_slice());
 
         let mut sh = Sha256::new();
-        sh.input(stream.as_slice());
+        sh.input(stream.as_ref());
         let out_str = sh.result_str();
         assert!(&out_str[..] == output_str);
     }

src/sha1.rs

@@ -38,7 +38,7 @@ hasher.input_str("hello world");
 // read hash digest
 let hex = hasher.result_str();
 
-assert_eq!(hex.as_slice(), "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed");
+assert_eq!(hex, "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed");
 ```
 
 # Mathematics

src/sha2.rs

@@ -41,7 +41,7 @@ hasher.input_str("hello world");
 // read hash digest
 let hex = hasher.result_str();
 
-assert_eq!(hex.as_slice(),
+assert_eq!(hex,
            concat!("b94d27b9934d3e08a52e52d7da7dabfa",
                    "c484efe37a5380ee9088f7ace2efcde9"));
 ```
@@ -61,7 +61,7 @@ hasher.input_str("hello world");
 // read hash digest
 let hex = hasher.result_str();
 
-assert_eq!(hex.as_slice(),
+assert_eq!(hex,
            concat!("309ecc489c12d6eb4cc40f50c902f2b4",
                    "d0ed77ee511a7c7a9bcd3ca86d4cd86f",
                    "989dd35bc5ff499670da34255b45b0cf",

src/sosemanuk.rs

@@ -2344,10 +2344,11 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut sosemanuk = Sosemanuk::new(key.as_slice(), nonce.as_slice());
+
+        let mut sosemanuk = Sosemanuk::new(key.as_ref(), nonce.as_ref());
         sosemanuk.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(output.as_ref() == expected);
     }
 
     #[test]
@@ -2360,10 +2361,11 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut sosemanuk = Sosemanuk::new(key.as_slice(), nonce.as_slice());
+
+        let mut sosemanuk = Sosemanuk::new(key.as_ref(), nonce.as_ref());
         sosemanuk.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(output.as_ref() == expected);
     }
 
     #[test]
@@ -2376,10 +2378,11 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut sosemanuk = Sosemanuk::new(key.as_slice(), nonce.as_slice());
+
+        let mut sosemanuk = Sosemanuk::new(key.as_ref(), nonce.as_ref());
         sosemanuk.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(output.as_ref() == expected);
     }
 
     #[test]
@@ -2392,10 +2395,11 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut sosemanuk = Sosemanuk::new(key.as_slice(), nonce.as_slice());
+
+        let mut sosemanuk = Sosemanuk::new(key.as_ref(), nonce.as_ref());
         sosemanuk.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(output.as_ref() == expected);
     }
 
     #[test]
@@ -2408,12 +2412,13 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut sosemanuk = Sosemanuk::new(key.as_slice(), nonce.as_slice());
+
+        let mut sosemanuk = Sosemanuk::new(key.as_ref(), nonce.as_ref());
         sosemanuk.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(output.as_ref() == expected);
     }
-   
+
     #[test]
     fn test_sosemanuk_ecrypt_set_6_vector_3() {
         let key = "0F62B5085BAE0154A7FA4DA0F34699EC3F92E5388BDE3184D72A7DD02376C91C".from_hex().unwrap();
@@ -2424,10 +2429,11 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 64];
- 
-        let mut sosemanuk = Sosemanuk::new(key.as_slice(), nonce.as_slice());
+
+        let mut sosemanuk = Sosemanuk::new(key.as_ref(), nonce.as_ref());
         sosemanuk.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(output.as_ref() == expected);
     }
 
     // From TEST_VECTOR_128.txt from reference C implementation
@@ -2442,10 +2448,11 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 160];
- 
-        let mut sosemanuk = Sosemanuk::new(key.as_slice(), nonce.as_slice());
+
+        let mut sosemanuk = Sosemanuk::new(key.as_ref(), nonce.as_ref());
         sosemanuk.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(output.as_ref() == expected);
     }
 
     #[test]
@@ -2458,19 +2465,20 @@ mod test {
         let expected_output = expected_output_hex.from_hex().unwrap();
 
         let mut output = [0u8; 160];
- 
-        let mut sosemanuk = Sosemanuk::new(key.as_slice(), nonce.as_slice());
+
+        let mut sosemanuk = Sosemanuk::new(key.as_ref(), nonce.as_ref());
         sosemanuk.process(&input, &mut output);
-        assert!(output.as_slice() == expected_output.as_slice());
+        let expected: &[u8] = expected_output.as_ref();
+        assert!(output.as_ref() == expected);
     }
 }
- 
+
 #[cfg(test)]
 mod bench {
     use test::Bencher;
     use symmetriccipher::SynchronousStreamCipher;
     use sosemanuk::Sosemanuk;
- 
+
     #[bench]
     pub fn sosemanuk_10(bh: & mut Bencher) {
         let mut sosemanuk = Sosemanuk::new(&[0; 32], &[0; 16]);