Claude Code is an agentic coding tool that reads and modifies files and runs commands in a development environment. CVE-2026-39861 is a sandbox escape vulnerability affecting versions of Claude Code prior to 2.1.64. A process running inside the sandbox could create a symbolic link to a location outside the workspace, allowing a subsequent file write by Claude Code’s unsandboxed process to reach that location without prompting the user for confirmation. Reliable exploitation requires untrusted content to enter the Claude Code context and trigger sandboxed code execution via prompt injection. Successful exploitation can result in arbitrary file writes outside the workspace and may lead to code execution on the host. Anthropic addressed the vulnerability in version 2.1.64, and users who manage updates manually should update to version 2.1.64 or later. Tags: CVE-2026-39861, Claude Code, Anthropic, Sandbox Escape, Prompt Injection, Symbolic Link, Arbitrary File Write, CWE-22, CWE-61 — 1. Overview Claude Code is an agent-based coding tool capable not only of reading and modifying source code but also of executing commands necessary for the development process. During command execution, it uses a sandbox to restrict file access and network communication, and to control actions that access resources outside the workspace. This report addresses CVE-2026-39861, a symbolic link handling vulnerability discovered in Claude Code’s sandbox. This vulnerability occurs when a non-sandboxed Claude Code process follows a symbolic link created within the sandbox; a successful attack could allow an attacker to write a file to an arbitrary path outside the workspace. CVE-2026-39861 affects versions of Claude Code prior to 2.1.64, and Anthropic has fixed the related issue in version 2.1.64. — 2. Attack Type CVE-2026-39861 is a sandbox escape vulnerability disclosed in April 2026. It is registered in the NVD as a path handling flaw (CWE-22) that allows access to paths outside a restricted directory and a UNIX symbolic link traversal flaw (CWE-61). Sandbox Operation Structure A symbolic link is a mechanism that allows a specific file or directory to be referenced from a different path. Claude Code’s sandbox restricted internal processes from writing files directly outside the sandbox, but it did not sufficiently block the creation of symbolic links pointing to external paths within the sandbox. Since the links themselves are created within the sandbox, the sandbox treated them as writes to permitted paths. Cause of the Vulnerability In this scenario, if a non-sandboxed process in Claude Code writes a file to the path specified by the link, the operating system resolves the symbolic link and performs the write operation at the actual location to which the link points. The key point is that it is not enough to simply verify whether the requested path is within the workspace; it is also necessary to double-check that the final resolved path—after all links have been resolved—is within the same boundary. In the vulnerable version, this verification was insufficient, allowing a write operation that began as a path within the workspace to reach an external file without undergoing any user verification. Consequently, the sandboxed process creates only the link without writing directly to the external file, while the non-sandboxed process writes the file to a path that appears to be within the workspace. While each action individually appears to be within acceptable limits, the combination of these two actions results in a path verification discrepancy that circumvents the sandbox boundary. Attack Flow ***Figure 1_.*CVE-2026-39861 Attack Flow and Sandbox Boundary Bypass Process_ Untrusted content, such as repository files or documents created by an attacker, is included in the Claude Code context. A prompt injection embedded in this content triggers command execution within the sandbox. A Bash process running in the sandbox creates a symbolic link within the workspace that points to a path outside the workspace. Subsequently, when a file-writing function operating outside the sandbox attempts to write to that path, the operating system follows the link and modifies the actual target file outside the sandbox. Exploitation Conditions and Impact This vulnerability cannot be exploited simply by executing Claude Code. An attacker must be able to inject untrusted content into the Claude Code context, and conditions must be met for commands to be executed within the sandbox via prompt injection. If the attack is successful, files outside the workspace can be created or overwritten within the scope of the user account running Claude Code. If shell initialization files, Git hooks, or editor settings are modified, the subsequent code may execute upon the next login or when development tools are launched. If configuration files related to SSH, cloud services, or package repositories are targeted, the scope of the impact could extend to development credentials and the supply chain. The paths listed above are examples intended to illustrate potential impacts; the official advisory did not cite any actual attack cases involving specific files. — 3. Mitigation Measures Patches and Version Verification Anthropic has addressed this vulnerability in Claude Code version 2.1.64. The fix has been automatically deployed to environments using standard automatic updates; in environments where versions are managed manually, you must verify the installed version yourself. You can check your current version and perform a manual update using the following command. claude –version claude update If installed via a package manager such as Homebrew, WinGet, or apk, you must follow the update procedure for each respective package manager. The need to check for updates is not limited to developer devices. The environments listed below often do not receive automatic updates and must be checked separately. Developer devices with Claude Code installed CI/CD runner images with a fixed version Development container definition files Internal package mirrors and offline caches Temporary Workarounds If immediate updates are not feasible, you must restrict Claude Code from accessing untrusted repositories, documentation, issue descriptions, or build logs. If external content must be processed, users should manually review the file writes and shell commands that Claude Code attempts to execute to ensure there are no actions that reference paths outside the workspace or create unexpected symbolic links. In managed environments, ensure that the system does not switch to non-isolated execution when the sandbox is not initialized sandbox.failIfUnavailableset to trueto prevent non-isolated retries of commands that failed due to sandbox restrictions, set sandbox.allowUnsandboxedCommandssetto falseto prevent non-isolated retries of commands that failed due to sandbox restrictions. While these settings do not replace security patches, they help reduce the risk of bypassed execution in environments where sandboxing is mandatory under operational policies. In sensitive development environments, it is recommended to run Claude Code within a development container or a separate virtual environment. In such cases, do not mount critical files—such as the host’s SSH keys or cloud credentials—into the container, and limit external communication to only what is strictly necessary. Verifying Compromise and Post-Incident Measures If there is a history of processing external content using a version prior to the patch, you should check the following items: The actual paths pointed to by symbolic links within the workspace The timestamps and contents of shell initialization files, Git hooks, and SSH and cloud configuration files During a Claude Code session symlink() or symlinkat() any subsequent file writes to the same path following the call The last item can be used as a detection criterion in environments that collect endpoint logs. If suspicious changes are detected, do not stop at file recovery; you must also replace the relevant SSH keys and access tokens. Limitations from a network security perspective This vulnerability does not arise from specific external HTTP requests directly triggering a web server vulnerability, but rather occurs during the file processing of the local Claude Code. Therefore, it is not suitable for direct detection or blocking via web application firewalls based on attack patterns; prioritizing Claude Code updates and endpoint access controls is more important than adding web attack patterns. Read more about [2026.08 Vulnerability Report] Claude Code Sandbox Escape (CVE-2026-39861)[…]

CVE-2026-50522 is a critical unauthenticated Remote Code Execution (RCE) vulnerability in Microsoft SharePoint Server, caused by insecure deserialization of untrusted data via the legacy BinaryFormatter in the WS-Federation token processing endpoint. An unauthenticated remote attacker can post a specially crafted malicious payload to the /_trust/default.aspx endpoint to execute arbitrary code in the context of the SharePoint service account, requiring no credentials and no user interaction (CVSS 3.1: 9.8 Critical). Following the public release of a proof-of-concept (PoC) on July 20, 2026, active exploitation was immediately observed, with attackers targeting SharePoint machine keys to forge persistent authentication tokens that survive even after patching. The MONITORAPP TA team is actively monitoring exploitation attempts and has confirmed that AIWAAP is capable of detecting the malicious deserialization payload pattern in HTTP POST traffic. Tags: CVE-2026-50522, Microsoft SharePoint, Deserialization, RCE, BinaryFormatter, CWE-502, Machine Key Theft, WS-Federation, T1190, Unauthenticated, CVSS 9.8, August 2026, Actively Exploited — 1. Overview Source: Microsoft Security Response Center (MSRC) Microsoft SharePoint Server is an enterprise platform widely used for document management, collaboration, and intranet portal development within organizations, and is currently operated by hundreds of thousands of organizations worldwide. In on-premises deployment environments, it is often directly exposed to the internet, making it a prime target for external attacks. CVE-2026-50522 is a deserialization vulnerability that occurs during the WS-Federation authentication process in SharePoint Server, allowing an unauthenticated remote attacker to send a specially crafted payload to execute arbitrary code on the server (CWE-502). In particular, a successful exploit allows for the theft of the ASP.NET machine key, enabling attackers to re-access the server using forged authentication tokens even after the patch has been applied, resulting in a very broad scope of damage. Following the release of the July 2026 Patch Tuesday updates (July 8), a public proof-of-concept (PoC) emerged on July 20, and actual attacks were confirmed within a few hours. — 2. Attack Types The core vulnerability in CVE-2026-50522 arises when SharePoint Server deserializes user-provided data through the SessionSecurityTokenHandler deserializes user-supplied data via a class, using an outdated BinaryFormatter. BinaryFormatterThis allows for the reconstruction of an arbitrary .NET object graph; consequently, by exploiting a pre-known gadget chain, arbitrary code can be executed during the deserialization process. An attacker can serialize a malicious .NET gadget chain BinaryFormatter disguise the payload as a SecurityContextToken disguise the payload—serialized as a malicious .NET gadget chain—as a cookie value, wrap it as a WS-Federation login response (WSFederationMessage), and send it via an HTTP POST request to a SharePoint /_trust/default.aspx via an HTTP POST request. Since the server deserializes the token before verifying authentication, the payload executes with the server-side service account’s permissions without requiring authentication. Once RCE is achieved, the attacker’s primary target is the **ASP.NET machine key**. The machine key is a secret key used by ASP.NET for encryption and signing—such as form authentication cookies, ViewState, and session tokens—and is stored in plain text in the IIS configuration file (web.config or the registry). An attacker can steal this key with a single request and subsequently forge arbitrary authentication tokens; this is extremely dangerous because re-access remains possible even after a patch is applied unless the key is replaced. In actual attack cases, a pattern has been observed where, following an initial RCE, an attacker uploads a web shell (in ASPX format) to the SharePoint web root to establish a persistent remote access foothold, which subsequently leads to lateral movement within the internal network and the theft of corporate documents and credentials. Example of an attack packet POST /_trust/default.aspx HTTP/1.1 Host: sharepoint.victim.corp Content-Type: application/x-www-form-urlencoded Cookie: SecurityContextToken=<BinaryFormatter_Gadget_Payload_Base64> wa=wsignin1.0 &wresult=<t%3ARequestSecurityTokenResponse+xmlns%3At%3D…> <t%3ALifetime>…</t%3ALifetime> <wsp%3AAppliesTo>…</wsp%3AAppliesTo> <t%3ARequestedSecurityToken> <!– 조작된 SecurityContextToken (BinaryFormatter 역직렬화 페이로드 포함) –> <wsse%3ASecurityContextToken> <wsse%3AIdentifier>urn:uuid:attacker-controlled</wsse%3AIdentifier> </wsse%3ASecurityContextToken> </t%3ARequestedSecurityToken> </t%3ARequestSecurityTokenResponse> &wctx= <– 서버 응답: 가젯 체인 실행 → SharePoint 서비스 계정 권한으로 임의 Read more about [2026.08 Vulnerability Report] Microsoft SharePoint Server Deserialization Remote Code Execution Vulnerability (CVE-2026-50522)[…]

This vulnerability is an RCE vulnerability found in Ivanti Endpoint Manager Mobile. An attacker could attempt an attack by sending a request with a malicious OS command appended to the /mifs/c/appstore/fob/3/ path and executing it. On January 29, 2026, Ivanti issued a security advisory regarding this vulnerability and later released a version that addresses it via the 12.8.0.0 update on May 7. At AIWAF, we are responding to the “2336 / Ivanti EPMM Remote Code Execution” pattern added in the July 2026 pattern update. Tags: CVE-2026-1281, CVE-2026-1340, Ivanti, Ivanti Endpoint Manager Mobile, Ivanti EPMM, Remote Code Execution, Command Injection — 1. Overview Ivanti Endpoint Manager Mobile (EPMM, formerly MobileIron Core) is a UEM (Unified Endpoint Management)/MDM solution that provides unified management and policy enforcement for enterprise mobile devices, such as iOS and Android devices. It offers app deployment, content management, and enterprise resource access control features and is widely used in large organizations. This report summarizes the analysis of the vulnerabilities identified in this system: Ivanti EPMM Pre-Auth RCE: CVE-2026-1281 & CVE-2026-1340. 2. Attack Type This vulnerability is a command injection vulnerability that occurs because the Apache RewriteMap directive, used for mobile app deployment in Ivanti EPMM, passes parameter values from an unauthenticated HTTP endpoint directly to a server-side Bash script (/mi/bin/map-appstore-url, /mi/bin/map-aft-store-url) without authentication, and the script fails to properly validate the received values, leading to a command injection vulnerability. An attacker passes the values contained in the URL path under /mifs/c/appstore/fob/3/ directly as arguments to the Bash script on the server. By manipulating the value of the “h” parameter to take the form of “gPath[malicious OS command], and by setting the value of the `st` parameter to a length that satisfies the validation logic, an attacker can execute malicious commands without authentication. CVE-2026-1281 occurs in endpoints and scripts related to the In-House Application deployment feature (appstore), while CVE-2026-1340 occurs in endpoints and scripts related to the Android File Transfer (aftstore) deployment feature. Attack Request: GET /mifs/c/appstore/fob/3/5/sha256:kid=1,st=theValue ,et=1337133713,h=gPath[`sleep 5`]/e2327851-1e09-4463-9b5a-b524bc71fc07.ipa Host: www.test.com GET /mifs/c/aftstore/fob/3/5/sha256:kid=1,st=theValue%20%20,et=1337133713,h=gPath%5B%60id%20%3E%20/mi/poc%60%5D/13371337-1337-1337-1337-133713371337.ipa HTTP/1.1 Host: www.test.com — 3. Mitigation Measures On January 29, 2026, Ivanti issued a security advisory regarding these vulnerabilities and released interim security patches for each version. Subsequently, on May 7, they released version 12.8.0.0, which resolves these vulnerabilities. Our AIWAF is addressing this vulnerability using the “2336 / Ivanti EPMM Remote Code Execution” pattern, which was added in the July 2026 pattern update. Source: https://hub.ivanti.com/s/article/May-2026-Security-Advisory-Ivanti-Endpoint-Manager-Mobile-EPMM-Multiple-CVEs — 4. Conclusion Ivanti EPMM is a solution widely used by many large enterprises and organizations for mobile device management (MDM/UEM). Regarding the CVE-2026-1281 & CVE-2026-1340 vulnerabilities, detailed information and proof-of-concept (PoC) code have already been disclosed, and attack cases have been confirmed via the CISA KEV; therefore, customers using this system must promptly apply the relevant security patches and update to version 12.8.0.0 or higher. Our TA team is actively monitoring vulnerabilities in Ivanti products and plans to respond promptly to any related vulnerabilities discovered in the future. — 5. Reference https://nvd.nist.gov/vuln/detail/CVE-2026-1281 https://nvd.nist.gov/vuln/detail/CVE-2026-1340 https://labs.watchtowr.com/someone-knows-bash-far-too-well-and-we-love-it-ivanti-epmm-pre-auth-rces-cve-2026-1281-cve-2026-1340/

CVE-2026-63077 is a critical Remote Code Execution (RCE) vulnerability in JetBrains TeamCity On-Premises that allows unauthenticated attackers to bypass authentication via HTTP(S) and execute arbitrary operating system commands. This flaw stems from the uncontrolled deserialization of untrusted data (CWE-502) within the Agent Polling protocol. If successfully exploited, an attacker gains the same privileges as the TeamCity server process, which can lead to the exposure of internal data, stored credentials, and unauthorized server modifications. As TeamCity is a core CI/CD platform, this vulnerability poses a severe threat to software supply chain security. A successful attack could potentially allow threat actors to steal source code, manipulate build artifacts, and compromise the integrity of downstream CI/CD pipelines. Tags: jetbrains, teamcity — 1. Overview CVE-2026-63077 is a critical remote code execution (RCE) vulnerability affecting JetBrains TeamCity On-Premises environments. An attacker targeting a vulnerable TeamCity server accessible via HTTP(S) can bypass the authentication process without separate authentication and execute arbitrary operating system commands. This vulnerability arises from inadequate controls over the deserialization of untrusted data (CWE-502) in TeamCity’s Agent Polling protocol. A successful attack allows the execution of arbitrary operating system commands with the privileges of the TeamCity server process; depending on the permissions granted to that process, this could result in the exposure of internal TeamCity data, configuration information, and stored credentials, or the tampering of the server’s state. In particular, since TeamCity is a CI/CD platform directly involved in the source code build and deployment processes, exploitation of this vulnerability could lead not only to the theft of source code and credentials but also to the tampering of build artifacts and the compromise of the integrity of downstream CI/CD pipelines, potentially causing serious impacts on software supply chain security. Furthermore, as of August 2026, actual attacks and exploitation attempts targeting unpatched TeamCity servers have been confirmed, and CISA has added this vulnerability to its Known Exploited Vulnerabilities (KEV) catalog. — 2. Cause The root cause of this vulnerability lies in the incomplete configuration of the type allowlist in the XStream library, which serializes and deserializes Java objects into XML format. Insecure Deserialization Handling: TeamCity uses the XStream type allowlist to restrict the Java classes that can be deserialized when processing unauthenticated agent requests. However, in the vulnerable version, only TeamCity protocol-related classes were added NoTypePermission.NONEand instead only added classes related to the TeamCity protocol. As a result, XStream’s existing default permissions remained in effect alongside the allowlist defined by TeamCity. Configurable Gadget Chain: The remaining default XStream type permissions Map, Throwablepermissions that encompassed various implementation classes and subclasses, as shown above. An attacker could exploit this by combining methods and callbacks invoked during object creation and deserialization to construct a gadget chain that could lead to arbitrary code execution. In the patched version, before configuring the deserialization allowlist, NoTypePermission.NONEto remove the existing permissions for primitive types and explicitly allow only the classes necessary for TeamCity’s operation. — 3. Key Attack Process The attack flow exploiting CVE-2026-63077 proceeds as follows: 1- Initial Access and Agent Protocol Exploitation: The attacker sends a request to the Agent Polling protocol endpoint of an externally accessible TeamCity server via HTTP or HTTPS. During this process, TeamCity-AgentSessionId the attacker manipulates the request—including agent communication information—to gain unauthenticated access to the vulnerable deserialization processing path. 2- Transmission of Malicious XML Payload: The attacker sends a specially crafted XML payload via a POST request to trigger a gadget chain during the XStream deserialization process. In the disclosed attack technique, the attacker combines the Apache DBCP BasicDataSource, FreeMarker, and the HSQLDB driver included in TeamCity to construct the gadget chain. 3- Executing the Gadget Chain and Generating a JSP File: During the deserialization of the malicious XML, this is invoked through access to FreeMarker’s object properties BasicDataSource.getConnection()is invoked. Subsequently, Apache DBCP creates an in-memory HSQLDB database configured by the attacker and connectionInitSqlsexecutes the SQL contained within it. Finally, by exploiting HSQLDB’s SCRIPT can be exploited to create a malicious JSP file in the TeamCity web root. 4- Remote Command Execution: The attacker accesses the generated JSP file via a separate HTTP request. As the JSP runs on the server side, Runtime.getRuntime().exec() the attacker can use features such as to execute operating system commands specified by the attacker with TeamCity server process privileges. These attacks can be carried out remotely and automatically without requiring user authentication or administrator interaction. Furthermore, since they are accessible over the network and have low attack complexity, there is a high likelihood of rapid exploitation for TeamCity servers exposed to the Internet following the disclosure of this vulnerability. — 4. Impact CVE-2026-63077 is a critical vulnerability rated 9.8 (Critical) under CVSS v3.1. It allows unauthenticated attacks over the network and enables the execution of arbitrary operating system commands with the privileges of the TeamCity server process without user interaction. Furthermore, its inclusion in the U.S. CISA’s Known Exploited Vulnerabilities (KEV) catalog on August 5, 2026, confirms that this vulnerability is currently being exploited in real-world environments. In particular, since TeamCity is a CI/CD platform directly involved in the software build and deployment process, the risk is extremely high because a compromise could extend beyond a single server to affect the integrity of the entire development and deployment environment. Gaining Control of the TeamCity Server: An attacker can execute arbitrary operating system commands and alter the server’s state within the scope of privileges granted to the TeamCity server process. In environments where the server process is granted excessive privileges, the scope of the damage can be even greater. Compromise of CI/CD Supply Chain Integrity: If TeamCity’s build and deployment functions are compromised, build configurations or artifacts may be tampered with, affecting downstream CI/CD pipelines and undermining the reliability of the normal software deployment process. Exposure of Confidential Information and Credentials: Configuration information and various credentials stored in TeamCity may be exposed. Depending on the environment configuration, source repository access information, API keys, deployment accounts, and cloud-related credentials may be exploited in subsequent attacks. This vulnerability has a network-based attack vector, low attack complexity, and does not require special privileges or user interaction. Accordingly, unpatched TeamCity servers exposed to the internet should be classified as high-risk assets requiring immediate inspection and remediation. — 5. Mitigation Measures CVE-2026-63077 is a high-risk vulnerability with confirmed real-world exploitation; applying security patches should be a top priority in affected TeamCity On-Premises environments. If applying the patch immediately is not feasible, the scope of attack exposure must be minimized by using the security plugin provided by JetBrains in conjunction with network access controls. Security Patches and Upgrades: As a top priority, TeamCity servers must be promptly updated to version 2025.11.7 or 2026.1.3 or later, where the vulnerability has been resolved. We recommend upgrading to the latest release version whenever possible to apply additional security patches as well. Applying the Security Patch Plugin: If an immediate version upgrade is not feasible, apply the official Security Patch Plugin provided by JetBrains. This plugin can be used as a temporary mitigation measure for CVE-2026-63077; however, you should prioritize upgrading to the official version whenever possible. Network Access Control: Restrict access so that the TeamCity server is not directly exposed to the internet, and configure firewall and ACL policies to allow access only via a VPN or a trusted internal network. In particular, for TeamCity servers exposed to the public, access policies should be reviewed as a priority to reduce the attack surface. Web Application Firewall (WAF) Detection and Secondary Blocking: In a WAF environment, monitor for abnormal requests entering TeamCity Agent Polling-related endpoints and XML-based deserialization attack patterns. TeamCity-AgentSessionIdTargets for detection can include repetitive abnormal requests, suspicious XML structures, and strings associated with gadget chains. However, since a web application firewall is a secondary defense mechanism, it must be used in conjunction with security patches to address the root cause. Log Review and Breach Verification: In TeamCity server logs, com.thoughtworks.xstream.converters.ConversionException, com.thoughtworks.xstream.security.ForbiddenClassException for exceptions related to the deserialization process. If suspicious requests or evidence of abnormal JSP file creation are found, further breach analysis must be conducted. Least Privilege and Server Segregation: Read more about [2026.08 Vulnerability Report] JetBrains TeamCity Unauthenticated Remote Code Execution Vulnerability (CVE-2026-63077)[…]