Module zerocaf::edwards

Edwards Point operations and their implementations are shown with the corresponding definitions. Encoding/decoding process implementations are shown, as is support for all kind of interactions which apply each of the processes.

Examples

use zerocaf::edwards::*;
use zerocaf::traits::ops::*;
use zerocaf::traits::Identity;
use zerocaf::field::FieldElement;
use zerocaf::scalar::Scalar;

use subtle::Choice;
use core::ops::{Add, Sub, Mul};

use rand::rngs::OsRng;

// You can work in different point coordinates, such as:
// Affine, Projective or Extended.
//
// It's highly recommended to work using the Extended cooridnates,
// for defined curves such as as the one in Zerocaf,
// as they they allow for the fastest known arithmetic operations.
// Additionally, they formats can be directly compressed from just
// a singular coordinate.

// In order to produce a point over the Sonny curve,
// you can do the following:

// From the y-coordinate of a point:
let y = FieldElement([2369245568431362, 2665603790611352, 3317390952748653, 1908583331312524, 8011773354506]);
// The `Choice` specifies the symbol that we want to get as a result
// for the `x-coordinate`.
let ex_point = EdwardsPoint::new_from_y_coord(&y, Choice::from(0u8)).unwrap();


let rngp = EdwardsPoint::from(ProjectivePoint::identity());

// The same examples work for the ProjectivePoint struct.

// You can perform the following operations with an EdwardsPoint
// or a ProjectivePoint:

// Point addition:
let p1 = &ex_point + &rngp;
// Point subtraction (which is a point negation and a sum):
let p2 = &ex_point - &rngp;
// Point doubling:
let p3 = &ex_point.double();
// Scalar mul:
let p4 = double_and_add(&ex_point, &Scalar::from(8u8));

// You can also multiply by the cofactor directly:
assert!(p4 == mul_by_cofactor(&ex_point));

// In order to send points for saving space, you can use
// compressed points, whih are repressented as: `CompressedEwdardsY`.

// The only means of obtaining a `CompressedEdwardsY` is:
// By compressing an `EdwardsPoint`:
let cp_point = rngp.compress();
// Note that you can get your EdwardsPoint back just by doing:
let decompr_point = &cp_point.decompress().unwrap();

// You can also get a compressed point by copying it from a
// slice of bytes (as if it came from a socket or similar situations).
let cpedw = CompressedEdwardsY::from_slice(&cp_point.to_bytes());

Structs

AffinePoint	An AffinePoint represents a point on the Sonny Curve expressed over the Twisted Edwards Affine Coordinates also known as cartesian coordinates: (X, Y).
CompressedEdwardsY	The first 255 bits of a CompressedEdwardsY represent the (y)-coordinate. The high bit of the 32nd byte gives the sign of (x).
EdwardsPoint	An EdwardsPoint represents a point on the Sonny Curve which is expressed in the Twisted Edwards Extended Coordinates format, eg. (X, Y, Z, T).
ProjectivePoint	A ProjectivePoint represents a point on the Sonny Curve expressed over the Twisted Edwards Projective Coordinates eg. (X:Y:Z).

Functions

binary_naf_mul
double_and_add	Implementation of the standard algorithm of double_and_add. This is a function implemented for Generic points that have implemented Add, Double, Identity and Clone.
ltr_bin_mul
mul_by_cofactor	Multiply by the cofactor: return (8 P).
mul_by_pow_2	Compute ([2^k] * P (mod l)).
window_naf_mul