mac: Fix gcry_mac_close to allow for a NULL handle.
[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 /* We need a 64 bit type for this code.  */
32 #ifdef HAVE_U64_TYPEDEF
33
34
35 #define set_burn(burn, nburn) do { \
36   unsigned int __nburn = (nburn); \
37   (burn) = (burn) > __nburn ? (burn) : __nburn; } while (0)
38
39
40 static unsigned int
41 do_cbc_mac (gcry_cipher_hd_t c, const unsigned char *inbuf, size_t inlen,
42             int do_padding)
43 {
44   const unsigned int blocksize = 16;
45   gcry_cipher_encrypt_t enc_fn = c->spec->encrypt;
46   unsigned char tmp[blocksize];
47   unsigned int burn = 0;
48   unsigned int unused = c->u_mode.ccm.mac_unused;
49   size_t nblocks;
50
51   if (inlen == 0 && (unused == 0 || !do_padding))
52     return 0;
53
54   do
55     {
56       if (inlen + unused < blocksize || unused > 0)
57         {
58           for (; inlen && unused < blocksize; inlen--)
59             c->u_mode.ccm.macbuf[unused++] = *inbuf++;
60         }
61       if (!inlen)
62         {
63           if (!do_padding)
64             break;
65
66           while (unused < blocksize)
67             c->u_mode.ccm.macbuf[unused++] = 0;
68         }
69
70       if (unused > 0)
71         {
72           /* Process one block from macbuf.  */
73           buf_xor(c->u_iv.iv, c->u_iv.iv, c->u_mode.ccm.macbuf, blocksize);
74           set_burn (burn, enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv ));
75
76           unused = 0;
77         }
78
79       if (c->bulk.cbc_enc)
80         {
81           nblocks = inlen / blocksize;
82           c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, tmp, inbuf, nblocks, 1);
83           inbuf += nblocks * blocksize;
84           inlen -= nblocks * blocksize;
85
86           wipememory (tmp, sizeof(tmp));
87         }
88       else
89         {
90           while (inlen >= blocksize)
91             {
92               buf_xor(c->u_iv.iv, c->u_iv.iv, inbuf, blocksize);
93
94               set_burn (burn, enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv ));
95
96               inlen -= blocksize;
97               inbuf += blocksize;
98             }
99         }
100     }
101   while (inlen > 0);
102
103   c->u_mode.ccm.mac_unused = unused;
104
105   if (burn)
106     burn += 4 * sizeof(void *);
107
108   return burn;
109 }
110
111
112 gcry_err_code_t
113 _gcry_cipher_ccm_set_nonce (gcry_cipher_hd_t c, const unsigned char *nonce,
114                             size_t noncelen)
115 {
116   size_t L = 15 - noncelen;
117   size_t L_;
118
119   L_ = L - 1;
120
121   if (!nonce)
122     return GPG_ERR_INV_ARG;
123   /* Length field must be 2, 3, ..., or 8. */
124   if (L < 2 || L > 8)
125     return GPG_ERR_INV_LENGTH;
126
127   /* Reset state */
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
135   /* Setup CTR */
136   c->u_ctr.ctr[0] = L_;
137   memcpy (&c->u_ctr.ctr[1], nonce, noncelen);
138   memset (&c->u_ctr.ctr[1 + noncelen], 0, L);
139
140   /* Setup IV */
141   c->u_iv.iv[0] = L_;
142   memcpy (&c->u_iv.iv[1], nonce, noncelen);
143   /* Add (8 * M_ + 64 * flags) to iv[0] and set iv[noncelen + 1 ... 15] later
144      in set_aad.  */
145   memset (&c->u_iv.iv[1 + noncelen], 0, L);
146
147   c->u_mode.ccm.nonce = 1;
148
149   return GPG_ERR_NO_ERROR;
150 }
151
152
153 gcry_err_code_t
154 _gcry_cipher_ccm_set_lengths (gcry_cipher_hd_t c, u64 encryptlen, u64 aadlen,
155                               u64 taglen)
156 {
157   unsigned int burn = 0;
158   unsigned char b0[16];
159   size_t noncelen = 15 - (c->u_iv.iv[0] + 1);
160   u64 M = taglen;
161   u64 M_;
162   int i;
163
164   M_ = (M - 2) / 2;
165
166   /* Authentication field must be 4, 6, 8, 10, 12, 14 or 16. */
167   if ((M_ * 2 + 2) != M || M < 4 || M > 16)
168     return GPG_ERR_INV_LENGTH;
169   if (!c->u_mode.ccm.nonce || c->marks.tag)
170     return GPG_ERR_INV_STATE;
171   if (c->u_mode.ccm.lengths)
172     return GPG_ERR_INV_STATE;
173
174   c->u_mode.ccm.authlen = taglen;
175   c->u_mode.ccm.encryptlen = encryptlen;
176   c->u_mode.ccm.aadlen = aadlen;
177
178   /* Complete IV setup.  */
179   c->u_iv.iv[0] += (aadlen > 0) * 64 + M_ * 8;
180   for (i = 16 - 1; i >= 1 + noncelen; i--)
181     {
182       c->u_iv.iv[i] = encryptlen & 0xff;
183       encryptlen >>= 8;
184     }
185
186   memcpy (b0, c->u_iv.iv, 16);
187   memset (c->u_iv.iv, 0, 16);
188
189   set_burn (burn, do_cbc_mac (c, b0, 16, 0));
190
191   if (aadlen == 0)
192     {
193       /* Do nothing.  */
194     }
195   else if (aadlen > 0 && aadlen <= (unsigned int)0xfeff)
196     {
197       b0[0] = (aadlen >> 8) & 0xff;
198       b0[1] = aadlen & 0xff;
199       set_burn (burn, do_cbc_mac (c, b0, 2, 0));
200     }
201   else if (aadlen > 0xfeff && aadlen <= (unsigned int)0xffffffff)
202     {
203       b0[0] = 0xff;
204       b0[1] = 0xfe;
205       buf_put_be32(&b0[2], aadlen);
206       set_burn (burn, do_cbc_mac (c, b0, 6, 0));
207     }
208   else if (aadlen > (unsigned int)0xffffffff)
209     {
210       b0[0] = 0xff;
211       b0[1] = 0xff;
212       buf_put_be64(&b0[2], aadlen);
213       set_burn (burn, do_cbc_mac (c, b0, 10, 0));
214     }
215
216   /* Generate S_0 and increase counter.  */
217   set_burn (burn, c->spec->encrypt ( &c->context.c, c->u_mode.ccm.s0,
218                                      c->u_ctr.ctr ));
219   c->u_ctr.ctr[15]++;
220
221   if (burn)
222     _gcry_burn_stack (burn + sizeof(void *) * 5);
223
224   c->u_mode.ccm.lengths = 1;
225
226   return GPG_ERR_NO_ERROR;
227 }
228
229
230 gcry_err_code_t
231 _gcry_cipher_ccm_authenticate (gcry_cipher_hd_t c, const unsigned char *abuf,
232                                size_t abuflen)
233 {
234   unsigned int burn;
235
236   if (abuflen > 0 && !abuf)
237     return GPG_ERR_INV_ARG;
238   if (!c->u_mode.ccm.nonce || !c->u_mode.ccm.lengths || c->marks.tag)
239     return GPG_ERR_INV_STATE;
240   if (abuflen > c->u_mode.ccm.aadlen)
241     return GPG_ERR_INV_LENGTH;
242
243   c->u_mode.ccm.aadlen -= abuflen;
244   burn = do_cbc_mac (c, abuf, abuflen, c->u_mode.ccm.aadlen == 0);
245
246   if (burn)
247     _gcry_burn_stack (burn + sizeof(void *) * 5);
248
249   return GPG_ERR_NO_ERROR;
250 }
251
252
253 gcry_err_code_t
254 _gcry_cipher_ccm_tag (gcry_cipher_hd_t c, unsigned char *outbuf,
255                       size_t outbuflen, int check)
256 {
257   unsigned int burn;
258
259   if (!outbuf || outbuflen == 0)
260     return GPG_ERR_INV_ARG;
261   /* Tag length must be same as initial authlen.  */
262   if (c->u_mode.ccm.authlen != outbuflen)
263     return GPG_ERR_INV_LENGTH;
264   if (!c->u_mode.ccm.nonce || !c->u_mode.ccm.lengths || c->u_mode.ccm.aadlen > 0)
265     return GPG_ERR_INV_STATE;
266   /* Initial encrypt length must match with length of actual data processed.  */
267   if (c->u_mode.ccm.encryptlen > 0)
268     return GPG_ERR_UNFINISHED;
269
270   if (!c->marks.tag)
271     {
272       burn = do_cbc_mac (c, NULL, 0, 1); /* Perform final padding.  */
273
274       /* Add S_0 */
275       buf_xor (c->u_iv.iv, c->u_iv.iv, c->u_mode.ccm.s0, 16);
276
277       wipememory (c->u_ctr.ctr, 16);
278       wipememory (c->u_mode.ccm.s0, 16);
279       wipememory (c->u_mode.ccm.macbuf, 16);
280
281       if (burn)
282         _gcry_burn_stack (burn + sizeof(void *) * 5);
283
284       c->marks.tag = 1;
285     }
286
287   if (!check)
288     {
289       memcpy (outbuf, c->u_iv.iv, outbuflen);
290       return GPG_ERR_NO_ERROR;
291     }
292   else
293     {
294       return buf_eq_const(outbuf, c->u_iv.iv, outbuflen) ?
295              GPG_ERR_NO_ERROR : GPG_ERR_CHECKSUM;
296     }
297 }
298
299
300 gcry_err_code_t
301 _gcry_cipher_ccm_get_tag (gcry_cipher_hd_t c, unsigned char *outtag,
302                           size_t taglen)
303 {
304   return _gcry_cipher_ccm_tag (c, outtag, taglen, 0);
305 }
306
307
308 gcry_err_code_t
309 _gcry_cipher_ccm_check_tag (gcry_cipher_hd_t c, const unsigned char *intag,
310                             size_t taglen)
311 {
312   return _gcry_cipher_ccm_tag (c, (unsigned char *)intag, taglen, 1);
313 }
314
315
316 gcry_err_code_t
317 _gcry_cipher_ccm_encrypt (gcry_cipher_hd_t c, unsigned char *outbuf,
318                           size_t outbuflen, const unsigned char *inbuf,
319                           size_t inbuflen)
320 {
321   unsigned int burn;
322
323   if (outbuflen < inbuflen)
324     return GPG_ERR_BUFFER_TOO_SHORT;
325   if (!c->u_mode.ccm.nonce || c->marks.tag || !c->u_mode.ccm.lengths ||
326       c->u_mode.ccm.aadlen > 0)
327     return GPG_ERR_INV_STATE;
328   if (inbuflen > c->u_mode.ccm.encryptlen)
329     return GPG_ERR_INV_LENGTH;
330
331   c->u_mode.ccm.encryptlen -= inbuflen;
332   burn = do_cbc_mac (c, inbuf, inbuflen, 0);
333   if (burn)
334     _gcry_burn_stack (burn + sizeof(void *) * 5);
335
336   return _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
337 }
338
339
340 gcry_err_code_t
341 _gcry_cipher_ccm_decrypt (gcry_cipher_hd_t c, unsigned char *outbuf,
342                           size_t outbuflen, const unsigned char *inbuf,
343                           size_t inbuflen)
344 {
345   gcry_err_code_t err;
346   unsigned int burn;
347
348   if (outbuflen < inbuflen)
349     return GPG_ERR_BUFFER_TOO_SHORT;
350   if (!c->u_mode.ccm.nonce || c->marks.tag || !c->u_mode.ccm.lengths ||
351       c->u_mode.ccm.aadlen > 0)
352     return GPG_ERR_INV_STATE;
353   if (inbuflen > c->u_mode.ccm.encryptlen)
354     return GPG_ERR_INV_LENGTH;
355
356   err = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
357   if (err)
358     return err;
359
360   c->u_mode.ccm.encryptlen -= inbuflen;
361   burn = do_cbc_mac (c, outbuf, inbuflen, 0);
362   if (burn)
363     _gcry_burn_stack (burn + sizeof(void *) * 5);
364
365   return err;
366 }
367
368 #else
369
370 /*
371  * Provide dummy functions so that we avoid adding too much #ifdefs in
372  * cipher.c.
373  */
374
375 gcry_err_code_t
376 _gcry_cipher_ccm_encrypt(gcry_cipher_hd_t c, unsigned char *outbuf,
377                          size_t outbuflen, const unsigned char *inbuf,
378                          size_t inbuflen)
379 {
380   (void)c;
381   (void)outbuf;
382   (void)outbuflen;
383   (void)inbuf;
384   (void)inbuflen;
385   return GPG_ERR_NOT_SUPPORTED;
386 }
387
388 gcry_err_code_t
389 _gcry_cipher_ccm_decrypt(gcry_cipher_hd_t c, unsigned char *outbuf,
390                          size_t outbuflen, const unsigned char *inbuf,
391                          size_t inbuflen)
392 {
393   (void)c;
394   (void)outbuf;
395   (void)outbuflen;
396   (void)inbuf;
397   (void)inbuflen;
398   return GPG_ERR_NOT_SUPPORTED;
399 }
400
401 gcry_err_code_t
402 _gcry_cipher_ccm_set_nonce(gcry_cipher_hd_t c, const unsigned char *nonce,
403                            size_t noncelen)
404 {
405   (void)c;
406   (void)nonce;
407   (void)noncelen;
408   return GPG_ERR_NOT_SUPPORTED;
409 }
410
411 gcry_err_code_t
412 _gcry_cipher_ccm_authenticate(gcry_cipher_hd_t c, const unsigned char *abuf,
413                               size_t abuflen)
414 {
415   (void)c;
416   (void)abuf;
417   (void)abuflen;
418   return GPG_ERR_NOT_SUPPORTED;
419 }
420
421 gcry_err_code_t
422 _gcry_cipher_ccm_get_tag(gcry_cipher_hd_t c, unsigned char *outtag,
423                          size_t taglen)
424 {
425   (void)c;
426   (void)outtag;
427   (void)taglen;
428   return GPG_ERR_NOT_SUPPORTED;
429 }
430
431 gcry_err_code_t
432 _gcry_cipher_ccm_check_tag(gcry_cipher_hd_t c, const unsigned char *intag,
433                            size_t taglen)
434 {
435   (void)c;
436   (void)intag;
437   (void)taglen;
438   return GPG_ERR_NOT_SUPPORTED;
439 }
440
441 #endif /*HAVE_U64_TYPEDEF*/