Supported Advisory: Remove compromised eMudhra root certificates from AppDynamics trust stores

Remove the affected eMudhra and AAA Certificate Services roots from the Java trust stores used by AppDynamics On-Premises components until a fixed release is installed.

Apply this workaround on each host that runs an AppDynamics On-Premises component. Include both nodes of a high-availability Controller pair and every Events Service, EUM, and Synthetic Server node. Use the component's bundled Java runtime for the workaround. For customer-managed Java runtimes, follow the JDK vendor's guidance.

Before removing roots, replace any certificates issued by eMudhra in your environment, such as certificates on LDAP, mail, or proxy servers. If a trust store is a symbolic link to an operating system trust store, follow your operating system vendor's instructions to update that store.

Oracle tracks the Java exposure as CVE-2026-91403. The affected roots are emSign ECC Root CA - G3 and AAA Certificate Services. Oracle and OpenJDK also recommend removing emSign Root CA - G1 and emSign Root CA - G2. Do not remove other emSign roots, such as emSign Root CA - C1 or emSign ECC Root CA - C3.

All currently released AppDynamics On-Premises versions are affected while their trust stores contain these roots.

The affected components are Controller, Enterprise Console, Events Service, EUM Server, Synthetic Server, and Virtual Appliance. To fix this issue, upgrade the Virtual Appliance to 26.7.2 version.

Potentially affected connections include Controller outbound TLS, EUM Server and Events Service connections to Controller, Enterprise Console outbound HTTPS, and agents that use a bundled or host JVM trust store containing the roots.

Browser access to the Controller and Enterprise Console user interfaces is not expected to be affected. AppDynamics server certificates issued by other CAs do not need replacement. Java Agent ZIP and RPM packages contain no CA certificates and use the host JVM trust store.

If a compromised key holder can intercept or redirect network traffic, the attacker might impersonate a server trusted by an AppDynamics component. Possible consequences include exposure of credentials, interception or modification of exchanged data, and acceptance of forged certificates for internal hostnames. Exploitation requires no AppDynamics credentials or user interaction and normally produces no visible symptoms.

Follow these steps in your Linux machine:
  1. Locate the trust stores for each AppDynamics installation.

    Run the following command for each installation directory:

    CODE
    find <appdynamics_install_dir> \( -path '*/lib/security/cacerts' -o -name 'cacerts.jks' \) -ls

    Typical locations include:

    • Controller: <controller_home>/appserver/jetty/etc/cacerts.jks and <controller_home>/jre/<version>/lib/security/cacerts

    • Enterprise Console: <EC_installationDir>/conf/keys/cacerts.jks and the bundled JRE's lib/security/cacerts

    • Events Service: <platform_home>/product/events-service/processor/jre/lib/security/cacerts

    • EUM Server: <eum_home>/jre/lib/security/cacerts

    • Synthetic Server: <Synthetic Server home>/lib/security/cacerts

  2. Check every trust store for the affected roots.

    Replace the placeholders with the bundled JRE and trust store paths. For Enterprise Console, use its configured trust store password. The default password for other stores is changeit. If you changed the password, use your configured password.

    Before you begin, confirm that keytool can read the trust store. Run this command to verify the keytool access:
    CODE
    <bundled_jre>/bin/keytool -list -keystore <trust_store> -storepass <password>
    This command will display a list of certificate entries. If it displays empty or an error, keytool did not list the trust store. Then, correct the path, password or keytool before the running the command again.
    CODE
    <bundled_jre>/bin/keytool -list -v -keystore <trust_store> -storepass changeit \
      | grep -E '^(Alias name|Owner):' \
      | grep -B1 -E 'CN=(emSign Root CA - G1|emSign Root CA - G2|emSign ECC Root CA - G3|AAA Certificate Services)'

    If you see the error, record each Alias name; alias names vary across Java distributions. If it prints nothing, none of the listed roots are present. The error Keystore was tampered with, or password was incorrect means the check did not run. You can ignore a warning recommending the -cacerts option.

  3. Back up each trust store that contains an affected root.
    CODE
    cp -p <trust_store> <trust_store>.bak-emudhra
  4. Delete each affected root alias reported by the check.
    CODE
    <bundled_jre>/bin/keytool -delete -keystore <trust_store> -storepass changeit -alias "<alias_name>"
    Important: Delete only emSign Root CA - G1, emSign Root CA - G2, emSign ECC Root CA - G3, and AAA Certificate Services. Do not delete other emSign root certificates.
  5. Run the trust store check again.

    The check should print no output.

  6. Restart the component.

    Use Enterprise Console or the component's standard stop and start procedure. Java reads trust stores at startup.

  7. Test the component's outbound connections.

    Test outbound connections, such as LDAP, SAML login, email notifications, HTTP Request Template actions, and Events Service and EUM connectivity. If a connection fails with `PKIX path building failed` after you remove AAA Certificate Services, contact AppDynamics Support.

    To roll back, stop the component, restore the backup trust store, and start the component.

Follow these steps in your Windows machine:

Open Windows PowerShell as Administrator. Run the following steps in the same PowerShell session. Repeat them for each trust store used by each installed component, including both nodes of an HA Controller pair. Replace the example paths with the paths on your host.

  1. Find the trust stores and bundled keytool.exe utilities under your installation directory:
    JSON
    $InstallDir = 'C:\AppDynamics'
    Get-ChildItem -LiteralPath $InstallDir -Recurse -File -ErrorAction Stop |
        Where-Object {
            $_.Name -eq 'cacerts.jks' -or
            ($_.Name -eq 'cacerts' -and $_.DirectoryName -match '\\lib\\security$')
        } |
        Select-Object FullName, LinkType, Target
    
    Get-ChildItem -LiteralPath $InstallDir -Recurse -File -Filter keytool.exe -ErrorAction Stop |
        Select-Object FullName
    Typical locations include:
    • Controller: <controller_home>\appserver\jetty\etc\cacerts.jks and the lib\security\cacerts file of its bundled JRE. The JRE can be shared outside <controller_home>; for example, the tested 26.7.2 installation uses C:\AppDynamics\Product\jre\17.0_19\.

    • Enterprise Console: <EC_home>\conf\cacerts.jks, <EC_home>\conf\keys\cacerts.jks where configured, and <EC_home>\jre\lib\security\cacerts. In the tested installation, <EC_home> is C:\AppDynamics\EnterpriseConsole\platform-admin.

    • Events Service: <platform_home>\product\events-service\processor\jre\lib\security\cacerts

    • EUM Server: <eum_home>\jre\lib\security\cacerts

    • Synthetic Server: <Synthetic Server home>\lib\security\cacerts

    Also check the component's configuration for a custom trust store, such as a javax.net.ssl.trustStore setting outside the installation directory. Work on the stores used by running components, rather than installer caches or old backups. If a discovered file is a symbolic link, identify and back up its target before making changes.

  2. Update both variables in the code block below using the paths found in step 1 before running it:
    • $Keytool: the full path to keytool.exe in the selected component's bundled JRE.
    • $TrustStore: the full path to the trust store you want to check and update.
    The paths shown below are examples. Repeat this step when moving to another trust store or component, updating both variables as needed. Enter the password for the selected trust store when prompted:
    JSON
    $Keytool = 'C:\AppDynamics\Product\jre\17.0_19\bin\keytool.exe'
    $TrustStore = 'C:\AppDynamics\Product\controller\appserver\jetty\etc\cacerts.jks'
    Get-Item -LiteralPath $Keytool, $TrustStore -ErrorAction Stop | Select-Object FullName
    
    $SecurePassword = Read-Host 'Trust store password' -AsSecureString
    $env:APPD_TRUSTSTORE_PASSWORD = ([PSCredential]::new('unused', $SecurePassword)).GetNetworkCredential().Password
    if ([string]::IsNullOrEmpty($env:APPD_TRUSTSTORE_PASSWORD)) {
        throw 'A trust store password is required.'
    }

    changeit is the default password for bundled JRE stores and the Controller trust store. Use your configured password if it differs; for Enterprise Console, use its configured trust store password. The commands below pass the password through a temporary process environment variable, so it does not appear in the keytool.exe command line.

  3. Define and run this check. It forces English keytool output, checks that the store was read successfully, and reports the actual aliases for the four root certificates:
    JAVASCRIPT
    function Get-AffectedRoots {
        if (-not (Test-Path -LiteralPath $Keytool -PathType Leaf)) { throw 'keytool.exe was not found.' }
        if (-not (Test-Path -LiteralPath $TrustStore -PathType Leaf)) { throw 'Trust store was not found.' }
        # Capture native stderr on Windows PowerShell 5.1, including keytool warnings.
        $ErrorActionPreference = 'Continue'
        $Listing = & $Keytool '-J-Duser.language=en' '-J-Duser.country=US' `
            -list -v -keystore $TrustStore -storepass:env APPD_TRUSTSTORE_PASSWORD 2>&1
        if ($LASTEXITCODE -ne 0) {
            throw ("Trust store check failed:`n" + ($Listing -join "`n"))
        }
    
        $Alias = $null
        $EntryType = $null
        foreach ($Line in $Listing) {
            $Text = [string]$Line
            if ($Text -match '^Alias name:\s*(.+)$') {
                $Alias = $Matches[1]
                $EntryType = $null
            } elseif ($Text -match '^Entry type:\s*(.+)$') {
                $EntryType = $Matches[1]
            } elseif ($Text -match '^Owner:.*\bCN=(emSign Root CA - G1|emSign Root CA - G2|emSign ECC Root CA - G3|AAA Certificate Services)(?:,|$)') {
                if ($EntryType -ne 'trustedCertEntry') {
                    throw "Review alias '$Alias' with Support: it is not a trusted certificate entry."
                }
                [PSCustomObject]@{ Alias = $Alias; Root = $Matches[1] }
            }
        }
    }
    
    $Affected = @(Get-AffectedRoots)
    $Affected | Format-Table -AutoSize

    If the table contains entries, review the root names and aliases before continuing. Alias names vary between Java distributions. If the check succeeds and prints nothing, none of the four roots are present in this store; skip steps 4 and 5 for that store. A password error or any other error means the check failed, not that the store is unaffected. A warning recommending -cacerts can be ignored.

  4. Back up the selected store, preserve its access permissions, and verify the backup before deleting any certificate:
    JSON
    $Backup = "$TrustStore.bak-emudhra-$(Get-Date -Format 'yyyyMMdd-HHmmss')"
    if (Test-Path -LiteralPath $Backup) { throw 'Backup already exists; choose a new backup path.' }
    Copy-Item -LiteralPath $TrustStore -Destination $Backup -ErrorAction Stop
    Get-Acl -LiteralPath $TrustStore -ErrorAction Stop |
        Set-Acl -LiteralPath $Backup -ErrorAction Stop
    $OriginalHash = (Get-FileHash -LiteralPath $TrustStore -Algorithm SHA256 -ErrorAction Stop).Hash
    if ((Get-FileHash -LiteralPath $Backup -Algorithm SHA256 -ErrorAction Stop).Hash -ne $OriginalHash) {
        throw 'Backup verification failed; do not delete any certificates.'
    }
    Write-Output "Verified backup: $Backup"
  5. Remove only the aliases returned by step 3. This loop stops if a deletion fails:
    JSON
    foreach ($Certificate in $Affected) {
        & $Keytool '-J-Duser.language=en' '-J-Duser.country=US' `
            -delete -keystore $TrustStore -storepass:env APPD_TRUSTSTORE_PASSWORD `
            -alias $Certificate.Alias
        if ($LASTEXITCODE -ne 0) {
            throw "Deletion failed for alias '$($Certificate.Alias)'; check the store before proceeding."
        }
    }

    Do not remove other emSign roots, such as emSign Root CA - C1 or emSign ECC Root CA - C3. Do not delete the whole trust store or a server keystore.jks file.

  6. Check the modified store again. Success requires a completed check with zero remaining affected roots:
    JSON
    $Remaining = @(Get-AffectedRoots)
    if ($Remaining.Count -ne 0) {
        $Remaining | Format-Table -AutoSize
        throw 'Affected root certificates remain in this trust store.'
    }
    Write-Output 'Verified: none of the four affected roots remain.'
  7. Repeat the check and, where needed, backup and removal for each remaining trust store. Restart each affected component through Enterprise Console or its standard Windows stop and start procedure so the JVM reloads the trust stores. Test LDAP, SAML login, email notifications, HTTP Request Template actions, and Events Service and EUM connectivity as applicable. If a connection fails with PKIX path building failed after removing AAA Certificate Services, contact AppDynamics Support.
  8. Clear the temporary password when finished, including if an earlier step failed:
    CODE
    Remove-Item Env:\APPD_TRUSTSTORE_PASSWORD -ErrorAction SilentlyContinue
    Remove-Variable SecurePassword -ErrorAction SilentlyContinue
    Windows rollback:
    Stop the component. In the same session, $Backup identifies the backup for the currently selected store. In a new session, set $TrustStore and $Backup to the exact original and backup paths first. Restore that store and its permissions, verify the restored contents, then start the component:
    PYTHON
    Copy-Item -LiteralPath $Backup -Destination $TrustStore -Force -ErrorAction Stop
    Get-Acl -LiteralPath $Backup -ErrorAction Stop |
        Set-Acl -LiteralPath $TrustStore -ErrorAction Stop
    if ((Get-FileHash -LiteralPath $TrustStore -Algorithm SHA256 -ErrorAction Stop).Hash -ne
        (Get-FileHash -LiteralPath $Backup -Algorithm SHA256 -ErrorAction Stop).Hash) {
        throw 'Rollback verification failed; do not start the component.'
    }
    Write-Output 'Verified: trust store restored from backup.'

    Restoring the backup also restores trust in the affected roots. Use rollback only to recover from a problem.

Fixed releases are planned for version 26.10 for Enterprise Console (including Controller and Events Service), Virtual Appliance, EUM Server, and Synthetic Server. For customers on 26.7.x, planned hotfixes are Enterprise Console 26.7.3 (including Controller and Events Service) and Virtual Appliance 26.7.2.

Until installing a fixed release or hotfix, apply this workaround. After upgrading, patching, or reinstalling, check every trust store again because these operations can restore the affected roots.

Do not rely on a Java update alone. Oracle and OpenJDK guidance recommends removing the affected roots even after the October 2026 Java updates. If you previously applied the blocked.certs workaround, keep it and also remove the roots.

For additional information, see Oracle Security Alert for CVE-2026-91403, OpenJDK guidance on the eMudhra CA compromise, Azul workaround, eMudhra's incident statement, AppDynamics Controller SSL and certificates, and Enterprise Console HTTPS support.