indent,i18n: Make some new strings translatable. Wrap too long lines.
[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
317   memset (&encparm, 0, sizeof encparm);
318
319   audit_set_type (ctrl->audit, AUDIT_TYPE_ENCRYPT);
320
321   /* Check that the certificate list is not empty and that at least
322      one certificate is not flagged as encrypt_to; i.e. is a real
323      recipient. */
324   for (cl = recplist; cl; cl = cl->next)
325     if (!cl->is_encrypt_to)
326       break;
327   if (!cl)
328     {
329       log_error(_("no valid recipients given\n"));
330       gpgsm_status (ctrl, STATUS_NO_RECP, "0");
331       audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, 0);
332       rc = gpg_error (GPG_ERR_NO_PUBKEY);
333       goto leave;
334     }
335
336   for (count = 0, cl = recplist; cl; cl = cl->next)
337     count++;
338   audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, count);
339
340   kh = keydb_new ();
341   if (!kh)
342     {
343       log_error (_("failed to allocate keyDB handle\n"));
344       rc = gpg_error (GPG_ERR_GENERAL);
345       goto leave;
346     }
347
348   /* Fixme:  We should use the unlocked version of the es functions.  */
349   data_fp = es_fdopen_nc (data_fd, "rb");
350   if (!data_fp)
351     {
352       rc = gpg_error_from_syserror ();
353       log_error ("fdopen() failed: %s\n", strerror (errno));
354       goto leave;
355     }
356
357   err = ksba_reader_new (&reader);
358   if (err)
359       rc = err;
360   if (!rc)
361     rc = ksba_reader_set_cb (reader, encrypt_cb, &encparm);
362   if (rc)
363       goto leave;
364
365   encparm.fp = data_fp;
366
367   ctrl->pem_name = "ENCRYPTED MESSAGE";
368   rc = gnupg_ksba_create_writer
369     (&b64writer, ((ctrl->create_pem? GNUPG_KSBA_IO_PEM : 0)
370                   | (ctrl->create_base64? GNUPG_KSBA_IO_BASE64 : 0)),
371      ctrl->pem_name, out_fp, &writer);
372   if (rc)
373     {
374       log_error ("can't create writer: %s\n", gpg_strerror (rc));
375       goto leave;
376     }
377
378   err = ksba_cms_new (&cms);
379   if (err)
380     {
381       rc = err;
382       goto leave;
383     }
384
385   err = ksba_cms_set_reader_writer (cms, reader, writer);
386   if (err)
387     {
388       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
389                  gpg_strerror (err));
390       rc = err;
391       goto leave;
392     }
393
394   audit_log (ctrl->audit, AUDIT_GOT_DATA);
395
396   /* We are going to create enveloped data with uninterpreted data as
397      inner content */
398   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_ENVELOPED_DATA);
399   if (!err)
400     err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
401   if (err)
402     {
403       log_debug ("ksba_cms_set_content_type failed: %s\n",
404                  gpg_strerror (err));
405       rc = err;
406       goto leave;
407     }
408
409   /* Check compliance.  */
410   if (!gnupg_cipher_is_allowed
411       (opt.compliance, 1, gcry_cipher_map_name (opt.def_cipher_algoid),
412        gcry_cipher_mode_from_oid (opt.def_cipher_algoid)))
413     {
414       log_error (_("you may not use cipher algorithm '%s'"
415                    " while in %s mode\n"),
416                  opt.def_cipher_algoid,
417                  gnupg_compliance_option_string (opt.compliance));
418       rc = gpg_error (GPG_ERR_CIPHER_ALGO);
419       goto leave;
420     }
421
422   /* Create a session key */
423   dek = xtrycalloc_secure (1, sizeof *dek);
424   if (!dek)
425     rc = out_of_core ();
426   else
427   {
428     dek->algoid = opt.def_cipher_algoid;
429     rc = init_dek (dek);
430   }
431   if (rc)
432     {
433       log_error ("failed to create the session key: %s\n",
434                  gpg_strerror (rc));
435       goto leave;
436     }
437
438   err = ksba_cms_set_content_enc_algo (cms, dek->algoid, dek->iv, dek->ivlen);
439   if (err)
440     {
441       log_error ("ksba_cms_set_content_enc_algo failed: %s\n",
442                  gpg_strerror (err));
443       rc = err;
444       goto leave;
445     }
446
447   encparm.dek = dek;
448   /* Use a ~8k (AES) or ~4k (3DES) buffer */
449   encparm.bufsize = 500 * dek->ivlen;
450   encparm.buffer = xtrymalloc (encparm.bufsize);
451   if (!encparm.buffer)
452     {
453       rc = out_of_core ();
454       goto leave;
455     }
456
457   audit_log_s (ctrl->audit, AUDIT_SESSION_KEY, dek->algoid);
458
459   /* Gather certificates of recipients, encrypt the session key for
460      each and store them in the CMS object */
461   for (recpno = 0, cl = recplist; cl; recpno++, cl = cl->next)
462     {
463       unsigned char *encval;
464
465       /* Check compliance.  */
466       unsigned int nbits;
467       int pk_algo = gpgsm_get_key_algo_info (cl->cert, &nbits);
468       if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_ENCRYPTION, pk_algo,
469                                  NULL, nbits, NULL))
470         {
471           log_error ("certificate ID 0x%08lX not suitable for "
472                      "encryption while in %s mode\n",
473                      gpgsm_get_short_fingerprint (cl->cert, NULL),
474                      gnupg_compliance_option_string (opt.compliance));
475           rc = gpg_error (GPG_ERR_PUBKEY_ALGO);
476           goto leave;
477         }
478
479       rc = encrypt_dek (dek, cl->cert, &encval);
480       if (rc)
481         {
482           audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, rc);
483           log_error ("encryption failed for recipient no. %d: %s\n",
484                      recpno, gpg_strerror (rc));
485           goto leave;
486         }
487
488       err = ksba_cms_add_recipient (cms, cl->cert);
489       if (err)
490         {
491           audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
492           log_error ("ksba_cms_add_recipient failed: %s\n",
493                      gpg_strerror (err));
494           rc = err;
495           xfree (encval);
496           goto leave;
497         }
498
499       err = ksba_cms_set_enc_val (cms, recpno, encval);
500       xfree (encval);
501       audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
502       if (err)
503         {
504           log_error ("ksba_cms_set_enc_val failed: %s\n",
505                      gpg_strerror (err));
506           rc = err;
507           goto leave;
508         }
509     }
510
511   /* Main control loop for encryption. */
512   recpno = 0;
513   do
514     {
515       err = ksba_cms_build (cms, &stopreason);
516       if (err)
517         {
518           log_debug ("ksba_cms_build failed: %s\n", gpg_strerror (err));
519           rc = err;
520           goto leave;
521         }
522     }
523   while (stopreason != KSBA_SR_READY);
524
525   if (encparm.readerror)
526     {
527       log_error ("error reading input: %s\n", strerror (encparm.readerror));
528       rc = gpg_error (gpg_err_code_from_errno (encparm.readerror));
529       goto leave;
530     }
531
532
533   rc = gnupg_ksba_finish_writer (b64writer);
534   if (rc)
535     {
536       log_error ("write failed: %s\n", gpg_strerror (rc));
537       goto leave;
538     }
539   audit_log (ctrl->audit, AUDIT_ENCRYPTION_DONE);
540   log_info ("encrypted data created\n");
541
542  leave:
543   ksba_cms_release (cms);
544   gnupg_ksba_destroy_writer (b64writer);
545   ksba_reader_release (reader);
546   keydb_release (kh);
547   xfree (dek);
548   es_fclose (data_fp);
549   xfree (encparm.buffer);
550   return rc;
551 }