Skip to content

Commit e795323

Browse files
holaguzholaguz
committed
feat: add implementation using generics for elliptic curves over finite fields
1 parent 490fa56 commit e795323

File tree

3 files changed

+554
-0
lines changed

3 files changed

+554
-0
lines changed

‎src/ec_generic.rs

+293
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,293 @@
1+
#![allow(dead_code)]
2+
3+
use crate::finite_field_generic::FiniteField;
4+
use std::ops::{Add, Div, Mul, Rem, Sub};
5+
6+
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
7+
pub enum PointType<T: FiniteField> {
8+
Invalid,
9+
Infinity,
10+
Point(Coordinates<T>),
11+
}
12+
13+
// An elliptic curve defined by the equation y**2 = x**3 + Ax + B
14+
#[derive(Debug, Eq, PartialEq)]
15+
pub struct ECurve<T: FiniteField> {
16+
a: T,
17+
b: T,
18+
}
19+
20+
// Coordinates of a point on the curve
21+
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
22+
pub struct Coordinates<T: FiniteField> {
23+
pub x: T,
24+
pub y: T,
25+
}
26+
27+
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
28+
pub struct ECPoint<'a, T: FiniteField> {
29+
curve: &'a ECurve<T>,
30+
p: PointType<T>,
31+
}
32+
33+
impl<'a, T: FiniteField> ECurve<T> {
34+
pub const fn new(a: T, b: T) -> Self {
35+
Self { a, b }
36+
}
37+
38+
pub fn point_at(&'a self, x: T, y: T) -> ECPoint<'a, T> {
39+
match self.contains(x, y) {
40+
false => ECPoint::<'a, T> {
41+
curve: self,
42+
p: PointType::Invalid,
43+
},
44+
true => ECPoint::<'a, T> {
45+
curve: self,
46+
p: PointType::Point(Coordinates { x, y }),
47+
},
48+
}
49+
}
50+
51+
pub fn infinity(&'a self) -> ECPoint<'a, T> {
52+
ECPoint::<'a, T> {
53+
curve: self,
54+
p: PointType::Infinity,
55+
}
56+
}
57+
58+
pub fn contains(&self, x: T, y: T) -> bool {
59+
y * y == x * x * x + self.a * x + self.b
60+
}
61+
}
62+
63+
impl<T: FiniteField> Add for ECPoint<'_, T> {
64+
type Output = Self;
65+
66+
fn add(self, rhs: Self) -> Self {
67+
// Points must be from the same curve
68+
assert!(
69+
self.curve == rhs.curve,
70+
"Cannot add points from different curves"
71+
);
72+
73+
let (p, rhs) = match (self.p, rhs.p) {
74+
// Infinity is the additive identity
75+
(PointType::Infinity, _) => return rhs,
76+
(_, PointType::Infinity) => return self,
77+
78+
// Invalid + anything = Invalid
79+
(PointType::Invalid, _) | (_, PointType::Invalid) => {
80+
return ECPoint {
81+
curve: self.curve,
82+
p: PointType::Invalid,
83+
}
84+
}
85+
(PointType::Point(p1), PointType::Point(p2)) => (p1, p2),
86+
};
87+
88+
// 2. Points are additive inverses. The two points have the same x coord but different y.
89+
if p.x == rhs.x && p.y != rhs.y {
90+
return ECPoint {
91+
curve: self.curve,
92+
p: PointType::Infinity,
93+
};
94+
}
95+
96+
// 3. Either the points are the same point (P1 = P2) or are different (P1 != P2)
97+
// The only difference between the two cases is how we calculate the slope. For P1 == P2,
98+
// the line is tangent to the curve. For P1 != P2 the line intersects the curve at both
99+
// points. Furthermore, when P1 == P2 and P1.y == 0 the tangent line is vertical and the
100+
// resulting point lies at infinity.
101+
let s = match p == rhs {
102+
// 3.1. Points are the same point.
103+
true => {
104+
// Special case: If the y coord is 0, the tangent line is vertical since the elliptic
105+
// curve is symmetrical wrt. the x axis. This results on a point on the infinity.
106+
if p.y == T::from_i32(0).unwrap() {
107+
return ECPoint {
108+
curve: self.curve,
109+
p: PointType::Infinity,
110+
};
111+
}
112+
let three = T::from_i32(3).unwrap();
113+
let two = T::from_i32(2).unwrap();
114+
(three * p.x * p.x + self.curve.a) / (two * p.y)
115+
}
116+
false => (rhs.y - p.y) / (rhs.x - p.x),
117+
};
118+
119+
let x = s * s - p.x - rhs.x;
120+
let y = s * (p.x - x) - p.y;
121+
122+
ECPoint {
123+
curve: self.curve,
124+
p: PointType::Point(Coordinates { x, y }),
125+
}
126+
}
127+
}
128+
129+
#[cfg(test)]
130+
mod tests {
131+
use super::*;
132+
133+
mod i32_field {
134+
use super::*;
135+
#[test]
136+
fn test_contains() {
137+
let curve = ECurve::new(5_i32, 7_i32);
138+
let contained = curve.contains(-1, 1);
139+
let not_contained = curve.contains(-1, -2);
140+
141+
assert!(contained);
142+
assert!(!not_contained);
143+
}
144+
145+
#[test]
146+
fn test_point_at() {
147+
let curve = ECurve::new(5_i32, 7_i32);
148+
let exists = curve.point_at(-1, 1);
149+
let not_exists = curve.point_at(-1, -2);
150+
151+
assert_eq!(exists.p, PointType::Point(Coordinates { x: -1, y: 1 }));
152+
assert_eq!(not_exists.p, PointType::Invalid);
153+
}
154+
155+
#[test]
156+
fn test_add_infinity() {
157+
let curve = ECurve::new(5_i32, 7_i32);
158+
let a = curve.point_at(-1, 1);
159+
let ifty = curve.infinity();
160+
161+
assert_eq!(a + ifty, a);
162+
assert_eq!(ifty + a, a);
163+
}
164+
165+
#[test]
166+
fn test_add_inverse() {
167+
let curve = ECurve::new(5_i32, 7_i32);
168+
let a = curve.point_at(-1, 1);
169+
let b = curve.point_at(-1, -1);
170+
171+
assert_eq!(a + b, curve.infinity());
172+
assert_eq!(b + a, curve.infinity());
173+
}
174+
175+
#[test]
176+
fn test_add_same() {
177+
let curve = ECurve::new(5_i32, 7_i32);
178+
let a = curve.point_at(-1, -1);
179+
let res = curve.point_at(18, 77);
180+
assert_eq!(res, a + a);
181+
182+
let a = curve.point_at(-1, 1);
183+
let res = curve.point_at(18, -77);
184+
assert_eq!(res, a + a);
185+
}
186+
187+
#[test]
188+
fn test_add_same_at_y0() {
189+
let curve = ECurve::new(1_i32, 10_i32);
190+
let p = curve.point_at(-2, 0);
191+
assert_eq!(curve.infinity(), p + p);
192+
}
193+
194+
#[test]
195+
fn test_add() {
196+
let curve = ECurve::new(5_i32, 7_i32);
197+
let a = curve.point_at(-1, -1);
198+
let b = curve.point_at(2, 5);
199+
let res = curve.point_at(3, -7);
200+
assert_eq!(res, a + b);
201+
assert_eq!(res, b + a);
202+
}
203+
}
204+
205+
mod prime_field {
206+
use super::*;
207+
use crate::finite_field_generic::FieldElement;
208+
type FE = FieldElement<i32>;
209+
210+
#[test]
211+
fn test_contains() {
212+
let a = FE::new(0, 103).unwrap();
213+
let b = FE::new(7, 103).unwrap();
214+
let curve = ECurve::new(a, b);
215+
216+
let x = FE::new(17, 103).unwrap();
217+
let y = FE::new(64, 103).unwrap();
218+
let contained = curve.contains(x, y);
219+
220+
let x = FE::new(0, 103).unwrap();
221+
let y = FE::new(1, 103).unwrap();
222+
let not_contained = curve.contains(x, y);
223+
224+
assert!(contained);
225+
assert!(!not_contained);
226+
227+
// The same point (17,64) should not be contained in the curve over the field of the
228+
// integers
229+
let curve = ECurve::new(0, 7);
230+
let not_contained = curve.contains(17, 64);
231+
assert!(!not_contained);
232+
}
233+
234+
// #[test]
235+
// fn test_point_at() {
236+
// let curve = ECurve::new(5_i32, 7_i32);
237+
// let exists = curve.point_at(-1, 1);
238+
// let not_exists = curve.point_at(-1, -2);
239+
//
240+
// assert_eq!(exists.p, PointType::Point(Coordinates { x: -1, y: 1 }));
241+
// assert_eq!(not_exists.p, PointType::Invalid);
242+
// }
243+
//
244+
// #[test]
245+
// fn test_add_infinity() {
246+
// let curve = ECurve::new(5_i32, 7_i32);
247+
// let a = curve.point_at(-1, 1);
248+
// let ifty = curve.infinity();
249+
//
250+
// assert_eq!(a + ifty, a);
251+
// assert_eq!(ifty + a, a);
252+
// }
253+
//
254+
// #[test]
255+
// fn test_add_inverse() {
256+
// let curve = ECurve::new(5_i32, 7_i32);
257+
// let a = curve.point_at(-1, 1);
258+
// let b = curve.point_at(-1, -1);
259+
//
260+
// assert_eq!(a + b, curve.infinity());
261+
// assert_eq!(b + a, curve.infinity());
262+
// }
263+
//
264+
// #[test]
265+
// fn test_add_same() {
266+
// let curve = ECurve::new(5_i32, 7_i32);
267+
// let a = curve.point_at(-1, -1);
268+
// let res = curve.point_at(18, 77);
269+
// assert_eq!(res, a + a);
270+
//
271+
// let a = curve.point_at(-1, 1);
272+
// let res = curve.point_at(18, -77);
273+
// assert_eq!(res, a + a);
274+
// }
275+
//
276+
// #[test]
277+
// fn test_add_same_at_y0() {
278+
// let curve = ECurve::new(1_i32, 10_i32);
279+
// let p = curve.point_at(-2, 0);
280+
// assert_eq!(curve.infinity(), p + p);
281+
// }
282+
//
283+
// #[test]
284+
// fn test_add() {
285+
// let curve = ECurve::new(5_i32, 7_i32);
286+
// let a = curve.point_at(-1, -1);
287+
// let b = curve.point_at(2, 5);
288+
// let res = curve.point_at(3, -7);
289+
// assert_eq!(res, a + b);
290+
// assert_eq!(res, b + a);
291+
// }
292+
}
293+
}

0 commit comments

Comments
 (0)