8#include <botan/pkix_types.h>
10#include <botan/ber_dec.h>
11#include <botan/der_enc.h>
12#include <botan/internal/charset.h>
13#include <botan/internal/loadstor.h>
14#include <botan/internal/x509_utils.h>
26bool is_space(
char c) {
27 return c ==
' ' || c ==
'\t';
30std::optional<uint8_t> hex_digit_value(
char c) {
31 if(c >=
'0' && c <=
'9') {
32 return static_cast<uint8_t
>(c -
'0');
33 }
else if(c >=
'a' && c <=
'f') {
34 return static_cast<uint8_t
>(c -
'a' + 10);
35 }
else if(c >=
'A' && c <=
'F') {
36 return static_cast<uint8_t
>(c -
'A' + 10);
45bool is_escapable_char(
char c) {
63bool is_unescaped_special_value_char(
char c) {
79class X500_Char_Iterator final {
81 explicit X500_Char_Iterator(std::string_view s) : m_str(s), m_pos(0) {
83 while(m_pos < m_str.size() && is_space(m_str[m_pos])) {
89 std::optional<char> next() {
90 if(m_pos >= m_str.size()) {
94 if(is_space(m_str[m_pos])) {
96 while(m_pos < m_str.size() && is_space(m_str[m_pos])) {
100 if(m_pos < m_str.size()) {
106 const char c = m_str[m_pos++];
108 if(c >=
'A' && c <=
'Z') {
109 return static_cast<char>(c + (
'a' -
'A'));
114 static std::string canonicalize(std::string_view
name) {
116 result.reserve(
name.size());
118 X500_Char_Iterator it(
name);
119 while(
auto c = it.next()) {
127 std::string_view m_str;
136std::vector<std::pair<OID, std::string>> canonicalize_rdn(
const std::vector<std::pair<OID, ASN1_String>>& rdn) {
137 std::vector<std::pair<OID, std::string>> result;
138 result.reserve(rdn.size());
139 for(
const auto& ava : rdn) {
140 result.emplace_back(ava.first, X500_Char_Iterator::canonicalize(ava.second.value()));
142 if(result.size() != 1) {
143 std::sort(result.begin(), result.end());
152void append_canonical_rdn(std::vector<uint8_t>& canonical_bits,
const std::vector<std::pair<OID, ASN1_String>>& rdn) {
153 const auto append_canonical_data = []<
typename T>(std::vector<uint8_t>& out,
const T& data) {
154 const std::array<uint8_t, 8> data_len =
store_le(
static_cast<uint64_t
>(data.size()));
155 out.insert(out.end(), data_len.begin(), data_len.end());
156 out.insert(out.end(), data.begin(), data.end());
159 std::vector<uint8_t> rdn_bits;
161 for(
const auto& [oid, value] : canonicalize_rdn(rdn)) {
162 append_canonical_data(rdn_bits, oid.BER_encode());
163 append_canonical_data(rdn_bits, value);
166 append_canonical_data(canonical_bits, rdn_bits);
169std::vector<uint8_t> canonicalize_dn(
const std::vector<std::vector<std::pair<OID, ASN1_String>>>& rdns) {
170 std::vector<uint8_t> canonical_bits;
172 for(
const auto& rdn : rdns) {
173 append_canonical_rdn(canonical_bits, rdn);
176 return canonical_bits;
197 add_rdn({std::make_pair(oid, str)});
204 append_canonical_rdn(m_canonical_dn_bits, rdn);
205 m_rdn.push_back(std::move(rdn));
210 std::vector<std::pair<OID, ASN1_String>> flat;
211 for(
const auto& rdn : m_rdn) {
212 for(
const auto& ava : rdn) {
223 std::multimap<OID, std::string> retval;
225 for(
const auto& rdn : m_rdn) {
226 for(
const auto& ava : rdn) {
227 retval.emplace(ava.first, ava.second.value());
237 std::multimap<std::string, std::string> retval;
239 for(
const auto& rdn : m_rdn) {
240 for(
const auto& ava : rdn) {
241 retval.emplace(ava.first.to_formatted_string(), ava.second.value());
259 for(
const auto& rdn : m_rdn) {
260 for(
const auto& ava : rdn) {
261 if(ava.first == oid) {
276 for(
const auto& rdn : m_rdn) {
277 for(
const auto& ava : rdn) {
278 if(ava.first == oid) {
293 std::vector<std::string> values;
295 for(
const auto& rdn : m_rdn) {
296 for(
const auto& ava : rdn) {
297 if(ava.first == oid) {
298 values.push_back(ava.second.value());
310 if(info ==
"Name" || info ==
"CommonName" || info ==
"CN") {
311 return "X520.CommonName";
313 if(info ==
"SerialNumber" || info ==
"SN") {
314 return "X520.SerialNumber";
316 if(info ==
"Country" || info ==
"C") {
317 return "X520.Country";
319 if(info ==
"Organization" || info ==
"O") {
320 return "X520.Organization";
322 if(info ==
"Organizational Unit" || info ==
"OrgUnit" || info ==
"OU") {
323 return "X520.OrganizationalUnit";
325 if(info ==
"Locality" || info ==
"L") {
326 return "X520.Locality";
328 if(info ==
"State" || info ==
"Province" || info ==
"ST") {
331 if(info ==
"Email") {
334 return std::string(info);
348 return !(dn1 == dn2);
360 const auto& name_bits =
name._canonical_bytes();
363 if(constraint_bits.size() > name_bits.size()) {
367 return std::equal(constraint_bits.begin(), constraint_bits.end(), name_bits.begin());
371 std::vector<uint8_t> result;
383 if(!m_dn_bits.empty()) {
390 for(
const auto& rdn : m_rdn) {
392 for(
const auto& ava : rdn) {
406 std::vector<uint8_t> bits;
412 std::vector<std::vector<std::pair<OID, ASN1_String>>>
rdns;
416 constexpr size_t MAX_AVAS_PER_RDN = 32;
421 std::vector<std::pair<OID, ASN1_String>> rdn;
431 rdn.emplace_back(std::move(oid), std::move(str));
433 if(rdn.size() > MAX_AVAS_PER_RDN) {
434 throw Decoding_Error(
"X.500 RDN has too many attribute-value assertions");
444 throw Decoding_Error(
"X.500 RDN must contain at least one attribute-value assertion");
446 rdns.push_back(std::move(rdn));
449 auto canonical_bits = canonicalize_dn(
rdns);
451 m_rdn = std::move(
rdns);
452 m_dn_bits = std::move(bits);
453 m_canonical_dn_bits = std::move(canonical_bits);
458std::string to_short_form(
const OID& oid) {
461 if(long_id ==
"X520.CommonName") {
465 if(long_id ==
"X520.Country") {
469 if(long_id ==
"X520.Organization") {
473 if(long_id ==
"X520.OrganizationalUnit") {
483 std::ostringstream out;
489 const auto& rdns = dn.
rdns();
493 const auto hex_escape = [](std::ostream& s,
char c) {
494 const auto b =
static_cast<uint8_t
>(c);
501 bool first_rdn =
true;
502 for(
const auto& rdn : rdns) {
508 bool first_ava =
true;
509 for(
const auto& ava : rdn) {
514 out << to_short_form(ava.first) <<
"=\"";
515 const std::string_view value = ava.second.value();
517 while(pos < value.size()) {
518 const size_t start = pos;
525 hex_escape(out, value[start]);
530 if(cp ==
'\\' || cp ==
'"') {
531 out << '\\' << static_cast<char>(cp);
533 for(
size_t i = start; i < pos; ++i) {
534 hex_escape(out, value[i]);
537 out << value.substr(start, pos - start);
556 std::vector<std::pair<OID, ASN1_String>> pending_rdn;
560 char terminator =
'\0';
563 while(pos < str.size()) {
566 while(pos < str.size() && is_space(str[pos])) {
569 if(pos == str.size()) {
574 const size_t type_start = pos;
575 while(pos < str.size() && str[pos] !=
'=' && !is_space(str[pos])) {
578 const std::string_view type = str.substr(type_start, pos - type_start);
579 if(type.empty() || pos == str.size() || str[pos] !=
'=') {
591 size_t value_len = 0;
596 enum class Quote : uint8_t {
None, Open, Closed };
597 Quote quote = Quote::None;
601 while(pos < str.size()) {
602 const char c = str[pos];
605 if(quote == Quote::Open) {
606 quote = Quote::Closed;
607 }
else if(quote == Quote::None && value.empty()) {
613 }
else if(c ==
'\\') {
614 if(quote == Quote::Closed) {
619 if(pos == str.size()) {
622 if(
const auto hi = hex_digit_value(str[pos])) {
623 const auto lo = (pos + 1 < str.size()) ? hex_digit_value(str[pos + 1]) : std::nullopt;
627 value.push_back(
static_cast<char>((*hi << 4) | *lo));
629 }
else if(is_escapable_char(str[pos])) {
630 value.push_back(str[pos]);
635 value_len = value.size();
636 }
else if((c ==
',' || c ==
'+') && quote != Quote::Open) {
640 }
else if(quote == Quote::Closed) {
645 }
else if(quote != Quote::Open && is_unescaped_special_value_char(c)) {
649 if(is_space(c) && quote != Quote::Open) {
657 value_len = value.size();
662 if(quote == Quote::Open) {
665 value.resize(value_len);
671 pending_rdn.emplace_back(std::move(oid),
ASN1_String(value));
676 if(terminator !=
'+') {
677 dn.
add_rdn(std::move(pending_rdn));
683 if(terminator ==
',' || terminator ==
'+') {
690 const std::istreambuf_iterator<char> begin(in);
691 const std::istreambuf_iterator<char> end;
692 const std::string contents(begin, end);
695 dn = std::move(*parsed);
697 in.setstate(std::ios::failbit);
const std::string & value() const
BER_Decoder & raw_bytes(T &out_wrapped)
BER_Decoder & decode(bool &out)
BER_Decoder start_sequence()
DER_Encoder & start_set()
DER_Encoder & start_sequence()
DER_Encoder & raw_bytes(const uint8_t val[], size_t len)
DER_Encoder & encode(bool b)
std::string to_formatted_string() const
static OID from_string(std::string_view str)
const std::vector< std::vector< std::pair< OID, ASN1_String > > > & rdns() const
void add_rdn(std::vector< std::pair< OID, ASN1_String > > rdn)
static std::optional< X509_DN > parse(std::string_view str)
bool has_field(const OID &oid) const
std::multimap< std::string, std::string > contents() const
std::vector< std::pair< OID, ASN1_String > > dn_info() const
std::vector< std::string > get_attribute(std::string_view attr) const
void add_attribute(std::string_view key, std::string_view val)
std::multimap< OID, std::string > get_attributes() const
ASN1_String get_first_attribute(const OID &oid) const
void encode_into(DER_Encoder &to) const override
std::vector< uint8_t > DER_encode() const
std::string to_string() const
const std::vector< uint8_t > & _canonical_bytes() const
void decode_from(BER_Decoder &from) override
static std::string deref_info_field(std::string_view key)
constexpr char nibble_to_hex(uint8_t b)
bool is_unicode_control_char(uint32_t cp)
bool operator<(const OID &a, const OID &b)
std::ostream & operator<<(std::ostream &out, const OID &oid)
constexpr auto store_le(ParamTs &&... params)
bool x509_dn_subtree_match(const X509_DN &name, const X509_DN &constraint)
int operator>>(int fd, Pipe &pipe)
bool operator!=(const AlgorithmIdentifier &x, const AlgorithmIdentifier &y)
uint32_t next_utf8_codepoint(std::string_view utf8, size_t &pos)
bool operator==(const AlgorithmIdentifier &x, const AlgorithmIdentifier &y)