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