Struct AnnihlKey 

pub struct AnnihlKey {
    pub solution: Solution,
    /* private fields */
}

An AnnihlKey represents the mined proof-of-work solution and elliptic curve point of an annihilative key.

Fields

solution: Solution

Serialised proof-of-work solution.

Implementations

impl AnnihlKey

pub fn new(solution: Solution, base_point: EdwardsPoint) -> Self

Construct a new AnnihlKey from a mined proof-of-work solution and shared base curve point.

pub fn new_pair(ikm: &[u8], iam: &[u8], constraint: u8) -> (Self, Self)

Derive a new annihilative pair from keying material.

Returns a pair that satisfies the given proof-of-work constraint, where each AnnihlKey consists of the mined Solution, and an EdwardsPoint at an offset from the pair’s shared base curve point.

pub fn verify(&self, other: &Self) -> Result<[u8; 32], AnnihlErr>

Verify that two annihilative keys form a valid pair.

First checks that both members share the same base curve point, then checks if the hash of their XOR satisfies the proof-of-work constraint.

Returns the XOR hash as an artifact on success, or an error when the members do not form a valid annihilative pair.

pub fn authenticate(&self, keying_material: &[u8]) -> Result<(), AnnihlErr>

Authenticate than an AnnihlKey was derived from given keying material.

Returns an error if the annihilative key could not be authenticated by the keying material.

pub fn to_annihilation(&self, other: &Self) -> Result<[u8; 32], AnnihlErr>

Compute an annihilation key from an annihilative pair.

Verifies the pair, then computes an Hmac of the verification artifact, keyed by the sum of both curve points. Requires both a key and antikey to compute. As long as one half of the annihilative pair remains secret, the secrecy of the derived annihilation key is preserved.

Returns the MAC as the annihilation key on success, or an error when the pair is invalid or the proof-of-work constraint is not satisfied.

pub fn into_annihilation(self, other: Self) -> Result<[u8; 32], AnnihlErr>

Compute an annihilation key from an annihilative pair, consuming both keys.

Convenience method that consumes ownership of both keys while delegating to to_annihilation.

Returns the MAC as the annihilation key on success, or an error when the pair is invalid or the proof-of-work constraint is not satisfied.

pub fn to_bytes(&self) -> [u8; 64]

Copy this AnnihlKey to a 64 byte array.

pub fn to_edwards_point(&self) -> EdwardsPoint

Return this AnnihlKey’s curve point as an EdwardsPoint.

Trait Implementations

impl Clone for AnnihlKey

fn clone(&self) -> AnnihlKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConstantTimeEq for AnnihlKey

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

Determine if two items are equal.

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

Determine if two items are NOT equal.

impl Debug for AnnihlKey

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

Formats the value using the given formatter.

impl Drop for AnnihlKey

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq for AnnihlKey

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&[u8; 64]> for AnnihlKey

fn try_from(value: &[u8; 64]) -> Result<Self, Self::Error>

Construct an AnnihlKey from a 64 byte array.

type Error = AnnihlErr

The type returned in the event of a conversion error.

impl Zeroize for AnnihlKey

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.

impl Eq for AnnihlKey