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 = keydb_classify_name (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 allocate 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_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_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 }