fastcrypto-tbls 0.1.0

Threshold BLS and DKG protocols
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

// Copyright (c) 2022, Mysten Labs, Inc.
// SPDX-License-Identifier: Apache-2.0

use crate::nizk::{DLNizk, DdhTupleNizk};
use crate::random_oracle::RandomOracle;
use fastcrypto::groups::bls12381::{G1Element, G2Element};
use fastcrypto::groups::ristretto255::RistrettoPoint;
use fastcrypto::groups::{FiatShamirChallenge, GroupElement, Scalar};
use rand::thread_rng;
use serde::de::DeserializeOwned;
use serde::Serialize;

#[generic_tests::define]
mod point_tests {
    use super::*;

    #[test]
    fn test_dl_nizk<G: GroupElement + Serialize + DeserializeOwned>()
    where
        G::ScalarType: FiatShamirChallenge + DeserializeOwned,
    {
        // basic flow
        let aux_data = [1, 2, 3];
        let x = G::ScalarType::rand(&mut thread_rng());
        let g_x = G::generator() * x;
        let nizk = DLNizk::create(
            &x,
            &g_x,
            &aux_data,
            &RandomOracle::new("test"),
            &mut thread_rng(),
        );
        assert!(nizk
            .verify(&g_x, &aux_data, &RandomOracle::new("test"))
            .is_ok());
        assert!(nizk
            .verify(&g_x, &aux_data, &RandomOracle::new("test2"))
            .is_err());
        assert!(nizk
            .verify(&G::generator(), &aux_data, &RandomOracle::new("test"))
            .is_err());
        assert!(nizk
            .verify(&g_x, &[0, 0], &RandomOracle::new("test"))
            .is_err());

        // x_g=inf should be rejected
        let zero = G::ScalarType::zero();
        let inf = G::zero();
        let g = G::generator();
        let invalid_nizk = DLNizk::create(
            &zero,
            &inf,
            &aux_data,
            &RandomOracle::new("test"),
            &mut thread_rng(),
        );
        assert!(invalid_nizk
            .verify(&inf, &aux_data, &RandomOracle::new("test"))
            .is_err());
        assert!(invalid_nizk
            .verify(&g, &aux_data, &RandomOracle::new("test"))
            .is_err());

        // serde
        let as_bytes = bcs::to_bytes(&nizk).unwrap();
        let nizk2: DLNizk<G> = bcs::from_bytes(&as_bytes).unwrap();
        assert_eq!(nizk, nizk2);
        let as_bytes = bcs::to_bytes(&(G::generator(), G::ScalarType::generator())).unwrap();
        assert!(bcs::from_bytes::<DLNizk<G>>(&as_bytes).is_ok());
        let as_bytes = bcs::to_bytes(&(G::zero(), G::ScalarType::generator())).unwrap();
        assert!(bcs::from_bytes::<DLNizk<G>>(&as_bytes).is_err());
        let as_bytes = bcs::to_bytes(&(G::generator(), G::ScalarType::zero())).unwrap();
        assert!(bcs::from_bytes::<DLNizk<G>>(&as_bytes).is_err());
    }

    #[test]
    fn test_ddh_nizk<G: GroupElement + Serialize + DeserializeOwned>()
    where
        G::ScalarType: FiatShamirChallenge + DeserializeOwned,
    {
        // basic flow
        let x1 = G::ScalarType::rand(&mut thread_rng());
        let x2 = G::ScalarType::rand(&mut thread_rng());
        let g_x1 = G::generator() * x1;
        let g_x2 = G::generator() * x2;
        let g_x1_x2 = g_x1 * x2;
        let nizk = DdhTupleNizk::create(
            &x2,
            &g_x1,
            &g_x2,
            &g_x1_x2,
            &RandomOracle::new("test"),
            &mut thread_rng(),
        );
        assert!(nizk
            .verify(&g_x1, &g_x2, &g_x1_x2, &RandomOracle::new("test"))
            .is_ok());
        assert!(nizk
            .verify(&g_x1, &g_x2, &g_x1_x2, &RandomOracle::new("test2"))
            .is_err());
        assert!(nizk
            .verify(&g_x1, &g_x2, &g_x2, &RandomOracle::new("test"))
            .is_err());

        // x_g/h_g/h=inf should be rejected
        let invalid_nizk = DdhTupleNizk::create(
            &x2,
            &g_x1,
            &g_x2,
            &g_x1_x2,
            &RandomOracle::new("test"),
            &mut thread_rng(),
        );
        assert!(invalid_nizk
            .verify(&G::zero(), &g_x2, &g_x1_x2, &RandomOracle::new("test"))
            .is_err());
        assert!(invalid_nizk
            .verify(&g_x1, &G::zero(), &g_x1_x2, &RandomOracle::new("test"))
            .is_err());
        assert!(invalid_nizk
            .verify(&g_x1, &g_x2, &G::zero(), &RandomOracle::new("test"))
            .is_err());

        // serde
        let as_bytes = bcs::to_bytes(&nizk).unwrap();
        let nizk2: DdhTupleNizk<G> = bcs::from_bytes(&as_bytes).unwrap();
        assert_eq!(nizk, nizk2);
        let as_bytes =
            bcs::to_bytes(&(G::generator(), G::generator(), G::ScalarType::generator())).unwrap();
        assert!(bcs::from_bytes::<DdhTupleNizk<G>>(&as_bytes).is_ok());
        let as_bytes =
            bcs::to_bytes(&(G::zero(), G::generator(), G::ScalarType::generator())).unwrap();
        assert!(bcs::from_bytes::<DdhTupleNizk<G>>(&as_bytes).is_err());
        let as_bytes =
            bcs::to_bytes(&(G::generator(), G::zero(), G::ScalarType::generator())).unwrap();
        assert!(bcs::from_bytes::<DdhTupleNizk<G>>(&as_bytes).is_err());
        let as_bytes =
            bcs::to_bytes(&(G::generator(), G::generator(), G::ScalarType::zero())).unwrap();
        assert!(bcs::from_bytes::<DdhTupleNizk<G>>(&as_bytes).is_err());
    }

    #[instantiate_tests(<RistrettoPoint>)]
    mod ristretto_point {}

    #[instantiate_tests(<G1Element>)]
    mod g1_element {}

    #[instantiate_tests(<G2Element>)]
    mod g2_element {}
}