/

CVE-2025-62193

Severity:

CRITICAL RISK

(9.8)

OS Command Injection in NOAA PMEL Live Access Server

CVE-2025-62193

Awaiting Analysis

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

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

NOAA PMEL Live Access Server (LAS) is vulnerable to OS command injection when processing specially crafted requests that embed PyFerret expressions.

An unauthenticated remote attacker can abuse SPAWN-like functionality in these expressions to execute arbitrary operating system commands on the LAS host.

Affected context

This vulnerability affects deployments of NOAA PMEL Live Access Server that:

  • Expose LAS functionality over HTTP/HTTPS to untrusted clients
  • Enable PyFerret expression support in request processing
  • Use the vulnerable implementation of gov.noaa.pmel.tmap.las.filter.RequestInputFilter

Under these conditions, user-controlled request parameters can flow into PyFerret evaluation in a way that ultimately influences shell command construction on the server.

Exploit preconditions

  • Attack surface: Network-accessible LAS endpoints that parse and evaluate PyFerret expressions from incoming requests.
  • Required access: None; exploitation can be attempted by any remote, unauthenticated user able to send HTTP(S) requests to the LAS instance.
  • Trigger point: Submission of a specially crafted request parameter or payload containing PyFerret expressions that invoke SPAWN-style commands.
  • Why exploitation is possible: User-supplied data is interpreted as part of a PyFerret expression and passed to command execution primitives without adequate sanitization, escaping, or restriction, allowing arbitrary OS command construction.

Why this happens

The core issue is an OS command injection flaw in the request filtering and evaluation pipeline.

The vulnerable RequestInputFilter trusts portions of incoming requests that contain PyFerret expressions and allows those expressions to invoke SPAWN or equivalent features that delegate to the operating system shell. Because the data driving these expressions is not strictly validated or constrained, attackers can introduce tokens that modify the intended command or inject entirely new commands.

This maps directly to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), where application code builds or forwards commands to the OS using untrusted input instead of using safely parameterized, constrained, or disabled execution paths.

Potential impact

  • Remote execution of arbitrary OS commands with the privileges of the LAS service account
  • Full compromise of the affected LAS host, including data theft or modification
  • Installation of backdoors or malware for persistent access
  • Use of the server as a pivot point for lateral movement within the network
  • Disruption or manipulation of scientific data services, including availability and integrity loss

General mitigation guidance

Mitigation typically focuses on removing or strictly constraining the ability of user input to reach OS command execution paths:

  • Disable or restrict SPAWN or similar command-execution features in PyFerret when handling untrusted client input.
  • Constrain the interpreter environment so that only a minimal, pre-defined set of safe operations can be invoked from user-supplied expressions.
  • Apply robust input validation to PyFerret-related parameters, rejecting or stripping constructs that could lead to command execution.
  • Avoid constructing shell commands from dynamic input; where OS interaction is required, prefer fixed command templates and safe APIs that do not invoke the shell.
  • Run LAS under a dedicated, least-privileged account and with restrictive OS-level controls (e.g., filesystem permissions, outbound network limits, process isolation) to limit blast radius if exploitation occurs.
  • Place LAS behind application gateways or proxies that can restrict or sanitize high-risk request patterns related to expression evaluation.

How teams detect issues like this

Effective detection usually combines code-centric and operational approaches:

  • Static analysis: Scan the LAS codebase and related filters for any use of shell invocation APIs (e.g., Java Runtime.exec, ProcessBuilder) that derive arguments from request parameters, especially around PyFerret expression handling and SPAWN-like operations.
  • Code review: Examine RequestInputFilter and associated expression parsing logic for direct or indirect flows of user input into command execution, paying attention to string concatenation, unescaped parameters, and broad interpreter features.
  • Runtime monitoring: Instrument LAS hosts to log command executions originating from the LAS process and alert on unexpected binaries, unusual arguments, or commands triggered by web traffic patterns.
  • Web and API logging: Monitor HTTP(S) logs for suspicious PyFerret expressions, atypical symbols indicative of command injection, or repeated failed attempts targeting expression-related parameters.
  • Policy and CI enforcement: Incorporate secure coding policies that prohibit unbounded interpreter features and shell calls with request-derived data, enforcing them through CI checks and automated code review tools.

Sources

SourceLink
github.comgithub.com/NOAA-PMEL/LAS/blob/main/README.md
github.comgithub.com/NOAA-PMEL/LAS/commit/de5f9237bfd4ac5085bcc49a6e30bbc9507ddb29
github.comgithub.com/NOAA-PMEL/LAS/commit/e69afb1898ae7e69f3e047513fc1e5570373912b
github.comgithub.com/NOAA-PMEL/LAS/compare/b4b7306..de5f923
github.comgithub.com/NOAA-PMEL/LAS/tree/main
raw.githubusercontent.comraw.githubusercontent.com/cisagov/CSAF/develop/csaf_files/IT/white/2025/va-26-015-01.json
cve.orgcve.org/CVERecord?id=CVE-2025-62193

Frequently asked

questions

Yes. If a LAS instance is reachable over the network and processes PyFerret expressions from client requests, an unauthenticated attacker can attempt to exploit this issue purely through crafted HTTP(S) traffic.

No. The described behavior occurs during handling of incoming requests and does not inherently require authenticated access, although some deployments might place LAS behind additional access controls that reduce exposure.

The safest pattern is to eliminate direct OS command execution from the user-controlled expression path. This includes disabling SPAWN-like features for untrusted inputs, avoiding shell invocation altogether when possible, and strictly confining any remaining command execution behind fixed, parameter-safe APIs.

Avoid mixing user-controllable expression languages with powerful system-level capabilities. When interpreters are necessary, expose only a minimal, curated set of operations, validate and constrain all user inputs, perform security-focused code reviews around expression evaluation, and integrate static analysis rules that flag any data flow from requests into command execution primitives.

Find out what's already
exploitable in your codebase.