/* * PKCS#12 * (C) 2026 Damiano Mazzella * * Botan is released under the Simplified BSD License (see license.txt) */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace Botan { namespace { /// Maximum allowed SafeContentsBag nesting depth during parsing (anti-DoS). constexpr size_t PKCS12_MAX_NESTING = 10; // Associates a parsed certificate with its bag attributes struct ParsedCert { X509_Certificate cert; std::vector local_key_id; std::string friendly_name; }; /* * Encode a friendly name as a BMPString (UTF-16BE) * ASN1_String doesn't support encoding BMPStrings, so we do it manually */ void encode_bmpstring(DER_Encoder& enc, std::string_view str) { const std::vector utf16be = utf8_to_ucs2(str); enc.add_object(ASN1_Type::BmpString, ASN1_Class::Universal, utf16be); } /* * Resolve a MAC digest OID to a hash name, throwing on unsupported algorithms. */ std::string resolve_mac_hash(const OID& oid) { if(oid == OID::from_string("SHA-1")) { return "SHA-1"; } if(oid == OID::from_string("SHA-224")) { return "SHA-224"; } if(oid == OID::from_string("SHA-256")) { return "SHA-256"; } if(oid == OID::from_string("SHA-384")) { return "SHA-384"; } if(oid == OID::from_string("SHA-512")) { return "SHA-512"; } if(oid == OID::from_string("SHA-512-256")) { return "SHA-512-256"; } throw Decoding_Error(fmt("Unsupported PKCS#12 MAC digest: {}", oid.to_formatted_string())); } /* * Validate PKCS12_Export_Options before starting export. */ void validate_options(const PKCS12_Export_Options& opts) { if(opts.iterations() == 0 || opts.iterations() > PKCS12_MAX_ITERATIONS) { throw Invalid_Argument(fmt("PKCS#12: iteration count must be between 1 and {}", PKCS12_MAX_ITERATIONS)); } static const std::array supported_key_algos = { "PBE-SHA1-3DES", "PBE-SHA1-2DES", "PBES2-SHA256-AES256", "PBES2-SHA256-AES128", }; if(std::find(supported_key_algos.begin(), supported_key_algos.end(), opts.key_encryption_algo()) == supported_key_algos.end()) { throw Invalid_Argument(fmt("PKCS#12: unsupported key encryption algorithm '{}'", opts.key_encryption_algo())); } if(!opts.cert_encryption_algo().empty()) { if(std::find(supported_key_algos.begin(), supported_key_algos.end(), opts.cert_encryption_algo()) == supported_key_algos.end()) { throw Invalid_Argument( fmt("PKCS#12: unsupported cert encryption algorithm '{}'", opts.cert_encryption_algo())); } } // An empty password is permitted for both encryption and the MAC: PKCS#12 // defines an encoding for it (RFC 7292) and such files are common in the // wild (e.g. some Java keystores). It offers no real protection, but there // is no technical reason to reject it. if(opts.include_mac()) { static const std::array supported_mac_digests = { "SHA-1", "SHA-224", "SHA-256", "SHA-384", "SHA-512", "SHA-512-256"}; if(std::find(supported_mac_digests.begin(), supported_mac_digests.end(), opts.mac_digest()) == supported_mac_digests.end()) { throw Invalid_Argument(fmt("PKCS#12: unsupported MAC digest '{}'", opts.mac_digest())); } if(!HashFunction::create(opts.mac_digest())) { throw Invalid_Argument(fmt("PKCS#12: MAC digest '{}' is not available in this build", opts.mac_digest())); } } } /* * Verify PKCS#12 MAC. * * When @p openssl_empty_pwd_compat is @c true and @p password is empty, the * KDF is fed an empty byte string (OpenSSL non-conforming behavior) instead * of the RFC 7292 form (a two-byte {0x00,0x00} terminator). */ void verify_mac(std::span auth_safe_data, std::span mac_value, std::span mac_salt, size_t iterations, const std::string& hash_name, std::string_view password, bool openssl_empty_pwd_compat) { auto hmac = MessageAuthenticationCode::create_or_throw(fmt("HMAC({})", hash_name)); const size_t mac_key_len = hmac->output_length(); secure_vector mac_key(mac_key_len); if(openssl_empty_pwd_compat && password.empty()) { const auto hash = HashFunction::create_or_throw(hash_name); pkcs12_kdf({mac_key.data(), mac_key_len}, {}, {mac_salt.data(), mac_salt.size()}, iterations, 3, *hash); } else { const PKCS12_KDF kdf(HashFunction::create_or_throw(hash_name), 3, iterations); kdf.derive_key(mac_key.data(), mac_key_len, password.data(), password.size(), mac_salt.data(), mac_salt.size()); } hmac->set_key(mac_key); hmac->update(auth_safe_data); if(!constant_time_compare(hmac->final(), mac_value)) { throw Invalid_Authentication_Tag("PKCS#12 MAC verification failed"); } } /* * Parse attributes from a SafeBag. Only FriendlyName and LocalKeyId are * handled; other attributes are silently skipped (RFC 7292 sec.4.2). */ void parse_bag_attributes(BER_Decoder& decoder, std::string& friendly_name, std::vector& local_key_id) { if(!decoder.more_items()) { return; } const OID friendly_name_oid = OID::from_string("PKCS9.FriendlyName"); const OID local_key_id_oid = OID::from_string("PKCS9.LocalKeyId"); BER_Decoder attrs = decoder.start_set(); while(attrs.more_items()) { OID attr_oid; BER_Decoder attr_seq = attrs.start_sequence(); attr_seq.decode(attr_oid); BER_Decoder values = attr_seq.start_set(); if(attr_oid == friendly_name_oid) { ASN1_String str; values.decode(str); friendly_name = str.value(); } else if(attr_oid == local_key_id_oid) { values.decode(local_key_id, ASN1_Type::OctetString); } values.discard_remaining(); values.end_cons(); attr_seq.discard_remaining(); attr_seq.end_cons(); } attrs.end_cons(); } // Helper bag carrying a parsed private key with its attributes. struct ParsedKey { std::shared_ptr key; std::vector local_key_id; std::string friendly_name; }; /* * Parse SafeContents (sequence of SafeBag) */ void parse_safe_contents(BER_Decoder& decoder, std::string_view password, std::vector& cert_entries, std::vector& key_entries, std::vector& unknown_bag_types, bool openssl_empty_pwd_compat, size_t depth = 0) { if(depth >= PKCS12_MAX_NESTING) { throw Decoding_Error("PKCS#12: SafeContentsBag nesting too deep"); } const OID cert_bag_oid = OID::from_string("PKCS12.CertBag"); const OID shrouded_key_bag_oid = OID::from_string("PKCS12.PKCS8ShroudedKeyBag"); const OID key_bag_oid = OID::from_string("PKCS12.KeyBag"); const OID safe_contents_bag_oid = OID::from_string("PKCS12.SafeContentsBag"); const OID x509_cert_oid = OID::from_string("PKCS9.X509Certificate"); while(decoder.more_items()) { OID bag_type; std::string bag_friendly_name; std::vector bag_key_id; BER_Decoder bag_seq = decoder.start_sequence(); bag_seq.decode(bag_type); BER_Decoder bag_value = bag_seq.start_context_specific(0); bool pushed_cert = false; bool pushed_key = false; if(bag_type == cert_bag_oid) { OID cert_type; BER_Decoder cert_bag = bag_value.start_sequence(); cert_bag.decode(cert_type); if(cert_type == x509_cert_oid) { std::vector cert_data; BER_Decoder cert_value = cert_bag.start_context_specific(0); cert_value.decode(cert_data, ASN1_Type::OctetString); cert_value.verify_end(); cert_entries.push_back({X509_Certificate(cert_data), {}, {}}); pushed_cert = true; } else { cert_bag.discard_remaining(); } cert_bag.end_cons(); bag_value.verify_end(); } else if(bag_type == shrouded_key_bag_oid) { AlgorithmIdentifier pbe_algo; std::vector encrypted_key; BER_Decoder shrouded = bag_value.start_sequence(); shrouded.decode(pbe_algo); shrouded.decode(encrypted_key, ASN1_Type::OctetString); shrouded.verify_end(); auto decrypted = pkcs12_pbe_decrypt(encrypted_key, password, pbe_algo, openssl_empty_pwd_compat); DataSource_Memory src(decrypted); key_entries.push_back({std::shared_ptr(PKCS8::load_key(src)), {}, {}}); pushed_key = true; } else if(bag_type == key_bag_oid) { secure_vector key_data; bag_value.raw_bytes(key_data); bag_value.verify_end(); DataSource_Memory src(key_data); key_entries.push_back({std::shared_ptr(PKCS8::load_key(src)), {}, {}}); pushed_key = true; } else if(bag_type == safe_contents_bag_oid) { BER_Decoder nested_sc = bag_value.start_sequence(); parse_safe_contents( nested_sc, password, cert_entries, key_entries, unknown_bag_types, openssl_empty_pwd_compat, depth + 1); nested_sc.verify_end(); bag_value.verify_end(); } else { unknown_bag_types.push_back(bag_type); bag_value.discard_remaining(); } bag_value.end_cons(); parse_bag_attributes(bag_seq, bag_friendly_name, bag_key_id); if(pushed_cert && !cert_entries.empty()) { if(!bag_key_id.empty()) { cert_entries.back().local_key_id = bag_key_id; } if(!bag_friendly_name.empty()) { cert_entries.back().friendly_name = bag_friendly_name; } } else if(pushed_key && !key_entries.empty()) { if(!bag_key_id.empty()) { key_entries.back().local_key_id = bag_key_id; } if(!bag_friendly_name.empty()) { key_entries.back().friendly_name = bag_friendly_name; } } bag_seq.verify_end(); } } /* * Parse AuthenticatedSafe (sequence of ContentInfo) */ void parse_authenticated_safe(std::span data, std::string_view password, std::vector& cert_entries, std::vector& key_entries, std::vector& unknown_bag_types, bool openssl_empty_pwd_compat) { const OID pkcs7_data_oid = OID::from_string("PKCS7.Data"); const OID pkcs7_enc_data_oid = OID::from_string("PKCS7.EncryptedData"); BER_Decoder auth_safe(data); BER_Decoder seq = auth_safe.start_sequence(); while(seq.more_items()) { OID content_type; BER_Decoder content_info = seq.start_sequence(); content_info.decode(content_type); if(content_type == pkcs7_data_oid) { std::vector safe_contents_data; BER_Decoder content = content_info.start_context_specific(0); content.decode(safe_contents_data, ASN1_Type::OctetString); content.verify_end(); BER_Decoder safe_contents(safe_contents_data); BER_Decoder sc_seq = safe_contents.start_sequence(); parse_safe_contents(sc_seq, password, cert_entries, key_entries, unknown_bag_types, openssl_empty_pwd_compat); sc_seq.verify_end(); safe_contents.verify_end(); content_info.verify_end(); } else if(content_type == pkcs7_enc_data_oid) { BER_Decoder content = content_info.start_context_specific(0); BER_Decoder enc_data = content.start_sequence(); size_t version = 0; enc_data.decode(version); if(version != 0) { throw Decoding_Error(fmt("PKCS#12: unsupported EncryptedData version: {}", version)); } BER_Decoder enc_content_info = enc_data.start_sequence(); OID enc_content_type; AlgorithmIdentifier enc_algo; enc_content_info.decode(enc_content_type); enc_content_info.decode(enc_algo); if(enc_content_type != pkcs7_data_oid) { throw Decoding_Error( fmt("PKCS#12: EncryptedData contentType must be Data, got {}", enc_content_type.to_formatted_string())); } std::vector encrypted_content; const BER_Object enc_content_obj = enc_content_info.get_next_object(); if(enc_content_obj.is_a(0, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) { const std::span raw(enc_content_obj.bits(), enc_content_obj.length()); encrypted_content.reserve(raw.size()); BER_Decoder chunks(raw); while(chunks.more_items()) { std::vector chunk; chunks.decode(chunk, ASN1_Type::OctetString); encrypted_content.insert(encrypted_content.end(), chunk.begin(), chunk.end()); } chunks.verify_end(); } else if(enc_content_obj.is_a(0, ASN1_Class::ContextSpecific)) { encrypted_content.assign(enc_content_obj.bits(), enc_content_obj.bits() + enc_content_obj.length()); } else { throw Decoding_Error("PKCS#12: Expected [0] context-specific for encrypted content"); } enc_content_info.verify_end(); enc_data.verify_end(); const secure_vector decrypted = pkcs12_pbe_decrypt(encrypted_content, password, enc_algo, openssl_empty_pwd_compat); BER_Decoder safe_contents(decrypted); BER_Decoder sc_seq = safe_contents.start_sequence(); parse_safe_contents(sc_seq, password, cert_entries, key_entries, unknown_bag_types, openssl_empty_pwd_compat); sc_seq.verify_end(); safe_contents.verify_end(); content.verify_end(); content_info.verify_end(); } else { throw Decoding_Error( fmt("PKCS#12: unsupported AuthenticatedSafe content type {}", content_type.to_formatted_string())); } } seq.verify_end(); auth_safe.verify_end(); } } // namespace // // PKCS12_Export_Options // PKCS12_Export_Options::PKCS12_Export_Options(std::string_view password, std::optional friendly_name) : m_password(password), m_friendly_name(std::move(friendly_name)) {} PKCS12_Export_Options PKCS12_Export_Options::modern(std::string_view password, std::optional friendly_name) { return PKCS12_Export_Options(password, std::move(friendly_name)); } PKCS12_Export_Options PKCS12_Export_Options::legacy_compat(std::string_view password, std::optional friendly_name) { PKCS12_Export_Options opts(password, std::move(friendly_name)); opts.m_iterations = 2048; opts.m_key_encryption_algo = "PBE-SHA1-3DES"; opts.m_mac_digest = "SHA-1"; return opts; } PKCS12_Export_Options& PKCS12_Export_Options::with_friendly_name(std::string name) { m_friendly_name = std::move(name); return *this; } PKCS12_Export_Options& PKCS12_Export_Options::with_iterations(size_t n) { m_iterations = n; return *this; } PKCS12_Export_Options& PKCS12_Export_Options::with_key_encryption_algo(std::string algo) { m_key_encryption_algo = std::move(algo); return *this; } PKCS12_Export_Options& PKCS12_Export_Options::with_cert_encryption_algo(std::string algo) { m_cert_encryption_algo = std::move(algo); return *this; } PKCS12_Export_Options& PKCS12_Export_Options::with_mac_digest(std::string algo) { m_mac_digest = std::move(algo); return *this; } PKCS12_Export_Options& PKCS12_Export_Options::without_mac() { m_include_mac = false; return *this; } // // PKCS12 // PKCS12::PKCS12(std::span data, std::string_view password) { std::vector cert_entries; std::vector key_entries; BER_Decoder pfx(data); BER_Decoder pfx_seq = pfx.start_sequence(); size_t version = 0; pfx_seq.decode(version); if(version != 3) { throw Decoding_Error(fmt("Unsupported PKCS#12 version: {}", version)); } OID auth_safe_type; std::vector auth_safe_content; BER_Decoder auth_safe_info = pfx_seq.start_sequence(); auth_safe_info.decode(auth_safe_type); const OID pkcs7_data_oid = OID::from_string("PKCS7.Data"); if(auth_safe_type != pkcs7_data_oid) { throw Decoding_Error("PKCS#12 authSafe must be of type Data"); } BER_Decoder auth_safe_content_wrapper = auth_safe_info.start_context_specific(0); auth_safe_content_wrapper.decode(auth_safe_content, ASN1_Type::OctetString); auth_safe_content_wrapper.verify_end(); auth_safe_info.verify_end(); // Tracks whether MAC verification succeeded with OpenSSL's non-conforming // empty-password encoding; if so, the same convention is used for any // subsequent EncryptedData / PKCS8ShroudedKeyBag decryption. bool openssl_empty_pwd_compat = false; if(pfx_seq.more_items()) { BER_Decoder mac_data = pfx_seq.start_sequence(); BER_Decoder digest_info = mac_data.start_sequence(); AlgorithmIdentifier digest_algo; std::vector mac_value; digest_info.decode(digest_algo); digest_info.decode(mac_value, ASN1_Type::OctetString); digest_info.verify_end(); std::vector mac_salt; size_t iterations = 1; mac_data.decode(mac_salt, ASN1_Type::OctetString); if(mac_data.more_items()) { mac_data.decode(iterations); } mac_data.verify_end(); if(iterations == 0 || iterations > PKCS12_MAX_ITERATIONS) { throw Decoding_Error(fmt("PKCS#12 MAC has invalid iteration count: {}", iterations)); } const std::string hash_name = resolve_mac_hash(digest_algo.oid()); // Try RFC 7292 password encoding first. If MAC verification fails and // the password is empty, retry with OpenSSL's non-conforming empty // encoding (some OpenSSL releases pass an empty byte string to the KDF // instead of the RFC {0x00,0x00} form when the password is empty). // Propagate the chosen convention to any subsequent PBE decryption. try { verify_mac(auth_safe_content, mac_value, mac_salt, iterations, hash_name, password, false); } catch(const Invalid_Authentication_Tag&) { if(!password.empty()) { throw; } verify_mac(auth_safe_content, mac_value, mac_salt, iterations, hash_name, password, true); openssl_empty_pwd_compat = true; } } parse_authenticated_safe( auth_safe_content, password, cert_entries, key_entries, m_unknown_bag_types, openssl_empty_pwd_compat); // Move all parsed keys into storage. m_private_keys.reserve(key_entries.size()); for(auto& ke : key_entries) { m_private_keys.push_back(std::move(ke.key)); } // Capture bundle-level attributes from the first key (if any), or from // the end-entity certificate (if found below). if(!key_entries.empty()) { if(!key_entries.front().friendly_name.empty()) { m_friendly_name = key_entries.front().friendly_name; } if(!key_entries.front().local_key_id.empty()) { m_local_key_id = key_entries.front().local_key_id; } } // Reorder certificates so the end-entity (cert matching the first key) // comes first; rest follow in original order. Match prefers localKeyId, // falls back to subjectPublicKeyInfo comparison. std::optional end_entity_idx; if(!cert_entries.empty() && !m_private_keys.empty()) { const auto& first_key = m_private_keys.front(); const auto& first_key_id = key_entries.empty() ? std::vector{} : key_entries.front().local_key_id; if(!first_key_id.empty()) { for(size_t i = 0; i < cert_entries.size(); ++i) { if(cert_entries[i].local_key_id == first_key_id) { end_entity_idx = i; break; } } } if(!end_entity_idx) { const auto key_spki = first_key->subject_public_key(); for(size_t i = 0; i < cert_entries.size(); ++i) { try { if(cert_entries[i].cert.subject_public_key_info() == key_spki) { end_entity_idx = i; break; } } catch(const Decoding_Error&) { // Certificate with unsupported key algorithm - skip } } } } m_certificates.reserve(cert_entries.size()); if(end_entity_idx) { m_certificates.push_back(std::move(cert_entries[*end_entity_idx].cert)); if(!m_friendly_name && !cert_entries[*end_entity_idx].friendly_name.empty()) { m_friendly_name = cert_entries[*end_entity_idx].friendly_name; } if(!m_local_key_id && !cert_entries[*end_entity_idx].local_key_id.empty()) { m_local_key_id = cert_entries[*end_entity_idx].local_key_id; } for(size_t i = 0; i < cert_entries.size(); ++i) { if(i != *end_entity_idx) { // Still surface any friendly name found on non-end-entity certs // when the bundle doesn't have one yet (some producers attach the // attribute to the CA bag instead of the end-entity bag). if(!m_friendly_name && !cert_entries[i].friendly_name.empty()) { m_friendly_name = cert_entries[i].friendly_name; } m_certificates.push_back(std::move(cert_entries[i].cert)); } } } else { for(auto& ce : cert_entries) { if(!m_friendly_name && !ce.friendly_name.empty()) { m_friendly_name = ce.friendly_name; } m_certificates.push_back(std::move(ce.cert)); } } pfx_seq.verify_end(); pfx_seq.end_cons(); pfx.verify_end("PKCS#12: trailing data after PFX"); } std::vector PKCS12::ca_certificates() const { if(m_certificates.size() < 2) { return {}; } const auto ee = end_entity_certificate(); std::vector result; result.reserve(m_certificates.size() - 1); if(ee) { // Skip the first certificate matching the end-entity (only one, in case // the bundle contains multiple certs signed for the same key, e.g. an // old leaf still kept alongside a renewed one). const auto ee_spki = ee->subject_public_key_info(); bool skipped = false; for(const auto& c : m_certificates) { if(!skipped && c.subject_public_key_info() == ee_spki) { skipped = true; continue; } result.push_back(c); } } else { // No end-entity (e.g. key-less bundle): treat the first stored cert as // the "primary" and surface the rest as CA / chain certs. This matches // the storage order used by parsing. for(size_t i = 1; i < m_certificates.size(); ++i) { result.push_back(m_certificates[i]); } } return result; } std::optional PKCS12::end_entity_certificate() const { if(m_certificates.empty() || m_private_keys.empty()) { return std::nullopt; } const auto& first_key = m_private_keys.front(); const auto key_spki = first_key->subject_public_key(); for(const auto& c : m_certificates) { try { if(c.subject_public_key_info() == key_spki) { return c; } } catch(const Decoding_Error&) { // Skip certificates with unsupported algorithms } } return std::nullopt; } void PKCS12::add_key(std::shared_ptr key) { if(!key) { throw Invalid_Argument("PKCS12::add_key: key must not be null"); } m_private_keys.push_back(std::move(key)); } void PKCS12::add_certificate(X509_Certificate cert) { m_certificates.push_back(std::move(cert)); } void PKCS12::set_friendly_name(std::string name) { m_friendly_name = std::move(name); } void PKCS12::clear_friendly_name() { m_friendly_name.reset(); } void PKCS12::set_local_key_id(std::vector id) { m_local_key_id = std::move(id); } void PKCS12::clear_local_key_id() { m_local_key_id.reset(); } std::vector PKCS12::export_to(const PKCS12_Export_Options& options, RandomNumberGenerator& rng) const { if(m_private_keys.empty() && m_certificates.empty()) { throw Invalid_Argument("PKCS#12::export_to requires at least a key or certificate"); } validate_options(options); // Determine end-entity certificate(s). With a single key we pair it // against a cert matching its SPKI; that pair gets the // friendly_name/localKeyId from options or the bundle. std::optional end_entity_idx; if(!m_private_keys.empty() && !m_certificates.empty()) { const auto& first_key = m_private_keys.front(); const auto key_spki = first_key->subject_public_key(); for(size_t i = 0; i < m_certificates.size(); ++i) { try { if(m_certificates[i].subject_public_key_info() == key_spki) { end_entity_idx = i; break; } } catch(const Decoding_Error&) { // skip } } if(!end_entity_idx) { throw Invalid_Argument("PKCS#12::export_to: private key does not match any certificate"); } } const OID cert_bag_oid = OID::from_string("PKCS12.CertBag"); const OID shrouded_key_oid = OID::from_string("PKCS12.PKCS8ShroudedKeyBag"); const OID x509_cert_oid = OID::from_string("PKCS9.X509Certificate"); const OID friendly_name_oid = OID::from_string("PKCS9.FriendlyName"); const OID local_key_id_oid = OID::from_string("PKCS9.LocalKeyId"); const OID pkcs7_data_oid = OID::from_string("PKCS7.Data"); const OID pkcs7_enc_data_oid = OID::from_string("PKCS7.EncryptedData"); // Pick the friendly-name and local-key-id used by attribute encoding. // Options take precedence over the bundle-level fields. const std::optional& friendly_name = options.friendly_name().has_value() ? options.friendly_name() : m_friendly_name; std::vector local_key_id; if(m_local_key_id) { local_key_id = *m_local_key_id; } else if(end_entity_idx) { local_key_id = m_certificates[*end_entity_idx].subject_public_key_bitstring_sha1(); } else if(!m_private_keys.empty()) { // Key-only bundle: derive from SHA-1 of the public key bits (matching the // convention used by X509_Certificate::subject_public_key_bitstring_sha1). auto sha1 = HashFunction::create_or_throw("SHA-1"); const auto pub_bits = m_private_keys.front()->public_key_bits(); sha1->update(pub_bits); local_key_id = unlock(sha1->final()); } auto write_attributes = [&](DER_Encoder& enc) { const bool has_fn = friendly_name.has_value() && !friendly_name->empty(); const bool has_id = !local_key_id.empty(); if(!has_fn && !has_id) { return; } enc.start_set(); if(has_fn) { enc.start_sequence(); enc.encode(friendly_name_oid); enc.start_set(); encode_bmpstring(enc, *friendly_name); enc.end_cons(); enc.end_cons(); } if(has_id) { enc.start_sequence(); enc.encode(local_key_id_oid); enc.start_set(); enc.encode(local_key_id, ASN1_Type::OctetString); enc.end_cons(); enc.end_cons(); } enc.end_cons(); }; // CertBags std::vector cert_safe_contents; if(!m_certificates.empty()) { DER_Encoder cert_bags(cert_safe_contents); cert_bags.start_sequence(); auto add_cert_bag = [&](const X509_Certificate& c, bool add_attrs) { cert_bags.start_sequence(); cert_bags.encode(cert_bag_oid); cert_bags.start_context_specific(0); cert_bags.start_sequence(); cert_bags.encode(x509_cert_oid); cert_bags.start_context_specific(0); cert_bags.encode(c.BER_encode(), ASN1_Type::OctetString); cert_bags.end_cons(); cert_bags.end_cons(); cert_bags.end_cons(); if(add_attrs) { write_attributes(cert_bags); } cert_bags.end_cons(); }; // End-entity first (so the file is read in the typical order), then // the rest in their stored order. if(end_entity_idx) { add_cert_bag(m_certificates[*end_entity_idx], true); for(size_t i = 0; i < m_certificates.size(); ++i) { if(i != *end_entity_idx) { add_cert_bag(m_certificates[i], false); } } } else { for(const auto& c : m_certificates) { add_cert_bag(c, false); } } cert_bags.end_cons(); } // Key SafeBag(s) std::vector key_safe_contents; if(!m_private_keys.empty()) { DER_Encoder key_bags(key_safe_contents); key_bags.start_sequence(); for(size_t i = 0; i < m_private_keys.size(); ++i) { const Private_Key& key = *m_private_keys[i]; key_bags.start_sequence(); key_bags.encode(shrouded_key_oid); secure_vector pkcs8_key = PKCS8::BER_encode(key); auto [enc_algo, enc_key] = pkcs12_pbe_encrypt(pkcs8_key, options.password(), options.key_encryption_algo(), options.iterations(), rng); key_bags.start_context_specific(0); key_bags.start_sequence(); key_bags.encode(enc_algo); key_bags.encode(enc_key, ASN1_Type::OctetString); key_bags.end_cons(); key_bags.end_cons(); // Only the first key carries the bundle-level attributes (preserves // the historical single-key behavior). if(i == 0) { write_attributes(key_bags); } key_bags.end_cons(); } key_bags.end_cons(); } // AuthenticatedSafe std::vector auth_safe_content; DER_Encoder auth_safe(auth_safe_content); auth_safe.start_sequence(); if(!cert_safe_contents.empty()) { if(!options.cert_encryption_algo().empty()) { auto [enc_algo, enc_data] = pkcs12_pbe_encrypt( cert_safe_contents, options.password(), options.cert_encryption_algo(), options.iterations(), rng); auth_safe.start_sequence(); auth_safe.encode(pkcs7_enc_data_oid); auth_safe.start_context_specific(0); auth_safe.start_sequence(); auth_safe.encode(size_t(0)); auth_safe.start_sequence(); auth_safe.encode(pkcs7_data_oid); auth_safe.encode(enc_algo); auth_safe.add_object(ASN1_Type(0), ASN1_Class::ContextSpecific, enc_data); auth_safe.end_cons(); auth_safe.end_cons(); auth_safe.end_cons(); auth_safe.end_cons(); } else { auth_safe.start_sequence(); auth_safe.encode(pkcs7_data_oid); auth_safe.start_context_specific(0); auth_safe.encode(cert_safe_contents, ASN1_Type::OctetString); auth_safe.end_cons(); auth_safe.end_cons(); } } if(!key_safe_contents.empty()) { auth_safe.start_sequence(); auth_safe.encode(pkcs7_data_oid); auth_safe.start_context_specific(0); auth_safe.encode(key_safe_contents, ASN1_Type::OctetString); auth_safe.end_cons(); auth_safe.end_cons(); } auth_safe.end_cons(); // PFX std::vector pfx_data; DER_Encoder pfx(pfx_data); pfx.start_sequence(); pfx.encode(size_t(3)); pfx.start_sequence(); pfx.encode(pkcs7_data_oid); pfx.start_context_specific(0); pfx.encode(auth_safe_content, ASN1_Type::OctetString); pfx.end_cons(); pfx.end_cons(); if(options.include_mac()) { const std::string& mac_hash = options.mac_digest(); auto hmac = MessageAuthenticationCode::create_or_throw(fmt("HMAC({})", mac_hash)); std::vector mac_salt(hmac->output_length()); rng.randomize(mac_salt.data(), mac_salt.size()); const size_t mac_key_len = hmac->output_length(); secure_vector mac_key(mac_key_len); const PKCS12_KDF kdf(HashFunction::create_or_throw(mac_hash), 3, options.iterations()); kdf.derive_key(mac_key.data(), mac_key_len, options.password().data(), options.password().size(), mac_salt.data(), mac_salt.size()); hmac->set_key(mac_key); hmac->update(auth_safe_content); const secure_vector mac_value = hmac->final(); pfx.start_sequence(); pfx.start_sequence(); const auto param_encoding = (mac_hash == "SHA-1") ? AlgorithmIdentifier::USE_NULL_PARAM : AlgorithmIdentifier::USE_EMPTY_PARAM; pfx.encode(AlgorithmIdentifier(OID::from_string(mac_hash), param_encoding)); pfx.encode(mac_value, ASN1_Type::OctetString); pfx.end_cons(); pfx.encode(mac_salt, ASN1_Type::OctetString); if(options.iterations() != 1) { pfx.encode(options.iterations()); } pfx.end_cons(); } pfx.end_cons(); return pfx_data; } } // namespace Botan