Returns k*(x1,y1) where k is interge using Montgomery ladder for constant time. https://en.wikipedia.org/wiki/Elliptic_curve_point_multiplication#Mont

Returns the sum of (x1,y1) and (x2,y2). ```text x^2 + y^2 = 1 addtion formual: (x3,y3) = (x1,y1) + (x2,y2) = (x1*y2 + x2*y1,y2*y1 - x1*x2) ``` # Exa

Computes two numbers product in modulo arithmetic. ```text a * b (mod m) ``` # Examples ```rust use algebra::arith; fn main() { let x = arith::mod

Computes two numbers product in finite field. ```text a * b (mod primer) ``` # Examples ```rust use fields::field; fn main() { let fp = field::Fie

Computes two numbers sum in modulo arithmetic. ```text a + b (mod m) ``` # Examples ```rust use algebra::arith; fn main() { let x = arith::mod_add

Computes two numbers division in modulo arithmetic. ```text a / b (mod m) ``` # Examples ```rust use algebra::arith; fn main() { let x = arith::mo

Computes two numbers subtract in modulo arithmetic. ```text a - b (mod m) ``` # Examples ```rust use algebra::arith; fn main() { let x = arith::mo

Returns k*(subgroup base point) where k is integer. # Examples ```rust use curves::clockcurve; use subgroups::subgroup; fn main() { let g = clockcu

Returns signature with the param(message, private, random nonce). # Examples ```rust use signatures::ecdsa; fn main() { let message = 10; let priva

Returns k*(base point) where k is integer. # Examples ```rust use curves::clockcurve; fn main() { let curve = clockcurve::ClockCurve::default(); le

Returns the sum of (x1,y1) and (x1,y1). # Examples ```rust use curves::clockcurve; fn main() { let curve = clockcurve::ClockCurve::default(); let p

Computes two numbers sum in finite field. ```text a + b (mod primer) ``` # Examples ```rust use fields::field; fn main() { let fp = field::Field::

Returns the order of the subgroup. # Examples ```rust use curves::clockcurve; use subgroups::subgroup; fn main() { let g = clockcurve::Point { x: 1

Computes exponention in modulo arithmetic. ```text a ^ b (mod m) ``` # Examples ```rust use algebra::arith; fn main() { let x = arith::mod_exp(3,

Computes the inverse of x in modulo arithmetic. ```text x = a ^ -1 (mod m) ``` ```text Algorithm: x == a ^ -1 (mod m) a * x == 1 (mod m) a * x + m *

Returns verify result. # Examples ```rust use signatures::ecdsa; fn main() { let message = 10; let private = 5; let randomk = 7; let ecd = ecdsa::E

Returns all points of the subgroup. # Examples ```rust use curves::clockcurve; use subgroups::subgroup; fn main() { let g = clockcurve::Point { x:

Computes two numbers sum in finite field. ```text a - b (mod primer) ``` # Examples ```rust use fields::field; fn main() { let fp = field::Field::

Implements Extended Euclidean algorithm with non-recursive Given integers a and b, compute integers a and b such that ```text a * x + b * y == gcd(a,

Returns y coordinate if exists, otherwise None. # Examples ```rust use curves::clockcurve; fn main() { let curve = clockcurve::ClockCurve::default(

Returns the final round authenticated key. 𝐾(𝐴𝑙𝑖𝑐𝑒) = (𝑆 − 𝑁^𝑤)^𝑥 # Examples ```rust use zkps::spake2; fn main() { let password = 7; let alice_rand

Checks the point p is on the curve or not. # Examples ```rust use curves::clockcurve; fn main() { let curve = clockcurve::ClockCurve::default(); le

Computes the Legendre symbol a|p using Euler's criterion. ```text Returns 1 if a has a square root modulo p, -1 otherwise. ``` # Examples ```rust u

Returns the first round pake key. 𝐾(𝐴𝑙𝑖𝑐𝑒) = (𝑆 − 𝑁^𝑤)^𝑥 # Examples ```rust use zkps::spake2; fn main() { let password = 7; let alice_rand_number =

Returns the neg(x1,y1) = (-x1,y1). # Examples ```rust use curves::clockcurve; fn main() { let curve = clockcurve::ClockCurve::default(); let p1 = c

Computes the square root (mod primer) of 'a'. ```text Returns None if has no square root. ``` ```text Solve the congruence of the form: x^2 = a (mod

Returns batch verify result. (s1+s2+…+s1000)×G=(r1+…+r1000)+(hash(r1,m1)×P1+ hash(r2,m2)×P2+…+hash(r1000,m1000)×P1000) # Examples ```rust use signa

Computes exponention in finite field. ```text a ^ b (mod m) ``` # Examples ```rust use fields::field; fn main() { let fp = field::Field::new(37);

Returns the sum of (x1,y1) and (x2,-y2). # Examples ```rust use curves::clockcurve; fn main() { let curve = clockcurve::ClockCurve::default(); let

Elliptic Curve Diffie-Hellman (ECDH) 1. Alice selects a as secert key and calculates 𝐴 = 𝑔^𝑎 mod 𝑝 2. Bob b selects b as secert key and calculates 𝐵 =

Implements Euclidean algorithm with non-recursive ```text Algorithm: gcd(37,14) 37 = 14(2) + 9 14 = 9(1) + 5 9 = 5(1) + 4 5 = 4(1) + 1 ``` # Exa

Returns the serialize format of the public key. ```text [0] -- x [1] -- y ``` # Examples ```rust use curves::keys; fn main() { let privatekey = key

Returns signature with the param(message, private, random nonce). r = k*G s = k + hash(r,m)*pk # Examples ```rust use signatures::schnorr; fn main(

s1 = (H(m1) + r1*x1) / k s2 = (H(m2) + r2*x2) / k r1 = r2 and x1 = x2 k = (H(m1) - H(m2)) / (s1 - s2) x1 = ((k * s1) - H(m1)) / r1 https://crypto.sta

s1 = k+hash(r|m1)*pk s2 = k+hash(r|m2)*pk pk = (s1 - s2)/(hash(r|m1) - hash(r|m2)) https://en.wikipedia.org/wiki/Schnorr_signature#Key_leakage_from_no

Returns verify result. check s*G = r + hash(r,m)*P # Examples ```rust use signatures::schnorr; fn main() { let message = 10; let private = 5; let