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