g10: Don't leak memory if we fail to initialize a new database handle.
[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   proc_packets (ctrl, procctx, ed->buf );
225   ed->buf = NULL;
226   if (dfx->eof_seen > 1 )
227     rc = gpg_error (GPG_ERR_INV_PACKET);
228   else if ( ed->mdc_method )
229     {
230       /* We used to let parse-packet.c handle the MDC packet but this
231          turned out to be a problem with compressed packets: With old
232          style packets there is no length information available and
233          the decompressor uses an implicit end.  However we can't know
234          this implicit end beforehand (:-) and thus may feed the
235          decompressor with more bytes than actually needed.  It would
236          be possible to unread the extra bytes but due to our weird
237          iobuf system any unread is non reliable due to filters
238          already popped off.  The easy and sane solution is to care
239          about the MDC packet only here and never pass it to the
240          packet parser.  Fortunatley the OpenPGP spec requires a
241          strict format for the MDC packet so that we know that 22
242          bytes are appended.  */
243       int datalen = gcry_md_get_algo_dlen (ed->mdc_method);
244
245       assert (dfx->cipher_hd);
246       assert (dfx->mdc_hash);
247       gcry_cipher_decrypt (dfx->cipher_hd, dfx->defer, 22, NULL, 0);
248       gcry_md_write (dfx->mdc_hash, dfx->defer, 2);
249       gcry_md_final (dfx->mdc_hash);
250
251       if (   dfx->defer[0] != '\xd3'
252           || dfx->defer[1] != '\x14'
253           || datalen != 20
254           || memcmp (gcry_md_read (dfx->mdc_hash, 0), dfx->defer+2, datalen))
255         rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
256       /* log_printhex("MDC message:", dfx->defer, 22); */
257       /* log_printhex("MDC calc:", gcry_md_read (dfx->mdc_hash,0), datalen); */
258     }
259
260
261  leave:
262   release_dfx_context (dfx);
263   return rc;
264 }
265
266
267
268 static int
269 mdc_decode_filter (void *opaque, int control, IOBUF a,
270                    byte *buf, size_t *ret_len)
271 {
272   decode_filter_ctx_t dfx = opaque;
273   size_t n, size = *ret_len;
274   int rc = 0;
275   int c;
276
277   /* Note: We need to distinguish between a partial and a fixed length
278      packet.  The first is the usual case as created by GPG.  However
279      for short messages the format degrades to a fixed length packet
280      and other implementations might use fixed length as well.  Only
281      looking for the EOF on fixed data works only if the encrypted
282      packet is not followed by other data.  This used to be a long
283      standing bug which was fixed on 2009-10-02.  */
284
285   if ( control == IOBUFCTRL_UNDERFLOW && dfx->eof_seen )
286     {
287       *ret_len = 0;
288       rc = -1;
289     }
290   else if( control == IOBUFCTRL_UNDERFLOW )
291     {
292       assert (a);
293       assert (size > 44); /* Our code requires at least this size.  */
294
295       /* Get at least 22 bytes and put it ahead in the buffer.  */
296       if (dfx->partial)
297         {
298           for (n=22; n < 44; n++)
299             {
300               if ( (c = iobuf_get(a)) == -1 )
301                 break;
302               buf[n] = c;
303             }
304         }
305       else
306         {
307           for (n=22; n < 44 && dfx->length; n++, dfx->length--)
308             {
309               c = iobuf_get (a);
310               if (c == -1)
311                 break; /* Premature EOF.  */
312               buf[n] = c;
313             }
314         }
315       if (n == 44)
316         {
317           /* We have enough stuff - flush the deferred stuff.  */
318           if ( !dfx->defer_filled )  /* First time. */
319             {
320               memcpy (buf, buf+22, 22);
321               n = 22;
322             }
323           else
324             {
325               memcpy (buf, dfx->defer, 22);
326             }
327           /* Fill up the buffer. */
328           if (dfx->partial)
329             {
330               for (; n < size; n++ )
331                 {
332                   if ( (c = iobuf_get(a)) == -1 )
333                     {
334                       dfx->eof_seen = 1; /* Normal EOF. */
335                       break;
336                     }
337                   buf[n] = c;
338                 }
339             }
340           else
341             {
342               for (; n < size && dfx->length; n++, dfx->length--)
343                 {
344                   c = iobuf_get(a);
345                   if (c == -1)
346                     {
347                       dfx->eof_seen = 3; /* Premature EOF. */
348                       break;
349                     }
350                   buf[n] = c;
351                 }
352               if (!dfx->length)
353                 dfx->eof_seen = 1; /* Normal EOF.  */
354             }
355
356           /* Move the trailing 22 bytes back to the defer buffer.  We
357              have at least 44 bytes thus a memmove is not needed.  */
358           n -= 22;
359           memcpy (dfx->defer, buf+n, 22 );
360           dfx->defer_filled = 1;
361         }
362       else if ( !dfx->defer_filled )  /* EOF seen but empty defer buffer. */
363         {
364           /* This is bad because it means an incomplete hash. */
365           n -= 22;
366           memcpy (buf, buf+22, n );
367           dfx->eof_seen = 2; /* EOF with incomplete hash.  */
368         }
369       else  /* EOF seen (i.e. read less than 22 bytes). */
370         {
371           memcpy (buf, dfx->defer, 22 );
372           n -= 22;
373           memcpy (dfx->defer, buf+n, 22 );
374           dfx->eof_seen = 1; /* Normal EOF. */
375         }
376
377       if ( n )
378         {
379           if ( dfx->cipher_hd )
380             gcry_cipher_decrypt (dfx->cipher_hd, buf, n, NULL, 0);
381           if ( dfx->mdc_hash )
382             gcry_md_write (dfx->mdc_hash, buf, n);
383         }
384       else
385         {
386           assert ( dfx->eof_seen );
387           rc = -1; /* Return EOF.  */
388         }
389       *ret_len = n;
390     }
391   else if ( control == IOBUFCTRL_FREE )
392     {
393       release_dfx_context (dfx);
394     }
395   else if ( control == IOBUFCTRL_DESC )
396     {
397       *(char**)buf = "mdc_decode_filter";
398     }
399   return rc;
400 }
401
402
403 static int
404 decode_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len)
405 {
406   decode_filter_ctx_t fc = opaque;
407   size_t size = *ret_len;
408   size_t n;
409   int c, rc = 0;
410
411
412   if ( control == IOBUFCTRL_UNDERFLOW && fc->eof_seen )
413     {
414       *ret_len = 0;
415       rc = -1;
416     }
417   else if ( control == IOBUFCTRL_UNDERFLOW )
418     {
419       assert(a);
420
421       if (fc->partial)
422         {
423           for (n=0; n < size; n++ )
424             {
425               c = iobuf_get(a);
426               if (c == -1)
427                 {
428                   fc->eof_seen = 1; /* Normal EOF. */
429                   break;
430                 }
431               buf[n] = c;
432             }
433         }
434       else
435         {
436           for (n=0; n < size && fc->length; n++, fc->length--)
437             {
438               c = iobuf_get(a);
439               if (c == -1)
440                 {
441                   fc->eof_seen = 3; /* Premature EOF. */
442                   break;
443                 }
444               buf[n] = c;
445             }
446           if (!fc->length)
447             fc->eof_seen = 1; /* Normal EOF.  */
448         }
449       if (n)
450         {
451           if (fc->cipher_hd)
452             gcry_cipher_decrypt (fc->cipher_hd, buf, n, NULL, 0);
453         }
454       else
455         {
456           if (!fc->eof_seen)
457             fc->eof_seen = 1;
458           rc = -1; /* Return EOF. */
459         }
460       *ret_len = n;
461     }
462   else if ( control == IOBUFCTRL_FREE )
463     {
464       release_dfx_context (fc);
465     }
466   else if ( control == IOBUFCTRL_DESC )
467     {
468       *(char**)buf = "decode_filter";
469     }
470   return rc;
471 }