Critical 9.8 JetBrains TeamCity RCE exploited by ransomware, says CISA

The Cybersecurity and Infrastructure Security Agency (CISA) warned on Sept. 23 that a critical remote code execution (RCE) flaw in JetBrains TeamCity is under exploitation in ransomware campaigns.

The CVSS 9.8 flaw CVE-2026-63077 was patched July 25 and then added to CISA’s known exploited vulnerabilities (KEV) catalog Aug. 5, a mere two months from disclosure to being exploited by ransomware.

JetBrains TeamCity is one of the industry’s leading CI/CD pipeline environments and security pros said the potential impact of an exploit was potentially extensive.

"Ransomware groups have figured out that build servers are one of the highest-value targets in most environments,” said Seemant Sehgal, chief executive officer at BreachLock. “They can inject malicious code into legitimate builds, steal signing keys and cloud credentials that build servers routinely hold, and pivot into production infrastructure that trusts the pipeline as an internal caller.”

Sehgal said security teams running TeamCity should treat this as an active compromise scenario until they have applied the patch, rotated credentials and tokens issued during the exposure window, and reviewed build logs for unexpected artifacts or configuration changes.

“Patching alone leaves attacker access from the pre-patch window in place, and that step is what teams sometimes miss on compressed timelines like this one,” said Sehgal.

Adrian Culley, offensive security engineer at SafeBreach, added that TeamCity sits at a chokepoint most CVEs don't reach: it holds build credentials, signing material and the pipeline that turns source code into shipped software. Culley said the bug is an unauthenticated RCE via the agent polling protocol (CWE-502), so an attacker with network access to the server needs no credentials at all.

“Compromise there isn't just a host incident, it's a potential foothold into every downstream build the server touches: T1190 in, T1195.002 as the objective,” said Culley. “Owning a patch cycle isn't the same as knowing your detection stack catches exploitation of an internet-facing build server before it pivots downstream — that's the gap organizations should be testing, not assuming.”

Boris Cipot, principal security engineer at Black Duck, said he’s mostly concerned about how quickly a vulnerability in critical development infrastructure can move from disclosure to real-world exploitation and ransomware.

Cipot said TeamCity sits at the heart of many CI/CD environments, automating how software gets built, tested, and deployed, making it a particularly attractive target.

“A compromised build server can potentially expose credentials and configuration, alter the server itself, and even undermine the integrity of build artifacts and downstream pipelines,” said Cipot.

Cipot also pointed out that we also need to consider that patching CI/CD infrastructure is not always straightforward: these systems are deeply connected to development workflows, and organizations may hesitate to update them because they are concerned about disrupting builds and releases.

“But attackers do not have the same operational constraints,” said Cipot. “Once exploitation begins, every internet-accessible and unpatched instance becomes an obvious target. In this case, the risk is particularly high because exploitation does not require authentication.”

John Strand, owner at Black Hills Information Security, added that the months from disclosure to ransomware isn’t that unusual. Even before AI, Strand said we could absolutely see an exploit emerge two months after a patch was released. Strand said his team has seen cases where that window gets measured in days, and sometimes less than a day.

“What concerns me much more is the very precise focus we’re seeing on software supply chain tools,” said Strand. “Whether we’re talking about NPM packages or TeamCity, attackers are targeting systems that can give them incredibly broad distribution. Compromise the right package or build system, and suddenly you have a path to spread malware across a huge number of systems.”

Strand said visibility presents another issue: a lot of these systems don’t have the same security telemetry we’ve come to expect from traditional endpoints.

“We can’t necessarily drop an EDR agent onto every component of the software supply chain and expect the same level of detection,” said Strand. “That makes these environments incredibly attractive to advanced attackers. They can potentially compromise one system, spread widely, and remain there for a long time without being detected.”