Merge "Replace DWORD with uint32_t" (2a5614d1) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/smp/p_256_ecc_pp.cc

+23 −23

Original line number	Original line	Diff line number	Diff line
	@@ -43,15 +43,15 @@ static void p_256_copy_point(Point q, Point p)
	// q=2q		// q=2q
	static void ECC_Double(Point q, Point p, uint32_t keyLength)		static void ECC_Double(Point q, Point p, uint32_t keyLength)
	{		{
	DWORD t1[KEY_LENGTH_DWORDS_P256];		uint32_t t1[KEY_LENGTH_DWORDS_P256];
	DWORD t2[KEY_LENGTH_DWORDS_P256];		uint32_t t2[KEY_LENGTH_DWORDS_P256];
	DWORD t3[KEY_LENGTH_DWORDS_P256];		uint32_t t3[KEY_LENGTH_DWORDS_P256];
	DWORD *x1;		uint32_t *x1;
	DWORD *x3;		uint32_t *x3;
	DWORD *y1;		uint32_t *y1;
	DWORD *y3;		uint32_t *y3;
	DWORD *z1;		uint32_t *z1;
	DWORD *z3;		uint32_t *z3;

	if (multiprecision_iszero(p->z, keyLength))		if (multiprecision_iszero(p->z, keyLength))
	{		{
	@@ -90,17 +90,17 @@ static void ECC_Double(Point q, Point p, uint32_t keyLength)
	// q=q+p, zp must be 1		// 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 keyLength)
	{		{
	DWORD t1[KEY_LENGTH_DWORDS_P256];		uint32_t t1[KEY_LENGTH_DWORDS_P256];
	DWORD t2[KEY_LENGTH_DWORDS_P256];		uint32_t t2[KEY_LENGTH_DWORDS_P256];
	DWORD *x1;		uint32_t *x1;
	DWORD *x2;		uint32_t *x2;
	DWORD *x3;		uint32_t *x3;
	DWORD *y1;		uint32_t *y1;
	DWORD *y2;		uint32_t *y2;
	DWORD *y3;		uint32_t *y3;
	DWORD *z1;		uint32_t *z1;
	DWORD *z2;		uint32_t *z2;
	DWORD *z3;		uint32_t *z3;

	x1=p->x; y1=p->y; z1=p->z;		x1=p->x; y1=p->y; z1=p->z;
	x2=q->x; y2=q->y; z2=q->z;		x2=q->x; y2=q->y; z2=q->z;
	@@ -157,7 +157,7 @@ static void ECC_Add(Point r, Point p, Point *q, uint32_t keyLength)
	}		}

	// Computing the Non-Adjacent Form of a positive integer		// Computing the Non-Adjacent Form of a positive integer
	static void ECC_NAF(uint8_t naf, uint32_t NumNAF, DWORD *k, uint32_t keyLength)		static void ECC_NAF(uint8_t naf, uint32_t NumNAF, uint32_t *k, uint32_t keyLength)
	{		{
	uint32_t sign;		uint32_t sign;
	int i=0;		int i=0;
	@@ -198,14 +198,14 @@ static void ECC_NAF(uint8_t naf, uint32_t NumNAF, DWORD *k, uint32_t keyLength
	}		}

	// Binary Non-Adjacent Form for point multiplication		// Binary Non-Adjacent Form for point multiplication
	void ECC_PointMult_Bin_NAF(Point q, Point p, DWORD *n, uint32_t keyLength)		void ECC_PointMult_Bin_NAF(Point q, Point p, uint32_t *n, uint32_t keyLength)
	{		{
	uint32_t sign;		uint32_t sign;
	uint8_t naf[256 / 4 +1];		uint8_t naf[256 / 4 +1];
	uint32_t NumNaf;		uint32_t NumNaf;
	Point minus_p;		Point minus_p;
	Point r;		Point r;
	DWORD *modp;		uint32_t *modp;

	if (keyLength == KEY_LENGTH_DWORDS_P256)		if (keyLength == KEY_LENGTH_DWORDS_P256)
	{		{

system/stack/smp/p_256_ecc_pp.h

+8 −10

Original line number	Original line	Diff line number	Diff line
	@@ -26,27 +26,25 @@

	#include "p_256_multprecision.h"		#include "p_256_multprecision.h"

	typedef unsigned long DWORD;

	typedef struct {		typedef struct {
	DWORD x[KEY_LENGTH_DWORDS_P256];		uint32_t x[KEY_LENGTH_DWORDS_P256];
	DWORD y[KEY_LENGTH_DWORDS_P256];		uint32_t y[KEY_LENGTH_DWORDS_P256];
	DWORD z[KEY_LENGTH_DWORDS_P256];		uint32_t z[KEY_LENGTH_DWORDS_P256];
	} Point;		} Point;

	typedef struct {		typedef struct {
	// curve's coefficients		// curve's coefficients
	DWORD a[KEY_LENGTH_DWORDS_P256];		uint32_t a[KEY_LENGTH_DWORDS_P256];
	DWORD b[KEY_LENGTH_DWORDS_P256];		uint32_t b[KEY_LENGTH_DWORDS_P256];

	//whether a is -3		//whether a is -3
	int a_minus3;		int a_minus3;

	// prime modulus		// prime modulus
	DWORD p[KEY_LENGTH_DWORDS_P256];		uint32_t p[KEY_LENGTH_DWORDS_P256];

	// Omega, p = 2^m -omega		// Omega, p = 2^m -omega
	DWORD omega[KEY_LENGTH_DWORDS_P256];		uint32_t omega[KEY_LENGTH_DWORDS_P256];

	// base point, a point on E of order r		// base point, a point on E of order r
	Point G;		Point G;
	@@ -56,7 +54,7 @@ typedef struct {
	extern elliptic_curve_t curve;		extern elliptic_curve_t curve;
	extern elliptic_curve_t curve_p256;		extern elliptic_curve_t curve_p256;

	void ECC_PointMult_Bin_NAF(Point q, Point p, DWORD *n, uint32_t keyLength);		void ECC_PointMult_Bin_NAF(Point q, Point p, uint32_t *n, uint32_t keyLength);

	#define ECC_PointMult(q, p, n, keyLength) ECC_PointMult_Bin_NAF(q, p, n, keyLength)		#define ECC_PointMult(q, p, n, keyLength) ECC_PointMult_Bin_NAF(q, p, n, keyLength)

system/stack/smp/p_256_multprecision.cc

+64 −64

Original line number	Original line	Diff line number	Diff line
	@@ -27,19 +27,19 @@
	#include "p_256_ecc_pp.h"		#include "p_256_ecc_pp.h"
	#include "p_256_multprecision.h"		#include "p_256_multprecision.h"

	void multiprecision_init(DWORD *c, uint32_t keyLength)		void multiprecision_init(uint32_t *c, uint32_t keyLength)
	{		{
	for (uint32_t i = 0; i < keyLength; i++)		for (uint32_t i = 0; i < keyLength; i++)
	c[i] = 0;		c[i] = 0;
	}		}

	void multiprecision_copy(DWORD c, DWORD a, uint32_t keyLength)		void multiprecision_copy(uint32_t c, uint32_t a, uint32_t keyLength)
	{		{
	for (uint32_t i = 0; i < keyLength; i++)		for (uint32_t i = 0; i < keyLength; i++)
	c[i] = a[i];		c[i] = a[i];
	}		}

	int multiprecision_compare(DWORD a, DWORD b, uint32_t keyLength)		int multiprecision_compare(uint32_t a, uint32_t b, uint32_t keyLength)
	{		{
	for (int i = keyLength - 1; i >= 0; i--)		for (int i = keyLength - 1; i >= 0; i--)
	{		{
	@@ -51,7 +51,7 @@ int multiprecision_compare(DWORD a, DWORD b, uint32_t keyLength)
	return 0;		return 0;
	}		}

	int multiprecision_iszero(DWORD *a, uint32_t keyLength)		int multiprecision_iszero(uint32_t *a, uint32_t keyLength)
	{		{
	for (uint32_t i = 0; i < keyLength; i++)		for (uint32_t i = 0; i < keyLength; i++)
	if (a[i])		if (a[i])
	@@ -60,7 +60,7 @@ int multiprecision_iszero(DWORD *a, uint32_t keyLength)
	return 1;		return 1;
	}		}

	uint32_t multiprecision_dword_bits(DWORD a)		uint32_t multiprecision_dword_bits(uint32_t a)
	{		{
	uint32_t i;		uint32_t i;
	for (i = 0; i < DWORD_BITS; i++, a >>= 1)		for (i = 0; i < DWORD_BITS; i++, a >>= 1)
	@@ -70,7 +70,7 @@ uint32_t multiprecision_dword_bits(DWORD a)
	return i;		return i;
	}		}

	uint32_t multiprecision_most_signdwords(DWORD *a, uint32_t keyLength)		uint32_t multiprecision_most_signdwords(uint32_t *a, uint32_t keyLength)
	{		{
	int i;		int i;
	for (i = keyLength - 1; i >= 0; i--)		for (i = keyLength - 1; i >= 0; i--)
	@@ -79,7 +79,7 @@ uint32_t multiprecision_most_signdwords(DWORD *a, uint32_t keyLength)
	return (i + 1);		return (i + 1);
	}		}

	uint32_t multiprecision_most_signbits(DWORD *a, uint32_t keyLength)		uint32_t multiprecision_most_signbits(uint32_t *a, uint32_t keyLength)
	{		{
	int aMostSignDWORDs;		int aMostSignDWORDs;

	@@ -91,10 +91,10 @@ uint32_t multiprecision_most_signbits(DWORD *a, uint32_t keyLength)
	multiprecision_dword_bits(a[aMostSignDWORDs-1]) );		multiprecision_dword_bits(a[aMostSignDWORDs-1]) );
	}		}

	DWORD multiprecision_add(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)		uint32_t multiprecision_add(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength)
	{		{
	DWORD carrier;		uint32_t carrier;
	DWORD temp;		uint32_t temp;

	carrier=0;		carrier=0;
	for (uint32_t i = 0; i < keyLength; i++)		for (uint32_t i = 0; i < keyLength; i++)
	@@ -110,10 +110,10 @@ DWORD multiprecision_add(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)
	}		}

	//c=a-b		//c=a-b
	DWORD multiprecision_sub(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)		uint32_t multiprecision_sub(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength)
	{		{
	DWORD borrow;		uint32_t borrow;
	DWORD temp;		uint32_t temp;

	borrow=0;		borrow=0;
	for (uint32_t i=0; i < keyLength; i++)		for (uint32_t i=0; i < keyLength; i++)
	@@ -128,10 +128,10 @@ DWORD multiprecision_sub(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)
	}		}

	// c = a << 1		// c = a << 1
	void multiprecision_lshift_mod(DWORD * c, DWORD * a, uint32_t keyLength)		void multiprecision_lshift_mod(uint32_t * c, uint32_t * a, uint32_t keyLength)
	{		{
	DWORD carrier;		uint32_t carrier;
	DWORD *modp;		uint32_t *modp;

	if (keyLength == KEY_LENGTH_DWORDS_P192)		if (keyLength == KEY_LENGTH_DWORDS_P192)
	{		{
	@@ -156,15 +156,15 @@ void multiprecision_lshift_mod(DWORD * c, DWORD * a, uint32_t keyLength)
	}		}

	// c=a>>1		// c=a>>1
	void multiprecision_rshift(DWORD * c, DWORD * a, uint32_t keyLength)		void multiprecision_rshift(uint32_t * c, uint32_t * a, uint32_t keyLength)
	{		{
	int j;		int j;
	DWORD b = 1;		uint32_t b = 1;

	j = DWORD_BITS - b;		j = DWORD_BITS - b;

	DWORD carrier = 0;		uint32_t carrier = 0;
	DWORD temp;		uint32_t temp;
	for (int i = keyLength-1; i >= 0; i--)		for (int i = keyLength-1; i >= 0; i--)
	{		{
	temp = a[i]; // in case of c==a		temp = a[i]; // in case of c==a
	@@ -174,9 +174,9 @@ void multiprecision_rshift(DWORD * c, DWORD * a, uint32_t keyLength)
	}		}

	// Curve specific optimization when p is a pseudo-Mersenns prime, p=2^(KEY_LENGTH_BITS)-omega		// Curve specific optimization when p is a pseudo-Mersenns prime, p=2^(KEY_LENGTH_BITS)-omega
	void multiprecision_mersenns_mult_mod(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)		void multiprecision_mersenns_mult_mod(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength)
	{		{
	DWORD cc[2*KEY_LENGTH_DWORDS_P256];		uint32_t cc[2*KEY_LENGTH_DWORDS_P256];

	multiprecision_mult(cc, a, b, keyLength);		multiprecision_mult(cc, a, b, keyLength);
	if (keyLength == 6)		if (keyLength == 6)
	@@ -190,16 +190,16 @@ void multiprecision_mersenns_mult_mod(DWORD c, DWORD a, DWORD *b, uint32_t key
	}		}

	// Curve specific optimization when p is a pseudo-Mersenns prime		// Curve specific optimization when p is a pseudo-Mersenns prime
	void multiprecision_mersenns_squa_mod(DWORD c, DWORD a, uint32_t keyLength)		void multiprecision_mersenns_squa_mod(uint32_t c, uint32_t a, uint32_t keyLength)
	{		{
	multiprecision_mersenns_mult_mod(c, a, a, keyLength);		multiprecision_mersenns_mult_mod(c, a, a, keyLength);
	}		}

	// c=(a+b) mod p, b<p, a<p		// c=(a+b) mod p, b<p, a<p
	void multiprecision_add_mod(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)		void multiprecision_add_mod(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength)
	{		{
	DWORD carrier;		uint32_t carrier;
	DWORD *modp;		uint32_t *modp;

	if (keyLength == KEY_LENGTH_DWORDS_P192)		if (keyLength == KEY_LENGTH_DWORDS_P192)
	{		{
	@@ -224,10 +224,10 @@ void multiprecision_add_mod(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)
	}		}

	// c=(a-b) mod p, a<p, b<p		// c=(a-b) mod p, a<p, b<p
	void multiprecision_sub_mod(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)		void multiprecision_sub_mod(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength)
	{		{
	DWORD borrow;		uint32_t borrow;
	DWORD *modp;		uint32_t *modp;

	if (keyLength == KEY_LENGTH_DWORDS_P192)		if (keyLength == KEY_LENGTH_DWORDS_P192)
	{		{
	@@ -245,15 +245,15 @@ void multiprecision_sub_mod(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)
	multiprecision_add(c, c, modp, keyLength);		multiprecision_add(c, c, modp, keyLength);
	}		}

	// c=a<<b, b<DWORD_BITS, c has a buffer size of NumDWORDs+1		// c=a<<b, b<DWORD_BITS, c has a buffer size of Numuint32_ts+1
	DWORD multiprecision_lshift(DWORD * c, DWORD * a, uint32_t keyLength)		uint32_t multiprecision_lshift(uint32_t * c, uint32_t * a, uint32_t keyLength)
	{		{
	int j;		int j;
	uint32_t b = 1;		uint32_t b = 1;
	j = DWORD_BITS - b;		j = DWORD_BITS - b;

	DWORD carrier = 0;		uint32_t carrier = 0;
	DWORD temp;		uint32_t temp;

	for (uint32_t i = 0; i < keyLength; i++)		for (uint32_t i = 0; i < keyLength; i++)
	{		{
	@@ -265,12 +265,12 @@ DWORD multiprecision_lshift(DWORD * c, DWORD * a, uint32_t keyLength)
	return carrier;		return carrier;
	}		}

	// c=ab; c must have a buffer of 2Key_LENGTH_DWORDS, c != a != b		// c=ab; c must have a buffer of 2Key_LENGTH_uint32_tS, c != a != b
	void multiprecision_mult(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)		void multiprecision_mult(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength)
	{		{
	DWORD W;		uint32_t W;
	DWORD U;		uint32_t U;
	DWORD V;		uint32_t V;

	U = V = W = 0;		U = V = W = 0;
	multiprecision_init(c, keyLength);		multiprecision_init(c, keyLength);
	@@ -296,11 +296,11 @@ void multiprecision_mult(DWORD c, DWORD a, DWORD *b, uint32_t keyLength)
	}		}
	}		}

	void multiprecision_fast_mod(DWORD c, DWORD a)		void multiprecision_fast_mod(uint32_t c, uint32_t a)
	{		{
	DWORD U;		uint32_t U;
	DWORD V;		uint32_t V;
	DWORD *modp = curve.p;		uint32_t *modp = curve.p;

	c[0] = a[0] + a[6];		c[0] = a[0] + a[6];
	U=c[0] < a[0];		U=c[0] < a[0];
	@@ -371,15 +371,15 @@ void multiprecision_fast_mod(DWORD c, DWORD a)
	}		}
	}		}

	void multiprecision_fast_mod_P256(DWORD c, DWORD a)		void multiprecision_fast_mod_P256(uint32_t c, uint32_t a)
	{		{
	DWORD A;		uint32_t A;
	DWORD B;		uint32_t B;
	DWORD C;		uint32_t C;
	DWORD D;		uint32_t D;
	DWORD E;		uint32_t E;
	DWORD F;		uint32_t F;
	DWORD G;		uint32_t G;
	uint8_t UA;		uint8_t UA;
	uint8_t UB;		uint8_t UB;
	uint8_t UC;		uint8_t UC;
	@@ -387,8 +387,8 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)
	uint8_t UE;		uint8_t UE;
	uint8_t UF;		uint8_t UF;
	uint8_t UG;		uint8_t UG;
	DWORD U;		uint32_t U;
	DWORD *modp = curve_p256.p;		uint32_t *modp = curve_p256.p;

	// C = a[13] + a[14] + a[15];		// C = a[13] + a[14] + a[15];
	C = a[13];		C = a[13];
	@@ -444,7 +444,7 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)

	if (U & 0x80000000)		if (U & 0x80000000)
	{		{
	DWORD UU;		uint32_t UU;
	UU = 0 - U;		UU = 0 - U;
	U = (a[1] < UU);		U = (a[1] < UU);
	c[1] = a[1] - UU;		c[1] = a[1] - UU;
	@@ -464,7 +464,7 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)

	if (U & 0x80000000)		if (U & 0x80000000)
	{		{
	DWORD UU;		uint32_t UU;
	UU = 0 - U;		UU = 0 - U;
	U = (a[2] < UU);		U = (a[2] < UU);
	c[2] = a[2] - UU;		c[2] = a[2] - UU;
	@@ -484,7 +484,7 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)

	if (U & 0x80000000)		if (U & 0x80000000)
	{		{
	DWORD UU;		uint32_t UU;
	UU = 0 - U;		UU = 0 - U;
	U = (a[3] < UU);		U = (a[3] < UU);
	c[3] = a[3] - UU;		c[3] = a[3] - UU;
	@@ -512,7 +512,7 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)

	if (U & 0x80000000)		if (U & 0x80000000)
	{		{
	DWORD UU;		uint32_t UU;
	UU = 0 - U;		UU = 0 - U;
	U = (a[4] < UU);		U = (a[4] < UU);
	c[4] = a[4] - UU;		c[4] = a[4] - UU;
	@@ -538,7 +538,7 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)

	if (U & 0x80000000)		if (U & 0x80000000)
	{		{
	DWORD UU;		uint32_t UU;
	UU = 0 - U;		UU = 0 - U;
	U = (a[5] < UU);		U = (a[5] < UU);
	c[5] = a[5] - UU;		c[5] = a[5] - UU;
	@@ -562,7 +562,7 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)

	if (U & 0x80000000)		if (U & 0x80000000)
	{		{
	DWORD UU;		uint32_t UU;
	UU = 0 - U;		UU = 0 - U;
	U = (a[6] < UU);		U = (a[6] < UU);
	c[6] = a[6] - UU;		c[6] = a[6] - UU;
	@@ -588,7 +588,7 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)

	if (U & 0x80000000)		if (U & 0x80000000)
	{		{
	DWORD UU;		uint32_t UU;
	UU = 0 - U;		UU = 0 - U;
	U = (a[7] < UU);		U = (a[7] < UU);
	c[7] = a[7] - UU;		c[7] = a[7] - UU;
	@@ -633,12 +633,12 @@ void multiprecision_fast_mod_P256(DWORD c, DWORD a)

	}		}

	void multiprecision_inv_mod(DWORD aminus, DWORD u, uint32_t keyLength)		void multiprecision_inv_mod(uint32_t aminus, uint32_t u, uint32_t keyLength)
	{		{
	DWORD v[KEY_LENGTH_DWORDS_P256];		uint32_t v[KEY_LENGTH_DWORDS_P256];
	DWORD A[KEY_LENGTH_DWORDS_P256+1];		uint32_t A[KEY_LENGTH_DWORDS_P256+1];
	DWORD C[KEY_LENGTH_DWORDS_P256+1];		uint32_t C[KEY_LENGTH_DWORDS_P256+1];
	DWORD *modp;		uint32_t *modp;

	if(keyLength == KEY_LENGTH_DWORDS_P256)		if(keyLength == KEY_LENGTH_DWORDS_P256)
	{		{

system/stack/smp/p_256_multprecision.h

+22 −25

Original line number	Original line	Diff line number	Diff line
	@@ -25,9 +25,6 @@

	#include "bt_types.h"		#include "bt_types.h"

	/* Type definitions */
	typedef unsigned long DWORD;

	#define DWORD_BITS 32		#define DWORD_BITS 32
	#define DWORD_BYTES 4		#define DWORD_BYTES 4
	#define DWORD_BITS_SHIFT 5		#define DWORD_BITS_SHIFT 5
	@@ -36,27 +33,27 @@ typedef unsigned long DWORD;
	#define KEY_LENGTH_DWORDS_P256 8		#define KEY_LENGTH_DWORDS_P256 8
	/* Arithmetic Operations */		/* Arithmetic Operations */

	int multiprecision_compare(DWORD a, DWORD b, uint32_t keyLength);		int multiprecision_compare(uint32_t a, uint32_t b, uint32_t keyLength);
	int multiprecision_iszero(DWORD *a, uint32_t keyLength);		int multiprecision_iszero(uint32_t *a, uint32_t keyLength);
	void multiprecision_init(DWORD *c, uint32_t keyLength);		void multiprecision_init(uint32_t *c, uint32_t keyLength);
	void multiprecision_copy(DWORD c, DWORD a, uint32_t keyLength);		void multiprecision_copy(uint32_t c, uint32_t a, uint32_t keyLength);
	uint32_t multiprecision_dword_bits (DWORD a);		uint32_t multiprecision_dword_bits (uint32_t a);
	uint32_t multiprecision_most_signdwords(DWORD *a, uint32_t keyLength);		uint32_t multiprecision_most_signdwords(uint32_t *a, uint32_t keyLength);
	uint32_t multiprecision_most_signbits(DWORD *a, uint32_t keyLength);		uint32_t multiprecision_most_signbits(uint32_t *a, uint32_t keyLength);
	void multiprecision_inv_mod(DWORD aminus, DWORD a, uint32_t keyLength);		void multiprecision_inv_mod(uint32_t aminus, uint32_t a, uint32_t keyLength);
	DWORD multiprecision_add(DWORD c, DWORD a, DWORD *b, uint32_t keyLength); // c=a+b		uint32_t multiprecision_add(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength); // c=a+b
	void multiprecision_add_mod(DWORD c, DWORD a, DWORD *b, uint32_t keyLength);		void multiprecision_add_mod(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength);
	DWORD multiprecision_sub(DWORD c, DWORD a, DWORD *b, uint32_t keyLength); // c=a-b		uint32_t multiprecision_sub(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength); // c=a-b
	void multiprecision_sub_mod(DWORD c, DWORD a, DWORD *b, uint32_t keyLength);		void multiprecision_sub_mod(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength);
	void multiprecision_rshift(DWORD * c, DWORD * a, uint32_t keyLength); // c=a>>1, return carrier		void multiprecision_rshift(uint32_t * c, uint32_t * a, uint32_t keyLength); // c=a>>1, return carrier
	void multiprecision_lshift_mod(DWORD * c, DWORD * a, uint32_t keyLength); // c=a<<b, return carrier		void multiprecision_lshift_mod(uint32_t * c, uint32_t * a, uint32_t keyLength); // c=a<<b, return carrier
	DWORD multiprecision_lshift(DWORD * c, DWORD * 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(DWORD c, DWORD a, DWORD b, uint32_t keyLength); // c=ab		void multiprecision_mult(uint32_t c, uint32_t a, uint32_t b, uint32_t keyLength); // c=ab
	void multiprecision_mersenns_mult_mod(DWORD c, DWORD a, DWORD *b, uint32_t keyLength);		void multiprecision_mersenns_mult_mod(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength);
	void multiprecision_mersenns_squa_mod(DWORD c, DWORD a, uint32_t keyLength);		void multiprecision_mersenns_squa_mod(uint32_t c, uint32_t a, uint32_t keyLength);
	DWORD multiprecision_lshift(DWORD * c, DWORD * a, uint32_t keyLength);		uint32_t multiprecision_lshift(uint32_t * c, uint32_t * a, uint32_t keyLength);
	void multiprecision_mult(DWORD c, DWORD a, DWORD *b, uint32_t keyLength);		void multiprecision_mult(uint32_t c, uint32_t a, uint32_t *b, uint32_t keyLength);
	void multiprecision_fast_mod(DWORD c, DWORD a);		void multiprecision_fast_mod(uint32_t c, uint32_t a);
	void multiprecision_fast_mod_P256(DWORD c, DWORD a);		void multiprecision_fast_mod_P256(uint32_t c, uint32_t a);

system/stack/smp/smp_keys.cc

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -1059,7 +1059,7 @@ void smp_process_private_key(tSMP_CB *p_cb)
	SMP_TRACE_DEBUG ("%s", __func__);		SMP_TRACE_DEBUG ("%s", __func__);

	memcpy(private_key, p_cb->private_key, BT_OCTET32_LEN);		memcpy(private_key, p_cb->private_key, BT_OCTET32_LEN);
	ECC_PointMult(&public_key, &(curve_p256.G), (DWORD*) private_key, KEY_LENGTH_DWORDS_P256);		ECC_PointMult(&public_key, &(curve_p256.G), (uint32_t*) private_key, KEY_LENGTH_DWORDS_P256);
	memcpy(p_cb->loc_publ_key.x, public_key.x, BT_OCTET32_LEN);		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);		memcpy(p_cb->loc_publ_key.y, public_key.y, BT_OCTET32_LEN);

	@@ -1096,7 +1096,7 @@ void smp_compute_dhkey (tSMP_CB *p_cb)
	memcpy(peer_publ_key.x, p_cb->peer_publ_key.x, BT_OCTET32_LEN);		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);		memcpy(peer_publ_key.y, p_cb->peer_publ_key.y, BT_OCTET32_LEN);

	ECC_PointMult(&new_publ_key, &peer_publ_key, (DWORD*) private_key, KEY_LENGTH_DWORDS_P256);		ECC_PointMult(&new_publ_key, &peer_publ_key, (uint32_t*) private_key, KEY_LENGTH_DWORDS_P256);

	memcpy(p_cb->dhkey, new_publ_key.x, BT_OCTET32_LEN);		memcpy(p_cb->dhkey, new_publ_key.x, BT_OCTET32_LEN);