rijndael: refactor to reduce number of #ifdefs and branches
[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 #ifdef GCM_USE_TABLES
33 static const u16 gcmR[256] = {
34   0x0000, 0x01c2, 0x0384, 0x0246, 0x0708, 0x06ca, 0x048c, 0x054e,
35   0x0e10, 0x0fd2, 0x0d94, 0x0c56, 0x0918, 0x08da, 0x0a9c, 0x0b5e,
36   0x1c20, 0x1de2, 0x1fa4, 0x1e66, 0x1b28, 0x1aea, 0x18ac, 0x196e,
37   0x1230, 0x13f2, 0x11b4, 0x1076, 0x1538, 0x14fa, 0x16bc, 0x177e,
38   0x3840, 0x3982, 0x3bc4, 0x3a06, 0x3f48, 0x3e8a, 0x3ccc, 0x3d0e,
39   0x3650, 0x3792, 0x35d4, 0x3416, 0x3158, 0x309a, 0x32dc, 0x331e,
40   0x2460, 0x25a2, 0x27e4, 0x2626, 0x2368, 0x22aa, 0x20ec, 0x212e,
41   0x2a70, 0x2bb2, 0x29f4, 0x2836, 0x2d78, 0x2cba, 0x2efc, 0x2f3e,
42   0x7080, 0x7142, 0x7304, 0x72c6, 0x7788, 0x764a, 0x740c, 0x75ce,
43   0x7e90, 0x7f52, 0x7d14, 0x7cd6, 0x7998, 0x785a, 0x7a1c, 0x7bde,
44   0x6ca0, 0x6d62, 0x6f24, 0x6ee6, 0x6ba8, 0x6a6a, 0x682c, 0x69ee,
45   0x62b0, 0x6372, 0x6134, 0x60f6, 0x65b8, 0x647a, 0x663c, 0x67fe,
46   0x48c0, 0x4902, 0x4b44, 0x4a86, 0x4fc8, 0x4e0a, 0x4c4c, 0x4d8e,
47   0x46d0, 0x4712, 0x4554, 0x4496, 0x41d8, 0x401a, 0x425c, 0x439e,
48   0x54e0, 0x5522, 0x5764, 0x56a6, 0x53e8, 0x522a, 0x506c, 0x51ae,
49   0x5af0, 0x5b32, 0x5974, 0x58b6, 0x5df8, 0x5c3a, 0x5e7c, 0x5fbe,
50   0xe100, 0xe0c2, 0xe284, 0xe346, 0xe608, 0xe7ca, 0xe58c, 0xe44e,
51   0xef10, 0xeed2, 0xec94, 0xed56, 0xe818, 0xe9da, 0xeb9c, 0xea5e,
52   0xfd20, 0xfce2, 0xfea4, 0xff66, 0xfa28, 0xfbea, 0xf9ac, 0xf86e,
53   0xf330, 0xf2f2, 0xf0b4, 0xf176, 0xf438, 0xf5fa, 0xf7bc, 0xf67e,
54   0xd940, 0xd882, 0xdac4, 0xdb06, 0xde48, 0xdf8a, 0xddcc, 0xdc0e,
55   0xd750, 0xd692, 0xd4d4, 0xd516, 0xd058, 0xd19a, 0xd3dc, 0xd21e,
56   0xc560, 0xc4a2, 0xc6e4, 0xc726, 0xc268, 0xc3aa, 0xc1ec, 0xc02e,
57   0xcb70, 0xcab2, 0xc8f4, 0xc936, 0xcc78, 0xcdba, 0xcffc, 0xce3e,
58   0x9180, 0x9042, 0x9204, 0x93c6, 0x9688, 0x974a, 0x950c, 0x94ce,
59   0x9f90, 0x9e52, 0x9c14, 0x9dd6, 0x9898, 0x995a, 0x9b1c, 0x9ade,
60   0x8da0, 0x8c62, 0x8e24, 0x8fe6, 0x8aa8, 0x8b6a, 0x892c, 0x88ee,
61   0x83b0, 0x8272, 0x8034, 0x81f6, 0x84b8, 0x857a, 0x873c, 0x86fe,
62   0xa9c0, 0xa802, 0xaa44, 0xab86, 0xaec8, 0xaf0a, 0xad4c, 0xac8e,
63   0xa7d0, 0xa612, 0xa454, 0xa596, 0xa0d8, 0xa11a, 0xa35c, 0xa29e,
64   0xb5e0, 0xb422, 0xb664, 0xb7a6, 0xb2e8, 0xb32a, 0xb16c, 0xb0ae,
65   0xbbf0, 0xba32, 0xb874, 0xb9b6, 0xbcf8, 0xbd3a, 0xbf7c, 0xbebe,
66 };
67
68 #ifdef GCM_TABLES_USE_U64
69 static void
70 bshift (u64 * b0, u64 * b1)
71 {
72   u64 t[2], mask;
73
74   t[0] = *b0;
75   t[1] = *b1;
76   mask = t[1] & 1 ? 0xe1 : 0;
77   mask <<= 56;
78
79   *b1 = (t[1] >> 1) ^ (t[0] << 63);
80   *b0 = (t[0] >> 1) ^ mask;
81 }
82
83 static void
84 do_fillM (unsigned char *h, u64 *M)
85 {
86   int i, j;
87
88   M[0 + 0] = 0;
89   M[0 + 16] = 0;
90
91   M[8 + 0] = buf_get_be64 (h + 0);
92   M[8 + 16] = buf_get_be64 (h + 8);
93
94   for (i = 4; i > 0; i /= 2)
95     {
96       M[i + 0] = M[2 * i + 0];
97       M[i + 16] = M[2 * i + 16];
98
99       bshift (&M[i], &M[i + 16]);
100     }
101
102   for (i = 2; i < 16; i *= 2)
103     for (j = 1; j < i; j++)
104       {
105         M[(i + j) + 0] = M[i + 0] ^ M[j + 0];
106         M[(i + j) + 16] = M[i + 16] ^ M[j + 16];
107       }
108 }
109
110 static inline unsigned int
111 do_ghash (unsigned char *result, const unsigned char *buf, const u64 *gcmM)
112 {
113   u64 V[2];
114   u64 tmp[2];
115   const u64 *M;
116   u64 T;
117   u32 A;
118   int i;
119
120   buf_xor (V, result, buf, 16);
121   V[0] = be_bswap64 (V[0]);
122   V[1] = be_bswap64 (V[1]);
123
124   /* First round can be manually tweaked based on fact that 'tmp' is zero. */
125   i = 15;
126
127   M = &gcmM[(V[1] & 0xf)];
128   V[1] >>= 4;
129   tmp[0] = (M[0] >> 4) ^ ((u64) gcmR[(M[16] & 0xf) << 4] << 48);
130   tmp[1] = (M[16] >> 4) ^ (M[0] << 60);
131   tmp[0] ^= gcmM[(V[1] & 0xf) + 0];
132   tmp[1] ^= gcmM[(V[1] & 0xf) + 16];
133   V[1] >>= 4;
134
135   --i;
136   while (1)
137     {
138       M = &gcmM[(V[1] & 0xf)];
139       V[1] >>= 4;
140
141       A = tmp[1] & 0xff;
142       T = tmp[0];
143       tmp[0] = (T >> 8) ^ ((u64) gcmR[A] << 48) ^ gcmM[(V[1] & 0xf) + 0];
144       tmp[1] = (T << 56) ^ (tmp[1] >> 8) ^ gcmM[(V[1] & 0xf) + 16];
145
146       tmp[0] ^= (M[0] >> 4) ^ ((u64) gcmR[(M[16] & 0xf) << 4] << 48);
147       tmp[1] ^= (M[16] >> 4) ^ (M[0] << 60);
148
149       if (i == 0)
150         break;
151       else if (i == 8)
152         V[1] = V[0];
153       else
154         V[1] >>= 4;
155       --i;
156     }
157
158   buf_put_be64 (result + 0, tmp[0]);
159   buf_put_be64 (result + 8, tmp[1]);
160
161   return (sizeof(V) + sizeof(T) + sizeof(tmp) +
162           sizeof(int)*2 + sizeof(void*)*5);
163 }
164
165 #else
166
167 static void
168 bshift (u32 * M, int i)
169 {
170   u32 t[4], mask;
171
172   t[0] = M[i * 4 + 0];
173   t[1] = M[i * 4 + 1];
174   t[2] = M[i * 4 + 2];
175   t[3] = M[i * 4 + 3];
176   mask = t[3] & 1 ? 0xe1 : 0;
177
178   M[i * 4 + 3] = (t[3] >> 1) ^ (t[2] << 31);
179   M[i * 4 + 2] = (t[2] >> 1) ^ (t[1] << 31);
180   M[i * 4 + 1] = (t[1] >> 1) ^ (t[0] << 31);
181   M[i * 4 + 0] = (t[0] >> 1) ^ (mask << 24);
182 }
183
184 static void
185 do_fillM (unsigned char *h, u32 *M)
186 {
187   int i, j;
188
189   M[0 * 4 + 0] = 0;
190   M[0 * 4 + 1] = 0;
191   M[0 * 4 + 2] = 0;
192   M[0 * 4 + 3] = 0;
193
194   M[8 * 4 + 0] = buf_get_be32 (h + 0);
195   M[8 * 4 + 1] = buf_get_be32 (h + 4);
196   M[8 * 4 + 2] = buf_get_be32 (h + 8);
197   M[8 * 4 + 3] = buf_get_be32 (h + 12);
198
199   for (i = 4; i > 0; i /= 2)
200     {
201       M[i * 4 + 0] = M[2 * i * 4 + 0];
202       M[i * 4 + 1] = M[2 * i * 4 + 1];
203       M[i * 4 + 2] = M[2 * i * 4 + 2];
204       M[i * 4 + 3] = M[2 * i * 4 + 3];
205
206       bshift (M, i);
207     }
208
209   for (i = 2; i < 16; i *= 2)
210     for (j = 1; j < i; j++)
211       {
212         M[(i + j) * 4 + 0] = M[i * 4 + 0] ^ M[j * 4 + 0];
213         M[(i + j) * 4 + 1] = M[i * 4 + 1] ^ M[j * 4 + 1];
214         M[(i + j) * 4 + 2] = M[i * 4 + 2] ^ M[j * 4 + 2];
215         M[(i + j) * 4 + 3] = M[i * 4 + 3] ^ M[j * 4 + 3];
216       }
217 }
218
219 static inline unsigned int
220 do_ghash (unsigned char *result, const unsigned char *buf, const u32 *gcmM)
221 {
222   byte V[16];
223   u32 tmp[4];
224   u32 v;
225   const u32 *M, *m;
226   u32 T[3];
227   int i;
228
229   buf_xor (V, result, buf, 16); /* V is big-endian */
230
231   /* First round can be manually tweaked based on fact that 'tmp' is zero. */
232   i = 15;
233
234   v = V[i];
235   M = &gcmM[(v & 0xf) * 4];
236   v = (v & 0xf0) >> 4;
237   m = &gcmM[v * 4];
238   v = V[--i];
239
240   tmp[0] = (M[0] >> 4) ^ ((u64) gcmR[(M[3] << 4) & 0xf0] << 16) ^ m[0];
241   tmp[1] = (M[1] >> 4) ^ (M[0] << 28) ^ m[1];
242   tmp[2] = (M[2] >> 4) ^ (M[1] << 28) ^ m[2];
243   tmp[3] = (M[3] >> 4) ^ (M[2] << 28) ^ m[3];
244
245   while (1)
246     {
247       M = &gcmM[(v & 0xf) * 4];
248       v = (v & 0xf0) >> 4;
249       m = &gcmM[v * 4];
250
251       T[0] = tmp[0];
252       T[1] = tmp[1];
253       T[2] = tmp[2];
254       tmp[0] = (T[0] >> 8) ^ ((u32) gcmR[tmp[3] & 0xff] << 16) ^ m[0];
255       tmp[1] = (T[0] << 24) ^ (tmp[1] >> 8) ^ m[1];
256       tmp[2] = (T[1] << 24) ^ (tmp[2] >> 8) ^ m[2];
257       tmp[3] = (T[2] << 24) ^ (tmp[3] >> 8) ^ m[3];
258
259       tmp[0] ^= (M[0] >> 4) ^ ((u64) gcmR[(M[3] << 4) & 0xf0] << 16);
260       tmp[1] ^= (M[1] >> 4) ^ (M[0] << 28);
261       tmp[2] ^= (M[2] >> 4) ^ (M[1] << 28);
262       tmp[3] ^= (M[3] >> 4) ^ (M[2] << 28);
263
264       if (i == 0)
265         break;
266
267       v = V[--i];
268     }
269
270   buf_put_be32 (result + 0, tmp[0]);
271   buf_put_be32 (result + 4, tmp[1]);
272   buf_put_be32 (result + 8, tmp[2]);
273   buf_put_be32 (result + 12, tmp[3]);
274
275   return (sizeof(V) + sizeof(T) + sizeof(tmp) +
276           sizeof(int)*2 + sizeof(void*)*6);
277 }
278 #endif /* !HAVE_U64_TYPEDEF || SIZEOF_UNSIGNED_LONG != 8 */
279
280 #define fillM(c, h) do_fillM (h, c->u_mode.gcm.gcm_table)
281 #define GHASH(c, result, buf) do_ghash (result, buf, c->u_mode.gcm.gcm_table)
282
283 #else
284
285 static unsigned long
286 bshift (unsigned long *b)
287 {
288   unsigned long c;
289   int i;
290   c = b[3] & 1;
291   for (i = 3; i > 0; i--)
292     {
293       b[i] = (b[i] >> 1) | (b[i - 1] << 31);
294     }
295   b[i] >>= 1;
296   return c;
297 }
298
299 static unsigned int
300 do_ghash (unsigned char *hsub, unsigned char *result, const unsigned char *buf)
301 {
302   unsigned long V[4];
303   int i, j;
304   byte *p;
305
306 #ifdef WORDS_BIGENDIAN
307   p = result;
308 #else
309   unsigned long T[4];
310
311   buf_xor (V, result, buf, 16);
312   for (i = 0; i < 4; i++)
313     {
314       V[i] = (V[i] & 0x00ff00ff) << 8 | (V[i] & 0xff00ff00) >> 8;
315       V[i] = (V[i] & 0x0000ffff) << 16 | (V[i] & 0xffff0000) >> 16;
316     }
317   p = (byte *) T;
318 #endif
319
320   memset (p, 0, 16);
321
322   for (i = 0; i < 16; i++)
323     {
324       for (j = 0x80; j; j >>= 1)
325         {
326           if (hsub[i] & j)
327             buf_xor (p, p, V, 16);
328           if (bshift (V))
329             V[0] ^= 0xe1000000;
330         }
331     }
332 #ifndef WORDS_BIGENDIAN
333   for (i = 0, p = (byte *) T; i < 16; i += 4, p += 4)
334     {
335       result[i + 0] = p[3];
336       result[i + 1] = p[2];
337       result[i + 2] = p[1];
338       result[i + 3] = p[0];
339     }
340 #endif
341
342   return (sizeof(V) + sizeof(T) + sizeof(int)*2 + sizeof(void*)*5);
343 }
344
345 #define fillM(c, h) do { } while (0)
346 #define GHASH(c, result, buf) do_ghash (c->u_mode.gcm.u_ghash_key.key, result, buf)
347
348 #endif /* !GCM_USE_TABLES */
349
350
351 #ifdef GCM_USE_INTEL_PCLMUL
352 /*
353  Intel PCLMUL ghash based on white paper:
354   "Intel® Carry-Less Multiplication Instruction and its Usage for Computing the
355    GCM Mode - Rev 2.01"; Shay Gueron, Michael E. Kounavis.
356  */
357 static inline void gfmul_pclmul(void)
358 {
359   /* Input: XMM0 and XMM1, Output: XMM1. Input XMM0 stays unmodified.
360      Input must be converted to little-endian.
361    */
362   asm volatile (/* gfmul, xmm0 has operator a and xmm1 has operator b. */
363                 "pshufd $78, %%xmm0, %%xmm2\n\t"
364                 "pshufd $78, %%xmm1, %%xmm4\n\t"
365                 "pxor %%xmm0, %%xmm2\n\t" /* xmm2 holds a0+a1 */
366                 "pxor %%xmm1, %%xmm4\n\t" /* xmm4 holds b0+b1 */
367
368                 "movdqa %%xmm0, %%xmm3\n\t"
369                 "pclmulqdq $0, %%xmm1, %%xmm3\n\t"  /* xmm3 holds a0*b0 */
370                 "movdqa %%xmm0, %%xmm6\n\t"
371                 "pclmulqdq $17, %%xmm1, %%xmm6\n\t" /* xmm6 holds a1*b1 */
372                 "movdqa %%xmm3, %%xmm5\n\t"
373                 "pclmulqdq $0, %%xmm2, %%xmm4\n\t"  /* xmm4 holds (a0+a1)*(b0+b1) */
374
375                 "pxor %%xmm6, %%xmm5\n\t" /* xmm5 holds a0*b0+a1*b1 */
376                 "pxor %%xmm5, %%xmm4\n\t" /* xmm4 holds a0*b0+a1*b1+(a0+a1)*(b0+b1) */
377                 "movdqa %%xmm4, %%xmm5\n\t"
378                 "psrldq $8, %%xmm4\n\t"
379                 "pslldq $8, %%xmm5\n\t"
380                 "pxor %%xmm5, %%xmm3\n\t"
381                 "pxor %%xmm4, %%xmm6\n\t" /* <xmm6:xmm3> holds the result of the
382                                              carry-less multiplication of xmm0
383                                              by xmm1 */
384
385                 /* shift the result by one bit position to the left cope for
386                    the fact that bits are reversed */
387                 "movdqa %%xmm3, %%xmm4\n\t"
388                 "movdqa %%xmm6, %%xmm5\n\t"
389                 "pslld $1, %%xmm3\n\t"
390                 "pslld $1, %%xmm6\n\t"
391                 "psrld $31, %%xmm4\n\t"
392                 "psrld $31, %%xmm5\n\t"
393                 "movdqa %%xmm4, %%xmm1\n\t"
394                 "pslldq $4, %%xmm5\n\t"
395                 "pslldq $4, %%xmm4\n\t"
396                 "psrldq $12, %%xmm1\n\t"
397                 "por %%xmm4, %%xmm3\n\t"
398                 "por %%xmm5, %%xmm6\n\t"
399                 "por %%xmm6, %%xmm1\n\t"
400
401                 /* first phase of the reduction */
402                 "movdqa %%xmm3, %%xmm6\n\t"
403                 "movdqa %%xmm3, %%xmm7\n\t"
404                 "pslld $31, %%xmm6\n\t"  /* packed right shifting << 31 */
405                 "movdqa %%xmm3, %%xmm5\n\t"
406                 "pslld $30, %%xmm7\n\t"  /* packed right shifting shift << 30 */
407                 "pslld $25, %%xmm5\n\t"  /* packed right shifting shift << 25 */
408                 "pxor %%xmm7, %%xmm6\n\t" /* xor the shifted versions */
409                 "pxor %%xmm5, %%xmm6\n\t"
410                 "movdqa %%xmm6, %%xmm7\n\t"
411                 "pslldq $12, %%xmm6\n\t"
412                 "psrldq $4, %%xmm7\n\t"
413                 "pxor %%xmm6, %%xmm3\n\t" /* first phase of the reduction
414                                              complete */
415
416                 /* second phase of the reduction */
417                 "movdqa %%xmm3, %%xmm2\n\t"
418                 "movdqa %%xmm3, %%xmm4\n\t"
419                 "psrld $1, %%xmm2\n\t"    /* packed left shifting >> 1 */
420                 "movdqa %%xmm3, %%xmm5\n\t"
421                 "psrld $2, %%xmm4\n\t"    /* packed left shifting >> 2 */
422                 "psrld $7, %%xmm5\n\t"    /* packed left shifting >> 7 */
423                 "pxor %%xmm4, %%xmm2\n\t" /* xor the shifted versions */
424                 "pxor %%xmm5, %%xmm2\n\t"
425                 "pxor %%xmm7, %%xmm2\n\t"
426                 "pxor %%xmm2, %%xmm3\n\t"
427                 "pxor %%xmm3, %%xmm1\n\t" /* the result is in xmm1 */
428                 ::: "cc" );
429 }
430
431 #ifdef __x86_64__
432 static inline void gfmul_pclmul_aggr4(void)
433 {
434   /* Input:
435       H¹: XMM0         X_i            : XMM6
436       H²: XMM8         X_(i-1)        : XMM3
437       H³: XMM9         X_(i-2)        : XMM2
438       H⁴: XMM10               X_(i-3)⊕Y_(i-4): XMM1
439      Output:
440       Y_i: XMM1
441      Inputs XMM0 stays unmodified.
442      Input must be converted to little-endian.
443    */
444   asm volatile (/* perform clmul and merge results... */
445                 "pshufd $78, %%xmm10, %%xmm11\n\t"
446                 "pshufd $78, %%xmm1, %%xmm12\n\t"
447                 "pxor %%xmm10, %%xmm11\n\t" /* xmm11 holds 4:a0+a1 */
448                 "pxor %%xmm1, %%xmm12\n\t" /* xmm12 holds 4:b0+b1 */
449
450                 "pshufd $78, %%xmm9, %%xmm13\n\t"
451                 "pshufd $78, %%xmm2, %%xmm14\n\t"
452                 "pxor %%xmm9, %%xmm13\n\t" /* xmm13 holds 3:a0+a1 */
453                 "pxor %%xmm2, %%xmm14\n\t" /* xmm14 holds 3:b0+b1 */
454
455                 "pshufd $78, %%xmm8, %%xmm5\n\t"
456                 "pshufd $78, %%xmm3, %%xmm15\n\t"
457                 "pxor %%xmm8, %%xmm5\n\t" /* xmm1 holds 2:a0+a1 */
458                 "pxor %%xmm3, %%xmm15\n\t" /* xmm2 holds 2:b0+b1 */
459
460                 "movdqa %%xmm10, %%xmm4\n\t"
461                 "movdqa %%xmm9, %%xmm7\n\t"
462                 "pclmulqdq $0, %%xmm1, %%xmm4\n\t"   /* xmm4 holds 4:a0*b0 */
463                 "pclmulqdq $0, %%xmm2, %%xmm7\n\t"   /* xmm7 holds 3:a0*b0 */
464                 "pclmulqdq $17, %%xmm10, %%xmm1\n\t" /* xmm1 holds 4:a1*b1 */
465                 "pclmulqdq $17, %%xmm9, %%xmm2\n\t"  /* xmm9 holds 3:a1*b1 */
466                 "pclmulqdq $0, %%xmm11, %%xmm12\n\t" /* xmm12 holds 4:(a0+a1)*(b0+b1) */
467                 "pclmulqdq $0, %%xmm13, %%xmm14\n\t" /* xmm14 holds 3:(a0+a1)*(b0+b1) */
468
469                 "pshufd $78, %%xmm0, %%xmm10\n\t"
470                 "pshufd $78, %%xmm6, %%xmm11\n\t"
471                 "pxor %%xmm0, %%xmm10\n\t" /* xmm10 holds 1:a0+a1 */
472                 "pxor %%xmm6, %%xmm11\n\t" /* xmm11 holds 1:b0+b1 */
473
474                 "pxor %%xmm4, %%xmm7\n\t"   /* xmm7 holds 3+4:a0*b0 */
475                 "pxor %%xmm2, %%xmm1\n\t"   /* xmm1 holds 3+4:a1*b1 */
476                 "pxor %%xmm14, %%xmm12\n\t" /* xmm12 holds 3+4:(a0+a1)*(b0+b1) */
477
478                 "movdqa %%xmm8, %%xmm13\n\t"
479                 "pclmulqdq $0, %%xmm3, %%xmm13\n\t"  /* xmm13 holds 2:a0*b0 */
480                 "pclmulqdq $17, %%xmm8, %%xmm3\n\t"  /* xmm3 holds 2:a1*b1 */
481                 "pclmulqdq $0, %%xmm5, %%xmm15\n\t" /* xmm15 holds 2:(a0+a1)*(b0+b1) */
482
483                 "pxor %%xmm13, %%xmm7\n\t" /* xmm7 holds 2+3+4:a0*b0 */
484                 "pxor %%xmm3, %%xmm1\n\t"  /* xmm1 holds 2+3+4:a1*b1 */
485                 "pxor %%xmm15, %%xmm12\n\t" /* xmm12 holds 2+3+4:(a0+a1)*(b0+b1) */
486
487                 "movdqa %%xmm0, %%xmm3\n\t"
488                 "pclmulqdq $0, %%xmm6, %%xmm3\n\t"  /* xmm3 holds 1:a0*b0 */
489                 "pclmulqdq $17, %%xmm0, %%xmm6\n\t" /* xmm6 holds 1:a1*b1 */
490                 "movdqa %%xmm11, %%xmm4\n\t"
491                 "pclmulqdq $0, %%xmm10, %%xmm4\n\t" /* xmm4 holds 1:(a0+a1)*(b0+b1) */
492
493                 "pxor %%xmm7, %%xmm3\n\t"  /* xmm3 holds 1+2+3+4:a0*b0 */
494                 "pxor %%xmm1, %%xmm6\n\t"  /* xmm6 holds 1+2+3+4:a1*b1 */
495                 "pxor %%xmm12, %%xmm4\n\t" /* xmm4 holds 1+2+3+4:(a0+a1)*(b0+b1) */
496
497                 /* aggregated reduction... */
498                 "movdqa %%xmm3, %%xmm5\n\t"
499                 "pxor %%xmm6, %%xmm5\n\t" /* xmm5 holds a0*b0+a1*b1 */
500                 "pxor %%xmm5, %%xmm4\n\t" /* xmm4 holds a0*b0+a1*b1+(a0+a1)*(b0+b1) */
501                 "movdqa %%xmm4, %%xmm5\n\t"
502                 "psrldq $8, %%xmm4\n\t"
503                 "pslldq $8, %%xmm5\n\t"
504                 "pxor %%xmm5, %%xmm3\n\t"
505                 "pxor %%xmm4, %%xmm6\n\t" /* <xmm6:xmm3> holds the result of the
506                                              carry-less multiplication of xmm0
507                                              by xmm1 */
508
509                 /* shift the result by one bit position to the left cope for
510                    the fact that bits are reversed */
511                 "movdqa %%xmm3, %%xmm4\n\t"
512                 "movdqa %%xmm6, %%xmm5\n\t"
513                 "pslld $1, %%xmm3\n\t"
514                 "pslld $1, %%xmm6\n\t"
515                 "psrld $31, %%xmm4\n\t"
516                 "psrld $31, %%xmm5\n\t"
517                 "movdqa %%xmm4, %%xmm1\n\t"
518                 "pslldq $4, %%xmm5\n\t"
519                 "pslldq $4, %%xmm4\n\t"
520                 "psrldq $12, %%xmm1\n\t"
521                 "por %%xmm4, %%xmm3\n\t"
522                 "por %%xmm5, %%xmm6\n\t"
523                 "por %%xmm6, %%xmm1\n\t"
524
525                 /* first phase of the reduction */
526                 "movdqa %%xmm3, %%xmm6\n\t"
527                 "movdqa %%xmm3, %%xmm7\n\t"
528                 "pslld $31, %%xmm6\n\t"  /* packed right shifting << 31 */
529                 "movdqa %%xmm3, %%xmm5\n\t"
530                 "pslld $30, %%xmm7\n\t"  /* packed right shifting shift << 30 */
531                 "pslld $25, %%xmm5\n\t"  /* packed right shifting shift << 25 */
532                 "pxor %%xmm7, %%xmm6\n\t" /* xor the shifted versions */
533                 "pxor %%xmm5, %%xmm6\n\t"
534                 "movdqa %%xmm6, %%xmm7\n\t"
535                 "pslldq $12, %%xmm6\n\t"
536                 "psrldq $4, %%xmm7\n\t"
537                 "pxor %%xmm6, %%xmm3\n\t" /* first phase of the reduction
538                                              complete */
539
540                 /* second phase of the reduction */
541                 "movdqa %%xmm3, %%xmm2\n\t"
542                 "movdqa %%xmm3, %%xmm4\n\t"
543                 "psrld $1, %%xmm2\n\t"    /* packed left shifting >> 1 */
544                 "movdqa %%xmm3, %%xmm5\n\t"
545                 "psrld $2, %%xmm4\n\t"    /* packed left shifting >> 2 */
546                 "psrld $7, %%xmm5\n\t"    /* packed left shifting >> 7 */
547                 "pxor %%xmm4, %%xmm2\n\t" /* xor the shifted versions */
548                 "pxor %%xmm5, %%xmm2\n\t"
549                 "pxor %%xmm7, %%xmm2\n\t"
550                 "pxor %%xmm2, %%xmm3\n\t"
551                 "pxor %%xmm3, %%xmm1\n\t" /* the result is in xmm1 */
552                 :::"cc");
553 }
554 #endif
555
556 #endif /*GCM_USE_INTEL_PCLMUL*/
557
558
559 static unsigned int
560 ghash (gcry_cipher_hd_t c, byte *result, const byte *buf,
561        size_t nblocks)
562 {
563   const unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
564   unsigned int burn;
565
566   if (nblocks == 0)
567     return 0;
568
569   if (0)
570     ;
571 #ifdef GCM_USE_INTEL_PCLMUL
572   else if (c->u_mode.gcm.use_intel_pclmul)
573     {
574       static const unsigned char be_mask[16] __attribute__ ((aligned (16))) =
575         { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
576
577       /* Preload hash and H1. */
578       asm volatile ("movdqu %[hash], %%xmm1\n\t"
579                     "movdqa %[hsub], %%xmm0\n\t"
580                     "pshufb %[be_mask], %%xmm1\n\t" /* be => le */
581                     :
582                     : [hash] "m" (*result), [be_mask] "m" (*be_mask),
583                       [hsub] "m" (*c->u_mode.gcm.u_ghash_key.key));
584
585 #ifdef __x86_64__
586       if (nblocks >= 4)
587         {
588           do
589             {
590               asm volatile ("movdqa %[be_mask], %%xmm4\n\t"
591                             "movdqu 0*16(%[buf]), %%xmm5\n\t"
592                             "movdqu 1*16(%[buf]), %%xmm2\n\t"
593                             "movdqu 2*16(%[buf]), %%xmm3\n\t"
594                             "movdqu 3*16(%[buf]), %%xmm6\n\t"
595                             "pshufb %%xmm4, %%xmm5\n\t" /* be => le */
596
597                             /* Load H2, H3, H4. */
598                             "movdqu 2*16(%[h_234]), %%xmm10\n\t"
599                             "movdqu 1*16(%[h_234]), %%xmm9\n\t"
600                             "movdqu 0*16(%[h_234]), %%xmm8\n\t"
601
602                             "pxor %%xmm5, %%xmm1\n\t"
603                             "pshufb %%xmm4, %%xmm2\n\t" /* be => le */
604                             "pshufb %%xmm4, %%xmm3\n\t" /* be => le */
605                             "pshufb %%xmm4, %%xmm6\n\t" /* be => le */
606                             :
607                             : [buf] "r" (buf), [be_mask] "m" (*be_mask),
608                               [h_234] "r" (c->u_mode.gcm.gcm_table));
609
610               gfmul_pclmul_aggr4 ();
611
612               buf += 4 * blocksize;
613               nblocks -= 4;
614             }
615           while (nblocks >= 4);
616
617           /* Clear used x86-64/XMM registers. */
618           asm volatile( "pxor %%xmm8, %%xmm8\n\t"
619                         "pxor %%xmm9, %%xmm9\n\t"
620                         "pxor %%xmm10, %%xmm10\n\t"
621                         "pxor %%xmm11, %%xmm11\n\t"
622                         "pxor %%xmm12, %%xmm12\n\t"
623                         "pxor %%xmm13, %%xmm13\n\t"
624                         "pxor %%xmm14, %%xmm14\n\t"
625                         "pxor %%xmm15, %%xmm15\n\t"
626                         ::: "cc" );
627         }
628 #endif
629
630       while (nblocks--)
631         {
632           asm volatile ("movdqu %[buf], %%xmm2\n\t"
633                         "pshufb %[be_mask], %%xmm2\n\t" /* be => le */
634                         "pxor %%xmm2, %%xmm1\n\t"
635                         :
636                         : [buf] "m" (*buf), [be_mask] "m" (*be_mask));
637
638           gfmul_pclmul ();
639
640           buf += blocksize;
641         }
642
643       /* Store hash. */
644       asm volatile ("pshufb %[be_mask], %%xmm1\n\t" /* be => le */
645                     "movdqu %%xmm1, %[hash]\n\t"
646                     : [hash] "=m" (*result)
647                     : [be_mask] "m" (*be_mask));
648
649       /* Clear used registers. */
650       asm volatile( "pxor %%xmm0, %%xmm0\n\t"
651                     "pxor %%xmm1, %%xmm1\n\t"
652                     "pxor %%xmm2, %%xmm2\n\t"
653                     "pxor %%xmm3, %%xmm3\n\t"
654                     "pxor %%xmm4, %%xmm4\n\t"
655                     "pxor %%xmm5, %%xmm5\n\t"
656                     "pxor %%xmm6, %%xmm6\n\t"
657                     "pxor %%xmm7, %%xmm7\n\t"
658                     ::: "cc" );
659       burn = 0;
660     }
661 #endif
662   else
663     {
664       while (nblocks)
665         {
666           burn = GHASH (c, result, buf);
667           buf += blocksize;
668           nblocks--;
669         }
670     }
671
672   return burn + (burn ? 5*sizeof(void*) : 0);
673 }
674
675
676 static void
677 setupM (gcry_cipher_hd_t c, byte *h)
678 {
679   if (0)
680     ;
681 #ifdef GCM_USE_INTEL_PCLMUL
682   else if (_gcry_get_hw_features () & HWF_INTEL_PCLMUL)
683     {
684       u64 tmp[2];
685
686       c->u_mode.gcm.use_intel_pclmul = 1;
687
688       /* Swap endianness of hsub. */
689       tmp[0] = buf_get_be64(c->u_mode.gcm.u_ghash_key.key + 8);
690       tmp[1] = buf_get_be64(c->u_mode.gcm.u_ghash_key.key + 0);
691       buf_cpy (c->u_mode.gcm.u_ghash_key.key, tmp, GCRY_GCM_BLOCK_LEN);
692
693 #ifdef __x86_64__
694       asm volatile ("movdqu %[h_1], %%xmm0\n\t"
695                     "movdqa %%xmm0, %%xmm1\n\t"
696                     :
697                     : [h_1] "m" (*tmp));
698
699       gfmul_pclmul (); /* H•H => H² */
700
701       asm volatile ("movdqu %%xmm1, 0*16(%[h_234])\n\t"
702                     "movdqa %%xmm1, %%xmm8\n\t"
703                     :
704                     : [h_234] "r" (c->u_mode.gcm.gcm_table)
705                     : "memory");
706
707       gfmul_pclmul (); /* H•H² => H³ */
708
709       asm volatile ("movdqa %%xmm8, %%xmm0\n\t"
710                     "movdqu %%xmm1, 1*16(%[h_234])\n\t"
711                     "movdqa %%xmm8, %%xmm1\n\t"
712                     :
713                     : [h_234] "r" (c->u_mode.gcm.gcm_table)
714                     : "memory");
715
716       gfmul_pclmul (); /* H²•H² => H⁴ */
717
718       asm volatile ("movdqu %%xmm1, 2*16(%[h_234])\n\t"
719                     :
720                     : [h_234] "r" (c->u_mode.gcm.gcm_table)
721                     : "memory");
722
723       /* Clear used registers. */
724       asm volatile( "pxor %%xmm0, %%xmm0\n\t"
725                     "pxor %%xmm1, %%xmm1\n\t"
726                     "pxor %%xmm2, %%xmm2\n\t"
727                     "pxor %%xmm3, %%xmm3\n\t"
728                     "pxor %%xmm4, %%xmm4\n\t"
729                     "pxor %%xmm5, %%xmm5\n\t"
730                     "pxor %%xmm6, %%xmm6\n\t"
731                     "pxor %%xmm7, %%xmm7\n\t"
732                     "pxor %%xmm8, %%xmm8\n\t"
733                     ::: "cc" );
734 #endif
735
736       wipememory (tmp, sizeof(tmp));
737     }
738 #endif
739   else
740     fillM (c, h);
741 }
742
743
744 static inline void
745 gcm_bytecounter_add (u32 ctr[2], size_t add)
746 {
747   if (sizeof(add) > sizeof(u32))
748     {
749       u32 high_add = ((add >> 31) >> 1) & 0xffffffff;
750       ctr[1] += high_add;
751     }
752
753   ctr[0] += add;
754   if (ctr[0] >= add)
755     return;
756   ++ctr[1];
757 }
758
759
760 static inline u32
761 gcm_add32_be128 (byte *ctr, unsigned int add)
762 {
763   /* 'ctr' must be aligned to four bytes. */
764   const unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
765   u32 *pval = (u32 *)(void *)(ctr + blocksize - sizeof(u32));
766   u32 val;
767
768   val = be_bswap32(*pval) + add;
769   *pval = be_bswap32(val);
770
771   return val; /* return result as host-endian value */
772 }
773
774
775 static inline int
776 gcm_check_datalen (u32 ctr[2])
777 {
778   /* len(plaintext) <= 2^39-256 bits == 2^36-32 bytes == 2^32-2 blocks */
779   if (ctr[1] > 0xfU)
780     return 0;
781   if (ctr[1] < 0xfU)
782     return 1;
783
784   if (ctr[0] <= 0xffffffe0U)
785     return 1;
786
787   return 0;
788 }
789
790
791 static inline int
792 gcm_check_aadlen_or_ivlen (u32 ctr[2])
793 {
794   /* len(aad/iv) <= 2^64-1 bits ~= 2^61-1 bytes */
795   if (ctr[1] > 0x1fffffffU)
796     return 0;
797   if (ctr[1] < 0x1fffffffU)
798     return 1;
799
800   if (ctr[0] <= 0xffffffffU)
801     return 1;
802
803   return 0;
804 }
805
806
807 static void
808 do_ghash_buf(gcry_cipher_hd_t c, byte *hash, const byte *buf,
809              size_t buflen, int do_padding)
810 {
811   unsigned int blocksize = GCRY_GCM_BLOCK_LEN;
812   unsigned int unused = c->u_mode.gcm.mac_unused;
813   size_t nblocks, n;
814   unsigned int burn = 0;
815
816   if (buflen == 0 && (unused == 0 || !do_padding))
817     return;
818
819   do
820     {
821       if (buflen + unused < blocksize || unused > 0)
822         {
823           n = blocksize - unused;
824           n = n < buflen ? n : buflen;
825
826           buf_cpy (&c->u_mode.gcm.macbuf[unused], buf, n);
827
828           unused += n;
829           buf += n;
830           buflen -= n;
831         }
832       if (!buflen)
833         {
834           if (!do_padding)
835             break;
836
837           while (unused < blocksize)
838             c->u_mode.gcm.macbuf[unused++] = 0;
839         }
840
841       if (unused > 0)
842         {
843           gcry_assert (unused == blocksize);
844
845           /* Process one block from macbuf.  */
846           burn = ghash (c, hash, c->u_mode.gcm.macbuf, 1);
847           unused = 0;
848         }
849
850       nblocks = buflen / blocksize;
851
852       if (nblocks)
853         {
854           burn = ghash (c, hash, buf, nblocks);
855           buf += blocksize * nblocks;
856           buflen -= blocksize * nblocks;
857         }
858     }
859   while (buflen > 0);
860
861   c->u_mode.gcm.mac_unused = unused;
862
863   if (burn)
864     _gcry_burn_stack (burn);
865 }
866
867
868 gcry_err_code_t
869 _gcry_cipher_gcm_encrypt (gcry_cipher_hd_t c,
870                           byte *outbuf, size_t outbuflen,
871                           const byte *inbuf, size_t inbuflen)
872 {
873   static const unsigned char zerobuf[MAX_BLOCKSIZE];
874   gcry_err_code_t err;
875
876   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
877     return GPG_ERR_CIPHER_ALGO;
878   if (outbuflen < inbuflen)
879     return GPG_ERR_BUFFER_TOO_SHORT;
880   if (c->u_mode.gcm.datalen_over_limits)
881     return GPG_ERR_INV_LENGTH;
882   if (c->marks.tag || c->u_mode.gcm.ghash_data_finalized)
883     return GPG_ERR_INV_STATE;
884
885   if (!c->marks.iv)
886     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
887
888   if (c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode)
889     return GPG_ERR_INV_STATE;
890
891   if (!c->u_mode.gcm.ghash_aad_finalized)
892     {
893       /* Start of encryption marks end of AAD stream. */
894       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
895       c->u_mode.gcm.ghash_aad_finalized = 1;
896     }
897
898   gcm_bytecounter_add(c->u_mode.gcm.datalen, inbuflen);
899   if (!gcm_check_datalen(c->u_mode.gcm.datalen))
900     {
901       c->u_mode.gcm.datalen_over_limits = 1;
902       return GPG_ERR_INV_LENGTH;
903     }
904
905   err = _gcry_cipher_ctr_encrypt(c, outbuf, outbuflen, inbuf, inbuflen);
906   if (err != 0)
907     return err;
908
909   do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, outbuf, inbuflen, 0);
910
911   return 0;
912 }
913
914
915 gcry_err_code_t
916 _gcry_cipher_gcm_decrypt (gcry_cipher_hd_t c,
917                           byte *outbuf, size_t outbuflen,
918                           const byte *inbuf, size_t inbuflen)
919 {
920   static const unsigned char zerobuf[MAX_BLOCKSIZE];
921
922   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
923     return GPG_ERR_CIPHER_ALGO;
924   if (outbuflen < inbuflen)
925     return GPG_ERR_BUFFER_TOO_SHORT;
926   if (c->u_mode.gcm.datalen_over_limits)
927     return GPG_ERR_INV_LENGTH;
928   if (c->marks.tag || c->u_mode.gcm.ghash_data_finalized)
929     return GPG_ERR_INV_STATE;
930
931   if (!c->marks.iv)
932     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
933
934   if (!c->u_mode.gcm.ghash_aad_finalized)
935     {
936       /* Start of decryption marks end of AAD stream. */
937       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
938       c->u_mode.gcm.ghash_aad_finalized = 1;
939     }
940
941   gcm_bytecounter_add(c->u_mode.gcm.datalen, inbuflen);
942   if (!gcm_check_datalen(c->u_mode.gcm.datalen))
943     {
944       c->u_mode.gcm.datalen_over_limits = 1;
945       return GPG_ERR_INV_LENGTH;
946     }
947
948   do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, inbuf, inbuflen, 0);
949
950   return _gcry_cipher_ctr_encrypt(c, outbuf, outbuflen, inbuf, inbuflen);
951 }
952
953
954 gcry_err_code_t
955 _gcry_cipher_gcm_authenticate (gcry_cipher_hd_t c,
956                                const byte * aadbuf, size_t aadbuflen)
957 {
958   static const unsigned char zerobuf[MAX_BLOCKSIZE];
959
960   if (c->spec->blocksize != GCRY_GCM_BLOCK_LEN)
961     return GPG_ERR_CIPHER_ALGO;
962   if (c->u_mode.gcm.datalen_over_limits)
963     return GPG_ERR_INV_LENGTH;
964   if (c->marks.tag || c->u_mode.gcm.ghash_aad_finalized ||
965       c->u_mode.gcm.ghash_data_finalized)
966     return GPG_ERR_INV_STATE;
967
968   if (!c->marks.iv)
969     _gcry_cipher_gcm_setiv (c, zerobuf, GCRY_GCM_BLOCK_LEN);
970
971   gcm_bytecounter_add(c->u_mode.gcm.aadlen, aadbuflen);
972   if (!gcm_check_aadlen_or_ivlen(c->u_mode.gcm.aadlen))
973     {
974       c->u_mode.gcm.datalen_over_limits = 1;
975       return GPG_ERR_INV_LENGTH;
976     }
977
978   do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, aadbuf, aadbuflen, 0);
979
980   return 0;
981 }
982
983
984 void
985 _gcry_cipher_gcm_setkey (gcry_cipher_hd_t c)
986 {
987   memset (c->u_mode.gcm.u_ghash_key.key, 0, GCRY_GCM_BLOCK_LEN);
988
989   c->spec->encrypt (&c->context.c, c->u_mode.gcm.u_ghash_key.key,
990                     c->u_mode.gcm.u_ghash_key.key);
991   setupM (c, c->u_mode.gcm.u_ghash_key.key);
992 }
993
994
995 static gcry_err_code_t
996 _gcry_cipher_gcm_initiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
997 {
998   memset (c->u_mode.gcm.aadlen, 0, sizeof(c->u_mode.gcm.aadlen));
999   memset (c->u_mode.gcm.datalen, 0, sizeof(c->u_mode.gcm.datalen));
1000   memset (c->u_mode.gcm.u_tag.tag, 0, GCRY_GCM_BLOCK_LEN);
1001   c->u_mode.gcm.datalen_over_limits = 0;
1002   c->u_mode.gcm.ghash_data_finalized = 0;
1003   c->u_mode.gcm.ghash_aad_finalized = 0;
1004
1005   if (ivlen == 0)
1006     return GPG_ERR_INV_LENGTH;
1007
1008   if (ivlen != GCRY_GCM_BLOCK_LEN - 4)
1009     {
1010       u32 iv_bytes[2] = {0, 0};
1011       u32 bitlengths[2][2];
1012
1013       memset(c->u_ctr.ctr, 0, GCRY_GCM_BLOCK_LEN);
1014
1015       gcm_bytecounter_add(iv_bytes, ivlen);
1016       if (!gcm_check_aadlen_or_ivlen(iv_bytes))
1017         {
1018           c->u_mode.gcm.datalen_over_limits = 1;
1019           return GPG_ERR_INV_LENGTH;
1020         }
1021
1022       do_ghash_buf(c, c->u_ctr.ctr, iv, ivlen, 1);
1023
1024       /* iv length, 64-bit */
1025       bitlengths[1][1] = be_bswap32(iv_bytes[0] << 3);
1026       bitlengths[1][0] = be_bswap32((iv_bytes[0] >> 29) |
1027                                     (iv_bytes[1] << 3));
1028       /* zeros, 64-bit */
1029       bitlengths[0][1] = 0;
1030       bitlengths[0][0] = 0;
1031
1032       do_ghash_buf(c, c->u_ctr.ctr, (byte*)bitlengths, GCRY_GCM_BLOCK_LEN, 1);
1033
1034       wipememory (iv_bytes, sizeof iv_bytes);
1035       wipememory (bitlengths, sizeof bitlengths);
1036     }
1037   else
1038     {
1039       /* 96-bit IV is handled differently. */
1040       memcpy (c->u_ctr.ctr, iv, ivlen);
1041       c->u_ctr.ctr[12] = c->u_ctr.ctr[13] = c->u_ctr.ctr[14] = 0;
1042       c->u_ctr.ctr[15] = 1;
1043     }
1044
1045   c->spec->encrypt (&c->context.c, c->u_mode.gcm.tagiv, c->u_ctr.ctr);
1046
1047   gcm_add32_be128 (c->u_ctr.ctr, 1);
1048
1049   c->unused = 0;
1050   c->marks.iv = 1;
1051   c->marks.tag = 0;
1052
1053   return 0;
1054 }
1055
1056
1057 gcry_err_code_t
1058 _gcry_cipher_gcm_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
1059 {
1060   c->marks.iv = 0;
1061   c->marks.tag = 0;
1062   c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 0;
1063
1064   if (fips_mode ())
1065     {
1066       /* Direct invocation of GCM setiv in FIPS mode disables encryption. */
1067       c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 1;
1068     }
1069
1070   return _gcry_cipher_gcm_initiv (c, iv, ivlen);
1071 }
1072
1073
1074 #if 0 && TODO
1075 void
1076 _gcry_cipher_gcm_geniv (gcry_cipher_hd_t c,
1077                         byte *ivout, size_t ivoutlen, const byte *nonce,
1078                         size_t noncelen)
1079 {
1080   /* nonce:    user provided part (might be null) */
1081   /* noncelen: check if proper length (if nonce not null) */
1082   /* ivout:    iv used to initialize gcm, output to user */
1083   /* ivoutlen: check correct size */
1084   byte iv[IVLEN];
1085
1086   if (!ivout)
1087     return GPG_ERR_INV_ARG;
1088   if (ivoutlen != IVLEN)
1089     return GPG_ERR_INV_LENGTH;
1090   if (nonce != NULL && !is_nonce_ok_len(noncelen))
1091     return GPG_ERR_INV_ARG;
1092
1093   gcm_generate_iv(iv, nonce, noncelen);
1094
1095   c->marks.iv = 0;
1096   c->marks.tag = 0;
1097   c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode = 0;
1098
1099   _gcry_cipher_gcm_initiv (c, iv, IVLEN);
1100
1101   buf_cpy(ivout, iv, IVLEN);
1102   wipememory(iv, sizeof(iv));
1103 }
1104 #endif
1105
1106
1107 static gcry_err_code_t
1108 _gcry_cipher_gcm_tag (gcry_cipher_hd_t c,
1109                       byte * outbuf, size_t outbuflen, int check)
1110 {
1111   if (outbuflen < GCRY_GCM_BLOCK_LEN)
1112     return GPG_ERR_BUFFER_TOO_SHORT;
1113   if (c->u_mode.gcm.datalen_over_limits)
1114     return GPG_ERR_INV_LENGTH;
1115
1116   if (!c->marks.tag)
1117     {
1118       u32 bitlengths[2][2];
1119
1120       /* aad length */
1121       bitlengths[0][1] = be_bswap32(c->u_mode.gcm.aadlen[0] << 3);
1122       bitlengths[0][0] = be_bswap32((c->u_mode.gcm.aadlen[0] >> 29) |
1123                                     (c->u_mode.gcm.aadlen[1] << 3));
1124       /* data length */
1125       bitlengths[1][1] = be_bswap32(c->u_mode.gcm.datalen[0] << 3);
1126       bitlengths[1][0] = be_bswap32((c->u_mode.gcm.datalen[0] >> 29) |
1127                                     (c->u_mode.gcm.datalen[1] << 3));
1128
1129       /* Finalize data-stream. */
1130       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, NULL, 0, 1);
1131       c->u_mode.gcm.ghash_aad_finalized = 1;
1132       c->u_mode.gcm.ghash_data_finalized = 1;
1133
1134       /* Add bitlengths to tag. */
1135       do_ghash_buf(c, c->u_mode.gcm.u_tag.tag, (byte*)bitlengths,
1136                    GCRY_GCM_BLOCK_LEN, 1);
1137       buf_xor (c->u_mode.gcm.u_tag.tag, c->u_mode.gcm.tagiv,
1138                c->u_mode.gcm.u_tag.tag, GCRY_GCM_BLOCK_LEN);
1139       c->marks.tag = 1;
1140
1141       wipememory (bitlengths, sizeof (bitlengths));
1142       wipememory (c->u_mode.gcm.macbuf, GCRY_GCM_BLOCK_LEN);
1143       wipememory (c->u_mode.gcm.tagiv, GCRY_GCM_BLOCK_LEN);
1144       wipememory (c->u_mode.gcm.aadlen, sizeof (c->u_mode.gcm.aadlen));
1145       wipememory (c->u_mode.gcm.datalen, sizeof (c->u_mode.gcm.datalen));
1146     }
1147
1148   if (!check)
1149     {
1150       memcpy (outbuf, c->u_mode.gcm.u_tag.tag, outbuflen);
1151       return GPG_ERR_NO_ERROR;
1152     }
1153   else
1154     {
1155       return buf_eq_const(outbuf, c->u_mode.gcm.u_tag.tag, outbuflen) ?
1156                GPG_ERR_NO_ERROR : GPG_ERR_CHECKSUM;
1157     }
1158
1159   return 0;
1160 }
1161
1162
1163 gcry_err_code_t
1164 _gcry_cipher_gcm_get_tag (gcry_cipher_hd_t c, unsigned char *outtag,
1165                           size_t taglen)
1166 {
1167   /* Outputting authentication tag is part of encryption. */
1168   if (c->u_mode.gcm.disallow_encryption_because_of_setiv_in_fips_mode)
1169     return GPG_ERR_INV_STATE;
1170
1171   return _gcry_cipher_gcm_tag (c, outtag, taglen, 0);
1172 }
1173
1174 gcry_err_code_t
1175 _gcry_cipher_gcm_check_tag (gcry_cipher_hd_t c, const unsigned char *intag,
1176                             size_t taglen)
1177 {
1178   return _gcry_cipher_gcm_tag (c, (unsigned char *) intag, taglen, 1);
1179 }