Key generation and signing using the OpenPGP card does rudimentary work.
[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 encryptionkey (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_randomize (dek->iv, dek->ivlen, GCRY_STRONG_RANDOM);
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 /* Encode the session key. NBITS is the number of bits which should be
130    used for packing the session key.  returns: An mpi with the session
131    key (caller must free) */
132 static gcry_mpi_t
133 encode_session_key (DEK dek, unsigned int nbits)
134 {
135   int nframe = (nbits+7) / 8;
136   byte *p;
137   byte *frame;
138   int i,n;
139   gcry_mpi_t a;
140
141   if (dek->keylen + 7 > nframe || !nframe)
142     log_bug ("can't encode a %d bit key in a %d bits frame\n",
143              dek->keylen*8, nbits );
144
145   /* We encode the session key in this way:
146    *
147    *       0  2  RND(n bytes)  0  KEY(k bytes)
148    *
149    * (But how can we store the leading 0 - the external representaion
150    *    of MPIs doesn't allow leading zeroes =:-)
151    *
152    * RND are non-zero random bytes.
153    * KEY is the encryption key (session key) 
154    */
155
156   frame = gcry_xmalloc_secure (nframe);
157   n = 0;
158   frame[n++] = 0;
159   frame[n++] = 2;
160   i = nframe - 3 - dek->keylen;
161   assert (i > 0);
162   p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
163   /* replace zero bytes by new values */
164   for (;;)
165     {
166       int j, k;
167       byte *pp;
168
169       /* count the zero bytes */
170       for(j=k=0; j < i; j++ )
171         {
172           if( !p[j] )
173             k++;
174         }
175       if( !k )
176         break; /* okay: no zero bytes */
177
178       k += k/128; /* better get some more */
179       pp = gcry_random_bytes_secure (k, GCRY_STRONG_RANDOM);
180       for (j=0; j < i && k; j++)
181         {
182           if( !p[j] )
183             p[j] = pp[--k];
184         }
185       xfree (pp);
186     }
187   memcpy (frame+n, p, i);
188   xfree (p);
189
190   n += i;
191   frame[n++] = 0;
192   memcpy (frame+n, dek->key, dek->keylen);
193   n += dek->keylen;
194   assert (n == nframe);
195   if (gcry_mpi_scan (&a, GCRYMPI_FMT_USG, frame, &nframe) )
196     BUG ();
197   gcry_free(frame);
198
199   return a;
200 }
201
202
203
204 /* encrypt the DEK under the key contained in CERT and return it as a
205    canonical S-Exp in encval */
206 static int
207 encrypt_dek (const DEK dek, KsbaCert cert, char **encval)
208 {
209   gcry_sexp_t s_ciph, s_data, s_pkey;
210   int rc;
211   KsbaSexp buf;
212   size_t len;
213
214   *encval = NULL;
215
216   /* get the key from the cert */
217   buf = ksba_cert_get_public_key (cert);
218   if (!buf)
219     {
220       log_error ("no public key for recipient\n");
221       return gpg_error (GPG_ERR_NO_PUBKEY);
222     }
223   len = gcry_sexp_canon_len (buf, 0, NULL, NULL);
224   if (!len)
225     {
226       log_error ("libksba did not return a proper S-Exp\n");
227       return gpg_error (GPG_ERR_BUG);
228     }
229   rc = gcry_sexp_sscan (&s_pkey, NULL, buf, len);
230   xfree (buf); buf = NULL;
231   if (rc)
232     {
233       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
234       return rc;
235     }
236
237   /* put the encoded cleartext into a simple list */
238   {
239     /* fixme: actually the pkcs-1 encoding should go into libgcrypt */
240     gcry_mpi_t data = encode_session_key (dek, gcry_pk_get_nbits (s_pkey));
241     if (!data)
242       {
243         gcry_mpi_release (data);
244         return gpg_error (GPG_ERR_GENERAL);
245       }
246     if (gcry_sexp_build (&s_data, NULL, "%m", data))
247       BUG ();
248     gcry_mpi_release (data);
249   }
250
251   /* pass it to libgcrypt */
252   rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
253   gcry_sexp_release (s_data);
254   gcry_sexp_release (s_pkey);
255   
256   /* reformat it */
257   len = gcry_sexp_sprint (s_ciph, GCRYSEXP_FMT_CANON, NULL, 0);
258   assert (len); 
259   buf = xtrymalloc (len);
260   if (!buf)
261     {
262       gpg_error_t tmperr = OUT_OF_CORE (errno);
263       gcry_sexp_release (s_ciph);
264       return tmperr;
265     }
266   len = gcry_sexp_sprint (s_ciph, GCRYSEXP_FMT_CANON, buf, len);
267   assert (len);
268
269   *encval = buf;
270   return 0;
271 }
272
273
274 \f
275 /* do the actual encryption */
276 static int
277 encrypt_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
278 {
279   struct encrypt_cb_parm_s *parm = cb_value;
280   int blklen = parm->dek->ivlen;
281   unsigned char *p;
282   size_t n;
283
284   *nread = 0;
285   if (!buffer)
286     return -1; /* not supported */
287
288   if (parm->ready)
289     return -1;
290
291   if (count < blklen)
292     BUG ();
293      
294   if (!parm->eof_seen)
295     { /* fillup the buffer */
296       p = parm->buffer;
297       for (n=parm->buflen; n < parm->bufsize; n++)
298         {
299           int c = getc (parm->fp);
300           if (c == EOF)
301             {
302               if (ferror (parm->fp))
303                 {
304                   parm->readerror = errno;
305                   return -1;
306                 }
307               parm->eof_seen = 1;
308               break; 
309             }
310           p[n] = c;
311         }
312       parm->buflen = n;
313     }
314   
315   n = parm->buflen < count? parm->buflen : count;
316   n = n/blklen * blklen;
317   if (n)
318     { /* encrypt the stuff */
319       gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
320       *nread = n;
321       /* Who cares about cycles, take the easy way and shift the buffer */
322       parm->buflen -= n;
323       memmove (parm->buffer, parm->buffer+n, parm->buflen);
324     }
325   else if (parm->eof_seen)
326     { /* no complete block but eof: add padding */
327       /* fixme: we should try to do this also in the above code path */
328       int i, npad = blklen - (parm->buflen % blklen);
329       p = parm->buffer;
330       for (n=parm->buflen, i=0; n < parm->bufsize && i < npad; n++, i++)
331         p[n] = npad;
332       gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
333       *nread = n;
334       parm->ready = 1;
335     }
336
337   return 0;
338 }
339
340
341
342 \f
343 /* Perform an encrypt operation.  
344
345    Encrypt the data received on DATA-FD and write it to OUT_FP.  The
346    recipients are take from the certificate given in recplist; if this
347    is NULL it will be encrypted for a default recipient */
348 int
349 gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
350 {
351   int rc = 0;
352   Base64Context b64writer = NULL;
353   KsbaError err;
354   KsbaWriter writer;
355   KsbaReader reader = NULL;
356   KsbaCMS cms = NULL;
357   KsbaStopReason stopreason;
358   KEYDB_HANDLE kh = NULL;
359   struct encrypt_cb_parm_s encparm;
360   DEK dek = NULL;
361   int recpno;
362   FILE *data_fp = NULL;
363   CERTLIST cl;
364
365   memset (&encparm, 0, sizeof encparm);
366
367   if (!recplist)
368     {
369       log_error(_("no valid recipients given\n"));
370       gpgsm_status (ctrl, STATUS_NO_RECP, "0");
371       rc = gpg_error (GPG_ERR_NO_PUBKEY);
372       goto leave;
373     }
374
375   kh = keydb_new (0);
376   if (!kh)
377     {
378       log_error (_("failed to allocated keyDB handle\n"));
379       rc = gpg_error (GPG_ERR_GENERAL);
380       goto leave;
381     }
382
383   data_fp = fdopen ( dup (data_fd), "rb");
384   if (!data_fp)
385     {
386       rc = gpg_error (gpg_err_code_from_errno (errno));
387       log_error ("fdopen() failed: %s\n", strerror (errno));
388       goto leave;
389     }
390
391   reader = ksba_reader_new ();
392   if (!reader)
393       rc = KSBA_Out_Of_Core;
394   if (!rc)
395     rc = ksba_reader_set_cb (reader, encrypt_cb, &encparm);
396   if (rc)
397     {
398       rc = map_ksba_err (rc);
399       goto leave;
400     }
401   encparm.fp = data_fp;
402
403   ctrl->pem_name = "ENCRYPTED MESSAGE";
404   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
405   if (rc)
406     {
407       log_error ("can't create writer: %s\n", gpg_strerror (rc));
408       goto leave;
409     }
410
411   cms = ksba_cms_new ();
412   if (!cms)
413     {
414       rc = gpg_error (GPG_ERR_ENOMEM);
415       goto leave;
416     }
417
418   err = ksba_cms_set_reader_writer (cms, reader, writer);
419   if (err)
420     {
421       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
422                  ksba_strerror (err));
423       rc = map_ksba_err (err);
424       goto leave;
425     }
426
427   /* We are going to create enveloped data with uninterpreted data as
428      inner content */
429   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_ENVELOPED_DATA);
430   if (!err)
431     err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
432   if (err)
433     {
434       log_debug ("ksba_cms_set_content_type failed: %s\n",
435                  ksba_strerror (err));
436       rc = map_ksba_err (err);
437       goto leave;
438     }
439
440   /* create a session key */
441   dek = xtrycalloc (1, sizeof *dek); /* hmmm: should we put it into secmem?*/
442   if (!dek)
443     rc = OUT_OF_CORE (errno);
444   else
445   {
446     dek->algoid = opt.def_cipher_algoid;
447     rc = init_dek (dek);
448   }
449   if (rc)
450     {
451       log_error ("failed to create the session key: %s\n",
452                  gpg_strerror (rc));
453       goto leave;
454     }
455
456   err = ksba_cms_set_content_enc_algo (cms, dek->algoid, dek->iv, dek->ivlen);
457   if (err)
458     {
459       log_error ("ksba_cms_set_content_enc_algo failed: %s\n",
460                  ksba_strerror (err));
461       rc = map_ksba_err (err);
462       goto leave;
463     }
464
465   encparm.dek = dek;
466   /* Use a ~8k (AES) or ~4k (3DES) buffer */
467   encparm.bufsize = 500 * dek->ivlen;
468   encparm.buffer = xtrymalloc (encparm.bufsize);
469   if (!encparm.buffer)
470     {
471       rc = OUT_OF_CORE (errno);
472       goto leave;
473     }
474
475   /* gather certificates of recipients, encrypt the session key for
476      each and store them in the CMS object */
477   for (recpno = 0, cl = recplist; cl; recpno++, cl = cl->next)
478     {
479       char *encval;
480       
481       rc = encrypt_dek (dek, cl->cert, &encval);
482       if (rc)
483         {
484           log_error ("encryption failed for recipient no. %d: %s\n",
485                      recpno, gpg_strerror (rc));
486           goto leave;
487         }
488       
489       err = ksba_cms_add_recipient (cms, cl->cert);
490       if (err)
491         {
492           log_error ("ksba_cms_add_recipient failed: %s\n",
493                      ksba_strerror (err));
494           rc = map_ksba_err (err);
495           xfree (encval);
496           goto leave;
497         }
498       
499       err = ksba_cms_set_enc_val (cms, recpno, encval);
500       xfree (encval);
501       if (err)
502         {
503           log_error ("ksba_cms_set_enc_val failed: %s\n",
504                      ksba_strerror (err));
505           rc = map_ksba_err (err);
506           goto leave;
507         }
508   }
509
510   /* main control loop for encryption */
511   recpno = 0;
512   do 
513     {
514       err = ksba_cms_build (cms, &stopreason);
515       if (err)
516         {
517           log_debug ("ksba_cms_build failed: %s\n", ksba_strerror (err));
518           rc = map_ksba_err (err);
519           goto leave;
520         }
521     }
522   while (stopreason != KSBA_SR_READY);   
523
524   if (encparm.readerror)
525     {
526       log_error ("error reading input: %s\n", strerror (encparm.readerror));
527       rc = gpg_error (gpg_err_code_from_errno (encparm.readerror));
528       goto leave;
529     }
530
531
532   rc = gpgsm_finish_writer (b64writer);
533   if (rc) 
534     {
535       log_error ("write failed: %s\n", gpg_strerror (rc));
536       goto leave;
537     }
538   log_info ("encrypted data created\n");
539
540  leave:
541   ksba_cms_release (cms);
542   gpgsm_destroy_writer (b64writer);
543   ksba_reader_release (reader);
544   keydb_release (kh); 
545   xfree (dek);
546   if (data_fp)
547     fclose (data_fp);
548   xfree (encparm.buffer);
549   return rc;
550 }