Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach build messages protocol endpoint
-
DeliveryCraft message bypassing type whitelist
-
ExploitTrigger unsafe deserialization (CWE-502)
-
ExecutionExecute arbitrary code on server
-
ImpactCompromise CI/CD pipeline and secrets
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires network reachability to the TeamCity 'build messages protocol' - the channel used for communication involving build agents - and the ability to send a serialized message that bypasses the server's deserialization type whitelist (CWE-502). Affected deployments are TeamCity before 2026.2, 2026.1.4, and 2025.11.8; the fix is available from JetBrains. Limiting factors: in typical architectures the build messages protocol is an agent-facing channel, so real-world exploitation may depend on whether the endpoint is exposed to untrusted networks or whether the attacker can impersonate/reach an agent connection - the CVSS asserts PR:N (no authentication), but operators should verify exposure of this protocol port. CISA SSVC marks the attack as not automatable. |
| Impact | Signals are mixed and point to a serious-but-not-yet-actively-exploited flaw. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H, score 9.8) describes a network-reachable, unauthenticated, low-complexity RCE via unsafe deserialization (CWE-502), which is genuinely critical by design. However, the exploitation-intensity signals are low: EPSS is only 0.38% (31st percentile), the CVE is NOT in CISA KEV, no public POC is indicated, and CISA SSVC rates Exploitation as 'none' and Automatable as 'no' while confirming Technical Impact as 'total'. So the theoretical impact is maximal but observed/predicted exploitation is currently low - this is a patch-now priority for internet-exposed or CI/CD-critical TeamCity servers, but there is no evidence of in-the-wild attacks yet. One tension to verify: the CVSS claims PR:N (unauthenticated), yet the flaw is in the 'build messages protocol' between TeamCity server and build agents, which in many deployments is an authenticated/agent-trust channel - confirm with JetBrains whether a truly unauthenticated attacker can reach the vulnerable deserialization path, as the practical attack surface may be narrower than AV:N/PR:N implies. SSVC 'Automatable: no' is consistent with the latter interpretation. |
| Exploit ScenarioDerived | An attacker who can reach the TeamCity build messages protocol endpoint sends a crafted, malicious serialized message that bypasses the type whitelist, triggering unsafe deserialization and arbitrary code execution on the TeamCity server. Because TeamCity orchestrates CI/CD, successful RCE yields control over build pipelines, secrets, and artifacts. No public exploit code is identified at time of analysis, and CVSS indicates low attack complexity with no user interaction. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 16, 2026
Remote code execution affects JetBrains TeamCity releases older than 2026.2, 2026.1.4, and 2025.11.8, where a type-whitelist bypass in the build messages protocol lets a serialized payload cross the deserialization trust boundary and execute code in the server process; the flaw carries a CVSS of 9.8 (AV:N/AC:L/PR:N/UI:N, unauthicated per the PR:N vector). There is no public exploit identified at time of analysis, CISA's SSVC records Exploitation as 'none' with Automatable set to 'no', and EPSS is low at 0.38% (31st percentile), though Technical Impact is rated 'total'. JetBrains has released fixes, so the primary risk is unpatched, network-reachable TeamCity servers whose agent-facing build messages channel is exposed beyond trusted build-agent hosts.
Earlier versions of this analysis (1)
Remote code execution in JetBrains TeamCity (versions before 2026.2, 2026.1.4, and 2025.11.8) allows unauthenticated remote attackers to bypass the build messages protocol whitelist and reach a deserialization flaw (CWE-502). The CVSS vector indicates high attack complexity (AC:H), meaning exploitation is not trivial, and no public exploit code or active exploitation has been identified at time of analysis. Attackers with network access to the build messages endpoint could achieve full compromise of confidentiality, integrity, and availability.
RemediationAI
Vendor-released patch: upgrade to TeamCity 2026.2, 2026.1.4, or 2025.11.8 depending on the release line in use, as documented on JetBrains' fixed-issues page (https://www.jetbrains.com/privacy-security/issues-fixed/) and the CVE record (https://nvd.nist.gov/vuln/detail/CVE-2026-111094). If immediate upgrade is not possible, restrict network access to the build messages protocol so that only known build-agent hosts can reach the server's agent-facing port - block it at the perimeter or host firewall and allowlist agent IPs - accepting that remote, cloud, or dynamically addressed agents will fail to register until connectivity is restored; this is a compensating control, not a fix, and can be bypassed by an attacker who already controls a legitimate agent host. Additional interim steps include reviewing TeamCity server and agent logs for unexpected serialized payloads or anomalous agent connections from unfamiliar hosts, and removing any unnecessary internet exposure of the TeamCity server (the agent channel and administrative UI should not be publicly reachable). Note that no public exploit is known at time of analysis and CISA SSVC does not mark the attack as automatable, so prioritized patching of internet-exposed or multi-tenant instances is the appropriate response rather than emergency containment.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause class is CWE-502, deserialization of untrusted data: TeamCity's build messages protocol - the channel used by the server and its build agents to exchange commands, status, and build metadata - deserializes messages and is supposed to enforce a whitelist of permitted types. The bypass allows an attacker to craft a serialized message that evades that whitelist and reaches dangerous classes, producing remote code execution within the TeamCity server's Java process. The CPE cpe:2.3:a:jetbrains:teamcity:*:*:*:*:*:*:*:* describes the entire TeamCity product, consistent with EUVD's affected range covering all builds preceding the fixed 2026.2, 2026.1.4, and 2025.11.8 releases. Because this protocol is normally agent-facing rather than a public web endpoint, practical exploitability hinges on whether the port is reachable from untrusted networks or whether an attacker can reach or impersonate an agent connection; the CVSS vector asserts no privileges are required (PR:N), and the SSVC assessment notes the attack is not automatable, meaning exploitation likely requires a tailored payload rather than commodity scanning.
Know when Teamcity gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Network-facing whitelist-bypass deserialization with no stated auth or interaction yields AV:N/AC:L/PR:N/UI:N and total server compromise (C:H/I:H/A:H), matching the vendor vector.
Primary rating from Vendor (JetBrains).
CVSS VectorNVD
Lifecycle Timeline
4DescriptionNVD
In JetBrains TeamCity before 2026.2, 2026.1.4, 2025.11.8 remote code execution via a whitelist bypass in the build messages protocol was possible
Executive ViewAI
A critical remote code execution vulnerability in JetBrains TeamCity, the CI/CD server that many organizations rely on to build and deploy software, could let an unauthenticated attacker with network access execute arbitrary code on the server, potentially compromising the entire software supply chain and any credentials or secrets managed by the platform. Although no public exploit or active exploitation has been identified at this time, the flaw's maximum severity and network-reachable attack surface make it a priority for any business running affected versions, especially those exposing the agent-facing build-messages channel beyond trusted hosts.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Path traversal in JetBrains TeamCity before 2023.11.4 enables remote attackers to perform a limited set of administrativ
Remote code execution in JetBrains TeamCity before 2026.1.3 and 2025.11.7 allows unauthenticated attackers to execute ar
In JetBrains TeamCity before 2023.11.4 authentication bypass allowing to perform admin actions was possible. Rated criti
In JetBrains TeamCity before 2023.05.4 authentication bypass leading to RCE on TeamCity Server was possible. Rated criti
In JetBrains TeamCity before 2023.11.3 authentication bypass leading to RCE was possible. Rated critical severity (CVSS
Remote code execution in JetBrains TeamCity before 2026.1.2 and 2025.11.6 allows an attacker to escape the Kotlin DSL sa
Sandbox escape in JetBrains TeamCity's Kotlin DSL configuration mechanism allows an attacker who can supply or modify ve
JetBrains TeamCity versions prior to 2026.2, 2026.1.4, and 2025.11.8 contain a flaw in the password reset mechanism that
In JetBrains TeamCity before 2024.07 access tokens could continue working after deletion or expiration. Rated critical s
In JetBrains TeamCity before 2022.04.7, 2022.10.6, 2023.05.6, 2023.11.5 authentication bypass was possible in specific e
In JetBrains TeamCity before 2023.05 bypass of permission checks allowing to perform admin actions was possible. Rated c
JetBrains TeamCity before 2021.2.3 was vulnerable to OS command injection in the Agent Push feature configuration. Rated
EUVD-2026-102147
GHSA-x7hh-wg8w-g7jc
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB