diff --git a/openssl/Cargo.toml b/openssl/Cargo.toml
index 1417bea7..ef2443aa 100644
--- a/openssl/Cargo.toml
+++ b/openssl/Cargo.toml
@@ -23,7 +23,7 @@ libc = "0.2"
 openssl-sys = { version = "0.9", path = "../openssl-sys" }
 
 [dev-dependencies]
-rustc-serialize = "0.3"
 tempdir = "0.3"
 winapi = "0.2"
 ws2_32-sys = "0.2"
+hex = "0.2"
diff --git a/openssl/src/hash.rs b/openssl/src/hash.rs
index 6a13371d..1d2089ef 100644
--- a/openssl/src/hash.rs
+++ b/openssl/src/hash.rs
@@ -208,17 +208,17 @@ pub fn hash(t: MessageDigest, data: &[u8]) -> Result<Vec<u8>, ErrorStack> {
 
 #[cfg(test)]
 mod tests {
-    use serialize::hex::{FromHex, ToHex};
+    use hex::{FromHex, ToHex};
     use super::{hash, Hasher, MessageDigest};
     use std::io::prelude::*;
 
     fn hash_test(hashtype: MessageDigest, hashtest: &(&str, &str)) {
-        let res = hash(hashtype, &*hashtest.0.from_hex().unwrap()).unwrap();
+        let res = hash(hashtype, &Vec::from_hex(hashtest.0).unwrap()).unwrap();
         assert_eq!(res.to_hex(), hashtest.1);
     }
 
     fn hash_recycle_test(h: &mut Hasher, hashtest: &(&str, &str)) {
-        let _ = h.write_all(&*hashtest.0.from_hex().unwrap()).unwrap();
+        let _ = h.write_all(&Vec::from_hex(hashtest.0).unwrap()).unwrap();
         let res = h.finish().unwrap();
         assert_eq!(res.to_hex(), hashtest.1);
     }
@@ -258,7 +258,7 @@ mod tests {
     #[test]
     fn test_finish_twice() {
         let mut h = Hasher::new(MessageDigest::md5()).unwrap();
-        h.write_all(&*md5_tests[6].0.from_hex().unwrap()).unwrap();
+        h.write_all(&Vec::from_hex(md5_tests[6].0).unwrap()).unwrap();
         h.finish().unwrap();
         let res = h.finish().unwrap();
         let null = hash(MessageDigest::md5(), &[]).unwrap();
@@ -268,7 +268,7 @@ mod tests {
     #[test]
     fn test_clone() {
         let i = 7;
-        let inp = md5_tests[i].0.from_hex().unwrap();
+        let inp = Vec::from_hex(md5_tests[i].0).unwrap();
         assert!(inp.len() > 2);
         let p = inp.len() / 2;
         let h0 = Hasher::new(MessageDigest::md5()).unwrap();
@@ -289,7 +289,7 @@ mod tests {
 
         println!("Clone a finished hasher");
         let mut h3 = h1.clone();
-        h3.write_all(&*md5_tests[i + 1].0.from_hex().unwrap()).unwrap();
+        h3.write_all(&Vec::from_hex(md5_tests[i + 1].0).unwrap()).unwrap();
         let res = h3.finish().unwrap();
         assert_eq!(res.to_hex(), md5_tests[i + 1].1);
     }
diff --git a/openssl/src/lib.rs b/openssl/src/lib.rs
index a9d937ba..51097733 100644
--- a/openssl/src/lib.rs
+++ b/openssl/src/lib.rs
@@ -8,8 +8,7 @@ extern crate lazy_static;
 extern crate openssl_sys as ffi;
 
 #[cfg(test)]
-extern crate rustc_serialize as serialize;
-
+extern crate hex;
 #[cfg(test)]
 extern crate tempdir;
 
diff --git a/openssl/src/pkcs12.rs b/openssl/src/pkcs12.rs
index 1ef0bf3f..9c224ccd 100644
--- a/openssl/src/pkcs12.rs
+++ b/openssl/src/pkcs12.rs
@@ -66,7 +66,7 @@ pub struct ParsedPkcs12 {
 #[cfg(test)]
 mod test {
     use hash::MessageDigest;
-    use serialize::hex::ToHex;
+    use hex::ToHex;
 
     use super::*;
 
diff --git a/openssl/src/sign.rs b/openssl/src/sign.rs
index 4ca551b6..679a30aa 100644
--- a/openssl/src/sign.rs
+++ b/openssl/src/sign.rs
@@ -205,7 +205,7 @@ unsafe fn EVP_DigestVerifyFinal(ctx: *mut ffi::EVP_MD_CTX,
 
 #[cfg(test)]
 mod test {
-    use serialize::hex::FromHex;
+    use hex::FromHex;
     use std::iter;
 
     use hash::MessageDigest;
@@ -339,27 +339,27 @@ mod test {
         let tests: [(Vec<u8>, Vec<u8>, Vec<u8>); 7] =
             [(iter::repeat(0x0b_u8).take(16).collect(),
               b"Hi There".to_vec(),
-              "9294727a3638bb1c13f48ef8158bfc9d".from_hex().unwrap()),
+              Vec::from_hex("9294727a3638bb1c13f48ef8158bfc9d").unwrap()),
              (b"Jefe".to_vec(),
               b"what do ya want for nothing?".to_vec(),
-              "750c783e6ab0b503eaa86e310a5db738".from_hex().unwrap()),
+              Vec::from_hex("750c783e6ab0b503eaa86e310a5db738").unwrap()),
              (iter::repeat(0xaa_u8).take(16).collect(),
               iter::repeat(0xdd_u8).take(50).collect(),
-              "56be34521d144c88dbb8c733f0e8b3f6".from_hex().unwrap()),
-             ("0102030405060708090a0b0c0d0e0f10111213141516171819".from_hex().unwrap(),
+              Vec::from_hex("56be34521d144c88dbb8c733f0e8b3f6").unwrap()),
+             (Vec::from_hex("0102030405060708090a0b0c0d0e0f10111213141516171819").unwrap(),
               iter::repeat(0xcd_u8).take(50).collect(),
-              "697eaf0aca3a3aea3a75164746ffaa79".from_hex().unwrap()),
+              Vec::from_hex("697eaf0aca3a3aea3a75164746ffaa79").unwrap()),
              (iter::repeat(0x0c_u8).take(16).collect(),
               b"Test With Truncation".to_vec(),
-              "56461ef2342edc00f9bab995690efd4c".from_hex().unwrap()),
+              Vec::from_hex("56461ef2342edc00f9bab995690efd4c").unwrap()),
              (iter::repeat(0xaa_u8).take(80).collect(),
               b"Test Using Larger Than Block-Size Key - Hash Key First".to_vec(),
-              "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd".from_hex().unwrap()),
+              Vec::from_hex("6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd").unwrap()),
              (iter::repeat(0xaa_u8).take(80).collect(),
               b"Test Using Larger Than Block-Size Key \
               and Larger Than One Block-Size Data"
                  .to_vec(),
-              "6f630fad67cda0ee1fb1f562db3aa53e".from_hex().unwrap())];
+              Vec::from_hex("6f630fad67cda0ee1fb1f562db3aa53e").unwrap())];
 
         test_hmac(MessageDigest::md5(), &tests);
     }
@@ -370,27 +370,27 @@ mod test {
         let tests: [(Vec<u8>, Vec<u8>, Vec<u8>); 7] =
             [(iter::repeat(0x0b_u8).take(20).collect(),
               b"Hi There".to_vec(),
-              "b617318655057264e28bc0b6fb378c8ef146be00".from_hex().unwrap()),
+              Vec::from_hex("b617318655057264e28bc0b6fb378c8ef146be00").unwrap()),
              (b"Jefe".to_vec(),
               b"what do ya want for nothing?".to_vec(),
-              "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79".from_hex().unwrap()),
+              Vec::from_hex("effcdf6ae5eb2fa2d27416d5f184df9c259a7c79").unwrap()),
              (iter::repeat(0xaa_u8).take(20).collect(),
               iter::repeat(0xdd_u8).take(50).collect(),
-              "125d7342b9ac11cd91a39af48aa17b4f63f175d3".from_hex().unwrap()),
-             ("0102030405060708090a0b0c0d0e0f10111213141516171819".from_hex().unwrap(),
+              Vec::from_hex("125d7342b9ac11cd91a39af48aa17b4f63f175d3").unwrap()),
+             (Vec::from_hex("0102030405060708090a0b0c0d0e0f10111213141516171819").unwrap(),
               iter::repeat(0xcd_u8).take(50).collect(),
-              "4c9007f4026250c6bc8414f9bf50c86c2d7235da".from_hex().unwrap()),
+              Vec::from_hex("4c9007f4026250c6bc8414f9bf50c86c2d7235da").unwrap()),
              (iter::repeat(0x0c_u8).take(20).collect(),
               b"Test With Truncation".to_vec(),
-              "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04".from_hex().unwrap()),
+              Vec::from_hex("4c1a03424b55e07fe7f27be1d58bb9324a9a5a04").unwrap()),
              (iter::repeat(0xaa_u8).take(80).collect(),
               b"Test Using Larger Than Block-Size Key - Hash Key First".to_vec(),
-              "aa4ae5e15272d00e95705637ce8a3b55ed402112".from_hex().unwrap()),
+              Vec::from_hex("aa4ae5e15272d00e95705637ce8a3b55ed402112").unwrap()),
              (iter::repeat(0xaa_u8).take(80).collect(),
               b"Test Using Larger Than Block-Size Key \
               and Larger Than One Block-Size Data"
                  .to_vec(),
-              "e8e99d0f45237d786d6bbaa7965c7808bbff1a91".from_hex().unwrap())];
+              Vec::from_hex("e8e99d0f45237d786d6bbaa7965c7808bbff1a91").unwrap())];
 
         test_hmac(MessageDigest::sha1(), &tests);
     }
diff --git a/openssl/src/ssl/tests/mod.rs b/openssl/src/ssl/tests/mod.rs
index 146d0806..96c0d585 100644
--- a/openssl/src/ssl/tests/mod.rs
+++ b/openssl/src/ssl/tests/mod.rs
@@ -11,7 +11,6 @@ use std::path::Path;
 use std::process::{Command, Child, Stdio, ChildStdin};
 use std::thread;
 use std::time::Duration;
-
 use tempdir::TempDir;
 
 use hash::MessageDigest;
@@ -170,7 +169,7 @@ macro_rules! run_test(
             use ssl::SSL_VERIFY_PEER;
             use hash::MessageDigest;
             use x509::X509StoreContext;
-            use serialize::hex::FromHex;
+            use hex::FromHex;
             use types::OpenSslTypeRef;
             use super::Server;
 
@@ -302,7 +301,7 @@ run_test!(verify_callback_data, |method, stream| {
 // Command: openssl x509 -in test/cert.pem  -outform DER | openssl dgst -sha256
 // Please update if "test/cert.pem" will ever change
     let node_hash_str = "59172d9313e84459bcff27f967e79e6e9217e584";
-    let node_id = node_hash_str.from_hex().unwrap();
+    let node_id = Vec::from_hex(node_hash_str).unwrap();
     ctx.set_verify_callback(SSL_VERIFY_PEER, move |_preverify_ok, x509_ctx| {
         let cert = x509_ctx.current_cert();
         match cert {
@@ -330,7 +329,7 @@ run_test!(ssl_verify_callback, |method, stream| {
     let mut ssl = Ssl::new(&ctx.build()).unwrap();
 
     let node_hash_str = "59172d9313e84459bcff27f967e79e6e9217e584";
-    let node_id = node_hash_str.from_hex().unwrap();
+    let node_id = Vec::from_hex(node_hash_str).unwrap();
     ssl.set_verify_callback(SSL_VERIFY_PEER, move |_, x509| {
         CHECKED.store(1, Ordering::SeqCst);
         match x509.current_cert() {
@@ -427,7 +426,7 @@ run_test!(get_peer_certificate, |method, stream| {
     let cert = stream.ssl().peer_certificate().unwrap();
     let fingerprint = cert.fingerprint(MessageDigest::sha1()).unwrap();
     let node_hash_str = "59172d9313e84459bcff27f967e79e6e9217e584";
-    let node_id = node_hash_str.from_hex().unwrap();
+    let node_id = Vec::from_hex(node_hash_str).unwrap();
     assert_eq!(node_id, fingerprint)
 });
 
diff --git a/openssl/src/symm.rs b/openssl/src/symm.rs
index 6e9c5796..f94a8d70 100644
--- a/openssl/src/symm.rs
+++ b/openssl/src/symm.rs
@@ -421,7 +421,7 @@ use self::compat::*;
 
 #[cfg(test)]
 mod tests {
-    use serialize::hex::{FromHex, ToHex};
+    use hex::{FromHex, ToHex};
     use super::*;
 
     // Test vectors from FIPS-197:
@@ -489,12 +489,10 @@ mod tests {
     }
 
     fn cipher_test(ciphertype: super::Cipher, pt: &str, ct: &str, key: &str, iv: &str) {
-        use serialize::hex::ToHex;
-
-        let pt = pt.from_hex().unwrap();
-        let ct = ct.from_hex().unwrap();
-        let key = key.from_hex().unwrap();
-        let iv = iv.from_hex().unwrap();
+        let pt = Vec::from_hex(pt).unwrap();
+        let ct = Vec::from_hex(ct).unwrap();
+        let key = Vec::from_hex(key).unwrap();
+        let iv = Vec::from_hex(iv).unwrap();
 
         let computed = super::decrypt(ciphertype, &key, Some(&iv), &ct).unwrap();
         let expected = pt;
@@ -662,21 +660,21 @@ mod tests {
         // the NIST test vectors that cover 4 byte tags.
         let mut actual_tag = [0; 4];
         let out = encrypt_aead(Cipher::aes_128_gcm(),
-                               &key.from_hex().unwrap(),
-                               Some(&iv.from_hex().unwrap()),
-                               &aad.from_hex().unwrap(),
-                               &pt.from_hex().unwrap(),
+                               &Vec::from_hex(key).unwrap(),
+                               Some(&Vec::from_hex(iv).unwrap()),
+                               &Vec::from_hex(aad).unwrap(),
+                               &Vec::from_hex(pt).unwrap(),
                                &mut actual_tag)
             .unwrap();
         assert_eq!(ct, out.to_hex());
         assert_eq!(tag, actual_tag.to_hex());
 
         let out = decrypt_aead(Cipher::aes_128_gcm(),
-                               &key.from_hex().unwrap(),
-                               Some(&iv.from_hex().unwrap()),
-                               &aad.from_hex().unwrap(),
-                               &ct.from_hex().unwrap(),
-                               &tag.from_hex().unwrap()).unwrap();
+                               &Vec::from_hex(key).unwrap(),
+                               Some(&Vec::from_hex(iv).unwrap()),
+                               &Vec::from_hex(aad).unwrap(),
+                               &Vec::from_hex(ct).unwrap(),
+                               &Vec::from_hex(tag).unwrap()).unwrap();
         assert_eq!(pt, out.to_hex());
     }
 }
diff --git a/openssl/src/x509/tests.rs b/openssl/src/x509/tests.rs
index 2527d538..16ad661d 100644
--- a/openssl/src/x509/tests.rs
+++ b/openssl/src/x509/tests.rs
@@ -1,4 +1,4 @@
-use serialize::hex::FromHex;
+use hex::FromHex;
 
 use hash::MessageDigest;
 use pkey::PKey;
@@ -85,7 +85,7 @@ fn test_cert_loading() {
     let fingerprint = cert.fingerprint(MessageDigest::sha1()).unwrap();
 
     let hash_str = "59172d9313e84459bcff27f967e79e6e9217e584";
-    let hash_vec = hash_str.from_hex().unwrap();
+    let hash_vec = Vec::from_hex(hash_str).unwrap();
 
     assert_eq!(fingerprint, hash_vec);
 }