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