/

CVE-2026-58454

Severity:

HIGH RISK

(7.5)

Remote Code Injection (CWE-94) in JAIOTlink IP Cameras

CVE-2026-58454

Deferred

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Persistent Remote Code Execution on IP Camera

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

JAIOTlink C492A-W6 Wi-Fi IP cameras allow authenticated attackers to execute arbitrary shell scripts by abusing a writable persistent storage path and an HTTP configuration endpoint.

By staging malicious scripts in JFFS2 storage and triggering execution via popen(), an attacker can gain persistent remote code execution that survives device reboots.

Affected context

This vulnerability arises in JAIOTlink C492A-W6 Wi-Fi IP cameras running firmware 4.8.30.57701411, where configuration-related functionality interacts with scripts stored on a writable JFFS2 filesystem.

It is relevant in deployments where:

  • The device's HTTP configuration endpoints are exposed to authenticated users or integrated controllers
  • Writable persistent storage remains accessible and is treated as a source of executable scripts
  • popen() or equivalent shell invocation is used to execute files from that storage without robust validation or sanitization

Exploit preconditions

  • Attack surface: Authenticated HTTP configuration endpoint on the IP camera
  • Required access: Valid credentials or equivalent authenticated access to the camera's web interface or API
  • Trigger point: Invoking the configuration endpoint that causes the device to execute scripts via popen()
  • Why exploitation is possible: The implementation allows scripts stored on writable persistent JFFS2 storage to be executed without ensuring they are trusted, signed, or strictly constrained, enabling attackers with write access to inject and run arbitrary shell code.

Why this happens

The core issue maps to CWE-94: Improper Control of Generation of Code ('Code Injection').

The firmware uses popen() to execute shell-level scripts derived from data residing in a writable persistent filesystem, treating them as trusted operational artifacts.

Because there is insufficient validation of what scripts may be stored or referenced, and no strong integrity or origin checks, authenticated users who can write to the JFFS2 storage area can influence which code is executed.

Abstractly, this reflects a pattern where application logic dynamically generates or selects executable code from modifiable storage locations, without enforcing strict validation, signing, or containment of that code.

Potential impact

  • Attackers can gain persistent remote code execution on the camera device
  • Device configuration and recorded media may be modified or exfiltrated
  • The camera can be repurposed as a node in a botnet or used for further network attacks
  • Local network reconnaissance and credential harvesting could be performed from the compromised device
  • Long-term stealthy surveillance or tampering with monitoring data may occur

General mitigation guidance

Mitigation patterns focus on reducing the trust placed in writable storage and avoiding dynamic execution of scripts derived from it.

Common approaches include:

  • Refactoring configuration handling so that scripts or commands are not dynamically loaded from user-writable locations
  • Restricting or removing popen() and similar shell invocation paths in favor of fixed, parameterized operations without script-level indirection
  • Enforcing strict integrity controls on any executable or script content, such as mandatory signing and verification before use
  • Segregating configuration data from executable logic, ensuring that configuration files cannot be interpreted as shell scripts
  • Applying least-privilege principles to runtime processes so that, if code execution paths remain, they operate with minimal permissions and limited filesystem access

How teams detect issues like this

Detection typically involves examining both firmware code and device behavior for script-based execution patterns.

Useful strategies include:

  • Static analysis rules targeting uses of popen(), system(), or similar shell invocation APIs that reference paths under writable storage
  • Code review focused on configuration endpoints and any logic that reads from persistent filesystems and subsequently executes their contents
  • Policy enforcement to prohibit dynamically executed scripts from user-writable locations, validated via secure coding checklists or internal standards
  • Runtime monitoring or firmware integrity checks to detect unexpected scripts or binaries appearing in persistent storage locations

Sources

SourceLink
github.comgithub.com/rwprimitives/jaiotlink-c492a-wifi-camera/blob/main/writeups/03-anyka-config-execution-trigger.md
amazon.comamazon.com/stores/JAIOTlink/page/3B00DC41-70C3-4BAA-925C-3D222C2633D5?lp_asin=B0GX1BNZ78&ref_=ast_bln&store_ref=bl_ast_dp_brandlogo_sto
vulncheck.comvulncheck.com/advisories/jaiotlink-c492a-w6-rce-via-anyka-config-endpoint

Frequently asked

questions

Yes, provided the attacker can reach the camera's HTTP configuration interface and has valid credentials or equivalent authenticated access, they can interact with the vulnerable endpoint remotely.

Exploitation requires authenticated access to the device, allowing the attacker to write malicious scripts to the persistent JFFS2 storage and call the configuration endpoint that triggers execution.

The most robust approach is to remove dynamic script execution from writable storage entirely, eliminating paths where configuration or user-provided content can be treated as executable code, and instead rely on fixed, non-scripted operations.

Future designs should avoid executing code from modifiable storage, enforce strict separation between data and executable logic, apply integrity checks for any operational scripts or binaries, and incorporate secure coding reviews and automated analysis to flag unsafe shell invocation and code generation patterns during development.

Find out what's already
exploitable in your codebase.