Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as low-privileged TeamCity user
-
DeliveryAuthor malicious Kotlin DSL in versioned settings
-
ExploitTrigger sandbox escape on DSL evaluation
-
ExecutionExecute arbitrary code on server
-
ImpactCompromise CI/CD pipeline and secrets
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation completeness
|
| Exploitation Conditions | Exploitation requires an authenticated TeamCity account with permission to create or modify a project's versioned settings using the Kotlin DSL (settings-as-code) feature - this is the exact feature named in the advisory. The attacker must be able to supply/commit a Kotlin DSL configuration that TeamCity will evaluate; the flaw is the DSL sandbox failing to block certain disallowed inputs (CWE-184). Limiting factors: PR:L means it is not exploitable by fully anonymous remote users, and organizations that do not use versioned settings / Kotlin DSL, or that tightly restrict who can edit build configurations, materially reduce exposure. No user interaction is required once malicious settings are processed (UI:N). |
| Impact | This is a genuine high-priority issue rather than an inflated CVSS score. The vendor-provided CVSS:3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H = 8.8) is internally consistent with the described impact: a sandbox escape in the versioned settings Kotlin DSL that yields code execution on the TeamCity server. The critical honest caveat is PR:L - this is NOT an unauthenticated bug. An attacker needs a valid account with sufficient permission to author or modify versioned settings (Kotlin DSL) for a project, so the realistic threat model is a malicious or compromised project/build engineer, a rogue contributor to a repository whose settings are stored as code, or an attacker who has already phished a developer account. No EPSS score, no CISA KEV listing, and no public POC are present in the supplied data, so there is no evidence of active exploitation or automated weaponization at this time; exploitation status is 'no public exploit identified at time of analysis.' The CWE-184 mapping (incomplete list of disallowed inputs) fits a sandbox that fails to block certain Kotlin constructs. Net: because successful exploitation gives full RCE on a CI/CD server - a high-value software-supply-chain target - defenders running TeamCity with self-service versioned settings should treat this as urgent to patch despite the authentication requirement. |
| Exploit ScenarioDerived | An attacker with a low-privileged TeamCity account that can edit a project's versioned settings commits or supplies a crafted Kotlin DSL configuration that abuses constructs the sandbox fails to disallow. When TeamCity evaluates the DSL, the payload escapes the sandbox and executes arbitrary code in the server process context. No public exploit code was identified in the supplied data, but the attack requires no user interaction once the malicious settings are processed. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 30, 2026
Remote code execution in JetBrains TeamCity (CVE-2026-100253) lets an authenticated attacker with permission to edit a project's versioned settings escape the Kotlin DSL sandbox and execute code on the TeamCity server. Affected versions are those before 2026.2, before 2026.1.4, and before 2025.11.8. No public exploit identified at time of analysis, but this is a genuine high-priority issue rather than an inflated CVSS score because it can compromise a CI/CD server; exploitation requires a low-privileged, non-anonymous account able to supply or commit malicious Kotlin DSL settings.
RemediationAI
Vendor-released patch: upgrade to JetBrains TeamCity 2026.2 or later, 2026.1.4 or later, or 2025.11.8 or later, matching the applicable release branch; see https://www.jetbrains.com/privacy-security/issues-fixed/. If immediate upgrade is not possible, restrict the ability to create or modify project versioned settings and Kotlin DSL configurations to trusted administrators only, and review recent settings-as-code commits for unexpected Kotlin DSL changes. Disabling versioned settings or removing write access for less-trusted projects eliminates the attack path but breaks legitimate settings-as-code workflows and may require manual configuration management. Run the TeamCity server with least privilege, monitor for unusual server-side processes or outbound connections, and use network segmentation so that a compromised TeamCity server cannot freely reach sensitive internal systems. No public exploit identified at time of analysis, so these steps are precautionary but important for an authenticated RCE in CI/CD infrastructure.
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 flaw is in JetBrains TeamCity's versioned settings feature, which stores project configuration as code and evaluates Kotlin DSL scripts on the TeamCity server. CWE-184 (Incomplete List of Disallowed Inputs) indicates the DSL sandbox relies on a denylist that does not block all dangerous constructs, allowing crafted Kotlin DSL configuration to escape the sandbox and execute arbitrary code. The CVSS vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H shows a network-reachable, low-complexity issue requiring low privileges, no user interaction, and high confidentiality, integrity, and availability impact. The CPE string cpe:2.3:a:jetbrains:teamcity:*:*:*:*:*:*:*:* confirms TeamCity as the affected product, and the vendor advisory is available at https://www.jetbrains.com/privacy-security/issues-fixed/.
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:L/UI:N/S:U/C:H/I:H/A:H
Network-reachable CI server, low-privileged authenticated user who can edit versioned Kotlin DSL settings (PR:L), sandbox escape yields full server code execution so C/I/A:H.
Primary rating from Vendor (JetBrains).
CVSS VectorVendor: JetBrains
Lifecycle Timeline
2DescriptionCVE.org
In JetBrains TeamCity before 2026.2, 2026.1.4, 2025.11.8 sandbox escape leading to code execution was possible via the versioned settings Kotlin DSL
Executive ViewAI
JetBrains TeamCity, a critical CI/CD platform, is affected by a high-severity flaw that enables code execution on the build server by an attacker with limited project editing rights. Organizations running versions prior to 2026.2, 2026.1.4, or 2025.11.8 are at risk of supply chain compromise, including unauthorized software modifications and credential exposure. Despite no public exploit identified at time of analysis, the potential for significant operational disruption and reputational damage warrants immediate executive attention.
No vendor-released patch identified at time of analysis. Interim mitigations include: restrict edit permissions for project versioned settings to a minimal set of trusted administrators; enforce multi-factor authentication and least privilege across all TeamCity accounts; segment the TeamCity server network to limit lateral movement; enable and monitor detailed audit logs for suspicious Kotlin DSL modifications or unexpected process execution; and review version control history for unauthorized changes to versioned settings.
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
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
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
EUVD-2026-89997
GHSA-6hq9-538r-6p54
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB