tls_gcm.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212
  1. /* AES-128-GCM for the TLS 1.2 client; see tls_gcm.h. */
  2. #include "tls_gcm.h"
  3. #include "wpa_crypto.h"
  4. /* ---- GHASH: GF(2^128) multiply by H with 4-bit tables (Shoup) ---- */
  5. /* Reduction constants for shifting a 128-bit value right by 4 bits. */
  6. static const unsigned int last4[16] = {
  7. 0x0000, 0x1c20, 0x3840, 0x2460, 0x7080, 0x6ca0, 0x48c0, 0x54e0,
  8. 0xe100, 0xfd20, 0xd940, 0xc560, 0x9180, 0x8da0, 0xa9c0, 0xb5e0
  9. };
  10. static unsigned int be32(const unsigned char *p)
  11. {
  12. return ((unsigned int)p[0] << 24) | ((unsigned int)p[1] << 16) |
  13. ((unsigned int)p[2] << 8) | p[3];
  14. }
  15. static void put_be32(unsigned char *p, unsigned int v)
  16. {
  17. p[0] = (unsigned char)(v >> 24);
  18. p[1] = (unsigned char)(v >> 16);
  19. p[2] = (unsigned char)(v >> 8);
  20. p[3] = (unsigned char)v;
  21. }
  22. void gcm_setkey(struct gcm_key *k, const unsigned char key[16])
  23. {
  24. unsigned char zero[16] = { 0 }, h[16];
  25. unsigned int v[4], i, j;
  26. aes128_setkey(k->rk, key);
  27. aes128_encrypt(k->rk, zero, h);
  28. for (i = 0; i < 4; i++)
  29. v[i] = be32(h + 4 * i);
  30. /* hl[8] = H, hl[4] = H*x, hl[2] = H*x^2, hl[1] = H*x^3 (bit-reflected
  31. * GCM convention: multiplying by x is a right shift). */
  32. for (j = 0; j < 4; j++)
  33. k->hl[0][j] = 0;
  34. for (j = 0; j < 4; j++)
  35. k->hl[8][j] = v[j];
  36. for (i = 4; i > 0; i >>= 1) {
  37. unsigned int *s = k->hl[i * 2], *d = k->hl[i];
  38. unsigned int lsb = s[3] & 1;
  39. d[3] = (s[3] >> 1) | (s[2] << 31);
  40. d[2] = (s[2] >> 1) | (s[1] << 31);
  41. d[1] = (s[1] >> 1) | (s[0] << 31);
  42. d[0] = (s[0] >> 1) ^ (lsb ? 0xe1000000u : 0);
  43. }
  44. for (i = 2; i < 16; i <<= 1)
  45. for (j = 1; j < i; j++) {
  46. unsigned int w;
  47. for (w = 0; w < 4; w++)
  48. k->hl[i + j][w] = k->hl[i][w] ^ k->hl[j][w];
  49. }
  50. }
  51. /* y = (y ^ block) * H */
  52. static void ghash_block(const struct gcm_key *k, unsigned int y[4],
  53. const unsigned char b[16])
  54. {
  55. unsigned char x[16];
  56. unsigned int z[4], i;
  57. int n;
  58. for (i = 0; i < 4; i++)
  59. put_be32(x + 4 * i, y[i] ^ be32(b + 4 * i));
  60. z[0] = z[1] = z[2] = z[3] = 0;
  61. for (n = 15; n >= 0; n--) {
  62. unsigned int nib, rem, w;
  63. for (w = 0; w < 2; w++) {
  64. nib = w == 0 ? (x[n] & 0x0f) : (x[n] >> 4);
  65. if (!(n == 15 && w == 0)) {
  66. rem = z[3] & 0x0f;
  67. z[3] = (z[3] >> 4) | (z[2] << 28);
  68. z[2] = (z[2] >> 4) | (z[1] << 28);
  69. z[1] = (z[1] >> 4) | (z[0] << 28);
  70. z[0] = (z[0] >> 4) ^ (last4[rem] << 16);
  71. }
  72. z[0] ^= k->hl[nib][0];
  73. z[1] ^= k->hl[nib][1];
  74. z[2] ^= k->hl[nib][2];
  75. z[3] ^= k->hl[nib][3];
  76. }
  77. }
  78. for (i = 0; i < 4; i++)
  79. y[i] = z[i];
  80. }
  81. static void ghash_bytes(struct gcm_ctx *c, const unsigned char *p,
  82. unsigned int len)
  83. {
  84. while (len) {
  85. c->part[c->part_len++] = *p++;
  86. len--;
  87. if (c->part_len == 16) {
  88. ghash_block(c->k, c->y, c->part);
  89. c->part_len = 0;
  90. }
  91. }
  92. }
  93. static void ghash_pad(struct gcm_ctx *c)
  94. {
  95. if (c->part_len) {
  96. while (c->part_len < 16)
  97. c->part[c->part_len++] = 0;
  98. ghash_block(c->k, c->y, c->part);
  99. c->part_len = 0;
  100. }
  101. }
  102. static void ctr_inc(unsigned char ctr[16])
  103. {
  104. int i;
  105. for (i = 15; i >= 12; i--)
  106. if (++ctr[i])
  107. break;
  108. }
  109. static void gcm_start(struct gcm_ctx *c, const struct gcm_key *k,
  110. const unsigned char nonce[12],
  111. const unsigned char *aad, unsigned int aad_len)
  112. {
  113. unsigned int i;
  114. c->k = k;
  115. c->y[0] = c->y[1] = c->y[2] = c->y[3] = 0;
  116. for (i = 0; i < 12; i++)
  117. c->ctr[i] = nonce[i];
  118. c->ctr[12] = c->ctr[13] = c->ctr[14] = 0;
  119. c->ctr[15] = 1;
  120. aes128_encrypt(k->rk, c->ctr, c->ej0);
  121. c->ks_pos = 16; /* first data block uses inc32(J0) */
  122. c->part_len = 0;
  123. c->aad_len = aad_len;
  124. c->ct_len = 0;
  125. ghash_bytes(c, aad, aad_len);
  126. ghash_pad(c);
  127. }
  128. static void gcm_xor(struct gcm_ctx *c, unsigned char *out,
  129. const unsigned char *in, unsigned int len)
  130. {
  131. unsigned int i;
  132. for (i = 0; i < len; i++) {
  133. if (c->ks_pos == 16) {
  134. ctr_inc(c->ctr);
  135. aes128_encrypt(c->k->rk, c->ctr, c->ks);
  136. c->ks_pos = 0;
  137. }
  138. out[i] = in[i] ^ c->ks[c->ks_pos++];
  139. }
  140. }
  141. static void gcm_finish(struct gcm_ctx *c, unsigned char tag[16])
  142. {
  143. unsigned char lens[16];
  144. unsigned int i;
  145. ghash_pad(c);
  146. /* bit lengths: 64-bit AAD, 64-bit ciphertext (both < 2^29 bytes) */
  147. put_be32(lens, 0);
  148. put_be32(lens + 4, c->aad_len << 3);
  149. put_be32(lens + 8, 0);
  150. put_be32(lens + 12, c->ct_len << 3);
  151. ghash_block(c->k, c->y, lens);
  152. for (i = 0; i < 4; i++)
  153. put_be32(tag + 4 * i, c->y[i]);
  154. for (i = 0; i < 16; i++)
  155. tag[i] ^= c->ej0[i];
  156. }
  157. void gcm_open_init(struct gcm_ctx *c, const struct gcm_key *k,
  158. const unsigned char nonce[12],
  159. const unsigned char *aad, unsigned int aad_len)
  160. {
  161. gcm_start(c, k, nonce, aad, aad_len);
  162. }
  163. void gcm_open_update(struct gcm_ctx *c, unsigned char *out,
  164. const unsigned char *in, unsigned int len)
  165. {
  166. ghash_bytes(c, in, len); /* GHASH runs over the ciphertext */
  167. c->ct_len += len;
  168. gcm_xor(c, out, in, len);
  169. }
  170. void gcm_open_tag(struct gcm_ctx *c, unsigned char tag[16])
  171. {
  172. gcm_finish(c, tag);
  173. }
  174. void gcm_seal(const struct gcm_key *k, const unsigned char nonce[12],
  175. const unsigned char *aad, unsigned int aad_len,
  176. const unsigned char *pt, unsigned int len,
  177. unsigned char *ct, unsigned char tag[16])
  178. {
  179. struct gcm_ctx c;
  180. gcm_start(&c, k, nonce, aad, aad_len);
  181. gcm_xor(&c, ct, pt, len);
  182. ghash_bytes(&c, ct, len);
  183. c.ct_len = len;
  184. gcm_finish(&c, tag);
  185. }