remove a bunch of unnecessary imports

5 files changed, 30 insertions, 37 deletions

diff --git a/src/aes.rs b/src/aes.rs
index d86246f..19a47cc 100644
--- a/src/aes.rs
+++ b/src/aes.rs
@@ -1,13 +1,10 @@
-use openssl;
-use std;
-
 use primitives::{fixed_xor, pad_pkcs7, unpad_pkcs7};
 
 pub fn decrypt_aes_128_ecb (bytes: &[u8], key: &[u8]) -> Option<Vec<u8>> {
     // openssl already doesn't return differentiable results for invalid
     // padding, so we can't either
-    return Some(openssl::crypto::symm::decrypt(
-        openssl::crypto::symm::Type::AES_128_ECB,
+    return Some(::openssl::crypto::symm::decrypt(
+        ::openssl::crypto::symm::Type::AES_128_ECB,
         key,
         vec![],
         bytes
@@ -31,8 +28,8 @@ pub fn decrypt_aes_128_cbc (bytes: &[u8], key: &[u8], iv: &[u8]) -> Option<Vec<u
 }
 
 pub fn encrypt_aes_128_ecb (bytes: &[u8], key: &[u8]) -> Vec<u8> {
-    return openssl::crypto::symm::encrypt(
-        openssl::crypto::symm::Type::AES_128_ECB,
+    return ::openssl::crypto::symm::encrypt(
+        ::openssl::crypto::symm::Type::AES_128_ECB,
         key,
         vec![],
         bytes
@@ -56,13 +53,13 @@ pub fn encrypt_aes_128_cbc (bytes: &[u8], key: &[u8], iv: &[u8]) -> Vec<u8> {
 
 pub fn aes_128_ctr (bytes: &[u8], key: &[u8], nonce: u64) -> Vec<u8> {
     let nonce_array: [u8; 8] = unsafe {
-        std::mem::transmute(nonce.to_le())
+        ::std::mem::transmute(nonce.to_le())
     };
     let mut counter = 0u64;
     let mut ret = vec![];
     for block in bytes.chunks(16) {
         let counter_array: [u8; 8] = unsafe {
-            std::mem::transmute(counter.to_le())
+            ::std::mem::transmute(counter.to_le())
         };
         let keystream = encrypt_aes_128_ecb(
             &pad_pkcs7(
diff --git a/src/crack.rs b/src/crack.rs
index dda7b15..92950c4 100644
--- a/src/crack.rs
+++ b/src/crack.rs
@@ -1,4 +1,3 @@
-use std;
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::collections::{HashMap, HashSet};
@@ -96,14 +95,14 @@ pub fn find_aes_128_ecb_encrypted_string (inputs: &[Vec<u8>]) -> Vec<u8> {
 }
 
 pub fn detect_ecb_cbc<F> (f: &F, block_size: usize) -> BlockCipherMode where F: Fn(&[u8]) -> Vec<u8> {
-    if block_size >= std::u8::MAX as usize {
+    if block_size >= ::std::u8::MAX as usize {
         panic!("invalid block size: {}", block_size);
     }
     let block_size_byte = block_size as u8;
     let plaintext: Vec<u8> = (0..block_size_byte)
         .cycle()
         .take(block_size * 2)
-        .flat_map(|n| std::iter::repeat(n).take(block_size + 1))
+        .flat_map(|n| ::std::iter::repeat(n).take(block_size + 1))
         .collect();
     let ciphertext = f(&plaintext[..]);
 
@@ -135,7 +134,7 @@ pub fn crack_padded_aes_128_ecb<F> (f: &F) -> Vec<u8> where F: Fn(&[u8]) -> Vec<
     loop {
         let mut map = HashMap::new();
 
-        let prefix: Vec<u8> = std::iter::repeat(b'A')
+        let prefix: Vec<u8> = ::std::iter::repeat(b'A')
             .take(block_size - ((i % block_size) + 1))
             .collect();
         for c in 0..256 {
@@ -165,7 +164,7 @@ pub fn crack_padded_aes_128_ecb_with_prefix<F> (f: &F) -> Vec<u8> where F: Fn(&[
     let (block_size, prefix_len) = find_block_size_and_fixed_prefix_len(f);
     let wrapped_f = |input: &[u8]| {
         let alignment_padding = block_size - (prefix_len % block_size);
-        let padded_input: Vec<u8> = std::iter::repeat(b'A')
+        let padded_input: Vec<u8> = ::std::iter::repeat(b'A')
             .take(alignment_padding)
             .chain(input.iter().map(|x| *x))
             .collect();
@@ -191,8 +190,8 @@ pub fn crack_querystring_aes_128_ecb<F> (encrypter: &F) -> (String, Vec<Vec<u8>>
     let find_uid_role_blocks = || {
         let mut map = HashMap::new();
         for c in 32..127 {
-            let email_bytes: Vec<u8> = std::iter::repeat(c).take(9).collect();
-            let email = std::str::from_utf8(&email_bytes[..]).unwrap();
+            let email_bytes: Vec<u8> = ::std::iter::repeat(c).take(9).collect();
+            let email = ::std::str::from_utf8(&email_bytes[..]).unwrap();
             let ciphertext = encrypter(email);
             incr_map_element(&mut map, ciphertext[..16].to_vec());
             incr_map_element(&mut map, ciphertext[16..32].to_vec());
@@ -393,7 +392,7 @@ fn crack_single_byte_xor_with_confidence (input: &[u8]) -> (u8, f64) {
     for a in 0..256u16 {
         let decrypted = fixed_xor(
             input,
-            &std::iter::repeat(a as u8)
+            &::std::iter::repeat(a as u8)
                 .take(input.len())
                 .collect::<Vec<u8>>()[..]
         );
@@ -483,7 +482,7 @@ fn find_block_size_and_fixed_prefix_len<F> (f: &F) -> (usize, usize) where F: Fn
     let mut prev = f(&[b'f']);
     let mut len = 0;
     loop {
-        let prefix: Vec<u8> = std::iter::repeat(byte)
+        let prefix: Vec<u8> = ::std::iter::repeat(byte)
             .take(len)
             .collect();
         let next = f(&prefix[..]);
diff --git a/src/primitives.rs b/src/primitives.rs
index fb80a79..d537081 100644
--- a/src/primitives.rs
+++ b/src/primitives.rs
@@ -1,5 +1,3 @@
-use std;
-
 pub fn fixed_xor (bytes1: &[u8], bytes2: &[u8]) -> Vec<u8> {
     return bytes1.iter()
         .zip(bytes2.iter())
@@ -28,7 +26,7 @@ pub fn pad_pkcs7 (block: &[u8], blocksize: u8) -> Vec<u8> {
     return block
         .iter()
         .map(|c| *c)
-        .chain(std::iter::repeat(padding_bytes).take(padding_bytes as usize))
+        .chain(::std::iter::repeat(padding_bytes).take(padding_bytes as usize))
         .collect();
 }
 
diff --git a/src/random.rs b/src/random.rs
index af0bc43..e248293 100644
--- a/src/random.rs
+++ b/src/random.rs
@@ -1,5 +1,4 @@
 use rand::{Rand, Rng, SeedableRng};
-use std;
 
 pub struct MersenneTwister {
     state: [u32; 624],
@@ -83,12 +82,12 @@ impl Clone for MersenneTwister {
     }
 }
 
-impl std::fmt::Debug for MersenneTwister {
-    fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+impl ::std::fmt::Debug for MersenneTwister {
+    fn fmt (&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
         try!(write!(f, "MersenneTwister {{ "));
-        try!(std::fmt::Debug::fmt(&&self.state[..], f));
+        try!(::std::fmt::Debug::fmt(&&self.state[..], f));
         try!(write!(f, ", "));
-        try!(std::fmt::Debug::fmt(&self.index, f));
+        try!(::std::fmt::Debug::fmt(&self.index, f));
         write!(f, " }}")
     }
 }
diff --git a/tests/lib.rs b/tests/lib.rs
index 4e172d1..71c5e32 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -8,7 +8,7 @@ use std::collections::HashMap;
 use std::io::prelude::*;
 use std::fs::File;
 
-use rand::{Rng, SeedableRng, thread_rng};
+use rand::{Rng, SeedableRng};
 use serialize::base64::FromBase64;
 use serialize::hex::FromHex;
 
@@ -52,12 +52,12 @@ fn read (filename: &str) -> Vec<u8> {
 
 fn random_aes_128_key () -> [u8; 16] {
     let mut key = [0; 16];
-    thread_rng().fill_bytes(&mut key);
+    rand::thread_rng().fill_bytes(&mut key);
     return key;
 }
 
 fn coinflip () -> bool {
-    thread_rng().gen()
+    rand::thread_rng().gen()
 }
 
 #[test]
@@ -165,13 +165,13 @@ fn problem_11 () {
     static mut last_mode: matasano::BlockCipherMode = matasano::BlockCipherMode::ECB;
 
     fn random_padding (input: &[u8]) -> Vec<u8> {
-        let front_padding: Vec<u8> = thread_rng()
+        let front_padding: Vec<u8> = rand::thread_rng()
             .gen_iter()
-            .take(thread_rng().gen_range(5, 10))
+            .take(rand::thread_rng().gen_range(5, 10))
             .collect();
-        let back_padding: Vec<u8> = thread_rng()
+        let back_padding: Vec<u8> = rand::thread_rng()
             .gen_iter()
-            .take(thread_rng().gen_range(5, 10))
+            .take(rand::thread_rng().gen_range(5, 10))
             .collect();
         return front_padding
             .iter()
@@ -278,9 +278,9 @@ fn problem_14 () {
                     aGUgZ2lybGllcyBvbiBzdGFuZGJ5IHdhdmluZyBq\
                     dXN0IHRvIHNheSBoaQpEaWQgeW91IHN0b3A/IE5v\
                     LCBJIGp1c3QgZHJvdmUgYnkK".from_base64().unwrap();
-    let front_padding: Vec<u8> = thread_rng()
+    let front_padding: Vec<u8> = rand::thread_rng()
         .gen_iter()
-        .take(thread_rng().gen_range(1, 100))
+        .take(rand::thread_rng().gen_range(1, 100))
         .collect();
     let fixed_padding = |input: &[u8]| -> Vec<u8> {
         return front_padding
@@ -381,7 +381,7 @@ fn problem_17 () {
 
     static mut chosen_plaintext_idx: usize = 0;
     let encrypter = || {
-        let idx = thread_rng().gen_range(0, strings.len());
+        let idx = rand::thread_rng().gen_range(0, strings.len());
         let plaintext = strings[idx].from_base64().unwrap();
         unsafe { chosen_plaintext_idx = idx };
         let iv = random_aes_128_key();
@@ -476,7 +476,7 @@ fn problem_21 () {
 
 #[test]
 fn problem_22 () {
-    let mut mt: matasano::MersenneTwister = thread_rng().gen();
+    let mut mt: matasano::MersenneTwister = rand::thread_rng().gen();
     let outputs: Vec<u32> = mt.gen_iter().take(624).collect();
     let mut mt2 = matasano::clone_mersenne_twister_from_output(&outputs[..]);
     for _ in 1..1000 {