vendor/crypto-bigint/src/checked.rs

   1 //! Checked arithmetic.
   2
   3 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption};
   4
   5 #[cfg(feature = "serde")]
   6 use serdect::serde::{Deserialize, Deserializer, Serialize, Serializer};
   7
   8 /// Provides intentionally-checked arithmetic on `T`.
   9 ///
  10 /// Internally this leverages the [`CtOption`] type from the [`subtle`] crate
  11 /// in order to handle overflows in constant time.
  12 #[derive(Copy, Clone, Debug)]
  13 pub struct Checked<T>(pub CtOption<T>);
  14
  15 impl<T> Checked<T> {
  16     /// Create a new checked arithmetic wrapper for the given value.
  17     pub fn new(val: T) -> Self {
  18         Self(CtOption::new(val, Choice::from(1)))
  19     }
  20 }
  21
  22 impl<T> Default for Checked<T>
  23 where
  24     T: Default,
  25 {
  26     fn default() -> Self {
  27         Self::new(T::default())
  28     }
  29 }
  30
  31 impl<T: ConditionallySelectable> ConditionallySelectable for Checked<T> {
  32     #[inline]
  33     fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self {
  34         Self(CtOption::conditional_select(&a.0, &b.0, choice))
  35     }
  36 }
  37
  38 impl<T: ConstantTimeEq> ConstantTimeEq for Checked<T> {
  39     #[inline]
  40     fn ct_eq(&self, rhs: &Self) -> Choice {
  41         self.0.ct_eq(&rhs.0)
  42     }
  43 }
  44
  45 impl<T> From<Checked<T>> for CtOption<T> {
  46     fn from(checked: Checked<T>) -> CtOption<T> {
  47         checked.0
  48     }
  49 }
  50
  51 impl<T> From<CtOption<T>> for Checked<T> {
  52     fn from(ct_option: CtOption<T>) -> Checked<T> {
  53         Checked(ct_option)
  54     }
  55 }
  56
  57 impl<T> From<Checked<T>> for Option<T> {
  58     fn from(checked: Checked<T>) -> Option<T> {
  59         checked.0.into()
  60     }
  61 }
  62
  63 #[cfg(feature = "serde")]
  64 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
  65 impl<'de, T: Default + Deserialize<'de>> Deserialize<'de> for Checked<T> {
  66     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  67     where
  68         D: Deserializer<'de>,
  69     {
  70         let value = Option::<T>::deserialize(deserializer)?;
  71         let choice = Choice::from(value.is_some() as u8);
  72         Ok(Self(CtOption::new(value.unwrap_or_default(), choice)))
  73     }
  74 }
  75
  76 #[cfg(feature = "serde")]
  77 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
  78 impl<'de, T: Copy + Serialize> Serialize for Checked<T> {
  79     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  80     where
  81         S: Serializer,
  82     {
  83         Option::<T>::from(self.0).serialize(serializer)
  84     }
  85 }
  86
  87 #[cfg(all(test, feature = "serde"))]
  88 mod tests {
  89     use crate::{Checked, U64};
  90     use subtle::{Choice, ConstantTimeEq, CtOption};
  91
  92     #[test]
  93     fn serde() {
  94         let test = Checked::new(U64::from_u64(0x0011223344556677));
  95
  96         let serialized = bincode::serialize(&test).unwrap();
  97         let deserialized: Checked<U64> = bincode::deserialize(&serialized).unwrap();
  98
  99         assert!(bool::from(test.ct_eq(&deserialized)));
 100
 101         let test = Checked::new(U64::ZERO) - Checked::new(U64::ONE);
 102         assert!(bool::from(
 103             test.ct_eq(&Checked(CtOption::new(U64::ZERO, Choice::from(0))))
 104         ));
 105
 106         let serialized = bincode::serialize(&test).unwrap();
 107         let deserialized: Checked<U64> = bincode::deserialize(&serialized).unwrap();
 108
 109         assert!(bool::from(test.ct_eq(&deserialized)));
 110     }
 111
 112     #[test]
 113     fn serde_owned() {
 114         let test = Checked::new(U64::from_u64(0x0011223344556677));
 115
 116         let serialized = bincode::serialize(&test).unwrap();
 117         let deserialized: Checked<U64> = bincode::deserialize_from(serialized.as_slice()).unwrap();
 118
 119         assert!(bool::from(test.ct_eq(&deserialized)));
 120
 121         let test = Checked::new(U64::ZERO) - Checked::new(U64::ONE);
 122         assert!(bool::from(
 123             test.ct_eq(&Checked(CtOption::new(U64::ZERO, Choice::from(0))))
 124         ));
 125
 126         let serialized = bincode::serialize(&test).unwrap();
 127         let deserialized: Checked<U64> = bincode::deserialize_from(serialized.as_slice()).unwrap();
 128
 129         assert!(bool::from(test.ct_eq(&deserialized)));
 130     }
 131 }