dirmngr: Fix https incorrectly reported in help
[gnupg.git] / g10 / decrypt-data.c
1 /* decrypt-data.c - Decrypt an encrypted data packet
2  * Copyright (C) 1998, 1999, 2000, 2001, 2005,
3  *               2006, 2009 Free Software Foundation, Inc.
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 <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26
27 #include "gpg.h"
28 #include "util.h"
29 #include "packet.h"
30 #include "options.h"
31 #include "i18n.h"
32 #include "status.h"
33
34
35 static int mdc_decode_filter ( void *opaque, int control, IOBUF a,
36                                byte *buf, size_t *ret_len);
37 static int decode_filter ( void *opaque, int control, IOBUF a,
38                                         byte *buf, size_t *ret_len);
39
40 typedef struct decode_filter_context_s
41 {
42   gcry_cipher_hd_t cipher_hd;
43   gcry_md_hd_t mdc_hash;
44   char defer[22];
45   int  defer_filled;
46   int  eof_seen;
47   int  refcount;
48   int  partial;   /* Working on a partial length packet.  */
49   size_t length;  /* If !partial: Remaining bytes in the packet.  */
50 } *decode_filter_ctx_t;
51
52
53 /* Helper to release the decode context.  */
54 static void
55 release_dfx_context (decode_filter_ctx_t dfx)
56 {
57   if (!dfx)
58     return;
59
60   assert (dfx->refcount);
61   if ( !--dfx->refcount )
62     {
63       gcry_cipher_close (dfx->cipher_hd);
64       dfx->cipher_hd = NULL;
65       gcry_md_close (dfx->mdc_hash);
66       dfx->mdc_hash = NULL;
67       xfree (dfx);
68     }
69 }
70
71
72
73 /****************
74  * Decrypt the data, specified by ED with the key DEK.
75  */
76 int
77 decrypt_data (ctrl_t ctrl, void *procctx, PKT_encrypted *ed, DEK *dek)
78 {
79   decode_filter_ctx_t dfx;
80   byte *p;
81   int rc=0, c, i;
82   byte temp[32];
83   unsigned blocksize;
84   unsigned nprefix;
85
86   dfx = xtrycalloc (1, sizeof *dfx);
87   if (!dfx)
88     return gpg_error_from_syserror ();
89   dfx->refcount = 1;
90
91   if ( opt.verbose && !dek->algo_info_printed )
92     {
93       if (!openpgp_cipher_test_algo (dek->algo))
94         log_info (_("%s encrypted data\n"),
95                   openpgp_cipher_algo_name (dek->algo));
96       else
97         log_info (_("encrypted with unknown algorithm %d\n"), dek->algo );
98       dek->algo_info_printed = 1;
99     }
100
101   {
102     char buf[20];
103
104     snprintf (buf, sizeof buf, "%d %d", ed->mdc_method, dek->algo);
105     write_status_text (STATUS_DECRYPTION_INFO, buf);
106   }
107
108   if (opt.show_session_key)
109     {
110       char numbuf[25];
111       char *hexbuf;
112
113       snprintf (numbuf, sizeof numbuf, "%d:", dek->algo);
114       hexbuf = bin2hex (dek->key, dek->keylen, NULL);
115       if (!hexbuf)
116         {
117           rc = gpg_error_from_syserror ();
118           goto leave;
119         }
120       log_info ("session key: '%s%s'\n", numbuf, hexbuf);
121       write_status_strings (STATUS_SESSION_KEY, numbuf, hexbuf, NULL);
122       xfree (hexbuf);
123     }
124
125   rc = openpgp_cipher_test_algo (dek->algo);
126   if (rc)
127     goto leave;
128   blocksize = openpgp_cipher_get_algo_blklen (dek->algo);
129   if ( !blocksize || blocksize > 16 )
130     log_fatal ("unsupported blocksize %u\n", blocksize );
131   nprefix = blocksize;
132   if ( ed->len && ed->len < (nprefix+2) )
133     {
134        /* An invalid message.  We can't check that during parsing
135           because we may not know the used cipher then.  */
136       rc = gpg_error (GPG_ERR_INV_PACKET);
137       goto leave;
138     }
139
140   if ( ed->mdc_method )
141     {
142       if (gcry_md_open (&dfx->mdc_hash, ed->mdc_method, 0 ))
143         BUG ();
144       if ( DBG_HASHING )
145         gcry_md_debug (dfx->mdc_hash, "checkmdc");
146     }
147
148   rc = openpgp_cipher_open (&dfx->cipher_hd, dek->algo,
149                             GCRY_CIPHER_MODE_CFB,
150                             (GCRY_CIPHER_SECURE
151                              | ((ed->mdc_method || dek->algo >= 100)?
152                                 0 : GCRY_CIPHER_ENABLE_SYNC)));
153   if (rc)
154     {
155       /* We should never get an error here cause we already checked
156        * that the algorithm is available.  */
157       BUG();
158     }
159
160
161   /* log_hexdump( "thekey", dek->key, dek->keylen );*/
162   rc = gcry_cipher_setkey (dfx->cipher_hd, dek->key, dek->keylen);
163   if ( gpg_err_code (rc) == GPG_ERR_WEAK_KEY )
164     {
165       log_info(_("WARNING: message was encrypted with"
166                  " a weak key in the symmetric cipher.\n"));
167       rc=0;
168     }
169   else if( rc )
170     {
171       log_error("key setup failed: %s\n", gpg_strerror (rc) );
172       goto leave;
173     }
174
175   if (!ed->buf)
176     {
177       log_error(_("problem handling encrypted packet\n"));
178       goto leave;
179     }
180
181   gcry_cipher_setiv (dfx->cipher_hd, NULL, 0);
182
183   if ( ed->len )
184     {
185       for (i=0; i < (nprefix+2) && ed->len; i++, ed->len-- )
186         {
187           if ( (c=iobuf_get(ed->buf)) == -1 )
188             break;
189           else
190             temp[i] = c;
191         }
192     }
193   else
194     {
195       for (i=0; i < (nprefix+2); i++ )
196         if ( (c=iobuf_get(ed->buf)) == -1 )
197           break;
198         else
199           temp[i] = c;
200     }
201
202   gcry_cipher_decrypt (dfx->cipher_hd, temp, nprefix+2, NULL, 0);
203   gcry_cipher_sync (dfx->cipher_hd);
204   p = temp;
205   /* log_hexdump( "prefix", temp, nprefix+2 ); */
206   if (dek->symmetric
207       && (p[nprefix-2] != p[nprefix] || p[nprefix-1] != p[nprefix+1]) )
208     {
209       rc = gpg_error (GPG_ERR_BAD_KEY);
210       goto leave;
211     }
212
213   if ( dfx->mdc_hash )
214     gcry_md_write (dfx->mdc_hash, temp, nprefix+2);
215
216   dfx->refcount++;
217   dfx->partial = ed->is_partial;
218   dfx->length = ed->len;
219   if ( ed->mdc_method )
220     iobuf_push_filter ( ed->buf, mdc_decode_filter, dfx );
221   else
222     iobuf_push_filter ( ed->buf, decode_filter, dfx );
223
224   if (opt.unwrap_encryption)
225     {
226       char *filename;
227       estream_t fp;
228       rc = get_output_file ("", 0, ed->buf, &filename, &fp);
229       if (! rc)
230         {
231           iobuf_t output = iobuf_esopen (fp, "w", 0);
232           armor_filter_context_t *afx = NULL;
233
234           if (opt.armor)
235             {
236               afx = new_armor_context ();
237               push_armor_filter (afx, output);
238             }
239
240           iobuf_copy (output, ed->buf);
241           if ((rc = iobuf_error (ed->buf)))
242             log_error (_("error reading '%s': %s\n"),
243                        filename, gpg_strerror (rc));
244           else if ((rc = iobuf_error (output)))
245             log_error (_("error writing '%s': %s\n"),
246                        filename, gpg_strerror (rc));
247
248           iobuf_close (output);
249           if (afx)
250             release_armor_context (afx);
251         }
252     }
253   else
254     proc_packets (ctrl, procctx, ed->buf );
255
256   ed->buf = NULL;
257   if (dfx->eof_seen > 1 )
258     rc = gpg_error (GPG_ERR_INV_PACKET);
259   else if ( ed->mdc_method )
260     {
261       /* We used to let parse-packet.c handle the MDC packet but this
262          turned out to be a problem with compressed packets: With old
263          style packets there is no length information available and
264          the decompressor uses an implicit end.  However we can't know
265          this implicit end beforehand (:-) and thus may feed the
266          decompressor with more bytes than actually needed.  It would
267          be possible to unread the extra bytes but due to our weird
268          iobuf system any unread is non reliable due to filters
269          already popped off.  The easy and sane solution is to care
270          about the MDC packet only here and never pass it to the
271          packet parser.  Fortunatley the OpenPGP spec requires a
272          strict format for the MDC packet so that we know that 22
273          bytes are appended.  */
274       int datalen = gcry_md_get_algo_dlen (ed->mdc_method);
275
276       assert (dfx->cipher_hd);
277       assert (dfx->mdc_hash);
278       gcry_cipher_decrypt (dfx->cipher_hd, dfx->defer, 22, NULL, 0);
279       gcry_md_write (dfx->mdc_hash, dfx->defer, 2);
280       gcry_md_final (dfx->mdc_hash);
281
282       if (   dfx->defer[0] != '\xd3'
283           || dfx->defer[1] != '\x14'
284           || datalen != 20
285           || memcmp (gcry_md_read (dfx->mdc_hash, 0), dfx->defer+2, datalen))
286         rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
287       /* log_printhex("MDC message:", dfx->defer, 22); */
288       /* log_printhex("MDC calc:", gcry_md_read (dfx->mdc_hash,0), datalen); */
289     }
290
291
292  leave:
293   release_dfx_context (dfx);
294   return rc;
295 }
296
297
298
299 static int
300 mdc_decode_filter (void *opaque, int control, IOBUF a,
301                    byte *buf, size_t *ret_len)
302 {
303   decode_filter_ctx_t dfx = opaque;
304   size_t n, size = *ret_len;
305   int rc = 0;
306   int c;
307
308   /* Note: We need to distinguish between a partial and a fixed length
309      packet.  The first is the usual case as created by GPG.  However
310      for short messages the format degrades to a fixed length packet
311      and other implementations might use fixed length as well.  Only
312      looking for the EOF on fixed data works only if the encrypted
313      packet is not followed by other data.  This used to be a long
314      standing bug which was fixed on 2009-10-02.  */
315
316   if ( control == IOBUFCTRL_UNDERFLOW && dfx->eof_seen )
317     {
318       *ret_len = 0;
319       rc = -1;
320     }
321   else if( control == IOBUFCTRL_UNDERFLOW )
322     {
323       assert (a);
324       assert (size > 44); /* Our code requires at least this size.  */
325
326       /* Get at least 22 bytes and put it ahead in the buffer.  */
327       if (dfx->partial)
328         {
329           for (n=22; n < 44; n++)
330             {
331               if ( (c = iobuf_get(a)) == -1 )
332                 break;
333               buf[n] = c;
334             }
335         }
336       else
337         {
338           for (n=22; n < 44 && dfx->length; n++, dfx->length--)
339             {
340               c = iobuf_get (a);
341               if (c == -1)
342                 break; /* Premature EOF.  */
343               buf[n] = c;
344             }
345         }
346       if (n == 44)
347         {
348           /* We have enough stuff - flush the deferred stuff.  */
349           if ( !dfx->defer_filled )  /* First time. */
350             {
351               memcpy (buf, buf+22, 22);
352               n = 22;
353             }
354           else
355             {
356               memcpy (buf, dfx->defer, 22);
357             }
358           /* Fill up the buffer. */
359           if (dfx->partial)
360             {
361               for (; n < size; n++ )
362                 {
363                   if ( (c = iobuf_get(a)) == -1 )
364                     {
365                       dfx->eof_seen = 1; /* Normal EOF. */
366                       break;
367                     }
368                   buf[n] = c;
369                 }
370             }
371           else
372             {
373               for (; n < size && dfx->length; n++, dfx->length--)
374                 {
375                   c = iobuf_get(a);
376                   if (c == -1)
377                     {
378                       dfx->eof_seen = 3; /* Premature EOF. */
379                       break;
380                     }
381                   buf[n] = c;
382                 }
383               if (!dfx->length)
384                 dfx->eof_seen = 1; /* Normal EOF.  */
385             }
386
387           /* Move the trailing 22 bytes back to the defer buffer.  We
388              have at least 44 bytes thus a memmove is not needed.  */
389           n -= 22;
390           memcpy (dfx->defer, buf+n, 22 );
391           dfx->defer_filled = 1;
392         }
393       else if ( !dfx->defer_filled )  /* EOF seen but empty defer buffer. */
394         {
395           /* This is bad because it means an incomplete hash. */
396           n -= 22;
397           memcpy (buf, buf+22, n );
398           dfx->eof_seen = 2; /* EOF with incomplete hash.  */
399         }
400       else  /* EOF seen (i.e. read less than 22 bytes). */
401         {
402           memcpy (buf, dfx->defer, 22 );
403           n -= 22;
404           memcpy (dfx->defer, buf+n, 22 );
405           dfx->eof_seen = 1; /* Normal EOF. */
406         }
407
408       if ( n )
409         {
410           if ( dfx->cipher_hd )
411             gcry_cipher_decrypt (dfx->cipher_hd, buf, n, NULL, 0);
412           if ( dfx->mdc_hash )
413             gcry_md_write (dfx->mdc_hash, buf, n);
414         }
415       else
416         {
417           assert ( dfx->eof_seen );
418           rc = -1; /* Return EOF.  */
419         }
420       *ret_len = n;
421     }
422   else if ( control == IOBUFCTRL_FREE )
423     {
424       release_dfx_context (dfx);
425     }
426   else if ( control == IOBUFCTRL_DESC )
427     {
428       mem2str (buf, "mdc_decode_filter", *ret_len);
429     }
430   return rc;
431 }
432
433
434 static int
435 decode_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len)
436 {
437   decode_filter_ctx_t fc = opaque;
438   size_t size = *ret_len;
439   size_t n;
440   int c, rc = 0;
441
442
443   if ( control == IOBUFCTRL_UNDERFLOW && fc->eof_seen )
444     {
445       *ret_len = 0;
446       rc = -1;
447     }
448   else if ( control == IOBUFCTRL_UNDERFLOW )
449     {
450       assert(a);
451
452       if (fc->partial)
453         {
454           for (n=0; n < size; n++ )
455             {
456               c = iobuf_get(a);
457               if (c == -1)
458                 {
459                   fc->eof_seen = 1; /* Normal EOF. */
460                   break;
461                 }
462               buf[n] = c;
463             }
464         }
465       else
466         {
467           for (n=0; n < size && fc->length; n++, fc->length--)
468             {
469               c = iobuf_get(a);
470               if (c == -1)
471                 {
472                   fc->eof_seen = 3; /* Premature EOF. */
473                   break;
474                 }
475               buf[n] = c;
476             }
477           if (!fc->length)
478             fc->eof_seen = 1; /* Normal EOF.  */
479         }
480       if (n)
481         {
482           if (fc->cipher_hd)
483             gcry_cipher_decrypt (fc->cipher_hd, buf, n, NULL, 0);
484         }
485       else
486         {
487           if (!fc->eof_seen)
488             fc->eof_seen = 1;
489           rc = -1; /* Return EOF. */
490         }
491       *ret_len = n;
492     }
493   else if ( control == IOBUFCTRL_FREE )
494     {
495       release_dfx_context (fc);
496     }
497   else if ( control == IOBUFCTRL_DESC )
498     {
499       mem2str (buf, "decode_filter", *ret_len);
500     }
501   return rc;
502 }