Date Observed: August 8–24, 2026 (confirmed Cadence exploitation; CVE disclosed July 27)
Ecosystem: JetBrains TeamCity On-Premises, CI/CD servers, build agents, and connected cloud/source-control systems
Targets: Internet-reachable TeamCity servers; build credentials; source code; cloud, repository, registry, and deployment access
Attack Type: Unauthenticated remote code execution through the TeamCity agent polling protocol; CI/CD control-plane compromise
Impact: 2024 Cadence backup compromised; multiple AWS IAM credentials compromised; JetBrains S3 files accessed; current Cadence source code and credentials treated as potentially exposed
Key Takeaways
- CVE-2026-63077 affects TeamCity On-Premises and allows an unauthenticated attacker with HTTP(S) access to execute operating-system commands with the privileges of the TeamCity server process. JetBrains fixed the flaw in versions 2025.11.7 and 2026.1.3 and released a security patch plugin for older supported installations. TeamCity Cloud customers were not instructed to take remedial action.
- The vulnerability was privately reported July 10 and fixed July 27. CISA added it to the Known Exploited Vulnerabilities catalog on August 5; confirmed malicious activity against JetBrains Cadence began August 8 — after a fix was already available.
- The exploit reaches TeamCity through its agent polling protocol. Rapid7 demonstrated that a remote attacker can register a synthetic agent, send crafted XML to an unauthenticated endpoint, and reach arbitrary command execution without a TeamCity account.
- JetBrains confirmed the Cadence incident exposed a 2024 server backup, compromised multiple AWS IAM users and credentials, and allowed access to JetBrains S3 data. Its final September 3 update said current Cadence storage containing project source code and credentials must also be treated as potentially exposed.
- Patching is the primary defense. InvisiRisk does not block the TeamCity server vulnerability itself, but when a compromised CI/CD control plane causes protected builds or agents to make unauthorized outbound, source-control, registry, or API actions, build-time enforcement can provide a containment layer.
Introduction
On July 27, 2026, JetBrains disclosed CVE-2026-63077, a critical vulnerability affecting TeamCity On-Premises. The flaw can be exploited without authentication by an attacker who can reach a TeamCity server over HTTP or HTTPS, allowing arbitrary operating-system commands to run with the privileges of the TeamCity server process. JetBrains released fixed versions 2025.11.7 and 2026.1.3 the same day, along with a security patch plugin for TeamCity 2017.1 and later.
The risk moved quickly from theoretical to real-world. On August 5, CISA added the vulnerability to its Known Exploited Vulnerabilities catalog. JetBrains subsequently reported active exploitation against unpatched TeamCity servers. Three days after the KEV listing, malicious activity began against JetBrains’ own Cadence environment, which used an unpatched TeamCity server to orchestrate workloads.
That incident makes CVE-2026-63077 particularly important for DevOps and DevSecOps teams. Compromising a CI/CD control plane is not just server access: it can expose source code, stored credentials, build configuration, artifacts, cloud accounts, registries, and downstream delivery systems that trust the build environment.
Scope and Impact of the Attack
The vulnerability was privately reported to JetBrains on July 10. JetBrains disclosed it and made fixes available on July 27. CISA added the CVE to its KEV catalog on August 5. JetBrains identified malicious activity against Cadence beginning August 8, discovered the compromise on August 23, and took the affected server offline on August 24. The company publicly disclosed the Cadence incident on August 28 and concluded its investigation with a final update on September 3.
The timing matters: the confirmed Cadence compromise began 12 days after patched TeamCity releases were available and three days after CISA identified the vulnerability as actively exploited. JetBrains later stated that the Cadence server “should have been patched as part of our response to the vulnerability, but it was not.”
According to JetBrains’ Cadence incident report, attackers accessed and extracted personal data, compromised a full Cadence server backup dating from 2024, compromised multiple AWS IAM users and associated credentials, and accessed files in S3 buckets within JetBrains AWS accounts used by Cadence. The September 3 update also confirmed that the actor obtained access that could have reached current Cadence storage containing email addresses, project source code, and credentials; JetBrains therefore treated that current data as potentially exposed.
JetBrains advised affected Cadence users to rotate all credentials and secrets that may have been used with the service and to review AWS accounts, source repositories, deployment environments, package/container registries, and other connected systems for suspicious activity. The company also warned users to treat Cadence executions and synchronized project files as potentially untrusted.
How the Attack Works
Stage 0: Reach an exposed TeamCity server
CVE-2026-63077 affects the TeamCity server’s agent polling protocol, the HTTP-based channel used by build agents to register with the server, poll for commands, and report results. Exploitation does not require a TeamCity user account. If an attacker can reach a vulnerable TeamCity server over HTTP(S), the vulnerable protocol is exposed.
JetBrains recommends restricting internet-facing TeamCity servers to trusted networks wherever possible, using VPN or an additional access layer, and running the TeamCity server with the minimum operating-system privileges required for normal operation.
Stage 1: Abuse the agent polling protocol
Rapid7’s technical analysis traces the flaw to unsafe XStream deserialization in the agent polling protocol. A remote attacker can first register a synthetic agent through /app/agents/v1/register and receive a TeamCity-AgentSessionId. The attacker can then send crafted XML to /app/agents/v1/commands/error, where the vulnerable server deserializes attacker-controlled data.
Rapid7 demonstrated a working gadget chain that can write a temporary .jspws web shell into the TeamCity web root and then invoke it to execute an arbitrary operating-system command. This describes a verified exploitation path for the vulnerability; JetBrains has not publicly detailed every command or post-exploitation technique used by the actors in the Cadence incident.
Stage 2: Execute as the TeamCity server process
Successful exploitation runs commands with the privileges of the TeamCity server process. JetBrains warns that, depending on those privileges, an attacker may be able to expose TeamCity data, configurations, and stored credentials, modify server state, and compromise the integrity of build artifacts and downstream CI/CD pipelines.
For defenders investigating suspected exploitation, JetBrains recommends reviewing server logs for com.thoughtworks.xstream.converters.ConversionException, which may indicate an attempted or successful exploit. After patching, com.thoughtworks.xstream.security.ForbiddenClassException can indicate that a malicious deserialization attempt was blocked by the fixed server.
Stage 3: Reach credentials, source, storage, and downstream systems
The Cadence incident shows why CI/CD control-plane access is so sensitive. JetBrains confirmed that attackers reached a server backup containing credentials and configuration, compromised AWS IAM credentials, and accessed JetBrains S3 data. It also identified potential exposure of current Cadence users’ source code and credentials.
The blast radius can extend beyond TeamCity itself because build systems routinely hold or receive access to source-control tokens, cloud credentials, package-registry credentials, container registries, signing material, deployment keys, webhooks, and service-account credentials. JetBrains specifically advised affected users to investigate unexpected repository clones or commits, cloud IAM changes, package or release modifications, new API tokens, and suspicious cloud-storage access.
Why This Matters to DevOps and DevSecOps Teams
This vulnerability does not rely on a malicious open-source package or a developer clicking a phishing link. It attacks the CI/CD control plane itself. An unauthenticated internet attacker can move from network reachability to command execution on a system that often sits at the center of software delivery and has privileged access to code, credentials, build artifacts, registries, and deployment infrastructure.
The Cadence breach also illustrates the danger of patch latency. A fix existed before the confirmed attack began, but one exposed TeamCity environment remained vulnerable. Once a CI/CD server is compromised, the response is no longer just “apply the patch”: organizations must assume that credentials, build configurations, artifacts, source code, and connected systems may have been touched and investigate the downstream impact.
Why Patch Availability Isn’t the Same as Protection
Patching is the first and most important control for CVE-2026-63077. Vulnerability scanners, asset inventories, and KEV-based prioritization can help identify exposed TeamCity servers, but they do not contain post-exploitation activity after an attacker has already gained command execution.
The Cadence timeline is the key lesson: the fixed versions were available on July 27, active exploitation was confirmed by August 5, and Cadence was attacked beginning August 8. Build environments therefore also benefit from controls that limit what code and automation are allowed to communicate with or change if the CI/CD control plane is compromised.
How InvisiRisk Can Limit the Downstream Impact
The InvisiRisk Build Application Firewall (BAF) operates inline with protected CI/CD build traffic and enforces policy while builds are running. It is important to separate that role from the vulnerability itself: InvisiRisk is not a WAF for the TeamCity management server and would not prevent the unauthenticated CVE-2026-63077 exploit. Direct access to TeamCity backups or storage outside protected build traffic can also occur outside the BAF boundary.
Block unauthorized outbound activity from compromised builds. If a compromised TeamCity control plane launches or modifies build jobs, InvisiRisk can restrict the destinations those builds and agents are allowed to contact. Unexpected command-and-control callbacks, unapproved downloads, or outbound connections can be blocked before the build environment communicates with an unauthorized endpoint.
Detect and block credential exfiltration during build execution. TeamCity and its build agents routinely handle cloud, repository, registry, signing, and deployment credentials. If malicious code executing inside a protected build attempts to transmit those secrets outside the approved workflow, InvisiRisk can inspect the outbound traffic and enforce secrets-exfiltration policy in real time.
Block unauthorized source-control, registry, and API actions. A compromised CI/CD environment can be used to clone unexpected repositories, push unauthorized changes, publish packages, modify releases, or call cloud and source-control APIs outside normal build scope. InvisiRisk can apply protocol-aware policy to build-time network and API actions so expected operations remain allowed while out-of-scope actions can be stopped.
Patching remains the primary defense against CVE-2026-63077 and should be applied as quickly as possible. But patching only closes a vulnerability after it is known. If a TeamCity server is exploited before a patch is applied — or through a future vulnerability that has not yet been discovered — InvisiRisk can provide an additional containment layer when the attacker uses the compromised control plane to launch or modify protected builds or agents. By restricting unauthorized outbound connections, credential exfiltration, source-control activity, registry access, and API actions, the BAF can help prevent initial access from becoming a successful downstream attack through protected builds.
Why Build-Time Defenses Matter
CVE-2026-63077 illustrates a broader CI/CD security problem: there will always be a period between when a vulnerability exists and when organizations know about it, patch it, and confirm that every affected system has been remediated. During that window, traditional vulnerability management cannot prevent an attacker from exploiting the unknown or unpatched flaw.
That is where build-time enforcement adds another layer of protection. InvisiRisk does not need to know the CVE number or recognize the exploit itself. It can enforce expected build behavior by limiting outbound destinations and blocking out-of-scope repository, registry, and API activity. That helps contain malicious activity inside protected builds, whether it originates from a known vulnerability or one that has not yet been disclosed.


