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