include: Remove this directory.
[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   if (opt.show_session_key)
110     {
111       char numbuf[25];
112       char *hexbuf;
113
114       snprintf (numbuf, sizeof numbuf, "%d:", dek->algo);
115       hexbuf = bin2hex (dek->key, dek->keylen, NULL);
116       if (!hexbuf)
117         {
118           rc = gpg_error_from_syserror ();
119           goto leave;
120         }
121       log_info ("session key: '%s%s'\n", numbuf, hexbuf);
122       write_status_strings (STATUS_SESSION_KEY, numbuf, hexbuf, NULL);
123       xfree (hexbuf);
124     }
125
126   rc = openpgp_cipher_test_algo (dek->algo);
127   if (rc)
128     goto leave;
129   blocksize = openpgp_cipher_get_algo_blklen (dek->algo);
130   if ( !blocksize || blocksize > 16 )
131     log_fatal ("unsupported blocksize %u\n", blocksize );
132   nprefix = blocksize;
133   if ( ed->len && ed->len < (nprefix+2) )
134     BUG();
135
136   if ( ed->mdc_method )
137     {
138       if (gcry_md_open (&dfx->mdc_hash, ed->mdc_method, 0 ))
139         BUG ();
140       if ( DBG_HASHING )
141         gcry_md_debug (dfx->mdc_hash, "checkmdc");
142     }
143
144   rc = openpgp_cipher_open (&dfx->cipher_hd, dek->algo,
145                             GCRY_CIPHER_MODE_CFB,
146                             (GCRY_CIPHER_SECURE
147                              | ((ed->mdc_method || dek->algo >= 100)?
148                                 0 : GCRY_CIPHER_ENABLE_SYNC)));
149   if (rc)
150     {
151       /* We should never get an error here cause we already checked
152        * that the algorithm is available.  */
153       BUG();
154     }
155
156
157   /* log_hexdump( "thekey", dek->key, dek->keylen );*/
158   rc = gcry_cipher_setkey (dfx->cipher_hd, dek->key, dek->keylen);
159   if ( gpg_err_code (rc) == GPG_ERR_WEAK_KEY )
160     {
161       log_info(_("WARNING: message was encrypted with"
162                  " a weak key in the symmetric cipher.\n"));
163       rc=0;
164     }
165   else if( rc )
166     {
167       log_error("key setup failed: %s\n", g10_errstr(rc) );
168       goto leave;
169     }
170
171   if (!ed->buf)
172     {
173       log_error(_("problem handling encrypted packet\n"));
174       goto leave;
175     }
176
177   gcry_cipher_setiv (dfx->cipher_hd, NULL, 0);
178
179   if ( ed->len )
180     {
181       for (i=0; i < (nprefix+2) && ed->len; i++, ed->len-- )
182         {
183           if ( (c=iobuf_get(ed->buf)) == -1 )
184             break;
185           else
186             temp[i] = c;
187         }
188     }
189   else
190     {
191       for (i=0; i < (nprefix+2); i++ )
192         if ( (c=iobuf_get(ed->buf)) == -1 )
193           break;
194         else
195           temp[i] = c;
196     }
197
198   gcry_cipher_decrypt (dfx->cipher_hd, temp, nprefix+2, NULL, 0);
199   gcry_cipher_sync (dfx->cipher_hd);
200   p = temp;
201   /* log_hexdump( "prefix", temp, nprefix+2 ); */
202   if (dek->symmetric
203       && (p[nprefix-2] != p[nprefix] || p[nprefix-1] != p[nprefix+1]) )
204     {
205       rc = gpg_error (GPG_ERR_BAD_KEY);
206       goto leave;
207     }
208
209   if ( dfx->mdc_hash )
210     gcry_md_write (dfx->mdc_hash, temp, nprefix+2);
211
212   dfx->refcount++;
213   dfx->partial = ed->is_partial;
214   dfx->length = ed->len;
215   if ( ed->mdc_method )
216     iobuf_push_filter ( ed->buf, mdc_decode_filter, dfx );
217   else
218     iobuf_push_filter ( ed->buf, decode_filter, dfx );
219
220   proc_packets (ctrl, procctx, ed->buf );
221   ed->buf = NULL;
222   if (dfx->eof_seen > 1 )
223     rc = gpg_error (GPG_ERR_INV_PACKET);
224   else if ( ed->mdc_method )
225     {
226       /* We used to let parse-packet.c handle the MDC packet but this
227          turned out to be a problem with compressed packets: With old
228          style packets there is no length information available and
229          the decompressor uses an implicit end.  However we can't know
230          this implicit end beforehand (:-) and thus may feed the
231          decompressor with more bytes than actually needed.  It would
232          be possible to unread the extra bytes but due to our weird
233          iobuf system any unread is non reliable due to filters
234          already popped off.  The easy and sane solution is to care
235          about the MDC packet only here and never pass it to the
236          packet parser.  Fortunatley the OpenPGP spec requires a
237          strict format for the MDC packet so that we know that 22
238          bytes are appended.  */
239       int datalen = gcry_md_get_algo_dlen (ed->mdc_method);
240
241       assert (dfx->cipher_hd);
242       assert (dfx->mdc_hash);
243       gcry_cipher_decrypt (dfx->cipher_hd, dfx->defer, 22, NULL, 0);
244       gcry_md_write (dfx->mdc_hash, dfx->defer, 2);
245       gcry_md_final (dfx->mdc_hash);
246
247       if (dfx->defer[0] != '\xd3' || dfx->defer[1] != '\x14' )
248         {
249           log_error("mdc_packet with invalid encoding\n");
250           rc = gpg_error (GPG_ERR_INV_PACKET);
251         }
252       else if (datalen != 20
253                || memcmp (gcry_md_read (dfx->mdc_hash, 0),
254                           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 }