Trait subtle::ConstantTimeEq

pub trait ConstantTimeEq {
    fn ct_eq(&self, other: &Self) -> Choice;
}

An Eq-like trait that produces a Choice instead of a bool.

Example

use subtle::ConstantTimeEq;
let x: u8 = 5;
let y: u8 = 13;

assert_eq!(x.ct_eq(&y).unwrap_u8(), 0);
assert_eq!(x.ct_eq(&x).unwrap_u8(), 1);

Required methods

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

The ct_eq function should execute in constant time.

Returns

• Choice(1u8) if self == other;
• Choice(0u8) if self != other.

Loading content...

Implementors

impl ConstantTimeEq for i8

fn ct_eq(&self, other: &i8) -> Choice

impl ConstantTimeEq for i16

fn ct_eq(&self, other: &i16) -> Choice

impl ConstantTimeEq for i32

fn ct_eq(&self, other: &i32) -> Choice

impl ConstantTimeEq for i64

fn ct_eq(&self, other: &i64) -> Choice

impl ConstantTimeEq for isize

fn ct_eq(&self, other: &isize) -> Choice

impl ConstantTimeEq for u8

fn ct_eq(&self, other: &u8) -> Choice

impl ConstantTimeEq for u16

fn ct_eq(&self, other: &u16) -> Choice

impl ConstantTimeEq for u32

fn ct_eq(&self, other: &u32) -> Choice

impl ConstantTimeEq for u64

fn ct_eq(&self, other: &u64) -> Choice

impl ConstantTimeEq for usize

fn ct_eq(&self, other: &usize) -> Choice

impl<T: ConstantTimeEq> ConstantTimeEq for [T]

fn ct_eq(&self, _rhs: &[T]) -> Choice

Check whether two slices of ConstantTimeEq types are equal.

Note

This function short-circuits if the lengths of the input slices are different. Otherwise, it should execute in time independent of the slice contents.

Since arrays coerce to slices, this function works with fixed-size arrays:

let a: [u8; 8] = [0,1,2,3,4,5,6,7];
let b: [u8; 8] = [0,1,2,3,0,1,2,3];

let a_eq_a = a.ct_eq(&a);
let a_eq_b = a.ct_eq(&b);

assert_eq!(a_eq_a.unwrap_u8(), 1);
assert_eq!(a_eq_b.unwrap_u8(), 0);

Loading content...