gpg,gpgsm: Emit status code ENCRYPTION_COMPLIANCE_MODE.
[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   /* Create a session key */
424   dek = xtrycalloc_secure (1, sizeof *dek);
425   if (!dek)
426     rc = out_of_core ();
427   else
428   {
429     dek->algoid = opt.def_cipher_algoid;
430     rc = init_dek (dek);
431   }
432   if (rc)
433     {
434       log_error ("failed to create the session key: %s\n",
435                  gpg_strerror (rc));
436       goto leave;
437     }
438
439   err = ksba_cms_set_content_enc_algo (cms, dek->algoid, dek->iv, dek->ivlen);
440   if (err)
441     {
442       log_error ("ksba_cms_set_content_enc_algo failed: %s\n",
443                  gpg_strerror (err));
444       rc = err;
445       goto leave;
446     }
447
448   encparm.dek = dek;
449   /* Use a ~8k (AES) or ~4k (3DES) buffer */
450   encparm.bufsize = 500 * dek->ivlen;
451   encparm.buffer = xtrymalloc (encparm.bufsize);
452   if (!encparm.buffer)
453     {
454       rc = out_of_core ();
455       goto leave;
456     }
457
458   audit_log_s (ctrl->audit, AUDIT_SESSION_KEY, dek->algoid);
459
460   compliant = gnupg_cipher_is_compliant (CO_DE_VS, dek->algo,
461                                          GCRY_CIPHER_MODE_CBC);
462
463   /* Gather certificates of recipients, encrypt the session key for
464      each and store them in the CMS object */
465   for (recpno = 0, cl = recplist; cl; recpno++, cl = cl->next)
466     {
467       unsigned char *encval;
468       unsigned int nbits;
469       int pk_algo;
470
471       /* Check compliance.  */
472       pk_algo = gpgsm_get_key_algo_info (cl->cert, &nbits);
473       if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_ENCRYPTION, pk_algo,
474                                  NULL, nbits, NULL))
475         {
476           log_error ("certificate ID 0x%08lX not suitable for "
477                      "encryption while in %s mode\n",
478                      gpgsm_get_short_fingerprint (cl->cert, NULL),
479                      gnupg_compliance_option_string (opt.compliance));
480           rc = gpg_error (GPG_ERR_PUBKEY_ALGO);
481           goto leave;
482         }
483
484       /* Fixme: When adding ECC we need to provide the curvename and
485        * the key to gnupg_pk_is_compliant.  */
486       if (compliant
487           && !gnupg_pk_is_compliant (CO_DE_VS, pk_algo, NULL, nbits, NULL))
488         compliant = 0;
489
490       rc = encrypt_dek (dek, cl->cert, &encval);
491       if (rc)
492         {
493           audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, rc);
494           log_error ("encryption failed for recipient no. %d: %s\n",
495                      recpno, gpg_strerror (rc));
496           goto leave;
497         }
498
499       err = ksba_cms_add_recipient (cms, cl->cert);
500       if (err)
501         {
502           audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
503           log_error ("ksba_cms_add_recipient failed: %s\n",
504                      gpg_strerror (err));
505           rc = err;
506           xfree (encval);
507           goto leave;
508         }
509
510       err = ksba_cms_set_enc_val (cms, recpno, encval);
511       xfree (encval);
512       audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
513       if (err)
514         {
515           log_error ("ksba_cms_set_enc_val failed: %s\n",
516                      gpg_strerror (err));
517           rc = err;
518           goto leave;
519         }
520     }
521
522   if (compliant)
523     gpgsm_status (ctrl, STATUS_ENCRYPTION_COMPLIANCE_MODE,
524                   gnupg_status_compliance_flag (CO_DE_VS));
525
526   /* Main control loop for encryption. */
527   recpno = 0;
528   do
529     {
530       err = ksba_cms_build (cms, &stopreason);
531       if (err)
532         {
533           log_debug ("ksba_cms_build failed: %s\n", gpg_strerror (err));
534           rc = err;
535           goto leave;
536         }
537     }
538   while (stopreason != KSBA_SR_READY);
539
540   if (encparm.readerror)
541     {
542       log_error ("error reading input: %s\n", strerror (encparm.readerror));
543       rc = gpg_error (gpg_err_code_from_errno (encparm.readerror));
544       goto leave;
545     }
546
547
548   rc = gnupg_ksba_finish_writer (b64writer);
549   if (rc)
550     {
551       log_error ("write failed: %s\n", gpg_strerror (rc));
552       goto leave;
553     }
554   audit_log (ctrl->audit, AUDIT_ENCRYPTION_DONE);
555   log_info ("encrypted data created\n");
556
557  leave:
558   ksba_cms_release (cms);
559   gnupg_ksba_destroy_writer (b64writer);
560   ksba_reader_release (reader);
561   keydb_release (kh);
562   xfree (dek);
563   es_fclose (data_fp);
564   xfree (encparm.buffer);
565   return rc;
566 }