bool operator()(const X509* lhs, const X509* rhs) const noexcept {

return X509_cmp(const_cast<X509*>(lhs), const_cast<X509*>(rhs)) < 0;

}

if (v->IsString() || v->IsArrayBufferView()) {

auto bio = BIOPointer::NewSecMem();

if (!bio) return {};

ByteSource bsrc = ByteSource::FromStringOrBuffer(env, v);

if (bsrc.size() > INT_MAX) return {};

int written = BIOPointer::Write(

&bio, std::string_view(bsrc.data<char>(), bsrc.size()));

if (written < 0) return {};

if (static_cast<size_t>(written) != bsrc.size()) return {};

return bio;

}

return {};

BIOPointer&& in,

X509Pointer* cert,

X509Pointer* issuer) {

// Just to ensure that `ERR_peek_last_error` below will return only errors

// that we are interested in

ERR_clear_error();

X509Pointer x(

PEM_read_bio_X509_AUX(in.get(), nullptr, NoPasswordCallback, nullptr));

if (!x)

return 0;

unsigned long err = 0; // NOLINT(runtime/int)

StackOfX509 extra_certs(sk_X509_new_null());

if (!extra_certs)

return 0;

while (X509Pointer extra {PEM_read_bio_X509(in.get(),

nullptr,

NoPasswordCallback,

nullptr)}) {

if (sk_X509_push(extra_certs.get(), extra.get())) {

extra.release();

continue;

}

return 0;

}

// When the while loop ends, it's usually just EOF.

err = ERR_peek_last_error();

if (ERR_GET_LIB(err) == ERR_LIB_PEM &&

ERR_GET_REASON(err) == PEM_R_NO_START_LINE) {

ERR_clear_error();

} else {

// some real error

return 0;

}

return SSL_CTX_use_certificate_chain(ctx,

std::move(x),

extra_certs.get(),

cert,

issuer);

std::vector<X509*>* certs,

BIOPointer bio) {

MarkPopErrorOnReturn mark_pop_error_on_return;

while (X509* x509 = PEM_read_bio_X509(

bio.get(), nullptr, NoPasswordCallback, nullptr)) {

certs->push_back(x509);

}

unsigned long err = ERR_peek_last_error(); // NOLINT(runtime/int)

// Ignore error if its EOF/no start line found.

if (ERR_GET_LIB(err) == ERR_LIB_PEM &&

ERR_GET_REASON(err) == PEM_R_NO_START_LINE) {

return 0;

} else {

return err;

}

std::vector<X509*>* certs,

const char* file) {

MarkPopErrorOnReturn mark_pop_error_on_return;

auto bio = BIOPointer::NewFile(file, "r");

if (!bio) return ERR_get_error();

return LoadCertsFromBIO(certs, std::move(bio));

// Trust status is unknown / uninitialized.

UNKNOWN,

// Certificate inherits trust value from its issuer. If the certificate is the

// root of the chain, this implies distrust.

UNSPECIFIED,

// Certificate is a trust anchor.

TRUSTED,

// Certificate is blocked / explicitly distrusted.

DISTRUSTED

auto subject = X509_get_subject_name(cert);

auto issuer = X509_get_issuer_name(cert);

return X509_NAME_cmp(subject, issuer) == 0;

bool is_self_issued) {

// Trust settings may be scoped to a single application

// skip as this is not supported

if (CFDictionaryContainsKey(trust_dict, kSecTrustSettingsApplication)) {

return TrustStatus::UNSPECIFIED;

}

// Trust settings may be scoped using policy-specific constraints. For

// example, SSL trust settings might be scoped to a single hostname, or EAP

// settings specific to a particular WiFi network.

// As this is not presently supported, skip any policy-specific trust

// settings.

if (CFDictionaryContainsKey(trust_dict, kSecTrustSettingsPolicyString)) {

return TrustStatus::UNSPECIFIED;

}

// If the trust settings are scoped to a specific policy (via

// kSecTrustSettingsPolicy), ensure that the policy is the same policy as

// |kSecPolicyAppleSSL|. If there is no kSecTrustSettingsPolicy key, it's

// considered a match for all policies.

if (CFDictionaryContainsKey(trust_dict, kSecTrustSettingsPolicy)) {

SecPolicyRef policy_ref = reinterpret_cast<SecPolicyRef>(const_cast<void*>(

CFDictionaryGetValue(trust_dict, kSecTrustSettingsPolicy)));

if (!policy_ref) {

return TrustStatus::UNSPECIFIED;

}

CFDictionaryRef policy_dict(SecPolicyCopyProperties(policy_ref));

// kSecPolicyOid is guaranteed to be present in the policy dictionary.

CFStringRef policy_oid = reinterpret_cast<CFStringRef>(

const_cast<void*>(CFDictionaryGetValue(policy_dict, kSecPolicyOid)));

if (!CFEqual(policy_oid, kSecPolicyAppleSSL)) {

return TrustStatus::UNSPECIFIED;

}

}

int trust_settings_result = kSecTrustSettingsResultTrustRoot;

if (CFDictionaryContainsKey(trust_dict, kSecTrustSettingsResult)) {

CFNumberRef trust_settings_result_ref =

reinterpret_cast<CFNumberRef>(const_cast<void*>(

CFDictionaryGetValue(trust_dict, kSecTrustSettingsResult)));

if (!trust_settings_result_ref ||

!CFNumberGetValue(trust_settings_result_ref,

kCFNumberIntType,

&trust_settings_result)) {

return TrustStatus::UNSPECIFIED;

}

if (trust_settings_result == kSecTrustSettingsResultDeny) {

return TrustStatus::DISTRUSTED;

}

// This is a bit of a hack: if the cert is self-issued allow either

// kSecTrustSettingsResultTrustRoot or kSecTrustSettingsResultTrustAsRoot on

// the basis that SecTrustSetTrustSettings should not allow creating an

// invalid trust record in the first place. (The spec is that

// kSecTrustSettingsResultTrustRoot can only be applied to root(self-signed)

// certs and kSecTrustSettingsResultTrustAsRoot is used for other certs.)

// This hack avoids having to check the signature on the cert which is slow

// if using the platform APIs, and may require supporting MD5 signature

// algorithms on some older OSX versions or locally added roots, which is

// undesirable in the built-in signature verifier.

if (is_self_issued) {

return trust_settings_result == kSecTrustSettingsResultTrustRoot ||

trust_settings_result == kSecTrustSettingsResultTrustAsRoot

? TrustStatus::TRUSTED

: TrustStatus::UNSPECIFIED;

}

// kSecTrustSettingsResultTrustAsRoot can only be applied to non-root certs.

return (trust_settings_result == kSecTrustSettingsResultTrustAsRoot)

? TrustStatus::TRUSTED

: TrustStatus::UNSPECIFIED;

}

return TrustStatus::UNSPECIFIED;

bool is_self_issued) {

// The trust_settings parameter can return a valid but empty CFArrayRef.

// This empty trust-settings array means “always trust this certificate”

// with an overall trust setting for the certificate of

// kSecTrustSettingsResultTrustRoot

if (CFArrayGetCount(trust_settings) == 0) {

return is_self_issued ? TrustStatus::TRUSTED : TrustStatus::UNSPECIFIED;

}

for (CFIndex i = 0; i < CFArrayGetCount(trust_settings); ++i) {

CFDictionaryRef trust_dict = reinterpret_cast<CFDictionaryRef>(

const_cast<void*>(CFArrayGetValueAtIndex(trust_settings, i)));

TrustStatus trust =

IsTrustDictionaryTrustedForPolicy(trust_dict, is_self_issued);

if (trust == TrustStatus::DISTRUSTED || trust == TrustStatus::TRUSTED) {

return trust;

}

}

return TrustStatus::UNSPECIFIED;

SecTrustRef sec_trust = nullptr;

CFMutableArrayRef subj_certs =

CFArrayCreateMutable(nullptr, 1, &kCFTypeArrayCallBacks);

CFArraySetValueAtIndex(subj_certs, 0, ref);

SecPolicyRef policy = SecPolicyCreateSSL(false, nullptr);

OSStatus ortn =

SecTrustCreateWithCertificates(subj_certs, policy, &sec_trust);

bool result = false;

if (ortn) {

/* should never happen */

} else {

result = SecTrustEvaluateWithError(sec_trust, nullptr);

}

if (policy) {

CFRelease(policy);

}

if (sec_trust) {

CFRelease(sec_trust);

}

if (subj_certs) {

CFRelease(subj_certs);

}

return result;

OSStatus err;

bool trust_evaluated = false;

bool is_self_issued = isSelfIssued(cert);

// Evaluate user trust domain, then admin. User settings can override

// admin (and both override the system domain, but we don't check that).

for (const auto& trust_domain :

{kSecTrustSettingsDomainUser, kSecTrustSettingsDomainAdmin}) {

CFArrayRef trust_settings = nullptr;

err = SecTrustSettingsCopyTrustSettings(ref, trust_domain, &trust_settings);

if (err != errSecSuccess && err != errSecItemNotFound) {

fprintf(stderr,

"ERROR: failed to copy trust settings of system certificate%d\n",

err);

continue;

}

if (err == errSecSuccess && trust_settings != nullptr) {

TrustStatus result =

IsTrustSettingsTrustedForPolicy(trust_settings, is_self_issued);

if (result != TrustStatus::UNSPECIFIED) {

CFRelease(trust_settings);

return result == TrustStatus::TRUSTED;

}

}

// An empty trust settings array isn’t the same as no trust settings,

// where the trust_settings parameter returns NULL.

// No trust-settings array means

// “this certificate must be verifiable using a known trusted certificate”.

if (trust_settings == nullptr && !trust_evaluated) {

bool result = IsCertificateTrustValid(ref);

if (result) {

return true;

}

// no point re-evaluating this in the admin domain

trust_evaluated = true;

} else if (trust_settings) {

CFRelease(trust_settings);

}

}

return false;

std::vector<X509*>* system_root_certificates_X509) {

CFTypeRef search_keys[] = {kSecClass, kSecMatchLimit, kSecReturnRef};

CFTypeRef search_values[] = {

kSecClassCertificate, kSecMatchLimitAll, kCFBooleanTrue};

CFDictionaryRef search = CFDictionaryCreate(kCFAllocatorDefault,

search_keys,

search_values,

3,

&kCFTypeDictionaryKeyCallBacks,

&kCFTypeDictionaryValueCallBacks);

CFArrayRef curr_anchors = nullptr;

OSStatus ortn =

SecItemCopyMatching(search, reinterpret_cast<CFTypeRef*>(&curr_anchors));

CFRelease(search);

if (ortn) {

fprintf(stderr, "ERROR: SecItemCopyMatching failed %d\n", ortn);

}

CFIndex count = CFArrayGetCount(curr_anchors);

for (int i = 0; i < count; ++i) {

SecCertificateRef cert_ref = reinterpret_cast<SecCertificateRef>(

const_cast<void*>(CFArrayGetValueAtIndex(curr_anchors, i)));

CFDataRef der_data = SecCertificateCopyData(cert_ref);

if (!der_data) {

fprintf(stderr, "ERROR: SecCertificateCopyData failed\n");

continue;

}

auto data_buffer_pointer = CFDataGetBytePtr(der_data);

X509* cert =

d2i_X509(nullptr, &data_buffer_pointer, CFDataGetLength(der_data));

CFRelease(der_data);

bool is_valid = IsCertificateTrustedForPolicy(cert, cert_ref);

if (is_valid) {

system_root_certificates_X509->emplace_back(cert);

}

}

CFRelease(curr_anchors);

DWORD usage_size = 0;

if (!CertGetEnhancedKeyUsage(cert, 0, nullptr, &usage_size)) {

return false;

}

std::vector<BYTE> usage_bytes(usage_size);

CERT_ENHKEY_USAGE* usage =

reinterpret_cast<CERT_ENHKEY_USAGE*>(usage_bytes.data());

if (!CertGetEnhancedKeyUsage(cert, 0, usage, &usage_size)) {

return false;

}

if (usage->cUsageIdentifier == 0) {

// check GetLastError

HRESULT error_code = GetLastError();

switch (error_code) {

case CRYPT_E_NOT_FOUND:

return true;

case S_OK:

return false;

default:

return false;

}

}

// SAFETY: `usage->rgpszUsageIdentifier` is an array of LPSTR (pointer to null

// terminated string) of length `usage->cUsageIdentifier`.

for (DWORD i = 0; i < usage->cUsageIdentifier; ++i) {

std::string_view eku(usage->rgpszUsageIdentifier[i]);

if ((eku == szOID_PKIX_KP_SERVER_AUTH) ||

(eku == szOID_ANY_ENHANCED_KEY_USAGE)) {

return true;

}

}

return false;

DWORD location,

LPCWSTR store_name) {

if (!(location == CERT_SYSTEM_STORE_LOCAL_MACHINE ||

location == CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY ||

location == CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE ||

location == CERT_SYSTEM_STORE_CURRENT_USER ||

location == CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY)) {

return;

}

DWORD flags =

location | CERT_STORE_OPEN_EXISTING_FLAG | CERT_STORE_READONLY_FLAG;

HCERTSTORE opened_store(

CertOpenStore(CERT_STORE_PROV_SYSTEM,

0,

// The Windows API only accepts NULL for hCryptProv.

NULL, /* NOLINT (readability/null_usage) */

flags,

store_name));

if (!opened_store) {

return;

}

auto cleanup = OnScopeLeave(

[opened_store]() { CHECK_EQ(CertCloseStore(opened_store, 0), TRUE); });

PCCERT_CONTEXT cert_from_store = nullptr;

while ((cert_from_store = CertEnumCertificatesInStore(

opened_store, cert_from_store)) != nullptr) {

if (!IsCertTrustedForServerAuth(cert_from_store)) {

continue;

}

const unsigned char* cert_data =

reinterpret_cast<const unsigned char*>(cert_from_store->pbCertEncoded);

const size_t cert_size = cert_from_store->cbCertEncoded;

vector->emplace_back(d2i_X509(nullptr, &cert_data, cert_size));

}

std::vector<X509*>* system_root_certificates_X509) {

// TODO(joyeecheung): match Chromium's policy, collect more certificates

// from user-added CAs and support disallowed (revoked) certificates.

// Grab the user-added roots.

GatherCertsForLocation(

system_root_certificates_X509, CERT_SYSTEM_STORE_LOCAL_MACHINE, L"ROOT");

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY,

L"ROOT");

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE,

L"ROOT");

GatherCertsForLocation(

system_root_certificates_X509, CERT_SYSTEM_STORE_CURRENT_USER, L"ROOT");

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY,

L"ROOT");

// Grab the intermediate certs

GatherCertsForLocation(

system_root_certificates_X509, CERT_SYSTEM_STORE_LOCAL_MACHINE, L"CA");

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY,

L"CA");

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE,

L"CA");

GatherCertsForLocation(

system_root_certificates_X509, CERT_SYSTEM_STORE_CURRENT_USER, L"CA");

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY,

L"CA");

// Grab the user-added trusted server certs. Trusted end-entity certs are

// only allowed for server auth in the "local machine" store, but not in the

// "current user" store.

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_LOCAL_MACHINE,

L"TrustedPeople");

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY,

L"TrustedPeople");

GatherCertsForLocation(system_root_certificates_X509,

CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE,

L"TrustedPeople");

std::string_view cert_dir) {

uv_fs_t dir_req;

auto cleanup = OnScopeLeave([&dir_req]() { uv_fs_req_cleanup(&dir_req); });

int err = uv_fs_scandir(nullptr, &dir_req, cert_dir.data(), 0, nullptr);

if (err < 0) {

fprintf(stderr,

"Cannot open directory %s to load OpenSSL certificates.\n",

cert_dir.data());

return;

}

for (;;) {

uv_dirent_t ent;

int r = uv_fs_scandir_next(&dir_req, &ent);

if (r == UV_EOF) {

break;

}

if (r < 0) {

char message[64];

uv_strerror_r(r, message, sizeof(message));

fprintf(stderr,

"Cannot scan directory %s to load OpenSSL certificates.\n",

cert_dir.data());

return;

}

uv_fs_t stats_req;

std::string file_path = std::string(cert_dir) + "/" + ent.name;

int stats_r = uv_fs_stat(nullptr, &stats_req, file_path.c_str(), nullptr);

if (stats_r == 0 &&

(static_cast<uv_stat_t*>(stats_req.ptr)->st_mode & S_IFREG)) {

LoadCertsFromFile(certs, file_path.c_str());

}

uv_fs_req_cleanup(&stats_req);

}

std::string cert_file;

// While configurable when OpenSSL is built, this is usually SSL_CERT_FILE.

if (!credentials::SafeGetenv(X509_get_default_cert_file_env(), &cert_file)) {

// This is usually /etc/ssl/cert.pem if we are using the OpenSSL statically

// linked and built with default configurations.

cert_file = X509_get_default_cert_file();

}

std::string cert_dir;

// While configurable when OpenSSL is built, this is usually SSL_CERT_DIR.

if (!credentials::SafeGetenv(X509_get_default_cert_dir_env(), &cert_dir)) {

// This is usually /etc/ssl/certs if we are using the OpenSSL statically

// linked and built with default configurations.

cert_dir = X509_get_default_cert_dir();

}

if (!cert_file.empty()) {

LoadCertsFromFile(system_store_certs, cert_file.c_str());

}

if (!cert_dir.empty()) {

LoadCertsFromDir(system_store_certs, cert_dir.c_str());

}

// Read the bundled certificates in node_root_certs.h into

// bundled_root_certs_vector.

std::vector<X509*> bundled_root_certs;

size_t bundled_root_cert_count = arraysize(root_certs);

bundled_root_certs.reserve(bundled_root_cert_count);

for (size_t i = 0; i < bundled_root_cert_count; i++) {

X509* x509 = PEM_read_bio_X509(

NodeBIO::NewFixed(root_certs[i], strlen(root_certs[i])).get(),

nullptr, // no re-use of X509 structure

NoPasswordCallback,

nullptr); // no callback data

// Parse errors from the built-in roots are fatal.

CHECK_NOT_NULL(x509);

bundled_root_certs.push_back(x509);

}

return bundled_root_certs;

std::vector<X509*> system_store_certs;

#ifdef __APPLE__

ReadMacOSKeychainCertificates(&system_store_certs);

#endif

#ifdef _WIN32

ReadWindowsCertificates(&system_store_certs);

#endif

#if !defined(__APPLE__) && !defined(_WIN32)

GetOpenSSLSystemCertificates(&system_store_certs);

#endif

return system_store_certs;

// This is only run once during the initialization of the process, so

// it is safe to use a static thread here.

int r =

uv_thread_create(&system_ca_thread, LoadSystemCACertificates, nullptr);

if (r == 0) {

system_ca_thread_started = true;

}

return r;

std::vector<X509*> extra_certs;

unsigned long err = LoadCertsFromFile( // NOLINT(runtime/int)

&extra_certs,

extra_root_certs_file.c_str());

if (err) {

char buf[256];

ERR_error_string_n(err, buf, sizeof(buf));

fprintf(stderr,

"Warning: Ignoring extra certs from `%s`, load failed: %s\n",

extra_root_certs_file.c_str(),

buf);

}

return extra_certs;

if (has_cached_bundled_root_certs.load()) {

for (X509* cert : GetBundledRootCertificates()) {

X509_free(cert);

}

}

if (has_cached_system_root_certs.load()) {

for (X509* cert : GetSystemStoreCACertificates()) {

X509_free(cert);

}

}

if (has_cached_extra_root_certs.load()) {

for (X509* cert : GetExtraCACertificates()) {

X509_free(cert);

}

}

if (system_ca_thread_started) {

uv_thread_join(&system_ca_thread);

system_ca_thread_started = false;

}

Environment* env = Environment::GetCurrent(args);

Local<Value> result[arraysize(root_certs)];

for (size_t i = 0; i < arraysize(root_certs); i++) {

if (!String::NewFromOneByte(

env->isolate(),

reinterpret_cast<const uint8_t*>(root_certs[i]))

.ToLocal(&result[i])) {

return;

}

}

args.GetReturnValue().Set(

Array::New(env->isolate(), result, arraysize(root_certs)));

Local<Array> cert_array,

std::vector<X509*>* certs) {

ClearErrorOnReturn clear_error_on_return;

Isolate* isolate = context->GetIsolate();

Environment* env = Environment::GetCurrent(context);

uint32_t array_length = cert_array->Length();

std::vector<v8::Global<Value>> cert_items;

if (FromV8Array(context, cert_array, &cert_items).IsNothing()) {

return false;

}

for (uint32_t i = 0; i < array_length; i++) {

Local<Value> cert_val = cert_items[i].Get(isolate);

// Parse the PEM certificate.

BIOPointer bio(LoadBIO(env, cert_val));

if (!bio) {

ThrowCryptoError(env, ERR_get_error(), "Failed to load certificate data");

return false;

}

// Read all certificates from this PEM string

size_t start = certs->size();

auto err = LoadCertsFromBIO(certs, std::move(bio));

if (err != 0) {

size_t end = certs->size();

// Clean up any certificates we've already parsed upon failure.

for (size_t j = start; j < end; ++j) {

X509_free((*certs)[j]);

}

ThrowCryptoError(env, err, "Failed to parse certificate");

return false;