sqisign-verify 0.3.0

SQIsign signature verification (no_std, zero allocation, pure Rust)
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

use crate::ec::jacobian::{jac_add, jac_dbl, jac_dbl_ws};
use crate::ec::point::{ec_dbl, test_point_order_twof};
use crate::ec::EcBasis;
use crate::fp::FpBackend;

use super::{ThetaCoupleCurve, ThetaCoupleJacPoint, ThetaCouplePoint, ThetaKernelCouplePoints};

/// Double a couple point on E1 x E2.
///
/// `(P1, P2) -> ([2]P1, [2]P2)`
#[inline]
pub fn double_couple_point<L: FpBackend>(
    p: &ThetaCouplePoint<L>,
    e12: &ThetaCoupleCurve<L>,
) -> ThetaCouplePoint<L> {
    ThetaCouplePoint {
        p1: ec_dbl(&p.p1, &e12.e1),
        p2: ec_dbl(&p.p2, &e12.e2),
    }
}

/// Iterated doubling of a couple point: \[2ⁿ\](P1, P2).
#[inline]
pub fn double_couple_point_iter<L: FpBackend>(
    p: &ThetaCouplePoint<L>,
    n: u32,
    e12: &ThetaCoupleCurve<L>,
) -> ThetaCouplePoint<L> {
    if n == 0 {
        p.clone()
    } else {
        let mut out = double_couple_point(p, e12);
        for _ in 1..n {
            out = double_couple_point(&out, e12);
        }
        out
    }
}

/// Add two Jacobian couple points on E1 x E2.
///
/// (P1, P2) + (Q1, Q2) = (P1+Q1, P2+Q2)
#[inline]
pub fn add_couple_jac_points<L: FpBackend>(
    t1: &ThetaCoupleJacPoint<L>,
    t2: &ThetaCoupleJacPoint<L>,
    e12: &ThetaCoupleCurve<L>,
) -> ThetaCoupleJacPoint<L> {
    ThetaCoupleJacPoint {
        p1: jac_add(&t1.p1, &t2.p1, &e12.e1),
        p2: jac_add(&t1.p2, &t2.p2, &e12.e2),
    }
}

/// Double a Jacobian couple point on E1 x E2.
#[inline]
pub fn double_couple_jac_point<L: FpBackend>(
    p: &ThetaCoupleJacPoint<L>,
    e12: &ThetaCoupleCurve<L>,
) -> ThetaCoupleJacPoint<L> {
    ThetaCoupleJacPoint {
        p1: jac_dbl(&p.p1, &e12.e1),
        p2: jac_dbl(&p.p2, &e12.e2),
    }
}

/// Iterated Jacobian doubling with Weierstrass optimization for n >= 2.
#[inline]
pub fn double_couple_jac_point_iter<L: FpBackend>(
    p: &ThetaCoupleJacPoint<L>,
    n: u32,
    e12: &ThetaCoupleCurve<L>,
) -> ThetaCoupleJacPoint<L> {
    if n == 0 {
        p.clone()
    } else if n == 1 {
        double_couple_jac_point(p, e12)
    } else {
        let (mut q1, mut t1, a1) = p.p1.to_ws(&e12.e1);
        let (mut q2, mut t2, a2) = p.p2.to_ws(&e12.e2);

        for _ in 0..n {
            let (new_q1, new_t1) = jac_dbl_ws(&q1, &t1);
            q1 = new_q1;
            t1 = new_t1;
            let (new_q2, new_t2) = jac_dbl_ws(&q2, &t2);
            q2 = new_q2;
            t2 = new_t2;
        }

        ThetaCoupleJacPoint {
            p1: crate::ec::JacPoint::from_ws(&q1, &a1, &e12.e1),
            p2: crate::ec::JacPoint::from_ws(&q2, &a2, &e12.e2),
        }
    }
}

/// Convert Jacobian couple points to (X : Z) couple points.
#[inline]
pub fn couple_jac_to_xz<L: FpBackend>(p: &ThetaCoupleJacPoint<L>) -> ThetaCouplePoint<L> {
    ThetaCouplePoint {
        p1: p.p1.to_xz(),
        p2: p.p2.to_xz(),
    }
}

/// Pack two EC bases B1, B2 into a kernel triple (T1, T2, T1-T2).
///
/// T1 = (B1.P, B2.P), T2 = (B1.Q, B2.Q), T1-T2 = (B1.PmQ, B2.PmQ)
#[inline]
pub fn copy_bases_to_kernel<L: FpBackend>(
    b1: &EcBasis<L>,
    b2: &EcBasis<L>,
) -> ThetaKernelCouplePoints<L> {
    ThetaKernelCouplePoints {
        t1: ThetaCouplePoint {
            p1: b1.p.clone(),
            p2: b2.p.clone(),
        },
        t2: ThetaCouplePoint {
            p1: b1.q.clone(),
            p2: b2.q.clone(),
        },
        t1m2: ThetaCouplePoint {
            p1: b1.pmq.clone(),
            p2: b2.pmq.clone(),
        },
    }
}

/// Test if both points in a couple point have order exactly 2ᵗ.
#[inline]
pub fn test_couple_point_order_twof<L: FpBackend>(
    p: &ThetaCouplePoint<L>,
    e: &ThetaCoupleCurve<L>,
    t: usize,
) -> subtle::Choice {
    let check_p1 = test_point_order_twof(&p.p1, &e.e1, t);
    let check_p2 = test_point_order_twof(&p.p2, &e.e2, t);
    check_p1 & check_p2
}