• Apple Closes macOS Security Gap That Allowed Compromised eMudhra Certificates to Remain Trusted

    From mummycullen@mummycullen@gmail-dot-com.no-spam.invalid (MummyChunk) to comp.sys.mac.advocacy on Tue Nov 10 12:04:34 2026
    From Newsgroup: comp.sys.mac.advocacy

    Apple Closes macOS Security Gap That Allowed Compromised eMudhra Certificates to Remain Trusted

    Apple has released security updates for three generations of macOS to close a certificate-validation weakness that could have allowed certain command-line utilities to accept fraudulent HTTPS certificates associated with a major cryptographic security incident. The updates, released on November 9, 2026, extend protections that Apple introduced in October after researchers discovered that eight intermediate certificate authorities operated by Indian digital trust provider eMudhra had been created using dangerously weak private keys.

    The corrections are included in macOS 27.2.1, macOS 26.7.3 and macOS Sequoia 15.8.3. They address an inconsistency between Apple's standard certificate-validation system and command-line software that relies on a separate collection of trusted certificate authorities. Although Safari, Mail and applications using Apple's security frameworks had already been protected through automatic updates, utilities such as curl, git and certain programming-language tools could continue accepting the compromised certificates under particular circumstances.

    The underlying incident was unusually serious because the affected cryptographic keys were not merely suspected of being stolen. They were so weak that researchers could reconstruct them directly from publicly available certificate information with negligible computational effort. Someone possessing those keys could potentially create certificates that appeared to have been issued by a trusted authority, enabling impersonation of websites and other attacks against software that still accepted the affected certificate chains.

    Apple's latest updates remove the relevant trust paths from the certificate bundle used by affected command-line utilities, eliminating the need for administrators to perform a previously recommended manual workaround.

    The incident has also triggered broader action across the internet security industry. Mozilla, Microsoft, Google and other organizations have withdrawn trust from affected certificates, while eMudhra has announced plans to exit the publicly trusted TLS certificate business. A separate deadline on November 30 could affect organizations that still depend on certificates issued under eMudhra's older G1 hierarchy.

    Although the immediate macOS vulnerability has now been addressed, the events surrounding eMudhra expose a larger problem: different applications on the same computer can make different decisions about whether a supposedly secure internet connection should be trusted.

    Why Some macOS Command-Line Tools Remained Vulnerable

    The security gap originated in the different ways that software on macOS verifies digital certificates.

    When an application establishes an HTTPS connection, it must determine whether the server's certificate is authentic. This normally involves checking a chain of digital signatures connecting the website's certificate to a certificate authority trusted by the operating system or application.

    Apple provides security and networking frameworks that handle much of this process for software developed around its platform technologies.

    Safari, Mail and many third-party Mac applications use these frameworks, which incorporate Apple's certificate trust policies and automatically distributed restrictions.

    When Apple learned of the eMudhra incident, it was able to block the compromised certificates through updates to its certificate configuration data. Those changes were delivered independently of a full operating system release, allowing affected devices to receive protection without installing a new version of macOS.

    However, not every application relies on the same certificate-validation mechanism.

    Many developers and system administrators use Unix-style command-line tools that maintain compatibility with conventional OpenSSL and other cross-platform software environments.

    Some command-line utilities included with macOS or Apple's Xcode Command Line Tools consult a certificate bundle stored at /etc/ssl/cert.pem.

    This file contains certificates that the tools can use as trust anchors when verifying remote connections.

    Apple's documentation identifies curl, git, python3, ruby, perl and openssl among the tools that can rely on this file for certificate verification.

    The problem was that these tools did not necessarily consult Apple's separate certificate blocklist or check whether the affected intermediate certificates had been revoked.

    If a compromised intermediate certificate could form a valid chain to a root certificate still present in the bundle, the connection might be accepted even though Apple's standard networking frameworks would reject it.

    This created an inconsistent security situation.

    A user opening a maliciously impersonated website in Safari could be protected by Apple's certificate restrictions, while a command-line program contacting the same destination might not enforce the same decision.

    For developers, that inconsistency is particularly relevant because command-line programs frequently access remote systems automatically.

    Git can retrieve source code from repositories, curl can download data or software packages, and programming-language tools may communicate with external services during installation, development and deployment.

    A fraudulent certificate accepted during one of these operations could undermine the authentication normally provided by HTTPS.

    The vulnerability did not mean every command-line connection was automatically compromised. Exploitation would require additional circumstances, including an attacker-controlled certificate and the ability to direct or intercept a relevant connection.

    Nevertheless, retaining trust in a known-compromised certificate authority created an unnecessary security risk.

    The eMudhra Incident Began With Eight Exceptionally Weak Private Keys

    The crisis began on October 17, when an independent researcher alerted major browser vendors that private keys belonging to eight eMudhra intermediate certificate authorities could be recovered from publicly available certificates.

    The discovery involved six intermediate authorities used for TLS certificates and two associated with code signing.

    Intermediate certificate authorities occupy an important position within the public key infrastructure that secures much of the modern internet.

    A root certificate authority establishes a widely trusted foundation. It can authorize intermediate certificate authorities, which in turn issue certificates used by websites and other services.

    This arrangement allows certificate providers to manage large numbers of certificates without repeatedly exposing the most sensitive root signing keys.

    However, the intermediate authority's private key must remain secure. Anyone who obtains it may be able to create additional certificates that appear to have been legitimately issued by that authority.

    In eMudhra's case, the problem was a catastrophic failure of key generation.

    The affected authorities used the ECDSA digital signature algorithm with the P-384 elliptic curve, a well-established cryptographic system that is considered secure when implemented correctly.

    A properly generated P-384 private key should be selected unpredictably from an enormous range of possible values.

    The eight affected keys were instead represented by the integers 4, 56, 66, 115, 155, 156, 230 and 237.

    Every one of those values is smaller than 256.

    That meant researchers could recover the private keys simply by testing a tiny collection of possible values against the publicly available corresponding keys.

    No sophisticated attack on elliptic curve cryptography was necessary, and there was no need to compromise eMudhra's servers or physically access its cryptographic hardware.

    The mathematical algorithms themselves had not been broken. The failure occurred because the private keys supplied to those algorithms lacked the randomness required for security.

    eMudhra subsequently acknowledged that a scripting error during a key-generation ceremony on April 30, 2025, had produced the weak keys.

    The company said the ceremony used FIPS 140-2 Level 3-certified hardware security modules, specialized devices intended to protect sensitive cryptographic operations.

    The use of certified security hardware did not prevent the mistake because the surrounding process generated and selected incorrect keys.

    According to eMudhra, seven of the eight affected intermediate authorities were never deployed in production. The remaining authority had been deployed but had not issued any publicly trusted end-entity certificates.

    The company also stated that its infrastructure and customer data had not been breached.

    Those statements are significant because the incident is sometimes described simply as a theft of private keys. The confirmed problem was that the keys were recoverable due to their extremely weak values.

    This distinction changes the nature of the risk.

    A conventional stolen-key incident might involve one attacker or a limited group possessing the secret. In this case, anybody with the public certificates and knowledge of the weakness could independently reconstruct the same signing keys.

    The security failure was therefore potentially available to an unlimited number of attackers.

    How Fraudulent Certificates Could Threaten Encrypted Connections

    HTTPS relies on two related but distinct protections: encryption and authentication.

    Encryption protects information from being read or modified by unauthorized parties during transmission. Authentication allows a client to verify that it is communicating with the intended website or service.

    Digital certificates play a central role in authentication.

    When a computer connects to a website, the server presents a certificate identifying the domain. The client examines the certificate, checks its validity and determines whether the associated signatures lead to a trusted certificate authority.

    If the chain is accepted and the other required checks succeed, the client can proceed with an encrypted connection.

    The compromised eMudhra keys threatened this process because they could be used to sign certificates that appeared to originate from legitimate certificate authorities.

    An attacker could potentially create a certificate claiming to represent a domain the attacker did not control.

    If the victim's software accepted the fraudulent certificate and the attacker could intercept or redirect the connection, the attacker might be able to impersonate the intended service.

    That could expose credentials, confidential data or information exchanged through the connection.

    The attacker might also alter returned content, creating risks involving downloaded files, software updates or responses from application programming interfaces.

    The ability to generate a fraudulent certificate does not, by itself, provide control over another company's network or website.

    An attacker would generally need a way to place the fraudulent certificate in the victim's connection path, such as through a compromised network, malicious proxy, manipulated routing arrangement or another form of traffic interception.

    Modern browsers also use additional protections, including certificate transparency requirements and mechanisms for distributing certificate revocations.

    These safeguards can make certain types of fraudulent certificate attacks more difficult.

    However, their enforcement differs among applications, which is precisely why the macOS command-line issue mattered.

    Software that checks a certificate chain against a trusted root without applying the same blocklists or transparency policies as a modern browser may be more willing to accept a forged certificate.

    The eMudhra incident therefore exposed a weakness not only in the original certificate authority, but also in the consistency of the software ecosystem responsible for interpreting trust.

    Apple's Response Unfolded in Three Stages

    Apple began responding before the November macOS updates became available.

    On October 19, the company started automatically blocking twelve certificates associated with the six compromised TLS intermediate authorities.

    The number twelve reflects the existence of two certificate paths for each of the six TLS authorities.

    One path connected the intermediate certificates to eMudhra's own hierarchy, ultimately leading to emSign ECC Root CA - G3.

    The other used cross-signatures from Sectigo, allowing the certificates to chain through AAA Certificate Services.

    These alternative paths are important because a certificate can sometimes be accepted through more than one trusted hierarchy.

    Blocking only one path may not prevent software from establishing trust through another.

    On October 23, Apple introduced an additional block against the emSign ECC Root CA - G3 certificate.

    These restrictions reached Apple devices through automatic certificate configuration updates.

    They protected Safari, Mail and software using Apple's standard security and networking frameworks without requiring users to install a new operating system release.

    The remaining problem concerned command-line utilities using /etc/ssl/cert.pem.

    Apple initially provided instructions for administrators to remove affected root certificates manually from that file.

    The workaround could help prevent acceptance of fraudulent certificates, but it required administrative access and careful modification of a security-sensitive system resource.

    On November 9, Apple delivered the permanent correction through macOS 27.2.1, macOS 26.7.3 and macOS Sequoia 15.8.3.

    The updates extend the blocking of the twelve affected TLS certificates to the relevant command-line tools.

    They also remove five root certificates from the certificate bundle.

    Two are associated with the compromised certificates' available trust paths: emSign ECC Root CA - G3 and AAA Certificate Services.

    Three additional eMudhra roots are removed as part of the broader trust changes: emSign Root CA - G1, emSign Root CA - C1 and emSign ECC Root CA - C3.

    The result is that affected command-line utilities no longer retain the original trust paths that created the security gap.

    Importantly, Apple's correction is not limited to the newest macOS generation.

    By distributing corresponding updates for macOS 26 and macOS Sequoia 15, the company has provided protection for users and organizations that have not moved to macOS 27.

    Apple confirms that administrators who install the appropriate update no longer need to maintain the earlier manual certificate-removal workaround.

    Why Cross-Signed Certificates Made the Problem More Complicated

    The involvement of Sectigo's AAA Certificate Services certificate illustrates a subtle but important aspect of internet security.

    Certificate authorities do not always operate through a single linear chain of trust.

    Cross-signing allows one certificate authority to sign a certificate associated with another hierarchy, helping establish compatibility with systems that recognize different sets of trusted roots.

    This arrangement can be useful when introducing a new certificate authority or supporting older devices.

    However, it also creates additional routes through which a certificate may be accepted.

    In the eMudhra incident, each affected TLS intermediate authority had a certificate under eMudhra's own hierarchy and another cross-signed through Sectigo.

    Removing only the eMudhra root from a certificate bundle would not necessarily prevent a vulnerable application from trusting the cross-signed version through AAA Certificate Services.

    That is why Apple's original manual workaround included an optional step to remove the AAA Certificate Services root as well.

    The November updates automate the relevant changes, removing both trust paths from the affected command-line certificate bundle.

    There is a compatibility trade-off.

    AAA Certificate Services has been used beyond the compromised eMudhra intermediates. Removing a broadly trusted root certificate can therefore affect legitimate services whose certificate chains depend on it.

    Apple acknowledges that tools relying exclusively on /etc/ssl/cert.pem may no longer be able to verify some websites whose certificates connect to the removed roots through otherwise unaffected intermediates.

    Administrators may consequently encounter certificate-validation errors after updating certain development environments or automated systems.

    Those failures should not automatically be treated as defects in the macOS update.

    They may indicate that the remote service depends on a certificate hierarchy no longer trusted through the relevant bundle.

    The safer response is to identify the affected certificate chain and arrange a replacement or otherwise appropriate configuration, rather than simply restoring a removed certificate authority to the trusted list.

    Restoring trust without examining the implications could reintroduce the security weakness the update was designed to eliminate.

    Mozilla, Microsoft and Cloudflare Responded to the Wider Threat

    Apple's action was part of a coordinated response across the browser and internet infrastructure industries.

    Mozilla received the original disclosure on October 17 at 20:06 UTC.

    Its security engineers responded by adding the compromised certificates to OneCRL, Firefox's centrally distributed certificate blocklist.

    Mozilla reports that distribution was completed for standard Firefox configurations by 22:59 UTC, less than three hours after the initial notification.

    The company subsequently released browser updates for configurations that might not have received the automatic blocklist and modified the Mozilla Network Security Services trust store to remove the root certificate associated with the affected intermediates.

    Microsoft followed a similar approach.

    On October 20, it updated the Windows Disallowed Certificate Trust List and distributed additional protections for Microsoft Edge and WebView2.

    On October 26 and 27, it introduced broader root-trust changes affecting Windows and Edge.

    These responses illustrate why certificate security incidents require action from multiple organizations. A certificate authority may revoke a compromised certificate, but applications and operating systems must actually recognize and enforce that revocation.

    Cloudflare's investigation provides additional evidence about what happened after the weak keys became publicly known.

    The company implemented protections across its infrastructure and introduced logging to detect certificates signed using the compromised keys.

    In a report published on October 30, Cloudflare said it had observed approximately 22,000 attempted TLS handshakes involving those keys.

    Most involved test sites or servers that appeared to have configured certificates for themselves.

    Around 160 connections were more unusual because the presented certificates identified domains unrelated to the destination being requested.

    Some of the names were associated with consumer internet-connected devices.

    Cloudflare concluded that these certificates appeared to be configured on the servers themselves rather than being used to intercept its connections.

    Nevertheless, the observations demonstrated that forged certificates had been created using the compromised keys shortly after the weakness became public.

    Cloudflare reported no evidence that the keys had been used to intercept its own connections, although it emphasized that this could not exclude more targeted attacks elsewhere.

    This distinction matters.

    The ability to forge certificates was not merely theoretical, but the available observations do not establish a widespread campaign successfully intercepting users' encrypted traffic.

    The incident was serious enough to justify urgent defensive measures without requiring evidence that every possible form of exploitation had already occurred.

    A Separate November 30 Deadline Could Affect Websites and Institutions

    The November macOS updates resolve the specific command-line trust problem, but they do not mark the end of the wider eMudhra transition.

    Following the incident, eMudhra announced that it would discontinue issuing publicly trusted TLS certificates.

    The company is arranging replacements for customers whose certificates depend on affected or soon-to-be-distrusted hierarchies.

    In a November 5 update, eMudhra outlined additional changes involving its older emSign G1 certificate hierarchy.

    Google Chrome and Mozilla Firefox are adopting a November 16 cutoff for new G1 certificates, using certificate transparency timestamps to determine whether later issuance should be trusted.

    According to eMudhra, existing certificates issued before that cutoff are not affected by those particular Chrome and Firefox restrictions.

    Apple has adopted a different approach.

    eMudhra states that Apple plans to remove trust in the G1 hierarchy on November 30, 2026, regardless of when individual certificates were issued.

    That creates a more immediate replacement requirement for organizations whose websites or applications still depend on that hierarchy and must remain accessible to Apple users.

    The two events should not be confused.

    The November 9 macOS security updates address compromised G3 intermediate certificates and related root-trust vulnerabilities in command-line software.

    The November 30 deadline concerns Apple's planned withdrawal of trust from the older G1 hierarchy as part of the broader response to eMudhra's certificate authority operations.

    This distinction is particularly important for website administrators.

    Installing macOS 27.2.1 on a user's computer does not replace a server certificate that is about to lose trust under Apple's separate policy.

    Website operators must examine the certificates used by their services and migrate affected systems to another trusted certificate authority before the relevant deadline.

    The consequences could extend beyond ordinary commercial websites.

    eMudhra has identified a substantial customer ecosystem in the United States that uses certificates associated with its affected hierarchies.

    Its October 28 update referred to approximately 30,800 certificates associated with the affected G3 environment, whose customers had been provided an alternative issuance path through the G1 hierarchy during the transition.

    However, the forthcoming withdrawal of G1 trust requires those customers to complete another migration to alternative certificate providers.

    The issue has already prompted warnings within the American higher education sector.

    Cornell University published an advisory on November 9 explaining that its certificate services, provided through InCommon, were affected by the transition.

    The university warned administrators that certificates not replaced before the applicable deadlines could cause websites and applications to become unavailable or generate security warnings.

    Its technology teams were working with InCommon to move certificate issuance to SSL.com.

    For affected organizations, the work involves more than purchasing new certificates.

    Administrators may need to inventory existing certificates, identify which intermediate and root authorities they depend on, coordinate replacements across multiple servers and verify that automated renewal systems use an appropriate provider.

    Services operating behind load balancers, proxies or content delivery networks may have multiple locations where certificates need attention.

    Incomplete migrations could produce failures that appear only for particular operating systems or browsers, depending on their different trust policies.

    The November 30 deadline therefore represents an operational issue for some institutions even though the original compromised keys have already been revoked.

    What Mac Users and System Administrators Should Do

    For ordinary Mac users, the recommended action is straightforward: install the latest security update available for the version of macOS they are running.

    The relevant patched releases are macOS 27.2.1, macOS 26.7.3 and macOS Sequoia 15.8.3.

    Updates can be checked through System Settings and the Software Update interface.

    Apple's earlier automatic certificate restrictions already protect Safari, Mail and applications using its standard security frameworks. The November updates address the additional exposure involving affected command-line software.

    Users who do not work with Terminal or development tools generally do not need to modify certificate files manually.

    For developers and system administrators, installing the update is preferable to editing the trust bundle because it provides Apple's supported correction and avoids the risk of introducing errors through manual changes.

    Administrators who cannot install the update immediately can still consult Apple's official instructions for removing the affected root certificates from /etc/ssl/cert.pem.

    Those instructions include backing up the file, removing the relevant certificate entries and verifying the result.

    The process requires administrator privileges and can affect every tool that relies on the modified certificate bundle.

    Consequently, it should not be performed casually or by copying commands from an unverified source.

    Apple also advises that earlier backups of the certificate bundle should not be restored after the corrected macOS update has been installed, since doing so could reintroduce certificates removed for security reasons.

    A separate consideration concerns applications that maintain their own trusted certificate stores.

    Some programming-language environments, containerized applications, cross-platform networking libraries and third-party tools use certificate bundles that are independent of both Apple's security frameworks and the macOS /etc/ssl/cert.pem file.

    Apple explicitly warns that its update does not necessarily change the trust configuration of those applications.

    Administrators therefore need to identify whether critical software uses a separate certificate authority store and, where necessary, obtain updated trust information from the relevant developer or vendor.

    This is particularly important for automated systems that download software, access source repositories or transmit sensitive information through HTTPS connections.

    Organizations should also avoid disabling certificate verification as a workaround for unexpected connection errors.

    Options that instruct tools to ignore certificate errors may restore connectivity, but they undermine the authentication provided by TLS and can expose connections to precisely the type of impersonation risk involved in this incident.

    The appropriate response is to investigate the failing certificate chain and correct the underlying trust or server configuration.

    Administrators responsible for public websites should separately review whether their certificates depend on eMudhra's G1 hierarchy and whether replacement is necessary before Apple's November 30 deadline.

    The Incident Exposes a Weakness in the Internet's Chain of Trust

    The eMudhra compromise is remarkable because its root cause was comparatively simple.

    The affected certificate authorities used a respected cryptographic algorithm and keys supposedly created through a controlled procedure involving certified hardware security modules.

    Yet a scripting error produced private keys so predictable that they could be recovered almost instantly from information available to anyone.

    The mistake remained undetected long enough for the affected hierarchy to pass independent audit cycles and become part of widely trusted internet security infrastructure.

    That sequence raises difficult questions about key-generation procedures, verification requirements and the ability of audits to detect failures that occur during the creation of critical cryptographic material.

    It also demonstrates the limitations of relying on any single defensive mechanism.

    eMudhra revoked the affected intermediate certificates, but some software did not enforce those revocations.

    Apple distributed automatic trust restrictions, but certain macOS command-line tools relied on a separate certificate bundle.

    Removing the compromised authorities addressed the immediate threat, but cross-signatures created alternative chains that required additional attention.

    Finally, the broader withdrawal of certificate trust introduced operational consequences for legitimate organizations that had to replace certificates despite not being responsible for the original security failure.

    Each stage reflects a different responsibility within the public key infrastructure.

    Certificate authorities must generate and protect trustworthy keys. Browser and operating system vendors must respond quickly when that trust is undermined. Application developers must ensure that their software respects relevant certificate restrictions. Website operators must maintain valid certificate chains as trust policies change.

    Apple's November 9 macOS updates close a specific and potentially dangerous inconsistency in that system.

    They bring affected command-line tools into alignment with the restrictions that had already protected mainstream Apple applications since October, reducing the opportunity for fraudulent eMudhra certificates to be accepted.

    However, the broader incident remains significant because it shows that the security of an encrypted connection depends on more than the strength of the encryption algorithm.

    It also depends on how keys are generated, which authorities are trusted, whether revocations are enforced and whether every application follows a consistent validation policy.

    For Mac users, the immediate solution is to update their systems. For administrators, the remaining tasks include checking independently maintained trust stores and replacing certificates affected by the upcoming hierarchy changes.

    For the technology industry, the lasting lesson is more fundamental: a cryptographic system can be mathematically sound and still fail disastrously when the procedures surrounding its most sensitive keys are not independently verified.
    --
    Via JLA Forums web gateway for comp.sys.mac.advocacy
    --- Synchronet 3.22a-Linux NewsLink 1.2