gcc-4 defaults forced me to edit many many files to get rid of the
[gnupg.git] / sm / keylist.c
1 /* keylist.c - Print certificates in various formats.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
3  *               2004, 2005 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
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 2 of the License, or
10  * (at your option) any later version.
11  *
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.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <unistd.h> 
28 #include <time.h>
29 #include <assert.h>
30
31 #include "gpgsm.h"
32
33 #include <gcrypt.h>
34 #include <ksba.h>
35
36 #include "keydb.h"
37 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
38 #include "i18n.h"
39
40 struct list_external_parm_s {
41   ctrl_t ctrl;
42   FILE *fp;
43   int print_header;
44   int with_colons;
45   int with_chain;
46   int raw_mode;
47 };
48
49
50 /* This table is to map Extended Key Usage OIDs to human readable
51    names.  */
52 struct {
53   const char *oid;
54   const char *name;
55 } key_purpose_map[] = {
56   { "1.3.6.1.5.5.7.3.1",  "serverAuth" },
57   { "1.3.6.1.5.5.7.3.2",  "clientAuth" },          
58   { "1.3.6.1.5.5.7.3.3",  "codeSigning" },      
59   { "1.3.6.1.5.5.7.3.4",  "emailProtection" },     
60   { "1.3.6.1.5.5.7.3.5",  "ipsecEndSystem" }, 
61   { "1.3.6.1.5.5.7.3.6",  "ipsecTunnel" },  
62   { "1.3.6.1.5.5.7.3.7",  "ipsecUser" },     
63   { "1.3.6.1.5.5.7.3.8",  "timeStamping" },       
64   { "1.3.6.1.5.5.7.3.9",  "ocspSigning" },    
65   { "1.3.6.1.5.5.7.3.10", "dvcs" },      
66   { "1.3.6.1.5.5.7.3.11", "sbgpCertAAServerAuth" },
67   { "1.3.6.1.5.5.7.3.13", "eapOverPPP" },
68   { "1.3.6.1.5.5.7.3.14", "wlanSSID" },       
69   { NULL, NULL }
70 };
71
72
73 /* A table mapping OIDs to a descriptive string. */
74 static struct {
75   char *oid;
76   char *name;
77   unsigned int flag;
78 } oidtranstbl[] = {
79
80   /* Algorithms. */
81   { "1.2.840.10040.4.1", "dsa" },
82   { "1.2.840.10040.4.3", "dsaWithSha1" },
83
84   { "1.2.840.113549.1.1.1", "rsaEncryption" },
85   { "1.2.840.113549.1.1.2", "md2WithRSAEncryption" },
86   { "1.2.840.113549.1.1.3", "md4WithRSAEncryption" },
87   { "1.2.840.113549.1.1.4", "md5WithRSAEncryption" },
88   { "1.2.840.113549.1.1.5", "sha1WithRSAEncryption" },
89   { "1.2.840.113549.1.1.7", "rsaOAEP" },
90   { "1.2.840.113549.1.1.8", "rsaOAEP-MGF" },
91   { "1.2.840.113549.1.1.9", "rsaOAEP-pSpecified" },
92   { "1.2.840.113549.1.1.10", "rsaPSS" },
93   { "1.2.840.113549.1.1.11", "sha256WithRSAEncryption" },
94   { "1.2.840.113549.1.1.12", "sha384WithRSAEncryption" },
95   { "1.2.840.113549.1.1.13", "sha512WithRSAEncryption" },
96
97   { "1.3.14.3.2.26", "sha1" },
98   { "1.3.14.3.2.29",  "sha-1WithRSAEncryption" },
99   { "1.3.36.3.3.1.2", "rsaSignatureWithripemd160" },
100
101
102   /* Telesec extensions. */
103   { "0.2.262.1.10.12.0", "certExtensionLiabilityLimitationExt" },
104   { "0.2.262.1.10.12.1", "telesecCertIdExt" },
105   { "0.2.262.1.10.12.2", "telesecPolicyIdentifier" },
106   { "0.2.262.1.10.12.3", "telesecPolicyQualifierID" },
107   { "0.2.262.1.10.12.4", "telesecCRLFilteredExt" },
108   { "0.2.262.1.10.12.5", "telesecCRLFilterExt"},
109   { "0.2.262.1.10.12.6", "telesecNamingAuthorityExt" },
110
111   /* PKIX private extensions. */
112   { "1.3.6.1.5.5.7.1.1", "authorityInfoAccess" },
113   { "1.3.6.1.5.5.7.1.2", "biometricInfo" },
114   { "1.3.6.1.5.5.7.1.3", "qcStatements" },
115   { "1.3.6.1.5.5.7.1.4", "acAuditIdentity" },
116   { "1.3.6.1.5.5.7.1.5", "acTargeting" },
117   { "1.3.6.1.5.5.7.1.6", "acAaControls" },
118   { "1.3.6.1.5.5.7.1.7", "sbgp-ipAddrBlock" },
119   { "1.3.6.1.5.5.7.1.8", "sbgp-autonomousSysNum" },
120   { "1.3.6.1.5.5.7.1.9", "sbgp-routerIdentifier" },
121   { "1.3.6.1.5.5.7.1.10", "acProxying" },
122   { "1.3.6.1.5.5.7.1.11", "subjectInfoAccess" },
123
124   /* X.509 id-ce */
125   { "2.5.29.14", "subjectKeyIdentifier", 1},
126   { "2.5.29.15", "keyUsage", 1 },
127   { "2.5.29.16", "privateKeyUsagePeriod" },
128   { "2.5.29.17", "subjectAltName", 1 },
129   { "2.5.29.18", "issuerAltName", 1 },
130   { "2.5.29.19", "basicConstraints", 1},
131   { "2.5.29.20", "cRLNumber" },
132   { "2.5.29.21", "cRLReason" },
133   { "2.5.29.22", "expirationDate" },
134   { "2.5.29.23", "instructionCode" }, 
135   { "2.5.29.24", "invalidityDate" },
136   { "2.5.29.27", "deltaCRLIndicator" },
137   { "2.5.29.28", "issuingDistributionPoint" },
138   { "2.5.29.29", "certificateIssuer" },
139   { "2.5.29.30", "nameConstraints" },
140   { "2.5.29.31", "cRLDistributionPoints", 1 },
141   { "2.5.29.32", "certificatePolicies", 1 },
142   { "2.5.29.32.0", "anyPolicy" },
143   { "2.5.29.33", "policyMappings" },
144   { "2.5.29.35", "authorityKeyIdentifier", 1 },
145   { "2.5.29.36", "policyConstraints" },
146   { "2.5.29.37", "extKeyUsage", 1 },
147   { "2.5.29.46", "freshestCRL" },
148   { "2.5.29.54", "inhibitAnyPolicy" },
149
150   /* Netscape certificate extensions. */
151   { "2.16.840.1.113730.1.1", "netscape-cert-type" },
152   { "2.16.840.1.113730.1.2", "netscape-base-url" },
153   { "2.16.840.1.113730.1.3", "netscape-revocation-url" },
154   { "2.16.840.1.113730.1.4", "netscape-ca-revocation-url" },
155   { "2.16.840.1.113730.1.7", "netscape-cert-renewal-url" },
156   { "2.16.840.1.113730.1.8", "netscape-ca-policy-url" },
157   { "2.16.840.1.113730.1.9", "netscape-homePage-url" },
158   { "2.16.840.1.113730.1.10", "netscape-entitylogo" },
159   { "2.16.840.1.113730.1.11", "netscape-userPicture" },
160   { "2.16.840.1.113730.1.12", "netscape-ssl-server-name" },
161   { "2.16.840.1.113730.1.13", "netscape-comment" },
162
163   { NULL }
164 };
165
166
167 /* Return the description for OID; if no description is available 
168    NULL is returned. */
169 static const char *
170 get_oid_desc (const char *oid, unsigned int *flag)
171 {
172   int i;
173
174   if (oid)
175     for (i=0; oidtranstbl[i].oid; i++)
176       if (!strcmp (oidtranstbl[i].oid, oid))
177         {
178           if (flag)
179             *flag = oidtranstbl[i].flag;
180           return oidtranstbl[i].name;
181         }
182   if (flag)
183     *flag = 0;
184   return NULL;
185 }
186
187
188 static void
189 print_key_data (ksba_cert_t cert, FILE *fp)
190 {
191 #if 0  
192   int n = pk ? pubkey_get_npkey( pk->pubkey_algo ) : 0;
193   int i;
194
195   for(i=0; i < n; i++ ) 
196     {
197       fprintf (fp, "pkd:%d:%u:", i, mpi_get_nbits( pk->pkey[i] ) );
198       mpi_print(stdout, pk->pkey[i], 1 );
199       putchar(':');
200       putchar('\n');
201     }
202 #endif
203 }
204
205 static void
206 print_capabilities (ksba_cert_t cert, FILE *fp)
207 {
208   gpg_error_t err;
209   unsigned int use;
210
211   err = ksba_cert_get_key_usage (cert, &use);
212   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
213     {
214       putc ('e', fp);
215       putc ('s', fp);
216       putc ('c', fp);
217       putc ('E', fp);
218       putc ('S', fp);
219       putc ('C', fp);
220       return;
221     }
222   if (err)
223     { 
224       log_error (_("error getting key usage information: %s\n"),
225                  gpg_strerror (err));
226       return;
227     } 
228
229   if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
230     putc ('e', fp);
231   if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
232     putc ('s', fp);
233   if ((use & KSBA_KEYUSAGE_KEY_CERT_SIGN))
234     putc ('c', fp);
235   if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
236     putc ('E', fp);
237   if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
238     putc ('S', fp);
239   if ((use & KSBA_KEYUSAGE_KEY_CERT_SIGN))
240     putc ('C', fp);
241 }
242
243
244 static void
245 print_time (gnupg_isotime_t t, FILE *fp)
246 {
247   if (!t || !*t)
248     ;
249   else 
250     fputs (t, fp);
251 }
252
253
254 /* return an allocated string with the email address extracted from a
255    DN */
256 static char *
257 email_kludge (const char *name)
258 {
259   const char *p;
260   unsigned char *buf;
261   int n;
262
263   if (strncmp (name, "1.2.840.113549.1.9.1=#", 22))
264     return NULL;
265   /* This looks pretty much like an email address in the subject's DN
266      we use this to add an additional user ID entry.  This way,
267      openSSL generated keys get a nicer and usable listing */
268   name += 22;    
269   for (n=0, p=name; hexdigitp (p) && hexdigitp (p+1); p +=2, n++)
270     ;
271   if (*p != '#' || !n)
272     return NULL;
273   buf = xtrymalloc (n+3);
274   if (!buf)
275     return NULL; /* oops, out of core */
276   *buf = '<';
277   for (n=1, p=name; *p != '#'; p +=2, n++)
278     buf[n] = xtoi_2 (p);
279   buf[n++] = '>';
280   buf[n] = 0;
281   return (char*)buf;
282 }
283
284
285
286
287 /* List one certificate in colon mode */
288 static void
289 list_cert_colon (ctrl_t ctrl, ksba_cert_t cert, unsigned int validity,
290                  FILE *fp, int have_secret)
291 {
292   int rc;
293   int idx;
294   char truststring[2];
295   char *p;
296   ksba_sexp_t sexp;
297   char *fpr;
298   ksba_isotime_t t;
299   gpg_error_t valerr;
300   int algo;
301   unsigned int nbits;
302   const char *chain_id;
303   char *chain_id_buffer = NULL;
304   int is_root = 0;
305
306   if (ctrl->with_validation)
307     valerr = gpgsm_validate_chain (ctrl, cert, NULL, 1, NULL, 0);
308   else
309     valerr = 0;
310
311
312   /* We need to get the fingerprint and the chaining ID in advance. */
313   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
314   {
315     ksba_cert_t next;
316
317     rc = gpgsm_walk_cert_chain (cert, &next);
318     if (!rc) /* We known the issuer's certificate. */
319       {
320         p = gpgsm_get_fingerprint_hexstring (next, GCRY_MD_SHA1);
321         chain_id_buffer = p;
322         chain_id = chain_id_buffer;
323         ksba_cert_release (next);
324       }
325     else if (rc == -1)  /* We have reached the root certificate. */
326       {
327         chain_id = fpr;
328         is_root = 1;
329       }
330     else
331       chain_id = NULL;
332   }
333
334
335   fputs (have_secret? "crs:":"crt:", fp);
336
337   /* Note: We can't use multiple flags, like "ei", because the
338      validation check does only return one error.  */
339   truststring[0] = 0;
340   truststring[1] = 0;
341   if ((validity & VALIDITY_REVOKED)
342       || gpg_err_code (valerr) == GPG_ERR_CERT_REVOKED)
343     *truststring = 'r';
344   else if (gpg_err_code (valerr) == GPG_ERR_CERT_EXPIRED)
345     *truststring = 'e';
346   else 
347     {
348       /* Lets also check whether the certificate under question
349          expired.  This is merely a hack until we found a proper way
350          to store the expiration flag in the keybox. */
351       ksba_isotime_t current_time, not_after;
352   
353       gnupg_get_isotime (current_time);
354       if (!opt.ignore_expiration
355           && !ksba_cert_get_validity (cert, 1, not_after)
356           && *not_after && strcmp (current_time, not_after) > 0 )
357         *truststring = 'e';
358       else if (valerr)
359         *truststring = 'i';
360     }
361
362   /* Is we have no truststring yet (i.e. the certificate might be
363      good) and this is a root certificate, we ask the agent whether
364      this is a trusted root certificate. */
365   if (!*truststring && is_root)
366     {
367       rc = gpgsm_agent_istrusted (ctrl, cert);
368       if (!rc)
369         *truststring = 'u';  /* Yes, we trust this one (ultimately). */
370       else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
371         *truststring = 'n';  /* No, we do not trust this one. */
372       /* (in case of an error we can't tell anything.) */
373     }
374   
375   if (*truststring)
376     fputs (truststring, fp);
377
378   algo = gpgsm_get_key_algo_info (cert, &nbits);
379   fprintf (fp, ":%u:%d:%s:", nbits, algo, fpr+24);
380
381   /* We assume --fixed-list-mode for gpgsm */
382   ksba_cert_get_validity (cert, 0, t);
383   print_time (t, fp);
384   putc (':', fp);
385   ksba_cert_get_validity (cert, 1, t);
386   print_time ( t, fp);
387   putc (':', fp);
388   /* Field 8, serial number: */
389   if ((sexp = ksba_cert_get_serial (cert)))
390     {
391       int len;
392       const unsigned char *s = sexp;
393       
394       if (*s == '(')
395         {
396           s++;
397           for (len=0; *s && *s != ':' && digitp (s); s++)
398             len = len*10 + atoi_1 (s);
399           if (*s == ':')
400             for (s++; len; len--, s++)
401               fprintf (fp,"%02X", *s);
402         }
403       xfree (sexp);
404     }
405   putc (':', fp);
406   /* Field 9, ownertrust - not used here */
407   putc (':', fp);
408   /* field 10, old user ID - we use it here for the issuer DN */
409   if ((p = ksba_cert_get_issuer (cert,0)))
410     {
411       print_sanitized_string (fp, p, ':');
412       xfree (p);
413     }
414   putc (':', fp);
415   /* Field 11, signature class - not used */ 
416   putc (':', fp);
417   /* Field 12, capabilities: */ 
418   print_capabilities (cert, fp);
419   putc (':', fp);
420   putc ('\n', fp);
421
422   /* FPR record */
423   fprintf (fp, "fpr:::::::::%s:::", fpr);
424   /* Print chaining ID (field 13)*/
425   if (chain_id)
426     fputs (chain_id, fp);
427   putc (':', fp);
428   putc ('\n', fp);
429   xfree (fpr); fpr = NULL; chain_id = NULL;
430   xfree (chain_id_buffer); chain_id_buffer = NULL;
431
432   if (opt.with_key_data)
433     {
434       if ( (p = gpgsm_get_keygrip_hexstring (cert)))
435         {
436           fprintf (fp, "grp:::::::::%s:\n", p);
437           xfree (p);
438         }
439       print_key_data (cert, fp);
440     }
441
442   for (idx=0; (p = ksba_cert_get_subject (cert,idx)); idx++)
443     {
444       fprintf (fp, "uid:%s::::::::", truststring);
445       print_sanitized_string (fp, p, ':');
446       putc (':', fp);
447       putc (':', fp);
448       putc ('\n', fp);
449       if (!idx)
450         {
451           /* It would be better to get the faked email address from
452              the keydb.  But as long as we don't have a way to pass
453              the meta data back, we just check it the same way as the
454              code used to create the keybox meta data does */
455           char *pp = email_kludge (p);
456           if (pp)
457             {
458               fprintf (fp, "uid:%s::::::::", truststring);
459               print_sanitized_string (fp, pp, ':');
460               putc (':', fp);
461               putc (':', fp);
462               putc ('\n', fp);
463               xfree (pp);
464             }
465         }
466       xfree (p);
467     }
468 }
469
470
471 static void
472 print_name_raw (FILE *fp, const char *string)
473 {
474   if (!string)
475     fputs ("[error]", fp);
476   else
477     print_sanitized_string (fp, string, 0);
478 }
479
480 static void
481 print_names_raw (FILE *fp, int indent, ksba_name_t name)
482 {
483   int idx;
484   const char *s;
485   int indent_all;
486
487   if ((indent_all = (indent < 0)))
488     indent = - indent;
489
490   if (!name)
491     {
492       fputs ("none\n", fp);
493       return;
494     }
495   
496   for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
497     {
498       char *p = ksba_name_get_uri (name, idx);
499       printf ("%*s%s\n", idx||indent_all?indent:0, "", p?p:s);
500       xfree (p);
501     }
502 }
503
504
505 /* List one certificate in raw mode useful to have a closer look at
506    the certificate.  This one does no beautification and only minimal
507    output sanitation.  It is mainly useful for debugging. */
508 static void
509 list_cert_raw (ctrl_t ctrl, KEYDB_HANDLE hd,
510                ksba_cert_t cert, FILE *fp, int have_secret,
511                int with_validation)
512 {
513   gpg_error_t err;
514   size_t off, len;
515   ksba_sexp_t sexp, keyid;
516   char *dn;
517   ksba_isotime_t t;
518   int idx, i;
519   int is_ca, chainlen;
520   unsigned int kusage;
521   char *string, *p, *pend;
522   const char *oid, *s;
523   ksba_name_t name, name2;
524   unsigned int reason;
525
526   sexp = ksba_cert_get_serial (cert);
527   fputs ("Serial number: ", fp);
528   gpgsm_print_serial (fp, sexp);
529   ksba_free (sexp);
530   putc ('\n', fp);
531
532   dn = ksba_cert_get_issuer (cert, 0);
533   fputs ("       Issuer: ", fp);
534   print_name_raw (fp, dn);
535   ksba_free (dn);
536   putc ('\n', fp);
537   for (idx=1; (dn = ksba_cert_get_issuer (cert, idx)); idx++)
538     {
539       fputs ("          aka: ", fp);
540       print_name_raw (fp, dn);
541       ksba_free (dn);
542       putc ('\n', fp);
543     }
544
545   dn = ksba_cert_get_subject (cert, 0);
546   fputs ("      Subject: ", fp);
547   print_name_raw (fp, dn);
548   ksba_free (dn);
549   putc ('\n', fp);
550   for (idx=1; (dn = ksba_cert_get_subject (cert, idx)); idx++)
551     {
552       fputs ("          aka: ", fp);
553       print_name_raw (fp, dn);
554       ksba_free (dn);
555       putc ('\n', fp);
556     }
557
558   dn = gpgsm_get_fingerprint_string (cert, 0);
559   fprintf (fp, "     sha1_fpr: %s\n", dn?dn:"error");
560   xfree (dn);
561
562   dn = gpgsm_get_fingerprint_string (cert, GCRY_MD_MD5);
563   fprintf (fp, "      md5_fpr: %s\n", dn?dn:"error");
564   xfree (dn);
565
566   dn = gpgsm_get_keygrip_hexstring (cert);
567   fprintf (fp, "      keygrip: %s\n", dn?dn:"error");
568   xfree (dn);
569
570   ksba_cert_get_validity (cert, 0, t);
571   fputs ("    notBefore: ", fp);
572   gpgsm_print_time (fp, t);
573   putc ('\n', fp);
574   fputs ("     notAfter: ", fp);
575   ksba_cert_get_validity (cert, 1, t);
576   gpgsm_print_time (fp, t);
577   putc ('\n', fp);
578
579   oid = ksba_cert_get_digest_algo (cert);
580   s = get_oid_desc (oid, NULL);
581   fprintf (fp, "     hashAlgo: %s%s%s%s\n", oid, s?" (":"",s?s:"",s?")":"");
582
583   {
584     const char *algoname;
585     unsigned int nbits;
586
587     algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
588     fprintf (fp, "      keyType: %u bit %s\n",  nbits, algoname? algoname:"?");
589   }
590
591   /* subjectKeyIdentifier */
592   fputs ("    subjKeyId: ", fp);
593   err = ksba_cert_get_subj_key_id (cert, NULL, &keyid);
594   if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
595     {
596       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
597         fputs ("[none]\n", fp);
598       else
599         {
600           gpgsm_print_serial (fp, keyid);
601           ksba_free (keyid);
602           putc ('\n', fp);
603         }
604     }
605   else
606     fputs ("[?]\n", fp);
607
608
609   /* authorityKeyIdentifier */
610   fputs ("    authKeyId: ", fp);
611   err = ksba_cert_get_auth_key_id (cert, &keyid, &name, &sexp);
612   if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
613     {
614       if (gpg_err_code (err) == GPG_ERR_NO_DATA || !name)
615         fputs ("[none]\n", fp);
616       else
617         {
618           gpgsm_print_serial (fp, sexp);
619           ksba_free (sexp);
620           putc ('\n', fp);
621           print_names_raw (fp, -15, name);
622           ksba_name_release (name);
623         }
624       if (keyid)
625         {
626           fputs (" authKeyId.ki: ", fp);
627           gpgsm_print_serial (fp, keyid);
628           ksba_free (keyid);
629           putc ('\n', fp);
630         }
631     }
632   else
633     fputs ("[?]\n", fp);
634
635   fputs ("     keyUsage:", fp);
636   err = ksba_cert_get_key_usage (cert, &kusage);
637   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
638     {
639       if (err)
640         fprintf (fp, " [error: %s]", gpg_strerror (err));
641       else
642         {
643           if ( (kusage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
644             fputs (" digitalSignature", fp);
645           if ( (kusage & KSBA_KEYUSAGE_NON_REPUDIATION))  
646             fputs (" nonRepudiation", fp);
647           if ( (kusage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT)) 
648             fputs (" keyEncipherment", fp);
649           if ( (kusage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
650             fputs (" dataEncipherment", fp);
651           if ( (kusage & KSBA_KEYUSAGE_KEY_AGREEMENT))    
652             fputs (" keyAgreement", fp);
653           if ( (kusage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
654             fputs (" certSign", fp);
655           if ( (kusage & KSBA_KEYUSAGE_CRL_SIGN))  
656             fputs (" crlSign", fp);
657           if ( (kusage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
658             fputs (" encipherOnly", fp);
659           if ( (kusage & KSBA_KEYUSAGE_DECIPHER_ONLY))  
660             fputs (" decipherOnly", fp);
661         }
662       putc ('\n', fp);
663     }
664   else
665     fputs ("[none]\n", fp);
666
667   fputs ("  extKeyUsage: ", fp);
668   err = ksba_cert_get_ext_key_usages (cert, &string);
669   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
670     { 
671       if (err)
672         fprintf (fp, "[error: %s]", gpg_strerror (err));
673       else
674         {
675           p = string;
676           while (p && (pend=strchr (p, ':')))
677             {
678               *pend++ = 0;
679               for (i=0; key_purpose_map[i].oid; i++)
680                 if ( !strcmp (key_purpose_map[i].oid, p) )
681                   break;
682               fputs (key_purpose_map[i].oid?key_purpose_map[i].name:p, fp);
683               p = pend;
684               if (*p != 'C')
685                 fputs (" (suggested)", fp);
686               if ((p = strchr (p, '\n')))
687                 {
688                   p++;
689                   fputs ("\n               ", fp);
690                 }
691             }
692           xfree (string);
693         }
694       putc ('\n', fp);
695     }
696   else
697     fputs ("[none]\n", fp);
698
699
700   fputs ("     policies: ", fp);
701   err = ksba_cert_get_cert_policies (cert, &string);
702   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
703     {
704       if (err)
705         fprintf (fp, "[error: %s]", gpg_strerror (err));
706       else
707         {
708           p = string;
709           while (p && (pend=strchr (p, ':')))
710             {
711               *pend++ = 0;
712               for (i=0; key_purpose_map[i].oid; i++)
713                 if ( !strcmp (key_purpose_map[i].oid, p) )
714                   break;
715               fputs (p, fp);
716               p = pend;
717               if (*p == 'C')
718                 fputs (" (critical)", fp);
719               if ((p = strchr (p, '\n')))
720                 {
721                   p++;
722                   fputs ("\n               ", fp);
723                 }
724             }
725           xfree (string);
726         }
727       putc ('\n', fp);
728     }
729   else
730     fputs ("[none]\n", fp);
731
732   fputs ("  chainLength: ", fp);
733   err = ksba_cert_is_ca (cert, &is_ca, &chainlen);
734   if (err || is_ca)
735     {
736       if (err)
737         fprintf (fp, "[error: %s]", gpg_strerror (err));
738       else if (chainlen == -1)
739         fputs ("unlimited", fp);
740       else
741         fprintf (fp, "%d", chainlen);
742       putc ('\n', fp);
743     }
744   else
745     fputs ("not a CA\n", fp);
746
747
748   /* CRL distribution point */
749   for (idx=0; !(err=ksba_cert_get_crl_dist_point (cert, idx, &name, &name2,
750                                                   &reason)) ;idx++)
751     {
752       fputs ("        crlDP: ", fp);
753       print_names_raw (fp, 15, name);
754       if (reason)
755         {
756           fputs ("               reason: ", fp);
757           if ( (reason & KSBA_CRLREASON_UNSPECIFIED))
758             fputs (" unused", stdout);
759           if ( (reason & KSBA_CRLREASON_KEY_COMPROMISE))
760             fputs (" keyCompromise", stdout);
761           if ( (reason & KSBA_CRLREASON_CA_COMPROMISE))
762             fputs (" caCompromise", stdout);
763           if ( (reason & KSBA_CRLREASON_AFFILIATION_CHANGED))
764             fputs (" affiliationChanged", stdout);
765           if ( (reason & KSBA_CRLREASON_SUPERSEDED))
766             fputs (" superseded", stdout);
767           if ( (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION))
768             fputs (" cessationOfOperation", stdout);
769           if ( (reason & KSBA_CRLREASON_CERTIFICATE_HOLD))
770             fputs (" certificateHold", stdout);
771           putchar ('\n');
772         }
773       fputs ("               issuer: ", fp);
774       print_names_raw (fp, 23, name2);
775       ksba_name_release (name);
776       ksba_name_release (name2);
777     }
778   if (err && gpg_err_code (err) != GPG_ERR_EOF)
779     fputs ("        crlDP: [error]\n", fp);
780   else if (!idx)
781     fputs ("        crlDP: [none]\n", fp);
782
783
784   /* authorityInfoAccess. */
785   for (idx=0; !(err=ksba_cert_get_authority_info_access (cert, idx, &string,
786                                                          &name)); idx++)
787     {
788       fputs ("     authInfo: ", fp);
789       s = get_oid_desc (string, NULL);
790       fprintf (fp, "%s%s%s%s\n", string, s?" (":"", s?s:"", s?")":"");
791       print_names_raw (fp, -15, name);
792       ksba_name_release (name);
793       ksba_free (string);
794     }
795   if (err && gpg_err_code (err) != GPG_ERR_EOF)
796     fputs ("     authInfo: [error]\n", fp);
797   else if (!idx)
798     fputs ("     authInfo: [none]\n", fp);
799
800   /* subjectInfoAccess. */
801   for (idx=0; !(err=ksba_cert_get_subject_info_access (cert, idx, &string,
802                                                          &name)); idx++)
803     {
804       fputs ("  subjectInfo: ", fp);
805       s = get_oid_desc (string, NULL);
806       fprintf (fp, "%s%s%s%s\n", string, s?" (":"", s?s:"", s?")":"");
807       print_names_raw (fp, -15, name);
808       ksba_name_release (name);
809       ksba_free (string);
810     }
811   if (err && gpg_err_code (err) != GPG_ERR_EOF)
812     fputs ("     subjInfo: [error]\n", fp);
813   else if (!idx)
814     fputs ("     subjInfo: [none]\n", fp);
815
816
817   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
818                                              &oid, &i, &off, &len));idx++)
819     {
820       unsigned int flag;
821
822       s = get_oid_desc (oid, &flag);
823
824       if (!(flag & 1))
825         fprintf (fp, "     %s: %s%s%s%s  [%d octets]\n",
826                  i? "critExtn":"    extn",
827                  oid, s?" (":"", s?s:"", s?")":"", (int)len);
828     }
829
830
831   if (with_validation)
832     {
833       err = gpgsm_validate_chain (ctrl, cert, NULL, 1, fp, 0);
834       if (!err)
835         fprintf (fp, "  [certificate is good]\n");
836       else
837         fprintf (fp, "  [certificate is bad: %s]\n", gpg_strerror (err));
838     }
839
840   if (opt.with_ephemeral_keys && hd)
841     {
842       unsigned int blobflags;
843
844       err = keydb_get_flags (hd, KEYBOX_FLAG_BLOB, 0, &blobflags);
845       if (err)
846         fprintf (fp, "  [error getting keyflags: %s]\n", gpg_strerror (err));
847       else if ((blobflags & 2))
848         fprintf (fp, "  [stored as ephemeral]\n");
849     }
850
851 }
852
853
854
855
856 /* List one certificate in standard mode */
857 static void
858 list_cert_std (ctrl_t ctrl, ksba_cert_t cert, FILE *fp, int have_secret,
859                int with_validation)
860 {
861   gpg_error_t err;
862   ksba_sexp_t sexp;
863   char *dn;
864   ksba_isotime_t t;
865   int idx, i;
866   int is_ca, chainlen;
867   unsigned int kusage;
868   char *string, *p, *pend;
869
870   sexp = ksba_cert_get_serial (cert);
871   fputs ("Serial number: ", fp);
872   gpgsm_print_serial (fp, sexp);
873   ksba_free (sexp);
874   putc ('\n', fp);
875
876   dn = ksba_cert_get_issuer (cert, 0);
877   fputs ("       Issuer: ", fp);
878   gpgsm_print_name (fp, dn);
879   ksba_free (dn);
880   putc ('\n', fp);
881   for (idx=1; (dn = ksba_cert_get_issuer (cert, idx)); idx++)
882     {
883       fputs ("          aka: ", fp);
884       gpgsm_print_name (fp, dn);
885       ksba_free (dn);
886       putc ('\n', fp);
887     }
888
889   dn = ksba_cert_get_subject (cert, 0);
890   fputs ("      Subject: ", fp);
891   gpgsm_print_name (fp, dn);
892   ksba_free (dn);
893   putc ('\n', fp);
894   for (idx=1; (dn = ksba_cert_get_subject (cert, idx)); idx++)
895     {
896       fputs ("          aka: ", fp);
897       gpgsm_print_name (fp, dn);
898       ksba_free (dn);
899       putc ('\n', fp);
900     }
901
902   ksba_cert_get_validity (cert, 0, t);
903   fputs ("     validity: ", fp);
904   gpgsm_print_time (fp, t);
905   fputs (" through ", fp);
906   ksba_cert_get_validity (cert, 1, t);
907   gpgsm_print_time (fp, t);
908   putc ('\n', fp);
909
910
911   {
912     const char *algoname;
913     unsigned int nbits;
914
915     algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
916     fprintf (fp, "     key type: %u bit %s\n", nbits, algoname? algoname:"?");
917   }
918
919
920   err = ksba_cert_get_key_usage (cert, &kusage);
921   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
922     {
923       fputs ("    key usage:", fp);
924       if (err)
925         fprintf (fp, " [error: %s]", gpg_strerror (err));
926       else
927         {
928           if ( (kusage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
929             fputs (" digitalSignature", fp);
930           if ( (kusage & KSBA_KEYUSAGE_NON_REPUDIATION))  
931             fputs (" nonRepudiation", fp);
932           if ( (kusage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT)) 
933             fputs (" keyEncipherment", fp);
934           if ( (kusage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
935             fputs (" dataEncipherment", fp);
936           if ( (kusage & KSBA_KEYUSAGE_KEY_AGREEMENT))    
937             fputs (" keyAgreement", fp);
938           if ( (kusage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
939             fputs (" certSign", fp);
940           if ( (kusage & KSBA_KEYUSAGE_CRL_SIGN))  
941             fputs (" crlSign", fp);
942           if ( (kusage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
943             fputs (" encipherOnly", fp);
944           if ( (kusage & KSBA_KEYUSAGE_DECIPHER_ONLY))  
945             fputs (" decipherOnly", fp);
946         }
947       putc ('\n', fp);
948     }
949
950   err = ksba_cert_get_ext_key_usages (cert, &string);
951   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
952     { 
953       fputs ("ext key usage: ", fp);
954       if (err)
955         fprintf (fp, "[error: %s]", gpg_strerror (err));
956       else
957         {
958           p = string;
959           while (p && (pend=strchr (p, ':')))
960             {
961               *pend++ = 0;
962               for (i=0; key_purpose_map[i].oid; i++)
963                 if ( !strcmp (key_purpose_map[i].oid, p) )
964                   break;
965               fputs (key_purpose_map[i].oid?key_purpose_map[i].name:p, fp);
966               p = pend;
967               if (*p != 'C')
968                 fputs (" (suggested)", fp);
969               if ((p = strchr (p, '\n')))
970                 {
971                   p++;
972                   fputs (", ", fp);
973                 }
974             }
975           xfree (string);
976         }
977       putc ('\n', fp);
978     }
979
980   err = ksba_cert_get_cert_policies (cert, &string);
981   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
982     {
983       fputs ("     policies: ", fp);
984       if (err)
985         fprintf (fp, "[error: %s]", gpg_strerror (err));
986       else
987         {
988           for (p=string; *p; p++)
989             {
990               if (*p == '\n')
991                 *p = ',';
992             }
993           print_sanitized_string (fp, string, 0);
994           xfree (string);
995         }
996       putc ('\n', fp);
997     }
998
999   err = ksba_cert_is_ca (cert, &is_ca, &chainlen);
1000   if (err || is_ca)
1001     {
1002       fputs (" chain length: ", fp);
1003       if (err)
1004         fprintf (fp, "[error: %s]", gpg_strerror (err));
1005       else if (chainlen == -1)
1006         fputs ("unlimited", fp);
1007       else
1008         fprintf (fp, "%d", chainlen);
1009       putc ('\n', fp);
1010     }
1011
1012   if (opt.with_md5_fingerprint)
1013     {
1014       dn = gpgsm_get_fingerprint_string (cert, GCRY_MD_MD5);
1015       fprintf (fp, "      md5 fpr: %s\n", dn?dn:"error");
1016       xfree (dn);
1017     }
1018
1019   dn = gpgsm_get_fingerprint_string (cert, 0);
1020   fprintf (fp, "  fingerprint: %s\n", dn?dn:"error");
1021   xfree (dn);
1022
1023   if (with_validation)
1024     {
1025       err = gpgsm_validate_chain (ctrl, cert, NULL, 1, fp, 0);
1026       if (!err)
1027         fprintf (fp, "  [certificate is good]\n");
1028       else
1029         fprintf (fp, "  [certificate is bad: %s]\n", gpg_strerror (err));
1030     }
1031 }
1032
1033
1034 /* Same as standard mode mode list all certifying certs too. */
1035 static void
1036 list_cert_chain (ctrl_t ctrl, KEYDB_HANDLE hd,
1037                  ksba_cert_t cert, int raw_mode,
1038                  FILE *fp, int with_validation)
1039 {
1040   ksba_cert_t next = NULL;
1041
1042   if (raw_mode)
1043     list_cert_raw (ctrl, hd, cert, fp, 0, with_validation);
1044   else
1045     list_cert_std (ctrl, cert, fp, 0, with_validation);
1046   ksba_cert_ref (cert);
1047   while (!gpgsm_walk_cert_chain (cert, &next))
1048     {
1049       ksba_cert_release (cert);
1050       fputs ("Certified by\n", fp);
1051       if (raw_mode)
1052         list_cert_raw (ctrl, hd, next, fp, 0, with_validation);
1053       else
1054         list_cert_std (ctrl, next, fp, 0, with_validation);
1055       cert = next;
1056     }
1057   ksba_cert_release (cert);
1058   putc ('\n', fp);
1059 }
1060
1061
1062 \f
1063 /* List all internal keys or just the keys given as NAMES.  MODE is a
1064    bit vector to specify what keys are to be included; see
1065    gpgsm_list_keys (below) for details.  If RAW_MODE is true, the raw
1066    output mode will be used intead of the standard beautified one.
1067  */
1068 static gpg_error_t
1069 list_internal_keys (ctrl_t ctrl, STRLIST names, FILE *fp,
1070                     unsigned int mode, int raw_mode)
1071 {
1072   KEYDB_HANDLE hd;
1073   KEYDB_SEARCH_DESC *desc = NULL;
1074   STRLIST sl;
1075   int ndesc;
1076   ksba_cert_t cert = NULL;
1077   gpg_error_t rc = 0;
1078   const char *lastresname, *resname;
1079   int have_secret;
1080
1081   hd = keydb_new (0);
1082   if (!hd)
1083     {
1084       log_error ("keydb_new failed\n");
1085       rc = gpg_error (GPG_ERR_GENERAL);
1086       goto leave;
1087     }
1088
1089   if (!names)
1090     ndesc = 1;
1091   else
1092     {
1093       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++) 
1094         ;
1095     }
1096
1097   desc = xtrycalloc (ndesc, sizeof *desc);
1098   if (!ndesc)
1099     {
1100       rc = gpg_error_from_errno (errno);
1101       log_error ("out of core\n");
1102       goto leave;
1103     }
1104
1105   if (!names)
1106     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1107   else 
1108     {
1109       for (ndesc=0, sl=names; sl; sl = sl->next) 
1110         {
1111           rc = keydb_classify_name (sl->d, desc+ndesc);
1112           if (rc)
1113             {
1114               log_error ("key `%s' not found: %s\n",
1115                          sl->d, gpg_strerror (rc));
1116               rc = 0;
1117             }
1118           else
1119             ndesc++;
1120         }
1121       
1122     }
1123
1124   if (opt.with_ephemeral_keys)
1125     keydb_set_ephemeral (hd, 1);
1126
1127   /* It would be nice to see which of the given users did actually
1128      match one in the keyring.  To implement this we need to have a
1129      found flag for each entry in desc and to set this we must check
1130      all those entries after a match to mark all matched one -
1131      currently we stop at the first match.  To do this we need an
1132      extra flag to enable this feature so */
1133
1134   lastresname = NULL;
1135   while (!(rc = keydb_search (hd, desc, ndesc)))
1136     {
1137       unsigned int validity;
1138
1139       if (!names) 
1140         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1141
1142       rc = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &validity);
1143       if (rc)
1144         {
1145           log_error ("keydb_get_flags failed: %s\n", gpg_strerror (rc));
1146           goto leave;
1147         }
1148       rc = keydb_get_cert (hd, &cert);
1149       if (rc) 
1150         {
1151           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
1152           goto leave;
1153         }
1154       
1155       resname = keydb_get_resource_name (hd);
1156       
1157       if (lastresname != resname ) 
1158         {
1159           int i;
1160           
1161           if (ctrl->no_server)
1162             {
1163               fprintf (fp, "%s\n", resname );
1164               for (i=strlen(resname); i; i-- )
1165                 putchar('-');
1166               putc ('\n', fp);
1167               lastresname = resname;
1168             }
1169         }
1170
1171       have_secret = 0;
1172       if (mode)
1173         {
1174           char *p = gpgsm_get_keygrip_hexstring (cert);
1175           if (p)
1176             {
1177               rc = gpgsm_agent_havekey (ctrl, p); 
1178              if (!rc)
1179                 have_secret = 1;
1180               else if ( gpg_err_code (rc) != GPG_ERR_NO_SECKEY)
1181                 goto leave;
1182               rc = 0;
1183               xfree (p);
1184             }
1185         }
1186
1187       if (!mode
1188           || ((mode & 1) && !have_secret)
1189           || ((mode & 2) && have_secret)  )
1190         {
1191           if (ctrl->with_colons)
1192             list_cert_colon (ctrl, cert, validity, fp, have_secret);
1193           else if (ctrl->with_chain)
1194             list_cert_chain (ctrl, hd, cert,
1195                              raw_mode, fp, ctrl->with_validation);
1196           else
1197             {
1198               if (raw_mode)
1199                 list_cert_raw (ctrl, hd, cert, fp, have_secret,
1200                                ctrl->with_validation);
1201               else
1202                 list_cert_std (ctrl, cert, fp, have_secret,
1203                                ctrl->with_validation);
1204               putc ('\n', fp);
1205             }
1206         }
1207       ksba_cert_release (cert); 
1208       cert = NULL;
1209     }
1210   if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1 )
1211     rc = 0;
1212   if (rc)
1213     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
1214   
1215  leave:
1216   ksba_cert_release (cert);
1217   xfree (desc);
1218   keydb_release (hd);
1219   return rc;
1220 }
1221
1222
1223
1224 static void
1225 list_external_cb (void *cb_value, ksba_cert_t cert)
1226 {
1227   struct list_external_parm_s *parm = cb_value;
1228
1229   if (keydb_store_cert (cert, 1, NULL))
1230     log_error ("error storing certificate as ephemeral\n");
1231
1232   if (parm->print_header)
1233     {
1234       const char *resname = "[external keys]";
1235       int i;
1236
1237       fprintf (parm->fp, "%s\n", resname );
1238       for (i=strlen(resname); i; i-- )
1239         putchar('-');
1240       putc ('\n', parm->fp);
1241       parm->print_header = 0;
1242     }
1243
1244   if (parm->with_colons)
1245     list_cert_colon (parm->ctrl, cert, 0, parm->fp, 0);
1246   else if (parm->with_chain)
1247     list_cert_chain (parm->ctrl, NULL, cert, parm->raw_mode, parm->fp, 0);
1248   else
1249     {
1250       if (parm->raw_mode)
1251         list_cert_raw (parm->ctrl, NULL, cert, parm->fp, 0, 0);
1252       else
1253         list_cert_std (parm->ctrl, cert, parm->fp, 0, 0);
1254       putc ('\n', parm->fp);
1255     }
1256 }
1257
1258
1259 /* List external keys similar to internal one.  Note: mode does not
1260    make sense here because it would be unwise to list external secret
1261    keys */
1262 static gpg_error_t
1263 list_external_keys (CTRL ctrl, STRLIST names, FILE *fp, int raw_mode)
1264 {
1265   int rc;
1266   struct list_external_parm_s parm;
1267
1268   parm.fp = fp;
1269   parm.ctrl = ctrl,
1270   parm.print_header = ctrl->no_server;
1271   parm.with_colons = ctrl->with_colons;
1272   parm.with_chain = ctrl->with_chain;
1273   parm.raw_mode  = raw_mode;
1274
1275   rc = gpgsm_dirmngr_lookup (ctrl, names, list_external_cb, &parm);
1276   if (rc)
1277     log_error ("listing external keys failed: %s\n", gpg_strerror (rc));
1278   return rc;
1279 }
1280
1281 /* List all keys or just the key given as NAMES.
1282    MODE controls the operation mode: 
1283     Bit 0-2:
1284       0 = list all public keys but don't flag secret ones
1285       1 = list only public keys
1286       2 = list only secret keys
1287       3 = list secret and public keys
1288     Bit 6: list internal keys
1289     Bit 7: list external keys
1290     Bit 8: Do a raw format dump.
1291  */
1292 gpg_error_t
1293 gpgsm_list_keys (CTRL ctrl, STRLIST names, FILE *fp, unsigned int mode)
1294 {
1295   gpg_error_t err = 0;
1296
1297   if ((mode & (1<<6)))
1298     err = list_internal_keys (ctrl, names, fp, (mode & 3), (mode&256));
1299   if (!err && (mode & (1<<7)))
1300     err = list_external_keys (ctrl, names, fp, (mode&256)); 
1301   return err;
1302 }