sigma-proof-compiler 0.1.0

A Rust library for creating and verifying sigma protocols (zero-knowledge proofs of knowledge) using symbolic computation over elliptic curves
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use curve25519_dalek::{RistrettoPoint, Scalar};
use rand_core::CryptoRngCore;

use crate::errors::{SigmaProofError, SigmaProofResult};

//
// Traits only available in this crate
//

pub(crate) mod sealed_witness {
    pub trait Sealed {}

    impl Sealed for super::SymScalar {}
}

pub(crate) mod sealed_instance {
    pub trait Sealed {}

    impl Sealed for super::SymScalar {}
    impl Sealed for super::SymPoint {}
}

pub trait SymWitness: sealed_witness::Sealed {
    fn rand<R: CryptoRngCore + ?Sized>(rng: &mut R) -> Self;
    fn values(&self) -> SigmaProofResult<Vec<Scalar>>;
    fn from_values(scalars: &[Scalar]) -> SigmaProofResult<Self>
    where
        Self: Sized;
    fn num_scalars() -> usize;
    fn get_var_name(index: usize) -> &'static str;
}

pub trait SymInstance: sealed_instance::Sealed {
    fn num_scalars() -> usize;
    fn num_points() -> usize;
    fn from_values(scalars: &[Scalar], points: &[RistrettoPoint]) -> SigmaProofResult<Self>
    where
        Self: Sized;
    fn get_field_names() -> Vec<&'static str>;
    fn points(&self) -> Vec<SymPoint>;
    fn scalars(&self) -> Vec<SymScalar>;
}

//
// Implementations
//

pub use crate::equations::{SymPoint, SymScalar};
pub use sigma_proof_compiler_derive::{SymInstance, SymWitness};

impl SymWitness for SymScalar {
    fn rand<R: CryptoRngCore + ?Sized>(rng: &mut R) -> Self {
        SymScalar::Const(Scalar::random(rng))
    }

    fn values(&self) -> SigmaProofResult<Vec<Scalar>> {
        match self {
            SymScalar::Var(None) => Err(SigmaProofError::UninstantiatedScalar),
            _ => Ok(vec![self.evaluate()?]),
        }
    }

    fn from_values(scalars: &[Scalar]) -> SigmaProofResult<Self> {
        if scalars.len() == 1 {
            Ok(SymScalar::Var(Some(scalars[0])))
        } else {
            Err(SigmaProofError::TooManyScalars {
                expected: 1,
                actual: scalars.len(),
            })
        }
    }

    fn num_scalars() -> usize {
        1
    }

    fn get_var_name(index: usize) -> &'static str {
        if index == 0 {
            "s"
        } else {
            "unknown"
        }
    }
}

impl SymInstance for SymScalar {
    fn num_scalars() -> usize {
        1
    }

    fn num_points() -> usize {
        0
    }

    fn from_values(scalars: &[Scalar], points: &[RistrettoPoint]) -> SigmaProofResult<Self> {
        if scalars.len() == 1 && points.is_empty() {
            Ok(SymScalar::Const(scalars[0]))
        } else {
            Err(SigmaProofError::TooManyScalars {
                expected: 1,
                actual: scalars.len(),
            })
        }
    }

    fn get_field_names() -> Vec<&'static str> {
        vec!["scalar"]
    }

    fn points(&self) -> Vec<SymPoint> {
        vec![]
    }

    fn scalars(&self) -> Vec<SymScalar> {
        vec![self.clone()]
    }
}

impl SymInstance for SymPoint {
    fn num_scalars() -> usize {
        0
    }

    fn num_points() -> usize {
        1
    }

    fn from_values(scalars: &[Scalar], points: &[RistrettoPoint]) -> SigmaProofResult<Self> {
        if scalars.is_empty() && points.len() == 1 {
            Ok(SymPoint::Const(points[0]))
        } else {
            Err(SigmaProofError::TooManyScalars {
                expected: 0,
                actual: scalars.len(),
            })
        }
    }

    fn get_field_names() -> Vec<&'static str> {
        vec!["point"]
    }

    fn points(&self) -> Vec<SymPoint> {
        vec![self.clone()]
    }

    fn scalars(&self) -> Vec<SymScalar> {
        vec![]
    }
}