/

CVE-2026-25885

Severity:

HIGH RISK

(7.5)

Authentication and Authorization Failures in PolarLearn

CVE-2026-25885

Analyzed

Vulnerability type

Category:

Authentication and Authorization Failures

CWE:

CWE-285, CWE-306

Impact:

Unauthorized Access and Data Integrity Compromise

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

PolarLearn's group chat WebSocket endpoint allows unauthenticated clients to subscribe to any group chat and send messages by simply providing a group UUID.

Because the server accepts and stores these messages in persistent chat content, attackers can inject arbitrary messages into any group without logging in, leading to trust, integrity, and abuse risks.

Affected context

This vulnerability occurs in the PolarLearn group chat functionality exposed via the WebSocket endpoint at wss://polarlearn.nl/api/v1/ws.

In affected versions, the server:

  • Does not require users to be authenticated before establishing a chat WebSocket session
  • Does not sufficiently verify that a client is authorized to join or post to a specific group
  • Trusts a client-supplied group UUID to decide which chat room to access

As a result, any party capable of opening a WebSocket connection to this endpoint can interact with group chats as if they were legitimate group members.

Exploit preconditions

  • Attack surface: Publicly reachable WebSocket endpoint at wss://polarlearn.nl/api/v1/ws.
  • Required access: Network-level ability to reach the PolarLearn service; no user account or login session required.
  • Trigger point: Establishing a WebSocket connection and sending messages that include any valid or guessed group UUID.
  • Why exploitation is possible:
  • The server does not enforce authentication (CWE-306) for the chat WebSocket.
  • The server does not enforce authorization checks (CWE-285) to confirm that a client is a member of the specified group.
  • Group membership is effectively inferred from untrusted client input (the group UUID) without server-side verification.

Why this happens

The core issue stems from missing authentication and authorization controls on a stateful, multi-tenant WebSocket API.

Instead of binding WebSocket sessions to a verified user identity and checking group membership on the server, the design allows any client to:

  • Connect anonymously
  • Declare which group they want to interact with via a group UUID

This maps to:

  • CWE-306: Missing Authentication for Critical Function, because a critical operation (reading and writing group chat content) is exposed without requiring a logged-in user.
  • CWE-285: Improper Authorization, because the server fails to validate that the client is permitted to access or modify the chosen group's chat.

The insecure pattern is treating identifiers supplied by the client (group UUIDs) as proof of authorization instead of deriving permissions from authenticated session state.

Potential impact

  • Unauthenticated posting of arbitrary messages into any group chat, impacting data and conversation integrity.
  • Large-scale spam or harassment against all accessible groups.
  • Impersonation risk, where messages appear to come from "the group chat" and may be misattributed to legitimate members.
  • Disruption of educational activities, moderation workflows, or classroom communication.
  • Potential social engineering, phishing, or malicious links distributed through trusted group channels.

General mitigation guidance

Mitigation generally focuses on enforcing proper identity and access control for all real-time communication channels:

  • Require authentication before allowing WebSocket connections, using session cookies, tokens, or other strong mechanisms tied to a user account.
  • Associate each WebSocket connection with a server-side user identity and only allow access to groups that the server confirms the user belongs to.
  • Implement explicit authorization checks whenever subscribing to a group or posting a message, based on server-maintained membership and role data.
  • Treat group identifiers (UUIDs) as opaque references, not as proof of access, and avoid relying solely on their unpredictability for security.
  • Apply least-privilege principles in chat APIs (e.g., separate "read" vs. "write" permissions, enforce moderator or teacher roles where appropriate).
  • Design APIs so that failure to authenticate or authorize results in denying access by default, with clear error responses but no data leakage.

How teams detect issues like this

Detection can combine application-layer testing and code-level review:

  • Static/code review:
  • Identify WebSocket endpoints that perform sensitive operations without explicit authentication or authorization logic.
  • Look for handlers that accept resource identifiers (e.g., group UUIDs) from the client and immediately subscribe or write to that resource without checking user membership.
  • Verify that permission checks rely on server-side user identity, not on client-supplied identifiers or flags.
  • Dynamic testing:
  • Attempt to connect to WebSocket endpoints without credentials and observe whether chat content can be read or written.
  • Use automated security tests to enumerate group identifiers where feasible and verify whether unauthorized interactions are possible.
  • Policy and tooling:
  • Enforce internal security policies that require every API—including WebSockets—to have documented authentication and authorization requirements.
  • Use automated application security testing tools or SAST rules that flag missing auth/authorization around real-time communication endpoints.

Sources

SourceLink
github.comgithub.com/polarnl/PolarLearn/commit/3ba588fda0d3f8e238483a20772719f27e52e79f
github.comgithub.com/polarnl/PolarLearn/security/advisories/GHSA-gvjm-5pw7-6c8c

Frequently asked

questions

Yes. Any remote client that can reach the WebSocket endpoint over the network can subscribe to and post in group chats, even without a PolarLearn account.

No. The described behavior allows completely unauthenticated clients to connect and interact with group chats, as long as they supply a group UUID.

The safest pattern is to enforce strong authentication on all WebSocket connections and perform server-side authorization checks on every action, ensuring that only users with verified group membership can subscribe to or send messages in that group.

Adopt a "secure by default" design for all APIs: require authentication for every state-changing or data-accessing operation, centralize authorization logic, avoid trusting client-supplied identifiers as proof of access, and include WebSocket endpoints in routine security reviews and automated testing.

Find out what's already
exploitable in your codebase.