CVE-2026-63077

Executive Summary

CVE-2026-63077 is a critical unauthenticated remote code execution vulnerability in JetBrains TeamCity, affecting versions prior to 2026.1.3 and prior to 2025.11.7. The flaw exists within the agent polling protocol, allowing an unauthenticated attacker to send specially crafted requests that lead to arbitrary code execution on the TeamCity server. With a CVSS score of 9.8, the vulnerability is highly exploitable and poses a severe risk to confidentiality, integrity, and availability. No public proof‑of‑concept or exploit code has been released at the time of writing, but the potential for weaponisation is high. Immediate upgrading to the fixed versions is strongly recommended, along with strict network segmentation and monitoring.

CVSS Breakdown & Threat Level

• CVSS Base Score: 9.8 (Critical)
• Attack Vector: Network (AV:N) – exploitable remotely
• Attack Complexity: Low (AC:L) – no special conditions required
• Privileges Required: None (PR:N) – unauthenticated
• User Interaction: None (UI:N) – no user action needed
• Scope: Unchanged (S:U)
• CIA Impact: High/High/High (C:H/I:H/A:H)
• EPSS Score: 0.0% – currently low exploitation probability but expected to rise

Deep Dive & Mechanics

The vulnerability resides in the agent polling protocol, a mechanism used by TeamCity build agents to communicate with the server. The endpoint responsible for handling poll requests (typically /app/agents/poll) fails to enforce authentication checks for certain operations. An attacker can craft a malicious HTTP request that triggers a deserialization or command injection flow, ultimately resulting in remote code execution under the context of the TeamCity server process.

Key technical points:

• Agent Polling Protocol: Build agents periodically poll the server for tasks. The request structure includes agent ID, build configuration, and command payloads that are processed with insufficient validation.
• Authentication Bypass: The vulnerable code path does not verify the session token or API key, allowing unauthenticated attackers to reach the polling handler.
• Injection / Deserialization Flaw: The protocol uses a serialized data format (e.g., Java serialization, XML, or JSON) that is deserialized without proper sanitisation, enabling runtime code execution.

Vulnerable vs. Patched Code

While the exact code diff is not publicly available, the fix involves:

• Authentication Enforcement: Adding mandatory checks for a valid agent token or session before processing any polling request.
• Input Sanitisation: Stripping or escaping dangerous content from the payload before deserialization.
• Protocol Hardening: Switching to a more secure, non‑serialized communication channel (e.g., gRPC with TLS mutual authentication).

Vulnerable pattern (simplified):

// Vulnerable – no auth check
public void processPollRequest(HttpServletRequest req) {
    ObjectInputStream ois = new ObjectInputStream(req.getInputStream());
    AgentPollData data = (AgentPollData) ois.readObject();
    executeCommand(data.getCommand());
}

Patched pattern (simplified):

// Patched – authentication enforced
public void processPollRequest(HttpServletRequest req) {
    if (!validateAgentToken(req)) throw new SecurityException();
    ObjectInputStream ois = new ObjectInputStream(req.getInputStream());
    AgentPollData data = (AgentPollData) ois.readObject();
    if (!sanitize(data.getCommand())) throw new SecurityException();
    executeCommand(data.getCommand());
}

Exploitation & Lab Setup

Red Team

1. Reconnaissance: Identify TeamCity instances using Shodan (Product: TeamCity, Server: TeamCity).
2. Endpoint Discovery: Scan for /app/agents/poll or similar endpoints. Use curl -v http://target:8111/app/agents/poll to check response.
3. Craft Payload: Construct a malicious agent poll request. Since no public exploit is available, research possible deserialisation gadgets (e.g., CommonsCollections) or command injection points in the polling protocol.
4. Execute:

   curl -X POST http://target:8111/app/agents/poll \
     -H "Content-Type: application/x-java-serialized-object" \
     --data-binary @payload.bin
   

5. Post‑exploitation: Achieve interactive shell (reverse shell via netcat/powershell), escalate privileges, and move laterally within the CI/CD pipeline.

Blue Team

1. Network Segmentation: Place TeamCity servers behind a firewall; restrict inbound access to only trusted IP ranges.
2. Web Application Firewall (WAF): Deploy rules to block anomalous POST requests to /app/agents/poll – especially those with abnormal content types or lengthy payloads.
3. Monitoring: Enable detailed HTTP request logging for the agent poll endpoint. Alert on:
   • Requests without expected agent authentication headers.
   • Payloads containing Java serialisation objects (AC ED 00 05).
   • Multiple failed requests from same source IP.
4. Honeypot: Set up a fake agent polling service that alerts on any unauthorised access attempts.

Indicators of Compromise (IOCs)

• Network:
  • HTTP POST requests to /app/agents/poll (or similar) with no Authorization header.
  • Packets containing Java serialisation magic bytes 0xAC 0xED 0x00 0x05.
• Host:
  • Unusual child processes spawned from the TeamCity Java process (e.g., cmd.exe, /bin/bash, python).
  • Files in the TeamCity installation directory with suspicious timestamps.
  • New reverse shell connections outgoing to unknown IPs.
• Logs:
  • teamcity-agent-poll.log (if enabled) showing unauthorised access attempts.
  • catalina.out (Tomcat logs) containing SecurityException or ClassNotFoundException for deserialisation gadgets.

Detection Engineering

YARA Rule

rule CVE_2026_63077_JetBrains_TeamCity_AgentPoll_AuthBypass {
    meta:
        description = "Detect malicious requests to TeamCity agent poll endpoint"
        author = "Valters IT"
        date = "2025-04-14"
        cve = "CVE-2026-63077"
    strings:
        $s1 = "/app/agents/poll" ascii wide nocase
        $s2 = "POST" ascii wide
        $magic = { AC ED 00 05 }
    condition:
        $s1 and $s2 and (uint16(0) == 0x0A0D or $magic)
}

Sigma Rule

title: CVE-2026-63077 - JetBrains TeamCity Agent Poll RCE Attempt
id: 9f8e3b7a-12d4-4c6e-8d9f-1a2b3c4d5e6f
status: experimental
description: Detects unauthenticated POST requests to TeamCity agent poll endpoint with potential deserialisation payloads
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2026-63077
author: Valters IT
date: 2025/04/14
tags:
    - attack.initial_access
    - attack.t1190
logsource:
    category: web_server
    product: apache
    service: access_combined
detection:
    selection:
        cs-method: POST
        cs-uri-stem:
            - '/app/agents/poll'
            - '/app/agents/*'
        sc-status: 200
        cs(User-Agent):
            - '*curl*'
            - '*python*'
            - '*wget*'
    condition: selection
falsepositives:
    - Legitimate agent polling with valid authentication
    - Automated monitoring tools
level: high

Suricata Rule

alert http $HOME_NET any -> $EXTERNAL_NET $HTTP_PORTS (
    msg:"CVE-2026-63077 - Possible JetBrains TeamCity Agent Poll RCE";
    flow:to_server,established;
    content:"POST"; http_method;
    content:"/app/agents/poll"; http_uri;
    pcre:"/(AC\:ED\:00\:05|java\.io\.ObjectInputStream)/Pi";
    classtype:attempted-admin;
    sid:20260414;
    rev:1;
    priority:1;
)

Remediation & Mitigation

1. Immediate Upgrade: Update TeamCity to version 2026.1.3 or 2025.11.7 (depending on your branch). This is the only definitive fix.
2. Workaround (if patching is delayed):
   • Block external access to the /app/agents/poll endpoint using a WAF or reverse proxy.
   • Enforce IP whitelisting for known build agent addresses.
   • Disable the agent polling protocol entirely if not needed.
3. Compromise Assessment: If no patch can be applied, assume breach. Conduct forensic analysis of TeamCity logs, server processes, and network connections. Rotate all secrets and credentials stored in TeamCity.
4. Long‑term Hardening:
   • Enable Mutual TLS (mTLS) for agent‑server communication.
   • Replace serialisation‑based protocols with REST/JSON over HTTPS.
   • Implement a Security Information and Event Management (SIEM) solution to correlate agent polling events.

Valters IT
Secure CI/CD & Threat Intelligence