diff --git a/rust/bssl-crypto/src/digest.rs b/rust/bssl-crypto/src/digest.rs
index 125f427..59d3b2a 100644
--- a/rust/bssl-crypto/src/digest.rs
+++ b/rust/bssl-crypto/src/digest.rs
@@ -62,7 +62,7 @@
     fn update(&mut self, input: &[u8]);
 
     /// Finish the hashing and return the digest.
-    fn digest_to_vec(mut self) -> Vec<u8>;
+    fn digest_to_vec(self) -> Vec<u8>;
 }
 
 /// Trait parameterized by the size of the output of the digest
@@ -70,7 +70,7 @@
 /// this parameter.
 pub trait WithOutputLength<const OUTPUT_LEN: usize> {
     /// Finish the hashing and return the digest.
-    fn digest(mut self) -> [u8; OUTPUT_LEN];
+    fn digest(self) -> [u8; OUTPUT_LEN];
 }
 
 /// The insecure SHA-1 hash algorithm.
diff --git a/rust/bssl-crypto/src/macros.rs b/rust/bssl-crypto/src/macros.rs
index 0d49646..c9e6698 100644
--- a/rust/bssl-crypto/src/macros.rs
+++ b/rust/bssl-crypto/src/macros.rs
@@ -59,7 +59,7 @@
             }
 
             /// Finish the hashing and return the digest.
-            fn digest_to_vec(mut self) -> alloc::vec::Vec<u8> {
+            fn digest_to_vec(self) -> alloc::vec::Vec<u8> {
                 WithOutputLength::<$output_len>::digest(self).to_vec()
             }
         }
