← Back to branch summary

~ubuntu-branches/ubuntu/karmic/gnupg2/karmic-updates

« back to all changes in this revision

Viewing changes to sm/certreqgen.c

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Viehmann
  • Date: 2008-10-04 10:25:53 UTC
  • mfrom: (5.1.15 intrepid)
  • Revision ID: james.westby@ubuntu.com-20081004102553-fv62pp8dsitxli47
Tags: 2.0.9-3.1
http://bugs.debian.org/499569
* Non-maintainer upload.
* agent/gpg-agent.c: Deinit the threading library before exec'ing
  the command to run in --daemon mode. And because that still doesn't
  restore the sigprocmask, do that manually. Closes: #499569

Show diffs side-by-side

added added

removed removed

Lines of Context:
sm/certreqgen.c
1
1
/* certreqgen.c - Generate a key and a certification request
2
 
 *      Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.
 
2
 * Copyright (C) 2002, 2003, 2005, 2007 Free Software Foundation, Inc.
3
3
 *
4
4
 * This file is part of GnuPG.
5
5
 *
6
6
 * GnuPG is free software; you can redistribute it and/or modify
7
7
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * the Free Software Foundation; either version 3 of the License, or
9
9
 * (at your option) any later version.
10
10
 *
11
11
 * GnuPG is distributed in the hope that it will be useful,
14
14
 * GNU General Public License for more details.
15
15
 *
16
16
 * You should have received a copy of the GNU General Public License
17
 
 * along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 
17
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19
18
 */
20
19
 
21
20
/*
65
64
        Length of the key in bits.  Default is 1024.
66
65
     Key-Grip: hexstring
67
66
        This is optional and used to generate a request for an already
68
 
        existsing key.  Key-Length will be ignored when given,
 
67
        existing key.  Key-Length will be ignored when given,
69
68
     Key-Usage: <usage-list>
70
69
        Space or comma delimited list of key usage, allowed values are
71
70
        "encrypt" and "sign".  This is used to generate the KeyUsage extension.
147
146
                            struct reqgen_ctrl_s *outctrl);
148
147
static int create_request (ctrl_t ctrl,
149
148
                           struct para_data_s *para,
 
149
                           const char *carddirect,
150
150
                           ksba_const_sexp_t public,
151
151
                           struct reqgen_ctrl_s *outctrl);
152
152
 
247
247
/* Read the certificate generation parameters from FP and generate
248
248
   (all) certificate requests.  */
249
249
static int
250
 
read_parameters (ctrl_t ctrl, FILE *fp, ksba_writer_t writer)
 
250
read_parameters (ctrl_t ctrl, estream_t fp, ksba_writer_t writer)
251
251
{
252
252
  static struct {
253
253
    const char *name;
275
275
 
276
276
  err = NULL;
277
277
  para = NULL;
278
 
  while (fgets (line, DIM(line)-1, fp) )
 
278
  while (es_fgets (line, DIM(line)-1, fp) )
279
279
    {
280
280
      char *keyword, *value;
281
281
 
391
391
      log_error ("line %d: %s\n", outctrl.lnr, err);
392
392
      rc = gpg_error (GPG_ERR_GENERAL);
393
393
    }
394
 
  else if (ferror(fp))
 
394
  else if (es_ferror(fp))
395
395
    {
396
396
      log_error ("line %d: read error: %s\n", outctrl.lnr, strerror(errno) );
397
397
      rc = gpg_error (GPG_ERR_GENERAL);
440
440
proc_parameters (ctrl_t ctrl,
441
441
                 struct para_data_s *para, struct reqgen_ctrl_s *outctrl)
442
442
{
 
443
  gpg_error_t err;
443
444
  struct para_data_s *r;
444
445
  const char *s;
445
446
  int i;
449
450
  int rc;
450
451
  ksba_sexp_t public;
451
452
  int seq;
452
 
  
453
 
  /* check that we have all required parameters */
 
453
  size_t erroff, errlen;
 
454
  char *cardkeyid = NULL;
 
455
 
 
456
  /* Check that we have all required parameters; */
454
457
  assert (get_parameter (para, pKEYTYPE, 0));
455
458
 
456
 
  /* We can only use RSA for now.  There is a with pkcs-10 on how to
457
 
     use ElGamal because it is expected that a PK algorithm can always
458
 
     be used for signing. */
 
459
  /* We can only use RSA for now.  There is a problem with pkcs-10 on
 
460
     how to use ElGamal because it is expected that a PK algorithm can
 
461
     always be used for signing. Another problem is that on-card
 
462
     generated encryption keys may not be used for signing.  */
459
463
  i = get_parameter_algo (para, pKEYTYPE);
460
 
  if (i < 1 || i != GCRY_PK_RSA )
 
464
  if (!i && (s = get_parameter_value (para, pKEYTYPE, 0)) && *s)
 
465
    {
 
466
      /* Hack to allow creation of certificates directly from a smart
 
467
         card.  For example: "Key-Type: card:OPENPGP.3".  */
 
468
      if (!strncmp (s, "card:", 5) && s[5])
 
469
        cardkeyid = xtrystrdup (s+5);
 
470
    }
 
471
  if ( (i < 1 || i != GCRY_PK_RSA) && !cardkeyid )
461
472
    {
462
473
      r = get_parameter (para, pKEYTYPE, 0);
463
474
      log_error (_("line %d: invalid algorithm\n"), r->lnr);
464
475
      return gpg_error (GPG_ERR_INV_PARAMETER);
465
476
    }
466
477
  
467
 
  /* check the keylength */
 
478
  /* Check the keylength. */
468
479
  if (!get_parameter (para, pKEYLENGTH, 0))
469
480
    nbits = 1024;
470
481
  else
471
482
    nbits = get_parameter_uint (para, pKEYLENGTH);
472
 
  if (nbits < 1024 || nbits > 4096)
 
483
  if ((nbits < 1024 || nbits > 4096) && !cardkeyid)
473
484
    {
474
485
      /* The BSI specs dated 2002-11-25 don't allow lengths below 1024. */
475
486
      r = get_parameter (para, pKEYLENGTH, 0);
476
487
      log_error (_("line %d: invalid key length %u (valid are %d to %d)\n"),
477
488
                 r->lnr, nbits, 1024, 4096);
 
489
      xfree (cardkeyid);
478
490
      return gpg_error (GPG_ERR_INV_PARAMETER);
479
491
    }
480
492
    
481
 
  /* check the usage */
 
493
  /* Check the usage. */
482
494
  if (parse_parameter_usage (para, pKEYUSAGE))
483
 
    return gpg_error (GPG_ERR_INV_PARAMETER);
 
495
    {
 
496
      xfree (cardkeyid);
 
497
      return gpg_error (GPG_ERR_INV_PARAMETER);
 
498
    }
484
499
 
485
 
  /* check that there is a subject name and that this DN fits our
486
 
     requirements */
 
500
  /* Check that there is a subject name and that this DN fits our
 
501
     requirements. */
487
502
  if (!(s=get_parameter_value (para, pNAMEDN, 0)))
488
503
    {
489
 
      r = get_parameter (para, pKEYTYPE, 0);
 
504
      r = get_parameter (para, pNAMEDN, 0);
490
505
      log_error (_("line %d: no subject name given\n"), r->lnr);
491
 
      return gpg_error (GPG_ERR_INV_PARAMETER);
492
 
    }
493
 
  /* fixme check s */
494
 
 
495
 
  /* check that the optional email address is okay */
 
506
      xfree (cardkeyid);
 
507
      return gpg_error (GPG_ERR_INV_PARAMETER);
 
508
    }
 
509
  err = ksba_dn_teststr (s, 0, &erroff, &errlen);
 
510
  if (err)
 
511
    {
 
512
      r = get_parameter (para, pNAMEDN, 0);
 
513
      if (gpg_err_code (err) == GPG_ERR_UNKNOWN_NAME)
 
514
        log_error (_("line %d: invalid subject name label `%.*s'\n"),
 
515
                   r->lnr, (int)errlen, s+erroff);
 
516
      else
 
517
        log_error (_("line %d: invalid subject name `%s' at pos %d\n"),
 
518
                   r->lnr, s, (int)erroff);
 
519
 
 
520
      xfree (cardkeyid);
 
521
      return gpg_error (GPG_ERR_INV_PARAMETER);
 
522
    }
 
523
 
 
524
  /* Check that the optional email address is okay. */
496
525
  for (seq=0; (s=get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
497
526
    { 
498
527
      if (has_invalid_email_chars (s)
503
532
        {
504
533
          r = get_parameter (para, pNAMEEMAIL, seq);
505
534
          log_error (_("line %d: not a valid email address\n"), r->lnr);
 
535
          xfree (cardkeyid);
506
536
          return gpg_error (GPG_ERR_INV_PARAMETER);
507
537
        }
508
538
    }
509
539
 
510
 
  s = get_parameter_value (para, pKEYGRIP, 0);
511
 
  if (s) /* Use existing key.  */
512
 
    {
513
 
      rc = gpgsm_agent_readkey (ctrl, s, &public);
 
540
  if (cardkeyid) /* Take the key from the current smart card. */
 
541
    {
 
542
      rc = gpgsm_agent_readkey (ctrl, 1, cardkeyid, &public);
 
543
      if (rc)
 
544
        {
 
545
          r = get_parameter (para, pKEYTYPE, 0);
 
546
          log_error (_("line %d: error reading key `%s' from card: %s\n"),
 
547
                     r->lnr, cardkeyid, gpg_strerror (rc));
 
548
          xfree (cardkeyid);
 
549
          return rc;
 
550
        }
 
551
    }
 
552
  else if ((s=get_parameter_value (para, pKEYGRIP, 0))) /* Use existing key.*/
 
553
    {
 
554
      rc = gpgsm_agent_readkey (ctrl, 0, s, &public);
514
555
      if (rc)
515
556
        {
516
557
          r = get_parameter (para, pKEYTYPE, 0);
517
558
          log_error (_("line %d: error getting key by keygrip `%s': %s\n"),
518
559
                     r->lnr, s, gpg_strerror (rc));
 
560
          xfree (cardkeyid);
519
561
          return rc;
520
562
        }
521
563
    }
529
571
      if (rc)
530
572
        {
531
573
          r = get_parameter (para, pKEYTYPE, 0);
532
 
          log_error (_("line %d: key generation failed: %s\n"),
533
 
                     r->lnr, gpg_strerror (rc));
 
574
          log_error (_("line %d: key generation failed: %s <%s>\n"),
 
575
                     r->lnr, gpg_strerror (rc), gpg_strsource (rc));
 
576
          xfree (cardkeyid);
534
577
          return rc;
535
578
        }
536
579
    }
537
580
 
538
 
  rc = create_request (ctrl, para, public, outctrl);
 
581
  rc = create_request (ctrl, para, cardkeyid, public, outctrl);
539
582
  xfree (public);
 
583
  xfree (cardkeyid);
540
584
 
541
585
  return rc;
542
586
}
545
589
/* Parameters are checked, the key pair has been created.  Now
546
590
   generate the request and write it out */
547
591
static int
548
 
create_request (ctrl_t ctrl,
549
 
                struct para_data_s *para, ksba_const_sexp_t public,
 
592
create_request (ctrl_t ctrl, 
 
593
                struct para_data_s *para, 
 
594
                const char *carddirect,
 
595
                ksba_const_sexp_t public,
550
596
                struct reqgen_ctrl_s *outctrl)
551
597
{
552
598
  ksba_certreq_t cr;
591
637
      buf = xtrymalloc (strlen (s) + 3);
592
638
      if (!buf)
593
639
        {
594
 
          rc = OUT_OF_CORE (errno);
 
640
          rc = out_of_core ();
595
641
          goto leave;
596
642
        }
597
643
      *buf = '<';
616
662
      buf = p = xtrymalloc (11 + strlen (numbuf) + len + 3);
617
663
      if (!buf)
618
664
        {
619
 
          rc = OUT_OF_CORE (errno);
 
665
          rc = out_of_core ();
620
666
          goto leave;
621
667
        }
622
668
      p = stpcpy (p, "(8:dns-name");
643
689
      buf = p = xtrymalloc (6 + strlen (numbuf) + len + 3);
644
690
      if (!buf)
645
691
        {
646
 
          rc = OUT_OF_CORE (errno);
 
692
          rc = out_of_core ();
647
693
          goto leave;
648
694
        }
649
695
      p = stpcpy (p, "(3:uri");
740
786
              goto leave;
741
787
            }
742
788
          gcry_sexp_release (s_pkey);
743
 
          for (n=0; n < 20; n++)
744
 
            sprintf (hexgrip+n*2, "%02X", grip[n]);
 
789
          bin2hex (grip, 20, hexgrip);
745
790
 
746
 
          rc = gpgsm_agent_pksign (ctrl, hexgrip, NULL,
747
 
                                   gcry_md_read(md, GCRY_MD_SHA1), 
748
 
                                   gcry_md_get_algo_dlen (GCRY_MD_SHA1),
749
 
                                   GCRY_MD_SHA1,
750
 
                                   &sigval, &siglen);
 
791
          if (carddirect)
 
792
            rc = gpgsm_scd_pksign (ctrl, carddirect, NULL,
 
793
                                     gcry_md_read(md, GCRY_MD_SHA1), 
 
794
                                     gcry_md_get_algo_dlen (GCRY_MD_SHA1),
 
795
                                     GCRY_MD_SHA1,
 
796
                                     &sigval, &siglen);
 
797
          else
 
798
            rc = gpgsm_agent_pksign (ctrl, hexgrip, NULL,
 
799
                                     gcry_md_read(md, GCRY_MD_SHA1), 
 
800
                                     gcry_md_get_algo_dlen (GCRY_MD_SHA1),
 
801
                                     GCRY_MD_SHA1,
 
802
                                     &sigval, &siglen);
751
803
          if (rc)
752
804
            {
753
805
              log_error ("signing failed: %s\n", gpg_strerror (rc));
776
828
 
777
829
 
778
830
 
779
 
/* Create a new key by reading the parameters from in_fd.  Multiple
 
831
/* Create a new key by reading the parameters from IN_FP.  Multiple
780
832
   keys may be created */
781
833
int
782
 
gpgsm_genkey (ctrl_t ctrl, int in_fd, FILE *out_fp)
 
834
gpgsm_genkey (ctrl_t ctrl, estream_t in_stream, FILE *out_fp)
783
835
{
784
836
  int rc;
785
 
  FILE *in_fp;
786
837
  Base64Context b64writer = NULL;
787
838
  ksba_writer_t writer;
788
839
 
789
 
  in_fp = fdopen (dup (in_fd), "rb");
790
 
  if (!in_fp)
791
 
    {
792
 
      gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
793
 
      log_error ("fdopen() failed: %s\n", strerror (errno));
794
 
      return tmperr;
795
 
    }
796
 
 
797
840
  ctrl->pem_name = "CERTIFICATE REQUEST";
798
 
  rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
 
841
  rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, NULL, &writer);
799
842
  if (rc)
800
843
    {
801
844
      log_error ("can't create writer: %s\n", gpg_strerror (rc));
802
845
      goto leave;
803
846
    }
804
847
 
805
 
  rc = read_parameters (ctrl, in_fp, writer);
 
848
  rc = read_parameters (ctrl, in_stream, writer);
806
849
  if (rc)
807
850
    {
808
 
      log_error ("error creating certificate request: %s\n",
809
 
                 gpg_strerror (rc));
 
851
      log_error ("error creating certificate request: %s <%s>\n",
 
852
                 gpg_strerror (rc), gpg_strsource (rc));
810
853
      goto leave;
811
854
    }
812
855
 
822
865
 
823
866
 leave:
824
867
  gpgsm_destroy_writer (b64writer);
825
 
  fclose (in_fp);
826
868
  return rc;
827
869
}
828
870