May 7, 2026·7 min read·42 visits
A malicious version (5.0.2) of the intercom/intercom-php package was published via a compromised GitHub tag. It uses a malicious Composer plugin to automatically execute code during installation, exfiltrating local secrets and environment variables. All organizations that installed this version must immediately rotate all potentially exposed credentials.
The intercom/intercom-php package on Packagist was subjected to a supply chain compromise by the TeamPCP threat actor group. Attackers published a malicious package version (5.0.2) utilizing a Composer plugin to achieve arbitrary code execution upon installation, resulting in the exfiltration of environment variables and sensitive credentials to an external command-and-control server.
The vulnerability tracked as GHSA-GR3R-CRP5-QRRM represents a direct supply chain compromise of the intercom/intercom-php package, a widely utilized PHP binding for the Intercom API. Threat actors successfully gained unauthorized access to the repository's publishing pipeline and released a malicious version tagged as 5.0.2. This attack is attributed to the "Mini Shai-Hulud" campaign operated by the TeamPCP group.
The attack vector leverages the Packagist ecosystem's integration with GitHub for version tagging. The threat actors pushed the 5.0.2 tag containing an altered composer.json file. This file reconfigured the package type from a standard library to a Composer plugin. The modified package metadata instructed the Composer package manager to execute untrusted PHP code automatically upon installation or update.
This incident is classified under CWE-506 (Embedded Malicious Code) and CWE-912 (Supply Chain Compromise). The malware targets the developer environment or the Continuous Integration/Continuous Deployment (CI/CD) pipeline running the Composer process. The primary objective of the embedded payload is the immediate exfiltration of sensitive configuration files and environment variables to an external infrastructure.
The compromise of intercom-php occurred simultaneously with a similar attack against the intercom-client npm package (version 7.0.4). This cross-ecosystem strategy indicates a coordinated effort to target environments utilizing Intercom developer tools, maximizing the probability of successful credential harvesting across diverse technology stacks.
The root cause of this vulnerability lies in the compromise of maintainer credentials combined with the inherent execution privileges granted to Composer plugins. Attackers obtained sufficient authorization to push signed tags to the official GitHub repository, which Packagist automatically synchronized and published to the broader PHP ecosystem.
Composer plugins are a deliberate feature of the PHP package manager designed to extend its core functionality. When a package is defined with "type": "composer-plugin" in its composer.json file, Composer loads and executes the plugin's code within its own runtime during the lifecycle events, such as init, pre-install-cmd, and post-install-cmd. This design assumes explicit trust between the developer and the package maintainer.
The threat actors exploited this trust model by embedding malicious logic within the plugin initialization class. Because Composer operations frequently run with the privileges of the developer user or the CI/CD service account, the executing malware inherits extensive access to the local filesystem and the host's environment variables. The system lacks native sandboxing or permission boundaries for executing plugins.
Once the authentication boundary was breached, the technical mechanism relied entirely on the abuse of intended functionality. The system functioned exactly as designed, prioritizing automated extensibility over execution restrictions. This lack of runtime isolation for dependency lifecycle hooks remains a systemic weakness in modern package managers.
The attack mechanics center on the structural modification of the composer.json file introduced in the malicious 5.0.2 tag. A standard PHP library configuration was replaced with a plugin configuration requiring automatic initialization. Below is an illustrative comparison of the metadata structure.
// Standard Package Configuration
{
"name": "intercom/intercom-php",
"type": "library",
"autoload": {
"psr-4": { "Intercom\\": "src/" }
}
}
// Malicious Plugin Configuration
{
"name": "intercom/intercom-php",
"type": "composer-plugin",
"extra": {
"class": "Intercom\\Plugin\\MaliciousInit"
},
"autoload": {
"psr-4": { "Intercom\\": "src/" }
}
}The extra.class directive instructs Composer to instantiate the specified PHP class immediately upon loading the package. The malicious class implements the Composer\Plugin\PluginInterface and utilizes the activate method to execute its primary payload before the developer or build system interacts with the codebase.
The payload executes a targeted search across the host filesystem for high-value configuration files. It systematically reads files such as .env, .aws/credentials, and .kube/config. It also captures the runtime environment using the PHP getenv() function. The collected data is concatenated, encoded, and transmitted via an HTTP POST request to a remote command-and-control server operated by TeamPCP.
Because the malicious code is invoked during the resolution and installation phase, the exfiltration occurs prior to any application-level testing or runtime execution. The developer only needs to issue a standard command like composer require intercom/intercom-php or composer update to trigger the complete execution chain.
The exploitation flow requires no direct interaction beyond the routine management of application dependencies. The process begins when an automated system or a developer resolves the package graph for a project depending on intercom/intercom-php. If the constraints allow for version 5.0.2, Composer retrieves the artifact from Packagist.
During the extraction phase, the Composer runtime parses the composer.json file and identifies the package as a plugin. It loads the autoloader and invokes the plugin's entry point. This phase happens synchronously within the console session, often delaying the output of the terminal slightly while the HTTP request to the C2 server completes.
The attack completes its primary objective in seconds. The exfiltrated payload typically contains AWS Access Keys, database connection strings, GitHub Personal Access Tokens, and internal API keys. These credentials are subsequently weaponized by the threat actors for secondary intrusions, privilege escalation within cloud environments, or further supply chain compromises.
This vector bypasses traditional perimeter defenses because the outbound network connection originates from a trusted host (a developer workstation or an established CI runner) and utilizes standard web protocols (HTTPS). Security controls focusing solely on incoming traffic or application-layer vulnerabilities provide no visibility into this execution path.
The impact of installing version 5.0.2 of intercom-php is an immediate and total compromise of confidentiality for the affected environment. The malicious plugin achieves arbitrary code execution with the permissions of the user running the Composer process. In CI/CD environments, this often includes administrative access to deployment targets and access to highly privileged service principals.
The exfiltration of environment variables and credential files provides the attackers with persistent access to the victim's infrastructure. With stolen AWS credentials, attackers can provision unauthorized resources, access private S3 buckets, or manipulate Route53 DNS records. With stolen database credentials, they can extract or destroy customer data.
The secondary impact involves lateral movement across the software supply chain. If the compromised developer account holds publishing rights to other internal or external packages, the attackers can inject similar malware into downstream dependencies. This cascading effect was a primary goal of the Mini Shai-Hulud campaign.
Due to the automated nature of the exploitation and the severe consequences of credential theft, this vulnerability carries a functional severity equivalent to a CVSS 10.0. The lack of authentication required to deliver the payload, combined with the high privileges of the target process, maximizes the overall risk profile for any affected organization.
The immediate remediation step is the absolute removal of the 5.0.2 version from all environments. Organizations must audit their composer.lock files across all repositories to verify if the 5.0.2 tag was ever resolved and installed. If the version is detected, it must be downgraded to a known safe version (e.g., 4.x) or upgraded to a secure version released post-incident.
If evidence suggests that version 5.0.2 was executed on any system, organizations must assume a total compromise of all secrets accessible to that system. This requires the immediate rotation of all environment variables, database passwords, AWS IAM keys, and API tokens present on the affected developer workstations or CI/CD runners. Failure to rotate these credentials leaves the infrastructure vulnerable to persistent access, even after the malicious package is removed.
To mitigate future supply chain risks, organizations should implement strict version pinning in dependency management. Relying on exact versions in composer.json and rigidly enforcing the use of composer.lock during deployments prevents unexpected automated upgrades to malicious tags. Furthermore, limiting the network egress of CI/CD environments to a strict allowlist prevents the successful exfiltration of data to unauthorized C2 domains.
Maintainers of open-source projects must enforce Two-Factor Authentication (2FA) on all repository and registry accounts. Limiting the lifespan of API tokens and employing automated secrets scanning within the repository can prevent the initial account takeover that facilitates these supply chain attacks.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
intercom/intercom-php Intercom | 5.0.2 | Removed from registry; use alternative verified versions. |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-506 / CWE-912 |
| Attack Vector | Supply Chain / Malicious Package |
| CVSS Score | 10.0 (Critical) |
| Execution Context | Composer Plugin Lifecycle |
| Primary Impact | Credential Exfiltration |
| Exploit Status | Active Exploitation (Remediated) |
Embedded Malicious Code executing within the package manager lifecycle.
A path traversal vulnerability (CWE-22) in termux-sync prior to version 1.2.4 allows an attacker to overwrite arbitrary files within the Termux environment during the backup restoration process. The flaw stems from the application trusting attacker-controlled extraction paths defined in the backup's manifest.json file, failing to validate archive members against directory traversal sequences during tar extraction, and using unsanitized backup names when constructing temporary directories. If a user restores a malicious backup archive from local storage, shared folders, GitHub, or Google Drive, an attacker can overwrite sensitive configuration files such as shell startup scripts or local binaries, resulting in arbitrary code execution under the privileges of the Termux user.
SpamScope mail-parser versions 3.8.0 prior to 4.6.0 contain a path traversal vulnerability (CWE-22) within the write_attachments() and write_sample() functions. The library passes untrusted attachment filenames directly into os.path.join() without stripping directory components, validating path containment, or verifying symbolic links. An attacker can send a crafted email containing relative path traversal sequences or absolute filesystem paths in the Content-Disposition header to write or overwrite arbitrary files accessible to the parsing process.
A Regular Expression Denial of Service (ReDoS) vulnerability exists in SpamScope mail-parser versions 4.2.0 prior to 4.6.1. Two separate regular expressions evaluated during standard email header parsing exhibit quadratic to cubic backtracking complexity when processing headers padded with whitespace or angle brackets. An unauthenticated remote attacker can exploit this flaw by sending a small, RFC-compliant email message, causing parsing worker threads or processes to stall at 100% CPU utilization for extended periods.
CVE-2026-129297 is an origin validation vulnerability (CWE-345) in the Python library mail-parser prior to version 4.6.2. The MailParser.get_server_ipaddress() method fails to properly isolate MTA-recorded client IP addresses from sender-controlled text within email Received headers. Due to naive substring delimiter matching, appearance-based regular expression scanning, and fail-open header traversal, remote attackers can spoof their originating IP address to bypass email security controls, blocklists, and anti-spam attribution.
CVE-2026-129299 (GHSA-24mq-4vc6-2prf) is a parsing and serialization flaw in SpamScope mail-parser prior to version 4.6.2. The library uses reflective Python attribute resolution (getattr) over untrusted email header names and applies caller convenience transformations (such as underscore-to-hyphen folding and _json/_raw suffix stripping) directly to wire headers. An unauthenticated remote attacker can send crafted emails that trigger uncaught TypeError exceptions during JSON serialization or cause security-relevant headers and body content to be silently dropped without setting defect indicators.
CVE-2026-129236 is a command-line argument injection vulnerability (CWE-88) in Kubeshark, an eBPF-based network observability tool for Kubernetes. Located within the Model Context Protocol (MCP) server implementation in cmd/mcpRunner.go, the flaw occurs when handling the start_kubeshark tool request. When the MCP server runs with the --allow-destructive flag, the callStartKubeshark function appends the caller-supplied pod_regex parameter directly to the kubeshark tap argument slice without an end-of-options (--) delimiter. Because Kubeshark uses the Cobra and pflag libraries for command-line parsing, any pod_regex value prefixed with a hyphen is interpreted as a CLI flag rather than a positional regular expression. An attacker capable of influencing MCP tool arguments, such as through indirect prompt injection against a connected Large Language Model (LLM) agent, can inject the --set flag to override Helm chart values like tap.docker.registry. Because Kubeshark deploys its worker DaemonSet with privileged security contexts and host networking enabled, redirecting the container image registry allows arbitrary code execution as root across all Kubernetes cluster nodes.