Allow export to work on systems without funopen/fopencookie.
[gnupg.git] / sm / sign.c
1 /* sign.c - Sign a message
2  *      Copyright (C) 2001, 2002, 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <unistd.h> 
28 #include <time.h>
29 #include <assert.h>
30
31 #include "gpgsm.h"
32 #include <gcrypt.h>
33 #include <ksba.h>
34
35 #include "keydb.h"
36 #include "i18n.h"
37
38
39 static void
40 hash_data (int fd, gcry_md_hd_t md)
41 {
42   FILE *fp;
43   char buffer[4096];
44   int nread;
45
46   fp = fdopen ( dup (fd), "rb");
47   if (!fp)
48     {
49       log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
50       return;
51     }
52
53   do 
54     {
55       nread = fread (buffer, 1, DIM(buffer), fp);
56       gcry_md_write (md, buffer, nread);
57     }
58   while (nread);
59   if (ferror (fp))
60       log_error ("read error on fd %d: %s\n", fd, strerror (errno));
61   fclose (fp);
62 }
63
64 static int
65 hash_and_copy_data (int fd, gcry_md_hd_t md, ksba_writer_t writer)
66 {
67   gpg_error_t err;
68   FILE *fp;
69   char buffer[4096];
70   int nread;
71   int rc = 0;
72   int any = 0;
73
74   fp = fdopen ( dup (fd), "rb");
75   if (!fp)
76     {
77       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
78       log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
79       return tmperr;
80     }
81
82   do 
83     {
84       nread = fread (buffer, 1, DIM(buffer), fp);
85       if (nread)
86         {
87           any = 1;
88           gcry_md_write (md, buffer, nread);
89           err = ksba_writer_write_octet_string (writer, buffer, nread, 0);
90           if (err)
91             {
92               log_error ("write failed: %s\n", gpg_strerror (err));
93               rc = err;
94             }
95         }
96     }
97   while (nread && !rc);
98   if (ferror (fp))
99     {
100       rc = gpg_error (gpg_err_code_from_errno (errno));
101       log_error ("read error on fd %d: %s\n", fd, strerror (errno));
102     }
103   fclose (fp);
104   if (!any)
105     {
106       /* We can't allow to sign an empty message because it does not
107          make much sense and more seriously, ksba-cms_build has
108          already written the tag for data and now expects an octet
109          string but an octet string of zeize 0 is illegal. */
110       log_error ("cannot sign an empty message\n");
111       rc = gpg_error (GPG_ERR_NO_DATA);
112     }
113   if (!rc)
114     {
115       err = ksba_writer_write_octet_string (writer, NULL, 0, 1);
116       if (err)
117         {
118           log_error ("write failed: %s\n", gpg_strerror (err));
119           rc = err;
120         }
121     }
122
123   return rc;
124 }
125
126
127 /* Get the default certificate which is defined as the first cabable
128    of signing our keyDB returns and has a secret key available. */
129 int
130 gpgsm_get_default_cert (ctrl_t ctrl, ksba_cert_t *r_cert)
131 {
132   KEYDB_HANDLE hd;
133   ksba_cert_t cert = NULL;
134   int rc;
135   char *p;
136
137   hd = keydb_new (0);
138   if (!hd)
139     return gpg_error (GPG_ERR_GENERAL);
140   rc = keydb_search_first (hd);
141   if (rc)
142     {
143       keydb_release (hd);
144       return rc;
145     }
146
147   do
148     {
149       rc = keydb_get_cert (hd, &cert);
150       if (rc) 
151         {
152           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
153           keydb_release (hd);
154           return rc;
155         }
156
157       if (!gpgsm_cert_use_sign_p (cert))
158         {
159           p = gpgsm_get_keygrip_hexstring (cert);
160           if (p)
161             {
162               if (!gpgsm_agent_havekey (ctrl, p))
163                 {
164                   xfree (p);
165                   keydb_release (hd);
166                   *r_cert = cert;
167                   return 0; /* got it */
168                 }
169               xfree (p);
170             }
171         }
172
173       ksba_cert_release (cert); 
174       cert = NULL;
175     }
176   while (!(rc = keydb_search_next (hd)));
177   if (rc && rc != -1)
178     log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
179   
180   ksba_cert_release (cert);
181   keydb_release (hd);
182   return rc;
183 }
184
185
186 static ksba_cert_t
187 get_default_signer (ctrl_t ctrl)
188 {
189   KEYDB_SEARCH_DESC desc;
190   ksba_cert_t cert = NULL;
191   KEYDB_HANDLE kh = NULL;
192   int rc;
193
194   if (!opt.local_user)
195     {
196       rc = gpgsm_get_default_cert (ctrl, &cert);
197       if (rc)
198         {
199           if (rc != -1)
200             log_debug ("failed to find default certificate: %s\n",
201                        gpg_strerror (rc));
202           return NULL;
203         }
204       return cert;
205     }
206
207   rc = keydb_classify_name (opt.local_user, &desc);
208   if (rc)
209     {
210       log_error ("failed to find default signer: %s\n", gpg_strerror (rc));
211       return NULL;
212     }
213
214   kh = keydb_new (0);
215   if (!kh)
216     return NULL;
217
218   rc = keydb_search (kh, &desc, 1);
219   if (rc)
220     {
221       log_debug ("failed to find default certificate: rc=%d\n", rc);
222     }
223   else 
224     {
225       rc = keydb_get_cert (kh, &cert);
226       if (rc)
227         {
228           log_debug ("failed to get cert: rc=%d\n", rc);
229         }
230     }
231
232   keydb_release (kh);
233   return cert;
234 }
235
236 /* Depending on the options in CTRL add the certificate CERT as well as
237    other certificate up in the chain to the Root-CA to the CMS
238    object. */
239 static int 
240 add_certificate_list (ctrl_t ctrl, ksba_cms_t cms, ksba_cert_t cert)
241 {
242   gpg_error_t err;
243   int rc = 0;
244   ksba_cert_t next = NULL;
245   int n;
246   int not_root = 0;
247
248   ksba_cert_ref (cert);
249
250   n = ctrl->include_certs;
251   log_debug ("adding certificates at level %d\n", n);
252   if (n == -2)
253     {
254       not_root = 1;
255       n = -1;
256     }
257   if (n < 0 || n > 50)
258     n = 50; /* We better apply an upper bound */
259
260   /* First add my own certificate unless we don't want any certificate
261      included at all. */
262   if (n)
263     {
264       if (not_root && gpgsm_is_root_cert (cert))
265         err = 0;
266       else
267         err = ksba_cms_add_cert (cms, cert);
268       if (err)
269         goto ksba_failure;
270       if (n>0)
271         n--;
272     }
273   /* Walk the chain to include all other certificates.  Note that a -1
274      used for N makes sure that there is no limit and all certs get
275      included. */
276   while ( n-- && !(rc = gpgsm_walk_cert_chain (cert, &next)) )
277     {
278       if (not_root && gpgsm_is_root_cert (next))
279         err = 0;
280       else
281         err = ksba_cms_add_cert (cms, next);
282       ksba_cert_release (cert);
283       cert = next; next = NULL;
284       if (err)
285         goto ksba_failure;
286     }
287   ksba_cert_release (cert);
288
289   return rc == -1? 0: rc;
290
291  ksba_failure:
292   ksba_cert_release (cert);
293   log_error ("ksba_cms_add_cert failed: %s\n", gpg_strerror (err));
294   return err;
295 }
296
297
298
299 \f
300 /* Perform a sign operation.  
301
302    Sign the data received on DATA-FD in embedded mode or in detached
303    mode when DETACHED is true.  Write the signature to OUT_FP.  The
304    keys used to sign are taken from SIGNERLIST or the default one will
305    be used if the value of this argument is NULL. */
306 int
307 gpgsm_sign (ctrl_t ctrl, certlist_t signerlist,
308             int data_fd, int detached, FILE *out_fp)
309 {
310   int i, rc;
311   gpg_error_t err;
312   Base64Context b64writer = NULL;
313   ksba_writer_t writer;
314   ksba_cms_t cms = NULL;
315   ksba_stop_reason_t stopreason;
316   KEYDB_HANDLE kh = NULL;
317   gcry_md_hd_t data_md = NULL;
318   int signer;
319   const char *algoid;
320   int algo;
321   ksba_isotime_t signed_at;
322   certlist_t cl;
323   int release_signerlist = 0;
324
325   kh = keydb_new (0);
326   if (!kh)
327     {
328       log_error (_("failed to allocated keyDB handle\n"));
329       rc = gpg_error (GPG_ERR_GENERAL);
330       goto leave;
331     }
332
333   ctrl->pem_name = "SIGNED MESSAGE";
334   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, NULL, &writer);
335   if (rc)
336     {
337       log_error ("can't create writer: %s\n", gpg_strerror (rc));
338       goto leave;
339     }
340
341   err = ksba_cms_new (&cms);
342   if (err)
343     {
344       rc = err;
345       goto leave;
346     }
347
348   err = ksba_cms_set_reader_writer (cms, NULL, writer);
349   if (err)
350     {
351       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
352                  gpg_strerror (err));
353       rc = err;
354       goto leave;
355     }
356
357   /* We are going to create signed data with data as encap. content */
358   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_SIGNED_DATA);
359   if (!err)
360     err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
361   if (err)
362     {
363       log_debug ("ksba_cms_set_content_type failed: %s\n",
364                  gpg_strerror (err));
365       rc = err;
366       goto leave;
367     }
368
369   /* If no list of signers is given, use a default one. */
370   if (!signerlist)
371     {
372       ksba_cert_t cert = get_default_signer (ctrl);
373       if (!cert)
374         {
375           log_error ("no default signer found\n");
376           rc = gpg_error (GPG_ERR_GENERAL);
377           goto leave;
378         }
379
380       /* Although we don't check for ambigious specification we will
381          check that the signer's certificate is is usable and
382          valid. */
383       rc = gpgsm_cert_use_sign_p (cert);
384       if (!rc)
385         rc = gpgsm_validate_chain (ctrl, cert, NULL, 0, NULL, 0);
386       if (rc)
387         goto leave;
388
389       /* That one is fine - create signerlist. */
390       signerlist = xtrycalloc (1, sizeof *signerlist);
391       if (!signerlist)
392         {
393           rc = out_of_core ();
394           ksba_cert_release (cert);
395           goto leave;
396         }
397       signerlist->cert = cert;
398       release_signerlist = 1;
399     }
400
401
402   /* Gather certificates of signers and store them in the CMS object. */
403   for (cl=signerlist; cl; cl = cl->next)
404     {
405       rc = gpgsm_cert_use_sign_p (cl->cert);
406       if (rc)
407         goto leave;
408       
409       err = ksba_cms_add_signer (cms, cl->cert);
410       if (err)
411         {
412           log_error ("ksba_cms_add_signer failed: %s\n", gpg_strerror (err));
413           rc = err;
414           goto leave;
415         }
416       rc = add_certificate_list (ctrl, cms, cl->cert);
417       if (rc)
418         {
419           log_error ("failed to store list of certificates: %s\n",
420                      gpg_strerror(rc));
421           goto leave;
422         }
423       /* Set the hash algorithm we are going to use */
424       err = ksba_cms_add_digest_algo (cms, "1.3.14.3.2.26" /*SHA-1*/);
425       if (err)
426         {
427           log_debug ("ksba_cms_add_digest_algo failed: %s\n",
428                      gpg_strerror (err));
429           rc = err;
430           goto leave;
431         }
432     }
433
434
435   /* Check whether one of the certificates is qualified.  Note that we
436      already validated the certificate and thus the user data stored
437      flag must be available. */
438   for (cl=signerlist; cl; cl = cl->next)
439     {
440       size_t buflen;
441       char buffer[1];
442       
443       err = ksba_cert_get_user_data (cl->cert, "is_qualified", 
444                                      &buffer, sizeof (buffer), &buflen);
445       if (err || !buflen)
446         {
447           log_error (_("checking for qualified certificate failed: %s\n"),
448                      gpg_strerror (err)); 
449           rc = err;
450           goto leave;
451         }
452       if (*buffer)
453         err = gpgsm_qualified_consent (ctrl, cl->cert);
454       else
455         err = gpgsm_not_qualified_warning (ctrl, cl->cert);
456       if (err)
457         {
458           rc = err;
459           goto leave;
460         }
461     }
462   
463   /* Prepare hashing (actually we are figuring out what we have set above)*/
464   rc = gcry_md_open (&data_md, 0, 0);
465   if (rc)
466     {
467       log_error ("md_open failed: %s\n", gpg_strerror (rc));
468       goto leave;
469     }
470   if (DBG_HASHING)
471     gcry_md_start_debug (data_md, "sign.data");
472
473   for (i=0; (algoid=ksba_cms_get_digest_algo_list (cms, i)); i++)
474     {
475       algo = gcry_md_map_name (algoid);
476       if (!algo)
477         {
478           log_error ("unknown hash algorithm `%s'\n", algoid? algoid:"?");
479           if (algoid
480               && (  !strcmp (algoid, "1.2.840.113549.1.1.2")
481                     ||!strcmp (algoid, "1.2.840.113549.2.2")))
482             log_info (_("(this is the MD2 algorithm)\n"));
483           rc = gpg_error (GPG_ERR_BUG);
484           goto leave;
485         }
486       gcry_md_enable (data_md, algo);
487     }
488
489   if (detached)
490     { /* we hash the data right now so that we can store the message
491          digest.  ksba_cms_build() takes this as an flag that detached
492          data is expected. */
493       unsigned char *digest;
494       size_t digest_len;
495       /* Fixme do this for all signers and get the algo to use from
496          the signer's certificate - does not make mich sense, but we
497          should do this consistent as we have already done it above. */
498       algo = GCRY_MD_SHA1; 
499       hash_data (data_fd, data_md);
500       digest = gcry_md_read (data_md, algo);
501       digest_len = gcry_md_get_algo_dlen (algo);
502       if ( !digest || !digest_len)
503         {
504           log_error ("problem getting the hash of the data\n");
505           rc = gpg_error (GPG_ERR_BUG);
506           goto leave;
507         }
508       for (cl=signerlist,signer=0; cl; cl = cl->next, signer++)
509         {
510           err = ksba_cms_set_message_digest (cms, signer, digest, digest_len);
511           if (err)
512             {
513               log_error ("ksba_cms_set_message_digest failed: %s\n",
514                          gpg_strerror (err));
515               rc = err;
516               goto leave;
517             }
518         }
519     }
520
521   gnupg_get_isotime (signed_at);
522   for (cl=signerlist,signer=0; cl; cl = cl->next, signer++)
523     {
524       err = ksba_cms_set_signing_time (cms, signer, signed_at);
525       if (err)
526         {
527           log_error ("ksba_cms_set_signing_time failed: %s\n",
528                      gpg_strerror (err));
529           rc = err;
530           goto leave;
531         }
532     }
533
534   /* We need to write at least a minimal list of our capabilities to
535      try to convince some MUAs to use 3DEs and not the crippled
536      RC2. Our list is:
537
538         aes128-CBC
539         des-EDE3-CBC
540   */
541   err = ksba_cms_add_smime_capability (cms, "2.16.840.1.101.3.4.1.2", NULL, 0);
542   if (!err)
543     err = ksba_cms_add_smime_capability (cms, "1.2.840.113549.3.7", NULL, 0);
544   if (err)
545     {
546       log_error ("ksba_cms_add_smime_capability failed: %s\n",
547                  gpg_strerror (err));
548       goto leave;
549     }
550
551
552   /* Main building loop. */
553   do 
554     {
555       err = ksba_cms_build (cms, &stopreason);
556       if (err)
557         {
558           log_debug ("ksba_cms_build failed: %s\n", gpg_strerror (err));
559           rc = err;
560           goto leave;
561         }
562
563       if (stopreason == KSBA_SR_BEGIN_DATA)
564         { /* hash the data and store the message digest */
565           unsigned char *digest;
566           size_t digest_len;
567
568           assert (!detached);
569           /* Fixme: get the algo to use from the signer's certificate
570              - does not make much sense, but we should do this
571              consistent as we have already done it above.  Code is
572              mostly duplicated above. */
573
574           algo = GCRY_MD_SHA1; 
575           rc = hash_and_copy_data (data_fd, data_md, writer);
576           if (rc)
577             goto leave;
578           digest = gcry_md_read (data_md, algo);
579           digest_len = gcry_md_get_algo_dlen (algo);
580           if ( !digest || !digest_len)
581             {
582               log_error ("problem getting the hash of the data\n");
583               rc = gpg_error (GPG_ERR_BUG);
584               goto leave;
585             }
586           for (cl=signerlist,signer=0; cl; cl = cl->next, signer++)
587             {
588               err = ksba_cms_set_message_digest (cms, signer,
589                                                  digest, digest_len);
590               if (err)
591                 {
592                   log_error ("ksba_cms_set_message_digest failed: %s\n",
593                              gpg_strerror (err));
594                   rc = err;
595                   goto leave;
596                 }
597             }
598         }
599       else if (stopreason == KSBA_SR_NEED_SIG)
600         { /* calculate the signature for all signers */
601           gcry_md_hd_t md;
602
603           algo = GCRY_MD_SHA1;
604           rc = gcry_md_open (&md, algo, 0);
605           if (rc)
606             {
607               log_error ("md_open failed: %s\n", gpg_strerror (rc));
608               goto leave;
609             }
610           if (DBG_HASHING)
611             gcry_md_start_debug (md, "sign.attr");
612           ksba_cms_set_hash_function (cms, HASH_FNC, md);
613           for (cl=signerlist,signer=0; cl; cl = cl->next, signer++)
614             {
615               unsigned char *sigval = NULL;
616               char *buf, *fpr;
617
618               if (signer)
619                 gcry_md_reset (md);
620               rc = ksba_cms_hash_signed_attrs (cms, signer);
621               if (rc)
622                 {
623                   log_debug ("hashing signed attrs failed: %s\n",
624                              gpg_strerror (rc));
625                   gcry_md_close (md);
626                   goto leave;
627                 }
628             
629               rc = gpgsm_create_cms_signature (ctrl, cl->cert,
630                                                md, algo, &sigval);
631               if (rc)
632                 {
633                   gcry_md_close (md);
634                   goto leave;
635                 }
636
637               err = ksba_cms_set_sig_val (cms, signer, sigval);
638               xfree (sigval);
639               if (err)
640                 {
641                   log_error ("failed to store the signature: %s\n",
642                              gpg_strerror (err));
643                   rc = err;
644                   gcry_md_close (md);
645                   goto leave;
646                 }
647
648               /* write a status message */
649               fpr = gpgsm_get_fingerprint_hexstring (cl->cert, GCRY_MD_SHA1);
650               if (!fpr)
651                 {
652                   rc = gpg_error (GPG_ERR_ENOMEM);
653                   gcry_md_close (md);
654                   goto leave;
655                 }
656               {
657                 int pkalgo = gpgsm_get_key_algo_info (cl->cert, NULL);
658                 rc = asprintf (&buf, "%c %d %d 00 %s %s",
659                                detached? 'D':'S',
660                                pkalgo, 
661                                algo, 
662                                signed_at,
663                                fpr);
664               }
665               xfree (fpr);
666               if (rc < 0)
667                 {
668                   rc = gpg_error (GPG_ERR_ENOMEM);
669                   gcry_md_close (md);
670                   goto leave;
671                 }
672               rc = 0;
673               gpgsm_status (ctrl, STATUS_SIG_CREATED, buf);
674               free (buf); /* yes, we must use the regular free() here */
675             }
676           gcry_md_close (md);
677
678         }
679     }
680   while (stopreason != KSBA_SR_READY);   
681
682   rc = gpgsm_finish_writer (b64writer);
683   if (rc) 
684     {
685       log_error ("write failed: %s\n", gpg_strerror (rc));
686       goto leave;
687     }
688
689   log_info ("signature created\n");
690
691
692  leave:
693   if (rc)
694     log_error ("error creating signature: %s <%s>\n",
695                gpg_strerror (rc), gpg_strsource (rc) );
696   if (release_signerlist)
697     gpgsm_release_certlist (signerlist);
698   ksba_cms_release (cms);
699   gpgsm_destroy_writer (b64writer);
700   keydb_release (kh); 
701   gcry_md_close (data_md);
702   return rc;
703 }