diff --git a/src/buf/byte.rs b/src/buf/byte.rs
index 106f574351d67e91e6d38283506cef029f576fef..e2993e3185d988f6cb2d1fa4661c9cacaab80ac1 100644
--- a/src/buf/byte.rs
+++ b/src/buf/byte.rs
@@ -321,7 +321,7 @@ impl MutBuf for MutByteBuf {
         self.buf.advance(cnt)
     }
 
-    fn mut_bytes<'a>(&'a mut self) -> &'a mut [u8] {
+    unsafe fn mut_bytes<'a>(&'a mut self) -> &'a mut [u8] {
         let pos = self.buf.pos();
         let lim = self.buf.lim();
         &mut self.buf.mem.bytes_mut()[pos..lim]
diff --git a/src/buf/mod.rs b/src/buf/mod.rs
index 07de5f8b772237fb882e1fcd9662152171df6510..2eab003762d27245ae85b3357445cb88e704624e 100644
--- a/src/buf/mod.rs
+++ b/src/buf/mod.rs
@@ -102,7 +102,9 @@ pub trait MutBuf : Sized {
 
     /// Returns a mutable slice starting at the current MutBuf position and of
     /// length between 0 and `MutBuf::remaining()`.
-    fn mut_bytes<'a>(&'a mut self) -> &'a mut [u8];
+    ///
+    /// The returned byte slice may represent uninitialized memory.
+    unsafe fn mut_bytes<'a>(&'a mut self) -> &'a mut [u8];
 
     /// Write bytes from the given slice into the `MutBuf` and advance the
     /// cursor by the number of bytes written.
@@ -268,7 +270,7 @@ impl<'a, R: io::Read+'a> Source for &'a mut R {
         let mut cnt = 0;
 
         while buf.has_remaining() {
-            let i = try!(self.read(buf.mut_bytes()));
+            let i = try!(self.read(unsafe { buf.mut_bytes() }));
 
             if i == 0 {
                 break;
@@ -349,7 +351,7 @@ impl MutBuf for Vec<u8> {
         }
     }
 
-    fn mut_bytes(&mut self) -> &mut [u8] {
+    unsafe fn mut_bytes(&mut self) -> &mut [u8] {
         use std::slice;
 
         if self.capacity() == self.len() {
@@ -359,10 +361,8 @@ impl MutBuf for Vec<u8> {
         let cap = self.capacity();
         let len = self.len();
 
-        unsafe {
-            let ptr = self.as_mut_ptr();
-            &mut slice::from_raw_parts_mut(ptr, cap)[len..]
-        }
+        let ptr = self.as_mut_ptr();
+        &mut slice::from_raw_parts_mut(ptr, cap)[len..]
     }
 }
 
diff --git a/src/buf/ring.rs b/src/buf/ring.rs
index a422093f4a25231e0a87ad37e56242e9a689c2ee..926d05420e6e5649be523d2de85ac3286e7c1a7e 100644
--- a/src/buf/ring.rs
+++ b/src/buf/ring.rs
@@ -196,7 +196,7 @@ impl MutBuf for RingBuf {
         self.advance_writer(cnt)
     }
 
-    fn mut_bytes(&mut self) -> &mut [u8] {
+    unsafe fn mut_bytes(&mut self) -> &mut [u8] {
         if self.cap == 0 {
             return self.ptr.bytes_mut();
         }
diff --git a/src/buf/slice.rs b/src/buf/slice.rs
index eaa2cf3ebe9b6f998c8ebc8548cd30941f2631cd..fb117ff05bad85a1f55de5c9ac971e42bb827642 100644
--- a/src/buf/slice.rs
+++ b/src/buf/slice.rs
@@ -53,7 +53,7 @@ impl<'a> MutBuf for MutSliceBuf<'a> {
         self.pos += cnt;
     }
 
-    fn mut_bytes<'b>(&'b mut self) -> &'b mut [u8] {
+    unsafe fn mut_bytes<'b>(&'b mut self) -> &'b mut [u8] {
         &mut self.bytes[self.pos..]
     }
 }
diff --git a/src/str/bytes.rs b/src/str/bytes.rs
index a0bef44a6b7e345002e52a22df450111dec02e0f..42e1756105fe6fb76279ae0638516e34a30a2a78 100644
--- a/src/str/bytes.rs
+++ b/src/str/bytes.rs
@@ -208,17 +208,15 @@ impl<'a> Source for &'a Bytes {
         while src.has_remaining() && dst.has_remaining() {
             let l;
 
-            {
+            unsafe {
                 let s = src.bytes();
                 let d = dst.mut_bytes();
                 l = cmp::min(s.len(), d.len());
 
-                unsafe {
-                    ptr::copy_nonoverlapping(
-                        s.as_ptr(),
-                        d.as_mut_ptr(),
-                        l);
-                }
+                ptr::copy_nonoverlapping(
+                    s.as_ptr(),
+                    d.as_mut_ptr(),
+                    l);
             }
 
             src.advance(l);
diff --git a/test/test_buf.rs b/test/test_buf.rs
index 93689ac020b608a11b60d01ad36436fa7860deda..592bc0d53740a14aad5857f9de4ef895346fbc69 100644
--- a/test/test_buf.rs
+++ b/test/test_buf.rs
@@ -30,7 +30,10 @@ pub fn test_vec_as_mut_buf() {
     let mut buf = vec![];
 
     assert_eq!(buf.remaining(), usize::MAX);
-    assert_eq!(buf.mut_bytes().len(), 64);
+
+    unsafe {
+        assert_eq!(buf.mut_bytes().len(), 64);
+    }
 
     buf.write(&b"zomg"[..]).unwrap();