Struct PermutationKey 

pub struct PermutationKey<const N: usize>(/* private fields */);

Implementations

impl<const N: usize> PermutationKey<N>

pub unsafe fn new_unchecked(key: [u8; N]) -> Self

Safety

This function is unsafe because it does not check that the key is a valid permutation.

pub fn from_seed(seed: [u8; 32]) -> Result<Self, RandomError>

where [u8; N]: IsPermutable,

Creates a new permutation key from a seed. TODO: Perhaps seed should be protected?

pub fn invert(self) -> Self

where [u8; N]: IsPermutable,

Consumes the key and returns its inverse.

pub fn complement(&self, target: &Self) -> Self

where [u8; N]: IsPermutable + Zeroed,

Returns the complement of the key with respect to the target key. That is: C(T) = Self

Example

use vitaminc::permutation::{Permute, PermutationKey};
use vitaminc::random::{Generatable, SafeRand, SeedableRng};
let mut rng = SafeRand::from_entropy().expect("Failed to seed RNG");
let key = PermutationKey::random(&mut rng).expect("Random error");
let target = PermutationKey::random(&mut rng).expect("Random error");
let complement = key.complement(&target);
let input: [u8; 16] = Generatable::random(&mut rng).expect("Random error");
assert_eq!(
    complement.permute(target).permute(input),
    key.permute(input)
);

Trait Implementations

impl BitwisePermute<8, NonZero<u8>> for PermutationKey<8>

fn bitwise_permute(&self, input: NonZeroU8) -> NonZeroU8

impl BitwisePermute<8, u8> for PermutationKey<8>

fn bitwise_permute(&self, input: u8) -> u8

impl BitwisePermute<16, NonZero<u16>> for PermutationKey<16>

fn bitwise_permute(&self, input: NonZeroU16) -> NonZeroU16

impl BitwisePermute<16, u16> for PermutationKey<16>

fn bitwise_permute(&self, input: u16) -> u16

impl BitwisePermute<32, NonZero<u32>> for PermutationKey<32>

fn bitwise_permute(&self, input: NonZeroU32) -> NonZeroU32

impl BitwisePermute<32, u32> for PermutationKey<32>

fn bitwise_permute(&self, input: u32) -> u32

impl BitwisePermute<64, NonZero<u64>> for PermutationKey<64>

fn bitwise_permute(&self, input: NonZeroU64) -> NonZeroU64

impl BitwisePermute<64, u64> for PermutationKey<64>

fn bitwise_permute(&self, input: u64) -> u64

impl BitwisePermute<128, NonZero<u128>> for PermutationKey<128>

fn bitwise_permute(&self, input: NonZeroU128) -> NonZeroU128

impl BitwisePermute<128, u128> for PermutationKey<128>

fn bitwise_permute(&self, input: u128) -> u128

impl<const N: usize> Clone for PermutationKey<N>

fn clone(&self) -> PermutationKey<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Copy for PermutationKey<N>

impl<const N: usize> Debug for PermutationKey<N>

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

Formats the value using the given formatter.

impl<const N: usize, T> Depermute<[T; N]> for PermutationKey<N>

where T: Zeroize + Default + Copy + ConditionallySelectable, [T; N]: IsPermutable + Zeroed,

fn depermute(&self, input: [T; N]) -> [T; N]

impl<'de, const N: usize> Deserialize<'de> for PermutationKey<N>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> Generatable for PermutationKey<N>

where [u8; N]: IsPermutable,

fn random(rng: &mut SafeRand) -> Result<Self, RandomError>

impl<const N: usize> Permute<PermutationKey<N>> for PermutationKey<N>

where [u8; N]: IsPermutable + Zeroed,

fn permute(&self, Self: Self) -> Self

impl<const N: usize, T> Permute<[T; N]> for PermutationKey<N>

where T: Zeroize + Default + Copy + ConditionallySelectable, [T; N]: IsPermutable + Zeroed,

Implement permutation for Protected type containing a permutable array.

fn permute(&self, input: [T; N]) -> [T; N]

impl<const N: usize> Serialize for PermutationKey<N>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> Zeroize for PermutationKey<N>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.