Struct secret_integers::U32

pub struct U32(pub u32);

Tuple Fields

0: u32

Implementations

impl U32

pub fn classify<T: Into<u32>>(x: T) -> Self

Examples found in repository

examples/chacha20.rs (line 13)

pub fn classify_u32s(v: &[u32]) -> Vec<U32> {
    v.iter().map(|x| U32::classify(*x)).collect()
}

fn line(a: Index, b: Index, d: Index, s: RotVal, m: &mut State) {
    m[a] = m[a] + m[b];
    m[d] = m[d] ^ m[a];
    m[d] = m[d].rotate_left(s);
}

fn quarter_round(a: Index, b: Index, c: Index, d: Index, m: &mut State) {
    line(a, b, d, 16, m);
    line(c, d, b, 12, m);
    line(a, b, d, 8, m);
    line(c, d, b, 7, m);
}

fn double_round(m: &mut State) {
    quarter_round(0, 4, 8, 12, m);
    quarter_round(1, 5, 9, 13, m);
    quarter_round(2, 6, 10, 14, m);
    quarter_round(3, 7, 11, 15, m);

    quarter_round(0, 5, 10, 15, m);
    quarter_round(1, 6, 11, 12, m);
    quarter_round(2, 7, 8, 13, m);
    quarter_round(3, 4, 9, 14, m);
}

const CONSTANTS: Constants = [0x61707865, 0x3320646e, 0x79622d32, 0x6b206574];

fn chacha20_init(k: &Key, counter: U32, nonce: &Nonce) -> State {
    let mut st = [U32::classify(0u32); 16];
    st[0..4].copy_from_slice(&classify_u32s(&CONSTANTS));
    st[4..12].copy_from_slice(U32::from_le_bytes(k).as_slice());
    st[12] = counter;
    st[13..16].copy_from_slice(U32::from_le_bytes(nonce).as_slice());
    st
}

pub fn declassify(self) -> u32

Warning: use with caution, breaks the constant-time guarantee.

pub fn zero() -> Self

pub fn one() -> Self

Examples found in repository

examples/chacha20.rs (line 100)

fn chacha20_counter_mode(key: &Key, counter: U32, nonce: &Nonce, msg: &Vec<U8>) -> Vec<U8> {
    let mut blocks: Vec<[U8; BLOCK_SIZE]> = msg
        .chunks(BLOCK_SIZE)
        .map(|block| {
            let mut new_block = [U8::zero(); BLOCK_SIZE];
            new_block[0..block.len()].copy_from_slice(block);
            new_block
        })
        .collect();
    let nb_blocks = blocks.len();
    let mut key_block: [U8; BLOCK_SIZE];
    let mut ctr = counter;
    for i in 0..blocks.len() - 1 {
        key_block = chacha20_block(key, ctr, nonce);
        blocks[i] = xor_block(&blocks[i], &key_block);
        ctr += U32::one();
    }
    let last = &mut blocks[nb_blocks - 1];
    key_block = chacha20_block(key, ctr, nonce);
    *last = xor_block(last, &key_block);
    blocks
        .iter()
        .map(|block| block.to_vec())
        .flatten()
        .take(msg.len())
        .collect()
}

pub fn ones() -> Self

pub fn from_le_bytes(bytes: &[U8]) -> Vec<U32>

Examples found in repository

examples/chacha20.rs (line 46)

fn chacha20_init(k: &Key, counter: U32, nonce: &Nonce) -> State {
    let mut st = [U32::classify(0u32); 16];
    st[0..4].copy_from_slice(&classify_u32s(&CONSTANTS));
    st[4..12].copy_from_slice(U32::from_le_bytes(k).as_slice());
    st[12] = counter;
    st[13..16].copy_from_slice(U32::from_le_bytes(nonce).as_slice());
    st
}

pub fn to_le_bytes(ints: &[U32]) -> Vec<U8>

Examples found in repository

examples/chacha20.rs (line 71)

fn chacha20_block(k: &Key, counter: U32, nonce: &Nonce) -> Block {
    let st = chacha20(k, counter, nonce);
    let mut block = [U8::classify(0u8); BLOCK_SIZE];
    block.copy_from_slice(U32::to_le_bytes(&st).as_slice());
    block
}

pub fn from_be_bytes(bytes: &[U8]) -> Vec<U32>

pub fn to_be_bytes(ints: &[U32]) -> Vec<U8>

pub fn max_value() -> U32

impl U32

pub fn checked_add(self, rhs: Self) -> Self

Warning: panics when overflow.

impl U32

pub fn checked_sub(self, rhs: Self) -> Self

Warning: panics when overflow.

impl U32

pub fn checked_mul(self, rhs: Self) -> Self

Warning: panics when overflow.

impl U32

pub fn rotate_left(self, rotval: usize) -> Self

Examples found in repository

examples/chacha20.rs (line 19)

fn line(a: Index, b: Index, d: Index, s: RotVal, m: &mut State) {
    m[a] = m[a] + m[b];
    m[d] = m[d] ^ m[a];
    m[d] = m[d].rotate_left(s);
}

pub fn rotate_right(self, rotval: usize) -> Self

impl U32

Constant-time comparison operators

pub fn comp_eq(self, rhs: Self) -> Self

Produces a new integer which is all ones if the two arguments are equal and all zeroes otherwise. With inspiration from Wireguard.

pub fn comp_ne(self, rhs: Self) -> Self

Produces a new integer which is all ones if the first argument is different from the second argument, and all zeroes otherwise.

pub fn comp_gte(self, rhs: Self) -> Self

Produces a new integer which is all ones if the first argument is greater than or equal to the second argument, and all zeroes otherwise. With inspiration from WireGuard.

pub fn comp_gt(self, rhs: Self) -> Self

Produces a new integer which is all ones if the first argument is strictly greater than the second argument, and all zeroes otherwise.

pub fn comp_lte(self, rhs: Self) -> Self

Produces a new integer which is all ones if the first argument is less than or equal to the second argument, and all zeroes otherwise.

pub fn comp_lt(self, rhs: Self) -> Self

Produces a new integer which is all ones if the first argument is strictly less than the second argument, and all zeroes otherwise.

Trait Implementations

impl Add<U32> for U32

Warning: has wrapping semantics.

type Output = U32

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl AddAssign<U32> for U32

Warning: has wrapping semantics.

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl BitAnd<U32> for U32

type Output = U32

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self

Performs the & operation.

impl BitAndAssign<U32> for U32

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<U32> for U32

type Output = U32

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl BitOrAssign<U32> for U32

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor<U32> for U32

type Output = U32

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self

Performs the ^ operation.

impl BitXorAssign<U32> for U32

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for U32

fn clone(&self) -> U32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for U32

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for U32

fn default() -> U32

Returns the “default value” for a type.

impl Display for U32

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<I32> for U32

fn from(x: I32) -> U32

Converts to this type from the input type.

impl From<U128> for U32

Warning: wrapping semantics.

fn from(x: U128) -> U32

Converts to this type from the input type.

impl From<U16> for U32

fn from(x: U16) -> U32

Converts to this type from the input type.

impl From<U32> for I32

Warning: wrapping semantics.

fn from(x: U32) -> I32

Converts to this type from the input type.

impl From<U32> for U128

fn from(x: U32) -> U128

Converts to this type from the input type.

impl From<U32> for U16

Warning: wrapping semantics.

fn from(x: U32) -> U16

Converts to this type from the input type.

impl From<U32> for U64

fn from(x: U32) -> U64

Converts to this type from the input type.

impl From<U32> for U8

Warning: wrapping semantics.

fn from(x: U32) -> U8

Converts to this type from the input type.

impl From<U32> for u128

Warning: conversion can be lossy!

fn from(x: U32) -> u128

Converts to this type from the input type.

impl From<U32> for u32

Warning: conversion can be lossy!

fn from(x: U32) -> u32

Converts to this type from the input type.

impl From<U32> for u64

Warning: conversion can be lossy!

fn from(x: U32) -> u64

Converts to this type from the input type.

impl From<U64> for U32

Warning: wrapping semantics.

fn from(x: U64) -> U32

Converts to this type from the input type.

impl From<U8> for U32

fn from(x: U8) -> U32

Converts to this type from the input type.

impl From<u16> for U32

fn from(x: u16) -> U32

Converts to this type from the input type.

impl From<u32> for U32

fn from(x: u32) -> Self

Converts to this type from the input type.

impl From<u8> for U32

fn from(x: u8) -> U32

Converts to this type from the input type.

impl LowerHex for U32

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Mul<U32> for U32

Warning: has wrapping semantics.

type Output = U32

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl MulAssign<U32> for U32

Warning: has wrapping semantics.

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for U32

type Output = U32

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Not for U32

type Output = U32

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Shl<usize> for U32

type Output = U32

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self

Performs the << operation.

impl ShlAssign<usize> for U32

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<usize> for U32

type Output = U32

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self

Performs the >> operation.

impl ShrAssign<usize> for U32

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl Sub<U32> for U32

Warning: has wrapping semantics.

type Output = U32

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl SubAssign<U32> for U32

Warning: has wrapping semantics.

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for U32