gpgscm: Use boxed values for source locations.
[gnupg.git] / sm / encrypt.c
1 /* encrypt.c - Encrypt a message
2  * Copyright (C) 2001, 2003, 2004, 2007, 2008,
3  *               2010 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 #include <errno.h>
26 #include <unistd.h>
27 #include <time.h>
28 #include <assert.h>
29
30 #include "gpgsm.h"
31 #include <gcrypt.h>
32 #include <ksba.h>
33
34 #include "keydb.h"
35 #include "i18n.h"
36
37
38 struct dek_s {
39   const char *algoid;
40   int algo;
41   gcry_cipher_hd_t chd;
42   char key[32];
43   int keylen;
44   char iv[32];
45   int ivlen;
46 };
47 typedef struct dek_s *DEK;
48
49
50 /* Callback parameters for the encryption.  */
51 struct encrypt_cb_parm_s
52 {
53   estream_t fp;
54   DEK dek;
55   int eof_seen;
56   int ready;
57   int readerror;
58   int bufsize;
59   unsigned char *buffer;
60   int buflen;
61 };
62
63
64
65
66 \f
67 /* Initialize the data encryption key (session key). */
68 static int
69 init_dek (DEK dek)
70 {
71   int rc=0, mode, i;
72
73   dek->algo = gcry_cipher_map_name (dek->algoid);
74   mode = gcry_cipher_mode_from_oid (dek->algoid);
75   if (!dek->algo || !mode)
76     {
77       log_error ("unsupported algorithm '%s'\n", dek->algoid);
78       return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
79     }
80
81   /* Extra check for algorithms we consider to be too weak for
82      encryption, although we support them for decryption.  Note that
83      there is another check below discriminating on the key length. */
84   switch (dek->algo)
85     {
86     case GCRY_CIPHER_DES:
87     case GCRY_CIPHER_RFC2268_40:
88       log_error ("cipher algorithm '%s' not allowed: too weak\n",
89                  gnupg_cipher_algo_name (dek->algo));
90       return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
91     default:
92       break;
93     }
94
95   dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
96   if (!dek->keylen || dek->keylen > sizeof (dek->key))
97     return gpg_error (GPG_ERR_BUG);
98
99   dek->ivlen = gcry_cipher_get_algo_blklen (dek->algo);
100   if (!dek->ivlen || dek->ivlen > sizeof (dek->iv))
101     return gpg_error (GPG_ERR_BUG);
102
103   /* Make sure we don't use weak keys. */
104   if (dek->keylen < 100/8)
105     {
106       log_error ("key length of '%s' too small\n", dek->algoid);
107       return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
108     }
109
110   rc = gcry_cipher_open (&dek->chd, dek->algo, mode, GCRY_CIPHER_SECURE);
111   if (rc)
112     {
113       log_error ("failed to create cipher context: %s\n", gpg_strerror (rc));
114       return rc;
115     }
116
117   for (i=0; i < 8; i++)
118     {
119       gcry_randomize (dek->key, dek->keylen, GCRY_STRONG_RANDOM );
120       rc = gcry_cipher_setkey (dek->chd, dek->key, dek->keylen);
121       if (gpg_err_code (rc) != GPG_ERR_WEAK_KEY)
122         break;
123       log_info(_("weak key created - retrying\n") );
124     }
125   if (rc)
126     {
127       log_error ("failed to set the key: %s\n", gpg_strerror (rc));
128       gcry_cipher_close (dek->chd);
129       dek->chd = NULL;
130       return rc;
131     }
132
133   gcry_create_nonce (dek->iv, dek->ivlen);
134   rc = gcry_cipher_setiv (dek->chd, dek->iv, dek->ivlen);
135   if (rc)
136     {
137       log_error ("failed to set the IV: %s\n", gpg_strerror (rc));
138       gcry_cipher_close (dek->chd);
139       dek->chd = NULL;
140       return rc;
141     }
142
143   return 0;
144 }
145
146
147 static int
148 encode_session_key (DEK dek, gcry_sexp_t * r_data)
149 {
150   gcry_sexp_t data;
151   char *p;
152   int rc;
153
154   p = xtrymalloc (64 + 2 * dek->keylen);
155   if (!p)
156     return gpg_error_from_syserror ();
157   strcpy (p, "(data\n (flags pkcs1)\n (value #");
158   bin2hex (dek->key, dek->keylen, p + strlen (p));
159   strcat (p, "#))\n");
160   rc = gcry_sexp_sscan (&data, NULL, p, strlen (p));
161   xfree (p);
162   *r_data = data;
163   return rc;
164 }
165
166
167 /* Encrypt the DEK under the key contained in CERT and return it as a
168    canonical S-Exp in encval. */
169 static int
170 encrypt_dek (const DEK dek, ksba_cert_t cert, unsigned char **encval)
171 {
172   gcry_sexp_t s_ciph, s_data, s_pkey;
173   int rc;
174   ksba_sexp_t buf;
175   size_t len;
176
177   *encval = NULL;
178
179   /* get the key from the cert */
180   buf = ksba_cert_get_public_key (cert);
181   if (!buf)
182     {
183       log_error ("no public key for recipient\n");
184       return gpg_error (GPG_ERR_NO_PUBKEY);
185     }
186   len = gcry_sexp_canon_len (buf, 0, NULL, NULL);
187   if (!len)
188     {
189       log_error ("libksba did not return a proper S-Exp\n");
190       return gpg_error (GPG_ERR_BUG);
191     }
192   rc = gcry_sexp_sscan (&s_pkey, NULL, (char*)buf, len);
193   xfree (buf); buf = NULL;
194   if (rc)
195     {
196       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
197       return rc;
198     }
199
200   /* Put the encoded cleartext into a simple list. */
201   s_data = NULL; /* (avoid compiler warning) */
202   rc = encode_session_key (dek, &s_data);
203   if (rc)
204     {
205       log_error ("encode_session_key failed: %s\n", gpg_strerror (rc));
206       return rc;
207     }
208
209   /* pass it to libgcrypt */
210   rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
211   gcry_sexp_release (s_data);
212   gcry_sexp_release (s_pkey);
213
214   /* Reformat it. */
215   if (!rc)
216     {
217       rc = make_canon_sexp (s_ciph, encval, NULL);
218       gcry_sexp_release (s_ciph);
219     }
220   return rc;
221 }
222
223
224 \f
225 /* do the actual encryption */
226 static int
227 encrypt_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
228 {
229   struct encrypt_cb_parm_s *parm = cb_value;
230   int blklen = parm->dek->ivlen;
231   unsigned char *p;
232   size_t n;
233
234   *nread = 0;
235   if (!buffer)
236     return -1; /* not supported */
237
238   if (parm->ready)
239     return -1;
240
241   if (count < blklen)
242     BUG ();
243
244   if (!parm->eof_seen)
245     { /* fillup the buffer */
246       p = parm->buffer;
247       for (n=parm->buflen; n < parm->bufsize; n++)
248         {
249           int c = es_getc (parm->fp);
250           if (c == EOF)
251             {
252               if (es_ferror (parm->fp))
253                 {
254                   parm->readerror = errno;
255                   return -1;
256                 }
257               parm->eof_seen = 1;
258               break;
259             }
260           p[n] = c;
261         }
262       parm->buflen = n;
263     }
264
265   n = parm->buflen < count? parm->buflen : count;
266   n = n/blklen * blklen;
267   if (n)
268     { /* encrypt the stuff */
269       gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
270       *nread = n;
271       /* Who cares about cycles, take the easy way and shift the buffer */
272       parm->buflen -= n;
273       memmove (parm->buffer, parm->buffer+n, parm->buflen);
274     }
275   else if (parm->eof_seen)
276     { /* no complete block but eof: add padding */
277       /* fixme: we should try to do this also in the above code path */
278       int i, npad = blklen - (parm->buflen % blklen);
279       p = parm->buffer;
280       for (n=parm->buflen, i=0; n < parm->bufsize && i < npad; n++, i++)
281         p[n] = npad;
282       gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
283       *nread = n;
284       parm->ready = 1;
285     }
286
287   return 0;
288 }
289
290
291
292 \f
293 /* Perform an encrypt operation.
294
295    Encrypt the data received on DATA-FD and write it to OUT_FP.  The
296    recipients are take from the certificate given in recplist; if this
297    is NULL it will be encrypted for a default recipient */
298 int
299 gpgsm_encrypt (ctrl_t ctrl, certlist_t recplist, int data_fd, estream_t out_fp)
300 {
301   int rc = 0;
302   Base64Context b64writer = NULL;
303   gpg_error_t err;
304   ksba_writer_t writer;
305   ksba_reader_t reader = NULL;
306   ksba_cms_t cms = NULL;
307   ksba_stop_reason_t stopreason;
308   KEYDB_HANDLE kh = NULL;
309   struct encrypt_cb_parm_s encparm;
310   DEK dek = NULL;
311   int recpno;
312   estream_t data_fp = NULL;
313   certlist_t cl;
314   int count;
315
316   memset (&encparm, 0, sizeof encparm);
317
318   audit_set_type (ctrl->audit, AUDIT_TYPE_ENCRYPT);
319
320   /* Check that the certificate list is not empty and that at least
321      one certificate is not flagged as encrypt_to; i.e. is a real
322      recipient. */
323   for (cl = recplist; cl; cl = cl->next)
324     if (!cl->is_encrypt_to)
325       break;
326   if (!cl)
327     {
328       log_error(_("no valid recipients given\n"));
329       gpgsm_status (ctrl, STATUS_NO_RECP, "0");
330       audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, 0);
331       rc = gpg_error (GPG_ERR_NO_PUBKEY);
332       goto leave;
333     }
334
335   for (count = 0, cl = recplist; cl; cl = cl->next)
336     count++;
337   audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, count);
338
339   kh = keydb_new ();
340   if (!kh)
341     {
342       log_error (_("failed to allocate keyDB handle\n"));
343       rc = gpg_error (GPG_ERR_GENERAL);
344       goto leave;
345     }
346
347   /* Fixme:  We should use the unlocked version of the es functions.  */
348   data_fp = es_fdopen_nc (data_fd, "rb");
349   if (!data_fp)
350     {
351       rc = gpg_error_from_syserror ();
352       log_error ("fdopen() failed: %s\n", strerror (errno));
353       goto leave;
354     }
355
356   err = ksba_reader_new (&reader);
357   if (err)
358       rc = err;
359   if (!rc)
360     rc = ksba_reader_set_cb (reader, encrypt_cb, &encparm);
361   if (rc)
362       goto leave;
363
364   encparm.fp = data_fp;
365
366   ctrl->pem_name = "ENCRYPTED MESSAGE";
367   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
368   if (rc)
369     {
370       log_error ("can't create writer: %s\n", gpg_strerror (rc));
371       goto leave;
372     }
373
374   err = ksba_cms_new (&cms);
375   if (err)
376     {
377       rc = err;
378       goto leave;
379     }
380
381   err = ksba_cms_set_reader_writer (cms, reader, writer);
382   if (err)
383     {
384       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
385                  gpg_strerror (err));
386       rc = err;
387       goto leave;
388     }
389
390   audit_log (ctrl->audit, AUDIT_GOT_DATA);
391
392   /* We are going to create enveloped data with uninterpreted data as
393      inner content */
394   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_ENVELOPED_DATA);
395   if (!err)
396     err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
397   if (err)
398     {
399       log_debug ("ksba_cms_set_content_type failed: %s\n",
400                  gpg_strerror (err));
401       rc = err;
402       goto leave;
403     }
404
405   /* Create a session key */
406   dek = xtrycalloc_secure (1, sizeof *dek);
407   if (!dek)
408     rc = out_of_core ();
409   else
410   {
411     dek->algoid = opt.def_cipher_algoid;
412     rc = init_dek (dek);
413   }
414   if (rc)
415     {
416       log_error ("failed to create the session key: %s\n",
417                  gpg_strerror (rc));
418       goto leave;
419     }
420
421   err = ksba_cms_set_content_enc_algo (cms, dek->algoid, dek->iv, dek->ivlen);
422   if (err)
423     {
424       log_error ("ksba_cms_set_content_enc_algo failed: %s\n",
425                  gpg_strerror (err));
426       rc = err;
427       goto leave;
428     }
429
430   encparm.dek = dek;
431   /* Use a ~8k (AES) or ~4k (3DES) buffer */
432   encparm.bufsize = 500 * dek->ivlen;
433   encparm.buffer = xtrymalloc (encparm.bufsize);
434   if (!encparm.buffer)
435     {
436       rc = out_of_core ();
437       goto leave;
438     }
439
440   audit_log_s (ctrl->audit, AUDIT_SESSION_KEY, dek->algoid);
441
442   /* Gather certificates of recipients, encrypt the session key for
443      each and store them in the CMS object */
444   for (recpno = 0, cl = recplist; cl; recpno++, cl = cl->next)
445     {
446       unsigned char *encval;
447
448       rc = encrypt_dek (dek, cl->cert, &encval);
449       if (rc)
450         {
451           audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, rc);
452           log_error ("encryption failed for recipient no. %d: %s\n",
453                      recpno, gpg_strerror (rc));
454           goto leave;
455         }
456
457       err = ksba_cms_add_recipient (cms, cl->cert);
458       if (err)
459         {
460           audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
461           log_error ("ksba_cms_add_recipient failed: %s\n",
462                      gpg_strerror (err));
463           rc = err;
464           xfree (encval);
465           goto leave;
466         }
467
468       err = ksba_cms_set_enc_val (cms, recpno, encval);
469       xfree (encval);
470       audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
471       if (err)
472         {
473           log_error ("ksba_cms_set_enc_val failed: %s\n",
474                      gpg_strerror (err));
475           rc = err;
476           goto leave;
477         }
478     }
479
480   /* Main control loop for encryption. */
481   recpno = 0;
482   do
483     {
484       err = ksba_cms_build (cms, &stopreason);
485       if (err)
486         {
487           log_debug ("ksba_cms_build failed: %s\n", gpg_strerror (err));
488           rc = err;
489           goto leave;
490         }
491     }
492   while (stopreason != KSBA_SR_READY);
493
494   if (encparm.readerror)
495     {
496       log_error ("error reading input: %s\n", strerror (encparm.readerror));
497       rc = gpg_error (gpg_err_code_from_errno (encparm.readerror));
498       goto leave;
499     }
500
501
502   rc = gpgsm_finish_writer (b64writer);
503   if (rc)
504     {
505       log_error ("write failed: %s\n", gpg_strerror (rc));
506       goto leave;
507     }
508   audit_log (ctrl->audit, AUDIT_ENCRYPTION_DONE);
509   log_info ("encrypted data created\n");
510
511  leave:
512   ksba_cms_release (cms);
513   gpgsm_destroy_writer (b64writer);
514   ksba_reader_release (reader);
515   keydb_release (kh);
516   xfree (dek);
517   es_fclose (data_fp);
518   xfree (encparm.buffer);
519   return rc;
520 }