sm/certlist.c

   1 /* certlist.c - build list of certificates
   2  *      Copyright (C) 2001, 2003 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   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
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  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
  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 /* Return 0 if the cert is usable for encryption.  A MODE of 0 checks
  38    for signing a MODE of 1 checks for encryption, a MODE of 2 checks
  39    for verification and a MODE of 3 for decryption (just for
  40    debugging) */
  41 static int
  42 cert_usage_p (ksba_cert_t cert, int mode)
  43 {
  44   gpg_error_t err;
  45   unsigned int use;
  46
  47   err = ksba_cert_get_key_usage (cert, &use);
  48   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
  49     {
  50       if (opt.verbose && mode < 2)
  51         log_info (mode?
  52                   _("no key usage specified - accepted for encryption\n"):
  53                   _("no key usage specified - accepted for signing\n"));
  54       return 0;
  55     }
  56   if (err)
  57     {
  58       log_error (_("error getting key usage information: %s\n"),
  59                  gpg_strerror (err));
  60       return err;
  61     }
  62
  63   if (mode == 4)
  64     {
  65       if ((use & (KSBA_KEYUSAGE_KEY_CERT_SIGN)))
  66         return 0;
  67       log_info ( _("certificate should have not been used certification\n"));
  68       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
  69     }
  70
  71   if ((use & ((mode&1)?
  72               (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT):
  73               (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
  74       )
  75     return 0;
  76   log_info (mode==3? _("certificate should have not been used for encryption\n"):
  77             mode==2? _("certificate should have not been used for signing\n"):
  78             mode==1? _("certificate is not usable for encryption\n"):
  79                      _("certificate is not usable for signing\n"));
  80   return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
  81 }
  82
  83
  84 /* Return 0 if the cert is usable for signing */
  85 int
  86 gpgsm_cert_use_sign_p (ksba_cert_t cert)
  87 {
  88   return cert_usage_p (cert, 0);
  89 }
  90
  91
  92 /* Return 0 if the cert is usable for encryption */
  93 int
  94 gpgsm_cert_use_encrypt_p (ksba_cert_t cert)
  95 {
  96   return cert_usage_p (cert, 1);
  97 }
  98
  99 int
 100 gpgsm_cert_use_verify_p (ksba_cert_t cert)
 101 {
 102   return cert_usage_p (cert, 2);
 103 }
 104
 105 int
 106 gpgsm_cert_use_decrypt_p (ksba_cert_t cert)
 107 {
 108   return cert_usage_p (cert, 3);
 109 }
 110
 111 int
 112 gpgsm_cert_use_cert_p (ksba_cert_t cert)
 113 {
 114   return cert_usage_p (cert, 4);
 115 }
 116
 117
 118 static int
 119 same_subject_issuer (const char *subject, const char *issuer, ksba_cert_t cert)
 120 {
 121   char *subject2 = ksba_cert_get_subject (cert, 0);
 122   char *issuer2 = ksba_cert_get_subject (cert, 0);
 123   int tmp;
 124
 125   tmp = (subject && subject2
 126          && !strcmp (subject, subject2)
 127          && issuer && issuer2
 128          && !strcmp (issuer, issuer2));
 129   xfree (subject2);
 130   xfree (issuer2);
 131   return tmp;
 132 }
 133
 134 /* Return true if CERT is already contained in CERTLIST. */
 135 static int
 136 is_cert_in_certlist (ksba_cert_t cert, certlist_t certlist)
 137 {
 138   const unsigned char *img_a, *img_b;
 139   size_t len_a, len_b;
 140
 141   img_a = ksba_cert_get_image (cert, &len_a);
 142   if (img_a)
 143     {
 144       for ( ; certlist; certlist = certlist->next)
 145         {
 146           img_b = ksba_cert_get_image (certlist->cert, &len_b);
 147           if (img_b && len_a == len_b && !memcmp (img_a, img_b, len_a))
 148             return 1; /* Already contained. */
 149         }
 150     }
 151   return 0;
 152 }
 153
 154
 155 /* Add CERT to the list of certificates at CERTADDR but avoid
 156    duplicates. */
 157 int
 158 gpgsm_add_cert_to_certlist (ctrl_t ctrl, ksba_cert_t cert,
 159                             certlist_t *listaddr, int is_encrypt_to)
 160 {
 161   if (!is_cert_in_certlist (cert, *listaddr))
 162     {
 163       certlist_t cl = xtrycalloc (1, sizeof *cl);
 164       if (!cl)
 165         return OUT_OF_CORE (errno);
 166       cl->cert = cert;
 167       ksba_cert_ref (cert);
 168       cl->next = *listaddr;
 169       cl->is_encrypt_to = is_encrypt_to;
 170       *listaddr = cl;
 171     }
 172    return 0;
 173 }
 174
 175 /* Add a certificate to a list of certificate and make sure that it is
 176    a valid certificate.  With SECRET set to true a secret key must be
 177    available for the certificate. IS_ENCRYPT_TO sets the corresponding
 178    flag in the new create LISTADDR item.  */
 179 int
 180 gpgsm_add_to_certlist (CTRL ctrl, const char *name, int secret,
 181                        CERTLIST *listaddr, int is_encrypt_to)
 182 {
 183   int rc;
 184   KEYDB_SEARCH_DESC desc;
 185   KEYDB_HANDLE kh = NULL;
 186   ksba_cert_t cert = NULL;
 187
 188   rc = keydb_classify_name (name, &desc);
 189   if (!rc)
 190     {
 191       kh = keydb_new (0);
 192       if (!kh)
 193         rc = gpg_error (GPG_ERR_ENOMEM);
 194       else
 195         {
 196           int wrong_usage = 0;
 197           char *subject = NULL;
 198           char *issuer = NULL;
 199
 200         get_next:
 201           rc = keydb_search (kh, &desc, 1);
 202           if (!rc)
 203             rc = keydb_get_cert (kh, &cert);
 204           if (!rc)
 205             {
 206               rc = secret? gpgsm_cert_use_sign_p (cert)
 207                          : gpgsm_cert_use_encrypt_p (cert);
 208               if (gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE)
 209                 {
 210                   /* There might be another certificate with the
 211                      correct usage, so we try again */
 212                   if (!wrong_usage)
 213                     { /* save the first match */
 214                       wrong_usage = rc;
 215                       subject = ksba_cert_get_subject (cert, 0);
 216                       issuer = ksba_cert_get_subject (cert, 0);
 217                       ksba_cert_release (cert);
 218                       cert = NULL;
 219                       goto get_next;
 220                     }
 221                   else if (same_subject_issuer (subject, issuer, cert))
 222                     {
 223                       wrong_usage = rc;
 224                       ksba_cert_release (cert);
 225                       cert = NULL;
 226                       goto get_next;
 227                     }
 228                   else
 229                     wrong_usage = rc;
 230
 231                 }
 232             }
 233           /* We want the error code from the first match in this case. */
 234           if (rc && wrong_usage)
 235             rc = wrong_usage;
 236
 237           if (!rc)
 238             {
 239             next_ambigious:
 240               rc = keydb_search (kh, &desc, 1);
 241               if (rc == -1)
 242                 rc = 0;
 243               else if (!rc)
 244                 {
 245                   ksba_cert_t cert2 = NULL;
 246
 247                   /* We have to ignore ambigious names as long as
 248                      there only fault is a bad key usage */
 249                   if (!keydb_get_cert (kh, &cert2))
 250                     {
 251                       int tmp = (same_subject_issuer (subject, issuer, cert2)
 252                                  && ((gpg_err_code (
 253                                       secret? gpgsm_cert_use_sign_p (cert2)
 254                                             : gpgsm_cert_use_encrypt_p (cert2)
 255                                       )
 256                                      )  == GPG_ERR_WRONG_KEY_USAGE));
 257                       ksba_cert_release (cert2);
 258                       if (tmp)
 259                         goto next_ambigious;
 260                     }
 261                   rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
 262                 }
 263             }
 264           xfree (subject);
 265           xfree (issuer);
 266
 267           if (!rc && !is_cert_in_certlist (cert, *listaddr))
 268             {
 269               if (!rc && secret)
 270                 {
 271                   char *p;
 272
 273                   rc = gpg_error (GPG_ERR_NO_SECKEY);
 274                   p = gpgsm_get_keygrip_hexstring (cert);
 275                   if (p)
 276                     {
 277                       if (!gpgsm_agent_havekey (p))
 278                         rc = 0;
 279                       xfree (p);
 280                     }
 281                 }
 282               if (!rc)
 283                 rc = gpgsm_validate_chain (ctrl, cert, NULL);
 284               if (!rc)
 285                 {
 286                   CERTLIST cl = xtrycalloc (1, sizeof *cl);
 287                   if (!cl)
 288                     rc = OUT_OF_CORE (errno);
 289                   else
 290                     {
 291                       cl->cert = cert; cert = NULL;
 292                       cl->next = *listaddr;
 293                       cl->is_encrypt_to = is_encrypt_to;
 294                       *listaddr = cl;
 295                     }
 296                 }
 297             }
 298         }
 299     }
 300
 301   keydb_release (kh);
 302   ksba_cert_release (cert);
 303   return rc == -1? gpg_error (GPG_ERR_NO_PUBKEY): rc;
 304 }
 305
 306 void
 307 gpgsm_release_certlist (CERTLIST list)
 308 {
 309   while (list)
 310     {
 311       CERTLIST cl = list->next;
 312       ksba_cert_release (list->cert);
 313       xfree (list);
 314       list = cl;
 315     }
 316 }
 317
 318 \f
 319 /* Like gpgsm_add_to_certlist, but look only for one certificate.  No
 320    chain validation is done */
 321 int
 322 gpgsm_find_cert (const char *name, ksba_cert_t *r_cert)
 323 {
 324   int rc;
 325   KEYDB_SEARCH_DESC desc;
 326   KEYDB_HANDLE kh = NULL;
 327
 328   *r_cert = NULL;
 329   rc = keydb_classify_name (name, &desc);
 330   if (!rc)
 331     {
 332       kh = keydb_new (0);
 333       if (!kh)
 334         rc = gpg_error (GPG_ERR_ENOMEM);
 335       else
 336         {
 337           rc = keydb_search (kh, &desc, 1);
 338           if (!rc)
 339             rc = keydb_get_cert (kh, r_cert);
 340           if (!rc)
 341             {
 342               rc = keydb_search (kh, &desc, 1);
 343               if (rc == -1)
 344                 rc = 0;
 345               else
 346                 {
 347                   if (!rc)
 348                     rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
 349                   ksba_cert_release (*r_cert);
 350                   *r_cert = NULL;
 351                 }
 352             }
 353         }
 354     }
 355
 356   keydb_release (kh);
 357   return rc == -1? gpg_error (GPG_ERR_NO_PUBKEY): rc;
 358 }
 359