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