diff --git a/src/field.rs b/src/field.rs
index cad3145..05b4960 100644
--- a/src/field.rs
+++ b/src/field.rs
@@ -64,9 +64,10 @@ const EXP_TABLE: [u8; 512] = [
     0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01, 0x02,
 ];
 
-#[derive(Debug, PartialEq, Copy, Clone)]
+#[derive(Debug, PartialEq, Clone)]
 #[cfg_attr(feature = "fuzzing", derive(Arbitrary))]
 #[cfg_attr(feature = "zeroize_memory", derive(Zeroize))]
+#[cfg_attr(feature = "zeroize_memory", zeroize(drop))]
 pub struct GF256(pub u8);
 
 #[allow(clippy::suspicious_arithmetic_impl)]
diff --git a/src/lib.rs b/src/lib.rs
index e32f44e..b76467c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -201,7 +201,7 @@ mod tests {
         let sharks = Sharks(255);
         let mut shares: Vec<Share> = sharks.make_shares(&[1]).take(255).collect();
         shares[1] = Share {
-            x: shares[0].x,
+            x: shares[0].x.clone(),
             y: shares[0].y.clone(),
         };
         let secret = sharks.recover(&shares);
diff --git a/src/math.rs b/src/math.rs
index 7279018..2151033 100644
--- a/src/math.rs
+++ b/src/math.rs
@@ -20,9 +20,9 @@ pub fn interpolate(shares: &[Share]) -> Vec<u8> {
                     shares
                         .iter()
                         .filter(|s_j| s_j.x != s_i.x)
-                        .map(|s_j| s_j.x / (s_j.x - s_i.x))
+                        .map(|s_j| s_j.x.clone() / (s_j.x.clone() - s_i.x.clone()))
                         .product::<GF256>()
-                        * s_i.y[s]
+                        * s_i.y[s].clone()
                 })
                 .sum::<GF256>()
                 .0
@@ -51,10 +51,13 @@ pub fn random_polynomial<R: rand::Rng>(s: GF256, k: u8, rng: &mut R) -> Vec<GF25
 // The iterator will start at `x = 1` and end at `x = 255`.
 pub fn get_evaluator(polys: Vec<Vec<GF256>>) -> impl Iterator<Item = Share> {
     (1..=u8::max_value()).map(GF256).map(move |x| Share {
-        x,
+        x: x.clone(),
         y: polys
             .iter()
-            .map(|p| p.iter().fold(GF256(0), |acc, c| acc * x + *c))
+            .map(|p| {
+                p.iter()
+                    .fold(GF256(0), |acc, c| acc * x.clone() + c.clone())
+            })
             .collect(),
     })
 }