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