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.javaindex 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;+@Overridepublic void init(boolean isServlet, FilterConfig filterConfig) throws ServletException {super.init(isServlet, filterConfig);@@ -45,9 +53,56 @@ public class WebSocketFilter extends AbstractUpgradeFilter {@Overrideprotected 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.javanew file mode 100644index 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;+ }+}