void/ZeroTierOne
2
0
Fork 0
mirror of https://github.com/zerotier/ZeroTierOne.git synced 2025-05-08 22:53:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Some optimizations.

Browse source
This commit is contained in:
Adam Ierymenko 2021-11-09 16:58:31 -05:00
parent 30b4344acd
commit 16aa1b4eeb
No known key found for this signature in database
GPG key ID: C8877CF2D7A5D7F3
2 changed files with 31 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
zerotier-core-crypto/src/sidh/field.rs
View file

@ -39,6 +39,7 @@ pub struct ExtensionFieldElement {
} }
impl<'b> AddAssign<&'b ExtensionFieldElement> for ExtensionFieldElement { impl<'b> AddAssign<&'b ExtensionFieldElement> for ExtensionFieldElement {
#[inline(always)]
fn add_assign(&mut self, _rhs: &'b ExtensionFieldElement) { fn add_assign(&mut self, _rhs: &'b ExtensionFieldElement) {
let result = (self as &ExtensionFieldElement) + _rhs; let result = (self as &ExtensionFieldElement) + _rhs;
self.A = result.A; self.A = result.A;
@ -48,6 +49,7 @@ impl<'b> AddAssign<&'b ExtensionFieldElement> for ExtensionFieldElement {
impl<'a, 'b> Add<&'b ExtensionFieldElement> for &'a ExtensionFieldElement { impl<'a, 'b> Add<&'b ExtensionFieldElement> for &'a ExtensionFieldElement {
type Output = ExtensionFieldElement; type Output = ExtensionFieldElement;
#[inline(always)]
fn add(self, _rhs: &'b ExtensionFieldElement) -> ExtensionFieldElement { fn add(self, _rhs: &'b ExtensionFieldElement) -> ExtensionFieldElement {
let a = &self.A + &_rhs.A; let a = &self.A + &_rhs.A;
let b = &self.B + &_rhs.B; let b = &self.B + &_rhs.B;
@ -60,6 +62,7 @@ impl<'a, 'b> Add<&'b ExtensionFieldElement> for &'a ExtensionFieldElement {
} }
impl <'b> SubAssign<&'b ExtensionFieldElement> for ExtensionFieldElement { impl <'b> SubAssign<&'b ExtensionFieldElement> for ExtensionFieldElement {
#[inline(always)]
fn sub_assign(&mut self, _rhs: &'b ExtensionFieldElement) { fn sub_assign(&mut self, _rhs: &'b ExtensionFieldElement) {
let result = (self as &ExtensionFieldElement) - _rhs; let result = (self as &ExtensionFieldElement) - _rhs;
self.A = result.A; self.A = result.A;
@ -69,6 +72,7 @@ impl <'b> SubAssign<&'b ExtensionFieldElement> for ExtensionFieldElement {
impl<'a, 'b> Sub<&'b ExtensionFieldElement> for &'a ExtensionFieldElement { impl<'a, 'b> Sub<&'b ExtensionFieldElement> for &'a ExtensionFieldElement {
type Output = ExtensionFieldElement; type Output = ExtensionFieldElement;
#[inline(always)]
fn sub(self, _rhs: &'b ExtensionFieldElement) -> ExtensionFieldElement { fn sub(self, _rhs: &'b ExtensionFieldElement) -> ExtensionFieldElement {
let a = &self.A - &_rhs.A; let a = &self.A - &_rhs.A;
let b = &self.B - &_rhs.B; let b = &self.B - &_rhs.B;
@ -81,6 +85,7 @@ impl<'a, 'b> Sub<&'b ExtensionFieldElement> for &'a ExtensionFieldElement {
} }
impl<'b> MulAssign<&'b ExtensionFieldElement> for ExtensionFieldElement { impl<'b> MulAssign<&'b ExtensionFieldElement> for ExtensionFieldElement {
#[inline(always)]
fn mul_assign(&mut self, _rhs: &'b ExtensionFieldElement) { fn mul_assign(&mut self, _rhs: &'b ExtensionFieldElement) {
let result = (self as &ExtensionFieldElement) * _rhs; let result = (self as &ExtensionFieldElement) * _rhs;
self.A = result.A; self.A = result.A;
@ -129,6 +134,7 @@ impl<'a, 'b> Mul<&'b ExtensionFieldElement> for &'a ExtensionFieldElement {
impl <'a> Neg for &'a ExtensionFieldElement { impl <'a> Neg for &'a ExtensionFieldElement {
type Output = ExtensionFieldElement; type Output = ExtensionFieldElement;
#[inline(always)]
fn neg(self) -> ExtensionFieldElement { fn neg(self) -> ExtensionFieldElement {
let zero = ExtensionFieldElement::zero(); let zero = ExtensionFieldElement::zero();
let result = &zero - (self as &ExtensionFieldElement); let result = &zero - (self as &ExtensionFieldElement);
@ -263,6 +269,7 @@ impl ExtensionFieldElement {
} }
} }
/// Returns true if both sides are equal. Takes variable time. /// Returns true if both sides are equal. Takes variable time.
#[inline(always)]
pub fn vartime_eq(&self, _rhs: &ExtensionFieldElement) -> bool { pub fn vartime_eq(&self, _rhs: &ExtensionFieldElement) -> bool {
(&self.A == &_rhs.A) && (&self.B == &_rhs.B) (&self.A == &_rhs.A) && (&self.B == &_rhs.B)
} }
@ -295,6 +302,7 @@ pub struct PrimeFieldElement {
} }
impl<'b> AddAssign<&'b PrimeFieldElement> for PrimeFieldElement { impl<'b> AddAssign<&'b PrimeFieldElement> for PrimeFieldElement {
#[inline(always)]
fn add_assign(&mut self, _rhs: &'b PrimeFieldElement) { fn add_assign(&mut self, _rhs: &'b PrimeFieldElement) {
let result = (self as &PrimeFieldElement) + _rhs; let result = (self as &PrimeFieldElement) + _rhs;
self.A = result.A; self.A = result.A;
@ -303,6 +311,7 @@ impl<'b> AddAssign<&'b PrimeFieldElement> for PrimeFieldElement {
impl<'a, 'b> Add<&'b PrimeFieldElement> for &'a PrimeFieldElement { impl<'a, 'b> Add<&'b PrimeFieldElement> for &'a PrimeFieldElement {
type Output = PrimeFieldElement; type Output = PrimeFieldElement;
#[inline(always)]
fn add(self, _rhs: &'b PrimeFieldElement) -> PrimeFieldElement { fn add(self, _rhs: &'b PrimeFieldElement) -> PrimeFieldElement {
let a = &self.A + &_rhs.A; let a = &self.A + &_rhs.A;
PrimeFieldElement{ A: a } PrimeFieldElement{ A: a }
@ -310,6 +319,7 @@ impl<'a, 'b> Add<&'b PrimeFieldElement> for &'a PrimeFieldElement {
} }
impl <'b> SubAssign<&'b PrimeFieldElement> for PrimeFieldElement { impl <'b> SubAssign<&'b PrimeFieldElement> for PrimeFieldElement {
#[inline(always)]
fn sub_assign(&mut self, _rhs: &'b PrimeFieldElement) { fn sub_assign(&mut self, _rhs: &'b PrimeFieldElement) {
let result = (self as &PrimeFieldElement) - _rhs; let result = (self as &PrimeFieldElement) - _rhs;
self.A = result.A; self.A = result.A;
@ -318,6 +328,7 @@ impl <'b> SubAssign<&'b PrimeFieldElement> for PrimeFieldElement {
impl<'a, 'b> Sub<&'b PrimeFieldElement> for &'a PrimeFieldElement { impl<'a, 'b> Sub<&'b PrimeFieldElement> for &'a PrimeFieldElement {
type Output = PrimeFieldElement; type Output = PrimeFieldElement;
#[inline(always)]
fn sub(self, _rhs: &'b PrimeFieldElement) -> PrimeFieldElement { fn sub(self, _rhs: &'b PrimeFieldElement) -> PrimeFieldElement {
let a = &self.A - &_rhs.A; let a = &self.A - &_rhs.A;
PrimeFieldElement{ A: a } PrimeFieldElement{ A: a }
@ -325,6 +336,7 @@ impl<'a, 'b> Sub<&'b PrimeFieldElement> for &'a PrimeFieldElement {
} }
impl<'b> MulAssign<&'b PrimeFieldElement> for PrimeFieldElement { impl<'b> MulAssign<&'b PrimeFieldElement> for PrimeFieldElement {
#[inline(always)]
fn mul_assign(&mut self, _rhs: &'b PrimeFieldElement) { fn mul_assign(&mut self, _rhs: &'b PrimeFieldElement) {
let result = (self as &PrimeFieldElement) * _rhs; let result = (self as &PrimeFieldElement) * _rhs;
self.A = result.A; self.A = result.A;
@ -333,6 +345,7 @@ impl<'b> MulAssign<&'b PrimeFieldElement> for PrimeFieldElement {
impl<'a, 'b> Mul<&'b PrimeFieldElement> for &'a PrimeFieldElement { impl<'a, 'b> Mul<&'b PrimeFieldElement> for &'a PrimeFieldElement {
type Output = PrimeFieldElement; type Output = PrimeFieldElement;
#[inline(always)]
fn mul(self, _rhs: &'b PrimeFieldElement) -> PrimeFieldElement { fn mul(self, _rhs: &'b PrimeFieldElement) -> PrimeFieldElement {
// Alias self, _rhs for more readable formulas. // Alias self, _rhs for more readable formulas.
let a = &self.A; // = a*R let a = &self.A; // = a*R
@ -346,6 +359,7 @@ impl<'a, 'b> Mul<&'b PrimeFieldElement> for &'a PrimeFieldElement {
impl <'a> Neg for &'a PrimeFieldElement { impl <'a> Neg for &'a PrimeFieldElement {
type Output = PrimeFieldElement; type Output = PrimeFieldElement;
#[inline(always)]
fn neg(self) -> PrimeFieldElement { fn neg(self) -> PrimeFieldElement {
let zero = PrimeFieldElement::zero(); let zero = PrimeFieldElement::zero();
let result = &zero - (self as &PrimeFieldElement); let result = &zero - (self as &PrimeFieldElement);
@ -393,6 +407,7 @@ impl PrimeFieldElement {
} }
} }
/// Set the output to `x^2`. /// Set the output to `x^2`.
#[inline(always)]
pub fn square(&self) -> PrimeFieldElement { pub fn square(&self) -> PrimeFieldElement {
let a = &self.A; // = a*R let a = &self.A; // = a*R
let b = &self.A; // = b*R let b = &self.A; // = b*R
@ -466,6 +481,7 @@ impl PrimeFieldElement {
//-----------------------------------------------------------------------------// //-----------------------------------------------------------------------------//
impl<'b> AddAssign<&'b Fp751Element> for Fp751Element { impl<'b> AddAssign<&'b Fp751Element> for Fp751Element {
#[inline(always)]
fn add_assign(&mut self, _rhs: &'b Fp751Element) { fn add_assign(&mut self, _rhs: &'b Fp751Element) {
let result = (self as &Fp751Element) + _rhs; let result = (self as &Fp751Element) + _rhs;
self.0 = result.0 self.0 = result.0
@ -474,6 +490,7 @@ impl<'b> AddAssign<&'b Fp751Element> for Fp751Element {
impl<'a, 'b> Add<&'b Fp751Element> for &'a Fp751Element { impl<'a, 'b> Add<&'b Fp751Element> for &'a Fp751Element {
type Output = Fp751Element; type Output = Fp751Element;
#[inline(always)]
fn add(self, _rhs: &'b Fp751Element) -> Fp751Element { fn add(self, _rhs: &'b Fp751Element) -> Fp751Element {
let mut result = Fp751Element::zero(); let mut result = Fp751Element::zero();
fpadd751(&self, _rhs, &mut result); fpadd751(&self, _rhs, &mut result);
@ -482,6 +499,7 @@ impl<'a, 'b> Add<&'b Fp751Element> for &'a Fp751Element {
} }
impl <'b> SubAssign<&'b Fp751Element> for Fp751Element { impl <'b> SubAssign<&'b Fp751Element> for Fp751Element {
#[inline(always)]
fn sub_assign(&mut self, _rhs: &'b Fp751Element) { fn sub_assign(&mut self, _rhs: &'b Fp751Element) {
let result = (self as &Fp751Element) - _rhs; let result = (self as &Fp751Element) - _rhs;
self.0 = result.0 self.0 = result.0
@ -490,6 +508,7 @@ impl <'b> SubAssign<&'b Fp751Element> for Fp751Element {
impl<'a, 'b> Sub<&'b Fp751Element> for &'a Fp751Element { impl<'a, 'b> Sub<&'b Fp751Element> for &'a Fp751Element {
type Output = Fp751Element; type Output = Fp751Element;
#[inline(always)]
fn sub(self, _rhs: &'b Fp751Element) -> Fp751Element { fn sub(self, _rhs: &'b Fp751Element) -> Fp751Element {
let mut result = Fp751Element::zero(); let mut result = Fp751Element::zero();
fpsub751(&self, _rhs, &mut result); fpsub751(&self, _rhs, &mut result);
@ -499,6 +518,7 @@ impl<'a, 'b> Sub<&'b Fp751Element> for &'a Fp751Element {
impl<'a, 'b> Mul<&'b Fp751Element> for &'a Fp751Element { impl<'a, 'b> Mul<&'b Fp751Element> for &'a Fp751Element {
type Output = Fp751X2; type Output = Fp751X2;
#[inline(always)]
fn mul(self, _rhs: &'b Fp751Element) -> Fp751X2 { fn mul(self, _rhs: &'b Fp751Element) -> Fp751X2 {
let mut result = Fp751X2::zero(); let mut result = Fp751X2::zero();
mul751(&self, _rhs, &mut result); // = a*c*R*R mul751(&self, _rhs, &mut result); // = a*c*R*R
@ -508,6 +528,7 @@ impl<'a, 'b> Mul<&'b Fp751Element> for &'a Fp751Element {
impl <'a> Neg for &'a Fp751Element { impl <'a> Neg for &'a Fp751Element {
type Output = Fp751Element; type Output = Fp751Element;
#[inline(always)]
fn neg(self) -> Fp751Element { fn neg(self) -> Fp751Element {
let zero = Fp751Element::zero(); let zero = Fp751Element::zero();
let result = &zero - (self as &Fp751Element); let result = &zero - (self as &Fp751Element);
@ -575,6 +596,7 @@ impl ConstantTimeEq for Fp751Element {
impl Fp751Element { impl Fp751Element {
/// Reduce a field element in `[0, 2*p)` to one in `[0,p)`. /// Reduce a field element in `[0, 2*p)` to one in `[0,p)`.
#[inline(always)]
pub fn strong_reduce(&self) -> Fp751Element { pub fn strong_reduce(&self) -> Fp751Element {
let mut _self = *self; let mut _self = *self;
srdc751(&mut _self); srdc751(&mut _self);
@ -583,6 +605,7 @@ impl Fp751Element {
} }
impl<'b> AddAssign<&'b Fp751X2> for Fp751X2 { impl<'b> AddAssign<&'b Fp751X2> for Fp751X2 {
#[inline(always)]
fn add_assign(&mut self, _rhs: &'b Fp751X2) { fn add_assign(&mut self, _rhs: &'b Fp751X2) {
let result = (self as &Fp751X2) + _rhs; let result = (self as &Fp751X2) + _rhs;
self.0 = result.0 self.0 = result.0
@ -591,6 +614,7 @@ impl<'b> AddAssign<&'b Fp751X2> for Fp751X2 {
impl<'a, 'b> Add<&'b Fp751X2> for &'a Fp751X2 { impl<'a, 'b> Add<&'b Fp751X2> for &'a Fp751X2 {
type Output = Fp751X2; type Output = Fp751X2;
#[inline(always)]
fn add(self, _rhs: &'b Fp751X2) -> Fp751X2 { fn add(self, _rhs: &'b Fp751X2) -> Fp751X2 {
let mut result = Fp751X2::zero(); let mut result = Fp751X2::zero();
mp_add751x2(&self, _rhs, &mut result); mp_add751x2(&self, _rhs, &mut result);
@ -599,6 +623,7 @@ impl<'a, 'b> Add<&'b Fp751X2> for &'a Fp751X2 {
} }
impl <'b> SubAssign<&'b Fp751X2> for Fp751X2 { impl <'b> SubAssign<&'b Fp751X2> for Fp751X2 {
#[inline(always)]
fn sub_assign(&mut self, _rhs: &'b Fp751X2) { fn sub_assign(&mut self, _rhs: &'b Fp751X2) {
let result = (self as &Fp751X2) - _rhs; let result = (self as &Fp751X2) - _rhs;
self.0 = result.0 self.0 = result.0
@ -607,6 +632,7 @@ impl <'b> SubAssign<&'b Fp751X2> for Fp751X2 {
impl<'a, 'b> Sub<&'b Fp751X2> for &'a Fp751X2 { impl<'a, 'b> Sub<&'b Fp751X2> for &'a Fp751X2 {
type Output = Fp751X2; type Output = Fp751X2;
#[inline(always)]
fn sub(self, _rhs: &'b Fp751X2) -> Fp751X2 { fn sub(self, _rhs: &'b Fp751X2) -> Fp751X2 {
let mut result = Fp751X2::zero(); let mut result = Fp751X2::zero();
mp_sub751x2(&self, _rhs, &mut result); mp_sub751x2(&self, _rhs, &mut result);
@ -616,6 +642,7 @@ impl<'a, 'b> Sub<&'b Fp751X2> for &'a Fp751X2 {
impl Fp751X2 { impl Fp751X2 {
/// Perform Montgomery reduction, `x R^{-1} (mod p)`. /// Perform Montgomery reduction, `x R^{-1} (mod p)`.
#[inline(always)]
pub fn reduce(&self) -> Fp751Element { pub fn reduce(&self) -> Fp751Element {
let mut result = Fp751Element::zero(); let mut result = Fp751Element::zero();
rdc751(self, &mut result); rdc751(self, &mut result);

7
zerotier-core-crypto/src/sidh/fp.rs
View file

@ -90,6 +90,7 @@ fn digit_x_digit(a: &u32, b: &u32, c: &mut [u32]) {
c[1] ^= (ahbh & mask_high) + carry; c[1] ^= (ahbh & mask_high) + carry;
} }
#[inline(always)]
fn mul(multiplier: &u32, multiplicant: &u32, uv: &mut [u32]) { fn mul(multiplier: &u32, multiplicant: &u32, uv: &mut [u32]) {
digit_x_digit(multiplier, multiplicant, uv); digit_x_digit(multiplier, multiplicant, uv);
} }
@ -235,7 +236,7 @@ pub fn rdc751(x: &Fp751X2, z: &mut Fp751Element) {
z.0[FP751_NUM_WORDS-1] = v; z.0[FP751_NUM_WORDS-1] = v;
} }
#[inline] #[inline(always)]
pub fn srdc751(x: &mut Fp751Element) { pub fn srdc751(x: &mut Fp751Element) {
let mut borrow: u32 = 0; let mut borrow: u32 = 0;
@ -250,7 +251,7 @@ pub fn srdc751(x: &mut Fp751Element) {
} }
} }
#[inline] #[inline(always)]
pub fn mp_add751(x: &Fp751Element, y: &Fp751Element, z: &mut Fp751Element) { pub fn mp_add751(x: &Fp751Element, y: &Fp751Element, z: &mut Fp751Element) {
let mut carry: u32 = 0; let mut carry: u32 = 0;
@ -259,7 +260,7 @@ pub fn mp_add751(x: &Fp751Element, y: &Fp751Element, z: &mut Fp751Element) {
} }
} }
#[inline] #[inline(always)]
pub fn mp_add751x2(x: &Fp751X2, y: &Fp751X2, z: &mut Fp751X2) { pub fn mp_add751x2(x: &Fp751X2, y: &Fp751X2, z: &mut Fp751X2) {
let mut carry: u32 = 0; let mut carry: u32 = 0;