Back to Intelligence

CVE-2026-63077: JetBrains TeamCity Unauthenticated RCE Under Active Exploitation — Detection and Remediation Guide

SA
Security Arsenal Team
August 6, 2026
12 min read

Threat actors have begun actively exploiting CVE-2026-63077, a critical unauthenticated remote code execution vulnerability in JetBrains TeamCity, according to reporting from SecurityWeek. If you run TeamCity — on-premises or self-hosted in the cloud — your build infrastructure is a live target right now.

This should set off every alarm bell in your organization. CI/CD servers are among the highest-value assets in any environment: they hold source code, signing keys, deployment credentials, API tokens, and pipeline secrets. An unauthenticated RCE on a build server isn't just a server compromise — it's a potential supply-chain compromise of every artifact that server produces. We saw this play out with the TeamCity CVE-2023-42793 and CVE-2024-27198 campaigns, where ransomware operators and nation-state actors (including APT groups attributed to North Korea and Russia) moved within hours-to-days of disclosure. The exploitation timeline for CVE-2026-63077 appears to be following the same compressed pattern.

If you haven't patched, assume exposure. If you were exposed before patching, assume compromise and hunt.

Technical Analysis

What We Know

AttributeDetail
CVECVE-2026-63077
SeverityCritical
Vulnerability classUnauthenticated remote code execution
Affected productJetBrains TeamCity (self-hosted server)
Exploitation statusConfirmed active exploitation in the wild
Authentication requiredNone — pre-auth RCE

The defining characteristic of CVE-2026-63077 is that it requires no authentication. An attacker who can reach the TeamCity web interface — typically TCP 8111 (default HTTP) or 443/8443 if you've fronted it properly — can execute arbitrary code in the context of the TeamCity server service account. On Windows installs that is frequently SYSTEM or a dedicated service account; on Linux it is whatever user the teamcity service runs as (too often root in poorly managed deployments).

Why the Attack Chain Matters

From a defender's perspective, the exploitation chain for TeamCity RCEs is remarkably consistent across historical campaigns, and your detection strategy should be built around these post-exploitation behaviors:

  1. Initial access: Malicious HTTP request to the TeamCity web listener (teamcity-server process, Java-based).
  2. Code execution: The TeamCity JVM (java.exe / java) spawns a child process — cmd.exe, powershell.exe, /bin/sh, or /bin/bash. This is your single highest-fidelity detection point. A build server JVM shelling out to system interpreters outside of agent contexts is anomalous.
  3. Discovery & credential access: Attackers enumerate build configurations, extract secrets from TeamCity's data directory (.BuildServer, config/projects, system/caches), and harvest environment variables containing deployment tokens.
  4. Persistence: Rogue administrator accounts created via the REST API, malicious build steps injected into existing pipelines, webshells dropped under the webapps directory, or scheduled tasks/services.
  5. Payload staging: Historical TeamCity exploitation has led to ransomware deployment, coin miners, and supply-chain backdoors injected into build artifacts.

Exploitation Status

Per the SecurityWeek reporting, exploitation has already begun — this is not a theoretical or PoC-only situation. Given the precedent of prior TeamCity CVEs being added to CISA's Known Exploited Vulnerabilities catalog within days of active exploitation, monitor the CISA KEV catalog for a formal listing and any associated federal remediation deadline. Do not wait for KEV inclusion to patch — the exploitation clock is already running.

Detection & Response

The detections below target the post-exploitation behaviors described above: the TeamCity JVM spawning shells, webshell placement in the TeamCity directory tree, and suspicious access to the server's secret stores. These are deliberately narrow — they are designed to catch intrusion activity, not normal build behavior.

Sigma Rules

YAML
---
title: TeamCity Server Process Spawning Shell or Script Interpreter
id: 8f2c4a91-3d7e-4b6a-9c15-2e8f0a1d4b6c
status: experimental
description: Detects the TeamCity server Java process spawning command shells or script interpreters, a strong indicator of post-exploitation activity following RCE such as CVE-2026-63077. TeamCity server (not build agents) should rarely spawn interactive shells.
references:
  - https://www.securityweek.com/hackers-start-exploiting-recent-jetbrains-teamcity-vulnerability/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.execution
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\java.exe'
      - '\javaw.exe'
    ParentCommandLine|contains:
      - 'teamcity'
      - 'catalina'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
      - '\curl.exe'
      - '\wget.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Build steps executing on the server agent co-located with the TeamCity server — exclude known build agent service paths
level: high
---
title: Webshell or Script Dropped in TeamCity Web Directory
id: 3b7e1d52-9a4f-4c82-b6d1-5e0f2a8c9d3e
status: experimental
description: Detects creation of executable script or JSP files within TeamCity web application directories, consistent with webshell deployment after exploitation of CVE-2026-63077.
references:
  - https://www.securityweek.com/hackers-start-exploiting-recent-jetbrains-teamcity-vulnerability/
  - https://attack.mitre.org/techniques/T1505/003/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.persistence
  - attack.t1505.003
logsource:
  category: file_event
  product: windows
detection:
  selection_path:
    TargetFilename|contains:
      - '\TeamCity\webapps\'
      - '\TeamCity\work\'
      - '\TeamCity\temp\'
  selection_ext:
    TargetFilename|endswith:
      - '.jsp'
      - '.jspx'
      - '.asp'
      - '.aspx'
      - '.php'
      - '.exe'
      - '.dll'
      - '.ps1'
      - '.bat'
  condition: selection_path and selection_ext
falsepositives:
  - TeamCity upgrades and plugin installations — correlate with maintenance windows
level: high
---
title: Suspicious Process Access to TeamCity Data Directory Secrets
id: 6c1f9e74-2b8a-4d35-a7c9-8f3e1b6d0a42
status: experimental
description: Detects non-TeamCity processes reading files from the TeamCity data directory where configuration, project settings, and stored credentials reside — a hallmark of post-exploitation secret harvesting.
references:
  - https://www.securityweek.com/hackers-start-exploiting-recent-jetbrains-teamcity-vulnerability/
  - https://attack.mitre.org/techniques/T1552/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.credential_access
  - attack.t1552
logsource:
  category: file_event
  product: windows
detection:
  selection:
    TargetFilename|contains:
      - '\.BuildServer\config\'
      - '\.BuildServer\system\'
  filter_legit:
    Image|endswith:
      - '\java.exe'
      - '\javaw.exe'
      - '\TeamCityService.exe'
      - '\MsMpEng.exe'
      - '\MsSense.exe'
  condition: selection and not filter_legit
falsepositives:
  - Backup and EDR agents — tune exclusions to your environment's approved tooling
level: medium

KQL — Microsoft Sentinel / Defender

This query hunts for the core post-exploitation pattern — the TeamCity JVM spawning shells or LOLBins — across both Windows (Defender process events) and Linux (Syslog/CEF ingestion) hosts. Run it over at least the last 14 days to catch pre-patch compromise.

KQL — Microsoft Sentinel / Defender
let lookback = 14d;
let teamcity_parents = dynamic(["java.exe", "javaw.exe", "java", "TeamCityService.exe"]);
let suspicious_children = dynamic(["cmd.exe", "powershell.exe", "pwsh.exe", "mshta.exe", "certutil.exe", "bitsadmin.exe", "curl.exe", "wget.exe", "nc.exe", "sh", "bash", "dash", "python", "python3", "perl", "curl", "wget", "nc", "ncat"]);
union isfuzzy=true
    (DeviceProcessEvents
    | where TimeGenerated > ago(lookback)
    | where InitiatingProcessFileName in~ (teamcity_parents)
       or InitiatingProcessCommandLine has_any ("teamcity", "catalina")
    | where FileName in~ (suspicious_children)
    | project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, AccountName, ReportId),
    (Syslog
    | where TimeGenerated > ago(lookback)
    | where Facility == "user" or Facility == "daemon"
    | where SyslogMessage has_any ("teamcity", "catalina")
    | where SyslogMessage has_any ("/bin/sh", "/bin/bash", "curl", "wget", "python", "nc ")
    | project TimeGenerated, Computer, ProcessName, SyslogMessage)
| order by TimeGenerated desc

A second hunt for network egress from the TeamCity server to uncommon destinations — legitimate servers talk to VCS systems, artifact repositories, and agents, not random internet IPs:

KQL — Microsoft Sentinel / Defender
let lookback = 14d;
DeviceNetworkEvents
| where TimeGenerated > ago(lookback)
| where InitiatingProcessFileName in~ ("java.exe", "javaw.exe", "java")
   and InitiatingProcessCommandLine has_any ("teamcity", "catalina")
| where RemoteIPType == "Public"
| summarize ConnectionCount = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated),
            Destinations = make_set(RemoteUrl, 20), Ports = make_set(RemotePort, 10)
  by DeviceName, RemoteIP
| where ConnectionCount < 50  // low-volume, novel egress is more suspicious than steady CI traffic
| order by FirstSeen asc

Velociraptor VQL

This hunt artifact identifies suspicious child processes of the TeamCity JVM and network connections held by the server process — useful for rapid triage across a fleet of build servers:

VQL — Velociraptor
-- Hunt for suspicious TeamCity server child processes and network connections
-- Relevant to CVE-2026-63077 post-exploitation triage
SELECT Pid,
       Ppid,
       Name,
       Exe,
       CommandLine,
       Username,
       CreateTime
FROM pslist()
WHERE CommandLine =~ '(?i)(cmd\.exe|powershell|pwsh|mshta|certutil|bitsadmin|/bin/sh|/bin/bash|curl |wget |nc -|python)'
  AND Ppid IN (
      SELECT Pid FROM pslist()
      WHERE Name =~ '(?i)java|TeamCityService'
        AND CommandLine =~ '(?i)teamcity|catalina'
  )

A companion artifact for enumerating current network connections from the TeamCity process:

VQL — Velociraptor
-- Enumerate network connections owned by the TeamCity server process
SELECT Pid,
       Name,
       Status,
       Laddr,
       Raddr,
       Family
FROM netstat()
WHERE Pid IN (
    SELECT Pid FROM pslist()
    WHERE Name =~ '(?i)java|TeamCityService'
      AND CommandLine =~ '(?i)teamcity|catalina'
)
  AND Status =~ 'ESTAB|LISTEN'

Verification and Hardening Script

Use this Bash script to inventory TeamCity versions, check exposure, and gather triage artifacts on Linux hosts. For Windows-hosted TeamCity, the equivalent checks are shown in PowerShell.

Bash / Shell
#!/bin/bash
# CVE-2026-63077 triage — identify TeamCity installs, version, and exposure

echo "=== TeamCity process check ==="
ps aux | grep -i [t]eamcity

echo ""
echo "=== TeamCity version (from build.txt / server logs) ==="
find /opt /home /usr/local -maxdepth 4 -iname "build.txt" -path "*TeamCity*" -exec cat {} \; 2>/dev/null
grep -rh "TeamCity (build" /home/*/.BuildServer/logs/teamcity-server.log 2>/dev/null | head -5

echo ""
echo "=== Listening ports (8111 default) ==="
ss -tlnp | grep -E ':(8111|443|8443|80)'

echo ""
echo "=== Firewall exposure of TeamCity listener ==="
iptables -L -n | grep 8111 2>/dev/null || echo "No iptables rules for 8111"

echo ""
echo "=== Suspicious files in TeamCity web/temp dirs (last 14 days) ==="
find /opt/TeamCity/webapps /opt/TeamCity/temp /opt/TeamCity/work \
  -type f \( -name "*.jsp" -o -name "*.sh" -o -name "*.py" \) -mtime -14 2>/dev/null

echo ""
echo "=== Recently modified files in TeamCity data directory ==="
find /home/*/.BuildServer/config -type f -mtime -14 2>/dev/null | head -40

echo ""
echo "=== New local users (last 30 days) ==="
find /etc/passwd -mtime -30 -exec grep -v nologin {} \; 2>/dev/null

echo ""
echo "REMINDER: Patch to the fixed TeamCity build per the JetBrains advisory, then rotate all credentials/secrets stored in TeamCity."
PowerShell
# CVE-2026-63077 triage for Windows-hosted TeamCity servers

Write-Output "=== TeamCity service status ==="
Get-Service | Where-Object { $_.DisplayName -like "*TeamCity*" } | Format-Table Name, Status, StartType -AutoSize

Write-Output "=== TeamCity version ==="
$versionFile = "C:\TeamCity\buildAgent\..\build.txt"
if (Test-Path $versionFile) { Get-Content $versionFile }
Get-ChildItem "C:\Program Files\JetBrains","C:\TeamCity" -Recurse -Filter "version.txt" -ErrorAction SilentlyContinue | ForEach-Object { Get-Content $_.FullName }

Write-Output "=== Network listeners (8111 default) ==="
Get-NetTCPConnection -State Listen | Where-Object { $_.LocalPort -in 80,443,8111,8443 } | Format-Table LocalAddress, LocalPort, OwningProcess -AutoSize

Write-Output "=== Suspicious child processes of java (last 14 days, requires Sysmon) ==="
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-Sysmon/Operational'; Id=1; StartTime=(Get-Date).AddDays(-14)} -ErrorAction SilentlyContinue |
  Where-Object { $_.Message -match 'ParentImage.*java' -and $_.Message -match 'Image.*(cmd|powershell|pwsh|mshta|certutil)' } |
  Select-Object TimeCreated, Message | Format-List

Write-Output "=== Recently modified files in TeamCity web/temp directories ==="
Get-ChildItem "C:\TeamCity\webapps","C:\TeamCity\work","C:\TeamCity\temp" -Recurse -Include *.jsp,*.ps1,*.bat,*.exe -ErrorAction SilentlyContinue |
  Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-14) } |
  Select-Object FullName, LastWriteTime | Format-Table -AutoSize

Write-Output "REMINDER: Apply the fixed TeamCity build per JetBrains, then rotate ALL credentials stored in TeamCity projects and global configuration."

Remediation

Priority 1 — Patch immediately.

  1. Upgrade TeamCity to the fixed build published by JetBrains for CVE-2026-63077. Pull the current patched release directly from the official JetBrains channels: https://www.jetbrains.com/teamcity/download/ and cross-reference the security advisory at https://www.jetbrains.com/security-updates/. If your maintenance subscription is current, TeamCity's in-product update mechanism will surface the fixed build — do not defer it to the next maintenance window.
  2. Build agents need review too. While the vulnerability targets the server, agents inherit trust from it. After patching, force agent re-registration and verify no unauthorized agents have enrolled — rogue agent enrollment was a documented persistence technique in prior TeamCity campaigns.

Priority 2 — Assume compromise and hunt.

If your server was internet-reachable and unpatched during the exploitation window:

  • Run the Sigma/KQL/VQL detections above across a lookback window of at least 14 days.
  • Review TeamCity audit logs (Administration → Audit) for new users, unexpected project modifications, new VCS roots, and global configuration changes.
  • Check for unauthorized REST API tokens and newly created administrator accounts.
  • Inspect running build configurations for injected build steps (curl/wget to unknown hosts, base64 payloads).

Priority 3 — Rotate everything.

Treat every secret TeamCity could access as compromised:

  • Rotate all credentials stored in TeamCity project parameters, VCS roots, and global configuration.
  • Rotate cloud deployment keys, artifact repository tokens, code-signing certificates, and SSH keys used in build steps.
  • Invalidate API tokens issued to users and agents.

Priority 4 — Architectural hardening (do this regardless of patch status).

  • Remove TeamCity from direct internet exposure. Put it behind a VPN, zero-trust access proxy, or IP allow-list. There is no defensible reason for a CI server to be anonymously reachable from the internet.
  • Enforce HTTPS and disable the plain HTTP listener.
  • Enforce MFA for all TeamCity accounts and audit the user list.
  • Restrict outbound egress from the TeamCity server to only required destinations (VCS, artifact repos, license servers).
  • Segment the network. The build server should not be able to reach domain controllers, production databases, or unrelated internal services. Historical TeamCity compromises became enterprise-wide incidents precisely because this segmentation was absent.
  • Deploy EDR and Sysmon on build infrastructure — CI/CD servers are frequently excluded from endpoint coverage because of "performance concerns." That exclusion is exactly what attackers are counting on.

The Bigger Lesson

CVE-2026-63077 is the latest entry in a pattern defenders cannot afford to ignore: CI/CD infrastructure is now a first-tier target class, and exploitation timelines for build-server RCEs are measured in hours, not weeks. If your vulnerability management program treats TeamCity, Jenkins, GitLab runners, and similar infrastructure as "just another internal app," you are structurally blind to your highest-impact attack surface. Inventory your build infrastructure, patch it on an emergency cadence, monitor it like a production crown jewel, and — above all — get it off the internet.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.