doc: Fix typo.
[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 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 #ifdef GCM_USE_INTEL_PCLMUL
34 extern void _gcry_ghash_setup_intel_pclmul (gcry_cipher_hd_t c);
35
36 extern unsigned int _gcry_ghash_intel_pclmul (gcry_cipher_hd_t c, byte *result,
37                                               const byte *buf, size_t nblocks);
38 #endif
39
40
41 #ifdef GCM_USE_TABLES
42 static const u16 gcmR[256] = {
43   0x0000, 0x01c2, 0x0384, 0x0246, 0x0708, 0x06ca, 0x048c, 0x054e,
44   0x0e10, 0x0fd2, 0x0d94, 0x0c56, 0x0918, 0x08da, 0x0a9c, 0x0b5e,
45   0x1c20, 0x1de2, 0x1fa4, 0x1e66, 0x1b28, 0x1aea, 0x18ac, 0x196e,
46   0x1230, 0x13f2, 0x11b4, 0x1076, 0x1538, 0x14fa, 0x16bc, 0x177e,
47   0x3840, 0x3982, 0x3bc4, 0x3a06, 0x3f48, 0x3e8a, 0x3ccc, 0x3d0e,
48   0x3650, 0x3792, 0x35d4, 0x3416, 0x3158, 0x309a, 0x32dc, 0x331e,
49   0x2460, 0x25a2, 0x27e4, 0x2626, 0x2368, 0x22aa, 0x20ec, 0x212e,
50   0x2a70, 0x2bb2, 0x29f4, 0x2836, 0x2d78, 0x2cba, 0x2efc, 0x2f3e,
51   0x7080, 0x7142, 0x7304, 0x72c6, 0x7788, 0x764a, 0x740c, 0x75ce,
52   0x7e90, 0x7f52, 0x7d14, 0x7cd6, 0x7998, 0x785a, 0x7a1c, 0x7bde,
53   0x6ca0, 0x6d62, 0x6f24, 0x6ee6, 0x6ba8, 0x6a6a, 0x682c, 0x69ee,
54   0x62b0, 0x6372, 0x6134, 0x60f6, 0x65b8, 0x647a, 0x663c, 0x67fe,
55   0x48c0, 0x4902, 0x4b44, 0x4a86, 0x4fc8, 0x4e0a, 0x4c4c, 0x4d8e,
56   0x46d0, 0x4712, 0x4554, 0x4496, 0x41d8, 0x401a, 0x425c, 0x439e,
57   0x54e0, 0x5522, 0x5764, 0x56a6, 0x53e8, 0x522a, 0x506c, 0x51ae,
58   0x5af0, 0x5b32, 0x5974, 0x58b6, 0x5df8, 0x5c3a, 0x5e7c, 0x5fbe,
59   0xe100, 0xe0c2, 0xe284, 0xe346, 0xe608, 0xe7ca, 0xe58c, 0xe44e,
60   0xef10, 0xeed2, 0xec94, 0xed56, 0xe818, 0xe9da, 0xeb9c, 0xea5e,
61   0xfd20, 0xfce2, 0xfea4, 0xff66, 0xfa28, 0xfbea, 0xf9ac, 0xf86e,
62   0xf330, 0xf2f2, 0xf0b4, 0xf176, 0xf438, 0xf5fa, 0xf7bc, 0xf67e,
63   0xd940, 0xd882, 0xdac4, 0xdb06, 0xde48, 0xdf8a, 0xddcc, 0xdc0e,
64   0xd750, 0xd692, 0xd4d4, 0xd516, 0xd058, 0xd19a, 0xd3dc, 0xd21e,
65   0xc560, 0xc4a2, 0xc6e4, 0xc726, 0xc268, 0xc3aa, 0xc1ec, 0xc02e,
66   0xcb70, 0xcab2, 0xc8f4, 0xc936, 0xcc78, 0xcdba, 0xcffc, 0xce3e,
67   0x9180, 0x9042, 0x9204, 0x93c6, 0x9688, 0x974a, 0x950c, 0x94ce,
68   0x9f90, 0x9e52, 0x9c14, 0x9dd6, 0x9898, 0x995a, 0x9b1c, 0x9ade,
69   0x8da0, 0x8c62, 0x8e24, 0x8fe6, 0x8aa8, 0x8b6a, 0x892c, 0x88ee,
70   0x83b0, 0x8272, 0x8034, 0x81f6, 0x84b8, 0x857a, 0x873c, 0x86fe,
71   0xa9c0, 0xa802, 0xaa44, 0xab86, 0xaec8, 0xaf0a, 0xad4c, 0xac8e,
72   0xa7d0, 0xa612, 0xa454, 0xa596, 0xa0d8, 0xa11a, 0xa35c, 0xa29e,
73   0xb5e0, 0xb422, 0xb664, 0xb7a6, 0xb2e8, 0xb32a, 0xb16c, 0xb0ae,
74   0xbbf0, 0xba32, 0xb874, 0xb9b6, 0xbcf8, 0xbd3a, 0xbf7c, 0xbebe,
75 };
76
77 #ifdef GCM_TABLES_USE_U64
78 static void
79 bshift (u64 * b0, u64 * b1)
80 {
81   u64 t[2], mask;
82
83   t[0] = *b0;
84   t[1] = *b1;
85   mask = t[1] & 1 ? 0xe1 : 0;
86   mask <<= 56;
87
88   *b1 = (t[1] >> 1) ^ (t[0] << 63);
89   *b0 = (t[0] >> 1) ^ mask;
90 }
91
92 static void
93 do_fillM (unsigned char *h, u64 *M)
94 {
95   int i, j;
96
97   M[0 + 0] = 0;
98   M[0 + 16] = 0;
99
100   M[8 + 0] = buf_get_be64 (h + 0);
101   M[8 + 16] = buf_get_be64 (h + 8);
102
103   for (i = 4; i > 0; i /= 2)
104     {
105       M[i + 0] = M[2 * i + 0];
106       M[i + 16] = M[2 * i + 16];
107
108       bshift (&M[i], &M[i + 16]);
109     }
110
111   for (i = 2; i < 16; i *= 2)
112     for (j = 1; j < i; j++)
113       {
114         M[(i + j) + 0] = M[i + 0] ^ M[j + 0];
115         M[(i + j) + 16] = M[i + 16] ^ M[j + 16];
116       }
117 }
118
119 static inline unsigned int
120 do_ghash (unsigned char *result, const unsigned char *buf, const u64 *gcmM)
121 {
122   u64 V[2];
123   u64 tmp[2];
124   const u64 *M;
125   u64 T;
126   u32 A;
127   int i;
128
129   buf_xor (V, result, buf, 16);
130   V[0] = be_bswap64 (V[0]);
131   V[1] = be_bswap64 (V[1]);
132
133   /* First round can be manually tweaked based on fact that 'tmp' is zero. */
134   i = 15;
135
136   M = &gcmM[(V[1] & 0xf)];
137   V[1] >>= 4;
138   tmp[0] = (M[0] >> 4) ^ ((u64) gcmR[(M[16] & 0xf) << 4] << 48);
139   tmp[1] = (M[16] >> 4) ^ (M[0] << 60);
140   tmp[0] ^= gcmM[(V[1] & 0xf) + 0];
141   tmp[1] ^= gcmM[(V[1] & 0xf) + 16];
142   V[1] >>= 4;
143
144   --i;
145   while (1)
146     {
147       M = &gcmM[(V[1] & 0xf)];
148       V[1] >>= 4;
149
150       A = tmp[1] & 0xff;
151       T = tmp[0];
152       tmp[0] = (T >> 8) ^ ((u64) gcmR[A] << 48) ^ gcmM[(V[1] & 0xf) + 0];
153       tmp[1] = (T << 56) ^ (tmp[1] >> 8) ^ gcmM[(V[1] & 0xf) + 16];
154
155       tmp[0] ^= (M[0] >> 4) ^ ((u64) gcmR[(M[16] & 0xf) << 4] << 48);
156       tmp[1] ^= (M[16] >> 4) ^ (M[0] << 60);
157
158       if (i == 0)
159         break;
160       else if (i == 8)
161         V[1] = V[0];
162       else
163         V[1] >>= 4;
164       --i;
165     }
166
167   buf_put_be64 (result + 0, tmp[0]);
168   buf_put_be64 (result + 8, tmp[1]);
169
170   return (sizeof(V) + sizeof(T) + sizeof(tmp) +
171           sizeof(int)*2 + sizeof(void*)*5);
172 }
173
174 #else
175
176 static void
177 bshift (u32 * M, int i)
178 {
179   u32 t[4], mask;
180
181   t[0] = M[i * 4 + 0];
182   t[1] = M[i * 4 + 1];
183   t[2] = M[i * 4 + 2];
184   t[3] = M[i * 4 + 3];
185   mask = t[3] & 1 ? 0xe1 : 0;
186
187   M[i * 4 + 3] = (t[3] >> 1) ^ (t[2] << 31);
188   M[i * 4 + 2] = (t[2] >> 1) ^ (t[1] << 31);
189   M[i * 4 + 1] = (t[1] >> 1) ^ (t[0] << 31);
190   M[i * 4 + 0] = (t[0] >> 1) ^ (mask << 24);
191 }
192
193 static void
194 do_fillM (unsigned char *h, u32 *M)
195 {
196   int i, j;
197
198   M[0 * 4 + 0] = 0;
199   M[0 * 4 + 1] = 0;
200   M[0 * 4 + 2] = 0;
201   M[0 * 4 + 3] = 0;
202
203   M[8 * 4 + 0] = buf_get_be32 (h + 0);
204   M[8 * 4 + 1] = buf_get_be32 (h + 4);
205   M[8 * 4 + 2] = buf_get_be32 (h + 8);
206   M[8 * 4 + 3] = buf_get_be32 (h + 12);
207
208   for (i = 4; i > 0; i /= 2)
209     {
210       M[i * 4 + 0] = M[2 * i * 4 + 0];
211       M[i * 4 + 1] = M[2 * i * 4 + 1];
212       M[i * 4 + 2] = M[2 * i * 4 + 2];
213       M[i * 4 + 3] = M[2 * i * 4 + 3];
214
215       bshift (M, i);
216     }
217
218   for (i = 2; i < 16; i *= 2)
219     for (j = 1; j < i; j++)
220       {
221         M[(i + j) * 4 + 0] = M[i * 4 + 0] ^ M[j * 4 + 0];
222         M[(i + j) * 4 + 1] = M[i * 4 + 1] ^ M[j * 4 + 1];
223         M[(i + j) * 4 + 2] = M[i * 4 + 2] ^ M[j * 4 + 2];
224         M[(i + j) * 4 + 3] = M[i * 4 + 3] ^ M[j * 4 + 3];
225       }
226 }
227
228 static inline unsigned int
229 do_ghash (unsigned char *result, const unsigned char *buf, const u32 *gcmM)
230 {
231   byte V[16];
232   u32 tmp[4];
233   u32 v;
234   const u32 *M, *m;
235   u32 T[3];
236   int i;
237
238   buf_xor (V, result, buf, 16); /* V is big-endian */
239
240   /* First round can be manually tweaked based on fact that 'tmp' is zero. */
241   i = 15;
242
243   v = V[i];
244   M = &gcmM[(v & 0xf) * 4];
245   v = (v & 0xf0) >> 4;
246   m = &gcmM[v * 4];
247   v = V[--i];
248
249   tmp[0] = (M[0] >> 4) ^ ((u64) gcmR[(M[3] << 4) & 0xf0] << 16) ^ m[0];
250   tmp[1] = (M[1] >> 4) ^ (M[0] << 28) ^ m[1];
251   tmp[2] = (M[2] >> 4) ^ (M[1] << 28) ^ m[2];
252   tmp[3] = (M[3] >> 4) ^ (M[2] << 28) ^ m[3];
253
254   while (1)
255     {
256       M = &gcmM[(v & 0xf) * 4];
257       v = (v & 0xf0) >> 4;
258       m = &gcmM[v * 4];
259
260       T[0] = tmp[0];
261       T[1] = tmp[1];
262       T[2] = tmp[2];
263       tmp[0] = (T[0] >> 8) ^ ((u32) gcmR[tmp[3] & 0xff] << 16) ^ m[0];
264       tmp[1] = (T[0] << 24) ^ (tmp[1] >> 8) ^ m[1];
265       tmp[2] = (T[1] << 24) ^ (tmp[2] >> 8) ^ m[2];
266       tmp[3] = (T[2] << 24) ^ (tmp[3] >> 8) ^ m[3];
267
268       tmp[0] ^= (M[0] >> 4) ^ ((u64) gcmR[(M[3] << 4) & 0xf0] << 16);
269       tmp[1] ^= (M[1] >> 4) ^ (M[0] << 28);
270       tmp[2] ^= (M[2] >> 4) ^ (M[1] << 28);
271       tmp[3] ^= (M[3] >> 4) ^ (M[2] << 28);
272
273       if (i == 0)
274         break;
275
276       v = V[--i];
277     }
278
279   buf_put_be32 (result + 0, tmp[0]);
280   buf_put_be32 (result + 4, tmp[1]);
281   buf_put_be32 (result + 8, tmp[2]);
282   buf_put_be32 (result + 12, tmp[3]);
283
284   return (sizeof(V) + sizeof(T) + sizeof(tmp) +
285           sizeof(int)*2 + sizeof(void*)*6);
286 }
287 #endif /* !HAVE_U64_TYPEDEF || SIZEOF_UNSIGNED_LONG != 8 */
288
289 #define fillM(c) \
290   do_fillM (c->u_mode.gcm.u_ghash_key.key, c->u_mode.gcm.gcm_table)
291 #define GHASH(c, result, buf) do_ghash (result, buf, c->u_mode.gcm.gcm_table)
292
293 #else
294
295 static unsigned long
296 bshift (unsigned long *b)
297 {
298   unsigned long c;
299   int i;
300   c = b[3] & 1;
301   for (i = 3; i > 0; i--)
302     {
303       b[i] = (b[i] >> 1) | (b[i - 1] << 31);
304     }
305   b[i] >>= 1;
306   return c;
307 }
308
309 static unsigned int
310 do_ghash (unsigned char *hsub, unsigned char *result, const unsigned char *buf)
311 {
312   unsigned long V[4];
313   int i, j;
314   byte *p;
315
316 #ifdef WORDS_BIGENDIAN
317   p = result;
318 #else
319   unsigned long T[4];
320
321   buf_xor (V, result, buf, 16);
322   for (i = 0; i < 4; i++)
323     {
324       V[i] = (V[i] & 0x00ff00ff) << 8 | (V[i] & 0xff00ff00) >> 8;
325       V[i] = (V[i] & 0x0000ffff) << 16 | (V[i] & 0xffff0000) >> 16;
326     }
327   p = (byte *) T;
328 #endif
329
330   memset (p, 0, 16);
331
332   for (i = 0; i < 16; i++)
333     {
334       for (j = 0x80; j; j >>= 1)
335         {
336           if (hsub[i] & j)
337             buf_xor (p, p, V, 16);
338           if (bshift (V))
339             V[0] ^= 0xe1000000;
340         }
341     }
342 #ifndef WORDS_BIGENDIAN
343   for (i = 0, p = (byte *) T; i < 16; i += 4, p += 4)
344     {
345       result[i + 0] = p[3];
346       result[i + 1] = p[2];
347       result[i + 2] = p[1];
348       result[i + 3] = p[0];
349     }
350 #endif
351
352   return (sizeof(V) + sizeof(T) + sizeof(int)*2 + sizeof(void*)*5);
353 }
354
355 #define fillM(c) do { } while (0)
356 #define GHASH(c, result, buf) do_ghash (c->u_mode.gcm.u_ghash_key.key, result, buf)
357
358 #endif /* !GCM_USE_TABLES */
359
360
361 static unsigned int
362 ghash_internal (gcry_cipher_hd_t c, byte *result, const byte *buf,
363                 size_t nblocks)
364 {
365   const unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
366   unsigned int burn = 0;
367
368   while (nblocks)
369     {
370       burn = GHASH (c, result, buf);
371       buf += blocksize;
372       nblocks--;
373     }
374
375   return burn + (burn ? 5*sizeof(void*) : 0);
376 }
377
378
379 static void
380 setupM (gcry_cipher_hd_t c)
381 {
382   if (0)
383     ;
384 #ifdef GCM_USE_INTEL_PCLMUL
385   else if (_gcry_get_hw_features () & HWF_INTEL_PCLMUL)
386     {
387       c->u_mode.gcm.ghash_fn = _gcry_ghash_intel_pclmul;
388       _gcry_ghash_setup_intel_pclmul (c);
389     }
390 #endif
391   else
392     {
393       c->u_mode.gcm.ghash_fn = ghash_internal;
394       fillM (c);
395     }
396 }
397
398
399 static inline void
400 gcm_bytecounter_add (u32 ctr[2], size_t add)
401 {
402   if (sizeof(add) > sizeof(u32))
403     {
404       u32 high_add = ((add >> 31) >> 1) & 0xffffffff;
405       ctr[1] += high_add;
406     }
407
408   ctr[0] += add;
409   if (ctr[0] >= add)
410     return;
411   ++ctr[1];
412 }
413
414
415 static inline u32
416 gcm_add32_be128 (byte *ctr, unsigned int add)
417 {
418   /* 'ctr' must be aligned to four bytes. */
419   const unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
420   u32 *pval = (u32 *)(void *)(ctr + blocksize - sizeof(u32));
421   u32 val;
422
423   val = be_bswap32(*pval) + add;
424   *pval = be_bswap32(val);
425
426   return val; /* return result as host-endian value */
427 }
428
429
430 static inline int
431 gcm_check_datalen (u32 ctr[2])
432 {
433   /* len(plaintext) <= 2^39-256 bits == 2^36-32 bytes == 2^32-2 blocks */
434   if (ctr[1] > 0xfU)
435     return 0;
436   if (ctr[1] < 0xfU)
437     return 1;
438
439   if (ctr[0] <= 0xffffffe0U)
440     return 1;
441
442   return 0;
443 }
444
445
446 static inline int
447 gcm_check_aadlen_or_ivlen (u32 ctr[2])
448 {
449   /* len(aad/iv) <= 2^64-1 bits ~= 2^61-1 bytes */
450   if (ctr[1] > 0x1fffffffU)
451     return 0;
452   if (ctr[1] < 0x1fffffffU)
453     return 1;
454
455   if (ctr[0] <= 0xffffffffU)
456     return 1;
457
458   return 0;
459 }
460
461
462 static void
463 do_ghash_buf(gcry_cipher_hd_t c, byte *hash, const byte *buf,
464              size_t buflen, int do_padding)
465 {
466   unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
467   unsigned int unused = c->u_mode.gcm.mac_unused;
468   ghash_fn_t ghash_fn = c->u_mode.gcm.ghash_fn;
469   size_t nblocks, n;
470   unsigned int burn = 0;
471
472   if (buflen == 0 && (unused == 0 || !do_padding))
473     return;
474
475   do
476     {
477       if (buflen > 0 && (buflen + unused < blocksize || unused > 0))
478         {
479           n = blocksize - unused;
480           n = n < buflen ? n : buflen;
481
482           buf_cpy (&c->u_mode.gcm.macbuf[unused], buf, n);
483
484           unused += n;
485           buf += n;
486           buflen -= n;
487         }
488       if (!buflen)
489         {
490           if (!do_padding)
491             break;
492
493           while (unused < blocksize)
494             c->u_mode.gcm.macbuf[unused++] = 0;
495         }
496
497       if (unused > 0)
498         {
499           gcry_assert (unused == blocksize);
500
501           /* Process one block from macbuf.  */
502           burn = ghash_fn (c, hash, c->u_mode.gcm.macbuf, 1);
503           unused = 0;
504         }
505
506       nblocks = buflen / blocksize;
507
508       if (nblocks)
509         {
510           burn = ghash_fn (c, hash, buf, nblocks);
511           buf += blocksize * nblocks;
512           buflen -= blocksize * nblocks;
513         }
514     }
515   while (buflen > 0);
516
517   c->u_mode.gcm.mac_unused = unused;
518
519   if (burn)
520     _gcry_burn_stack (burn);
521 }
522
523
524 gcry_err_code_t
525 _gcry_cipher_gcm_encrypt (gcry_cipher_hd_t c,
526                           byte *outbuf, size_t outbuflen,
527                           const byte *inbuf, size_t inbuflen)
528 {
529   static const unsigned char zerobuf[MAX_BLOCKSIZE];
530   gcry_err_code_t err;
531
532   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
533     return GPG_ERR_CIPHER_ALGO;
534   if (outbuflen < inbuflen)
535     return GPG_ERR_BUFFER_TOO_SHORT;
536   if (c->u_mode.gcm.datalen_over_limits)
537     return GPG_ERR_INV_LENGTH;
538   if (c->marks.tag || c->u_mode.gcm.ghash_data_finalized)
539     return GPG_ERR_INV_STATE;
540
541   if (!c->marks.iv)
542     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
543
544   if (c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode)
545     return GPG_ERR_INV_STATE;
546
547   if (!c->u_mode.gcm.ghash_aad_finalized)
548     {
549       /* Start of encryption marks end of AAD stream. */
550       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
551       c->u_mode.gcm.ghash_aad_finalized = 1;
552     }
553
554   gcm_bytecounter_add(c->u_mode.gcm.datalen, inbuflen);
555   if (!gcm_check_datalen(c->u_mode.gcm.datalen))
556     {
557       c->u_mode.gcm.datalen_over_limits = 1;
558       return GPG_ERR_INV_LENGTH;
559     }
560
561   err = _gcry_cipher_ctr_encrypt(c, outbuf, outbuflen, inbuf, inbuflen);
562   if (err != 0)
563     return err;
564
565   do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, outbuf, inbuflen, 0);
566
567   return 0;
568 }
569
570
571 gcry_err_code_t
572 _gcry_cipher_gcm_decrypt (gcry_cipher_hd_t c,
573                           byte *outbuf, size_t outbuflen,
574                           const byte *inbuf, size_t inbuflen)
575 {
576   static const unsigned char zerobuf[MAX_BLOCKSIZE];
577
578   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
579     return GPG_ERR_CIPHER_ALGO;
580   if (outbuflen < inbuflen)
581     return GPG_ERR_BUFFER_TOO_SHORT;
582   if (c->u_mode.gcm.datalen_over_limits)
583     return GPG_ERR_INV_LENGTH;
584   if (c->marks.tag || c->u_mode.gcm.ghash_data_finalized)
585     return GPG_ERR_INV_STATE;
586
587   if (!c->marks.iv)
588     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
589
590   if (!c->u_mode.gcm.ghash_aad_finalized)
591     {
592       /* Start of decryption marks end of AAD stream. */
593       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
594       c->u_mode.gcm.ghash_aad_finalized = 1;
595     }
596
597   gcm_bytecounter_add(c->u_mode.gcm.datalen, inbuflen);
598   if (!gcm_check_datalen(c->u_mode.gcm.datalen))
599     {
600       c->u_mode.gcm.datalen_over_limits = 1;
601       return GPG_ERR_INV_LENGTH;
602     }
603
604   do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, inbuf, inbuflen, 0);
605
606   return _gcry_cipher_ctr_encrypt(c, outbuf, outbuflen, inbuf, inbuflen);
607 }
608
609
610 gcry_err_code_t
611 _gcry_cipher_gcm_authenticate (gcry_cipher_hd_t c,
612                                const byte * aadbuf, size_t aadbuflen)
613 {
614   static const unsigned char zerobuf[MAX_BLOCKSIZE];
615
616   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
617     return GPG_ERR_CIPHER_ALGO;
618   if (c->u_mode.gcm.datalen_over_limits)
619     return GPG_ERR_INV_LENGTH;
620   if (c->marks.tag || c->u_mode.gcm.ghash_aad_finalized ||
621       c->u_mode.gcm.ghash_data_finalized)
622     return GPG_ERR_INV_STATE;
623
624   if (!c->marks.iv)
625     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
626
627   gcm_bytecounter_add(c->u_mode.gcm.aadlen, aadbuflen);
628   if (!gcm_check_aadlen_or_ivlen(c->u_mode.gcm.aadlen))
629     {
630       c->u_mode.gcm.datalen_over_limits = 1;
631       return GPG_ERR_INV_LENGTH;
632     }
633
634   do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, aadbuf, aadbuflen, 0);
635
636   return 0;
637 }
638
639
640 void
641 _gcry_cipher_gcm_setkey (gcry_cipher_hd_t c)
642 {
643   memset (c->u_mode.gcm.u_ghash_key.key, 0, GCRY_GCM_BLOCK_LEN);
644
645   c->spec->encrypt (&c->context.c, c->u_mode.gcm.u_ghash_key.key,
646                     c->u_mode.gcm.u_ghash_key.key);
647   setupM (c);
648 }
649
650
651 static gcry_err_code_t
652 _gcry_cipher_gcm_initiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
653 {
654   memset (c->u_mode.gcm.aadlen, 0, sizeof(c->u_mode.gcm.aadlen));
655   memset (c->u_mode.gcm.datalen, 0, sizeof(c->u_mode.gcm.datalen));
656   memset (c->u_mode.gcm.u_tag.tag, 0, GCRY_GCM_BLOCK_LEN);
657   c->u_mode.gcm.datalen_over_limits = 0;
658   c->u_mode.gcm.ghash_data_finalized = 0;
659   c->u_mode.gcm.ghash_aad_finalized = 0;
660
661   if (ivlen == 0)
662     return GPG_ERR_INV_LENGTH;
663
664   if (ivlen != GCRY_GCM_BLOCK_LEN - 4)
665     {
666       u32 iv_bytes[2] = {0, 0};
667       u32 bitlengths[2][2];
668
669       memset(c->u_ctr.ctr, 0, GCRY_GCM_BLOCK_LEN);
670
671       gcm_bytecounter_add(iv_bytes, ivlen);
672       if (!gcm_check_aadlen_or_ivlen(iv_bytes))
673         {
674           c->u_mode.gcm.datalen_over_limits = 1;
675           return GPG_ERR_INV_LENGTH;
676         }
677
678       do_ghash_buf(c, c->u_ctr.ctr, iv, ivlen, 1);
679
680       /* iv length, 64-bit */
681       bitlengths[1][1] = be_bswap32(iv_bytes[0] << 3);
682       bitlengths[1][0] = be_bswap32((iv_bytes[0] >> 29) |
683                                     (iv_bytes[1] << 3));
684       /* zeros, 64-bit */
685       bitlengths[0][1] = 0;
686       bitlengths[0][0] = 0;
687
688       do_ghash_buf(c, c->u_ctr.ctr, (byte*)bitlengths, GCRY_GCM_BLOCK_LEN, 1);
689
690       wipememory (iv_bytes, sizeof iv_bytes);
691       wipememory (bitlengths, sizeof bitlengths);
692     }
693   else
694     {
695       /* 96-bit IV is handled differently. */
696       memcpy (c->u_ctr.ctr, iv, ivlen);
697       c->u_ctr.ctr[12] = c->u_ctr.ctr[13] = c->u_ctr.ctr[14] = 0;
698       c->u_ctr.ctr[15] = 1;
699     }
700
701   c->spec->encrypt (&c->context.c, c->u_mode.gcm.tagiv, c->u_ctr.ctr);
702
703   gcm_add32_be128 (c->u_ctr.ctr, 1);
704
705   c->unused = 0;
706   c->marks.iv = 1;
707   c->marks.tag = 0;
708
709   return 0;
710 }
711
712
713 gcry_err_code_t
714 _gcry_cipher_gcm_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
715 {
716   c->marks.iv = 0;
717   c->marks.tag = 0;
718   c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 0;
719
720   if (fips_mode ())
721     {
722       /* Direct invocation of GCM setiv in FIPS mode disables encryption. */
723       c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 1;
724     }
725
726   return _gcry_cipher_gcm_initiv (c, iv, ivlen);
727 }
728
729
730 #if 0 && TODO
731 void
732 _gcry_cipher_gcm_geniv (gcry_cipher_hd_t c,
733                         byte *ivout, size_t ivoutlen, const byte *nonce,
734                         size_t noncelen)
735 {
736   /* nonce:    user provided part (might be null) */
737   /* noncelen: check if proper length (if nonce not null) */
738   /* ivout:    iv used to initialize gcm, output to user */
739   /* ivoutlen: check correct size */
740   byte iv[IVLEN];
741
742   if (!ivout)
743     return GPG_ERR_INV_ARG;
744   if (ivoutlen != IVLEN)
745     return GPG_ERR_INV_LENGTH;
746   if (nonce != NULL && !is_nonce_ok_len(noncelen))
747     return GPG_ERR_INV_ARG;
748
749   gcm_generate_iv(iv, nonce, noncelen);
750
751   c->marks.iv = 0;
752   c->marks.tag = 0;
753   c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 0;
754
755   _gcry_cipher_gcm_initiv (c, iv, IVLEN);
756
757   buf_cpy(ivout, iv, IVLEN);
758   wipememory(iv, sizeof(iv));
759 }
760 #endif
761
762
763 static gcry_err_code_t
764 _gcry_cipher_gcm_tag (gcry_cipher_hd_t c,
765                       byte * outbuf, size_t outbuflen, int check)
766 {
767   if (outbuflen < GCRY_GCM_BLOCK_LEN)
768     return GPG_ERR_BUFFER_TOO_SHORT;
769   if (c->u_mode.gcm.datalen_over_limits)
770     return GPG_ERR_INV_LENGTH;
771
772   if (!c->marks.tag)
773     {
774       u32 bitlengths[2][2];
775
776       /* aad length */
777       bitlengths[0][1] = be_bswap32(c->u_mode.gcm.aadlen[0] << 3);
778       bitlengths[0][0] = be_bswap32((c->u_mode.gcm.aadlen[0] >> 29) |
779                                     (c->u_mode.gcm.aadlen[1] << 3));
780       /* data length */
781       bitlengths[1][1] = be_bswap32(c->u_mode.gcm.datalen[0] << 3);
782       bitlengths[1][0] = be_bswap32((c->u_mode.gcm.datalen[0] >> 29) |
783                                     (c->u_mode.gcm.datalen[1] << 3));
784
785       /* Finalize data-stream. */
786       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
787       c->u_mode.gcm.ghash_aad_finalized = 1;
788       c->u_mode.gcm.ghash_data_finalized = 1;
789
790       /* Add bitlengths to tag. */
791       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, (byte*)bitlengths,
792                    GCRY_GCM_BLOCK_LEN, 1);
793       buf_xor (c->u_mode.gcm.u_tag.tag, c->u_mode.gcm.tagiv,
794                c->u_mode.gcm.u_tag.tag, GCRY_GCM_BLOCK_LEN);
795       c->marks.tag = 1;
796
797       wipememory (bitlengths, sizeof (bitlengths));
798       wipememory (c->u_mode.gcm.macbuf, GCRY_GCM_BLOCK_LEN);
799       wipememory (c->u_mode.gcm.tagiv, GCRY_GCM_BLOCK_LEN);
800       wipememory (c->u_mode.gcm.aadlen, sizeof (c->u_mode.gcm.aadlen));
801       wipememory (c->u_mode.gcm.datalen, sizeof (c->u_mode.gcm.datalen));
802     }
803
804   if (!check)
805     {
806       memcpy (outbuf, c->u_mode.gcm.u_tag.tag, outbuflen);
807       return GPG_ERR_NO_ERROR;
808     }
809   else
810     {
811       return buf_eq_const(outbuf, c->u_mode.gcm.u_tag.tag, outbuflen) ?
812                GPG_ERR_NO_ERROR : GPG_ERR_CHECKSUM;
813     }
814
815   return 0;
816 }
817
818
819 gcry_err_code_t
820 _gcry_cipher_gcm_get_tag (gcry_cipher_hd_t c, unsigned char *outtag,
821                           size_t taglen)
822 {
823   /* Outputting authentication tag is part of encryption. */
824   if (c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode)
825     return GPG_ERR_INV_STATE;
826
827   return _gcry_cipher_gcm_tag (c, outtag, taglen, 0);
828 }
829
830 gcry_err_code_t
831 _gcry_cipher_gcm_check_tag (gcry_cipher_hd_t c, const unsigned char *intag,
832                             size_t taglen)
833 {
834   return _gcry_cipher_gcm_tag (c, (unsigned char *) intag, taglen, 1);
835 }