9#include <botan/certstor_macos.h>
11#include <botan/assert.h>
12#include <botan/ber_dec.h>
13#include <botan/bigint.h>
14#include <botan/exceptn.h>
15#include <botan/pkix_types.h>
16#include <botan/internal/x509_cert_cache.h>
21#define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
22#include <CoreFoundation/CoreFoundation.h>
23#include <CoreServices/CoreServices.h>
36 explicit scoped_CFType(T value) : m_value(value) {}
38 scoped_CFType(
const scoped_CFType<T>& rhs) =
delete;
40 scoped_CFType(scoped_CFType<T>&& rhs) : m_value(std::move(rhs.m_value)) { rhs.m_value =
nullptr; }
48 operator bool()
const {
return m_value !=
nullptr; }
50 void assign(T value) {
51 BOTAN_ASSERT(m_value ==
nullptr,
"scoped_CFType was not set yet");
55 T& get() {
return m_value; }
57 const T& get()
const {
return m_value; }
68X509_DN normalize(
const X509_DN& dn) {
72 const auto flat = dn.dn_info();
73 for(
const auto& [oid, str] : flat) {
75 std::string normalized;
76 normalized.reserve(str.value().size());
78 for(
const char c : str.value()) {
81 const char up = (c >=
'a' && c <= 'z') ? static_cast<char>(c - (
'a' -
'A')) : c;
82 normalized.push_back(up);
83 }
else if(!normalized.empty() && normalized.back() !=
' ') {
85 normalized.push_back(c);
89 if(!normalized.empty() && normalized.back() ==
' ') {
91 normalized.pop_back();
94 result.add_attribute(oid, ASN1_String(normalized, str.tagging()));
96 result.add_attribute(oid, str);
102std::vector<uint8_t> normalizeAndSerialize(
const X509_DN& dn) {
103 return normalize(dn).DER_encode();
106std::string
to_string(
const CFStringRef cfstring) {
107 const char* ccstr = CFStringGetCStringPtr(cfstring, kCFStringEncodingUTF8);
109 if(ccstr !=
nullptr) {
110 return std::string(ccstr);
113 auto utf16_pairs = CFStringGetLength(cfstring);
114 auto max_utf8_bytes = CFStringGetMaximumSizeForEncoding(utf16_pairs, kCFStringEncodingUTF8);
116 std::vector<char> cstr(max_utf8_bytes,
'\0');
117 auto result = CFStringGetCString(cfstring, cstr.data(), cstr.size(), kCFStringEncodingUTF8);
119 return (result) ? std::string(cstr.data()) : std::string();
122std::string
to_string(
const OSStatus status) {
123 scoped_CFType<CFStringRef> eCFString(SecCopyErrorMessageString(status,
nullptr));
127void check_success(
const OSStatus status,
const std::string context) {
128 if(errSecSuccess == status) {
132 throw Internal_Error(std::string(
"failed to " + context +
": " +
to_string(status)));
136void check_notnull(
const T& value,
const std::string context) {
141 throw Internal_Error(std::string(
"failed to ") + context);
151class Certificate_Store_MacOS_Impl {
153 static constexpr const char* system_roots =
"/System/Library/Keychains/SystemRootCertificates.keychain";
154 static constexpr const char* system_keychain =
"/Library/Keychains/System.keychain";
158 static constexpr size_t SystemStore_CertCacheSize = 128;
170 Query(Query&& other) =
default;
171 Query& operator=(Query&& other) =
default;
173 Query(
const Query& other) =
delete;
174 Query& operator=(
const Query& other) =
delete;
177 void addParameter(CFStringRef key, CFTypeRef value) {
178 m_keys.emplace_back(key);
179 m_values.emplace_back(value);
182 void addParameter(CFStringRef key, std::vector<uint8_t> value) {
183 const auto& data = m_data_store.emplace_back(std::move(value));
185 const auto& data_ref = m_data_refs.emplace_back(
186 CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, data.data(), data.size(), kCFAllocatorNull));
187 check_notnull(data_ref,
"create CFDataRef of search object failed");
189 addParameter(key, data_ref.get());
197 scoped_CFType<CFDictionaryRef> prepare(
const CFArrayRef& keychains,
const SecPolicyRef& policy) {
198 addParameter(kSecClass, kSecClassCertificate);
199 addParameter(kSecReturnRef, kCFBooleanTrue);
200 addParameter(kSecMatchLimit, kSecMatchLimitAll);
201 addParameter(kSecMatchTrustedOnly, kCFBooleanTrue);
202 addParameter(kSecMatchSearchList, keychains);
203 addParameter(kSecMatchPolicy, policy);
207 auto query = scoped_CFType<CFDictionaryRef>(CFDictionaryCreate(kCFAllocatorDefault,
208 (
const void**)m_keys.data(),
209 (
const void**)m_values.data(),
211 &kCFTypeDictionaryKeyCallBacks,
212 &kCFTypeDictionaryValueCallBacks));
213 check_notnull(query,
"create search query");
219 using Data = std::vector<std::vector<uint8_t>>;
220 using DataRefs = std::vector<scoped_CFType<CFDataRef>>;
221 using Keys = std::vector<CFStringRef>;
222 using Values = std::vector<CFTypeRef>;
225 DataRefs m_data_refs;
231 Certificate_Store_MacOS_Impl() :
232 m_policy(SecPolicyCreateBasicX509()),
233 m_system_roots(
nullptr),
234 m_system_chain(
nullptr),
235 m_keychains(
nullptr),
236 m_cert_cache(SystemStore_CertCacheSize) {
242 check_success(SecKeychainOpen(system_roots, &m_system_roots.get()),
"open system root certificates");
243 check_success(SecKeychainOpen(system_keychain, &m_system_chain.get()),
"open system keychain");
245 check_notnull(m_system_roots,
"open system root certificate chain");
246 check_notnull(m_system_chain,
"open system certificate chain");
250 std::array<const void*, 2> keychains{{m_system_roots.get(), m_system_chain.get()}};
253 CFArrayCreate(kCFAllocatorDefault, keychains.data(), keychains.size(), &kCFTypeArrayCallBacks));
254 check_notnull(m_keychains,
"initialize keychain array");
257 std::optional<X509_Certificate> findOne(Query query)
const {
258 query.addParameter(kSecMatchLimit, kSecMatchLimitOne);
260 scoped_CFType<CFTypeRef> result(
nullptr);
261 search(std::move(query), &result.get());
264 return readCertificate(result.get());
269 std::vector<X509_Certificate> findAll(Query query)
const {
270 query.addParameter(kSecMatchLimit, kSecMatchLimitAll);
272 scoped_CFType<CFArrayRef> result(
nullptr);
273 search(std::move(query), (CFTypeRef*)&result.get());
275 std::vector<X509_Certificate> output;
278 const auto count = CFArrayGetCount(result.get());
279 BOTAN_ASSERT(count > 0,
"certificate result list contains data");
281 for(
unsigned int i = 0; i < count; ++i) {
282 auto cert = CFArrayGetValueAtIndex(result.get(), i);
283 output.emplace_back(readCertificate(cert));
291 void search(Query query, CFTypeRef* result)
const {
292 scoped_CFType<CFDictionaryRef> fullQuery(query.prepare(keychains(), policy()));
294 auto status = SecItemCopyMatching(fullQuery.get(), result);
296 if(errSecItemNotFound == status) {
300 check_success(status,
"look up certificate");
301 check_notnull(result,
"look up certificate (invalid result value)");
311 X509_Certificate readCertificate(CFTypeRef
object)
const {
312 if(!
object || CFGetTypeID(
object) != SecCertificateGetTypeID()) {
313 throw Internal_Error(
"cannot convert CFTypeRef to SecCertificateRef");
316 auto cert =
static_cast<SecCertificateRef
>(
const_cast<void*
>(object));
318 scoped_CFType<CFDataRef> derData(SecCertificateCopyData(cert));
319 check_notnull(derData,
"read extracted certificate");
321 const auto data = CFDataGetBytePtr(derData.get());
322 const auto length =
static_cast<size_t>(CFDataGetLength(derData.get()));
327 CFArrayRef keychains()
const {
return m_keychains.get(); }
329 SecPolicyRef policy()
const {
return m_policy.get(); }
332 scoped_CFType<SecPolicyRef> m_policy;
333 scoped_CFType<SecKeychainRef> m_system_roots;
334 scoped_CFType<SecKeychainRef> m_system_chain;
335 scoped_CFType<CFArrayRef> m_keychains;
339 mutable X509_Certificate_Cache m_cert_cache;
358 const auto certificates = m_impl->findAll({});
360 std::vector<X509_DN> output;
361 std::transform(certificates.cbegin(),
363 std::back_inserter(output),
364 [](
const std::optional<X509_Certificate> cert) { return cert->subject_dn(); });
370 const std::vector<uint8_t>& key_id)
const {
371 Certificate_Store_MacOS_Impl::Query query;
372 query.addParameter(kSecAttrSubject, normalizeAndSerialize(subject_dn));
374 if(!key_id.empty()) {
375 query.addParameter(kSecAttrSubjectKeyID, key_id);
378 return m_impl->findOne(std::move(query));
382 const std::vector<uint8_t>& key_id)
const {
383 Certificate_Store_MacOS_Impl::Query query;
384 query.addParameter(kSecAttrSubject, normalizeAndSerialize(subject_dn));
386 if(!key_id.empty()) {
387 query.addParameter(kSecAttrSubjectKeyID, key_id);
390 return m_impl->findAll(std::move(query));
394 const std::vector<uint8_t>& key_hash)
const {
395 if(key_hash.size() != 20) {
396 throw Invalid_Argument(
"Certificate_Store_MacOS::find_cert_by_pubkey_sha1 invalid hash");
399 Certificate_Store_MacOS_Impl::Query query;
400 query.addParameter(kSecAttrPublicKeyHash, key_hash);
402 return m_impl->findOne(std::move(query));
406 const std::vector<uint8_t>& subject_hash)
const {
408 throw Not_Implemented(
"Certificate_Store_MacOS::find_cert_by_raw_subject_dn_sha256");
412 const X509_DN& issuer_dn, std::span<const uint8_t> serial_number)
const {
423 Certificate_Store_MacOS_Impl::Query query;
424 query.addParameter(kSecAttrIssuer, normalizeAndSerialize(issuer_dn));
426 const auto contents = s.der_contents();
427 query.addParameter(kSecAttrSerialNumber, std::vector<uint8_t>(contents.begin(), contents.end()));
429 return m_impl->findOne(std::move(query));
432 if(
auto cert = lookup(serial)) {
443 if(!serial.is_zero()) {
465 Certificate_Store_MacOS_Impl::Query query;
469 for(
const auto& candidate : m_impl->findAll(std::move(query))) {
470 if(std::ranges::equal(candidate.certificate_data_sha256(), sha256)) {
#define BOTAN_DIAGNOSTIC_POP
#define BOTAN_DIAGNOSTIC_PUSH
#define BOTAN_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
#define BOTAN_ASSERT_EQUAL(expr1, expr2, assertion_made)
#define BOTAN_ASSERT(expr, assertion_made)
std::optional< X509_Certificate > find_cert_by_pubkey_sha1(const std::vector< uint8_t > &key_hash) const override
std::optional< X509_Certificate > find_cert(const X509_DN &subject_dn, const std::vector< uint8_t > &key_id) const override
bool contains(const X509_Certificate &cert) const override
std::vector< X509_Certificate > find_all_certs(const X509_DN &subject_dn, const std::vector< uint8_t > &key_id) const override
std::optional< X509_Certificate > find_cert_by_issuer_dn_and_serial_number(const X509_DN &issuer_dn, std::span< const uint8_t > serial_number) const override
std::vector< X509_DN > all_subjects() const override
std::optional< X509_Certificate > find_cert_by_raw_subject_dn_sha256(const std::vector< uint8_t > &subject_hash) const override
Certificate_Store_MacOS()
std::optional< X509_CRL > find_crl_for(const X509_Certificate &subject) const override
X509_Certificate find_or_insert(std::span< const uint8_t > encoding)
std::span< const uint8_t, 32 > certificate_data_sha256() const
const std::vector< uint8_t > & subject_public_key_bitstring_sha1() const
static X509_Serial_Number from_bytes(std::span< const uint8_t > bytes)
std::string to_string(ErrorType type)
Convert an ErrorType to string.