/

CVE-2026-36960

Severity:

HIGH RISK

(8.8)

CSRF in U-SPEED N300 Router Web Management Interface

CVE-2026-36960

Deferred

Vulnerability type

Category:

Cross-Site Request Forgery (CSRF)

CWE:

CWE-352

Impact:

Unauthorized Administrative Actions and Configuration Manipulation

Severity:

HIGH RISK

(8.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

A Cross-Site Request Forgery (CSRF) flaw in the U-SPEED N300 Router V1.0.0 web management interface allows attackers to trigger administrative actions through the victim's browser without their explicit consent.

When an authenticated administrator visits a malicious webpage, the browser automatically sends existing session cookies to the router, enabling unauthorized configuration changes as if performed by the legitimate admin.

Affected context

This vulnerability affects environments where the U-SPEED N300 Router V1.0.0 web management interface is accessible via a browser and administrators remain logged in or reuse sessions.

Risk increases when:

  • The admin panel is reachable from the general network (e.g., default LAN IP with no additional access controls)
  • Administrators frequently browse external websites while logged into the router
  • Default credentials or weak authentication practices are used

The issue specifically concerns administrative endpoints that process state-changing HTTP requests without CSRF protections.

Exploit preconditions

  • Attack surface: Web-based management interface of the router, typically over HTTP/HTTPS on the local network.
  • Required access:
  • Attacker needs to lure or trick an authenticated administrator into visiting a malicious webpage while their session with the router is active.
  • No direct access to the router UI or credentials is required if the victim is already logged in.
  • Trigger point:
  • Embedded HTML, JavaScript, or auto-submitting forms in the attacker-controlled page send HTTP requests (e.g., POST/GET) to router configuration endpoints.
  • The victim's browser automatically attaches valid session cookies to these requests.
  • Why exploitation is possible:
  • The router's management interface does not implement CSRF protections such as anti-CSRF tokens, same-site defenses, or strict Origin/Referer validation.
  • The router accepts state-changing requests solely based on session cookies, without verifying that the request originated from its own UI.

Why this happens

The root cause aligns with CWE-352: Cross-Site Request Forgery (CSRF), where a web application accepts state-changing requests based only on ambient authentication (cookies, HTTP auth) and does not verify the legitimacy of the request source.

In this case, the router's administrative API endpoints:

  • Treat any request carrying a valid session cookie as authorized,
  • Do not require a per-request, unguessable CSRF token tied to the user session,
  • Do not enforce strict Origin/Referer header checks for sensitive operations.

This trust in the browser's automatically included authentication context, without additional request integrity checks, allows an attacker's page to induce unauthorized actions through the victim's browser.

Potential impact

  • Unauthorized modification of router configuration (e.g., DNS servers, routing rules, firewall settings)
  • Change of Wi‑Fi SSID, passwords, or security parameters, potentially enabling network compromise
  • Enabling remote administration or port forwarding, expanding the attack surface beyond the local network
  • Locking out legitimate administrators by changing admin passwords or access policies
  • Traffic redirection to malicious DNS or proxy servers, leading to phishing or malware distribution
  • Degradation or denial of service on the local network through malicious configuration changes

General mitigation guidance

Effective mitigation focuses on enforcing request integrity for all state-changing administrative operations and reducing trust in ambient authentication alone.

Recommended patterns include:

  • Anti-CSRF tokens: Require unique, unpredictable tokens tied to the user session for all configuration-changing requests. Tokens should be:
  • Generated server-side and bound to the session
  • Transmitted in HTML forms or as part of an authenticated header
  • Validated server-side before processing the request
  • Same-site request validation:
  • Enforce strict Origin and/or Referer header checks for all administrative endpoints, accepting only trusted domains or IPs corresponding to the router's management interface.
  • Reject state-changing requests when these headers are missing or mismatched, where practical.
  • Cookie and session hardening:
  • Use cookies with SameSite defenses where feasible to limit cross-site request contexts.
  • Limit session lifetime and idle timeout to reduce exposure windows for CSRF.
  • Privileged action confirmation:
  • Introduce explicit confirmation steps (e.g., re-authentication or secondary confirmation for critical operations such as password changes, DNS changes, or remote management enablement).
  • Least-privilege and isolation in usage:
  • Encourage accessing the management interface from a dedicated or hardened browser profile that is not used for general web browsing.
  • Restrict network access to the management interface to trusted subnets when possible.

How teams detect issues like this

Organizations and vendors can detect and manage CSRF risks through a combination of review and automated analysis:

  • Code review signals:
  • Identify administrative or configuration endpoints that change device state (POST/PUT/DELETE or stateful GET requests).
  • Verify that these endpoints enforce CSRF tokens or robust Origin/Referer checks.
  • Look for reliance solely on cookies/session identifiers for authorization without additional request validation.
  • Static analysis and security testing:
  • Use static analysis tools configured to flag state-changing HTTP handlers that:
  • Do not read or validate CSRF tokens
  • Do not inspect Origin/Referer headers for sensitive operations
  • Run web security scanners or manual penetration tests that:
  • Attempt cross-site form submissions or XHR/fetch calls to protected endpoints
  • Confirm whether actions succeed without interaction from the router UI.
  • Policy and development guidelines:
  • Maintain secure coding standards that mandate CSRF protection for all authenticated, state-changing endpoints.
  • Integrate automated checks in CI/CD pipelines to ensure new or changed management endpoints adhere to CSRF requirements.

Sources

SourceLink
github.comgithub.com/kirubel-cve/CVE-2026-36960

Frequently asked

questions

It can be indirectly exploitable if an attacker can entice an authenticated administrator to visit a malicious webpage while their browser can reach the router's management IP. Direct internet reachability of the admin interface is not strictly required if the victim's browser is on the same network, but exposing the interface to the internet significantly increases risk.

The attacker does not need credentials if the administrator is already authenticated. The attack leverages the victim's existing session and browser-stored cookies; the critical requirement is that the victim is logged in (or has a valid session) when visiting the malicious page.

The safest pattern is to require per-request CSRF tokens for all state-changing administrative actions, validate them server-side, and combine this with strict Origin/Referer header enforcement. These measures ensure that only requests originating from the legitimate management interface are honored.

Prevention should be built into the design: treat all authenticated, state-changing endpoints as CSRF-sensitive, standardize on CSRF token frameworks, enforce header-based origin checks, set secure cookie attributes, and include CSRF testing in both automated security scans and manual reviews throughout the development lifecycle.

Find out what's already
exploitable in your codebase.