sangge/ecc_rs
1
0
Fork 0
Code Issues 1 Pull Requests Packages Activity

use less clone and builtin modinv

Browse Source
This commit is contained in:
sangge-redmi 2024-09-05 15:18:33 +08:00
parent 0b9ae82c17
commit 880c34ce03
1 changed files with 37 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
src/lib.rs
View File

@ -16,19 +16,19 @@ struct CurveFp {
}
#[derive(Debug, Clone)]
struct Point {
struct Point<'a> {
x: BigUint,
y: BigUint,
curve: CurveFp,
curve: &'a CurveFp,
}
/// 椭圆曲线上的点（雅可比坐标）
#[derive(Clone)]
struct JacobianPoint {
x: BigUint, // X 坐标
y: BigUint, // Y 坐标
z: BigUint, // Z 坐标
curve: CurveFp, // 椭圆曲线的参数
struct JacobianPoint<'a> {
x: BigUint, // X 坐标
y: BigUint, // Y 坐标
z: BigUint, // Z 坐标
curve: &'a CurveFp, // 椭圆曲线的参数
}
// Initialize the SM2 Curve
@ -68,105 +68,35 @@ fn sm2p256v1() -> CurveFp {
}
}
/// Calculates the greatest common divisor (GCD) of two `BigUint` numbers.
///
/// The function uses the Euclidean algorithm to compute the GCD. The algorithm is based on
/// the principle that the greatest common divisor of two numbers does not change if the larger
/// number is replaced by its difference with the smaller number.
///
/// # Arguments
///
/// * `a` - The first `BigUint` number.
/// * `b` - The second `BigUint` number.
///
/// # Returns
///
/// * `BigUint` - The greatest common divisor of `a` and `b`.
///
/// # Example
///
/// ```
/// let a = BigUint::from(60u32);
/// let b = BigUint::from(48u32);
/// let result = gcd(a, b);
/// assert_eq!(result, BigUint::from(12u32));
/// ```
fn gcd(a: &BigUint, b: &BigUint) -> BigUint {
let mut c = a.clone();
let mut d = b.clone();
while !a.is_zero() {
let temp = c.clone();
c = d % c;
d = temp;
}
d
}
/// Computes the modular inverse of `a` under modulo `m`.
///
/// # Arguments
///
/// * `a` - A reference to a BigUint representing the number to find the modular inverse of.
/// * `p` - A reference to a BigUint representing the modulus.
///
/// # Return1
///
/// * A BigUint representing the modular inverse of `a` modulo `p`.
///
/// # Panics
///
/// This function will panic if the modular inverse does not exist (i.e., if `a` and `p` are not coprime).
fn mod_inverse(a: &BigUint, m: &BigUint) -> BigUint {
let (mut t, mut new_t) = (BigUint::zero(), BigUint::one());
let (mut r, mut new_r) = (m.clone(), a.clone());
while !new_r.is_zero() {
let quotient = &r / &new_r;
let temp_t = new_t.clone();
new_t = if t < (quotient.clone() * &temp_t) {
// BigUint can't be negative,
// so we use mod to handle the case where t < quotient * temp_t
(&t + m - &(quotient.clone() * &temp_t) % m) % m
} else {
&t - &(quotient.clone() * &temp_t)
};
let temp_r = new_r.clone();
new_r = &r - &(quotient.clone() * &temp_r);
r = temp_r;
t = temp_t;
}
if r > BigUint::one() {
panic!("Modular inverse does not exist");
}
if t < BigUint::zero() {
t += m;
}
t
}
fn point_addition(p1: &Point, p2: &Point) -> Point {
fn point_addition<'a>(p1: &'a Point<'a>, p2: &'a Point<'a>) -> Point<'a> {
// 如果 p1 是零点，返回一个新构造的 p2 点，而不是克隆
if p1.x.is_zero() && p1.y.is_zero() {
return p2.clone();
return Point {
x: p2.x.clone(),
y: p2.y.clone(),
curve: p2.curve, // 如果 curve 是引用，保持引用即可
};
}
// 如果 p2 是零点，返回一个新构造的 p1 点，而不是克隆
if p2.x.is_zero() && p2.y.is_zero() {
return p1.clone();
return Point {
x: p1.x.clone(),
y: p1.y.clone(),
curve: p1.curve, // 如果 curve 是引用，保持引用即可
};
}
from_jacobian(jacobian_add(to_jacobian(p1), to_jacobian(p2)))
}
/// 将仿射坐标转换为雅可比坐标 (X, Y, Z)
fn to_jacobian(p: &Point) -> JacobianPoint {
fn to_jacobian<'a>(p: &'a Point) -> JacobianPoint<'a> {
JacobianPoint {
x: p.x.clone(),
y: p.y.clone(),
z: BigUint::one(), // Z = 1 表示仿射坐标
curve: sm2p256v1(),
curve: p.curve,
}
}
@ -176,13 +106,13 @@ fn from_jacobian(p: JacobianPoint) -> Point {
return Point {
x: BigUint::zero(),
y: BigUint::zero(),
curve: sm2p256v1(),
curve: p.curve,
};
}
let p_mod = &p.curve.p;
// 计算 Z 的模反
let z_inv = mod_inverse(&p.z, p_mod);
let z_inv = p.z.modinv(p_mod).expect("modinv failed");
let z_inv2 = (&z_inv * &z_inv) % p_mod; // Z_inv^2
let z_inv3 = (&z_inv2 * &z_inv) % p_mod; // Z_inv^3
@ -193,12 +123,12 @@ fn from_jacobian(p: JacobianPoint) -> Point {
Point {
x: x_affine,
y: y_affine,
curve: sm2p256v1(),
curve: p.curve,
}
}
/// 雅可比坐标下的点加法
fn jacobian_add(p1: JacobianPoint, p2: JacobianPoint) -> JacobianPoint {
fn jacobian_add<'a>(p1: JacobianPoint<'a>, p2: JacobianPoint<'a>) -> JacobianPoint<'a> {
if p1.z.is_zero() {
return p2.clone();
}
@ -245,21 +175,20 @@ fn jacobian_add(p1: JacobianPoint, p2: JacobianPoint) -> JacobianPoint {
x: x3,
y: y3,
z: z3,
curve: sm2p256v1(),
curve: p1.curve,
}
}
/// 雅可比坐标下的点倍运算
fn jacobian_double(p: JacobianPoint) -> JacobianPoint {
let curve = &p.curve;
let p_mod = &curve.p;
let p_mod = &p.curve.p;
if p.y.is_zero() {
return JacobianPoint {
x: BigUint::zero(),
y: BigUint::zero(),
z: BigUint::zero(),
curve: curve.clone(),
curve: p.curve,
};
}
@ -270,7 +199,7 @@ fn jacobian_double(p: JacobianPoint) -> JacobianPoint {
// M = 3 * X^2 + a * Z^4
let z2 = (&p.z * &p.z) % p_mod;
let z4 = (&z2 * &z2) % p_mod;
let m = ((&p.x * &p.x * BigUint::from(3u32)) + &curve.a * &z4) % p_mod;
let m = ((&p.x * &p.x * BigUint::from(3u32)) + &p.curve.a * &z4) % p_mod;
// X3 = M^2 - 2 * S
let x3 = (&m * &m + p_mod - &s * BigUint::from(2u32)) % p_mod;
@ -286,16 +215,16 @@ fn jacobian_double(p: JacobianPoint) -> JacobianPoint {
x: x3,
y: y3,
z: z3,
curve: curve.clone(),
curve: p.curve,
}
}
fn point_multiplication(p: &Point, n: &BigUint) -> Point {
fn point_multiplication<'a>(p: &'a Point<'a>, n: &BigUint) -> Point<'a> {
let mut result = JacobianPoint {
x: BigUint::zero(),
y: BigUint::one(), // 无穷远点的雅可比坐标表示
z: BigUint::zero(),
curve: p.curve.clone(),
curve: p.curve,
};
// 将输入点从仿射坐标转换为雅可比坐标
@ -336,13 +265,13 @@ fn add(p1: (BigUint, BigUint), p2: (BigUint, BigUint)) -> (BigUint, BigUint) {
let point1 = Point {
x: x1,
y: y1,
curve: sm2p256v1(),
curve: &curve,
};
let point2 = Point {
x: x2,
y: y2,
curve: sm2p256v1(),
curve: &curve,
};
let result = point_addition(&point1, &point2);
@ -367,7 +296,7 @@ fn multiply(point: (BigUint, BigUint), mut n: BigUint) -> (BigUint, BigUint) {
let point = Point {
x: point.0,
y: point.1,
curve,
curve: &curve,
};
// Perform point multiplication
let result = point_multiplication(&point, &n);