fix: parse Common-Name-less certificates and report their real hostnames (#1531)

* fix: parse Common-Name-less certificates and report their real hostnames

A SAN-only leaf certificate (no subject Common Name) failed to parse, so a
TLS name-mismatch error reported the wrong hostname — the intermediate CA's
CN on Swift, an empty list on Kotlin. Make the subject and issuer
`common_name` `Option<String>`, add `SslCertificateInfo.presented_hostnames()`
(Common Name plus SANs, de-duplicated), and have both executors report the
leaf's presented hostnames instead of only its Common Name. The Swift
executor also parses the raw leaf directly rather than assuming it survived
the chain's `compactMap`.

Fixes #1508.

* test: breadcrumb the #1498 coupling on the SAN-only SSL spec

no-common-name.badssl.com's certificate is expired, so the failure is a bad-date one that currently surfaces as certificateNotValidForName. When #1498 remaps bad-date failures to genericSslError, this endpoint yields no presented hostnames and the assertion breaks; note to move it to a non-expired CN-less cert (local mock, #1208) then. Per @oguzkocer review.

* test: prefer expect over unwrap in the ssl presented-hostnames test

Matches the module's other tests and the repo convention. Per @oguzkocer review.

Author: jkmassel

CHANGELOG.md

@@ -27,6 +27,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Internal:** Corrected `GET /all-domains/` fixtures that claimed subtypes the endpoint never returns (`site_redirect`, `domain_mapping`).
 - Kotlin: The request executor now classifies cancelling an in-flight request via `CancellableCall.cancel()` as `CancellationError` instead of `GenericError`, matching Swift's handling of `URLError.cancelled`. Whole-call `callTimeout` expiry is classified as `HttpTimeoutError` rather than being mistaken for a cancellation, and a `CancellationException` surfacing synchronously inside the executor (e.g. from an upload callback) is classified as `CancellationError` rather than flattened into a `GenericError` ([#1492](https://github.com/Automattic/wordpress-rs/issues/1492)).
 - **Internal:** Run clippy's `--tests` lint pass with `--jobs 1` to cap the Rust lint step's peak memory at ~4.7 GiB (down from ~9 GiB) on CI.
+- **BREAKING:** The `commonName` on `SslCertificateInfo` and its `issuer` changed from `String` to `Option<String>` (`String?` on Swift and Kotlin). A certificate that omits its subject Common Name — the direction CAs are moving, toward SAN-only certificates — now parses instead of failing outright, so callers reading `commonName` must handle its absence. `SslCertificateInfo` gained `presentedHostnames()`, which returns the Common Name (when present) followed by the Subject Alternative Names, de-duplicated; prefer it over `commonName` when reporting which names a certificate covers.
 - **Internal:** Build the Android JNI libraries with `cargo-ndk` instead of the `rust-android-gradle` Gradle plugin.
 - **Internal:** Upgraded the Android/Kotlin build to Android Gradle Plugin `9.3.0` / Gradle `9.5.0` (Kotlin `2.3.21`, `compileSdk` 36), migrating `api/android` to the AGP 9 variant APIs and splitting the example app into a `com.android.kotlin.multiplatform.library` shared module and a standalone `com.android.application` module.
 - **Internal:** Bumped `syn` from `2.0` to `3.0`, updating the proc-macro crates for its breaking changes.
@@ -53,6 +54,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Internal:** Upgraded `reqwest` from `0.12` to `0.13` and removed the direct `hickory-resolver` dependency, moving `hickory-proto` to `0.26.1` to clear [RUSTSEC-2026-0119](https://rustsec.org/advisories/RUSTSEC-2026-0119.html) ([`GHSA-q2qq-hmj6-3wpp`](https://github.com/hickory-dns/hickory-dns/security/advisories/GHSA-q2qq-hmj6-3wpp)), a medium-severity O(n²) CPU-exhaustion DoS in DNS message encoding. Only the Rust `reqwest` request executor — used by the CLI, web tool, and integration tests — pulls in `hickory`; the shipping iOS/Android bindings don't compile `reqwest`, so they were never affected. `reqwest` 0.13 also drops the `native-tls`/`openssl` stack in favor of rustls-only, so the executor no longer links OpenSSL.
 - **Internal:** Bumped the transitive `rand` dependency to `0.9.3` and `0.8.6` to clear [RUSTSEC-2026-0097](https://rustsec.org/advisories/RUSTSEC-2026-0097.html) (`GHSA-cq8v-f236-94qc`), a low-severity unsoundness in `rand` 0.9.2 / 0.8.5. Lockfile-only; the affected code path (a custom `log` logger calling `rand::rng()` during reseed) is not exercised here.
 - **Internal:** Bumped `wp_rs_web`'s transitive `nanoid` dependency from `3.3.16` to `3.3.18` to clear [CVE-2026-67213](https://nvd.nist.gov/vuln/detail/CVE-2026-67213) ([GHSA-2v37-7h3g-55p8](https://github.com/advisories/GHSA-2v37-7h3g-55p8)), a denial-of-service via an infinite loop in `nanoid`'s `customAlphabet`/`customRandom` when called with a size of `0`. Lockfile-only; `nanoid` is pulled in only by Tailwind's build-time `postcss`, which never reaches the affected functions.
+- A SAN-only (Common-Name-less) leaf certificate is now parsed rather than dropped, so a TLS name-mismatch error reports the site certificate's own hostnames. Previously the whole parse failed on the missing Common Name: the Swift executor could then report an intermediate CA's Common Name (e.g. `R10`) as the presented hostname, and the Kotlin executor reported an empty list. Both executors now report the leaf certificate's Common Name plus its Subject Alternative Names, and the Swift executor no longer assumes the leaf survived parsing when picking the site certificate out of the chain.
 
 ## [0.6.0] - 2026-07-16
 

native/kotlin/api/kotlin/src/integrationTest/kotlin/ApiUrlDiscoveryTest.kt

@@ -283,6 +283,33 @@ class ApiUrlDiscoveryTest {
         assertContains(presentedHostnames, "vanilla.wpmt.co")
     }
 
+    // `wrong.host.badssl.com` serves a valid `*.badssl.com` certificate on a host
+    // it doesn't cover — a genuine name mismatch whose identities live in the SANs.
+    // The old code reported only the Common Name; assert the `badssl.com` SAN is
+    // now included too.
+    //
+    // The CN-less case (`no-common-name.badssl.com`) isn't exercised here: that
+    // certificate is expired, which OkHttp raises as an `SSLHandshakeException` —
+    // not the `SSLPeerUnverifiedException` that routes to certificate inspection —
+    // and the inspection's re-connect would fail on the expiry regardless. The
+    // Rust `parse_certificate` unit test covers the CN-less parse directly.
+    @Test
+    fun testNameMismatchReportsAllPresentedNames() = runTest {
+        val reason = loginClient.apiDiscovery("https://wrong.host.badssl.com")
+            .assertFailureFindApiRoot().getRequestExecutionErrorReason()
+        assertInstanceOf(RequestExecutionErrorReason.InvalidSslError::class.java, reason)
+
+        val sslError = (reason as RequestExecutionErrorReason.InvalidSslError).reason
+        assertInstanceOf(
+            InvalidSslErrorReason.CertificateNotValidForName::class.java,
+            sslError
+        )
+
+        val presentedHostnames =
+            (sslError as InvalidSslErrorReason.CertificateNotValidForName).presentedHostnames
+        assertContains(presentedHostnames, "badssl.com")
+    }
+
     @Test // Spec Example 17 (with exception)
     fun testInvalidHttpsWithExceptionWorks() = runTest {
         val httpClient = WpHttpClient.DefaultHttpClient(emptyList())

native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpRequestExecutor.kt

@@ -356,11 +356,15 @@ private fun RequestExecutionErrorReason.Companion.invalidSSLError(
 
         try {
             // Certificate is parsed by the Rust shared implementation.
+            // `serverCertificates` is leaf-first, so the site's certificate is the
+            // first element. Report every hostname it presents (Common Name plus
+            // SANs), not only its Common Name — a modern SAN-only certificate may
+            // omit the Common Name entirely.
             val certificates = newConnection.serverCertificates.map { parseCertificate(it.encoded) }
             RequestExecutionErrorReason.InvalidSslError(
                 reason = InvalidSslErrorReason.CertificateNotValidForName(
                     hostname = requestUrl.host,
-                    presentedHostnames = listOfNotNull(certificates.first()?.commonName())
+                    presentedHostnames = certificates.firstOrNull()?.presentedHostnames() ?: emptyList()
                 )
             )
         } finally {

native/swift/Sources/wordpress-api/SafeRequestExecutor.swift

@@ -197,10 +197,7 @@ public final class WpRequestExecutor: SafeRequestExecutor {
         for request: NetworkRequestContent
     ) -> Result<WpNetworkResponse, RequestExecutionError> {
 
-        guard
-            var peerCertificateChain = getPeerCertificateChain(error),
-            !peerCertificateChain.isEmpty
-        else {
+        guard let siteCertificate = leafCertificate(from: error) else {
             return .failure(
                 .RequestExecutionFailed(
                     statusCode: nil,
@@ -212,16 +209,14 @@ public final class WpRequestExecutor: SafeRequestExecutor {
             )
         }
 
-        let siteCertificate = peerCertificateChain.remove(at: 0)
-
         return .failure(
             .RequestExecutionFailed(
                 statusCode: nil,
                 redirects: executorDelegate.redirects(for: request.requestId()),
                 reason: RequestExecutionErrorReason.invalidSslError(
                     reason: .certificateNotValidForName(
                         hostname: URL(string: request.url())?.host ?? "unknown host",
-                        presentedHostnames: [siteCertificate.commonName()]
+                        presentedHostnames: siteCertificate.presentedHostnames()
                     )
                 ),
                 requestUrl: request.url(),
@@ -346,19 +341,28 @@ public final class WpRequestExecutor: SafeRequestExecutor {
         )
     }
 
-    private func getPeerCertificateChain(_ error: Error) -> [SslCertificateInfo]? {
+    /// Parse the site (leaf) certificate out of a failed TLS handshake.
+    ///
+    /// The peer certificate chain is leaf-first, so the site's certificate is
+    /// element 0 of the *raw* chain. We parse that element directly rather than
+    /// parsing the whole chain and taking element 0 of whatever survived: a leaf
+    /// we can't parse must degrade to `genericSslError`, never silently promote an
+    /// intermediate CA's certificate into the site's position and report the CA's
+    /// name (e.g. `R10`) as the presented hostname.
+    private func leafCertificate(from error: Error) -> SslCertificateInfo? {
         #if os(Linux) // Linux doesn't support `SecCertificate`
-        return []
+        return nil
         #else
         // The certificate chain the server presented during the failed TLS handshake.
         guard
             let trust = (error as? URLError)?.failureURLPeerTrust,
-            let certChainArray = SecTrustCopyCertificateChain(trust) as? [SecCertificate]
+            let certChainArray = SecTrustCopyCertificateChain(trust) as? [SecCertificate],
+            let leaf = certChainArray.first
         else {
             return nil
         }
 
-        return certChainArray.compactMap { parseCertificate(data: SecCertificateCopyData($0) as Data) }
+        return parseCertificate(data: SecCertificateCopyData(leaf) as Data)
         #endif
     }
 }
@@ -396,8 +400,12 @@ private final class RequestExecutorDelegate:
     }
 
     private func alternateNames(forCertificate cert: SslCertificateInfo) -> Set<String> {
-        lock.withLock {
-            additionalAlternativeNames[cert.commonName()] ?? []
+        // The allowlist is keyed on the certificate's Common Name, so a SAN-only
+        // certificate that omits its CN can't be matched here — there's no key to
+        // look it up under. Fall through to default handling in that case.
+        guard let commonName = cert.commonName() else { return [] }
+        return lock.withLock {
+            additionalAlternativeNames[commonName] ?? []
         }
     }
 

native/swift/Tests/wordpress-api/LoginTests.swift

@@ -317,7 +317,12 @@ class LoginTests {
                 }
 
                 #expect(hostname == "wordpress-1315525-4803651.cloudwaysapps.com")
-                #expect(presentedHostnames == ["vanilla.wpmt.co"])
+                // The presented names are the leaf certificate's Common Name and
+                // its SANs, not only the CN. Assert the certificate's identity is
+                // reported and the requested host is absent, without pinning the
+                // exact SAN list (it changes when the certificate is reissued).
+                #expect(presentedHostnames.contains("vanilla.wpmt.co"))
+                #expect(!presentedHostnames.contains("wordpress-1315525-4803651.cloudwaysapps.com"))
                 #endif
 
                 return true
@@ -341,6 +346,97 @@ class LoginTests {
         _ = try await self.client.details(ofSite: "https://vanilla1.wpmt.co")
     }
 
+    /// Regression for a SAN-only (Common-Name-less) leaf certificate — see #1508.
+    /// `no-common-name.badssl.com` serves a certificate whose subject carries no
+    /// Common Name and a single SAN. Before the fix the leaf failed to parse, the
+    /// `compactMap` dropped it, and element 0 of the survivors — the issuer CA —
+    /// was reported, so `presentedHostnames` was the CA's name (`COMODO ...`)
+    /// rather than the site's.
+    @Test("SAN-only certificate reports its SAN, not the issuer CA")
+    func testCommonNameLessCertificateReportsSan() async throws {
+        await #expect(
+            performing: {
+                _ = try await self.client.details(ofSite: "https://no-common-name.badssl.com")
+            },
+            throws: { error in
+                let reason = try #require(try self.getRequestExecutionErrorReason(from: error))
+
+                guard case .invalidSslError(let underlyingReason) = reason else {
+                    Issue.record("The transport error must be `invalidSslError`")
+                    return false
+                }
+
+                #if os(watchOS) // watchOS doesn't make the underlying certificate available to us
+                guard case .genericSslError = underlyingReason else {
+                    Issue.record("The underlying error must be `genericSslError`")
+                    return false
+                }
+                #else
+                // Breadcrumb (#1498): this endpoint's certificate is expired, so the failure is a
+                // bad-date one that the executor currently reports as `certificateNotValidForName`.
+                // Once #1498 remaps bad-date failures to `genericSslError`, this endpoint yields no
+                // presented hostnames and the assertion below breaks — move it to a non-expired
+                // Common-Name-less certificate then (e.g. a local mock, #1208). The parsing itself
+                // is already covered #1498-proof by the Rust `ssl` unit tests.
+                guard case .certificateNotValidForName(_, let presentedHostnames) = underlyingReason else {
+                    Issue.record("The underlying error must be `certificateNotValidForName`")
+                    return false
+                }
+
+                // The leaf carries no Common Name and exactly one SAN, so that SAN
+                // is the entire presented-hostname list. The bug reported the
+                // COMODO issuer CA's name here instead.
+                #expect(presentedHostnames == ["no-common-name.badssl.com"])
+                #endif
+
+                return true
+            }
+        )
+    }
+
+    /// Regression for the SANs half of the same payload — see #1507.
+    /// `wrong.host.badssl.com` serves a valid `*.badssl.com` certificate on a host
+    /// it doesn't cover, so it's a genuine name mismatch whose identities live in
+    /// the SANs. `presentedHostnames` must include them, not only the Common Name.
+    @Test("Name-mismatch certificate reports its SANs, not only its CN")
+    func testNameMismatchReportsAllPresentedNames() async throws {
+        await #expect(
+            performing: {
+                _ = try await self.client.details(ofSite: "https://wrong.host.badssl.com")
+            },
+            throws: { error in
+                let reason = try #require(try self.getRequestExecutionErrorReason(from: error))
+
+                guard case .invalidSslError(let underlyingReason) = reason else {
+                    Issue.record("The transport error must be `invalidSslError`")
+                    return false
+                }
+
+                #if os(watchOS) // watchOS doesn't make the underlying certificate available to us
+                guard case .genericSslError = underlyingReason else {
+                    Issue.record("The underlying error must be `genericSslError`")
+                    return false
+                }
+                #else
+                guard case .certificateNotValidForName(let hostname, let presentedHostnames) = underlyingReason else {
+                    Issue.record("The underlying error must be `certificateNotValidForName`")
+                    return false
+                }
+
+                #expect(hostname == "wrong.host.badssl.com")
+                // The certificate is for `*.badssl.com` with SANs `*.badssl.com`
+                // and `badssl.com`. The old code reported only the CN, so the
+                // `badssl.com` SAN is the discriminator that proves SANs are now
+                // included.
+                #expect(presentedHostnames.contains("badssl.com"))
+                #expect(presentedHostnames.contains("*.badssl.com"))
+                #endif
+
+                return true
+            }
+        )
+    }
+
     @Test("Cancel API discovery process")
     func testCancellation() async throws {
         let task = Task { [client] in