Skip to content

The Unified and Autonomous Development Platform

fix: validate Wicket WebSocket origins

Robin Shen816ace8eb5eb
diff --git a/server-core/src/main/java/io/onedev/server/web/websocket/WebSocketFilter.java b/server-core/src/main/java/io/onedev/server/web/websocket/WebSocketFilter.java
index 24a3e3c0ac..616500919c 100644
--- a/server-core/src/main/java/io/onedev/server/web/websocket/WebSocketFilter.java
+++ b/server-core/src/main/java/io/onedev/server/web/websocket/WebSocketFilter.java
@@ -17,7 +17,10 @@
package io.onedev.server.web.websocket;
import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import jakarta.inject.Inject;
import jakarta.servlet.FilterConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
@@ -27,6 +30,8 @@ import org.apache.shiro.SecurityUtils;
import org.apache.wicket.protocol.ws.AbstractUpgradeFilter;
import org.eclipse.jetty.ee11.websocket.server.JettyWebSocketServerContainer;
+import io.onedev.server.service.SettingService;
+
/** Upgrades Wicket connections through Jetty's Jakarta Servlet WebSocket container. */
public class WebSocketFilter extends AbstractUpgradeFilter {
@@ -34,6 +39,9 @@ public class WebSocketFilter extends AbstractUpgradeFilter {
private JettyWebSocketServerContainer webSocketContainer;
+ @Inject
+ private SettingService settingService;
+
@Override
public void init(boolean isServlet, FilterConfig filterConfig) throws ServletException {
super.init(isServlet, filterConfig);
@@ -45,9 +53,56 @@ public class WebSocketFilter extends AbstractUpgradeFilter {
@Override
protected boolean acceptWebSocket(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
+ if (!super.acceptWebSocket(request, response))
+ return false;
+ if (!isOriginAllowed(request)) {
+ response.sendError(HttpServletResponse.SC_FORBIDDEN);
+ return false;
+ }
request.setAttribute(SHIRO_SUBJECT, SecurityUtils.getSubject());
- return super.acceptWebSocket(request, response)
- && webSocketContainer.upgrade((req, resp) -> new WebSocketProcessor(req, resp, getApplication()),
- request, response);
+ return webSocketContainer.upgrade((req, resp) -> new WebSocketProcessor(req, resp, getApplication()),
+ request, response);
+ }
+
+ private boolean isOriginAllowed(HttpServletRequest request) {
+ var origins = request.getHeaders("Origin");
+ if (!origins.hasMoreElements())
+ return false;
+ var originHeader = origins.nextElement();
+ if (origins.hasMoreElements())
+ return false;
+ try {
+ var origin = new URI(originHeader);
+ if ((!"http".equalsIgnoreCase(origin.getScheme()) && !"https".equalsIgnoreCase(origin.getScheme()))
+ || origin.getHost() == null || origin.getRawUserInfo() != null
+ || !origin.getRawPath().isEmpty() || origin.getRawQuery() != null
+ || origin.getRawFragment() != null || origin.getPort() > 65535)
+ return false;
+
+ // Reverse proxies may replace the public scheme, host, and port with backend values.
+ var systemSetting = settingService.getSystemSetting();
+ if (systemSetting != null && systemSetting.getServerUrl() != null
+ && isSameOrigin(origin, new URI(systemSetting.getServerUrl())))
+ return true;
+
+ // Preserve direct access via localhost, IP addresses, or alternate hostnames.
+ var requestOrigin = new URI(request.getScheme(), null, request.getServerName(),
+ request.getServerPort(), null, null, null);
+ return isSameOrigin(origin, requestOrigin);
+ } catch (URISyntaxException e) {
+ return false;
+ }
+ }
+
+ private boolean isSameOrigin(URI origin, URI target) {
+ return origin.getScheme().equalsIgnoreCase(target.getScheme())
+ && origin.getHost().equalsIgnoreCase(target.getHost())
+ && getPort(origin) == getPort(target);
+ }
+
+ private int getPort(URI uri) {
+ if (uri.getPort() != -1)
+ return uri.getPort();
+ return "https".equalsIgnoreCase(uri.getScheme()) ? 443 : 80;
}
}
diff --git a/server-core/src/test/java/io/onedev/server/web/websocket/WebSocketFilterTest.java b/server-core/src/test/java/io/onedev/server/web/websocket/WebSocketFilterTest.java
new file mode 100644
index 0000000000..0cc9512a82
--- /dev/null
+++ b/server-core/src/test/java/io/onedev/server/web/websocket/WebSocketFilterTest.java
@@ -0,0 +1,188 @@
+package io.onedev.server.web.websocket;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+import org.apache.shiro.subject.Subject;
+import org.apache.shiro.subject.support.SubjectThreadState;
+import org.eclipse.jetty.ee11.websocket.server.JettyWebSocketServerContainer;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import io.onedev.server.model.support.administration.SecuritySetting;
+import io.onedev.server.model.support.administration.SystemSetting;
+import io.onedev.server.security.CorsFilter;
+import io.onedev.server.service.SettingService;
+
+class WebSocketFilterTest {
+
+ private final WebSocketFilter filter = new WebSocketFilter();
+
+ private final SettingService settingService = mock(SettingService.class);
+
+ private final SystemSetting systemSetting = new SystemSetting();
+
+ private final JettyWebSocketServerContainer container = mock(JettyWebSocketServerContainer.class);
+
+ private final Subject subject = mock(Subject.class);
+
+ private final SubjectThreadState threadState = new SubjectThreadState(subject);
+
+ @BeforeEach
+ void setUp() throws Exception {
+ systemSetting.setServerUrl("https://onedev.example.com/");
+ when(settingService.getSystemSetting()).thenReturn(systemSetting);
+ when(container.upgrade(any(), any(), any())).thenReturn(true);
+ FieldUtils.writeField(filter, "settingService", settingService, true);
+ FieldUtils.writeField(filter, "webSocketContainer", container, true);
+ threadState.bind();
+ }
+
+ @AfterEach
+ void tearDown() {
+ threadState.restore();
+ }
+
+ @Test
+ void acceptsDirectAccessWithADifferentConfiguredServerUrl() throws Exception {
+ for (String host : List.of("localhost", "127.0.0.1", "server", "[::1]"))
+ assertAccepted(request("http", host, 6610, "http://" + host + ":6610"));
+ assertAccepted(request("http", "::1", 6610, "http://[::1]:6610"));
+ }
+
+ @Test
+ void acceptsConfiguredPublicOriginBehindAReverseProxy() throws Exception {
+ assertAccepted(request("http", "backend", 6610, "https://onedev.example.com"));
+ assertAccepted(request("http", "onedev_backend", 6610, "https://onedev.example.com"));
+ systemSetting.setServerUrl("https://onedev.example.com:8443/");
+ assertAccepted(request("http", "backend", 6610, "https://onedev.example.com:8443"));
+ assertRejected(request("http", "backend", 6610, "https://onedev.example.com"));
+ }
+
+ @Test
+ void comparesHostAndSchemeIgnoringCaseAndNormalizesDefaultPorts() throws Exception {
+ assertAccepted(request("http", "SERVER", 80, "http://server"));
+ assertAccepted(request("http", "server", 80, "http://SERVER:80"));
+ assertAccepted(request("https", "server", 443, "https://server"));
+ assertAccepted(request("http", "backend", 6610, "HTTPS://ONEDEV.EXAMPLE.COM:443"));
+ systemSetting.setServerUrl("https://ONEDEV.EXAMPLE.COM:443/");
+ assertAccepted(request("http", "backend", 6610, "https://onedev.example.com"));
+ }
+
+ @Test
+ void allowsDirectAccessDuringInitialSetup() throws Exception {
+ when(settingService.getSystemSetting()).thenReturn(null);
+ assertAccepted(request("http", "server", 6610, "http://server:6610"));
+ assertRejected(request("http", "server", 6610, "http://other.example"));
+ when(settingService.getSystemSetting()).thenReturn(new SystemSetting());
+ assertAccepted(request("http", "server", 6610, "http://server:6610"));
+ assertRejected(request("http", "server", 6610, "http://other.example"));
+ }
+
+ @Test
+ void rejectsMissingNullMalformedAndMultipleOrigins() throws Exception {
+ assertRejected(request("http", "server", 6610));
+ for (String origin : List.of("null", "", " ", "server:6610", "//server:6610",
+ "ws://server:6610", "file:///", "http://server:6610/", "http://server:6610/path",
+ "http://user@server:6610", "http://server:6610?query", "http://server:6610#fragment",
+ "http://server:99999", "http://server:invalid", "http://[invalid",
+ "http://server:6610 https://onedev.example.com",
+ "http://server:6610,https://onedev.example.com")) {
+ assertRejected(request("http", "server", 6610, origin));
+ }
+ assertRejected(request("http", "server", 6610, "http://server:6610", "http://other.example"));
+ assertRejected(request("http", "server", 6610, "http://server:6610", "http://server:6610"));
+ }
+
+ @Test
+ void rejectsDifferentHostsSchemesAndPorts() throws Exception {
+ for (String origin : List.of("http://other.example", "https://server:6610", "http://server:8000",
+ "http://server", "http://127.0.0.1:6610", "http://onedev.example.com",
+ "https://onedev.example.com:8443", "https://onedev.example.com.other.example")) {
+ assertRejected(request("http", "server", 6610, origin));
+ }
+ }
+
+ @Test
+ void doesNotTrustArbitraryForwardingHeaders() throws Exception {
+ var request = request("http", "server", 6610, "https://other.example");
+ when(request.getHeader("Forwarded")).thenReturn("host=other.example;proto=https");
+ when(request.getHeader("X-Forwarded-Host")).thenReturn("other.example");
+ when(request.getHeader("X-Forwarded-Proto")).thenReturn("https");
+ assertRejected(request);
+ }
+
+ @Test
+ void corsPermissionDoesNotAuthorizeWicketWebSockets() throws Exception {
+ var securitySetting = new SecuritySetting();
+ securitySetting.setCorsAllowedOrigins(List.of("https://other.example"));
+ when(settingService.getSecuritySetting()).thenReturn(securitySetting);
+ var request = request("http", "server", 6610, "https://other.example");
+ var response = mock(HttpServletResponse.class);
+ new CorsFilter(settingService).doFilter(request, response, (req, resp) -> {
+ assertFalse(filter.acceptWebSocket((HttpServletRequest) req, (HttpServletResponse) resp));
+ });
+ verify(response).addHeader("Access-Control-Allow-Origin", "https://other.example");
+ verify(response).sendError(HttpServletResponse.SC_FORBIDDEN);
+ verifyNoInteractions(container);
+ }
+
+ @Test
+ void leavesOrdinaryHttpRequestsAlone() throws Exception {
+ var request = request("http", "server", 6610);
+ when(request.getHeaders("Upgrade")).thenReturn(Collections.emptyEnumeration());
+ var response = mock(HttpServletResponse.class);
+ assertFalse(filter.acceptWebSocket(request, response));
+ verifyNoInteractions(response, container, settingService);
+ }
+
+ private void assertAccepted(HttpServletRequest request) throws Exception {
+ clearInvocations(container);
+ var response = mock(HttpServletResponse.class);
+ assertTrue(filter.acceptWebSocket(request, response), request.getHeader("Origin"));
+ verify(container).upgrade(any(), same(request), same(response));
+ verify(request).setAttribute(WebSocketFilter.SHIRO_SUBJECT, subject);
+ verify(response, never()).sendError(anyInt());
+ }
+
+ private void assertRejected(HttpServletRequest request) throws Exception {
+ clearInvocations(container);
+ var response = mock(HttpServletResponse.class);
+ assertFalse(filter.acceptWebSocket(request, response), request.getHeader("Origin"));
+ verify(response).sendError(HttpServletResponse.SC_FORBIDDEN);
+ verifyNoInteractions(container);
+ verify(request, never()).setAttribute(eq(WebSocketFilter.SHIRO_SUBJECT), any());
+ }
+
+ private HttpServletRequest request(String scheme, String host, int port, String... origins) {
+ var request = mock(HttpServletRequest.class);
+ when(request.getMethod()).thenReturn("GET");
+ when(request.getScheme()).thenReturn(scheme);
+ when(request.getServerName()).thenReturn(host);
+ when(request.getServerPort()).thenReturn(port);
+ Map<String, List<String>> headers = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+ headers.put("Upgrade", List.of("websocket"));
+ headers.put("Connection", List.of("Upgrade"));
+ headers.put("Sec-WebSocket-Version", List.of("13"));
+ headers.put("Sec-WebSocket-Key", List.of("dGhlIHNhbXBsZSBub25jZQ=="));
+ headers.put("Origin", Arrays.asList(origins));
+ when(request.getHeaders(anyString())).thenAnswer(invocation ->
+ Collections.enumeration(headers.getOrDefault(invocation.getArgument(0), List.of())));
+ when(request.getHeader(anyString())).thenAnswer(invocation -> {
+ var values = headers.getOrDefault(invocation.getArgument(0), List.of());
+ return values.isEmpty() ? null : values.get(0);
+ });
+ return request;
+ }
+}