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