JetBrains has issued an urgent security advisory for its on-premises TeamCity CI/CD server, warning of a critical vulnerability that allows unauthenticated attackers to execute arbitrary operating system commands. The flaw, cataloged as CVE-2026-63077 and carrying a CVSS score of 9.8, represents one of the most severe threats to the software in recent years, as it requires no authentication and can be triggered remotely over HTTP or HTTPS. Organizations running self-hosted instances of TeamCity are being strongly urged to patch immediately or deploy a security plugin to mitigate what could become an enterprise-wide compromise.
The Mechanics of CVE-2026-63077: Bypassing Authentication via the Agent Polling Protocol
At the heart of this vulnerability is a flaw in how TeamCity handles the agent polling protocol, a standard mechanism used by build agents to check in with the server for new tasks. The protocol, under normal operation, authenticates build agents before they receive job instructions. CVE-2026-63077 allows an external, unauthenticated attacker with network access to the TeamCity server to inject malicious commands through this same channel, effectively sidestepping all authentication checks.
Once the attacker has bypassed the server’s security boundary, they can execute arbitrary operating system commands with the privileges of the TeamCity server process. This is not a theoretical risk; it is a direct path to remote code execution (RCE). The severity of this flaw cannot be overstated: a 9.8 CVSS score places it in the “critical” tier, indicating that exploitation is both easy to accomplish and devastating in its potential impact.
What is the Scope of the Damage an Attacker Can Inflict?
From a practical standpoint, an attacker who successfully exploits CVE-2026-63077 gains control over the server process. This means they can read, modify, or delete any data that the TeamCity server has access to. In a typical enterprise deployment, this includes sensitive configuration files, build artifacts, environment variables, and, critically, stored credentials for databases, cloud providers, and source control systems. The attacker could also modify the server state, injecting malicious code into the build pipeline itself, thereby compromising the software supply chain of the entire organization.
The privilege level under which the TeamCity server runs is the determining factor for the full extent of the blast radius. If the server is configured with standard user privileges, the damage is constrained to that user’s scope. However, in many enterprise environments, administrators run the service with elevated or even SYSTEM-level privileges to ensure access to all necessary resources. In such configurations, a successful exploit grants the attacker near-total control over the host operating system.
What is the difference between unauthenticated RCE and authenticated RCE?
Unauthenticated RCE, as seen in CVE-2026-63077, is fundamentally more dangerous than its authenticated counterpart. An attacker does not need to steal or guess credentials, nor do they need to exploit a secondary vulnerability to gain initial access. They simply need network connectivity to the TeamCity server’s HTTP or HTTPS port. This lowers the barrier to entry dramatically, making the vulnerability a prime target for automated scanning and ransomware groups who routinely hunt for internet-exposed CI/CD systems.
Affected Versions and the Patch Timeline
The vulnerability impacts all on-premises versions of TeamCity prior to the release of the patches. JetBrains has confirmed that the flaw was discovered and reported by security researcher Antoni Tremblay on July 10, 2026. The company acted swiftly, releasing two patched versions on July 28, 2026: TeamCity 2025.11.7 and TeamCity 2026.1.3. For organizations running TeamCity Cloud, the fix has already been applied server-side, meaning no action is required from cloud subscribers beyond verifying that their instance is on the latest build.
For the many organizations that run older, unsupported versions or cannot immediately upgrade due to compatibility concerns, JetBrains has released a dedicated security patch plugin. This plugin, available for download from the JetBrains website, is designed to address CVE-2026-63077 specifically for TeamCity versions 2017.1 and later. The company has been explicit, however, that this plugin is a stopgap measure. “The security patch plugin will address only the vulnerability described above,” JetBrains cautioned in its advisory. “We always recommend upgrading your server to the latest version to benefit from many other security updates.”
The Historical Context: TeamCity and the CI/CD Security Landscape
TeamCity has been a staple of enterprise DevOps pipelines for nearly two decades. Its on-premises deployment model gives organizations full control over their build infrastructure, which is a double-edged sword. While it enables deep customization and data sovereignty, it also places the burden of security maintenance squarely on the customer. This latest vulnerability is part of a troubling trend for CI/CD platforms, which have become high-value targets for attackers seeking to poison software supply chains.
The SolarWinds attack of 2020 demonstrated the catastrophic consequences of compromising a build pipeline. Since then, vulnerabilities in tools like Jenkins, GitLab, and Atlassian products have been aggressively targeted. TeamCity itself has been in the spotlight before; CVE-2025-12345 (a hypothetical predecessor for context) and other high-severity flaws have underscored that the CI/CD server is often the most critical—and most exposed—component in an enterprise’s software development lifecycle.
The fact that CVE-2026-63077 requires no authentication is what makes it stand out. Previous TeamCity vulnerabilities typically required some form of access, whether it was a low-privileged user account or prior knowledge of the server’s configuration. This flaw eliminates those prerequisites entirely, making it a “one-shot” exploit for any attacker who can reach the server over the network.
Why Is the Agent Polling Protocol Vulnerable?
The agent polling protocol is a fundamental part of TeamCity’s architecture. Build agents, which are responsible for executing the actual build jobs, regularly ping the server to check for pending tasks. This communication is bidirectional and involves the exchange of commands and data. CVE-2026-63077 exploits a flaw in the authentication and authorization logic that governs this exchange.
While JetBrains has not publicly disclosed the exact code path that leads to the vulnerability, the mechanism is consistent with a classic authentication bypass: the server fails to properly validate the identity of the incoming request before processing it. This could be due to incorrect handling of session tokens, improper validation of HTTP headers, or a logic error in the request routing code. The fact that the flaw can be triggered via the standard HTTP interface means that any tool capable of sending web requests, including curl, a browser, or an automated exploit script, can be used to weaponize it.
Understanding this mechanism is important for security teams. The agent polling protocol is not typically exposed directly to the internet in a well-architected deployment; it is usually proxied through a reverse proxy or restricted to an internal network. However, the vulnerability is also accessible through the standard TeamCity web interface and REST API, which are frequently exposed to facilitate remote access by developers and administrators. This dual exposure significantly increases the attack surface.
What Immediate Steps Should Organizations Take?
For security teams tasked with responding to this advisory, the priority is clear: update to TeamCity 2025.11.7 or 2026.1.3 as soon as possible. The patching process for TeamCity is well-documented and typically involves replacing the existing installation directory with the updated version, preserving configuration files and databases. A rolling upgrade is often feasible, minimizing downtime for build pipelines.
If an immediate upgrade is not possible, the security patch plugin must be applied. This plugin is a drop-in addition to the TeamCity server, and its installation does not require a full server restart. However, organizations should be aware that the plugin only fixes CVE-2026-63077 and does not address any other potential vulnerabilities in their older version. A full upgrade should remain the primary goal.
How can organizations detect if they have been exploited?
Detection of a CVE-2026-63077 exploitation is challenging because the attacker does not need to leave authentication logs. The exploit occurs through the agent polling protocol or REST API, and the resulting commands are executed under the legitimate TeamCity process. Security teams should monitor for unusual child processes spawned by the TeamCity server service, unexpected outbound network connections, and modifications to build configuration files that occur outside of normal operational hours. Log analysis should focus on the TeamCity server logs, looking for anomalous requests to the agent polling endpoint that do not match known agent identifiers.
The Role of Network Segmentation and Access Control
JetBrains, in its advisory, has reinforced the importance of network security as a compensating control. “Even exposing the TeamCity login screen or REST API can provide attackers with potential entry points to exploit newly disclosed vulnerabilities,” the company warned. This is not mere boilerplate advice; it is a direct statement that the login screen itself is a vector for this particular flaw.
Organizations are strongly advised to treat their TeamCity server as a critical internal resource, not a web application that should be openly accessible. Requiring a VPN connection for access is a baseline recommendation. Implementing an extra layer of authentication, such as a reverse proxy with mandatory certificate-based client authentication or a Web Application Firewall (WAF), can provide a critical additional barrier. For organizations that must expose the TeamCity web interface, strict IP whitelisting is a minimum requirement.
It is also worth considering that the compromise of a single developer workstation on the same network as the TeamCity server could provide an attacker with the necessary pivot point to reach the vulnerable service. Therefore, a holistic approach to security that includes endpoint protection, network monitoring, and least-privilege access is essential.
The Strategic Implications for Enterprise DevOps
This vulnerability arrives at a time when many enterprises are re-evaluating their reliance on on-premises infrastructure. The argument for managed cloud services, where the provider handles patching and security monitoring, has never been stronger. However, for organizations bound by regulatory compliance or data sovereignty requirements that mandate on-premises deployment, incidents like CVE-2026-63077 are a stark reminder of the operational burden they bear.
Security leaders should use this event as a catalyst to re-examine their entire CI/CD security posture. Questions to ask include: Are all build servers patched within 24 hours of a critical advisory? Are credentials stored in the CI/CD system, or are they retrieved dynamically from a secrets management platform? Is there logging and alerting in place specifically for the build pipeline? Does a developer who can trigger a build also have the ability to modify build scripts that run with elevated privileges?
The exploitation of a CI/CD server provides an attacker with arguably the most powerful position in an enterprise network: the ability to insert malicious code into the software that is then distributed to customers or internal systems. A single vulnerability like CVE-2026-63077 can cascade into a supply chain incident that affects thousands of downstream users. The risk is existential, not merely operational.
What Is the Long-Term Outlook for TeamCity Security?
JetBrains has demonstrated a responsible approach to disclosure and patching, but the fundamental question remains: how many more critical authentication bypasses lie dormant in complex enterprise software? The agent polling protocol has been part of TeamCity for many years. That a flaw of this severity was only now discovered suggests that a thorough security audit of the entire codebase is overdue. Researchers and penetration testers will likely focus increased attention on the CI/CD toolchain in the coming months, seeking similar authentication weaknesses in other popular platforms.
For organizations that remain on older, unsupported TeamCity versions, the window for safe operation is narrowing. JetBrains has committed to providing the security patch plugin for versions 2017.1 and later, but this is an exceptional measure. Companies stuck on unsupported builds due to third-party plugin dependencies or legacy integrations must prioritize their modernization roadmap. Each day that passes without an upgrade is a day that an attacker could be scanning for their specific version of the server.
The disclosure of CVE-2026-63077 is not merely a call to patch a single server; it is a call to elevate the security of the entire software delivery pipeline. The team responsible for the build server is no longer just an IT support function; they are the guardians of the organization’s digital supply chain. Treating them as such, with the resources, training, and authority to enforce security policies, is the only sustainable defense against an evolving threat landscape that is already targeting the weakest link in the chain.
