gpgscm: Use boxed values for source locations.
[gnupg.git] / sm / decrypt.c
1 /* decrypt.c - Decrypt a message
2  * Copyright (C) 2001, 2003, 2010 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <unistd.h>
26 #include <time.h>
27 #include <assert.h>
28
29 #include "gpgsm.h"
30 #include <gcrypt.h>
31 #include <ksba.h>
32
33 #include "keydb.h"
34 #include "i18n.h"
35
36 struct decrypt_filter_parm_s
37 {
38   int algo;
39   int mode;
40   int blklen;
41   gcry_cipher_hd_t hd;
42   char iv[16];
43   size_t ivlen;
44   int any_data;  /* dod we push anything through the filter at all? */
45   unsigned char lastblock[16];  /* to strip the padding we have to
46                                    keep this one */
47   char helpblock[16];  /* needed because there is no block buffering in
48                           libgcrypt (yet) */
49   int  helpblocklen;
50 };
51
52
53
54 /* Decrypt the session key and fill in the parm structure.  The
55    algo and the IV is expected to be already in PARM. */
56 static int
57 prepare_decryption (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
58                     ksba_const_sexp_t enc_val,
59                     struct decrypt_filter_parm_s *parm)
60 {
61   char *seskey = NULL;
62   size_t n, seskeylen;
63   int rc;
64
65   rc = gpgsm_agent_pkdecrypt (ctrl, hexkeygrip, desc, enc_val,
66                               &seskey, &seskeylen);
67   if (rc)
68     {
69       log_error ("error decrypting session key: %s\n", gpg_strerror (rc));
70       goto leave;
71     }
72
73   if (DBG_CRYPTO)
74     log_printhex ("pkcs1 encoded session key:", seskey, seskeylen);
75
76   n=0;
77   if (seskeylen == 24 || seskeylen == 16)
78     {
79       /* Smells like a 3-DES or AES-128 key.  This might happen
80        * because a SC has already done the unpacking.  A better
81        * solution would be to test for this only after we triggered
82        * the GPG_ERR_INV_SESSION_KEY. */
83     }
84   else
85     {
86       if (n + 7 > seskeylen )
87         {
88           rc = gpg_error (GPG_ERR_INV_SESSION_KEY);
89           goto leave;
90         }
91
92       /* FIXME: Actually the leading zero is required but due to the way
93          we encode the output in libgcrypt as an MPI we are not able to
94          encode that leading zero.  However, when using a Smartcard we are
95          doing it the right way and therefore we have to skip the zero.  This
96          should be fixed in gpg-agent of course. */
97       if (!seskey[n])
98         n++;
99
100       if (seskey[n] != 2 )  /* Wrong block type version. */
101         {
102           rc = gpg_error (GPG_ERR_INV_SESSION_KEY);
103           goto leave;
104         }
105
106       for (n++; n < seskeylen && seskey[n]; n++) /* Skip the random bytes. */
107         ;
108       n++; /* and the zero byte */
109       if (n >= seskeylen )
110         {
111           rc = gpg_error (GPG_ERR_INV_SESSION_KEY);
112           goto leave;
113         }
114     }
115
116   if (DBG_CRYPTO)
117     log_printhex ("session key:", seskey+n, seskeylen-n);
118
119   rc = gcry_cipher_open (&parm->hd, parm->algo, parm->mode, 0);
120   if (rc)
121     {
122       log_error ("error creating decryptor: %s\n", gpg_strerror (rc));
123       goto leave;
124     }
125
126   rc = gcry_cipher_setkey (parm->hd, seskey+n, seskeylen-n);
127   if (gpg_err_code (rc) == GPG_ERR_WEAK_KEY)
128     {
129       log_info (_("WARNING: message was encrypted with "
130                   "a weak key in the symmetric cipher.\n"));
131       rc = 0;
132     }
133   if (rc)
134     {
135       log_error("key setup failed: %s\n", gpg_strerror(rc) );
136       goto leave;
137     }
138
139   gcry_cipher_setiv (parm->hd, parm->iv, parm->ivlen);
140
141  leave:
142   xfree (seskey);
143   return rc;
144 }
145
146
147 /* This function is called by the KSBA writer just before the actual
148    write is done.  The function must take INLEN bytes from INBUF,
149    decrypt it and store it inoutbuf which has a maximum size of
150    maxoutlen.  The valid bytes in outbuf should be return in outlen.
151    Due to different buffer sizes or different length of input and
152    output, it may happen that fewer bytes are processed or fewer bytes
153    are written. */
154 static gpg_error_t
155 decrypt_filter (void *arg,
156                 const void *inbuf, size_t inlen, size_t *inused,
157                 void *outbuf, size_t maxoutlen, size_t *outlen)
158 {
159   struct decrypt_filter_parm_s *parm = arg;
160   int blklen = parm->blklen;
161   size_t orig_inlen = inlen;
162
163   /* fixme: Should we issue an error when we have not seen one full block? */
164   if (!inlen)
165     return gpg_error (GPG_ERR_BUG);
166
167   if (maxoutlen < 2*parm->blklen)
168     return gpg_error (GPG_ERR_BUG);
169   /* Make some space because we will later need an extra block at the end.  */
170   maxoutlen -= blklen;
171
172   if (parm->helpblocklen)
173     {
174       int i, j;
175
176       for (i=parm->helpblocklen,j=0; i < blklen && j < inlen; i++, j++)
177         parm->helpblock[i] = ((const char*)inbuf)[j];
178       inlen -= j;
179       if (blklen > maxoutlen)
180         return gpg_error (GPG_ERR_BUG);
181       if (i < blklen)
182         {
183           parm->helpblocklen = i;
184           *outlen = 0;
185         }
186       else
187         {
188           parm->helpblocklen = 0;
189           if (parm->any_data)
190             {
191               memcpy (outbuf, parm->lastblock, blklen);
192               *outlen =blklen;
193             }
194           else
195             *outlen = 0;
196           gcry_cipher_decrypt (parm->hd, parm->lastblock, blklen,
197                                parm->helpblock, blklen);
198           parm->any_data = 1;
199         }
200       *inused = orig_inlen - inlen;
201       return 0;
202     }
203
204
205   if (inlen > maxoutlen)
206     inlen = maxoutlen;
207   if (inlen % blklen)
208     { /* store the remainder away */
209       parm->helpblocklen = inlen%blklen;
210       inlen = inlen/blklen*blklen;
211       memcpy (parm->helpblock, (const char*)inbuf+inlen, parm->helpblocklen);
212     }
213
214   *inused = inlen + parm->helpblocklen;
215   if (inlen)
216     {
217       assert (inlen >= blklen);
218       if (parm->any_data)
219         {
220           gcry_cipher_decrypt (parm->hd, (char*)outbuf+blklen, inlen,
221                                inbuf, inlen);
222           memcpy (outbuf, parm->lastblock, blklen);
223           memcpy (parm->lastblock,(char*)outbuf+inlen, blklen);
224           *outlen = inlen;
225         }
226       else
227         {
228           gcry_cipher_decrypt (parm->hd, outbuf, inlen, inbuf, inlen);
229           memcpy (parm->lastblock, (char*)outbuf+inlen-blklen, blklen);
230           *outlen = inlen - blklen;
231           parm->any_data = 1;
232         }
233     }
234   else
235     *outlen = 0;
236   return 0;
237 }
238
239
240 \f
241 /* Perform a decrypt operation.  */
242 int
243 gpgsm_decrypt (ctrl_t ctrl, int in_fd, estream_t out_fp)
244 {
245   int rc;
246   Base64Context b64reader = NULL;
247   Base64Context b64writer = NULL;
248   ksba_reader_t reader;
249   ksba_writer_t writer;
250   ksba_cms_t cms = NULL;
251   ksba_stop_reason_t stopreason;
252   KEYDB_HANDLE kh;
253   int recp;
254   estream_t in_fp = NULL;
255   struct decrypt_filter_parm_s dfparm;
256
257   memset (&dfparm, 0, sizeof dfparm);
258
259   audit_set_type (ctrl->audit, AUDIT_TYPE_DECRYPT);
260
261   kh = keydb_new ();
262   if (!kh)
263     {
264       log_error (_("failed to allocate keyDB handle\n"));
265       rc = gpg_error (GPG_ERR_GENERAL);
266       goto leave;
267     }
268
269   in_fp = es_fdopen_nc (in_fd, "rb");
270   if (!in_fp)
271     {
272       rc = gpg_error_from_syserror ();
273       log_error ("fdopen() failed: %s\n", strerror (errno));
274       goto leave;
275     }
276
277   rc = gpgsm_create_reader (&b64reader, ctrl, in_fp, 0, &reader);
278   if (rc)
279     {
280       log_error ("can't create reader: %s\n", gpg_strerror (rc));
281       goto leave;
282     }
283
284   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
285   if (rc)
286     {
287       log_error ("can't create writer: %s\n", gpg_strerror (rc));
288       goto leave;
289     }
290
291   rc = ksba_cms_new (&cms);
292   if (rc)
293     goto leave;
294
295   rc = ksba_cms_set_reader_writer (cms, reader, writer);
296   if (rc)
297     {
298       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
299                  gpg_strerror (rc));
300       goto leave;
301     }
302
303   audit_log (ctrl->audit, AUDIT_SETUP_READY);
304
305   /* Parser loop. */
306   do
307     {
308       rc = ksba_cms_parse (cms, &stopreason);
309       if (rc)
310         {
311           log_debug ("ksba_cms_parse failed: %s\n", gpg_strerror (rc));
312           goto leave;
313         }
314
315       if (stopreason == KSBA_SR_BEGIN_DATA
316           || stopreason == KSBA_SR_DETACHED_DATA)
317         {
318           int algo, mode;
319           const char *algoid;
320           int any_key = 0;
321
322           audit_log (ctrl->audit, AUDIT_GOT_DATA);
323
324           algoid = ksba_cms_get_content_oid (cms, 2/* encryption algo*/);
325           algo = gcry_cipher_map_name (algoid);
326           mode = gcry_cipher_mode_from_oid (algoid);
327           if (!algo || !mode)
328             {
329               rc = gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
330               log_error ("unsupported algorithm '%s'\n", algoid? algoid:"?");
331               if (algoid && !strcmp (algoid, "1.2.840.113549.3.2"))
332                 log_info (_("(this is the RC2 algorithm)\n"));
333               else if (!algoid)
334                 log_info (_("(this does not seem to be an encrypted"
335                             " message)\n"));
336               {
337                 char numbuf[50];
338                 sprintf (numbuf, "%d", rc);
339                 gpgsm_status2 (ctrl, STATUS_ERROR, "decrypt.algorithm",
340                                numbuf, algoid?algoid:"?", NULL);
341                 audit_log_s (ctrl->audit, AUDIT_BAD_DATA_CIPHER_ALGO, algoid);
342               }
343
344               /* If it seems that this is not an encrypted message we
345                  return a more sensible error code. */
346               if (!algoid)
347                 rc = gpg_error (GPG_ERR_NO_DATA);
348
349               goto leave;
350             }
351
352           audit_log_i (ctrl->audit, AUDIT_DATA_CIPHER_ALGO, algo);
353           dfparm.algo = algo;
354           dfparm.mode = mode;
355           dfparm.blklen = gcry_cipher_get_algo_blklen (algo);
356           if (dfparm.blklen > sizeof (dfparm.helpblock))
357             return gpg_error (GPG_ERR_BUG);
358
359           rc = ksba_cms_get_content_enc_iv (cms,
360                                             dfparm.iv,
361                                             sizeof (dfparm.iv),
362                                             &dfparm.ivlen);
363           if (rc)
364             {
365               log_error ("error getting IV: %s\n", gpg_strerror (rc));
366               goto leave;
367             }
368
369           for (recp=0; !any_key; recp++)
370             {
371               char *issuer;
372               ksba_sexp_t serial;
373               ksba_sexp_t enc_val;
374               char *hexkeygrip = NULL;
375               char *desc = NULL;
376               char kidbuf[16+1];
377
378               *kidbuf = 0;
379
380               rc = ksba_cms_get_issuer_serial (cms, recp, &issuer, &serial);
381               if (rc == -1 && recp)
382                 break; /* no more recipients */
383               audit_log_i (ctrl->audit, AUDIT_NEW_RECP, recp);
384               if (rc)
385                 log_error ("recp %d - error getting info: %s\n",
386                            recp, gpg_strerror (rc));
387               else
388                 {
389                   ksba_cert_t cert = NULL;
390
391                   log_debug ("recp %d - issuer: '%s'\n",
392                              recp, issuer? issuer:"[NONE]");
393                   log_debug ("recp %d - serial: ", recp);
394                   gpgsm_dump_serial (serial);
395                   log_printf ("\n");
396
397                   if (ctrl->audit)
398                     {
399                       char *tmpstr = gpgsm_format_sn_issuer (serial, issuer);
400                       audit_log_s (ctrl->audit, AUDIT_RECP_NAME, tmpstr);
401                       xfree (tmpstr);
402                     }
403
404                   keydb_search_reset (kh);
405                   rc = keydb_search_issuer_sn (ctrl, kh, issuer, serial);
406                   if (rc)
407                     {
408                       log_error ("failed to find the certificate: %s\n",
409                                  gpg_strerror(rc));
410                       goto oops;
411                     }
412
413                   rc = keydb_get_cert (kh, &cert);
414                   if (rc)
415                     {
416                       log_error ("failed to get cert: %s\n", gpg_strerror (rc));
417                       goto oops;
418                     }
419
420                   /* Print the ENC_TO status line.  Note that we can
421                      do so only if we have the certificate.  This is
422                      in contrast to gpg where the keyID is commonly
423                      included in the encrypted messages. It is too
424                      cumbersome to retrieve the used algorithm, thus
425                      we don't print it for now.  We also record the
426                      keyid for later use.  */
427                   {
428                     unsigned long kid[2];
429
430                     kid[0] = gpgsm_get_short_fingerprint (cert, kid+1);
431                     snprintf (kidbuf, sizeof kidbuf, "%08lX%08lX",
432                               kid[1], kid[0]);
433                     gpgsm_status2 (ctrl, STATUS_ENC_TO,
434                                    kidbuf, "0", "0", NULL);
435                   }
436
437                   /* Put the certificate into the audit log.  */
438                   audit_log_cert (ctrl->audit, AUDIT_SAVE_CERT, cert, 0);
439
440                   /* Just in case there is a problem with the own
441                      certificate we print this message - should never
442                      happen of course */
443                   rc = gpgsm_cert_use_decrypt_p (cert);
444                   if (rc)
445                     {
446                       char numbuf[50];
447                       sprintf (numbuf, "%d", rc);
448                       gpgsm_status2 (ctrl, STATUS_ERROR, "decrypt.keyusage",
449                                      numbuf, NULL);
450                       rc = 0;
451                     }
452
453                   hexkeygrip = gpgsm_get_keygrip_hexstring (cert);
454                   desc = gpgsm_format_keydesc (cert);
455
456                 oops:
457                   xfree (issuer);
458                   xfree (serial);
459                   ksba_cert_release (cert);
460                 }
461
462               if (!hexkeygrip)
463                 ;
464               else if (!(enc_val = ksba_cms_get_enc_val (cms, recp)))
465                 log_error ("recp %d - error getting encrypted session key\n",
466                            recp);
467               else
468                 {
469                   rc = prepare_decryption (ctrl,
470                                            hexkeygrip, desc, enc_val, &dfparm);
471                   xfree (enc_val);
472                   if (rc)
473                     {
474                       log_info ("decrypting session key failed: %s\n",
475                                 gpg_strerror (rc));
476                       if (gpg_err_code (rc) == GPG_ERR_NO_SECKEY && *kidbuf)
477                         gpgsm_status2 (ctrl, STATUS_NO_SECKEY, kidbuf, NULL);
478                     }
479                   else
480                     { /* setup the bulk decrypter */
481                       any_key = 1;
482                       ksba_writer_set_filter (writer,
483                                               decrypt_filter,
484                                               &dfparm);
485                     }
486                   audit_log_ok (ctrl->audit, AUDIT_RECP_RESULT, rc);
487                 }
488               xfree (hexkeygrip);
489               xfree (desc);
490             }
491
492           /* If we write an audit log add the unused recipients to the
493              log as well.  */
494           if (ctrl->audit && any_key)
495             {
496               for (;; recp++)
497                 {
498                   char *issuer;
499                   ksba_sexp_t serial;
500                   int tmp_rc;
501
502                   tmp_rc = ksba_cms_get_issuer_serial (cms, recp,
503                                                        &issuer, &serial);
504                   if (tmp_rc == -1)
505                     break; /* no more recipients */
506                   audit_log_i (ctrl->audit, AUDIT_NEW_RECP, recp);
507                   if (tmp_rc)
508                     log_error ("recp %d - error getting info: %s\n",
509                                recp, gpg_strerror (rc));
510                   else
511                     {
512                       char *tmpstr = gpgsm_format_sn_issuer (serial, issuer);
513                       audit_log_s (ctrl->audit, AUDIT_RECP_NAME, tmpstr);
514                       xfree (tmpstr);
515                       xfree (issuer);
516                       xfree (serial);
517                     }
518                 }
519             }
520
521           if (!any_key)
522             {
523               rc = gpg_error (GPG_ERR_NO_SECKEY);
524               goto leave;
525             }
526         }
527       else if (stopreason == KSBA_SR_END_DATA)
528         {
529           ksba_writer_set_filter (writer, NULL, NULL);
530           if (dfparm.any_data)
531             { /* write the last block with padding removed */
532               int i, npadding = dfparm.lastblock[dfparm.blklen-1];
533               if (!npadding || npadding > dfparm.blklen)
534                 {
535                   log_error ("invalid padding with value %d\n", npadding);
536                   rc = gpg_error (GPG_ERR_INV_DATA);
537                   goto leave;
538                 }
539               rc = ksba_writer_write (writer,
540                                       dfparm.lastblock,
541                                       dfparm.blklen - npadding);
542               if (rc)
543                 goto leave;
544
545               for (i=dfparm.blklen - npadding; i < dfparm.blklen; i++)
546                 {
547                   if (dfparm.lastblock[i] != npadding)
548                     {
549                       log_error ("inconsistent padding\n");
550                       rc = gpg_error (GPG_ERR_INV_DATA);
551                       goto leave;
552                     }
553                 }
554             }
555         }
556
557     }
558   while (stopreason != KSBA_SR_READY);
559
560   rc = gpgsm_finish_writer (b64writer);
561   if (rc)
562     {
563       log_error ("write failed: %s\n", gpg_strerror (rc));
564       goto leave;
565     }
566   gpgsm_status (ctrl, STATUS_DECRYPTION_OKAY, NULL);
567
568
569  leave:
570   audit_log_ok (ctrl->audit, AUDIT_DECRYPTION_RESULT, rc);
571   if (rc)
572     {
573       gpgsm_status (ctrl, STATUS_DECRYPTION_FAILED, NULL);
574       log_error ("message decryption failed: %s <%s>\n",
575                  gpg_strerror (rc), gpg_strsource (rc));
576     }
577   ksba_cms_release (cms);
578   gpgsm_destroy_reader (b64reader);
579   gpgsm_destroy_writer (b64writer);
580   keydb_release (kh);
581   es_fclose (in_fp);
582   if (dfparm.hd)
583     gcry_cipher_close (dfparm.hd);
584   return rc;
585 }