Loading vulnerability…
CVE-2026-63077 is a critical deserialization of untrusted data vulnerability in JetBrains TeamCity On-Premises. Affected versions prior to 2026.1.3 and 2025.11.7 improperly handle attacker-controlled data in the agent polling protocol, allowing unauthenticated remote code execution over HTTP or HTTPS. The vulnerable code path deserializes XML supplied to the agent communication endpoints under /app/agents/v1, including the error-handling flow that processes agent command failure data. The issue stems from unsafe XStream configuration: TeamCity applied an allowlist without first clearing XStream’s default permissions, leaving broad type hierarchies deserializable and enabling gadget-based exploitation. Public technical analysis indicates exploitation can begin by registering an agent session, obtaining a server-issued agent session identifier, and then submitting crafted XML that triggers deserialization and a gadget chain leading to arbitrary operating system command execution with the privileges of the TeamCity server process.
Mallory correlates every CVE against your assets, your vendors, and active adversary campaigns. Know which vulnerabilities matter for you, not just which ones are loud.
What it means. What to do now. Patch path, mitigations, and the assume-compromise checklist.
What an attacker gets, and what they’ve been doing with it.
If you can’t patch tonight, do this now.
Patch, then assume compromise.
2 valid exploits after Mallory filtered fakes, detection scripts, and README-only repos (2 hidden).
Repository contains a Python proof-of-concept exploit (exploit.py) and a descriptive README. The exploit targets JetBrains TeamCity On-Premises CVE-2026-63077, described as an unauthenticated deserialization flaw in the agent polling protocol leading to remote code execution. The code is standalone Python using only the standard library, with exploit.py as the clear entry point. Core exploit flow: it generates random identifiers/tokens, builds an agent registration XML document with a spoofed agent address 127.0.0.1:9090, obtains a temporary TeamCity agent session, then submits a crafted XML payload to /app/agents/v1/commands/error. The payload appears designed to abuse server-side deserialization and HSQLDB scripting behavior to write a JSP file into a relative web root path ../webapps/ROOT/<random>.jspws. That JSP is a one-shot scriptlet that executes an attacker-supplied command via bash -c, returns stdout/stderr in the HTTP response, appends a response token for success detection, and attempts to delete itself after first execution. The exploit then requests the generated JSP path over HTTP(S), checks for the expected token in the response, strips HSQLDB-related wrapper text from output, and records successful command results to result.txt. The README documents single-target and multi-target usage, notes disabled TLS verification, and highlights operational limitations such as dependence on bash and the hard-coded web-root path. Overall, this is a real offensive PoC for unauthenticated network/web exploitation that provides arbitrary command execution rather than mere detection.
Repository contains a single Python proof-of-concept exploit and a README. The main file, CVE-2026-63077.py, targets JetBrains TeamCity CVE-2026-63077 and performs unauthenticated RCE through TeamCity agent polling functionality. The exploit flow is: generate randomized identifiers; build synthetic agent registration XML; register to /app/agents/v1/register; craft a malicious XStream gadget graph that instantiates an HSQLDB datasource and uses connectionInitSqls to create a table, insert a JSP scriptlet, and write it into the TeamCity webroot as a randomized .jspws file; submit that XML to /app/agents/v1/commands/error with TeamCity session headers; then request the dropped JSPWS path to execute the attacker-supplied OS command. The JSP payload is intentionally one-shot: it sets an application guard attribute, deletes its own source file, launches Runtime.exec(command), and prints a random token only if execution reaches that point. The README documents usage, expected output, and the underlying gadget chain. Overall, this is a real exploit PoC rather than a scanner: it provides direct command execution capability but does not include a reusable interactive shell framework or payload customization beyond the supplied command string.
Products and vendors Mallory has correlated with this vulnerability. Open in Mallory to drill down to specific CPE configurations and version ranges.
Vendor-confirmed product mapping. Mallory continuously reconciles this list against your asset inventory.
234 sources tracked across advisories, community write-ups, and news. New activity surfaces here as Mallory finds it.
An unauthenticated remote code execution vulnerability in JetBrains TeamCity, exploited via an XStream deserialization payload and demonstrated to yield SYSTEM-level code execution.
A deserialization of untrusted data vulnerability affecting JetBrains TeamCity.
A critical unauthenticated remote code execution vulnerability in JetBrains TeamCity caused by unsafe deserialization in the agent polling protocol due to an incorrect XStream allowlist configuration.
Unknown
Query your assets running an affected version, and investigate the blast radius.
Every observed campaign linking this CVE to a named adversary.
Malware families riding this exploit, with evidence and IOCs.
YARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Cross-references every affected SKU, including bundled OEM variants.
Community discussion across Reddit, Mastodon, and other social sources.