Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconAuthenticate as Standard Registry user
-
DeliveryAccess Custom Logic policy block editor
-
ExploitSubmit JavaScript payload with require('process').env access
-
InstallExtract credentials from environment variables
-
C2Forge admin JWT token
-
ExecuteAuthenticate as administrator
-
ImpactExfiltrate sensitive policy data
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Resource sphere isolation
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Attacker must possess authenticated Standard Registry user credentials with permissions to create or modify Custom Logic policy blocks within the Guardian platform. The Custom Logic policy block worker feature must be enabled and accessible to the attacker's user role - if Guardian deployments restrict this advanced policy feature to administrators only or disable it entirely, the attack surface is eliminated. Exploitation requires no user interaction (UI:N) and works against default Guardian container configurations that store sensitive credentials in process environment variables. The authentication requirement (PR:L) limits exploitation to insider threats or scenarios where attacker has already compromised a Standard Registry account through separate means such as credential stuffing or phishing. Non-network deployments or air-gapped Guardian instances reduce but don't eliminate risk if malicious insiders have local access. |
| Impact | CVSS 8.7 (High) reflects the severe impact potential (VC:H/VI:H/VA:H) with authenticated network exploitation (AV:N/PR:L) requiring no user interaction. However, real-world risk signals show divergence: EPSS 0.12% (31st percentile) indicates very low probability of mass exploitation, SSVC classifies exploitation status as 'none' and automatable as 'no', and no CISA KEV listing exists. This discrepancy suggests the vulnerability requires specific deployment contexts - organizations must use the Custom Logic policy block feature and grant Standard Registry user roles, which may not be universally enabled. The authentication requirement (PR:L) significantly reduces attack surface versus unauthenticated RCE, but the 'total' technical impact rating in SSVC correctly identifies that successful exploitation yields complete container compromise including credential theft and horizontal privilege escalation via token forgery. Priority for patching should be HIGH for Guardian deployments actively using Custom Logic policies with multiple user roles, MEDIUM for single-admin deployments, and LOWER for installations not utilizing this feature. Critical gap: no confirmation whether exploitation requires non-default configuration of the Custom Logic block or if it's enabled by default in Guardian installations. |
| Exploit ScenarioDerived | An authenticated Standard Registry user with legitimate access to Guardian's policy management interface creates a new Custom Logic policy block containing malicious JavaScript code. The payload uses require('fs') to read /proc/self/environ and extract JWT_SECRET and RSA_PRIVATE_KEY environment variables, then uses require('crypto') to forge a valid JWT token for an administrator account. The attacker authenticates as admin, gains full platform control, and exfiltrates all policy data and user credentials. No public POC exists at time of analysis, but exploitation complexity is low (AC:L) for users with policy creation permissions. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Apr 22, 2026
Authenticated Standard Registry users can execute arbitrary Node.js code in Hashgraph Guardian ≤3.5.0 through unsandboxed JavaScript evaluation in the Custom Logic policy block worker, enabling credential theft and privilege escalation. The vulnerability allows importing native Node.js modules to read container filesystem contents, extract RSA private keys and JWT signing secrets from environment variables, and forge administrator authentication tokens. Despite low EPSS (0.12%) indicating minimal widespread exploitation probability, the authenticated RCE path to total system compromise warrants immediate patching for deployments using Custom Logic policy features.
Earlier versions of this analysis (1)
Remote code execution in Hashgraph Guardian ≤3.5.0 enables authenticated Standard Registry users to execute arbitrary JavaScript through unsandboxed Function() constructor in Custom Logic policy block worker. Attackers can import Node.js modules to read container files, extract environment credentials (RSA private keys, JWT signing keys, API tokens), and forge authentication tokens for privilege escalation to administrator access. Requires low-privilege authentication (PR:L). No public exploit identified at time of analysis.
RemediationAI
Upgrade Hashgraph Guardian to version 3.5.1 or later once the fix from GitHub PR #5929 (https://github.com/hashgraph/guardian/pull/5929) is released in a tagged version. Until patched versions are available, implement these compensating controls with noted trade-offs: (1) Disable or remove the Custom Logic policy block feature entirely if not business-critical - eliminates attack surface but may break existing policy workflows requiring dynamic JavaScript evaluation; (2) Restrict Standard Registry user role assignments to only absolutely trusted administrators and implement mandatory code review for all Custom Logic policy blocks before deployment - reduces attacker pool but introduces operational overhead and doesn't prevent malicious insiders; (3) Deploy Guardian containers with read-only root filesystems and externalize all secrets to secure secret management systems rather than environment variables - limits filesystem read impact and credential exposure but requires infrastructure reconfiguration and may affect other Guardian components expecting writable paths. Monitor container process execution for unexpected child processes or require() calls to filesystem/process modules as detection layer. Consult VulnCheck advisory at https://www.vulncheck.com/advisories/hashgraph-guardian-unsandboxed-javascript-execution-rce for additional vendor guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Hashgraph Guardian's Custom Logic policy block worker accepts user-supplied JavaScript expressions and executes them via the Node.js Function() constructor without sandboxing or isolation mechanisms. This CWE-668 (Exposure of Resource to Wrong Sphere) vulnerability stems from directly passing untrusted code to a JavaScript evaluation primitive that inherits full Node.js runtime capabilities. Unlike browser-based JavaScript execution which operates in a restricted environment, Node.js Function() provides access to require() for importing native modules (fs, process, crypto), filesystem I/O, and process memory. The affected component appears to be designed for dynamic policy logic evaluation but lacks the VM sandboxing (vm2, isolated-vm) or capability restriction mechanisms necessary when executing user-controlled code in server-side JavaScript runtimes.
Know when Guardian gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Primary rating from Vendor (VulnCheck) · only source for this CVE.
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Hashgraph Guardian through version 3.5.0 contains an unsandboxed JavaScript execution vulnerability in the Custom Logic policy block worker that allows authenticated Standard Registry users to execute arbitrary code by passing user-supplied JavaScript expressions directly to the Node.js Function() constructor without isolation. Attackers can import native Node.js modules to read arbitrary files from the container filesystem, access process environment variables containing sensitive credentials such as RSA private keys, JWT signing keys, and API tokens, and forge valid authentication tokens for any user including administrators.
Executive ViewAI
Hashgraph Guardian versions 3.5.0 and earlier contain an authenticated remote code execution vulnerability in the Custom Logic policy block that allows standard registry users to execute arbitrary Node.js code, access container filesystems, and extract cryptographic credentials including RSA private keys and JWT secrets. Organizations deploying Guardian with Custom Logic policies face complete system compromise including credential theft and unauthorized privilege escalation to administrator accounts.
No vendor-released patch identified at time of analysis. Interim mitigations: Disable Custom Logic policy block feature completely; implement strict role-based access controls limiting policy creation to administrators only; isolate Guardian deployments on restricted networks with egress filtering; enable detailed audit logging of all policy modifications and code execution events; regularly monitor container filesystem access and environment variable exposure; implement network segmentation to prevent lateral movement if credentials are compromised.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
OS command injection in Guardian language-system lets unauthenticated remote attackers run arbitrary shell commands by i
Remote code execution in Guardian language-system allows unauthenticated attackers to run arbitrary OS commands by injec
Unauthenticated SQL injection in Guardian Language System lets remote attackers manipulate the backend database by injec
Error-based SQL injection in Guardian Language-System allows a network-accessible authenticated attacker to extract the
SQL injection in Guardian Language-System's designer.php (line 124) allows attackers to extract, modify, or destroy the
Error-based SQL injection in Guardian language-system's subtitles.php exposes full database contents to low-privileged a
Error-based SQL injection in Guardian Language-System exposes the full database to low-privileged authenticated attacker
Error-based SQL injection in Guardian language-system's text_file.php exposes the full database to extraction via a triv
SQL injection in Guardian language-system's media.php endpoint allows low-privilege authenticated attackers to extract t
Nozomi Networks OS before 19.0.4 allows /#/network?tab=network_node_list.html CSV Injection. Rated high severity (CVSS 7
Nozomi Guardian before 19.0.4 allows attackers to achieve stored XSS (in the web front end) by leveraging the ability to
A SQL Injection vulnerability in Nozomi Networks Guardian and CMC, due to improper input validation in certain fields us
EUVD-2026-20993
GHSA-wf7f-q2xr-hrmh
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB