gpg: Rename a variable in decrypt-data for clarity.
[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 at
60    * least 32+1 byte for MDC 22 bytes are required.  */
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 initial length of BUF.  */
540   gpg_error_t err;
541   size_t n; /* Finally the number of decrypted bytes in BUF.  */
542   int c;
543
544   log_assert (size > 64); /* Our code requires at least this size.  */
545
546   /* Get at least 32 bytes and put it ahead in the buffer.  */
547   if (dfx->partial)
548     {
549       for (n=32; n < 64; n++)
550         {
551           if ((c = iobuf_get (a)) == -1)
552             break;
553           buf[n] = c;
554         }
555     }
556   else
557     {
558       for (n=32; n < 64 && dfx->length; n++, dfx->length--)
559         {
560           if ((c = iobuf_get (a)) == -1)
561             break; /* Premature EOF.  */
562           buf[n] = c;
563         }
564     }
565
566   if (n == 64)
567     {
568       /* We got 32 bytes from A which are good for the last chunk's
569        * auth tag and the final chunk's auth tag.  On the first time
570        * we don't have anything in the holdback buffer and thus we move
571        * those 32 bytes to the start of the buffer.  All further calls
572        * will copy the 32 bytes from the holdback buffer to the start of the
573        * buffer.  */
574       if (!dfx->holdbacklen)
575         {
576           memcpy (buf, buf+32, 32);
577           n = 32;  /* Continue at this position.  */
578         }
579       else
580         {
581           memcpy (buf, dfx->holdback, 32);
582         }
583
584       /* Now fill up the provided buffer.  */
585       if (dfx->partial)
586         {
587           for (; n < size; n++ )
588             {
589               if ((c = iobuf_get (a)) == -1)
590                 {
591                   dfx->eof_seen = 1; /* Normal EOF. */
592                   break;
593                 }
594               buf[n] = c;
595             }
596         }
597       else
598         {
599           for (; n < size && dfx->length; n++, dfx->length--)
600             {
601               c = iobuf_get (a);
602               if (c == -1)
603                 {
604                   dfx->eof_seen = 3; /* Premature EOF. */
605                   break;
606                 }
607               buf[n] = c;
608             }
609           if (!dfx->length)
610             dfx->eof_seen = 1; /* Normal EOF.  */
611         }
612
613       /* Move the trailing 32 bytes back to the holdback buffer.  We
614        * got at least 64 bytes and thus a memmove is not needed.  */
615       n -= 32;
616       memcpy (dfx->holdback, buf+n, 32);
617       dfx->holdbacklen = 32;
618     }
619   else if (!dfx->holdbacklen)
620     {
621       /* EOF seen but empty holdback buffer.  This means that we did
622        * not read enough for the two auth tags.  */
623       n -= 32;
624       memcpy (buf, buf+32, n );
625       dfx->eof_seen = 2; /* EOF with incomplete tag.  */
626     }
627   else
628     {
629       /* EOF seen (i.e. read less than 32 bytes). */
630       memcpy (buf, dfx->holdback, 32);
631       n -= 32;
632       memcpy (dfx->holdback, buf+n, 32);
633       dfx->eof_seen = 1; /* Normal EOF. */
634     }
635
636   if (DBG_FILTER)
637     log_debug ("decrypt: chunklen=%ju total=%ju size=%zu n=%zu%s\n",
638                (uintmax_t)dfx->chunklen, (uintmax_t)dfx->total, size, n,
639                dfx->eof_seen? " eof":"");
640
641   /* Now decrypt the buffer.  */
642   if (n && dfx->eof_seen > 1)
643     {
644       err = gpg_error (GPG_ERR_TRUNCATED);
645     }
646   else if (!n)
647     {
648       log_assert (dfx->eof_seen);
649       err = gpg_error (GPG_ERR_EOF);
650     }
651   else
652     {
653       size_t off = 0;
654
655       if (dfx->chunklen + n >= dfx->chunksize)
656         {
657           size_t n0 = dfx->chunksize - dfx->chunklen;
658
659           if (DBG_FILTER)
660             log_debug ("chunksize will be reached: n0=%zu\n", n0);
661           gcry_cipher_final (dfx->cipher_hd);
662           err = gcry_cipher_decrypt (dfx->cipher_hd, buf, n0, NULL, 0);
663           if (err)
664             {
665               log_error ("gcry_cipher_decrypt failed (1): %s\n",
666                          gpg_strerror (err));
667               goto leave;
668             }
669           /*log_printhex (buf, n, "buf:");*/
670           dfx->chunklen += n0;
671           dfx->total += n0;
672           off = n0;
673           n -= n0;
674
675           if (DBG_FILTER)
676             log_debug ("bytes left: %zu  off=%zu\n", n, off);
677           log_assert (n >= 16);
678           log_assert (dfx->holdbacklen);
679           if (DBG_CRYPTO)
680             log_printhex (buf+off, 16, "tag:");
681           err = gcry_cipher_checktag (dfx->cipher_hd, buf + off, 16);
682           if (err)
683             {
684               if (DBG_FILTER)
685                 log_debug ("gcry_cipher_checktag failed (1): %s\n",
686                            gpg_strerror (err));
687               /* Return Bad Signature like we do with MDC encryption. */
688               if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
689                 err = gpg_error (GPG_ERR_BAD_SIGNATURE);
690               goto leave;
691             }
692           /* Remove that tag from the output.  */
693           memmove (buf + off, buf + off + 16, n - 16);
694           n -= 16;
695
696           /* Prepare a new chunk.  */
697           dfx->chunklen = 0;
698           dfx->chunkindex++;
699           err = aead_set_nonce (dfx);
700           if (err)
701             goto leave;
702           err = aead_set_ad (dfx, 0);
703           if (err)
704             goto leave;
705         }
706
707       if (dfx->eof_seen)
708         {
709           /* This is the last block of the last chunk.  Its length may
710            * not be a multiple of the block length.  We expect that it
711            * is followed by two authtags.  The first being the one
712            * from the current chunk and the second form the final
713            * chunk encrypting the empty string.  Note that for the
714            * other blocks we assume a multiple of the block length
715            * which is only true because the filter is called with
716            * large 2^n sized buffers.  There is no assert because
717            * gcry_cipher_decrypt would detect such an error.  */
718           gcry_cipher_final (dfx->cipher_hd);
719           /* log_printhex (buf+off, n, "buf+off:"); */
720         }
721       err = gcry_cipher_decrypt (dfx->cipher_hd, buf + off, n, NULL, 0);
722       if (err)
723         {
724           log_error ("gcry_cipher_decrypt failed (2): %s\n",
725                      gpg_strerror (err));
726           goto leave;
727         }
728       dfx->chunklen += n;
729       dfx->total += n;
730
731       if (dfx->eof_seen)
732         {
733           log_printhex (buf+off, n, "buf+off:");
734           if (DBG_FILTER)
735             log_debug ("eof seen: chunklen=%ju total=%ju off=%zu n=%zu\n",
736                        (uintmax_t)dfx->chunklen, (uintmax_t)dfx->total, off, n);
737
738           log_assert (dfx->holdbacklen);
739           err = gcry_cipher_checktag (dfx->cipher_hd, dfx->holdback, 16);
740           if (err)
741             {
742               log_printhex (dfx->holdback, 16, "tag:");
743               log_error ("gcry_cipher_checktag failed (2): %s\n",
744                          gpg_strerror (err));
745               /* Return Bad Signature like we do with MDC encryption. */
746               if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
747                 err = gpg_error (GPG_ERR_BAD_SIGNATURE);
748               goto leave;
749             }
750
751           /* Check the final chunk.  */
752           dfx->chunkindex++;
753           err = aead_set_nonce (dfx);
754           if (err)
755             goto leave;
756           err = aead_set_ad (dfx, 1);
757           if (err)
758             goto leave;
759           gcry_cipher_final (dfx->cipher_hd);
760           /* decrypt an empty string.  */
761           err = gcry_cipher_decrypt (dfx->cipher_hd, buf, 0, NULL, 0);
762           if (err)
763             {
764               log_error ("gcry_cipher_decrypt failed (final): %s\n",
765                          gpg_strerror (err));
766               goto leave;
767             }
768           err = gcry_cipher_checktag (dfx->cipher_hd, dfx->holdback+16, 16);
769           if (err)
770             {
771               if (DBG_FILTER)
772                 log_debug ("gcry_cipher_checktag failed (final): %s\n",
773                            gpg_strerror (err));
774               /* Return Bad Signature like we do with MDC encryption. */
775               if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
776                 err = gpg_error (GPG_ERR_BAD_SIGNATURE);
777               goto leave;
778             }
779
780           n += off;
781           if (DBG_FILTER)
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 holdback buffer.  */
885           if ( !dfx->holdbacklen )  /* First time. */
886             {
887               memcpy (buf, buf+22, 22);
888               n = 22;
889             }
890           else
891             {
892
893               memcpy (buf, dfx->holdback, 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 holdback buffer.  We
925              have at least 44 bytes thus a memmove is not needed.  */
926           n -= 22;
927           memcpy (dfx->holdback, buf+n, 22 );
928           dfx->holdbacklen = 22;
929         }
930       else if ( !dfx->holdbacklen ) /* EOF seen but empty holdback. */
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->holdback, 22 );
940           n -= 22;
941           memcpy (dfx->holdback, 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 }