Struct PairwiseAuthKey 

#[repr(C)]
pub struct PairwiseAuthKey<A, B> {
    pub alpha: GlobalKey<A>,
    pub beta: B,
}

Generic authenticated key: a global key alpha: A and a local key beta: B, satisfying MAC(x) = α · x + β.

This is the base type for both:

• [FieldShareKey<F>] — single-value authenticated key
• [FieldShareKeys<F,M>] — batched authenticated key (M values, shared α)

Fields

alpha: GlobalKey<A>

beta: B

Implementations

impl<A, B> PairwiseAuthKey<A, B>

pub fn new(alpha: Arc<A>, beta: B) -> Self

Create a new PairwiseAuthKey with the given global key alpha and local key beta.

pub fn get_beta(&self) -> &B

Return a reference to the local key beta.

pub fn get_alpha(&self) -> &A

Return a reference to the global key alpha.

pub fn alpha(&self) -> Arc<A>

Return the value of the global key alpha.

impl<A: Clone, B: Copy, M: Positive> PairwiseAuthKey<A, HeapArray<B, M>>

Generic split and merge operations on any batched key PairwiseAuthKey<A, HeapArray<B, M>>. Covers both FieldShareKeys<F, M> and CurveKeys<C, M>.

pub fn split<M1, M2>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, M1>>, PairwiseAuthKey<A, HeapArray<B, M2>>)

where M1: Positive, M2: Positive + Add<M1, Output = M>,

Split a batched key into two smaller batched keys with the same global key alpha and disjoint local keys beta (first M1 values in the first key, next M2 values in the second key).

pub fn split_halves<MDiv2>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, MDiv2>>, PairwiseAuthKey<A, HeapArray<B, MDiv2>>)

where MDiv2: Positive + Mul<U2, Output = M>,

Split a batched key into two smaller batched keys with the same global key alpha and disjoint local keys beta (first M/2 values in the first key, next M/2 values in the second key).

pub fn merge_halves( this: Self, other: Self, ) -> PairwiseAuthKey<A, HeapArray<B, Prod<M, U2>>>

where M: Positive + Mul<U2, Output: Positive>, A: PartialEq,

Merge two batched keys with the same global key alpha and disjoint local keys beta (first M/2 values in the first key, next M/2 values in the second key) into a single batched key with M values in the local key.

pub fn split3<M1, M2, M3>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, M1>>, PairwiseAuthKey<A, HeapArray<B, M2>>, PairwiseAuthKey<A, HeapArray<B, M3>>)

where M1: Positive, M2: Positive + Add<M1>, M3: Positive + Add<Sum<M2, M1>, Output = M>,

Split a batched key into three smaller batched keys with the same global key alpha and disjoint local keys beta (first M1 values in the first key, next M2 values in the second key, last M3 values in the third key).

pub fn split_thirds<MDiv3>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, MDiv3>>, PairwiseAuthKey<A, HeapArray<B, MDiv3>>, PairwiseAuthKey<A, HeapArray<B, MDiv3>>)

where MDiv3: Positive + Mul<U3, Output = M>,

Split a batched key into three smaller batched keys with the same global key alpha and disjoint local keys beta (first M/3 values in the first key, next M/3 values in the second key, last M/3 values in the third key).

pub fn merge_thirds( first: Self, second: Self, third: Self, ) -> PairwiseAuthKey<A, HeapArray<B, Prod<M, U3>>>

where M: Positive + Mul<U3, Output: Positive>, A: PartialEq,

Merge three batched keys with the same global key alpha and disjoint local keys beta (first M/3 values in the first key, next M/3 values in the second key, last M/3 values in the third key) into a single batched key with M values in the local key.

Trait Implementations

impl<A: PartialEq, B> Add<&PairwiseAuthKey<A, B>> for &PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B>, PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the + operator.

fn add(self, rhs: &PairwiseAuthKey<A, B>) -> Self::Output

Performs the + operation.

impl<A: PartialEq, B> Add<&PairwiseAuthKey<A, B>> for PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B>,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the + operator.

fn add(self, other: &PairwiseAuthKey<A, B>) -> Self::Output

Performs the + operation.

impl<A: PartialEq, B> Add<PairwiseAuthKey<A, B>> for &PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B>, PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the + operator.

fn add(self, rhs: PairwiseAuthKey<A, B>) -> Self::Output

Performs the + operation.

impl<A: PartialEq, B> Add for PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B>,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the + operator.

fn add(self, rhs: PairwiseAuthKey<A, B>) -> Self::Output

Performs the + operation.

impl<'a, A: PartialEq, B> AddAssign<&'a PairwiseAuthKey<A, B>> for PairwiseAuthKey<A, B>

where for<'b> B: AddAssign<&'b B>,

fn add_assign(&mut self, other: &'a PairwiseAuthKey<A, B>)

Performs the += operation.

impl<'a, A: PartialEq, B> AddAssign for PairwiseAuthKey<A, B>

where for<'b> B: AddAssign<&'b B>,

fn add_assign(&mut self, rhs: PairwiseAuthKey<A, B>)

Performs the += operation.

impl<A: Clone, B: Clone> Clone for PairwiseAuthKey<A, B>

fn clone(&self) -> PairwiseAuthKey<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: ConditionallySelectable, B: ConditionallySelectable> ConditionallySelectable for PairwiseAuthKey<A, B>

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

impl<A: ConstantTimeEq, B: ConstantTimeEq> ConstantTimeEq for PairwiseAuthKey<A, B>

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<A: Debug, B: Debug> Debug for PairwiseAuthKey<A, B>

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

Formats the value using the given formatter.

impl<A: Default, B: Default> Default for PairwiseAuthKey<A, B>

fn default() -> PairwiseAuthKey<A, B>

Returns the “default value” for a type.

impl<'de, A, B> Deserialize<'de> for PairwiseAuthKey<A, B>

where A: Deserialize<'de>, B: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A, T> From<PairwiseAuthKey<A, T>> for PairwiseAuthKey<A, HeapArray<T, U1>>

Convert a single-element key into a one-element batched key. Covers From<FieldShareKey<F>> for FieldShareKeys<F, U1> and From<CurveKey<C>> for CurveKeys<C, U1>.

fn from(key: PairwiseAuthKey<A, T>) -> Self

Converts to this type from the input type.

impl<C: Curve> From<PairwiseAuthKey<FieldElement<<C as Curve>::Scalar>, FieldElement<<C as Curve>::Scalar>>> for CurveKey<C>

fn from(scalar_key: ScalarKey<C>) -> Self

Converts to this type from the input type.

impl<C: Curve, M: Positive> From<PairwiseAuthKey<FieldElement<<C as Curve>::Scalar>, HeapArray<FieldElement<<C as Curve>::Scalar>, M>>> for CurveKeys<C, M>

fn from(scalar_key: ScalarKeys<C, M>) -> Self

Converts to this type from the input type.

impl<A: Clone, B, RHS, BPrime> Mul<RHS> for &PairwiseAuthKey<A, B>

where for<'b> &'b B: Mul<RHS, Output = BPrime>,

type Output = PairwiseAuthKey<A, BPrime>

The resulting type after applying the * operator.

fn mul(self, other: RHS) -> Self::Output

Performs the * operation.

impl<A, B, RHS, BPrime> Mul<RHS> for PairwiseAuthKey<A, B>

where B: Mul<RHS, Output = BPrime>,

type Output = PairwiseAuthKey<A, BPrime>

The resulting type after applying the * operator.

fn mul(self, other: RHS) -> Self::Output

Performs the * operation.

impl<A, B, RHS> MulAssign<RHS> for PairwiseAuthKey<A, B>

where B: MulAssign<RHS>,

fn mul_assign(&mut self, other: RHS)

Performs the *= operation.

impl<A, B: Neg<Output = B>> Neg for &PairwiseAuthKey<A, B>

where PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, B: Neg<Output = B>> Neg for PairwiseAuthKey<A, B>

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A: PartialEq, B: PartialEq> PartialEq for PairwiseAuthKey<A, B>

fn eq(&self, other: &PairwiseAuthKey<A, B>) -> 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<A: Random, B: Random> Random for PairwiseAuthKey<A, B>

fn random(rng: impl CryptoRngCore) -> Self

fn random_n<Container: FromIterator<Self>>( rng: impl CryptoRngCore, size: usize, ) -> Container

fn random_array<M: Positive>(rng: impl CryptoRngCore) -> HeapArray<Self, M>

impl<A: Clone, B: Random> RandomWith<Arc<A>> for PairwiseAuthKey<A, B>

fn random_with(rng: impl CryptoRngCore, alpha: GlobalKey<A>) -> Self

fn random_n_with<Container: FromIterator<Self>>( rng: impl CryptoRngCore, size: usize, data: D, ) -> Container

fn random_n_with_each<Container: FromIterator<Self>>( rng: impl CryptoRngCore, all_data: impl IntoExactSizeIterator<Item = D>, ) -> Container

impl<'de, A: SchemaRead<'de, Dst = A>, B: SchemaRead<'de, Dst = B>> SchemaRead<'de> for PairwiseAuthKey<A, B>

type Dst = PairwiseAuthKey<A, B>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

Read into dst from reader.

const TYPE_META: TypeMeta = TypeMeta::Dynamic

fn get(reader: &mut impl Reader<'de>) -> Result<Self::Dst, ReadError>

Read Self::Dst from reader into a new Self::Dst.

impl<A: SchemaWrite<Src = A>, B: SchemaWrite<Src = B>> SchemaWrite for PairwiseAuthKey<A, B>

type Src = PairwiseAuthKey<A, B>

fn size_of(src: &Self::Src) -> WriteResult<usize>

Get the serialized size of Self::Src.

fn write(writer: &mut impl Writer, src: &Self::Src) -> WriteResult<()>

Write Self::Src to writer.

const TYPE_META: TypeMeta = TypeMeta::Dynamic

impl<A, B> Serialize for PairwiseAuthKey<A, B>

where A: Serialize, B: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: PartialEq, B> Sub<&PairwiseAuthKey<A, B>> for &PairwiseAuthKey<A, B>

where for<'a> B: Sub<&'a B, Output = B>, PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &PairwiseAuthKey<A, B>) -> Self::Output

Performs the - operation.

impl<A: PartialEq, B> Sub<&PairwiseAuthKey<A, B>> for PairwiseAuthKey<A, B>

where for<'a> B: Sub<&'a B, Output = B>,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn sub(self, other: &PairwiseAuthKey<A, B>) -> Self::Output

Performs the - operation.

impl<A: PartialEq, B> Sub<PairwiseAuthKey<A, B>> for &PairwiseAuthKey<A, B>

where for<'a> B: Sub<&'a B, Output = B>, PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn sub(self, rhs: PairwiseAuthKey<A, B>) -> Self::Output

Performs the - operation.

impl<A: PartialEq, B> Sub for PairwiseAuthKey<A, B>

where for<'a> B: Sub<&'a B, Output = B>,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn sub(self, rhs: PairwiseAuthKey<A, B>) -> Self::Output

Performs the - operation.

impl<'a, A: PartialEq, B> SubAssign<&'a PairwiseAuthKey<A, B>> for PairwiseAuthKey<A, B>

where for<'b> B: SubAssign<&'b B>,

fn sub_assign(&mut self, other: &'a PairwiseAuthKey<A, B>)

Performs the -= operation.

impl<'a, A: PartialEq, B> SubAssign for PairwiseAuthKey<A, B>

where for<'b> B: SubAssign<&'b B>,

fn sub_assign(&mut self, rhs: PairwiseAuthKey<A, B>)

Performs the -= operation.

impl<A: Default + PartialEq, B> Sum for PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B> + Default,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<A: Eq, B: Eq> Eq for PairwiseAuthKey<A, B>

impl<A, B> StructuralPartialEq for PairwiseAuthKey<A, B>