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