sm/certlist.c

   1 /* certlist.c - build list of certificates
   2  * Copyright (C) 2001, 2003, 2004, 2005, 2007,
   3  *               2008 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 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <unistd.h>
  27 #include <time.h>
  28 #include <assert.h>
  29
  30 #include "gpgsm.h"
  31 #include <gcrypt.h>
  32 #include <ksba.h>
  33
  34 #include "keydb.h"
  35 #include "i18n.h"
  36
  37
  38 static const char oid_kp_serverAuth[]     = "1.3.6.1.5.5.7.3.1";
  39 static const char oid_kp_clientAuth[]     = "1.3.6.1.5.5.7.3.2";
  40 static const char oid_kp_codeSigning[]    = "1.3.6.1.5.5.7.3.3";
  41 static const char oid_kp_emailProtection[]= "1.3.6.1.5.5.7.3.4";
  42 static const char oid_kp_timeStamping[]   = "1.3.6.1.5.5.7.3.8";
  43 static const char oid_kp_ocspSigning[]    = "1.3.6.1.5.5.7.3.9";
  44
  45 /* Return 0 if the cert is usable for encryption.  A MODE of 0 checks
  46    for signing a MODE of 1 checks for encryption, a MODE of 2 checks
  47    for verification and a MODE of 3 for decryption (just for
  48    debugging).  MODE 4 is for certificate signing, MODE for COSP
  49    response signing. */
  50 static int
  51 cert_usage_p (ksba_cert_t cert, int mode)
  52 {
  53   gpg_error_t err;
  54   unsigned int use;
  55   char *extkeyusages;
  56   int have_ocsp_signing = 0;
  57
  58   err = ksba_cert_get_ext_key_usages (cert, &extkeyusages);
  59   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
  60     err = 0; /* no policy given */
  61   if (!err)
  62     {
  63       unsigned int extusemask = ~0; /* Allow all. */
  64
  65       if (extkeyusages)
  66         {
  67           char *p, *pend;
  68           int any_critical = 0;
  69
  70           extusemask = 0;
  71
  72           p = extkeyusages;
  73           while (p && (pend=strchr (p, ':')))
  74             {
  75               *pend++ = 0;
  76               /* Only care about critical flagged usages. */
  77               if ( *pend == 'C' )
  78                 {
  79                   any_critical = 1;
  80                   if ( !strcmp (p, oid_kp_serverAuth))
  81                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
  82                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
  83                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
  84                   else if ( !strcmp (p, oid_kp_clientAuth))
  85                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
  86                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
  87                   else if ( !strcmp (p, oid_kp_codeSigning))
  88                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE);
  89                   else if ( !strcmp (p, oid_kp_emailProtection))
  90                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
  91                                    | KSBA_KEYUSAGE_NON_REPUDIATION
  92                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
  93                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
  94                   else if ( !strcmp (p, oid_kp_timeStamping))
  95                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
  96                                    | KSBA_KEYUSAGE_NON_REPUDIATION);
  97                 }
  98
  99               /* This is a hack to cope with OCSP.  Note that we do
 100                  not yet fully comply with the requirements and that
 101                  the entire CRL/OCSP checking thing should undergo a
 102                  thorough review and probably redesign. */
 103               if ( !strcmp (p, oid_kp_ocspSigning))
 104                 have_ocsp_signing = 1;
 105
 106               if ((p = strchr (pend, '\n')))
 107                 p++;
 108             }
 109           xfree (extkeyusages);
 110           extkeyusages = NULL;
 111
 112           if (!any_critical)
 113             extusemask = ~0; /* Reset to the don't care mask. */
 114         }
 115
 116
 117       err = ksba_cert_get_key_usage (cert, &use);
 118       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
 119         {
 120           err = 0;
 121           if (opt.verbose && mode < 2)
 122             log_info (_("no key usage specified - assuming all usages\n"));
 123           use = ~0;
 124         }
 125
 126       /* Apply extKeyUsage. */
 127       use &= extusemask;
 128
 129     }
 130   if (err)
 131     {
 132       log_error (_("error getting key usage information: %s\n"),
 133                  gpg_strerror (err));
 134       xfree (extkeyusages);
 135       return err;
 136     }
 137
 138   if (mode == 4)
 139     {
 140       if ((use & (KSBA_KEYUSAGE_KEY_CERT_SIGN)))
 141         return 0;
 142       log_info (_("certificate should have not "
 143                   "been used for certification\n"));
 144       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
 145     }
 146
 147   if (mode == 5)
 148     {
 149       if (use != ~0
 150           && (have_ocsp_signing
 151               || (use & (KSBA_KEYUSAGE_KEY_CERT_SIGN
 152                          |KSBA_KEYUSAGE_CRL_SIGN))))
 153         return 0;
 154       log_info (_("certificate should have not "
 155                   "been used for OCSP response signing\n"));
 156       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
 157     }
 158
 159   if ((use & ((mode&1)?
 160               (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT):
 161               (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
 162       )
 163     return 0;
 164
 165   log_info (mode==3? _("certificate should have not been used for encryption\n"):
 166             mode==2? _("certificate should have not been used for signing\n"):
 167             mode==1? _("certificate is not usable for encryption\n"):
 168                      _("certificate is not usable for signing\n"));
 169   return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
 170 }
 171
 172
 173 /* Return 0 if the cert is usable for signing */
 174 int
 175 gpgsm_cert_use_sign_p (ksba_cert_t cert)
 176 {
 177   return cert_usage_p (cert, 0);
 178 }
 179
 180
 181 /* Return 0 if the cert is usable for encryption */
 182 int
 183 gpgsm_cert_use_encrypt_p (ksba_cert_t cert)
 184 {
 185   return cert_usage_p (cert, 1);
 186 }
 187
 188 int
 189 gpgsm_cert_use_verify_p (ksba_cert_t cert)
 190 {
 191   return cert_usage_p (cert, 2);
 192 }
 193
 194 int
 195 gpgsm_cert_use_decrypt_p (ksba_cert_t cert)
 196 {
 197   return cert_usage_p (cert, 3);
 198 }
 199
 200 int
 201 gpgsm_cert_use_cert_p (ksba_cert_t cert)
 202 {
 203   return cert_usage_p (cert, 4);
 204 }
 205
 206 int
 207 gpgsm_cert_use_ocsp_p (ksba_cert_t cert)
 208 {
 209   return cert_usage_p (cert, 5);
 210 }
 211
 212
 213 static int
 214 same_subject_issuer (const char *subject, const char *issuer, ksba_cert_t cert)
 215 {
 216   char *subject2 = ksba_cert_get_subject (cert, 0);
 217   char *issuer2 = ksba_cert_get_issuer (cert, 0);
 218   int tmp;
 219
 220   tmp = (subject && subject2
 221          && !strcmp (subject, subject2)
 222          && issuer && issuer2
 223          && !strcmp (issuer, issuer2));
 224   xfree (subject2);
 225   xfree (issuer2);
 226   return tmp;
 227 }
 228
 229
 230 /* Return true if CERT_A is the same as CERT_B.  */
 231 int
 232 gpgsm_certs_identical_p (ksba_cert_t cert_a, ksba_cert_t cert_b)
 233 {
 234   const unsigned char *img_a, *img_b;
 235   size_t len_a, len_b;
 236
 237   img_a = ksba_cert_get_image (cert_a, &len_a);
 238   if (img_a)
 239     {
 240       img_b = ksba_cert_get_image (cert_b, &len_b);
 241       if (img_b && len_a == len_b && !memcmp (img_a, img_b, len_a))
 242         return 1; /* Identical. */
 243     }
 244   return 0;
 245 }
 246
 247
 248 /* Return true if CERT is already contained in CERTLIST. */
 249 static int
 250 is_cert_in_certlist (ksba_cert_t cert, certlist_t certlist)
 251 {
 252   const unsigned char *img_a, *img_b;
 253   size_t len_a, len_b;
 254
 255   img_a = ksba_cert_get_image (cert, &len_a);
 256   if (img_a)
 257     {
 258       for ( ; certlist; certlist = certlist->next)
 259         {
 260           img_b = ksba_cert_get_image (certlist->cert, &len_b);
 261           if (img_b && len_a == len_b && !memcmp (img_a, img_b, len_a))
 262             return 1; /* Already contained. */
 263         }
 264     }
 265   return 0;
 266 }
 267
 268
 269 /* Add CERT to the list of certificates at CERTADDR but avoid
 270    duplicates. */
 271 int
 272 gpgsm_add_cert_to_certlist (ctrl_t ctrl, ksba_cert_t cert,
 273                             certlist_t *listaddr, int is_encrypt_to)
 274 {
 275   (void)ctrl;
 276
 277   if (!is_cert_in_certlist (cert, *listaddr))
 278     {
 279       certlist_t cl = xtrycalloc (1, sizeof *cl);
 280       if (!cl)
 281         return out_of_core ();
 282       cl->cert = cert;
 283       ksba_cert_ref (cert);
 284       cl->next = *listaddr;
 285       cl->is_encrypt_to = is_encrypt_to;
 286       *listaddr = cl;
 287     }
 288    return 0;
 289 }
 290
 291 /* Add a certificate to a list of certificate and make sure that it is
 292    a valid certificate.  With SECRET set to true a secret key must be
 293    available for the certificate. IS_ENCRYPT_TO sets the corresponding
 294    flag in the new create LISTADDR item.  */
 295 int
 296 gpgsm_add_to_certlist (ctrl_t ctrl, const char *name, int secret,
 297                        certlist_t *listaddr, int is_encrypt_to)
 298 {
 299   int rc;
 300   KEYDB_SEARCH_DESC desc;
 301   KEYDB_HANDLE kh = NULL;
 302   ksba_cert_t cert = NULL;
 303
 304   rc = keydb_classify_name (name, &desc);
 305   if (!rc)
 306     {
 307       kh = keydb_new (0);
 308       if (!kh)
 309         rc = gpg_error (GPG_ERR_ENOMEM);
 310       else
 311         {
 312           int wrong_usage = 0;
 313           char *first_subject = NULL;
 314           char *first_issuer = NULL;
 315
 316         get_next:
 317           rc = keydb_search (kh, &desc, 1);
 318           if (!rc)
 319             rc = keydb_get_cert (kh, &cert);
 320           if (!rc)
 321             {
 322               if (!first_subject)
 323                 {
 324                   /* Save the the subject and the issuer for key usage
 325                      and ambiguous name tests. */
 326                   first_subject = ksba_cert_get_subject (cert, 0);
 327                   first_issuer = ksba_cert_get_issuer (cert, 0);
 328                 }
 329               rc = secret? gpgsm_cert_use_sign_p (cert)
 330                          : gpgsm_cert_use_encrypt_p (cert);
 331               if (gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE)
 332                 {
 333                   /* There might be another certificate with the
 334                      correct usage, so we try again */
 335                   if (!wrong_usage)
 336                     { /* save the first match */
 337                       wrong_usage = rc;
 338                       ksba_cert_release (cert);
 339                       cert = NULL;
 340                       goto get_next;
 341                     }
 342                   else if (same_subject_issuer (first_subject, first_issuer,
 343                                                 cert))
 344                     {
 345                       wrong_usage = rc;
 346                       ksba_cert_release (cert);
 347                       cert = NULL;
 348                       goto get_next;
 349                     }
 350                   else
 351                     wrong_usage = rc;
 352
 353                 }
 354             }
 355           /* We want the error code from the first match in this case. */
 356           if (rc && wrong_usage)
 357             rc = wrong_usage;
 358
 359           if (!rc)
 360             {
 361               certlist_t dup_certs = NULL;
 362
 363             next_ambigious:
 364               rc = keydb_search (kh, &desc, 1);
 365               if (rc == -1)
 366                 rc = 0;
 367               else if (!rc)
 368                 {
 369                   ksba_cert_t cert2 = NULL;
 370
 371                   /* If this is the first possible duplicate, add the original
 372                      certificate to our list of duplicates.  */
 373                   if (!dup_certs)
 374                     gpgsm_add_cert_to_certlist (ctrl, cert, &dup_certs, 0);
 375
 376                   /* We have to ignore ambigious names as long as
 377                      there only fault is a bad key usage.  This is
 378                      required to support encryption and signing
 379                      certificates of the same subject.
 380
 381                      Further we ignore them if they are due to an
 382                      identical certificate (which may happen if a
 383                      certificate is accidential duplicated in the
 384                      keybox).  */
 385                   if (!keydb_get_cert (kh, &cert2))
 386                     {
 387                       int tmp = (same_subject_issuer (first_subject,
 388                                                       first_issuer,
 389                                                       cert2)
 390                                  && ((gpg_err_code (
 391                                       secret? gpgsm_cert_use_sign_p (cert2)
 392                                       : gpgsm_cert_use_encrypt_p (cert2)
 393                                       )
 394                                      )  == GPG_ERR_WRONG_KEY_USAGE));
 395                       if (tmp)
 396                         gpgsm_add_cert_to_certlist (ctrl, cert2,
 397                                                     &dup_certs, 0);
 398                       else
 399                         {
 400                           if (is_cert_in_certlist (cert2, dup_certs))
 401                             tmp = 1;
 402                         }
 403
 404                       ksba_cert_release (cert2);
 405                       if (tmp)
 406                         goto next_ambigious;
 407                     }
 408                   rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
 409                 }
 410               gpgsm_release_certlist (dup_certs);
 411             }
 412           xfree (first_subject);
 413           xfree (first_issuer);
 414           first_subject = NULL;
 415           first_issuer = NULL;
 416
 417           if (!rc && !is_cert_in_certlist (cert, *listaddr))
 418             {
 419               if (!rc && secret)
 420                 {
 421                   char *p;
 422
 423                   rc = gpg_error (GPG_ERR_NO_SECKEY);
 424                   p = gpgsm_get_keygrip_hexstring (cert);
 425                   if (p)
 426                     {
 427                       if (!gpgsm_agent_havekey (ctrl, p))
 428                         rc = 0;
 429                       xfree (p);
 430                     }
 431                 }
 432               if (!rc)
 433                 rc = gpgsm_validate_chain (ctrl, cert, "", NULL,
 434                                            0, NULL, 0, NULL);
 435               if (!rc)
 436                 {
 437                   certlist_t cl = xtrycalloc (1, sizeof *cl);
 438                   if (!cl)
 439                     rc = out_of_core ();
 440                   else
 441                     {
 442                       cl->cert = cert; cert = NULL;
 443                       cl->next = *listaddr;
 444                       cl->is_encrypt_to = is_encrypt_to;
 445                       *listaddr = cl;
 446                     }
 447                 }
 448             }
 449         }
 450     }
 451
 452   keydb_release (kh);
 453   ksba_cert_release (cert);
 454   return rc == -1? gpg_error (GPG_ERR_NO_PUBKEY): rc;
 455 }
 456
 457
 458 void
 459 gpgsm_release_certlist (certlist_t list)
 460 {
 461   while (list)
 462     {
 463       certlist_t cl = list->next;
 464       ksba_cert_release (list->cert);
 465       xfree (list);
 466       list = cl;
 467     }
 468 }
 469
 470 \f
 471 /* Like gpgsm_add_to_certlist, but look only for one certificate.  No
 472    chain validation is done.  If KEYID is not NULL it is taken as an
 473    additional filter value which must match the
 474    subjectKeyIdentifier. */
 475 int
 476 gpgsm_find_cert (const char *name, ksba_sexp_t keyid, ksba_cert_t *r_cert)
 477 {
 478   int rc;
 479   KEYDB_SEARCH_DESC desc;
 480   KEYDB_HANDLE kh = NULL;
 481
 482   *r_cert = NULL;
 483   rc = keydb_classify_name (name, &desc);
 484   if (!rc)
 485     {
 486       kh = keydb_new (0);
 487       if (!kh)
 488         rc = gpg_error (GPG_ERR_ENOMEM);
 489       else
 490         {
 491         nextone:
 492           rc = keydb_search (kh, &desc, 1);
 493           if (!rc)
 494             {
 495               rc = keydb_get_cert (kh, r_cert);
 496               if (!rc && keyid)
 497                 {
 498                   ksba_sexp_t subj;
 499
 500                   rc = ksba_cert_get_subj_key_id (*r_cert, NULL, &subj);
 501                   if (!rc)
 502                     {
 503                       if (cmp_simple_canon_sexp (keyid, subj))
 504                         {
 505                           xfree (subj);
 506                           goto nextone;
 507                         }
 508                       xfree (subj);
 509                       /* Okay: Here we know that the certificate's
 510                          subjectKeyIdentifier matches the requested
 511                          one. */
 512                     }
 513                   else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
 514                     goto nextone;
 515                 }
 516             }
 517
 518           /* If we don't have the KEYID filter we need to check for
 519              ambigious search results.  Note, that it is somehwat
 520              reasonable to assume that a specification of a KEYID
 521              won't lead to ambiguous names. */
 522           if (!rc && !keyid)
 523             {
 524             next_ambiguous:
 525               rc = keydb_search (kh, &desc, 1);
 526               if (rc == -1)
 527                 rc = 0;
 528               else
 529                 {
 530                   if (!rc)
 531                     {
 532                       ksba_cert_t cert2 = NULL;
 533
 534                       if (!keydb_get_cert (kh, &cert2))
 535                         {
 536                           if (gpgsm_certs_identical_p (*r_cert, cert2))
 537                             {
 538                               ksba_cert_release (cert2);
 539                               goto next_ambiguous;
 540                             }
 541                           ksba_cert_release (cert2);
 542                         }
 543                       rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
 544                     }
 545                   ksba_cert_release (*r_cert);
 546                   *r_cert = NULL;
 547                 }
 548             }
 549         }
 550     }
 551
 552   keydb_release (kh);
 553   return rc == -1? gpg_error (GPG_ERR_NO_PUBKEY): rc;
 554 }
 555