Struct PairwiseAuthShare 

pub struct PairwiseAuthShare<V, A, B> { /* private fields */ }

Generic base for pairwise authenticated shares, analogous to PairwiseAuthKey.

The three type parameters are:

• V: value type.
• B: MAC and local key (Beta) type, an additive Group.
• A: global key (Alpha) type.

The authenticated shares fulfill this relation:

MAC(x_i)_j = α_ji · x_i + β_ji ∀i∈[1..n] ∀j∈[1..n]∖{i}

where β_ji and α_ji are the (local and global) keys of value x_i held by P_j.

As such, the share of party P_i contains:

• x_i, the unauthenticated share value (s.t. x = Σ x_i)
• {MAC(x_i)_j} ∀j∈[1..n]∖{i}, the MACs of x_i for each of the other n-1 parties.
• {β_ij} ∀j∈[1..n]∖{i} and {α_ij} ∀j∈[1..n]∖{i}, the (local and global) keys tied to the values&MACs of the other n-1 parties.

Implementations

impl<V, A, B> PairwiseAuthShare<V, A, B>

pub fn try_new( value: V, macs: Box<[B]>, keys: Box<[PairwiseAuthKey<A, B>]>, ) -> Result<Self, PrimitiveError>

Constructs a new share, returning an error if the MAC and key slices are inconsistent (empty or length-mismatched).

pub fn get_value(&self) -> &V

Returns a reference to the share value.

pub fn get_value_mut(&mut self) -> &mut V

Returns a mutable reference to the share value.

pub fn get_macs(&self) -> &[B]

Returns a slice of all MACs (one per distant peer).

pub fn get_mac(&self, peer_index: PeerIndex) -> Option<&B>

Returns the MAC for the given peer index, or None if out of bounds.

pub fn get_keys(&self) -> &[PairwiseAuthKey<A, B>]

Returns a slice of all keys (one per distant peer).

pub fn get_keys_mut(&mut self) -> &mut [PairwiseAuthKey<A, B>]

Returns a mutable slice of all keys.

pub fn get_key(&self, peer_index: PeerIndex) -> Option<&PairwiseAuthKey<A, B>>

Returns the key for the given peer index, or None if out of bounds.

pub fn into_value(self) -> V

Consumes the share, returning the value.

pub fn into_inner(self) -> (V, Box<[B]>, Box<[PairwiseAuthKey<A, B>]>)

Consumes the share, returning all the internal data (value, MACs, and keys).

pub fn n_parties(&self) -> usize

Total number of parties (including the local party).

pub fn n_distant_parties(&self) -> usize

Number of distant parties (excludes the local party).

pub fn get_alphas(&self) -> impl ExactSizeIterator<Item = GlobalKey<A>> + '_

Returns an iterator over the global keys (alpha values) for each distant peer.

pub fn get_betas(&self) -> impl ExactSizeIterator<Item = &B> + '_

Returns an iterator over the local keys (beta values) for each distant peer.

impl<V, A, B> PairwiseAuthShare<V, A, B>

pub fn compute_mac(value: V, key: &PairwiseAuthKey<A, B>) -> B

where A: Clone, B: for<'b> Add<&'b B, Output = B>, for<'a> V: Mul<&'a A, Output = B>,

Compute the MAC of a value x for ( α-global, β-local) keys as: MAC(x) = α * x + β

pub fn verify_mac( key: &PairwiseAuthKey<A, B>, opening: PairwiseAuthOpenShare<V, B>, ) -> Choice

where A: Clone, B: ConstantTimeEq + SubAssign + for<'b> Add<&'b B, Output = B>, for<'a> V: Mul<&'a A, Output = B>,

Verify the MAC of a value x for ( α-global, β-local) keys fulfills: MAC(x) == α * x + β

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

pub fn split<M1, M2>( self, ) -> (BatchedShare<V, A, B, M1>, BatchedShare<V, A, B, M2>)

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

Splits a batched share of size M into two smaller batched shares (M1, M2), where M = M1 + M2.

pub fn split_halves<MDiv2>( self, ) -> (BatchedShare<V, A, B, MDiv2>, BatchedShare<V, A, B, MDiv2>)

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

Splits a batched share of size M into two smaller batched shares (M1, M2), where M = M1 + M2.

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

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

Merges two batched shares of sizes M/2 into a larger batched share of size M.

pub fn split_thirds<MDiv3>( self, ) -> (BatchedShare<V, A, B, MDiv3>, BatchedShare<V, A, B, MDiv3>, BatchedShare<V, A, B, MDiv3>)

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

Splits a batched share of size M into three smaller batched shares (M1, M2, M3), where M = M1 + M2 + M3.

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

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

Merges three batched shares of sizes M/3 into a larger batched share of size M.

pub fn chunks<CS: Positive>( &self, ) -> BatchedSharesChunks<<HeapArray<V, M> as IntoIterator>::IntoIter, <HeapArray<B, M> as IntoIterator>::IntoIter, A, <HeapArray<B, M> as IntoIterator>::IntoIter, CS>

where M: PartialDiv<CS>,

Creates an iterator that yields fixed-size batched chunks of size CS.

pub fn swap(&mut self, i: usize, j: usize)

Swaps elements at positions i and j in-place across value, macs, and key betas arrays.

Trait Implementations

impl<'a, V, A, B> Add<&'a PairwiseAuthShare<V, A, B>> for &PairwiseAuthShare<V, A, B>

where for<'v> V: Add<&'v V, Output = V>, for<'b> B: Add<&'b B, Output = B>, for<'k> PairwiseAuthKey<A, B>: Add<&'k PairwiseAuthKey<A, B>, Output = PairwiseAuthKey<A, B>>, PairwiseAuthShare<V, A, B>: Clone,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the + operator.

fn add(self, rhs: &'a PairwiseAuthShare<V, A, B>) -> Self::Output

Performs the + operation.

impl<'a, V, A, B> Add<&'a PairwiseAuthShare<V, A, B>> for PairwiseAuthShare<V, A, B>

where for<'v> V: Add<&'v V, Output = V>, for<'b> B: Add<&'b B, Output = B>, for<'k> PairwiseAuthKey<A, B>: Add<&'k PairwiseAuthKey<A, B>, Output = PairwiseAuthKey<A, B>>,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the + operator.

fn add(self, other: &'a PairwiseAuthShare<V, A, B>) -> Self::Output

Performs the + operation.

impl<'a, V, A, B> Add<PairwiseAuthShare<V, A, B>> for &PairwiseAuthShare<V, A, B>

where for<'v> V: Add<&'v V, Output = V>, for<'b> B: Add<&'b B, Output = B>, for<'k> PairwiseAuthKey<A, B>: Add<&'k PairwiseAuthKey<A, B>, Output = PairwiseAuthKey<A, B>>,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, V, A, B> Add for PairwiseAuthShare<V, A, B>

where for<'v> V: Add<&'v V, Output = V>, for<'b> B: Add<&'b B, Output = B>, for<'k> PairwiseAuthKey<A, B>: Add<&'k PairwiseAuthKey<A, B>, Output = PairwiseAuthKey<A, B>>,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, V, A, B> AddAssign<&'a PairwiseAuthShare<V, A, B>> for PairwiseAuthShare<V, A, B>

where for<'v> V: AddAssign<&'v V>, for<'b> B: AddAssign<&'b B>, for<'k> PairwiseAuthKey<A, B>: AddAssign<&'k PairwiseAuthKey<A, B>>,

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

Performs the += operation.

impl<'a, V, A, B> AddAssign for PairwiseAuthShare<V, A, B>

where for<'v> V: AddAssign<&'v V>, for<'b> B: AddAssign<&'b B>, for<'k> PairwiseAuthKey<A, B>: AddAssign<&'k PairwiseAuthKey<A, B>>,

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

Performs the += operation.

impl<V: Clone, A: Clone, B: Clone> Clone for PairwiseAuthShare<V, A, B>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V, A, B> ConditionallySelectable for PairwiseAuthShare<V, A, B>

where V: ConditionallySelectable, B: ConditionallySelectable, PairwiseAuthKey<A, B>: ConditionallySelectable,

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

Select a or b according to choice.

impl<V, A, B> ConstantTimeEq for PairwiseAuthShare<V, A, B>

where V: ConstantTimeEq, B: ConstantTimeEq, PairwiseAuthKey<A, B>: ConstantTimeEq,

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

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

Formats the value using the given formatter.

impl<V: Default, A: Default, B: Default> Default for PairwiseAuthShare<V, A, B>

fn default() -> PairwiseAuthShare<V, A, B>

Returns the “default value” for a type.

impl<'de, V, A, B> Deserialize<'de> for PairwiseAuthShare<V, A, B>

where V: Serialize + DeserializeOwned, A: Serialize + DeserializeOwned, B: Serialize + DeserializeOwned,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<ItemV, A: Clone, ItemB, V, B, N: Positive> From<HeapArray<PairwiseAuthShare<ItemV, A, ItemB>, N>> for PairwiseAuthShare<V, A, B>

where V: FromIterator<ItemV>, B: FromIterator<ItemB>,

fn from(shares: HeapArray<PairwiseAuthShare<ItemV, A, ItemB>, N>) -> Self

Converts to this type from the input type.

impl<C: Curve, M: Positive> From<PairwiseAuthShare<HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>, FieldElement<<C as Curve>::Scalar>, HeapArray<FieldElement<<C as Curve>::Scalar>, M>>> for PointShares<C, M>

fn from(scalar_shares: ScalarShares<C, M>) -> Self

Converts to this type from the input type.

impl<ItemV, A, ItemB> From<PairwiseAuthShare<ItemV, A, ItemB>> for BatchedShare<ItemV, A, ItemB, U1>

fn from(share: PairwiseAuthShare<ItemV, A, ItemB>) -> Self

Converts to this type from the input type.

impl<C: Curve> From<PairwiseAuthShare<SubfieldElement<<C as Curve>::Scalar>, FieldElement<<C as Curve>::Scalar>, FieldElement<<C as Curve>::Scalar>>> for PointShare<C>

fn from(scalar_share: ScalarShare<C>) -> Self

Converts to this type from the input type.

impl<ItemV, A: Clone, ItemB, V, B> FromIterator<PairwiseAuthShare<ItemV, A, ItemB>> for PairwiseAuthShare<V, A, B>

where V: FromIterator<ItemV>, B: FromIterator<ItemB>,

fn from_iter<T: IntoIterator<Item = PairwiseAuthShare<ItemV, A, ItemB>>>( iter: T, ) -> Self

Creates a value from an iterator.

impl<V, A, B> IntoIterator for &PairwiseAuthShare<V, A, B>

where V: Clone + IntoIterator, V::IntoIter: ExactSizeIterator, B: Clone + IntoIterator, A: Clone,

type Item = PairwiseAuthShare<<V as IntoIterator>::Item, A, <B as IntoIterator>::Item>

The type of the elements being iterated over.

type IntoIter = BatchedSharesIterator<<V as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, A, <B as IntoIterator>::IntoIter>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V, A, B> IntoIterator for PairwiseAuthShare<V, A, B>

where V: IntoIterator, V::IntoIter: ExactSizeIterator, B: IntoIterator, A: Clone,

type Item = PairwiseAuthShare<<V as IntoIterator>::Item, A, <B as IntoIterator>::Item>

The type of the elements being iterated over.

type IntoIter = BatchedSharesIterator<<V as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, A, <B as IntoIterator>::IntoIter>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, V, V2, A, B, B2, Const> Mul<&'a Const> for &PairwiseAuthShare<V, A, B>

where for<'v> V: Mul<&'v Const, Output = V2>, for<'b> B: Mul<&'b Const, Output = B2>, PairwiseAuthShare<V, A, B>: Clone,

type Output = PairwiseAuthShare<V2, A, B2>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Const) -> Self::Output

Performs the * operation.

impl<'a, V, V2, A, B, B2, Const> Mul<&'a Const> for PairwiseAuthShare<V, A, B>

where for<'v> V: Mul<&'v Const, Output = V2>, for<'b> B: Mul<&'b Const, Output = B2>,

type Output = PairwiseAuthShare<V2, A, B2>

The resulting type after applying the * operator.

fn mul(self, other: &'a Const) -> Self::Output

Performs the * operation.

impl<'a, V, A, B, Const> MulAssign<&'a Const> for PairwiseAuthShare<V, A, B>

where for<'v> V: MulAssign<&'v Const>, for<'b> B: MulAssign<&'b Const>,

fn mul_assign(&mut self, other: &'a Const)

Performs the *= operation.

impl<V, A, B> Neg for &PairwiseAuthShare<V, A, B>

where V: Neg<Output = V>, B: Neg<Output = B>, PairwiseAuthKey<A, B>: Neg<Output = PairwiseAuthKey<A, B>>, PairwiseAuthShare<V, A, B>: Clone,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<V, A, B> Neg for PairwiseAuthShare<V, A, B>

where V: Neg<Output = V>, B: Neg<Output = B>, PairwiseAuthKey<A, B>: Neg<Output = PairwiseAuthKey<A, B>>,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<V: PartialEq, A: PartialEq, B: PartialEq> PartialEq for PairwiseAuthShare<V, A, B>

fn eq(&self, other: &PairwiseAuthShare<V, 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<V, A, B> PlaintextOps for PairwiseAuthShare<V, A, B>

where PairwiseAuthShare<V, A, B>: Reconstructible<Value = V>, for<'a> V: Clone + for<'a> AddAssign<&'a V> + for<'a> SubAssign<&'a V> + Mul<&'a A, Output = B>, A: Clone, B: Clone + for<'b> AddAssign<&'b B> + for<'b> SubAssign<&'b B> + ConstantTimeEq,

fn add_plaintext(self, ptx: &V, is_first_peer: bool) -> Self

If this is the first peer, adds the plaintext to the value; otherwise adjusts the first key’s beta: β₀ -= α₀ · ptx.

fn sub_plaintext(self, ptx: &V, is_first_peer: bool) -> Self

If this is the first peer, subtracts the plaintext from the value; otherwise adjusts the first key’s beta: β₀ += α₀ · ptx.

impl<V, A, B> Random for PairwiseAuthShare<V, A, B>

where for<'a> V: Random + Clone + Mul<&'a A, Output = B>, A: Random + Clone, B: Random + Clone + ConstantTimeEq + SubAssign + for<'b> Add<&'b B, Output = B>,

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

Generate one random authenticated share per peer, with consistent MACs and keys across all peers.

fn random(_rng: impl CryptoRngCore) -> Self

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

impl<V, A, B> RandomWith<(V, Vec<Arc<A>>)> for PairwiseAuthShare<V, A, B>

where for<'a> V: Clone + Mul<&'a A, Output = B>, A: Random + Clone, B: Random + Clone + ConstantTimeEq + SubAssign + for<'b> Add<&'b B, Output = B>,

fn random_with( rng: impl CryptoRngCore, (value, alphas): (V, Vec<GlobalKey<A>>), ) -> Self

Generate a random authenticated share with a given value whose keys are derived from alphas.

fn random_n_with_each<Container: FromIterator<Self>>( rng: impl CryptoRngCore, unauth_shares_and_alphas: impl IntoExactSizeIterator<Item = (V, Vec<GlobalKey<A>>)>, ) -> Container

Generate one authenticated share per peer from (value, alphas) pairs, computing MACs consistently across parties.

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

impl<V, A, B> RandomWith<(V, Vec<Vec<Arc<A>>>)> for PairwiseAuthShare<V, A, B>

where for<'a> V: AdditiveShares + Mul<&'a A, Output = B>, A: Random + Clone, B: Random + Clone + ConstantTimeEq + SubAssign + for<'b> Add<&'b B, Output = B>,

fn random_n_with<Container: FromIterator<Self>>( rng: impl CryptoRngCore, n_parties: usize, (secret_value, all_alphas): (V, Vec<Vec<GlobalKey<A>>>), ) -> Container

Secret share a value among n parties, each supplied with their own list of global keys.

fn random_with(_rng: impl CryptoRngCore, _: (V, Vec<Vec<GlobalKey<A>>>)) -> Self

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

impl<V, A, B> RandomWith<(usize, V)> for PairwiseAuthShare<V, A, B>

where V: Clone, A: Random + Clone, B: Random,

fn random_with(rng: impl CryptoRngCore, (n_parties, value): (usize, V)) -> Self

Generate a random authenticated share with a given value and random MACs and keys.

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<V, A, B> RandomWith<V> for PairwiseAuthShare<V, A, B>

where for<'a> V: AdditiveShares + Mul<&'a A, Output = B>, A: Random + Clone, B: Random + Clone + ConstantTimeEq + SubAssign + for<'b> Add<&'b B, Output = B>,

fn random_n_with<Container: FromIterator<Self>>( rng: impl CryptoRngCore, n_parties: usize, value: V, ) -> Container

Secret share a value among n parties, generating an authenticated share for each peer with consistent MACs and keys across all peers.

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

Generate an authenticated share for each peer given its additive share value, with consistent MACs and keys across all peers.

fn random_with(_rng: impl CryptoRngCore, _data: V) -> Self

impl<V, A, B> RandomWith<Vec<Arc<A>>> for PairwiseAuthShare<V, A, B>

where for<'a> V: Random + Clone + Mul<&'a A, Output = B>, A: Random + Clone, B: Random + Clone + ConstantTimeEq + SubAssign + for<'b> Add<&'b B, Output = B>,

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

Generate a random authenticated share whose keys are derived from the given global keys.

fn random_n_with_each<Container: FromIterator<Self>>( rng: impl CryptoRngCore, all_alphas: impl IntoExactSizeIterator<Item = Vec<GlobalKey<A>>>, ) -> Container

Generate one authenticated share per peer, deriving each party’s keys from their global keys.

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

impl<V, A, B> RandomWith<usize> for PairwiseAuthShare<V, A, B>

where V: Random, A: Random + Clone, B: Random,

fn random_with(rng: impl CryptoRngCore, n_parties: usize) -> Self

Generate a random authenticated share with random MACs and keys for all other parties.

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<V, A, B> Reconstructible for PairwiseAuthShare<V, A, B>

where for<'a, 'a> V: Clone + PartialEq + Send + Sync + 'static + Serialize + DeserializeOwned + SchemaWrite<Src = V> + for<'de> SchemaRead<'de, Dst = V> + Add<&'a V, Output = V> + Mul<&'a A, Output = B>, A: Clone, B: Clone + Send + Sync + 'static + Serialize + DeserializeOwned + SchemaWrite<Src = B> + for<'de> SchemaRead<'de, Dst = B> + ConstantTimeEq + SubAssign + for<'b> Add<&'b B, Output = B>,

fn open_to( &self, peer: PeerIndex, ) -> Result<PairwiseAuthOpenShare<V, B>, PrimitiveError>

Open the share towards another peer.

fn open_to_all_others( &self, ) -> impl ExactSizeIterator<Item = PairwiseAuthOpenShare<V, B>>

Open the share towards all other peers.

fn reconstruct( &self, openings: Vec<PairwiseAuthOpenShare<V, B>>, ) -> Result<V, PrimitiveError>

Reconstruct a secret from openings coming from all other parties.

type Opening = PairwiseAuthOpenShare<V, B>

The type that is sent to / received from other peers.

type Value = V

The type of the reconstructed value.

fn reconstruct_all<T: Borrow<Self>>( shares: Vec<T>, ) -> Result<Self::Value, PrimitiveError>

Reconstruct a secret from a collection of shares, by opening each share towards all other peers, reconstructing n secrets from the openings and checking that they are all equal.

impl<'de, V, A, B> SchemaRead<'de> for PairwiseAuthShare<V, A, B>

where V: SchemaRead<'de, Dst = V>, B: SchemaRead<'de, Dst = B>, PairwiseAuthKey<A, B>: SchemaRead<'de, Dst = PairwiseAuthKey<A, B>>,

type Dst = PairwiseAuthShare<V, A, B>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self>, ) -> 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<V, A, B> SchemaWrite for PairwiseAuthShare<V, A, B>

where V: SchemaWrite<Src = V>, B: SchemaWrite<Src = B>, PairwiseAuthKey<A, B>: SchemaWrite<Src = PairwiseAuthKey<A, B>>,

type Src = PairwiseAuthShare<V, A, B>

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

Get the serialized size of Self::Src.

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

Write Self::Src to writer.

const TYPE_META: TypeMeta = TypeMeta::Dynamic

impl<V, A, B> Serialize for PairwiseAuthShare<V, A, B>

where V: Serialize + DeserializeOwned, A: Serialize + DeserializeOwned, B: Serialize + DeserializeOwned,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, V, A, B> Sub<&'a PairwiseAuthShare<V, A, B>> for &PairwiseAuthShare<V, A, B>

where for<'v> V: Sub<&'v V, Output = V>, for<'b> B: Sub<&'b B, Output = B>, for<'k> PairwiseAuthKey<A, B>: Sub<&'k PairwiseAuthKey<A, B>, Output = PairwiseAuthKey<A, B>>, PairwiseAuthShare<V, A, B>: Clone,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a PairwiseAuthShare<V, A, B>) -> Self::Output

Performs the - operation.

impl<'a, V, A, B> Sub<&'a PairwiseAuthShare<V, A, B>> for PairwiseAuthShare<V, A, B>

where for<'v> V: Sub<&'v V, Output = V>, for<'b> B: Sub<&'b B, Output = B>, for<'k> PairwiseAuthKey<A, B>: Sub<&'k PairwiseAuthKey<A, B>, Output = PairwiseAuthKey<A, B>>,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the - operator.

fn sub(self, other: &'a PairwiseAuthShare<V, A, B>) -> Self::Output

Performs the - operation.

impl<'a, V, A, B> Sub<PairwiseAuthShare<V, A, B>> for &PairwiseAuthShare<V, A, B>

where for<'v> V: Sub<&'v V, Output = V>, for<'b> B: Sub<&'b B, Output = B>, for<'k> PairwiseAuthKey<A, B>: Sub<&'k PairwiseAuthKey<A, B>, Output = PairwiseAuthKey<A, B>>, PairwiseAuthShare<V, A, B>: Clone,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, V, A, B> Sub for PairwiseAuthShare<V, A, B>

where for<'v> V: Sub<&'v V, Output = V>, for<'b> B: Sub<&'b B, Output = B>, for<'k> PairwiseAuthKey<A, B>: Sub<&'k PairwiseAuthKey<A, B>, Output = PairwiseAuthKey<A, B>>,

type Output = PairwiseAuthShare<V, A, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, V, A, B> SubAssign<&'a PairwiseAuthShare<V, A, B>> for PairwiseAuthShare<V, A, B>

where for<'v> V: SubAssign<&'v V>, for<'b> B: SubAssign<&'b B>, for<'k> PairwiseAuthKey<A, B>: SubAssign<&'k PairwiseAuthKey<A, B>>,

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

Performs the -= operation.

impl<'a, V, A, B> SubAssign for PairwiseAuthShare<V, A, B>

where for<'v> V: SubAssign<&'v V>, for<'b> B: SubAssign<&'b B>, for<'k> PairwiseAuthKey<A, B>: SubAssign<&'k PairwiseAuthKey<A, B>>,

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

Performs the -= operation.

impl<'a, V, A, B> Sum<&'a PairwiseAuthShare<V, A, B>> for PairwiseAuthShare<V, A, B>

where PairwiseAuthShare<V, A, B>: Clone + Default + AddAssign<&'a PairwiseAuthShare<V, A, B>>,

fn sum<I: Iterator<Item = &'a PairwiseAuthShare<V, A, B>>>(iter: I) -> Self

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

impl<V, A, B> Sum for PairwiseAuthShare<V, A, B>

where for<'v> V: AddAssign<&'v V>, for<'b> B: AddAssign<&'b B>, for<'k> PairwiseAuthKey<A, B>: AddAssign<&'k PairwiseAuthKey<A, B>>, PairwiseAuthShare<V, A, 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<V, A, B> VerifiableWith for PairwiseAuthShare<V, A, B>

where for<'a, 'a> V: Clone + PartialEq + Send + Sync + 'static + Serialize + DeserializeOwned + SchemaWrite<Src = V> + for<'de> SchemaRead<'de, Dst = V> + Add<&'a V, Output = V> + Mul<&'a A, Output = B>, A: Clone, B: Clone + Send + Sync + 'static + Serialize + DeserializeOwned + SchemaWrite<Src = B> + for<'de> SchemaRead<'de, Dst = B> + ConstantTimeEq + SubAssign + for<'b> Add<&'b B, Output = B>,

fn verify_from_peer_with( &self, open_share: PairwiseAuthOpenShare<V, B>, peer: PeerIndex, _verification_data: (), ) -> Result<(), PrimitiveError>

Check the MACs of the share received from another peer.

fn verify_with( &self, open_shares: Vec<PairwiseAuthOpenShare<V, B>>, _verification_data: (), ) -> Result<(), PrimitiveError>

Check the MACs of each share received from all other peers.

type VerificationData = ()

The associated data that is used to verify this secret shared type.

fn verify_all_with( shares: Vec<Self>, verification_data: Self::VerificationData, ) -> Result<(), PrimitiveError>

Verify all shares by opening each share towards all other peers and performing pairwise verification of the openings.

impl<V: Eq, A: Eq, B: Eq> Eq for PairwiseAuthShare<V, A, B>

impl<V, A, B> StructuralPartialEq for PairwiseAuthShare<V, A, B>