Struct State 

pub(crate) struct State {
    r: [u32; 5],
    h: [u32; 5],
    pad: [u32; 4],
}

Fields

r: [u32; 5]

h: [u32; 5]

pad: [u32; 4]

Implementations

impl State

pub(crate) fn new(key: &Key) -> State

Initialize Poly1305 State with the given key

pub(crate) fn compute_block(&mut self, block: &Block, partial: bool)

Compute a Poly1305 block

pub(crate) fn finalize_mut(&mut self) -> Tag

Finalize output producing a Tag

Trait Implementations

impl BlockSizeUser for State

type BlockSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>

Size of the block in bytes.

fn block_size() -> usize

Return block size in bytes.

impl Clone for State

fn clone(&self) -> State

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for State

fn default() -> State

Returns the “default value” for a type.

impl ParBlocksSizeUser for State

type ParBlocksSize = UInt<UTerm, B1>

Number of blocks which can be processed in parallel.

impl UhfBackend for State

fn proc_block(&mut self, block: &Block)

Process single block.

fn proc_par_blocks( &mut self, blocks: &GenericArray<GenericArray<u8, Self::BlockSize>, Self::ParBlocksSize>, )

Process several blocks in parallel.

fn blocks_needed_to_align(&self) -> usize

Returns the number of blocks that should be passed to Self::proc_block before Self::proc_par_blocks can be used efficiently. This is always less than Self::ParBlocksSize.

impl UniversalHash for State

fn finalize(self) -> Tag

Finalize output producing a Tag

fn update_with_backend( &mut self, f: impl UhfClosure<BlockSize = Self::BlockSize>, )

Update hash function state using the provided rank-2 closure.

fn update(&mut self, blocks: &[GenericArray<u8, Self::BlockSize>])

Update hash function state with the provided block.

fn update_padded(&mut self, data: &[u8])

Input data into the universal hash function. If the length of the data is not a multiple of the block size, the remaining data is padded with zeroes up to the BlockSize.

fn verify( self, expected: &GenericArray<u8, Self::BlockSize>, ) -> Result<(), Error>

Verify the UniversalHash of the processed input matches a given expected value.