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