sm/certreqgen.c

   1 /* certreqgen.c - Generate a key and a certification [request]
   2  * Copyright (C) 2002, 2003, 2005, 2007, 2010,
   3  *               2011 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 <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /*
  22    The format of the parameter file is described in the manual under
  23    "Unattended Usage".
  24
  25    Here is an example:
  26      $ cat >foo <<EOF
  27      %echo Generating a standard key
  28      Key-Type: RSA
  29      Key-Length: 2048
  30      Name-DN: CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=Ddorf,C=DE
  31      Name-Email: joe@foo.bar
  32      # Do a commit here, so that we can later print a "done"
  33      %commit
  34      %echo done
  35      EOF
  36
  37    This parameter file was used to create the STEED CA:
  38      Key-Type: RSA
  39      Key-Length: 1024
  40      Key-Grip: 68A638998DFABAC510EA645CE34F9686B2EDF7EA
  41      Key-Usage: cert
  42      Serial: 1
  43      Name-DN: CN=The STEED Self-Signing Nonthority
  44      Not-Before: 2011-11-11
  45      Not-After: 2106-02-06
  46      Subject-Key-Id: 68A638998DFABAC510EA645CE34F9686B2EDF7EA
  47      Extension: 2.5.29.19 c 30060101ff020101
  48      Extension: 1.3.6.1.4.1.11591.2.2.2 n 0101ff
  49      Signing-Key: 68A638998DFABAC510EA645CE34F9686B2EDF7EA
  50      %commit
  51
  52 */
  53
  54
  55 #include <config.h>
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58 #include <string.h>
  59 #include <errno.h>
  60 #include <unistd.h>
  61 #include <time.h>
  62 #include <assert.h>
  63
  64 #include "gpgsm.h"
  65 #include <gcrypt.h>
  66 #include <ksba.h>
  67
  68 #include "keydb.h"
  69 #include "i18n.h"
  70
  71
  72 enum para_name
  73   {
  74     pKEYTYPE,
  75     pKEYLENGTH,
  76     pKEYGRIP,
  77     pKEYUSAGE,
  78     pNAMEDN,
  79     pNAMEEMAIL,
  80     pNAMEDNS,
  81     pNAMEURI,
  82     pSERIAL,
  83     pISSUERDN,
  84     pNOTBEFORE,
  85     pNOTAFTER,
  86     pSIGNINGKEY,
  87     pHASHALGO,
  88     pAUTHKEYID,
  89     pSUBJKEYID,
  90     pEXTENSION
  91   };
  92
  93 struct para_data_s
  94 {
  95   struct para_data_s *next;
  96   int lnr;
  97   enum para_name key;
  98   union {
  99     unsigned int usage;
 100     char value[1];
 101   } u;
 102 };
 103
 104 struct reqgen_ctrl_s
 105 {
 106   int lnr;
 107   int dryrun;
 108 };
 109
 110
 111 static const char oidstr_authorityKeyIdentifier[] = "2.5.29.35";
 112 static const char oidstr_subjectKeyIdentifier[] = "2.5.29.14";
 113 static const char oidstr_keyUsage[] = "2.5.29.15";
 114 static const char oidstr_basicConstraints[] = "2.5.29.19";
 115 static const char oidstr_standaloneCertificate[] = "1.3.6.1.4.1.11591.2.2.1";
 116
 117
 118 static int proc_parameters (ctrl_t ctrl,
 119                             struct para_data_s *para,
 120                             estream_t out_fp,
 121                             struct reqgen_ctrl_s *outctrl);
 122 static int create_request (ctrl_t ctrl,
 123                            struct para_data_s *para,
 124                            const char *carddirect,
 125                            ksba_const_sexp_t public,
 126                            ksba_const_sexp_t sigkey,
 127                            ksba_writer_t writer);
 128
 129
 130 \f
 131 static void
 132 release_parameter_list (struct para_data_s *r)
 133 {
 134   struct para_data_s *r2;
 135
 136   for (; r ; r = r2)
 137     {
 138       r2 = r->next;
 139       xfree(r);
 140     }
 141 }
 142
 143 static struct para_data_s *
 144 get_parameter (struct para_data_s *para, enum para_name key, int seq)
 145 {
 146   struct para_data_s *r;
 147
 148   for (r = para; r ; r = r->next)
 149     if ( r->key == key && !seq--)
 150       return r;
 151   return NULL;
 152 }
 153
 154 static const char *
 155 get_parameter_value (struct para_data_s *para, enum para_name key, int seq)
 156 {
 157   struct para_data_s *r = get_parameter (para, key, seq);
 158   return (r && *r->u.value)? r->u.value : NULL;
 159 }
 160
 161 static int
 162 get_parameter_algo (struct para_data_s *para, enum para_name key)
 163 {
 164   struct para_data_s *r = get_parameter (para, key, 0);
 165   if (!r)
 166     return -1;
 167   if (digitp (r->u.value))
 168     return atoi( r->u.value );
 169   return gcry_pk_map_name (r->u.value);
 170 }
 171
 172 /* Parse the usage parameter.  Returns 0 on success.  Note that we
 173    only care about sign and encrypt and don't (yet) allow all the
 174    other X.509 usage to be specified; instead we will use a fixed
 175    mapping to the X.509 usage flags. */
 176 static int
 177 parse_parameter_usage (struct para_data_s *para, enum para_name key)
 178 {
 179   struct para_data_s *r = get_parameter (para, key, 0);
 180   char *p, *pn;
 181   unsigned int use;
 182
 183   if (!r)
 184     return 0; /* none (this is an optional parameter)*/
 185
 186   use = 0;
 187   pn = r->u.value;
 188   while ( (p = strsep (&pn, " \t,")) )
 189     {
 190       if (!*p)
 191         ;
 192       else if ( !ascii_strcasecmp (p, "sign") )
 193         use |= GCRY_PK_USAGE_SIGN;
 194       else if ( !ascii_strcasecmp (p, "encrypt")
 195                 || !ascii_strcasecmp (p, "encr") )
 196         use |= GCRY_PK_USAGE_ENCR;
 197       else if ( !ascii_strcasecmp (p, "cert") )
 198         use |= GCRY_PK_USAGE_CERT;
 199       else
 200         {
 201           log_error ("line %d: invalid usage list\n", r->lnr);
 202           return -1; /* error */
 203         }
 204     }
 205   r->u.usage = use;
 206   return 0;
 207 }
 208
 209
 210 static unsigned int
 211 get_parameter_uint (struct para_data_s *para, enum para_name key)
 212 {
 213   struct para_data_s *r = get_parameter (para, key, 0);
 214
 215   if (!r)
 216     return 0;
 217
 218   if (r->key == pKEYUSAGE)
 219     return r->u.usage;
 220
 221   return (unsigned int)strtoul (r->u.value, NULL, 10);
 222 }
 223
 224
 225
 226 /* Read the certificate generation parameters from FP and generate
 227    (all) certificate requests.  */
 228 static int
 229 read_parameters (ctrl_t ctrl, estream_t fp, estream_t out_fp)
 230 {
 231   static struct {
 232     const char *name;
 233     enum para_name key;
 234     int allow_dups;
 235   } keywords[] = {
 236     { "Key-Type",       pKEYTYPE},
 237     { "Key-Length",     pKEYLENGTH },
 238     { "Key-Grip",       pKEYGRIP },
 239     { "Key-Usage",      pKEYUSAGE },
 240     { "Name-DN",        pNAMEDN },
 241     { "Name-Email",     pNAMEEMAIL, 1 },
 242     { "Name-DNS",       pNAMEDNS, 1 },
 243     { "Name-URI",       pNAMEURI, 1 },
 244     { "Serial",         pSERIAL },
 245     { "Issuer-DN",      pISSUERDN },
 246     { "Creation-Date",  pNOTBEFORE },
 247     { "Not-Before",     pNOTBEFORE },
 248     { "Expire-Date",    pNOTAFTER },
 249     { "Not-After",      pNOTAFTER },
 250     { "Signing-Key",    pSIGNINGKEY },
 251     { "Hash-Algo",      pHASHALGO },
 252     { "Authority-Key-Id", pAUTHKEYID },
 253     { "Subject-Key-Id", pSUBJKEYID },
 254     { "Extension",      pEXTENSION, 1 },
 255     { NULL, 0 }
 256   };
 257   char line[1024], *p;
 258   const char *err = NULL;
 259   struct para_data_s *para, *r;
 260   int i, rc = 0, any = 0;
 261   struct reqgen_ctrl_s outctrl;
 262
 263   memset (&outctrl, 0, sizeof (outctrl));
 264
 265   err = NULL;
 266   para = NULL;
 267   while (es_fgets (line, DIM(line)-1, fp) )
 268     {
 269       char *keyword, *value;
 270
 271       outctrl.lnr++;
 272       if (*line && line[strlen(line)-1] != '\n')
 273         {
 274           err = "line too long";
 275           break;
 276         }
 277       for (p=line; spacep (p); p++)
 278         ;
 279       if (!*p || *p == '#')
 280         continue;
 281
 282       keyword = p;
 283       if (*keyword == '%')
 284         {
 285           for (; *p && !ascii_isspace (*p); p++)
 286             ;
 287           if (*p)
 288             *p++ = 0;
 289           for (; ascii_isspace (*p); p++)
 290             ;
 291           value = p;
 292           trim_trailing_spaces (value);
 293
 294           if (!ascii_strcasecmp (keyword, "%echo"))
 295             log_info ("%s\n", value);
 296           else if (!ascii_strcasecmp (keyword, "%dry-run"))
 297             outctrl.dryrun = 1;
 298           else if (!ascii_strcasecmp( keyword, "%commit"))
 299             {
 300               rc = proc_parameters (ctrl, para, out_fp, &outctrl);
 301               if (rc)
 302                 goto leave;
 303               any = 1;
 304               release_parameter_list (para);
 305               para = NULL;
 306             }
 307           else
 308             log_info ("skipping control '%s' (%s)\n", keyword, value);
 309
 310           continue;
 311         }
 312
 313
 314       if (!(p = strchr (p, ':')) || p == keyword)
 315         {
 316           err = "missing colon";
 317           break;
 318         }
 319       if (*p)
 320         *p++ = 0;
 321       for (; spacep (p); p++)
 322         ;
 323       if (!*p)
 324         {
 325           err = "missing argument";
 326           break;
 327         }
 328       value = p;
 329       trim_trailing_spaces (value);
 330
 331       for (i=0; (keywords[i].name
 332                  && ascii_strcasecmp (keywords[i].name, keyword)); i++)
 333         ;
 334       if (!keywords[i].name)
 335         {
 336           err = "unknown keyword";
 337           break;
 338         }
 339       if (keywords[i].key != pKEYTYPE && !para)
 340         {
 341           err = "parameter block does not start with \"Key-Type\"";
 342           break;
 343         }
 344
 345       if (keywords[i].key == pKEYTYPE && para)
 346         {
 347           rc = proc_parameters (ctrl, para, out_fp, &outctrl);
 348           if (rc)
 349             goto leave;
 350           any = 1;
 351           release_parameter_list (para);
 352           para = NULL;
 353         }
 354       else if (!keywords[i].allow_dups)
 355         {
 356           for (r = para; r && r->key != keywords[i].key; r = r->next)
 357             ;
 358           if (r)
 359             {
 360               err = "duplicate keyword";
 361               break;
 362             }
 363         }
 364
 365       r = xtrycalloc (1, sizeof *r + strlen( value ));
 366       if (!r)
 367         {
 368           err = "out of core";
 369           break;
 370         }
 371       r->lnr = outctrl.lnr;
 372       r->key = keywords[i].key;
 373       strcpy (r->u.value, value);
 374       r->next = para;
 375       para = r;
 376     }
 377
 378   if (err)
 379     {
 380       log_error ("line %d: %s\n", outctrl.lnr, err);
 381       rc = gpg_error (GPG_ERR_GENERAL);
 382     }
 383   else if (es_ferror(fp))
 384     {
 385       log_error ("line %d: read error: %s\n", outctrl.lnr, strerror(errno) );
 386       rc = gpg_error (GPG_ERR_GENERAL);
 387     }
 388   else if (para)
 389     {
 390       rc = proc_parameters (ctrl, para, out_fp, &outctrl);
 391       if (rc)
 392         goto leave;
 393       any = 1;
 394     }
 395
 396   if (!rc && !any)
 397     rc = gpg_error (GPG_ERR_NO_DATA);
 398
 399  leave:
 400   release_parameter_list (para);
 401   return rc;
 402 }
 403
 404 /* check whether there are invalid characters in the email address S */
 405 static int
 406 has_invalid_email_chars (const char *s)
 407 {
 408   int at_seen=0;
 409   static char valid_chars[] = "01234567890_-."
 410                               "abcdefghijklmnopqrstuvwxyz"
 411                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 412   for (; *s; s++)
 413     {
 414       if (*s & 0x80)
 415         return 1;
 416       if (*s == '@')
 417         at_seen++;
 418       else if (!at_seen && !( !!strchr (valid_chars, *s) || *s == '+'))
 419         return 1;
 420       else if (at_seen && !strchr (valid_chars, *s))
 421         return 1;
 422     }
 423   return at_seen != 1;
 424 }
 425
 426
 427 /* Check that all required parameters are given and perform the action */
 428 static int
 429 proc_parameters (ctrl_t ctrl, struct para_data_s *para,
 430                  estream_t out_fp, struct reqgen_ctrl_s *outctrl)
 431 {
 432   gpg_error_t err;
 433   struct para_data_s *r;
 434   const char *s, *string;
 435   int i;
 436   unsigned int nbits;
 437   char numbuf[20];
 438   unsigned char keyparms[100];
 439   int rc = 0;
 440   ksba_sexp_t public;
 441   ksba_sexp_t sigkey = NULL;
 442   int seq;
 443   size_t erroff, errlen;
 444   char *cardkeyid = NULL;
 445
 446   /* Check that we have all required parameters; */
 447   assert (get_parameter (para, pKEYTYPE, 0));
 448
 449   /* We can only use RSA for now.  There is a problem with pkcs-10 on
 450      how to use ElGamal because it is expected that a PK algorithm can
 451      always be used for signing. Another problem is that on-card
 452      generated encryption keys may not be used for signing.  */
 453   i = get_parameter_algo (para, pKEYTYPE);
 454   if (!i && (s = get_parameter_value (para, pKEYTYPE, 0)) && *s)
 455     {
 456       /* Hack to allow creation of certificates directly from a smart
 457          card.  For example: "Key-Type: card:OPENPGP.3".  */
 458       if (!strncmp (s, "card:", 5) && s[5])
 459         cardkeyid = xtrystrdup (s+5);
 460     }
 461   if ( (i < 1 || i != GCRY_PK_RSA) && !cardkeyid )
 462     {
 463       r = get_parameter (para, pKEYTYPE, 0);
 464       log_error (_("line %d: invalid algorithm\n"), r->lnr);
 465       return gpg_error (GPG_ERR_INV_PARAMETER);
 466     }
 467
 468   /* Check the keylength.  NOTE: If you change this make sure that it
 469      macthes the gpgconflist item in gpgsm.c  */
 470   if (!get_parameter (para, pKEYLENGTH, 0))
 471     nbits = 2048;
 472   else
 473     nbits = get_parameter_uint (para, pKEYLENGTH);
 474   if ((nbits < 1024 || nbits > 4096) && !cardkeyid)
 475     {
 476       /* The BSI specs dated 2002-11-25 don't allow lengths below 1024. */
 477       r = get_parameter (para, pKEYLENGTH, 0);
 478       log_error (_("line %d: invalid key length %u (valid are %d to %d)\n"),
 479                  r->lnr, nbits, 1024, 4096);
 480       xfree (cardkeyid);
 481       return gpg_error (GPG_ERR_INV_PARAMETER);
 482     }
 483
 484   /* Check the usage. */
 485   if (parse_parameter_usage (para, pKEYUSAGE))
 486     {
 487       xfree (cardkeyid);
 488       return gpg_error (GPG_ERR_INV_PARAMETER);
 489     }
 490
 491   /* Check that there is a subject name and that this DN fits our
 492      requirements. */
 493   if (!(s=get_parameter_value (para, pNAMEDN, 0)))
 494     {
 495       r = get_parameter (para, pNAMEDN, 0);
 496       log_error (_("line %d: no subject name given\n"), r->lnr);
 497       xfree (cardkeyid);
 498       return gpg_error (GPG_ERR_INV_PARAMETER);
 499     }
 500   err = ksba_dn_teststr (s, 0, &erroff, &errlen);
 501   if (err)
 502     {
 503       r = get_parameter (para, pNAMEDN, 0);
 504       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_NAME)
 505         log_error (_("line %d: invalid subject name label '%.*s'\n"),
 506                    r->lnr, (int)errlen, s+erroff);
 507       else
 508         log_error (_("line %d: invalid subject name '%s' at pos %d\n"),
 509                    r->lnr, s, (int)erroff);
 510
 511       xfree (cardkeyid);
 512       return gpg_error (GPG_ERR_INV_PARAMETER);
 513     }
 514
 515   /* Check that the optional email address is okay. */
 516   for (seq=0; (s=get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
 517     {
 518       if (has_invalid_email_chars (s)
 519           || *s == '@'
 520           || s[strlen(s)-1] == '@'
 521           || s[strlen(s)-1] == '.'
 522           || strstr(s, ".."))
 523         {
 524           r = get_parameter (para, pNAMEEMAIL, seq);
 525           log_error (_("line %d: not a valid email address\n"), r->lnr);
 526           xfree (cardkeyid);
 527           return gpg_error (GPG_ERR_INV_PARAMETER);
 528         }
 529     }
 530
 531   /* Check the optional serial number.  */
 532   string = get_parameter_value (para, pSERIAL, 0);
 533   if (string)
 534     {
 535       if (!strcmp (string, "random"))
 536         ; /* Okay.  */
 537       else
 538         {
 539           for (s=string, i=0; hexdigitp (s); s++, i++)
 540             ;
 541           if (*s)
 542             {
 543               r = get_parameter (para, pSERIAL, 0);
 544               log_error (_("line %d: invalid serial number\n"), r->lnr);
 545               xfree (cardkeyid);
 546               return gpg_error (GPG_ERR_INV_PARAMETER);
 547             }
 548         }
 549     }
 550
 551   /* Check the optional issuer DN.  */
 552   string = get_parameter_value (para, pISSUERDN, 0);
 553   if (string)
 554     {
 555       err = ksba_dn_teststr (string, 0, &erroff, &errlen);
 556       if (err)
 557         {
 558           r = get_parameter (para, pISSUERDN, 0);
 559           if (gpg_err_code (err) == GPG_ERR_UNKNOWN_NAME)
 560             log_error (_("line %d: invalid issuer name label '%.*s'\n"),
 561                        r->lnr, (int)errlen, string+erroff);
 562           else
 563             log_error (_("line %d: invalid issuer name '%s' at pos %d\n"),
 564                        r->lnr, string, (int)erroff);
 565           xfree (cardkeyid);
 566           return gpg_error (GPG_ERR_INV_PARAMETER);
 567         }
 568     }
 569
 570   /* Check the optional creation date.  */
 571   string = get_parameter_value (para, pNOTBEFORE, 0);
 572   if (string && !string2isotime (NULL, string))
 573     {
 574       r = get_parameter (para, pNOTBEFORE, 0);
 575       log_error (_("line %d: invalid date given\n"), r->lnr);
 576       xfree (cardkeyid);
 577       return gpg_error (GPG_ERR_INV_PARAMETER);
 578     }
 579
 580
 581   /* Check the optional expire date.  */
 582   string = get_parameter_value (para, pNOTAFTER, 0);
 583   if (string && !string2isotime (NULL, string))
 584     {
 585       r = get_parameter (para, pNOTAFTER, 0);
 586       log_error (_("line %d: invalid date given\n"), r->lnr);
 587       xfree (cardkeyid);
 588       return gpg_error (GPG_ERR_INV_PARAMETER);
 589     }
 590
 591   /* Get the optional signing key.  */
 592   string = get_parameter_value (para, pSIGNINGKEY, 0);
 593   if (string)
 594     {
 595       rc = gpgsm_agent_readkey (ctrl, 0, string, &sigkey);
 596       if (rc)
 597         {
 598           r = get_parameter (para, pKEYTYPE, 0);
 599           log_error (_("line %d: error getting signing key by keygrip '%s'"
 600                        ": %s\n"), r->lnr, s, gpg_strerror (rc));
 601           xfree (cardkeyid);
 602           return rc;
 603         }
 604     }
 605
 606   /* Check the optional hash-algo.  */
 607   {
 608     int mdalgo;
 609
 610     string = get_parameter_value (para, pHASHALGO, 0);
 611     if (string && !((mdalgo = gcry_md_map_name (string))
 612                     && (mdalgo == GCRY_MD_SHA1
 613                         || mdalgo == GCRY_MD_SHA256
 614                         || mdalgo == GCRY_MD_SHA384
 615                         || mdalgo == GCRY_MD_SHA512)))
 616       {
 617         r = get_parameter (para, pHASHALGO, 0);
 618         log_error (_("line %d: invalid hash algorithm given\n"), r->lnr);
 619         xfree (cardkeyid);
 620         return gpg_error (GPG_ERR_INV_PARAMETER);
 621       }
 622   }
 623
 624   /* Check the optional AuthorityKeyId.  */
 625   string = get_parameter_value (para, pAUTHKEYID, 0);
 626   if (string)
 627     {
 628       for (s=string, i=0; hexdigitp (s); s++, i++)
 629         ;
 630       if (*s || (i&1))
 631         {
 632           r = get_parameter (para, pAUTHKEYID, 0);
 633           log_error (_("line %d: invalid authority-key-id\n"), r->lnr);
 634           xfree (cardkeyid);
 635           return gpg_error (GPG_ERR_INV_PARAMETER);
 636         }
 637     }
 638
 639   /* Check the optional SubjectKeyId.  */
 640   string = get_parameter_value (para, pSUBJKEYID, 0);
 641   if (string)
 642     {
 643       for (s=string, i=0; hexdigitp (s); s++, i++)
 644         ;
 645       if (*s || (i&1))
 646         {
 647           r = get_parameter (para, pSUBJKEYID, 0);
 648           log_error (_("line %d: invalid subject-key-id\n"), r->lnr);
 649           xfree (cardkeyid);
 650           return gpg_error (GPG_ERR_INV_PARAMETER);
 651         }
 652     }
 653
 654   /* Check the optional extensions. */
 655   for (seq=0; (string=get_parameter_value (para, pEXTENSION, seq)); seq++)
 656     {
 657       int okay = 0;
 658
 659       s = strpbrk (string, " \t:");
 660       if (s)
 661         {
 662           s++;
 663           while (spacep (s))
 664             s++;
 665           if (*s && strchr ("nNcC", *s))
 666             {
 667               s++;
 668               while (spacep (s))
 669                 s++;
 670               if (*s == ':')
 671                 s++;
 672               if (*s)
 673                 {
 674                   while (spacep (s))
 675                     s++;
 676                   for (i=0; hexdigitp (s); s++, i++)
 677                     ;
 678                   if (!((*s && *s != ':') || !i || (i&1)))
 679                     okay = 1;
 680                 }
 681             }
 682         }
 683       if (!okay)
 684         {
 685           r = get_parameter (para, pEXTENSION, seq);
 686           log_error (_("line %d: invalid extension syntax\n"), r->lnr);
 687           xfree (cardkeyid);
 688           return gpg_error (GPG_ERR_INV_PARAMETER);
 689         }
 690     }
 691
 692   /* Create or retrieve the public key.  */
 693   if (cardkeyid) /* Take the key from the current smart card. */
 694     {
 695       rc = gpgsm_agent_readkey (ctrl, 1, cardkeyid, &public);
 696       if (rc)
 697         {
 698           r = get_parameter (para, pKEYTYPE, 0);
 699           log_error (_("line %d: error reading key '%s' from card: %s\n"),
 700                      r->lnr, cardkeyid, gpg_strerror (rc));
 701           xfree (sigkey);
 702           xfree (cardkeyid);
 703           return rc;
 704         }
 705     }
 706   else if ((s=get_parameter_value (para, pKEYGRIP, 0))) /* Use existing key.*/
 707     {
 708       rc = gpgsm_agent_readkey (ctrl, 0, s, &public);
 709       if (rc)
 710         {
 711           r = get_parameter (para, pKEYTYPE, 0);
 712           log_error (_("line %d: error getting key by keygrip '%s': %s\n"),
 713                      r->lnr, s, gpg_strerror (rc));
 714           xfree (sigkey);
 715           xfree (cardkeyid);
 716           return rc;
 717         }
 718     }
 719   else if (!outctrl->dryrun) /* Generate new key.  */
 720     {
 721       sprintf (numbuf, "%u", nbits);
 722       snprintf ((char*)keyparms, DIM (keyparms)-1,
 723                 "(6:genkey(3:rsa(5:nbits%d:%s)))",
 724                 (int)strlen (numbuf), numbuf);
 725       rc = gpgsm_agent_genkey (ctrl, keyparms, &public);
 726       if (rc)
 727         {
 728           r = get_parameter (para, pKEYTYPE, 0);
 729           log_error (_("line %d: key generation failed: %s <%s>\n"),
 730                      r->lnr, gpg_strerror (rc), gpg_strsource (rc));
 731           xfree (sigkey);
 732           xfree (cardkeyid);
 733           return rc;
 734         }
 735     }
 736
 737
 738   if (!outctrl->dryrun)
 739     {
 740       Base64Context b64writer = NULL;
 741       ksba_writer_t writer;
 742       int create_cert ;
 743
 744       create_cert = !!get_parameter_value (para, pSERIAL, 0);
 745
 746       ctrl->pem_name = create_cert? "CERTIFICATE" : "CERTIFICATE REQUEST";
 747       rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
 748       if (rc)
 749         log_error ("can't create writer: %s\n", gpg_strerror (rc));
 750       else
 751         {
 752           rc = create_request (ctrl, para, cardkeyid, public, sigkey, writer);
 753           if (!rc)
 754             {
 755               rc = gpgsm_finish_writer (b64writer);
 756               if (rc)
 757                 log_error ("write failed: %s\n", gpg_strerror (rc));
 758               else
 759                 {
 760                   gpgsm_status (ctrl, STATUS_KEY_CREATED, "P");
 761                   log_info ("certificate%s created\n",
 762                             create_cert?"":" request");
 763                 }
 764             }
 765           gpgsm_destroy_writer (b64writer);
 766         }
 767     }
 768
 769   xfree (sigkey);
 770   xfree (public);
 771   xfree (cardkeyid);
 772
 773   return rc;
 774 }
 775
 776
 777 /* Parameters are checked, the key pair has been created.  Now
 778    generate the request and write it out */
 779 static int
 780 create_request (ctrl_t ctrl,
 781                 struct para_data_s *para,
 782                 const char *carddirect,
 783                 ksba_const_sexp_t public,
 784                 ksba_const_sexp_t sigkey,
 785                 ksba_writer_t writer)
 786 {
 787   ksba_certreq_t cr;
 788   gpg_error_t err;
 789   gcry_md_hd_t md;
 790   ksba_stop_reason_t stopreason;
 791   int rc = 0;
 792   const char *s, *string;
 793   unsigned int use;
 794   int seq;
 795   char *buf, *p;
 796   size_t len;
 797   char numbuf[30];
 798   ksba_isotime_t atime;
 799   int certmode = 0;
 800   int mdalgo;
 801
 802   err = ksba_certreq_new (&cr);
 803   if (err)
 804     return err;
 805
 806   string = get_parameter_value (para, pHASHALGO, 0);
 807   if (string)
 808     mdalgo = gcry_md_map_name (string);
 809   else
 810     mdalgo = GCRY_MD_SHA1;
 811   rc = gcry_md_open (&md, mdalgo, 0);
 812   if (rc)
 813     {
 814       log_error ("md_open failed: %s\n", gpg_strerror (rc));
 815       goto leave;
 816     }
 817   if (DBG_HASHING)
 818     gcry_md_debug (md, "cr.cri");
 819
 820   ksba_certreq_set_hash_function (cr, HASH_FNC, md);
 821   ksba_certreq_set_writer (cr, writer);
 822
 823   err = ksba_certreq_add_subject (cr, get_parameter_value (para, pNAMEDN, 0));
 824   if (err)
 825     {
 826       log_error ("error setting the subject's name: %s\n",
 827                  gpg_strerror (err));
 828       rc = err;
 829       goto leave;
 830     }
 831
 832   for (seq=0; (s = get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
 833     {
 834       buf = xtrymalloc (strlen (s) + 3);
 835       if (!buf)
 836         {
 837           rc = out_of_core ();
 838           goto leave;
 839         }
 840       *buf = '<';
 841       strcpy (buf+1, s);
 842       strcat (buf+1, ">");
 843       err = ksba_certreq_add_subject (cr, buf);
 844       xfree (buf);
 845       if (err)
 846         {
 847           log_error ("error setting the subject's alternate name: %s\n",
 848                      gpg_strerror (err));
 849           rc = err;
 850           goto leave;
 851         }
 852     }
 853
 854   for (seq=0; (s = get_parameter_value (para, pNAMEDNS, seq)); seq++)
 855     {
 856       len = strlen (s);
 857       assert (len);
 858       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
 859       buf = p = xtrymalloc (11 + strlen (numbuf) + len + 3);
 860       if (!buf)
 861         {
 862           rc = out_of_core ();
 863           goto leave;
 864         }
 865       p = stpcpy (p, "(8:dns-name");
 866       p = stpcpy (p, numbuf);
 867       p = stpcpy (p, s);
 868       strcpy (p, ")");
 869
 870       err = ksba_certreq_add_subject (cr, buf);
 871       xfree (buf);
 872       if (err)
 873         {
 874           log_error ("error setting the subject's alternate name: %s\n",
 875                      gpg_strerror (err));
 876           rc = err;
 877           goto leave;
 878         }
 879     }
 880
 881   for (seq=0; (s = get_parameter_value (para, pNAMEURI, seq)); seq++)
 882     {
 883       len = strlen (s);
 884       assert (len);
 885       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
 886       buf = p = xtrymalloc (6 + strlen (numbuf) + len + 3);
 887       if (!buf)
 888         {
 889           rc = out_of_core ();
 890           goto leave;
 891         }
 892       p = stpcpy (p, "(3:uri");
 893       p = stpcpy (p, numbuf);
 894       p = stpcpy (p, s);
 895       strcpy (p, ")");
 896
 897       err = ksba_certreq_add_subject (cr, buf);
 898       xfree (buf);
 899       if (err)
 900         {
 901           log_error ("error setting the subject's alternate name: %s\n",
 902                      gpg_strerror (err));
 903           rc = err;
 904           goto leave;
 905         }
 906     }
 907
 908
 909   err = ksba_certreq_set_public_key (cr, public);
 910   if (err)
 911     {
 912       log_error ("error setting the public key: %s\n",
 913                  gpg_strerror (err));
 914       rc = err;
 915       goto leave;
 916     }
 917
 918   /* Set key usage flags.  */
 919   use = get_parameter_uint (para, pKEYUSAGE);
 920   if (use == GCRY_PK_USAGE_SIGN)
 921     {
 922       /* For signing only we encode the bits:
 923          KSBA_KEYUSAGE_DIGITAL_SIGNATURE
 924          KSBA_KEYUSAGE_NON_REPUDIATION */
 925       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1,
 926                                         "\x03\x02\x06\xC0", 4);
 927     }
 928   else if (use == GCRY_PK_USAGE_ENCR)
 929     {
 930       /* For encrypt only we encode the bits:
 931          KSBA_KEYUSAGE_KEY_ENCIPHERMENT
 932          KSBA_KEYUSAGE_DATA_ENCIPHERMENT */
 933       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1,
 934                                         "\x03\x02\x04\x30", 4);
 935     }
 936   else if (use == GCRY_PK_USAGE_CERT)
 937     {
 938       /* For certify only we encode the bits:
 939          KSBA_KEYUSAGE_KEY_CERT_SIGN
 940          KSBA_KEYUSAGE_CRL_SIGN */
 941       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1,
 942                                         "\x03\x02\x01\x06", 4);
 943     }
 944   else
 945     err = 0; /* Both or none given: don't request one. */
 946   if (err)
 947     {
 948       log_error ("error setting the key usage: %s\n",
 949                  gpg_strerror (err));
 950       rc = err;
 951       goto leave;
 952     }
 953
 954
 955   /* See whether we want to create an X.509 certificate.  */
 956   string = get_parameter_value (para, pSERIAL, 0);
 957   if (string)
 958     {
 959       certmode = 1;
 960
 961       /* Store the serial number.  */
 962       if (!strcmp (string, "random"))
 963         {
 964           char snbuf[3+8+1];
 965
 966           memcpy (snbuf, "(8:", 3);
 967           gcry_create_nonce (snbuf+3, 8);
 968           /* Clear high bit to guarantee a positive integer.  */
 969           snbuf[3] &= 0x7f;
 970           snbuf[3+8] = ')';
 971           err = ksba_certreq_set_serial (cr, snbuf);
 972         }
 973       else
 974         {
 975           char *hexbuf;
 976
 977           /* Allocate a buffer large enough to prefix the string with
 978              a '0' so to have an even number of digits.  Prepend two
 979              further '0' so that the binary result will have a leading
 980              0 byte and thus can't be the representation of a negative
 981              number.  Note that ksba_certreq_set_serial strips all
 982              unneeded leading 0 bytes.  */
 983           hexbuf = p = xtrymalloc (2 + 1 + strlen (string) + 1);
 984           if (!hexbuf)
 985             {
 986               err = gpg_error_from_syserror ();
 987               goto leave;
 988             }
 989           if ((strlen (string) & 1))
 990             *p++ = '0';
 991           *p++ = '0';
 992           *p++ = '0';
 993           strcpy (p, string);
 994           for (p=hexbuf, len=0; p[0] && p[1]; p += 2)
 995             ((unsigned char*)hexbuf)[len++] = xtoi_2 (p);
 996           /* Now build the S-expression.  */
 997           snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
 998           buf = p = xtrymalloc (1 + strlen (numbuf) + len + 1 + 1);
 999           if (!buf)
1000             {
1001               err = gpg_error_from_syserror ();
1002               xfree (hexbuf);
1003               goto leave;
1004             }
1005           p = stpcpy (stpcpy (buf, "("), numbuf);
1006           memcpy (p, hexbuf, len);
1007           p += len;
1008           strcpy (p, ")");
1009           xfree (hexbuf);
1010           err = ksba_certreq_set_serial (cr, buf);
1011           xfree (buf);
1012         }
1013       if (err)
1014         {
1015           log_error ("error setting the serial number: %s\n",
1016                      gpg_strerror (err));
1017           goto leave;
1018         }
1019
1020
1021       /* Store the issuer DN.  If no issuer DN is given and no signing
1022          key has been set we add the standalone extension and the
1023          basic constraints to mark it as a self-signed CA
1024          certificate.  */
1025       string = get_parameter_value (para, pISSUERDN, 0);
1026       if (string)
1027         {
1028           /* Issuer DN given.  Note that this may be the same as the
1029              subject DN and thus this could as well be a self-signed
1030              certificate.  However the caller needs to explicitly
1031              specify basicConstraints and so forth.  */
1032           err = ksba_certreq_set_issuer (cr, string);
1033           if (err)
1034             {
1035               log_error ("error setting the issuer DN: %s\n",
1036                          gpg_strerror (err));
1037               goto leave;
1038             }
1039
1040         }
1041       else if (!string && !sigkey)
1042         {
1043           /* Self-signed certificate requested.  Add basicConstraints
1044              and the custom GnuPG standalone extension.  */
1045           err = ksba_certreq_add_extension (cr, oidstr_basicConstraints, 1,
1046                                             "\x30\x03\x01\x01\xff", 5);
1047           if (err)
1048             goto leave;
1049           err = ksba_certreq_add_extension (cr, oidstr_standaloneCertificate, 0,
1050                                             "\x01\x01\xff", 3);
1051           if (err)
1052             goto leave;
1053         }
1054
1055       /* Store the creation date.  */
1056       string = get_parameter_value (para, pNOTBEFORE, 0);
1057       if (string)
1058         {
1059           if (!string2isotime (atime, string))
1060             BUG (); /* We already checked the value.  */
1061         }
1062       else
1063         gnupg_get_isotime (atime);
1064       err = ksba_certreq_set_validity (cr, 0, atime);
1065       if (err)
1066         {
1067           log_error ("error setting the creation date: %s\n",
1068                      gpg_strerror (err));
1069           goto leave;
1070         }
1071
1072
1073       /* Store the expire date.  If it is not given, libksba inserts a
1074          default value.  */
1075       string = get_parameter_value (para, pNOTAFTER, 0);
1076       if (string)
1077         {
1078           if (!string2isotime (atime, string))
1079             BUG (); /* We already checked the value.  */
1080           err = ksba_certreq_set_validity (cr, 1, atime);
1081           if (err)
1082             {
1083               log_error ("error setting the expire date: %s\n",
1084                          gpg_strerror (err));
1085               goto leave;
1086             }
1087         }
1088
1089
1090       /* Figure out the signing algorithm.  If no sigkey has been
1091          given we set it to the public key to create a self-signed
1092          certificate. */
1093       if (!sigkey)
1094         sigkey = public;
1095
1096       {
1097         unsigned char *siginfo;
1098
1099         err = transform_sigval (sigkey,
1100                                 gcry_sexp_canon_len (sigkey, 0, NULL, NULL),
1101                                 mdalgo, &siginfo, NULL);
1102         if (!err)
1103           {
1104             err = ksba_certreq_set_siginfo (cr, siginfo);
1105             xfree (siginfo);
1106           }
1107         if (err)
1108           {
1109             log_error ("error setting the siginfo: %s\n",
1110                        gpg_strerror (err));
1111             rc = err;
1112             goto leave;
1113           }
1114       }
1115
1116       /* Insert the AuthorityKeyId.  */
1117       string = get_parameter_value (para, pAUTHKEYID, 0);
1118       if (string)
1119         {
1120           char *hexbuf;
1121
1122           /* Allocate a buffer for in-place conversion.  We also add 4
1123              extra bytes space for the tags and lengths fields.  */
1124           hexbuf = xtrymalloc (4 + strlen (string) + 1);
1125           if (!hexbuf)
1126             {
1127               err = gpg_error_from_syserror ();
1128               goto leave;
1129             }
1130           strcpy (hexbuf+4, string);
1131           for (p=hexbuf+4, len=0; p[0] && p[1]; p += 2)
1132             ((unsigned char*)hexbuf)[4+len++] = xtoi_2 (p);
1133           if (len > 125)
1134             {
1135               err = gpg_error (GPG_ERR_TOO_LARGE);
1136               xfree (hexbuf);
1137               goto leave;
1138             }
1139           hexbuf[0] = 0x30;  /* Tag for a Sequence.  */
1140           hexbuf[1] = len+2;
1141           hexbuf[2] = 0x80;  /* Context tag for an implicit Octet string.  */
1142           hexbuf[3] = len;
1143           err = ksba_certreq_add_extension (cr, oidstr_authorityKeyIdentifier,
1144                                             0,
1145                                             hexbuf, 4+len);
1146           xfree (hexbuf);
1147           if (err)
1148             {
1149               log_error ("error setting the authority-key-id: %s\n",
1150                          gpg_strerror (err));
1151               goto leave;
1152             }
1153         }
1154
1155       /* Insert the SubjectKeyId.  */
1156       string = get_parameter_value (para, pSUBJKEYID, 0);
1157       if (string)
1158         {
1159           char *hexbuf;
1160
1161           /* Allocate a buffer for in-place conversion.  We also add 2
1162              extra bytes space for the tag and length field.  */
1163           hexbuf = xtrymalloc (2 + strlen (string) + 1);
1164           if (!hexbuf)
1165             {
1166               err = gpg_error_from_syserror ();
1167               goto leave;
1168             }
1169           strcpy (hexbuf+2, string);
1170           for (p=hexbuf+2, len=0; p[0] && p[1]; p += 2)
1171             ((unsigned char*)hexbuf)[2+len++] = xtoi_2 (p);
1172           if (len > 127)
1173             {
1174               err = gpg_error (GPG_ERR_TOO_LARGE);
1175               xfree (hexbuf);
1176               goto leave;
1177             }
1178           hexbuf[0] = 0x04;  /* Tag for an Octet string.  */
1179           hexbuf[1] = len;
1180           err = ksba_certreq_add_extension (cr, oidstr_subjectKeyIdentifier, 0,
1181                                             hexbuf, 2+len);
1182           xfree (hexbuf);
1183           if (err)
1184             {
1185               log_error ("error setting the subject-key-id: %s\n",
1186                          gpg_strerror (err));
1187               goto leave;
1188             }
1189         }
1190
1191       /* Insert additional extensions.  */
1192       for (seq=0; (string = get_parameter_value (para, pEXTENSION, seq)); seq++)
1193         {
1194           char *hexbuf;
1195           char *oidstr;
1196           int crit = 0;
1197
1198           s = strpbrk (string, " \t:");
1199           if (!s)
1200             {
1201               err = gpg_error (GPG_ERR_INTERNAL);
1202               goto leave;
1203             }
1204
1205           oidstr = xtrymalloc (s - string + 1);
1206           if (!oidstr)
1207             {
1208               err = gpg_error_from_syserror ();
1209               goto leave;
1210             }
1211           memcpy (oidstr, string, (s-string));
1212           oidstr[(s-string)] = 0;
1213
1214           s++;
1215           while (spacep (s))
1216             s++;
1217           if (!*s)
1218             {
1219               err = gpg_error (GPG_ERR_INTERNAL);
1220               xfree (oidstr);
1221               goto leave;
1222             }
1223
1224           if (strchr ("cC", *s))
1225             crit = 1;
1226           s++;
1227           while (spacep (s))
1228             s++;
1229           if (*s == ':')
1230             s++;
1231           while (spacep (s))
1232             s++;
1233
1234           hexbuf = xtrystrdup (s);
1235           if (!hexbuf)
1236             {
1237               err = gpg_error_from_syserror ();
1238               xfree (oidstr);
1239               goto leave;
1240             }
1241           for (p=hexbuf, len=0; p[0] && p[1]; p += 2)
1242             ((unsigned char*)hexbuf)[len++] = xtoi_2 (p);
1243           err = ksba_certreq_add_extension (cr, oidstr, crit,
1244                                             hexbuf, len);
1245           xfree (oidstr);
1246           xfree (hexbuf);
1247         }
1248     }
1249   else
1250     sigkey = public;
1251
1252   do
1253     {
1254       err = ksba_certreq_build (cr, &stopreason);
1255       if (err)
1256         {
1257           log_error ("ksba_certreq_build failed: %s\n", gpg_strerror (err));
1258           rc = err;
1259           goto leave;
1260         }
1261       if (stopreason == KSBA_SR_NEED_SIG)
1262         {
1263           gcry_sexp_t s_pkey;
1264           size_t n;
1265           unsigned char grip[20];
1266           char hexgrip[41];
1267           unsigned char *sigval, *newsigval;
1268           size_t siglen;
1269
1270           n = gcry_sexp_canon_len (sigkey, 0, NULL, NULL);
1271           if (!n)
1272             {
1273               log_error ("libksba did not return a proper S-Exp\n");
1274               rc = gpg_error (GPG_ERR_BUG);
1275               goto leave;
1276             }
1277           rc = gcry_sexp_sscan (&s_pkey, NULL, (const char*)sigkey, n);
1278           if (rc)
1279             {
1280               log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
1281               goto leave;
1282             }
1283           if ( !gcry_pk_get_keygrip (s_pkey, grip) )
1284             {
1285               rc = gpg_error (GPG_ERR_GENERAL);
1286               log_error ("can't figure out the keygrip\n");
1287               gcry_sexp_release (s_pkey);
1288               goto leave;
1289             }
1290           gcry_sexp_release (s_pkey);
1291           bin2hex (grip, 20, hexgrip);
1292
1293           log_info ("about to sign the %s for key: &%s\n",
1294                     certmode? "certificate":"CSR", hexgrip);
1295
1296           if (carddirect)
1297             rc = gpgsm_scd_pksign (ctrl, carddirect, NULL,
1298                                    gcry_md_read (md, mdalgo),
1299                                    gcry_md_get_algo_dlen (mdalgo),
1300                                    mdalgo,
1301                                    &sigval, &siglen);
1302           else
1303             {
1304               char *orig_codeset;
1305               char *desc;
1306
1307               orig_codeset = i18n_switchto_utf8 ();
1308               desc = percent_plus_escape
1309                 (_("To complete this certificate request please enter"
1310                    " the passphrase for the key you just created once"
1311                    " more.\n"));
1312               i18n_switchback (orig_codeset);
1313               rc = gpgsm_agent_pksign (ctrl, hexgrip, desc,
1314                                        gcry_md_read(md, mdalgo),
1315                                        gcry_md_get_algo_dlen (mdalgo),
1316                                        mdalgo,
1317                                        &sigval, &siglen);
1318               xfree (desc);
1319             }
1320           if (rc)
1321             {
1322               log_error ("signing failed: %s\n", gpg_strerror (rc));
1323               goto leave;
1324             }
1325
1326           err = transform_sigval (sigval, siglen, mdalgo,
1327                                   &newsigval, NULL);
1328           xfree (sigval);
1329           if (!err)
1330             {
1331               err = ksba_certreq_set_sig_val (cr, newsigval);
1332               xfree (newsigval);
1333             }
1334           if (err)
1335             {
1336               log_error ("failed to store the sig_val: %s\n",
1337                          gpg_strerror (err));
1338               rc = err;
1339               goto leave;
1340             }
1341         }
1342     }
1343   while (stopreason != KSBA_SR_READY);
1344
1345
1346  leave:
1347   gcry_md_close (md);
1348   ksba_certreq_release (cr);
1349   return rc;
1350 }
1351
1352
1353 \f
1354 /* Create a new key by reading the parameters from IN_FP.  Multiple
1355    keys may be created */
1356 int
1357 gpgsm_genkey (ctrl_t ctrl, estream_t in_stream, estream_t out_stream)
1358 {
1359   int rc;
1360
1361   rc = read_parameters (ctrl, in_stream, out_stream);
1362   if (rc)
1363     {
1364       log_error ("error creating certificate request: %s <%s>\n",
1365                  gpg_strerror (rc), gpg_strsource (rc));
1366       goto leave;
1367     }
1368
1369  leave:
1370   return rc;
1371 }