* gpgsm.c (main): New option --debug-ignore-expiration.
[gnupg.git] / sm / certlist.c
1 /* certlist.c - build list of certificates
2  *      Copyright (C) 2001, 2003, 2004 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
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
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) */
48 static int
49 cert_usage_p (ksba_cert_t cert, int mode)
50 {
51   gpg_error_t err;
52   unsigned int use;
53   char *extkeyusages;
54
55   err = ksba_cert_get_ext_key_usages (cert, &extkeyusages);
56   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
57     err = 0; /* no policy given */
58   if (!err)
59     {
60       unsigned int extusemask = ~0; /* Allow all. */
61
62       if (extkeyusages)
63         {
64           char *p, *pend;
65           int any_critical = 0;
66
67           extusemask = 0;
68
69           p = extkeyusages;
70           while (p && (pend=strchr (p, ':')))
71             {
72               *pend++ = 0;
73               /* Only care about critical flagged usages. */
74               if ( *pend == 'C' )
75                 {
76                   any_critical = 1;
77                   if ( !strcmp (p, oid_kp_serverAuth))
78                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
79                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
80                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
81                   else if ( !strcmp (p, oid_kp_clientAuth))
82                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
83                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
84                   else if ( !strcmp (p, oid_kp_codeSigning))
85                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE);
86                   else if ( !strcmp (p, oid_kp_emailProtection))
87                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
88                                    | KSBA_KEYUSAGE_NON_REPUDIATION
89                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
90                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
91                   else if ( !strcmp (p, oid_kp_timeStamping))
92                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
93                                    | KSBA_KEYUSAGE_NON_REPUDIATION);
94                 }
95               
96               if ((p = strchr (pend, '\n')))
97                 p++;
98             }
99           xfree (extkeyusages);
100           extkeyusages = NULL;
101           
102           if (!any_critical)
103             extusemask = ~0; /* Reset to the don't care mask. */
104         }
105
106
107       err = ksba_cert_get_key_usage (cert, &use);
108       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
109         {
110           err = 0;
111           if (opt.verbose && mode < 2)
112             log_info (_("no key usage specified - assuming all usages\n"));
113           use = ~0;
114         }
115
116       /* Apply extKeyUsage. */
117       use &= extusemask;
118
119     }
120   if (err)
121     { 
122       log_error (_("error getting key usage information: %s\n"),
123                  gpg_strerror (err));
124       xfree (extkeyusages);
125       return err;
126     } 
127
128   if (mode == 4)
129     {
130       if ((use & (KSBA_KEYUSAGE_KEY_CERT_SIGN)))
131         return 0;
132       log_info ( _("certificate should have not been used certification\n"));
133       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
134     }
135
136   if ((use & ((mode&1)?
137               (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT):
138               (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
139       )
140     return 0;
141
142   log_info (mode==3? _("certificate should have not been used for encryption\n"):
143             mode==2? _("certificate should have not been used for signing\n"):
144             mode==1? _("certificate is not usable for encryption\n"):
145                      _("certificate is not usable for signing\n"));
146   return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
147 }
148
149
150 /* Return 0 if the cert is usable for signing */
151 int
152 gpgsm_cert_use_sign_p (ksba_cert_t cert)
153 {
154   return cert_usage_p (cert, 0);
155 }
156
157
158 /* Return 0 if the cert is usable for encryption */
159 int
160 gpgsm_cert_use_encrypt_p (ksba_cert_t cert)
161 {
162   return cert_usage_p (cert, 1);
163 }
164
165 int
166 gpgsm_cert_use_verify_p (ksba_cert_t cert)
167 {
168   return cert_usage_p (cert, 2);
169 }
170
171 int
172 gpgsm_cert_use_decrypt_p (ksba_cert_t cert)
173 {
174   return cert_usage_p (cert, 3);
175 }
176
177 int
178 gpgsm_cert_use_cert_p (ksba_cert_t cert)
179 {
180   return cert_usage_p (cert, 4);
181 }
182
183
184 static int
185 same_subject_issuer (const char *subject, const char *issuer, ksba_cert_t cert)
186 {
187   char *subject2 = ksba_cert_get_subject (cert, 0);
188   char *issuer2 = ksba_cert_get_subject (cert, 0);
189   int tmp;
190   
191   tmp = (subject && subject2
192          && !strcmp (subject, subject2)
193          && issuer && issuer2
194          && !strcmp (issuer, issuer2));
195   xfree (subject2);
196   xfree (issuer2);
197   return tmp;
198 }
199
200 /* Return true if CERT is already contained in CERTLIST. */
201 static int
202 is_cert_in_certlist (ksba_cert_t cert, certlist_t certlist)
203 {
204   const unsigned char *img_a, *img_b;
205   size_t len_a, len_b;
206
207   img_a = ksba_cert_get_image (cert, &len_a);
208   if (img_a)
209     {
210       for ( ; certlist; certlist = certlist->next)
211         {
212           img_b = ksba_cert_get_image (certlist->cert, &len_b);
213           if (img_b && len_a == len_b && !memcmp (img_a, img_b, len_a))
214             return 1; /* Already contained. */
215         }
216     }
217   return 0;
218 }
219
220
221 /* Add CERT to the list of certificates at CERTADDR but avoid
222    duplicates. */
223 int 
224 gpgsm_add_cert_to_certlist (ctrl_t ctrl, ksba_cert_t cert,
225                             certlist_t *listaddr, int is_encrypt_to)
226 {
227   if (!is_cert_in_certlist (cert, *listaddr))
228     {
229       certlist_t cl = xtrycalloc (1, sizeof *cl);
230       if (!cl)
231         return OUT_OF_CORE (errno);
232       cl->cert = cert;
233       ksba_cert_ref (cert);
234       cl->next = *listaddr;
235       cl->is_encrypt_to = is_encrypt_to;
236       *listaddr = cl;
237     }
238    return 0;
239 }
240
241 /* Add a certificate to a list of certificate and make sure that it is
242    a valid certificate.  With SECRET set to true a secret key must be
243    available for the certificate. IS_ENCRYPT_TO sets the corresponding
244    flag in the new create LISTADDR item.  */
245 int
246 gpgsm_add_to_certlist (CTRL ctrl, const char *name, int secret,
247                        CERTLIST *listaddr, int is_encrypt_to)
248 {
249   int rc;
250   KEYDB_SEARCH_DESC desc;
251   KEYDB_HANDLE kh = NULL;
252   ksba_cert_t cert = NULL;
253
254   rc = keydb_classify_name (name, &desc);
255   if (!rc)
256     {
257       kh = keydb_new (0);
258       if (!kh)
259         rc = gpg_error (GPG_ERR_ENOMEM);
260       else
261         {
262           int wrong_usage = 0;
263           char *subject = NULL;
264           char *issuer = NULL;
265
266         get_next:
267           rc = keydb_search (kh, &desc, 1);
268           if (!rc)
269             rc = keydb_get_cert (kh, &cert);
270           if (!rc)
271             {
272               rc = secret? gpgsm_cert_use_sign_p (cert)
273                          : gpgsm_cert_use_encrypt_p (cert);
274               if (gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE)
275                 {
276                   /* There might be another certificate with the
277                      correct usage, so we try again */
278                   if (!wrong_usage)
279                     { /* save the first match */
280                       wrong_usage = rc;
281                       subject = ksba_cert_get_subject (cert, 0);
282                       issuer = ksba_cert_get_subject (cert, 0);
283                       ksba_cert_release (cert);
284                       cert = NULL;
285                       goto get_next;
286                     }
287                   else if (same_subject_issuer (subject, issuer, cert))
288                     {
289                       wrong_usage = rc;
290                       ksba_cert_release (cert);
291                       cert = NULL;
292                       goto get_next;
293                     }
294                   else
295                     wrong_usage = rc;
296
297                 }
298             }
299           /* We want the error code from the first match in this case. */
300           if (rc && wrong_usage)
301             rc = wrong_usage;
302           
303           if (!rc)
304             {
305             next_ambigious:
306               rc = keydb_search (kh, &desc, 1);
307               if (rc == -1)
308                 rc = 0;
309               else if (!rc)
310                 {
311                   ksba_cert_t cert2 = NULL;
312
313                   /* We have to ignore ambigious names as long as
314                      there only fault is a bad key usage */
315                   if (!keydb_get_cert (kh, &cert2))
316                     {
317                       int tmp = (same_subject_issuer (subject, issuer, cert2)
318                                  && ((gpg_err_code (
319                                       secret? gpgsm_cert_use_sign_p (cert2)
320                                             : gpgsm_cert_use_encrypt_p (cert2)
321                                       )
322                                      )  == GPG_ERR_WRONG_KEY_USAGE));
323                       ksba_cert_release (cert2);
324                       if (tmp)
325                         goto next_ambigious;
326                     }
327                   rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
328                 }
329             }
330           xfree (subject);
331           xfree (issuer);
332
333           if (!rc && !is_cert_in_certlist (cert, *listaddr))
334             {
335               if (!rc && secret) 
336                 {
337                   char *p;
338                   
339                   rc = gpg_error (GPG_ERR_NO_SECKEY);
340                   p = gpgsm_get_keygrip_hexstring (cert);
341                   if (p)
342                     {
343                       if (!gpgsm_agent_havekey (p))
344                         rc = 0;
345                       xfree (p);
346                     }
347                 }
348               if (!rc)
349                 rc = gpgsm_validate_chain (ctrl, cert, NULL, 0, NULL);
350               if (!rc)
351                 {
352                   CERTLIST cl = xtrycalloc (1, sizeof *cl);
353                   if (!cl)
354                     rc = OUT_OF_CORE (errno);
355                   else 
356                     {
357                       cl->cert = cert; cert = NULL;
358                       cl->next = *listaddr;
359                       cl->is_encrypt_to = is_encrypt_to;
360                       *listaddr = cl;
361                     }
362                 }
363             }
364         }
365     }
366   
367   keydb_release (kh);
368   ksba_cert_release (cert);
369   return rc == -1? gpg_error (GPG_ERR_NO_PUBKEY): rc;
370 }
371
372 void
373 gpgsm_release_certlist (CERTLIST list)
374 {
375   while (list)
376     {
377       CERTLIST cl = list->next;
378       ksba_cert_release (list->cert);
379       xfree (list);
380       list = cl;
381     }
382 }
383
384 \f
385 /* Like gpgsm_add_to_certlist, but look only for one certificate.  No
386    chain validation is done */
387 int
388 gpgsm_find_cert (const char *name, ksba_cert_t *r_cert)
389 {
390   int rc;
391   KEYDB_SEARCH_DESC desc;
392   KEYDB_HANDLE kh = NULL;
393
394   *r_cert = NULL;
395   rc = keydb_classify_name (name, &desc);
396   if (!rc)
397     {
398       kh = keydb_new (0);
399       if (!kh)
400         rc = gpg_error (GPG_ERR_ENOMEM);
401       else
402         {
403           rc = keydb_search (kh, &desc, 1);
404           if (!rc)
405             rc = keydb_get_cert (kh, r_cert);
406           if (!rc)
407             {
408               rc = keydb_search (kh, &desc, 1);
409               if (rc == -1)
410                 rc = 0;
411               else 
412                 {
413                   if (!rc)
414                     rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
415                   ksba_cert_release (*r_cert);
416                   *r_cert = NULL;
417                 }
418             }
419         }
420     }
421   
422   keydb_release (kh);
423   return rc == -1? gpg_error (GPG_ERR_NO_PUBKEY): rc;
424 }
425