pkgconfig: Fix libgcrypt.pc.
[libgcrypt.git] / cipher / cipher-gcm.c
1 /* cipher-gcm.c  - Generic Galois Counter Mode implementation
2  * Copyright (C) 2013 Dmitry Eremin-Solenikov
3  * Copyright (C) 2013, 2018-2019 Jussi Kivilinna <jussi.kivilinna@iki.fi>
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser general Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "g10lib.h"
28 #include "cipher.h"
29 #include "bufhelp.h"
30 #include "./cipher-internal.h"
31
32
33 /* Helper macro to force alignment to 16 or 64 bytes.  */
34 #ifdef HAVE_GCC_ATTRIBUTE_ALIGNED
35 # define ATTR_ALIGNED_64  __attribute__ ((aligned (64)))
36 #else
37 # define ATTR_ALIGNED_64
38 #endif
39
40
41 #ifdef GCM_USE_INTEL_PCLMUL
42 extern void _gcry_ghash_setup_intel_pclmul (gcry_cipher_hd_t c);
43
44 extern unsigned int _gcry_ghash_intel_pclmul (gcry_cipher_hd_t c, byte *result,
45                                               const byte *buf, size_t nblocks);
46 #endif
47
48 #ifdef GCM_USE_ARM_PMULL
49 extern void _gcry_ghash_setup_armv8_ce_pmull (void *gcm_key, void *gcm_table);
50
51 extern unsigned int _gcry_ghash_armv8_ce_pmull (void *gcm_key, byte *result,
52                                                 const byte *buf, size_t nblocks,
53                                                 void *gcm_table);
54
55 static void
56 ghash_setup_armv8_ce_pmull (gcry_cipher_hd_t c)
57 {
58   _gcry_ghash_setup_armv8_ce_pmull(c->u_mode.gcm.u_ghash_key.key,
59                                    c->u_mode.gcm.gcm_table);
60 }
61
62 static unsigned int
63 ghash_armv8_ce_pmull (gcry_cipher_hd_t c, byte *result, const byte *buf,
64                       size_t nblocks)
65 {
66   return _gcry_ghash_armv8_ce_pmull(c->u_mode.gcm.u_ghash_key.key, result, buf,
67                                     nblocks, c->u_mode.gcm.gcm_table);
68 }
69 #endif /* GCM_USE_ARM_PMULL */
70
71 #ifdef GCM_USE_ARM_NEON
72 extern void _gcry_ghash_setup_armv7_neon (void *gcm_key);
73
74 extern unsigned int _gcry_ghash_armv7_neon (void *gcm_key, byte *result,
75                                             const byte *buf, size_t nblocks);
76
77 static void
78 ghash_setup_armv7_neon (gcry_cipher_hd_t c)
79 {
80   _gcry_ghash_setup_armv7_neon(c->u_mode.gcm.u_ghash_key.key);
81 }
82
83 static unsigned int
84 ghash_armv7_neon (gcry_cipher_hd_t c, byte *result, const byte *buf,
85                   size_t nblocks)
86 {
87   return _gcry_ghash_armv7_neon(c->u_mode.gcm.u_ghash_key.key, result, buf,
88                                 nblocks);
89 }
90 #endif /* GCM_USE_ARM_NEON */
91
92
93 #ifdef GCM_USE_TABLES
94 static struct
95 {
96   volatile u32 counter_head;
97   u32 cacheline_align[64 / 4 - 1];
98   u16 R[256];
99   volatile u32 counter_tail;
100 } gcm_table ATTR_ALIGNED_64 =
101   {
102     0,
103     { 0, },
104     {
105       0x0000, 0x01c2, 0x0384, 0x0246, 0x0708, 0x06ca, 0x048c, 0x054e,
106       0x0e10, 0x0fd2, 0x0d94, 0x0c56, 0x0918, 0x08da, 0x0a9c, 0x0b5e,
107       0x1c20, 0x1de2, 0x1fa4, 0x1e66, 0x1b28, 0x1aea, 0x18ac, 0x196e,
108       0x1230, 0x13f2, 0x11b4, 0x1076, 0x1538, 0x14fa, 0x16bc, 0x177e,
109       0x3840, 0x3982, 0x3bc4, 0x3a06, 0x3f48, 0x3e8a, 0x3ccc, 0x3d0e,
110       0x3650, 0x3792, 0x35d4, 0x3416, 0x3158, 0x309a, 0x32dc, 0x331e,
111       0x2460, 0x25a2, 0x27e4, 0x2626, 0x2368, 0x22aa, 0x20ec, 0x212e,
112       0x2a70, 0x2bb2, 0x29f4, 0x2836, 0x2d78, 0x2cba, 0x2efc, 0x2f3e,
113       0x7080, 0x7142, 0x7304, 0x72c6, 0x7788, 0x764a, 0x740c, 0x75ce,
114       0x7e90, 0x7f52, 0x7d14, 0x7cd6, 0x7998, 0x785a, 0x7a1c, 0x7bde,
115       0x6ca0, 0x6d62, 0x6f24, 0x6ee6, 0x6ba8, 0x6a6a, 0x682c, 0x69ee,
116       0x62b0, 0x6372, 0x6134, 0x60f6, 0x65b8, 0x647a, 0x663c, 0x67fe,
117       0x48c0, 0x4902, 0x4b44, 0x4a86, 0x4fc8, 0x4e0a, 0x4c4c, 0x4d8e,
118       0x46d0, 0x4712, 0x4554, 0x4496, 0x41d8, 0x401a, 0x425c, 0x439e,
119       0x54e0, 0x5522, 0x5764, 0x56a6, 0x53e8, 0x522a, 0x506c, 0x51ae,
120       0x5af0, 0x5b32, 0x5974, 0x58b6, 0x5df8, 0x5c3a, 0x5e7c, 0x5fbe,
121       0xe100, 0xe0c2, 0xe284, 0xe346, 0xe608, 0xe7ca, 0xe58c, 0xe44e,
122       0xef10, 0xeed2, 0xec94, 0xed56, 0xe818, 0xe9da, 0xeb9c, 0xea5e,
123       0xfd20, 0xfce2, 0xfea4, 0xff66, 0xfa28, 0xfbea, 0xf9ac, 0xf86e,
124       0xf330, 0xf2f2, 0xf0b4, 0xf176, 0xf438, 0xf5fa, 0xf7bc, 0xf67e,
125       0xd940, 0xd882, 0xdac4, 0xdb06, 0xde48, 0xdf8a, 0xddcc, 0xdc0e,
126       0xd750, 0xd692, 0xd4d4, 0xd516, 0xd058, 0xd19a, 0xd3dc, 0xd21e,
127       0xc560, 0xc4a2, 0xc6e4, 0xc726, 0xc268, 0xc3aa, 0xc1ec, 0xc02e,
128       0xcb70, 0xcab2, 0xc8f4, 0xc936, 0xcc78, 0xcdba, 0xcffc, 0xce3e,
129       0x9180, 0x9042, 0x9204, 0x93c6, 0x9688, 0x974a, 0x950c, 0x94ce,
130       0x9f90, 0x9e52, 0x9c14, 0x9dd6, 0x9898, 0x995a, 0x9b1c, 0x9ade,
131       0x8da0, 0x8c62, 0x8e24, 0x8fe6, 0x8aa8, 0x8b6a, 0x892c, 0x88ee,
132       0x83b0, 0x8272, 0x8034, 0x81f6, 0x84b8, 0x857a, 0x873c, 0x86fe,
133       0xa9c0, 0xa802, 0xaa44, 0xab86, 0xaec8, 0xaf0a, 0xad4c, 0xac8e,
134       0xa7d0, 0xa612, 0xa454, 0xa596, 0xa0d8, 0xa11a, 0xa35c, 0xa29e,
135       0xb5e0, 0xb422, 0xb664, 0xb7a6, 0xb2e8, 0xb32a, 0xb16c, 0xb0ae,
136       0xbbf0, 0xba32, 0xb874, 0xb9b6, 0xbcf8, 0xbd3a, 0xbf7c, 0xbebe,
137     },
138     0
139   };
140
141 #define gcmR gcm_table.R
142
143 static inline
144 void prefetch_table(const void *tab, size_t len)
145 {
146   const volatile byte *vtab = tab;
147   size_t i;
148
149   for (i = 0; len - i >= 8 * 32; i += 8 * 32)
150     {
151       (void)vtab[i + 0 * 32];
152       (void)vtab[i + 1 * 32];
153       (void)vtab[i + 2 * 32];
154       (void)vtab[i + 3 * 32];
155       (void)vtab[i + 4 * 32];
156       (void)vtab[i + 5 * 32];
157       (void)vtab[i + 6 * 32];
158       (void)vtab[i + 7 * 32];
159     }
160   for (; i < len; i += 32)
161     {
162       (void)vtab[i];
163     }
164
165   (void)vtab[len - 1];
166 }
167
168 static inline void
169 do_prefetch_tables (const void *gcmM, size_t gcmM_size)
170 {
171   /* Modify counters to trigger copy-on-write and unsharing if physical pages
172    * of look-up table are shared between processes.  Modifying counters also
173    * causes checksums for pages to change and hint same-page merging algorithm
174    * that these pages are frequently changing.  */
175   gcm_table.counter_head++;
176   gcm_table.counter_tail++;
177
178   /* Prefetch look-up tables to cache.  */
179   prefetch_table(gcmM, gcmM_size);
180   prefetch_table(&gcm_table, sizeof(gcm_table));
181 }
182
183 #ifdef GCM_TABLES_USE_U64
184 static void
185 bshift (u64 * b0, u64 * b1)
186 {
187   u64 t[2], mask;
188
189   t[0] = *b0;
190   t[1] = *b1;
191   mask = -(t[1] & 1) & 0xe1;
192   mask <<= 56;
193
194   *b1 = (t[1] >> 1) ^ (t[0] << 63);
195   *b0 = (t[0] >> 1) ^ mask;
196 }
197
198 static void
199 do_fillM (unsigned char *h, u64 *M)
200 {
201   int i, j;
202
203   M[0 + 0] = 0;
204   M[0 + 16] = 0;
205
206   M[8 + 0] = buf_get_be64 (h + 0);
207   M[8 + 16] = buf_get_be64 (h + 8);
208
209   for (i = 4; i > 0; i /= 2)
210     {
211       M[i + 0] = M[2 * i + 0];
212       M[i + 16] = M[2 * i + 16];
213
214       bshift (&M[i], &M[i + 16]);
215     }
216
217   for (i = 2; i < 16; i *= 2)
218     for (j = 1; j < i; j++)
219       {
220         M[(i + j) + 0] = M[i + 0] ^ M[j + 0];
221         M[(i + j) + 16] = M[i + 16] ^ M[j + 16];
222       }
223
224   for (i = 0; i < 16; i++)
225     {
226       M[i + 32] = (M[i + 0] >> 4) ^ ((u64) gcmR[(M[i + 16] & 0xf) << 4] << 48);
227       M[i + 48] = (M[i + 16] >> 4) ^ (M[i + 0] << 60);
228     }
229 }
230
231 static inline unsigned int
232 do_ghash (unsigned char *result, const unsigned char *buf, const u64 *gcmM)
233 {
234   u64 V[2];
235   u64 tmp[2];
236   const u64 *M;
237   u64 T;
238   u32 A;
239   int i;
240
241   cipher_block_xor (V, result, buf, 16);
242   V[0] = be_bswap64 (V[0]);
243   V[1] = be_bswap64 (V[1]);
244
245   /* First round can be manually tweaked based on fact that 'tmp' is zero. */
246   M = &gcmM[(V[1] & 0xf) + 32];
247   V[1] >>= 4;
248   tmp[0] = M[0];
249   tmp[1] = M[16];
250   tmp[0] ^= gcmM[(V[1] & 0xf) + 0];
251   tmp[1] ^= gcmM[(V[1] & 0xf) + 16];
252   V[1] >>= 4;
253
254   i = 6;
255   while (1)
256     {
257       M = &gcmM[(V[1] & 0xf) + 32];
258       V[1] >>= 4;
259
260       A = tmp[1] & 0xff;
261       T = tmp[0];
262       tmp[0] = (T >> 8) ^ ((u64) gcmR[A] << 48) ^ gcmM[(V[1] & 0xf) + 0];
263       tmp[1] = (T << 56) ^ (tmp[1] >> 8) ^ gcmM[(V[1] & 0xf) + 16];
264
265       tmp[0] ^= M[0];
266       tmp[1] ^= M[16];
267
268       if (i == 0)
269         break;
270
271       V[1] >>= 4;
272       --i;
273     }
274
275   i = 7;
276   while (1)
277     {
278       M = &gcmM[(V[0] & 0xf) + 32];
279       V[0] >>= 4;
280
281       A = tmp[1] & 0xff;
282       T = tmp[0];
283       tmp[0] = (T >> 8) ^ ((u64) gcmR[A] << 48) ^ gcmM[(V[0] & 0xf) + 0];
284       tmp[1] = (T << 56) ^ (tmp[1] >> 8) ^ gcmM[(V[0] & 0xf) + 16];
285
286       tmp[0] ^= M[0];
287       tmp[1] ^= M[16];
288
289       if (i == 0)
290         break;
291
292       V[0] >>= 4;
293       --i;
294     }
295
296   buf_put_be64 (result + 0, tmp[0]);
297   buf_put_be64 (result + 8, tmp[1]);
298
299   return (sizeof(V) + sizeof(T) + sizeof(tmp) +
300           sizeof(int)*2 + sizeof(void*)*5);
301 }
302
303 #else /*!GCM_TABLES_USE_U64*/
304
305 static void
306 bshift (u32 * M, int i)
307 {
308   u32 t[4], mask;
309
310   t[0] = M[i * 4 + 0];
311   t[1] = M[i * 4 + 1];
312   t[2] = M[i * 4 + 2];
313   t[3] = M[i * 4 + 3];
314   mask = -(t[3] & 1) & 0xe1;
315
316   M[i * 4 + 3] = (t[3] >> 1) ^ (t[2] << 31);
317   M[i * 4 + 2] = (t[2] >> 1) ^ (t[1] << 31);
318   M[i * 4 + 1] = (t[1] >> 1) ^ (t[0] << 31);
319   M[i * 4 + 0] = (t[0] >> 1) ^ (mask << 24);
320 }
321
322 static void
323 do_fillM (unsigned char *h, u32 *M)
324 {
325   int i, j;
326
327   M[0 * 4 + 0] = 0;
328   M[0 * 4 + 1] = 0;
329   M[0 * 4 + 2] = 0;
330   M[0 * 4 + 3] = 0;
331
332   M[8 * 4 + 0] = buf_get_be32 (h + 0);
333   M[8 * 4 + 1] = buf_get_be32 (h + 4);
334   M[8 * 4 + 2] = buf_get_be32 (h + 8);
335   M[8 * 4 + 3] = buf_get_be32 (h + 12);
336
337   for (i = 4; i > 0; i /= 2)
338     {
339       M[i * 4 + 0] = M[2 * i * 4 + 0];
340       M[i * 4 + 1] = M[2 * i * 4 + 1];
341       M[i * 4 + 2] = M[2 * i * 4 + 2];
342       M[i * 4 + 3] = M[2 * i * 4 + 3];
343
344       bshift (M, i);
345     }
346
347   for (i = 2; i < 16; i *= 2)
348     for (j = 1; j < i; j++)
349       {
350         M[(i + j) * 4 + 0] = M[i * 4 + 0] ^ M[j * 4 + 0];
351         M[(i + j) * 4 + 1] = M[i * 4 + 1] ^ M[j * 4 + 1];
352         M[(i + j) * 4 + 2] = M[i * 4 + 2] ^ M[j * 4 + 2];
353         M[(i + j) * 4 + 3] = M[i * 4 + 3] ^ M[j * 4 + 3];
354       }
355
356   for (i = 0; i < 4 * 16; i += 4)
357     {
358       M[i + 0 + 64] = (M[i + 0] >> 4)
359                       ^ ((u64) gcmR[(M[i + 3] << 4) & 0xf0] << 16);
360       M[i + 1 + 64] = (M[i + 1] >> 4) ^ (M[i + 0] << 28);
361       M[i + 2 + 64] = (M[i + 2] >> 4) ^ (M[i + 1] << 28);
362       M[i + 3 + 64] = (M[i + 3] >> 4) ^ (M[i + 2] << 28);
363     }
364 }
365
366 static inline unsigned int
367 do_ghash (unsigned char *result, const unsigned char *buf, const u32 *gcmM)
368 {
369   byte V[16];
370   u32 tmp[4];
371   u32 v;
372   const u32 *M, *m;
373   u32 T[3];
374   int i;
375
376   cipher_block_xor (V, result, buf, 16); /* V is big-endian */
377
378   /* First round can be manually tweaked based on fact that 'tmp' is zero. */
379   i = 15;
380
381   v = V[i];
382   M = &gcmM[(v & 0xf) * 4 + 64];
383   v = (v & 0xf0) >> 4;
384   m = &gcmM[v * 4];
385   v = V[--i];
386
387   tmp[0] = M[0] ^ m[0];
388   tmp[1] = M[1] ^ m[1];
389   tmp[2] = M[2] ^ m[2];
390   tmp[3] = M[3] ^ m[3];
391
392   while (1)
393     {
394       M = &gcmM[(v & 0xf) * 4 + 64];
395       v = (v & 0xf0) >> 4;
396       m = &gcmM[v * 4];
397
398       T[0] = tmp[0];
399       T[1] = tmp[1];
400       T[2] = tmp[2];
401       tmp[0] = (T[0] >> 8) ^ ((u32) gcmR[tmp[3] & 0xff] << 16) ^ m[0];
402       tmp[1] = (T[0] << 24) ^ (tmp[1] >> 8) ^ m[1];
403       tmp[2] = (T[1] << 24) ^ (tmp[2] >> 8) ^ m[2];
404       tmp[3] = (T[2] << 24) ^ (tmp[3] >> 8) ^ m[3];
405
406       tmp[0] ^= M[0];
407       tmp[1] ^= M[1];
408       tmp[2] ^= M[2];
409       tmp[3] ^= M[3];
410
411       if (i == 0)
412         break;
413
414       v = V[--i];
415     }
416
417   buf_put_be32 (result + 0, tmp[0]);
418   buf_put_be32 (result + 4, tmp[1]);
419   buf_put_be32 (result + 8, tmp[2]);
420   buf_put_be32 (result + 12, tmp[3]);
421
422   return (sizeof(V) + sizeof(T) + sizeof(tmp) +
423           sizeof(int)*2 + sizeof(void*)*6);
424 }
425 #endif /*!GCM_TABLES_USE_U64*/
426
427 #define fillM(c) \
428   do_fillM (c->u_mode.gcm.u_ghash_key.key, c->u_mode.gcm.gcm_table)
429 #define GHASH(c, result, buf) do_ghash (result, buf, c->u_mode.gcm.gcm_table)
430 #define prefetch_tables(c) \
431   do_prefetch_tables(c->u_mode.gcm.gcm_table, sizeof(c->u_mode.gcm.gcm_table))
432
433 #else
434
435 static unsigned long
436 bshift (unsigned long *b)
437 {
438   unsigned long c;
439   int i;
440   c = b[3] & 1;
441   for (i = 3; i > 0; i--)
442     {
443       b[i] = (b[i] >> 1) | (b[i - 1] << 31);
444     }
445   b[i] >>= 1;
446   return c;
447 }
448
449 static unsigned int
450 do_ghash (unsigned char *hsub, unsigned char *result, const unsigned char *buf)
451 {
452   unsigned long V[4];
453   int i, j;
454   byte *p;
455
456 #ifdef WORDS_BIGENDIAN
457   p = result;
458 #else
459   unsigned long T[4];
460
461   cipher_block_xor (V, result, buf, 16);
462   for (i = 0; i < 4; i++)
463     {
464       V[i] = (V[i] & 0x00ff00ff) << 8 | (V[i] & 0xff00ff00) >> 8;
465       V[i] = (V[i] & 0x0000ffff) << 16 | (V[i] & 0xffff0000) >> 16;
466     }
467   p = (byte *) T;
468 #endif
469
470   memset (p, 0, 16);
471
472   for (i = 0; i < 16; i++)
473     {
474       for (j = 0x80; j; j >>= 1)
475         {
476           if (hsub[i] & j)
477             cipher_block_xor (p, p, V, 16);
478           if (bshift (V))
479             V[0] ^= 0xe1000000;
480         }
481     }
482 #ifndef WORDS_BIGENDIAN
483   for (i = 0, p = (byte *) T; i < 16; i += 4, p += 4)
484     {
485       result[i + 0] = p[3];
486       result[i + 1] = p[2];
487       result[i + 2] = p[1];
488       result[i + 3] = p[0];
489     }
490 #endif
491
492   return (sizeof(V) + sizeof(T) + sizeof(int)*2 + sizeof(void*)*5);
493 }
494
495 #define fillM(c) do { } while (0)
496 #define GHASH(c, result, buf) do_ghash (c->u_mode.gcm.u_ghash_key.key, result, buf)
497 #define prefetch_tables(c) do {} while (0)
498
499 #endif /* !GCM_USE_TABLES */
500
501
502 static unsigned int
503 ghash_internal (gcry_cipher_hd_t c, byte *result, const byte *buf,
504                 size_t nblocks)
505 {
506   const unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
507   unsigned int burn = 0;
508
509   prefetch_tables (c);
510
511   while (nblocks)
512     {
513       burn = GHASH (c, result, buf);
514       buf += blocksize;
515       nblocks--;
516     }
517
518   return burn + (burn ? 5*sizeof(void*) : 0);
519 }
520
521
522 static void
523 setupM (gcry_cipher_hd_t c)
524 {
525 #if defined(GCM_USE_INTEL_PCLMUL) || defined(GCM_USE_ARM_PMULL)
526   unsigned int features = _gcry_get_hw_features ();
527 #endif
528
529   if (0)
530     ;
531 #ifdef GCM_USE_INTEL_PCLMUL
532   else if (features & HWF_INTEL_PCLMUL)
533     {
534       c->u_mode.gcm.ghash_fn = _gcry_ghash_intel_pclmul;
535       _gcry_ghash_setup_intel_pclmul (c);
536     }
537 #endif
538 #ifdef GCM_USE_ARM_PMULL
539   else if (features & HWF_ARM_PMULL)
540     {
541       c->u_mode.gcm.ghash_fn = ghash_armv8_ce_pmull;
542       ghash_setup_armv8_ce_pmull (c);
543     }
544 #endif
545 #ifdef GCM_USE_ARM_NEON
546   else if (features & HWF_ARM_NEON)
547     {
548       c->u_mode.gcm.ghash_fn = ghash_armv7_neon;
549       ghash_setup_armv7_neon (c);
550     }
551 #endif
552   else
553     {
554       c->u_mode.gcm.ghash_fn = ghash_internal;
555       fillM (c);
556     }
557 }
558
559
560 static inline void
561 gcm_bytecounter_add (u32 ctr[2], size_t add)
562 {
563   if (sizeof(add) > sizeof(u32))
564     {
565       u32 high_add = ((add >> 31) >> 1) & 0xffffffff;
566       ctr[1] += high_add;
567     }
568
569   ctr[0] += add;
570   if (ctr[0] >= add)
571     return;
572   ++ctr[1];
573 }
574
575
576 static inline u32
577 gcm_add32_be128 (byte *ctr, unsigned int add)
578 {
579   /* 'ctr' must be aligned to four bytes. */
580   const unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
581   u32 *pval = (u32 *)(void *)(ctr + blocksize - sizeof(u32));
582   u32 val;
583
584   val = be_bswap32(*pval) + add;
585   *pval = be_bswap32(val);
586
587   return val; /* return result as host-endian value */
588 }
589
590
591 static inline int
592 gcm_check_datalen (u32 ctr[2])
593 {
594   /* len(plaintext) <= 2^39-256 bits == 2^36-32 bytes == 2^32-2 blocks */
595   if (ctr[1] > 0xfU)
596     return 0;
597   if (ctr[1] < 0xfU)
598     return 1;
599
600   if (ctr[0] <= 0xffffffe0U)
601     return 1;
602
603   return 0;
604 }
605
606
607 static inline int
608 gcm_check_aadlen_or_ivlen (u32 ctr[2])
609 {
610   /* len(aad/iv) <= 2^64-1 bits ~= 2^61-1 bytes */
611   if (ctr[1] > 0x1fffffffU)
612     return 0;
613   if (ctr[1] < 0x1fffffffU)
614     return 1;
615
616   if (ctr[0] <= 0xffffffffU)
617     return 1;
618
619   return 0;
620 }
621
622
623 static void
624 do_ghash_buf(gcry_cipher_hd_t c, byte *hash, const byte *buf,
625              size_t buflen, int do_padding)
626 {
627   unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
628   unsigned int unused = c->u_mode.gcm.mac_unused;
629   ghash_fn_t ghash_fn = c->u_mode.gcm.ghash_fn;
630   size_t nblocks, n;
631   unsigned int burn = 0;
632
633   if (buflen == 0 && (unused == 0 || !do_padding))
634     return;
635
636   do
637     {
638       if (buflen > 0 && (buflen + unused < blocksize || unused > 0))
639         {
640           n = blocksize - unused;
641           n = n < buflen ? n : buflen;
642
643           buf_cpy (&c->u_mode.gcm.macbuf[unused], buf, n);
644
645           unused += n;
646           buf += n;
647           buflen -= n;
648         }
649       if (!buflen)
650         {
651           if (!do_padding)
652             break;
653
654           n = blocksize - unused;
655           if (n > 0)
656             {
657               memset (&c->u_mode.gcm.macbuf[unused], 0, n);
658               unused = blocksize;
659             }
660         }
661
662       if (unused > 0)
663         {
664           gcry_assert (unused == blocksize);
665
666           /* Process one block from macbuf.  */
667           burn = ghash_fn (c, hash, c->u_mode.gcm.macbuf, 1);
668           unused = 0;
669         }
670
671       nblocks = buflen / blocksize;
672
673       if (nblocks)
674         {
675           burn = ghash_fn (c, hash, buf, nblocks);
676           buf += blocksize * nblocks;
677           buflen -= blocksize * nblocks;
678         }
679     }
680   while (buflen > 0);
681
682   c->u_mode.gcm.mac_unused = unused;
683
684   if (burn)
685     _gcry_burn_stack (burn);
686 }
687
688
689 static gcry_err_code_t
690 gcm_ctr_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
691                  const byte *inbuf, size_t inbuflen)
692 {
693   gcry_err_code_t err = 0;
694
695   while (inbuflen)
696     {
697       u32 nblocks_to_overflow;
698       u32 num_ctr_increments;
699       u32 curr_ctr_low;
700       size_t currlen = inbuflen;
701       byte ctr_copy[GCRY_GCM_BLOCK_LEN];
702       int fix_ctr = 0;
703
704       /* GCM CTR increments only least significant 32-bits, without carry
705        * to upper 96-bits of counter.  Using generic CTR implementation
706        * directly would carry 32-bit overflow to upper 96-bit.  Detect
707        * if input length is long enough to cause overflow, and limit
708        * input length so that CTR overflow happen but updated CTR value is
709        * not used to encrypt further input.  After overflow, upper 96 bits
710        * of CTR are restored to cancel out modification done by generic CTR
711        * encryption. */
712
713       if (inbuflen > c->unused)
714         {
715           curr_ctr_low = gcm_add32_be128 (c->u_ctr.ctr, 0);
716
717           /* Number of CTR increments this inbuflen would cause. */
718           num_ctr_increments = (inbuflen - c->unused) / GCRY_GCM_BLOCK_LEN +
719                                !!((inbuflen - c->unused) % GCRY_GCM_BLOCK_LEN);
720
721           if ((u32)(num_ctr_increments + curr_ctr_low) < curr_ctr_low)
722             {
723               nblocks_to_overflow = 0xffffffffU - curr_ctr_low + 1;
724               currlen = nblocks_to_overflow * GCRY_GCM_BLOCK_LEN + c->unused;
725               if (currlen > inbuflen)
726                 {
727                   currlen = inbuflen;
728                 }
729
730               fix_ctr = 1;
731               cipher_block_cpy(ctr_copy, c->u_ctr.ctr, GCRY_GCM_BLOCK_LEN);
732             }
733         }
734
735       err = _gcry_cipher_ctr_encrypt(c, outbuf, outbuflen, inbuf, currlen);
736       if (err != 0)
737         return err;
738
739       if (fix_ctr)
740         {
741           /* Lower 32-bits of CTR should now be zero. */
742           gcry_assert(gcm_add32_be128 (c->u_ctr.ctr, 0) == 0);
743
744           /* Restore upper part of CTR. */
745           buf_cpy(c->u_ctr.ctr, ctr_copy, GCRY_GCM_BLOCK_LEN - sizeof(u32));
746
747           wipememory(ctr_copy, sizeof(ctr_copy));
748         }
749
750       inbuflen -= currlen;
751       inbuf += currlen;
752       outbuflen -= currlen;
753       outbuf += currlen;
754     }
755
756   return err;
757 }
758
759
760 gcry_err_code_t
761 _gcry_cipher_gcm_encrypt (gcry_cipher_hd_t c,
762                           byte *outbuf, size_t outbuflen,
763                           const byte *inbuf, size_t inbuflen)
764 {
765   static const unsigned char zerobuf[MAX_BLOCKSIZE];
766   gcry_err_code_t err;
767
768   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
769     return GPG_ERR_CIPHER_ALGO;
770   if (outbuflen < inbuflen)
771     return GPG_ERR_BUFFER_TOO_SHORT;
772   if (c->u_mode.gcm.datalen_over_limits)
773     return GPG_ERR_INV_LENGTH;
774   if (c->marks.tag
775       || c->u_mode.gcm.ghash_data_finalized
776       || !c->u_mode.gcm.ghash_fn)
777     return GPG_ERR_INV_STATE;
778
779   if (!c->marks.iv)
780     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
781
782   if (c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode)
783     return GPG_ERR_INV_STATE;
784
785   if (!c->u_mode.gcm.ghash_aad_finalized)
786     {
787       /* Start of encryption marks end of AAD stream. */
788       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
789       c->u_mode.gcm.ghash_aad_finalized = 1;
790     }
791
792   gcm_bytecounter_add(c->u_mode.gcm.datalen, inbuflen);
793   if (!gcm_check_datalen(c->u_mode.gcm.datalen))
794     {
795       c->u_mode.gcm.datalen_over_limits = 1;
796       return GPG_ERR_INV_LENGTH;
797     }
798
799   while (inbuflen)
800     {
801       size_t currlen = inbuflen;
802
803       /* Since checksumming is done after encryption, process input in 24KiB
804        * chunks to keep data loaded in L1 cache for checksumming. */
805       if (currlen > 24 * 1024)
806         currlen = 24 * 1024;
807
808       err = gcm_ctr_encrypt(c, outbuf, outbuflen, inbuf, currlen);
809       if (err != 0)
810         return err;
811
812       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, outbuf, currlen, 0);
813
814       outbuf += currlen;
815       inbuf += currlen;
816       outbuflen -= currlen;
817       inbuflen -= currlen;
818     }
819
820   return 0;
821 }
822
823
824 gcry_err_code_t
825 _gcry_cipher_gcm_decrypt (gcry_cipher_hd_t c,
826                           byte *outbuf, size_t outbuflen,
827                           const byte *inbuf, size_t inbuflen)
828 {
829   static const unsigned char zerobuf[MAX_BLOCKSIZE];
830   gcry_err_code_t err;
831
832   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
833     return GPG_ERR_CIPHER_ALGO;
834   if (outbuflen < inbuflen)
835     return GPG_ERR_BUFFER_TOO_SHORT;
836   if (c->u_mode.gcm.datalen_over_limits)
837     return GPG_ERR_INV_LENGTH;
838   if (c->marks.tag
839       || c->u_mode.gcm.ghash_data_finalized
840       || !c->u_mode.gcm.ghash_fn)
841     return GPG_ERR_INV_STATE;
842
843   if (!c->marks.iv)
844     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
845
846   if (!c->u_mode.gcm.ghash_aad_finalized)
847     {
848       /* Start of decryption marks end of AAD stream. */
849       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
850       c->u_mode.gcm.ghash_aad_finalized = 1;
851     }
852
853   gcm_bytecounter_add(c->u_mode.gcm.datalen, inbuflen);
854   if (!gcm_check_datalen(c->u_mode.gcm.datalen))
855     {
856       c->u_mode.gcm.datalen_over_limits = 1;
857       return GPG_ERR_INV_LENGTH;
858     }
859
860   while (inbuflen)
861     {
862       size_t currlen = inbuflen;
863
864       /* Since checksumming is done before decryption, process input in
865        * 24KiB chunks to keep data loaded in L1 cache for decryption. */
866       if (currlen > 24 * 1024)
867         currlen = 24 * 1024;
868
869       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, inbuf, currlen, 0);
870
871       err = gcm_ctr_encrypt(c, outbuf, outbuflen, inbuf, currlen);
872       if (err)
873         return err;
874
875       outbuf += currlen;
876       inbuf += currlen;
877       outbuflen -= currlen;
878       inbuflen -= currlen;
879     }
880
881   return 0;
882 }
883
884
885 gcry_err_code_t
886 _gcry_cipher_gcm_authenticate (gcry_cipher_hd_t c,
887                                const byte * aadbuf, size_t aadbuflen)
888 {
889   static const unsigned char zerobuf[MAX_BLOCKSIZE];
890
891   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
892     return GPG_ERR_CIPHER_ALGO;
893   if (c->u_mode.gcm.datalen_over_limits)
894     return GPG_ERR_INV_LENGTH;
895   if (c->marks.tag
896       || c->u_mode.gcm.ghash_aad_finalized
897       || c->u_mode.gcm.ghash_data_finalized
898       || !c->u_mode.gcm.ghash_fn)
899     return GPG_ERR_INV_STATE;
900
901   if (!c->marks.iv)
902     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
903
904   gcm_bytecounter_add(c->u_mode.gcm.aadlen, aadbuflen);
905   if (!gcm_check_aadlen_or_ivlen(c->u_mode.gcm.aadlen))
906     {
907       c->u_mode.gcm.datalen_over_limits = 1;
908       return GPG_ERR_INV_LENGTH;
909     }
910
911   do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, aadbuf, aadbuflen, 0);
912
913   return 0;
914 }
915
916
917 void
918 _gcry_cipher_gcm_setkey (gcry_cipher_hd_t c)
919 {
920   memset (c->u_mode.gcm.u_ghash_key.key, 0, GCRY_GCM_BLOCK_LEN);
921
922   c->spec->encrypt (&c->context.c, c->u_mode.gcm.u_ghash_key.key,
923                     c->u_mode.gcm.u_ghash_key.key);
924   setupM (c);
925 }
926
927
928 static gcry_err_code_t
929 _gcry_cipher_gcm_initiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
930 {
931   memset (c->u_mode.gcm.aadlen, 0, sizeof(c->u_mode.gcm.aadlen));
932   memset (c->u_mode.gcm.datalen, 0, sizeof(c->u_mode.gcm.datalen));
933   memset (c->u_mode.gcm.u_tag.tag, 0, GCRY_GCM_BLOCK_LEN);
934   c->u_mode.gcm.datalen_over_limits = 0;
935   c->u_mode.gcm.ghash_data_finalized = 0;
936   c->u_mode.gcm.ghash_aad_finalized = 0;
937
938   if (ivlen == 0)
939     return GPG_ERR_INV_LENGTH;
940
941   if (ivlen != GCRY_GCM_BLOCK_LEN - 4)
942     {
943       u32 iv_bytes[2] = {0, 0};
944       u32 bitlengths[2][2];
945
946       if (!c->u_mode.gcm.ghash_fn)
947         return GPG_ERR_INV_STATE;
948
949       memset(c->u_ctr.ctr, 0, GCRY_GCM_BLOCK_LEN);
950
951       gcm_bytecounter_add(iv_bytes, ivlen);
952       if (!gcm_check_aadlen_or_ivlen(iv_bytes))
953         {
954           c->u_mode.gcm.datalen_over_limits = 1;
955           return GPG_ERR_INV_LENGTH;
956         }
957
958       do_ghash_buf(c, c->u_ctr.ctr, iv, ivlen, 1);
959
960       /* iv length, 64-bit */
961       bitlengths[1][1] = be_bswap32(iv_bytes[0] << 3);
962       bitlengths[1][0] = be_bswap32((iv_bytes[0] >> 29) |
963                                     (iv_bytes[1] << 3));
964       /* zeros, 64-bit */
965       bitlengths[0][1] = 0;
966       bitlengths[0][0] = 0;
967
968       do_ghash_buf(c, c->u_ctr.ctr, (byte*)bitlengths, GCRY_GCM_BLOCK_LEN, 1);
969
970       wipememory (iv_bytes, sizeof iv_bytes);
971       wipememory (bitlengths, sizeof bitlengths);
972     }
973   else
974     {
975       /* 96-bit IV is handled differently. */
976       memcpy (c->u_ctr.ctr, iv, ivlen);
977       c->u_ctr.ctr[12] = c->u_ctr.ctr[13] = c->u_ctr.ctr[14] = 0;
978       c->u_ctr.ctr[15] = 1;
979     }
980
981   c->spec->encrypt (&c->context.c, c->u_mode.gcm.tagiv, c->u_ctr.ctr);
982
983   gcm_add32_be128 (c->u_ctr.ctr, 1);
984
985   c->unused = 0;
986   c->marks.iv = 1;
987   c->marks.tag = 0;
988
989   return 0;
990 }
991
992
993 gcry_err_code_t
994 _gcry_cipher_gcm_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
995 {
996   c->marks.iv = 0;
997   c->marks.tag = 0;
998   c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 0;
999
1000   if (fips_mode ())
1001     {
1002       /* Direct invocation of GCM setiv in FIPS mode disables encryption. */
1003       c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 1;
1004     }
1005
1006   return _gcry_cipher_gcm_initiv (c, iv, ivlen);
1007 }
1008
1009
1010 #if 0 && TODO
1011 void
1012 _gcry_cipher_gcm_geniv (gcry_cipher_hd_t c,
1013                         byte *ivout, size_t ivoutlen, const byte *nonce,
1014                         size_t noncelen)
1015 {
1016   /* nonce:    user provided part (might be null) */
1017   /* noncelen: check if proper length (if nonce not null) */
1018   /* ivout:    iv used to initialize gcm, output to user */
1019   /* ivoutlen: check correct size */
1020   byte iv[IVLEN];
1021
1022   if (!ivout)
1023     return GPG_ERR_INV_ARG;
1024   if (ivoutlen != IVLEN)
1025     return GPG_ERR_INV_LENGTH;
1026   if (nonce != NULL && !is_nonce_ok_len(noncelen))
1027     return GPG_ERR_INV_ARG;
1028
1029   gcm_generate_iv(iv, nonce, noncelen);
1030
1031   c->marks.iv = 0;
1032   c->marks.tag = 0;
1033   c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 0;
1034
1035   _gcry_cipher_gcm_initiv (c, iv, IVLEN);
1036
1037   buf_cpy(ivout, iv, IVLEN);
1038   wipememory(iv, sizeof(iv));
1039 }
1040 #endif
1041
1042
1043 static int
1044 is_tag_length_valid(size_t taglen)
1045 {
1046   switch (taglen)
1047     {
1048     /* Allowed tag lengths from NIST SP 800-38D.  */
1049     case 128 / 8: /* GCRY_GCM_BLOCK_LEN */
1050     case 120 / 8:
1051     case 112 / 8:
1052     case 104 / 8:
1053     case 96 / 8:
1054     case 64 / 8:
1055     case 32 / 8:
1056       return 1;
1057
1058     default:
1059       return 0;
1060     }
1061 }
1062
1063 static gcry_err_code_t
1064 _gcry_cipher_gcm_tag (gcry_cipher_hd_t c,
1065                       byte * outbuf, size_t outbuflen, int check)
1066 {
1067   if (!(is_tag_length_valid (outbuflen) || outbuflen >= GCRY_GCM_BLOCK_LEN))
1068     return GPG_ERR_INV_LENGTH;
1069   if (c->u_mode.gcm.datalen_over_limits)
1070     return GPG_ERR_INV_LENGTH;
1071
1072   if (!c->marks.tag)
1073     {
1074       u32 bitlengths[2][2];
1075
1076       if (!c->u_mode.gcm.ghash_fn)
1077         return GPG_ERR_INV_STATE;
1078
1079       /* aad length */
1080       bitlengths[0][1] = be_bswap32(c->u_mode.gcm.aadlen[0] << 3);
1081       bitlengths[0][0] = be_bswap32((c->u_mode.gcm.aadlen[0] >> 29) |
1082                                     (c->u_mode.gcm.aadlen[1] << 3));
1083       /* data length */
1084       bitlengths[1][1] = be_bswap32(c->u_mode.gcm.datalen[0] << 3);
1085       bitlengths[1][0] = be_bswap32((c->u_mode.gcm.datalen[0] >> 29) |
1086                                     (c->u_mode.gcm.datalen[1] << 3));
1087
1088       /* Finalize data-stream. */
1089       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
1090       c->u_mode.gcm.ghash_aad_finalized = 1;
1091       c->u_mode.gcm.ghash_data_finalized = 1;
1092
1093       /* Add bitlengths to tag. */
1094       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, (byte*)bitlengths,
1095                    GCRY_GCM_BLOCK_LEN, 1);
1096       cipher_block_xor (c->u_mode.gcm.u_tag.tag, c->u_mode.gcm.tagiv,
1097                         c->u_mode.gcm.u_tag.tag, GCRY_GCM_BLOCK_LEN);
1098       c->marks.tag = 1;
1099
1100       wipememory (bitlengths, sizeof (bitlengths));
1101       wipememory (c->u_mode.gcm.macbuf, GCRY_GCM_BLOCK_LEN);
1102       wipememory (c->u_mode.gcm.tagiv, GCRY_GCM_BLOCK_LEN);
1103       wipememory (c->u_mode.gcm.aadlen, sizeof (c->u_mode.gcm.aadlen));
1104       wipememory (c->u_mode.gcm.datalen, sizeof (c->u_mode.gcm.datalen));
1105     }
1106
1107   if (!check)
1108     {
1109       if (outbuflen > GCRY_GCM_BLOCK_LEN)
1110         outbuflen = GCRY_GCM_BLOCK_LEN;
1111
1112       /* NB: We already checked that OUTBUF is large enough to hold
1113        * the result or has valid truncated length.  */
1114       memcpy (outbuf, c->u_mode.gcm.u_tag.tag, outbuflen);
1115     }
1116   else
1117     {
1118       /* OUTBUFLEN gives the length of the user supplied tag in OUTBUF
1119        * and thus we need to compare its length first.  */
1120       if (!is_tag_length_valid (outbuflen)
1121           || !buf_eq_const (outbuf, c->u_mode.gcm.u_tag.tag, outbuflen))
1122         return GPG_ERR_CHECKSUM;
1123     }
1124
1125   return 0;
1126 }
1127
1128
1129 gcry_err_code_t
1130 _gcry_cipher_gcm_get_tag (gcry_cipher_hd_t c, unsigned char *outtag,
1131                           size_t taglen)
1132 {
1133   /* Outputting authentication tag is part of encryption. */
1134   if (c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode)
1135     return GPG_ERR_INV_STATE;
1136
1137   return _gcry_cipher_gcm_tag (c, outtag, taglen, 0);
1138 }
1139
1140 gcry_err_code_t
1141 _gcry_cipher_gcm_check_tag (gcry_cipher_hd_t c, const unsigned char *intag,
1142                             size_t taglen)
1143 {
1144   return _gcry_cipher_gcm_tag (c, (unsigned char *) intag, taglen, 1);
1145 }