arcium-primitives 0.4.5

Arcium primitives
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::mem::MaybeUninit;

use serde::{de::DeserializeOwned, Deserialize, Serialize};
use wincode::{
    io::{Reader, Writer},
    ReadResult,
    SchemaRead,
    SchemaWrite,
    WriteResult,
};

use crate::{
    algebra::{
        elliptic_curve::{BaseField, Point, ScalarField},
        field::{binary::Gf2_128, FieldElement, SubfieldElement},
    },
    types::heap_array::{CurvePoints, FieldElements, SubfieldElements},
};

/// Generic opening of a [`PairwiseAuthShare`]: the value and the corresponding MAC,
/// shared towards a remote peer for verification.
///
/// All four concrete opening types are type aliases of this struct:
/// - [`OpenFieldShare<F>`]     = `PairwiseAuthOpenShare<SubfieldElement<F>,   FieldElement<F>>`
/// - [`OpenFieldShares<F, M>`] = `PairwiseAuthOpenShare<SubfieldElements<F,M>,FieldElements<F,M>>`
/// - [`OpenPointShare<C>`]     = `PairwiseAuthOpenShare<Point<C>,             Point<C>>`
/// - [`OpenPointShares<C, M>`] = `PairwiseAuthOpenShare<CurvePoints<C,M>,     CurvePoints<C,M>>`
#[derive(Debug, Copy, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound = "V: Serialize + DeserializeOwned, Mac: Serialize + DeserializeOwned")]
#[repr(C)]
pub struct PairwiseAuthOpenShare<V, Mac> {
    pub value: V,
    pub mac: Mac,
}

impl<V, Mac> SchemaWrite for PairwiseAuthOpenShare<V, Mac>
where
    V: SchemaWrite<Src = V>,
    Mac: SchemaWrite<Src = Mac>,
{
    type Src = Self;

    fn size_of(src: &Self) -> WriteResult<usize> {
        Ok(V::size_of(&src.value)? + Mac::size_of(&src.mac)?)
    }

    fn write(writer: &mut impl Writer, src: &Self) -> WriteResult<()> {
        V::write(writer, &src.value)?;
        Mac::write(writer, &src.mac)
    }
}

impl<'de, V, Mac> SchemaRead<'de> for PairwiseAuthOpenShare<V, Mac>
where
    V: SchemaRead<'de, Dst = V>,
    Mac: SchemaRead<'de, Dst = Mac>,
{
    type Dst = Self;

    fn read(reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self>) -> ReadResult<()> {
        let mut value = MaybeUninit::<V>::uninit();
        let mut mac = MaybeUninit::<Mac>::uninit();
        V::read(reader, &mut value)?;
        Mac::read(reader, &mut mac)?;
        // SAFETY: all fields were initialised by the reads above
        let value = unsafe { value.assume_init() };
        let mac = unsafe { mac.assume_init() };
        dst.write(PairwiseAuthOpenShare { value, mac });
        Ok(())
    }
}

impl<V, Mac> PairwiseAuthOpenShare<V, Mac> {
    pub fn new(value: V, mac: Mac) -> Self {
        Self { value, mac }
    }

    pub fn get_value(&self) -> &V {
        &self.value
    }

    pub fn get_mac(&self) -> &Mac {
        &self.mac
    }
}

// --- Aliases --- //

// Single-element

/// Opening of a single authenticated field share.
/// Alias for [`PairwiseAuthOpenShare<SubfieldElement<F>, FieldElement<F>>`].
pub type OpenFieldShare<F> = PairwiseAuthOpenShare<SubfieldElement<F>, FieldElement<F>>;
/// Opening of a single authenticated curve-point share.
/// Alias for [`PairwiseAuthOpenShare<Point<C>, Point<C>>`].
pub type OpenPointShare<C> = PairwiseAuthOpenShare<Point<C>, Point<C>>;
/// Opening of a single authenticated share of a scalar field element (`ScalarField<C>`).
pub type OpenScalarShare<C> = OpenFieldShare<ScalarField<C>>;
/// Opening of a single authenticated share of a base field element (`BaseField<C>`).
pub type OpenBaseFieldShare<C> = OpenFieldShare<BaseField<C>>;
/// Opening of a single authenticated share of a GF(2^128) bit.
pub type OpenBitShare = OpenFieldShare<Gf2_128>;
/// Opening of a batch of `M` authenticated field shares.
/// Alias for [`PairwiseAuthOpenShare<SubfieldElements<F,M>, FieldElements<F,M>>`].
pub type OpenFieldShares<F, M> = PairwiseAuthOpenShare<SubfieldElements<F, M>, FieldElements<F, M>>;

// Batched

/// Opening of a batch of `M` authenticated curve-point shares.
/// Alias for [`PairwiseAuthOpenShare<CurvePoints<C,M>, CurvePoints<C,M>>`].
pub type OpenPointShares<C, M> = PairwiseAuthOpenShare<CurvePoints<C, M>, CurvePoints<C, M>>;
/// Opening of a batch of authenticated scalar field shares. See [`PairwiseAuthOpenShare`].
pub type OpenScalarShares<C, M> = OpenFieldShares<ScalarField<C>, M>;
/// Opening of a batch of authenticated base field shares. See [`PairwiseAuthOpenShare`].
pub type OpenBaseFieldShares<C, M> = OpenFieldShares<BaseField<C>, M>;