Automated Threat Modeling

Brief Summary: JetBrains TeamCity CVE-2026-133015, Remote Code Execution via Boot Classpath Libraries in the Kotlin DSL Sandbox

A brief summary of CVE-2026-133015, a high-severity (CVSS 8.8) flaw in the JetBrains TeamCity Kotlin DSL sandbox that allowed remote code execution through boot classpath libraries. We cover the published technical facts, the fixed builds 2026.2.1 and 2026.1.5, and how this fits into a series of 2026 sandbox fixes.

CVE Analysis

7 min read

Gaurav Sarraf
Gaurav Sarraf

2026-11-19

Brief Summary: JetBrains TeamCity CVE-2026-133015, Remote Code Execution via Boot Classpath Libraries in the Kotlin DSL Sandbox

Introduction

A recently patched flaw in the JetBrains TeamCity Kotlin DSL sandbox made remote code execution possible through libraries on the boot classpath of the DSL execution environment. TeamCity compiles and runs versioned settings code that anyone with push access to a settings repository can influence. That makes the sandbox one of the main trust boundaries between configuration authors and the CI/CD server itself.

TeamCity is the JetBrains CI/CD platform, used to define and execute build, test and deployment workflows. JetBrains states that it is trusted by 30K+ DevOps teams, naming Amazon Game Studios, Citibank, Samsung and Tesla among them (a vendor-reported figure, not an independent market share measure). Since CI/CD servers sit next to source code, build secrets and deployment paths, weaknesses in how they execute configuration code matter beyond any single project.

Technical information

What was published

The authoritative description, carried by both NVD and the CVE record, reads:

In JetBrains TeamCity before 2026.2.1, 2026.1.5 remote code execution was possible via boot classpath libraries in the Kotlin DSL sandbox

JetBrains, acting as CNA, scores the issue CVSS 3.1 8.8 (High) with the vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. NVD does not supply a separate assessment. The weakness is mapped to CWE-266, Incorrect Privilege Assignment, which MITRE defines as incorrectly assigning a privilege to an actor, creating an unintended sphere of control. In the JetBrains Fixed Security Issues bulletin the bug is tracked as TW-103144, rated High and marked resolved in 2026.2.1,2026.1.5.

How the Kotlin DSL sandbox fits in

TeamCity versioned settings let a project keep its build configuration as Kotlin DSL code (.teamcity/settings.kts) in a VCS repository. To turn that code into configuration, TeamCity has to compile and run it before applying the result. JetBrains documents two places this can happen:

  • On the TeamCity server, inside a sandbox (the SANDBOX execution mode)
  • On a free build agent (the ON_AGENT execution mode)

JetBrains explicitly describes the server sandbox as not entirely isolated. Its intended restrictions include preventing:

  • Reads outside the parent .teamcity directory
  • Network calls
  • Subprocess launches
  • Native library loading
  • Reflection into internal or JDK classes

Whoever can push to the settings repository controls the code TeamCity executes. The sandbox is what keeps those configuration authors from acting with the privileges of the server process.

Root cause

The official description names the mechanism (boot classpath libraries) and the CWE names the class of failure (privilege assignment). Read together, they indicate that libraries on the boot classpath of the DSL execution environment were given more privilege than the sandbox meant to allow. Code supplied through the DSL could therefore lean on those trusted libraries to perform operations the sandbox was supposed to block, ending in arbitrary code execution. The fix in 2026.2.1 and 2026.1.5 corrects that privilege assignment so boot classpath code no longer works as a route around the sandbox.

This is an interpretation built from the description and the CWE mapping. JetBrains has not published implementation details, and the CVE does not say which of the sandbox restrictions listed above an exploit defeats.

The CWE mapping also differs from an earlier 2026 sandbox fix. CVE-2026-106218 was filed under CWE-184 (incomplete list of disallowed inputs), which is a blocklist problem. CVE-2026-133015 is filed under CWE-266. That change suggests this round dealt with which code is trusted inside the sandbox rather than adding one more banned API to a list.

What the CVSS vector establishes

  • Attack Vector: Network. Network reachability is enough for this metric. It does not imply the server must be internet facing.
  • Attack Complexity: Low. No specialized access conditions are assumed.
  • Privileges Required: Low. Some privileges are needed, but the specific TeamCity role or permission is not identified.
  • User Interaction: None. No other user has to act.
  • Scope: Unchanged, with High confidentiality, integrity and availability impact.

The score rates severity and does not estimate the probability of exploitation. It also does not identify the request format, required repository access, target endpoint or operating system account used after exploitation.

Conceptual attack flow

Based on the published description, the CVSS vector and the documented sandbox design, the attack shape looks like this:

  1. An attacker holds low privileges in the TeamCity environment and is able to supply Kotlin DSL code that TeamCity will evaluate (for example, through a versioned settings repository). The CVE record does not confirm repository commit access as the exact prerequisite.
  2. TeamCity compiles and runs the DSL inside the server-side Kotlin DSL sandbox.
  3. The supplied code uses libraries on the sandbox boot classpath, which carry more privilege than the sandbox intended.
  4. Through those libraries, the code escapes the sandbox restrictions and executes arbitrary code, with the high confidentiality, integrity and availability impact reflected in the score.

The specific libraries, the call sequence, the required TeamCity permission and any indicators of compromise remain undisclosed.

Patch information

JetBrains fixed CVE-2026-133015 in two TeamCity bug fix releases for on-premises installations, both released on October 5, 2026:

  • 2026.2.x branch: fixed in 2026.2.1 (build 239120). Affected range: 2026.2 up to, but not including, 2026.2.1.
  • 2026.1.x and earlier: fixed in 2026.1.5 (build 222949). Affected range: every version before 2026.1.5.

No separate fix was released for older major lines such as 2025.11.x, so anyone on an older line needs to move to one of the two builds above or a later supported release.

A few practical notes from the JetBrains release material:

  • The fixed builds are available through TeamCity automatic update, the JetBrains download page, or updated Docker images.
  • Builds in the same major series share a data format, so you can upgrade or downgrade within a series without a backup and restore. JetBrains still recommends backing up before major upgrades.
  • The release notes do not name the CVE. They state that 2026.2.1 fixes 41 security problems and 2026.1.5 fixes 27, and point to the security bulletin, which JetBrains says is usually published a few days after release. These are per-release counts and should not be summed as unique vulnerabilities.
  • The fix shipped on October 5, 2026, ahead of CVE publication on November 19, 2026. That ordering does not by itself indicate a zero day or any exploitation timeline.

Limits of the public evidence. TeamCity is closed source, so there is no public commit, diff or pull request for this fix. The tracker issue TW-103144 is not public, and a YouTrack API request for it returns "not found". The only fix artifacts available are the fixed binaries.

Each sandbox fix closes one path. Being on a build that fixed an earlier sandbox CVE does not cover this one, and being on 2026.2.1 or 2026.1.5 does not cover a later sandbox CVE.

Additional hardening from JetBrains documentation. The reviewed records provide no configuration-only workaround, plugin or WAF rule for this identifier. JetBrains security notes do describe general measures that reduce exposure and impact. These are layers on top of the upgrade, not substitutes for it:

  • Run the TeamCity server and agent processes with the minimal required permissions.
  • Keep versioned settings in a separate repository, with commit access limited to a small set of users. JetBrains warns that a malicious developer with access to versioned settings can modify configuration or expose secrets.
  • Limit access to the server machine and the TeamCity Data Directory, and enable and review access logs (no CVE-specific log signature is published).

JetBrains also generally recommends compiling Kotlin DSL on build agents, since the code then runs on a separate machine away from the main server. The documented tradeoffs are that agent execution occupies build capacity, can add hosting cost, can be slower while waiting for an agent, and is not subject to the server sandbox restrictions. Switching execution modes is not confirmed as a standalone remediation for this CVE.

Affected systems and versions

  • JetBrains TeamCity 2026.2, up to but not including 2026.2.1
  • JetBrains TeamCity, all versions from 0 up to but not including 2026.1.5, as encoded in the CVE record. This includes the 2026.1.x line before 2026.1.5 and older major lines such as 2025.11.x.

The vulnerable component is the Kotlin DSL sandbox used to evaluate versioned settings. The reviewed records do not state whether installations that only compile DSL on agents are unaffected, and they do not establish any exemption for TeamCity Cloud.

Vendor security history

A pattern of Kotlin DSL sandbox fixes in 2026. The JetBrains bulletin lists several earlier, separately patched sandbox issues:

  • CVE-2026-65906 (TW-101634), fixed in 2026.1.2 and 2025.11.6
  • CVE-2026-100253 (TW-101840), a sandbox escape through versioned settings Kotlin DSL, fixed in 2026.2, 2026.1.4 and 2025.11.8
  • CVE-2026-106218 (TW-102046), filed under CWE-184, fixed in 2026.1.3 and 2025.11.7

CVE-2026-133015 is the latest in that sequence, and the first of these listed with a privilege assignment classification rather than a blocklist one.

Exploitation history of other TeamCity flaws. TeamCity vulnerabilities have attracted real attackers before:

  • CVE-2023-42793, an authorization bypass through insecure handling of specific paths resulting in arbitrary code execution. CISA reports exploitation from September 2023 by the Russian Foreign Intelligence Service (SVR), also tracked as APT29 and NOBELIUM/Midnight Blizzard.
  • CVE-2026-63077, unauthenticated remote code execution through the agent polling protocol. JetBrains reports active and attempted exploitation against unpatched servers, without naming an actor.

Status of this CVE. As of November 19, 2026, an exact search of the CISA Known Exploited Vulnerabilities catalog for CVE-2026-133015 returns no result, and the NVD and CVE records name no campaign, threat actor or public exploit. That absence is a gap in intelligence and does not show that exploitation cannot occur. The earlier incidents involve different mechanisms and should not be used to attribute activity to this CVE, but they do explain why timely installation of TeamCity fixes is worth prioritizing.

References

Detect & fix
what others miss

Works with
  • GitHub
  • GitLab
  • Bitbucket
  • Azure DevOps Services
  • Gerrit
  • CVS
  • Jira
  • Linear
  • Slack
  • Security Compass
Explore integrations
Security magnifying glass visualization