Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach TeamCity settings interface
-
DeliverySubmit crafted Kotlin DSL
-
ExploitEscape DSL evaluation sandbox
-
ExecutionExecute code on CI server
-
PersistHarvest VCS/deploy credentials
-
ImpactTamper with build pipeline
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
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 the ability to supply crafted Kotlin DSL to a TeamCity server running a version below 2026.1.2 or 2025.11.6 - i.e., the target must use TeamCity's Kotlin DSL / versioned-settings feature, and the attacker must be able to introduce DSL content (typically via write access to the VCS repository backing project settings or via project-settings edit rights). The NVD vector marks this PR:N (unauthenticated), but the realistic prerequisite of submitting DSL implies at least VCS-write or project-edit privilege, so the true authentication requirement is not fully confirmed from available data and should be validated with JetBrains. Limiting factors: servers that do not enable Kotlin/versioned settings, that restrict settings-write permissions, or that are not network-reachable by the attacker are materially harder to exploit. |
| Impact | The NVD-style CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H = 10.0) paints a worst-case picture: unauthenticated, network-reachable, low-complexity RCE with a scope change and total impact. However, that maximal score partially conflicts with how the Kotlin DSL is actually reached - supplying DSL to a project normally requires write access to a connected VCS repository or project-settings edit rights, which implies some level of authenticated/privileged access; PR:N should be verified against the vendor's exploitation model, and my independent assessment uses PR:L for this reason. The supporting signals temper the raw score: SSVC records Exploitation=none and Automatable=no (only Technical Impact=total is severe), EPSS is a modest 0.40%, and no POC or KEV listing exists, so this reads as a high-impact-but-not-yet-exploited priority rather than an actively-weaponized emergency. That said, TeamCity is a high-value CI/CD target whose compromise enables supply-chain attacks, so even a mid-sized operator should treat patching as urgent and not defer it on the strength of the low EPSS alone. Bottom line: prioritize the update quickly, but the 'unauthenticated' framing warrants confirmation with JetBrains' advisory. |
| Exploit ScenarioDerived | An attacker with the ability to submit Kotlin DSL settings - for example by committing to a VCS repository that TeamCity uses for versioned settings, or by abusing an exposed settings endpoint - crafts DSL that breaks out of the evaluation sandbox. When TeamCity compiles and evaluates the settings, the malicious code runs on the server, letting the attacker steal VCS/deployment credentials and tamper with builds. No public POC is identified at time of analysis, and the low-complexity network vector means exploitation is straightforward once DSL submission is possible. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Aug 11, 2026
Remote code execution in JetBrains TeamCity before 2026.1.2 and 2025.11.6 allows an attacker to escape the Kotlin DSL sandbox used to define build configurations-as-code and run arbitrary code in the context of the CI server. Because TeamCity servers hold VCS credentials, deployment keys, and build artifacts, a successful escape effectively compromises the entire build pipeline and downstream software supply chain. There is no public exploit identified at time of analysis, and the flaw is not listed in CISA KEV; EPSS is low at 0.40% (33rd percentile).
Earlier versions of this analysis (1)
Authenticated remote code execution in JetBrains TeamCity before 2026.1.2 and 2025.11.6 arises from a sandbox escape in the Kotlin DSL used to define build configurations, letting a low-privileged user break out of the intended DSL restrictions and run arbitrary code on the CI/CD server (CWE-94). With CVSS 8.8 (AV:N/AC:L/PR:L/UI:N) an attacker who can edit versioned build settings gains full host compromise. No public exploit identified at time of analysis, and the issue is not in CISA KEV.
RemediationAI
Vendor-released patch: upgrade to TeamCity 2026.1.2 (2026.1.x branch) or 2025.11.6 (2025.11.x maintenance branch), whichever matches your current major line, per JetBrains at https://www.jetbrains.com/privacy-security/issues-fixed/. Until you can upgrade, reduce exposure by restricting who can author or import Kotlin DSL settings: limit project-settings edit and 'versioned settings' write permissions to trusted administrators, and tighten write access on the VCS repositories that back TeamCity settings so untrusted commits cannot introduce DSL. Additionally, keep the TeamCity web UI and API off the public internet (place it behind a VPN or IP allowlist), which limits reachability if the unauthenticated vector is confirmed; the trade-off is reduced convenience for remote developers and integrations. These are compensating controls only - apply the patch as the definitive fix, since disabling versioned settings entirely would break teams that rely on configuration-as-code.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
TeamCity supports defining project and build settings 'as code' using a Kotlin-based DSL (Kotlin DSL), which is compiled and evaluated by the server. To contain the arbitrary Kotlin code this feature accepts, TeamCity evaluates it inside a restricted sandbox. This vulnerability is a CWE-94 (Improper Control of Generation of Code / code injection) issue where crafted DSL content bypasses the sandbox's restrictions, allowing the supplied Kotlin to execute outside its intended confinement on the server JVM. The affected component is the TeamCity server itself (CPE cpe:2.3:a:jetbrains:teamcity:*), specifically the settings/DSL evaluation subsystem rather than build agents.
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:C/C:H/I:H/A:H
Supplying Kotlin DSL realistically requires VCS-write or project-edit rights, so PR:L rather than PR:N; sandbox escape crosses a trust boundary (S:C) with total host impact (C/I/A:H).
Primary rating from Vendor (JetBrains).
CVSS VectorNVD
Lifecycle Timeline
5DescriptionNVD
In JetBrains TeamCity before 2026.1.2, 2025.11.6 сode execution via Kotlin DSL sandbox escape was possible
Executive ViewAI
A critical remote code execution vulnerability in JetBrains TeamCity (CVE-2026-65906) allows sandbox escape and arbitrary code execution with server privileges, with no public exploit identified at time of analysis. The vulnerability exposes VCS credentials, deployment keys, and the entire software supply chain to compromise; organizations using affected versions face exposure across every build and software release.
Vendor-released patch: JetBrains TeamCity 2026.1.2 and 2025.11.6. Apply to all affected instances immediately.
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
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
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
Remote code execution affects JetBrains TeamCity releases older than 2026.2, 2026.1.4, and 2025.11.8, where a type-white
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-48251
GHSA-8m5q-x899-528f
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB