lattice-commitments 0.0.1

Structured lattice commitments from Baum16.
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

use commitment::BetaRing;
use ring_math::polynomial_ring;
use ring_math::Polynomial;
use ring_math::PolynomialRingElement;
use ring_math::Vector;
use scalarff::scalar_ring;
use scalarff::FieldElement;

mod commitment;

use commitment::Vcs;

// creates a scalar ring struct DilithiumRingElement
scalar_ring!(DilithiumRingElement, 8380417, "dilithium 23 bit");
scalar_ring!(BabyBearRingElement, 2013265921, "baby bear 32 bit");
scalar_ring!(F101, 101u128, "101 field");

// // Change this to OxfoiFieldElement to use 2^64-2^32+1 base field
type ActiveField = BabyBearRingElement;
const RING_DEGREE: usize = 1024;

polynomial_ring!(
    FieldPolynomial,
    ActiveField,
    {
        let mut p = Polynomial::identity();
        p.term(&ActiveField::one(), RING_DEGREE);
        p
    },
    "% x^RING_DEGREE + 1"
);

fn main() {
    println!(
        "Base field cardinality: {} ({})",
        ActiveField::prime(),
        ActiveField::name_str()
    );
    println!(
        "Polynomial ring: ℤ[X]/<X^{} + 1>\n",
        FieldPolynomial::modulus().degree()
    );
    let vcs = Vcs::new(RING_DEGREE);
    // the value being committed to
    let x = Vector::<FieldPolynomial>::sample_uniform(vcs.l, &mut rand::thread_rng());

    // r and x are secret until opening
    // alpha is a public parameter
    println!(
        "Committing to {} polynomials, each containing {} coefficients:\n{}\n",
        vcs.l,
        FieldPolynomial::modulus().degree(),
        {
            let mut s = x
                .iter()
                .map(|v| v.to_string())
                .collect::<Vec<_>>()
                .join(",\n");
            s.truncate(256);
            s += "...";
            s
        }
    );
    let (alpha, commitment, r) = vcs.commit(&x, &mut rand::thread_rng());
    println!(
        "Opening commitment with secret vector ({} polynomials):\n{}\n",
        vcs.k,
        {
            let mut s = r
                .iter()
                .map(|v| v.to_string())
                .collect::<Vec<_>>()
                .join(",\n");
            s.truncate(256);
            s += "...";
            s
        }
    );
    let valid = vcs.open(&commitment, &alpha, &x, &r);
    if valid {
        println!("Commitment opening is valid!\n");
        println!(
            "Commitment size: {} bytes",
            commitment.len() * FieldPolynomial::byte_len()
        );
        println!(
            "Public parameters size: {} bytes",
            alpha.dimensions.0 * alpha.dimensions.1 * FieldPolynomial::byte_len()
        );
        println!("Secret size: {} bytes", r.len() * BetaRing::byte_len());
    } else {
        println!("Commitment opening is NOT valid!")
    }

    assert!(valid);

    // TODO: fix zk proofs of opening
    //
    // println!("\nGenerating ZK proof of opening");
    // let (t, z, d) = vcs.prove_opening(alpha.clone(), r);
    // println!("ZK proof:");
    // println!("t: {} polynomials", t.len());
    // println!("z: {} polynomials", z.len());
    // println!("d: {d}");
    // let valid = vcs.verify_opening_proof(t, d, z, commitment, alpha);
    // assert!(valid);
}