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