Import Andrew Moon's ed25519-donna. (7b10741b) · Commits · Nick Mathewson / Tor

src/ext/README

+5 −0

Original line number	Diff line number	Diff line
		@@ -60,6 +60,11 @@ ed25519/ref10/*
		Daniel Bernsten's portable ref10 implementation of ed25519.
		Public domain.

		ed25519/donna/*

		Andrew Moon's semi-portable ed25519-donna implementation of
		ed25519. Public domain.

		readpassphrase.[ch]

		Portable readpassphrase implementation from OpenSSH portable, version

src/ext/ed25519/donna/README.md

0 → 100644

+183 −0

Original line number	Diff line number	Diff line
		[ed25519](http://ed25519.cr.yp.to/) is an
		[Elliptic Curve Digital Signature Algortithm](http://en.wikipedia.org/wiki/Elliptic_Curve_DSA),
		developed by [Dan Bernstein](http://cr.yp.to/djb.html),
		[Niels Duif](http://www.nielsduif.nl/),
		[Tanja Lange](http://hyperelliptic.org/tanja),
		[Peter Schwabe](http://www.cryptojedi.org/users/peter/),
		and [Bo-Yin Yang](http://www.iis.sinica.edu.tw/pages/byyang/).

		This project provides performant, portable 32-bit & 64-bit implementations. All implementations are
		of course constant time in regard to secret data.

		#### Performance

		SSE2 code and benches have not been updated yet. I will do those next.

		Compilers versions are gcc 4.6.3, icc 13.1.1, clang 3.4-1~exp1.

		Batch verification time (in parentheses) is the average time per 1 verification in a batch of 64 signatures. Counts are in thousands of cycles.

		Note that SSE2 performance may be less impressive on AMD & older CPUs with slower SSE ops!

		Visual Studio performance for `ge25519_scalarmult_base_niels` will lag behind a bit until optimized assembler versions of `ge25519_scalarmult_base_choose_niels`
		are made.

		##### E5200 @ 2.5ghz, march=core2

		<table>
		<thead><tr><th>Implementation</th><th>Sign</th><th>gcc</th><th>icc</th><th>clang</th><th>Verify</th><th>gcc</th><th>icc</th><th>clang</th></tr></thead>
		<tbody>
		<tr><td>ed25519-donna 64bit </td><td></td><td>100k</td><td>110k</td><td>137k</td><td></td><td>327k (144k) </td><td>342k (163k) </td><td>422k (194k) </td></tr>
		<tr><td>amd64-64-24k </td><td></td><td>102k</td><td> </td><td> </td><td></td><td>355k (158k) </td><td> </td><td> </td></tr>
		<tr><td>ed25519-donna-sse2 64bit</td><td></td><td>108k</td><td>111k</td><td>116k</td><td></td><td>353k (155k) </td><td>345k (154k) </td><td>360k (161k) </td></tr>
		<tr><td>amd64-51-32k </td><td></td><td>116k</td><td> </td><td> </td><td></td><td>380k (175k) </td><td> </td><td> </td></tr>
		<tr><td>ed25519-donna-sse2 32bit</td><td></td><td>147k</td><td>147k</td><td>156k</td><td></td><td>380k (178k) </td><td>381k (173k) </td><td>430k (192k) </td></tr>
		<tr><td>ed25519-donna 32bit </td><td></td><td>597k</td><td>335k</td><td>380k</td><td></td><td>1693k (720k)</td><td>1052k (453k)</td><td>1141k (493k)</td></tr>
		</tbody>
		</table>

		##### E3-1270 @ 3.4ghz, march=corei7-avx

		<table>
		<thead><tr><th>Implementation</th><th>Sign</th><th>gcc</th><th>icc</th><th>clang</th><th>Verify</th><th>gcc</th><th>icc</th><th>clang</th></tr></thead>
		<tbody>
		<tr><td>amd64-64-24k </td><td></td><td> 68k</td><td> </td><td> </td><td></td><td>225k (104k) </td><td> </td><td> </td></tr>
		<tr><td>ed25519-donna 64bit </td><td></td><td> 71k</td><td> 75k</td><td> 90k</td><td></td><td>226k (105k) </td><td>226k (112k) </td><td>277k (125k) </td></tr>
		<tr><td>amd64-51-32k </td><td></td><td> 72k</td><td> </td><td> </td><td></td><td>218k (107k) </td><td> </td><td> </td></tr>
		<tr><td>ed25519-donna-sse2 64bit</td><td></td><td> 79k</td><td> 82k</td><td> 92k</td><td></td><td>252k (122k) </td><td>259k (124k) </td><td>282k (131k) </td></tr>
		<tr><td>ed25519-donna-sse2 32bit</td><td></td><td> 94k</td><td> 95k</td><td>103k</td><td></td><td>296k (146k) </td><td>294k (137k) </td><td>306k (147k) </td></tr>
		<tr><td>ed25519-donna 32bit </td><td></td><td>525k</td><td>299k</td><td>316k</td><td></td><td>1502k (645k)</td><td>959k (418k) </td><td>954k (416k) </td></tr>
		</tbody>
		</table>

		#### Compilation

		No configuration is needed if you are compiling against OpenSSL.

		##### Hash Options

		If you are not compiling aginst OpenSSL, you will need a hash function.

		To use a simple/slow implementation of SHA-512, use `-DED25519_REFHASH` when compiling `ed25519.c`.
		This should never be used except to verify the code works when OpenSSL is not available.

		To use a custom hash function, use `-DED25519_CUSTOMHASH` when compiling `ed25519.c` and put your
		custom hash implementation in ed25519-hash-custom.h. The hash must have a 512bit digest and implement

		struct ed25519_hash_context;

		void ed25519_hash_init(ed25519_hash_context *ctx);
		void ed25519_hash_update(ed25519_hash_context ctx, const uint8_t in, size_t inlen);
		void ed25519_hash_final(ed25519_hash_context ctx, uint8_t hash);
		void ed25519_hash(uint8_t hash, const uint8_t in, size_t inlen);

		##### Random Options

		If you are not compiling aginst OpenSSL, you will need a random function for batch verification.

		To use a custom random function, use `-DED25519_CUSTOMRANDOM` when compiling `ed25519.c` and put your
		custom hash implementation in ed25519-randombytes-custom.h. The random function must implement:

		void ED25519_FN(ed25519_randombytes_unsafe) (void *p, size_t len);

		Use `-DED25519_TEST` when compiling `ed25519.c` to use a deterministically seeded, non-thread safe CSPRNG
		variant of Bob Jenkins [ISAAC](http://en.wikipedia.org/wiki/ISAAC_%28cipher%29)

		##### Minor options

		Use `-DED25519_INLINE_ASM` to disable the use of custom assembler routines and instead rely on portable C.

		Use `-DED25519_FORCE_32BIT` to force the use of 32 bit routines even when compiling for 64 bit.

		##### 32-bit

		gcc ed25519.c -m32 -O3 -c

		##### 64-bit

		gcc ed25519.c -m64 -O3 -c

		##### SSE2

		gcc ed25519.c -m32 -O3 -c -DED25519_SSE2 -msse2
		gcc ed25519.c -m64 -O3 -c -DED25519_SSE2

		clang and icc are also supported


		#### Usage

		To use the code, link against `ed25519.o -mbits` and:

		#include "ed25519.h"

		Add `-lssl -lcrypto` when using OpenSSL (Some systems don't need -lcrypto? It might be trial and error).

		To generate a private key, simply generate 32 bytes from a secure
		cryptographic source:

		ed25519_secret_key sk;
		randombytes(sk, sizeof(ed25519_secret_key));

		To generate a public key:

		ed25519_public_key pk;
		ed25519_publickey(sk, pk);

		To sign a message:

		ed25519_signature sig;
		ed25519_sign(message, message_len, sk, pk, signature);

		To verify a signature:

		int valid = ed25519_sign_open(message, message_len, pk, signature) == 0;

		To batch verify signatures:

		const unsigned char *mp[num] = {message1, message2..}
		size_t ml[num] = {message_len1, message_len2..}
		const unsigned char *pkp[num] = {pk1, pk2..}
		const unsigned char *sigp[num] = {signature1, signature2..}
		int valid[num]

		/* valid[i] will be set to 1 if the individual signature was valid, 0 otherwise */
		int all_valid = ed25519_sign_open_batch(mp, ml, pkp, sigp, num, valid) == 0;

		Note: Batch verification uses `ed25519_randombytes_unsafe`, implemented in
		`ed25519-randombytes.h`, to generate random scalars for the verification code.
		The default implementation now uses OpenSSLs `RAND_bytes`.

		Unlike the [SUPERCOP](http://bench.cr.yp.to/supercop.html) version, signatures are
		not appended to messages, and there is no need for padding in front of messages.
		Additionally, the secret key does not contain a copy of the public key, so it is
		32 bytes instead of 64 bytes, and the public key must be provided to the signing
		function.

		##### Curve25519

		Curve25519 public keys can be generated thanks to
		[Adam Langley](http://www.imperialviolet.org/2013/05/10/fastercurve25519.html)
		leveraging Ed25519's precomputed basepoint scalar multiplication.

		curved25519_key sk, pk;
		randombytes(sk, sizeof(curved25519_key));
		curved25519_scalarmult_basepoint(pk, sk);

		Note the name is curved25519, a combination of curve and ed25519, to prevent
		name clashes. Performance is slightly faster than short message ed25519
		signing due to both using the same code for the scalar multiply.

		#### Testing

		Fuzzing against reference implemenations is now available. See [fuzz/README](fuzz/README.md).

		Building `ed25519.c` with `-DED25519_TEST` and linking with `test.c` will run basic sanity tests
		and benchmark each function. `test-batch.c` has been incorporated in to `test.c`.

		`test-internals.c` is standalone and built the same way as `ed25519.c`. It tests the math primitives
		with extreme values to ensure they function correctly. SSE2 is now supported.

		#### Papers

		[Available on the Ed25519 website](http://ed25519.cr.yp.to/papers.html)
		No newline at end of file

src/ext/ed25519/donna/curve25519-donna-32bit.h

0 → 100644

+579 −0

File added.

Preview size limit exceeded, changes collapsed.

src/ext/ed25519/donna/curve25519-donna-64bit.h

0 → 100644

+413 −0

Original line number	Diff line number	Diff line
		/*
		Public domain by Adam Langley <agl@imperialviolet.org> &
		Andrew M. <liquidsun@gmail.com>
		See: https://github.com/floodyberry/curve25519-donna

		64bit integer curve25519 implementation
		*/

		typedef uint64_t bignum25519[5];

		static const uint64_t reduce_mask_40 = ((uint64_t)1 << 40) - 1;
		static const uint64_t reduce_mask_51 = ((uint64_t)1 << 51) - 1;
		static const uint64_t reduce_mask_56 = ((uint64_t)1 << 56) - 1;

		/* out = in */
		DONNA_INLINE static void
		curve25519_copy(bignum25519 out, const bignum25519 in) {
		out[0] = in[0];
		out[1] = in[1];
		out[2] = in[2];
		out[3] = in[3];
		out[4] = in[4];
		}

		/* out = a + b */
		DONNA_INLINE static void
		curve25519_add(bignum25519 out, const bignum25519 a, const bignum25519 b) {
		out[0] = a[0] + b[0];
		out[1] = a[1] + b[1];
		out[2] = a[2] + b[2];
		out[3] = a[3] + b[3];
		out[4] = a[4] + b[4];
		}

		/* out = a + b, where a and/or b are the result of a basic op (add,sub) */
		DONNA_INLINE static void
		curve25519_add_after_basic(bignum25519 out, const bignum25519 a, const bignum25519 b) {
		out[0] = a[0] + b[0];
		out[1] = a[1] + b[1];
		out[2] = a[2] + b[2];
		out[3] = a[3] + b[3];
		out[4] = a[4] + b[4];
		}

		DONNA_INLINE static void
		curve25519_add_reduce(bignum25519 out, const bignum25519 a, const bignum25519 b) {
		uint64_t c;
		out[0] = a[0] + b[0] ; c = (out[0] >> 51); out[0] &= reduce_mask_51;
		out[1] = a[1] + b[1] + c; c = (out[1] >> 51); out[1] &= reduce_mask_51;
		out[2] = a[2] + b[2] + c; c = (out[2] >> 51); out[2] &= reduce_mask_51;
		out[3] = a[3] + b[3] + c; c = (out[3] >> 51); out[3] &= reduce_mask_51;
		out[4] = a[4] + b[4] + c; c = (out[4] >> 51); out[4] &= reduce_mask_51;
		out[0] += c * 19;
		}

		/* multiples of p */
		static const uint64_t twoP0 = 0x0fffffffffffda;
		static const uint64_t twoP1234 = 0x0ffffffffffffe;
		static const uint64_t fourP0 = 0x1fffffffffffb4;
		static const uint64_t fourP1234 = 0x1ffffffffffffc;

		/* out = a - b */
		DONNA_INLINE static void
		curve25519_sub(bignum25519 out, const bignum25519 a, const bignum25519 b) {
		out[0] = a[0] + twoP0 - b[0];
		out[1] = a[1] + twoP1234 - b[1];
		out[2] = a[2] + twoP1234 - b[2];
		out[3] = a[3] + twoP1234 - b[3];
		out[4] = a[4] + twoP1234 - b[4];
		}

		/* out = a - b, where a and/or b are the result of a basic op (add,sub) */
		DONNA_INLINE static void
		curve25519_sub_after_basic(bignum25519 out, const bignum25519 a, const bignum25519 b) {
		out[0] = a[0] + fourP0 - b[0];
		out[1] = a[1] + fourP1234 - b[1];
		out[2] = a[2] + fourP1234 - b[2];
		out[3] = a[3] + fourP1234 - b[3];
		out[4] = a[4] + fourP1234 - b[4];
		}

		DONNA_INLINE static void
		curve25519_sub_reduce(bignum25519 out, const bignum25519 a, const bignum25519 b) {
		uint64_t c;
		out[0] = a[0] + fourP0 - b[0] ; c = (out[0] >> 51); out[0] &= reduce_mask_51;
		out[1] = a[1] + fourP1234 - b[1] + c; c = (out[1] >> 51); out[1] &= reduce_mask_51;
		out[2] = a[2] + fourP1234 - b[2] + c; c = (out[2] >> 51); out[2] &= reduce_mask_51;
		out[3] = a[3] + fourP1234 - b[3] + c; c = (out[3] >> 51); out[3] &= reduce_mask_51;
		out[4] = a[4] + fourP1234 - b[4] + c; c = (out[4] >> 51); out[4] &= reduce_mask_51;
		out[0] += c * 19;
		}

		/* out = -a */
		DONNA_INLINE static void
		curve25519_neg(bignum25519 out, const bignum25519 a) {
		uint64_t c;
		out[0] = twoP0 - a[0] ; c = (out[0] >> 51); out[0] &= reduce_mask_51;
		out[1] = twoP1234 - a[1] + c; c = (out[1] >> 51); out[1] &= reduce_mask_51;
		out[2] = twoP1234 - a[2] + c; c = (out[2] >> 51); out[2] &= reduce_mask_51;
		out[3] = twoP1234 - a[3] + c; c = (out[3] >> 51); out[3] &= reduce_mask_51;
		out[4] = twoP1234 - a[4] + c; c = (out[4] >> 51); out[4] &= reduce_mask_51;
		out[0] += c * 19;
		}

		/* out = a * b */
		DONNA_INLINE static void
		curve25519_mul(bignum25519 out, const bignum25519 in2, const bignum25519 in) {
		#if !defined(HAVE_NATIVE_UINT128)
		uint128_t mul;
		#endif
		uint128_t t[5];
		uint64_t r0,r1,r2,r3,r4,s0,s1,s2,s3,s4,c;

		r0 = in[0];
		r1 = in[1];
		r2 = in[2];
		r3 = in[3];
		r4 = in[4];

		s0 = in2[0];
		s1 = in2[1];
		s2 = in2[2];
		s3 = in2[3];
		s4 = in2[4];

		#if defined(HAVE_NATIVE_UINT128)
		t[0] = ((uint128_t) r0) * s0;
		t[1] = ((uint128_t) r0) * s1 + ((uint128_t) r1) * s0;
		t[2] = ((uint128_t) r0) * s2 + ((uint128_t) r2) * s0 + ((uint128_t) r1) * s1;
		t[3] = ((uint128_t) r0) * s3 + ((uint128_t) r3) * s0 + ((uint128_t) r1) * s2 + ((uint128_t) r2) * s1;
		t[4] = ((uint128_t) r0) * s4 + ((uint128_t) r4) * s0 + ((uint128_t) r3) * s1 + ((uint128_t) r1) * s3 + ((uint128_t) r2) * s2;
		#else
		mul64x64_128(t[0], r0, s0)
		mul64x64_128(t[1], r0, s1) mul64x64_128(mul, r1, s0) add128(t[1], mul)
		mul64x64_128(t[2], r0, s2) mul64x64_128(mul, r2, s0) add128(t[2], mul) mul64x64_128(mul, r1, s1) add128(t[2], mul)
		mul64x64_128(t[3], r0, s3) mul64x64_128(mul, r3, s0) add128(t[3], mul) mul64x64_128(mul, r1, s2) add128(t[3], mul) mul64x64_128(mul, r2, s1) add128(t[3], mul)
		mul64x64_128(t[4], r0, s4) mul64x64_128(mul, r4, s0) add128(t[4], mul) mul64x64_128(mul, r3, s1) add128(t[4], mul) mul64x64_128(mul, r1, s3) add128(t[4], mul) mul64x64_128(mul, r2, s2) add128(t[4], mul)
		#endif

		r1 *= 19;
		r2 *= 19;
		r3 *= 19;
		r4 *= 19;

		#if defined(HAVE_NATIVE_UINT128)
		t[0] += ((uint128_t) r4) * s1 + ((uint128_t) r1) * s4 + ((uint128_t) r2) * s3 + ((uint128_t) r3) * s2;
		t[1] += ((uint128_t) r4) * s2 + ((uint128_t) r2) * s4 + ((uint128_t) r3) * s3;
		t[2] += ((uint128_t) r4) * s3 + ((uint128_t) r3) * s4;
		t[3] += ((uint128_t) r4) * s4;
		#else
		mul64x64_128(mul, r4, s1) add128(t[0], mul) mul64x64_128(mul, r1, s4) add128(t[0], mul) mul64x64_128(mul, r2, s3) add128(t[0], mul) mul64x64_128(mul, r3, s2) add128(t[0], mul)
		mul64x64_128(mul, r4, s2) add128(t[1], mul) mul64x64_128(mul, r2, s4) add128(t[1], mul) mul64x64_128(mul, r3, s3) add128(t[1], mul)
		mul64x64_128(mul, r4, s3) add128(t[2], mul) mul64x64_128(mul, r3, s4) add128(t[2], mul)
		mul64x64_128(mul, r4, s4) add128(t[3], mul)
		#endif


		r0 = lo128(t[0]) & reduce_mask_51; shr128(c, t[0], 51);
		add128_64(t[1], c) r1 = lo128(t[1]) & reduce_mask_51; shr128(c, t[1], 51);
		add128_64(t[2], c) r2 = lo128(t[2]) & reduce_mask_51; shr128(c, t[2], 51);
		add128_64(t[3], c) r3 = lo128(t[3]) & reduce_mask_51; shr128(c, t[3], 51);
		add128_64(t[4], c) r4 = lo128(t[4]) & reduce_mask_51; shr128(c, t[4], 51);
		r0 += c * 19; c = r0 >> 51; r0 = r0 & reduce_mask_51;
		r1 += c;

		out[0] = r0;
		out[1] = r1;
		out[2] = r2;
		out[3] = r3;
		out[4] = r4;
		}

		DONNA_NOINLINE static void
		curve25519_mul_noinline(bignum25519 out, const bignum25519 in2, const bignum25519 in) {
		curve25519_mul(out, in2, in);
		}

		/* out = in^(2 * count) */
		DONNA_NOINLINE static void
		curve25519_square_times(bignum25519 out, const bignum25519 in, uint64_t count) {
		#if !defined(HAVE_NATIVE_UINT128)
		uint128_t mul;
		#endif
		uint128_t t[5];
		uint64_t r0,r1,r2,r3,r4,c;
		uint64_t d0,d1,d2,d4,d419;

		r0 = in[0];
		r1 = in[1];
		r2 = in[2];
		r3 = in[3];
		r4 = in[4];

		do {
		d0 = r0 * 2;
		d1 = r1 * 2;
		d2 = r2 * 2 * 19;
		d419 = r4 * 19;
		d4 = d419 * 2;

		#if defined(HAVE_NATIVE_UINT128)
		t[0] = ((uint128_t) r0) * r0 + ((uint128_t) d4) * r1 + (((uint128_t) d2) * (r3 ));
		t[1] = ((uint128_t) d0) * r1 + ((uint128_t) d4) * r2 + (((uint128_t) r3) * (r3 * 19));
		t[2] = ((uint128_t) d0) * r2 + ((uint128_t) r1) * r1 + (((uint128_t) d4) * (r3 ));
		t[3] = ((uint128_t) d0) * r3 + ((uint128_t) d1) * r2 + (((uint128_t) r4) * (d419 ));
		t[4] = ((uint128_t) d0) * r4 + ((uint128_t) d1) * r3 + (((uint128_t) r2) * (r2 ));
		#else
		mul64x64_128(t[0], r0, r0) mul64x64_128(mul, d4, r1) add128(t[0], mul) mul64x64_128(mul, d2, r3) add128(t[0], mul)
		mul64x64_128(t[1], d0, r1) mul64x64_128(mul, d4, r2) add128(t[1], mul) mul64x64_128(mul, r3, r3 * 19) add128(t[1], mul)
		mul64x64_128(t[2], d0, r2) mul64x64_128(mul, r1, r1) add128(t[2], mul) mul64x64_128(mul, d4, r3) add128(t[2], mul)
		mul64x64_128(t[3], d0, r3) mul64x64_128(mul, d1, r2) add128(t[3], mul) mul64x64_128(mul, r4, d419) add128(t[3], mul)
		mul64x64_128(t[4], d0, r4) mul64x64_128(mul, d1, r3) add128(t[4], mul) mul64x64_128(mul, r2, r2) add128(t[4], mul)
		#endif

		r0 = lo128(t[0]) & reduce_mask_51;
		r1 = lo128(t[1]) & reduce_mask_51; shl128(c, t[0], 13); r1 += c;
		r2 = lo128(t[2]) & reduce_mask_51; shl128(c, t[1], 13); r2 += c;
		r3 = lo128(t[3]) & reduce_mask_51; shl128(c, t[2], 13); r3 += c;
		r4 = lo128(t[4]) & reduce_mask_51; shl128(c, t[3], 13); r4 += c;
		shl128(c, t[4], 13); r0 += c * 19;
		c = r0 >> 51; r0 &= reduce_mask_51;
		r1 += c ; c = r1 >> 51; r1 &= reduce_mask_51;
		r2 += c ; c = r2 >> 51; r2 &= reduce_mask_51;
		r3 += c ; c = r3 >> 51; r3 &= reduce_mask_51;
		r4 += c ; c = r4 >> 51; r4 &= reduce_mask_51;
		r0 += c * 19;
		} while(--count);

		out[0] = r0;
		out[1] = r1;
		out[2] = r2;
		out[3] = r3;
		out[4] = r4;
		}

		DONNA_INLINE static void
		curve25519_square(bignum25519 out, const bignum25519 in) {
		#if !defined(HAVE_NATIVE_UINT128)
		uint128_t mul;
		#endif
		uint128_t t[5];
		uint64_t r0,r1,r2,r3,r4,c;
		uint64_t d0,d1,d2,d4,d419;

		r0 = in[0];
		r1 = in[1];
		r2 = in[2];
		r3 = in[3];
		r4 = in[4];

		d0 = r0 * 2;
		d1 = r1 * 2;
		d2 = r2 * 2 * 19;
		d419 = r4 * 19;
		d4 = d419 * 2;

		#if defined(HAVE_NATIVE_UINT128)
		t[0] = ((uint128_t) r0) * r0 + ((uint128_t) d4) * r1 + (((uint128_t) d2) * (r3 ));
		t[1] = ((uint128_t) d0) * r1 + ((uint128_t) d4) * r2 + (((uint128_t) r3) * (r3 * 19));
		t[2] = ((uint128_t) d0) * r2 + ((uint128_t) r1) * r1 + (((uint128_t) d4) * (r3 ));
		t[3] = ((uint128_t) d0) * r3 + ((uint128_t) d1) * r2 + (((uint128_t) r4) * (d419 ));
		t[4] = ((uint128_t) d0) * r4 + ((uint128_t) d1) * r3 + (((uint128_t) r2) * (r2 ));
		#else
		mul64x64_128(t[0], r0, r0) mul64x64_128(mul, d4, r1) add128(t[0], mul) mul64x64_128(mul, d2, r3) add128(t[0], mul)
		mul64x64_128(t[1], d0, r1) mul64x64_128(mul, d4, r2) add128(t[1], mul) mul64x64_128(mul, r3, r3 * 19) add128(t[1], mul)
		mul64x64_128(t[2], d0, r2) mul64x64_128(mul, r1, r1) add128(t[2], mul) mul64x64_128(mul, d4, r3) add128(t[2], mul)
		mul64x64_128(t[3], d0, r3) mul64x64_128(mul, d1, r2) add128(t[3], mul) mul64x64_128(mul, r4, d419) add128(t[3], mul)
		mul64x64_128(t[4], d0, r4) mul64x64_128(mul, d1, r3) add128(t[4], mul) mul64x64_128(mul, r2, r2) add128(t[4], mul)
		#endif

		r0 = lo128(t[0]) & reduce_mask_51; shr128(c, t[0], 51);
		add128_64(t[1], c) r1 = lo128(t[1]) & reduce_mask_51; shr128(c, t[1], 51);
		add128_64(t[2], c) r2 = lo128(t[2]) & reduce_mask_51; shr128(c, t[2], 51);
		add128_64(t[3], c) r3 = lo128(t[3]) & reduce_mask_51; shr128(c, t[3], 51);
		add128_64(t[4], c) r4 = lo128(t[4]) & reduce_mask_51; shr128(c, t[4], 51);
		r0 += c * 19; c = r0 >> 51; r0 = r0 & reduce_mask_51;
		r1 += c;

		out[0] = r0;
		out[1] = r1;
		out[2] = r2;
		out[3] = r3;
		out[4] = r4;
		}

		/* Take a little-endian, 32-byte number and expand it into polynomial form */
		DONNA_INLINE static void
		curve25519_expand(bignum25519 out, const unsigned char *in) {
		static const union { uint8_t b[2]; uint16_t s; } endian_check = {{1,0}};
		uint64_t x0,x1,x2,x3;

		if (endian_check.s == 1) {
		x0 = (uint64_t )(in + 0);
		x1 = (uint64_t )(in + 8);
		x2 = (uint64_t )(in + 16);
		x3 = (uint64_t )(in + 24);
		} else {
		#define F(s) \
		((((uint64_t)in[s + 0]) ) \| \
		(((uint64_t)in[s + 1]) << 8) \| \
		(((uint64_t)in[s + 2]) << 16) \| \
		(((uint64_t)in[s + 3]) << 24) \| \
		(((uint64_t)in[s + 4]) << 32) \| \
		(((uint64_t)in[s + 5]) << 40) \| \
		(((uint64_t)in[s + 6]) << 48) \| \
		(((uint64_t)in[s + 7]) << 56))

		x0 = F(0);
		x1 = F(8);
		x2 = F(16);
		x3 = F(24);
		}

		out[0] = x0 & reduce_mask_51; x0 = (x0 >> 51) \| (x1 << 13);
		out[1] = x0 & reduce_mask_51; x1 = (x1 >> 38) \| (x2 << 26);
		out[2] = x1 & reduce_mask_51; x2 = (x2 >> 25) \| (x3 << 39);
		out[3] = x2 & reduce_mask_51; x3 = (x3 >> 12);
		out[4] = x3 & reduce_mask_51;
		}

		/* Take a fully reduced polynomial form number and contract it into a
		* little-endian, 32-byte array
		*/
		DONNA_INLINE static void
		curve25519_contract(unsigned char *out, const bignum25519 input) {
		uint64_t t[5];
		uint64_t f, i;

		t[0] = input[0];
		t[1] = input[1];
		t[2] = input[2];
		t[3] = input[3];
		t[4] = input[4];

		#define curve25519_contract_carry() \
		t[1] += t[0] >> 51; t[0] &= reduce_mask_51; \
		t[2] += t[1] >> 51; t[1] &= reduce_mask_51; \
		t[3] += t[2] >> 51; t[2] &= reduce_mask_51; \
		t[4] += t[3] >> 51; t[3] &= reduce_mask_51;

		#define curve25519_contract_carry_full() curve25519_contract_carry() \
		t[0] += 19 * (t[4] >> 51); t[4] &= reduce_mask_51;

		#define curve25519_contract_carry_final() curve25519_contract_carry() \
		t[4] &= reduce_mask_51;

		curve25519_contract_carry_full()
		curve25519_contract_carry_full()

		/* now t is between 0 and 2^255-1, properly carried. */
		/* case 1: between 0 and 2^255-20. case 2: between 2^255-19 and 2^255-1. */
		t[0] += 19;
		curve25519_contract_carry_full()

		/* now between 19 and 2^255-1 in both cases, and offset by 19. */
		t[0] += (reduce_mask_51 + 1) - 19;
		t[1] += (reduce_mask_51 + 1) - 1;
		t[2] += (reduce_mask_51 + 1) - 1;
		t[3] += (reduce_mask_51 + 1) - 1;
		t[4] += (reduce_mask_51 + 1) - 1;

		/* now between 2^255 and 2^256-20, and offset by 2^255. */
		curve25519_contract_carry_final()

		#define write51full(n,shift) \
		f = ((t[n] >> shift) \| (t[n+1] << (51 - shift))); \
		for (i = 0; i < 8; i++, f >>= 8) *out++ = (unsigned char)f;
		#define write51(n) write51full(n,13*n)
		write51(0)
		write51(1)
		write51(2)
		write51(3)
		}

		#if !defined(ED25519_GCC_64BIT_CHOOSE)

		/* out = (flag) ? in : out */
		DONNA_INLINE static void
		curve25519_move_conditional_bytes(uint8_t out[96], const uint8_t in[96], uint64_t flag) {
		const uint64_t nb = flag - 1, b = ~nb;
		const uint64_t inq = (const uint64_t )in;
		uint64_t outq = (uint64_t )out;
		outq[0] = (outq[0] & nb) \| (inq[0] & b);
		outq[1] = (outq[1] & nb) \| (inq[1] & b);
		outq[2] = (outq[2] & nb) \| (inq[2] & b);
		outq[3] = (outq[3] & nb) \| (inq[3] & b);
		outq[4] = (outq[4] & nb) \| (inq[4] & b);
		outq[5] = (outq[5] & nb) \| (inq[5] & b);
		outq[6] = (outq[6] & nb) \| (inq[6] & b);
		outq[7] = (outq[7] & nb) \| (inq[7] & b);
		outq[8] = (outq[8] & nb) \| (inq[8] & b);
		outq[9] = (outq[9] & nb) \| (inq[9] & b);
		outq[10] = (outq[10] & nb) \| (inq[10] & b);
		outq[11] = (outq[11] & nb) \| (inq[11] & b);
		}

		/* if (iswap) swap(a, b) */
		DONNA_INLINE static void
		curve25519_swap_conditional(bignum25519 a, bignum25519 b, uint64_t iswap) {
		const uint64_t swap = (uint64_t)(-(int64_t)iswap);
		uint64_t x0,x1,x2,x3,x4;

		x0 = swap & (a[0] ^ b[0]); a[0] ^= x0; b[0] ^= x0;
		x1 = swap & (a[1] ^ b[1]); a[1] ^= x1; b[1] ^= x1;
		x2 = swap & (a[2] ^ b[2]); a[2] ^= x2; b[2] ^= x2;
		x3 = swap & (a[3] ^ b[3]); a[3] ^= x3; b[3] ^= x3;
		x4 = swap & (a[4] ^ b[4]); a[4] ^= x4; b[4] ^= x4;
		}

		#endif /* ED25519_GCC_64BIT_CHOOSE */

		#define ED25519_64BIT_TABLES

src/ext/ed25519/donna/curve25519-donna-helpers.h

0 → 100644

+67 −0

File added.

Preview size limit exceeded, changes collapsed.