Replace ConstantTimeEq with CtEq in trait bounds

Changes all of the traits in `traits.rs`, most notably the `Integer`,
`Zero`, and `One` traits, to use `ctutils::CtEq` instead of
`subtle::ConstantTimeEq`, as part of a larger overall migration to
`ctutils` (see also #1040, #1043)

Author: tarcieri

Cargo.lock

@@ -86,3 +86,6 @@ harness = false
 
 [profile.dev]
 opt-level = 2
+
+[patch.crates-io.ctutils]
+path = "../utils/ctutils"

Cargo.toml

@@ -1,6 +1,6 @@
 //! Checked arithmetic.
 
-use crate::{CheckedAdd, CheckedDiv, CheckedMul, CheckedSub};
+use crate::{CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, ConstChoice, CtEq, CtSelect};
 use core::ops::{Add, Div, Mul, Sub};
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption};
 
@@ -268,13 +268,36 @@ impl<T: ConditionallySelectable> ConditionallySelectable for Checked<T> {
     }
 }
 
-impl<T: ConstantTimeEq> ConstantTimeEq for Checked<T> {
+impl<T> ConstantTimeEq for Checked<T>
+where
+    T: ConstantTimeEq,
+{
     #[inline]
     fn ct_eq(&self, rhs: &Self) -> Choice {
         self.0.ct_eq(&rhs.0)
     }
 }
 
+impl<T> CtEq for Checked<T>
+where
+    Self: ConstantTimeEq,
+{
+    #[inline]
+    fn ct_eq(&self, other: &Self) -> ConstChoice {
+        ConstantTimeEq::ct_eq(self, &other).into()
+    }
+}
+
+impl<T> CtSelect for Checked<T>
+where
+    Self: ConditionallySelectable,
+{
+    #[inline]
+    fn ct_select(&self, other: &Self, choice: ConstChoice) -> Self {
+        Self::conditional_select(self, other, choice.into())
+    }
+}
+
 impl<T> Default for Checked<T>
 where
     T: Default,

src/checked.rs

@@ -2,11 +2,9 @@
 //!
 //! By default, these are all constant-time.
 
+use crate::{ConstChoice, CtEq, Int, Uint};
 use core::cmp::Ordering;
-
-use subtle::{Choice, ConstantTimeEq, ConstantTimeGreater, ConstantTimeLess};
-
-use crate::{ConstChoice, Int, Uint};
+use subtle::{Choice, ConstantTimeGreater, ConstantTimeLess};
 
 impl<const LIMBS: usize> Int<LIMBS> {
     /// Return `b` if `c` is truthy, otherwise return `a`.
@@ -61,10 +59,17 @@ impl<const LIMBS: usize> Int<LIMBS> {
     }
 }
 
-impl<const LIMBS: usize> ConstantTimeEq for Int<LIMBS> {
+impl<const LIMBS: usize> CtEq for Int<LIMBS> {
+    #[inline]
+    fn ct_eq(&self, other: &Self) -> ConstChoice {
+        CtEq::ct_eq(&self.0, &other.0)
+    }
+}
+
+impl<const LIMBS: usize> subtle::ConstantTimeEq for Int<LIMBS> {
     #[inline]
     fn ct_eq(&self, other: &Self) -> Choice {
-        Int::eq(self, other).into()
+        CtEq::ct_eq(self, other).into()
     }
 }
 

src/int/cmp.rs

@@ -193,7 +193,7 @@ pub use crate::{
 };
 
 // TODO(tarcieri): get rid of `Const*` prefix
-pub use ctutils::{Choice as ConstChoice, CtOption as ConstCtOption, CtSelect};
+pub use ctutils::{Choice as ConstChoice, CtEq, CtOption as ConstCtOption, CtSelect};
 
 #[cfg(feature = "alloc")]
 pub use crate::uint::boxed::BoxedUint;

src/lib.rs

@@ -20,12 +20,12 @@ mod sub;
 mod rand;
 
 use crate::{
-    Bounded, ConstChoice, ConstCtOption, ConstOne, ConstZero, Constants, NonZero, One, WideWord,
-    Word, Zero,
+    Bounded, ConstChoice, ConstCtOption, ConstOne, ConstZero, Constants, CtEq, NonZero, One,
+    WideWord, Word, Zero,
 };
 use core::fmt;
 use ctutils::CtSelect;
-use subtle::{Choice, ConstantTimeEq};
+use subtle::Choice;
 
 #[cfg(feature = "serde")]
 use serdect::serde::{Deserialize, Deserializer, Serialize, Serializer};

src/limb.rs

@@ -83,7 +83,7 @@ impl CheckedAdd for Limb {
     #[inline]
     fn checked_add(&self, rhs: &Self) -> CtOption<Self> {
         let (result, carry) = self.overflowing_add(*rhs);
-        CtOption::new(result, carry.is_zero())
+        CtOption::new(result, carry.is_zero().into())
     }
 }
 

src/limb/add.rs

@@ -1,10 +1,8 @@
 //! Limb comparisons
 
-use crate::{ConstChoice, Limb, word};
+use crate::{ConstChoice, CtEq, Limb, word};
 use core::cmp::Ordering;
-use subtle::{
-    Choice, ConditionallySelectable, ConstantTimeEq, ConstantTimeGreater, ConstantTimeLess,
-};
+use subtle::{Choice, ConditionallySelectable, ConstantTimeGreater, ConstantTimeLess};
 
 impl Limb {
     /// Is this limb an odd number?
@@ -48,15 +46,27 @@ impl Limb {
     }
 }
 
-impl ConstantTimeEq for Limb {
+impl CtEq for Limb {
+    #[inline]
+    fn ct_eq(&self, other: &Self) -> ConstChoice {
+        CtEq::ct_eq(&self.0, &other.0)
+    }
+
+    #[inline]
+    fn ct_ne(&self, other: &Self) -> ConstChoice {
+        CtEq::ct_ne(&self.0, &other.0)
+    }
+}
+
+impl subtle::ConstantTimeEq for Limb {
     #[inline]
     fn ct_eq(&self, other: &Self) -> Choice {
-        self.0.ct_eq(&other.0)
+        CtEq::ct_eq(self, other).into()
     }
 
     #[inline]
     fn ct_ne(&self, other: &Self) -> Choice {
-        self.0.ct_ne(&other.0)
+        CtEq::ct_ne(self, other).into()
     }
 }
 
@@ -79,7 +89,7 @@ impl Eq for Limb {}
 impl Ord for Limb {
     fn cmp(&self, other: &Self) -> Ordering {
         let mut ret = Ordering::Less;
-        ret.conditional_assign(&Ordering::Equal, self.ct_eq(other));
+        ret.conditional_assign(&Ordering::Equal, self.ct_eq(other).into());
         ret.conditional_assign(&Ordering::Greater, self.ct_gt(other));
         debug_assert_eq!(ret == Ordering::Less, bool::from(self.ct_lt(other)));
         ret

src/limb/cmp.rs

@@ -48,7 +48,7 @@ impl CheckedMul for Limb {
     #[inline]
     fn checked_mul(&self, rhs: &Self) -> CtOption<Self> {
         let (lo, hi) = self.widening_mul(*rhs);
-        CtOption::new(lo, hi.is_zero())
+        CtOption::new(lo, hi.is_zero().into())
     }
 }
 

src/limb/mul.rs

@@ -36,7 +36,7 @@ impl CheckedSub for Limb {
     #[inline]
     fn checked_sub(&self, rhs: &Self) -> CtOption<Self> {
         let (result, underflow) = self.borrowing_sub(*rhs, Limb::ZERO);
-        CtOption::new(result, underflow.is_zero())
+        CtOption::new(result, underflow.is_zero().into())
     }
 }