gpg: Support EAX if for latest Libgcrypt.
[gnupg.git] / g10 / decrypt-data.c
1 /* decrypt-data.c - Decrypt an encrypted data packet
2  * Copyright (C) 1998-2001, 2005-2006, 2009 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2001, 2005-2006, 2009, 2018 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "gpg.h"
27 #include "../common/util.h"
28 #include "packet.h"
29 #include "options.h"
30 #include "../common/i18n.h"
31 #include "../common/status.h"
32 #include "../common/compliance.h"
33
34 /* FIXME: Libgcrypt 1.9 will support EAX.  Until we kame this a
35  * requirement we hardwire the enum used for EAX.  */
36 #define MY_GCRY_CIPHER_MODE_EAX 14
37
38
39 static int aead_decode_filter (void *opaque, int control, iobuf_t a,
40                                byte *buf, size_t *ret_len);
41 static int mdc_decode_filter ( void *opaque, int control, IOBUF a,
42                                byte *buf, size_t *ret_len);
43 static int decode_filter ( void *opaque, int control, IOBUF a,
44                                         byte *buf, size_t *ret_len);
45
46 /* Our context object.  */
47 struct decode_filter_context_s
48 {
49   /* Recounter (max value is 2).  We need it becuase we do not know
50    * whether the iobuf or the outer control code frees this object
51    * first.  */
52   int  refcount;
53
54   /* The cipher handle.  */
55   gcry_cipher_hd_t cipher_hd;
56
57   /* The hash handle for use in MDC mode.  */
58   gcry_md_hd_t mdc_hash;
59
60   /* The start IV for AEAD encryption.   */
61   byte startiv[16];
62
63   /* The holdback buffer.  For AEAD we need 32 bytes for MDC 22 bytes
64    * are enough.  The flag indicates whether the holdback buffer is
65    * filled. */
66   char defer[32];
67   unsigned int defer_filled : 1;
68
69   /* Working on a partial length packet.  */
70   unsigned int partial : 1;
71
72   /* EOF indicator with these true values:
73    *   1 = normal EOF
74    *   2 = premature EOF (tag incomplete)
75    *   3 = premature EOF (general)       */
76   unsigned int eof_seen : 2;
77
78   /* The actually used cipher algo for AEAD.  */
79   byte cipher_algo;
80
81   /* The AEAD algo.  */
82   byte aead_algo;
83
84   /* The encoded chunk byte for AEAD.  */
85   byte chunkbyte;
86
87   /* The decoded CHUNKBYTE.  */
88   uint64_t chunksize;
89
90   /* The chunk index for AEAD.  */
91   uint64_t chunkindex;
92
93   /* The number of bytes in the current chunk.  */
94   uint64_t chunklen;
95
96   /* The total count of decrypted plaintext octets.  */
97   uint64_t total;
98
99   /* Remaining bytes in the packet according to the packet header.
100    * Not used if PARTIAL is true.  */
101   size_t length;
102 };
103 typedef struct decode_filter_context_s *decode_filter_ctx_t;
104
105
106 /* Helper to release the decode context.  */
107 static void
108 release_dfx_context (decode_filter_ctx_t dfx)
109 {
110   if (!dfx)
111     return;
112
113   log_assert (dfx->refcount);
114   if ( !--dfx->refcount )
115     {
116       gcry_cipher_close (dfx->cipher_hd);
117       dfx->cipher_hd = NULL;
118       gcry_md_close (dfx->mdc_hash);
119       dfx->mdc_hash = NULL;
120       xfree (dfx);
121     }
122 }
123
124
125 /* Set the nonce for AEAD.  This also reset the decryption machinery
126  * so that the handle can be used for a new chunk.  */
127 static gpg_error_t
128 aead_set_nonce (decode_filter_ctx_t dfx)
129 {
130   unsigned char nonce[16];
131   int i;
132
133   switch (dfx->aead_algo)
134     {
135     case AEAD_ALGO_OCB:
136       memcpy (nonce, dfx->startiv, 15);
137       i = 7;
138       break;
139
140     case AEAD_ALGO_EAX:
141       memcpy (nonce, dfx->startiv, 16);
142       i = 8;
143       break;
144
145     default:
146       BUG ();
147     }
148   nonce[i++] ^= dfx->chunkindex >> 56;
149   nonce[i++] ^= dfx->chunkindex >> 48;
150   nonce[i++] ^= dfx->chunkindex >> 40;
151   nonce[i++] ^= dfx->chunkindex >> 32;
152   nonce[i++] ^= dfx->chunkindex >> 24;
153   nonce[i++] ^= dfx->chunkindex >> 16;
154   nonce[i++] ^= dfx->chunkindex >>  8;
155   nonce[i++] ^= dfx->chunkindex;
156
157   log_printhex (nonce, i, "nonce:");
158   return gcry_cipher_setiv (dfx->cipher_hd, nonce, i);
159 }
160
161
162 /* Set the additional data for the current chunk.  If FINAL is set the
163  * final AEAD chunk is processed.  */
164 static gpg_error_t
165 aead_set_ad (decode_filter_ctx_t dfx, int final)
166 {
167   unsigned char ad[21];
168
169   ad[0] = (0xc0 | PKT_ENCRYPTED_AEAD);
170   ad[1] = 1;
171   ad[2] = dfx->cipher_algo;
172   ad[3] = dfx->aead_algo;
173   ad[4] = dfx->chunkbyte;
174   ad[5] = dfx->chunkindex >> 56;
175   ad[6] = dfx->chunkindex >> 48;
176   ad[7] = dfx->chunkindex >> 40;
177   ad[8] = dfx->chunkindex >> 32;
178   ad[9] = dfx->chunkindex >> 24;
179   ad[10]= dfx->chunkindex >> 16;
180   ad[11]= dfx->chunkindex >>  8;
181   ad[12]= dfx->chunkindex;
182   if (final)
183     {
184       ad[13] = dfx->total >> 56;
185       ad[14] = dfx->total >> 48;
186       ad[15] = dfx->total >> 40;
187       ad[16] = dfx->total >> 32;
188       ad[17] = dfx->total >> 24;
189       ad[18] = dfx->total >> 16;
190       ad[19] = dfx->total >>  8;
191       ad[20] = dfx->total;
192     }
193   log_printhex (ad, final? 21 : 13, "authdata:");
194   return gcry_cipher_authenticate (dfx->cipher_hd, ad, final? 21 : 13);
195 }
196
197
198 /****************
199  * Decrypt the data, specified by ED with the key DEK.
200  */
201 int
202 decrypt_data (ctrl_t ctrl, void *procctx, PKT_encrypted *ed, DEK *dek)
203 {
204   decode_filter_ctx_t dfx;
205   byte *p;
206   int rc=0, c, i;
207   byte temp[32];
208   unsigned int blocksize;
209   unsigned int nprefix;
210
211   dfx = xtrycalloc (1, sizeof *dfx);
212   if (!dfx)
213     return gpg_error_from_syserror ();
214   dfx->refcount = 1;
215
216   if ( opt.verbose && !dek->algo_info_printed )
217     {
218       if (!openpgp_cipher_test_algo (dek->algo))
219         log_info (_("%s encrypted data\n"),
220                   openpgp_cipher_algo_name (dek->algo));
221       else
222         log_info (_("encrypted with unknown algorithm %d\n"), dek->algo );
223       dek->algo_info_printed = 1;
224     }
225
226   /* Check compliance.  */
227   if (! gnupg_cipher_is_allowed (opt.compliance, 0, dek->algo,
228                                  GCRY_CIPHER_MODE_CFB))
229     {
230       log_error (_("cipher algorithm '%s' may not be used in %s mode\n"),
231                  openpgp_cipher_algo_name (dek->algo),
232                  gnupg_compliance_option_string (opt.compliance));
233       rc = gpg_error (GPG_ERR_CIPHER_ALGO);
234       goto leave;
235     }
236
237   write_status_printf (STATUS_DECRYPTION_INFO, "%d %d %d",
238                        ed->mdc_method, dek->algo, ed->aead_algo);
239
240   if (opt.show_session_key)
241     {
242       char numbuf[30];
243       char *hexbuf;
244
245       if (ed->aead_algo)
246         snprintf (numbuf, sizeof numbuf, "%d.%u:", dek->algo, ed->aead_algo);
247       else
248         snprintf (numbuf, sizeof numbuf, "%d:", dek->algo);
249       hexbuf = bin2hex (dek->key, dek->keylen, NULL);
250       if (!hexbuf)
251         {
252           rc = gpg_error_from_syserror ();
253           goto leave;
254         }
255       log_info ("session key: '%s%s'\n", numbuf, hexbuf);
256       write_status_strings (STATUS_SESSION_KEY, numbuf, hexbuf, NULL);
257       xfree (hexbuf);
258     }
259
260   rc = openpgp_cipher_test_algo (dek->algo);
261   if (rc)
262     goto leave;
263   blocksize = openpgp_cipher_get_algo_blklen (dek->algo);
264   if ( !blocksize || blocksize > 16 )
265     log_fatal ("unsupported blocksize %u\n", blocksize );
266   if (ed->aead_algo)
267     {
268       enum gcry_cipher_modes ciphermode;
269       unsigned int startivlen;
270
271       if (blocksize != 16)
272         {
273           rc = gpg_error (GPG_ERR_CIPHER_ALGO);
274           goto leave;
275         }
276
277       switch (ed->aead_algo)
278         {
279         case AEAD_ALGO_OCB:
280           startivlen = 15;
281           ciphermode = GCRY_CIPHER_MODE_OCB;
282           break;
283         case AEAD_ALGO_EAX:
284           startivlen = 16;
285           ciphermode = MY_GCRY_CIPHER_MODE_EAX;
286           break;
287         default:
288           log_error ("unknown AEAD algo %d\n", ed->aead_algo);
289           rc = gpg_error (GPG_ERR_INV_CIPHER_MODE);
290           goto leave;
291         }
292       log_assert (startivlen <= sizeof dfx->startiv);
293
294       if (ed->chunkbyte != 10)
295         {
296           /* FIXME */
297           log_error ("unsupported chunkbyte %u\n", ed->chunkbyte);
298           rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
299           goto leave;
300         }
301
302       /* Read the Start-IV. */
303       if (ed->len)
304         {
305           for (i=0; i < startivlen && ed->len; i++, ed->len--)
306             {
307               if ((c=iobuf_get (ed->buf)) == -1)
308                 break;
309               dfx->startiv[i] = c;
310             }
311         }
312       else
313         {
314           for (i=0; i < startivlen; i++ )
315             if ( (c=iobuf_get (ed->buf)) == -1 )
316               break;
317             else
318               dfx->startiv[i] = c;
319         }
320       if (i != startivlen)
321         {
322           log_error ("Start-IV in AEAD packet too short (%d/%u)\n",
323                      i, startivlen);
324           rc = gpg_error (GPG_ERR_TOO_SHORT);
325           goto leave;
326         }
327
328       dfx->cipher_algo = ed->cipher_algo;
329       dfx->aead_algo = ed->aead_algo;
330       dfx->chunkbyte = ed->chunkbyte;
331       dfx->chunksize = (uint64_t)1 << (dfx->chunkbyte + 6);
332
333       if (dek->algo != dfx->cipher_algo)
334         log_info ("Note: different cipher algorithms used (%s/%s)\n",
335                   openpgp_cipher_algo_name (dek->algo),
336                   openpgp_cipher_algo_name (dfx->cipher_algo));
337
338       rc = openpgp_cipher_open (&dfx->cipher_hd,
339                                 dfx->cipher_algo,
340                                 ciphermode,
341                                 GCRY_CIPHER_SECURE);
342       if (rc)
343         goto leave; /* Should never happen.  */
344
345       log_printhex (dek->key, dek->keylen, "thekey:");
346       rc = gcry_cipher_setkey (dfx->cipher_hd, dek->key, dek->keylen);
347       if (gpg_err_code (rc) == GPG_ERR_WEAK_KEY)
348         {
349           log_info (_("WARNING: message was encrypted with"
350                       " a weak key in the symmetric cipher.\n"));
351           rc = 0;
352         }
353       else if (rc)
354         {
355           log_error("key setup failed: %s\n", gpg_strerror (rc));
356           goto leave;
357         }
358
359       if (!ed->buf)
360         {
361           log_error(_("problem handling encrypted packet\n"));
362           goto leave;
363         }
364
365       rc = aead_set_nonce (dfx);
366       if (rc)
367         goto leave;
368
369       rc = aead_set_ad (dfx, 0);
370       if (rc)
371         goto leave;
372
373     }
374   else /* CFB encryption.  */
375     {
376       nprefix = blocksize;
377       if ( ed->len && ed->len < (nprefix+2) )
378         {
379           /* An invalid message.  We can't check that during parsing
380              because we may not know the used cipher then.  */
381           rc = gpg_error (GPG_ERR_INV_PACKET);
382           goto leave;
383         }
384
385       if ( ed->mdc_method )
386         {
387           if (gcry_md_open (&dfx->mdc_hash, ed->mdc_method, 0 ))
388             BUG ();
389           if ( DBG_HASHING )
390             gcry_md_debug (dfx->mdc_hash, "checkmdc");
391         }
392
393       rc = openpgp_cipher_open (&dfx->cipher_hd, dek->algo,
394                                 GCRY_CIPHER_MODE_CFB,
395                                 (GCRY_CIPHER_SECURE
396                                  | ((ed->mdc_method || dek->algo >= 100)?
397                                     0 : GCRY_CIPHER_ENABLE_SYNC)));
398       if (rc)
399         {
400           /* We should never get an error here cause we already checked
401            * that the algorithm is available.  */
402           BUG();
403         }
404
405
406       /* log_hexdump( "thekey", dek->key, dek->keylen );*/
407       rc = gcry_cipher_setkey (dfx->cipher_hd, dek->key, dek->keylen);
408       if ( gpg_err_code (rc) == GPG_ERR_WEAK_KEY )
409         {
410           log_info(_("WARNING: message was encrypted with"
411                      " a weak key in the symmetric cipher.\n"));
412           rc=0;
413         }
414       else if( rc )
415         {
416           log_error("key setup failed: %s\n", gpg_strerror (rc) );
417           goto leave;
418         }
419
420       if (!ed->buf)
421         {
422           log_error(_("problem handling encrypted packet\n"));
423           goto leave;
424         }
425
426       gcry_cipher_setiv (dfx->cipher_hd, NULL, 0);
427
428       if ( ed->len )
429         {
430           for (i=0; i < (nprefix+2) && ed->len; i++, ed->len-- )
431             {
432               if ( (c=iobuf_get(ed->buf)) == -1 )
433                 break;
434               else
435                 temp[i] = c;
436             }
437         }
438       else
439         {
440           for (i=0; i < (nprefix+2); i++ )
441             if ( (c=iobuf_get(ed->buf)) == -1 )
442               break;
443             else
444               temp[i] = c;
445         }
446
447       gcry_cipher_decrypt (dfx->cipher_hd, temp, nprefix+2, NULL, 0);
448       gcry_cipher_sync (dfx->cipher_hd);
449       p = temp;
450       /* log_hexdump( "prefix", temp, nprefix+2 ); */
451       if (dek->symmetric
452           && (p[nprefix-2] != p[nprefix] || p[nprefix-1] != p[nprefix+1]) )
453         {
454           rc = gpg_error (GPG_ERR_BAD_KEY);
455           goto leave;
456         }
457
458       if ( dfx->mdc_hash )
459         gcry_md_write (dfx->mdc_hash, temp, nprefix+2);
460     }
461
462   dfx->refcount++;
463   dfx->partial = !!ed->is_partial;
464   dfx->length = ed->len;
465   if (ed->aead_algo)
466     iobuf_push_filter ( ed->buf, aead_decode_filter, dfx );
467   else if (ed->mdc_method)
468     iobuf_push_filter ( ed->buf, mdc_decode_filter, dfx );
469   else
470     iobuf_push_filter ( ed->buf, decode_filter, dfx );
471
472   if (opt.unwrap_encryption)
473     {
474       char *filename = NULL;
475       estream_t fp;
476       rc = get_output_file ("", 0, ed->buf, &filename, &fp);
477       if (! rc)
478         {
479           iobuf_t output = iobuf_esopen (fp, "w", 0);
480           armor_filter_context_t *afx = NULL;
481
482           if (opt.armor)
483             {
484               afx = new_armor_context ();
485               push_armor_filter (afx, output);
486             }
487
488           iobuf_copy (output, ed->buf);
489           if ((rc = iobuf_error (ed->buf)))
490             log_error (_("error reading '%s': %s\n"),
491                        filename, gpg_strerror (rc));
492           else if ((rc = iobuf_error (output)))
493             log_error (_("error writing '%s': %s\n"),
494                        filename, gpg_strerror (rc));
495
496           iobuf_close (output);
497           if (afx)
498             release_armor_context (afx);
499         }
500       xfree (filename);
501     }
502   else
503     proc_packets (ctrl, procctx, ed->buf );
504
505   ed->buf = NULL;
506   if (dfx->eof_seen > 1 )
507     rc = gpg_error (GPG_ERR_INV_PACKET);
508   else if ( ed->mdc_method )
509     {
510       /* We used to let parse-packet.c handle the MDC packet but this
511          turned out to be a problem with compressed packets: With old
512          style packets there is no length information available and
513          the decompressor uses an implicit end.  However we can't know
514          this implicit end beforehand (:-) and thus may feed the
515          decompressor with more bytes than actually needed.  It would
516          be possible to unread the extra bytes but due to our weird
517          iobuf system any unread is non reliable due to filters
518          already popped off.  The easy and sane solution is to care
519          about the MDC packet only here and never pass it to the
520          packet parser.  Fortunatley the OpenPGP spec requires a
521          strict format for the MDC packet so that we know that 22
522          bytes are appended.  */
523       int datalen = gcry_md_get_algo_dlen (ed->mdc_method);
524
525       log_assert (dfx->cipher_hd);
526       log_assert (dfx->mdc_hash);
527       gcry_cipher_decrypt (dfx->cipher_hd, dfx->defer, 22, NULL, 0);
528       gcry_md_write (dfx->mdc_hash, dfx->defer, 2);
529       gcry_md_final (dfx->mdc_hash);
530
531       if (   dfx->defer[0] != '\xd3'
532           || dfx->defer[1] != '\x14'
533           || datalen != 20
534           || memcmp (gcry_md_read (dfx->mdc_hash, 0), dfx->defer+2, datalen))
535         rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
536       /* log_printhex("MDC message:", dfx->defer, 22); */
537       /* log_printhex("MDC calc:", gcry_md_read (dfx->mdc_hash,0), datalen); */
538     }
539
540
541  leave:
542   release_dfx_context (dfx);
543   return rc;
544 }
545
546
547 /* The core of the AEAD decryption.  This is the underflow function of
548  * the aead_decode_filter.  */
549 static gpg_error_t
550 aead_underflow (decode_filter_ctx_t dfx, iobuf_t a, byte *buf, size_t *ret_len)
551 {
552   const size_t size = *ret_len; /* The initial length of BUF.  */
553   gpg_error_t err;
554   size_t n; /* Finally the number of decrypted bytes in BUF.  */
555   int c;
556
557   log_assert (size > 64); /* Our code requires at least this size.  */
558
559   /* Get at least 32 bytes and put it ahead in the buffer.  */
560   if (dfx->partial)
561     {
562       for (n=32; n < 64; n++)
563         {
564           if ((c = iobuf_get (a)) == -1)
565             break;
566           buf[n] = c;
567         }
568     }
569   else
570     {
571       for (n=32; n < 64 && dfx->length; n++, dfx->length--)
572         {
573           if ((c = iobuf_get (a)) == -1)
574             break; /* Premature EOF.  */
575           buf[n] = c;
576         }
577     }
578
579   if (n == 64)
580     {
581       /* We got 32 bytes from A which are good for the last chunk's
582        * auth tag and the final chunk's auth tag.  On the first time
583        * we don't have anything in the defer buffer and thus we move
584        * those 32 bytes to the start of the buffer.  All further calls
585        * will copy the deferred 32 bytes to the start of the
586        * buffer.  */
587       if (!dfx->defer_filled)
588         {
589           memcpy (buf, buf+32, 32);
590           n = 32;  /* Continue at this position.  */
591         }
592       else
593         {
594           memcpy (buf, dfx->defer, 32);
595         }
596
597       /* Now fill up the provided buffer.  */
598       if (dfx->partial)
599         {
600           for (; n < size; n++ )
601             {
602               if ((c = iobuf_get (a)) == -1)
603                 {
604                   dfx->eof_seen = 1; /* Normal EOF. */
605                   break;
606                 }
607               buf[n] = c;
608             }
609         }
610       else
611         {
612           for (; n < size && dfx->length; n++, dfx->length--)
613             {
614               c = iobuf_get (a);
615               if (c == -1)
616                 {
617                   dfx->eof_seen = 3; /* Premature EOF. */
618                   break;
619                 }
620               buf[n] = c;
621             }
622           if (!dfx->length)
623             dfx->eof_seen = 1; /* Normal EOF.  */
624         }
625
626       /* Move the trailing 32 bytes back to the defer buffer.  We
627        * got at least 64 bytes and thus a memmove is not needed.  */
628       n -= 32;
629       memcpy (dfx->defer, buf+n, 32);
630       dfx->defer_filled = 1;
631     }
632   else if (!dfx->defer_filled)
633     {
634       /* EOF seen but empty defer buffer.  This means that we did not
635        * read enough for the two auth tags.  */
636       n -= 32;
637       memcpy (buf, buf+32, n );
638       dfx->eof_seen = 2; /* EOF with incomplete tag.  */
639     }
640   else
641     {
642       /* EOF seen (i.e. read less than 32 bytes). */
643       memcpy (buf, dfx->defer, 32);
644       n -= 32;
645       memcpy (dfx->defer, buf+n, 32);
646       dfx->eof_seen = 1; /* Normal EOF. */
647     }
648
649   log_debug ("decrypt: chunklen=%ju total=%ju size=%zu n=%zu%s\n",
650              (uintmax_t)dfx->chunklen, (uintmax_t)dfx->total, size, n,
651              dfx->eof_seen? " eof":"");
652
653   /* Now decrypt the buffer.  */
654   if (n && dfx->eof_seen > 1)
655     {
656       err = gpg_error (GPG_ERR_TRUNCATED);
657     }
658   else if (!n)
659     {
660       log_assert (dfx->eof_seen);
661       err = gpg_error (GPG_ERR_EOF);
662     }
663   else
664     {
665       size_t off = 0;
666
667       if (dfx->chunklen + n >= dfx->chunksize)
668         {
669           size_t n0 = dfx->chunksize - dfx->chunklen;
670
671           log_debug ("chunksize will be reached: n0=%zu\n", n0);
672           gcry_cipher_final (dfx->cipher_hd);
673           err = gcry_cipher_decrypt (dfx->cipher_hd, buf, n0, NULL, 0);
674           if (err)
675             {
676               log_debug ("gcry_cipher_decrypt failed (1): %s\n",
677                          gpg_strerror (err));
678               goto leave;
679             }
680           /*log_printhex (buf, n, "buf:");*/
681           dfx->chunklen += n0;
682           dfx->total += n0;
683           off = n0;
684           n -= n0;
685
686           log_debug ("bytes left: %zu  off=%zu\n", n, off);
687           log_assert (n >= 16);
688           log_assert (dfx->defer_filled);
689           log_printhex (buf+off, 16, "tag:");
690           err = gcry_cipher_checktag (dfx->cipher_hd, buf + off, 16);
691           if (err)
692             {
693               log_debug ("gcry_cipher_checktag failed (1): %s\n",
694                          gpg_strerror (err));
695               /* Return Bad Signature like we do with MDC encryption. */
696               if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
697                 err = gpg_error (GPG_ERR_BAD_SIGNATURE);
698               goto leave;
699             }
700           /* Remove that tag from the output.  */
701           memmove (buf + off, buf + off + 16, n - 16);
702           n -= 16;
703
704           /* Prepare a new chunk.  */
705           dfx->chunklen = 0;
706           dfx->chunkindex++;
707           err = aead_set_nonce (dfx);
708           if (err)
709             goto leave;
710           err = aead_set_ad (dfx, 0);
711           if (err)
712             goto leave;
713         }
714
715       if (dfx->eof_seen)
716         {
717           /* This is the last block of the last chunk.  Its length may
718            * not be a multiple of the block length.  We expect that it
719            * is followed by two authtags.  The first being the one
720            * from the current chunk and the second form the final
721            * chunk encrypting the empty string.  Note that for the
722            * other blocks we assume a multiple of the block length
723            * which is only true because the filter is called with
724            * large 2^n sized buffers.  There is no assert because
725            * gcry_cipher_decrypt would detect such an error.  */
726           gcry_cipher_final (dfx->cipher_hd);
727           /*log_printhex (buf+off, n, "buf+off:");*/
728         }
729       err = gcry_cipher_decrypt (dfx->cipher_hd, buf + off, n, NULL, 0);
730       if (err)
731         {
732           log_debug ("gcry_cipher_decrypt failed (2): %s\n",gpg_strerror (err));
733           goto leave;
734         }
735       dfx->chunklen += n;
736       dfx->total += n;
737
738       if (dfx->eof_seen)
739         {
740           /* log_printhex (buf+off, n, "buf+off:"); */
741           log_debug ("eof seen: chunklen=%ju total=%ju off=%zu n=%zu\n",
742                      (uintmax_t)dfx->chunklen, (uintmax_t)dfx->total, off, n);
743
744           log_assert (dfx->defer_filled);
745           err = gcry_cipher_checktag (dfx->cipher_hd, dfx->defer, 16);
746           if (err)
747             {
748               log_debug ("gcry_cipher_checktag failed (2): %s\n",
749                          gpg_strerror (err));
750               /* Return Bad Signature like we do with MDC encryption. */
751               if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
752                 err = gpg_error (GPG_ERR_BAD_SIGNATURE);
753               goto leave;
754             }
755
756           /* Check the final chunk.  */
757           dfx->chunkindex++;
758           err = aead_set_nonce (dfx);
759           if (err)
760             goto leave;
761           err = aead_set_ad (dfx, 1);
762           if (err)
763             goto leave;
764           gcry_cipher_final (dfx->cipher_hd);
765           /* decrypt an empty string.  */
766           err = gcry_cipher_decrypt (dfx->cipher_hd, buf, 0, NULL, 0);
767           if (err)
768             {
769               log_debug ("gcry_cipher_decrypt failed (final): %s\n",
770                          gpg_strerror (err));
771               goto leave;
772             }
773           err = gcry_cipher_checktag (dfx->cipher_hd, dfx->defer+16, 16);
774           if (err)
775             {
776               log_debug ("gcry_cipher_checktag failed (final): %s\n",
777                          gpg_strerror (err));
778               /* Return Bad Signature like we do with MDC encryption. */
779               if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
780                 err = gpg_error (GPG_ERR_BAD_SIGNATURE);
781               goto leave;
782             }
783
784           n += off;
785           log_debug ("eof seen: returning %zu\n", n);
786           /* log_printhex (buf, n, "buf:"); */
787         }
788       else
789         n += off;
790     }
791
792  leave:
793   /* In case of a real error we better wipe out the buffer than to
794    * keep partly encrypted data.  */
795   if (err && gpg_err_code (err) != GPG_ERR_EOF)
796     memset (buf, 0, size);
797   *ret_len = n;
798
799   return err;
800 }
801
802
803 /* The IOBUF filter used to decrypt AEAD encrypted data.  */
804 static int
805 aead_decode_filter (void *opaque, int control, IOBUF a,
806                     byte *buf, size_t *ret_len)
807 {
808   decode_filter_ctx_t dfx = opaque;
809   int rc = 0;
810
811   if ( control == IOBUFCTRL_UNDERFLOW && dfx->eof_seen )
812     {
813       *ret_len = 0;
814       rc = -1;
815     }
816   else if ( control == IOBUFCTRL_UNDERFLOW )
817     {
818       log_assert (a);
819
820       rc = aead_underflow (dfx, a, buf, ret_len);
821       if (gpg_err_code (rc) == GPG_ERR_EOF)
822         rc = -1; /* We need to use the old convention in the filter.  */
823
824     }
825   else if ( control == IOBUFCTRL_FREE )
826     {
827       release_dfx_context (dfx);
828     }
829   else if ( control == IOBUFCTRL_DESC )
830     {
831       mem2str (buf, "aead_decode_filter", *ret_len);
832     }
833
834   return rc;
835 }
836
837
838 static int
839 mdc_decode_filter (void *opaque, int control, IOBUF a,
840                    byte *buf, size_t *ret_len)
841 {
842   decode_filter_ctx_t dfx = opaque;
843   size_t n, size = *ret_len;
844   int rc = 0;
845   int c;
846
847   /* Note: We need to distinguish between a partial and a fixed length
848      packet.  The first is the usual case as created by GPG.  However
849      for short messages the format degrades to a fixed length packet
850      and other implementations might use fixed length as well.  Only
851      looking for the EOF on fixed data works only if the encrypted
852      packet is not followed by other data.  This used to be a long
853      standing bug which was fixed on 2009-10-02.  */
854
855   if ( control == IOBUFCTRL_UNDERFLOW && dfx->eof_seen )
856     {
857       *ret_len = 0;
858       rc = -1;
859     }
860   else if( control == IOBUFCTRL_UNDERFLOW )
861     {
862       log_assert (a);
863       log_assert (size > 44); /* Our code requires at least this size.  */
864
865       /* Get at least 22 bytes and put it ahead in the buffer.  */
866       if (dfx->partial)
867         {
868           for (n=22; n < 44; n++)
869             {
870               if ( (c = iobuf_get(a)) == -1 )
871                 break;
872               buf[n] = c;
873             }
874         }
875       else
876         {
877           for (n=22; n < 44 && dfx->length; n++, dfx->length--)
878             {
879               c = iobuf_get (a);
880               if (c == -1)
881                 break; /* Premature EOF.  */
882               buf[n] = c;
883             }
884         }
885       if (n == 44)
886         {
887           /* We have enough stuff - flush the deferred stuff.  */
888           if ( !dfx->defer_filled )  /* First time. */
889             {
890               memcpy (buf, buf+22, 22);
891               n = 22;
892             }
893           else
894             {
895
896               memcpy (buf, dfx->defer, 22);
897             }
898           /* Fill up the buffer. */
899           if (dfx->partial)
900             {
901               for (; n < size; n++ )
902                 {
903                   if ( (c = iobuf_get(a)) == -1 )
904                     {
905                       dfx->eof_seen = 1; /* Normal EOF. */
906                       break;
907                     }
908                   buf[n] = c;
909                 }
910             }
911           else
912             {
913               for (; n < size && dfx->length; n++, dfx->length--)
914                 {
915                   c = iobuf_get(a);
916                   if (c == -1)
917                     {
918                       dfx->eof_seen = 3; /* Premature EOF. */
919                       break;
920                     }
921                   buf[n] = c;
922                 }
923               if (!dfx->length)
924                 dfx->eof_seen = 1; /* Normal EOF.  */
925             }
926
927           /* Move the trailing 22 bytes back to the defer buffer.  We
928              have at least 44 bytes thus a memmove is not needed.  */
929           n -= 22;
930           memcpy (dfx->defer, buf+n, 22 );
931           dfx->defer_filled = 1;
932         }
933       else if ( !dfx->defer_filled )  /* EOF seen but empty defer buffer. */
934         {
935           /* This is bad because it means an incomplete hash. */
936           n -= 22;
937           memcpy (buf, buf+22, n );
938           dfx->eof_seen = 2; /* EOF with incomplete hash.  */
939         }
940       else  /* EOF seen (i.e. read less than 22 bytes). */
941         {
942           memcpy (buf, dfx->defer, 22 );
943           n -= 22;
944           memcpy (dfx->defer, buf+n, 22 );
945           dfx->eof_seen = 1; /* Normal EOF. */
946         }
947
948       if ( n )
949         {
950           if ( dfx->cipher_hd )
951             gcry_cipher_decrypt (dfx->cipher_hd, buf, n, NULL, 0);
952           if ( dfx->mdc_hash )
953             gcry_md_write (dfx->mdc_hash, buf, n);
954         }
955       else
956         {
957           log_assert ( dfx->eof_seen );
958           rc = -1; /* Return EOF.  */
959         }
960       *ret_len = n;
961     }
962   else if ( control == IOBUFCTRL_FREE )
963     {
964       release_dfx_context (dfx);
965     }
966   else if ( control == IOBUFCTRL_DESC )
967     {
968       mem2str (buf, "mdc_decode_filter", *ret_len);
969     }
970   return rc;
971 }
972
973
974 static int
975 decode_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len)
976 {
977   decode_filter_ctx_t fc = opaque;
978   size_t size = *ret_len;
979   size_t n;
980   int c, rc = 0;
981
982
983   if ( control == IOBUFCTRL_UNDERFLOW && fc->eof_seen )
984     {
985       *ret_len = 0;
986       rc = -1;
987     }
988   else if ( control == IOBUFCTRL_UNDERFLOW )
989     {
990       log_assert (a);
991
992       if (fc->partial)
993         {
994           for (n=0; n < size; n++ )
995             {
996               c = iobuf_get(a);
997               if (c == -1)
998                 {
999                   fc->eof_seen = 1; /* Normal EOF. */
1000                   break;
1001                 }
1002               buf[n] = c;
1003             }
1004         }
1005       else
1006         {
1007           for (n=0; n < size && fc->length; n++, fc->length--)
1008             {
1009               c = iobuf_get(a);
1010               if (c == -1)
1011                 {
1012                   fc->eof_seen = 3; /* Premature EOF. */
1013                   break;
1014                 }
1015               buf[n] = c;
1016             }
1017           if (!fc->length)
1018             fc->eof_seen = 1; /* Normal EOF.  */
1019         }
1020       if (n)
1021         {
1022           if (fc->cipher_hd)
1023             gcry_cipher_decrypt (fc->cipher_hd, buf, n, NULL, 0);
1024         }
1025       else
1026         {
1027           if (!fc->eof_seen)
1028             fc->eof_seen = 1;
1029           rc = -1; /* Return EOF. */
1030         }
1031       *ret_len = n;
1032     }
1033   else if ( control == IOBUFCTRL_FREE )
1034     {
1035       release_dfx_context (fc);
1036     }
1037   else if ( control == IOBUFCTRL_DESC )
1038     {
1039       mem2str (buf, "decode_filter", *ret_len);
1040     }
1041   return rc;
1042 }