SHA-512: Add AVX and AVX2 implementations for x86-64
[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
33 #define set_burn(burn, nburn) do { \
34   unsigned int __nburn = (nburn); \
35   (burn) = (burn) > __nburn ? (burn) : __nburn; } while (0)
36
37
38 static unsigned int
39 do_cbc_mac (gcry_cipher_hd_t c, const unsigned char *inbuf, size_t inlen,
40             int do_padding)
41 {
42   const unsigned int blocksize = 16;
43   gcry_cipher_encrypt_t enc_fn = c->spec->encrypt;
44   unsigned char tmp[blocksize];
45   unsigned int burn = 0;
46   unsigned int unused = c->u_mode.ccm.mac_unused;
47   size_t nblocks;
48
49   if (inlen == 0 && (unused == 0 || !do_padding))
50     return 0;
51
52   do
53     {
54       if (inlen + unused < blocksize || unused > 0)
55         {
56           for (; inlen && unused < blocksize; inlen--)
57             c->u_mode.ccm.macbuf[unused++] = *inbuf++;
58         }
59       if (!inlen)
60         {
61           if (!do_padding)
62             break;
63
64           while (unused < blocksize)
65             c->u_mode.ccm.macbuf[unused++] = 0;
66         }
67
68       if (unused > 0)
69         {
70           /* Process one block from macbuf.  */
71           buf_xor(c->u_iv.iv, c->u_iv.iv, c->u_mode.ccm.macbuf, 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               buf_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   size_t L = 15 - noncelen;
115   size_t L_;
116
117   L_ = L - 1;
118
119   if (!nonce)
120     return GPG_ERR_INV_ARG;
121   /* Length field must be 2, 3, ..., or 8. */
122   if (L < 2 || L > 8)
123     return GPG_ERR_INV_LENGTH;
124
125   /* Reset state */
126   memset (&c->u_mode, 0, sizeof(c->u_mode));
127   memset (&c->marks, 0, sizeof(c->marks));
128   memset (&c->u_iv, 0, sizeof(c->u_iv));
129   memset (&c->u_ctr, 0, sizeof(c->u_ctr));
130   memset (c->lastiv, 0, sizeof(c->lastiv));
131   c->unused = 0;
132
133   /* Setup CTR */
134   c->u_ctr.ctr[0] = L_;
135   memcpy (&c->u_ctr.ctr[1], nonce, noncelen);
136   memset (&c->u_ctr.ctr[1 + noncelen], 0, L);
137
138   /* Setup IV */
139   c->u_iv.iv[0] = L_;
140   memcpy (&c->u_iv.iv[1], nonce, noncelen);
141   /* Add (8 * M_ + 64 * flags) to iv[0] and set iv[noncelen + 1 ... 15] later
142      in set_aad.  */
143   memset (&c->u_iv.iv[1 + noncelen], 0, L);
144
145   c->u_mode.ccm.nonce = 1;
146
147   return GPG_ERR_NO_ERROR;
148 }
149
150
151 gcry_err_code_t
152 _gcry_cipher_ccm_set_lengths (gcry_cipher_hd_t c, size_t encryptlen,
153                               size_t aadlen, size_t taglen)
154 {
155   unsigned int burn = 0;
156   unsigned char b0[16];
157   size_t noncelen = 15 - (c->u_iv.iv[0] + 1);
158   size_t M = taglen;
159   size_t M_;
160   int i;
161
162   M_ = (M - 2) / 2;
163
164   /* Authentication field must be 4, 6, 8, 10, 12, 14 or 16. */
165   if ((M_ * 2 + 2) != M || M < 4 || M > 16)
166     return GPG_ERR_INV_LENGTH;
167   if (!c->u_mode.ccm.nonce || c->marks.tag)
168     return GPG_ERR_INV_STATE;
169   if (c->u_mode.ccm.lengths)
170     return GPG_ERR_INV_STATE;
171
172   c->u_mode.ccm.authlen = taglen;
173   c->u_mode.ccm.encryptlen = encryptlen;
174   c->u_mode.ccm.aadlen = aadlen;
175
176   /* Complete IV setup.  */
177   c->u_iv.iv[0] += (aadlen > 0) * 64 + M_ * 8;
178   for (i = 16 - 1; i >= 1 + noncelen; i--)
179     {
180       c->u_iv.iv[i] = encryptlen & 0xff;
181       encryptlen >>= 8;
182     }
183
184   memcpy (b0, c->u_iv.iv, 16);
185   memset (c->u_iv.iv, 0, 16);
186
187   set_burn (burn, do_cbc_mac (c, b0, 16, 0));
188
189   if (aadlen == 0)
190     {
191       /* Do nothing.  */
192     }
193   else if (aadlen > 0 && aadlen <= (unsigned int)0xfeff)
194     {
195       b0[0] = (aadlen >> 8) & 0xff;
196       b0[1] = aadlen & 0xff;
197       set_burn (burn, do_cbc_mac (c, b0, 2, 0));
198     }
199   else if (aadlen > 0xfeff && aadlen <= (unsigned int)0xffffffff)
200     {
201       b0[0] = 0xff;
202       b0[1] = 0xfe;
203       buf_put_be32(&b0[2], aadlen);
204       set_burn (burn, do_cbc_mac (c, b0, 6, 0));
205     }
206 #ifdef HAVE_U64_TYPEDEF
207   else if (aadlen > (unsigned int)0xffffffff)
208     {
209       b0[0] = 0xff;
210       b0[1] = 0xff;
211       buf_put_be64(&b0[2], aadlen);
212       set_burn (burn, do_cbc_mac (c, b0, 10, 0));
213     }
214 #endif
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 }