Reduce amount of duplicated code in OCB bulk implementations
[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                  _gcry_cipher_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 accidently 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                      _gcry_cipher_ocb_get_l (c, l_tmp,
396                                              c->u_mode.ocb.data_nblocks),
397                      OCB_BLOCK_LEN);
398           /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
399           buf_xor (outbuf, c->u_iv.iv, inbuf, OCB_BLOCK_LEN);
400           nburn = crypt_fn (&c->context.c, outbuf, outbuf);
401           burn = nburn > burn ? nburn : burn;
402           buf_xor_1 (outbuf, c->u_iv.iv, OCB_BLOCK_LEN);
403
404           inbuf += OCB_BLOCK_LEN;
405           inbuflen -= OCB_BLOCK_LEN;
406           outbuf += OCB_BLOCK_LEN;
407           outbuflen =- OCB_BLOCK_LEN;
408         }
409
410       if (!encrypt)
411         {
412           /* Checksum_i = Checksum_{i-1} xor P_i  */
413           ocb_checksum (c->u_ctr.ctr, outbuf - nblks * OCB_BLOCK_LEN, nblks);
414         }
415     }
416
417   /* Encrypt final partial block.  Note that we expect INBUFLEN to be
418      shorter than OCB_BLOCK_LEN (see above).  */
419   if (inbuflen)
420     {
421       unsigned char pad[OCB_BLOCK_LEN];
422
423       /* Offset_* = Offset_m xor L_*  */
424       buf_xor_1 (c->u_iv.iv, c->u_mode.ocb.L_star, OCB_BLOCK_LEN);
425       /* Pad = ENCIPHER(K, Offset_*) */
426       nburn = c->spec->encrypt (&c->context.c, pad, c->u_iv.iv);
427       burn = nburn > burn ? nburn : burn;
428
429       if (encrypt)
430         {
431           /* Checksum_* = Checksum_m xor (P_* || 1 || zeros(127-bitlen(P_*))) */
432           /* Note that INBUFLEN is less than OCB_BLOCK_LEN.  */
433           buf_cpy (l_tmp, inbuf, inbuflen);
434           memset (l_tmp + inbuflen, 0, OCB_BLOCK_LEN - inbuflen);
435           l_tmp[inbuflen] = 0x80;
436           buf_xor_1 (c->u_ctr.ctr, l_tmp, OCB_BLOCK_LEN);
437           /* C_* = P_* xor Pad[1..bitlen(P_*)] */
438           buf_xor (outbuf, inbuf, pad, inbuflen);
439         }
440       else
441         {
442           /* P_* = C_* xor Pad[1..bitlen(C_*)] */
443           /* Checksum_* = Checksum_m xor (P_* || 1 || zeros(127-bitlen(P_*))) */
444           buf_cpy (l_tmp, pad, OCB_BLOCK_LEN);
445           buf_cpy (l_tmp, inbuf, inbuflen);
446           buf_xor_1 (l_tmp, pad, OCB_BLOCK_LEN);
447           l_tmp[inbuflen] = 0x80;
448           buf_cpy (outbuf, l_tmp, inbuflen);
449
450           buf_xor_1 (c->u_ctr.ctr, l_tmp, OCB_BLOCK_LEN);
451         }
452     }
453
454   /* Compute the tag if the finalize flag has been set.  */
455   if (c->marks.finalize)
456     {
457       /* Tag = ENCIPHER(K, Checksum xor Offset xor L_$) xor HASH(K,A) */
458       buf_xor (c->u_mode.ocb.tag, c->u_ctr.ctr, c->u_iv.iv, OCB_BLOCK_LEN);
459       buf_xor_1 (c->u_mode.ocb.tag, c->u_mode.ocb.L_dollar, OCB_BLOCK_LEN);
460       nburn = c->spec->encrypt (&c->context.c,
461                                 c->u_mode.ocb.tag, c->u_mode.ocb.tag);
462       burn = nburn > burn ? nburn : burn;
463
464       c->u_mode.ocb.data_finalized = 1;
465       /* Note that the the final part of the tag computation is done
466          by _gcry_cipher_ocb_get_tag.  */
467     }
468
469   if (burn > 0)
470     _gcry_burn_stack (burn + 4*sizeof(void*));
471
472   return 0;
473 }
474
475
476 /* Encrypt (INBUF,INBUFLEN) in OCB mode to OUTBUF.  OUTBUFLEN gives
477    the allocated size of OUTBUF.  This function accepts only multiples
478    of a full block unless gcry_cipher_final has been called in which
479    case the next block may have any length.  */
480 gcry_err_code_t
481 _gcry_cipher_ocb_encrypt (gcry_cipher_hd_t c,
482                           unsigned char *outbuf, size_t outbuflen,
483                           const unsigned char *inbuf, size_t inbuflen)
484
485 {
486   return ocb_crypt (c, 1, outbuf, outbuflen, inbuf, inbuflen);
487 }
488
489
490 /* Decrypt (INBUF,INBUFLEN) in OCB mode to OUTBUF.  OUTBUFLEN gives
491    the allocated size of OUTBUF.  This function accepts only multiples
492    of a full block unless gcry_cipher_final has been called in which
493    case the next block may have any length.  */
494 gcry_err_code_t
495 _gcry_cipher_ocb_decrypt (gcry_cipher_hd_t c,
496                           unsigned char *outbuf, size_t outbuflen,
497                           const unsigned char *inbuf, size_t inbuflen)
498 {
499   return ocb_crypt (c, 0, outbuf, outbuflen, inbuf, inbuflen);
500 }
501
502
503 /* Compute the tag.  The last data operation has already done some
504    part of it.  To allow adding AAD even after having done all data,
505    we finish the tag computation only here.  */
506 static void
507 compute_tag_if_needed (gcry_cipher_hd_t c)
508 {
509   if (!c->marks.tag)
510     {
511       buf_xor_1 (c->u_mode.ocb.tag, c->u_mode.ocb.aad_sum, OCB_BLOCK_LEN);
512       c->marks.tag = 1;
513     }
514 }
515
516
517 /* Copy the already computed tag to OUTTAG.  OUTTAGSIZE is the
518    allocated size of OUTTAG; the function returns an error if that is
519    too short to hold the tag.  */
520 gcry_err_code_t
521 _gcry_cipher_ocb_get_tag (gcry_cipher_hd_t c,
522                           unsigned char *outtag, size_t outtagsize)
523 {
524   if (c->u_mode.ocb.taglen > outtagsize)
525     return GPG_ERR_BUFFER_TOO_SHORT;
526   if (!c->u_mode.ocb.data_finalized)
527     return GPG_ERR_INV_STATE; /* Data has not yet been finalized.  */
528
529   compute_tag_if_needed (c);
530
531   memcpy (outtag, c->u_mode.ocb.tag, c->u_mode.ocb.taglen);
532
533   return 0;
534 }
535
536
537 /* Check that the tag (INTAG,TAGLEN) matches the computed tag for the
538    handle C.  */
539 gcry_err_code_t
540 _gcry_cipher_ocb_check_tag (gcry_cipher_hd_t c, const unsigned char *intag,
541                             size_t taglen)
542 {
543   size_t n;
544
545   if (!c->u_mode.ocb.data_finalized)
546     return GPG_ERR_INV_STATE; /* Data has not yet been finalized.  */
547
548   compute_tag_if_needed (c);
549
550   n = c->u_mode.ocb.taglen;
551   if (taglen < n)
552     n = taglen;
553
554   if (!buf_eq_const (intag, c->u_mode.ocb.tag, n)
555       || c->u_mode.ocb.taglen != taglen)
556     return GPG_ERR_CHECKSUM;
557
558   return 0;
559 }