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