sm/sign.c

   1 /* sign.c - Sign a message
   2  * Copyright (C) 2001, 2002, 2003, 2008,
   3  *               2010 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <unistd.h>
  27 #include <time.h>
  28
  29 #include "gpgsm.h"
  30 #include <gcrypt.h>
  31 #include <ksba.h>
  32
  33 #include "keydb.h"
  34 #include "../common/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   estream_t fp;
  42   char buffer[4096];
  43   int nread;
  44   int rc = 0;
  45
  46   fp = es_fdopen_nc (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 = es_fread (buffer, 1, DIM(buffer), fp);
  56       gcry_md_write (md, buffer, nread);
  57     }
  58   while (nread);
  59   if (es_ferror (fp))
  60     {
  61       log_error ("read error on fd %d: %s\n", fd, strerror (errno));
  62       rc = -1;
  63     }
  64   es_fclose (fp);
  65   return rc;
  66 }
  67
  68
  69 static int
  70 hash_and_copy_data (int fd, gcry_md_hd_t md, ksba_writer_t writer)
  71 {
  72   gpg_error_t err;
  73   estream_t fp;
  74   char buffer[4096];
  75   int nread;
  76   int rc = 0;
  77   int any = 0;
  78
  79   fp = es_fdopen_nc (fd, "rb");
  80   if (!fp)
  81     {
  82       gpg_error_t tmperr = gpg_error_from_syserror ();
  83       log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
  84       return tmperr;
  85     }
  86
  87   do
  88     {
  89       nread = es_fread (buffer, 1, DIM(buffer), fp);
  90       if (nread)
  91         {
  92           any = 1;
  93           gcry_md_write (md, buffer, nread);
  94           err = ksba_writer_write_octet_string (writer, buffer, nread, 0);
  95           if (err)
  96             {
  97               log_error ("write failed: %s\n", gpg_strerror (err));
  98               rc = err;
  99             }
 100         }
 101     }
 102   while (nread && !rc);
 103   if (es_ferror (fp))
 104     {
 105       rc = gpg_error_from_syserror ();
 106       log_error ("read error on fd %d: %s\n", fd, strerror (errno));
 107     }
 108   es_fclose (fp);
 109   if (!any)
 110     {
 111       /* We can't allow signing an empty message because it does not
 112          make much sense and more seriously, ksba_cms_build has
 113          already written the tag for data and now expects an octet
 114          string and an octet string of size 0 is illegal.  */
 115       log_error ("cannot sign an empty message\n");
 116       rc = gpg_error (GPG_ERR_NO_DATA);
 117     }
 118   if (!rc)
 119     {
 120       err = ksba_writer_write_octet_string (writer, NULL, 0, 1);
 121       if (err)
 122         {
 123           log_error ("write failed: %s\n", gpg_strerror (err));
 124           rc = err;
 125         }
 126     }
 127
 128   return rc;
 129 }
 130
 131
 132 /* Get the default certificate which is defined as the first
 133    certificate capable of signing returned by the keyDB and has a
 134    secret key available. */
 135 int
 136 gpgsm_get_default_cert (ctrl_t ctrl, ksba_cert_t *r_cert)
 137 {
 138   KEYDB_HANDLE hd;
 139   ksba_cert_t cert = NULL;
 140   int rc;
 141   char *p;
 142
 143   hd = keydb_new (ctrl);
 144   if (!hd)
 145     return gpg_error (GPG_ERR_GENERAL);
 146   rc = keydb_search_first (ctrl, hd);
 147   if (rc)
 148     {
 149       keydb_release (hd);
 150       return rc;
 151     }
 152
 153   do
 154     {
 155       rc = keydb_get_cert (hd, &cert);
 156       if (rc)
 157         {
 158           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
 159           keydb_release (hd);
 160           return rc;
 161         }
 162
 163       if (!gpgsm_cert_use_sign_p (cert, 1))
 164         {
 165           p = gpgsm_get_keygrip_hexstring (cert);
 166           if (p)
 167             {
 168               if (!gpgsm_agent_havekey (ctrl, p))
 169                 {
 170                   xfree (p);
 171                   keydb_release (hd);
 172                   *r_cert = cert;
 173                   return 0; /* got it */
 174                 }
 175               xfree (p);
 176             }
 177         }
 178
 179       ksba_cert_release (cert);
 180       cert = NULL;
 181     }
 182   while (!(rc = keydb_search_next (ctrl, hd)));
 183   if (rc && rc != -1)
 184     log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
 185
 186   ksba_cert_release (cert);
 187   keydb_release (hd);
 188   return rc;
 189 }
 190
 191
 192 static ksba_cert_t
 193 get_default_signer (ctrl_t ctrl)
 194 {
 195   KEYDB_SEARCH_DESC desc;
 196   ksba_cert_t cert = NULL;
 197   KEYDB_HANDLE kh = NULL;
 198   int rc;
 199
 200   if (!opt.local_user)
 201     {
 202       rc = gpgsm_get_default_cert (ctrl, &cert);
 203       if (rc)
 204         {
 205           if (rc != -1)
 206             log_debug ("failed to find default certificate: %s\n",
 207                        gpg_strerror (rc));
 208           return NULL;
 209         }
 210       return cert;
 211     }
 212
 213   rc = classify_user_id (opt.local_user, &desc, 0);
 214   if (rc)
 215     {
 216       log_error ("failed to find default signer: %s\n", gpg_strerror (rc));
 217       return NULL;
 218     }
 219
 220   kh = keydb_new (ctrl);
 221   if (!kh)
 222     return NULL;
 223
 224   rc = keydb_search (ctrl, kh, &desc, 1);
 225   if (rc)
 226     {
 227       log_debug ("failed to find default certificate: rc=%d\n", rc);
 228     }
 229   else
 230     {
 231       rc = keydb_get_cert (kh, &cert);
 232       if (rc)
 233         {
 234           log_debug ("failed to get cert: rc=%d\n", rc);
 235         }
 236     }
 237
 238   keydb_release (kh);
 239   return cert;
 240 }
 241
 242 /* Depending on the options in CTRL add the certificate CERT as well as
 243    other certificate up in the chain to the Root-CA to the CMS
 244    object. */
 245 static int
 246 add_certificate_list (ctrl_t ctrl, ksba_cms_t cms, ksba_cert_t cert)
 247 {
 248   gpg_error_t err;
 249   int rc = 0;
 250   ksba_cert_t next = NULL;
 251   int n;
 252   int not_root = 0;
 253
 254   ksba_cert_ref (cert);
 255
 256   n = ctrl->include_certs;
 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 gpg_err_code (rc) == GPG_ERR_NOT_FOUND? 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 #if KSBA_VERSION_NUMBER >= 0x010400 && 0 /* 1.4.0 */
 304 static gpg_error_t
 305 add_signed_attribute (ksba_cms_t cms, const char *attrstr)
 306 {
 307   gpg_error_t err;
 308   char **fields = NULL;
 309   const char *s;
 310   int i;
 311   unsigned char *der = NULL;
 312   size_t derlen;
 313
 314   fields = strtokenize (attrstr, ":");
 315   if (!fields)
 316     {
 317       err = gpg_error_from_syserror ();
 318       log_error ("strtokenize failed: %s\n", gpg_strerror (err));
 319       goto leave;
 320     }
 321
 322   for (i=0; fields[i]; i++)
 323     ;
 324   if (i != 3)
 325     {
 326       err = gpg_error (GPG_ERR_SYNTAX);
 327       log_error ("invalid attribute specification '%s': %s\n",
 328                  attrstr, i < 3 ? "not enough fields":"too many fields");
 329       goto leave;
 330     }
 331   if (!ascii_strcasecmp (fields[1], "u"))
 332     {
 333       err = 0;
 334       goto leave; /* Skip unsigned attributes.  */
 335     }
 336   if (ascii_strcasecmp (fields[1], "s"))
 337     {
 338       err = gpg_error (GPG_ERR_SYNTAX);
 339       log_error ("invalid attribute specification '%s': %s\n",
 340                  attrstr, "type is not 's' or 'u'");
 341       goto leave;
 342     }
 343   /* Check that the OID is valid.  */
 344   err = ksba_oid_from_str (fields[0], &der, &derlen);
 345   if (err)
 346     {
 347       log_error ("invalid attribute specification '%s': %s\n",
 348                  attrstr, gpg_strerror (err));
 349       goto leave;
 350     }
 351   xfree (der);
 352   der = NULL;
 353
 354   if (strchr (fields[2], '/'))
 355     {
 356       /* FIXME: read from file. */
 357     }
 358   else /* Directly given in hex.  */
 359     {
 360       for (i=0, s = fields[2]; hexdigitp (s); s++, i++)
 361         ;
 362       if (*s || !i || (i&1))
 363         {
 364           log_error ("invalid attribute specification '%s': %s\n",
 365                      attrstr, "invalid hex encoding of the data");
 366           err = gpg_error (GPG_ERR_SYNTAX);
 367           goto leave;
 368         }
 369       der = xtrystrdup (fields[2]);
 370       if (!der)
 371         {
 372           err = gpg_error_from_syserror ();
 373           log_error ("malloc failed: %s\n", gpg_strerror (err));
 374           goto leave;
 375         }
 376       for (s=fields[2], derlen=0; s[0] && s[1]; s += 2)
 377         der[derlen++] = xtoi_2 (s);
 378     }
 379
 380   /* Store the data in the CMS object for all signers.  */
 381   err = ksba_cms_add_attribute (cms, -1, fields[0], 0, der, derlen);
 382   if (err)
 383     {
 384       log_error ("invalid attribute specification '%s': %s\n",
 385                  attrstr, gpg_strerror (err));
 386       goto leave;
 387     }
 388
 389  leave:
 390   xfree (der);
 391   xfree (fields);
 392   return err;
 393 }
 394 #endif /*ksba >= 1.4.0 */
 395
 396
 397 \f
 398 /* Perform a sign operation.
 399
 400    Sign the data received on DATA-FD in embedded mode or in detached
 401    mode when DETACHED is true.  Write the signature to OUT_FP.  The
 402    keys used to sign are taken from SIGNERLIST or the default one will
 403    be used if the value of this argument is NULL. */
 404 int
 405 gpgsm_sign (ctrl_t ctrl, certlist_t signerlist,
 406             int data_fd, int detached, estream_t out_fp)
 407 {
 408   int i, rc;
 409   gpg_error_t err;
 410   gnupg_ksba_io_t b64writer = NULL;
 411   ksba_writer_t writer;
 412   ksba_cms_t cms = NULL;
 413   ksba_stop_reason_t stopreason;
 414   KEYDB_HANDLE kh = NULL;
 415   gcry_md_hd_t data_md = NULL;
 416   int signer;
 417   const char *algoid;
 418   int algo;
 419   ksba_isotime_t signed_at;
 420   certlist_t cl;
 421   int release_signerlist = 0;
 422
 423   audit_set_type (ctrl->audit, AUDIT_TYPE_SIGN);
 424
 425   kh = keydb_new (ctrl);
 426   if (!kh)
 427     {
 428       log_error (_("failed to allocate keyDB handle\n"));
 429       rc = gpg_error (GPG_ERR_GENERAL);
 430       goto leave;
 431     }
 432
 433   if (!gnupg_rng_is_compliant (opt.compliance))
 434     {
 435       rc = gpg_error (GPG_ERR_FORBIDDEN);
 436       log_error (_("%s is not compliant with %s mode\n"),
 437                  "RNG",
 438                  gnupg_compliance_option_string (opt.compliance));
 439       gpgsm_status_with_error (ctrl, STATUS_ERROR,
 440                                "random-compliance", rc);
 441       goto leave;
 442     }
 443
 444   ctrl->pem_name = "SIGNED MESSAGE";
 445   rc = gnupg_ksba_create_writer
 446     (&b64writer, ((ctrl->create_pem? GNUPG_KSBA_IO_PEM : 0)
 447                   | (ctrl->create_base64? GNUPG_KSBA_IO_BASE64 : 0)),
 448      ctrl->pem_name, out_fp, &writer);
 449   if (rc)
 450     {
 451       log_error ("can't create writer: %s\n", gpg_strerror (rc));
 452       goto leave;
 453     }
 454
 455   err = ksba_cms_new (&cms);
 456   if (err)
 457     {
 458       rc = err;
 459       goto leave;
 460     }
 461
 462   err = ksba_cms_set_reader_writer (cms, NULL, writer);
 463   if (err)
 464     {
 465       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
 466                  gpg_strerror (err));
 467       rc = err;
 468       goto leave;
 469     }
 470
 471   /* We are going to create signed data with data as encap. content.
 472    * In authenticode mode we use spcIndirectDataContext instead.  */
 473   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_SIGNED_DATA);
 474   if (!err)
 475     err = ksba_cms_set_content_type
 476       (cms, 1,
 477 #if KSBA_VERSION_NUMBER >= 0x010400 && 0
 478        opt.authenticode? KSBA_CT_SPC_IND_DATA_CTX :
 479 #endif
 480        KSBA_CT_DATA
 481        );
 482   if (err)
 483     {
 484       log_debug ("ksba_cms_set_content_type failed: %s\n",
 485                  gpg_strerror (err));
 486       rc = err;
 487       goto leave;
 488     }
 489
 490   /* If no list of signers is given, use the default certificate. */
 491   if (!signerlist)
 492     {
 493       ksba_cert_t cert = get_default_signer (ctrl);
 494       if (!cert)
 495         {
 496           log_error ("no default signer found\n");
 497           gpgsm_status2 (ctrl, STATUS_INV_SGNR,
 498                          get_inv_recpsgnr_code (GPG_ERR_NO_SECKEY), NULL);
 499           rc = gpg_error (GPG_ERR_GENERAL);
 500           goto leave;
 501         }
 502
 503       /* Although we don't check for ambiguous specification we will
 504          check that the signer's certificate is usable and valid.  */
 505       rc = gpgsm_cert_use_sign_p (cert, 0);
 506       if (!rc)
 507         rc = gpgsm_validate_chain (ctrl, cert, "", NULL, 0, NULL, 0, NULL);
 508       if (rc)
 509         {
 510           char *tmpfpr;
 511
 512           tmpfpr = gpgsm_get_fingerprint_hexstring (cert, 0);
 513           gpgsm_status2 (ctrl, STATUS_INV_SGNR,
 514                          get_inv_recpsgnr_code (rc), tmpfpr, NULL);
 515           xfree (tmpfpr);
 516           goto leave;
 517         }
 518
 519       /* That one is fine - create signerlist. */
 520       signerlist = xtrycalloc (1, sizeof *signerlist);
 521       if (!signerlist)
 522         {
 523           rc = out_of_core ();
 524           ksba_cert_release (cert);
 525           goto leave;
 526         }
 527       signerlist->cert = cert;
 528       release_signerlist = 1;
 529     }
 530
 531
 532   /* Figure out the hash algorithm to use. We do not want to use the
 533      one for the certificate but if possible an OID for the plain
 534      algorithm.  */
 535   if (opt.forced_digest_algo && opt.verbose)
 536     log_info ("user requested hash algorithm %d\n", opt.forced_digest_algo);
 537   for (i=0, cl=signerlist; cl; cl = cl->next, i++)
 538     {
 539       const char *oid;
 540       unsigned int nbits;
 541       int pk_algo;
 542
 543       pk_algo = gpgsm_get_key_algo_info (cl->cert, &nbits);
 544       cl->pk_algo = pk_algo;
 545
 546       if (opt.forced_digest_algo)
 547         {
 548           oid = NULL;
 549           cl->hash_algo = opt.forced_digest_algo;
 550         }
 551       else
 552         {
 553           if (pk_algo == GCRY_PK_ECC)
 554             {
 555               /* Map the Curve to a corresponding hash algo.  */
 556               if (nbits <= 256)
 557                 oid = "2.16.840.1.101.3.4.2.1"; /* sha256 */
 558               else if (nbits <= 384)
 559                 oid = "2.16.840.1.101.3.4.2.2"; /* sha384 */
 560               else
 561                 oid = "2.16.840.1.101.3.4.2.3"; /* sha512 */
 562             }
 563           else
 564             {
 565               /* For RSA we reuse the hash algo used by the certificate.  */
 566               oid = ksba_cert_get_digest_algo (cl->cert);
 567             }
 568           cl->hash_algo = oid ? gcry_md_map_name (oid) : 0;
 569         }
 570       switch (cl->hash_algo)
 571         {
 572         case GCRY_MD_SHA1:   oid = "1.3.14.3.2.26"; break;
 573         case GCRY_MD_RMD160: oid = "1.3.36.3.2.1"; break;
 574         case GCRY_MD_SHA224: oid = "2.16.840.1.101.3.4.2.4"; break;
 575         case GCRY_MD_SHA256: oid = "2.16.840.1.101.3.4.2.1"; break;
 576         case GCRY_MD_SHA384: oid = "2.16.840.1.101.3.4.2.2"; break;
 577         case GCRY_MD_SHA512: oid = "2.16.840.1.101.3.4.2.3"; break;
 578 /*         case GCRY_MD_WHIRLPOOL: oid = "No OID yet"; break; */
 579
 580         case GCRY_MD_MD5:  /* We don't want to use MD5.  */
 581         case 0:            /* No algorithm found in cert.  */
 582         default:           /* Other algorithms.  */
 583           log_info (_("hash algorithm %d (%s) for signer %d not supported;"
 584                       " using %s\n"),
 585                     cl->hash_algo, oid? oid: "?", i,
 586                     gcry_md_algo_name (GCRY_MD_SHA1));
 587           cl->hash_algo = GCRY_MD_SHA1;
 588           oid = "1.3.14.3.2.26";
 589           break;
 590         }
 591       cl->hash_algo_oid = oid;
 592
 593       /* Check compliance.  */
 594       if (! gnupg_digest_is_allowed (opt.compliance, 1, cl->hash_algo))
 595         {
 596           log_error (_("digest algorithm '%s' may not be used in %s mode\n"),
 597                      gcry_md_algo_name (cl->hash_algo),
 598                      gnupg_compliance_option_string (opt.compliance));
 599           err = gpg_error (GPG_ERR_DIGEST_ALGO);
 600           goto leave;
 601         }
 602
 603       if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_SIGNING, pk_algo, 0,
 604                                  NULL, nbits, NULL))
 605         {
 606           char  kidstr[10+1];
 607
 608           snprintf (kidstr, sizeof kidstr, "0x%08lX",
 609                     gpgsm_get_short_fingerprint (cl->cert, NULL));
 610           log_error (_("key %s may not be used for signing in %s mode\n"),
 611                      kidstr,
 612                      gnupg_compliance_option_string (opt.compliance));
 613           err = gpg_error (GPG_ERR_PUBKEY_ALGO);
 614           goto leave;
 615         }
 616
 617     }
 618
 619   if (opt.verbose > 1 || opt.debug)
 620     {
 621       for (i=0, cl=signerlist; cl; cl = cl->next, i++)
 622         log_info (_("hash algorithm used for signer %d: %s (%s)\n"),
 623                   i, gcry_md_algo_name (cl->hash_algo), cl->hash_algo_oid);
 624     }
 625
 626
 627   /* Gather certificates of signers and store them in the CMS object. */
 628   for (cl=signerlist; cl; cl = cl->next)
 629     {
 630       rc = gpgsm_cert_use_sign_p (cl->cert, 0);
 631       if (rc)
 632         goto leave;
 633
 634       err = ksba_cms_add_signer (cms, cl->cert);
 635       if (err)
 636         {
 637           log_error ("ksba_cms_add_signer failed: %s\n", gpg_strerror (err));
 638           rc = err;
 639           goto leave;
 640         }
 641       rc = add_certificate_list (ctrl, cms, cl->cert);
 642       if (rc)
 643         {
 644           log_error ("failed to store list of certificates: %s\n",
 645                      gpg_strerror(rc));
 646           goto leave;
 647         }
 648       /* Set the hash algorithm we are going to use */
 649       err = ksba_cms_add_digest_algo (cms, cl->hash_algo_oid);
 650       if (err)
 651         {
 652           log_debug ("ksba_cms_add_digest_algo failed: %s\n",
 653                      gpg_strerror (err));
 654           rc = err;
 655           goto leave;
 656         }
 657     }
 658
 659
 660   /* Check whether one of the certificates is qualified.  Note that we
 661      already validated the certificate and thus the user data stored
 662      flag must be available. */
 663   if (!opt.no_chain_validation)
 664     {
 665       for (cl=signerlist; cl; cl = cl->next)
 666         {
 667           size_t buflen;
 668           char buffer[1];
 669
 670           err = ksba_cert_get_user_data (cl->cert, "is_qualified",
 671                                          &buffer, sizeof (buffer), &buflen);
 672           if (err || !buflen)
 673             {
 674               log_error (_("checking for qualified certificate failed: %s\n"),
 675                          gpg_strerror (err));
 676               rc = err;
 677               goto leave;
 678             }
 679           if (*buffer)
 680             err = gpgsm_qualified_consent (ctrl, cl->cert);
 681           else
 682             err = gpgsm_not_qualified_warning (ctrl, cl->cert);
 683           if (err)
 684             {
 685               rc = err;
 686               goto leave;
 687             }
 688         }
 689     }
 690
 691   /* Prepare hashing (actually we are figuring out what we have set
 692      above). */
 693   rc = gcry_md_open (&data_md, 0, 0);
 694   if (rc)
 695     {
 696       log_error ("md_open failed: %s\n", gpg_strerror (rc));
 697       goto leave;
 698     }
 699   if (DBG_HASHING)
 700     gcry_md_debug (data_md, "sign.data");
 701
 702   for (i=0; (algoid=ksba_cms_get_digest_algo_list (cms, i)); i++)
 703     {
 704       algo = gcry_md_map_name (algoid);
 705       if (!algo)
 706         {
 707           log_error ("unknown hash algorithm '%s'\n", algoid? algoid:"?");
 708           rc = gpg_error (GPG_ERR_BUG);
 709           goto leave;
 710         }
 711       gcry_md_enable (data_md, algo);
 712       audit_log_i (ctrl->audit, AUDIT_DATA_HASH_ALGO, algo);
 713     }
 714
 715   audit_log (ctrl->audit, AUDIT_SETUP_READY);
 716
 717   if (detached)
 718     { /* We hash the data right now so that we can store the message
 719          digest.  ksba_cms_build() takes this as an flag that detached
 720          data is expected. */
 721       unsigned char *digest;
 722       size_t digest_len;
 723
 724       if (!hash_data (data_fd, data_md))
 725         audit_log (ctrl->audit, AUDIT_GOT_DATA);
 726       for (cl=signerlist,signer=0; cl; cl = cl->next, signer++)
 727         {
 728           digest = gcry_md_read (data_md, cl->hash_algo);
 729           digest_len = gcry_md_get_algo_dlen (cl->hash_algo);
 730           if ( !digest || !digest_len )
 731             {
 732               log_error ("problem getting the hash of the data\n");
 733               rc = gpg_error (GPG_ERR_BUG);
 734               goto leave;
 735             }
 736           err = ksba_cms_set_message_digest (cms, signer, digest, digest_len);
 737           if (err)
 738             {
 739               log_error ("ksba_cms_set_message_digest failed: %s\n",
 740                          gpg_strerror (err));
 741               rc = err;
 742               goto leave;
 743             }
 744         }
 745     }
 746
 747   gnupg_get_isotime (signed_at);
 748   for (cl=signerlist,signer=0; cl; cl = cl->next, signer++)
 749     {
 750       err = ksba_cms_set_signing_time (cms, signer, signed_at);
 751       if (err)
 752         {
 753           log_error ("ksba_cms_set_signing_time failed: %s\n",
 754                      gpg_strerror (err));
 755           rc = err;
 756           goto leave;
 757         }
 758     }
 759
 760   /* We can add signed attributes only when build against libksba 1.4.  */
 761 #if KSBA_VERSION_NUMBER >= 0x010400 && 0 /* 1.4.0 */
 762   {
 763     strlist_t sl;
 764
 765     for (sl = opt.attributes; sl; sl = sl->next)
 766       if ((err = add_signed_attribute (cms, sl->d)))
 767         goto leave;
 768   }
 769 #else
 770   if (opt.attributes)
 771     log_info ("Note: option --attribute is ignored by this version\n");
 772 #endif /*ksba >= 1.4.0  */
 773
 774
 775   /* We need to write at least a minimal list of our capabilities to
 776      try to convince some MUAs to use 3DES and not the crippled
 777      RC2. Our list is:
 778
 779         aes128-CBC
 780         des-EDE3-CBC
 781   */
 782   err = ksba_cms_add_smime_capability (cms, "2.16.840.1.101.3.4.1.2", NULL, 0);
 783   if (!err)
 784     err = ksba_cms_add_smime_capability (cms, "1.2.840.113549.3.7", NULL, 0);
 785   if (err)
 786     {
 787       log_error ("ksba_cms_add_smime_capability failed: %s\n",
 788                  gpg_strerror (err));
 789       goto leave;
 790     }
 791
 792
 793   /* Main building loop. */
 794   do
 795     {
 796       err = ksba_cms_build (cms, &stopreason);
 797       if (err)
 798         {
 799           log_debug ("ksba_cms_build failed: %s\n", gpg_strerror (err));
 800           rc = err;
 801           goto leave;
 802         }
 803
 804       if (stopreason == KSBA_SR_BEGIN_DATA)
 805         {
 806           /* Hash the data and store the message digest. */
 807           unsigned char *digest;
 808           size_t digest_len;
 809
 810           log_assert (!detached);
 811
 812           rc = hash_and_copy_data (data_fd, data_md, writer);
 813           if (rc)
 814             goto leave;
 815           audit_log (ctrl->audit, AUDIT_GOT_DATA);
 816           for (cl=signerlist,signer=0; cl; cl = cl->next, signer++)
 817             {
 818               digest = gcry_md_read (data_md, cl->hash_algo);
 819               digest_len = gcry_md_get_algo_dlen (cl->hash_algo);
 820               if ( !digest || !digest_len )
 821                 {
 822                   log_error ("problem getting the hash of the data\n");
 823                   rc = gpg_error (GPG_ERR_BUG);
 824                   goto leave;
 825                 }
 826               err = ksba_cms_set_message_digest (cms, signer,
 827                                                  digest, digest_len);
 828               if (err)
 829                 {
 830                   log_error ("ksba_cms_set_message_digest failed: %s\n",
 831                              gpg_strerror (err));
 832                   rc = err;
 833                   goto leave;
 834                 }
 835             }
 836         }
 837       else if (stopreason == KSBA_SR_NEED_SIG)
 838         {
 839           /* Compute the signature for all signers.  */
 840           gcry_md_hd_t md;
 841
 842           rc = gcry_md_open (&md, 0, 0);
 843           if (rc)
 844             {
 845               log_error ("md_open failed: %s\n", gpg_strerror (rc));
 846               goto leave;
 847             }
 848           if (DBG_HASHING)
 849             gcry_md_debug (md, "sign.attr");
 850           ksba_cms_set_hash_function (cms, HASH_FNC, md);
 851           for (cl=signerlist,signer=0; cl; cl = cl->next, signer++)
 852             {
 853               unsigned char *sigval = NULL;
 854               char *buf, *fpr;
 855
 856               audit_log_i (ctrl->audit, AUDIT_NEW_SIG, signer);
 857               if (signer)
 858                 gcry_md_reset (md);
 859               {
 860                 certlist_t cl_tmp;
 861
 862                 for (cl_tmp=signerlist; cl_tmp; cl_tmp = cl_tmp->next)
 863                   {
 864                     gcry_md_enable (md, cl_tmp->hash_algo);
 865                     audit_log_i (ctrl->audit, AUDIT_ATTR_HASH_ALGO,
 866                                  cl_tmp->hash_algo);
 867                   }
 868               }
 869
 870               rc = ksba_cms_hash_signed_attrs (cms, signer);
 871               if (rc)
 872                 {
 873                   log_debug ("hashing signed attrs failed: %s\n",
 874                              gpg_strerror (rc));
 875                   gcry_md_close (md);
 876                   goto leave;
 877                 }
 878
 879               rc = gpgsm_create_cms_signature (ctrl, cl->cert,
 880                                                md, cl->hash_algo, &sigval);
 881               if (rc)
 882                 {
 883                   audit_log_cert (ctrl->audit, AUDIT_SIGNED_BY, cl->cert, rc);
 884                   gcry_md_close (md);
 885                   goto leave;
 886                 }
 887
 888               err = ksba_cms_set_sig_val (cms, signer, sigval);
 889               xfree (sigval);
 890               if (err)
 891                 {
 892                   audit_log_cert (ctrl->audit, AUDIT_SIGNED_BY, cl->cert, err);
 893                   log_error ("failed to store the signature: %s\n",
 894                              gpg_strerror (err));
 895                   rc = err;
 896                   gcry_md_close (md);
 897                   goto leave;
 898                 }
 899
 900               /* write a status message */
 901               fpr = gpgsm_get_fingerprint_hexstring (cl->cert, GCRY_MD_SHA1);
 902               if (!fpr)
 903                 {
 904                   rc = gpg_error (GPG_ERR_ENOMEM);
 905                   gcry_md_close (md);
 906                   goto leave;
 907                 }
 908               rc = 0;
 909               if (opt.verbose)
 910                 {
 911                   char *pkalgostr = gpgsm_pubkey_algo_string (cl->cert, NULL);
 912                   log_info (_("%s/%s signature using %s key %s\n"),
 913                             pubkey_algo_to_string (cl->pk_algo),
 914                             gcry_md_algo_name (cl->hash_algo),
 915                             pkalgostr, fpr);
 916                   xfree (pkalgostr);
 917                 }
 918               buf = xtryasprintf ("%c %d %d 00 %s %s",
 919                                   detached? 'D':'S',
 920                                   cl->pk_algo,
 921                                   cl->hash_algo,
 922                                   signed_at,
 923                                   fpr);
 924               if (!buf)
 925                 rc = gpg_error_from_syserror ();
 926               xfree (fpr);
 927               if (rc)
 928                 {
 929                   gcry_md_close (md);
 930                   goto leave;
 931                 }
 932               gpgsm_status (ctrl, STATUS_SIG_CREATED, buf);
 933               xfree (buf);
 934               audit_log_cert (ctrl->audit, AUDIT_SIGNED_BY, cl->cert, 0);
 935             }
 936           gcry_md_close (md);
 937         }
 938     }
 939   while (stopreason != KSBA_SR_READY);
 940
 941   rc = gnupg_ksba_finish_writer (b64writer);
 942   if (rc)
 943     {
 944       log_error ("write failed: %s\n", gpg_strerror (rc));
 945       goto leave;
 946     }
 947
 948   audit_log (ctrl->audit, AUDIT_SIGNING_DONE);
 949   log_info ("signature created\n");
 950
 951  leave:
 952   if (rc)
 953     log_error ("error creating signature: %s <%s>\n",
 954                gpg_strerror (rc), gpg_strsource (rc) );
 955   if (release_signerlist)
 956     gpgsm_release_certlist (signerlist);
 957   ksba_cms_release (cms);
 958   gnupg_ksba_destroy_writer (b64writer);
 959   keydb_release (kh);
 960   gcry_md_close (data_md);
 961   return rc;
 962 }