Process CCM/EAX/GCM/Poly1305 AEAD cipher modes input in 24 KiB chucks
[libgcrypt.git] / cipher / cipher-ccm.c
1 /* cipher-ccm.c - CTR mode with CBC-MAC mode implementation
2  * Copyright (C) 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25
26 #include "g10lib.h"
27 #include "cipher.h"
28 #include "bufhelp.h"
29 #include "./cipher-internal.h"
30
31
32 #define set_burn(burn, nburn) do { \
33   unsigned int __nburn = (nburn); \
34   (burn) = (burn) > __nburn ? (burn) : __nburn; } while (0)
35
36
37 static unsigned int
38 do_cbc_mac (gcry_cipher_hd_t c, const unsigned char *inbuf, size_t inlen,
39             int do_padding)
40 {
41   const unsigned int blocksize = 16;
42   gcry_cipher_encrypt_t enc_fn = c->spec->encrypt;
43   unsigned char tmp[blocksize];
44   unsigned int burn = 0;
45   unsigned int unused = c->u_mode.ccm.mac_unused;
46   size_t nblocks;
47
48   if (inlen == 0 && (unused == 0 || !do_padding))
49     return 0;
50
51   do
52     {
53       if (inlen + unused < blocksize || unused > 0)
54         {
55           for (; inlen && unused < blocksize; inlen--)
56             c->u_mode.ccm.macbuf[unused++] = *inbuf++;
57         }
58       if (!inlen)
59         {
60           if (!do_padding)
61             break;
62
63           while (unused < blocksize)
64             c->u_mode.ccm.macbuf[unused++] = 0;
65         }
66
67       if (unused > 0)
68         {
69           /* Process one block from macbuf.  */
70           cipher_block_xor(c->u_iv.iv, c->u_iv.iv, c->u_mode.ccm.macbuf,
71                            blocksize);
72           set_burn (burn, enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv ));
73
74           unused = 0;
75         }
76
77       if (c->bulk.cbc_enc)
78         {
79           nblocks = inlen / blocksize;
80           c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, tmp, inbuf, nblocks, 1);
81           inbuf += nblocks * blocksize;
82           inlen -= nblocks * blocksize;
83
84           wipememory (tmp, sizeof(tmp));
85         }
86       else
87         {
88           while (inlen >= blocksize)
89             {
90               cipher_block_xor(c->u_iv.iv, c->u_iv.iv, inbuf, blocksize);
91
92               set_burn (burn, enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv ));
93
94               inlen -= blocksize;
95               inbuf += blocksize;
96             }
97         }
98     }
99   while (inlen > 0);
100
101   c->u_mode.ccm.mac_unused = unused;
102
103   if (burn)
104     burn += 4 * sizeof(void *);
105
106   return burn;
107 }
108
109
110 gcry_err_code_t
111 _gcry_cipher_ccm_set_nonce (gcry_cipher_hd_t c, const unsigned char *nonce,
112                             size_t noncelen)
113 {
114   unsigned int marks_key;
115   size_t L = 15 - noncelen;
116   size_t L_;
117
118   L_ = L - 1;
119
120   if (!nonce)
121     return GPG_ERR_INV_ARG;
122   /* Length field must be 2, 3, ..., or 8. */
123   if (L < 2 || L > 8)
124     return GPG_ERR_INV_LENGTH;
125
126   /* Reset state */
127   marks_key = c->marks.key;
128   memset (&c->u_mode, 0, sizeof(c->u_mode));
129   memset (&c->marks, 0, sizeof(c->marks));
130   memset (&c->u_iv, 0, sizeof(c->u_iv));
131   memset (&c->u_ctr, 0, sizeof(c->u_ctr));
132   memset (c->lastiv, 0, sizeof(c->lastiv));
133   c->unused = 0;
134   c->marks.key = marks_key;
135
136   /* Setup CTR */
137   c->u_ctr.ctr[0] = L_;
138   memcpy (&c->u_ctr.ctr[1], nonce, noncelen);
139   memset (&c->u_ctr.ctr[1 + noncelen], 0, L);
140
141   /* Setup IV */
142   c->u_iv.iv[0] = L_;
143   memcpy (&c->u_iv.iv[1], nonce, noncelen);
144   /* Add (8 * M_ + 64 * flags) to iv[0] and set iv[noncelen + 1 ... 15] later
145      in set_aad.  */
146   memset (&c->u_iv.iv[1 + noncelen], 0, L);
147
148   c->u_mode.ccm.nonce = 1;
149
150   return GPG_ERR_NO_ERROR;
151 }
152
153
154 gcry_err_code_t
155 _gcry_cipher_ccm_set_lengths (gcry_cipher_hd_t c, u64 encryptlen, u64 aadlen,
156                               u64 taglen)
157 {
158   unsigned int burn = 0;
159   unsigned char b0[16];
160   size_t noncelen = 15 - (c->u_iv.iv[0] + 1);
161   u64 M = taglen;
162   u64 M_;
163   int i;
164
165   M_ = (M - 2) / 2;
166
167   /* Authentication field must be 4, 6, 8, 10, 12, 14 or 16. */
168   if ((M_ * 2 + 2) != M || M < 4 || M > 16)
169     return GPG_ERR_INV_LENGTH;
170   if (!c->u_mode.ccm.nonce || c->marks.tag)
171     return GPG_ERR_INV_STATE;
172   if (c->u_mode.ccm.lengths)
173     return GPG_ERR_INV_STATE;
174
175   c->u_mode.ccm.authlen = taglen;
176   c->u_mode.ccm.encryptlen = encryptlen;
177   c->u_mode.ccm.aadlen = aadlen;
178
179   /* Complete IV setup.  */
180   c->u_iv.iv[0] += (aadlen > 0) * 64 + M_ * 8;
181   for (i = 16 - 1; i >= 1 + noncelen; i--)
182     {
183       c->u_iv.iv[i] = encryptlen & 0xff;
184       encryptlen >>= 8;
185     }
186
187   memcpy (b0, c->u_iv.iv, 16);
188   memset (c->u_iv.iv, 0, 16);
189
190   set_burn (burn, do_cbc_mac (c, b0, 16, 0));
191
192   if (aadlen == 0)
193     {
194       /* Do nothing.  */
195     }
196   else if (aadlen > 0 && aadlen <= (unsigned int)0xfeff)
197     {
198       b0[0] = (aadlen >> 8) & 0xff;
199       b0[1] = aadlen & 0xff;
200       set_burn (burn, do_cbc_mac (c, b0, 2, 0));
201     }
202   else if (aadlen > 0xfeff && aadlen <= (unsigned int)0xffffffff)
203     {
204       b0[0] = 0xff;
205       b0[1] = 0xfe;
206       buf_put_be32(&b0[2], aadlen);
207       set_burn (burn, do_cbc_mac (c, b0, 6, 0));
208     }
209   else if (aadlen > (unsigned int)0xffffffff)
210     {
211       b0[0] = 0xff;
212       b0[1] = 0xff;
213       buf_put_be64(&b0[2], aadlen);
214       set_burn (burn, do_cbc_mac (c, b0, 10, 0));
215     }
216
217   /* Generate S_0 and increase counter.  */
218   set_burn (burn, c->spec->encrypt ( &c->context.c, c->u_mode.ccm.s0,
219                                      c->u_ctr.ctr ));
220   c->u_ctr.ctr[15]++;
221
222   if (burn)
223     _gcry_burn_stack (burn + sizeof(void *) * 5);
224
225   c->u_mode.ccm.lengths = 1;
226
227   return GPG_ERR_NO_ERROR;
228 }
229
230
231 gcry_err_code_t
232 _gcry_cipher_ccm_authenticate (gcry_cipher_hd_t c, const unsigned char *abuf,
233                                size_t abuflen)
234 {
235   unsigned int burn;
236
237   if (abuflen > 0 && !abuf)
238     return GPG_ERR_INV_ARG;
239   if (!c->u_mode.ccm.nonce || !c->u_mode.ccm.lengths || c->marks.tag)
240     return GPG_ERR_INV_STATE;
241   if (abuflen > c->u_mode.ccm.aadlen)
242     return GPG_ERR_INV_LENGTH;
243
244   c->u_mode.ccm.aadlen -= abuflen;
245   burn = do_cbc_mac (c, abuf, abuflen, c->u_mode.ccm.aadlen == 0);
246
247   if (burn)
248     _gcry_burn_stack (burn + sizeof(void *) * 5);
249
250   return GPG_ERR_NO_ERROR;
251 }
252
253
254 gcry_err_code_t
255 _gcry_cipher_ccm_tag (gcry_cipher_hd_t c, unsigned char *outbuf,
256                       size_t outbuflen, int check)
257 {
258   unsigned int burn;
259
260   if (!outbuf || outbuflen == 0)
261     return GPG_ERR_INV_ARG;
262   /* Tag length must be same as initial authlen.  */
263   if (c->u_mode.ccm.authlen != outbuflen)
264     return GPG_ERR_INV_LENGTH;
265   if (!c->u_mode.ccm.nonce || !c->u_mode.ccm.lengths || c->u_mode.ccm.aadlen > 0)
266     return GPG_ERR_INV_STATE;
267   /* Initial encrypt length must match with length of actual data processed.  */
268   if (c->u_mode.ccm.encryptlen > 0)
269     return GPG_ERR_UNFINISHED;
270
271   if (!c->marks.tag)
272     {
273       burn = do_cbc_mac (c, NULL, 0, 1); /* Perform final padding.  */
274
275       /* Add S_0 */
276       cipher_block_xor (c->u_iv.iv, c->u_iv.iv, c->u_mode.ccm.s0, 16);
277
278       wipememory (c->u_ctr.ctr, 16);
279       wipememory (c->u_mode.ccm.s0, 16);
280       wipememory (c->u_mode.ccm.macbuf, 16);
281
282       if (burn)
283         _gcry_burn_stack (burn + sizeof(void *) * 5);
284
285       c->marks.tag = 1;
286     }
287
288   if (!check)
289     {
290       memcpy (outbuf, c->u_iv.iv, outbuflen);
291       return GPG_ERR_NO_ERROR;
292     }
293   else
294     {
295       return buf_eq_const(outbuf, c->u_iv.iv, outbuflen) ?
296              GPG_ERR_NO_ERROR : GPG_ERR_CHECKSUM;
297     }
298 }
299
300
301 gcry_err_code_t
302 _gcry_cipher_ccm_get_tag (gcry_cipher_hd_t c, unsigned char *outtag,
303                           size_t taglen)
304 {
305   return _gcry_cipher_ccm_tag (c, outtag, taglen, 0);
306 }
307
308
309 gcry_err_code_t
310 _gcry_cipher_ccm_check_tag (gcry_cipher_hd_t c, const unsigned char *intag,
311                             size_t taglen)
312 {
313   return _gcry_cipher_ccm_tag (c, (unsigned char *)intag, taglen, 1);
314 }
315
316
317 gcry_err_code_t
318 _gcry_cipher_ccm_encrypt (gcry_cipher_hd_t c, unsigned char *outbuf,
319                           size_t outbuflen, const unsigned char *inbuf,
320                           size_t inbuflen)
321 {
322   gcry_err_code_t err = 0;
323   unsigned int burn = 0;
324   unsigned int nburn;
325
326   if (outbuflen < inbuflen)
327     return GPG_ERR_BUFFER_TOO_SHORT;
328   if (!c->u_mode.ccm.nonce || c->marks.tag || !c->u_mode.ccm.lengths ||
329       c->u_mode.ccm.aadlen > 0)
330     return GPG_ERR_INV_STATE;
331   if (inbuflen > c->u_mode.ccm.encryptlen)
332     return GPG_ERR_INV_LENGTH;
333
334   while (inbuflen)
335     {
336       size_t currlen = inbuflen;
337
338       /* Since checksumming is done before encryption, process input in 24KiB
339        * chunks to keep data loaded in L1 cache for encryption. */
340       if (currlen > 24 * 1024)
341         currlen = 24 * 1024;
342
343       c->u_mode.ccm.encryptlen -= currlen;
344       nburn = do_cbc_mac (c, inbuf, currlen, 0);
345       burn = nburn > burn ? nburn : burn;
346
347       err = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, currlen);
348       if (err)
349         break;
350
351       outbuf += currlen;
352       inbuf += currlen;
353       outbuflen -= currlen;
354       inbuflen -= currlen;
355     }
356
357   if (burn)
358     _gcry_burn_stack (burn + sizeof(void *) * 5);
359   return err;
360 }
361
362
363 gcry_err_code_t
364 _gcry_cipher_ccm_decrypt (gcry_cipher_hd_t c, unsigned char *outbuf,
365                           size_t outbuflen, const unsigned char *inbuf,
366                           size_t inbuflen)
367 {
368   gcry_err_code_t err = 0;
369   unsigned int burn = 0;
370   unsigned int nburn;
371
372   if (outbuflen < inbuflen)
373     return GPG_ERR_BUFFER_TOO_SHORT;
374   if (!c->u_mode.ccm.nonce || c->marks.tag || !c->u_mode.ccm.lengths ||
375       c->u_mode.ccm.aadlen > 0)
376     return GPG_ERR_INV_STATE;
377   if (inbuflen > c->u_mode.ccm.encryptlen)
378     return GPG_ERR_INV_LENGTH;
379
380   while (inbuflen)
381     {
382       size_t currlen = inbuflen;
383
384       /* Since checksumming is done after decryption, process input in 24KiB
385        * chunks to keep data loaded in L1 cache for checksumming. */
386       if (currlen > 24 * 1024)
387         currlen = 24 * 1024;
388
389       err = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, currlen);
390       if (err)
391         break;
392
393       c->u_mode.ccm.encryptlen -= currlen;
394       nburn = do_cbc_mac (c, outbuf, currlen, 0);
395       burn = nburn > burn ? nburn : burn;
396
397       outbuf += currlen;
398       inbuf += currlen;
399       outbuflen -= currlen;
400       inbuflen -= currlen;
401     }
402
403   if (burn)
404     _gcry_burn_stack (burn + sizeof(void *) * 5);
405   return err;
406 }