ctutils: enhanced subtle interop

.github/workflows/ctutils.yml

@@ -64,6 +64,7 @@ jobs:
         with:
           toolchain: ${{ matrix.rust }}
       - run: cargo test
+      - run: cargo test --features subtle
       - run: cargo test --all-features
       - run: cargo test --all-features --release
 

ctutils/src/choice.rs

@@ -410,6 +410,15 @@ impl From<Choice> for bool {
     }
 }
 
+impl Not for Choice {
+    type Output = Choice;
+
+    #[inline]
+    fn not(self) -> Choice {
+        self.not()
+    }
+}
+
 #[cfg(feature = "subtle")]
 impl From<subtle::Choice> for Choice {
     #[inline]
@@ -426,12 +435,19 @@ impl From<Choice> for subtle::Choice {
     }
 }
 
-impl Not for Choice {
-    type Output = Choice;
+#[cfg(feature = "subtle")]
+impl subtle::ConditionallySelectable for Choice {
+    #[inline]
+    fn conditional_select(a: &Self, b: &Self, choice: subtle::Choice) -> Self {
+        CtSelect::ct_select(a, b, choice.into())
+    }
+}
 
+#[cfg(feature = "subtle")]
+impl subtle::ConstantTimeEq for Choice {
     #[inline]
-    fn not(self) -> Choice {
-        self.not()
+    fn ct_eq(&self, other: &Self) -> subtle::Choice {
+        CtEq::ct_eq(self, other).into()
     }
 }
 

ctutils/src/ct_option.rs

@@ -576,6 +576,29 @@ impl<T> From<CtOption<T>> for subtle::CtOption<T> {
     }
 }
 
+#[cfg(feature = "subtle")]
+impl<T> subtle::ConditionallySelectable for CtOption<T>
+where
+    T: Copy, // `ConditionallySelectable` supertrait bound
+    Self: CtSelect,
+{
+    #[inline]
+    fn conditional_select(a: &Self, b: &Self, choice: subtle::Choice) -> Self {
+        CtSelect::ct_select(a, b, choice.into())
+    }
+}
+
+#[cfg(feature = "subtle")]
+impl<T> subtle::ConstantTimeEq for CtOption<T>
+where
+    Self: CtEq,
+{
+    #[inline]
+    fn ct_eq(&self, other: &Self) -> subtle::Choice {
+        CtEq::ct_eq(self, other).into()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{Choice, CtEq, CtOption, CtSelect};

ctutils/src/traits/ct_eq.rs

@@ -2,6 +2,9 @@ use crate::Choice;
 use cmov::CmovEq;
 use core::cmp;
 
+#[cfg(feature = "subtle")]
+use crate::CtOption;
+
 /// Constant-time equality: like `(Partial)Eq` with [`Choice`] instead of [`bool`].
 ///
 /// Impl'd for: [`u8`], [`u16`], [`u32`], [`u64`], [`u128`], [`usize`], [`cmp::Ordering`],
@@ -89,6 +92,25 @@ impl<T: CtEq, const N: usize> CtEq for [T; N] {
     }
 }
 
+#[cfg(feature = "subtle")]
+impl CtEq for subtle::Choice {
+    #[inline]
+    fn ct_eq(&self, other: &Self) -> Choice {
+        self.unwrap_u8().ct_eq(&other.unwrap_u8())
+    }
+}
+
+#[cfg(feature = "subtle")]
+impl<T> CtEq for subtle::CtOption<T>
+where
+    T: CtEq + Default + subtle::ConditionallySelectable,
+{
+    #[inline]
+    fn ct_eq(&self, other: &Self) -> Choice {
+        CtOption::from(*self).ct_eq(&CtOption::from(*other))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::CtEq;

ctutils/src/traits/ct_select.rs

@@ -2,6 +2,9 @@ use crate::Choice;
 use cmov::Cmov;
 use core::cmp;
 
+#[cfg(feature = "subtle")]
+use crate::CtOption;
+
 /// Constant-time selection: pick between two values based on a given [`Choice`].
 pub trait CtSelect: Sized {
     /// Select between `self` and `other` based on `choice`, returning a copy of the value.
@@ -114,6 +117,29 @@ where
     }
 }
 
+#[cfg(feature = "subtle")]
+impl CtSelect for subtle::Choice {
+    #[inline]
+    fn ct_select(&self, other: &Self, choice: Choice) -> Self {
+        Choice::from(*self)
+            .ct_select(&Choice::from(*other), choice)
+            .into()
+    }
+}
+
+#[cfg(feature = "subtle")]
+impl<T> CtSelect for subtle::CtOption<T>
+where
+    T: CtSelect + Default + subtle::ConditionallySelectable,
+{
+    #[inline]
+    fn ct_select(&self, other: &Self, choice: Choice) -> Self {
+        CtOption::from(*self)
+            .ct_select(&CtOption::from(*other), choice)
+            .into()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::{Choice, CtSelect, cmp};