Commit 1c08a104 authored by Jason A. Donenfeld's avatar Jason A. Donenfeld Committed by Herbert Xu
Browse files

crypto: poly1305 - add new 32 and 64-bit generic versions 



These two C implementations from Zinc -- a 32x32 one and a 64x64 one,
depending on the platform -- come from Andrew Moon's public domain
poly1305-donna portable code, modified for usage in the kernel. The
precomputation in the 32-bit version and the use of 64x64 multiplies in
the 64-bit version make these perform better than the code it replaces.
Moon's code is also very widespread and has received many eyeballs of
scrutiny.

There's a bit of interference between the x86 implementation, which
relies on internal details of the old scalar implementation. In the next
commit, the x86 implementation will be replaced with a faster one that
doesn't rely on this, so none of this matters much. But for now, to keep
this passing the tests, we inline the bits of the old implementation
that the x86 implementation relied on. Also, since we now support a
slightly larger key space, via the union, some offsets had to be fixed
up.

Nonce calculation was folded in with the emit function, to take
advantage of 64x64 arithmetic. However, Adiantum appeared to rely on no
nonce handling in emit, so this path was conditionalized. We also
introduced a new struct, poly1305_core_key, to represent the precise
amount of space that particular implementation uses.

Testing with kbench9000, depending on the CPU, the update function for
the 32x32 version has been improved by 4%-7%, and for the 64x64 by
19%-30%. The 32x32 gains are small, but I think there's great value in
having a parallel implementation to the 64x64 one so that the two can be
compared side-by-side as nice stand-alone units.

Signed-off-by: default avatarJason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent e3419426

arch/x86/crypto/poly1305-avx2-x86_64.S

+10 −10
Original line number Diff line number Diff line
@@ -34,16 +34,16 @@ ORMASK: .octa 0x00000000010000000000000001000000 
#define u2 0x08(%r8)

#define u3 0x0c(%r8)

#define u4 0x10(%r8)

#define w0 0x14(%r8)

#define w1 0x18(%r8)

#define w2 0x1c(%r8)

#define w3 0x20(%r8)

#define w4 0x24(%r8)

#define y0 0x28(%r8)

#define y1 0x2c(%r8)

#define y2 0x30(%r8)

#define y3 0x34(%r8)

#define y4 0x38(%r8)

#define w0 0x18(%r8)

#define w1 0x1c(%r8)

#define w2 0x20(%r8)

#define w3 0x24(%r8)

#define w4 0x28(%r8)

#define y0 0x30(%r8)

#define y1 0x34(%r8)

#define y2 0x38(%r8)

#define y3 0x3c(%r8)

#define y4 0x40(%r8)

#define m %rsi

#define hc0 %ymm0

#define hc1 %ymm1

arch/x86/crypto/poly1305_glue.c

+204 −11
Original line number Diff line number Diff line
@@ -25,6 +25,21 @@ asmlinkage void poly1305_4block_avx2(u32 *h, const u8 *src, const u32 *r, 
static __ro_after_init DEFINE_STATIC_KEY_FALSE(poly1305_use_simd);

static __ro_after_init DEFINE_STATIC_KEY_FALSE(poly1305_use_avx2);



static inline u64 mlt(u64 a, u64 b)

{

	return a * b;

}



static inline u32 sr(u64 v, u_char n)

{

	return v >> n;

}



static inline u32 and(u32 v, u32 mask)

{

	return v & mask;

}



static void poly1305_simd_mult(u32 *a, const u32 *b)

{

	u8 m[POLY1305_BLOCK_SIZE];
@@ -36,6 +51,168 @@ static void poly1305_simd_mult(u32 *a, const u32 *b) 
	poly1305_block_sse2(a, m, b, 1);

}



static void poly1305_integer_setkey(struct poly1305_key *key, const u8 *raw_key)

{

	/* r &= 0xffffffc0ffffffc0ffffffc0fffffff */

	key->r[0] = (get_unaligned_le32(raw_key +  0) >> 0) & 0x3ffffff;

	key->r[1] = (get_unaligned_le32(raw_key +  3) >> 2) & 0x3ffff03;

	key->r[2] = (get_unaligned_le32(raw_key +  6) >> 4) & 0x3ffc0ff;

	key->r[3] = (get_unaligned_le32(raw_key +  9) >> 6) & 0x3f03fff;

	key->r[4] = (get_unaligned_le32(raw_key + 12) >> 8) & 0x00fffff;

}



static void poly1305_integer_blocks(struct poly1305_state *state,

				    const struct poly1305_key *key,

				    const void *src,

				    unsigned int nblocks, u32 hibit)

{

	u32 r0, r1, r2, r3, r4;

	u32 s1, s2, s3, s4;

	u32 h0, h1, h2, h3, h4;

	u64 d0, d1, d2, d3, d4;



	if (!nblocks)

		return;



	r0 = key->r[0];

	r1 = key->r[1];

	r2 = key->r[2];

	r3 = key->r[3];

	r4 = key->r[4];



	s1 = r1 * 5;

	s2 = r2 * 5;

	s3 = r3 * 5;

	s4 = r4 * 5;



	h0 = state->h[0];

	h1 = state->h[1];

	h2 = state->h[2];

	h3 = state->h[3];

	h4 = state->h[4];



	do {

		/* h += m[i] */

		h0 += (get_unaligned_le32(src +  0) >> 0) & 0x3ffffff;

		h1 += (get_unaligned_le32(src +  3) >> 2) & 0x3ffffff;

		h2 += (get_unaligned_le32(src +  6) >> 4) & 0x3ffffff;

		h3 += (get_unaligned_le32(src +  9) >> 6) & 0x3ffffff;

		h4 += (get_unaligned_le32(src + 12) >> 8) | (hibit << 24);



		/* h *= r */

		d0 = mlt(h0, r0) + mlt(h1, s4) + mlt(h2, s3) +

		     mlt(h3, s2) + mlt(h4, s1);

		d1 = mlt(h0, r1) + mlt(h1, r0) + mlt(h2, s4) +

		     mlt(h3, s3) + mlt(h4, s2);

		d2 = mlt(h0, r2) + mlt(h1, r1) + mlt(h2, r0) +

		     mlt(h3, s4) + mlt(h4, s3);

		d3 = mlt(h0, r3) + mlt(h1, r2) + mlt(h2, r1) +

		     mlt(h3, r0) + mlt(h4, s4);

		d4 = mlt(h0, r4) + mlt(h1, r3) + mlt(h2, r2) +

		     mlt(h3, r1) + mlt(h4, r0);



		/* (partial) h %= p */

		d1 += sr(d0, 26);     h0 = and(d0, 0x3ffffff);

		d2 += sr(d1, 26);     h1 = and(d1, 0x3ffffff);

		d3 += sr(d2, 26);     h2 = and(d2, 0x3ffffff);

		d4 += sr(d3, 26);     h3 = and(d3, 0x3ffffff);

		h0 += sr(d4, 26) * 5; h4 = and(d4, 0x3ffffff);

		h1 += h0 >> 26;       h0 = h0 & 0x3ffffff;



		src += POLY1305_BLOCK_SIZE;

	} while (--nblocks);



	state->h[0] = h0;

	state->h[1] = h1;

	state->h[2] = h2;

	state->h[3] = h3;

	state->h[4] = h4;

}



static void poly1305_integer_emit(const struct poly1305_state *state, void *dst)

{

	u32 h0, h1, h2, h3, h4;

	u32 g0, g1, g2, g3, g4;

	u32 mask;



	/* fully carry h */

	h0 = state->h[0];

	h1 = state->h[1];

	h2 = state->h[2];

	h3 = state->h[3];

	h4 = state->h[4];



	h2 += (h1 >> 26);     h1 = h1 & 0x3ffffff;

	h3 += (h2 >> 26);     h2 = h2 & 0x3ffffff;

	h4 += (h3 >> 26);     h3 = h3 & 0x3ffffff;

	h0 += (h4 >> 26) * 5; h4 = h4 & 0x3ffffff;

	h1 += (h0 >> 26);     h0 = h0 & 0x3ffffff;



	/* compute h + -p */

	g0 = h0 + 5;

	g1 = h1 + (g0 >> 26);             g0 &= 0x3ffffff;

	g2 = h2 + (g1 >> 26);             g1 &= 0x3ffffff;

	g3 = h3 + (g2 >> 26);             g2 &= 0x3ffffff;

	g4 = h4 + (g3 >> 26) - (1 << 26); g3 &= 0x3ffffff;



	/* select h if h < p, or h + -p if h >= p */

	mask = (g4 >> ((sizeof(u32) * 8) - 1)) - 1;

	g0 &= mask;

	g1 &= mask;

	g2 &= mask;

	g3 &= mask;

	g4 &= mask;

	mask = ~mask;

	h0 = (h0 & mask) | g0;

	h1 = (h1 & mask) | g1;

	h2 = (h2 & mask) | g2;

	h3 = (h3 & mask) | g3;

	h4 = (h4 & mask) | g4;



	/* h = h % (2^128) */

	put_unaligned_le32((h0 >>  0) | (h1 << 26), dst +  0);

	put_unaligned_le32((h1 >>  6) | (h2 << 20), dst +  4);

	put_unaligned_le32((h2 >> 12) | (h3 << 14), dst +  8);

	put_unaligned_le32((h3 >> 18) | (h4 <<  8), dst + 12);

}



void poly1305_init_arch(struct poly1305_desc_ctx *desc, const u8 *key)

{

	poly1305_integer_setkey(desc->opaque_r, key);

	desc->s[0] = get_unaligned_le32(key + 16);

	desc->s[1] = get_unaligned_le32(key + 20);

	desc->s[2] = get_unaligned_le32(key + 24);

	desc->s[3] = get_unaligned_le32(key + 28);

	poly1305_core_init(&desc->h);

	desc->buflen = 0;

	desc->sset = true;

	desc->rset = 1;

}

EXPORT_SYMBOL_GPL(poly1305_init_arch);



static unsigned int crypto_poly1305_setdesckey(struct poly1305_desc_ctx *dctx,

					       const u8 *src, unsigned int srclen)

{

	if (!dctx->sset) {

		if (!dctx->rset && srclen >= POLY1305_BLOCK_SIZE) {

			poly1305_integer_setkey(dctx->r, src);

			src += POLY1305_BLOCK_SIZE;

			srclen -= POLY1305_BLOCK_SIZE;

			dctx->rset = 1;

		}

		if (srclen >= POLY1305_BLOCK_SIZE) {

			dctx->s[0] = get_unaligned_le32(src +  0);

			dctx->s[1] = get_unaligned_le32(src +  4);

			dctx->s[2] = get_unaligned_le32(src +  8);

			dctx->s[3] = get_unaligned_le32(src + 12);

			src += POLY1305_BLOCK_SIZE;

			srclen -= POLY1305_BLOCK_SIZE;

			dctx->sset = true;

		}

	}

	return srclen;

}



static unsigned int poly1305_scalar_blocks(struct poly1305_desc_ctx *dctx,

					   const u8 *src, unsigned int srclen)

{
@@ -47,7 +224,7 @@ static unsigned int poly1305_scalar_blocks(struct poly1305_desc_ctx *dctx, 
		srclen = datalen;

	}

	if (srclen >= POLY1305_BLOCK_SIZE) {

		poly1305_core_blocks(&dctx->h, dctx->r, src,

		poly1305_integer_blocks(&dctx->h, dctx->opaque_r, src,

					srclen / POLY1305_BLOCK_SIZE, 1);

		srclen %= POLY1305_BLOCK_SIZE;

	}
@@ -105,12 +282,6 @@ static unsigned int poly1305_simd_blocks(struct poly1305_desc_ctx *dctx, 
	return srclen;

}



void poly1305_init_arch(struct poly1305_desc_ctx *desc, const u8 *key)

{

	poly1305_init_generic(desc, key);

}

EXPORT_SYMBOL(poly1305_init_arch);



void poly1305_update_arch(struct poly1305_desc_ctx *dctx, const u8 *src,

			  unsigned int srclen)

{
@@ -158,9 +329,31 @@ void poly1305_update_arch(struct poly1305_desc_ctx *dctx, const u8 *src, 
}

EXPORT_SYMBOL(poly1305_update_arch);



void poly1305_final_arch(struct poly1305_desc_ctx *desc, u8 *digest)

void poly1305_final_arch(struct poly1305_desc_ctx *desc, u8 *dst)

{

	poly1305_final_generic(desc, digest);

	__le32 digest[4];

	u64 f = 0;



	if (unlikely(desc->buflen)) {

		desc->buf[desc->buflen++] = 1;

		memset(desc->buf + desc->buflen, 0,

		       POLY1305_BLOCK_SIZE - desc->buflen);

		poly1305_integer_blocks(&desc->h, desc->opaque_r, desc->buf, 1, 0);

	}



	poly1305_integer_emit(&desc->h, digest);



	/* mac = (h + s) % (2^128) */

	f = (f >> 32) + le32_to_cpu(digest[0]) + desc->s[0];

	put_unaligned_le32(f, dst + 0);

	f = (f >> 32) + le32_to_cpu(digest[1]) + desc->s[1];

	put_unaligned_le32(f, dst + 4);

	f = (f >> 32) + le32_to_cpu(digest[2]) + desc->s[2];

	put_unaligned_le32(f, dst + 8);

	f = (f >> 32) + le32_to_cpu(digest[3]) + desc->s[3];

	put_unaligned_le32(f, dst + 12);



	*desc = (struct poly1305_desc_ctx){};

}

EXPORT_SYMBOL(poly1305_final_arch);
@@ -183,7 +376,7 @@ static int crypto_poly1305_final(struct shash_desc *desc, u8 *dst) 
	if (unlikely(!dctx->sset))

		return -ENOKEY;



	poly1305_final_generic(dctx, dst);

	poly1305_final_arch(dctx, dst);

	return 0;

}

crypto/adiantum.c

+2 −2
Original line number Diff line number Diff line
@@ -70,7 +70,7 @@ struct adiantum_tfm_ctx { 
	struct crypto_skcipher *streamcipher;

	struct crypto_cipher *blockcipher;

	struct crypto_shash *hash;

	struct poly1305_key header_hash_key;

	struct poly1305_core_key header_hash_key;

};



struct adiantum_request_ctx {
@@ -239,7 +239,7 @@ static void adiantum_hash_header(struct skcipher_request *req) 
	poly1305_core_blocks(&state, &tctx->header_hash_key, req->iv,

			     TWEAK_SIZE / POLY1305_BLOCK_SIZE, 1);



	poly1305_core_emit(&state, &rctx->header_hash);

	poly1305_core_emit(&state, NULL, &rctx->header_hash);

}



/* Hash the left-hand part (the "bulk") of the message using NHPoly1305 */

crypto/nhpoly1305.c

+1 −1
Original line number Diff line number Diff line
@@ -210,7 +210,7 @@ int crypto_nhpoly1305_final_helper(struct shash_desc *desc, u8 *dst, nh_t nh_fn) 
	if (state->nh_remaining)

		process_nh_hash_value(state, key);



	poly1305_core_emit(&state->poly_state, dst);

	poly1305_core_emit(&state->poly_state, NULL, dst);

	return 0;

}

EXPORT_SYMBOL(crypto_nhpoly1305_final_helper);

crypto/poly1305_generic.c

+24 −1
Original line number Diff line number Diff line
@@ -31,6 +31,29 @@ static int crypto_poly1305_init(struct shash_desc *desc) 
	return 0;

}



static unsigned int crypto_poly1305_setdesckey(struct poly1305_desc_ctx *dctx,

					       const u8 *src, unsigned int srclen)

{

	if (!dctx->sset) {

		if (!dctx->rset && srclen >= POLY1305_BLOCK_SIZE) {

			poly1305_core_setkey(&dctx->core_r, src);

			src += POLY1305_BLOCK_SIZE;

			srclen -= POLY1305_BLOCK_SIZE;

			dctx->rset = 2;

		}

		if (srclen >= POLY1305_BLOCK_SIZE) {

			dctx->s[0] = get_unaligned_le32(src +  0);

			dctx->s[1] = get_unaligned_le32(src +  4);

			dctx->s[2] = get_unaligned_le32(src +  8);

			dctx->s[3] = get_unaligned_le32(src + 12);

			src += POLY1305_BLOCK_SIZE;

			srclen -= POLY1305_BLOCK_SIZE;

			dctx->sset = true;

		}

	}

	return srclen;

}



static void poly1305_blocks(struct poly1305_desc_ctx *dctx, const u8 *src,

			    unsigned int srclen)

{
@@ -42,7 +65,7 @@ static void poly1305_blocks(struct poly1305_desc_ctx *dctx, const u8 *src, 
		srclen = datalen;

	}



	poly1305_core_blocks(&dctx->h, dctx->r, src,

	poly1305_core_blocks(&dctx->h, &dctx->core_r, src,

			     srclen / POLY1305_BLOCK_SIZE, 1);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE