diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index c95104f4e16e..7f6fbf7ffd40 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -5518,6 +5518,39 @@ const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
 console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
 ```
 
+### `crypto.parsePKCS12(bundle[, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `bundle` {ArrayBuffer|Buffer|TypedArray|DataView} A DER-encoded PKCS#12
+  (`.p12` or `.pfx`) bundle.
+* `options` {Object}
+  * `passphrase` {string|ArrayBuffer|Buffer|TypedArray|DataView} The passphrase
+    protecting the bundle. Omitting this option is equivalent to passing `''`.
+* Returns: {Object}
+  * `privateKey` {KeyObject|null} The first private key in the bundle, or
+    `null` if none is present.
+  * `certificate` {X509Certificate|null} The certificate matching `privateKey`,
+    or `null` if no matching certificate is present.
+  * `additionalCertificates` {X509Certificate\[]} All other certificates in
+    the bundle. If there is no private key, this contains all certificates.
+    May be empty.
+
+Parses a PKCS#12 bundle, commonly stored with a `.p12` or `.pfx` extension,
+and returns its private key and certificates.
+
+```mjs
+import { parsePKCS12 } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+const { privateKey, certificate, additionalCertificates } = parsePKCS12(
+  readFileSync('bundle.p12'),
+  { passphrase: 'secret' },
+);
+```
+
 ### `crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)`
 
 <!-- YAML
diff --git a/lib/crypto.js b/lib/crypto.js
index b44ae9de4e5d..3e720cd3bdf6 100644
--- a/lib/crypto.js
+++ b/lib/crypto.js
@@ -84,6 +84,7 @@ const {
   createSecretKey,
   createPublicKey,
   createPrivateKey,
+  parsePKCS12,
   KeyObject,
 } = require('internal/crypto/keys');
 const {
@@ -216,6 +217,7 @@ module.exports = {
   getMacs,
   hkdf,
   hkdfSync,
+  parsePKCS12,
   pbkdf2,
   pbkdf2Sync,
   generateKeyPair,
diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js
index 2f6830efce17..f54ba68f6705 100644
--- a/lib/internal/crypto/keys.js
+++ b/lib/internal/crypto/keys.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayPrototypeMap,
   ArrayPrototypeSlice,
   ObjectDefineProperties,
   ObjectPrototypeHasOwnProperty,
@@ -8,6 +9,7 @@ const {
   StringPrototypeIncludes,
   StringPrototypeStartsWith,
   SymbolToStringTag,
+  TypedArrayPrototypeIncludes,
   Uint8Array,
 } = primordials;
 
@@ -35,6 +37,7 @@ const {
   kKeyEncodingPKCS8,
   kKeyEncodingSPKI,
   kKeyEncodingSEC1,
+  parsePKCS12: _parsePKCS12,
 } = internalBinding('crypto');
 
 const {
@@ -63,6 +66,7 @@ const {
 
 const {
   getArrayBufferOrView,
+  getBufferSourceBytes,
   bigIntArrayToUnsignedBigInt,
   normalizeAlgorithm,
   hasAnyNotIn,
@@ -784,6 +788,65 @@ function createPublicKey(key) {
   return new PublicKeyObject(handle);
 }
 
+/**
+ * Parses a PKCS#12 (.p12 / .pfx) bundle. Returns an object holding the first
+ * private key as `privateKey`, the certificate associated with it as
+ * `certificate`, and every other certificate in the bundle as an array in
+ * `additionalCertificates`. `privateKey` and `certificate` are null when the
+ * bundle contains none.
+ * @param {ArrayBuffer|Buffer|TypedArray|DataView} bundle
+ * @param {object} [options]
+ * @returns {object}
+ */
+function parsePKCS12(bundle, options = kEmptyObject) {
+  if (!isArrayBufferView(bundle) && !isAnyArrayBuffer(bundle)) {
+    throw new ERR_INVALID_ARG_TYPE(
+      'bundle',
+      ['ArrayBuffer', 'TypedArray', 'DataView', 'Buffer'],
+      bundle);
+  }
+
+  validateObject(options, 'options');
+  const { passphrase } = options;
+
+  // `undefined` means no passphrase, '' a zero-length one. OpenSSL accepts
+  // either PKCS#12 password encoding for both, so they behave the same.
+  let passBuf;
+  if (passphrase !== undefined) {
+    passBuf = getArrayBufferOrView(passphrase, 'options.passphrase', 'utf8');
+    // OpenSSL takes the passphrase as a NUL-terminated C string, so one
+    // containing a NUL byte would be truncated there and the bundle opened
+    // with only the bytes before it. A PKCS#12 password cannot represent an
+    // embedded NUL anyway, so reject it outright.
+    if (TypedArrayPrototypeIncludes(getBufferSourceBytes(passBuf), 0)) {
+      throw new ERR_INVALID_ARG_VALUE(
+        'options.passphrase', passphrase, 'must not contain null bytes');
+    }
+    // The binding reads the passphrase as a view; wrap a bare ArrayBuffer.
+    if (isAnyArrayBuffer(passBuf)) passBuf = Buffer.from(passBuf);
+  }
+
+  // Likewise, the binding reads the bundle as a view.
+  const bundleBuf = isAnyArrayBuffer(bundle) ? Buffer.from(bundle) : bundle;
+
+  const {
+    0: keyHandle,
+    1: certHandle,
+    2: otherHandles,
+  } = _parsePKCS12(bundleBuf, passBuf);
+
+  // Required lazily: internal/crypto/x509 depends on this module.
+  const { InternalX509Certificate } = require('internal/crypto/x509');
+
+  return {
+    privateKey: keyHandle === null ? null : new PrivateKeyObject(keyHandle),
+    certificate:
+      certHandle === null ? null : new InternalX509Certificate(certHandle),
+    additionalCertificates:
+      ArrayPrototypeMap(otherHandles, (h) => new InternalX509Certificate(h)),
+  };
+}
+
 /**
  * Converts a secret KeyObjectHandle to a CryptoKey by dispatching to the
  * algorithm-specific Web Crypto import path.
@@ -1433,6 +1496,7 @@ module.exports = {
   createSecretKey,
   createPublicKey,
   createPrivateKey,
+  parsePKCS12,
   KeyObject,
   CryptoKey,
   InternalCryptoKey,
diff --git a/node.gyp b/node.gyp
index 52f421f3181c..1374033c9101 100644
--- a/node.gyp
+++ b/node.gyp
@@ -412,6 +412,7 @@
       'src/crypto/crypto_hash.cc',
       'src/crypto/crypto_keys.cc',
       'src/crypto/crypto_keygen.cc',
+      'src/crypto/crypto_pkcs12.cc',
       'src/crypto/crypto_scrypt.cc',
       'src/crypto/crypto_tls.cc',
       'src/crypto/crypto_x509.cc',
@@ -432,6 +433,7 @@
       'src/crypto/crypto_hash.h',
       'src/crypto/crypto_keys.h',
       'src/crypto/crypto_keygen.h',
+      'src/crypto/crypto_pkcs12.h',
       'src/crypto/crypto_scrypt.h',
       'src/crypto/crypto_tls.h',
       'src/crypto/crypto_context.h',
diff --git a/src/crypto/crypto_context.cc b/src/crypto/crypto_context.cc
index 9dc68f4d9d2d..d572f4784699 100644
--- a/src/crypto/crypto_context.cc
+++ b/src/crypto/crypto_context.cc
@@ -2,6 +2,7 @@
 #include "base_object-inl.h"
 #include "crypto/crypto_bio.h"
 #include "crypto/crypto_common.h"
+#include "crypto/crypto_pkcs12.h"
 #include "crypto/crypto_tls_certificates.h"
 #include "crypto/crypto_util.h"
 #include "env-inl.h"
@@ -16,7 +17,6 @@
 #ifdef NODE_OPENSSL_HAS_CERT_COMP
 #include <openssl/comp.h>
 #endif
-#include <openssl/pkcs12.h>
 #include <openssl/rand.h>
 #include <openssl/x509.h>
 #ifdef __APPLE__
@@ -2185,13 +2185,30 @@ void SecureContext::Close(const FunctionCallbackInfo<Value>& args) {
   sc->Reset();
 }
 
+namespace {
+// The historical error shape for the TLS `pfx` option: the OpenSSL reason
+// string, except for OpenSSL 3's bare "unsupported" error, which on its own
+// says nothing useful.
+// TODO(@jasnell): Should this use ThrowCryptoError?
+// NOLINTNEXTLINE(runtime/int) -- matches ERR_get_error()
+void ThrowPFXError(Environment* env, unsigned long err) {
+#if OPENSSL_VERSION_MAJOR >= 3
+  if (ERR_GET_REASON(err) == ERR_R_UNSUPPORTED) {
+    return THROW_ERR_CRYPTO_UNSUPPORTED_OPERATION(
+        env, "Unsupported PKCS12 PFX data");
+  }
+#endif
+
+  const char* str = ERR_reason_error_string(err);
+  str = str != nullptr ? str : "Unknown error";
+  env->ThrowError(str);
+}
+}  // namespace
+
 // Takes .pfx or .p12 and password in string or buffer format
 void SecureContext::LoadPKCS12(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
-  std::vector<char> pass;
-  bool ret = false;
-
   SecureContext* sc;
   ASSIGN_OR_RETURN_UNWRAP(&sc, args.This());
   ClearErrorOnReturn clear_error_on_return;
@@ -2206,66 +2223,55 @@ void SecureContext::LoadPKCS12(const FunctionCallbackInfo<Value>& args) {
         env, "Unable to load PFX certificate");
   }
 
+  // PKCS12_parse() takes a NUL-terminated C string; a view is not one, so copy
+  // the bytes out. A passphrase is optional; nullptr means none was given.
+  std::vector<char> pass_storage;
+  const char* pass = nullptr;
   if (args.Length() >= 2) {
     THROW_AND_RETURN_IF_NOT_BUFFER(env, args[1], "Pass phrase");
     Local<ArrayBufferView> abv = args[1].As<ArrayBufferView>();
     size_t passlen = abv->ByteLength();
-    pass.resize(passlen + 1);
-    abv->CopyContents(pass.data(), passlen);
-    pass[passlen] = '\0';
+    pass_storage.resize(passlen + 1);
+    abv->CopyContents(pass_storage.data(), passlen);
+    pass_storage[passlen] = '\0';
+    pass = pass_storage.data();
   }
 
   // Free previous certs
   sc->issuer_.reset();
   sc->cert_.reset();
 
-  DeleteFnPtr<PKCS12, PKCS12_free> p12;
-  EVPKeyPointer pkey;
-  X509Pointer cert;
-  StackOfX509 extra_certs;
-
-  PKCS12* p12_ptr = nullptr;
-  EVP_PKEY* pkey_ptr = nullptr;
-  X509* cert_ptr = nullptr;
-  STACK_OF(X509)* extra_certs_ptr = nullptr;
-
-  if (!d2i_PKCS12_bio(in.get(), &p12_ptr)) {
-    goto done;
-  }
-
-  // Move ownership to the smart pointer:
-  p12.reset(p12_ptr);
-
-  if (!PKCS12_parse(
-          p12.get(), pass.data(), &pkey_ptr, &cert_ptr, &extra_certs_ptr)) {
-    goto done;
+  auto parsed = ParsePKCS12Bundle(in, pass);
+  if (!parsed) {
+    // Every parse failure carries the OpenSSL error that caused it, which is
+    // all this path needs: ThrowPFXError() derives the same message it always
+    // has, the UNSUPPORTED_ALGORITHM case included.
+    return ThrowPFXError(env, parsed.openssl_error.value_or(0));
   }
 
-  // Move ownership of the parsed data:
-  pkey.reset(pkey_ptr);
-  cert.reset(cert_ptr);
-  extra_certs.reset(extra_certs_ptr);
-
-  if (!pkey) {
+  // Unlike crypto.parsePKCS12(), TLS needs both halves of the pair.
+  if (!parsed.value.key) {
     return THROW_ERR_CRYPTO_OPERATION_FAILED(
         env, "Unable to load private key from PFX data");
   }
 
-  if (!cert) {
+  if (!parsed.value.cert) {
     return THROW_ERR_CRYPTO_OPERATION_FAILED(
         env, "Unable to load certificate from PFX data");
   }
 
+  const StackOfX509& extra_certs = parsed.value.ca;
+
   if (!SSL_CTX_use_certificate_chain(sc->ctx_.get(),
-                                     std::move(cert),
+                                     std::move(parsed.value.cert),
                                      extra_certs.get(),
                                      &sc->cert_,
                                      &sc->issuer_)) {
-    goto done;
+    return ThrowPFXError(env, ERR_get_error());
   }
 
-  if (!SSL_CTX_use_PrivateKey(sc->ctx_.get(), pkey.get())) {
-    goto done;
+  if (!SSL_CTX_use_PrivateKey(sc->ctx_.get(), parsed.value.key.get())) {
+    return ThrowPFXError(env, ERR_get_error());
   }
 
   // Add CA certs too
@@ -2275,27 +2281,6 @@ void SecureContext::LoadPKCS12(const FunctionCallbackInfo<Value>& args) {
     X509_STORE_add_cert(sc->GetCertStoreOwnedByThisSecureContext(), ca);
     CHECK_EQ(1, SSL_CTX_add_client_CA(sc->ctx_.get(), ca));
   }
-  ret = true;
-
-done:
-  if (!ret) {
-    // TODO(@jasnell): Should this use ThrowCryptoError?
-    unsigned long err = ERR_get_error();  // NOLINT(runtime/int)
-
-#if OPENSSL_VERSION_MAJOR >= 3
-    if (ERR_GET_REASON(err) == ERR_R_UNSUPPORTED) {
-      // OpenSSL's "unsupported" error without any context is very
-      // common and not very helpful, so we override it:
-      return THROW_ERR_CRYPTO_UNSUPPORTED_OPERATION(
-          env, "Unsupported PKCS12 PFX data");
-    }
-#endif
-
-    const char* str = ERR_reason_error_string(err);
-    str = str != nullptr ? str : "Unknown error";
-
-    return env->ThrowError(str);
-  }
 }
 
 #ifndef OPENSSL_NO_ENGINE
diff --git a/src/crypto/crypto_pkcs12.cc b/src/crypto/crypto_pkcs12.cc
new file mode 100644
index 000000000000..8b0af44d9d7f
--- /dev/null
+++ b/src/crypto/crypto_pkcs12.cc
@@ -0,0 +1,193 @@
+#include "crypto/crypto_pkcs12.h"
+#include "crypto/crypto_context.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
+#include "crypto/crypto_x509.h"
+#include "env-inl.h"
+#include "ncrypto.h"
+#include "node_errors.h"
+#include "util-inl.h"
+#include "v8.h"
+
+#include <openssl/pkcs12.h>
+
+#include <string>
+
+namespace node {
+
+using ncrypto::BIOPointer;
+using v8::Array;
+using v8::ArrayBufferView;
+using v8::FunctionCallbackInfo;
+using v8::Local;
+using v8::LocalVector;
+using v8::Object;
+using v8::Value;
+
+namespace crypto {
+
+// Parses a PKCS#12 bundle from `bio`. See crypto_pkcs12.h; shared with
+// SecureContext::LoadPKCS12(), which backs the TLS `pfx` option.
+PKCS12ParseResult ParsePKCS12Bundle(const BIOPointer& bio, const char* pass) {
+  using PKCS12Pointer = ncrypto::DeleteFnPtr<PKCS12, PKCS12_free>;
+
+  ncrypto::ClearErrorOnReturn clear_error_on_return;
+
+  if (!bio) {
+    return PKCS12ParseResult(PKCS12ParseError::FAILED, ERR_get_error());
+  }
+
+  PKCS12* p12_ptr = nullptr;
+  if (!d2i_PKCS12_bio(bio.get(), &p12_ptr) || p12_ptr == nullptr) {
+    return PKCS12ParseResult(PKCS12ParseError::NOT_RECOGNIZED, ERR_get_error());
+  }
+  PKCS12Pointer p12(p12_ptr);
+
+  EVP_PKEY* pkey_ptr = nullptr;
+  X509* cert_ptr = nullptr;
+  STACK_OF(X509)* ca_ptr = nullptr;
+
+  if (!PKCS12_parse(p12.get(), pass, &pkey_ptr, &cert_ptr, &ca_ptr)) {
+    unsigned long err = ERR_get_error();  // NOLINT(runtime/int)
+#ifdef OPENSSL_IS_BORINGSSL
+    // BoringSSL's d2i_PKCS12() only copies the input; it does no ASN.1
+    // validation, so malformed input gets this far rather than failing above.
+    // PKCS8_R_BAD_PKCS12_DATA is raised only for structural failures -- a
+    // wrong passphrase is reported as PKCS8_R_INCORRECT_PASSWORD instead --
+    // so it means the same thing the d2i failure does on OpenSSL.
+    if (ERR_GET_LIB(err) == ERR_LIB_PKCS8 &&
+        ERR_GET_REASON(err) == PKCS8_R_BAD_PKCS12_DATA) {
+      return PKCS12ParseResult(PKCS12ParseError::NOT_RECOGNIZED, err);
+    }
+#endif
+#if OPENSSL_VERSION_MAJOR >= 3
+    // OpenSSL 3 reports algorithms that moved to the legacy provider as a
+    // bare "unsupported" error.
+    if (ERR_GET_REASON(err) == ERR_R_UNSUPPORTED) {
+      return PKCS12ParseResult(PKCS12ParseError::UNSUPPORTED_ALGORITHM, err);
+    }
+#endif
+    return PKCS12ParseResult(PKCS12ParseError::FAILED, err);
+  }
+
+  PKCS12Contents contents;
+  contents.key.reset(pkey_ptr);
+  contents.cert.reset(cert_ptr);
+  contents.ca.reset(ca_ptr);
+  return PKCS12ParseResult(std::move(contents));
+}
+
+namespace {
+
+// Returns [ keyHandle | null, certificate | null,
+//           [ ...additionalCertificates ] ].
+void ParsePKCS12(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  CHECK_GE(args.Length(), 2);
+
+  BIOPointer bio(LoadBIO(env, args[0]));
+  if (!bio) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
+                                             "Unable to read PKCS#12 data");
+  }
+
+  // PKCS12_parse() takes a NUL-terminated C string; a view is not one, so copy
+  // the bytes out.
+  std::string pass_storage;
+  const char* pass = nullptr;
+  if (!args[1]->IsUndefined()) {
+    THROW_AND_RETURN_IF_NOT_BUFFER(env, args[1], "passphrase");
+    Local<ArrayBufferView> abv = args[1].As<ArrayBufferView>();
+    size_t len = abv->ByteLength();
+    pass_storage.resize(len);
+    if (len > 0) abv->CopyContents(pass_storage.data(), len);
+    // PKCS12_parse() has no length parameter, so an embedded NUL byte would
+    // truncate the passphrase and open the bundle with only the bytes that
+    // precede it. Reject it rather than silently accepting a shorter
+    // passphrase than the caller supplied. The JS layer checks this too;
+    // this is the backstop.
+    if (pass_storage.find('\0') != std::string::npos) {
+      return THROW_ERR_INVALID_ARG_VALUE(
+          env, "passphrase must not contain null bytes");
+    }
+    pass = pass_storage.c_str();
+  }
+
+  auto parsed = ParsePKCS12Bundle(bio, pass);
+
+  if (!parsed) {
+    switch (*parsed.error) {
+      case PKCS12ParseError::NOT_RECOGNIZED:
+        return THROW_ERR_CRYPTO_OPERATION_FAILED(
+            env, "Input is not a valid PKCS#12 structure");
+      case PKCS12ParseError::UNSUPPORTED_ALGORITHM:
+        return THROW_ERR_CRYPTO_UNSUPPORTED_OPERATION(
+            env,
+            "PKCS#12 bundle uses an unsupported algorithm; it may require "
+            "the OpenSSL legacy provider");
+      case PKCS12ParseError::FAILED:
+        return ThrowCryptoError(env,
+                                parsed.openssl_error.value_or(0),
+                                "Unable to parse PKCS#12 data");
+    }
+  }
+
+  Local<Value> key_value = v8::Null(env->isolate());
+  if (parsed.value.key) {
+    auto data = KeyObjectData::CreateAsymmetric(KeyType::kKeyTypePrivate,
+                                                std::move(parsed.value.key));
+    Local<Object> handle;
+    if (!KeyObjectHandle::Create(env, data).ToLocal(&handle)) return;
+    key_value = handle;
+  }
+
+  Local<Value> cert_value = v8::Null(env->isolate());
+  if (parsed.value.cert) {
+    Local<Object> cert;
+    if (!X509Certificate::New(env, std::move(parsed.value.cert))
+             .ToLocal(&cert)) {
+      return;
+    }
+    cert_value = cert;
+  }
+
+  const int ca_count = parsed.value.ca ? sk_X509_num(parsed.value.ca.get()) : 0;
+  LocalVector<Value> ca_values(env->isolate());
+  ca_values.reserve(ca_count > 0 ? ca_count : 0);
+
+  for (int i = 0; i < ca_count; i++) {
+    X509* ca = sk_X509_value(parsed.value.ca.get(), i);
+    if (ca == nullptr) continue;
+    // New() takes ownership, so hand it a reference of its own rather than
+    // the stack's.
+    X509_up_ref(ca);
+    ncrypto::X509Pointer owned(ca);
+    Local<Object> obj;
+    if (!X509Certificate::New(env, std::move(owned)).ToLocal(&obj)) return;
+    ca_values.push_back(obj);
+  }
+
+  Local<Value> result[] = {
+      key_value,
+      cert_value,
+      Array::New(env->isolate(), ca_values.data(), ca_values.size()),
+  };
+
+  args.GetReturnValue().Set(
+      Array::New(env->isolate(), result, arraysize(result)));
+}
+
+}  // anonymous namespace
+
+void PKCS12Parser::Initialize(Environment* env, Local<Object> target) {
+  SetMethodNoSideEffect(env->context(), target, "parsePKCS12", ParsePKCS12);
+}
+
+void PKCS12Parser::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(ParsePKCS12);
+}
+
+}  // namespace crypto
+}  // namespace node
diff --git a/src/crypto/crypto_pkcs12.h b/src/crypto/crypto_pkcs12.h
new file mode 100644
index 000000000000..598b9e5094c9
--- /dev/null
+++ b/src/crypto/crypto_pkcs12.h
@@ -0,0 +1,54 @@
+#ifndef SRC_CRYPTO_CRYPTO_PKCS12_H_
+#define SRC_CRYPTO_CRYPTO_PKCS12_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "env.h"
+#include "ncrypto.h"
+#include "v8.h"
+
+namespace node {
+namespace crypto {
+
+// Parsed contents of a PKCS#12 bundle. Any field may be empty: a bundle can
+// legitimately contain only certificates, or only a key.
+struct PKCS12Contents {
+  ncrypto::EVPKeyPointer key;
+  ncrypto::X509Pointer cert;
+  ncrypto::StackOfX509 ca;
+};
+
+enum class PKCS12ParseError {
+  // Input is not a well-formed PKCS#12 structure.
+  NOT_RECOGNIZED,
+  // Structure is valid but uses an algorithm the active providers do not
+  // offer -- typically RC2 or PBE-SHA1 without the legacy provider.
+  UNSUPPORTED_ALGORITHM,
+  FAILED,
+};
+
+using PKCS12ParseResult = ncrypto::Result<PKCS12Contents, PKCS12ParseError>;
+
+// Parses a PKCS#12 bundle from `bio`. `pass` is nullptr for no passphrase, or
+// a NUL-terminated string. PKCS12_parse() verifies the MAC when one is present,
+// and for nullptr or "" it tries both PKCS#12 password encodings, so those two
+// arguments cannot give different results.
+//
+// Callers apply their own requirements to the result: crypto.parsePKCS12()
+// accepts any combination of key and certificates, while the TLS `pfx` option
+// requires both a key and a certificate.
+PKCS12ParseResult ParsePKCS12Bundle(const ncrypto::BIOPointer& bio,
+                                    const char* pass);
+
+class PKCS12Parser final {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+};
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CRYPTO_CRYPTO_PKCS12_H_
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index e82167b1fb4e..99cb556ecd9b 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -52,6 +52,7 @@ namespace crypto {
   V(NativeCryptoKey)                                                           \
   V(NativeKeyObject)                                                           \
   V(PBKDF2Job)                                                                 \
+  V(PKCS12Parser)                                                              \
   V(Random)                                                                    \
   V(RSAAlg)                                                                    \
   V(SecureContext)                                                             \
diff --git a/src/node_crypto.h b/src/node_crypto.h
index f3e006e5fee8..e15e5958808c 100644
--- a/src/node_crypto.h
+++ b/src/node_crypto.h
@@ -50,6 +50,7 @@
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_mac.h"
 #include "crypto/crypto_pbkdf2.h"
+#include "crypto/crypto_pkcs12.h"
 #include "crypto/crypto_pqc.h"
 #include "crypto/crypto_random.h"
 #include "crypto/crypto_rsa.h"
diff --git a/test/fixtures/keys/Makefile b/test/fixtures/keys/Makefile
index 0960e69f36fd..236063643ab6 100644
--- a/test/fixtures/keys/Makefile
+++ b/test/fixtures/keys/Makefile
@@ -7,6 +7,7 @@ all: \
   ca4-cert.pem \
   ca5-cert.pem \
   ca6-cert.pem \
+  cert-without-key-fips.pfx \
   agent1-cert.pem \
   agent1-fips.pfx \
   agent1.pfx \
@@ -816,6 +817,18 @@ ec-fips.pfx: ec-cert.pem ec-key.pem
 		-out ec-fips.pfx \
 		-password pass:password
 
+# A bundle of certificates with no private key. See agent1-fips.pfx for why the
+# FIPS fixture uses PBMAC1.
+cert-without-key-fips.pfx: ca1-cert.pem
+	openssl pkcs12 -export \
+		-nokeys \
+		-certpbe AES-256-CBC \
+		-iter 2048 \
+		-pbmac1_pbkdf2 \
+		-in ca1-cert.pem \
+		-out cert-without-key-fips.pfx \
+		-password pass:password
+
 dh512.pem:
 	openssl dhparam -out dh512.pem 512
 
diff --git a/test/fixtures/keys/cert-without-key-fips.pfx b/test/fixtures/keys/cert-without-key-fips.pfx
new file mode 100644
index 000000000000..613dbf1a6798
Binary files /dev/null and b/test/fixtures/keys/cert-without-key-fips.pfx differ
diff --git a/test/parallel/test-crypto-pkcs12.js b/test/parallel/test-crypto-pkcs12.js
new file mode 100644
index 000000000000..0ec9a2f544d8
--- /dev/null
+++ b/test/parallel/test-crypto-pkcs12.js
@@ -0,0 +1,226 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+const fixtures = require('../common/fixtures');
+const { hasOpenSSL3, hasFIPS } = require('../common/crypto');
+
+const fips3 = hasFIPS(3);
+
+if (fips3) {
+  // The long-standing fixtures protect their contents with PKCS12KDF and
+  // 3DES, neither of which the FIPS provider offers, so they cannot be opened
+  // at all. Assert the recognizable error rather than skipping: this is the
+  // same path the legacy.pfx case below exercises.
+  for (const name of ['rsa_cert.pfx', 'agent1.pfx']) {
+    assert.throws(
+      () => crypto.parsePKCS12(fixtures.readKey(name), { passphrase: 'sample' }),
+      { code: 'ERR_CRYPTO_UNSUPPORTED_OPERATION' });
+  }
+
+  // Reading the PBMAC1-protected FIPS fixtures needs OpenSSL 3.5 or newer, so
+  // below that there is nothing further this test can check.
+  if (!hasFIPS(3, 5)) return;
+}
+
+// The FIPS fixtures use PBMAC1/PBKDF2 and AES-256 in place of PKCS12KDF and
+// 3DES. Their passphrase is eight characters because the OpenSSL 4 FIPS
+// provider rejects shorter ones outright, which would mask the errors the
+// cases below are actually about.
+const keyAndCert = fips3 ?
+  { name: 'agent1-fips.pfx', passphrase: 'password', additional: 1 } :
+  { name: 'rsa_cert.pfx', passphrase: 'sample', additional: 0 };
+const withCaCert = fips3 ?
+  { name: 'agent1-fips.pfx', passphrase: 'password' } :
+  { name: 'agent1.pfx', passphrase: 'sample' };
+const ecKeyAndCert = fips3 ?
+  { name: 'ec-fips.pfx', passphrase: 'password' } :
+  { name: 'ec.pfx', passphrase: '' };
+const certWithoutKey = fips3 ?
+  { name: 'cert-without-key-fips.pfx', passphrase: 'password' } :
+  { name: 'cert-without-key.pfx', passphrase: 'test' };
+
+{
+  // Round-trip: a bundle holding one key and its certificate.
+  const bundle = fixtures.readKey(keyAndCert.name);
+  const { privateKey, certificate, additionalCertificates } =
+    crypto.parsePKCS12(bundle, { passphrase: keyAndCert.passphrase });
+
+  assert.strictEqual(privateKey.type, 'private');
+  assert.strictEqual(privateKey.asymmetricKeyType, 'rsa');
+  assert.ok(certificate instanceof crypto.X509Certificate);
+  assert.ok(Array.isArray(additionalCertificates));
+  assert.strictEqual(additionalCertificates.length, keyAndCert.additional);
+
+  // The parsed key and certificate must actually correspond.
+  assert.strictEqual(certificate.checkPrivateKey(privateKey), true);
+
+  // PEM export -- the primary reason callers want this API at all.
+  const keyPem = privateKey.export({ type: 'pkcs8', format: 'pem' });
+  assert.match(keyPem, /^-----BEGIN PRIVATE KEY-----/);
+  assert.match(certificate.toString(), /^-----BEGIN CERTIFICATE-----/);
+
+  // Round-trips back through createPrivateKey.
+  const reimported = crypto.createPrivateKey(keyPem);
+  assert.strictEqual(reimported.asymmetricKeyType, 'rsa');
+
+  // Passphrase accepted as a buffer as well as a string.
+  const { privateKey: key2 } = crypto.parsePKCS12(
+    bundle, { passphrase: Buffer.from(keyAndCert.passphrase) });
+  assert.strictEqual(key2.type, 'private');
+}
+
+{
+  // A bundle carrying a second certificate alongside the end-entity one.
+  const bundle = fixtures.readKey(withCaCert.name);
+  const { privateKey, certificate, additionalCertificates } =
+    crypto.parsePKCS12(bundle, { passphrase: withCaCert.passphrase });
+  assert.strictEqual(privateKey.type, 'private');
+  assert.ok(certificate instanceof crypto.X509Certificate);
+  assert.strictEqual(additionalCertificates.length, 1);
+  assert.ok(additionalCertificates[0] instanceof crypto.X509Certificate);
+  assert.strictEqual(certificate.checkPrivateKey(privateKey), true);
+}
+
+{
+  // EC key.
+  const bundle = fixtures.readKey(ecKeyAndCert.name);
+  const { privateKey, certificate } =
+    crypto.parsePKCS12(bundle, { passphrase: ecKeyAndCert.passphrase });
+  assert.strictEqual(privateKey.asymmetricKeyType, 'ec');
+  assert.strictEqual(certificate.checkPrivateKey(privateKey), true);
+}
+
+if (!fips3) {
+  // ec.pfx carries an empty passphrase, which the FIPS provider will not
+  // accept at all, so this case has no FIPS counterpart. Omitting the
+  // passphrase rather than passing it empty must behave identically: OpenSSL
+  // tries both PKCS#12 password encodings, so either variant opens the file.
+  const { privateKey } = crypto.parsePKCS12(fixtures.readKey('ec.pfx'));
+  assert.strictEqual(privateKey.asymmetricKeyType, 'ec');
+}
+
+{
+  // Wrong passphrase must be distinguishable from malformed input: OpenSSL
+  // reports it as a MAC verification failure of its own, and BoringSSL
+  // reports the same condition as an incorrect password. It is deliberately
+  // longer than the FIPS minimum password length so that this checks what it
+  // says it does under FIPS too.
+  const code = process.features.openssl_is_boringssl ?
+    'ERR_OSSL_INCORRECT_PASSWORD' : 'ERR_OSSL_PKCS12_MAC_VERIFY_FAILURE';
+  const bundle = fixtures.readKey(keyAndCert.name);
+  assert.throws(
+    () => crypto.parsePKCS12(bundle, { passphrase: 'wrongpassphrase' }),
+    { code });
+}
+
+{
+  // Not a PKCS#12 structure at all. The error must be the same on either
+  // crypto library: OpenSSL rejects this in d2i_PKCS12_bio(), while
+  // BoringSSL's only copies the bytes and leaves every structural check to
+  // PKCS12_parse(), so the binding has to recognize both.
+  assert.throws(
+    () => crypto.parsePKCS12(Buffer.from('not a bundle'), { passphrase: 'x' }),
+    { code: 'ERR_CRYPTO_OPERATION_FAILED', message: /not a valid PKCS#12/ });
+}
+
+{
+  // A bundle with no private key. PKCS12_parse() identifies the end-entity
+  // certificate by its association with the key, so with no key there is
+  // nothing to single out and everything arrives through
+  // `additionalCertificates` -- including the end-entity certificate itself.
+  const bundle = fixtures.readKey(certWithoutKey.name);
+  const { privateKey, certificate, additionalCertificates } =
+    crypto.parsePKCS12(bundle, { passphrase: certWithoutKey.passphrase });
+  assert.strictEqual(privateKey, null);
+  assert.strictEqual(certificate, null);
+  assert.strictEqual(additionalCertificates.length, 1);
+  assert.ok(additionalCertificates[0] instanceof crypto.X509Certificate);
+}
+
+if (hasOpenSSL3) {
+  // Legacy algorithms (RC2-40-CBC) throw a recognizable, actionable error
+  // rather than a bare OpenSSL string. Mirrors the behavior added for the
+  // TLS path in https://github.com/nodejs/node/pull/54485.
+  const bundle = fixtures.readKey('legacy.pfx');
+  assert.throws(
+    () => crypto.parsePKCS12(bundle, { passphrase: 'legacy' }),
+    { code: 'ERR_CRYPTO_UNSUPPORTED_OPERATION' });
+}
+
+{
+  // ArrayBuffer is a documented input type for both the bundle and the
+  // passphrase, and must behave the same as a view over the same bytes.
+  const buf = fixtures.readKey(keyAndCert.name);
+  const bundleAb =
+    buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  const passBuf = Buffer.from(keyAndCert.passphrase);
+  const passAb =
+    passBuf.buffer.slice(passBuf.byteOffset,
+                         passBuf.byteOffset + passBuf.byteLength);
+
+  const { privateKey, certificate } =
+    crypto.parsePKCS12(bundleAb, { passphrase: passAb });
+  assert.strictEqual(privateKey.type, 'private');
+  assert.ok(certificate instanceof crypto.X509Certificate);
+  assert.strictEqual(certificate.checkPrivateKey(privateKey), true);
+
+  // DataView too.
+  const { privateKey: key2 } = crypto.parsePKCS12(
+    new DataView(bundleAb), { passphrase: keyAndCert.passphrase });
+  assert.strictEqual(key2.type, 'private');
+}
+
+{
+  // A passphrase reaches OpenSSL as a NUL-terminated C string, and
+  // PKCS12_parse() takes no length alongside it. Without a check, everything
+  // from an embedded NUL onwards is dropped and the bundle opens under the
+  // truncated prefix -- a passphrase of '<pass>\0junk' would unlock a bundle
+  // protected by '<pass>'. Reject the passphrase instead, whatever form it
+  // arrives in.
+  const bundle = fixtures.readKey(keyAndCert.name);
+  const withNul = `${keyAndCert.passphrase}\u0000junk`;
+  const withNulBuf = Buffer.from(withNul);
+  const withNulAb = withNulBuf.buffer.slice(
+    withNulBuf.byteOffset, withNulBuf.byteOffset + withNulBuf.byteLength);
+
+  const passphrases = [
+    withNul,
+    withNulBuf,
+    withNulAb,
+    new DataView(withNulAb),
+    new Uint8Array(withNulAb),
+    // A trailing NUL is no more representable than an interior one.
+    `${keyAndCert.passphrase}\u0000`,
+    // And neither is a passphrase that is nothing but a NUL, which must not
+    // be mistaken for the empty passphrase.
+    '\u0000',
+    Buffer.from([0]),
+  ];
+
+  for (const passphrase of passphrases) {
+    assert.throws(
+      () => crypto.parsePKCS12(bundle, { passphrase }),
+      {
+        code: 'ERR_INVALID_ARG_VALUE',
+        message: /options\.passphrase.*must not contain null bytes/,
+      });
+  }
+
+  // The prefix on its own still opens the bundle, which is precisely why the
+  // truncation had to be rejected rather than tolerated.
+  assert.strictEqual(
+    crypto.parsePKCS12(bundle, { passphrase: keyAndCert.passphrase })
+      .privateKey.type,
+    'private');
+}
+
+{
+  // Argument validation.
+  assert.throws(() => crypto.parsePKCS12('a string'),
+                { code: 'ERR_INVALID_ARG_TYPE' });
+  assert.throws(() => crypto.parsePKCS12(Buffer.alloc(0), 'nope'),
+                { code: 'ERR_INVALID_ARG_TYPE' });
+}
diff --git a/typings/internalBinding/crypto.d.ts b/typings/internalBinding/crypto.d.ts
index e45a45ea7193..77bf1d799472 100644
--- a/typings/internalBinding/crypto.d.ts
+++ b/typings/internalBinding/crypto.d.ts
@@ -787,6 +787,12 @@ declare namespace InternalCryptoBinding {
       InternalX509Certificate: InternalX509CertificateConstructor,
     ];
 
+  type PKCS12ParseResult = [
+    privateKey: KeyObjectHandle | null,
+    certificate: X509CertificateHandle | null,
+    additionalCertificates: X509CertificateHandle[],
+  ];
+
   interface CipherInfo {
     name: string;
     nid: number;
@@ -1020,6 +1026,10 @@ export interface CryptoBinding {
     functionName?: InternalCryptoBinding.OptionalBufferSource,
     customization?: InternalCryptoBinding.OptionalBufferSource,
   ): string | InternalCryptoBinding.Buffer;
+  parsePKCS12(
+    bundle: InternalCryptoBinding.ByteSource,
+    passphrase?: InternalCryptoBinding.ByteSource,
+  ): InternalCryptoBinding.PKCS12ParseResult;
   parseX509(data: InternalCryptoBinding.ByteSource): InternalCryptoBinding.X509CertificateHandle;
   privateDecrypt: InternalCryptoBinding.PublicKeyCipher;
   privateEncrypt: InternalCryptoBinding.PublicKeyCipher;