diff --git a/src/rust-crypto-util/tool.rs b/src/rust-crypto-util/tool.rs
index ffe59728..2b4b5d52 100644
--- a/src/rust-crypto-util/tool.rs
+++ b/src/rust-crypto-util/tool.rs
@@ -14,7 +14,6 @@ extern crate rust_crypto = "rust-crypto";
 
 use std::io;
 use std::os;
-use std::slice;
 
 use getopts::{optopt, optflag, getopts, Matches};
 
@@ -60,10 +59,10 @@ fn run_scrypt(matches: &Matches) {
     let pass = io::stdio::stdin_raw().read_exact(pass_len as uint).unwrap();
 
     let params = scrypt::ScryptParams::new(logn, r, p);
-    let mut output = slice::from_elem(dklen, 0u8);
-    scrypt::scrypt(pass.as_slice(), salt.as_slice(), &params, output);
+    let mut output = Vec::from_elem(dklen, 0u8);
+    scrypt::scrypt(pass.as_slice(), salt.as_slice(), &params, output.as_mut_slice());
 
-    match io::stdout().write(output) {
+    match io::stdout().write(output.as_slice()) {
         Ok(_) => { },
         Err(_) => fail!("Error writing result")
     }
diff --git a/src/rust-crypto/aes.rs b/src/rust-crypto/aes.rs
index 1c054b14..60bc87be 100644
--- a/src/rust-crypto/aes.rs
+++ b/src/rust-crypto/aes.rs
@@ -175,17 +175,17 @@ pub fn cbc_encryptor<X: PaddingProcessor + Send>(
         match key_size {
             KeySize128 => {
                 let aes_enc = aesni::AesNi128Encryptor::new(key);
-                let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+                let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
                 enc as ~Encryptor
             }
             KeySize192 => {
                 let aes_enc = aesni::AesNi192Encryptor::new(key);
-                let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+                let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
                 enc as ~Encryptor
             }
             KeySize256 => {
                 let aes_enc = aesni::AesNi256Encryptor::new(key);
-                let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+                let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
                 enc as ~Encryptor
             }
         }
@@ -193,17 +193,17 @@ pub fn cbc_encryptor<X: PaddingProcessor + Send>(
         match key_size {
             KeySize128 => {
                 let aes_enc = aessafe::AesSafe128Encryptor::new(key);
-                let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+                let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
                 enc as ~Encryptor
             }
             KeySize192 => {
                 let aes_enc = aessafe::AesSafe192Encryptor::new(key);
-                let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+                let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
                 enc as ~Encryptor
             }
             KeySize256 => {
                 let aes_enc = aessafe::AesSafe256Encryptor::new(key);
-                let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+                let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
                 enc as ~Encryptor
             }
         }
@@ -219,17 +219,17 @@ pub fn cbc_encryptor<X: PaddingProcessor + Send>(
     match key_size {
         KeySize128 => {
             let aes_enc = aessafe::AesSafe128Encryptor::new(key);
-            let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+            let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
             enc as ~Encryptor
         }
         KeySize192 => {
             let aes_enc = aessafe::AesSafe192Encryptor::new(key);
-            let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+            let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
             enc as ~Encryptor
         }
         KeySize256 => {
             let aes_enc = aessafe::AesSafe256Encryptor::new(key);
-            let enc = ~CbcEncryptor::new(aes_enc, padding, iv.to_owned());
+            let enc = ~CbcEncryptor::new(aes_enc, padding, Vec::from_slice(iv));
             enc as ~Encryptor
         }
     }
@@ -247,17 +247,17 @@ pub fn cbc_decryptor<X: PaddingProcessor + Send>(
         match key_size {
             KeySize128 => {
                 let aes_dec = aesni::AesNi128Decryptor::new(key);
-                let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+                let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
                 dec as ~Decryptor
             }
             KeySize192 => {
                 let aes_dec = aesni::AesNi192Decryptor::new(key);
-                let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+                let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
                 dec as ~Decryptor
             }
             KeySize256 => {
                 let aes_dec = aesni::AesNi256Decryptor::new(key);
-                let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+                let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
                 dec as ~Decryptor
             }
         }
@@ -265,17 +265,17 @@ pub fn cbc_decryptor<X: PaddingProcessor + Send>(
         match key_size {
             KeySize128 => {
                 let aes_dec = aessafe::AesSafe128Decryptor::new(key);
-                let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+                let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
                 dec as ~Decryptor
             }
             KeySize192 => {
                 let aes_dec = aessafe::AesSafe192Decryptor::new(key);
-                let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+                let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
                 dec as ~Decryptor
             }
             KeySize256 => {
                 let aes_dec = aessafe::AesSafe256Decryptor::new(key);
-                let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+                let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
                 dec as ~Decryptor
             }
         }
@@ -292,17 +292,17 @@ pub fn cbc_decryptor<X: PaddingProcessor + Send>(
     match key_size {
         KeySize128 => {
             let aes_dec = aessafe::AesSafe128Decryptor::new(key);
-            let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+            let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
             dec as ~Decryptor
         }
         KeySize192 => {
             let aes_dec = aessafe::AesSafe192Decryptor::new(key);
-            let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+            let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
             dec as ~Decryptor
         }
         KeySize256 => {
             let aes_dec = aessafe::AesSafe256Decryptor::new(key);
-            let dec = ~CbcDecryptor::new(aes_dec, padding, iv.to_owned());
+            let dec = ~CbcDecryptor::new(aes_dec, padding, Vec::from_slice(iv));
             dec as ~Decryptor
         }
     }
@@ -319,17 +319,17 @@ pub fn ctr(
         match key_size {
             KeySize128 => {
                 let aes_dec = aesni::AesNi128Encryptor::new(key);
-                let dec = ~CtrMode::new(aes_dec, iv.to_owned());
+                let dec = ~CtrMode::new(aes_dec, Vec::from_slice(iv));
                 dec as ~SynchronousStreamCipher
             }
             KeySize192 => {
                 let aes_dec = aesni::AesNi192Encryptor::new(key);
-                let dec = ~CtrMode::new(aes_dec, iv.to_owned());
+                let dec = ~CtrMode::new(aes_dec, Vec::from_slice(iv));
                 dec as ~SynchronousStreamCipher
             }
             KeySize256 => {
                 let aes_dec = aesni::AesNi256Encryptor::new(key);
-                let dec = ~CtrMode::new(aes_dec, iv.to_owned());
+                let dec = ~CtrMode::new(aes_dec, Vec::from_slice(iv));
                 dec as ~SynchronousStreamCipher
             }
         }
@@ -337,17 +337,17 @@ pub fn ctr(
         match key_size {
             KeySize128 => {
                 let aes_dec = aessafe::AesSafe128EncryptorX8::new(key);
-                let dec = ~CtrModeX8::new(aes_dec, iv.to_owned());
+                let dec = ~CtrModeX8::new(aes_dec, iv);
                 dec as ~SynchronousStreamCipher
             }
             KeySize192 => {
                 let aes_dec = aessafe::AesSafe192EncryptorX8::new(key);
-                let dec = ~CtrModeX8::new(aes_dec, iv.to_owned());
+                let dec = ~CtrModeX8::new(aes_dec, iv);
                 dec as ~SynchronousStreamCipher
             }
             KeySize256 => {
                 let aes_dec = aessafe::AesSafe256EncryptorX8::new(key);
-                let dec = ~CtrModeX8::new(aes_dec, iv.to_owned());
+                let dec = ~CtrModeX8::new(aes_dec, iv);
                 dec as ~SynchronousStreamCipher
             }
         }
@@ -363,17 +363,17 @@ pub fn ctr(
     match key_size {
         KeySize128 => {
             let aes_dec = aessafe::AesSafe128Encryptor::new(key);
-            let dec = ~CtrModeX8::new(aes_dec, iv.to_owned());
+            let dec = ~CtrModeX8::new(aes_dec, Vec::from_slice(iv));
             dec as ~SynchronousStreamCipher
         }
         KeySize192 => {
             let aes_dec = aessafe::AesSafe192Encryptor::new(key);
-            let dec = ~CtrModeX8::new(aes_dec, iv.to_owned());
+            let dec = ~CtrModeX8::new(aes_dec, Vec::from_slice(iv));
             dec as ~SynchronousStreamCipher
         }
         KeySize256 => {
             let aes_dec = aessafe::AesSafe256Encryptor::new(key);
-            let dec = ~CtrModeX8::new(aes_dec, iv.to_owned());
+            let dec = ~CtrModeX8::new(aes_dec, Vec::from_slice(iv));
             dec as ~SynchronousStreamCipher
         }
     }
diff --git a/src/rust-crypto/blockmodes.rs b/src/rust-crypto/blockmodes.rs
index 12104e6e..cb171b06 100644
--- a/src/rust-crypto/blockmodes.rs
+++ b/src/rust-crypto/blockmodes.rs
@@ -60,8 +60,8 @@ struct BlockEngine<P, X> {
     /// in_hist and out_hist keep track of data that was input to and output from the last
     /// invocation of the process_block() method of the Processor. Depending on the mode, these may
     /// be empty vectors if history is not needed.
-    in_hist: ~[u8],
-    out_hist: ~[u8],
+    in_hist: Vec<u8>,
+    out_hist: Vec<u8>,
 
     /// If some input data is supplied, but not a complete blocks worth, it is stored in this buffer
     /// until enough arrives that it can be passed to the process_block() method of the Processor.
@@ -107,10 +107,10 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
     fn new(processor: P, padding: X, block_size: uint) -> BlockEngine<P, X> {
         BlockEngine {
             block_size: block_size,
-            in_hist: ~[],
-            out_hist: ~[],
-            in_scratch: OwnedWriteBuffer::new(slice::from_elem(block_size, 0u8)),
-            out_write_scratch: Some(OwnedWriteBuffer::new(slice::from_elem(block_size, 0u8))),
+            in_hist: Vec::new(),
+            out_hist: Vec::new(),
+            in_scratch: OwnedWriteBuffer::new(Vec::from_elem(block_size, 0u8)),
+            out_write_scratch: Some(OwnedWriteBuffer::new(Vec::from_elem(block_size, 0u8))),
             out_read_scratch: None,
             processor: processor,
             padding: padding,
@@ -124,8 +124,8 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
             processor: P,
             padding: X,
             block_size: uint,
-            in_hist: ~[u8],
-            out_hist: ~[u8]) -> BlockEngine<P, X> {
+            in_hist: Vec<u8>,
+            out_hist: Vec<u8>) -> BlockEngine<P, X> {
         BlockEngine {
             in_hist: in_hist,
             out_hist: out_hist,
@@ -195,7 +195,11 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
             let last_in = input.take_next(self.in_hist.len());
             output.rewind(self.out_hist.len());
             let last_out = output.take_next(self.out_hist.len());
-            update_history(self.in_hist, self.out_hist, last_in, last_out);
+            update_history(
+                self.in_hist.as_mut_slice(),
+                self.out_hist.as_mut_slice(),
+                last_in,
+                last_out);
         }
         if input.is_empty() {
             return FastMode;
@@ -224,7 +228,11 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
                     me.out_hist.as_slice(),
                     next_in,
                     next_out);
-                update_history(me.in_hist, me.out_hist, next_in, next_out);
+                update_history(
+                    me.in_hist.as_mut_slice(),
+                    me.out_hist.as_mut_slice(),
+                    next_in,
+                    next_out);
             }
 
             let rb = wout.into_read_buffer();
@@ -400,8 +408,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, in_hist);
-        slice::bytes::copy_memory(self.out_hist, out_hist);
+        slice::bytes::copy_memory(self.in_hist.as_mut_slice(), in_hist);
+        slice::bytes::copy_memory(self.out_hist.as_mut_slice(), out_hist);
     }
 }
 
@@ -553,7 +561,7 @@ impl <T: BlockDecryptor, X: PaddingProcessor> Decryptor for EcbDecryptor<T, X> {
 
 struct CbcEncryptorProcessor<T> {
     algo: T,
-    temp: ~[u8]
+    temp: Vec<u8>
 }
 
 impl <T: BlockEncryptor> BlockProcessor for CbcEncryptorProcessor<T> {
@@ -561,7 +569,7 @@ impl <T: BlockEncryptor> BlockProcessor for CbcEncryptorProcessor<T> {
         for ((&x, &y), o) in input.iter().zip(out_hist.iter()).zip(self.temp.mut_iter()) {
             *o = x ^ y;
         }
-        self.algo.encrypt_block(self.temp, output);
+        self.algo.encrypt_block(self.temp.as_slice(), output.as_mut_slice());
     }
 }
 
@@ -572,18 +580,18 @@ pub struct CbcEncryptor<T, X> {
 
 impl <T: BlockEncryptor, X: PaddingProcessor> CbcEncryptor<T, X> {
     /// Create a new CBC encryption mode object
-    pub fn new(algo: T, padding: X, iv: ~[u8]) -> CbcEncryptor<T, EncPadding<X>> {
+    pub fn new(algo: T, padding: X, iv: Vec<u8>) -> CbcEncryptor<T, EncPadding<X>> {
         let block_size = algo.block_size();
         let processor = CbcEncryptorProcessor {
             algo: algo,
-            temp: slice::from_elem(block_size, 0u8)
+            temp: Vec::from_elem(block_size, 0u8)
         };
         CbcEncryptor {
             block_engine: BlockEngine::new_with_history(
                 processor,
                 EncPadding::wrap(padding),
                 block_size,
-                ~[],
+                Vec::new(),
                 iv)
         }
     }
@@ -601,12 +609,12 @@ impl <T: BlockEncryptor, X: PaddingProcessor> Encryptor for CbcEncryptor<T, X> {
 
 struct CbcDecryptorProcessor<T> {
     algo: T,
-    temp: ~[u8]
+    temp: Vec<u8>
 }
 
 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);
+        self.algo.decrypt_block(input, self.temp.as_mut_slice());
         for ((&x, &y), o) in self.temp.iter().zip(in_hist.iter()).zip(output.mut_iter()) {
             *o = x ^ y;
         }
@@ -620,11 +628,11 @@ pub struct CbcDecryptor<T, X> {
 
 impl <T: BlockDecryptor, X: PaddingProcessor> CbcDecryptor<T, X> {
     /// Create a new CBC decryption mode object
-    pub fn new(algo: T, padding: X, iv: ~[u8]) -> CbcDecryptor<T, DecPadding<X>> {
+    pub fn new(algo: T, padding: X, iv: Vec<u8>) -> CbcDecryptor<T, DecPadding<X>> {
         let block_size = algo.block_size();
         let processor = CbcDecryptorProcessor {
             algo: algo,
-            temp: slice::from_elem(block_size, 0u8)
+            temp: Vec::from_elem(block_size, 0u8)
         };
         CbcDecryptor {
             block_engine: BlockEngine::new_with_history(
@@ -632,7 +640,7 @@ impl <T: BlockDecryptor, X: PaddingProcessor> CbcDecryptor<T, X> {
                 DecPadding::wrap(padding),
                 block_size,
                 iv,
-                ~[])
+                Vec::new())
         }
     }
     pub fn reset(&mut self, iv: &[u8]) {
@@ -661,22 +669,22 @@ fn add_ctr(ctr: &mut [u8], mut ammount: u8) {
 /// CTR Mode
 pub struct CtrMode<A> {
     algo: A,
-    ctr: ~[u8],
+    ctr: Vec<u8>,
     bytes: OwnedReadBuffer
 }
 
 impl <A: BlockEncryptor> CtrMode<A> {
     /// Create a new CTR object
-    pub fn new(algo: A, ctr: ~[u8]) -> CtrMode<A> {
+    pub fn new(algo: A, ctr: Vec<u8>) -> CtrMode<A> {
         let block_size = algo.block_size();
         CtrMode {
             algo: algo,
             ctr: ctr,
-            bytes: OwnedReadBuffer::new_with_len(slice::from_elem(block_size, 0u8), 0)
+            bytes: OwnedReadBuffer::new_with_len(Vec::from_elem(block_size, 0u8), 0)
         }
     }
     pub fn reset(&mut self, ctr: &[u8]) {
-        slice::bytes::copy_memory(self.ctr, ctr);
+        slice::bytes::copy_memory(self.ctr.as_mut_slice(), ctr);
         self.bytes.reset();
     }
     fn process(&mut self, input: &[u8], output: &mut [u8]) {
@@ -686,8 +694,8 @@ impl <A: BlockEncryptor> CtrMode<A> {
         while i < len {
             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, 1);
+                self.algo.encrypt_block(self.ctr.as_slice(), wb.take_remaining());
+                add_ctr(self.ctr.as_mut_slice(), 1);
             }
             let count = cmp::min(self.bytes.remaining(), len - i);
             let bytes_it = self.bytes.take_next(count).iter();
@@ -724,7 +732,7 @@ impl <A: BlockEncryptor> Decryptor for CtrMode<A> {
 /// CTR Mode that operates on 8 blocks at a time
 pub struct CtrModeX8<A> {
     algo: A,
-    ctr_x8: ~[u8],
+    ctr_x8: Vec<u8>,
     bytes: OwnedReadBuffer
 }
 
@@ -739,16 +747,16 @@ impl <A: BlockEncryptorX8> CtrModeX8<A> {
     /// Create a new CTR object that operates on 8 blocks at a time
     pub fn new(algo: A, ctr: &[u8]) -> CtrModeX8<A> {
         let block_size = algo.block_size();
-        let mut ctr_x8 = slice::from_elem(block_size * 8, 0u8);
-        construct_ctr_x8(ctr, ctr_x8);
+        let mut ctr_x8 = Vec::from_elem(block_size * 8, 0u8);
+        construct_ctr_x8(ctr, ctr_x8.as_mut_slice());
         CtrModeX8 {
             algo: algo,
             ctr_x8: ctr_x8,
-            bytes: OwnedReadBuffer::new_with_len(slice::from_elem(block_size * 8, 0u8), 0)
+            bytes: OwnedReadBuffer::new_with_len(Vec::from_elem(block_size * 8, 0u8), 0)
         }
     }
     pub fn reset(&mut self, ctr: &[u8]) {
-        construct_ctr_x8(ctr, self.ctr_x8);
+        construct_ctr_x8(ctr, self.ctr_x8.as_mut_slice());
         self.bytes.reset();
     }
     fn process(&mut self, input: &[u8], output: &mut [u8]) {
@@ -759,8 +767,8 @@ impl <A: BlockEncryptorX8> CtrModeX8<A> {
         while i < len {
             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.mut_chunks(self.algo.block_size()) {
+                self.algo.encrypt_block_x8(self.ctr_x8.as_slice(), wb.take_remaining());
+                for ctr_i in self.ctr_x8.as_mut_slice().mut_chunks(self.algo.block_size()) {
                     add_ctr(ctr_i, 8);
                 }
             }
@@ -806,7 +814,6 @@ mod test {
     use symmetriccipher::{Encryptor, Decryptor, SymmetricCipherError, InvalidLength, InvalidPadding};
 
     use std::cmp;
-    use std::slice;
     use test::Bencher;
 
     trait CipherTest {
@@ -967,29 +974,29 @@ mod test {
             test: &T,
             enc: &mut E,
             dec: &mut D) {
-        let mut cipher_out = slice::from_elem(test.get_cipher().len(), 0u8);
+        let mut cipher_out = Vec::from_elem(test.get_cipher().len(), 0u8);
         {
             let mut buff_in = RefReadBuffer::new(test.get_plain());
-            let mut buff_out = RefWriteBuffer::new(cipher_out);
+            let mut buff_out = RefWriteBuffer::new(cipher_out.as_mut_slice());
             match enc.encrypt(&mut buff_in, &mut buff_out, true) {
                 Ok(BufferUnderflow) => {}
                 Ok(BufferOverflow) => fail!("Encryption not completed"),
                 Err(_) => fail!("Error"),
             }
         }
-        assert!(test.get_cipher() == cipher_out);
+        assert!(test.get_cipher() == cipher_out.as_slice());
 
-        let mut plain_out = slice::from_elem(test.get_plain().len(), 0u8);
+        let mut plain_out = Vec::from_elem(test.get_plain().len(), 0u8);
         {
             let mut buff_in = RefReadBuffer::new(test.get_cipher());
-            let mut buff_out = RefWriteBuffer::new(plain_out);
+            let mut buff_out = RefWriteBuffer::new(plain_out.as_mut_slice());
             match dec.decrypt(&mut buff_in, &mut buff_out, true) {
                 Ok(BufferUnderflow) => {}
                 Ok(BufferOverflow) => fail!("Decryption not completed"),
                 Err(_) => fail!("Error"),
             }
         }
-        assert!(test.get_plain() == plain_out);
+        assert!(test.get_plain() == plain_out.as_slice());
     }
 
     /// Run and encryption or decryption operation, passing in variable sized input and output
@@ -1104,29 +1111,29 @@ mod test {
             test: &T,
             enc: &mut E,
             dec: &mut D) {
-        let mut cipher_out = slice::from_elem(test.get_cipher().len(), 0u8);
+        let mut cipher_out = Vec::from_elem(test.get_cipher().len(), 0u8);
         run_inc(
             test.get_plain(),
-            cipher_out,
+            cipher_out.as_mut_slice(),
             |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
                 enc.encrypt(in_buff, out_buff, eof)
             },
             || { 0 },
             || { 1 },
             false);
-        assert!(test.get_cipher() == cipher_out);
+        assert!(test.get_cipher() == cipher_out.as_slice());
 
-        let mut plain_out = slice::from_elem(test.get_plain().len(), 0u8);
+        let mut plain_out = Vec::from_elem(test.get_plain().len(), 0u8);
         run_inc(
             test.get_cipher(),
-            plain_out,
+            plain_out.as_mut_slice(),
             |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
                 dec.decrypt(in_buff, out_buff, eof)
             },
             || { 0 },
             || { 1 },
             false);
-        assert!(test.get_plain() == plain_out);
+        assert!(test.get_plain() == plain_out.as_slice());
     }
 
     fn run_rand_test<T: CipherTest, E: Encryptor, D: Decryptor>(
@@ -1148,29 +1155,29 @@ mod test {
             let mut enc = new_enc();
             let mut dec = new_dec();
 
-            let mut cipher_out = slice::from_elem(test.get_cipher().len(), 0u8);
+            let mut cipher_out = Vec::from_elem(test.get_cipher().len(), 0u8);
             run_inc(
                 test.get_plain(),
-                cipher_out,
+                cipher_out.as_mut_slice(),
                 |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
                     enc.encrypt(in_buff, out_buff, eof)
                 },
                 || { r() },
                 || { r() },
                 rng2.gen());
-            assert!(test.get_cipher() == cipher_out);
+            assert!(test.get_cipher() == cipher_out.as_slice());
 
-            let mut plain_out = slice::from_elem(test.get_plain().len(), 0u8);
+            let mut plain_out = Vec::from_elem(test.get_plain().len(), 0u8);
             run_inc(
                 test.get_cipher(),
-                plain_out,
+                plain_out.as_mut_slice(),
                 |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
                     dec.decrypt(in_buff, out_buff, eof)
                 },
                 || { r() },
                 || { r() },
                 rng2.gen());
-            assert!(test.get_plain() == plain_out);
+            assert!(test.get_plain() == plain_out.as_slice());
         }
     }
 
@@ -1225,11 +1232,11 @@ mod test {
                 test,
                 || {
                     let aes_enc = aessafe::AesSafe128Encryptor::new(test.key);
-                    CbcEncryptor::new(aes_enc, NoPadding, test.iv.clone())
+                    CbcEncryptor::new(aes_enc, NoPadding, Vec::from_slice(test.iv))
                 },
                 || {
                     let aes_dec = aessafe::AesSafe128Decryptor::new(test.key);
-                    CbcDecryptor::new(aes_dec, NoPadding, test.iv.clone())
+                    CbcDecryptor::new(aes_dec, NoPadding, Vec::from_slice(test.iv))
                 });
         }
     }
@@ -1242,11 +1249,11 @@ mod test {
                 test,
                 || {
                     let aes_enc = aessafe::AesSafe128Encryptor::new(test.key);
-                    CbcEncryptor::new(aes_enc, PkcsPadding, test.iv.clone())
+                    CbcEncryptor::new(aes_enc, PkcsPadding, Vec::from_slice(test.iv))
                 },
                 || {
                     let aes_dec = aessafe::AesSafe128Decryptor::new(test.key);
-                    CbcDecryptor::new(aes_dec, PkcsPadding, test.iv.clone())
+                    CbcDecryptor::new(aes_dec, PkcsPadding, Vec::from_slice(test.iv))
                 });
         }
     }
@@ -1259,11 +1266,11 @@ mod test {
                 test,
                 || {
                     let aes_enc = aessafe::AesSafe128Encryptor::new(test.key);
-                    CtrMode::new(aes_enc, test.ctr.clone())
+                    CtrMode::new(aes_enc, Vec::from_slice(test.ctr))
                 },
                 || {
                     let aes_enc = aessafe::AesSafe128Encryptor::new(test.key);
-                    CtrMode::new(aes_enc, test.ctr.clone())
+                    CtrMode::new(aes_enc, Vec::from_slice(test.ctr))
                 });
         }
     }
@@ -1318,7 +1325,7 @@ mod test {
         let mut cipher = [3u8, ..528];
 
         let aes_enc = aessafe::AesSafe128Encryptor::new(key);
-        let mut enc = CbcEncryptor::new(aes_enc, PkcsPadding, iv.to_owned());
+        let mut enc = CbcEncryptor::new(aes_enc, PkcsPadding, Vec::from_slice(iv));
 
         bh.iter( || {
             enc.reset(iv);
@@ -1344,7 +1351,7 @@ mod test {
         let mut cipher = [3u8, ..528];
 
         let aes_enc = aessafe::AesSafe128Encryptor::new(key);
-        let mut enc = CtrMode::new(aes_enc, ctr.to_owned());
+        let mut enc = CtrMode::new(aes_enc, Vec::from_slice(ctr));
 
         bh.iter( || {
             enc.reset(ctr);
diff --git a/src/rust-crypto/buffer.rs b/src/rust-crypto/buffer.rs
index 8788032a..a31b954e 100644
--- a/src/rust-crypto/buffer.rs
+++ b/src/rust-crypto/buffer.rs
@@ -97,13 +97,13 @@ impl <'a> ReadBuffer for RefReadBuffer<'a> {
 }
 
 pub struct OwnedReadBuffer {
-    buff: ~[u8],
+    buff: Vec<u8>,
     len: uint,
     pos: uint
 }
 
 impl OwnedReadBuffer {
-    pub fn new(buff: ~[u8]) -> OwnedReadBuffer {
+    pub fn new(buff: Vec<u8>) -> OwnedReadBuffer {
         let len = buff.len();
         OwnedReadBuffer {
             buff: buff,
@@ -111,7 +111,7 @@ impl OwnedReadBuffer {
             pos: 0
         }
     }
-    pub fn new_with_len<'a>(buff: ~[u8], len: uint) -> OwnedReadBuffer {
+    pub fn new_with_len<'a>(buff: Vec<u8>, len: uint) -> OwnedReadBuffer {
         OwnedReadBuffer {
             buff: buff,
             len: len,
@@ -240,13 +240,13 @@ impl <'a> WriteBuffer for BorrowedWriteBuffer<'a> {
 }
 
 pub struct OwnedWriteBuffer {
-    buff: ~[u8],
+    buff: Vec<u8>,
     len: uint,
     pos: uint
 }
 
 impl OwnedWriteBuffer {
-    pub fn new(buff: ~[u8]) -> OwnedWriteBuffer {
+    pub fn new(buff: Vec<u8>) -> OwnedWriteBuffer {
         let len = buff.len();
         OwnedWriteBuffer {
             buff: buff,
diff --git a/src/rust-crypto/cryptoutil.rs b/src/rust-crypto/cryptoutil.rs
index 55c4595e..f2394fc9 100644
--- a/src/rust-crypto/cryptoutil.rs
+++ b/src/rust-crypto/cryptoutil.rs
@@ -480,7 +480,6 @@ impl <T: FixedBuffer> StandardPadding for T {
 #[cfg(test)]
 pub mod test {
     use std::num::Bounded;
-    use std::slice;
 
     use rand::IsaacRng;
     use rand::distributions::{IndependentSample, Range};
@@ -492,7 +491,7 @@ pub mod test {
     /// correct.
     pub fn test_digest_1million_random<D: Digest>(digest: &mut D, blocksize: uint, expected: &str) {
         let total_size = 1000000;
-        let buffer = slice::from_elem(blocksize * 2, 'a' as u8);
+        let buffer = Vec::from_elem(blocksize * 2, 'a' as u8);
         let mut rng = IsaacRng::new_unseeded();
         let range = Range::new(0, 2 * blocksize + 1);
         let mut count = 0;
diff --git a/src/rust-crypto/digest.rs b/src/rust-crypto/digest.rs
index 6939375c..11d369f0 100644
--- a/src/rust-crypto/digest.rs
+++ b/src/rust-crypto/digest.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use std::num::ToStrRadix;
-use std::slice;
 
 /**
  * The Digest trait specifies an interface common to digest functions, such as SHA-1 and the SHA-2
@@ -73,9 +72,9 @@ pub trait Digest {
      * ~str in hexadecimal format.
      */
     fn result_str(&mut self) -> ~str {
-        let mut buf = slice::from_elem((self.output_bits()+7)/8, 0u8);
-        self.result(buf);
-        return to_hex(buf);
+        let mut buf = Vec::from_elem((self.output_bits()+7)/8, 0u8);
+        self.result(buf.as_mut_slice());
+        return to_hex(buf.as_slice());
     }
 }
 
diff --git a/src/rust-crypto/hmac.rs b/src/rust-crypto/hmac.rs
index e329b28a..066b75e6 100644
--- a/src/rust-crypto/hmac.rs
+++ b/src/rust-crypto/hmac.rs
@@ -18,8 +18,8 @@ use mac::{Mac, MacResult};
  */
 pub struct Hmac<D> {
     digest: D,
-    i_key: ~[u8],
-    o_key: ~[u8],
+    i_key: Vec<u8>,
+    o_key: Vec<u8>,
     finished: bool
 }
 
@@ -32,11 +32,11 @@ fn derive_key(key: &mut [u8], mask: u8) {
 // The key that Hmac processes must be the same as the block size of the underlying Digest. If the
 // provided key is smaller than that, we just pad it with zeros. If its larger, we hash it and then
 // pad it with zeros.
-fn expand_key<D: Digest>(digest: &mut D, key: &[u8]) -> ~[u8] {
+fn expand_key<D: Digest>(digest: &mut D, key: &[u8]) -> Vec<u8> {
     let bs = digest.block_size();
-    let mut expanded_key = slice::from_elem(bs, 0u8);
+    let mut expanded_key = Vec::from_elem(bs, 0u8);
     if key.len() <= bs {
-        slice::bytes::copy_memory(expanded_key, key);
+        slice::bytes::copy_memory(expanded_key.as_mut_slice(), key);
         for elem in expanded_key.mut_slice_from(key.len()).mut_iter() {
             *elem = 0;
         }
@@ -54,11 +54,11 @@ fn expand_key<D: Digest>(digest: &mut D, key: &[u8]) -> ~[u8] {
 
 // Hmac uses two keys derived from the provided key - one by xoring every byte with 0x36 and another
 // with 0x5c.
-fn create_keys<D: Digest>(digest: &mut D, key: &[u8]) -> (~[u8], ~[u8]) {
+fn create_keys<D: Digest>(digest: &mut D, key: &[u8]) -> (Vec<u8>, Vec<u8>) {
     let mut i_key = expand_key(digest, key);
     let mut o_key = i_key.clone();
-    derive_key(i_key, 0x36);
-    derive_key(o_key, 0x5c);
+    derive_key(i_key.as_mut_slice(), 0x36);
+    derive_key(o_key.as_mut_slice(), 0x5c);
     return (i_key, o_key);
 }
 
@@ -73,7 +73,7 @@ impl <D: Digest> Hmac<D> {
      */
     pub fn new(mut digest: D, key: &[u8]) -> Hmac<D> {
         let (i_key, o_key) = create_keys(&mut digest, key);
-        digest.input(i_key);
+        digest.input(i_key.as_slice());
         return Hmac {
             digest: digest,
             i_key: i_key,
@@ -91,15 +91,15 @@ impl <D: Digest> Mac for Hmac<D> {
 
     fn reset(&mut self) {
         self.digest.reset();
-        self.digest.input(self.i_key);
+        self.digest.input(self.i_key.as_slice());
         self.finished = false;
     }
 
     fn result(&mut self) -> MacResult {
         let output_size = self.digest.output_bytes();
-        let mut code = slice::from_elem(output_size, 0u8);
+        let mut code = Vec::from_elem(output_size, 0u8);
 
-        self.raw_result(code);
+        self.raw_result(code.as_mut_slice());
 
         return MacResult::new_from_owned(code);
     }
@@ -109,7 +109,7 @@ impl <D: Digest> Mac for Hmac<D> {
             self.digest.result(output);
 
             self.digest.reset();
-            self.digest.input(self.o_key);
+            self.digest.input(self.o_key.as_slice());
             self.digest.input(output);
 
             self.finished = true;
diff --git a/src/rust-crypto/mac.rs b/src/rust-crypto/mac.rs
index 49ff7d54..d8ff2af2 100644
--- a/src/rust-crypto/mac.rs
+++ b/src/rust-crypto/mac.rs
@@ -50,7 +50,7 @@ pub trait Mac {
  * A MacResult wraps a Mac code and provides a safe Eq implementation that runs in fixed time.
  */
 pub struct MacResult {
-    code: ~[u8]
+    code: Vec<u8>
 }
 
 impl MacResult {
@@ -59,14 +59,14 @@ impl MacResult {
      */
     pub fn new(code: &[u8]) -> MacResult {
         return MacResult {
-            code: code.to_owned()
+            code: Vec::from_slice(code)
         };
     }
 
     /**
      * Create a new MacResult taking ownership of the specified code value.
      */
-    pub fn new_from_owned(code: ~[u8]) -> MacResult {
+    pub fn new_from_owned(code: Vec<u8>) -> MacResult {
         return MacResult {
             code: code
         };
diff --git a/src/rust-crypto/pbkdf2.rs b/src/rust-crypto/pbkdf2.rs
index 4d206a65..6adb53cc 100644
--- a/src/rust-crypto/pbkdf2.rs
+++ b/src/rust-crypto/pbkdf2.rs
@@ -11,7 +11,6 @@
 
 use std::io::IoResult;
 use std::num::Bounded;
-use std::slice;
 use std::slice::MutableCloneableVector;
 
 use rand::{OSRng, Rng};
@@ -91,7 +90,7 @@ pub fn pbkdf2<M: Mac>(mac: &mut M, salt: &[u8], c: u32, output: &mut [u8]) {
     // Most users of pbkdf2 should use a value much larger than 1, so, this allocation should almost
     // always be necessary. A big exception is Scrypt. However, this allocation is unlikely to be
     // the bottleneck in Scrypt performance.
-    let mut scratch = slice::from_elem(os, 0u8);
+    let mut scratch = Vec::from_elem(os, 0u8);
 
     let mut idx: u32 = 0;
 
@@ -103,11 +102,11 @@ pub fn pbkdf2<M: Mac>(mac: &mut M, salt: &[u8], c: u32, output: &mut [u8]) {
             idx += 1;
         }
         if chunk.len() == os {
-            calculate_block(mac, salt, c, idx, scratch, chunk);
+            calculate_block(mac, salt, c, idx, scratch.as_mut_slice(), chunk);
         } else {
-            let mut tmp = slice::from_elem(os, 0u8);
-            calculate_block(mac, salt, c, idx, scratch, tmp);
-            chunk.copy_from(tmp);
+            let mut tmp = Vec::from_elem(os, 0u8);
+            calculate_block(mac, salt, c, idx, scratch.as_mut_slice(), tmp.as_mut_slice());
+            chunk.copy_from(tmp.as_slice());
         }
     }
 }
@@ -240,20 +239,18 @@ pub fn pbkdf2_check(password: &str, hashed_value: &str) -> Result<bool, &'static
 
     let mut mac = Hmac::new(Sha256::new(), password.as_bytes());
 
-    let mut output = slice::from_elem(hash.len(), 0u8);
-    pbkdf2(&mut mac, salt, c, output);
+    let mut output = Vec::from_elem(hash.len(), 0u8);
+    pbkdf2(&mut mac, salt, c, output.as_mut_slice());
 
     // Be careful here - its important that the comparison be done using a fixed time equality
     // check. Otherwise an adversary that can measure how long this step takes can learn about the
     // hashed value which would allow them to mount an offline brute force attack against the
     // hashed password.
-    return Ok(fixed_time_eq(output, hash));
+    return Ok(fixed_time_eq(output.as_slice(), hash));
 }
 
 #[cfg(test)]
 mod test {
-    use std::slice;
-
     use pbkdf2::{pbkdf2, pbkdf2_simple, pbkdf2_check};
     use hmac::Hmac;
     use sha1::Sha1;
@@ -322,9 +319,9 @@ mod test {
         let tests = tests();
         for t in tests.iter() {
             let mut mac = Hmac::new(Sha1::new(), t.password);
-            let mut result = slice::from_elem(t.expected.len(), 0u8);
-            pbkdf2(&mut mac, t.salt, t.c, result);
-            assert!(result == t.expected);
+            let mut result = Vec::from_elem(t.expected.len(), 0u8);
+            pbkdf2(&mut mac, t.salt, t.c, result.as_mut_slice());
+            assert!(result.as_slice() == t.expected);
         }
     }
 
diff --git a/src/rust-crypto/rc4.rs b/src/rust-crypto/rc4.rs
index a3542914..309d35a5 100644
--- a/src/rust-crypto/rc4.rs
+++ b/src/rust-crypto/rc4.rs
@@ -67,7 +67,6 @@ impl Decryptor for Rc4 {
 
 #[cfg(test)]
 mod test {
-    use std::slice;
     use symmetriccipher::SynchronousStreamCipher;
     use rc4::Rc4;
 
@@ -103,9 +102,9 @@ mod test {
         let tests = tests();
         for t in tests.iter() {
             let mut rc4 = Rc4::new(t.key.as_bytes());
-            let mut result = slice::from_elem(t.output.len(), 0u8);
-            rc4.process(t.input.as_bytes(), result);
-            assert!(result == t.output);
+            let mut result = Vec::from_elem(t.output.len(), 0u8);
+            rc4.process(t.input.as_bytes(), result.as_mut_slice());
+            assert!(result.as_slice() == t.output);
         }
     }
 }
diff --git a/src/rust-crypto/scrypt.rs b/src/rust-crypto/scrypt.rs
index 698ee674..bc245e14 100644
--- a/src/rust-crypto/scrypt.rs
+++ b/src/rust-crypto/scrypt.rs
@@ -15,7 +15,6 @@
 use std::io::IoResult;
 use std::num::ToPrimitive;
 use std::mem::size_of;
-use std::slice;
 use std::slice::MutableCloneableVector;
 
 use rand::{OSRng, Rng};
@@ -240,17 +239,17 @@ pub fn scrypt(password: &[u8], salt: &[u8], params: &ScryptParams, output: &mut
 
     let mut mac = Hmac::new(Sha256::new(), password);
 
-    let mut b = slice::from_elem(p * r * 128, 0u8);
-    pbkdf2(&mut mac, salt, 1, b);
+    let mut b = Vec::from_elem(p * r * 128, 0u8);
+    pbkdf2(&mut mac, salt, 1, b.as_mut_slice());
 
-    let mut v = slice::from_elem(n * r * 128, 0u8);
-    let mut t = slice::from_elem(r * 128, 0u8);
+    let mut v = Vec::from_elem(n * r * 128, 0u8);
+    let mut t = Vec::from_elem(r * 128, 0u8);
 
-    for chunk in b.mut_chunks(r * 128) {
-        scrypt_ro_mix(chunk, v, t, n);
+    for chunk in b.as_mut_slice().mut_chunks(r * 128) {
+        scrypt_ro_mix(chunk, v.as_mut_slice(), t.as_mut_slice(), n);
     }
 
-    pbkdf2(&mut mac, b, 1, output);
+    pbkdf2(&mut mac, b.as_slice(), 1, output.as_mut_slice());
 }
 
 /**
@@ -402,20 +401,18 @@ pub fn scrypt_check(password: &str, hashed_value: &str) -> Result<bool, &'static
         None => { }
     }
 
-    let mut output = slice::from_elem(hash.len(), 0u8);
-    scrypt(password.as_bytes(), salt, &params, output);
+    let mut output = Vec::from_elem(hash.len(), 0u8);
+    scrypt(password.as_bytes(), salt, &params, output.as_mut_slice());
 
     // Be careful here - its important that the comparison be done using a fixed time equality
     // check. Otherwise an adversary that can measure how long this step takes can learn about the
     // hashed value which would allow them to mount an offline brute force attack against the
     // hashed password.
-    return Ok(fixed_time_eq(output, hash));
+    return Ok(fixed_time_eq(output.as_slice(), hash));
 }
 
 #[cfg(test)]
 mod test {
-    use std::slice;
-
     use scrypt::{scrypt, scrypt_simple, scrypt_check, ScryptParams};
 
     struct Test {
@@ -486,10 +483,10 @@ mod test {
     fn test_scrypt() {
         let tests = tests();
         for t in tests.iter() {
-            let mut result = slice::from_elem(t.expected.len(), 0u8);
+            let mut result = Vec::from_elem(t.expected.len(), 0u8);
             let params = ScryptParams::new(t.log_n, t.r, t.p);
-            scrypt(t.password.as_bytes(), t.salt.as_bytes(), &params, result);
-            assert!(result == t.expected);
+            scrypt(t.password.as_bytes(), t.salt.as_bytes(), &params, result.as_mut_slice());
+            assert!(result.as_slice() == t.expected);
         }
     }