CVE-2026-106218: 
JetBrains TeamCity vulnerability analysis and mitigation

CVE-2026-106218 is a Kotlin DSL sandbox escape vulnerability in JetBrains TeamCity that allows authenticated attackers to execute arbitrary code on the server. It affects TeamCity versions before 2025.11.7 and versions 2026.1.1 through 2026.1.3 (fixed in 2026.1.3). The vulnerability was published on October 6, 2026. It carries a CVSS v3.1 base score of 10.0 (Critical) per NVD, though the GitHub Advisory and ENISA rate it 8.8 (High) with a lower-privilege required vector (GitHub Advisory, JetBrains).

The root cause is classified as CWE-184 (Incomplete List of Disallowed Inputs), meaning TeamCity's Kotlin DSL sandbox fails to enumerate and block all potentially dangerous inputs or constructs, allowing an attacker to escape the sandbox boundary. An authenticated user with low-level privileges can craft a malicious Kotlin DSL build configuration script that bypasses the sandbox restrictions and executes arbitrary code directly on the TeamCity server process. The attack is network-based, requires no user interaction, and has low attack complexity, making it straightforward to exploit once access to the Kotlin DSL configuration feature is available (GitHub Advisory, JetBrains).

Successful exploitation grants an attacker full remote code execution on the TeamCity server with system-level permissions, resulting in complete compromise of confidentiality, integrity, and availability. An attacker could exfiltrate source code, build artifacts, secrets, and credentials stored in TeamCity; tamper with build pipelines to inject malicious code into software supply chains; or disrupt CI/CD operations entirely. The scope change in the NVD CVSS vector reflects that a compromised TeamCity server can impact resources beyond the application itself, including downstream build targets and connected infrastructure (GitHub Advisory).

As of the time of disclosure, there is no public proof-of-concept exploit and no evidence of in-the-wild exploitation (Feedly). The NVD SSVC assessment classifies exploitation as "none" and automatable as "no," indicating that exploitation requires some level of authenticated interaction. The EPSS score is approximately 0.27–0.28%, placing it in the 19th percentile for exploitation likelihood within 30 days. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog at this time (GitHub Advisory).

1. Reconnaissance: Identify internet-facing JetBrains TeamCity instances running versions prior to 2025.11.7 or between 2026.1.1 and 2026.1.3 using tools like Shodan or Censys, or by checking the TeamCity version endpoint.
2. Obtain low-privileged access: Authenticate to the TeamCity server using any valid low-privileged user account (e.g., a developer account with access to project configuration).
3. Access Kotlin DSL configuration: Navigate to a project's build configuration and enable or access the Kotlin DSL settings, which allow defining build pipelines using Kotlin scripts.
4. Craft sandbox escape payload: Write a malicious Kotlin DSL script that exploits the incomplete input blocklist (CWE-184) to reference or invoke restricted Java/Kotlin APIs or runtime constructs that are not properly blocked by the sandbox.
5. Trigger execution: Save and trigger the build configuration, causing the TeamCity server to evaluate the Kotlin DSL script outside the intended sandbox, executing arbitrary code with the permissions of the TeamCity server process.
6. Achieve objectives: Use the RCE foothold to exfiltrate credentials, pivot to connected systems, or inject malicious artifacts into the build pipeline (GitHub Advisory, JetBrains).

• Logs: Unusual or unexpected Kotlin DSL script execution events in TeamCity server logs (teamcity-server.log), particularly scripts invoking Java runtime APIs (e.g., Runtime.exec, ProcessBuilder) or file system operations outside normal build paths.
• Process: Unexpected child processes spawned by the TeamCity server JVM process (e.g., cmd.exe, /bin/bash, curl, wget, powershell) that are not associated with legitimate build agents.
• Network: Outbound connections from the TeamCity server to unknown external IP addresses or domains, especially on non-standard ports, initiated by the server process rather than build agents.
• File System: New or modified files in the TeamCity installation directory, data directory, or temp folders that are not associated with a legitimate update or build artifact; presence of web shells or reverse shell scripts.
• Build Configuration: Unexpected modifications to Kotlin DSL build configuration files, especially those containing obfuscated or encoded strings, or references to system-level APIs.

JetBrains has released patched versions: 2025.11.7 and 2026.1.3. Organizations should upgrade to one of these versions immediately. As a temporary workaround if patching is not immediately possible, restrict access to Kotlin DSL configuration features to trusted users only, and consider disabling Kotlin DSL build configurations entirely until the patch is applied. Monitor TeamCity server logs for suspicious Kotlin DSL execution patterns as an additional detection measure (JetBrains, GitHub Advisory).

Coverage of CVE-2026-106218 appeared across security aggregation sites and social media shortly after disclosure, including posts on Bluesky and articles on SecurityOnline and Daily Security Review noting the critical nature of the sandbox escape (SecurityOnline, Daily Security Review). A dev.to post provided guidance for decision-makers on contextualizing the risk without overstating it, and another discussed the technical mechanics of the Kotlin DSL sandbox escape. Community sentiment reflects concern given JetBrains TeamCity's history of high-severity vulnerabilities and its role in CI/CD pipelines, though the absence of a public PoC has tempered urgency somewhat.