CVE-2026-2265

What it actually does

This vulnerability affects applications using the Replicator npm package version 1.0.5 when they deserialize data supplied by an untrusted user. A crafted serialized object can cause the application to instantiate or execute attacker-controlled behavior during deserialization, resulting in unauthenticated remote code execution in the context of the Node.js application process. Practical impact depends on how the application uses Replicator and the privileges of the Node.js process, but successful exploitation may allow command execution, application data access, or modification of application behavior.

Why it matters to the business

An attacker may be able to run code on vulnerable application servers without logging in, which can lead to theft or alteration of application data, deployment of backdoors, pivoting into connected services, or abuse of cloud credentials available to the application. Although this issue is not currently listed in CISA KEV, is not known to be ransomware-associated, and has a low EPSS score, it has been public for 131 days and is remotely reachable with low attack complexity where vulnerable deserialization is exposed to user input.

How an attack unfolds

An attacker first identifies an application endpoint that accepts serialized input later processed by Replicator 1.0.5. The attacker sends a specially crafted serialized object designed to trigger code execution during the deserialization workflow. If the application passes this input directly into Replicator without strict validation or isolation, the object is reconstructed and attacker-controlled behavior executes inside the Node.js process. The attacker may then run operating-system commands with the privileges of the application, read configuration files or secrets accessible to the process, modify application data, or install persistence such as a web shell, scheduled task, malicious npm package, or outbound command-and-control connection.

How to fix it

Remove or replace Replicator 1.0.5 anywhere it is used to deserialize untrusted input. No fixed version was provided in the source data, so organizations should check the package maintainer’s advisory, npm registry, and repository for a patched release; if one exists, upgrade immediately and pin the fixed version in package-lock.json, npm-shrinkwrap.json, pnpm-lock.yaml, or yarn.lock. If no patched version is available, stop using the package for untrusted data and migrate to a safe serialization format such as JSON with strict schema validation. As compensating controls, reject serialized objects from untrusted clients, enforce allowlisted schemas and primitive-only data structures, run the Node.js service with least privilege, remove unnecessary shell and filesystem permissions, isolate the service in a container or sandbox, restrict outbound egress, rotate secrets that may have been exposed, and add request filtering for suspicious serialized payloads.

How to confirm the fix worked

Confirm exposure by searching source repositories and lockfiles for Replicator version 1.0.5 and reviewing whether any code path deserializes request bodies, cookies, headers, query parameters, uploaded files, queue messages, or webhook payloads. Validate remediation by confirming the vulnerable package version is absent from package manifests and runtime images, rebuilding and redeploying all affected services, and verifying dependency scanners no longer report Replicator 1.0.5. Review application behavior to ensure untrusted input is parsed only through schema-validated safe formats. For externally exposed services, test that endpoints accepting serialized input reject unexpected object types, constructors, prototype fields, and function-like payloads without invoking deserialization side effects.

Typical attack path

1. Identify a web endpoint, API, queue consumer, webhook, or import feature that accepts user-controlled serialized data.
2. Confirm the application uses Replicator npm version 1.0.5 in the code path handling that input.
3. Submit a crafted serialized object that abuses unsafe deserialization behavior.
4. Trigger deserialization so the malicious object is reconstructed by the application.
5. Execute code in the context of the Node.js application process.
6. Use the application’s privileges to access files, environment variables, tokens, databases, or downstream services.
7. Establish persistence or pivot to additional systems if network access and credentials allow.

How to detect it

Investigate prior exploitation by correlating application access logs, API gateway logs, WAF events, Node.js application logs, dependency inventory, EDR telemetry, process creation logs, container runtime logs, and network egress records. Look for unusual requests to endpoints that process serialized data, especially payloads containing JavaScript execution primitives, prototype-manipulation fields, shell metacharacters, encoded commands, or references to child process execution. On hosts or containers, review whether the Node.js application spawned unexpected shells or utilities such as sh, bash, cmd.exe, powershell.exe, curl, wget, nc, python, perl, or node subprocesses. Examine application directories and temporary paths for recently modified JavaScript files, unexpected npm packages, web shells, cron entries, systemd units, startup scripts, or unauthorized changes to package files. Review outbound connections from application servers to unfamiliar IPs, paste sites, file-sharing services, tunneling services, or command-and-control-like domains shortly after suspicious requests. Because no public exploit pattern or threat actor attribution is provided, detection should focus on behavioral evidence of unsafe deserialization and post-exploitation rather than a single definitive signature.

• replicator@1.0.5
• "replicator": "1.0.5"
• "replicator":"1.0.5"
• node_modules/replicator/package.json
• "name": "replicator"
• "version": "1.0.5"
• child_process
• require('child_process')
• require("child_process")
• execSync
• spawnSync
• process.mainModule
• constructor.constructor
• __proto__
• prototype
• /bin/sh -c
• bash -c
• cmd.exe /c
• powershell -enc
• powershell -EncodedCommand
• curl http
• wget http
• /tmp/
• /var/tmp/
• nc -e
• ncat -e

What your security team should do

• Inventory all applications, containers, serverless functions, and build artifacts for Replicator npm version 1.0.5.
• Prioritize internet-facing services and any API, webhook, import, or message-processing component that deserializes user-controlled data.
• Remove, replace, or upgrade the vulnerable dependency; if no fixed version is available, disable affected functionality until a safe implementation is deployed.
• Add dependency policy controls to block Replicator 1.0.5 from future builds.
• Harden affected Node.js services with least-privilege runtime users, secret minimization, filesystem restrictions, container isolation, and outbound network egress controls.
• Review logs and host telemetry for signs of prior command execution, unexpected child processes, suspicious outbound connections, or modifications to application files.
• Rotate credentials, API keys, tokens, and signing secrets accessible to any confirmed vulnerable service.
• Monitor npm advisories, maintainer releases, and threat intelligence for exploit publication or a change in KEV/EPSS status.