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 <https://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 = NULL;
 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),
 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_SHA256;
 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)
 921     {
 922       unsigned int mask, pos;
 923       unsigned char der[4];
 924
 925       der[0] = 0x03;
 926       der[1] = 0x02;
 927       der[2] = 0;
 928       der[3] = 0;
 929       if ((use & GCRY_PK_USAGE_SIGN))
 930         {
 931           /* For signing only we encode the bits:
 932              KSBA_KEYUSAGE_DIGITAL_SIGNATURE
 933              KSBA_KEYUSAGE_NON_REPUDIATION  = 0b11 -> 0b11000000 */
 934           der[3] |= 0xc0;
 935         }
 936       if ((use & GCRY_PK_USAGE_ENCR))
 937         {
 938           /* For encrypt only we encode the bits:
 939              KSBA_KEYUSAGE_KEY_ENCIPHERMENT
 940              KSBA_KEYUSAGE_DATA_ENCIPHERMENT = 0b1100 -> 0b00110000 */
 941           der[3] |= 0x30;
 942         }
 943       if ((use & GCRY_PK_USAGE_CERT))
 944         {
 945           /* For certify only we encode the bits:
 946              KSBA_KEYUSAGE_KEY_CERT_SIGN
 947              KSBA_KEYUSAGE_CRL_SIGN      = 0b1100000 -> 0b00000110 */
 948           der[3] |= 0x06;
 949         }
 950
 951       /* Count number of unused bits.  */
 952       for (mask=1, pos=0; pos < 8 * sizeof mask; pos++, mask <<= 1)
 953         {
 954           if ((der[3] & mask))
 955             break;
 956           der[2]++;
 957         }
 958
 959       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1, der, 4);
 960       if (err)
 961         {
 962           log_error ("error setting the key usage: %s\n",
 963                      gpg_strerror (err));
 964           rc = err;
 965           goto leave;
 966         }
 967     }
 968
 969
 970   /* See whether we want to create an X.509 certificate.  */
 971   string = get_parameter_value (para, pSERIAL, 0);
 972   if (string)
 973     {
 974       certmode = 1;
 975
 976       /* Store the serial number.  */
 977       if (!strcmp (string, "random"))
 978         {
 979           char snbuf[3+8+1];
 980
 981           memcpy (snbuf, "(8:", 3);
 982           gcry_create_nonce (snbuf+3, 8);
 983           /* Clear high bit to guarantee a positive integer.  */
 984           snbuf[3] &= 0x7f;
 985           snbuf[3+8] = ')';
 986           err = ksba_certreq_set_serial (cr, snbuf);
 987         }
 988       else
 989         {
 990           char *hexbuf;
 991
 992           /* Allocate a buffer large enough to prefix the string with
 993              a '0' so to have an even number of digits.  Prepend two
 994              further '0' so that the binary result will have a leading
 995              0 byte and thus can't be the representation of a negative
 996              number.  Note that ksba_certreq_set_serial strips all
 997              unneeded leading 0 bytes.  */
 998           hexbuf = p = xtrymalloc (2 + 1 + strlen (string) + 1);
 999           if (!hexbuf)
1000             {
1001               err = gpg_error_from_syserror ();
1002               goto leave;
1003             }
1004           if ((strlen (string) & 1))
1005             *p++ = '0';
1006           *p++ = '0';
1007           *p++ = '0';
1008           strcpy (p, string);
1009           for (p=hexbuf, len=0; p[0] && p[1]; p += 2)
1010             ((unsigned char*)hexbuf)[len++] = xtoi_2 (p);
1011           /* Now build the S-expression.  */
1012           snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
1013           buf = p = xtrymalloc (1 + strlen (numbuf) + len + 1 + 1);
1014           if (!buf)
1015             {
1016               err = gpg_error_from_syserror ();
1017               xfree (hexbuf);
1018               goto leave;
1019             }
1020           p = stpcpy (stpcpy (buf, "("), numbuf);
1021           memcpy (p, hexbuf, len);
1022           p += len;
1023           strcpy (p, ")");
1024           xfree (hexbuf);
1025           err = ksba_certreq_set_serial (cr, buf);
1026           xfree (buf);
1027         }
1028       if (err)
1029         {
1030           log_error ("error setting the serial number: %s\n",
1031                      gpg_strerror (err));
1032           goto leave;
1033         }
1034
1035
1036       /* Store the issuer DN.  If no issuer DN is given and no signing
1037          key has been set we add the standalone extension and the
1038          basic constraints to mark it as a self-signed CA
1039          certificate.  */
1040       string = get_parameter_value (para, pISSUERDN, 0);
1041       if (string)
1042         {
1043           /* Issuer DN given.  Note that this may be the same as the
1044              subject DN and thus this could as well be a self-signed
1045              certificate.  However the caller needs to explicitly
1046              specify basicConstraints and so forth.  */
1047           err = ksba_certreq_set_issuer (cr, string);
1048           if (err)
1049             {
1050               log_error ("error setting the issuer DN: %s\n",
1051                          gpg_strerror (err));
1052               goto leave;
1053             }
1054
1055         }
1056       else if (!string && !sigkey)
1057         {
1058           /* Self-signed certificate requested.  Add basicConstraints
1059              and the custom GnuPG standalone extension.  */
1060           err = ksba_certreq_add_extension (cr, oidstr_basicConstraints, 1,
1061                                             "\x30\x03\x01\x01\xff", 5);
1062           if (err)
1063             goto leave;
1064           err = ksba_certreq_add_extension (cr, oidstr_standaloneCertificate, 0,
1065                                             "\x01\x01\xff", 3);
1066           if (err)
1067             goto leave;
1068         }
1069
1070       /* Store the creation date.  */
1071       string = get_parameter_value (para, pNOTBEFORE, 0);
1072       if (string)
1073         {
1074           if (!string2isotime (atime, string))
1075             BUG (); /* We already checked the value.  */
1076         }
1077       else
1078         gnupg_get_isotime (atime);
1079       err = ksba_certreq_set_validity (cr, 0, atime);
1080       if (err)
1081         {
1082           log_error ("error setting the creation date: %s\n",
1083                      gpg_strerror (err));
1084           goto leave;
1085         }
1086
1087
1088       /* Store the expire date.  If it is not given, libksba inserts a
1089          default value.  */
1090       string = get_parameter_value (para, pNOTAFTER, 0);
1091       if (string)
1092         {
1093           if (!string2isotime (atime, string))
1094             BUG (); /* We already checked the value.  */
1095           err = ksba_certreq_set_validity (cr, 1, atime);
1096           if (err)
1097             {
1098               log_error ("error setting the expire date: %s\n",
1099                          gpg_strerror (err));
1100               goto leave;
1101             }
1102         }
1103
1104
1105       /* Figure out the signing algorithm.  If no sigkey has been
1106          given we set it to the public key to create a self-signed
1107          certificate. */
1108       if (!sigkey)
1109         sigkey = public;
1110
1111       {
1112         unsigned char *siginfo;
1113
1114         err = transform_sigval (sigkey,
1115                                 gcry_sexp_canon_len (sigkey, 0, NULL, NULL),
1116                                 mdalgo, &siginfo, NULL);
1117         if (!err)
1118           {
1119             err = ksba_certreq_set_siginfo (cr, siginfo);
1120             xfree (siginfo);
1121           }
1122         if (err)
1123           {
1124             log_error ("error setting the siginfo: %s\n",
1125                        gpg_strerror (err));
1126             rc = err;
1127             goto leave;
1128           }
1129       }
1130
1131       /* Insert the AuthorityKeyId.  */
1132       string = get_parameter_value (para, pAUTHKEYID, 0);
1133       if (string)
1134         {
1135           char *hexbuf;
1136
1137           /* Allocate a buffer for in-place conversion.  We also add 4
1138              extra bytes space for the tags and lengths fields.  */
1139           hexbuf = xtrymalloc (4 + strlen (string) + 1);
1140           if (!hexbuf)
1141             {
1142               err = gpg_error_from_syserror ();
1143               goto leave;
1144             }
1145           strcpy (hexbuf+4, string);
1146           for (p=hexbuf+4, len=0; p[0] && p[1]; p += 2)
1147             ((unsigned char*)hexbuf)[4+len++] = xtoi_2 (p);
1148           if (len > 125)
1149             {
1150               err = gpg_error (GPG_ERR_TOO_LARGE);
1151               xfree (hexbuf);
1152               goto leave;
1153             }
1154           hexbuf[0] = 0x30;  /* Tag for a Sequence.  */
1155           hexbuf[1] = len+2;
1156           hexbuf[2] = 0x80;  /* Context tag for an implicit Octet string.  */
1157           hexbuf[3] = len;
1158           err = ksba_certreq_add_extension (cr, oidstr_authorityKeyIdentifier,
1159                                             0,
1160                                             hexbuf, 4+len);
1161           xfree (hexbuf);
1162           if (err)
1163             {
1164               log_error ("error setting the authority-key-id: %s\n",
1165                          gpg_strerror (err));
1166               goto leave;
1167             }
1168         }
1169
1170       /* Insert the SubjectKeyId.  */
1171       string = get_parameter_value (para, pSUBJKEYID, 0);
1172       if (string)
1173         {
1174           char *hexbuf;
1175
1176           /* Allocate a buffer for in-place conversion.  We also add 2
1177              extra bytes space for the tag and length field.  */
1178           hexbuf = xtrymalloc (2 + strlen (string) + 1);
1179           if (!hexbuf)
1180             {
1181               err = gpg_error_from_syserror ();
1182               goto leave;
1183             }
1184           strcpy (hexbuf+2, string);
1185           for (p=hexbuf+2, len=0; p[0] && p[1]; p += 2)
1186             ((unsigned char*)hexbuf)[2+len++] = xtoi_2 (p);
1187           if (len > 127)
1188             {
1189               err = gpg_error (GPG_ERR_TOO_LARGE);
1190               xfree (hexbuf);
1191               goto leave;
1192             }
1193           hexbuf[0] = 0x04;  /* Tag for an Octet string.  */
1194           hexbuf[1] = len;
1195           err = ksba_certreq_add_extension (cr, oidstr_subjectKeyIdentifier, 0,
1196                                             hexbuf, 2+len);
1197           xfree (hexbuf);
1198           if (err)
1199             {
1200               log_error ("error setting the subject-key-id: %s\n",
1201                          gpg_strerror (err));
1202               goto leave;
1203             }
1204         }
1205
1206       /* Insert additional extensions.  */
1207       for (seq=0; (string = get_parameter_value (para, pEXTENSION, seq)); seq++)
1208         {
1209           char *hexbuf;
1210           char *oidstr;
1211           int crit = 0;
1212
1213           s = strpbrk (string, " \t:");
1214           if (!s)
1215             {
1216               err = gpg_error (GPG_ERR_INTERNAL);
1217               goto leave;
1218             }
1219
1220           oidstr = xtrymalloc (s - string + 1);
1221           if (!oidstr)
1222             {
1223               err = gpg_error_from_syserror ();
1224               goto leave;
1225             }
1226           memcpy (oidstr, string, (s-string));
1227           oidstr[(s-string)] = 0;
1228
1229           s++;
1230           while (spacep (s))
1231             s++;
1232           if (!*s)
1233             {
1234               err = gpg_error (GPG_ERR_INTERNAL);
1235               xfree (oidstr);
1236               goto leave;
1237             }
1238
1239           if (strchr ("cC", *s))
1240             crit = 1;
1241           s++;
1242           while (spacep (s))
1243             s++;
1244           if (*s == ':')
1245             s++;
1246           while (spacep (s))
1247             s++;
1248
1249           hexbuf = xtrystrdup (s);
1250           if (!hexbuf)
1251             {
1252               err = gpg_error_from_syserror ();
1253               xfree (oidstr);
1254               goto leave;
1255             }
1256           for (p=hexbuf, len=0; p[0] && p[1]; p += 2)
1257             ((unsigned char*)hexbuf)[len++] = xtoi_2 (p);
1258           err = ksba_certreq_add_extension (cr, oidstr, crit,
1259                                             hexbuf, len);
1260           xfree (oidstr);
1261           xfree (hexbuf);
1262         }
1263     }
1264   else
1265     sigkey = public;
1266
1267   do
1268     {
1269       err = ksba_certreq_build (cr, &stopreason);
1270       if (err)
1271         {
1272           log_error ("ksba_certreq_build failed: %s\n", gpg_strerror (err));
1273           rc = err;
1274           goto leave;
1275         }
1276       if (stopreason == KSBA_SR_NEED_SIG)
1277         {
1278           gcry_sexp_t s_pkey;
1279           size_t n;
1280           unsigned char grip[20];
1281           char hexgrip[41];
1282           unsigned char *sigval, *newsigval;
1283           size_t siglen;
1284
1285           n = gcry_sexp_canon_len (sigkey, 0, NULL, NULL);
1286           if (!n)
1287             {
1288               log_error ("libksba did not return a proper S-Exp\n");
1289               rc = gpg_error (GPG_ERR_BUG);
1290               goto leave;
1291             }
1292           rc = gcry_sexp_sscan (&s_pkey, NULL, (const char*)sigkey, n);
1293           if (rc)
1294             {
1295               log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
1296               goto leave;
1297             }
1298           if ( !gcry_pk_get_keygrip (s_pkey, grip) )
1299             {
1300               rc = gpg_error (GPG_ERR_GENERAL);
1301               log_error ("can't figure out the keygrip\n");
1302               gcry_sexp_release (s_pkey);
1303               goto leave;
1304             }
1305           gcry_sexp_release (s_pkey);
1306           bin2hex (grip, 20, hexgrip);
1307
1308           log_info ("about to sign the %s for key: &%s\n",
1309                     certmode? "certificate":"CSR", hexgrip);
1310
1311           if (carddirect)
1312             rc = gpgsm_scd_pksign (ctrl, carddirect, NULL,
1313                                    gcry_md_read (md, mdalgo),
1314                                    gcry_md_get_algo_dlen (mdalgo),
1315                                    mdalgo,
1316                                    &sigval, &siglen);
1317           else
1318             {
1319               char *orig_codeset;
1320               char *desc;
1321
1322               orig_codeset = i18n_switchto_utf8 ();
1323               desc = percent_plus_escape
1324                 (_("To complete this certificate request please enter"
1325                    " the passphrase for the key you just created once"
1326                    " more.\n"));
1327               i18n_switchback (orig_codeset);
1328               rc = gpgsm_agent_pksign (ctrl, hexgrip, desc,
1329                                        gcry_md_read(md, mdalgo),
1330                                        gcry_md_get_algo_dlen (mdalgo),
1331                                        mdalgo,
1332                                        &sigval, &siglen);
1333               xfree (desc);
1334             }
1335           if (rc)
1336             {
1337               log_error ("signing failed: %s\n", gpg_strerror (rc));
1338               goto leave;
1339             }
1340
1341           err = transform_sigval (sigval, siglen, mdalgo,
1342                                   &newsigval, NULL);
1343           xfree (sigval);
1344           if (!err)
1345             {
1346               err = ksba_certreq_set_sig_val (cr, newsigval);
1347               xfree (newsigval);
1348             }
1349           if (err)
1350             {
1351               log_error ("failed to store the sig_val: %s\n",
1352                          gpg_strerror (err));
1353               rc = err;
1354               goto leave;
1355             }
1356         }
1357     }
1358   while (stopreason != KSBA_SR_READY);
1359
1360
1361  leave:
1362   gcry_md_close (md);
1363   ksba_certreq_release (cr);
1364   return rc;
1365 }
1366
1367
1368 \f
1369 /* Create a new key by reading the parameters from IN_FP.  Multiple
1370    keys may be created */
1371 int
1372 gpgsm_genkey (ctrl_t ctrl, estream_t in_stream, estream_t out_stream)
1373 {
1374   int rc;
1375
1376   rc = read_parameters (ctrl, in_stream, out_stream);
1377   if (rc)
1378     {
1379       log_error ("error creating certificate request: %s <%s>\n",
1380                  gpg_strerror (rc), gpg_strsource (rc));
1381       goto leave;
1382     }
1383
1384  leave:
1385   return rc;
1386 }