Trait ConditionallySelectable 

pub trait ConditionallySelectable: Copy {
    // Required method
    fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self;

    // Provided methods
    fn conditional_assign(&mut self, other: &Self, choice: Choice) { ... }
    fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice) { ... }
}

A type which can be conditionally selected in constant time.

This trait also provides generic implementations of conditional assignment and conditional swaps.

Required Methods

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

Returns

• a if choice == Choice(0);
• b if choice == Choice(1).

This function should execute in constant time.

Example

use subtle::ConditionallySelectable;
let x: u8 = 13;
let y: u8 = 42;

let z = u8::conditional_select(&x, &y, 0.into());
assert_eq!(z, x);
let z = u8::conditional_select(&x, &y, 1.into());
assert_eq!(z, y);

Provided Methods

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

This function should execute in constant time.

Example

use subtle::ConditionallySelectable;
let mut x: u8 = 13;
let mut y: u8 = 42;

x.conditional_assign(&y, 0.into());
assert_eq!(x, 13);
x.conditional_assign(&y, 1.into());
assert_eq!(x, 42);

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

This function should execute in constant time.

Example

use subtle::ConditionallySelectable;
let mut x: u8 = 13;
let mut y: u8 = 42;

u8::conditional_swap(&mut x, &mut y, 0.into());
assert_eq!(x, 13);
assert_eq!(y, 42);
u8::conditional_swap(&mut x, &mut y, 1.into());
assert_eq!(x, 42);
assert_eq!(y, 13);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl ConditionallySelectable for Ordering

Ordering is #[repr(i8)] where:

• Less => -1
• Equal => 0
• Greater => 1

Given this, it’s possible to operate on orderings as if they’re integers, which allows leveraging conditional masking for predication.

fn conditional_select(a: &Ordering, b: &Ordering, choice: Choice) -> Ordering

impl ConditionallySelectable for i8

fn conditional_select(a: &i8, b: &i8, choice: Choice) -> i8

fn conditional_assign(&mut self, other: &i8, choice: Choice)

fn conditional_swap(a: &mut i8, b: &mut i8, choice: Choice)

impl ConditionallySelectable for i16

fn conditional_select(a: &i16, b: &i16, choice: Choice) -> i16

fn conditional_assign(&mut self, other: &i16, choice: Choice)

fn conditional_swap(a: &mut i16, b: &mut i16, choice: Choice)

impl ConditionallySelectable for i32

fn conditional_select(a: &i32, b: &i32, choice: Choice) -> i32

fn conditional_assign(&mut self, other: &i32, choice: Choice)

fn conditional_swap(a: &mut i32, b: &mut i32, choice: Choice)

impl ConditionallySelectable for i64

fn conditional_select(a: &i64, b: &i64, choice: Choice) -> i64

fn conditional_assign(&mut self, other: &i64, choice: Choice)

fn conditional_swap(a: &mut i64, b: &mut i64, choice: Choice)

impl ConditionallySelectable for i128

fn conditional_select(a: &i128, b: &i128, choice: Choice) -> i128

fn conditional_assign(&mut self, other: &i128, choice: Choice)

fn conditional_swap(a: &mut i128, b: &mut i128, choice: Choice)

impl ConditionallySelectable for u8

fn conditional_select(a: &u8, b: &u8, choice: Choice) -> u8

fn conditional_assign(&mut self, other: &u8, choice: Choice)

fn conditional_swap(a: &mut u8, b: &mut u8, choice: Choice)

impl ConditionallySelectable for u16

fn conditional_select(a: &u16, b: &u16, choice: Choice) -> u16

fn conditional_assign(&mut self, other: &u16, choice: Choice)

fn conditional_swap(a: &mut u16, b: &mut u16, choice: Choice)

impl ConditionallySelectable for u32

fn conditional_select(a: &u32, b: &u32, choice: Choice) -> u32

fn conditional_assign(&mut self, other: &u32, choice: Choice)

fn conditional_swap(a: &mut u32, b: &mut u32, choice: Choice)

impl ConditionallySelectable for u64

fn conditional_select(a: &u64, b: &u64, choice: Choice) -> u64

fn conditional_assign(&mut self, other: &u64, choice: Choice)

fn conditional_swap(a: &mut u64, b: &mut u64, choice: Choice)

impl ConditionallySelectable for u128

fn conditional_select(a: &u128, b: &u128, choice: Choice) -> u128

fn conditional_assign(&mut self, other: &u128, choice: Choice)

fn conditional_swap(a: &mut u128, b: &mut u128, choice: Choice)

impl<C> ConditionallySelectable for AffinePoint<C>

where C: PrimeCurveParams,

fn conditional_select( a: &AffinePoint<C>, b: &AffinePoint<C>, choice: Choice, ) -> AffinePoint<C>

impl<C> ConditionallySelectable for ProjectivePoint<C>

where C: PrimeCurveParams,

fn conditional_select( a: &ProjectivePoint<C>, b: &ProjectivePoint<C>, choice: Choice, ) -> ProjectivePoint<C>

impl<Size> ConditionallySelectable for EncodedPoint<Size>

where Size: ModulusSize, <<Size as ModulusSize>::UncompressedPointSize as ArrayLength<u8>>::ArrayType: Copy,

Available on crate feature subtle only.

fn conditional_select( a: &EncodedPoint<Size>, b: &EncodedPoint<Size>, choice: Choice, ) -> EncodedPoint<Size>

Implementors

impl ConditionallySelectable for airbender_crypto::p256::Scalar

impl ConditionallySelectable for airbender_crypto::k256::AffinePoint

impl ConditionallySelectable for airbender_crypto::k256::ProjectivePoint

impl ConditionallySelectable for airbender_crypto::k256::Scalar

impl ConditionallySelectable for Limb

impl ConditionallySelectable for Reciprocal

impl ConditionallySelectable for Choice

impl<C> ConditionallySelectable for NonZeroScalar<C>

where C: CurveArithmetic,

impl<C> ConditionallySelectable for ScalarPrimitive<C>

where C: Curve,

impl<MOD, const LIMBS: usize> ConditionallySelectable for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS> + Copy,

impl<P> ConditionallySelectable for NonIdentity<P>

where P: ConditionallySelectable,

impl<T> ConditionallySelectable for Checked<T>

where T: ConditionallySelectable,

impl<T> ConditionallySelectable for NonZero<T>

where T: ConditionallySelectable + Zero,

impl<T> ConditionallySelectable for Wrapping<T>

where T: ConditionallySelectable,

impl<T> ConditionallySelectable for CtOption<T>

where T: ConditionallySelectable,

impl<const LIMBS: usize> ConditionallySelectable for DynResidue<LIMBS>

impl<const LIMBS: usize> ConditionallySelectable for DynResidueParams<LIMBS>

impl<const LIMBS: usize> ConditionallySelectable for Uint<LIMBS>