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