CVE-2026-133014 in TeamCityinfo

Summary

by MITRE • 11/19/2026

In JetBrains TeamCity before 2026.2.1, 2026.1.5 remote code execution was possible via public reflection in the Kotlin DSL sandbox

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/21/2026

The vulnerability identified in JetBrains TeamCity versions prior to 2026.2.1 and 2026.1.5 represents a critical security flaw rooted in the improper implementation of access controls within the Kotlin Domain Specific Language (DSL) execution environment. This issue allows for remote code execution, which is among the most severe categories of application vulnerabilities due to its potential for complete system compromise. The core technical deficiency lies in how the sandbox isolates user-supplied scripts from the underlying host operating system and internal service components. While TeamCity employs a Kotlin DSL sandbox intended to restrict script capabilities to safe operations such as build steps or notifications, this isolation mechanism was found to be insufficiently restrictive regarding reflection APIs.

Reflection is a powerful feature in programming languages like Kotlin that allows code to inspect and modify its own structure at runtime. In the context of a secure execution environment, access to reflection must be strictly limited to prevent scripts from bypassing sandbox boundaries. The vulnerability arises because public reflection methods were accessible within the DSL sandbox without adequate permission checks or filtering. An attacker who has been granted permissions to create or edit build configurations can inject malicious Kotlin DSL code that utilizes these unrestricted reflection capabilities. By leveraging reflection, the script can access classes and methods that are normally hidden from user-level scripts, effectively breaking out of the intended execution context.

The operational impact of this vulnerability is severe, as it enables an authenticated attacker with minimal privileges to execute arbitrary commands on the server hosting TeamCity. This capability allows for full control over the build infrastructure, including the ability to steal sensitive data such as source code repositories, credentials stored in environment variables or configuration files, and internal network topology information. Furthermore, because TeamCity often serves as a central hub for development pipelines, compromising it can lead to supply chain attacks where malicious artifacts are injected into builds distributed to downstream consumers. This aligns with the MITRE ATT&CK technique of Command and Scripting Interpreter abuse, specifically focusing on how attackers leverage legitimate system tools or APIs to execute unauthorized code.

From a classification perspective, this vulnerability maps directly to CWE-94 Improper Control of Generation of Code (Code Injection) and CWE-749 Exposed Dangerous Method or Function. The root cause is an access control failure where dangerous methods are exposed in a context that should be restricted. This reflects a common challenge in sandboxing implementations: ensuring that powerful language features do not provide unintended escape paths from the isolated environment. The flaw underscores the importance of principle of least privilege when configuring execution environments, particularly for languages with dynamic capabilities like Kotlin or Java.

Mitigation strategies primarily involve upgrading to TeamCity version 2026.2.1 or later, where JetBrains has addressed this issue by tightening access controls around reflection APIs within the DSL sandbox. Until an upgrade is performed, administrators should enforce strict role-based access control policies, ensuring that only trusted users with high-level privileges can create build configurations involving custom scripts. Additionally, implementing network segmentation to isolate TeamCity servers from critical internal networks and monitoring for unusual outbound connections or process executions originating from the application server can help detect potential exploitation attempts. Regular auditing of script permissions and disabling unnecessary features in the DSL environment further reduces the attack surface available to malicious actors seeking to leverage reflection-based escape vectors.

Responsible

JetBrains

Reservation

11/19/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00711

KEV

no

Activities

very low

Sources

Want to know what is going to be exploited?

We predict KEV entries!