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