/

CVE-2025-67448

Severity:

HIGH RISK

(7.1)

Stored Cross-Site Scripting (CWE-79) in Neterbit NW-431F Router SMS Module

CVE-2025-67448

Deferred

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Client-Side Code Execution in Management Interface

Severity:

HIGH RISK

(7.1)

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

The SMS module in Neterbit NW-431F Router 20241014-IR03 and earlier is vulnerable to stored cross-site scripting due to unsanitized handling of SMS message content.

An attacker can send an SMS containing malicious script code that is stored on the device and later executed in the victim's browser when the SMS is viewed via the router's web interface.

Affected context

This vulnerability appears in the web-based management interface of Neterbit NW-431F routers where SMS messages are received, stored, and rendered to administrators or users.

It becomes relevant in deployments where:

  • The router is configured to receive SMS messages (e.g., 3G/4G/LTE modem or GSM features),
  • SMS content is viewable through a browser-based dashboard, and
  • The interface displays raw message content without robust HTML/JavaScript sanitization or encoding.

The risk is heightened when administrator sessions are active and accessed from regular desktop or mobile browsers.

Exploit preconditions

  • Attack surface: Router web management interface, specifically pages that list or display SMS messages.
  • Required access: Ability to send an SMS message to the phone number/SIM associated with the router (no web authentication needed to inject the payload).
  • Victim interaction: A logged-in administrator or user must open the SMS inbox or detail view in a browser where the malicious message is rendered.
  • Trigger point: The vulnerable page renders SMS content without proper output encoding, allowing embedded script to execute in the browser.
  • Why exploitation is possible: User-controlled SMS text is stored server-side and later reflected into HTML responses without sufficient sanitization or context-aware encoding, enabling stored XSS.

Why this happens

The underlying bug is a typical stored XSS pattern aligned with CWE-79: Improper Neutralization of Input During Web Page Generation.

Application logic accepts SMS message content from an external source (the mobile network), stores it, and later injects it directly into HTML templates without:

  • Escaping special characters in the correct output context (HTML body, attribute, or script),
  • Filtering or neutralizing script-related constructs, or
  • Separating untrusted data from executable content.

Because the content is persisted and shown to other users, any script in the SMS body runs with the privileges of the logged-in browser context when the message list or details page is viewed.

Potential impact

  • Theft of administrator session information via malicious script execution in the browser.
  • Unauthorized actions performed in the management interface on behalf of the logged-in admin (changing settings, modifying firewall rules, DNS settings, etc.).
  • Injection of malicious configuration (e.g., redirecting traffic to attacker-controlled servers).
  • Use of the router's interface as a pivot for further attacks against internal network resources.
  • Persistent phishing or misleading UI content embedded into the SMS view pages.

General mitigation guidance

Defensive measures generally focus on robust output handling and strict separation of data from code:

  • Apply context-aware output encoding for all SMS content before inserting it into HTML pages (e.g., HTML-encode characters like <, >, ", ', and &).
  • Avoid rendering SMS content in HTML attributes, inline event handlers, or inline script blocks where small encoding mistakes are more dangerous.
  • Implement a sanitization layer that strips or neutralizes script tags, event handlers, and other active content constructs for message bodies.
  • Adopt templating or UI frameworks that default to safe escaping for untrusted data and require explicit opt-out for raw HTML.
  • Limit the privileges of the web interface session and enforce strong authentication, reducing impact if client-side compromise occurs.

How teams detect issues like this

High-level detection approaches can include:

  • Static analysis or secure code review focused on template rendering paths where SMS or other user-originated content is passed directly into HTML without encoding.
  • Search for patterns where raw message text is concatenated into HTML strings or passed to innerHTML-style constructs in client-side code.
  • Dynamic security testing (DAST) that sends test SMS messages with benign XSS probes and inspects resulting pages for reflected script execution.
  • Logging and monitoring for unusual administrative actions following the receipt of unexpected SMS messages, which may indicate exploitation attempts.

Sources

SourceLink
github.comgithub.com/fun-beep/CVEs/tree/main/CVE-2025-67448
neterbit.comneterbit.com/

Frequently asked

questions

It can be exploited remotely if an attacker can send SMS messages to the router's number and the admin accesses the web interface from a browser. The actual exploit runs in the victim's browser when they view the SMS, not directly on the router's OS.

The attacker does not need web UI credentials to inject the payload; they only need SMS-sending capability. However, for the payload to execute and have impact, a legitimate, authenticated user must open the SMS view page in their browser.

Ensure all SMS content is treated as untrusted data and is properly context-encoded before rendering. Use server-side templating or UI frameworks that escape by default and consider applying a strict sanitization policy for any rich text fields.

Adopt a consistent output-encoding strategy, conduct security-focused code reviews on all user-visible data paths, integrate automated XSS checks into testing pipelines, and design management interfaces under the assumption that any external input (including SMS, logs, and device metadata) is potentially malicious.

Find out what's already
exploitable in your codebase.