random: Take at max 25% from RDRAND
[libgcrypt.git] / cipher / cipher-ocb.c
1 /* cipher-ocb.c -  OCB cipher mode
2  * Copyright (C) 2015 g10 Code GmbH
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  * OCB is covered by several patents but may be used freely by most
21  * software.  See http://web.cs.ucdavis.edu/~rogaway/ocb/license.htm .
22  * In particular license 1 is suitable for Libgcrypt: See
23  * http://web.cs.ucdavis.edu/~rogaway/ocb/license1.pdf for the full
24  * license document; it basically says:
25  *
26  *   License 1 — License for Open-Source Software Implementations of OCB
27  *               (Jan 9, 2013)
28  *
29  *   Under this license, you are authorized to make, use, and
30  *   distribute open-source software implementations of OCB. This
31  *   license terminates for you if you sue someone over their
32  *   open-source software implementation of OCB claiming that you have
33  *   a patent covering their implementation.
34  */
35
36
37 #include <config.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <errno.h>
42
43 #include "g10lib.h"
44 #include "cipher.h"
45 #include "bufhelp.h"
46 #include "./cipher-internal.h"
47
48
49 /* Double the OCB_BLOCK_LEN sized block B in-place.  */
50 static inline void
51 double_block (unsigned char *b)
52 {
53 #if OCB_BLOCK_LEN != 16
54   unsigned char b_0 = b[0];
55   int i;
56
57   for (i=0; i < OCB_BLOCK_LEN - 1; i++)
58     b[i] = (b[i] << 1) | (b[i+1] >> 7);
59
60   b[OCB_BLOCK_LEN-1] = (b[OCB_BLOCK_LEN-1] << 1) ^ ((b_0 >> 7) * 135);
61 #else
62   /* This is the generic code for 16 byte blocks.  However it is not
63      faster than the straight byte by byte implementation.  */
64   u64 l_0, l, r;
65
66   l = buf_get_be64 (b);
67   r = buf_get_be64 (b + 8);
68
69   l_0 = (int64_t)l >> 63;
70   l = (l + l) ^ (r >> 63);
71   r = (r + r) ^ (l_0 & 135);
72
73   buf_put_be64 (b, l);
74   buf_put_be64 (b+8, r);
75 #endif
76 }
77
78
79 /* Double the OCB_BLOCK_LEN sized block S and store it at D.  S and D
80    may point to the same memory location but they may not overlap.  */
81 static void
82 double_block_cpy (unsigned char *d, const unsigned char *s)
83 {
84   if (d != s)
85     buf_cpy (d, s, OCB_BLOCK_LEN);
86   double_block (d);
87 }
88
89
90 /* Copy NBYTES from buffer S starting at bit offset BITOFF to buffer D.  */
91 static void
92 bit_copy (unsigned char *d, const unsigned char *s,
93           unsigned int bitoff, unsigned int nbytes)
94 {
95   unsigned int shift;
96
97   s += bitoff / 8;
98   shift = bitoff % 8;
99   if (shift)
100     {
101       for (; nbytes; nbytes--, d++, s++)
102         *d = (s[0] << shift) | (s[1] >> (8 - shift));
103     }
104   else
105     {
106       for (; nbytes; nbytes--, d++, s++)
107         *d = *s;
108     }
109 }
110
111
112 /* Return the L-value for block N.  In most cases we use the table;
113    only if the lower OCB_L_TABLE_SIZE bits of N are zero we need to
114    compute it.  With a table size of 16 we need to this this only
115    every 65536-th block.  L_TMP is a helper buffer of size
116    OCB_BLOCK_LEN which is used to hold the computation if not taken
117    from the table.  */
118 const unsigned char *
119 _gcry_cipher_ocb_get_l (gcry_cipher_hd_t c, unsigned char *l_tmp, u64 n)
120 {
121   int ntz = _gcry_ctz64 (n);
122
123   if (ntz < OCB_L_TABLE_SIZE)
124     return c->u_mode.ocb.L[ntz];
125
126   double_block_cpy (l_tmp, c->u_mode.ocb.L[OCB_L_TABLE_SIZE - 1]);
127   for (ntz -= OCB_L_TABLE_SIZE; ntz; ntz--)
128     double_block (l_tmp);
129
130   return l_tmp;
131 }
132
133
134 /* Set the nonce for OCB.  This requires that the key has been set.
135    Using it again resets start a new encryption cycle using the same
136    key.  */
137 gcry_err_code_t
138 _gcry_cipher_ocb_set_nonce (gcry_cipher_hd_t c, const unsigned char *nonce,
139                             size_t noncelen)
140 {
141   unsigned char ktop[OCB_BLOCK_LEN];
142   unsigned char stretch[OCB_BLOCK_LEN + 8];
143   unsigned int bottom;
144   int i;
145   unsigned int burn = 0;
146   unsigned int nburn;
147
148   /* Check args.  */
149   if (!c->marks.key)
150     return GPG_ERR_INV_STATE;  /* Key must have been set first.  */
151   switch (c->u_mode.ocb.taglen)
152     {
153     case 8:
154     case 12:
155     case 16:
156       break;
157     default:
158       return GPG_ERR_BUG; /* Invalid tag length. */
159     }
160
161   if (c->spec->blocksize != OCB_BLOCK_LEN)
162     return GPG_ERR_CIPHER_ALGO;
163   if (!nonce)
164     return GPG_ERR_INV_ARG;
165   /* 120 bit is the allowed maximum.  In addition we impose a minimum
166      of 64 bit.  */
167   if (noncelen > (120/8) || noncelen < (64/8) || noncelen >= OCB_BLOCK_LEN)
168     return GPG_ERR_INV_LENGTH;
169
170   /* Set up the L table.  */
171   /* L_star = E(zero_128) */
172   memset (ktop, 0, OCB_BLOCK_LEN);
173   nburn = c->spec->encrypt (&c->context.c, c->u_mode.ocb.L_star, ktop);
174   burn = nburn > burn ? nburn : burn;
175   /* L_dollar = double(L_star)  */
176   double_block_cpy (c->u_mode.ocb.L_dollar, c->u_mode.ocb.L_star);
177   /* L_0 = double(L_dollar), ...  */
178   double_block_cpy (c->u_mode.ocb.L[0], c->u_mode.ocb.L_dollar);
179   for (i = 1; i < OCB_L_TABLE_SIZE; i++)
180     double_block_cpy (c->u_mode.ocb.L[i], c->u_mode.ocb.L[i-1]);
181
182   /* Prepare the nonce.  */
183   memset (ktop, 0, (OCB_BLOCK_LEN - noncelen));
184   buf_cpy (ktop + (OCB_BLOCK_LEN - noncelen), nonce, noncelen);
185   ktop[0] = ((c->u_mode.ocb.taglen * 8) % 128) << 1;
186   ktop[OCB_BLOCK_LEN - noncelen - 1] |= 1;
187   bottom = ktop[OCB_BLOCK_LEN - 1] & 0x3f;
188   ktop[OCB_BLOCK_LEN - 1] &= 0xc0; /* Zero the bottom bits.  */
189   nburn = c->spec->encrypt (&c->context.c, ktop, ktop);
190   burn = nburn > burn ? nburn : burn;
191   /* Stretch = Ktop || (Ktop[1..64] xor Ktop[9..72]) */
192   buf_cpy (stretch, ktop, OCB_BLOCK_LEN);
193   buf_xor (stretch + OCB_BLOCK_LEN, ktop, ktop + 1, 8);
194   /* Offset_0 = Stretch[1+bottom..128+bottom]
195      (We use the IV field to store the offset) */
196   bit_copy (c->u_iv.iv, stretch, bottom, OCB_BLOCK_LEN);
197   c->marks.iv = 1;
198
199   /* Checksum_0 = zeros(128)
200      (We use the CTR field to store the checksum) */
201   memset (c->u_ctr.ctr, 0, OCB_BLOCK_LEN);
202
203   /* Clear AAD buffer.  */
204   memset (c->u_mode.ocb.aad_offset, 0, OCB_BLOCK_LEN);
205   memset (c->u_mode.ocb.aad_sum, 0, OCB_BLOCK_LEN);
206
207   /* Setup other values.  */
208   memset (c->lastiv, 0, sizeof(c->lastiv));
209   c->unused = 0;
210   c->marks.tag = 0;
211   c->marks.finalize = 0;
212   c->u_mode.ocb.data_nblocks = 0;
213   c->u_mode.ocb.aad_nblocks = 0;
214   c->u_mode.ocb.data_finalized = 0;
215   c->u_mode.ocb.aad_finalized = 0;
216
217   /* log_printhex ("L_*       ", c->u_mode.ocb.L_star, OCB_BLOCK_LEN); */
218   /* log_printhex ("L_$       ", c->u_mode.ocb.L_dollar, OCB_BLOCK_LEN); */
219   /* log_printhex ("L_0       ", c->u_mode.ocb.L[0], OCB_BLOCK_LEN); */
220   /* log_printhex ("L_1       ", c->u_mode.ocb.L[1], OCB_BLOCK_LEN); */
221   /* log_debug (   "bottom    : %u (decimal)\n", bottom); */
222   /* log_printhex ("Ktop      ", ktop, OCB_BLOCK_LEN); */
223   /* log_printhex ("Stretch   ", stretch, sizeof stretch); */
224   /* log_printhex ("Offset_0  ", c->u_iv.iv, OCB_BLOCK_LEN); */
225
226   /* Cleanup */
227   wipememory (ktop, sizeof ktop);
228   wipememory (stretch, sizeof stretch);
229   if (burn > 0)
230     _gcry_burn_stack (burn + 4*sizeof(void*));
231
232   return 0;
233 }
234
235
236 /* Process additional authentication data.  This implementation allows
237    to add additional authentication data at any time before the final
238    gcry_cipher_gettag.  The size of the data provided in
239    (ABUF,ABUFLEN) must be a multiple of the blocksize.  If a
240    non-multiple of the blocksize is used no further data may be passed
241    to this function.  */
242 gcry_err_code_t
243 _gcry_cipher_ocb_authenticate (gcry_cipher_hd_t c, const unsigned char *abuf,
244                                size_t abuflen)
245 {
246   unsigned char l_tmp[OCB_BLOCK_LEN];
247
248   /* Check that a nonce and thus a key has been set and that we have
249      not yet computed the tag.  We also return an error if the aad has
250      been finalized (i.e. a short block has been processed).  */
251   if (!c->marks.iv || c->marks.tag || c->u_mode.ocb.aad_finalized)
252     return GPG_ERR_INV_STATE;
253
254   /* Check correct usage and arguments.  */
255   if (c->spec->blocksize != OCB_BLOCK_LEN)
256     return GPG_ERR_CIPHER_ALGO;
257   if (!abuflen)
258     return 0;
259
260   /* Use a bulk method if available.  */
261   if (abuflen >= OCB_BLOCK_LEN && c->bulk.ocb_auth)
262     {
263       size_t nblks;
264       size_t nleft;
265       size_t ndone;
266
267       nblks = abuflen / OCB_BLOCK_LEN;
268       nleft = c->bulk.ocb_auth (c, abuf, nblks);
269       ndone = nblks - nleft;
270
271       abuf += ndone * OCB_BLOCK_LEN;
272       abuflen -= ndone * OCB_BLOCK_LEN;
273       nblks = nleft;
274     }
275
276   /* Hash all full blocks.  */
277   while (abuflen >= OCB_BLOCK_LEN)
278     {
279       c->u_mode.ocb.aad_nblocks++;
280
281       /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
282       buf_xor_1 (c->u_mode.ocb.aad_offset,
283                  ocb_get_l (c, l_tmp, c->u_mode.ocb.aad_nblocks),
284                  OCB_BLOCK_LEN);
285       /* Sum_i = Sum_{i-1} xor ENCIPHER(K, A_i xor Offset_i)  */
286       buf_xor (l_tmp, c->u_mode.ocb.aad_offset, abuf, OCB_BLOCK_LEN);
287       c->spec->encrypt (&c->context.c, l_tmp, l_tmp);
288       buf_xor_1 (c->u_mode.ocb.aad_sum, l_tmp, OCB_BLOCK_LEN);
289
290       abuf += OCB_BLOCK_LEN;
291       abuflen -= OCB_BLOCK_LEN;
292     }
293
294   /* Hash final partial block.  Note that we expect ABUFLEN to be
295      shorter than OCB_BLOCK_LEN.  */
296   if (abuflen)
297     {
298       /* Offset_* = Offset_m xor L_*  */
299       buf_xor_1 (c->u_mode.ocb.aad_offset,
300                  c->u_mode.ocb.L_star, OCB_BLOCK_LEN);
301       /* CipherInput = (A_* || 1 || zeros(127-bitlen(A_*))) xor Offset_*  */
302       buf_cpy (l_tmp, abuf, abuflen);
303       memset (l_tmp + abuflen, 0, OCB_BLOCK_LEN - abuflen);
304       l_tmp[abuflen] = 0x80;
305       buf_xor_1 (l_tmp, c->u_mode.ocb.aad_offset, OCB_BLOCK_LEN);
306       /* Sum = Sum_m xor ENCIPHER(K, CipherInput)  */
307       c->spec->encrypt (&c->context.c, l_tmp, l_tmp);
308       buf_xor_1 (c->u_mode.ocb.aad_sum, l_tmp, OCB_BLOCK_LEN);
309
310       /* Mark AAD as finalized to avoid accidentally calling this
311          function again after a non-full block has been processed.  */
312       c->u_mode.ocb.aad_finalized = 1;
313     }
314
315   return 0;
316 }
317
318
319 /* Checksumming for encrypt and decrypt.  */
320 static void
321 ocb_checksum (unsigned char *chksum, const unsigned char *plainbuf,
322               size_t nblks)
323 {
324   while (nblks > 0)
325     {
326       /* Checksum_i = Checksum_{i-1} xor P_i  */
327       buf_xor_1(chksum, plainbuf, OCB_BLOCK_LEN);
328
329       plainbuf += OCB_BLOCK_LEN;
330       nblks--;
331     }
332 }
333
334
335 /* Common code for encrypt and decrypt.  */
336 static gcry_err_code_t
337 ocb_crypt (gcry_cipher_hd_t c, int encrypt,
338            unsigned char *outbuf, size_t outbuflen,
339            const unsigned char *inbuf, size_t inbuflen)
340 {
341   unsigned char l_tmp[OCB_BLOCK_LEN];
342   unsigned int burn = 0;
343   unsigned int nburn;
344   size_t nblks = inbuflen / OCB_BLOCK_LEN;
345
346   /* Check that a nonce and thus a key has been set and that we are
347      not yet in end of data state. */
348   if (!c->marks.iv || c->u_mode.ocb.data_finalized)
349     return GPG_ERR_INV_STATE;
350
351   /* Check correct usage and arguments.  */
352   if (c->spec->blocksize != OCB_BLOCK_LEN)
353     return GPG_ERR_CIPHER_ALGO;
354   if (outbuflen < inbuflen)
355     return GPG_ERR_BUFFER_TOO_SHORT;
356   if (c->marks.finalize)
357     ; /* Allow arbitarty length. */
358   else if ((inbuflen % OCB_BLOCK_LEN))
359     return GPG_ERR_INV_LENGTH;  /* We support only full blocks for now.  */
360
361   /* Use a bulk method if available.  */
362   if (nblks && c->bulk.ocb_crypt)
363     {
364       size_t nleft;
365       size_t ndone;
366
367       nleft = c->bulk.ocb_crypt (c, outbuf, inbuf, nblks, encrypt);
368       ndone = nblks - nleft;
369
370       inbuf += ndone * OCB_BLOCK_LEN;
371       outbuf += ndone * OCB_BLOCK_LEN;
372       inbuflen -= ndone * OCB_BLOCK_LEN;
373       outbuflen -= ndone * OCB_BLOCK_LEN;
374       nblks = nleft;
375     }
376
377   if (nblks)
378     {
379       gcry_cipher_encrypt_t crypt_fn =
380           encrypt ? c->spec->encrypt : c->spec->decrypt;
381
382       if (encrypt)
383         {
384           /* Checksum_i = Checksum_{i-1} xor P_i  */
385           ocb_checksum (c->u_ctr.ctr, inbuf, nblks);
386         }
387
388       /* Encrypt all full blocks.  */
389       while (inbuflen >= OCB_BLOCK_LEN)
390         {
391           c->u_mode.ocb.data_nblocks++;
392
393           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
394           buf_xor_1 (c->u_iv.iv,
395                      ocb_get_l (c, l_tmp, c->u_mode.ocb.data_nblocks),
396                      OCB_BLOCK_LEN);
397           /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
398           buf_xor (outbuf, c->u_iv.iv, inbuf, OCB_BLOCK_LEN);
399           nburn = crypt_fn (&c->context.c, outbuf, outbuf);
400           burn = nburn > burn ? nburn : burn;
401           buf_xor_1 (outbuf, c->u_iv.iv, OCB_BLOCK_LEN);
402
403           inbuf += OCB_BLOCK_LEN;
404           inbuflen -= OCB_BLOCK_LEN;
405           outbuf += OCB_BLOCK_LEN;
406           outbuflen =- OCB_BLOCK_LEN;
407         }
408
409       if (!encrypt)
410         {
411           /* Checksum_i = Checksum_{i-1} xor P_i  */
412           ocb_checksum (c->u_ctr.ctr, outbuf - nblks * OCB_BLOCK_LEN, nblks);
413         }
414     }
415
416   /* Encrypt final partial block.  Note that we expect INBUFLEN to be
417      shorter than OCB_BLOCK_LEN (see above).  */
418   if (inbuflen)
419     {
420       unsigned char pad[OCB_BLOCK_LEN];
421
422       /* Offset_* = Offset_m xor L_*  */
423       buf_xor_1 (c->u_iv.iv, c->u_mode.ocb.L_star, OCB_BLOCK_LEN);
424       /* Pad = ENCIPHER(K, Offset_*) */
425       nburn = c->spec->encrypt (&c->context.c, pad, c->u_iv.iv);
426       burn = nburn > burn ? nburn : burn;
427
428       if (encrypt)
429         {
430           /* Checksum_* = Checksum_m xor (P_* || 1 || zeros(127-bitlen(P_*))) */
431           /* Note that INBUFLEN is less than OCB_BLOCK_LEN.  */
432           buf_cpy (l_tmp, inbuf, inbuflen);
433           memset (l_tmp + inbuflen, 0, OCB_BLOCK_LEN - inbuflen);
434           l_tmp[inbuflen] = 0x80;
435           buf_xor_1 (c->u_ctr.ctr, l_tmp, OCB_BLOCK_LEN);
436           /* C_* = P_* xor Pad[1..bitlen(P_*)] */
437           buf_xor (outbuf, inbuf, pad, inbuflen);
438         }
439       else
440         {
441           /* P_* = C_* xor Pad[1..bitlen(C_*)] */
442           /* Checksum_* = Checksum_m xor (P_* || 1 || zeros(127-bitlen(P_*))) */
443           buf_cpy (l_tmp, pad, OCB_BLOCK_LEN);
444           buf_cpy (l_tmp, inbuf, inbuflen);
445           buf_xor_1 (l_tmp, pad, OCB_BLOCK_LEN);
446           l_tmp[inbuflen] = 0x80;
447           buf_cpy (outbuf, l_tmp, inbuflen);
448
449           buf_xor_1 (c->u_ctr.ctr, l_tmp, OCB_BLOCK_LEN);
450         }
451     }
452
453   /* Compute the tag if the finalize flag has been set.  */
454   if (c->marks.finalize)
455     {
456       /* Tag = ENCIPHER(K, Checksum xor Offset xor L_$) xor HASH(K,A) */
457       buf_xor (c->u_mode.ocb.tag, c->u_ctr.ctr, c->u_iv.iv, OCB_BLOCK_LEN);
458       buf_xor_1 (c->u_mode.ocb.tag, c->u_mode.ocb.L_dollar, OCB_BLOCK_LEN);
459       nburn = c->spec->encrypt (&c->context.c,
460                                 c->u_mode.ocb.tag, c->u_mode.ocb.tag);
461       burn = nburn > burn ? nburn : burn;
462
463       c->u_mode.ocb.data_finalized = 1;
464       /* Note that the the final part of the tag computation is done
465          by _gcry_cipher_ocb_get_tag.  */
466     }
467
468   if (burn > 0)
469     _gcry_burn_stack (burn + 4*sizeof(void*));
470
471   return 0;
472 }
473
474
475 /* Encrypt (INBUF,INBUFLEN) in OCB mode to OUTBUF.  OUTBUFLEN gives
476    the allocated size of OUTBUF.  This function accepts only multiples
477    of a full block unless gcry_cipher_final has been called in which
478    case the next block may have any length.  */
479 gcry_err_code_t
480 _gcry_cipher_ocb_encrypt (gcry_cipher_hd_t c,
481                           unsigned char *outbuf, size_t outbuflen,
482                           const unsigned char *inbuf, size_t inbuflen)
483
484 {
485   return ocb_crypt (c, 1, outbuf, outbuflen, inbuf, inbuflen);
486 }
487
488
489 /* Decrypt (INBUF,INBUFLEN) in OCB mode to OUTBUF.  OUTBUFLEN gives
490    the allocated size of OUTBUF.  This function accepts only multiples
491    of a full block unless gcry_cipher_final has been called in which
492    case the next block may have any length.  */
493 gcry_err_code_t
494 _gcry_cipher_ocb_decrypt (gcry_cipher_hd_t c,
495                           unsigned char *outbuf, size_t outbuflen,
496                           const unsigned char *inbuf, size_t inbuflen)
497 {
498   return ocb_crypt (c, 0, outbuf, outbuflen, inbuf, inbuflen);
499 }
500
501
502 /* Compute the tag.  The last data operation has already done some
503    part of it.  To allow adding AAD even after having done all data,
504    we finish the tag computation only here.  */
505 static void
506 compute_tag_if_needed (gcry_cipher_hd_t c)
507 {
508   if (!c->marks.tag)
509     {
510       buf_xor_1 (c->u_mode.ocb.tag, c->u_mode.ocb.aad_sum, OCB_BLOCK_LEN);
511       c->marks.tag = 1;
512     }
513 }
514
515
516 /* Copy the already computed tag to OUTTAG.  OUTTAGSIZE is the
517    allocated size of OUTTAG; the function returns an error if that is
518    too short to hold the tag.  */
519 gcry_err_code_t
520 _gcry_cipher_ocb_get_tag (gcry_cipher_hd_t c,
521                           unsigned char *outtag, size_t outtagsize)
522 {
523   if (c->u_mode.ocb.taglen > outtagsize)
524     return GPG_ERR_BUFFER_TOO_SHORT;
525   if (!c->u_mode.ocb.data_finalized)
526     return GPG_ERR_INV_STATE; /* Data has not yet been finalized.  */
527
528   compute_tag_if_needed (c);
529
530   memcpy (outtag, c->u_mode.ocb.tag, c->u_mode.ocb.taglen);
531
532   return 0;
533 }
534
535
536 /* Check that the tag (INTAG,TAGLEN) matches the computed tag for the
537    handle C.  */
538 gcry_err_code_t
539 _gcry_cipher_ocb_check_tag (gcry_cipher_hd_t c, const unsigned char *intag,
540                             size_t taglen)
541 {
542   size_t n;
543
544   if (!c->u_mode.ocb.data_finalized)
545     return GPG_ERR_INV_STATE; /* Data has not yet been finalized.  */
546
547   compute_tag_if_needed (c);
548
549   n = c->u_mode.ocb.taglen;
550   if (taglen < n)
551     n = taglen;
552
553   if (!buf_eq_const (intag, c->u_mode.ocb.tag, n)
554       || c->u_mode.ocb.taglen != taglen)
555     return GPG_ERR_CHECKSUM;
556
557   return 0;
558 }