Get rid of KEY_LENGTH_DWORDS_P192
Only KEY_LENGTH_DWORDS_P256 is used.
Test: compilation
Bug: 126463795
Change-Id: I32a80e4b012c4606a70994fa9d0b5c2602707bb3
diff --git a/system/stack/smp/p_256_curvepara.cc b/system/stack/smp/p_256_curvepara.cc
index 5fb71a3..ebdf266 100644
--- a/system/stack/smp/p_256_curvepara.cc
+++ b/system/stack/smp/p_256_curvepara.cc
@@ -25,53 +25,49 @@
#include <string.h>
#include "p_256_ecc_pp.h"
-void p_256_init_curve(uint32_t keyLength) {
- elliptic_curve_t* ec;
+void p_256_init_curve() {
+ elliptic_curve_t* ec = &curve_p256;
- if (keyLength == KEY_LENGTH_DWORDS_P256) {
- ec = &curve_p256;
+ ec->p[7] = 0xFFFFFFFF;
+ ec->p[6] = 0x00000001;
+ ec->p[5] = 0x0;
+ ec->p[4] = 0x0;
+ ec->p[3] = 0x0;
+ ec->p[2] = 0xFFFFFFFF;
+ ec->p[1] = 0xFFFFFFFF;
+ ec->p[0] = 0xFFFFFFFF;
- ec->p[7] = 0xFFFFFFFF;
- ec->p[6] = 0x00000001;
- ec->p[5] = 0x0;
- ec->p[4] = 0x0;
- ec->p[3] = 0x0;
- ec->p[2] = 0xFFFFFFFF;
- ec->p[1] = 0xFFFFFFFF;
- ec->p[0] = 0xFFFFFFFF;
+ memset(ec->omega, 0, KEY_LENGTH_DWORDS_P256);
+ memset(ec->a, 0, KEY_LENGTH_DWORDS_P256);
- memset(ec->omega, 0, KEY_LENGTH_DWORDS_P256);
- memset(ec->a, 0, KEY_LENGTH_DWORDS_P256);
+ ec->a_minus3 = true;
- ec->a_minus3 = true;
+ // b
+ ec->b[7] = 0x5ac635d8;
+ ec->b[6] = 0xaa3a93e7;
+ ec->b[5] = 0xb3ebbd55;
+ ec->b[4] = 0x769886bc;
+ ec->b[3] = 0x651d06b0;
+ ec->b[2] = 0xcc53b0f6;
+ ec->b[1] = 0x3bce3c3e;
+ ec->b[0] = 0x27d2604b;
- // b
- ec->b[7] = 0x5ac635d8;
- ec->b[6] = 0xaa3a93e7;
- ec->b[5] = 0xb3ebbd55;
- ec->b[4] = 0x769886bc;
- ec->b[3] = 0x651d06b0;
- ec->b[2] = 0xcc53b0f6;
- ec->b[1] = 0x3bce3c3e;
- ec->b[0] = 0x27d2604b;
+ // base point
+ ec->G.x[7] = 0x6b17d1f2;
+ ec->G.x[6] = 0xe12c4247;
+ ec->G.x[5] = 0xf8bce6e5;
+ ec->G.x[4] = 0x63a440f2;
+ ec->G.x[3] = 0x77037d81;
+ ec->G.x[2] = 0x2deb33a0;
+ ec->G.x[1] = 0xf4a13945;
+ ec->G.x[0] = 0xd898c296;
- // base point
- ec->G.x[7] = 0x6b17d1f2;
- ec->G.x[6] = 0xe12c4247;
- ec->G.x[5] = 0xf8bce6e5;
- ec->G.x[4] = 0x63a440f2;
- ec->G.x[3] = 0x77037d81;
- ec->G.x[2] = 0x2deb33a0;
- ec->G.x[1] = 0xf4a13945;
- ec->G.x[0] = 0xd898c296;
-
- ec->G.y[7] = 0x4fe342e2;
- ec->G.y[6] = 0xfe1a7f9b;
- ec->G.y[5] = 0x8ee7eb4a;
- ec->G.y[4] = 0x7c0f9e16;
- ec->G.y[3] = 0x2bce3357;
- ec->G.y[2] = 0x6b315ece;
- ec->G.y[1] = 0xcbb64068;
- ec->G.y[0] = 0x37bf51f5;
- }
+ ec->G.y[7] = 0x4fe342e2;
+ ec->G.y[6] = 0xfe1a7f9b;
+ ec->G.y[5] = 0x8ee7eb4a;
+ ec->G.y[4] = 0x7c0f9e16;
+ ec->G.y[3] = 0x2bce3357;
+ ec->G.y[2] = 0x6b315ece;
+ ec->G.y[1] = 0xcbb64068;
+ ec->G.y[0] = 0x37bf51f5;
}
diff --git a/system/stack/smp/p_256_ecc_pp.cc b/system/stack/smp/p_256_ecc_pp.cc
index ff5dbde..cef368a 100644
--- a/system/stack/smp/p_256_ecc_pp.cc
+++ b/system/stack/smp/p_256_ecc_pp.cc
@@ -38,7 +38,7 @@
}
// q=2q
-static void ECC_Double(Point* q, Point* p, uint32_t keyLength) {
+static void ECC_Double(Point* q, Point* p) {
uint32_t t1[KEY_LENGTH_DWORDS_P256];
uint32_t t2[KEY_LENGTH_DWORDS_P256];
uint32_t t3[KEY_LENGTH_DWORDS_P256];
@@ -49,8 +49,8 @@
uint32_t* z1;
uint32_t* z3;
- if (multiprecision_iszero(p->z, keyLength)) {
- multiprecision_init(q->z, keyLength);
+ if (multiprecision_iszero(p->z)) {
+ multiprecision_init(q->z);
return; // return infinity
}
@@ -61,33 +61,33 @@
y3 = q->y;
z3 = q->z;
- multiprecision_mersenns_squa_mod(t1, z1, keyLength); // t1=z1^2
- multiprecision_sub_mod(t2, x1, t1, keyLength); // t2=x1-t1
- multiprecision_add_mod(t1, x1, t1, keyLength); // t1=x1+t1
- multiprecision_mersenns_mult_mod(t2, t1, t2, keyLength); // t2=t2*t1
- multiprecision_lshift_mod(t3, t2, keyLength);
- multiprecision_add_mod(t2, t3, t2, keyLength); // t2=3t2
+ multiprecision_mersenns_squa_mod(t1, z1); // t1=z1^2
+ multiprecision_sub_mod(t2, x1, t1); // t2=x1-t1
+ multiprecision_add_mod(t1, x1, t1); // t1=x1+t1
+ multiprecision_mersenns_mult_mod(t2, t1, t2); // t2=t2*t1
+ multiprecision_lshift_mod(t3, t2);
+ multiprecision_add_mod(t2, t3, t2); // t2=3t2
- multiprecision_mersenns_mult_mod(z3, y1, z1, keyLength); // z3=y1*z1
- multiprecision_lshift_mod(z3, z3, keyLength);
+ multiprecision_mersenns_mult_mod(z3, y1, z1); // z3=y1*z1
+ multiprecision_lshift_mod(z3, z3);
- multiprecision_mersenns_squa_mod(y3, y1, keyLength); // y3=y1^2
- multiprecision_lshift_mod(y3, y3, keyLength);
- multiprecision_mersenns_mult_mod(t3, y3, x1, keyLength); // t3=y3*x1=x1*y1^2
- multiprecision_lshift_mod(t3, t3, keyLength);
- multiprecision_mersenns_squa_mod(y3, y3, keyLength); // y3=y3^2=y1^4
- multiprecision_lshift_mod(y3, y3, keyLength);
+ multiprecision_mersenns_squa_mod(y3, y1); // y3=y1^2
+ multiprecision_lshift_mod(y3, y3);
+ multiprecision_mersenns_mult_mod(t3, y3, x1); // t3=y3*x1=x1*y1^2
+ multiprecision_lshift_mod(t3, t3);
+ multiprecision_mersenns_squa_mod(y3, y3); // y3=y3^2=y1^4
+ multiprecision_lshift_mod(y3, y3);
- multiprecision_mersenns_squa_mod(x3, t2, keyLength); // x3=t2^2
- multiprecision_lshift_mod(t1, t3, keyLength); // t1=2t3
- multiprecision_sub_mod(x3, x3, t1, keyLength); // x3=x3-t1
- multiprecision_sub_mod(t1, t3, x3, keyLength); // t1=t3-x3
- multiprecision_mersenns_mult_mod(t1, t1, t2, keyLength); // t1=t1*t2
- multiprecision_sub_mod(y3, t1, y3, keyLength); // y3=t1-y3
+ multiprecision_mersenns_squa_mod(x3, t2); // x3=t2^2
+ multiprecision_lshift_mod(t1, t3); // t1=2t3
+ multiprecision_sub_mod(x3, x3, t1); // x3=x3-t1
+ multiprecision_sub_mod(t1, t3, x3); // t1=t3-x3
+ multiprecision_mersenns_mult_mod(t1, t1, t2); // t1=t1*t2
+ multiprecision_sub_mod(y3, t1, y3); // y3=t1-y3
}
// q=q+p, zp must be 1
-static void ECC_Add(Point* r, Point* p, Point* q, uint32_t keyLength) {
+static void ECC_Add(Point* r, Point* p, Point* q) {
uint32_t t1[KEY_LENGTH_DWORDS_P256];
uint32_t t2[KEY_LENGTH_DWORDS_P256];
uint32_t* x1;
@@ -111,58 +111,57 @@
z3 = r->z;
// if Q=infinity, return p
- if (multiprecision_iszero(z2, keyLength)) {
+ if (multiprecision_iszero(z2)) {
p_256_copy_point(r, p);
return;
}
// if P=infinity, return q
- if (multiprecision_iszero(z1, keyLength)) {
+ if (multiprecision_iszero(z1)) {
p_256_copy_point(r, q);
return;
}
- multiprecision_mersenns_squa_mod(t1, z1, keyLength); // t1=z1^2
- multiprecision_mersenns_mult_mod(t2, z1, t1, keyLength); // t2=t1*z1
- multiprecision_mersenns_mult_mod(t1, x2, t1, keyLength); // t1=t1*x2
- multiprecision_mersenns_mult_mod(t2, y2, t2, keyLength); // t2=t2*y2
+ multiprecision_mersenns_squa_mod(t1, z1); // t1=z1^2
+ multiprecision_mersenns_mult_mod(t2, z1, t1); // t2=t1*z1
+ multiprecision_mersenns_mult_mod(t1, x2, t1); // t1=t1*x2
+ multiprecision_mersenns_mult_mod(t2, y2, t2); // t2=t2*y2
- multiprecision_sub_mod(t1, t1, x1, keyLength); // t1=t1-x1
- multiprecision_sub_mod(t2, t2, y1, keyLength); // t2=t2-y1
+ multiprecision_sub_mod(t1, t1, x1); // t1=t1-x1
+ multiprecision_sub_mod(t2, t2, y1); // t2=t2-y1
- if (multiprecision_iszero(t1, keyLength)) {
- if (multiprecision_iszero(t2, keyLength)) {
- ECC_Double(r, q, keyLength);
+ if (multiprecision_iszero(t1)) {
+ if (multiprecision_iszero(t2)) {
+ ECC_Double(r, q);
return;
} else {
- multiprecision_init(z3, keyLength);
+ multiprecision_init(z3);
return; // return infinity
}
}
- multiprecision_mersenns_mult_mod(z3, z1, t1, keyLength); // z3=z1*t1
- multiprecision_mersenns_squa_mod(y3, t1, keyLength); // t3=t1^2
- multiprecision_mersenns_mult_mod(z1, y3, t1, keyLength); // t4=t3*t1
- multiprecision_mersenns_mult_mod(y3, y3, x1, keyLength); // t3=t3*x1
- multiprecision_lshift_mod(t1, y3, keyLength); // t1=2*t3
- multiprecision_mersenns_squa_mod(x3, t2, keyLength); // x3=t2^2
- multiprecision_sub_mod(x3, x3, t1, keyLength); // x3=x3-t1
- multiprecision_sub_mod(x3, x3, z1, keyLength); // x3=x3-t4
- multiprecision_sub_mod(y3, y3, x3, keyLength); // t3=t3-x3
- multiprecision_mersenns_mult_mod(y3, y3, t2, keyLength); // t3=t3*t2
- multiprecision_mersenns_mult_mod(z1, z1, y1, keyLength); // t4=t4*t1
- multiprecision_sub_mod(y3, y3, z1, keyLength);
+ multiprecision_mersenns_mult_mod(z3, z1, t1); // z3=z1*t1
+ multiprecision_mersenns_squa_mod(y3, t1); // t3=t1^2
+ multiprecision_mersenns_mult_mod(z1, y3, t1); // t4=t3*t1
+ multiprecision_mersenns_mult_mod(y3, y3, x1); // t3=t3*x1
+ multiprecision_lshift_mod(t1, y3); // t1=2*t3
+ multiprecision_mersenns_squa_mod(x3, t2); // x3=t2^2
+ multiprecision_sub_mod(x3, x3, t1); // x3=x3-t1
+ multiprecision_sub_mod(x3, x3, z1); // x3=x3-t4
+ multiprecision_sub_mod(y3, y3, x3); // t3=t3-x3
+ multiprecision_mersenns_mult_mod(y3, y3, t2); // t3=t3*t2
+ multiprecision_mersenns_mult_mod(z1, z1, y1); // t4=t4*t1
+ multiprecision_sub_mod(y3, y3, z1);
}
// Computing the Non-Adjacent Form of a positive integer
-static void ECC_NAF(uint8_t* naf, uint32_t* NumNAF, uint32_t* k,
- uint32_t keyLength) {
+static void ECC_NAF(uint8_t* naf, uint32_t* NumNAF, uint32_t* k) {
uint32_t sign;
int i = 0;
int j;
uint32_t var;
- while ((var = multiprecision_most_signbits(k, keyLength)) >= 1) {
+ while ((var = multiprecision_most_signbits(k)) >= 1) {
if (k[0] & 0x01) // k is odd
{
sign = (k[0] & 0x03); // 1 or 3
@@ -183,7 +182,7 @@
} else
sign = 0;
- multiprecision_rshift(k, k, keyLength);
+ multiprecision_rshift(k, k);
naf[i / 4] |= (sign) << ((i % 4) * 2);
i++;
}
@@ -192,8 +191,7 @@
}
// Binary Non-Adjacent Form for point multiplication
-void ECC_PointMult_Bin_NAF(Point* q, Point* p, uint32_t* n,
- uint32_t keyLength) {
+void ECC_PointMult_Bin_NAF(Point* q, Point* p, uint32_t* n) {
uint32_t sign;
uint8_t naf[256 / 4 + 1];
uint32_t NumNaf;
@@ -201,69 +199,64 @@
Point r;
uint32_t* modp;
- if (keyLength == KEY_LENGTH_DWORDS_P256) {
- modp = curve_p256.p;
- } else {
- modp = curve.p;
- }
+ modp = curve_p256.p;
p_256_init_point(&r);
- multiprecision_init(p->z, keyLength);
+ multiprecision_init(p->z);
p->z[0] = 1;
// initialization
p_256_init_point(q);
// -p
- multiprecision_copy(minus_p.x, p->x, keyLength);
- multiprecision_sub(minus_p.y, modp, p->y, keyLength);
+ multiprecision_copy(minus_p.x, p->x);
+ multiprecision_sub(minus_p.y, modp, p->y);
- multiprecision_init(minus_p.z, keyLength);
+ multiprecision_init(minus_p.z);
minus_p.z[0] = 1;
// NAF
memset(naf, 0, sizeof(naf));
- ECC_NAF(naf, &NumNaf, n, keyLength);
+ ECC_NAF(naf, &NumNaf, n);
for (int i = NumNaf - 1; i >= 0; i--) {
p_256_copy_point(&r, q);
- ECC_Double(q, &r, keyLength);
+ ECC_Double(q, &r);
sign = (naf[i / 4] >> ((i % 4) * 2)) & 0x03;
if (sign == 1) {
p_256_copy_point(&r, q);
- ECC_Add(q, &r, p, keyLength);
+ ECC_Add(q, &r, p);
} else if (sign == 3) {
p_256_copy_point(&r, q);
- ECC_Add(q, &r, &minus_p, keyLength);
+ ECC_Add(q, &r, &minus_p);
}
}
- multiprecision_inv_mod(minus_p.x, q->z, keyLength);
- multiprecision_mersenns_squa_mod(q->z, minus_p.x, keyLength);
- multiprecision_mersenns_mult_mod(q->x, q->x, q->z, keyLength);
- multiprecision_mersenns_mult_mod(q->z, q->z, minus_p.x, keyLength);
- multiprecision_mersenns_mult_mod(q->y, q->y, q->z, keyLength);
+ multiprecision_inv_mod(minus_p.x, q->z);
+ multiprecision_mersenns_squa_mod(q->z, minus_p.x);
+ multiprecision_mersenns_mult_mod(q->x, q->x, q->z);
+ multiprecision_mersenns_mult_mod(q->z, q->z, minus_p.x);
+ multiprecision_mersenns_mult_mod(q->y, q->y, q->z);
}
bool ECC_ValidatePoint(const Point& pt) {
- const size_t kl = KEY_LENGTH_DWORDS_P256;
- p_256_init_curve(kl);
+ p_256_init_curve();
// Ensure y^2 = x^3 + a*x + b (mod p); a = -3
// y^2 mod p
- uint32_t y2_mod[kl] = {0};
- multiprecision_mersenns_squa_mod(y2_mod, (uint32_t*)pt.y, kl);
+ uint32_t y2_mod[KEY_LENGTH_DWORDS_P256] = {0};
+ multiprecision_mersenns_squa_mod(y2_mod, (uint32_t*)pt.y);
// Right hand side calculation
- uint32_t rhs[kl] = {0};
- multiprecision_mersenns_squa_mod(rhs, (uint32_t*)pt.x, kl);
- uint32_t three[kl] = {0};
+ uint32_t rhs[KEY_LENGTH_DWORDS_P256] = {0};
+ multiprecision_mersenns_squa_mod(rhs, (uint32_t*)pt.x);
+ uint32_t three[KEY_LENGTH_DWORDS_P256] = {0};
three[0] = 3;
- multiprecision_sub_mod(rhs, rhs, three, kl);
- multiprecision_mersenns_mult_mod(rhs, rhs, (uint32_t*)pt.x, kl);
- multiprecision_add_mod(rhs, rhs, curve_p256.b, kl);
+ multiprecision_sub_mod(rhs, rhs, three);
+ multiprecision_mersenns_mult_mod(rhs, rhs, (uint32_t*)pt.x);
+ multiprecision_add_mod(rhs, rhs, curve_p256.b);
- return multiprecision_compare(rhs, y2_mod, kl) == 0;
+ return multiprecision_compare(rhs, y2_mod) == 0;
}
diff --git a/system/stack/smp/p_256_ecc_pp.h b/system/stack/smp/p_256_ecc_pp.h
index b49b72a..4dff0a8 100644
--- a/system/stack/smp/p_256_ecc_pp.h
+++ b/system/stack/smp/p_256_ecc_pp.h
@@ -58,9 +58,8 @@
bool ECC_ValidatePoint(const Point& p);
-void ECC_PointMult_Bin_NAF(Point* q, Point* p, uint32_t* n, uint32_t keyLength);
+void ECC_PointMult_Bin_NAF(Point* q, Point* p, uint32_t* n);
-#define ECC_PointMult(q, p, n, keyLength) \
- ECC_PointMult_Bin_NAF(q, p, n, keyLength)
+#define ECC_PointMult(q, p, n) ECC_PointMult_Bin_NAF(q, p, n)
-void p_256_init_curve(uint32_t keyLength);
+void p_256_init_curve();
diff --git a/system/stack/smp/p_256_multprecision.cc b/system/stack/smp/p_256_multprecision.cc
index 286aca1..0310829 100644
--- a/system/stack/smp/p_256_multprecision.cc
+++ b/system/stack/smp/p_256_multprecision.cc
@@ -27,24 +27,24 @@
#include "bt_target.h"
#include "p_256_ecc_pp.h"
-void multiprecision_init(uint32_t* c, uint32_t keyLength) {
- for (uint32_t i = 0; i < keyLength; i++) c[i] = 0;
+void multiprecision_init(uint32_t* c) {
+ for (uint32_t i = 0; i < KEY_LENGTH_DWORDS_P256; i++) c[i] = 0;
}
-void multiprecision_copy(uint32_t* c, uint32_t* a, uint32_t keyLength) {
- for (uint32_t i = 0; i < keyLength; i++) c[i] = a[i];
+void multiprecision_copy(uint32_t* c, uint32_t* a) {
+ for (uint32_t i = 0; i < KEY_LENGTH_DWORDS_P256; i++) c[i] = a[i];
}
-int multiprecision_compare(uint32_t* a, uint32_t* b, uint32_t keyLength) {
- for (int i = keyLength - 1; i >= 0; i--) {
+int multiprecision_compare(uint32_t* a, uint32_t* b) {
+ for (int i = KEY_LENGTH_DWORDS_P256 - 1; i >= 0; i--) {
if (a[i] > b[i]) return 1;
if (a[i] < b[i]) return -1;
}
return 0;
}
-int multiprecision_iszero(uint32_t* a, uint32_t keyLength) {
- for (uint32_t i = 0; i < keyLength; i++)
+int multiprecision_iszero(uint32_t* a) {
+ for (uint32_t i = 0; i < KEY_LENGTH_DWORDS_P256; i++)
if (a[i]) return 0;
return 1;
@@ -58,30 +58,29 @@
return i;
}
-uint32_t multiprecision_most_signdwords(uint32_t* a, uint32_t keyLength) {
+uint32_t multiprecision_most_signdwords(uint32_t* a) {
int i;
- for (i = keyLength - 1; i >= 0; i--)
+ for (i = KEY_LENGTH_DWORDS_P256 - 1; i >= 0; i--)
if (a[i]) break;
return (i + 1);
}
-uint32_t multiprecision_most_signbits(uint32_t* a, uint32_t keyLength) {
+uint32_t multiprecision_most_signbits(uint32_t* a) {
int aMostSignDWORDs;
- aMostSignDWORDs = multiprecision_most_signdwords(a, keyLength);
+ aMostSignDWORDs = multiprecision_most_signdwords(a);
if (aMostSignDWORDs == 0) return 0;
return (((aMostSignDWORDs - 1) << DWORD_BITS_SHIFT) +
multiprecision_dword_bits(a[aMostSignDWORDs - 1]));
}
-uint32_t multiprecision_add(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength) {
+uint32_t multiprecision_add(uint32_t* c, uint32_t* a, uint32_t* b) {
uint32_t carrier;
uint32_t temp;
carrier = 0;
- for (uint32_t i = 0; i < keyLength; i++) {
+ for (uint32_t i = 0; i < KEY_LENGTH_DWORDS_P256; i++) {
temp = a[i] + carrier;
carrier = (temp < carrier);
temp += b[i];
@@ -93,13 +92,12 @@
}
// c=a-b
-uint32_t multiprecision_sub(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength) {
+uint32_t multiprecision_sub(uint32_t* c, uint32_t* a, uint32_t* b) {
uint32_t borrow;
uint32_t temp;
borrow = 0;
- for (uint32_t i = 0; i < keyLength; i++) {
+ for (uint32_t i = 0; i < KEY_LENGTH_DWORDS_P256; i++) {
temp = a[i] - borrow;
borrow = (temp > a[i]);
c[i] = temp - b[i];
@@ -110,27 +108,20 @@
}
// c = a << 1
-void multiprecision_lshift_mod(uint32_t* c, uint32_t* a, uint32_t keyLength) {
+void multiprecision_lshift_mod(uint32_t* c, uint32_t* a) {
uint32_t carrier;
- uint32_t* modp;
+ uint32_t* modp = curve_p256.p;
- if (keyLength == KEY_LENGTH_DWORDS_P192) {
- modp = curve.p;
- } else if (keyLength == KEY_LENGTH_DWORDS_P256) {
- modp = curve_p256.p;
- } else
- return;
-
- carrier = multiprecision_lshift(c, a, keyLength);
+ carrier = multiprecision_lshift(c, a);
if (carrier) {
- multiprecision_sub(c, c, modp, keyLength);
- } else if (multiprecision_compare(c, modp, keyLength) >= 0) {
- multiprecision_sub(c, c, modp, keyLength);
+ multiprecision_sub(c, c, modp);
+ } else if (multiprecision_compare(c, modp) >= 0) {
+ multiprecision_sub(c, c, modp);
}
}
// c=a>>1
-void multiprecision_rshift(uint32_t* c, uint32_t* a, uint32_t keyLength) {
+void multiprecision_rshift(uint32_t* c, uint32_t* a) {
int j;
uint32_t b = 1;
@@ -138,7 +129,7 @@
uint32_t carrier = 0;
uint32_t temp;
- for (int i = keyLength - 1; i >= 0; i--) {
+ for (int i = KEY_LENGTH_DWORDS_P256 - 1; i >= 0; i--) {
temp = a[i]; // in case of c==a
c[i] = (temp >> b) | carrier;
carrier = temp << j;
@@ -147,64 +138,42 @@
// Curve specific optimization when p is a pseudo-Mersenns prime,
// p=2^(KEY_LENGTH_BITS)-omega
-void multiprecision_mersenns_mult_mod(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength) {
+void multiprecision_mersenns_mult_mod(uint32_t* c, uint32_t* a, uint32_t* b) {
uint32_t cc[2 * KEY_LENGTH_DWORDS_P256];
- multiprecision_mult(cc, a, b, keyLength);
- if (keyLength == 6) {
- multiprecision_fast_mod(c, cc);
- } else if (keyLength == 8) {
- multiprecision_fast_mod_P256(c, cc);
- }
+ multiprecision_mult(cc, a, b);
+ multiprecision_fast_mod_P256(c, cc);
}
// Curve specific optimization when p is a pseudo-Mersenns prime
-void multiprecision_mersenns_squa_mod(uint32_t* c, uint32_t* a,
- uint32_t keyLength) {
- multiprecision_mersenns_mult_mod(c, a, a, keyLength);
+void multiprecision_mersenns_squa_mod(uint32_t* c, uint32_t* a) {
+ multiprecision_mersenns_mult_mod(c, a, a);
}
// c=(a+b) mod p, b<p, a<p
-void multiprecision_add_mod(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength) {
+void multiprecision_add_mod(uint32_t* c, uint32_t* a, uint32_t* b) {
uint32_t carrier;
- uint32_t* modp;
+ uint32_t* modp = curve_p256.p;
- if (keyLength == KEY_LENGTH_DWORDS_P192) {
- modp = curve.p;
- } else if (keyLength == KEY_LENGTH_DWORDS_P256) {
- modp = curve_p256.p;
- } else
- return;
-
- carrier = multiprecision_add(c, a, b, keyLength);
+ carrier = multiprecision_add(c, a, b);
if (carrier) {
- multiprecision_sub(c, c, modp, keyLength);
- } else if (multiprecision_compare(c, modp, keyLength) >= 0) {
- multiprecision_sub(c, c, modp, keyLength);
+ multiprecision_sub(c, c, modp);
+ } else if (multiprecision_compare(c, modp) >= 0) {
+ multiprecision_sub(c, c, modp);
}
}
// c=(a-b) mod p, a<p, b<p
-void multiprecision_sub_mod(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength) {
+void multiprecision_sub_mod(uint32_t* c, uint32_t* a, uint32_t* b) {
uint32_t borrow;
- uint32_t* modp;
+ uint32_t* modp = curve_p256.p;
- if (keyLength == KEY_LENGTH_DWORDS_P192) {
- modp = curve.p;
- } else if (keyLength == KEY_LENGTH_DWORDS_P256) {
- modp = curve_p256.p;
- } else
- return;
-
- borrow = multiprecision_sub(c, a, b, keyLength);
- if (borrow) multiprecision_add(c, c, modp, keyLength);
+ borrow = multiprecision_sub(c, a, b);
+ if (borrow) multiprecision_add(c, c, modp);
}
// c=a<<b, b<DWORD_BITS, c has a buffer size of Numuint32_ts+1
-uint32_t multiprecision_lshift(uint32_t* c, uint32_t* a, uint32_t keyLength) {
+uint32_t multiprecision_lshift(uint32_t* c, uint32_t* a) {
int j;
uint32_t b = 1;
j = DWORD_BITS - b;
@@ -212,7 +181,7 @@
uint32_t carrier = 0;
uint32_t temp;
- for (uint32_t i = 0; i < keyLength; i++) {
+ for (uint32_t i = 0; i < KEY_LENGTH_DWORDS_P256; i++) {
temp = a[i]; // in case c==a
c[i] = (temp << b) | carrier;
carrier = temp >> j;
@@ -222,19 +191,18 @@
}
// c=a*b; c must have a buffer of 2*Key_LENGTH_uint32_tS, c != a != b
-void multiprecision_mult(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength) {
+void multiprecision_mult(uint32_t* c, uint32_t* a, uint32_t* b) {
uint32_t W;
uint32_t U;
uint32_t V;
U = V = W = 0;
- multiprecision_init(c, keyLength);
+ multiprecision_init(c);
// assume little endian right now
- for (uint32_t i = 0; i < keyLength; i++) {
+ for (uint32_t i = 0; i < KEY_LENGTH_DWORDS_P256; i++) {
U = 0;
- for (uint32_t j = 0; j < keyLength; j++) {
+ for (uint32_t j = 0; j < KEY_LENGTH_DWORDS_P256; j++) {
uint64_t result;
result = ((uint64_t)a[i]) * ((uint64_t)b[j]);
W = result >> 32;
@@ -246,78 +214,7 @@
U += (V < c[i + j]);
c[i + j] = V;
}
- c[i + keyLength] = U;
- }
-}
-
-void multiprecision_fast_mod(uint32_t* c, uint32_t* a) {
- uint32_t U;
- uint32_t V;
- uint32_t* modp = curve.p;
-
- c[0] = a[0] + a[6];
- U = c[0] < a[0];
- c[0] += a[10];
- U += c[0] < a[10];
-
- c[1] = a[1] + U;
- U = c[1] < a[1];
- c[1] += a[7];
- U += c[1] < a[7];
- c[1] += a[11];
- U += c[1] < a[11];
-
- c[2] = a[2] + U;
- U = c[2] < a[2];
- c[2] += a[6];
- U += c[2] < a[6];
- c[2] += a[8];
- U += c[2] < a[8];
- c[2] += a[10];
- U += c[2] < a[10];
-
- c[3] = a[3] + U;
- U = c[3] < a[3];
- c[3] += a[7];
- U += c[3] < a[7];
- c[3] += a[9];
- U += c[3] < a[9];
- c[3] += a[11];
- U += c[3] < a[11];
-
- c[4] = a[4] + U;
- U = c[4] < a[4];
- c[4] += a[8];
- U += c[4] < a[8];
- c[4] += a[10];
- U += c[4] < a[10];
-
- c[5] = a[5] + U;
- U = c[5] < a[5];
- c[5] += a[9];
- U += c[5] < a[9];
- c[5] += a[11];
- U += c[5] < a[11];
-
- c[0] += U;
- V = c[0] < U;
- c[1] += V;
- V = c[1] < V;
- c[2] += V;
- V = c[2] < V;
- c[2] += U;
- V = c[2] < U;
- c[3] += V;
- V = c[3] < V;
- c[4] += V;
- V = c[4] < V;
- c[5] += V;
- V = c[5] < V;
-
- if (V) {
- multiprecision_sub(c, c, modp, KEY_LENGTH_DWORDS_P192);
- } else if (multiprecision_compare(c, modp, KEY_LENGTH_DWORDS_P192) >= 0) {
- multiprecision_sub(c, c, modp, KEY_LENGTH_DWORDS_P192);
+ c[i + KEY_LENGTH_DWORDS_P256] = U;
}
}
@@ -541,74 +438,67 @@
if (U & 0x80000000) {
while (U) {
- multiprecision_add(c, c, modp, KEY_LENGTH_DWORDS_P256);
+ multiprecision_add(c, c, modp);
U++;
}
} else if (U) {
while (U) {
- multiprecision_sub(c, c, modp, KEY_LENGTH_DWORDS_P256);
+ multiprecision_sub(c, c, modp);
U--;
}
}
- if (multiprecision_compare(c, modp, KEY_LENGTH_DWORDS_P256) >= 0)
- multiprecision_sub(c, c, modp, KEY_LENGTH_DWORDS_P256);
+ if (multiprecision_compare(c, modp) >= 0) multiprecision_sub(c, c, modp);
}
-void multiprecision_inv_mod(uint32_t* aminus, uint32_t* u, uint32_t keyLength) {
+void multiprecision_inv_mod(uint32_t* aminus, uint32_t* u) {
uint32_t v[KEY_LENGTH_DWORDS_P256];
uint32_t A[KEY_LENGTH_DWORDS_P256 + 1];
uint32_t C[KEY_LENGTH_DWORDS_P256 + 1];
- uint32_t* modp;
+ uint32_t* modp = curve_p256.p;
- if (keyLength == KEY_LENGTH_DWORDS_P256) {
- modp = curve_p256.p;
- } else {
- modp = curve.p;
- }
-
- multiprecision_copy(v, modp, keyLength);
- multiprecision_init(A, keyLength);
- multiprecision_init(C, keyLength);
+ multiprecision_copy(v, modp);
+ multiprecision_init(A);
+ multiprecision_init(C);
A[0] = 1;
- while (!multiprecision_iszero(u, keyLength)) {
+ while (!multiprecision_iszero(u)) {
while (!(u[0] & 0x01)) // u is even
{
- multiprecision_rshift(u, u, keyLength);
+ multiprecision_rshift(u, u);
if (!(A[0] & 0x01)) // A is even
- multiprecision_rshift(A, A, keyLength);
+ multiprecision_rshift(A, A);
else {
- A[keyLength] = multiprecision_add(A, A, modp, keyLength); // A =A+p
- multiprecision_rshift(A, A, keyLength);
- A[keyLength - 1] |= (A[keyLength] << 31);
+ A[KEY_LENGTH_DWORDS_P256] = multiprecision_add(A, A, modp); // A =A+p
+ multiprecision_rshift(A, A);
+ A[KEY_LENGTH_DWORDS_P256 - 1] |= (A[KEY_LENGTH_DWORDS_P256] << 31);
}
}
while (!(v[0] & 0x01)) // v is even
{
- multiprecision_rshift(v, v, keyLength);
+ multiprecision_rshift(v, v);
if (!(C[0] & 0x01)) // C is even
{
- multiprecision_rshift(C, C, keyLength);
+ multiprecision_rshift(C, C);
} else {
- C[keyLength] = multiprecision_add(C, C, modp, keyLength); // C =C+p
- multiprecision_rshift(C, C, keyLength);
- C[keyLength - 1] |= (C[keyLength] << 31);
+ C[KEY_LENGTH_DWORDS_P256] = multiprecision_add(C, C, modp); // C =C+p
+ multiprecision_rshift(C, C);
+ C[KEY_LENGTH_DWORDS_P256 - 1] |= (C[KEY_LENGTH_DWORDS_P256] << 31);
}
}
- if (multiprecision_compare(u, v, keyLength) >= 0) {
- multiprecision_sub(u, u, v, keyLength);
- multiprecision_sub_mod(A, A, C, keyLength);
+ if (multiprecision_compare(u, v) >= 0) {
+ multiprecision_sub(u, u, v);
+ multiprecision_sub_mod(A, A, C);
} else {
- multiprecision_sub(v, v, u, keyLength);
- multiprecision_sub_mod(C, C, A, keyLength);
+ multiprecision_sub(v, v, u);
+ multiprecision_sub_mod(C, C, A);
}
}
- if (multiprecision_compare(C, modp, keyLength) >= 0)
- multiprecision_sub(aminus, C, modp, keyLength);
+ if (multiprecision_compare(C, modp) >= 0)
+ multiprecision_sub(aminus, C, modp);
else
- multiprecision_copy(aminus, C, keyLength);
+ multiprecision_copy(aminus, C);
}
diff --git a/system/stack/smp/p_256_multprecision.h b/system/stack/smp/p_256_multprecision.h
index fbbd88d..a98fe4d 100644
--- a/system/stack/smp/p_256_multprecision.h
+++ b/system/stack/smp/p_256_multprecision.h
@@ -12,8 +12,7 @@
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
- * limitations under the License.
- *
+ * limitations under the License. *
******************************************************************************/
/*******************************************************************************
@@ -29,40 +28,30 @@
#define DWORD_BYTES 4
#define DWORD_BITS_SHIFT 5
-#define KEY_LENGTH_DWORDS_P192 6
#define KEY_LENGTH_DWORDS_P256 8
/* Arithmetic Operations */
-int multiprecision_compare(uint32_t* a, uint32_t* b, uint32_t keyLength);
-int multiprecision_iszero(uint32_t* a, uint32_t keyLength);
-void multiprecision_init(uint32_t* c, uint32_t keyLength);
-void multiprecision_copy(uint32_t* c, uint32_t* a, uint32_t keyLength);
+int multiprecision_compare(uint32_t* a, uint32_t* b);
+int multiprecision_iszero(uint32_t* a);
+void multiprecision_init(uint32_t* c);
+void multiprecision_copy(uint32_t* c, uint32_t* a);
uint32_t multiprecision_dword_bits(uint32_t a);
-uint32_t multiprecision_most_signdwords(uint32_t* a, uint32_t keyLength);
-uint32_t multiprecision_most_signbits(uint32_t* a, uint32_t keyLength);
-void multiprecision_inv_mod(uint32_t* aminus, uint32_t* a, uint32_t keyLength);
-uint32_t multiprecision_add(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength); // c=a+b
-void multiprecision_add_mod(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength);
-uint32_t multiprecision_sub(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength); // c=a-b
-void multiprecision_sub_mod(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength);
-void multiprecision_rshift(uint32_t* c, uint32_t* a,
- uint32_t keyLength); // c=a>>1, return carrier
-void multiprecision_lshift_mod(uint32_t* c, uint32_t* a,
- uint32_t keyLength); // c=a<<b, return carrier
-uint32_t multiprecision_lshift(uint32_t* c, uint32_t* a,
- uint32_t keyLength); // c=a<<b, return carrier
-void multiprecision_mult(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength); // c=a*b
-void multiprecision_mersenns_mult_mod(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength);
-void multiprecision_mersenns_squa_mod(uint32_t* c, uint32_t* a,
- uint32_t keyLength);
-uint32_t multiprecision_lshift(uint32_t* c, uint32_t* a, uint32_t keyLength);
-void multiprecision_mult(uint32_t* c, uint32_t* a, uint32_t* b,
- uint32_t keyLength);
+uint32_t multiprecision_most_signdwords(uint32_t* a);
+uint32_t multiprecision_most_signbits(uint32_t* a);
+void multiprecision_inv_mod(uint32_t* aminus, uint32_t* a);
+uint32_t multiprecision_add(uint32_t* c, uint32_t* a, uint32_t* b); // c=a+b
+void multiprecision_add_mod(uint32_t* c, uint32_t* a, uint32_t* b);
+uint32_t multiprecision_sub(uint32_t* c, uint32_t* a, uint32_t* b); // c=a-b
+void multiprecision_sub_mod(uint32_t* c, uint32_t* a, uint32_t* b);
+void multiprecision_rshift(uint32_t* c, uint32_t* a); // c=a>>1, return carrier
+void multiprecision_lshift_mod(uint32_t* c,
+ uint32_t* a); // c=a<<b, return carrier
+uint32_t multiprecision_lshift(uint32_t* c,
+ uint32_t* a); // c=a<<b, return carrier
+void multiprecision_mult(uint32_t* c, uint32_t* a, uint32_t* b); // c=a*b
+void multiprecision_mersenns_mult_mod(uint32_t* c, uint32_t* a, uint32_t* b);
+void multiprecision_mersenns_squa_mod(uint32_t* c, uint32_t* a);
+uint32_t multiprecision_lshift(uint32_t* c, uint32_t* a);
+void multiprecision_mult(uint32_t* c, uint32_t* a, uint32_t* b);
void multiprecision_fast_mod(uint32_t* c, uint32_t* a);
void multiprecision_fast_mod_P256(uint32_t* c, uint32_t* a);
diff --git a/system/stack/smp/smp_api.cc b/system/stack/smp/smp_api.cc
index baa41cf..e082356 100644
--- a/system/stack/smp/smp_api.cc
+++ b/system/stack/smp/smp_api.cc
@@ -62,7 +62,7 @@
smp_l2cap_if_init();
/* initialization of P-256 parameters */
- p_256_init_curve(KEY_LENGTH_DWORDS_P256);
+ p_256_init_curve();
/* Initialize failure case for certification */
smp_cb.cert_failure =
diff --git a/system/stack/smp/smp_keys.cc b/system/stack/smp/smp_keys.cc
index da8d0f4..64c969d 100644
--- a/system/stack/smp/smp_keys.cc
+++ b/system/stack/smp/smp_keys.cc
@@ -691,8 +691,7 @@
SMP_TRACE_DEBUG("%s", __func__);
memcpy(private_key, p_cb->private_key, BT_OCTET32_LEN);
- ECC_PointMult(&public_key, &(curve_p256.G), (uint32_t*)private_key,
- KEY_LENGTH_DWORDS_P256);
+ ECC_PointMult(&public_key, &(curve_p256.G), (uint32_t*)private_key);
memcpy(p_cb->loc_publ_key.x, public_key.x, BT_OCTET32_LEN);
memcpy(p_cb->loc_publ_key.y, public_key.y, BT_OCTET32_LEN);
@@ -728,8 +727,7 @@
memcpy(peer_publ_key.x, p_cb->peer_publ_key.x, BT_OCTET32_LEN);
memcpy(peer_publ_key.y, p_cb->peer_publ_key.y, BT_OCTET32_LEN);
- ECC_PointMult(&new_publ_key, &peer_publ_key, (uint32_t*)private_key,
- KEY_LENGTH_DWORDS_P256);
+ ECC_PointMult(&new_publ_key, &peer_publ_key, (uint32_t*)private_key);
memcpy(p_cb->dhkey, new_publ_key.x, BT_OCTET32_LEN);
diff --git a/system/stack/test/stack_smp_test.cc b/system/stack/test/stack_smp_test.cc
index 1bb51ea..d83430c 100644
--- a/system/stack/test/stack_smp_test.cc
+++ b/system/stack/test/stack_smp_test.cc
@@ -261,8 +261,8 @@
TEST(SmpEccValidationTest, test_invalid_points) {
Point p;
- multiprecision_init(p.x, 8);
- multiprecision_init(p.y, 8);
+ multiprecision_init(p.x);
+ multiprecision_init(p.y);
EXPECT_FALSE(ECC_ValidatePoint(p));
