Struct timing_shield::TpI8

pub struct TpI8(_);

A number type that prevents its value from being leaked to attackers through timing information.

Use this type's protect method as early as possible to prevent the value from being used in variable-time computations.

Unlike Rust's built-in number types, rust-timing-shield number types have no overflow checking, even in debug mode. In other words, they behave like Rust's Wrapping types.

Additionally, all shift distances are reduced mod the bit width of the type (e.g. some_i64 << 104 is equivalent to some_i64 << 40).

// Protect the value as early as possible to limit the risk
let protected_value = TpU8::protect(some_u8);
let other_protected_value = TpU8::protect(some_other_u8);

// Do some computation with the protected values
let x = (other_protected_value + protected_value) & 0x40;

// If needed, remove protection using `expose`
println!("{}", x.expose());

Methods

impl TpI8

fn protect(input: i8) -> Self

Hide input behind a protective abstraction to prevent the value from being used in such a way that the value could leak out via a timing side channel.

let protected = TpU32::protect(secret_u32);

// Use `protected` instead of `secret_u32` to avoid timing leaks

fn as_u8(self) -> TpU8

Casts from one number type to another, following the same conventions as Rust's as keyword.

fn as_u16(self) -> TpU16

Casts from one number type to another, following the same conventions as Rust's as keyword.

fn as_u32(self) -> TpU32

Casts from one number type to another, following the same conventions as Rust's as keyword.

fn as_u64(self) -> TpU64

Casts from one number type to another, following the same conventions as Rust's as keyword.

fn as_i16(self) -> TpI16

Casts from one number type to another, following the same conventions as Rust's as keyword.

fn as_i32(self) -> TpI32

Casts from one number type to another, following the same conventions as Rust's as keyword.

fn as_i64(self) -> TpI64

Casts from one number type to another, following the same conventions as Rust's as keyword.

fn rotate_left(self, n: u32) -> Self

Shifts left by n bits, wrapping truncated bits around to the right side of the resulting value.

If n is larger than the bitwidth of this number type, n is reduced mod that bitwidth. For example, rotating an i16 with n = 35 is equivalent to rotating with n = 3, since 35 = 3 mod 16.

fn rotate_right(self, n: u32) -> Self

Shifts right by n bits, wrapping truncated bits around to the left side of the resulting value.

If n is larger than the bitwidth of this number type, n is reduced mod that bitwidth. For example, rotating an i16 with n = 35 is equivalent to rotating with n = 3, since 35 = 3 mod 16.

fn expose(self) -> i8

Remove the timing protection and expose the raw number value. Once a value is exposed, it is the library user's responsibility to prevent timing leaks (if necessary).

Commonly, this method is used when a value is safe to make public (e.g. when an encryption algorithm outputs a ciphertext). Alternatively, this method may need to be used when providing a secret value to an interface that does not use timing-shield's types (e.g. writing a secret key to a file using a file system API).

Trait Implementations

impl Clone for TpI8

fn clone(&self) -> TpI8

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for TpI8

impl Not for TpI8

type Output = TpI8

The resulting type after applying the ! operator

fn not(self) -> TpI8

The method for the unary ! operator

impl Add<TpI8> for TpI8

type Output = TpI8

The resulting type after applying the + operator

fn add(self, other: TpI8) -> TpI8

The method for the + operator

impl Add<i8> for TpI8

type Output = TpI8

The resulting type after applying the + operator

fn add(self, other: i8) -> TpI8

The method for the + operator

impl Sub<TpI8> for TpI8

type Output = TpI8

The resulting type after applying the - operator

fn sub(self, other: TpI8) -> TpI8

The method for the - operator

impl Sub<i8> for TpI8

type Output = TpI8

The resulting type after applying the - operator

fn sub(self, other: i8) -> TpI8

The method for the - operator

impl Mul<TpI8> for TpI8

type Output = TpI8

The resulting type after applying the * operator

fn mul(self, other: TpI8) -> TpI8

The method for the * operator

impl Mul<i8> for TpI8

type Output = TpI8

The resulting type after applying the * operator

fn mul(self, other: i8) -> TpI8

The method for the * operator

impl BitAnd<TpI8> for TpI8

type Output = TpI8

The resulting type after applying the & operator

fn bitand(self, other: TpI8) -> TpI8

The method for the & operator

impl BitAnd<i8> for TpI8

type Output = TpI8

The resulting type after applying the & operator

fn bitand(self, other: i8) -> TpI8

The method for the & operator

impl BitOr<TpI8> for TpI8

type Output = TpI8

The resulting type after applying the | operator

fn bitor(self, other: TpI8) -> TpI8

The method for the | operator

impl BitOr<i8> for TpI8

type Output = TpI8

The resulting type after applying the | operator

fn bitor(self, other: i8) -> TpI8

The method for the | operator

impl BitXor<TpI8> for TpI8

type Output = TpI8

The resulting type after applying the ^ operator

fn bitxor(self, other: TpI8) -> TpI8

The method for the ^ operator

impl BitXor<i8> for TpI8

type Output = TpI8

The resulting type after applying the ^ operator

fn bitxor(self, other: i8) -> TpI8

The method for the ^ operator

impl Shl<u32> for TpI8

type Output = TpI8

The resulting type after applying the << operator

fn shl(self, other: u32) -> TpI8

The method for the << operator

impl Shr<u32> for TpI8

type Output = TpI8

The resulting type after applying the >> operator

fn shr(self, other: u32) -> TpI8

The method for the >> operator

impl AddAssign<TpI8> for TpI8

fn add_assign(&mut self, rhs: TpI8)

The method for the += operator

impl AddAssign<i8> for TpI8

fn add_assign(&mut self, rhs: i8)

The method for the += operator

impl SubAssign<TpI8> for TpI8

fn sub_assign(&mut self, rhs: TpI8)

The method for the -= operator

impl SubAssign<i8> for TpI8

fn sub_assign(&mut self, rhs: i8)

The method for the -= operator

impl MulAssign<TpI8> for TpI8

fn mul_assign(&mut self, rhs: TpI8)

The method for the *= operator

impl MulAssign<i8> for TpI8

fn mul_assign(&mut self, rhs: i8)

The method for the *= operator

impl BitAndAssign<TpI8> for TpI8

fn bitand_assign(&mut self, rhs: TpI8)

The method for the &= operator

impl BitAndAssign<i8> for TpI8

fn bitand_assign(&mut self, rhs: i8)

The method for the &= operator

impl BitOrAssign<TpI8> for TpI8

fn bitor_assign(&mut self, rhs: TpI8)

The method for the |= operator

impl BitOrAssign<i8> for TpI8

fn bitor_assign(&mut self, rhs: i8)

The method for the |= operator

impl BitXorAssign<TpI8> for TpI8

fn bitxor_assign(&mut self, rhs: TpI8)

The method for the ^= operator

impl BitXorAssign<i8> for TpI8

fn bitxor_assign(&mut self, rhs: i8)

The method for the ^= operator

impl ShlAssign<u32> for TpI8

fn shl_assign(&mut self, rhs: u32)

The method for the <<= operator

impl ShrAssign<u32> for TpI8

fn shr_assign(&mut self, rhs: u32)

The method for the >>= operator

impl TpEq<TpI8> for TpI8

fn tp_eq(&self, other: &TpI8) -> TpBool

Compare self with other for equality without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

fn tp_not_eq(&self, other: &TpI8) -> TpBool

Compare self with other for inequality without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

impl TpEq<i8> for TpI8

fn tp_eq(&self, other: &i8) -> TpBool

Compare self with other for equality without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

fn tp_not_eq(&self, other: &i8) -> TpBool

Compare self with other for inequality without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

impl TpOrd<TpI8> for TpI8

fn tp_lt(&self, other: &TpI8) -> TpBool

Compute self < other without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

fn tp_gt(&self, other: &TpI8) -> TpBool

Compute self > other without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

fn tp_lt_eq(&self, other: &TpI8) -> TpBool

Compute self <= other without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

fn tp_gt_eq(&self, other: &TpI8) -> TpBool

Compute self >= other without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

impl TpOrd<i8> for TpI8

fn tp_lt(&self, other: &i8) -> TpBool

Compute self < other without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

fn tp_gt(&self, other: &i8) -> TpBool

Compute self > other without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

fn tp_lt_eq(&self, other: &i8) -> TpBool

Compute self <= other without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

fn tp_gt_eq(&self, other: &i8) -> TpBool

Compute self >= other without leaking the result. Important: if either input is not a timing-protected type, this operation might leak the value of that type. To prevent timing leaks, protect values before performing any operations on them.

impl TpCondSwap for TpI8

fn tp_cond_swap(condition: TpBool, a: &mut TpI8, b: &mut TpI8)

Swap a and b if and only if condition is true.

impl Neg for TpI8

type Output = TpI8

The resulting type after applying the - operator

fn neg(self) -> TpI8

The method for the unary - operator