Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain low-privileged TeamCity account
-
DeliveryReach TeamCity web/API endpoint
-
ExploitRequest parameters of out-of-scope build config
-
ExecutionServer skips authorization check
-
PersistReceive sensitive build parameters
-
ImpactReuse leaked secrets against downstream systems
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization checks on every request
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Attacker must hold a valid authenticated TeamCity account with at least low-privilege access (PR:L in the CVSS vector), so the server must be reachable by the attacker and they must possess or obtain working credentials - for example a developer, contractor, build-agent service account, or any role created via SSO/LDAP that grants basic TeamCity login. The target TeamCity server must be running an on-premises version prior to 2026.1 with build configurations that contain parameters worth disclosing (passwords, tokens, environment values). Exploitation is limited by the requirement for prior authentication and by whether the deployment exposes the TeamCity API to the attacker's network position; purely internal, network-isolated TeamCity instances with tightly controlled accounts present a smaller realistic attack surface than internet-exposed or contractor-accessible servers. |
| Impact | The CVSS vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L describes a remote, low-complexity attack requiring only low privileges and no user interaction, which is realistic for a multi-tenant CI server where many developers, contractors, and service accounts hold basic project-viewer roles. Confidentiality impact is rated High because build parameters routinely include secrets that pivot to production systems, while the Low integrity and availability impacts reflect that the underlying weakness is disclosure rather than direct write or denial of service. EPSS and CISA KEV status were not provided in the input, so widespread automated exploitation cannot be confirmed; however, TeamCity has historically been a high-value target (prior CVEs have appeared in KEV), so defenders should not treat the absence of exploitation telemetry as proof of low real-world risk. The tag 'Authentication Bypass' in the source data is slightly misleading - the CVSS PR:L and the description point to broken authorization for already-authenticated users, not unauthenticated bypass; this discrepancy should be verified against the vendor advisory before scoping exposure. |
| Exploit ScenarioDerived | A contractor or compromised developer account with only a basic project-viewer role on one team's project authenticates to the TeamCity REST API and issues a parameter-enumeration request against a build configuration belonging to a different, higher-privileged project. Because the authorization check is missing, the server returns the parameter values - including deployment credentials and cloud API tokens - which the attacker then uses to pivot into production infrastructure outside TeamCity. No public exploit identified at time of analysis, but the low attack complexity means a working request can be constructed once the vulnerable endpoint is identified. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 29, 2026
Information disclosure in JetBrains TeamCity prior to version 2026.1 allows authenticated low-privilege users to read sensitive build configuration parameters they should not have access to due to missing authorization checks. The flaw carries a CVSS 7.6 score driven by high confidentiality impact on a network-reachable CI/CD server, though no public exploit identified at time of analysis. Because TeamCity build parameters frequently contain secrets such as deployment credentials, signing keys, and API tokens, the disclosure can cascade into broader compromise of downstream systems.
RemediationAI
Vendor-released patch: TeamCity 2026.1 - upgrade on-premises servers to 2026.1 or later as the primary fix, following the JetBrains upgrade guidance referenced from https://www.jetbrains.com/privacy-security/issues-fixed/. Where immediate upgrade is not feasible, reduce blast radius by auditing and tightening project-level role assignments so that only trusted users hold any project role, rotating any secrets that were stored as TeamCity parameters (deployment keys, registry credentials, signing tokens, cloud API keys) since they must be assumed disclosed, and moving high-value secrets out of build parameters into an external secrets manager fetched at build time with short-lived tokens. As a network-layer compensating control, restrict TeamCity web UI and REST API access to a VPN or SSO-gated reverse proxy to shrink the pool of accounts that can authenticate at all; the trade-off is added friction for remote contributors and CI integrations that call the REST API directly.
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
JetBrains TeamCity is a widely deployed continuous integration and build management server where build configurations carry parameters (typed values, passwords, environment variables, system properties) intended to be scoped by project-level role assignments. The root cause is CWE-862 Missing Authorization, meaning the server accepts a request to view or enumerate configuration parameters without verifying that the requesting account holds the permission required for the target project or build configuration. In TeamCity's permission model, parameters can be marked as 'password' type which masks them in the UI, but the underlying API surface must still enforce role-based access; when an authorization check is omitted at that layer, even masked secrets and project-private parameters can be returned to lower-privileged callers. The CPE confirms the affected product is the TeamCity application itself rather than a plugin or agent, and the issue affects all versions prior to 2026.1.
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:L/A:L
Primary rating from Vendor (JetBrains) · only source for this CVE.
CVSS VectorVendor: JetBrains
Lifecycle Timeline
2DescriptionCVE.org
In JetBrains TeamCity before 2026.1 improper permission checks exposed build configuration parameters
Executive ViewAI
JetBrains TeamCity contains an information disclosure vulnerability allowing any authenticated user to access sensitive build configuration parameters containing deployment credentials, API tokens, and cryptographic keys. Since these credentials are frequently reused across production systems, unauthorized disclosure creates direct risk to the security posture of downstream infrastructure and applications. Organizations running TeamCity for CI/CD should immediately audit and remediate how sensitive credentials are stored and accessed.
Restrict build parameter visibility through role-based access controls; implement immediate credential rotation; migrate secrets to external secret management solutions (HashiCorp Vault, AWS Secrets Manager, Azure Key Vault); enable comprehensive audit logging on parameter access; enforce principle of least privilege for all CI/CD system accounts.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
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-33382
GHSA-pqrm-v5f6-j44f
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB