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