CVE-2026-82559

Apache Wicket: WebSocket messages are processed against an HTTP session snapshot that survives invalidation

Published Nov 1, 2026 CVSS 4.0 · 2.3 Low EPSS < 1% KEV · Not listed
Description
Insufficient session expiration in Apache Wicket.

org.apache.wicket.protocol.ws.WebSocketSettings#newWebSocketRequest() wraps the WebSocket upgrade request in an org.apache.wicket.protocol.ws.api.ServletRequestCopy, which is kept for the life of the connection and used to build the request for every frame that arrives on it. Copying the request is deliberate and is documented as such, because the container recycles the upgrade request once the handshake is over. The container session is copied along with it, into an org.apache.wicket.protocol.ws.api.HttpSessionCopy holding the session attributes as they stood when the connection was opened. That second copy is not necessary, because a session, unlike a request, is not discarded at the end of a request. Every frame afterwards resolves its Wicket session through ISessionStore#lookup(), which reads it out of the copy, so the connection is detached from the live container session for as long as it stays open.

Ending the session through the container therefore does not end the connection. After an idle timeout, an HttpSession#invalidate() call made from a filter or from a security framework, a container-managed logout, or a session replacement, the connection goes on resolving the org.apache.wicket.Session instance that existed when it was opened, together with that session's attributes and, for applications built on wicket-auth-roles, the signed-in state held on that same instance, so an authorization decision taken inside a WebSocket callback is taken against an identity that has already been revoked. The copy is also what the connection writes through: a Session#invalidateNow() issued from inside a WebSocket callback invalidates the copy and leaves the container session valid, and session attributes set over the connection are written to the copy rather than to the session.

An application is affected where it uses Wicket's native WebSocket support on pages or shared resources that require an authenticated session, and where sessions are ended by the container rather than by Wicket. Session#invalidateNow(), and AuthenticatedWebSession#invalidate() and #signOut() which call it, remain effective for a WebSocketBehavior on a page: they clear the page manager, and the connection can then no longer resolve the page it was opened for. A WebSocketResource is not limited in that way, because a frame naming a resource is served against a throwaway page and never consults the page manager, so such a connection outlives Wicket's own sign-out as well. Some containers close WebSocket connections themselves when the HTTP session they were opened under is destroyed, in which case the connection ends regardless; that is a property of the container rather than of Wicket. Applications that do not use the native WebSocket support are not affected.

This issue affects Apache Wicket: from 8.0.0 through 8.19.0, from 9.0.0 through 9.24.0, from 10.0.0 through 10.11.0. Older, unsupported releases from 6.0.0 onwards are also affected. Users are recommended to upgrade to version 8.20.0, 9.25.0 or 10.12.0, which fix the issue.

Analysis

AI-generated

Technical impact

A flaw in Apache Wicket (CWE‑613) causes WebSocket connections to use a snapshot of the HTTP session taken when the connection is opened, and that snapshot is not updated when the real session is invalidated. Consequently, after an attacker or system invalidates the container session, any active WebSocket connections continue to see the old session attributes and may still be authorized to perform privileged actions. This allows a malicious actor to maintain or elevate privileges through a persistent WebSocket channel that ignores logout or session expiration.

Affected Systems

Apache Wicket 8.0.0 through 10.11.0, including older supported versions from 6.0.0 onward, are affected. Users are advised to upgrade to 8.20.0, 9.25.0, 10.12.0 or newer releases.

Risk and Exploitability

Based on the description, it is inferred that the likely attack vector involves an attacker establishing a WebSocket connection from a client before the container invalidates the session. The CVSS score of 2.3 indicates low overall severity, and there is no EPSS data or KEV listing to suggest widespread exploitation. However, the vulnerability can be exploited remotely by any actor who can establish a WebSocket session before the container invalidates the session. The attack requires the target application to use Wicket's native WebSocket support on authenticated pages or resources. After local conditions are met, a WebSocket connection can be used to perform actions under the old, revoked identity, resulting in temporary privilege persistence.

Remediation

No solution or workaround provided in the CVE record.

OpenCVE Recommended Actions

  • Upgrade Apache Wicket to a fixed release (8.20.0, 9.25.0, 10.12.0 or later).
  • Modify application logic to close all active WebSocket connections when the user logs out or when the container session is invalidated, ensuring no stale session data persists.
  • If upgrading immediately is not possible, restrict WebSocket usage to authenticated sessions only and add runtime checks to verify that the session associated with a WebSocket call matches the current live session state, rejecting or terminating the connection if a mismatch is detected.

Generated by OpenCVE AI on November 2, 2026 at 00:21 UTC.

Tracking

Sign in to view the affected projects.

Advisories

No advisories available
History
Type Values Removed Values Added
Metrics ssvc

{'options': {'Automatable': 'no', 'Exploitation': 'none', 'Technical Impact': 'partial'}, 'version': '2.0.3'}

Type Values Removed Values Added
First Time appeared Apache
Apache wicket
Vendors & Products Apache
Apache wicket
Type Values Removed Values Added
Description Insufficient session expiration in Apache Wicket. org.apache.wicket.protocol.ws.WebSocketSettings#newWebSocketRequest() wraps the WebSocket upgrade request in an org.apache.wicket.protocol.ws.api.ServletRequestCopy, which is kept for the life of the connection and used to build the request for every frame that arrives on it. Copying the request is deliberate and is documented as such, because the container recycles the upgrade request once the handshake is over. The container session is copied along with it, into an org.apache.wicket.protocol.ws.api.HttpSessionCopy holding the session attributes as they stood when the connection was opened. That second copy is not necessary, because a session, unlike a request, is not discarded at the end of a request. Every frame afterwards resolves its Wicket session through ISessionStore#lookup(), which reads it out of the copy, so the connection is detached from the live container session for as long as it stays open. Ending the session through the container therefore does not end the connection. After an idle timeout, an HttpSession#invalidate() call made from a filter or from a security framework, a container-managed logout, or a session replacement, the connection goes on resolving the org.apache.wicket.Session instance that existed when it was opened, together with that session's attributes and, for applications built on wicket-auth-roles, the signed-in state held on that same instance, so an authorization decision taken inside a WebSocket callback is taken against an identity that has already been revoked. The copy is also what the connection writes through: a Session#invalidateNow() issued from inside a WebSocket callback invalidates the copy and leaves the container session valid, and session attributes set over the connection are written to the copy rather than to the session. An application is affected where it uses Wicket's native WebSocket support on pages or shared resources that require an authenticated session, and where sessions are ended by the container rather than by Wicket. Session#invalidateNow(), and AuthenticatedWebSession#invalidate() and #signOut() which call it, remain effective for a WebSocketBehavior on a page: they clear the page manager, and the connection can then no longer resolve the page it was opened for. A WebSocketResource is not limited in that way, because a frame naming a resource is served against a throwaway page and never consults the page manager, so such a connection outlives Wicket's own sign-out as well. Some containers close WebSocket connections themselves when the HTTP session they were opened under is destroyed, in which case the connection ends regardless; that is a property of the container rather than of Wicket. Applications that do not use the native WebSocket support are not affected. This issue affects Apache Wicket: from 8.0.0 through 8.19.0, from 9.0.0 through 9.24.0, from 10.0.0 through 10.11.0. Older, unsupported releases from 6.0.0 onwards are also affected. Users are recommended to upgrade to version 8.20.0, 9.25.0 or 10.12.0, which fix the issue.
Title Apache Wicket: WebSocket messages are processed against an HTTP session snapshot that survives invalidation
Weaknesses CWE-613
References
Metrics cvssV4_0

{'score': 2.3, 'vector': 'CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N'}

Weaknesses
  • CWE-613

    Insufficient Session Expiration

Sources

Status
PUBLISHED
Assigner
apache
Published
Updated
Nov 6, 2026, 2:49 PM
Reserved
Aug 29, 2026, 8:41 PM
Status
Deferred
Published
Nov 1, 2026, 10:17 PM
Modified
Nov 6, 2026, 3:17 PM