1 /* certlist.c - build list of certificates
2 * Copyright (C) 2001, 2003, 2004, 2005, 2007,
3 * 2008, 2011 Free Software Foundation, Inc.
5 * This file is part of GnuPG.
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.
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.
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/>.
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";
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
51 cert_usage_p (ksba_cert_t cert, int mode)
56 int have_ocsp_signing = 0;
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 */
63 unsigned int extusemask = ~0; /* Allow all. */
73 while (p && (pend=strchr (p, ':')))
76 /* Only care about critical flagged usages. */
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);
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;
106 if ((p = strchr (pend, '\n')))
109 xfree (extkeyusages);
113 extusemask = ~0; /* Reset to the don't care mask. */
117 err = ksba_cert_get_key_usage (cert, &use);
118 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
121 if (opt.verbose && mode < 2)
122 log_info (_("no key usage specified - assuming all usages\n"));
126 /* Apply extKeyUsage. */
132 log_error (_("error getting key usage information: %s\n"),
134 xfree (extkeyusages);
140 if ((use & (KSBA_KEYUSAGE_KEY_CERT_SIGN)))
142 log_info (_("certificate should not have "
143 "been used for certification\n"));
144 return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
150 && (have_ocsp_signing
151 || (use & (KSBA_KEYUSAGE_KEY_CERT_SIGN
152 |KSBA_KEYUSAGE_CRL_SIGN))))
154 log_info (_("certificate should not have "
155 "been used for OCSP response signing\n"));
156 return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
159 if ((use & ((mode&1)?
160 (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT):
161 (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
165 log_info (mode==3? _("certificate should not have been used for encryption\n"):
166 mode==2? _("certificate should not have 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);
173 /* Return 0 if the cert is usable for signing */
175 gpgsm_cert_use_sign_p (ksba_cert_t cert)
177 return cert_usage_p (cert, 0);
181 /* Return 0 if the cert is usable for encryption */
183 gpgsm_cert_use_encrypt_p (ksba_cert_t cert)
185 return cert_usage_p (cert, 1);
189 gpgsm_cert_use_verify_p (ksba_cert_t cert)
191 return cert_usage_p (cert, 2);
195 gpgsm_cert_use_decrypt_p (ksba_cert_t cert)
197 return cert_usage_p (cert, 3);
201 gpgsm_cert_use_cert_p (ksba_cert_t cert)
203 return cert_usage_p (cert, 4);
207 gpgsm_cert_use_ocsp_p (ksba_cert_t cert)
209 return cert_usage_p (cert, 5);
213 /* Return true if CERT has the well known private key extension. */
215 gpgsm_cert_has_well_known_private_key (ksba_cert_t cert)
220 for (idx=0; !ksba_cert_get_extension (cert, idx,
221 &oid, NULL, NULL, NULL);idx++)
222 if (!strcmp (oid, "1.3.6.1.4.1.11591.2.2.2") )
229 same_subject_issuer (const char *subject, const char *issuer, ksba_cert_t cert)
231 char *subject2 = ksba_cert_get_subject (cert, 0);
232 char *issuer2 = ksba_cert_get_issuer (cert, 0);
235 tmp = (subject && subject2
236 && !strcmp (subject, subject2)
238 && !strcmp (issuer, issuer2));
245 /* Return true if CERT_A is the same as CERT_B. */
247 gpgsm_certs_identical_p (ksba_cert_t cert_a, ksba_cert_t cert_b)
249 const unsigned char *img_a, *img_b;
252 img_a = ksba_cert_get_image (cert_a, &len_a);
255 img_b = ksba_cert_get_image (cert_b, &len_b);
256 if (img_b && len_a == len_b && !memcmp (img_a, img_b, len_a))
257 return 1; /* Identical. */
263 /* Return true if CERT is already contained in CERTLIST. */
265 is_cert_in_certlist (ksba_cert_t cert, certlist_t certlist)
267 const unsigned char *img_a, *img_b;
270 img_a = ksba_cert_get_image (cert, &len_a);
273 for ( ; certlist; certlist = certlist->next)
275 img_b = ksba_cert_get_image (certlist->cert, &len_b);
276 if (img_b && len_a == len_b && !memcmp (img_a, img_b, len_a))
277 return 1; /* Already contained. */
284 /* Add CERT to the list of certificates at CERTADDR but avoid
287 gpgsm_add_cert_to_certlist (ctrl_t ctrl, ksba_cert_t cert,
288 certlist_t *listaddr, int is_encrypt_to)
292 if (!is_cert_in_certlist (cert, *listaddr))
294 certlist_t cl = xtrycalloc (1, sizeof *cl);
296 return out_of_core ();
298 ksba_cert_ref (cert);
299 cl->next = *listaddr;
300 cl->is_encrypt_to = is_encrypt_to;
306 /* Add a certificate to a list of certificate and make sure that it is
307 a valid certificate. With SECRET set to true a secret key must be
308 available for the certificate. IS_ENCRYPT_TO sets the corresponding
309 flag in the new create LISTADDR item. */
311 gpgsm_add_to_certlist (ctrl_t ctrl, const char *name, int secret,
312 certlist_t *listaddr, int is_encrypt_to)
315 KEYDB_SEARCH_DESC desc;
316 KEYDB_HANDLE kh = NULL;
317 ksba_cert_t cert = NULL;
319 rc = classify_user_id (name, &desc, 0);
324 rc = gpg_error (GPG_ERR_ENOMEM);
328 char *first_subject = NULL;
329 char *first_issuer = NULL;
332 rc = keydb_search (ctrl, kh, &desc, 1);
334 rc = keydb_get_cert (kh, &cert);
339 /* Save the the subject and the issuer for key usage
340 and ambiguous name tests. */
341 first_subject = ksba_cert_get_subject (cert, 0);
342 first_issuer = ksba_cert_get_issuer (cert, 0);
344 rc = secret? gpgsm_cert_use_sign_p (cert)
345 : gpgsm_cert_use_encrypt_p (cert);
346 if (gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE)
348 /* There might be another certificate with the
349 correct usage, so we try again */
351 { /* save the first match */
353 ksba_cert_release (cert);
357 else if (same_subject_issuer (first_subject, first_issuer,
361 ksba_cert_release (cert);
370 /* We want the error code from the first match in this case. */
371 if (rc && wrong_usage)
376 certlist_t dup_certs = NULL;
379 rc = keydb_search (ctrl, kh, &desc, 1);
384 ksba_cert_t cert2 = NULL;
386 /* If this is the first possible duplicate, add the original
387 certificate to our list of duplicates. */
389 gpgsm_add_cert_to_certlist (ctrl, cert, &dup_certs, 0);
391 /* We have to ignore ambigious names as long as
392 there only fault is a bad key usage. This is
393 required to support encryption and signing
394 certificates of the same subject.
396 Further we ignore them if they are due to an
397 identical certificate (which may happen if a
398 certificate is accidential duplicated in the
400 if (!keydb_get_cert (kh, &cert2))
402 int tmp = (same_subject_issuer (first_subject,
406 secret? gpgsm_cert_use_sign_p (cert2)
407 : gpgsm_cert_use_encrypt_p (cert2)
409 ) == GPG_ERR_WRONG_KEY_USAGE));
411 gpgsm_add_cert_to_certlist (ctrl, cert2,
415 if (is_cert_in_certlist (cert2, dup_certs))
419 ksba_cert_release (cert2);
423 rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
425 gpgsm_release_certlist (dup_certs);
427 xfree (first_subject);
428 xfree (first_issuer);
429 first_subject = NULL;
432 if (!rc && !is_cert_in_certlist (cert, *listaddr))
438 rc = gpg_error (GPG_ERR_NO_SECKEY);
439 p = gpgsm_get_keygrip_hexstring (cert);
442 if (!gpgsm_agent_havekey (ctrl, p))
448 rc = gpgsm_validate_chain (ctrl, cert, "", NULL,
452 certlist_t cl = xtrycalloc (1, sizeof *cl);
457 cl->cert = cert; cert = NULL;
458 cl->next = *listaddr;
459 cl->is_encrypt_to = is_encrypt_to;
468 ksba_cert_release (cert);
469 return rc == -1? gpg_error (GPG_ERR_NO_PUBKEY): rc;
474 gpgsm_release_certlist (certlist_t list)
478 certlist_t cl = list->next;
479 ksba_cert_release (list->cert);
486 /* Like gpgsm_add_to_certlist, but look only for one certificate. No
487 chain validation is done. If KEYID is not NULL it is taken as an
488 additional filter value which must match the
489 subjectKeyIdentifier. */
491 gpgsm_find_cert (ctrl_t ctrl,
492 const char *name, ksba_sexp_t keyid, ksba_cert_t *r_cert)
495 KEYDB_SEARCH_DESC desc;
496 KEYDB_HANDLE kh = NULL;
499 rc = classify_user_id (name, &desc, 0);
504 rc = gpg_error (GPG_ERR_ENOMEM);
508 rc = keydb_search (ctrl, kh, &desc, 1);
511 rc = keydb_get_cert (kh, r_cert);
516 rc = ksba_cert_get_subj_key_id (*r_cert, NULL, &subj);
519 if (cmp_simple_canon_sexp (keyid, subj))
525 /* Okay: Here we know that the certificate's
526 subjectKeyIdentifier matches the requested
529 else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
534 /* If we don't have the KEYID filter we need to check for
535 ambigious search results. Note, that it is somehwat
536 reasonable to assume that a specification of a KEYID
537 won't lead to ambiguous names. */
541 rc = keydb_search (ctrl, kh, &desc, 1);
548 ksba_cert_t cert2 = NULL;
550 if (!keydb_get_cert (kh, &cert2))
552 if (gpgsm_certs_identical_p (*r_cert, cert2))
554 ksba_cert_release (cert2);
557 ksba_cert_release (cert2);
559 rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
561 ksba_cert_release (*r_cert);
569 return rc == -1? gpg_error (GPG_ERR_NO_PUBKEY): rc;