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