fastcrypto 0.1.11

Common cryptographic library used at Mysten Labs
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

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

use crate::groups::{Doubling, GroupElement, MultiScalarMul};
use std::ops::{Mul, Neg};

use crate::groups::secp256k1::{ProjectivePoint, Scalar};
use crate::groups::{secp256k1, Scalar as ScalarTrait};
use crate::serde_helpers::ToFromByteArray;
use rand::thread_rng;

#[test]
fn test_arithmetic() {
    let p = ProjectivePoint::generator();
    let two_p = p + p;
    let s = Scalar::from(2);
    assert_eq!(two_p, p.double());
    assert_eq!(two_p, p * s);
    assert_eq!(p, two_p * (Scalar::generator() / s).unwrap());

    // Check that u128 is decoded correctly.
    let x: u128 = 2 << 66;
    let x_scalar = Scalar::from(x);
    let res = x_scalar / Scalar::from(8);
    assert_eq!(res.unwrap(), Scalar::from(2 << 63));
}

#[test]
fn test_serde() {
    let scalar = secp256k1::Scalar::rand(&mut thread_rng());
    let bytes = scalar.to_byte_array();
    let reconstructed = Scalar::from_byte_array(&bytes).unwrap();
    assert_eq!(scalar, reconstructed);

    let point = ProjectivePoint::generator() * scalar;
    let point_bytes = point.to_byte_array();
    let reconstructed_point = ProjectivePoint::from_byte_array(&point_bytes).unwrap();
    assert_eq!(point, reconstructed_point);
}

#[test]
fn test_regression() {
    let scalar = secp256k1::Scalar::from(7);
    assert_eq!(
        scalar.to_byte_array().to_vec(),
        hex::decode("0000000000000000000000000000000000000000000000000000000000000007").unwrap()
    );

    let point = ProjectivePoint::generator() * scalar;
    assert_eq!(
        point.to_byte_array().to_vec(),
        hex::decode("bcf9c4caeddd2be99ce330037e9b413d0e7aeaf265f398a3eab45d6e64f0bd5c00").unwrap()
    );

    let negate = point.neg();
    assert_eq!(
        negate.to_byte_array().to_vec(),
        hex::decode("bcf9c4caeddd2be99ce330037e9b413d0e7aeaf265f398a3eab45d6e64f0bd5c80").unwrap()
    );
}

#[test]
fn test_msm() {
    for l in 1..50 {
        let mut scalars = Vec::new();
        let mut points = Vec::new();
        let mut expected = ProjectivePoint::zero();
        for _ in 0..l {
            let s = Scalar::rand(&mut thread_rng());
            let e = Scalar::rand(&mut thread_rng());
            let g = ProjectivePoint::generator() * e;
            expected += g * s;
            scalars.push(s);
            points.push(g);
        }
        let actual = ProjectivePoint::multi_scalar_mul(&scalars, &points).unwrap();
        assert_eq!(expected, actual);
        assert!(ProjectivePoint::multi_scalar_mul(&scalars[1..], &points).is_err());
    }
}

#[test]
fn test_msm_edge_cases() {
    assert_eq!(
        ProjectivePoint::zero(),
        ProjectivePoint::multi_scalar_mul(&[], &[]).unwrap()
    );

    assert_eq!(
        ProjectivePoint::zero(),
        ProjectivePoint::multi_scalar_mul(&[Scalar::from(0)], &[ProjectivePoint::generator()])
            .unwrap()
    );

    assert_eq!(
        ProjectivePoint::generator(),
        ProjectivePoint::multi_scalar_mul(&[Scalar::from(1)], &[ProjectivePoint::generator()])
            .unwrap()
    );

    assert_eq!(
        ProjectivePoint::zero(),
        ProjectivePoint::multi_scalar_mul(
            &[Scalar::from(1).neg(), Scalar::from(1)],
            &[ProjectivePoint::generator(), ProjectivePoint::generator()]
        )
        .unwrap()
    );

    assert_eq!(
        ProjectivePoint::generator().mul(Scalar::from(2)),
        ProjectivePoint::multi_scalar_mul(
            &[Scalar::from(1), Scalar::from(1)],
            &[ProjectivePoint::generator(), ProjectivePoint::generator()]
        )
        .unwrap()
    );
}