Use u64 for CCM data lengths
[libgcrypt.git] / cipher / cipher-ccm.c
1 /* cipher-ccm.c - CTR mode with CBC-MAC mode implementation
2  * Copyright © 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 "ath.h"
29 #include "bufhelp.h"
30 #include "./cipher-internal.h"
31
32 /* We need a 64 bit type for this code.  */
33 #ifdef HAVE_U64_TYPEDEF
34
35
36 #define set_burn(burn, nburn) do { \
37   unsigned int __nburn = (nburn); \
38   (burn) = (burn) > __nburn ? (burn) : __nburn; } while (0)
39
40
41 static unsigned int
42 do_cbc_mac (gcry_cipher_hd_t c, const unsigned char *inbuf, size_t inlen,
43             int do_padding)
44 {
45   const unsigned int blocksize = 16;
46   gcry_cipher_encrypt_t enc_fn = c->spec->encrypt;
47   unsigned char tmp[blocksize];
48   unsigned int burn = 0;
49   unsigned int unused = c->u_mode.ccm.mac_unused;
50   size_t nblocks;
51
52   if (inlen == 0 && (unused == 0 || !do_padding))
53     return 0;
54
55   do
56     {
57       if (inlen + unused < blocksize || unused > 0)
58         {
59           for (; inlen && unused < blocksize; inlen--)
60             c->u_mode.ccm.macbuf[unused++] = *inbuf++;
61         }
62       if (!inlen)
63         {
64           if (!do_padding)
65             break;
66
67           while (unused < blocksize)
68             c->u_mode.ccm.macbuf[unused++] = 0;
69         }
70
71       if (unused > 0)
72         {
73           /* Process one block from macbuf.  */
74           buf_xor(c->u_iv.iv, c->u_iv.iv, c->u_mode.ccm.macbuf, blocksize);
75           set_burn (burn, enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv ));
76
77           unused = 0;
78         }
79
80       if (c->bulk.cbc_enc)
81         {
82           nblocks = inlen / blocksize;
83           c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, tmp, inbuf, nblocks, 1);
84           inbuf += nblocks * blocksize;
85           inlen -= nblocks * blocksize;
86
87           wipememory (tmp, sizeof(tmp));
88         }
89       else
90         {
91           while (inlen >= blocksize)
92             {
93               buf_xor(c->u_iv.iv, c->u_iv.iv, inbuf, blocksize);
94
95               set_burn (burn, enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv ));
96
97               inlen -= blocksize;
98               inbuf += blocksize;
99             }
100         }
101     }
102   while (inlen > 0);
103
104   c->u_mode.ccm.mac_unused = unused;
105
106   if (burn)
107     burn += 4 * sizeof(void *);
108
109   return burn;
110 }
111
112
113 gcry_err_code_t
114 _gcry_cipher_ccm_set_nonce (gcry_cipher_hd_t c, const unsigned char *nonce,
115                             size_t noncelen)
116 {
117   size_t L = 15 - noncelen;
118   size_t L_;
119
120   L_ = L - 1;
121
122   if (!nonce)
123     return GPG_ERR_INV_ARG;
124   /* Length field must be 2, 3, ..., or 8. */
125   if (L < 2 || L > 8)
126     return GPG_ERR_INV_LENGTH;
127
128   /* Reset state */
129   memset (&c->u_mode, 0, sizeof(c->u_mode));
130   memset (&c->marks, 0, sizeof(c->marks));
131   memset (&c->u_iv, 0, sizeof(c->u_iv));
132   memset (&c->u_ctr, 0, sizeof(c->u_ctr));
133   memset (c->lastiv, 0, sizeof(c->lastiv));
134   c->unused = 0;
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       buf_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   unsigned int burn;
323
324   if (outbuflen < inbuflen)
325     return GPG_ERR_BUFFER_TOO_SHORT;
326   if (!c->u_mode.ccm.nonce || c->marks.tag || !c->u_mode.ccm.lengths ||
327       c->u_mode.ccm.aadlen > 0)
328     return GPG_ERR_INV_STATE;
329   if (inbuflen > c->u_mode.ccm.encryptlen)
330     return GPG_ERR_INV_LENGTH;
331
332   c->u_mode.ccm.encryptlen -= inbuflen;
333   burn = do_cbc_mac (c, inbuf, inbuflen, 0);
334   if (burn)
335     _gcry_burn_stack (burn + sizeof(void *) * 5);
336
337   return _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
338 }
339
340
341 gcry_err_code_t
342 _gcry_cipher_ccm_decrypt (gcry_cipher_hd_t c, unsigned char *outbuf,
343                           size_t outbuflen, const unsigned char *inbuf,
344                           size_t inbuflen)
345 {
346   gcry_err_code_t err;
347   unsigned int burn;
348
349   if (outbuflen < inbuflen)
350     return GPG_ERR_BUFFER_TOO_SHORT;
351   if (!c->u_mode.ccm.nonce || c->marks.tag || !c->u_mode.ccm.lengths ||
352       c->u_mode.ccm.aadlen > 0)
353     return GPG_ERR_INV_STATE;
354   if (inbuflen > c->u_mode.ccm.encryptlen)
355     return GPG_ERR_INV_LENGTH;
356
357   err = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
358   if (err)
359     return err;
360
361   c->u_mode.ccm.encryptlen -= inbuflen;
362   burn = do_cbc_mac (c, outbuf, inbuflen, 0);
363   if (burn)
364     _gcry_burn_stack (burn + sizeof(void *) * 5);
365
366   return err;
367 }
368
369 #else
370
371 /*
372  * Provide dummy functions so that we avoid adding too much #ifdefs in
373  * cipher.c.
374  */
375
376 gcry_err_code_t
377 _gcry_cipher_ccm_encrypt(gcry_cipher_hd_t c, unsigned char *outbuf,
378                          size_t outbuflen, const unsigned char *inbuf,
379                          size_t inbuflen)
380 {
381   (void)c;
382   (void)outbuf;
383   (void)outbuflen;
384   (void)inbuf;
385   (void)inbuflen;
386   return GPG_ERR_NOT_SUPPORTED;
387 }
388
389 gcry_err_code_t
390 _gcry_cipher_ccm_decrypt(gcry_cipher_hd_t c, unsigned char *outbuf,
391                          size_t outbuflen, const unsigned char *inbuf,
392                          size_t inbuflen)
393 {
394   (void)c;
395   (void)outbuf;
396   (void)outbuflen;
397   (void)inbuf;
398   (void)inbuflen;
399   return GPG_ERR_NOT_SUPPORTED;
400 }
401
402 gcry_err_code_t
403 _gcry_cipher_ccm_set_nonce(gcry_cipher_hd_t c, const unsigned char *nonce,
404                            size_t noncelen)
405 {
406   (void)c;
407   (void)nonce;
408   (void)noncelen;
409   return GPG_ERR_NOT_SUPPORTED;
410 }
411
412 gcry_err_code_t
413 _gcry_cipher_ccm_authenticate(gcry_cipher_hd_t c, const unsigned char *abuf,
414                               size_t abuflen)
415 {
416   (void)c;
417   (void)abuf;
418   (void)abuflen;
419   return GPG_ERR_NOT_SUPPORTED;
420 }
421
422 gcry_err_code_t
423 _gcry_cipher_ccm_get_tag(gcry_cipher_hd_t c, unsigned char *outtag,
424                          size_t taglen)
425 {
426   (void)c;
427   (void)outtag;
428   (void)taglen;
429   return GPG_ERR_NOT_SUPPORTED;
430 }
431
432 gcry_err_code_t
433 _gcry_cipher_ccm_check_tag(gcry_cipher_hd_t c, const unsigned char *intag,
434                            size_t taglen)
435 {
436   (void)c;
437   (void)intag;
438   (void)taglen;
439   return GPG_ERR_NOT_SUPPORTED;
440 }
441
442 #endif /*HAVE_U64_TYPEDEF*/