fix!: zeroize temporary scalar value

src/extended_range_proof.rs

@@ -4,6 +4,7 @@
 //! Extended range proofs
 
 use std::{string::ToString, vec::Vec};
+use zeroize::Zeroize;
 
 use crate::{
     commitment::{ExtensionDegree, HomomorphicCommitment},
@@ -99,13 +100,19 @@ pub trait ExtendedRangeProofService {
 
 /// Extended blinding factor vector used as part of the witness to construct an extended proof, or rewind data
 /// extracted from a range proof containing the mask (e.g. blinding factor vector).
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Zeroize)]
 pub struct ExtendedMask<K>
 where K: SecretKey
 {
     secrets: Vec<K>,
 }
 
+impl<K:SecretKey> Drop for ExtendedMask<K>{
+    fn drop(&mut self) {
+        self.secrets.zeroize();
+    }
+}
+
 impl<K> ExtendedMask<K>
 where K: SecretKey
 {
@@ -200,7 +207,7 @@ where PK: PublicKey
 
 /// The extended witness contains the extended mask (blinding factor vector), value and a minimum value
 /// promise; this will be used to construct the extended range proof
-#[derive(Clone)]
+#[derive(Clone, Zeroize)]
 pub struct ExtendedWitness<K>
 where K: SecretKey
 {
@@ -212,6 +219,14 @@ where K: SecretKey
     pub minimum_value_promise: u64,
 }
 
+impl<K: SecretKey> Drop for ExtendedWitness<K>{
+    fn drop(&mut self) {
+        self.mask.zeroize();
+        self.value.zeroize();
+        self.minimum_value_promise.zeroize();
+    }
+}
+
 impl<K> ExtendedWitness<K>
 where K: SecretKey
 {

src/ristretto/pedersen/extended_commitment_factory.rs

@@ -4,13 +4,14 @@
 //! Extended commitments are commitments that have more than one blinding factor.
 
 use alloc::vec::Vec;
-use core::{borrow::Borrow, iter::once};
+use core::{iter::once};
 
 use curve25519_dalek::{
     ristretto::{CompressedRistretto, RistrettoPoint},
     scalar::Scalar,
     traits::{Identity, MultiscalarMul},
 };
+use zeroize::Zeroizing;
 
 #[cfg(feature = "precomputed_tables")]
 use crate::ristretto::pedersen::scalar_mul_with_pre_computation_tables;
@@ -84,13 +85,11 @@ impl ExtendedPedersenCommitmentFactory {
     }
 
     /// Creates a Pedersen commitment using the value scalar and a blinding factor vector
-    pub fn commit_scalars(
+    fn commit_scalars(
         &self,
         value: &Scalar,
         blinding_factors: &[Scalar],
     ) -> Result<RistrettoPoint, CommitmentError>
-    where
-        for<'a> &'a Scalar: Borrow<Scalar>,
     {
         if blinding_factors.is_empty() || blinding_factors.len() > self.extension_degree as usize {
             Err(CommitmentError::CommitmentExtensionDegree {
@@ -166,7 +165,7 @@ impl ExtendedHomomorphicCommitmentFactory for ExtendedPedersenCommitmentFactory
         k_vec: &[RistrettoSecretKey],
         v: &RistrettoSecretKey,
     ) -> Result<PedersenCommitment, CommitmentError> {
-        let blinding_factors: Vec<Scalar> = k_vec.iter().map(|k| k.0).collect();
+        let blinding_factors: Zeroizing<Vec<Scalar>> = Zeroizing::new(k_vec.iter().map(|k| k.0).collect());
         let c = self.commit_scalars(&v.0, &blinding_factors)?;
         Ok(HomomorphicCommitment(RistrettoPublicKey::new_from_pk(c)))
     }

src/ristretto/ristretto_keys.rs

@@ -65,9 +65,19 @@ impl borsh::BorshSerialize for RistrettoSecretKey {
 impl borsh::BorshDeserialize for RistrettoSecretKey {
     fn deserialize_reader<R>(reader: &mut R) -> Result<Self, borsh::maybestd::io::Error>
     where R: borsh::maybestd::io::Read {
-        let bytes: Vec<u8> = borsh::BorshDeserialize::deserialize_reader(reader)?;
-        Self::from_canonical_bytes(bytes.as_slice())
+        let mut bytes: Vec<u8> = borsh::BorshDeserialize::deserialize_reader(reader)?;
+        match Self::from_canonical_bytes(bytes.as_slice())
             .map_err(|e| borsh::maybestd::io::Error::new(borsh::maybestd::io::ErrorKind::InvalidInput, e.to_string()))
+        {
+            Ok(k) => {
+                bytes.zeroize();
+                Ok(k)
+            },
+            Err(e) => {
+                bytes.zeroize();
+                Err(e)
+            },
+        }
     }
 }
 
@@ -234,12 +244,6 @@ impl From<u64> for RistrettoSecretKey {
     }
 }
 
-impl From<Scalar> for RistrettoSecretKey {
-    fn from(s: Scalar) -> Self {
-        RistrettoSecretKey(s)
-    }
-}
-
 //---------------------------------------------      Borrow impl     -------------------------------------------------//
 
 impl<'a> Borrow<Scalar> for &'a RistrettoSecretKey {