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