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
use snarkvm_curves::traits::Group;
use snarkvm_fields::{ConstraintFieldError, Field, ToConstraintField};
use snarkvm_utilities::{FromBytes, ToBytes};
use rand::Rng;
use std::io::{Read, Result as IoResult, Write};
#[derive(Derivative)]
#[derivative(
Clone(bound = "G: Group"),
Debug(bound = "G: Group"),
PartialEq(bound = "G: Group"),
Eq(bound = "G: Group")
)]
pub struct GroupEncryptionParameters<G: Group> {
pub generator_powers: Vec<G>,
pub salt: [u8; 32],
}
impl<G: Group> GroupEncryptionParameters<G> {
pub fn setup<R: Rng>(rng: &mut R, private_key_size_in_bits: usize) -> Self {
assert!(private_key_size_in_bits < usize::MAX - 63);
let num_powers = (private_key_size_in_bits + 63) & !63usize;
Self {
generator_powers: Self::generator(num_powers, rng),
salt: rng.gen(),
}
}
fn generator<R: Rng>(num_powers: usize, rng: &mut R) -> Vec<G> {
let mut generator_powers = Vec::with_capacity(num_powers);
let mut generator = G::rand(rng);
for _ in 0..num_powers {
generator_powers.push(generator);
generator.double_in_place();
}
generator_powers
}
}
impl<G: Group> ToBytes for GroupEncryptionParameters<G> {
fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
(self.generator_powers.len() as u32).write_le(&mut writer)?;
for g in &self.generator_powers {
g.write_le(&mut writer)?;
}
self.salt.write_le(&mut writer)
}
}
impl<G: Group> FromBytes for GroupEncryptionParameters<G> {
#[inline]
fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
let generator_powers_length: u32 = FromBytes::read_le(&mut reader)?;
let mut generator_powers = Vec::with_capacity(generator_powers_length as usize);
for _ in 0..generator_powers_length {
let g: G = FromBytes::read_le(&mut reader)?;
generator_powers.push(g);
}
let salt: [u8; 32] = FromBytes::read_le(&mut reader)?;
Ok(Self { generator_powers, salt })
}
}
impl<F: Field, G: Group + ToConstraintField<F>> ToConstraintField<F> for GroupEncryptionParameters<G> {
#[inline]
fn to_field_elements(&self) -> Result<Vec<F>, ConstraintFieldError> {
Ok(Vec::new())
}
}