Threat Intelligence Report Archives | SECaaS Platform AIONCLOUD

[2026.09] Threat Intelligence Report

Status of High-Risk Vulnerabilities No. Vulnerability No. (CVE) Content CVSS Risk Level 1 CVE-2026-72898 Metabase Unauthenticated SQL Injection 10 CRITICAL 2 CVE-2026-58231 SAP Commerce Cloud Unauthenticated Code Injection 10 CRITICAL 3 CVE-2026-48362 Adobe ColdFusion OS Command Injection 10 CRITICAL 4 CVE-2026-18051 W3 Total Cache Unauthenticated Arbitrary File Write 10 CRITICAL 5 CVE-2026-74253 Joomla Sourcerer Unauthenticated Read more about [2026.09] Threat Intelligence Report[…]

[2026.09 Vulnerability Report] Adobe Commerce RCE (CVE-2026-75650)

CVE-2026-75650, dubbed “StyleSmuggler,” is a maximum-severity (CVSS 10.0) unauthenticated Remote Code Execution vulnerability in Adobe Commerce, Adobe Commerce B2B, and Magento Open Source. An attacker injects malicious PHP code through the template engine’s `styles` property—which bypasses all built-in security validation—causing it to be written to disk and later executed when Magento’s dependency-injection scanner processes a “Payment Transaction Failed” email template. No authentication, no user interaction, and no email delivery are required for code execution. Active exploitation was confirmed in the wild on September 4, 2026, three days before Adobe released the emergency hotfix (APSB26-146), making this a true zero-day. Observed post-exploitation activities include the deployment of a Rust-based Linux backdoor disguised as a system process and PHP web shells. The vulnerability has been added to CISA’s Known Exploited Vulnerabilities (KEV) catalog, and the MONITORAPP TA team has confirmed that AIWAAP can detect the malicious template injection payload in HTTP traffic. Tags: CVE-2026-75650, StyleSmuggler, Adobe Commerce, Magento, Template Injection, CWE-1336, RCE, Zero-Day, CVSS 10.0, CISA KEV, Rust Backdoor, Web Shell, T1190, September 2026, Actively Exploited — 1. Overview Read more about [2026.09 Vulnerability Report] Adobe Commerce RCE (CVE-2026-75650)[…]

[2026.09 Vulnerability Report] FuelCMS Remote Code Execution (CVE-2026-30457)

This is a Remote Code Execution (RCE) vulnerability found in FuelCMS. An attacker can execute arbitrary code by sending malicious PHP code via the `data` parameter of the `/fuel//preview?module=blocks&field=view` endpoint. Although the vulnerability was reported to the vendor, no patch has been released yet. AIWAAP plans to address this issue with the “2342 / Daylight Studio FuelCMS Remote Code Execution” pattern, which will be included in the September 2026 pattern update. Tags: CVE-2026-30457, FuelCMS, Daylight Studio, Dwoo, PHP Code Execution, Remote Code Execution, Code Injection — 1. Overview FuelCMS (Daylight Studio) is an open-source content management system (CMS) based on PHP CodeIgniter that provides functionality for managing content such as pages, blocks, and navigation. This report summarizes the analysis of the CVE-2026-30457 vulnerability discovered in FuelCMS. — 2. Attack Vector This vulnerability allows an attacker to execute arbitrary PHP code by exploiting a validation flaw in the Dwoo template parser—which is designed to prevent the injection of malicious PHP code into FuelCMS—specifically a failure to validate backslash characters, thereby bypassing the Dwoo string constraints. An attacker /fuel//preview?module=blocks&field=view send malicious PHP code containing backslashes via the endpoint’s `data` parameter, thereby bypassing the Dwoo template parser to execute the code. For example, if the string `{assign(aaa\ ‘bbb’)}` is sent in the `data` parameter, the backslash escapes the single quote (`’`) in the string, causing the safe value “’aaa\’“ to be expanded to “’aaa\’, ‘“, and the subsequent string “bbb” is interpreted as a T_STRING object, recognized as PHP code, and executed. Attack Request: POST /fuel//preview?module=blocks&field=view HTTP/1.1 Content-Length: 167 Content-Type: multipart/form-data; boundary=PieBoundary123456789012345678901234567 Host: www.test.com User-Agent: HTTPie –PieBoundary123456789012345678901234567 Content-Disposition: form-data; name=”data” {assign(aaa\’. die(`id`));//’)} –PieBoundary123456789012345678901234567– — 3. Mitigation Measures FuelCMS has not been updated for approximately four years. Although Pentest-Tools, the research team that discovered this vulnerability, reported it, no related patch had been released as of September 23, 2026. At AIWAAP, we plan to address this issue with the “2342 / Daylight Studio FuelCMS Remote Code Execution” pattern, which Read more about [2026.09 Vulnerability Report] FuelCMS Remote Code Execution (CVE-2026-30457)[…]

[2026.09 Vulnerability Report] Analysis of GitLab Unauthenticated Arbitrary File Read Vulnerability (CVE-2026-85706)

CVE-2026-85706 is a critical path traversal vulnerability (CWE-22) found in the widely used DevOps platforms GitLab Community Edition (CE) and Enterprise Edition (EE). Remote attackers can read arbitrary local files accessible to the GitLab server process by sending specially crafted HTTP(S) API requests without requiring authentication. This vulnerability stems from insufficient file path validation and missing authentication checks within the GitLab Repository Commits API. A successful attack could expose sensitive server-side information—such as system settings, GitLab configuration files, secrets, database credentials, and SSH keys—potentially leading to further system compromise through the use of leaked credentials or encryption keys. In particular, the exposure of core internal secrets, such as secret\_key\_base, could enable session forgery and privilege escalation, thereby expanding the scope of the impact across the entire GitLab environment. This vulnerability has been assigned the maximum CVSS v3.1 score of 10.0 (Critical); CISA confirmed active exploitation in September 2026 and added the vulnerability to its Known Exploited Vulnerabilities (KEV) catalog. Tags: gitlab, cve-2026-85706 — 1. Overview CVE-2026-85706 is a severe path traversal (CWE-22) vulnerability discovered in GitLab Community Edition (CE) and Enterprise Edition (EE), widely used DevOps platforms. A remote attacker can send a maliciously crafted HTTP(S) API request without any authentication to read arbitrary local files accessible to the GitLab server process. This vulnerability arises from insufficient file path validation and missing authentication checks in the GitLab Repository Commits API. A successful attack could expose critical internal server information, such as system configuration files, GitLab configuration files, secrets, database credentials, and SSH keys, and could lead to further system compromises using leaked credentials or encryption keys. In particular, if core GitLab secrets—such as `secret_key_base`—are exposed, session forgery and privilege escalation become possible, potentially expanding the scope of damage across the entire GitLab environment. This vulnerability was rated 10.0 (Critical)—the highest score under CVSS v3.1—and CISA confirmed its exploitation in September 2026, adding it to the Known Exploited Vulnerabilities (KEV) catalog. — 2. Cause This vulnerability arises from a combination of two flaws: the GitLab Repository Commits API references user-supplied paths without validation, and the file-handling logic executes before authentication checks. The interaction of these two flaws allows an unauthenticated remote attacker to read arbitrary files on the server. 2-1. Insufficient File Path Validation The GitLab Repository Commits API references the `file.path` value provided by the client when processing files to be included in a commit. In the normal processing flow, GitLab Workhorse stores the uploaded file as a temporary file and sets the path to that value. However, the API does not verify whether the path passed via `file.path` is located within an allowed repository or the temporary file area. Consequently, if an attacker directly specifies an absolute path on the server in the request, GitLab will open and process the file specified by the attacker—located on the server—instead of the intended upload file. 2-2. Issue with Authentication Check Order In the vulnerable API processing flow, user authentication checks are performed after file processing. In other words, the system first opens and reads the file at the path specified in the request before verifying whether the requester is an authenticated user. Due to this sequence, even requests without a valid user session or access token pass through the file-reading stage before being blocked by the authentication check. Consequently, an attacker can reach the vulnerable file-processing logic without a separate account or prior permissions. 2-3. Combination of the Two Flaws Although the two flaws described above do not constitute complete vulnerabilities on their own, when they coexist, they lead to unauthenticated file reading through the following processing flow. An attacker sends a request containing a manipulated path GitLab opens and reads the file without validating the path Although authentication checks are performed after the file is read, the file has already been read Under certain conditions, part or all of the read file’s contents are returned via the API response If path validation had been in place, the request would have been blocked in Step 2; if authentication checks had been performed first, it would have been blocked in an earlier step. However, because these two flaws overlap, the request is not filtered out at any point and leads to file exposure. — 3. Key Attack Process The attack flow exploiting CVE-2026-85706 proceeds as follows. While this vulnerability itself is limited to read-only access, it can escalate to subsequent attacks through exposed credentials. Scanning for Target Instances and Accessing Vulnerable APIs: The attacker scans for GitLab Self-Managed instances exposed to the internet to identify vulnerable versions. They then target public projects that can be read anonymously—without requiring a separate user login or access token—and access the Repository Commits API and Files API (POST /api/v4/projects/{id}/repository/commits, POST/PUT …/repository/files/{file_path}). Sending Malicious API Requests via File Path Manipulation: The attacker specifies an arbitrary local file path on the server—rather than a legitimate upload path—in the request’s `file.path` parameter. In the normal processing flow, GitLab Workhorse overwrites this value with a safe temporary file path; however, the attacker bypasses Workhorse’s preprocessing by percent-encoding static segments of the URL path (e.g., representing the “c” in “commits” as %63) and passes the forged `file.path` value directly to the Rails handler. Targeted files may include system configuration files, GitLab configuration files, and secret information. Loading Internal Server Files and Information Disclosure: A vulnerable GitLab server reads the local file with GitLab process privileges before performing authentication checks, without verifying whether the provided file path exists within an allowed directory. Subsequently, if a parsing error occurs while the file contents are being processed as request parameters, part or all of the file’s contents may be included in the error response and exposed to the attacker. Follow-up Attacks and System Compromise Based on Stolen Information: An attacker can analyze the exposed GitLab configuration information, database credentials, secret keys, or other authentication information to carry out further attacks. In particular, if critical secret information—such as `secret_key_base`—is exposed, this could escalate to session or credential forgery, account takeover, or the acquisition of administrative privileges. Furthermore, there is a possibility that the stolen credentials could be used to exploit features such as CI/CD pipelines or Runners, leading to remote code execution (RCE) and server takeover. — 4. Impact CVE-2026-85706 is a critical vulnerability rated 10.0 (Critical) under CVSS v3.1, the highest possible score. Since it allows access to files within the GitLab server without additional authentication, the impact can extend beyond simple information exposure to account compromise, privilege escalation, and compromise of the CI/CD environment. Leakage of Core Server Confidential Information and Secrets: Attackers can steal sensitive information—such as system configuration files, GitLab secrets, database credentials, SSH keys, deployment tokens, and CI/CD variables—that are accessible with GitLab server process privileges. In particular, if the /etc/gitlab/gitlab-secrets.json file—which is specifically targeted by the publicly available exploit code—is exposed, the encryption keys contained in this file could be used to decrypt other secrets stored by GitLab, potentially leading to a cascading increase in damage. Potential for Follow-up Attacks and System Compromise: Leaked secret keys, authentication information, or database credentials serve as the foundation for additional attacks, such as account takeover, session spoofing, and access to internal services. As a result, the scope of the breach may extend beyond the exposure of a single file to encompass the entire GitLab server and its associated internal infrastructure. It is important to note that while the patch blocks future file reads, it does not invalidate secrets that have already been leaked; therefore, the risk persists until potentially exposed credentials are revoked and reissued. Compromise of CI/CD Supply Chain Integrity: Since GitLab is used as a core platform for source code management and build and deployment automation, if an attacker gains control of a repository or CI/CD pipeline, the attack can escalate into a software supply chain attack, including source code tampering, modification of deployment scripts, credential theft, and tampering with build artifacts. Confirmed Exploitation (CISA KEV Listing): On September 11, 2026, CISA added CVE-2026-85706 to its Known Exploited Vulnerabilities (KEV) catalog and required federal agencies to complete remedial actions by September 14. Security firm watchTower reported observing scans across the internet beginning at 06:00 (UTC) on September 11 and subsequently confirmed that activity had progressed beyond simple detection to actual exploitation and the exfiltration of sensitive files. According to data compiled by the ShadowServer Foundation, as of the time of this report, thousands of exposed servers remain vulnerable, and vulnerable versions of GitLab Self-Managed environments exposed to the internet face a widespread risk of exploitation. — 5. Mitigation Measures Since CVE-2026-85706 is a Critical-rated vulnerability currently being exploited in real-world attacks, organizations operating GitLab Self-Managed environments must prioritize applying the official security patch. 5-1. Security Patches and Version Updates Upgrade immediately to the official security update version provided by GitLab. The fix versions for each affected version are as follows. GitLab 19.3.x users: Update to 19.3.2 or later GitLab 19.2.x users: Update to version 19.2.6 or later GitLab 18.7–19.1.x users: Update to version 19.1.8 or later Read more about [2026.09 Vulnerability Report] Analysis of GitLab Unauthenticated Arbitrary File Read Vulnerability (CVE-2026-85706)[…]

[2026.08] Threat Intelligence Report

Status of High-Risk Vulnerabilities No. Vulnerability No. (CVE) Content CVSS Risk Level 1CVE-2026-48276Adobe ColdFusion Arbitrary File Upload RCE10CRITICAL 2CVE-2026-48286Adobe Campaign Classic Authorization Bypass RCE10CRITICAL 3CVE-2026-10134IBM Langflow OSS Code Injection10CRITICAL 4CVE-2026-50160Hoppscotch Mass Assignment Authentication Bypass10CRITICAL 5CVE-2026-48316Adobe ColdFusion Improper Input Validation RCE10CRITICAL 6CVE-2026-57572Crawl4AI Docker API Argument Injection RCE10CRITICAL 7CVE-2026-15409SonicWall SMA1000 Server-Side Request Forgery10CRITICAL 8CVE-2026-16812Arista VeloCloud Orchestrator On-Prem Read more about [2026.08] Threat Intelligence Report[…]

[2026.08 Vulnerability Report] Claude Code Sandbox Escape (CVE-2026-39861)

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)[…]

[2026.08 Vulnerability Report] Microsoft SharePoint Server Deserialization Remote Code Execution Vulnerability (CVE-2026-50522)

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)[…]

[2026.08 Vulnerability Report] Ivanti EPMM Remote Code Execution (CVE-2026-1281, CVE-2026-1340)

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/

[2026.08 Vulnerability Report] JetBrains TeamCity Unauthenticated Remote Code Execution Vulnerability (CVE-2026-63077)

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)[…]

[2026.07 Vulnerability Report] Trends and Mitigation Strategies for High-Risk Joomla Vulnerabilities

Joomla is an open-source content management system (CMS) that helps users efficiently build and manage websites and content. While its adoption rate is relatively low in Korea, it is widely used overseas on a variety of websites, including those of corporations, public institutions, and educational organizations. Joomla allows users to add functionality not only through its core features but also via various extensions such as components, modules, and plugins. While this extension structure offers the advantage of increased flexibility and convenience, unmanaged extensions or environments where security updates have not been applied can become major attack vectors. Recently, various vulnerabilities—including file upload exploits, authentication bypasses, inadequate access controls, and remote code execution—have been continuously discovered in both the Joomla core and third-party extensions. Some of these vulnerabilities, if successfully exploited, can lead to the installation of web shells, the compromise of administrative privileges, data breaches, and service disruptions, necessitating a swift response. — 1. Overview Joomla is an open-source content management system (CMS) that supports the efficient creation and management of websites and content. While its adoption is relatively low in Korea, it is widely used overseas on various websites, including those of corporations, public institutions, and educational institutions. Joomla allows users to add functionality not only through its core features but also via various extensions such as components, modules, and plugins. While this extension structure offers the advantage of increased flexibility and convenience, unmanaged extensions or environments where security updates have not been applied can become major attack vectors. Recently, various vulnerabilities—including file upload exploits, authentication bypasses, inadequate access controls, and remote code execution—have been continuously discovered in both the Joomla core and third-party extensions. Some of these vulnerabilities, if successfully exploited, can lead to the installation of web shells, the compromise of administrator privileges, data breaches, and service disruptions, necessitating a swift response. This report examines recently disclosed high-risk Joomla vulnerabilities and their key characteristics, and proposes necessary security checks and response measures for Joomla operating environments. — 2. Recent Vulnerability Trends 2.1 Ongoing Discovery of Vulnerabilities Various security vulnerabilities have been continuously discovered in both the Joomla core and third-party extensions. Major vulnerability types include arbitrary file upload, remote code execution, authentication bypass, privilege escalation, and inadequate access controls. Joomla is structured to add functionality by installing various extensions, such as components, modules, and plugins. Consequently, not only the Joomla core but also third-party extensions serve as major attack surfaces. In particular, if extensions that provide file upload or administrative functions lack adequate authorization and input validation, attackers can upload malicious PHP files or web shells to take control of the server. 2.2 Key Features Increased Risk from Third-Party Extensions There has been an increase in cases where serious vulnerabilities are discovered in third-party extensions rather than in the Joomla core. Extensions that are no longer updated or have been neglected for a long time are unlikely to receive security patches, requiring even greater caution. Recurring File Upload Vulnerabilities Vulnerabilities allowing executable files to be uploaded due to insufficient validation of file extensions, MIME types, and storage paths have been repeatedly identified. These vulnerabilities can directly lead to the installation of web shells and remote code execution. Identification of Vulnerabilities Exploitable Without Authentication Some vulnerabilities can be exploited directly from the outside without requiring a separate account or user interaction. Vulnerable Joomla sites exposed to the internet are highly likely to become targets of automated scans and attacks once a vulnerability is disclosed. Need for Integrated Management of Core and Extensions Even if the Joomla core is kept up to date, the entire system may remain vulnerable to attack if vulnerable extensions are installed. Therefore, the versions, support status, and usage of both the core and extensions must be managed together. — 3. Major High-Risk Vulnerabilities This section analyzes representative examples of recent Joomla vulnerabilities that can be exploited without authentication or that could lead to serious consequences, such as remote code execution and privilege escalation. 3.1 CVE-2026-57827: RSFiles Arbitrary File Upload CVE-2026-57827 is an arbitrary file upload vulnerability discovered in the RSFiles extension for Joomla. An unauthenticated attacker can upload executable files to the server, which could lead to remote code execution. A successful attack could enable the installation of a web shell, website defacement, theft of system information, and the execution of additional malware. The vulnerability is highly dangerous because it allows attacks over the network without requiring a separate account or user interaction. CVSS Score: CVSS v4.0 9.3 (Critical) – CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H Exploitation Conditions: Unauthenticated Vulnerability Type: Arbitrary File Upload Main Impact: Remote Code Execution and Server Takeover (RCE & Server Takeover) Related CWE: CWE-434 (Unrestricted Upload of File with Dangerous Type) 3.2 CVE-2026-56291: Balbooa Forms Arbitrary File Upload CVE-2026-56291 is an arbitrary file upload vulnerability discovered in the Balbooa Forms extension for Joomla. An unauthenticated attacker can upload executable files, and a successful attack can lead to remote code execution. Features such as Balbooa Forms, which allow external users to enter data or attach files, are highly likely to be directly exposed to the internet. If you are using a vulnerable version, the public file upload feature could be exploited to install a web shell and compromise the server. CVSS Score: CVSS v4.0 9.3 (Critical) – CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H Exploitation Conditions: Unauthenticated Vulnerability Type: Arbitrary File Upload Main Impact: Webshell Installation and Remote Code Execution (Webshell & RCE) Related CWE: CWE-434 (Unrestricted Upload of File with Dangerous Type) 3.3 CVE-2026-56290: Page Builder CK Arbitrary File Upload CVE-2026-56290 is a vulnerability discovered in the Page Builder CK extension for Joomla. An unauthenticated attacker can upload executable files, and executing these uploaded files can lead to remote code execution. Content creation extensions, such as Page Builder, include functionality for handling images and media files. If validation of file types and executability is insufficient, the normal upload functionality can be exploited as a path to compromise the server. CVSS Score: CVSS v4.0 9.3 (Critical) – CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H Exploitation Conditions: Unauthenticated Vulnerability Type: Arbitrary File Upload & Improper Access Control Main Impact: Malware Execution & System Takeover Related CWE: CWE-284 (Improper Access Control) 3.4 CVE-2026-48907: Improper Access Control in JCE Editor CVE-2026-48907 is an access control vulnerability discovered in the JCE Editor extension for Joomla. Unauthenticated users can create new editor profiles and use them to upload and execute PHP code. This vulnerability is an example where a privilege verification issue, combined with the file upload functionality, leads to remote code execution. A successful attack could not only result in the tampering of website content but also allow access to internal server information and establish a foothold for further attacks. Read more about [2026.07 Vulnerability Report] Trends and Mitigation Strategies for High-Risk Joomla Vulnerabilities[…]