common: New function percent_data_escape.
[gnupg.git] / sm / keylist.c
1 /* keylist.c - Print certificates in various formats.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2008, 2009,
3  *               2010, 2011 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 3 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, see <https://www.gnu.org/licenses/>.
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
32 #include <gcrypt.h>
33 #include <ksba.h>
34
35 #include "keydb.h"
36 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
37 #include "../common/i18n.h"
38 #include "../common/tlv.h"
39 #include "../common/compliance.h"
40 #include "../common/pkscreening.h"
41
42 struct list_external_parm_s
43 {
44   ctrl_t ctrl;
45   estream_t fp;
46   int print_header;
47   int with_colons;
48   int with_chain;
49   int raw_mode;
50 };
51
52
53 /* This table is to map Extended Key Usage OIDs to human readable
54    names.  */
55 struct
56 {
57   const char *oid;
58   const char *name;
59 } key_purpose_map[] = {
60   { "1.3.6.1.5.5.7.3.1",  "serverAuth" },
61   { "1.3.6.1.5.5.7.3.2",  "clientAuth" },
62   { "1.3.6.1.5.5.7.3.3",  "codeSigning" },
63   { "1.3.6.1.5.5.7.3.4",  "emailProtection" },
64   { "1.3.6.1.5.5.7.3.5",  "ipsecEndSystem" },
65   { "1.3.6.1.5.5.7.3.6",  "ipsecTunnel" },
66   { "1.3.6.1.5.5.7.3.7",  "ipsecUser" },
67   { "1.3.6.1.5.5.7.3.8",  "timeStamping" },
68   { "1.3.6.1.5.5.7.3.9",  "ocspSigning" },
69   { "1.3.6.1.5.5.7.3.10", "dvcs" },
70   { "1.3.6.1.5.5.7.3.11", "sbgpCertAAServerAuth" },
71   { "1.3.6.1.5.5.7.3.13", "eapOverPPP" },
72   { "1.3.6.1.5.5.7.3.14", "wlanSSID" },
73
74   { "2.16.840.1.113730.4.1", "serverGatedCrypto.ns" }, /* Netscape. */
75   { "1.3.6.1.4.1.311.10.3.3", "serverGatedCrypto.ms"}, /* Microsoft. */
76
77   { "1.3.6.1.5.5.7.48.1.5", "ocspNoCheck" },
78
79   { NULL, NULL }
80 };
81
82
83 /* Do not print this extension in the list of extensions.  This is set
84    for oids which are already available via ksba functions. */
85 #define OID_FLAG_SKIP 1
86 /* The extension is a simple UTF8String and should be printed.  */
87 #define OID_FLAG_UTF8 2
88
89 /* A table mapping OIDs to a descriptive string. */
90 static struct
91 {
92   char *oid;
93   char *name;
94   unsigned int flag; /* A flag as described above.  */
95 } oidtranstbl[] = {
96
97   /* Algorithms. */
98   { "1.2.840.10040.4.1", "dsa" },
99   { "1.2.840.10040.4.3", "dsaWithSha1" },
100
101   { "1.2.840.113549.1.1.1", "rsaEncryption" },
102   { "1.2.840.113549.1.1.2", "md2WithRSAEncryption" },
103   { "1.2.840.113549.1.1.3", "md4WithRSAEncryption" },
104   { "1.2.840.113549.1.1.4", "md5WithRSAEncryption" },
105   { "1.2.840.113549.1.1.5", "sha1WithRSAEncryption" },
106   { "1.2.840.113549.1.1.7", "rsaOAEP" },
107   { "1.2.840.113549.1.1.8", "rsaOAEP-MGF" },
108   { "1.2.840.113549.1.1.9", "rsaOAEP-pSpecified" },
109   { "1.2.840.113549.1.1.10", "rsaPSS" },
110   { "1.2.840.113549.1.1.11", "sha256WithRSAEncryption" },
111   { "1.2.840.113549.1.1.12", "sha384WithRSAEncryption" },
112   { "1.2.840.113549.1.1.13", "sha512WithRSAEncryption" },
113
114   { "1.3.14.3.2.26", "sha1" },
115   { "1.3.14.3.2.29",  "sha-1WithRSAEncryption" },
116   { "1.3.36.3.3.1.2", "rsaSignatureWithripemd160" },
117
118
119   /* Telesec extensions. */
120   { "0.2.262.1.10.12.0", "certExtensionLiabilityLimitationExt" },
121   { "0.2.262.1.10.12.1", "telesecCertIdExt" },
122   { "0.2.262.1.10.12.2", "telesecPolicyIdentifier" },
123   { "0.2.262.1.10.12.3", "telesecPolicyQualifierID" },
124   { "0.2.262.1.10.12.4", "telesecCRLFilteredExt" },
125   { "0.2.262.1.10.12.5", "telesecCRLFilterExt"},
126   { "0.2.262.1.10.12.6", "telesecNamingAuthorityExt" },
127 #define OIDSTR_restriction \
128     "1.3.36.8.3.8"
129   { OIDSTR_restriction,      "restriction", OID_FLAG_UTF8 },
130
131
132   /* PKIX private extensions. */
133   { "1.3.6.1.5.5.7.1.1", "authorityInfoAccess" },
134   { "1.3.6.1.5.5.7.1.2", "biometricInfo" },
135   { "1.3.6.1.5.5.7.1.3", "qcStatements" },
136   { "1.3.6.1.5.5.7.1.4", "acAuditIdentity" },
137   { "1.3.6.1.5.5.7.1.5", "acTargeting" },
138   { "1.3.6.1.5.5.7.1.6", "acAaControls" },
139   { "1.3.6.1.5.5.7.1.7", "sbgp-ipAddrBlock" },
140   { "1.3.6.1.5.5.7.1.8", "sbgp-autonomousSysNum" },
141   { "1.3.6.1.5.5.7.1.9", "sbgp-routerIdentifier" },
142   { "1.3.6.1.5.5.7.1.10", "acProxying" },
143   { "1.3.6.1.5.5.7.1.11", "subjectInfoAccess" },
144
145   { "1.3.6.1.5.5.7.48.1", "ocsp" },
146   { "1.3.6.1.5.5.7.48.2", "caIssuers" },
147   { "1.3.6.1.5.5.7.48.3", "timeStamping" },
148   { "1.3.6.1.5.5.7.48.5", "caRepository" },
149
150   /* X.509 id-ce */
151   { "2.5.29.14", "subjectKeyIdentifier", OID_FLAG_SKIP},
152   { "2.5.29.15", "keyUsage", OID_FLAG_SKIP},
153   { "2.5.29.16", "privateKeyUsagePeriod" },
154   { "2.5.29.17", "subjectAltName", OID_FLAG_SKIP},
155   { "2.5.29.18", "issuerAltName", OID_FLAG_SKIP},
156   { "2.5.29.19", "basicConstraints", OID_FLAG_SKIP},
157   { "2.5.29.20", "cRLNumber" },
158   { "2.5.29.21", "cRLReason" },
159   { "2.5.29.22", "expirationDate" },
160   { "2.5.29.23", "instructionCode" },
161   { "2.5.29.24", "invalidityDate" },
162   { "2.5.29.27", "deltaCRLIndicator" },
163   { "2.5.29.28", "issuingDistributionPoint" },
164   { "2.5.29.29", "certificateIssuer" },
165   { "2.5.29.30", "nameConstraints" },
166   { "2.5.29.31", "cRLDistributionPoints", OID_FLAG_SKIP},
167   { "2.5.29.32", "certificatePolicies", OID_FLAG_SKIP},
168   { "2.5.29.32.0", "anyPolicy" },
169   { "2.5.29.33", "policyMappings" },
170   { "2.5.29.35", "authorityKeyIdentifier", OID_FLAG_SKIP},
171   { "2.5.29.36", "policyConstraints" },
172   { "2.5.29.37", "extKeyUsage", OID_FLAG_SKIP},
173   { "2.5.29.46", "freshestCRL" },
174   { "2.5.29.54", "inhibitAnyPolicy" },
175
176   /* Netscape certificate extensions. */
177   { "2.16.840.1.113730.1.1", "netscape-cert-type" },
178   { "2.16.840.1.113730.1.2", "netscape-base-url" },
179   { "2.16.840.1.113730.1.3", "netscape-revocation-url" },
180   { "2.16.840.1.113730.1.4", "netscape-ca-revocation-url" },
181   { "2.16.840.1.113730.1.7", "netscape-cert-renewal-url" },
182   { "2.16.840.1.113730.1.8", "netscape-ca-policy-url" },
183   { "2.16.840.1.113730.1.9", "netscape-homePage-url" },
184   { "2.16.840.1.113730.1.10", "netscape-entitylogo" },
185   { "2.16.840.1.113730.1.11", "netscape-userPicture" },
186   { "2.16.840.1.113730.1.12", "netscape-ssl-server-name" },
187   { "2.16.840.1.113730.1.13", "netscape-comment" },
188
189   /* GnuPG extensions */
190   { "1.3.6.1.4.1.11591.2.1.1", "pkaAddress" },
191   { "1.3.6.1.4.1.11591.2.2.1", "standaloneCertificate" },
192   { "1.3.6.1.4.1.11591.2.2.2", "wellKnownPrivateKey" },
193
194   /* Extensions used by the Bundesnetzagentur.  */
195   { "1.3.6.1.4.1.8301.3.5", "validityModel" },
196
197   { NULL }
198 };
199
200
201 /* Return the description for OID; if no description is available
202    NULL is returned. */
203 static const char *
204 get_oid_desc (const char *oid, unsigned int *flag)
205 {
206   int i;
207
208   if (oid)
209     for (i=0; oidtranstbl[i].oid; i++)
210       if (!strcmp (oidtranstbl[i].oid, oid))
211         {
212           if (flag)
213             *flag = oidtranstbl[i].flag;
214           return oidtranstbl[i].name;
215         }
216   if (flag)
217     *flag = 0;
218   return NULL;
219 }
220
221
222 static void
223 print_key_data (ksba_cert_t cert, estream_t fp)
224 {
225 #if 0
226   int n = pk ? pubkey_get_npkey( pk->pubkey_algo ) : 0;
227   int i;
228
229   for(i=0; i < n; i++ )
230     {
231       es_fprintf (fp, "pkd:%d:%u:", i, mpi_get_nbits( pk->pkey[i] ) );
232       mpi_print(stdout, pk->pkey[i], 1 );
233       putchar(':');
234       putchar('\n');
235     }
236 #else
237   (void)cert;
238   (void)fp;
239 #endif
240 }
241
242
243 /* Various public key screenings.  (Right now just ROCA).  With
244  * COLON_MODE set the output is formatted for use in the compliance
245  * field of a colon listing.  */
246 static void
247 print_pk_screening (ksba_cert_t cert, int colon_mode, estream_t fp)
248 {
249   gpg_error_t err;
250   gcry_mpi_t modulus;
251
252   modulus = gpgsm_get_rsa_modulus (cert);
253   if (modulus)
254     {
255       err = screen_key_for_roca (modulus);
256       if (!err)
257         ;
258       else if (gpg_err_code (err) == GPG_ERR_TRUE)
259         {
260           if (colon_mode)
261             es_fprintf (fp, colon_mode > 1? " %d":"%d", 6001);
262           else
263             es_fprintf (fp, "    screening: ROCA vulnerability detected\n");
264         }
265       else if (!colon_mode)
266         es_fprintf (fp, "    screening: [ROCA check failed: %s]\n",
267                     gpg_strerror (err));
268       gcry_mpi_release (modulus);
269     }
270
271 }
272
273
274 static void
275 print_capabilities (ksba_cert_t cert, estream_t fp)
276 {
277   gpg_error_t err;
278   unsigned int use;
279   size_t buflen;
280   char buffer[1];
281
282   err = ksba_cert_get_user_data (cert, "is_qualified",
283                                  &buffer, sizeof (buffer), &buflen);
284   if (!err && buflen)
285     {
286       if (*buffer)
287         es_putc ('q', fp);
288     }
289   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
290     ; /* Don't know - will not get marked as 'q' */
291   else
292     log_debug ("get_user_data(is_qualified) failed: %s\n",
293                gpg_strerror (err));
294
295   err = ksba_cert_get_key_usage (cert, &use);
296   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
297     {
298       es_putc ('e', fp);
299       es_putc ('s', fp);
300       es_putc ('c', fp);
301       es_putc ('E', fp);
302       es_putc ('S', fp);
303       es_putc ('C', fp);
304       return;
305     }
306   if (err)
307     {
308       log_error (_("error getting key usage information: %s\n"),
309                  gpg_strerror (err));
310       return;
311     }
312
313   if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
314     es_putc ('e', fp);
315   if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
316     es_putc ('s', fp);
317   if ((use & KSBA_KEYUSAGE_KEY_CERT_SIGN))
318     es_putc ('c', fp);
319   if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
320     es_putc ('E', fp);
321   if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
322     es_putc ('S', fp);
323   if ((use & KSBA_KEYUSAGE_KEY_CERT_SIGN))
324     es_putc ('C', fp);
325 }
326
327
328 static void
329 print_time (gnupg_isotime_t t, estream_t fp)
330 {
331   if (!t || !*t)
332     ;
333   else
334     es_fputs (t, fp);
335 }
336
337
338 /* Return an allocated string with the email address extracted from a
339    DN.  Note hat we use this code also in ../kbx/keybox-blob.c.  */
340 static char *
341 email_kludge (const char *name)
342 {
343   const char *p, *string;
344   unsigned char *buf;
345   int n;
346
347   string = name;
348   for (;;)
349     {
350       p = strstr (string, "1.2.840.113549.1.9.1=#");
351       if (!p)
352         return NULL;
353       if (p == name || (p > string+1 && p[-1] == ',' && p[-2] != '\\'))
354         {
355           name = p + 22;
356           break;
357         }
358       string = p + 22;
359     }
360
361
362   /* This looks pretty much like an email address in the subject's DN
363      we use this to add an additional user ID entry.  This way,
364      OpenSSL generated keys get a nicer and usable listing.  */
365   for (n=0, p=name; hexdigitp (p) && hexdigitp (p+1); p +=2, n++)
366     ;
367   if (!n)
368     return NULL;
369   buf = xtrymalloc (n+3);
370   if (!buf)
371     return NULL; /* oops, out of core */
372   *buf = '<';
373   for (n=1, p=name; hexdigitp (p); p +=2, n++)
374     buf[n] = xtoi_2 (p);
375   buf[n++] = '>';
376   buf[n] = 0;
377   return (char*)buf;
378 }
379
380
381 /* Print the compliance flags to field 18.  ALGO is the gcrypt algo
382  * number.  NBITS is the length of the key in bits.  */
383 static void
384 print_compliance_flags (ksba_cert_t cert, int algo, unsigned int nbits,
385                         estream_t fp)
386 {
387   int any = 0;
388
389   if (gnupg_pk_is_compliant (CO_DE_VS, algo, NULL, nbits, NULL))
390     {
391       es_fputs (gnupg_status_compliance_flag (CO_DE_VS), fp);
392       any++;
393     }
394
395   if (opt.with_key_screening)
396     print_pk_screening (cert, 1+any, fp);
397 }
398
399
400 /* List one certificate in colon mode */
401 static void
402 list_cert_colon (ctrl_t ctrl, ksba_cert_t cert, unsigned int validity,
403                  estream_t fp, int have_secret)
404 {
405   int rc;
406   int idx;
407   char truststring[2];
408   char *p;
409   ksba_sexp_t sexp;
410   char *fpr;
411   ksba_isotime_t t;
412   gpg_error_t valerr;
413   int algo;
414   unsigned int nbits;
415   const char *chain_id;
416   char *chain_id_buffer = NULL;
417   int is_root = 0;
418   char *kludge_uid;
419
420   if (ctrl->with_validation)
421     valerr = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, NULL, 0, NULL);
422   else
423     valerr = 0;
424
425
426   /* We need to get the fingerprint and the chaining ID in advance. */
427   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
428   {
429     ksba_cert_t next;
430
431     rc = gpgsm_walk_cert_chain (ctrl, cert, &next);
432     if (!rc) /* We known the issuer's certificate. */
433       {
434         p = gpgsm_get_fingerprint_hexstring (next, GCRY_MD_SHA1);
435         chain_id_buffer = p;
436         chain_id = chain_id_buffer;
437         ksba_cert_release (next);
438       }
439     else if (rc == -1)  /* We have reached the root certificate. */
440       {
441         chain_id = fpr;
442         is_root = 1;
443       }
444     else
445       chain_id = NULL;
446   }
447
448
449   es_fputs (have_secret? "crs:":"crt:", fp);
450
451   /* Note: We can't use multiple flags, like "ei", because the
452      validation check does only return one error.  */
453   truststring[0] = 0;
454   truststring[1] = 0;
455   if ((validity & VALIDITY_REVOKED)
456       || gpg_err_code (valerr) == GPG_ERR_CERT_REVOKED)
457     *truststring = 'r';
458   else if (gpg_err_code (valerr) == GPG_ERR_CERT_EXPIRED)
459     *truststring = 'e';
460   else
461     {
462       /* Lets also check whether the certificate under question
463          expired.  This is merely a hack until we found a proper way
464          to store the expiration flag in the keybox. */
465       ksba_isotime_t current_time, not_after;
466
467       gnupg_get_isotime (current_time);
468       if (!opt.ignore_expiration
469           && !ksba_cert_get_validity (cert, 1, not_after)
470           && *not_after && strcmp (current_time, not_after) > 0 )
471         *truststring = 'e';
472       else if (valerr)
473         {
474           if (gpgsm_cert_has_well_known_private_key (cert))
475             *truststring = 'w';  /* Well, this is dummy CA.  */
476           else
477             *truststring = 'i';
478         }
479       else if (ctrl->with_validation && !is_root)
480         *truststring = 'f';
481     }
482
483   /* If we have no truststring yet (i.e. the certificate might be
484      good) and this is a root certificate, we ask the agent whether
485      this is a trusted root certificate. */
486   if (!*truststring && is_root)
487     {
488       struct rootca_flags_s dummy_flags;
489
490       if (gpgsm_cert_has_well_known_private_key (cert))
491         *truststring = 'w';  /* Well, this is dummy CA.  */
492       else
493         {
494           rc = gpgsm_agent_istrusted (ctrl, cert, NULL, &dummy_flags);
495           if (!rc)
496             *truststring = 'u';  /* Yes, we trust this one (ultimately). */
497           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
498             *truststring = 'n';  /* No, we do not trust this one. */
499           /* (in case of an error we can't tell anything.) */
500         }
501     }
502
503   if (*truststring)
504     es_fputs (truststring, fp);
505
506   algo = gpgsm_get_key_algo_info (cert, &nbits);
507   es_fprintf (fp, ":%u:%d:%s:", nbits, algo, fpr+24);
508
509   ksba_cert_get_validity (cert, 0, t);
510   print_time (t, fp);
511   es_putc (':', fp);
512   ksba_cert_get_validity (cert, 1, t);
513   print_time ( t, fp);
514   es_putc (':', fp);
515   /* Field 8, serial number: */
516   if ((sexp = ksba_cert_get_serial (cert)))
517     {
518       int len;
519       const unsigned char *s = sexp;
520
521       if (*s == '(')
522         {
523           s++;
524           for (len=0; *s && *s != ':' && digitp (s); s++)
525             len = len*10 + atoi_1 (s);
526           if (*s == ':')
527             for (s++; len; len--, s++)
528               es_fprintf (fp,"%02X", *s);
529         }
530       xfree (sexp);
531     }
532   es_putc (':', fp);
533   /* Field 9, ownertrust - not used here */
534   es_putc (':', fp);
535   /* field 10, old user ID - we use it here for the issuer DN */
536   if ((p = ksba_cert_get_issuer (cert,0)))
537     {
538       es_write_sanitized (fp, p, strlen (p), ":", NULL);
539       xfree (p);
540     }
541   es_putc (':', fp);
542   /* Field 11, signature class - not used */
543   es_putc (':', fp);
544   /* Field 12, capabilities: */
545   print_capabilities (cert, fp);
546   es_putc (':', fp);
547   /* Field 13, not used: */
548   es_putc (':', fp);
549   /* Field 14, not used: */
550   es_putc (':', fp);
551   if (have_secret || ctrl->with_secret)
552     {
553       char *cardsn;
554
555       p = gpgsm_get_keygrip_hexstring (cert);
556       if (!gpgsm_agent_keyinfo (ctrl, p, &cardsn)
557           && (cardsn || ctrl->with_secret))
558         {
559           /* Field 15:  Token serial number or secret key indicator.  */
560           if (cardsn)
561             es_fputs (cardsn, fp);
562           else if (ctrl->with_secret)
563             es_putc ('+', fp);
564         }
565       xfree (cardsn);
566       xfree (p);
567     }
568   es_putc (':', fp);  /* End of field 15. */
569   es_putc (':', fp);  /* End of field 16. */
570   es_putc (':', fp);  /* End of field 17. */
571   print_compliance_flags (cert, algo, nbits, fp);
572   es_putc (':', fp);  /* End of field 18. */
573   es_putc ('\n', fp);
574
575   /* FPR record */
576   es_fprintf (fp, "fpr:::::::::%s:::", fpr);
577   /* Print chaining ID (field 13)*/
578   if (chain_id)
579     es_fputs (chain_id, fp);
580   es_putc (':', fp);
581   es_putc ('\n', fp);
582   xfree (fpr); fpr = NULL; chain_id = NULL;
583   xfree (chain_id_buffer); chain_id_buffer = NULL;
584
585   /* Always print the keygrip.  */
586   if ( (p = gpgsm_get_keygrip_hexstring (cert)))
587     {
588       es_fprintf (fp, "grp:::::::::%s:\n", p);
589       xfree (p);
590     }
591
592   if (opt.with_key_data)
593     print_key_data (cert, fp);
594
595   kludge_uid = NULL;
596   for (idx=0; (p = ksba_cert_get_subject (cert,idx)); idx++)
597     {
598       /* In the case that the same email address is in the subject DN
599          as well as in an alternate subject name we avoid printing it
600          a second time. */
601       if (kludge_uid && !strcmp (kludge_uid, p))
602         continue;
603
604       es_fprintf (fp, "uid:%s::::::::", truststring);
605       es_write_sanitized (fp, p, strlen (p), ":", NULL);
606       es_putc (':', fp);
607       es_putc (':', fp);
608       es_putc ('\n', fp);
609       if (!idx)
610         {
611           /* It would be better to get the faked email address from
612              the keydb.  But as long as we don't have a way to pass
613              the meta data back, we just check it the same way as the
614              code used to create the keybox meta data does */
615           kludge_uid = email_kludge (p);
616           if (kludge_uid)
617             {
618               es_fprintf (fp, "uid:%s::::::::", truststring);
619               es_write_sanitized (fp, kludge_uid, strlen (kludge_uid),
620                                   ":", NULL);
621               es_putc (':', fp);
622               es_putc (':', fp);
623               es_putc ('\n', fp);
624             }
625         }
626       xfree (p);
627     }
628   xfree (kludge_uid);
629 }
630
631
632 static void
633 print_name_raw (estream_t fp, const char *string)
634 {
635   if (!string)
636     es_fputs ("[error]", fp);
637   else
638     es_write_sanitized (fp, string, strlen (string), NULL, NULL);
639 }
640
641 static void
642 print_names_raw (estream_t fp, int indent, ksba_name_t name)
643 {
644   int idx;
645   const char *s;
646   int indent_all;
647
648   if ((indent_all = (indent < 0)))
649     indent = - indent;
650
651   if (!name)
652     {
653       es_fputs ("none\n", fp);
654       return;
655     }
656
657   for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
658     {
659       char *p = ksba_name_get_uri (name, idx);
660       es_fprintf (fp, "%*s", idx||indent_all?indent:0, "");
661       es_write_sanitized (fp, p?p:s, strlen (p?p:s), NULL, NULL);
662       es_putc ('\n', fp);
663       xfree (p);
664     }
665 }
666
667
668 static void
669 print_utf8_extn_raw (estream_t fp, int indent,
670                      const unsigned char *der, size_t derlen)
671 {
672   gpg_error_t err;
673   int class, tag, constructed, ndef;
674   size_t objlen, hdrlen;
675
676   if (indent < 0)
677     indent = - indent;
678
679   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
680                           &ndef, &objlen, &hdrlen);
681   if (!err && (objlen > derlen || tag != TAG_UTF8_STRING))
682     err = gpg_error (GPG_ERR_INV_OBJ);
683   if (err)
684     {
685       es_fprintf (fp, "%*s[%s]\n", indent, "", gpg_strerror (err));
686       return;
687     }
688   es_fprintf (fp, "%*s(%.*s)\n", indent, "", (int)objlen, der);
689 }
690
691
692 static void
693 print_utf8_extn (estream_t fp, int indent,
694                  const unsigned char *der, size_t derlen)
695 {
696   gpg_error_t err;
697   int class, tag, constructed, ndef;
698   size_t objlen, hdrlen;
699   int indent_all;
700
701   if ((indent_all = (indent < 0)))
702     indent = - indent;
703
704   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
705                           &ndef, &objlen, &hdrlen);
706   if (!err && (objlen > derlen || tag != TAG_UTF8_STRING))
707     err = gpg_error (GPG_ERR_INV_OBJ);
708   if (err)
709     {
710       es_fprintf (fp, "%*s[%s%s]\n",
711                   indent_all? indent:0, "", _("Error - "), gpg_strerror (err));
712       return;
713     }
714   es_fprintf (fp, "%*s\"", indent_all? indent:0, "");
715   /* Fixme: we should implement word wrapping */
716   es_write_sanitized (fp, der, objlen, "\"", NULL);
717   es_fputs ("\"\n", fp);
718 }
719
720
721 /* List one certificate in raw mode useful to have a closer look at
722    the certificate.  This one does no beautification and only minimal
723    output sanitation.  It is mainly useful for debugging. */
724 static void
725 list_cert_raw (ctrl_t ctrl, KEYDB_HANDLE hd,
726                ksba_cert_t cert, estream_t fp, int have_secret,
727                int with_validation)
728 {
729   gpg_error_t err;
730   size_t off, len;
731   ksba_sexp_t sexp, keyid;
732   char *dn;
733   ksba_isotime_t t;
734   int idx, i;
735   int is_ca, chainlen;
736   unsigned int kusage;
737   char *string, *p, *pend;
738   const char *oid, *s;
739   ksba_name_t name, name2;
740   unsigned int reason;
741   const unsigned char *cert_der = NULL;
742
743   (void)have_secret;
744
745   es_fprintf (fp, "           ID: 0x%08lX\n",
746               gpgsm_get_short_fingerprint (cert, NULL));
747
748   sexp = ksba_cert_get_serial (cert);
749   es_fputs ("          S/N: ", fp);
750   gpgsm_print_serial (fp, sexp);
751   ksba_free (sexp);
752   es_putc ('\n', fp);
753
754   dn = ksba_cert_get_issuer (cert, 0);
755   es_fputs ("       Issuer: ", fp);
756   print_name_raw (fp, dn);
757   ksba_free (dn);
758   es_putc ('\n', fp);
759   for (idx=1; (dn = ksba_cert_get_issuer (cert, idx)); idx++)
760     {
761       es_fputs ("          aka: ", fp);
762       print_name_raw (fp, dn);
763       ksba_free (dn);
764       es_putc ('\n', fp);
765     }
766
767   dn = ksba_cert_get_subject (cert, 0);
768   es_fputs ("      Subject: ", fp);
769   print_name_raw (fp, dn);
770   ksba_free (dn);
771   es_putc ('\n', fp);
772   for (idx=1; (dn = ksba_cert_get_subject (cert, idx)); idx++)
773     {
774       es_fputs ("          aka: ", fp);
775       print_name_raw (fp, dn);
776       ksba_free (dn);
777       es_putc ('\n', fp);
778     }
779
780   dn = gpgsm_get_fingerprint_string (cert, 0);
781   es_fprintf (fp, "     sha1_fpr: %s\n", dn?dn:"error");
782   xfree (dn);
783
784   dn = gpgsm_get_fingerprint_string (cert, GCRY_MD_MD5);
785   es_fprintf (fp, "      md5_fpr: %s\n", dn?dn:"error");
786   xfree (dn);
787
788   dn = gpgsm_get_certid (cert);
789   es_fprintf (fp, "       certid: %s\n", dn?dn:"error");
790   xfree (dn);
791
792   dn = gpgsm_get_keygrip_hexstring (cert);
793   es_fprintf (fp, "      keygrip: %s\n", dn?dn:"error");
794   xfree (dn);
795
796   ksba_cert_get_validity (cert, 0, t);
797   es_fputs ("    notBefore: ", fp);
798   gpgsm_print_time (fp, t);
799   es_putc ('\n', fp);
800   es_fputs ("     notAfter: ", fp);
801   ksba_cert_get_validity (cert, 1, t);
802   gpgsm_print_time (fp, t);
803   es_putc ('\n', fp);
804
805   oid = ksba_cert_get_digest_algo (cert);
806   s = get_oid_desc (oid, NULL);
807   es_fprintf (fp, "     hashAlgo: %s%s%s%s\n", oid, s?" (":"",s?s:"",s?")":"");
808
809   {
810     const char *algoname;
811     unsigned int nbits;
812
813     algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
814     es_fprintf (fp, "      keyType: %u bit %s\n",
815                 nbits, algoname? algoname:"?");
816   }
817
818   /* subjectKeyIdentifier */
819   es_fputs ("    subjKeyId: ", fp);
820   err = ksba_cert_get_subj_key_id (cert, NULL, &keyid);
821   if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
822     {
823       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
824         es_fputs ("[none]\n", fp);
825       else
826         {
827           gpgsm_print_serial (fp, keyid);
828           ksba_free (keyid);
829           es_putc ('\n', fp);
830         }
831     }
832   else
833     es_fputs ("[?]\n", fp);
834
835
836   /* authorityKeyIdentifier */
837   es_fputs ("    authKeyId: ", fp);
838   err = ksba_cert_get_auth_key_id (cert, &keyid, &name, &sexp);
839   if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
840     {
841       if (gpg_err_code (err) == GPG_ERR_NO_DATA || !name)
842         es_fputs ("[none]\n", fp);
843       else
844         {
845           gpgsm_print_serial (fp, sexp);
846           ksba_free (sexp);
847           es_putc ('\n', fp);
848           print_names_raw (fp, -15, name);
849           ksba_name_release (name);
850         }
851       if (keyid)
852         {
853           es_fputs (" authKeyId.ki: ", fp);
854           gpgsm_print_serial (fp, keyid);
855           ksba_free (keyid);
856           es_putc ('\n', fp);
857         }
858     }
859   else
860     es_fputs ("[?]\n", fp);
861
862   es_fputs ("     keyUsage:", fp);
863   err = ksba_cert_get_key_usage (cert, &kusage);
864   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
865     {
866       if (err)
867         es_fprintf (fp, " [error: %s]", gpg_strerror (err));
868       else
869         {
870           if ( (kusage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
871             es_fputs (" digitalSignature", fp);
872           if ( (kusage & KSBA_KEYUSAGE_NON_REPUDIATION))
873             es_fputs (" nonRepudiation", fp);
874           if ( (kusage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT))
875             es_fputs (" keyEncipherment", fp);
876           if ( (kusage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
877             es_fputs (" dataEncipherment", fp);
878           if ( (kusage & KSBA_KEYUSAGE_KEY_AGREEMENT))
879             es_fputs (" keyAgreement", fp);
880           if ( (kusage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
881             es_fputs (" certSign", fp);
882           if ( (kusage & KSBA_KEYUSAGE_CRL_SIGN))
883             es_fputs (" crlSign", fp);
884           if ( (kusage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
885             es_fputs (" encipherOnly", fp);
886           if ( (kusage & KSBA_KEYUSAGE_DECIPHER_ONLY))
887             es_fputs (" decipherOnly", fp);
888         }
889       es_putc ('\n', fp);
890     }
891   else
892     es_fputs (" [none]\n", fp);
893
894   es_fputs ("  extKeyUsage: ", fp);
895   err = ksba_cert_get_ext_key_usages (cert, &string);
896   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
897     {
898       if (err)
899         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
900       else
901         {
902           p = string;
903           while (p && (pend=strchr (p, ':')))
904             {
905               *pend++ = 0;
906               for (i=0; key_purpose_map[i].oid; i++)
907                 if ( !strcmp (key_purpose_map[i].oid, p) )
908                   break;
909               es_fputs (key_purpose_map[i].oid?key_purpose_map[i].name:p, fp);
910               p = pend;
911               if (*p != 'C')
912                 es_fputs (" (suggested)", fp);
913               if ((p = strchr (p, '\n')))
914                 {
915                   p++;
916                   es_fputs ("\n               ", fp);
917                 }
918             }
919           xfree (string);
920         }
921       es_putc ('\n', fp);
922     }
923   else
924     es_fputs ("[none]\n", fp);
925
926
927   es_fputs ("     policies: ", fp);
928   err = ksba_cert_get_cert_policies (cert, &string);
929   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
930     {
931       if (err)
932         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
933       else
934         {
935           p = string;
936           while (p && (pend=strchr (p, ':')))
937             {
938               *pend++ = 0;
939               for (i=0; key_purpose_map[i].oid; i++)
940                 if ( !strcmp (key_purpose_map[i].oid, p) )
941                   break;
942               es_fputs (p, fp);
943               p = pend;
944               if (*p == 'C')
945                 es_fputs (" (critical)", fp);
946               if ((p = strchr (p, '\n')))
947                 {
948                   p++;
949                   es_fputs ("\n               ", fp);
950                 }
951             }
952           xfree (string);
953         }
954       es_putc ('\n', fp);
955     }
956   else
957     es_fputs ("[none]\n", fp);
958
959   es_fputs ("  chainLength: ", fp);
960   err = ksba_cert_is_ca (cert, &is_ca, &chainlen);
961   if (err || is_ca)
962     {
963       if (gpg_err_code (err) == GPG_ERR_NO_VALUE )
964         es_fprintf (fp, "[none]");
965       else if (err)
966         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
967       else if (chainlen == -1)
968         es_fputs ("unlimited", fp);
969       else
970         es_fprintf (fp, "%d", chainlen);
971       es_putc ('\n', fp);
972     }
973   else
974     es_fputs ("not a CA\n", fp);
975
976
977   /* CRL distribution point */
978   for (idx=0; !(err=ksba_cert_get_crl_dist_point (cert, idx, &name, &name2,
979                                                   &reason)) ;idx++)
980     {
981       es_fputs ("        crlDP: ", fp);
982       print_names_raw (fp, 15, name);
983       if (reason)
984         {
985           es_fputs ("               reason: ", fp);
986           if ( (reason & KSBA_CRLREASON_UNSPECIFIED))
987             es_fputs (" unused", fp);
988           if ( (reason & KSBA_CRLREASON_KEY_COMPROMISE))
989             es_fputs (" keyCompromise", fp);
990           if ( (reason & KSBA_CRLREASON_CA_COMPROMISE))
991             es_fputs (" caCompromise", fp);
992           if ( (reason & KSBA_CRLREASON_AFFILIATION_CHANGED))
993             es_fputs (" affiliationChanged", fp);
994           if ( (reason & KSBA_CRLREASON_SUPERSEDED))
995             es_fputs (" superseded", fp);
996           if ( (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION))
997             es_fputs (" cessationOfOperation", fp);
998           if ( (reason & KSBA_CRLREASON_CERTIFICATE_HOLD))
999             es_fputs (" certificateHold", fp);
1000           es_putc ('\n', fp);
1001         }
1002       es_fputs ("               issuer: ", fp);
1003       print_names_raw (fp, 23, name2);
1004       ksba_name_release (name);
1005       ksba_name_release (name2);
1006     }
1007   if (err && gpg_err_code (err) != GPG_ERR_EOF
1008       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
1009     es_fputs ("        crlDP: [error]\n", fp);
1010   else if (!idx)
1011     es_fputs ("        crlDP: [none]\n", fp);
1012
1013
1014   /* authorityInfoAccess. */
1015   for (idx=0; !(err=ksba_cert_get_authority_info_access (cert, idx, &string,
1016                                                          &name)); idx++)
1017     {
1018       es_fputs ("     authInfo: ", fp);
1019       s = get_oid_desc (string, NULL);
1020       es_fprintf (fp, "%s%s%s%s\n", string, s?" (":"", s?s:"", s?")":"");
1021       print_names_raw (fp, -15, name);
1022       ksba_name_release (name);
1023       ksba_free (string);
1024     }
1025   if (err && gpg_err_code (err) != GPG_ERR_EOF
1026       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
1027     es_fputs ("     authInfo: [error]\n", fp);
1028   else if (!idx)
1029     es_fputs ("     authInfo: [none]\n", fp);
1030
1031   /* subjectInfoAccess. */
1032   for (idx=0; !(err=ksba_cert_get_subject_info_access (cert, idx, &string,
1033                                                          &name)); idx++)
1034     {
1035       es_fputs ("  subjectInfo: ", fp);
1036       s = get_oid_desc (string, NULL);
1037       es_fprintf (fp, "%s%s%s%s\n", string, s?" (":"", s?s:"", s?")":"");
1038       print_names_raw (fp, -15, name);
1039       ksba_name_release (name);
1040       ksba_free (string);
1041     }
1042   if (err && gpg_err_code (err) != GPG_ERR_EOF
1043       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
1044     es_fputs ("     subjInfo: [error]\n", fp);
1045   else if (!idx)
1046     es_fputs ("     subjInfo: [none]\n", fp);
1047
1048
1049   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
1050                                              &oid, &i, &off, &len));idx++)
1051     {
1052       unsigned int flag;
1053
1054       s = get_oid_desc (oid, &flag);
1055       if ((flag & OID_FLAG_SKIP))
1056         continue;
1057
1058       es_fprintf (fp, "     %s: %s%s%s%s  [%d octets]\n",
1059                   i? "critExtn":"    extn",
1060                   oid, s?" (":"", s?s:"", s?")":"", (int)len);
1061       if ((flag & OID_FLAG_UTF8))
1062         {
1063           if (!cert_der)
1064             cert_der = ksba_cert_get_image (cert, NULL);
1065           assert (cert_der);
1066           print_utf8_extn_raw (fp, -15, cert_der+off, len);
1067         }
1068     }
1069
1070
1071   if (with_validation)
1072     {
1073       err = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, fp, 0, NULL);
1074       if (!err)
1075         es_fprintf (fp, "  [certificate is good]\n");
1076       else
1077         es_fprintf (fp, "  [certificate is bad: %s]\n", gpg_strerror (err));
1078     }
1079
1080   if (hd)
1081     {
1082       unsigned int blobflags;
1083
1084       err = keydb_get_flags (hd, KEYBOX_FLAG_BLOB, 0, &blobflags);
1085       if (err)
1086         es_fprintf (fp, "  [error getting keyflags: %s]\n",gpg_strerror (err));
1087       else if ((blobflags & KEYBOX_FLAG_BLOB_EPHEMERAL))
1088         es_fprintf (fp, "  [stored as ephemeral]\n");
1089     }
1090
1091 }
1092
1093
1094
1095
1096 /* List one certificate in standard mode */
1097 static void
1098 list_cert_std (ctrl_t ctrl, ksba_cert_t cert, estream_t fp, int have_secret,
1099                int with_validation)
1100 {
1101   gpg_error_t err;
1102   ksba_sexp_t sexp;
1103   char *dn;
1104   ksba_isotime_t t;
1105   int idx, i;
1106   int is_ca, chainlen;
1107   unsigned int kusage;
1108   char *string, *p, *pend;
1109   size_t off, len;
1110   const char *oid;
1111   const unsigned char *cert_der = NULL;
1112
1113
1114   es_fprintf (fp, "           ID: 0x%08lX\n",
1115               gpgsm_get_short_fingerprint (cert, NULL));
1116
1117   sexp = ksba_cert_get_serial (cert);
1118   es_fputs ("          S/N: ", fp);
1119   gpgsm_print_serial (fp, sexp);
1120   ksba_free (sexp);
1121   es_putc ('\n', fp);
1122
1123   dn = ksba_cert_get_issuer (cert, 0);
1124   es_fputs ("       Issuer: ", fp);
1125   gpgsm_es_print_name (fp, dn);
1126   ksba_free (dn);
1127   es_putc ('\n', fp);
1128   for (idx=1; (dn = ksba_cert_get_issuer (cert, idx)); idx++)
1129     {
1130       es_fputs ("          aka: ", fp);
1131       gpgsm_es_print_name (fp, dn);
1132       ksba_free (dn);
1133       es_putc ('\n', fp);
1134     }
1135
1136   dn = ksba_cert_get_subject (cert, 0);
1137   es_fputs ("      Subject: ", fp);
1138   gpgsm_es_print_name (fp, dn);
1139   ksba_free (dn);
1140   es_putc ('\n', fp);
1141   for (idx=1; (dn = ksba_cert_get_subject (cert, idx)); idx++)
1142     {
1143       es_fputs ("          aka: ", fp);
1144       gpgsm_es_print_name (fp, dn);
1145       ksba_free (dn);
1146       es_putc ('\n', fp);
1147     }
1148
1149   ksba_cert_get_validity (cert, 0, t);
1150   es_fputs ("     validity: ", fp);
1151   gpgsm_print_time (fp, t);
1152   es_fputs (" through ", fp);
1153   ksba_cert_get_validity (cert, 1, t);
1154   gpgsm_print_time (fp, t);
1155   es_putc ('\n', fp);
1156
1157
1158   {
1159     const char *algoname;
1160     unsigned int nbits;
1161
1162     algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
1163     es_fprintf (fp, "     key type: %u bit %s\n",
1164                 nbits, algoname? algoname:"?");
1165   }
1166
1167
1168   err = ksba_cert_get_key_usage (cert, &kusage);
1169   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1170     {
1171       es_fputs ("    key usage:", fp);
1172       if (err)
1173         es_fprintf (fp, " [error: %s]", gpg_strerror (err));
1174       else
1175         {
1176           if ( (kusage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
1177             es_fputs (" digitalSignature", fp);
1178           if ( (kusage & KSBA_KEYUSAGE_NON_REPUDIATION))
1179             es_fputs (" nonRepudiation", fp);
1180           if ( (kusage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT))
1181             es_fputs (" keyEncipherment", fp);
1182           if ( (kusage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
1183             es_fputs (" dataEncipherment", fp);
1184           if ( (kusage & KSBA_KEYUSAGE_KEY_AGREEMENT))
1185             es_fputs (" keyAgreement", fp);
1186           if ( (kusage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
1187             es_fputs (" certSign", fp);
1188           if ( (kusage & KSBA_KEYUSAGE_CRL_SIGN))
1189             es_fputs (" crlSign", fp);
1190           if ( (kusage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
1191             es_fputs (" encipherOnly", fp);
1192           if ( (kusage & KSBA_KEYUSAGE_DECIPHER_ONLY))
1193             es_fputs (" decipherOnly", fp);
1194         }
1195       es_putc ('\n', fp);
1196     }
1197
1198   err = ksba_cert_get_ext_key_usages (cert, &string);
1199   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1200     {
1201       es_fputs ("ext key usage: ", fp);
1202       if (err)
1203         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1204       else
1205         {
1206           p = string;
1207           while (p && (pend=strchr (p, ':')))
1208             {
1209               *pend++ = 0;
1210               for (i=0; key_purpose_map[i].oid; i++)
1211                 if ( !strcmp (key_purpose_map[i].oid, p) )
1212                   break;
1213               es_fputs (key_purpose_map[i].oid?key_purpose_map[i].name:p, fp);
1214               p = pend;
1215               if (*p != 'C')
1216                 es_fputs (" (suggested)", fp);
1217               if ((p = strchr (p, '\n')))
1218                 {
1219                   p++;
1220                   es_fputs (", ", fp);
1221                 }
1222             }
1223           xfree (string);
1224         }
1225       es_putc ('\n', fp);
1226     }
1227
1228   /* Print restrictions.  */
1229   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
1230                                              &oid, NULL, &off, &len));idx++)
1231     {
1232       if (!strcmp (oid, OIDSTR_restriction) )
1233         {
1234           if (!cert_der)
1235             cert_der = ksba_cert_get_image (cert, NULL);
1236           assert (cert_der);
1237           es_fputs ("  restriction: ", fp);
1238           print_utf8_extn (fp, 15, cert_der+off, len);
1239         }
1240     }
1241
1242   /* Print policies.  */
1243   err = ksba_cert_get_cert_policies (cert, &string);
1244   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1245     {
1246       es_fputs ("     policies: ", fp);
1247       if (err)
1248         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1249       else
1250         {
1251           for (p=string; *p; p++)
1252             {
1253               if (*p == '\n')
1254                 *p = ',';
1255             }
1256           es_write_sanitized (fp, string, strlen (string), NULL, NULL);
1257           xfree (string);
1258         }
1259       es_putc ('\n', fp);
1260     }
1261
1262   err = ksba_cert_is_ca (cert, &is_ca, &chainlen);
1263   if (err || is_ca)
1264     {
1265       es_fputs (" chain length: ", fp);
1266       if (gpg_err_code (err) == GPG_ERR_NO_VALUE )
1267         es_fprintf (fp, "none");
1268       else if (err)
1269         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1270       else if (chainlen == -1)
1271         es_fputs ("unlimited", fp);
1272       else
1273         es_fprintf (fp, "%d", chainlen);
1274       es_putc ('\n', fp);
1275     }
1276
1277   if (opt.with_md5_fingerprint)
1278     {
1279       dn = gpgsm_get_fingerprint_string (cert, GCRY_MD_MD5);
1280       es_fprintf (fp, "      md5 fpr: %s\n", dn?dn:"error");
1281       xfree (dn);
1282     }
1283
1284   dn = gpgsm_get_fingerprint_string (cert, 0);
1285   es_fprintf (fp, "  fingerprint: %s\n", dn?dn:"error");
1286   xfree (dn);
1287
1288   if (opt.with_keygrip)
1289     {
1290       dn = gpgsm_get_keygrip_hexstring (cert);
1291       if (dn)
1292         {
1293           es_fprintf (fp, "      keygrip: %s\n", dn);
1294           xfree (dn);
1295         }
1296     }
1297
1298   if (opt.with_key_screening)
1299     print_pk_screening (cert, 0, fp);
1300
1301   if (have_secret)
1302     {
1303       char *cardsn;
1304
1305       p = gpgsm_get_keygrip_hexstring (cert);
1306       if (!gpgsm_agent_keyinfo (ctrl, p, &cardsn) && cardsn)
1307         es_fprintf (fp, "     card s/n: %s\n", cardsn);
1308       xfree (cardsn);
1309       xfree (p);
1310     }
1311
1312   if (with_validation)
1313     {
1314       gpg_error_t tmperr;
1315       size_t buflen;
1316       char buffer[1];
1317
1318       err = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, fp, 0, NULL);
1319       tmperr = ksba_cert_get_user_data (cert, "is_qualified",
1320                                         &buffer, sizeof (buffer), &buflen);
1321       if (!tmperr && buflen)
1322         {
1323           if (*buffer)
1324             es_fputs ("  [qualified]\n", fp);
1325         }
1326       else if (gpg_err_code (tmperr) == GPG_ERR_NOT_FOUND)
1327         ; /* Don't know - will not get marked as 'q' */
1328       else
1329         log_debug ("get_user_data(is_qualified) failed: %s\n",
1330                    gpg_strerror (tmperr));
1331
1332       if (!err)
1333         es_fprintf (fp, "  [certificate is good]\n");
1334       else
1335         es_fprintf (fp, "  [certificate is bad: %s]\n", gpg_strerror (err));
1336     }
1337 }
1338
1339
1340 /* Same as standard mode list all certifying certs too. */
1341 static void
1342 list_cert_chain (ctrl_t ctrl, KEYDB_HANDLE hd,
1343                  ksba_cert_t cert, int raw_mode,
1344                  estream_t fp, int with_validation)
1345 {
1346   ksba_cert_t next = NULL;
1347
1348   if (raw_mode)
1349     list_cert_raw (ctrl, hd, cert, fp, 0, with_validation);
1350   else
1351     list_cert_std (ctrl, cert, fp, 0, with_validation);
1352   ksba_cert_ref (cert);
1353   while (!gpgsm_walk_cert_chain (ctrl, cert, &next))
1354     {
1355       ksba_cert_release (cert);
1356       es_fputs ("Certified by\n", fp);
1357       if (raw_mode)
1358         list_cert_raw (ctrl, hd, next, fp, 0, with_validation);
1359       else
1360         list_cert_std (ctrl, next, fp, 0, with_validation);
1361       cert = next;
1362     }
1363   ksba_cert_release (cert);
1364   es_putc ('\n', fp);
1365 }
1366
1367
1368 \f
1369 /* List all internal keys or just the keys given as NAMES.  MODE is a
1370    bit vector to specify what keys are to be included; see
1371    gpgsm_list_keys (below) for details.  If RAW_MODE is true, the raw
1372    output mode will be used instead of the standard beautified one.
1373  */
1374 static gpg_error_t
1375 list_internal_keys (ctrl_t ctrl, strlist_t names, estream_t fp,
1376                     unsigned int mode, int raw_mode)
1377 {
1378   KEYDB_HANDLE hd;
1379   KEYDB_SEARCH_DESC *desc = NULL;
1380   strlist_t sl;
1381   int ndesc;
1382   ksba_cert_t cert = NULL;
1383   ksba_cert_t lastcert = NULL;
1384   gpg_error_t rc = 0;
1385   const char *lastresname, *resname;
1386   int have_secret;
1387   int want_ephemeral = ctrl->with_ephemeral_keys;
1388
1389   hd = keydb_new ();
1390   if (!hd)
1391     {
1392       log_error ("keydb_new failed\n");
1393       rc = gpg_error (GPG_ERR_GENERAL);
1394       goto leave;
1395     }
1396
1397   if (!names)
1398     ndesc = 1;
1399   else
1400     {
1401       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++)
1402         ;
1403     }
1404
1405   desc = xtrycalloc (ndesc, sizeof *desc);
1406   if (!ndesc)
1407     {
1408       rc = gpg_error_from_syserror ();
1409       log_error ("out of core\n");
1410       goto leave;
1411     }
1412
1413   if (!names)
1414     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1415   else
1416     {
1417       for (ndesc=0, sl=names; sl; sl = sl->next)
1418         {
1419           rc = classify_user_id (sl->d, desc+ndesc, 0);
1420           if (rc)
1421             {
1422               log_error ("key '%s' not found: %s\n",
1423                          sl->d, gpg_strerror (rc));
1424               rc = 0;
1425             }
1426           else
1427             ndesc++;
1428         }
1429
1430     }
1431
1432   /* If all specifications are done by fingerprint or keygrip, we
1433      switch to ephemeral mode so that _all_ currently available and
1434      matching certificates are listed.  */
1435   if (!want_ephemeral && names && ndesc)
1436     {
1437       int i;
1438
1439       for (i=0; (i < ndesc
1440                  && (desc[i].mode == KEYDB_SEARCH_MODE_FPR
1441                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR20
1442                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR16
1443                      || desc[i].mode == KEYDB_SEARCH_MODE_KEYGRIP)); i++)
1444         ;
1445       if (i == ndesc)
1446         want_ephemeral = 1;
1447     }
1448
1449   if (want_ephemeral)
1450     keydb_set_ephemeral (hd, 1);
1451
1452   /* It would be nice to see which of the given users did actually
1453      match one in the keyring.  To implement this we need to have a
1454      found flag for each entry in desc and to set this we must check
1455      all those entries after a match to mark all matched one -
1456      currently we stop at the first match.  To do this we need an
1457      extra flag to enable this feature so */
1458
1459   /* Suppress duplicates at least when they follow each other.  */
1460   lastresname = NULL;
1461   while (!(rc = keydb_search (ctrl, hd, desc, ndesc)))
1462     {
1463       unsigned int validity;
1464
1465       if (!names)
1466         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1467
1468       rc = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &validity);
1469       if (rc)
1470         {
1471           log_error ("keydb_get_flags failed: %s\n", gpg_strerror (rc));
1472           goto leave;
1473         }
1474       rc = keydb_get_cert (hd, &cert);
1475       if (rc)
1476         {
1477           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
1478           goto leave;
1479         }
1480       /* Skip duplicated certificates, at least if they follow each
1481          others.  This works best if a single key is searched for and
1482          expected.  FIXME: Non-sequential duplicates remain.  */
1483       if (gpgsm_certs_identical_p (cert, lastcert))
1484         {
1485           ksba_cert_release (cert);
1486           cert = NULL;
1487           continue;
1488         }
1489
1490       resname = keydb_get_resource_name (hd);
1491
1492       if (lastresname != resname )
1493         {
1494           int i;
1495
1496           if (ctrl->no_server)
1497             {
1498               es_fprintf (fp, "%s\n", resname );
1499               for (i=strlen(resname); i; i-- )
1500                 es_putc ('-', fp);
1501               es_putc ('\n', fp);
1502               lastresname = resname;
1503             }
1504         }
1505
1506       have_secret = 0;
1507       if (mode)
1508         {
1509           char *p = gpgsm_get_keygrip_hexstring (cert);
1510           if (p)
1511             {
1512               rc = gpgsm_agent_havekey (ctrl, p);
1513               if (!rc)
1514                 have_secret = 1;
1515               else if ( gpg_err_code (rc) != GPG_ERR_NO_SECKEY)
1516                 goto leave;
1517               rc = 0;
1518               xfree (p);
1519             }
1520         }
1521
1522       if (!mode          || ((mode & 1) && !have_secret)
1523           || ((mode & 2) && have_secret)  )
1524         {
1525           if (ctrl->with_colons)
1526             list_cert_colon (ctrl, cert, validity, fp, have_secret);
1527           else if (ctrl->with_chain)
1528             list_cert_chain (ctrl, hd, cert,
1529                              raw_mode, fp, ctrl->with_validation);
1530           else
1531             {
1532               if (raw_mode)
1533                 list_cert_raw (ctrl, hd, cert, fp, have_secret,
1534                                ctrl->with_validation);
1535               else
1536                 list_cert_std (ctrl, cert, fp, have_secret,
1537                                ctrl->with_validation);
1538               es_putc ('\n', fp);
1539             }
1540         }
1541
1542       ksba_cert_release (lastcert);
1543       lastcert = cert;
1544       cert = NULL;
1545     }
1546   if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1 )
1547     rc = 0;
1548   if (rc)
1549     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
1550
1551  leave:
1552   ksba_cert_release (cert);
1553   ksba_cert_release (lastcert);
1554   xfree (desc);
1555   keydb_release (hd);
1556   return rc;
1557 }
1558
1559
1560
1561 static void
1562 list_external_cb (void *cb_value, ksba_cert_t cert)
1563 {
1564   struct list_external_parm_s *parm = cb_value;
1565
1566   if (keydb_store_cert (parm->ctrl, cert, 1, NULL))
1567     log_error ("error storing certificate as ephemeral\n");
1568
1569   if (parm->print_header)
1570     {
1571       const char *resname = "[external keys]";
1572       int i;
1573
1574       es_fprintf (parm->fp, "%s\n", resname );
1575       for (i=strlen(resname); i; i-- )
1576         es_putc('-', parm->fp);
1577       es_putc ('\n', parm->fp);
1578       parm->print_header = 0;
1579     }
1580
1581   if (parm->with_colons)
1582     list_cert_colon (parm->ctrl, cert, 0, parm->fp, 0);
1583   else if (parm->with_chain)
1584     list_cert_chain (parm->ctrl, NULL, cert, parm->raw_mode, parm->fp, 0);
1585   else
1586     {
1587       if (parm->raw_mode)
1588         list_cert_raw (parm->ctrl, NULL, cert, parm->fp, 0, 0);
1589       else
1590         list_cert_std (parm->ctrl, cert, parm->fp, 0, 0);
1591       es_putc ('\n', parm->fp);
1592     }
1593 }
1594
1595
1596 /* List external keys similar to internal one.  Note: mode does not
1597    make sense here because it would be unwise to list external secret
1598    keys */
1599 static gpg_error_t
1600 list_external_keys (ctrl_t ctrl, strlist_t names, estream_t fp, int raw_mode)
1601 {
1602   int rc;
1603   struct list_external_parm_s parm;
1604
1605   parm.fp = fp;
1606   parm.ctrl = ctrl,
1607   parm.print_header = ctrl->no_server;
1608   parm.with_colons = ctrl->with_colons;
1609   parm.with_chain = ctrl->with_chain;
1610   parm.raw_mode  = raw_mode;
1611
1612   rc = gpgsm_dirmngr_lookup (ctrl, names, 0, list_external_cb, &parm);
1613   if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1
1614       || gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1615     rc = 0; /* "Not found" is not an error here. */
1616   if (rc)
1617     log_error ("listing external keys failed: %s\n", gpg_strerror (rc));
1618   return rc;
1619 }
1620
1621 /* List all keys or just the key given as NAMES.
1622    MODE controls the operation mode:
1623     Bit 0-2:
1624       0 = list all public keys but don't flag secret ones
1625       1 = list only public keys
1626       2 = list only secret keys
1627       3 = list secret and public keys
1628     Bit 6: list internal keys
1629     Bit 7: list external keys
1630     Bit 8: Do a raw format dump.
1631  */
1632 gpg_error_t
1633 gpgsm_list_keys (ctrl_t ctrl, strlist_t names, estream_t fp,
1634                  unsigned int mode)
1635 {
1636   gpg_error_t err = 0;
1637
1638   if ((mode & (1<<6)))
1639     err = list_internal_keys (ctrl, names, fp, (mode & 3), (mode&256));
1640   if (!err && (mode & (1<<7)))
1641     err = list_external_keys (ctrl, names, fp, (mode&256));
1642   return err;
1643 }