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