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.
5 * This file is part of GnuPG.
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.
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.
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/>.
36 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
40 struct list_external_parm_s
51 /* This table is to map Extended Key Usage OIDs to human readable
57 } key_purpose_map[] = {
58 { "1.3.6.1.5.5.7.3.1", "serverAuth" },
59 { "1.3.6.1.5.5.7.3.2", "clientAuth" },
60 { "1.3.6.1.5.5.7.3.3", "codeSigning" },
61 { "1.3.6.1.5.5.7.3.4", "emailProtection" },
62 { "1.3.6.1.5.5.7.3.5", "ipsecEndSystem" },
63 { "1.3.6.1.5.5.7.3.6", "ipsecTunnel" },
64 { "1.3.6.1.5.5.7.3.7", "ipsecUser" },
65 { "1.3.6.1.5.5.7.3.8", "timeStamping" },
66 { "1.3.6.1.5.5.7.3.9", "ocspSigning" },
67 { "1.3.6.1.5.5.7.3.10", "dvcs" },
68 { "1.3.6.1.5.5.7.3.11", "sbgpCertAAServerAuth" },
69 { "1.3.6.1.5.5.7.3.13", "eapOverPPP" },
70 { "1.3.6.1.5.5.7.3.14", "wlanSSID" },
72 { "2.16.840.1.113730.4.1", "serverGatedCrypto.ns" }, /* Netscape. */
73 { "1.3.6.1.4.1.311.10.3.3", "serverGatedCrypto.ms"}, /* Microsoft. */
75 { "1.3.6.1.5.5.7.48.1.5", "ocspNoCheck" },
81 /* Do not print this extension in the list of extensions. This is set
82 for oids which are already available via ksba fucntions. */
83 #define OID_FLAG_SKIP 1
84 /* The extension is a simple UTF8String and should be printed. */
85 #define OID_FLAG_UTF8 2
87 /* A table mapping OIDs to a descriptive string. */
92 unsigned int flag; /* A flag as described above. */
96 { "1.2.840.10040.4.1", "dsa" },
97 { "1.2.840.10040.4.3", "dsaWithSha1" },
99 { "1.2.840.113549.1.1.1", "rsaEncryption" },
100 { "1.2.840.113549.1.1.2", "md2WithRSAEncryption" },
101 { "1.2.840.113549.1.1.3", "md4WithRSAEncryption" },
102 { "1.2.840.113549.1.1.4", "md5WithRSAEncryption" },
103 { "1.2.840.113549.1.1.5", "sha1WithRSAEncryption" },
104 { "1.2.840.113549.1.1.7", "rsaOAEP" },
105 { "1.2.840.113549.1.1.8", "rsaOAEP-MGF" },
106 { "1.2.840.113549.1.1.9", "rsaOAEP-pSpecified" },
107 { "1.2.840.113549.1.1.10", "rsaPSS" },
108 { "1.2.840.113549.1.1.11", "sha256WithRSAEncryption" },
109 { "1.2.840.113549.1.1.12", "sha384WithRSAEncryption" },
110 { "1.2.840.113549.1.1.13", "sha512WithRSAEncryption" },
112 { "1.3.14.3.2.26", "sha1" },
113 { "1.3.14.3.2.29", "sha-1WithRSAEncryption" },
114 { "1.3.36.3.3.1.2", "rsaSignatureWithripemd160" },
117 /* Telesec extensions. */
118 { "0.2.262.1.10.12.0", "certExtensionLiabilityLimitationExt" },
119 { "0.2.262.1.10.12.1", "telesecCertIdExt" },
120 { "0.2.262.1.10.12.2", "telesecPolicyIdentifier" },
121 { "0.2.262.1.10.12.3", "telesecPolicyQualifierID" },
122 { "0.2.262.1.10.12.4", "telesecCRLFilteredExt" },
123 { "0.2.262.1.10.12.5", "telesecCRLFilterExt"},
124 { "0.2.262.1.10.12.6", "telesecNamingAuthorityExt" },
125 #define OIDSTR_restriction \
127 { OIDSTR_restriction, "restriction", OID_FLAG_UTF8 },
130 /* PKIX private extensions. */
131 { "1.3.6.1.5.5.7.1.1", "authorityInfoAccess" },
132 { "1.3.6.1.5.5.7.1.2", "biometricInfo" },
133 { "1.3.6.1.5.5.7.1.3", "qcStatements" },
134 { "1.3.6.1.5.5.7.1.4", "acAuditIdentity" },
135 { "1.3.6.1.5.5.7.1.5", "acTargeting" },
136 { "1.3.6.1.5.5.7.1.6", "acAaControls" },
137 { "1.3.6.1.5.5.7.1.7", "sbgp-ipAddrBlock" },
138 { "1.3.6.1.5.5.7.1.8", "sbgp-autonomousSysNum" },
139 { "1.3.6.1.5.5.7.1.9", "sbgp-routerIdentifier" },
140 { "1.3.6.1.5.5.7.1.10", "acProxying" },
141 { "1.3.6.1.5.5.7.1.11", "subjectInfoAccess" },
143 { "1.3.6.1.5.5.7.48.1", "ocsp" },
144 { "1.3.6.1.5.5.7.48.2", "caIssuers" },
145 { "1.3.6.1.5.5.7.48.3", "timeStamping" },
146 { "1.3.6.1.5.5.7.48.5", "caRepository" },
149 { "2.5.29.14", "subjectKeyIdentifier", OID_FLAG_SKIP},
150 { "2.5.29.15", "keyUsage", OID_FLAG_SKIP},
151 { "2.5.29.16", "privateKeyUsagePeriod" },
152 { "2.5.29.17", "subjectAltName", OID_FLAG_SKIP},
153 { "2.5.29.18", "issuerAltName", OID_FLAG_SKIP},
154 { "2.5.29.19", "basicConstraints", OID_FLAG_SKIP},
155 { "2.5.29.20", "cRLNumber" },
156 { "2.5.29.21", "cRLReason" },
157 { "2.5.29.22", "expirationDate" },
158 { "2.5.29.23", "instructionCode" },
159 { "2.5.29.24", "invalidityDate" },
160 { "2.5.29.27", "deltaCRLIndicator" },
161 { "2.5.29.28", "issuingDistributionPoint" },
162 { "2.5.29.29", "certificateIssuer" },
163 { "2.5.29.30", "nameConstraints" },
164 { "2.5.29.31", "cRLDistributionPoints", OID_FLAG_SKIP},
165 { "2.5.29.32", "certificatePolicies", OID_FLAG_SKIP},
166 { "2.5.29.32.0", "anyPolicy" },
167 { "2.5.29.33", "policyMappings" },
168 { "2.5.29.35", "authorityKeyIdentifier", OID_FLAG_SKIP},
169 { "2.5.29.36", "policyConstraints" },
170 { "2.5.29.37", "extKeyUsage", OID_FLAG_SKIP},
171 { "2.5.29.46", "freshestCRL" },
172 { "2.5.29.54", "inhibitAnyPolicy" },
174 /* Netscape certificate extensions. */
175 { "2.16.840.1.113730.1.1", "netscape-cert-type" },
176 { "2.16.840.1.113730.1.2", "netscape-base-url" },
177 { "2.16.840.1.113730.1.3", "netscape-revocation-url" },
178 { "2.16.840.1.113730.1.4", "netscape-ca-revocation-url" },
179 { "2.16.840.1.113730.1.7", "netscape-cert-renewal-url" },
180 { "2.16.840.1.113730.1.8", "netscape-ca-policy-url" },
181 { "2.16.840.1.113730.1.9", "netscape-homePage-url" },
182 { "2.16.840.1.113730.1.10", "netscape-entitylogo" },
183 { "2.16.840.1.113730.1.11", "netscape-userPicture" },
184 { "2.16.840.1.113730.1.12", "netscape-ssl-server-name" },
185 { "2.16.840.1.113730.1.13", "netscape-comment" },
187 /* GnuPG extensions */
188 { "1.3.6.1.4.1.11591.2.1.1", "pkaAddress" },
189 { "1.3.6.1.4.1.11591.2.2.1", "standaloneCertificate" },
190 { "1.3.6.1.4.1.11591.2.2.2", "wellKnownPrivateKey" },
192 /* Extensions used by the Bundesnetzagentur. */
193 { "1.3.6.1.4.1.8301.3.5", "validityModel" },
199 /* Return the description for OID; if no description is available
202 get_oid_desc (const char *oid, unsigned int *flag)
207 for (i=0; oidtranstbl[i].oid; i++)
208 if (!strcmp (oidtranstbl[i].oid, oid))
211 *flag = oidtranstbl[i].flag;
212 return oidtranstbl[i].name;
221 print_key_data (ksba_cert_t cert, estream_t fp)
224 int n = pk ? pubkey_get_npkey( pk->pubkey_algo ) : 0;
227 for(i=0; i < n; i++ )
229 es_fprintf (fp, "pkd:%d:%u:", i, mpi_get_nbits( pk->pkey[i] ) );
230 mpi_print(stdout, pk->pkey[i], 1 );
241 print_capabilities (ksba_cert_t cert, estream_t fp)
248 err = ksba_cert_get_user_data (cert, "is_qualified",
249 &buffer, sizeof (buffer), &buflen);
255 else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
256 ; /* Don't know - will not get marked as 'q' */
258 log_debug ("get_user_data(is_qualified) failed: %s\n",
261 err = ksba_cert_get_key_usage (cert, &use);
262 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
274 log_error (_("error getting key usage information: %s\n"),
279 if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
281 if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
283 if ((use & KSBA_KEYUSAGE_KEY_CERT_SIGN))
285 if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
287 if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
289 if ((use & KSBA_KEYUSAGE_KEY_CERT_SIGN))
297 print_time (gnupg_isotime_t t, estream_t fp)
306 /* Return an allocated string with the email address extracted from a
307 DN. Note hat we use this code also in ../kbx/keybox-blob.c. */
309 email_kludge (const char *name)
311 const char *p, *string;
318 p = strstr (string, "1.2.840.113549.1.9.1=#");
321 if (p == name || (p > string+1 && p[-1] == ',' && p[-2] != '\\'))
330 /* This looks pretty much like an email address in the subject's DN
331 we use this to add an additional user ID entry. This way,
332 OpenSSL generated keys get a nicer and usable listing. */
333 for (n=0, p=name; hexdigitp (p) && hexdigitp (p+1); p +=2, n++)
337 buf = xtrymalloc (n+3);
339 return NULL; /* oops, out of core */
341 for (n=1, p=name; hexdigitp (p); p +=2, n++)
351 /* List one certificate in colon mode */
353 list_cert_colon (ctrl_t ctrl, ksba_cert_t cert, unsigned int validity,
354 estream_t fp, int have_secret)
366 const char *chain_id;
367 char *chain_id_buffer = NULL;
371 if (ctrl->with_validation)
372 valerr = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, NULL, 0, NULL);
377 /* We need to get the fingerprint and the chaining ID in advance. */
378 fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
382 rc = gpgsm_walk_cert_chain (ctrl, cert, &next);
383 if (!rc) /* We known the issuer's certificate. */
385 p = gpgsm_get_fingerprint_hexstring (next, GCRY_MD_SHA1);
387 chain_id = chain_id_buffer;
388 ksba_cert_release (next);
390 else if (rc == -1) /* We have reached the root certificate. */
400 es_fputs (have_secret? "crs:":"crt:", fp);
402 /* Note: We can't use multiple flags, like "ei", because the
403 validation check does only return one error. */
406 if ((validity & VALIDITY_REVOKED)
407 || gpg_err_code (valerr) == GPG_ERR_CERT_REVOKED)
409 else if (gpg_err_code (valerr) == GPG_ERR_CERT_EXPIRED)
413 /* Lets also check whether the certificate under question
414 expired. This is merely a hack until we found a proper way
415 to store the expiration flag in the keybox. */
416 ksba_isotime_t current_time, not_after;
418 gnupg_get_isotime (current_time);
419 if (!opt.ignore_expiration
420 && !ksba_cert_get_validity (cert, 1, not_after)
421 && *not_after && strcmp (current_time, not_after) > 0 )
425 if (gpgsm_cert_has_well_known_private_key (cert))
426 *truststring = 'w'; /* Well, this is dummy CA. */
430 else if (ctrl->with_validation && !is_root)
434 /* If we have no truststring yet (i.e. the certificate might be
435 good) and this is a root certificate, we ask the agent whether
436 this is a trusted root certificate. */
437 if (!*truststring && is_root)
439 struct rootca_flags_s dummy_flags;
441 if (gpgsm_cert_has_well_known_private_key (cert))
442 *truststring = 'w'; /* Well, this is dummy CA. */
445 rc = gpgsm_agent_istrusted (ctrl, cert, NULL, &dummy_flags);
447 *truststring = 'u'; /* Yes, we trust this one (ultimately). */
448 else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
449 *truststring = 'n'; /* No, we do not trust this one. */
450 /* (in case of an error we can't tell anything.) */
455 es_fputs (truststring, fp);
457 algo = gpgsm_get_key_algo_info (cert, &nbits);
458 es_fprintf (fp, ":%u:%d:%s:", nbits, algo, fpr+24);
460 ksba_cert_get_validity (cert, 0, t);
463 ksba_cert_get_validity (cert, 1, t);
466 /* Field 8, serial number: */
467 if ((sexp = ksba_cert_get_serial (cert)))
470 const unsigned char *s = sexp;
475 for (len=0; *s && *s != ':' && digitp (s); s++)
476 len = len*10 + atoi_1 (s);
478 for (s++; len; len--, s++)
479 es_fprintf (fp,"%02X", *s);
484 /* Field 9, ownertrust - not used here */
486 /* field 10, old user ID - we use it here for the issuer DN */
487 if ((p = ksba_cert_get_issuer (cert,0)))
489 es_write_sanitized (fp, p, strlen (p), ":", NULL);
493 /* Field 11, signature class - not used */
495 /* Field 12, capabilities: */
496 print_capabilities (cert, fp);
497 /* Field 13, not used: */
499 if (have_secret || ctrl->with_secret)
503 p = gpgsm_get_keygrip_hexstring (cert);
504 if (!gpgsm_agent_keyinfo (ctrl, p, &cardsn)
505 && (cardsn || ctrl->with_secret))
507 /* Field 14, not used: */
509 /* Field 15: Token serial number or secret key indicator. */
511 es_fputs (cardsn, fp);
512 else if (ctrl->with_secret)
522 es_fprintf (fp, "fpr:::::::::%s:::", fpr);
523 /* Print chaining ID (field 13)*/
525 es_fputs (chain_id, fp);
528 xfree (fpr); fpr = NULL; chain_id = NULL;
529 xfree (chain_id_buffer); chain_id_buffer = NULL;
531 if (opt.with_key_data)
533 if ( (p = gpgsm_get_keygrip_hexstring (cert)))
535 es_fprintf (fp, "grp:::::::::%s:\n", p);
538 print_key_data (cert, fp);
542 for (idx=0; (p = ksba_cert_get_subject (cert,idx)); idx++)
544 /* In the case that the same email address is in the subject DN
545 as well as in an alternate subject name we avoid printing it
547 if (kludge_uid && !strcmp (kludge_uid, p))
550 es_fprintf (fp, "uid:%s::::::::", truststring);
551 es_write_sanitized (fp, p, strlen (p), ":", NULL);
557 /* It would be better to get the faked email address from
558 the keydb. But as long as we don't have a way to pass
559 the meta data back, we just check it the same way as the
560 code used to create the keybox meta data does */
561 kludge_uid = email_kludge (p);
564 es_fprintf (fp, "uid:%s::::::::", truststring);
565 es_write_sanitized (fp, kludge_uid, strlen (kludge_uid),
579 print_name_raw (estream_t fp, const char *string)
582 es_fputs ("[error]", fp);
584 es_write_sanitized (fp, string, strlen (string), NULL, NULL);
588 print_names_raw (estream_t fp, int indent, ksba_name_t name)
594 if ((indent_all = (indent < 0)))
599 es_fputs ("none\n", fp);
603 for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
605 char *p = ksba_name_get_uri (name, idx);
606 es_fprintf (fp, "%*s", idx||indent_all?indent:0, "");
607 es_write_sanitized (fp, p?p:s, strlen (p?p:s), NULL, NULL);
615 print_utf8_extn_raw (estream_t fp, int indent,
616 const unsigned char *der, size_t derlen)
619 int class, tag, constructed, ndef;
620 size_t objlen, hdrlen;
625 err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
626 &ndef, &objlen, &hdrlen);
627 if (!err && (objlen > derlen || tag != TAG_UTF8_STRING))
628 err = gpg_error (GPG_ERR_INV_OBJ);
631 es_fprintf (fp, "%*s[%s]\n", indent, "", gpg_strerror (err));
634 es_fprintf (fp, "%*s(%.*s)\n", indent, "", (int)objlen, der);
639 print_utf8_extn (estream_t fp, int indent,
640 const unsigned char *der, size_t derlen)
643 int class, tag, constructed, ndef;
644 size_t objlen, hdrlen;
647 if ((indent_all = (indent < 0)))
650 err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
651 &ndef, &objlen, &hdrlen);
652 if (!err && (objlen > derlen || tag != TAG_UTF8_STRING))
653 err = gpg_error (GPG_ERR_INV_OBJ);
656 es_fprintf (fp, "%*s[%s%s]\n",
657 indent_all? indent:0, "", _("Error - "), gpg_strerror (err));
660 es_fprintf (fp, "%*s\"", indent_all? indent:0, "");
661 /* Fixme: we should implement word wrapping */
662 es_write_sanitized (fp, der, objlen, "\"", NULL);
663 es_fputs ("\"\n", fp);
667 /* List one certificate in raw mode useful to have a closer look at
668 the certificate. This one does no beautification and only minimal
669 output sanitation. It is mainly useful for debugging. */
671 list_cert_raw (ctrl_t ctrl, KEYDB_HANDLE hd,
672 ksba_cert_t cert, estream_t fp, int have_secret,
677 ksba_sexp_t sexp, keyid;
683 char *string, *p, *pend;
685 ksba_name_t name, name2;
687 const unsigned char *cert_der = NULL;
691 es_fprintf (fp, " ID: 0x%08lX\n",
692 gpgsm_get_short_fingerprint (cert, NULL));
694 sexp = ksba_cert_get_serial (cert);
695 es_fputs (" S/N: ", fp);
696 gpgsm_print_serial (fp, sexp);
700 dn = ksba_cert_get_issuer (cert, 0);
701 es_fputs (" Issuer: ", fp);
702 print_name_raw (fp, dn);
705 for (idx=1; (dn = ksba_cert_get_issuer (cert, idx)); idx++)
707 es_fputs (" aka: ", fp);
708 print_name_raw (fp, dn);
713 dn = ksba_cert_get_subject (cert, 0);
714 es_fputs (" Subject: ", fp);
715 print_name_raw (fp, dn);
718 for (idx=1; (dn = ksba_cert_get_subject (cert, idx)); idx++)
720 es_fputs (" aka: ", fp);
721 print_name_raw (fp, dn);
726 dn = gpgsm_get_fingerprint_string (cert, 0);
727 es_fprintf (fp, " sha1_fpr: %s\n", dn?dn:"error");
730 dn = gpgsm_get_fingerprint_string (cert, GCRY_MD_MD5);
731 es_fprintf (fp, " md5_fpr: %s\n", dn?dn:"error");
734 dn = gpgsm_get_certid (cert);
735 es_fprintf (fp, " certid: %s\n", dn?dn:"error");
738 dn = gpgsm_get_keygrip_hexstring (cert);
739 es_fprintf (fp, " keygrip: %s\n", dn?dn:"error");
742 ksba_cert_get_validity (cert, 0, t);
743 es_fputs (" notBefore: ", fp);
744 gpgsm_print_time (fp, t);
746 es_fputs (" notAfter: ", fp);
747 ksba_cert_get_validity (cert, 1, t);
748 gpgsm_print_time (fp, t);
751 oid = ksba_cert_get_digest_algo (cert);
752 s = get_oid_desc (oid, NULL);
753 es_fprintf (fp, " hashAlgo: %s%s%s%s\n", oid, s?" (":"",s?s:"",s?")":"");
756 const char *algoname;
759 algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
760 es_fprintf (fp, " keyType: %u bit %s\n",
761 nbits, algoname? algoname:"?");
764 /* subjectKeyIdentifier */
765 es_fputs (" subjKeyId: ", fp);
766 err = ksba_cert_get_subj_key_id (cert, NULL, &keyid);
767 if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
769 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
770 es_fputs ("[none]\n", fp);
773 gpgsm_print_serial (fp, keyid);
779 es_fputs ("[?]\n", fp);
782 /* authorityKeyIdentifier */
783 es_fputs (" authKeyId: ", fp);
784 err = ksba_cert_get_auth_key_id (cert, &keyid, &name, &sexp);
785 if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
787 if (gpg_err_code (err) == GPG_ERR_NO_DATA || !name)
788 es_fputs ("[none]\n", fp);
791 gpgsm_print_serial (fp, sexp);
794 print_names_raw (fp, -15, name);
795 ksba_name_release (name);
799 es_fputs (" authKeyId.ki: ", fp);
800 gpgsm_print_serial (fp, keyid);
806 es_fputs ("[?]\n", fp);
808 es_fputs (" keyUsage:", fp);
809 err = ksba_cert_get_key_usage (cert, &kusage);
810 if (gpg_err_code (err) != GPG_ERR_NO_DATA)
813 es_fprintf (fp, " [error: %s]", gpg_strerror (err));
816 if ( (kusage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
817 es_fputs (" digitalSignature", fp);
818 if ( (kusage & KSBA_KEYUSAGE_NON_REPUDIATION))
819 es_fputs (" nonRepudiation", fp);
820 if ( (kusage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT))
821 es_fputs (" keyEncipherment", fp);
822 if ( (kusage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
823 es_fputs (" dataEncipherment", fp);
824 if ( (kusage & KSBA_KEYUSAGE_KEY_AGREEMENT))
825 es_fputs (" keyAgreement", fp);
826 if ( (kusage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
827 es_fputs (" certSign", fp);
828 if ( (kusage & KSBA_KEYUSAGE_CRL_SIGN))
829 es_fputs (" crlSign", fp);
830 if ( (kusage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
831 es_fputs (" encipherOnly", fp);
832 if ( (kusage & KSBA_KEYUSAGE_DECIPHER_ONLY))
833 es_fputs (" decipherOnly", fp);
838 es_fputs (" [none]\n", fp);
840 es_fputs (" extKeyUsage: ", fp);
841 err = ksba_cert_get_ext_key_usages (cert, &string);
842 if (gpg_err_code (err) != GPG_ERR_NO_DATA)
845 es_fprintf (fp, "[error: %s]", gpg_strerror (err));
849 while (p && (pend=strchr (p, ':')))
852 for (i=0; key_purpose_map[i].oid; i++)
853 if ( !strcmp (key_purpose_map[i].oid, p) )
855 es_fputs (key_purpose_map[i].oid?key_purpose_map[i].name:p, fp);
858 es_fputs (" (suggested)", fp);
859 if ((p = strchr (p, '\n')))
862 es_fputs ("\n ", fp);
870 es_fputs ("[none]\n", fp);
873 es_fputs (" policies: ", fp);
874 err = ksba_cert_get_cert_policies (cert, &string);
875 if (gpg_err_code (err) != GPG_ERR_NO_DATA)
878 es_fprintf (fp, "[error: %s]", gpg_strerror (err));
882 while (p && (pend=strchr (p, ':')))
885 for (i=0; key_purpose_map[i].oid; i++)
886 if ( !strcmp (key_purpose_map[i].oid, p) )
891 es_fputs (" (critical)", fp);
892 if ((p = strchr (p, '\n')))
895 es_fputs ("\n ", fp);
903 es_fputs ("[none]\n", fp);
905 es_fputs (" chainLength: ", fp);
906 err = ksba_cert_is_ca (cert, &is_ca, &chainlen);
909 if (gpg_err_code (err) == GPG_ERR_NO_VALUE )
910 es_fprintf (fp, "[none]");
912 es_fprintf (fp, "[error: %s]", gpg_strerror (err));
913 else if (chainlen == -1)
914 es_fputs ("unlimited", fp);
916 es_fprintf (fp, "%d", chainlen);
920 es_fputs ("not a CA\n", fp);
923 /* CRL distribution point */
924 for (idx=0; !(err=ksba_cert_get_crl_dist_point (cert, idx, &name, &name2,
927 es_fputs (" crlDP: ", fp);
928 print_names_raw (fp, 15, name);
931 es_fputs (" reason: ", fp);
932 if ( (reason & KSBA_CRLREASON_UNSPECIFIED))
933 es_fputs (" unused", fp);
934 if ( (reason & KSBA_CRLREASON_KEY_COMPROMISE))
935 es_fputs (" keyCompromise", fp);
936 if ( (reason & KSBA_CRLREASON_CA_COMPROMISE))
937 es_fputs (" caCompromise", fp);
938 if ( (reason & KSBA_CRLREASON_AFFILIATION_CHANGED))
939 es_fputs (" affiliationChanged", fp);
940 if ( (reason & KSBA_CRLREASON_SUPERSEDED))
941 es_fputs (" superseded", fp);
942 if ( (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION))
943 es_fputs (" cessationOfOperation", fp);
944 if ( (reason & KSBA_CRLREASON_CERTIFICATE_HOLD))
945 es_fputs (" certificateHold", fp);
948 es_fputs (" issuer: ", fp);
949 print_names_raw (fp, 23, name2);
950 ksba_name_release (name);
951 ksba_name_release (name2);
953 if (err && gpg_err_code (err) != GPG_ERR_EOF
954 && gpg_err_code (err) != GPG_ERR_NO_VALUE)
955 es_fputs (" crlDP: [error]\n", fp);
957 es_fputs (" crlDP: [none]\n", fp);
960 /* authorityInfoAccess. */
961 for (idx=0; !(err=ksba_cert_get_authority_info_access (cert, idx, &string,
964 es_fputs (" authInfo: ", fp);
965 s = get_oid_desc (string, NULL);
966 es_fprintf (fp, "%s%s%s%s\n", string, s?" (":"", s?s:"", s?")":"");
967 print_names_raw (fp, -15, name);
968 ksba_name_release (name);
971 if (err && gpg_err_code (err) != GPG_ERR_EOF
972 && gpg_err_code (err) != GPG_ERR_NO_VALUE)
973 es_fputs (" authInfo: [error]\n", fp);
975 es_fputs (" authInfo: [none]\n", fp);
977 /* subjectInfoAccess. */
978 for (idx=0; !(err=ksba_cert_get_subject_info_access (cert, idx, &string,
981 es_fputs (" subjectInfo: ", fp);
982 s = get_oid_desc (string, NULL);
983 es_fprintf (fp, "%s%s%s%s\n", string, s?" (":"", s?s:"", s?")":"");
984 print_names_raw (fp, -15, name);
985 ksba_name_release (name);
988 if (err && gpg_err_code (err) != GPG_ERR_EOF
989 && gpg_err_code (err) != GPG_ERR_NO_VALUE)
990 es_fputs (" subjInfo: [error]\n", fp);
992 es_fputs (" subjInfo: [none]\n", fp);
995 for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
996 &oid, &i, &off, &len));idx++)
1000 s = get_oid_desc (oid, &flag);
1001 if ((flag & OID_FLAG_SKIP))
1004 es_fprintf (fp, " %s: %s%s%s%s [%d octets]\n",
1005 i? "critExtn":" extn",
1006 oid, s?" (":"", s?s:"", s?")":"", (int)len);
1007 if ((flag & OID_FLAG_UTF8))
1010 cert_der = ksba_cert_get_image (cert, NULL);
1012 print_utf8_extn_raw (fp, -15, cert_der+off, len);
1017 if (with_validation)
1019 err = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, fp, 0, NULL);
1021 es_fprintf (fp, " [certificate is good]\n");
1023 es_fprintf (fp, " [certificate is bad: %s]\n", gpg_strerror (err));
1028 unsigned int blobflags;
1030 err = keydb_get_flags (hd, KEYBOX_FLAG_BLOB, 0, &blobflags);
1032 es_fprintf (fp, " [error getting keyflags: %s]\n",gpg_strerror (err));
1033 else if ((blobflags & KEYBOX_FLAG_BLOB_EPHEMERAL))
1034 es_fprintf (fp, " [stored as ephemeral]\n");
1042 /* List one certificate in standard mode */
1044 list_cert_std (ctrl_t ctrl, ksba_cert_t cert, estream_t fp, int have_secret,
1045 int with_validation)
1052 int is_ca, chainlen;
1053 unsigned int kusage;
1054 char *string, *p, *pend;
1057 const unsigned char *cert_der = NULL;
1060 es_fprintf (fp, " ID: 0x%08lX\n",
1061 gpgsm_get_short_fingerprint (cert, NULL));
1063 sexp = ksba_cert_get_serial (cert);
1064 es_fputs (" S/N: ", fp);
1065 gpgsm_print_serial (fp, sexp);
1069 dn = ksba_cert_get_issuer (cert, 0);
1070 es_fputs (" Issuer: ", fp);
1071 gpgsm_es_print_name (fp, dn);
1074 for (idx=1; (dn = ksba_cert_get_issuer (cert, idx)); idx++)
1076 es_fputs (" aka: ", fp);
1077 gpgsm_es_print_name (fp, dn);
1082 dn = ksba_cert_get_subject (cert, 0);
1083 es_fputs (" Subject: ", fp);
1084 gpgsm_es_print_name (fp, dn);
1087 for (idx=1; (dn = ksba_cert_get_subject (cert, idx)); idx++)
1089 es_fputs (" aka: ", fp);
1090 gpgsm_es_print_name (fp, dn);
1095 ksba_cert_get_validity (cert, 0, t);
1096 es_fputs (" validity: ", fp);
1097 gpgsm_print_time (fp, t);
1098 es_fputs (" through ", fp);
1099 ksba_cert_get_validity (cert, 1, t);
1100 gpgsm_print_time (fp, t);
1105 const char *algoname;
1108 algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
1109 es_fprintf (fp, " key type: %u bit %s\n",
1110 nbits, algoname? algoname:"?");
1114 err = ksba_cert_get_key_usage (cert, &kusage);
1115 if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1117 es_fputs (" key usage:", fp);
1119 es_fprintf (fp, " [error: %s]", gpg_strerror (err));
1122 if ( (kusage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
1123 es_fputs (" digitalSignature", fp);
1124 if ( (kusage & KSBA_KEYUSAGE_NON_REPUDIATION))
1125 es_fputs (" nonRepudiation", fp);
1126 if ( (kusage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT))
1127 es_fputs (" keyEncipherment", fp);
1128 if ( (kusage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
1129 es_fputs (" dataEncipherment", fp);
1130 if ( (kusage & KSBA_KEYUSAGE_KEY_AGREEMENT))
1131 es_fputs (" keyAgreement", fp);
1132 if ( (kusage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
1133 es_fputs (" certSign", fp);
1134 if ( (kusage & KSBA_KEYUSAGE_CRL_SIGN))
1135 es_fputs (" crlSign", fp);
1136 if ( (kusage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
1137 es_fputs (" encipherOnly", fp);
1138 if ( (kusage & KSBA_KEYUSAGE_DECIPHER_ONLY))
1139 es_fputs (" decipherOnly", fp);
1144 err = ksba_cert_get_ext_key_usages (cert, &string);
1145 if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1147 es_fputs ("ext key usage: ", fp);
1149 es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1153 while (p && (pend=strchr (p, ':')))
1156 for (i=0; key_purpose_map[i].oid; i++)
1157 if ( !strcmp (key_purpose_map[i].oid, p) )
1159 es_fputs (key_purpose_map[i].oid?key_purpose_map[i].name:p, fp);
1162 es_fputs (" (suggested)", fp);
1163 if ((p = strchr (p, '\n')))
1166 es_fputs (", ", fp);
1174 /* Print restrictions. */
1175 for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
1176 &oid, NULL, &off, &len));idx++)
1178 if (!strcmp (oid, OIDSTR_restriction) )
1181 cert_der = ksba_cert_get_image (cert, NULL);
1183 es_fputs (" restriction: ", fp);
1184 print_utf8_extn (fp, 15, cert_der+off, len);
1188 /* Print policies. */
1189 err = ksba_cert_get_cert_policies (cert, &string);
1190 if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1192 es_fputs (" policies: ", fp);
1194 es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1197 for (p=string; *p; p++)
1202 es_write_sanitized (fp, string, strlen (string), NULL, NULL);
1208 err = ksba_cert_is_ca (cert, &is_ca, &chainlen);
1211 es_fputs (" chain length: ", fp);
1212 if (gpg_err_code (err) == GPG_ERR_NO_VALUE )
1213 es_fprintf (fp, "none");
1215 es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1216 else if (chainlen == -1)
1217 es_fputs ("unlimited", fp);
1219 es_fprintf (fp, "%d", chainlen);
1223 if (opt.with_md5_fingerprint)
1225 dn = gpgsm_get_fingerprint_string (cert, GCRY_MD_MD5);
1226 es_fprintf (fp, " md5 fpr: %s\n", dn?dn:"error");
1230 dn = gpgsm_get_fingerprint_string (cert, 0);
1231 es_fprintf (fp, " fingerprint: %s\n", dn?dn:"error");
1234 if (opt.with_keygrip)
1236 dn = gpgsm_get_keygrip_hexstring (cert);
1239 es_fprintf (fp, " keygrip: %s\n", dn);
1248 p = gpgsm_get_keygrip_hexstring (cert);
1249 if (!gpgsm_agent_keyinfo (ctrl, p, &cardsn) && cardsn)
1250 es_fprintf (fp, " card s/n: %s\n", cardsn);
1255 if (with_validation)
1261 err = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, fp, 0, NULL);
1262 tmperr = ksba_cert_get_user_data (cert, "is_qualified",
1263 &buffer, sizeof (buffer), &buflen);
1264 if (!tmperr && buflen)
1267 es_fputs (" [qualified]\n", fp);
1269 else if (gpg_err_code (tmperr) == GPG_ERR_NOT_FOUND)
1270 ; /* Don't know - will not get marked as 'q' */
1272 log_debug ("get_user_data(is_qualified) failed: %s\n",
1273 gpg_strerror (tmperr));
1276 es_fprintf (fp, " [certificate is good]\n");
1278 es_fprintf (fp, " [certificate is bad: %s]\n", gpg_strerror (err));
1283 /* Same as standard mode mode list all certifying certs too. */
1285 list_cert_chain (ctrl_t ctrl, KEYDB_HANDLE hd,
1286 ksba_cert_t cert, int raw_mode,
1287 estream_t fp, int with_validation)
1289 ksba_cert_t next = NULL;
1292 list_cert_raw (ctrl, hd, cert, fp, 0, with_validation);
1294 list_cert_std (ctrl, cert, fp, 0, with_validation);
1295 ksba_cert_ref (cert);
1296 while (!gpgsm_walk_cert_chain (ctrl, cert, &next))
1298 ksba_cert_release (cert);
1299 es_fputs ("Certified by\n", fp);
1301 list_cert_raw (ctrl, hd, next, fp, 0, with_validation);
1303 list_cert_std (ctrl, next, fp, 0, with_validation);
1306 ksba_cert_release (cert);
1312 /* List all internal keys or just the keys given as NAMES. MODE is a
1313 bit vector to specify what keys are to be included; see
1314 gpgsm_list_keys (below) for details. If RAW_MODE is true, the raw
1315 output mode will be used instead of the standard beautified one.
1318 list_internal_keys (ctrl_t ctrl, strlist_t names, estream_t fp,
1319 unsigned int mode, int raw_mode)
1322 KEYDB_SEARCH_DESC *desc = NULL;
1325 ksba_cert_t cert = NULL;
1326 ksba_cert_t lastcert = NULL;
1328 const char *lastresname, *resname;
1330 int want_ephemeral = ctrl->with_ephemeral_keys;
1335 log_error ("keydb_new failed\n");
1336 rc = gpg_error (GPG_ERR_GENERAL);
1344 for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++)
1348 desc = xtrycalloc (ndesc, sizeof *desc);
1351 rc = gpg_error_from_syserror ();
1352 log_error ("out of core\n");
1357 desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1360 for (ndesc=0, sl=names; sl; sl = sl->next)
1362 rc = classify_user_id (sl->d, desc+ndesc, 0);
1365 log_error ("key '%s' not found: %s\n",
1366 sl->d, gpg_strerror (rc));
1375 /* If all specifications are done by fingerprint or keygrip, we
1376 switch to ephemeral mode so that _all_ currently available and
1377 matching certificates are listed. */
1378 if (!want_ephemeral && names && ndesc)
1382 for (i=0; (i < ndesc
1383 && (desc[i].mode == KEYDB_SEARCH_MODE_FPR
1384 || desc[i].mode == KEYDB_SEARCH_MODE_FPR20
1385 || desc[i].mode == KEYDB_SEARCH_MODE_FPR16
1386 || desc[i].mode == KEYDB_SEARCH_MODE_KEYGRIP)); i++)
1393 keydb_set_ephemeral (hd, 1);
1395 /* It would be nice to see which of the given users did actually
1396 match one in the keyring. To implement this we need to have a
1397 found flag for each entry in desc and to set this we must check
1398 all those entries after a match to mark all matched one -
1399 currently we stop at the first match. To do this we need an
1400 extra flag to enable this feature so */
1402 /* Suppress duplicates at least when they follow each other. */
1404 while (!(rc = keydb_search (ctrl, hd, desc, ndesc)))
1406 unsigned int validity;
1409 desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1411 rc = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &validity);
1414 log_error ("keydb_get_flags failed: %s\n", gpg_strerror (rc));
1417 rc = keydb_get_cert (hd, &cert);
1420 log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
1423 /* Skip duplicated certificates, at least if they follow each
1424 others. This works best if a single key is searched for and
1425 expected. FIXME: Non-sequential duplicates remain. */
1426 if (gpgsm_certs_identical_p (cert, lastcert))
1428 ksba_cert_release (cert);
1433 resname = keydb_get_resource_name (hd);
1435 if (lastresname != resname )
1439 if (ctrl->no_server)
1441 es_fprintf (fp, "%s\n", resname );
1442 for (i=strlen(resname); i; i-- )
1445 lastresname = resname;
1452 char *p = gpgsm_get_keygrip_hexstring (cert);
1455 rc = gpgsm_agent_havekey (ctrl, p);
1458 else if ( gpg_err_code (rc) != GPG_ERR_NO_SECKEY)
1465 if (!mode || ((mode & 1) && !have_secret)
1466 || ((mode & 2) && have_secret) )
1468 if (ctrl->with_colons)
1469 list_cert_colon (ctrl, cert, validity, fp, have_secret);
1470 else if (ctrl->with_chain)
1471 list_cert_chain (ctrl, hd, cert,
1472 raw_mode, fp, ctrl->with_validation);
1476 list_cert_raw (ctrl, hd, cert, fp, have_secret,
1477 ctrl->with_validation);
1479 list_cert_std (ctrl, cert, fp, have_secret,
1480 ctrl->with_validation);
1485 ksba_cert_release (lastcert);
1489 if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1 )
1492 log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
1495 ksba_cert_release (cert);
1496 ksba_cert_release (lastcert);
1505 list_external_cb (void *cb_value, ksba_cert_t cert)
1507 struct list_external_parm_s *parm = cb_value;
1509 if (keydb_store_cert (parm->ctrl, cert, 1, NULL))
1510 log_error ("error storing certificate as ephemeral\n");
1512 if (parm->print_header)
1514 const char *resname = "[external keys]";
1517 es_fprintf (parm->fp, "%s\n", resname );
1518 for (i=strlen(resname); i; i-- )
1519 es_putc('-', parm->fp);
1520 es_putc ('\n', parm->fp);
1521 parm->print_header = 0;
1524 if (parm->with_colons)
1525 list_cert_colon (parm->ctrl, cert, 0, parm->fp, 0);
1526 else if (parm->with_chain)
1527 list_cert_chain (parm->ctrl, NULL, cert, parm->raw_mode, parm->fp, 0);
1531 list_cert_raw (parm->ctrl, NULL, cert, parm->fp, 0, 0);
1533 list_cert_std (parm->ctrl, cert, parm->fp, 0, 0);
1534 es_putc ('\n', parm->fp);
1539 /* List external keys similar to internal one. Note: mode does not
1540 make sense here because it would be unwise to list external secret
1543 list_external_keys (ctrl_t ctrl, strlist_t names, estream_t fp, int raw_mode)
1546 struct list_external_parm_s parm;
1550 parm.print_header = ctrl->no_server;
1551 parm.with_colons = ctrl->with_colons;
1552 parm.with_chain = ctrl->with_chain;
1553 parm.raw_mode = raw_mode;
1555 rc = gpgsm_dirmngr_lookup (ctrl, names, 0, list_external_cb, &parm);
1556 if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1
1557 || gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1558 rc = 0; /* "Not found" is not an error here. */
1560 log_error ("listing external keys failed: %s\n", gpg_strerror (rc));
1564 /* List all keys or just the key given as NAMES.
1565 MODE controls the operation mode:
1567 0 = list all public keys but don't flag secret ones
1568 1 = list only public keys
1569 2 = list only secret keys
1570 3 = list secret and public keys
1571 Bit 6: list internal keys
1572 Bit 7: list external keys
1573 Bit 8: Do a raw format dump.
1576 gpgsm_list_keys (ctrl_t ctrl, strlist_t names, estream_t fp,
1579 gpg_error_t err = 0;
1581 if ((mode & (1<<6)))
1582 err = list_internal_keys (ctrl, names, fp, (mode & 3), (mode&256));
1583 if (!err && (mode & (1<<7)))
1584 err = list_external_keys (ctrl, names, fp, (mode&256));