CVE-2026-63077: JetBrains TeamCity — Deserialization RCE via Agent Protocol

Background

JetBrains TeamCity is a widely-deployed CI/CD platform used by software development organisations worldwide to automate build, test, and deployment pipelines. TeamCity servers hold some of the most sensitive credentials in an enterprise environment: VCS credentials, cloud API keys, deployment tokens, and code signing certificates. Access to a TeamCity server frequently provides a direct path to production environments and downstream software supply chains.

TeamCity has been one of the most consistently targeted CI/CD products over the past three years. CVE-2023-42793 was exploited by APT29 (Cozy Bear) and DIAMOND SLEET (Lazarus Group) within days of disclosure, producing significant supply chain compromise incidents. CVE-2024-27198 was weaponised at scale within hours. Both vulnerabilities share the same pattern as CVE-2026-63077: pre-authentication access, remote code execution, and immediate exploitation by nation-state threat actors.

CISA added CVE-2026-63077 to the Known Exploited Vulnerabilities catalog on August 5, 2026, with a three-day remediation deadline of August 8. That is the shortest deadline interval CISA applies. Organisations running internet-exposed TeamCity instances should treat this as requiring emergency patching.

Technical Mechanism

CWE-502: Deserialization of Untrusted Data

TeamCity’s distributed build architecture relies on a communication channel between the TeamCity server and its build agents. Build agents — external processes running on separate machines or in containers — periodically poll the server via HTTP to receive build task assignments, upload results, and report status.

The vulnerability exists in the server-side handler for the build agent polling endpoint. This endpoint deserializes Java objects received from polling agents to reconstruct session state and build data structures. Critically, the server deserializes the object payload from the raw HTTP request body before performing any agent authentication or credential validation.

Exploitation flow:

1. Attacker sends an HTTP POST request to the TeamCity agent communication endpoint (default port TCP 8111, same as the web interface)
2. The server-side handler accepts the request and begins deserialization of the body without checking credentials
3. The attacker’s payload is a serialized Java object constructed to trigger a gadget chain during deserialization
4. The gadget chain executes arbitrary OS commands in the context of the TeamCity server process

Gadget chain exploitation: Java deserialization vulnerabilities are exploitable when the target JVM’s classpath contains deserialization gadget chain libraries that can chain method calls during object construction. TeamCity’s bundled runtime includes Apache Commons Collections, Spring Framework, and Groovy runtime — all of which contain known gadget chains. Ysoserial-compatible payloads are effective against this endpoint. The binary Java serialization magic bytes (AC ED 00 05) are detectable in network traffic.

The agent polling endpoint cannot be isolated from the TeamCity web interface without significant reconfiguration — both are served on the same port. Internet-exposed TeamCity instances expose this endpoint to the public internet by default. Shodan and Censys enumeration of TCP 8111 consistently returns tens of thousands of internet-facing instances.

Real-World Exploitation Evidence

CISA’s addition of CVE-2026-63077 to the KEV catalog confirms active exploitation, with the three-day deadline indicating assessed exploitation risk at or above the level seen with prior critical TeamCity vulnerabilities.

APT29 (Cozy Bear / MIDNIGHT BLIZZARD) exploited CVE-2023-42793 within 72 hours of disclosure, targeting software development companies, healthcare, pharmaceutical, and energy sector organisations in the US and Europe. TeamCity compromise enables source code theft and build artifact manipulation for downstream supply chain attacks. APT29 has demonstrated persistent interest in CI/CD infrastructure and is expected to operationalise this capability rapidly.

DIAMOND SLEET / Lazarus Group also exploited CVE-2023-42793 for cryptocurrency theft and espionage. TeamCity’s access to deployment pipelines and cloud credentials provides direct financial and intelligence value.

Ransomware operators used CVE-2024-27198 as a lateral movement vector. A TeamCity server with network access to cloud environments, Kubernetes clusters, or deployment targets is a high-value pivot point. Multiple ransomware-as-a-service affiliates are expected to develop and deploy tooling rapidly after PoC publication.

Initial access brokers will likely develop and sell access to compromised TeamCity instances within days. IABs have consistently treated CI/CD servers as high-value commodities given the credential density.

Impact Assessment

Full exploitation of CVE-2026-63077 yields OS command execution in the context of the TeamCity server process, which typically runs with elevated privileges on the host system. The practical impact extends well beyond the server itself:

• Secrets exfiltration: TeamCity stores VCS credentials, cloud provider API keys, deployment tokens, and code signing certificates. A compromised server provides immediate access to all stored secrets.
• Build pipeline manipulation: An attacker can modify build configurations and inject malicious code into build artifacts, creating downstream supply chain compromise in any software distributed through the affected pipeline.
• Lateral movement: Network access from the TeamCity server host typically extends to production environments, cloud accounts, and development infrastructure.
• Persistent access: Build agent credentials and server API tokens can provide durable access even after the initial vulnerability is patched.

Sectors at elevated risk include software development, financial services, healthcare, and government — any organisation where software supply chain integrity is critical.

Affected Versions

The vulnerability affects JetBrains TeamCity On-Premises versions prior to 2026.05.2.

All TeamCity On-Premises deployments running earlier versions are affected, regardless of installation method (zip distribution, Docker image, or Windows installer). The agent polling protocol vulnerability is present across all delivery mechanisms.

TeamCity Cloud instances were patched automatically by JetBrains prior to public disclosure. No action required for TeamCity Cloud customers.

Remediation Steps

1. Patch immediately: Update TeamCity On-Premises to version 2026.05.2 or later. The patch is available from the JetBrains download portal and via the TeamCity in-product upgrade mechanism (Administration > Server Administration > Updates).

2. Verify the upgrade: Confirm successful upgrade by navigating to Administration > Server Administration > Diagnostics and verifying the version string shows 2026.05.2 or higher.

3. Network-level mitigation (if patching is not immediately possible): Restrict network access to TCP 8111 to known IP ranges. The agent polling endpoint shares the port with the web interface; network perimeter restriction is the most effective interim control. JetBrains has also confirmed that restricting the build agent communication port to known agent IP addresses via firewall rules limits exposure without patching.

4. Disable unused build agents: If build agents are not currently in active use, disable them in the TeamCity configuration to reduce accessible polling endpoints.

5. Rotate exposed secrets: If your TeamCity instance was internet-exposed prior to patching, treat all stored credentials as potentially compromised. Rotate VCS credentials, cloud API keys, deployment tokens, and code signing certificates as a precaution.

6. Review build artifacts: For any builds run on an unpatched server during the exposure window, review build artifacts for signs of tampering.

Detection Guidance

Network Detection

HTTP POST requests to TeamCity agent communication endpoints from unexpected source IPs should be investigated immediately. The agent polling endpoints include:

• /app/agents
• /app/agentsSlave
• /update/plugins.list (agent update mechanism)

Any request to these paths from an IP address not in your registered build agent subnet warrants immediate review. Deserialization payloads will contain the binary Java serialization magic bytes AC ED 00 05 in the request body. Network IDS rules should key on this byte sequence for the relevant endpoints.

Host-Based Detection

Post-exploitation from Java deserialization typically produces child processes spawned by the TeamCity JVM:

Process creation: java.exe / java spawning cmd.exe, powershell.exe, /bin/bash, /bin/sh, curl, wget
Parent process: TeamCity server process (teamcity-server.bat or startup.sh)

Unexpected outbound network connections from the TeamCity server process to non-configured build agent IPs or external infrastructure should be treated as indicators of compromise.

Log Sources

TeamCity server logs are located at:

• <TeamCity data directory>/system/buildserver.log
• <TeamCity data directory>/logs/teamcity-server.log

Look for:

• Deserialization errors or stack traces preceding unusual activity (failed exploitation produces exceptions before successful exploitation)
• Agent registration events from unrecognised IP addresses
• Configuration change events (build configuration modification, user creation, VCS root changes) without corresponding authenticated user sessions

YARA Rule (Network Traffic)

rule TeamCity_CVE_2026_63077_Deserialization_Attempt {
    meta:
        description = "Detects Java deserialization payload in TeamCity agent polling endpoint"
        cve = "CVE-2026-63077"
    strings:
        $magic = { AC ED 00 05 }
        $tc_agent_path = "/app/agents"
    condition:
        $tc_agent_path and $magic
}

Timeline

References

• JetBrains Security Advisory — CVE-2026-63077
• JetBrains Issues Fixed
• CISA KEV — CVE-2026-63077
• NVD — CVE-2026-63077
• CISA BOD 26-04 — Prioritizing Security Updates Based on Risk
• CISA Advisory — Prior TeamCity Exploitation by APT29