/* AES-128-GCM for the TLS 1.2 client; see tls_gcm.h. */ #include "tls_gcm.h" #include "wpa_crypto.h" /* ---- GHASH: GF(2^128) multiply by H with 4-bit tables (Shoup) ---- */ /* Reduction constants for shifting a 128-bit value right by 4 bits. */ static const unsigned int last4[16] = { 0x0000, 0x1c20, 0x3840, 0x2460, 0x7080, 0x6ca0, 0x48c0, 0x54e0, 0xe100, 0xfd20, 0xd940, 0xc560, 0x9180, 0x8da0, 0xa9c0, 0xb5e0 }; static unsigned int be32(const unsigned char *p) { return ((unsigned int)p[0] << 24) | ((unsigned int)p[1] << 16) | ((unsigned int)p[2] << 8) | p[3]; } static void put_be32(unsigned char *p, unsigned int v) { p[0] = (unsigned char)(v >> 24); p[1] = (unsigned char)(v >> 16); p[2] = (unsigned char)(v >> 8); p[3] = (unsigned char)v; } void gcm_setkey(struct gcm_key *k, const unsigned char key[16]) { unsigned char zero[16] = { 0 }, h[16]; unsigned int v[4], i, j; aes128_setkey(k->rk, key); aes128_encrypt(k->rk, zero, h); for (i = 0; i < 4; i++) v[i] = be32(h + 4 * i); /* hl[8] = H, hl[4] = H*x, hl[2] = H*x^2, hl[1] = H*x^3 (bit-reflected * GCM convention: multiplying by x is a right shift). */ for (j = 0; j < 4; j++) k->hl[0][j] = 0; for (j = 0; j < 4; j++) k->hl[8][j] = v[j]; for (i = 4; i > 0; i >>= 1) { unsigned int *s = k->hl[i * 2], *d = k->hl[i]; unsigned int lsb = s[3] & 1; d[3] = (s[3] >> 1) | (s[2] << 31); d[2] = (s[2] >> 1) | (s[1] << 31); d[1] = (s[1] >> 1) | (s[0] << 31); d[0] = (s[0] >> 1) ^ (lsb ? 0xe1000000u : 0); } for (i = 2; i < 16; i <<= 1) for (j = 1; j < i; j++) { unsigned int w; for (w = 0; w < 4; w++) k->hl[i + j][w] = k->hl[i][w] ^ k->hl[j][w]; } } /* y = (y ^ block) * H */ static void ghash_block(const struct gcm_key *k, unsigned int y[4], const unsigned char b[16]) { unsigned char x[16]; unsigned int z[4], i; int n; for (i = 0; i < 4; i++) put_be32(x + 4 * i, y[i] ^ be32(b + 4 * i)); z[0] = z[1] = z[2] = z[3] = 0; for (n = 15; n >= 0; n--) { unsigned int nib, rem, w; for (w = 0; w < 2; w++) { nib = w == 0 ? (x[n] & 0x0f) : (x[n] >> 4); if (!(n == 15 && w == 0)) { rem = z[3] & 0x0f; z[3] = (z[3] >> 4) | (z[2] << 28); z[2] = (z[2] >> 4) | (z[1] << 28); z[1] = (z[1] >> 4) | (z[0] << 28); z[0] = (z[0] >> 4) ^ (last4[rem] << 16); } z[0] ^= k->hl[nib][0]; z[1] ^= k->hl[nib][1]; z[2] ^= k->hl[nib][2]; z[3] ^= k->hl[nib][3]; } } for (i = 0; i < 4; i++) y[i] = z[i]; } static void ghash_bytes(struct gcm_ctx *c, const unsigned char *p, unsigned int len) { while (len) { c->part[c->part_len++] = *p++; len--; if (c->part_len == 16) { ghash_block(c->k, c->y, c->part); c->part_len = 0; } } } static void ghash_pad(struct gcm_ctx *c) { if (c->part_len) { while (c->part_len < 16) c->part[c->part_len++] = 0; ghash_block(c->k, c->y, c->part); c->part_len = 0; } } static void ctr_inc(unsigned char ctr[16]) { int i; for (i = 15; i >= 12; i--) if (++ctr[i]) break; } static void gcm_start(struct gcm_ctx *c, const struct gcm_key *k, const unsigned char nonce[12], const unsigned char *aad, unsigned int aad_len) { unsigned int i; c->k = k; c->y[0] = c->y[1] = c->y[2] = c->y[3] = 0; for (i = 0; i < 12; i++) c->ctr[i] = nonce[i]; c->ctr[12] = c->ctr[13] = c->ctr[14] = 0; c->ctr[15] = 1; aes128_encrypt(k->rk, c->ctr, c->ej0); c->ks_pos = 16; /* first data block uses inc32(J0) */ c->part_len = 0; c->aad_len = aad_len; c->ct_len = 0; ghash_bytes(c, aad, aad_len); ghash_pad(c); } static void gcm_xor(struct gcm_ctx *c, unsigned char *out, const unsigned char *in, unsigned int len) { unsigned int i; for (i = 0; i < len; i++) { if (c->ks_pos == 16) { ctr_inc(c->ctr); aes128_encrypt(c->k->rk, c->ctr, c->ks); c->ks_pos = 0; } out[i] = in[i] ^ c->ks[c->ks_pos++]; } } static void gcm_finish(struct gcm_ctx *c, unsigned char tag[16]) { unsigned char lens[16]; unsigned int i; ghash_pad(c); /* bit lengths: 64-bit AAD, 64-bit ciphertext (both < 2^29 bytes) */ put_be32(lens, 0); put_be32(lens + 4, c->aad_len << 3); put_be32(lens + 8, 0); put_be32(lens + 12, c->ct_len << 3); ghash_block(c->k, c->y, lens); for (i = 0; i < 4; i++) put_be32(tag + 4 * i, c->y[i]); for (i = 0; i < 16; i++) tag[i] ^= c->ej0[i]; } void gcm_open_init(struct gcm_ctx *c, const struct gcm_key *k, const unsigned char nonce[12], const unsigned char *aad, unsigned int aad_len) { gcm_start(c, k, nonce, aad, aad_len); } void gcm_open_update(struct gcm_ctx *c, unsigned char *out, const unsigned char *in, unsigned int len) { ghash_bytes(c, in, len); /* GHASH runs over the ciphertext */ c->ct_len += len; gcm_xor(c, out, in, len); } void gcm_open_tag(struct gcm_ctx *c, unsigned char tag[16]) { gcm_finish(c, tag); } void gcm_seal(const struct gcm_key *k, const unsigned char nonce[12], const unsigned char *aad, unsigned int aad_len, const unsigned char *pt, unsigned int len, unsigned char *ct, unsigned char tag[16]) { struct gcm_ctx c; gcm_start(&c, k, nonce, aad, aad_len); gcm_xor(&c, ct, pt, len); ghash_bytes(&c, ct, len); c.ct_len = len; gcm_finish(&c, tag); }