gpg: Remove cipher.h and put algo ids into a common file.
[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' || dfx->defer[1] != '\x14' )
247         {
248           log_error("mdc_packet with invalid encoding\n");
249           rc = gpg_error (GPG_ERR_INV_PACKET);
250         }
251       else if (datalen != 20
252                || memcmp (gcry_md_read (dfx->mdc_hash, 0),
253                           dfx->defer+2,datalen ))
254         rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
255       /* log_printhex("MDC message:", dfx->defer, 22); */
256       /* log_printhex("MDC calc:", gcry_md_read (dfx->mdc_hash,0), datalen); */
257     }
258
259
260  leave:
261   release_dfx_context (dfx);
262   return rc;
263 }
264
265
266
267 static int
268 mdc_decode_filter (void *opaque, int control, IOBUF a,
269                    byte *buf, size_t *ret_len)
270 {
271   decode_filter_ctx_t dfx = opaque;
272   size_t n, size = *ret_len;
273   int rc = 0;
274   int c;
275
276   /* Note: We need to distinguish between a partial and a fixed length
277      packet.  The first is the usual case as created by GPG.  However
278      for short messages the format degrades to a fixed length packet
279      and other implementations might use fixed length as well.  Only
280      looking for the EOF on fixed data works only if the encrypted
281      packet is not followed by other data.  This used to be a long
282      standing bug which was fixed on 2009-10-02.  */
283
284   if ( control == IOBUFCTRL_UNDERFLOW && dfx->eof_seen )
285     {
286       *ret_len = 0;
287       rc = -1;
288     }
289   else if( control == IOBUFCTRL_UNDERFLOW )
290     {
291       assert (a);
292       assert (size > 44); /* Our code requires at least this size.  */
293
294       /* Get at least 22 bytes and put it ahead in the buffer.  */
295       if (dfx->partial)
296         {
297           for (n=22; n < 44; n++)
298             {
299               if ( (c = iobuf_get(a)) == -1 )
300                 break;
301               buf[n] = c;
302             }
303         }
304       else
305         {
306           for (n=22; n < 44 && dfx->length; n++, dfx->length--)
307             {
308               c = iobuf_get (a);
309               if (c == -1)
310                 break; /* Premature EOF.  */
311               buf[n] = c;
312             }
313         }
314       if (n == 44)
315         {
316           /* We have enough stuff - flush the deferred stuff.  */
317           if ( !dfx->defer_filled )  /* First time. */
318             {
319               memcpy (buf, buf+22, 22);
320               n = 22;
321             }
322           else
323             {
324               memcpy (buf, dfx->defer, 22);
325             }
326           /* Fill up the buffer. */
327           if (dfx->partial)
328             {
329               for (; n < size; n++ )
330                 {
331                   if ( (c = iobuf_get(a)) == -1 )
332                     {
333                       dfx->eof_seen = 1; /* Normal EOF. */
334                       break;
335                     }
336                   buf[n] = c;
337                 }
338             }
339           else
340             {
341               for (; n < size && dfx->length; n++, dfx->length--)
342                 {
343                   c = iobuf_get(a);
344                   if (c == -1)
345                     {
346                       dfx->eof_seen = 3; /* Premature EOF. */
347                       break;
348                     }
349                   buf[n] = c;
350                 }
351               if (!dfx->length)
352                 dfx->eof_seen = 1; /* Normal EOF.  */
353             }
354
355           /* Move the trailing 22 bytes back to the defer buffer.  We
356              have at least 44 bytes thus a memmove is not needed.  */
357           n -= 22;
358           memcpy (dfx->defer, buf+n, 22 );
359           dfx->defer_filled = 1;
360         }
361       else if ( !dfx->defer_filled )  /* EOF seen but empty defer buffer. */
362         {
363           /* This is bad because it means an incomplete hash. */
364           n -= 22;
365           memcpy (buf, buf+22, n );
366           dfx->eof_seen = 2; /* EOF with incomplete hash.  */
367         }
368       else  /* EOF seen (i.e. read less than 22 bytes). */
369         {
370           memcpy (buf, dfx->defer, 22 );
371           n -= 22;
372           memcpy (dfx->defer, buf+n, 22 );
373           dfx->eof_seen = 1; /* Normal EOF. */
374         }
375
376       if ( n )
377         {
378           if ( dfx->cipher_hd )
379             gcry_cipher_decrypt (dfx->cipher_hd, buf, n, NULL, 0);
380           if ( dfx->mdc_hash )
381             gcry_md_write (dfx->mdc_hash, buf, n);
382         }
383       else
384         {
385           assert ( dfx->eof_seen );
386           rc = -1; /* Return EOF.  */
387         }
388       *ret_len = n;
389     }
390   else if ( control == IOBUFCTRL_FREE )
391     {
392       release_dfx_context (dfx);
393     }
394   else if ( control == IOBUFCTRL_DESC )
395     {
396       *(char**)buf = "mdc_decode_filter";
397     }
398   return rc;
399 }
400
401
402 static int
403 decode_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len)
404 {
405   decode_filter_ctx_t fc = opaque;
406   size_t size = *ret_len;
407   size_t n;
408   int c, rc = 0;
409
410
411   if ( control == IOBUFCTRL_UNDERFLOW && fc->eof_seen )
412     {
413       *ret_len = 0;
414       rc = -1;
415     }
416   else if ( control == IOBUFCTRL_UNDERFLOW )
417     {
418       assert(a);
419
420       if (fc->partial)
421         {
422           for (n=0; n < size; n++ )
423             {
424               c = iobuf_get(a);
425               if (c == -1)
426                 {
427                   fc->eof_seen = 1; /* Normal EOF. */
428                   break;
429                 }
430               buf[n] = c;
431             }
432         }
433       else
434         {
435           for (n=0; n < size && fc->length; n++, fc->length--)
436             {
437               c = iobuf_get(a);
438               if (c == -1)
439                 {
440                   fc->eof_seen = 3; /* Premature EOF. */
441                   break;
442                 }
443               buf[n] = c;
444             }
445           if (!fc->length)
446             fc->eof_seen = 1; /* Normal EOF.  */
447         }
448       if (n)
449         {
450           if (fc->cipher_hd)
451             gcry_cipher_decrypt (fc->cipher_hd, buf, n, NULL, 0);
452         }
453       else
454         {
455           if (!fc->eof_seen)
456             fc->eof_seen = 1;
457           rc = -1; /* Return EOF. */
458         }
459       *ret_len = n;
460     }
461   else if ( control == IOBUFCTRL_FREE )
462     {
463       release_dfx_context (fc);
464     }
465   else if ( control == IOBUFCTRL_DESC )
466     {
467       *(char**)buf = "decode_filter";
468     }
469   return rc;
470 }