9#include <botan/x509cert.h>
11#include <botan/asn1_obj.h>
12#include <botan/asn1_time.h>
13#include <botan/ber_dec.h>
14#include <botan/hash.h>
16#include <botan/pk_keys.h>
18#include <botan/x509_ext.h>
19#include <botan/x509_key.h>
20#include <botan/internal/charset.h>
25class X509_Certificate_Data final {
27 X509_Serial_Number m_serial;
29 std::vector<uint8_t> m_serial_bits;
30 AlgorithmIdentifier m_sig_algo_inner;
33 std::vector<uint8_t> m_issuer_dn_bits;
34 std::vector<uint8_t> m_subject_dn_bits;
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;
43 std::vector<uint8_t> m_subject_public_key_bitstring_sha1;
44 std::array<uint8_t, 32> m_subject_public_key_bitstring_sha256 = {};
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;
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;
55 std::vector<URI> m_crl_distribution_points;
56 std::vector<URI> m_ocsp_responders;
57 std::vector<URI> m_ca_issuers;
60 std::vector<uint8_t> m_issuer_dn_bits_sha256;
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 = {};
66 std::string m_fingerprint_sha1;
67 std::string m_fingerprint_sha256;
69 std::array<uint8_t, 20> m_cert_data_sha1 = {};
70 std::array<uint8_t, 32> m_cert_data_sha256 = {};
72 AlternativeName m_subject_alt_name;
73 AlternativeName m_issuer_alt_name;
74 NameConstraints m_name_constraints;
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;
92 return {
"X509 CERTIFICATE"};
104#if defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
113std::unique_ptr<X509_Certificate_Data> parse_x509_cert_body(
const X509_Object& obj) {
114 auto data = std::make_unique<X509_Certificate_Data>();
116 BER_Object public_key;
117 BER_Object v3_exts_data;
121 .decode(data->m_serial)
122 .decode(data->m_sig_algo_inner)
123 .decode(data->m_issuer_dn)
125 .decode(data->m_not_before)
126 .decode(data->m_not_after)
128 .decode(data->m_subject_dn)
129 .get_next(public_key)
132 .get_next(v3_exts_data)
133 .verify_end(
"TBSCertificate has extra data after extensions block");
135 if(data->m_version > 2) {
136 throw Decoding_Error(
"Unknown X.509 cert version " + std::to_string(data->m_version));
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");
145 data->m_version += 1;
147 data->m_serial_bits = data->m_serial.magnitude();
151 data->m_subject_public_key_bits.assign(public_key.bits(), public_key.bits() + public_key.length());
156 .
decode(data->m_subject_public_key_algid)
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());
171 data->m_key_constraints = ext->get_constraints();
176 if(data->m_key_constraints.empty()) {
177 throw Decoding_Error(
"Certificate has invalid encoding for KeyUsage");
182 data->m_subject_key_id = ext->get_key_id();
186 data->m_authority_key_id = ext->get_key_id();
190 data->m_name_constraints = ext->get_name_constraints();
194 data->m_extended_key_usage = ext->object_identifiers();
206 if(data->m_extended_key_usage.empty()) {
207 throw Decoding_Error(
"Certificate has invalid empty EKU extension");
217 if(ext->is_ca() ==
true) {
225 const bool allowed_by_ku =
240 const bool allowed_by_ext_ku = [](
const std::vector<OID>& ext_ku) ->
bool {
248 const auto any_eku =
OID::from_name(
"X509v3.AnyExtendedKeyUsage");
250 for(
const auto& oid : ext_ku) {
251 if(oid == any_eku || oid == server_auth || oid == client_auth || oid == ocsp_sign) {
257 }(data->m_extended_key_usage);
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();
267 data->m_issuer_alt_name = ext->get_alt_name();
271 data->m_subject_alt_name = ext->get_alt_name();
278 data->m_subject_alt_name_exists = data->m_v3_extensions.extension_set(san_oid);
288 data->m_skip_revocation_check =
293 data->m_cert_policies = ext->get_policy_oids();
297 data->m_ocsp_responders = ext->ocsp_responder_uris();
298 data->m_ca_issuers = ext->ca_issuer_uris();
302 data->m_crl_distribution_points = ext->crl_distribution_point_uris();
309 if(data->m_subject_dn == data->m_issuer_dn) {
310 if(!data->m_subject_key_id.empty() && !data->m_authority_key_id.empty()) {
315 data->m_self_signed = (data->m_subject_key_id == data->m_authority_key_id);
321 data->m_self_signed =
true;
325 const std::vector<uint8_t> full_encoding = obj.BER_encode();
328 sha1->update(data->m_subject_public_key_bitstring);
329 data->m_subject_public_key_bitstring_sha1 = sha1->final_stdvec();
332 sha1->update(full_encoding);
333 sha1->final(data->m_cert_data_sha1);
336 sha1->update(data->m_issuer_dn_bits);
337 sha1->final(data->m_issuer_dn_bits_sha1);
339 sha1->update(data->m_subject_dn_bits);
340 sha1->final(data->m_subject_dn_bits_sha1);
345 sha256->update(data->m_issuer_dn_bits);
346 data->m_issuer_dn_bits_sha256 = sha256->final_stdvec();
348 sha256->update(data->m_subject_dn_bits);
349 data->m_subject_dn_bits_sha256 = sha256->final_stdvec();
351 sha256->update(full_encoding);
352 sha256->final(data->m_cert_data_sha256);
355 sha256->update(data->m_subject_public_key_bitstring);
356 sha256->final(data->m_subject_public_key_bitstring_sha256);
366void X509_Certificate::force_decode() {
368 m_data = parse_x509_cert_body(*
this);
371const X509_Certificate_Data& X509_Certificate::data()
const {
372 if(m_data ==
nullptr) {
373 throw Invalid_State(
"X509_Certificate uninitialized");
379 return static_cast<uint32_t
>(data().m_version);
383 return data().m_self_signed;
387 return data().m_not_before;
391 return data().m_not_after;
395 return data().m_subject_public_key_algid;
399 return data().m_v2_issuer_key_id;
403 return data().m_v2_subject_key_id;
407 return data().m_subject_public_key_bits;
411 return data().m_subject_public_key_bits_seq;
415 return data().m_subject_public_key_bitstring;
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");
423 return data().m_subject_public_key_bitstring_sha1;
427 return data().m_subject_public_key_bitstring_sha256;
431 return data().m_authority_key_id;
435 return data().m_subject_key_id;
439 return data().m_serial_bits;
443 return data().m_serial;
451 return data().m_skip_revocation_check;
455 return data().m_issuer_dn;
459 return data().m_subject_dn;
463 return data().m_issuer_dn_bits;
467 return data().m_subject_dn_bits;
471 if(data().m_fingerprint_sha1.empty()) {
474 return data().m_cert_data_sha1;
478 return data().m_cert_data_sha256;
482 if(data().m_version < 3 && data().m_self_signed) {
486 return data().m_is_ca_certificate;
490 if(data().m_version < 3 && data().m_self_signed) {
494 return static_cast<uint32_t
>(data().m_path_len_constraint.value_or(Cert_Extension::NO_CERT_PATH_LIMIT));
498 return data().m_path_len_constraint;
502 return data().m_key_constraints;
506 return data().m_extended_key_usage;
510 return data().m_cert_policies;
514 return data().m_name_constraints;
518 return data().m_v3_extensions;
585 const auto any_eku =
OID::from_name(
"X509v3.AnyExtendedKeyUsage");
589 if(ext_ku == usage) {
600 if(ext_ku == any_eku && usage != ocsp_eku) {
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());
629 if(data().m_ocsp_responders.empty()) {
632 return data().m_ocsp_responders[0].original_input();
636 return uris_as_strings(data().m_ocsp_responders);
640 return data().m_ocsp_responders;
644 return uris_as_strings(data().m_ca_issuers);
648 return data().m_ca_issuers;
652 return uris_as_strings(data().m_crl_distribution_points);
656 return data().m_crl_distribution_points;
661 if(!data().m_crl_distribution_points.empty()) {
662 return data().m_crl_distribution_points[0].original_input();
670 std::vector<EmailAddress> out;
671 out.reserve(san_emails.size());
673 for(
const auto& addr : san_emails) {
677 for(
const auto& dn_email_str :
subject_dn().get_attribute(
"PKCS9.EmailAddress")) {
679 out.push_back(std::move(*parsed));
687 return data().m_subject_alt_name;
691 return data().m_issuer_alt_name;
696std::vector<std::string> get_cert_user_info(std::string_view req,
const X509_DN& dn,
const AlternativeName& alt_name) {
699 }
else if(req ==
"RFC822" || req ==
"Email") {
700 std::vector<std::string> out;
703 out.push_back(addr.to_string());
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());
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());
720 }
else if(req ==
"IP") {
721 std::vector<std::string> ip_str;
723 ip_str.push_back(ipv4.to_string());
726 }
else if(req ==
"IPv6") {
727 std::vector<std::string> ip_str;
729 ip_str.push_back(ipv6.to_string());
759 }
catch(std::exception& e) {
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");
772 return data().m_issuer_dn_bits_sha256;
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");
779 return data().m_subject_dn_bits_sha256;
783 return data().m_issuer_dn_bits_sha1;
787 return data().m_subject_dn_bits_sha1;
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;
810 return Tag(data().m_cert_data_sha256);
816 for(
const auto& san : sans) {
817 if(
name.matches_wildcard(san.name())) {
829 if(!data().m_subject_alt_name_exists) {
830 for(
const auto& cn :
subject_dn().get_attribute(
"CN")) {
832 if(
name.matches_wildcard(cn_dns->name())) {
892 return !(cert1 == cert2);
897void format_alt_name(std::ostream& out, std::string_view label,
const AlternativeName& alt_name) {
898 if(alt_name.is_empty()) {
902 out << label <<
":\n";
904 for(
const auto& dns : alt_name.dns_names()) {
907 for(
const auto& ipv4 : alt_name.ipv4_addresses()) {
908 out <<
" IP: " << ipv4.to_string() <<
"\n";
910 for(
const auto& ipv6 : alt_name.ipv6_addresses()) {
911 out <<
" IP: " << ipv6.to_string() <<
"\n";
913 for(
const auto& uri : alt_name.uri_names()) {
916 for(
const auto& email : alt_name.email_addresses()) {
919 for(
const auto& mbox : alt_name.smtp_utf8_mailboxes()) {
922 for(
const auto& dn : alt_name.directory_names()) {
923 out <<
" DirName: " << dn <<
"\n";
925 for(
const auto& oid : alt_name.registered_ids()) {
926 out <<
" RegisteredID: " << oid.to_formatted_string() <<
"\n";
932 for(
const auto& other : alt_name.other_name_values()) {
933 if(other.oid() == smtp_utf8_oid) {
936 out <<
" OtherName " << other.oid().to_formatted_string() <<
": " <<
hex_encode(other.value()) <<
"\n";
943 std::ostringstream out;
947 out <<
"Issuer: " <<
issuer_dn() <<
"\n";
953 out <<
"Public Key [" << pubkey->algo_name() <<
"-" << pubkey->key_length() <<
"]\n\n";
957 out <<
"Public Key Invalid!\n"
959 <<
" Error: " << ex.
what() <<
"\n"
965 out <<
"Constraints:\n";
967 if(constraints.
empty()) {
968 out <<
" No key constraints set\n";
971 out <<
" Digital Signature\n";
974 out <<
" Non-Repudiation\n";
977 out <<
" Key Encipherment\n";
980 out <<
" Data Encipherment\n";
983 out <<
" Key Agreement\n";
986 out <<
" Cert Sign\n";
989 out <<
" CRL Sign\n";
992 out <<
" Encipher Only\n";
995 out <<
" Decipher Only\n";
1000 out <<
"Basic Constraints: CA";
1002 out <<
", path length " << *path_len;
1008 if(!policies.empty()) {
1011 for(
const auto& oid : policies) {
1012 out <<
" " << oid.to_string() <<
"\n";
1017 if(!ex_constraints.empty()) {
1018 out <<
"Extended Constraints:\n";
1019 for(
auto&& oid : ex_constraints) {
1020 out <<
" " << oid.to_formatted_string() <<
"\n";
1027 out <<
"Name Constraints:\n";
1032 out <<
" " << st.base();
1040 out <<
" " << st.base();
1048 out <<
"OCSP Responders:\n";
1056 out <<
"CA Issuers:\n";
1058 out <<
" URI: " << ca_issuer.original_input() <<
"\n";
1063 out <<
"CRL " << cdp.original_input() <<
"\n";
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()) {
1074 out <<
" Range: " << entry.range().start().to_string() <<
" count " << entry.range().count() <<
"\n";
1077 out <<
" TN: " << entry.number().to_string() <<
"\n";
1095 format_alt_name(out,
"Issuer Alternative Name", this->
issuer_alt_name());
1098 out <<
"Revocation status checking is disabled for this certificate\n";
1102 out <<
"Certificate is self signed\n";
std::vector< uint8_t > BER_encode() const
std::string readable_string() const
Returns a human friendly string representation of no particular formatting.
const std::set< IPv6Address > & ipv6_addresses() const
Return the set of IPv6 addresses included in this alternative name.
const std::set< DNSName > & dns_names() const
Return the set of DNS names included in this alternative name.
const std::set< EmailAddress > & email_addresses() const
Return the set of email addresses included in this alternative name.
const std::set< IPv4Address > & ipv4_addresses() const
Return the set of IPv4 addresses included in this alternative name.
const std::set< URI > & uri_names() const
Return the set of URIs included in this alternative name.
BER_Decoder & decode(bool &out)
BER_Decoder & verify_end()
BER_Decoder & decode_octet_aligned_bitstring(T &out_wrapped, ASN1_Type type_tag=ASN1_Type::BitString, ASN1_Class class_tag=ASN1_Class::Universal)
static std::optional< DNSName > from_san_string(std::string_view name)
static std::optional< DNSName > from_string(std::string_view name)
static std::optional< EmailAddress > from_string(std::string_view addr)
const char * what() const noexcept override
bool critical_extension_set(const OID &oid) const
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
static std::unique_ptr< HashFunction > create(std::string_view algo_spec, std::string_view provider="")
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
const std::vector< GeneralSubtree > & permitted() const
std::string to_formatted_string() const
static std::optional< OID > from_name(std::string_view name)
static OID from_string(std::string_view str)
const std::vector< OID > & extended_key_usage() const
Key_Constraints constraints() const
bool operator==(const X509_Certificate &other) const
const NameConstraints & name_constraints() const
X509_Certificate()=default
std::vector< std::string > ocsp_responders() const
bool is_critical(std::string_view ex_name) const
const std::vector< uint8_t > & serial_number() const
std::string fingerprint(std::string_view hash_name="SHA-1") const
const std::vector< URI > & ocsp_responder_uris() const
const X509_DN & subject_dn() const
bool skip_revocation_check() const
uint32_t path_limit() const
const X509_Serial_Number & serial() const
const X509_Time & not_after() const
const std::vector< uint8_t > & authority_key_id() const
std::span< const uint8_t, 32 > certificate_data_sha256() const
bool allowed_extended_usage(std::string_view usage) const
const AlternativeName & issuer_alt_name() const
const std::vector< uint8_t > & raw_subject_dn() const
const std::vector< uint8_t > & subject_key_id() const
~X509_Certificate() override
std::span< const uint8_t, 32 > subject_public_key_bitstring_sha256() const
const std::vector< uint8_t > & subject_public_key_bits() const
bool has_constraints(Key_Constraints constraints) const
std::optional< size_t > path_length_constraint() const
const Extensions & v3_extensions() const
bool has_ex_constraint(std::string_view ex_constraint) const
std::vector< std::string > crl_distribution_points() const
const std::vector< uint8_t > & subject_public_key_bitstring_sha1() const
bool allowed_usage(Key_Constraints usage) const
const X509_DN & issuer_dn() const
const std::vector< uint8_t > & v2_issuer_key_id() const
std::string ocsp_responder() const
std::span< const uint8_t, 20 > certificate_data_sha1() const
bool matches_dns_name(std::string_view name) const
std::vector< std::string > subject_info(std::string_view name) const
const std::vector< uint8_t > & raw_subject_dn_sha256() const
const std::vector< URI > & crl_distribution_point_uris() const
uint32_t x509_version() const
const std::vector< URI > & ca_issuer_uris() const
std::string crl_distribution_point() const
const std::vector< OID > & certificate_policy_oids() const
std::unique_ptr< Public_Key > load_subject_public_key() const
X509_Certificate(DataSource &source)
bool is_self_signed() const
bool matches_ip(const IPv4Address &address) const
const std::vector< uint8_t > & raw_issuer_dn() const
bool operator<(const X509_Certificate &other) const
std::span< const uint8_t, 20 > raw_subject_dn_sha1() const
const std::vector< uint8_t > & raw_issuer_dn_sha256() const
const AlgorithmIdentifier & subject_public_key_algo() const
const AlternativeName & subject_alt_name() const
std::vector< std::string > ca_issuers() const
const std::vector< uint8_t > & subject_public_key_info() const
std::vector< EmailAddress > subject_email_addresses() const
bool is_serial_negative() const
const std::vector< uint8_t > & subject_public_key_bitstring() const
std::unique_ptr< Public_Key > subject_public_key() const
const std::vector< uint8_t > & v2_subject_key_id() const
const X509_Time & not_before() const
std::vector< std::string > issuer_info(std::string_view name) const
std::span< const uint8_t, 20 > raw_issuer_dn_sha1() const
std::string to_string() const
bool has_field(const OID &oid) const
std::vector< std::string > get_attribute(std::string_view attr) const
const std::vector< uint8_t > & signed_body() const
const AlgorithmIdentifier & signature_algorithm() const
virtual std::vector< std::string > alternate_PEM_labels() const
const std::vector< uint8_t > & signature() const
void load_data(DataSource &src)
virtual std::string PEM_label() const =0
std::string to_string() const
std::vector< uint8_t > put_in_sequence(const std::vector< uint8_t > &contents)
std::unique_ptr< Public_Key > load_key(DataSource &source)
std::string PEM_encode(const Public_Key &key)
std::string create_hex_fingerprint(std::span< const uint8_t > bits, std::string_view hash_name)
void hex_encode(char output[], const uint8_t input[], size_t input_length, bool uppercase)
bool operator!=(const AlgorithmIdentifier &x, const AlgorithmIdentifier &y)
std::string format_hex_fingerprint(std::span< const uint8_t > bits)
std::string escape_control_chars(std::string_view utf8)