TeamCity remote code execution flaw: What you need to know

JetBrains warned on July 27 that a critical authentication bypass vulnerability, tracked as CVE-2026-63077, could let an attacker with HTTPS access to a TeamCity server execute arbitrary operating‑system commands. That’s the catch. The flaw affects every on‑premises version of TeamCity, and it can be weaponized for a full‑blown remote code execution attack. Read the original report for the full advisory.

Key Takeaways

• All on‑premises TeamCity versions are vulnerable to an authentication bypass that enables remote code execution.
• JetBrains patched the issue in versions 2025.11.7 and 2026.1.3; a plugin covers older supported releases.
• No active exploitation was observed when the advisory was published, but past TeamCity flaws have been abused by ransomware gangs and nation‑state actors.
• Administrators should upgrade immediately, apply the plugin if they can’t upgrade, and harden internet‑facing endpoints.
• TeamCity Cloud users are exempt because the fixes were pre‑applied on the service side.

TeamCity remote code execution vulnerability (CVE-2026-63077)

The vulnerability lives in the agent polling protocol, which lets a client ask the server for work. An attacker who can reach the server over HTTPS can spoof a legitimate agent, bypass authentication, and then run OS commands with the same privileges as the TeamCity service. That’s a serious escalation. JetBrains says the bug lets the attacker “execute arbitrary operating system commands with the privileges of the server process.”

How the exploit works

First, the attacker sends a crafted polling request that pretends to be an authorized build agent. The server, trusting the request, skips the usual login checks. Then the attacker includes a payload that the server runs as a shell command. Because the TeamCity service often runs as a privileged system user, the attacker can read configuration files, steal stored credentials, or alter build artifacts. The chain is simple, but it’s effective. That’s why the bug is rated critical.

Historical Context

TeamCity has been in the spotlight before. In 2022, ransomware groups exploited a separate flaw to encrypt CI pipelines, forcing victims to pay for decryption keys. Those attackers targeted the same trust relationships that CI/CD tools maintain with source code and artifact stores. State‑backed actors have also set their sights on the platform, using its ability to move laterally across development environments. Those incidents demonstrate that the ecosystem around continuous integration is a proven vector for supply‑chain attacks.

Each high‑profile breach has nudged vendors toward tighter default configurations. JetBrains, for example, began automatically downloading security patches for releases newer than 2024.03 after earlier incidents revealed that many customers were slow to apply manual updates. The pattern repeats: a vulnerability surfaces, an advisory is issued, and the community scrambles to remediate. Understanding that cycle helps teams anticipate the next move in the threat landscape.

Scope and impact

JetBrains stresses that “All versions of TeamCity On-Premises are affected,” and that the cloud offering doesn’t need any action because the protective measures are already in place. The advisory lists no confirmed incidents, but the history of TeamCity exploits is anything but trivial. In 2022, ransomware groups used a separate flaw to encrypt CI pipelines; state‑backed actors have also targeted the platform in the past. If the new bug were weaponized, attackers could compromise the entire software supply chain.

“All versions of TeamCity On-Premises are affected,” JetBrains warns in the advisory, adding that “TeamCity Cloud customers are not required to take any action, as the necessary measures have already been applied.”

Patch timeline and mitigation steps

The issue was privately reported to JetBrains on July 10. The company rolled out fixes in the 2025.11.7 and 2026.1.3 releases. For customers who can’t jump to those versions right away, JetBrains offers a security‑patch plugin that covers TeamCity 2017.1 and newer. The plugin can be installed without a full upgrade, but versions 2017.1 through 2018.1 still need a server restart for the changes to take effect. That’s an important operational detail.

Upgrade vs. plugin

If you’re on a supported release newer than 2018.1, the simplest path is to upgrade to either 2025.11.7 or 2026.1.3. Those builds include the fix out of the box and will automatically download any future security plugins, as JetBrains notes that “TeamCity 2024.03 and newer automatically downloads available security patch plugins and notifies administrators so they can install them.” For legacy installations, the plugin offers a stop‑gap, but you’ll still have to schedule a restart if you’re on 2017.1‑2018.1. That downtime can be a pain, but it’s better than leaving the server exposed.

Why this matters now

TeamCity has been a favorite target for attackers because it sits at the heart of many organizations’ CI/CD pipelines. The platform’s ability to store credentials and orchestrate builds makes it a high‑value asset. The fact that the vulnerability can be triggered simply by reaching the server over HTTPS means that any misconfigured firewall or exposed login page could become an entry point. The advisory notes that “even exposing the login page or REST API can give attackers an entry point to exploit newly disclosed vulnerabilities.” That’s a reminder that surface‑area reduction is still a core defense.

• Attackers could steal stored credentials and reuse them elsewhere.
• Compromised build agents could inject malicious code into production releases.
• Unauthorized command execution might let threat actors pivot to other internal systems.
• Supply‑chain integrity could be jeopardized, affecting downstream customers.

Best practices beyond the patch

JetBrains recommends adding layers such as VPN‑only access for internet‑facing TeamCity instances. That’s a practical step you can take today. Restricting traffic to known IP ranges reduces the attack surface dramatically. Also, never expose the REST API or login page to the public internet without additional hardening, like rate‑limiting or multi‑factor authentication. Those controls buy you time to detect suspicious activity before it escalates.

Testing your layers

Security teams often miss the majority of successful attacks; the advisory cites a figure of 54% of successful attacks being logged, while only 14% trigger alerts. That gap underscores the value of breach‑and‑attack simulation tools that test your SIEM and EDR rules. If you’re not already simulating attacks, consider a pilot to see where your detection gaps lie. It’s a cheap way to expose blind spots before an actual adversary does.

What This Means For You

If you run TeamCity on‑premises, you need to verify which version you’re on right now. Check the server’s version string in the administration UI, and compare it to the patched releases listed above. If you’re on a vulnerable version, schedule an upgrade or install the security‑patch plugin within the next few days. Delaying could leave you open to an exploit that’s already proven easy to weaponize in the past.

Beyond the immediate fix, tighten your perimeter. Move the server behind a VPN, enforce MFA on all accounts, and limit REST API exposure. Run regular scans against your CI/CD tooling to ensure no lingering open ports or misconfigurations. Those habits will help you stay ahead of the next vulnerability that surfaces.

Three concrete scenarios illustrate why swift action matters. A small startup that relies on a single TeamCity instance for all builds might think the risk is low, but a single compromised build can insert a backdoor into every customer‑facing release. An enterprise with dozens of agents across multiple data centers could see the breach spread quickly, turning a localized incident into a corporate‑wide outage. A managed service provider hosting TeamCity for several clients faces liability if a shared server is abused to steal credentials that belong to different organizations.

In each case, the cost of a breach far outweighs the downtime required for a patch or restart. The trade‑off is clear: a short maintenance window versus a potentially catastrophic supply‑chain compromise.

Will future TeamCity releases continue to bundle security patches automatically, or will administrators still have to chase down updates manually? Only, but the pressure to automate security in CI/CD pipelines has never been higher.

Key Questions Remaining

• How quickly will JetBrains extend automatic patch distribution to older LTS releases?
• Will the industry adopt a standard for mandatory CI/CD hardening, similar to PCI‑DSS for payment systems?
• What mechanisms can organizations put in place to detect a compromised build agent before it pushes malicious artifacts?

Answers will emerge as the community reacts. In the meantime, treat this advisory as a call to action, not an isolated incident.

Sources: BleepingComputer, JetBrains Security Advisory