Botan 3.14.1
Crypto and TLS for C&
x509cert.cpp
Go to the documentation of this file.
1/*
2* X.509 Certificates
3* (C) 1999-2010,2015,2017,2026 Jack Lloyd
4* (C) 2016 René Korthaus, Rohde & Schwarz Cybersecurity
5*
6* Botan is released under the Simplified BSD License (see license.txt)
7*/
8
9#include <botan/x509cert.h>
10
11#include <botan/asn1_obj.h>
12#include <botan/asn1_time.h>
13#include <botan/ber_dec.h>
14#include <botan/hash.h>
15#include <botan/hex.h>
16#include <botan/pk_keys.h>
17#include <botan/uri.h>
18#include <botan/x509_ext.h>
19#include <botan/x509_key.h>
20#include <botan/internal/charset.h>
21#include <sstream>
22
23namespace Botan {
24
25class X509_Certificate_Data final {
26 public:
27 X509_Serial_Number m_serial;
28 // TODO(Botan4) once negative serials are rejected this extra vector can go away
29 std::vector<uint8_t> m_serial_bits;
30 AlgorithmIdentifier m_sig_algo_inner;
31 X509_DN m_issuer_dn;
32 X509_DN m_subject_dn;
33 std::vector<uint8_t> m_issuer_dn_bits;
34 std::vector<uint8_t> m_subject_dn_bits;
35 X509_Time m_not_before;
36 X509_Time m_not_after;
37 std::vector<uint8_t> m_subject_public_key_bits;
38 std::vector<uint8_t> m_subject_public_key_bits_seq;
39 std::vector<uint8_t> m_subject_public_key_bitstring;
40 AlgorithmIdentifier m_subject_public_key_algid;
41
42 // TODO(Botan4) change this to std::array<uint8_t, 20> and getter to span
43 std::vector<uint8_t> m_subject_public_key_bitstring_sha1;
44 std::array<uint8_t, 32> m_subject_public_key_bitstring_sha256 = {};
45
46 std::vector<uint8_t> m_v2_issuer_key_id;
47 std::vector<uint8_t> m_v2_subject_key_id;
48 Extensions m_v3_extensions;
49
50 std::vector<OID> m_extended_key_usage;
51 std::vector<uint8_t> m_authority_key_id;
52 std::vector<uint8_t> m_subject_key_id;
53 std::vector<OID> m_cert_policies;
54
55 std::vector<URI> m_crl_distribution_points;
56 std::vector<URI> m_ocsp_responders;
57 std::vector<URI> m_ca_issuers;
58
59 // TODO(Botan4) change this to std::array<uint8_t, 32> and getter to span
60 std::vector<uint8_t> m_issuer_dn_bits_sha256;
61 // TODO(Botan4) change this to std::array<uint8_t, 32> and getter to span
62 std::vector<uint8_t> m_subject_dn_bits_sha256;
63 std::array<uint8_t, 20> m_issuer_dn_bits_sha1 = {};
64 std::array<uint8_t, 20> m_subject_dn_bits_sha1 = {};
65
66 std::string m_fingerprint_sha1;
67 std::string m_fingerprint_sha256;
68
69 std::array<uint8_t, 20> m_cert_data_sha1 = {};
70 std::array<uint8_t, 32> m_cert_data_sha256 = {};
71
72 AlternativeName m_subject_alt_name;
73 AlternativeName m_issuer_alt_name;
74 NameConstraints m_name_constraints;
75
76 size_t m_version = 0;
77 std::optional<size_t> m_path_len_constraint;
78 Key_Constraints m_key_constraints;
79 bool m_self_signed = false;
80 bool m_is_ca_certificate = false;
81 bool m_subject_alt_name_exists = false;
82 bool m_skip_revocation_check = false;
83};
84
86
87std::string X509_Certificate::PEM_label() const {
88 return "CERTIFICATE";
89}
90
91std::vector<std::string> X509_Certificate::alternate_PEM_labels() const {
92 return {"X509 CERTIFICATE"};
93}
94
98
99X509_Certificate::X509_Certificate(std::span<const uint8_t> in) {
100 DataSource_Memory src(in);
101 load_data(src);
102}
103
104#if defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
105X509_Certificate::X509_Certificate(std::string_view fsname) {
106 DataSource_Stream src(fsname, true);
107 load_data(src);
108}
109#endif
110
111namespace {
112
113std::unique_ptr<X509_Certificate_Data> parse_x509_cert_body(const X509_Object& obj) {
114 auto data = std::make_unique<X509_Certificate_Data>();
115
116 BER_Object public_key;
117 BER_Object v3_exts_data;
118
119 BER_Decoder(obj.signed_body(), BER_Decoder::Limits::DER())
120 .decode_optional(data->m_version, ASN1_Type(0), ASN1_Class::Constructed | ASN1_Class::ContextSpecific)
121 .decode(data->m_serial)
122 .decode(data->m_sig_algo_inner)
123 .decode(data->m_issuer_dn)
124 .start_sequence()
125 .decode(data->m_not_before)
126 .decode(data->m_not_after)
127 .end_cons()
128 .decode(data->m_subject_dn)
129 .get_next(public_key)
130 .decode_optional_string(data->m_v2_issuer_key_id, ASN1_Type::BitString, 1)
131 .decode_optional_string(data->m_v2_subject_key_id, ASN1_Type::BitString, 2)
132 .get_next(v3_exts_data)
133 .verify_end("TBSCertificate has extra data after extensions block");
134
135 if(data->m_version > 2) {
136 throw Decoding_Error("Unknown X.509 cert version " + std::to_string(data->m_version));
137 }
138 if(obj.signature_algorithm() != data->m_sig_algo_inner) {
139 throw Decoding_Error("X.509 Certificate had differing algorithm identifiers in inner and outer ID fields");
140 }
141
142 public_key.assert_is_a(ASN1_Type::Sequence, ASN1_Class::Constructed, "X.509 certificate public key");
143
144 // for general sanity convert wire version (0 based) to standards version (v1 .. v3)
145 data->m_version += 1;
146
147 data->m_serial_bits = data->m_serial.magnitude();
148 data->m_subject_dn_bits = ASN1::put_in_sequence(data->m_subject_dn.get_bits());
149 data->m_issuer_dn_bits = ASN1::put_in_sequence(data->m_issuer_dn.get_bits());
150
151 data->m_subject_public_key_bits.assign(public_key.bits(), public_key.bits() + public_key.length());
152
153 data->m_subject_public_key_bits_seq = ASN1::put_in_sequence(data->m_subject_public_key_bits);
154
155 BER_Decoder(data->m_subject_public_key_bits, BER_Decoder::Limits::DER())
156 .decode(data->m_subject_public_key_algid)
157 .decode_octet_aligned_bitstring(data->m_subject_public_key_bitstring)
158 .verify_end();
159
160 if(v3_exts_data.is_a(3, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
161 // Path validation will reject a v1/v2 cert with v3 extensions
162 BER_Decoder cert_extensions(v3_exts_data, BER_Decoder::Limits::DER());
163 data->m_v3_extensions.decode_from(cert_extensions, Extension_Context::Certificate);
164 cert_extensions.verify_end();
165 } else if(v3_exts_data.is_set()) {
166 throw BER_Bad_Tag("Unknown tag in X.509 cert", v3_exts_data.tagging());
167 }
168
169 // Now cache some fields from the extensions
170 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Key_Usage>()) {
171 data->m_key_constraints = ext->get_constraints();
172 /*
173 RFC 5280: When the keyUsage extension appears in a certificate,
174 at least one of the bits MUST be set to 1.
175 */
176 if(data->m_key_constraints.empty()) {
177 throw Decoding_Error("Certificate has invalid encoding for KeyUsage");
178 }
179 }
180
181 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Subject_Key_ID>()) {
182 data->m_subject_key_id = ext->get_key_id();
183 }
184
185 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Authority_Key_ID>()) {
186 data->m_authority_key_id = ext->get_key_id();
187 }
188
189 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Name_Constraints>()) {
190 data->m_name_constraints = ext->get_name_constraints();
191 }
192
193 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Extended_Key_Usage>()) {
194 data->m_extended_key_usage = ext->object_identifiers();
195 /*
196 RFC 5280 section 4.2.1.12
197
198 "This extension indicates one or more purposes ..."
199
200 "If the extension is present, then the certificate MUST only be
201 used for one of the purposes indicated."
202
203 Thus we reject an EKU extension which is empty, since this indicates
204 the certificate cannot be used for any purpose.
205 */
206 if(data->m_extended_key_usage.empty()) {
207 throw Decoding_Error("Certificate has invalid empty EKU extension");
208 }
209 }
210
211 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Basic_Constraints>()) {
212 /*
213 * RFC 5280 4.2.1.9 requires that conforming CAs "MUST mark the
214 * extension [basicConstraints] as critical in such certificates"
215 * but places no such requirement on validators.
216 */
217 if(ext->is_ca() == true) {
218 /*
219 * RFC 5280 section 4.2.1.3 requires that CAs include KeyUsage in all
220 * intermediate CA certificates they issue. Currently we accept it being
221 * missing, as do most other implementations. But it may be worth
222 * removing this entirely, or alternately adding a warning level
223 * validation failure for it.
224 */
225 const bool allowed_by_ku =
226 data->m_key_constraints.includes(Key_Constraints::KeyCertSign) || data->m_key_constraints.empty();
227
228 /*
229 * If the extended key usages are set then we must restrict the usage in
230 * accordance with it as well.
231 *
232 * RFC 5280 does not define any extended key usages compatible with certificate
233 * signing, but some CAs use serverAuth, clientAuth, OCSPSigning, or AnyExtendedKeyUsage
234 * for this purpose, even though clearly all of these (besides AEKU) are invalid.
235 * This check at least allows excluding a certificate which is set for only eg
236 * timestamping or code signing, and that seems about the best we can possibly enforce.
237 * OpenSSL, BoringSSL, and Go all completely ignore EKUs in determining ability to
238 * issue certs.
239 */
240 const bool allowed_by_ext_ku = [](const std::vector<OID>& ext_ku) -> bool {
241 if(ext_ku.empty()) {
242 return true;
243 }
244
245 const auto server_auth = OID::from_name("PKIX.ServerAuth");
246 const auto client_auth = OID::from_name("PKIX.ClientAuth");
247 const auto ocsp_sign = OID::from_name("PKIX.OCSPSigning");
248 const auto any_eku = OID::from_name("X509v3.AnyExtendedKeyUsage");
249
250 for(const auto& oid : ext_ku) {
251 if(oid == any_eku || oid == server_auth || oid == client_auth || oid == ocsp_sign) {
252 return true;
253 }
254 }
255
256 return false;
257 }(data->m_extended_key_usage);
258
259 if(allowed_by_ku && allowed_by_ext_ku) {
260 data->m_is_ca_certificate = true;
261 data->m_path_len_constraint = ext->path_length_constraint();
262 }
263 }
264 }
265
266 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Issuer_Alternative_Name>()) {
267 data->m_issuer_alt_name = ext->get_alt_name();
268 }
269
270 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Subject_Alternative_Name>()) {
271 data->m_subject_alt_name = ext->get_alt_name();
272 }
273
274 // This will be set even if SAN parsing failed entirely eg due to a decoding error
275 // or if the SAN is empty. This is used to guard against using the CN for domain
276 // name checking.
277 const auto san_oid = OID::from_string("X509v3.SubjectAlternativeName");
278 data->m_subject_alt_name_exists = data->m_v3_extensions.extension_set(san_oid);
279
280 /*
281 * RFC 9608 Section 4:
282 *
283 * If the noRevAvail certificate extension specified in this document is
284 * present or the ocsp-nocheck certificate extension [RFC6960] is
285 * present, then Step (a)(3) is skipped. Otherwise, revocation status
286 * determination of the certificate is performed.
287 */
288 data->m_skip_revocation_check =
289 data->m_v3_extensions.extension_set(Cert_Extension::NoRevocationAvailable::static_oid()) ||
290 data->m_v3_extensions.extension_set(Cert_Extension::OCSP_NoCheck::static_oid());
291
292 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Certificate_Policies>()) {
293 data->m_cert_policies = ext->get_policy_oids();
294 }
295
296 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Authority_Information_Access>()) {
297 data->m_ocsp_responders = ext->ocsp_responder_uris();
298 data->m_ca_issuers = ext->ca_issuer_uris();
299 }
300
301 if(const auto* ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::CRL_Distribution_Points>()) {
302 data->m_crl_distribution_points = ext->crl_distribution_point_uris();
303 }
304
305 /*
306 Determine if this certificate appears to be self-issued (subject == issuer).
307 This is only a heuristic used for path building so it's ok it is not precise.
308 */
309 if(data->m_subject_dn == data->m_issuer_dn) {
310 if(!data->m_subject_key_id.empty() && !data->m_authority_key_id.empty()) {
311 /*
312 Both SKID and AKID are set so we can reliably determine self-signed vs
313 self-issued by comparing the two
314 */
315 data->m_self_signed = (data->m_subject_key_id == data->m_authority_key_id);
316 } else {
317 /*
318 Without both SKID and AKID we can't determine with certainty. Assume
319 self-signed since that's by far the common case.
320 */
321 data->m_self_signed = true;
322 }
323 }
324
325 const std::vector<uint8_t> full_encoding = obj.BER_encode();
326
327 if(auto sha1 = HashFunction::create("SHA-1")) {
328 sha1->update(data->m_subject_public_key_bitstring);
329 data->m_subject_public_key_bitstring_sha1 = sha1->final_stdvec();
330 // otherwise left as empty, and we will throw if subject_public_key_bitstring_sha1 is called
331
332 sha1->update(full_encoding);
333 sha1->final(data->m_cert_data_sha1);
334 data->m_fingerprint_sha1 = format_hex_fingerprint(data->m_cert_data_sha1);
335
336 sha1->update(data->m_issuer_dn_bits);
337 sha1->final(data->m_issuer_dn_bits_sha1);
338
339 sha1->update(data->m_subject_dn_bits);
340 sha1->final(data->m_subject_dn_bits_sha1);
341 }
342
343 // SHA-256 is a hard dependency of this module
344 auto sha256 = HashFunction::create_or_throw("SHA-256");
345 sha256->update(data->m_issuer_dn_bits);
346 data->m_issuer_dn_bits_sha256 = sha256->final_stdvec();
347
348 sha256->update(data->m_subject_dn_bits);
349 data->m_subject_dn_bits_sha256 = sha256->final_stdvec();
350
351 sha256->update(full_encoding);
352 sha256->final(data->m_cert_data_sha256);
353 data->m_fingerprint_sha256 = format_hex_fingerprint(data->m_cert_data_sha256);
354
355 sha256->update(data->m_subject_public_key_bitstring);
356 sha256->final(data->m_subject_public_key_bitstring_sha256);
357
358 return data;
359}
360
361} // namespace
362
363/*
364* Decode the TBSCertificate data
365*/
366void X509_Certificate::force_decode() {
367 m_data.reset();
368 m_data = parse_x509_cert_body(*this);
369}
370
371const X509_Certificate_Data& X509_Certificate::data() const {
372 if(m_data == nullptr) {
373 throw Invalid_State("X509_Certificate uninitialized");
374 }
375 return *m_data;
376}
377
379 return static_cast<uint32_t>(data().m_version);
380}
381
383 return data().m_self_signed;
384}
385
387 return data().m_not_before;
388}
389
391 return data().m_not_after;
392}
393
395 return data().m_subject_public_key_algid;
396}
397
398const std::vector<uint8_t>& X509_Certificate::v2_issuer_key_id() const {
399 return data().m_v2_issuer_key_id;
400}
401
402const std::vector<uint8_t>& X509_Certificate::v2_subject_key_id() const {
403 return data().m_v2_subject_key_id;
404}
405
406const std::vector<uint8_t>& X509_Certificate::subject_public_key_bits() const {
407 return data().m_subject_public_key_bits;
408}
409
410const std::vector<uint8_t>& X509_Certificate::subject_public_key_info() const {
411 return data().m_subject_public_key_bits_seq;
412}
413
414const std::vector<uint8_t>& X509_Certificate::subject_public_key_bitstring() const {
415 return data().m_subject_public_key_bitstring;
416}
417
418const std::vector<uint8_t>& X509_Certificate::subject_public_key_bitstring_sha1() const {
419 if(data().m_subject_public_key_bitstring_sha1.empty()) {
420 throw Encoding_Error("X509_Certificate::subject_public_key_bitstring_sha1 called but SHA-1 disabled in build");
421 }
422
423 return data().m_subject_public_key_bitstring_sha1;
424}
425
426std::span<const uint8_t, 32> X509_Certificate::subject_public_key_bitstring_sha256() const {
427 return data().m_subject_public_key_bitstring_sha256;
428}
429
430const std::vector<uint8_t>& X509_Certificate::authority_key_id() const {
431 return data().m_authority_key_id;
432}
433
434const std::vector<uint8_t>& X509_Certificate::subject_key_id() const {
435 return data().m_subject_key_id;
436}
437
438const std::vector<uint8_t>& X509_Certificate::serial_number() const {
439 return data().m_serial_bits;
440}
441
443 return data().m_serial;
444}
445
447 return data().m_serial.is_negative();
448}
449
451 return data().m_skip_revocation_check;
452}
453
455 return data().m_issuer_dn;
456}
457
459 return data().m_subject_dn;
460}
461
462const std::vector<uint8_t>& X509_Certificate::raw_issuer_dn() const {
463 return data().m_issuer_dn_bits;
464}
465
466const std::vector<uint8_t>& X509_Certificate::raw_subject_dn() const {
467 return data().m_subject_dn_bits;
468}
469
470std::span<const uint8_t, 20> X509_Certificate::certificate_data_sha1() const {
471 if(data().m_fingerprint_sha1.empty()) {
472 throw Not_Implemented("SHA-1 not available");
473 }
474 return data().m_cert_data_sha1;
475}
476
477std::span<const uint8_t, 32> X509_Certificate::certificate_data_sha256() const {
478 return data().m_cert_data_sha256;
479}
480
482 if(data().m_version < 3 && data().m_self_signed) {
483 return true;
484 }
485
486 return data().m_is_ca_certificate;
487}
488
490 if(data().m_version < 3 && data().m_self_signed) {
491 return 32; // in theory infinite, but this is more than enough
492 }
493
494 return static_cast<uint32_t>(data().m_path_len_constraint.value_or(Cert_Extension::NO_CERT_PATH_LIMIT));
495}
496
497std::optional<size_t> X509_Certificate::path_length_constraint() const {
498 return data().m_path_len_constraint;
499}
500
502 return data().m_key_constraints;
503}
504
505const std::vector<OID>& X509_Certificate::extended_key_usage() const {
506 return data().m_extended_key_usage;
507}
508
509const std::vector<OID>& X509_Certificate::certificate_policy_oids() const {
510 return data().m_cert_policies;
511}
512
514 return data().m_name_constraints;
515}
516
518 return data().m_v3_extensions;
519}
520
522 // Unlike allowed_usage, returns false if constraints was not set
523 return constraints().includes(usage);
524}
525
527 if(constraints().empty()) {
528 return true;
529 }
530 return constraints().includes(usage);
531}
532
533bool X509_Certificate::allowed_extended_usage(std::string_view usage) const {
535}
536
538 const std::vector<OID>& ex = extended_key_usage();
539 if(ex.empty()) {
540 return true;
541 }
542
543 if(has_ex_constraint(usage)) {
544 return true;
545 }
546
547 return false;
548}
549
579
580bool X509_Certificate::has_ex_constraint(std::string_view ex_constraint) const {
581 return has_ex_constraint(OID::from_string(ex_constraint));
582}
583
584bool X509_Certificate::has_ex_constraint(const OID& usage) const {
585 const auto any_eku = OID::from_name("X509v3.AnyExtendedKeyUsage");
586 const auto ocsp_eku = OID::from_name("PKIX.OCSPSigning");
587
588 for(const auto& ext_ku : extended_key_usage()) {
589 if(ext_ku == usage) {
590 return true;
591 }
592
593 /*
594 Do not accept AnyExtendedKeyUsage for OCSP due to RFC 6960 4.2.2.2:
595
596 OCSP signing delegation SHALL be designated by the inclusion of
597 id-kp-OCSPSigning in an extended key usage certificate extension
598 included in the OCSP response signer's certificate.
599 */
600 if(ext_ku == any_eku && usage != ocsp_eku) {
601 return true;
602 }
603 }
604
605 return false;
606}
607
608/*
609* Return if a certificate extension is marked critical
610*/
611bool X509_Certificate::is_critical(std::string_view ex_name) const {
613}
614
615namespace {
616
617std::vector<std::string> uris_as_strings(const std::vector<URI>& uris) {
618 std::vector<std::string> out;
619 out.reserve(uris.size());
620 for(const auto& uri : uris) {
621 out.push_back(uri.original_input());
622 }
623 return out;
624}
625
626} // namespace
627
629 if(data().m_ocsp_responders.empty()) {
630 return {};
631 }
632 return data().m_ocsp_responders[0].original_input();
633}
634
635std::vector<std::string> X509_Certificate::ocsp_responders() const {
636 return uris_as_strings(data().m_ocsp_responders);
637}
638
639const std::vector<URI>& X509_Certificate::ocsp_responder_uris() const {
640 return data().m_ocsp_responders;
641}
642
643std::vector<std::string> X509_Certificate::ca_issuers() const {
644 return uris_as_strings(data().m_ca_issuers);
645}
646
647const std::vector<URI>& X509_Certificate::ca_issuer_uris() const {
648 return data().m_ca_issuers;
649}
650
651std::vector<std::string> X509_Certificate::crl_distribution_points() const {
652 return uris_as_strings(data().m_crl_distribution_points);
653}
654
655const std::vector<URI>& X509_Certificate::crl_distribution_point_uris() const {
656 return data().m_crl_distribution_points;
657}
658
660 // just returns the first (arbitrarily)
661 if(!data().m_crl_distribution_points.empty()) {
662 return data().m_crl_distribution_points[0].original_input();
663 }
664 return "";
665}
666
667std::vector<EmailAddress> X509_Certificate::subject_email_addresses() const {
668 const auto& san_emails = subject_alt_name().email_addresses();
669
670 std::vector<EmailAddress> out;
671 out.reserve(san_emails.size());
672
673 for(const auto& addr : san_emails) {
674 out.push_back(addr);
675 }
676
677 for(const auto& dn_email_str : subject_dn().get_attribute("PKCS9.EmailAddress")) {
678 if(auto parsed = EmailAddress::from_string(dn_email_str)) {
679 out.push_back(std::move(*parsed));
680 }
681 }
682
683 return out;
684}
685
687 return data().m_subject_alt_name;
688}
689
691 return data().m_issuer_alt_name;
692}
693
694namespace {
695
696std::vector<std::string> get_cert_user_info(std::string_view req, const X509_DN& dn, const AlternativeName& alt_name) {
697 if(dn.has_field(req)) {
698 return dn.get_attribute(req);
699 } else if(req == "RFC822" || req == "Email") {
700 std::vector<std::string> out;
701 out.reserve(alt_name.email_addresses().size());
702 for(const auto& addr : alt_name.email_addresses()) {
703 out.push_back(addr.to_string());
704 }
705 return out;
706 } else if(req == "DNS") {
707 std::vector<std::string> out;
708 out.reserve(alt_name.dns_names().size());
709 for(const auto& dns : alt_name.dns_names()) {
710 out.push_back(dns.to_string());
711 }
712 return out;
713 } else if(req == "URI") {
714 std::vector<std::string> out;
715 out.reserve(alt_name.uri_names().size());
716 for(const auto& uri : alt_name.uri_names()) {
717 out.push_back(uri.original_input());
718 }
719 return out;
720 } else if(req == "IP") {
721 std::vector<std::string> ip_str;
722 for(const auto& ipv4 : alt_name.ipv4_addresses()) {
723 ip_str.push_back(ipv4.to_string());
724 }
725 return ip_str;
726 } else if(req == "IPv6") {
727 std::vector<std::string> ip_str;
728 for(const auto& ipv6 : alt_name.ipv6_addresses()) {
729 ip_str.push_back(ipv6.to_string());
730 }
731 return ip_str;
732 } else {
733 return {};
734 }
735}
736
737} // namespace
738
739/*
740* Return information about the subject
741*/
742std::vector<std::string> X509_Certificate::subject_info(std::string_view req) const {
743 return get_cert_user_info(req, subject_dn(), subject_alt_name());
744}
745
746/*
747* Return information about the issuer
748*/
749std::vector<std::string> X509_Certificate::issuer_info(std::string_view req) const {
750 return get_cert_user_info(req, issuer_dn(), issuer_alt_name());
751}
752
753/*
754* Return the public key in this certificate
755*/
756std::unique_ptr<Public_Key> X509_Certificate::subject_public_key() const {
757 try {
758 return std::unique_ptr<Public_Key>(X509::load_key(subject_public_key_info()));
759 } catch(std::exception& e) {
760 throw Decoding_Error("X509_Certificate::subject_public_key", e);
761 }
762}
763
764std::unique_ptr<Public_Key> X509_Certificate::load_subject_public_key() const {
765 return this->subject_public_key();
766}
767
768const std::vector<uint8_t>& X509_Certificate::raw_issuer_dn_sha256() const {
769 if(data().m_issuer_dn_bits_sha256.empty()) {
770 throw Encoding_Error("X509_Certificate::raw_issuer_dn_sha256 called but SHA-256 disabled in build");
771 }
772 return data().m_issuer_dn_bits_sha256;
773}
774
775const std::vector<uint8_t>& X509_Certificate::raw_subject_dn_sha256() const {
776 if(data().m_subject_dn_bits_sha256.empty()) {
777 throw Encoding_Error("X509_Certificate::raw_subject_dn_sha256 called but SHA-256 disabled in build");
778 }
779 return data().m_subject_dn_bits_sha256;
780}
781
782std::span<const uint8_t, 20> X509_Certificate::raw_issuer_dn_sha1() const {
783 return data().m_issuer_dn_bits_sha1;
784}
785
786std::span<const uint8_t, 20> X509_Certificate::raw_subject_dn_sha1() const {
787 return data().m_subject_dn_bits_sha1;
788}
789
790std::string X509_Certificate::fingerprint(std::string_view hash_name) const {
791 /*
792 * The SHA-1 and SHA-256 fingerprints are precomputed since these
793 * are the most commonly used. Especially, SHA-256 fingerprints are
794 * used for cycle detection during path construction.
795 *
796 * If SHA-1 or SHA-256 was missing at parsing time the vectors are
797 * left empty in which case we fall back to create_hex_fingerprint
798 * which will throw if the hash is unavailable.
799 */
800 if(hash_name == "SHA-256" && !data().m_fingerprint_sha256.empty()) {
801 return data().m_fingerprint_sha256;
802 } else if(hash_name == "SHA-1" && !data().m_fingerprint_sha1.empty()) {
803 return data().m_fingerprint_sha1;
804 } else {
805 return create_hex_fingerprint(this->BER_encode(), hash_name);
806 }
807}
808
810 return Tag(data().m_cert_data_sha256);
811}
812
814 const auto& sans = subject_alt_name().dns_names();
815 if(!sans.empty()) {
816 for(const auto& san : sans) {
817 if(name.matches_wildcard(san.name())) {
818 return true;
819 }
820 }
821 return false;
822 }
823
824 /*
825 Fall back to CN for DNS name only if no SAN is included
826 We assume if the issuer knew about SAN then they would have included
827 the DNS name there if the intention was to provide such a name.
828 */
829 if(!data().m_subject_alt_name_exists) {
830 for(const auto& cn : subject_dn().get_attribute("CN")) {
831 if(auto cn_dns = DNSName::from_san_string(cn)) {
832 if(name.matches_wildcard(cn_dns->name())) {
833 return true;
834 }
835 }
836 }
837 }
838
839 return false;
840}
841
842bool X509_Certificate::matches_ip(const IPv4Address& address) const {
843 return subject_alt_name().ipv4_addresses().contains(address);
844}
845
846bool X509_Certificate::matches_ip(const IPv6Address& address) const {
847 return subject_alt_name().ipv6_addresses().contains(address);
848}
849
850bool X509_Certificate::matches_dns_name(std::string_view name) const {
851 if(name.empty()) {
852 return false;
853 }
854
855 if(auto req_ipv4 = IPv4Address::from_string(name)) {
856 return matches_ip(*req_ipv4);
857 }
858
859 if(auto req_ipv6 = IPv6Address::from_string(name)) {
860 return matches_ip(*req_ipv6);
861 }
862
863 if(auto parsed = DNSName::from_string(name)) {
864 return matches_dns_name(*parsed);
865 }
866
867 return false;
868}
869
870/*
871* Compare two certificates for equality
872*/
874 return (this->signature() == other.signature() && this->signature_algorithm() == other.signature_algorithm() &&
875 this->signed_body() == other.signed_body());
876}
877
879 /* If signature values are not equal, sort by lexicographic ordering of that */
880 if(this->signature() != other.signature()) {
881 return (this->signature() < other.signature());
882 }
883
884 // Then compare the signed contents
885 return this->signed_body() < other.signed_body();
886}
887
888/*
889* X.509 Certificate Comparison
890*/
891bool operator!=(const X509_Certificate& cert1, const X509_Certificate& cert2) {
892 return !(cert1 == cert2);
893}
894
895namespace {
896
897void format_alt_name(std::ostream& out, std::string_view label, const AlternativeName& alt_name) {
898 if(alt_name.is_empty()) {
899 return;
900 }
901
902 out << label << ":\n";
903
904 for(const auto& dns : alt_name.dns_names()) {
905 out << " DNS: " << escape_control_chars(dns.to_string()) << "\n";
906 }
907 for(const auto& ipv4 : alt_name.ipv4_addresses()) {
908 out << " IP: " << ipv4.to_string() << "\n";
909 }
910 for(const auto& ipv6 : alt_name.ipv6_addresses()) {
911 out << " IP: " << ipv6.to_string() << "\n";
912 }
913 for(const auto& uri : alt_name.uri_names()) {
914 out << " URI: " << escape_control_chars(uri.original_input()) << "\n";
915 }
916 for(const auto& email : alt_name.email_addresses()) {
917 out << " Email: " << escape_control_chars(email.to_string()) << "\n";
918 }
919 for(const auto& mbox : alt_name.smtp_utf8_mailboxes()) {
920 out << " SmtpUTF8: " << escape_control_chars(mbox.to_string()) << "\n";
921 }
922 for(const auto& dn : alt_name.directory_names()) {
923 out << " DirName: " << dn << "\n";
924 }
925 for(const auto& oid : alt_name.registered_ids()) {
926 out << " RegisteredID: " << oid.to_formatted_string() << "\n";
927 }
928
929 // SmtpUTF8Mailbox values are also retained verbatim in other_name_values;
930 // skip them here since they are already printed in decoded form above
931 const auto smtp_utf8_oid = OID::from_string("PKIX.SmtpUTF8Mailbox");
932 for(const auto& other : alt_name.other_name_values()) {
933 if(other.oid() == smtp_utf8_oid) {
934 continue;
935 }
936 out << " OtherName " << other.oid().to_formatted_string() << ": " << hex_encode(other.value()) << "\n";
937 }
938}
939
940} // namespace
941
942std::string X509_Certificate::to_string() const {
943 std::ostringstream out;
944
945 out << "Version: " << this->x509_version() << "\n";
946 out << "Subject: " << subject_dn() << "\n";
947 out << "Issuer: " << issuer_dn() << "\n";
948 out << "Issued: " << this->not_before().readable_string() << "\n";
949 out << "Expires: " << this->not_after().readable_string() << "\n";
950
951 try {
952 auto pubkey = this->subject_public_key();
953 out << "Public Key [" << pubkey->algo_name() << "-" << pubkey->key_length() << "]\n\n";
954 out << X509::PEM_encode(*pubkey) << "\n";
955 } catch(const Decoding_Error& ex) {
956 const AlgorithmIdentifier& alg_id = this->subject_public_key_algo();
957 out << "Public Key Invalid!\n"
958 << " OID: " << alg_id.oid().to_formatted_string() << "\n"
959 << " Error: " << ex.what() << "\n"
960 << " Hex: " << hex_encode(this->subject_public_key_bitstring()) << "\n";
961 }
962
963 format_alt_name(out, "Subject Alternative Name", this->subject_alt_name());
964
965 out << "Constraints:\n";
967 if(constraints.empty()) {
968 out << " No key constraints set\n";
969 } else {
971 out << " Digital Signature\n";
972 }
974 out << " Non-Repudiation\n";
975 }
977 out << " Key Encipherment\n";
978 }
980 out << " Data Encipherment\n";
981 }
983 out << " Key Agreement\n";
984 }
986 out << " Cert Sign\n";
987 }
989 out << " CRL Sign\n";
990 }
992 out << " Encipher Only\n";
993 }
995 out << " Decipher Only\n";
996 }
997 }
998
999 if(this->is_CA_cert()) {
1000 out << "Basic Constraints: CA";
1001 if(const auto path_len = this->path_length_constraint()) {
1002 out << ", path length " << *path_len;
1003 }
1004 out << "\n";
1005 }
1006
1007 const std::vector<OID>& policies = this->certificate_policy_oids();
1008 if(!policies.empty()) {
1009 out << "Policies: "
1010 << "\n";
1011 for(const auto& oid : policies) {
1012 out << " " << oid.to_string() << "\n";
1013 }
1014 }
1015
1016 const std::vector<OID>& ex_constraints = this->extended_key_usage();
1017 if(!ex_constraints.empty()) {
1018 out << "Extended Constraints:\n";
1019 for(auto&& oid : ex_constraints) {
1020 out << " " << oid.to_formatted_string() << "\n";
1021 }
1022 }
1023
1025
1026 if(!name_constraints.permitted().empty() || !name_constraints.excluded().empty()) {
1027 out << "Name Constraints:\n";
1028
1029 if(!name_constraints.permitted().empty()) {
1030 out << " Permit";
1031 for(const auto& st : name_constraints.permitted()) {
1032 out << " " << st.base();
1033 }
1034 out << "\n";
1035 }
1036
1037 if(!name_constraints.excluded().empty()) {
1038 out << " Exclude";
1039 for(const auto& st : name_constraints.excluded()) {
1040 out << " " << st.base();
1041 }
1042 out << "\n";
1043 }
1044 }
1045
1046 const auto& ocsp_responders = this->ocsp_responder_uris();
1047 if(!ocsp_responders.empty()) {
1048 out << "OCSP Responders:\n";
1049 for(const auto& ocsp_responder : ocsp_responders) {
1050 out << " URI: " << ocsp_responder.original_input() << "\n";
1051 }
1052 }
1053
1054 const auto& ca_issuers = this->ca_issuer_uris();
1055 if(!ca_issuers.empty()) {
1056 out << "CA Issuers:\n";
1057 for(const auto& ca_issuer : ca_issuers) {
1058 out << " URI: " << ca_issuer.original_input() << "\n";
1059 }
1060 }
1061
1062 for(const auto& cdp : crl_distribution_point_uris()) {
1063 out << "CRL " << cdp.original_input() << "\n";
1064 }
1065
1066 if(const auto* tn_auth = v3_extensions().get_extension_object_as<Cert_Extension::TNAuthList>()) {
1067 out << "TN Authorization List:\n";
1068 for(const auto& entry : tn_auth->entries()) {
1069 switch(entry.type()) {
1071 out << " SPC: " << escape_control_chars(entry.service_provider_code()) << "\n";
1072 break;
1074 out << " Range: " << entry.range().start().to_string() << " count " << entry.range().count() << "\n";
1075 break;
1077 out << " TN: " << entry.number().to_string() << "\n";
1078 break;
1079 }
1080 }
1081 }
1082
1083 out << "Signature algorithm: " << this->signature_algorithm().oid().to_formatted_string() << "\n";
1084
1085 out << "Serial number: " << this->serial().to_string() << "\n";
1086
1087 if(!this->authority_key_id().empty()) {
1088 out << "Authority keyid: " << hex_encode(this->authority_key_id()) << "\n";
1089 }
1090
1091 if(!this->subject_key_id().empty()) {
1092 out << "Subject keyid: " << hex_encode(this->subject_key_id()) << "\n";
1093 }
1094
1095 format_alt_name(out, "Issuer Alternative Name", this->issuer_alt_name());
1096
1097 if(this->skip_revocation_check()) {
1098 out << "Revocation status checking is disabled for this certificate\n";
1099 }
1100
1101 if(this->is_self_signed()) {
1102 out << "Certificate is self signed\n";
1103 }
1104
1105 return out.str();
1106}
1107
1108} // namespace Botan
std::vector< uint8_t > BER_encode() const
Definition asn1_obj.cpp:21
std::string readable_string() const
Returns a human friendly string representation of no particular formatting.
const OID & oid() const
Definition asn1_obj.h:688
const std::set< IPv6Address > & ipv6_addresses() const
Return the set of IPv6 addresses included in this alternative name.
Definition pkix_types.h:421
const std::set< DNSName > & dns_names() const
Return the set of DNS names included in this alternative name.
Definition pkix_types.h:407
const std::set< EmailAddress > & email_addresses() const
Return the set of email addresses included in this alternative name.
Definition pkix_types.h:398
const std::set< IPv4Address > & ipv4_addresses() const
Return the set of IPv4 addresses included in this alternative name.
Definition pkix_types.h:418
const std::set< URI > & uri_names() const
Return the set of URIs included in this alternative name.
Definition pkix_types.h:389
static Limits DER()
Definition ber_dec.h:44
BER_Decoder & decode(bool &out)
Definition ber_dec.h:361
BER_Decoder & verify_end()
Definition ber_dec.cpp:471
BER_Decoder & decode_octet_aligned_bitstring(T &out_wrapped, ASN1_Type type_tag=ASN1_Type::BitString, ASN1_Class class_tag=ASN1_Class::Universal)
Definition ber_dec.h:458
static std::optional< DNSName > from_san_string(std::string_view name)
Definition dns_name.cpp:147
static std::optional< DNSName > from_string(std::string_view name)
Definition dns_name.cpp:134
static std::optional< EmailAddress > from_string(std::string_view addr)
Definition email.cpp:78
const char * what() const noexcept override
Definition exceptn.h:94
bool critical_extension_set(const OID &oid) const
Definition x509_ext.cpp:229
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:311
static std::unique_ptr< HashFunction > create(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:112
static std::optional< IPv4Address > from_string(std::string_view str)
static std::optional< IPv6Address > from_string(std::string_view str)
bool includes(Key_Constraints::Bits other) const
Definition pkix_enums.h:187
Name Constraints.
Definition pkix_types.h:748
const std::vector< GeneralSubtree > & permitted() const
Definition pkix_types.h:766
std::string to_formatted_string() const
Definition asn1_oid.cpp:137
static std::optional< OID > from_name(std::string_view name)
Definition asn1_oid.cpp:66
static OID from_string(std::string_view str)
Definition asn1_oid.cpp:80
const std::vector< OID > & extended_key_usage() const
Definition x509cert.cpp:505
bool is_CA_cert() const
Definition x509cert.cpp:481
Key_Constraints constraints() const
Definition x509cert.cpp:501
bool operator==(const X509_Certificate &other) const
Definition x509cert.cpp:873
const NameConstraints & name_constraints() const
Definition x509cert.cpp:513
std::vector< std::string > ocsp_responders() const
Definition x509cert.cpp:635
bool is_critical(std::string_view ex_name) const
Definition x509cert.cpp:611
const std::vector< uint8_t > & serial_number() const
Definition x509cert.cpp:438
std::string fingerprint(std::string_view hash_name="SHA-1") const
Definition x509cert.cpp:790
const std::vector< URI > & ocsp_responder_uris() const
Definition x509cert.cpp:639
const X509_DN & subject_dn() const
Definition x509cert.cpp:458
bool skip_revocation_check() const
Definition x509cert.cpp:450
uint32_t path_limit() const
Definition x509cert.cpp:489
const X509_Serial_Number & serial() const
Definition x509cert.cpp:442
const X509_Time & not_after() const
Definition x509cert.cpp:390
const std::vector< uint8_t > & authority_key_id() const
Definition x509cert.cpp:430
std::span< const uint8_t, 32 > certificate_data_sha256() const
Definition x509cert.cpp:477
bool allowed_extended_usage(std::string_view usage) const
Definition x509cert.cpp:533
const AlternativeName & issuer_alt_name() const
Definition x509cert.cpp:690
const std::vector< uint8_t > & raw_subject_dn() const
Definition x509cert.cpp:466
const std::vector< uint8_t > & subject_key_id() const
Definition x509cert.cpp:434
~X509_Certificate() override
std::span< const uint8_t, 32 > subject_public_key_bitstring_sha256() const
Definition x509cert.cpp:426
const std::vector< uint8_t > & subject_public_key_bits() const
Definition x509cert.cpp:406
bool has_constraints(Key_Constraints constraints) const
Definition x509cert.cpp:521
std::optional< size_t > path_length_constraint() const
Definition x509cert.cpp:497
const Extensions & v3_extensions() const
Definition x509cert.cpp:517
bool has_ex_constraint(std::string_view ex_constraint) const
Definition x509cert.cpp:580
std::vector< std::string > crl_distribution_points() const
Definition x509cert.cpp:651
const std::vector< uint8_t > & subject_public_key_bitstring_sha1() const
Definition x509cert.cpp:418
bool allowed_usage(Key_Constraints usage) const
Definition x509cert.cpp:526
const X509_DN & issuer_dn() const
Definition x509cert.cpp:454
const std::vector< uint8_t > & v2_issuer_key_id() const
Definition x509cert.cpp:398
std::string ocsp_responder() const
Definition x509cert.cpp:628
std::span< const uint8_t, 20 > certificate_data_sha1() const
Definition x509cert.cpp:470
bool matches_dns_name(std::string_view name) const
Definition x509cert.cpp:850
std::vector< std::string > subject_info(std::string_view name) const
Definition x509cert.cpp:742
const std::vector< uint8_t > & raw_subject_dn_sha256() const
Definition x509cert.cpp:775
const std::vector< URI > & crl_distribution_point_uris() const
Definition x509cert.cpp:655
uint32_t x509_version() const
Definition x509cert.cpp:378
const std::vector< URI > & ca_issuer_uris() const
Definition x509cert.cpp:647
std::string crl_distribution_point() const
Definition x509cert.cpp:659
const std::vector< OID > & certificate_policy_oids() const
Definition x509cert.cpp:509
std::unique_ptr< Public_Key > load_subject_public_key() const
Definition x509cert.cpp:764
X509_Certificate(DataSource &source)
Definition x509cert.cpp:95
bool is_self_signed() const
Definition x509cert.cpp:382
bool matches_ip(const IPv4Address &address) const
Definition x509cert.cpp:842
const std::vector< uint8_t > & raw_issuer_dn() const
Definition x509cert.cpp:462
bool operator<(const X509_Certificate &other) const
Definition x509cert.cpp:878
std::span< const uint8_t, 20 > raw_subject_dn_sha1() const
Definition x509cert.cpp:786
const std::vector< uint8_t > & raw_issuer_dn_sha256() const
Definition x509cert.cpp:768
const AlgorithmIdentifier & subject_public_key_algo() const
Definition x509cert.cpp:394
const AlternativeName & subject_alt_name() const
Definition x509cert.cpp:686
std::vector< std::string > ca_issuers() const
Definition x509cert.cpp:643
const std::vector< uint8_t > & subject_public_key_info() const
Definition x509cert.cpp:410
std::vector< EmailAddress > subject_email_addresses() const
Definition x509cert.cpp:667
bool is_serial_negative() const
Definition x509cert.cpp:446
const std::vector< uint8_t > & subject_public_key_bitstring() const
Definition x509cert.cpp:414
std::unique_ptr< Public_Key > subject_public_key() const
Definition x509cert.cpp:756
const std::vector< uint8_t > & v2_subject_key_id() const
Definition x509cert.cpp:402
const X509_Time & not_before() const
Definition x509cert.cpp:386
std::vector< std::string > issuer_info(std::string_view name) const
Definition x509cert.cpp:749
std::span< const uint8_t, 20 > raw_issuer_dn_sha1() const
Definition x509cert.cpp:782
std::string to_string() const
Definition x509cert.cpp:942
bool has_field(const OID &oid) const
Definition x509_dn.cpp:258
std::vector< std::string > get_attribute(std::string_view attr) const
Definition x509_dn.cpp:290
const std::vector< uint8_t > & signed_body() const
Definition x509_obj.cpp:66
const AlgorithmIdentifier & signature_algorithm() const
Definition x509_obj.cpp:73
virtual std::vector< std::string > alternate_PEM_labels() const
Definition x509_obj.h:102
const std::vector< uint8_t > & signature() const
Definition x509_obj.cpp:59
void load_data(DataSource &src)
Definition x509_obj.cpp:24
virtual std::string PEM_label() const =0
std::string to_string() const
const char * name
Definition ffi_tls.h:59
std::vector< uint8_t > put_in_sequence(const std::vector< uint8_t > &contents)
Definition asn1_obj.cpp:208
std::unique_ptr< Public_Key > load_key(DataSource &source)
Definition x509_key.cpp:28
std::string PEM_encode(const Public_Key &key)
Definition x509_key.cpp:21
ASN1_Time X509_Time
Definition asn1_obj.h:27
ASN1_Type
Definition asn1_obj.h:47
std::string create_hex_fingerprint(std::span< const uint8_t > bits, std::string_view hash_name)
Definition pk_keys.cpp:40
void hex_encode(char output[], const uint8_t input[], size_t input_length, bool uppercase)
Definition hex.cpp:34
bool operator!=(const AlgorithmIdentifier &x, const AlgorithmIdentifier &y)
Definition alg_id.cpp:58
std::string format_hex_fingerprint(std::span< const uint8_t > bits)
Definition pk_keys.cpp:47
std::string escape_control_chars(std::string_view utf8)
Definition charset.cpp:207