c56e01706ce3491a8811b63700804afb185c141f
[gnupg.git] / g10 / encr-data.c
1 /* encr-data.c -  process an encrypted data packet
2  * Copyright (C) 1998, 1999, 2000, 2001, 2005,
3  *               2006 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 2 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, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28
29 #include "gpg.h"
30 #include "util.h"
31 #include "packet.h"
32 #include "cipher.h"
33 #include "options.h"
34 #include "i18n.h"
35
36
37 static int mdc_decode_filter ( void *opaque, int control, IOBUF a,
38                                byte *buf, size_t *ret_len);
39 static int decode_filter ( void *opaque, int control, IOBUF a,
40                                         byte *buf, size_t *ret_len);
41
42 typedef struct 
43 {
44   gcry_cipher_hd_t cipher_hd;
45   gcry_md_hd_t mdc_hash;
46   char defer[22];
47   int  defer_filled;
48   int  eof_seen;
49 } decode_filter_ctx_t;
50
51
52 /****************
53  * Decrypt the data, specified by ED with the key DEK.
54  */
55 int
56 decrypt_data( void *procctx, PKT_encrypted *ed, DEK *dek )
57 {
58   decode_filter_ctx_t dfx;
59   byte *p;
60   int rc=0, c, i;
61   byte temp[32];
62   unsigned blocksize;
63   unsigned nprefix;
64   
65   memset( &dfx, 0, sizeof dfx );
66   if ( opt.verbose && !dek->algo_info_printed )
67     {
68       const char *s = gcry_cipher_algo_name (dek->algo);
69       if (s && *s)
70         log_info(_("%s encrypted data\n"), s );
71       else
72         log_info(_("encrypted with unknown algorithm %d\n"), dek->algo );
73       dek->algo_info_printed = 1;
74     }
75   rc = openpgp_cipher_test_algo (dek->algo);
76   if (rc)
77     goto leave;
78   blocksize = gcry_cipher_get_algo_blklen (dek->algo);
79   if ( !blocksize || blocksize > 16 )
80     log_fatal("unsupported blocksize %u\n", blocksize );
81   nprefix = blocksize;
82   if ( ed->len && ed->len < (nprefix+2) )
83     BUG();
84
85   if ( ed->mdc_method ) 
86     {
87       if (gcry_md_open (&dfx.mdc_hash, ed->mdc_method, 0 ))
88         BUG ();
89       if ( DBG_HASHING )
90         gcry_md_start_debug (dfx.mdc_hash, "checkmdc");
91     }
92
93   rc = gcry_cipher_open (&dfx.cipher_hd, dek->algo,
94                          GCRY_CIPHER_MODE_CFB,
95                          (GCRY_CIPHER_SECURE
96                           | ((ed->mdc_method || dek->algo >= 100)?
97                              0 : GCRY_CIPHER_ENABLE_SYNC)));
98   if (rc)
99     {
100       /* We should never get an error here cause we already checked
101        * that the algorithm is available.  */
102       BUG();
103     }
104
105
106   /* log_hexdump( "thekey", dek->key, dek->keylen );*/
107   rc = gcry_cipher_setkey (dfx.cipher_hd, dek->key, dek->keylen);
108   if ( gpg_err_code (rc) == GPG_ERR_WEAK_KEY )
109     {
110       log_info(_("WARNING: message was encrypted with"
111                  " a weak key in the symmetric cipher.\n"));
112       rc=0;
113     }
114   else if( rc )
115     {
116       log_error("key setup failed: %s\n", g10_errstr(rc) );
117       goto leave;
118     }
119
120   if (!ed->buf) 
121     {
122       log_error(_("problem handling encrypted packet\n"));
123       goto leave;
124     }
125
126   gcry_cipher_setiv (dfx.cipher_hd, NULL, 0);
127
128   if ( ed->len )
129     {
130       for (i=0; i < (nprefix+2) && ed->len; i++, ed->len-- ) 
131         {
132           if ( (c=iobuf_get(ed->buf)) == -1 )
133             break;
134           else
135             temp[i] = c;
136         }
137     }
138   else 
139     {
140       for (i=0; i < (nprefix+2); i++ )
141         if ( (c=iobuf_get(ed->buf)) == -1 )
142           break;
143         else
144           temp[i] = c;
145     }
146   
147   gcry_cipher_decrypt (dfx.cipher_hd, temp, nprefix+2, NULL, 0);
148   gcry_cipher_sync (dfx.cipher_hd);
149   p = temp;
150   /* log_hexdump( "prefix", temp, nprefix+2 ); */
151   if (dek->symmetric
152       && (p[nprefix-2] != p[nprefix] || p[nprefix-1] != p[nprefix+1]) )
153     {
154       rc = gpg_error (GPG_ERR_BAD_KEY);
155       goto leave;
156     }
157   
158   if ( dfx.mdc_hash )
159     gcry_md_write (dfx.mdc_hash, temp, nprefix+2);
160   
161   if ( ed->mdc_method )
162     iobuf_push_filter( ed->buf, mdc_decode_filter, &dfx );
163   else
164     iobuf_push_filter( ed->buf, decode_filter, &dfx );
165
166   proc_packets ( procctx, ed->buf );
167   ed->buf = NULL;
168   if ( ed->mdc_method && dfx.eof_seen == 2 )
169     rc = gpg_error (GPG_ERR_INV_PACKET);
170   else if ( ed->mdc_method )
171     { 
172       /* We used to let parse-packet.c handle the MDC packet but this
173          turned out to be a problem with compressed packets: With old
174          style packets there is no length information available and
175          the decompressor uses an implicit end.  However we can't know
176          this implicit end beforehand (:-) and thus may feed the
177          decompressor with more bytes than actually needed.  It would
178          be possible to unread the extra bytes but due to our weird
179          iobuf system any unread is non reliable due to filters
180          already popped off.  The easy and sane solution is to care
181          about the MDC packet only here and never pass it to the
182          packet parser.  Fortunatley the OpenPGP spec requires a
183          strict format for the MDC packet so that we know that 22
184          bytes are appended.  */
185       int datalen = gcry_md_get_algo_dlen (ed->mdc_method);
186
187       gcry_cipher_decrypt (dfx.cipher_hd, dfx.defer, 22, NULL, 0);
188       gcry_md_write (dfx.mdc_hash, dfx.defer, 2);
189       gcry_md_final (dfx.mdc_hash);
190
191       if (dfx.defer[0] != '\xd3' || dfx.defer[1] != '\x14' )
192         {
193           log_error("mdc_packet with invalid encoding\n");
194           rc = gpg_error (GPG_ERR_INV_PACKET);
195         }
196       else if (datalen != 20
197                || memcmp (gcry_md_read (dfx.mdc_hash, 0),dfx.defer+2,datalen))
198         rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
199       /* log_printhex("MDC message:", dfx.defer, 22); */
200       /* log_printhex("MDC calc:", gcry_md_read (dfx.mdc_hash,0), datalen); */
201     }
202   
203   
204  leave:
205   gcry_cipher_close (dfx.cipher_hd);
206   gcry_md_close (dfx.mdc_hash);
207   return rc;
208 }
209
210
211
212 /* I think we should merge this with cipher_filter */
213 static int
214 mdc_decode_filter (void *opaque, int control, IOBUF a,
215                    byte *buf, size_t *ret_len)
216 {
217   decode_filter_ctx_t *dfx = opaque;
218   size_t n, size = *ret_len;
219   int rc = 0;
220   int c;
221   
222   if ( control == IOBUFCTRL_UNDERFLOW && dfx->eof_seen )
223     {
224       *ret_len = 0;
225       rc = -1;
226     }
227   else if( control == IOBUFCTRL_UNDERFLOW )
228     {
229       assert(a);
230       assert( size > 44 );
231       
232       /* Get at least 22 bytes and put it somewhere ahead in the buffer. */
233       for(n=22; n < 44 ; n++ )
234         {
235           if( (c = iobuf_get(a)) == -1 )
236             break;
237           buf[n] = c;
238         }
239       if ( n == 44 ) 
240         {
241           /* We have enough stuff - flush the deferred stuff.  */
242           /* (we asserted that the buffer is large enough) */
243           if ( !dfx->defer_filled )  /* First time. */
244             {
245               memcpy (buf, buf+22, 22 );
246               n = 22;
247             }
248           else
249             {
250               memcpy (buf, dfx->defer, 22 );
251             }
252           /* Now fill up. */
253           for (; n < size; n++ ) 
254             {
255               if ( (c = iobuf_get(a)) == -1 )
256                 break;
257               buf[n] = c;
258             }
259           /* Move the last 22 bytes back to the defer buffer. */
260           /* (right, we are wasting 22 bytes of the supplied buffer.) */
261           n -= 22;
262           memcpy (dfx->defer, buf+n, 22 );
263           dfx->defer_filled = 1;
264         }
265       else if ( !dfx->defer_filled )  /* EOF seen but empty defer buffer. */
266         {
267           /* This is bad because it means an incomplete hash. */
268           n -= 22;
269           memcpy (buf, buf+22, n );
270           dfx->eof_seen = 2; /* EOF with incomplete hash.  */
271         }
272       else  /* EOF seen (i.e. read less than 22 bytes). */
273         {
274           memcpy (buf, dfx->defer, 22 );
275           n -= 22;
276           memcpy (dfx->defer, buf+n, 22 );
277           dfx->eof_seen = 1; /* Normal EOF. */
278         }
279
280       if ( n )
281         {
282           gcry_cipher_decrypt (dfx->cipher_hd, buf, n, NULL, 0);
283           gcry_md_write (dfx->mdc_hash, buf, n);
284         }
285       else
286         {
287           assert ( dfx->eof_seen );
288           rc = -1; /* eof */
289         }
290       *ret_len = n;
291     }
292   else if ( control == IOBUFCTRL_DESC ) 
293     {
294       *(char**)buf = "mdc_decode_filter";
295     }
296   return rc;
297 }
298
299
300 static int
301 decode_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len)
302 {
303   decode_filter_ctx_t *fc = opaque;
304   size_t n, size = *ret_len;
305   int rc = 0;
306   
307   if ( control == IOBUFCTRL_UNDERFLOW ) 
308     {
309       assert(a);
310       n = iobuf_read ( a, buf, size );
311       if ( n == -1 )
312         n = 0;
313       if ( n )
314         gcry_cipher_decrypt (fc->cipher_hd, buf, n, NULL, 0);
315       else
316         rc = -1; /* EOF */
317       *ret_len = n;
318     }
319   else if ( control == IOBUFCTRL_DESC )
320     {
321       *(char**)buf = "decode_filter";
322     }
323   return rc;
324 }
325