aba1dc12dc09bef6bda7468af56795aab4577145
[gnupg.git] / sm / encrypt.c
1 /* encrypt.c - Encrypt a message
2  *      Copyright (C) 2001 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 <gcrypt.h>
31 #include <ksba.h>
32
33 #include "gpgsm.h"
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 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 static KsbaCert
62 get_default_recipient (void)
63 {
64   const char key[] =
65     "CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=#44FC7373656C646F7266#,C=DE";
66
67   KsbaCert cert = NULL;
68   KEYDB_HANDLE kh = NULL;
69   int rc;
70
71   kh = keydb_new (0);
72   if (!kh)
73     return NULL;
74
75   rc = keydb_search_subject (kh, key);
76   if (rc)
77     {
78       log_debug ("failed to find default certificate: rc=%d\n", rc);
79     }
80   else 
81     {
82       rc = keydb_get_cert (kh, &cert);
83       if (rc)
84         {
85           log_debug ("failed to get cert: rc=%d\n", rc);
86         }
87     }
88
89   keydb_release (kh);
90   return cert;
91 }
92
93
94 \f
95 /* initialize the data encryptionkey (session key) */
96 static int
97 init_dek (DEK dek)
98 {
99   int rc=0, i;
100
101   dek->algo = gcry_cipher_map_name (dek->algoid);
102   if (!dek->algo)
103     {
104       log_error ("unsupported algorithm `%s'\n", dek->algoid);
105       return GNUPG_Unsupported_Algorithm;
106     }
107
108   dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
109   if (!dek->keylen || dek->keylen > sizeof (dek->key))
110     return GNUPG_Bug;
111
112   dek->ivlen = gcry_cipher_get_algo_blklen (dek->algo);
113   if (!dek->ivlen || dek->ivlen > sizeof (dek->iv))
114     return GNUPG_Bug;
115
116   if (dek->keylen < 100/8)
117     { /* make sure we don't use weak keys */
118       log_error ("key length of `%s' too small\n", dek->algoid);
119       return GNUPG_Unsupported_Algorithm;
120     }
121   
122
123   dek->chd = gcry_cipher_open (dek->algo,
124                                GCRY_CIPHER_MODE_CBC,
125                                GCRY_CIPHER_SECURE);
126   if (!dek->chd)
127     {
128       log_error ("failed to create cipher context: %s\n", gcry_strerror (-1));
129       return GNUPG_General_Error;
130     }
131   
132   for (i=0; i < 8; i++)
133     {
134       gcry_randomize (dek->key, dek->keylen, GCRY_STRONG_RANDOM );
135       rc = gcry_cipher_setkey (dek->chd, dek->key, dek->keylen);
136       if (rc != GCRYERR_WEAK_KEY)
137         break;
138       log_info(_("weak key created - retrying\n") );
139     }
140   if (rc)
141     {
142       log_error ("failed to set the key: %s\n", gcry_strerror (rc));
143       gcry_cipher_close (dek->chd);
144       dek->chd = NULL;
145       return map_gcry_err (rc);
146     }
147
148   gcry_randomize (dek->iv, dek->ivlen, GCRY_STRONG_RANDOM);
149   rc = gcry_cipher_setiv (dek->chd, dek->iv, dek->ivlen);
150   if (rc)
151     {
152       log_error ("failed to set the IV: %s\n", gcry_strerror (rc));
153       gcry_cipher_close (dek->chd);
154       dek->chd = NULL;
155       return map_gcry_err (rc);
156     }
157   
158   return 0;
159 }
160
161
162 /* Encode the session key. NBITS is the number of bits which should be
163    used for packing the session key.  returns: An mpi with the session
164    key (caller must free) */
165 static GCRY_MPI
166 encode_session_key (DEK dek, unsigned int nbits)
167 {
168   int nframe = (nbits+7) / 8;
169   byte *p;
170   byte *frame;
171   int i,n;
172   MPI a;
173
174   if (dek->keylen + 7 > nframe || !nframe)
175     log_bug ("can't encode a %d bit key in a %d bits frame\n",
176              dek->keylen*8, nbits );
177
178   /* We encode the session key in this way:
179    *
180    *       0  2  RND(n bytes)  0  KEY(k bytes)
181    *
182    * (But how can we store the leading 0 - the external representaion
183    *    of MPIs doesn't allow leading zeroes =:-)
184    *
185    * RND are non-zero random bytes.
186    * KEY is the encryption key (session key) 
187    */
188
189   frame = gcry_xmalloc_secure (nframe);
190   n = 0;
191   frame[n++] = 0;
192   frame[n++] = 2;
193   i = nframe - 3 - dek->keylen;
194   assert (i > 0);
195   p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
196   /* replace zero bytes by new values */
197   for (;;)
198     {
199       int j, k;
200       byte *pp;
201
202       /* count the zero bytes */
203       for(j=k=0; j < i; j++ )
204         {
205           if( !p[j] )
206             k++;
207         }
208       if( !k )
209         break; /* okay: no zero bytes */
210
211       k += k/128; /* better get some more */
212       pp = gcry_random_bytes_secure (k, GCRY_STRONG_RANDOM);
213       for (j=0; j < i && k; j++)
214         {
215           if( !p[j] )
216             p[j] = pp[--k];
217         }
218       xfree (pp);
219     }
220   memcpy (frame+n, p, i);
221   xfree (p);
222
223   n += i;
224   frame[n++] = 0;
225   memcpy (frame+n, dek->key, dek->keylen);
226   n += dek->keylen;
227   assert (n == nframe);
228   if (gcry_mpi_scan (&a, GCRYMPI_FMT_USG, frame, &nframe) )
229     BUG ();
230   gcry_free(frame);
231
232   return a;
233 }
234
235
236
237 /* encrypt the DEK under the key contained in CERT and return it as a
238    canonical S-Exp in encval */
239 static int
240 encrypt_dek (const DEK dek, KsbaCert cert, char **encval)
241 {
242   GCRY_SEXP s_ciph, s_data, s_pkey;
243   int rc;
244   char *buf;
245   size_t len;
246
247   *encval = NULL;
248
249   /* get the key from the cert */
250   buf = ksba_cert_get_public_key (cert);
251   if (!buf)
252     {
253       log_error ("no public key for recipient\n");
254       return GNUPG_No_Public_Key;
255     }
256   rc = gcry_sexp_sscan (&s_pkey, NULL, buf, strlen(buf));
257   xfree (buf); buf = NULL;
258   if (rc)
259     {
260       log_error ("gcry_sexp_scan failed: %s\n", gcry_strerror (rc));
261       return map_gcry_err (rc);
262     }
263
264   /* put the encoded cleartext into a simple list */
265   {
266     /* fixme: actually the pkcs-1 encoding should go into libgcrypt */
267     GCRY_MPI data = encode_session_key (dek, gcry_pk_get_nbits (s_pkey));
268     if (!data)
269       {
270         gcry_mpi_release (data);
271         return GNUPG_General_Error;
272       }
273     if (gcry_sexp_build (&s_data, NULL, "%m", data))
274       BUG ();
275     gcry_mpi_release (data);
276   }
277
278   /* pass it to libgcrypt */
279   rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
280   gcry_sexp_release (s_data);
281   gcry_sexp_release (s_pkey);
282   
283   /* reformat it */
284   len = gcry_sexp_sprint (s_ciph, GCRYSEXP_FMT_CANON, NULL, 0);
285   assert (len); 
286   buf = xtrymalloc (len);
287   if (!buf)
288     {
289       gcry_sexp_release (s_ciph);
290       return GNUPG_Out_Of_Core;
291     }
292   len = gcry_sexp_sprint (s_ciph, GCRYSEXP_FMT_CANON, buf, len);
293   assert (len);
294
295   *encval = buf;
296   return 0;
297 }
298
299
300 \f
301 /* do the actual encryption */
302 static int
303 encrypt_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
304 {
305   struct encrypt_cb_parm_s *parm = cb_value;
306   int blklen = parm->dek->ivlen;
307   unsigned char *p;
308   size_t n;
309
310   *nread = 0;
311   if (!buffer)
312     return -1; /* not supported */
313
314   if (parm->ready)
315     return -1;
316
317   if (count < blklen)
318     BUG ();
319      
320   if (!parm->eof_seen)
321     { /* fillup the buffer */
322       p = parm->buffer;
323       for (n=parm->buflen; n < parm->bufsize; n++)
324         {
325           int c = getc (parm->fp);
326           if (c == EOF)
327             {
328               if (ferror (parm->fp))
329                 {
330                   parm->readerror = errno;
331                   return -1;
332                 }
333               parm->eof_seen = 1;
334               break; 
335             }
336           p[n] = c;
337         }
338       parm->buflen = n;
339     }
340   
341   n = parm->buflen < count? parm->buflen : count;
342   n = n/blklen * blklen;
343   if (n)
344     { /* encrypt the stuff */
345       gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
346       *nread = n;
347       /* Who cares about cycles, take the easy way and shift the buffer */
348       parm->buflen -= n;
349       memmove (parm->buffer, parm->buffer+n, parm->buflen);
350     }
351   else if (parm->eof_seen)
352     { /* no complete block but eof: add padding */
353       /* fixme: we should try to do this also in the above code path */
354       int i, npad = blklen - (parm->buflen % blklen);
355       p = parm->buffer;
356       for (n=parm->buflen, i=0; n < parm->bufsize && i < npad; n++, i++)
357         p[n] = npad;
358       gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
359       *nread = n;
360       parm->ready = 1;
361     }
362
363   return 0;
364 }
365
366
367
368 \f
369 /* Perform an encrypt operation.  
370
371    Encrypt the data received on DATA-FD and write it to OUT_FP.  The
372    recipients are hardwired for now. */
373 int
374 gpgsm_encrypt (CTRL ctrl, int data_fd, FILE *out_fp)
375 {
376   int rc = 0;
377   Base64Context b64writer = NULL;
378   KsbaError err;
379   KsbaWriter writer;
380   KsbaReader reader = NULL;
381   KsbaCMS cms = NULL;
382   KsbaStopReason stopreason;
383   KEYDB_HANDLE kh = NULL;
384   struct encrypt_cb_parm_s encparm;
385   DEK dek = NULL;
386   int recpno;
387   FILE *data_fp = NULL;
388
389
390   memset (&encparm, 0, sizeof encparm);
391   kh = keydb_new (0);
392   if (!kh)
393     {
394       log_error (_("failed to allocated keyDB handle\n"));
395       rc = GNUPG_General_Error;
396       goto leave;
397     }
398
399   data_fp = fdopen ( dup (data_fd), "rb");
400   if (!data_fp)
401     {
402       log_error ("fdopen() failed: %s\n", strerror (errno));
403       rc = seterr (IO_Error);
404       goto leave;
405     }
406
407   reader = ksba_reader_new ();
408   if (!reader)
409       rc = KSBA_Out_Of_Core;
410   if (!rc)
411     rc = ksba_reader_set_cb (reader, encrypt_cb, &encparm);
412   if (rc)
413     {
414       rc = map_ksba_err (rc);
415       goto leave;
416     }
417   encparm.fp = data_fp;
418
419   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
420   if (rc)
421     {
422       log_error ("can't create writer: %s\n", gnupg_strerror (rc));
423       goto leave;
424     }
425
426   cms = ksba_cms_new ();
427   if (!cms)
428     {
429       rc = seterr (Out_Of_Core);
430       goto leave;
431     }
432
433   err = ksba_cms_set_reader_writer (cms, reader, writer);
434   if (err)
435     {
436       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
437                  ksba_strerror (err));
438       rc = map_ksba_err (err);
439       goto leave;
440     }
441
442   /* We are going to create enveloped data with uninterpreted data as
443      inner content */
444   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_ENVELOPED_DATA);
445   if (!err)
446     err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
447   if (err)
448     {
449       log_debug ("ksba_cms_set_content_type failed: %s\n",
450                  ksba_strerror (err));
451       rc = map_ksba_err (err);
452       goto leave;
453     }
454
455   /* create a session key */
456   dek = xtrycalloc (1, sizeof *dek); /* hmmm: should we put it into secmem?*/
457   if (!dek)
458     rc = GNUPG_Out_Of_Core;
459   else
460   {
461     dek->algoid = "1.2.840.113549.3.7";  /*des-EDE3-CBC*/
462     rc = init_dek (dek);
463   }
464   if (rc)
465     {
466       log_error ("failed to create the session key: %s\n",
467                  gnupg_strerror (rc));
468       goto leave;
469     }
470
471   err = ksba_cms_set_content_enc_algo (cms, dek->algoid, dek->iv, dek->ivlen);
472   if (err)
473     {
474       log_error ("ksba_cms_set_content_enc_algo failed: %s\n",
475                  ksba_strerror (err));
476       rc = map_ksba_err (err);
477       goto leave;
478     }
479
480   encparm.dek = dek;
481   /* fixme: we should use a larger buffer - the small one is better
482      for testing */
483   encparm.bufsize = 10 * dek->ivlen;
484   encparm.buffer = xtrymalloc (encparm.bufsize);
485   if (!encparm.buffer)
486     {
487       rc = seterr (Out_Of_Core);
488       goto leave;
489     }
490
491   /* gather certificates of recipients, encrypt the session key for
492      each and store them in the CMS object */
493   for (recpno = 0; recpno < 1; recpno++)
494     {
495       KsbaCert cert;
496       char *encval;
497       
498       /* fixme: get the recipients out of the arguments passed to us */
499       cert = get_default_recipient ();
500       if (!cert)
501         {
502           log_error ("no default recipient found\n");
503           rc = seterr (General_Error);
504           goto leave;
505         }
506       
507       rc = encrypt_dek (dek, cert, &encval);
508       if (rc)
509         {
510           log_error ("encryption failed for recipient no. %d: %s\n",
511                      recpno, gnupg_strerror (rc));
512           ksba_cert_release (cert);
513           goto leave;
514         }
515       
516       err = ksba_cms_add_recipient (cms, cert);
517       if (err)
518         {
519           log_error ("ksba_cms_add_recipient failed: %s\n",
520                      ksba_strerror (err));
521           rc = map_ksba_err (err);
522           xfree (encval);
523           ksba_cert_release (cert);
524           goto leave;
525         }
526       cert = NULL; /* cms does now own the certificate */
527       
528       err = ksba_cms_set_enc_val (cms, recpno, encval);
529       xfree (encval);
530       if (err)
531         {
532           log_error ("ksba_cms_set_enc_val failed: %s\n",
533                      ksba_strerror (err));
534           rc = map_ksba_err (err);
535           goto leave;
536         }
537   }
538
539   /* main control loop for encryption */
540   recpno = 0;
541   do 
542     {
543       err = ksba_cms_build (cms, &stopreason);
544       if (err)
545         {
546           log_debug ("ksba_cms_build failed: %s\n", ksba_strerror (err));
547           rc = map_ksba_err (err);
548           goto leave;
549         }
550       log_debug ("ksba_cms_build - stop reason %d\n", stopreason);
551     }
552   while (stopreason != KSBA_SR_READY);   
553
554   if (encparm.readerror)
555     {
556       log_error ("error reading input: %s\n", strerror (encparm.readerror));
557       rc = seterr (Read_Error);
558       goto leave;
559     }
560
561
562   rc = gpgsm_finish_writer (b64writer);
563   if (rc) 
564     {
565       log_error ("write failed: %s\n", gnupg_strerror (rc));
566       goto leave;
567     }
568   log_info ("encrypted data created\n");
569
570  leave:
571   ksba_cms_release (cms);
572   gpgsm_destroy_writer (b64writer);
573   ksba_reader_release (reader);
574   keydb_release (kh); 
575   xfree (dek);
576   if (data_fp)
577     fclose (data_fp);
578   xfree (encparm.buffer);
579   return rc;
580 }