amalie 0.1.2

Mathmatical library written for rust and python
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

use crate::{zz, ZZ, Error, Result};
use std::sync::Arc;

/// Montgomery curve
/// b*y^2 = x^3 + a*x + 1
#[derive(Eq, PartialEq, Clone, Debug)]
pub struct MontGomeryCurve {
    a: ZZ,
    b: ZZ,
    n: ZZ,
}

impl MontGomeryCurve  {
    pub fn new(a: ZZ, b: ZZ, n: ZZ) -> MontGomeryCurve{
        MontGomeryCurve {
            a, b, n
        }
    }
}

#[derive(PartialEq, Eq, Clone, Debug)]
pub enum Point {
    Val{ x: ZZ, y: ZZ, curve: Arc<MontGomeryCurve> },
    Inf,
}

impl Point {
    pub fn new(x: ZZ, y: ZZ, curve: Arc<MontGomeryCurve>) -> Point {
        Point::Val{ x, y, curve }
    }

    pub fn inf() -> Self {
        Point::Inf
    }

    pub fn neg(self) -> Result<Point> {
        match self {
            Point::Inf => {
                return Err(Error::NoResult);
            },
            Point::Val{x, y, curve} => {
                return Ok(Point::Val{ x, y: y.neg(), curve });
            },
        }
    }

    pub fn is_inf(&self) -> bool {
        *self == Point::Inf
    }

    pub fn add_with_diff(&self, rhs: Point, diff: &Point) -> Point {
        match (&self, &rhs, &diff) {
            (Point::Val{x:x1, y:y1, curve:curve1}, Point::Val{x:x2, y:y2, curve: curve2}, Point::Val{x:x3, y:y3, curve: curve3}) => {
                assert_eq!(curve1, curve2);
                assert_eq!(curve2, curve3);
                let u = (x1 - y1) * (x2 + y2);
                let v = (x1 + y1) * (x2 - y2);
                let add = &u + &v;
                let sub = &u - &v;
                let new_x = (y3 * &add * &add) % &curve1.n;
                let new_y = (x3 * &sub * &sub) % &curve1.n;
                return Point::new(new_x, new_y, curve1.clone());
                
            }
            _ => {
                panic!("Unable to add");
            }
        }
    }

    pub fn double(self) -> Point {
        match self {
            Point::Val{x, y, curve} => {
                let u = (&x + &y).pow(&zz!(2));
                let v = (x - y).pow(&zz!(2));
                let diff = &u - &v;
                let new_x = (&u * &v) % &curve.n;
                let tmp = (&curve.a+2) >> 2;
                let new_y = ((&v + tmp * &diff) * &diff) % &curve.n;
                return Point::new(new_x, new_y, curve.clone());
            },
            _ => {
                panic!("Unable to double");
            }
        }
    }

    pub fn product(&self, k: &ZZ) -> Point {
        let mut out = self.clone();
        let mut r = self.clone().double();
        for i in 0..k.bits() {
            if (k >> i) & 1 == 1 {
                out = r.add_with_diff(out, &self); 
                r = r.double();
            }
            else {
                r = out.add_with_diff(r, &self);
                out = out.double();
            }
        }
        return out;
    }
}


#[cfg(test)]
mod test {
    use super::{Point, MontGomeryCurve};
    use crate::{zz, ZZ};
    use std::sync::Arc;

    #[test]
    fn test_point() {
        let curve = Arc::new(MontGomeryCurve::new(zz!(1423), zz!(5123), zz!(97872)));
        let curve_c = Arc::new(MontGomeryCurve::new(zz!(1423), zz!(5123), zz!(97872)));
        let point = Point::new(zz!(129379), zz!(659742), curve.clone());
        let point_c = Point::new(zz!(129379), zz!(659742), curve_c.clone());
        assert_eq!(point, point_c);
    }
}