9#ifndef BOTAN_X509_EXTENSIONS_H_
10#define BOTAN_X509_EXTENSIONS_H_
12#include <botan/bigint.h>
13#include <botan/ipv4_address.h>
14#include <botan/ipv6_address.h>
15#include <botan/pkix_types.h>
16#include <botan/telephone_number.h>
35static const size_t NO_CERT_PATH_LIMIT = 0xFFFFFFF0;
42 std::unique_ptr<Certificate_Extension>
copy()
const override {
43 return std::make_unique<Basic_Constraints>(m_is_ca, m_path_length_constraint);
56 BOTAN_DEPRECATED(
"Use path_length_constraint") size_t get_path_limit() const;
58 bool is_ca()
const {
return m_is_ca; }
67 std::string oid_name()
const override {
return "X509v3.BasicConstraints"; }
71 std::vector<uint8_t> encode_inner()
const override;
72 void decode_inner(
const std::vector<uint8_t>& in)
override;
75 std::optional<size_t> m_path_length_constraint;
83 std::unique_ptr<Certificate_Extension>
copy()
const override {
84 return std::make_unique<Key_Usage>(m_constraints);
98 std::string oid_name()
const override {
return "X509v3.KeyUsage"; }
102 bool should_encode()
const override {
return !m_constraints.empty(); }
104 std::vector<uint8_t> encode_inner()
const override;
105 void decode_inner(
const std::vector<uint8_t>& in)
override;
107 Key_Constraints m_constraints;
130 Subject_Key_ID(const std::vector<uint8_t>& public_key, std::string_view hash_fn);
133 return std::make_unique<Subject_Key_ID>(m_key_id);
136 const std::vector<uint8_t>&
get_key_id()
const {
return m_key_id; }
143 std::string oid_name()
const override {
return "X509v3.SubjectKeyIdentifier"; }
147 bool should_encode()
const override {
return (!m_key_id.empty()); }
149 std::vector<uint8_t> encode_inner()
const override;
150 void decode_inner(
const std::vector<uint8_t>& in)
override;
152 std::vector<uint8_t> m_key_id;
160 std::unique_ptr<Certificate_Extension>
copy()
const override {
return std::make_unique<Authority_Key_ID>(*
this); }
176 m_key_id(k), m_authority_cert(std::move(authority_cert)) {}
178 const std::vector<uint8_t>&
get_key_id()
const {
return m_key_id; }
190 std::string oid_name()
const override {
return "X509v3.AuthorityKeyIdentifier"; }
194 bool should_encode()
const override {
return !m_key_id.empty() || m_authority_cert.has_value(); }
196 std::vector<uint8_t> encode_inner()
const override;
197 void decode_inner(
const std::vector<uint8_t>& in)
override;
199 std::vector<uint8_t> m_key_id;
200 std::optional<Authority_Cert_Identifier> m_authority_cert;
214 std::unique_ptr<Certificate_Extension>
copy()
const override {
215 return std::make_unique<Subject_Alternative_Name>(
get_alt_name());
221 std::string oid_name()
const override {
return "X509v3.SubjectAlternativeName"; }
225 bool should_encode()
const override {
return m_alt_name.has_items(); }
227 std::vector<uint8_t> encode_inner()
const override;
228 void decode_inner(
const std::vector<uint8_t>& in)
override;
230 AlternativeName m_alt_name;
244 std::unique_ptr<Certificate_Extension>
copy()
const override {
245 return std::make_unique<Issuer_Alternative_Name>(
get_alt_name());
251 std::string oid_name()
const override {
return "X509v3.IssuerAlternativeName"; }
255 bool should_encode()
const override {
return m_alt_name.has_items(); }
257 std::vector<uint8_t> encode_inner()
const override;
258 void decode_inner(
const std::vector<uint8_t>& in)
override;
260 AlternativeName m_alt_name;
268 std::unique_ptr<Certificate_Extension>
copy()
const override {
269 return std::make_unique<Extended_Key_Usage>(m_oids);
283 std::string oid_name()
const override {
return "X509v3.ExtendedKeyUsage"; }
287 bool should_encode()
const override {
return (!m_oids.empty()); }
289 std::vector<uint8_t> encode_inner()
const override;
290 void decode_inner(
const std::vector<uint8_t>& in)
override;
292 std::vector<OID> m_oids;
300 std::unique_ptr<Certificate_Extension>
copy()
const override {
301 return std::make_unique<Name_Constraints>(m_name_constraints);
309 const std::optional<X509_Certificate>& issuer,
310 const std::vector<X509_Certificate>& cert_path,
311 std::vector<std::set<Certificate_Status_Code>>& cert_status,
312 size_t pos)
const override;
321 std::string oid_name()
const override {
return "X509v3.NameConstraints"; }
325 bool should_encode()
const override {
return true; }
327 std::vector<uint8_t> encode_inner()
const override;
328 void decode_inner(
const std::vector<uint8_t>& in)
override;
330 NameConstraints m_name_constraints;
338 std::unique_ptr<Certificate_Extension>
copy()
const override {
339 return std::make_unique<Certificate_Policies>(*
this);
353 const std::optional<X509_Certificate>& issuer,
354 const std::vector<X509_Certificate>& cert_path,
355 std::vector<std::set<Certificate_Status_Code>>& cert_status,
356 size_t pos)
const override;
359 std::string oid_name()
const override {
return "X509v3.CertificatePolicies"; }
363 bool should_encode()
const override {
return (!m_oids.empty()); }
365 std::vector<uint8_t> encode_inner()
const override;
366 void decode_inner(
const std::vector<uint8_t>& in)
override;
368 std::vector<OID> m_oids;
369 bool m_has_duplicate =
false;
391 m_method(std::move(method)),
416 std::optional<std::string> location_as_uri_string()
const;
422 std::vector<uint8_t> m_location_value;
425 std::unique_ptr<Certificate_Extension> copy()
const override;
431 const std::vector<std::
string>&
ca_issuers = std::vector<std::
string>());
435 const std::vector<std::
string>&
ca_issuers = std::vector<std::
string>());
457 if(m_ocsp_responders.empty()) {
460 return m_ocsp_responders[0].original_input();
463 BOTAN_DEPRECATED(
"Use ocsp_responder_uris") std::vector<std::
string> ocsp_responders() const;
477 BOTAN_DEPRECATED(
"Use ca_issuer_uris") std::vector<std::
string> ca_issuers() const;
482 std::string oid_name()
const override {
return "PKIX.AuthorityInformationAccess"; }
486 bool should_encode()
const override {
488 return !m_access_descriptions.empty();
491 std::vector<uint8_t> encode_inner()
const override;
492 void decode_inner(
const std::vector<uint8_t>& in)
override;
494 std::vector<URI> m_ocsp_responders;
495 std::vector<URI> m_ca_issuers;
496 std::vector<AccessDescription> m_access_descriptions;
504 std::unique_ptr<Certificate_Extension>
copy()
const override;
512 const BigInt& crl_number()
const;
521 std::string oid_name()
const override {
return "X509v3.CRLNumber"; }
525 bool should_encode()
const override {
return m_has_value; }
527 std::vector<uint8_t> encode_inner()
const override;
528 void decode_inner(
const std::vector<uint8_t>& in)
override;
539 std::unique_ptr<Certificate_Extension>
copy()
const override {
540 return std::make_unique<CRL_ReasonCode>(m_reason);
552 std::string oid_name()
const override {
return "X509v3.ReasonCode"; }
558 std::vector<uint8_t> encode_inner()
const override;
559 void decode_inner(
const std::vector<uint8_t>& in)
override;
592 const std::optional<AlternativeName>&
full_name()
const {
return m_full_name; }
595 std::optional<AlternativeName> m_full_name;
619 std::optional<ReasonFlags>
reasons,
621 m_dp_name(std::move(dp_name)), m_reasons(
reasons), m_crl_issuer(std::move(
crl_issuer)) {}
631 const std::optional<ReasonFlags>&
reasons()
const {
return m_reasons; }
636 const std::optional<AlternativeName>&
crl_issuer()
const {
return m_crl_issuer; }
654 return std::make_unique<CRL_Distribution_Points>(*
this);
663 BOTAN_DEPRECATED(
"Use crl_distribution_point_uris") std::vector<std::
string> crl_distribution_urls() const;
672 std::string oid_name()
const override {
return "X509v3.CRLDistributionPoints"; }
676 bool should_encode()
const override {
return !m_distribution_points.empty(); }
678 std::vector<uint8_t> encode_inner()
const override;
679 void decode_inner(
const std::vector<uint8_t>& in)
override;
681 std::vector<Distribution_Point> m_distribution_points;
682 std::vector<URI> m_crl_distribution_urls;
708 m_dp_name(std::move(dp_name)),
723 std::unique_ptr<Certificate_Extension>
copy()
const override {
724 return std::make_unique<CRL_Issuing_Distribution_Point>(*
this);
754 std::string oid_name()
const override {
return "X509v3.CRLIssuingDistributionPoint"; }
763 bool should_encode()
const override {
764 return m_dp_name.has_value() || m_only_contains_user_certs || m_only_contains_ca_certs ||
765 m_only_some_reasons.has_value() || m_indirect_crl || m_only_contains_attribute_certs;
768 std::vector<uint8_t> encode_inner()
const override;
769 void decode_inner(
const std::vector<uint8_t>& in)
override;
771 std::optional<DistributionPointName> m_dp_name;
772 bool m_only_contains_user_certs =
false;
773 bool m_only_contains_ca_certs =
false;
774 std::optional<ReasonFlags> m_only_some_reasons;
775 bool m_indirect_crl =
false;
776 bool m_only_contains_attribute_certs =
false;
794 std::unique_ptr<Certificate_Extension>
copy()
const override {
return std::make_unique<OCSP_NoCheck>(); }
801 const std::optional<X509_Certificate>& issuer,
802 const std::vector<X509_Certificate>& cert_path,
803 std::vector<std::set<Certificate_Status_Code>>& cert_status,
804 size_t pos)
const override;
807 std::string oid_name()
const override {
return "PKIX.OCSP.NoCheck"; }
811 bool should_encode()
const override {
return true; }
813 std::vector<uint8_t> encode_inner()
const override;
815 void decode_inner(
const std::vector<uint8_t>& in)
override;
837 std::unique_ptr<Certificate_Extension>
copy()
const override {
return std::make_unique<NoRevocationAvailable>(); }
844 const std::optional<X509_Certificate>& issuer,
845 const std::vector<X509_Certificate>& cert_path,
846 std::vector<std::set<Certificate_Status_Code>>& cert_status,
847 size_t pos)
const override;
850 std::string oid_name()
const override {
return "X509v3.NoRevocationAvailable"; }
854 bool should_encode()
const override {
return true; }
856 std::vector<uint8_t> encode_inner()
const override;
857 void decode_inner(
const std::vector<uint8_t>& in)
override;
924 const std::string& service_provider_code()
const;
939 BOTAN_DEPRECATED(
"Use range()") const RangeContainer& telephone_number_range() const;
944 BOTAN_DEPRECATED(
"Use number()") const std::
string& telephone_number() const;
949 Type m_type = ServiceProviderCode;
952 RangeContainer m_legacy_range;
977 const std::vector<Entry>&
entries()
const {
return m_tn_entries; }
989 bool encompasses(
const TNAuthList& delegate)
const;
997 const std::optional<X509_Certificate>& issuer,
998 const std::vector<X509_Certificate>& cert_path,
999 std::vector<std::set<Certificate_Status_Code>>& cert_status,
1000 size_t pos)
const override;
1003 std::string oid_name()
const override {
return "PKIX.TNAuthList"; }
1007 bool should_encode()
const override {
return !m_tn_entries.empty(); }
1009 std::vector<uint8_t> encode_inner()
const override;
1010 void decode_inner(
const std::vector<uint8_t>& in)
override;
1012 std::vector<Entry> m_tn_entries;
1037 template <Version V>
1039 static constexpr size_t Length =
static_cast<size_t>(V);
1041 using Address = std::conditional_t<V == Version::IPv4, IPv4Address, IPv6Address>;
1045 explicit IPAddress(std::span<const uint8_t> v);
1060 std::array<uint8_t, Length>
to_bytes()
const {
return m_value; }
1066 operator Address()
const {
return Address(m_value); }
1072 static IPAddress<V> from_bytes(std::span<const uint8_t> v);
1080 for(
size_t i = 0; i < rhs; i++) {
1081 lhs = lhs.successor();
1087 for(
size_t i = 0; i < Length; i++) {
1088 if(lhs.m_value[i] < rhs.m_value[i]) {
1089 return std::strong_ordering::less;
1090 }
else if(lhs.m_value[i] > rhs.m_value[i]) {
1091 return std::strong_ordering::greater;
1094 return std::strong_ordering::equal;
1098 return lhs.m_value == rhs.m_value;
1101 std::array<uint8_t, Length> m_value;
1107 template <Version V>
1109 using Address = std::conditional_t<V == Version::IPv4, IPv4Address, IPv6Address>;
1110 using Subnet = std::conditional_t<V == Version::IPv4, IPv4Subnet, IPv6Subnet>;
1151 std::optional<Subnet> as_subnet()
const;
1155 IPAddress<V> m_max{};
1157 IPAddress<V> decode_single_address(
const ASN1_BitString& decoded,
bool min);
1160 template <Version V>
1166 const std::optional<std::vector<IPAddressOrRange<V>>>&
ranges()
const {
return m_ip_addr_ranges; }
1173 std::optional<std::vector<IPAddressOrRange<V>>> m_ip_addr_ranges;
1186 m_safi(
safi), m_ip_addr_choice(choice) {
1194 uint16_t
afi()
const {
return m_afi; }
1196 std::optional<uint8_t>
safi()
const {
return m_safi; }
1202 std::optional<uint8_t> m_safi;
1203 AddrChoice m_ip_addr_choice;
1208 explicit IPAddressBlocks(
const std::vector<IPAddressFamily>& blocks) : m_ip_addr_blocks(blocks) {
1209 this->sort_and_merge();
1212 std::unique_ptr<Certificate_Extension>
copy()
const override {
return std::make_unique<IPAddressBlocks>(*
this); }
1219 const std::optional<X509_Certificate>& issuer,
1220 const std::vector<X509_Certificate>& cert_path,
1221 std::vector<std::set<Certificate_Status_Code>>& cert_status,
1222 size_t pos)
const override;
1255 template <Version V>
1257 void
add_address(const std::array<uint8_t, static_cast<
size_t>(V)>& address,
1258 std::optional<uint8_t> safi = std::nullopt) {
1263 template <Version V>
1265 void
add_address(const std::array<uint8_t, static_cast<std::
size_t>(V)>& min,
1266 const std::array<uint8_t, static_cast<std::
size_t>(V)>& max,
1267 std::optional<uint8_t> safi = std::nullopt) {
1268 add_range(
IPAddressOrRange<V>(IPAddress<V>::from_bytes(min), IPAddress<V>::from_bytes(max)), safi);
1272 template <Version V>
1273 void restrict(std::optional<uint8_t> safi = std::nullopt) {
1274 std::vector<IPAddressOrRange<V>> addresses = {};
1280 template <Version V>
1281 void inherit(std::optional<uint8_t> safi = std::nullopt) {
1286 const std::vector<IPAddressFamily>&
addr_blocks()
const {
return m_ip_addr_blocks; }
1295 std::string oid_name()
const override {
return "PKIX.IpAddrBlocks"; }
1299 bool should_encode()
const override {
return true; }
1301 std::vector<uint8_t> encode_inner()
const override;
1302 void decode_inner(
const std::vector<uint8_t>& in)
override;
1304 std::vector<IPAddressFamily> m_ip_addr_blocks;
1305 size_t m_v4_count = 0;
1306 size_t m_v6_count = 0;
1308 template <Version V>
1309 void add_range(
const IPAddressOrRange<V>& range, std::optional<uint8_t> safi) {
1310 std::vector<IPAddressOrRange<V>> addresses = {range};
1311 m_ip_addr_blocks.push_back(IPAddressFamily(IPAddressChoice<V>(addresses), safi));
1315 void sort_and_merge();
1361 const std::optional<std::vector<ASIdOrRange>>&
ranges()
const {
return m_as_ranges; }
1364 std::optional<std::vector<ASIdOrRange>> m_as_ranges;
1373 const std::optional<ASIdentifierChoice>&
rdi) :
1375 if(!m_asnum.has_value() && !m_rdi.has_value()) {
1376 throw Decoding_Error(
"One of asnum, rdi must be present");
1380 const std::optional<ASIdentifierChoice>&
asnum()
const {
return m_asnum; }
1382 const std::optional<ASIdentifierChoice>&
rdi()
const {
return m_rdi; }
1388 std::optional<ASIdentifierChoice> m_asnum;
1389 std::optional<ASIdentifierChoice> m_rdi;
1396 std::unique_ptr<Certificate_Extension>
copy()
const override {
return std::make_unique<ASBlocks>(*
this); }
1403 const std::optional<X509_Certificate>& issuer,
1404 const std::vector<X509_Certificate>& cert_path,
1405 std::vector<std::set<Certificate_Status_Code>>& cert_status,
1406 size_t pos)
const override;
1413 m_as_identifiers =
ASIdentifiers(add_new(m_as_identifiers.asnum(), min, max), m_as_identifiers.rdi());
1418 std::vector<ASIdOrRange> empty;
1430 m_as_identifiers =
ASIdentifiers(m_as_identifiers.asnum(), add_new(m_as_identifiers.rdi(), min, max));
1435 std::vector<ASIdOrRange> empty;
1445 ASIdentifiers m_as_identifiers;
1447 std::string oid_name()
const override {
return "PKIX.AutonomousSysIds"; }
1451 bool should_encode()
const override {
return true; }
1453 static ASIdentifierChoice add_new(
const std::optional<ASIdentifierChoice>& old, asnum_t min, asnum_t max);
1455 std::vector<uint8_t> encode_inner()
const override;
1456 void decode_inner(
const std::vector<uint8_t>& in)
override;
1468 std::unique_ptr<Certificate_Extension>
copy()
const override {
1469 return std::make_unique<Unknown_Extension>(*
this);
1496 const std::optional<X509_Certificate>& ,
1497 const std::vector<X509_Certificate>& ,
1498 std::vector<std::set<Certificate_Status_Code>>& cert_status,
1499 size_t pos)
const override {
1500 if(m_failed_to_decode) {
1502 }
else if(m_critical) {
1508 std::string oid_name()
const override {
return ""; }
1512 bool should_encode()
const override {
return true; }
1514 std::vector<uint8_t> encode_inner()
const override;
1515 void decode_inner(
const std::vector<uint8_t>& in)
override;
1519 bool m_failed_to_decode;
1520 std::vector<uint8_t> m_bytes;
#define BOTAN_PUBLIC_API(maj, min)
#define BOTAN_DEPRECATED(msg)
#define BOTAN_FUTURE_EXPLICIT
void encode_into(DER_Encoder &to) const override
ASIdOrRange(asnum_t min, asnum_t max)
void decode_from(BER_Decoder &from) override
void encode_into(DER_Encoder &to) const override
ASIdentifierChoice()=default
void decode_from(BER_Decoder &from) override
const std::optional< std::vector< ASIdOrRange > > & ranges() const
const std::optional< ASIdentifierChoice > & asnum() const
ASIdentifiers(const std::optional< ASIdentifierChoice > &asnum, const std::optional< ASIdentifierChoice > &rdi)
const std::optional< ASIdentifierChoice > & rdi() const
void encode_into(DER_Encoder &to) const override
void decode_from(BER_Decoder &from) override
void inherit_asnum()
Mark the asnum entry as 'inherit'.
void restrict_rdi()
Make the extension contain no allowed rdi's.
void inherit_rdi()
Mark the rdi entry as 'inherit'.
void add_rdi(asnum_t min, asnum_t max)
Add an rdi range to this extension.
const ASIdentifiers & as_identifiers() const
ASBlocks(const ASIdentifiers &as_idents)
OID oid_of() const override
void restrict_asnum()
Make the extension contain no allowed asnum's.
std::unique_ptr< Certificate_Extension > copy() const override
void add_asnum(asnum_t asnum)
Add a single asnum to this extension.
void add_rdi(asnum_t rdi)
Add a single rdi to this extension.
void add_asnum(asnum_t min, asnum_t max)
Add an asnum range to this extension.
Authority_Key_ID(const std::vector< uint8_t > &k)
OID oid_of() const override
const std::optional< Authority_Cert_Identifier > & authority_cert_identifier() const
Authority_Key_ID()=default
std::unique_ptr< Certificate_Extension > copy() const override
const std::vector< uint8_t > & get_key_id() const
Authority_Key_ID(const std::vector< uint8_t > &k, Authority_Cert_Identifier authority_cert)
OID oid_of() const override
BOTAN_FUTURE_EXPLICIT Basic_Constraints(bool is_ca=false, size_t path_length_constraint=0)
std::unique_ptr< Certificate_Extension > copy() const override
std::optional< size_t > path_length_constraint() const
const std::optional< ReasonFlags > & reasons() const
Distribution_Point()=default
const std::optional< AlternativeName > & crl_issuer() const
void encode_into(DER_Encoder &to) const override
void decode_from(BER_Decoder &from) override
Distribution_Point(const AlternativeName &name)
Distribution_Point(std::optional< DistributionPointName > dp_name, std::optional< ReasonFlags > reasons, std::optional< AlternativeName > crl_issuer)
const std::optional< DistributionPointName > & distribution_point_name() const
CRL_Distribution_Points()=default
OID oid_of() const override
const std::vector< URI > & crl_distribution_point_uris() const
std::unique_ptr< Certificate_Extension > copy() const override
const std::vector< Distribution_Point > & distribution_points() const
bool only_contains_user_certs() const
const std::optional< DistributionPointName > & distribution_point_name() const
const std::optional< ReasonFlags > & only_some_reasons() const
OID oid_of() const override
std::unique_ptr< Certificate_Extension > copy() const override
bool only_contains_ca_certs() const
CRL_Issuing_Distribution_Point(DistributionPointName dp_name)
bool only_contains_attribute_certs() const
CRL_Issuing_Distribution_Point(std::optional< DistributionPointName > dp_name, bool only_contains_user_certs, bool only_contains_ca_certs, std::optional< ReasonFlags > only_some_reasons, bool indirect_crl, bool only_contains_attribute_certs)
CRL_Issuing_Distribution_Point()=default
bool indirect_crl() const
OID oid_of() const override
std::unique_ptr< Certificate_Extension > copy() const override
BOTAN_FUTURE_EXPLICIT CRL_Number(size_t n)
std::unique_ptr< Certificate_Extension > copy() const override
CRL_Code get_reason() const
CRL_ReasonCode(CRL_Code r=CRL_Code::Unspecified)
OID oid_of() const override
Certificate_Policies()=default
const std::vector< OID > & get_policy_oids() const
std::unique_ptr< Certificate_Extension > copy() const override
OID oid_of() const override
DistributionPointName()=default
const std::optional< AlternativeName > & full_name() const
DistributionPointName(AlternativeName full_name)
OID oid_of() const override
const std::vector< OID > & object_identifiers() const
std::unique_ptr< Certificate_Extension > copy() const override
Extended_Key_Usage()=default
Extended_Key_Usage(const std::vector< OID > &o)
const std::optional< std::vector< IPAddressOrRange< V > > > & ranges() const
void decode_from(BER_Decoder &from) override
void encode_into(DER_Encoder &to) const override
IPAddressChoice()=default
IPAddressChoice(std::optional< std::span< const IPAddressOrRange< V > > > ranges)
void encode_into(DER_Encoder &to) const override
std::variant< IPAddressChoice< Version::IPv4 >, IPAddressChoice< Version::IPv6 > > AddrChoice
IPAddressFamily(const AddrChoice &choice, std::optional< uint8_t > safi=std::nullopt)
std::optional< uint8_t > safi() const
void decode_from(BER_Decoder &from) override
const AddrChoice & addr_choice() const
IPAddressFamily()=default
IPAddressOrRange(const Address &min, const Address &max)
IPAddress< V > min() const
void encode_into(DER_Encoder &to) const override
IPAddressOrRange(const Subnet &subnet)
IPAddressOrRange(const IPAddress< V > &min, const IPAddress< V > &max)
IPAddressOrRange(const IPAddress< V > &addr)
IPAddressOrRange()=default
IPAddressOrRange(const Address &addr)
void decode_from(BER_Decoder &from) override
IPAddress< V > max() const
IPAddress(std::span< const uint8_t > v)
IPAddress(const Address &addr)
friend class IPAddressBlocks
friend bool operator==(const IPAddress< V > &lhs, const IPAddress< V > &rhs)
std::array< uint8_t, Length > to_bytes() const
friend std::strong_ordering operator<=>(const IPAddress< V > lhs, const IPAddress< V > &rhs)
std::array< uint8_t, Length > value() const
void inherit(std::optional< uint8_t > safi=std::nullopt)
Mark the specified IP version as 'inherit' (for the specified SAFI, if any).
IPAddressBlocks()=default
size_t v6_count() const
The number of IPv6 families contained in the extension.
void add_address(const IPv6Address &address, std::optional< uint8_t > safi=std::nullopt)
Add a single IPv6 address to this extension (for the specified SAFI, if any).
std::unique_ptr< Certificate_Extension > copy() const override
void restrict(std::optional< uint8_t > safi=std::nullopt)
Make the extension contain no allowed IP addresses for the specified IP version (and SAFI,...
void add_address(const IPv6Subnet &subnet, std::optional< uint8_t > safi=std::nullopt)
Add an IPv6 subnet to this extension (for the specified SAFI, if any).
void add_address(const IPv6Address &min, const IPv6Address &max, std::optional< uint8_t > safi=std::nullopt)
Add an IPv6 address range to this extension (for the specified SAFI, if any).
const std::vector< IPAddressFamily > & addr_blocks() const
void add_address(const IPv4Address &min, const IPv4Address &max, std::optional< uint8_t > safi=std::nullopt)
Add an IPv4 address range to this extension (for the specified SAFI, if any).
void add_address(const IPv4Address &address, std::optional< uint8_t > safi=std::nullopt)
Add a single IPv4 address to this extension (for the specified SAFI, if any).
void add_address(const IPv4Subnet &subnet, std::optional< uint8_t > safi=std::nullopt)
Add an IPv4 subnet to this extension (for the specified SAFI, if any).
IPAddressBlocks(const std::vector< IPAddressFamily > &blocks)
OID oid_of() const override
size_t v4_count() const
The number of IPv4 families contained in the extension.
std::unique_ptr< Certificate_Extension > copy() const override
const AlternativeName & get_alt_name() const
Issuer_Alternative_Name(const AlternativeName &name=AlternativeName())
OID oid_of() const override
std::unique_ptr< Certificate_Extension > copy() const override
OID oid_of() const override
Key_Usage(Key_Constraints c)
Key_Constraints get_constraints() const
BOTAN_FUTURE_EXPLICIT Name_Constraints(const NameConstraints &nc)
OID oid_of() const override
const NameConstraints & get_name_constraints() const
std::unique_ptr< Certificate_Extension > copy() const override
Name_Constraints()=default
std::unique_ptr< Certificate_Extension > copy() const override
OID oid_of() const override
NoRevocationAvailable()=default
std::unique_ptr< Certificate_Extension > copy() const override
OID oid_of() const override
const AlternativeName & get_alt_name() const
OID oid_of() const override
Subject_Alternative_Name(const AlternativeName &name=AlternativeName())
std::unique_ptr< Certificate_Extension > copy() const override
OID oid_of() const override
Subject_Key_ID(const std::vector< uint8_t > &k)
std::unique_ptr< Certificate_Extension > copy() const override
const std::vector< uint8_t > & get_key_id() const
static Entry from_service_provider_code(std::string_view spc)
static Entry from_telephone_number(const Botan::TelephoneNumber &tn)
void decode_from(BER_Decoder &from) override
std::vector< TelephoneNumberRangeData > RangeContainer
static Entry from_telephone_number_range(const Botan::TelephoneNumberRange &range)
void encode_into(DER_Encoder &to) const override
std::variant< ASN1_String, RangeContainer > DataContainer
const Botan::TelephoneNumberRange & range() const
std::unique_ptr< Certificate_Extension > copy() const override
static TNAuthList from_der(std::span< const uint8_t > der)
OID oid_of() const override
const std::vector< Entry > & entries() const
OID oid_of() const override
std::unique_ptr< Certificate_Extension > copy() const override
Unknown_Extension(const OID &oid, bool critical, bool failed_to_decode=false)
const std::vector< uint8_t > & extension_contents() const
bool failed_to_decode() const
void validate(const X509_Certificate &, const std::optional< X509_Certificate > &, const std::vector< X509_Certificate > &, std::vector< std::set< Certificate_Status_Code > > &cert_status, size_t pos) const override
bool is_critical_extension() const
@ EXTENSION_ENCODING_ERROR
@ UNKNOWN_CRITICAL_EXTENSION
X509_Serial_Number serial_number