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