The Unified and Autonomous Development Platform
fix: Token-authenticated subject leaks to anonymous requests on Java 25 (auth bypass)
Robin Shen69f99373b05e
diff --git a/server-core/src/main/java/io/onedev/server/CoreModule.java b/server-core/src/main/java/io/onedev/server/CoreModule.javaindex b771599cfa..8185505ca6 100644--- a/server-core/src/main/java/io/onedev/server/CoreModule.java+++ b/server-core/src/main/java/io/onedev/server/CoreModule.java@@ -179,6 +179,7 @@ import io.onedev.server.security.DefaultAuthorizingService;import io.onedev.server.security.DefaultFilterChainResolver;import io.onedev.server.security.DefaultPasswordService;import io.onedev.server.security.DefaultRememberMeManager;+import io.onedev.server.security.DefaultShiroFilter;import io.onedev.server.security.DefaultShiroFilterConfiguration;import io.onedev.server.security.DefaultWebSecurityManager;import io.onedev.server.security.FilterChainConfigurator;@@ -674,7 +675,7 @@ public class CoreModule extends AbstractPluginModule {bind(BasicAuthenticationFilter.class);bind(BearerAuthenticationFilter.class);bind(PasswordService.class).to(DefaultPasswordService.class);- bind(ShiroFilter.class);+ bind(ShiroFilter.class).to(DefaultShiroFilter.class);install(new ShiroAopModule());contribute(FilterChainConfigurator.class, filterChainManager -> {filterChainManager.createChain("/**/info/refs", "noSessionCreation, authcBasic, authcBearer");diff --git a/server-core/src/main/java/io/onedev/server/security/DefaultShiroFilter.java b/server-core/src/main/java/io/onedev/server/security/DefaultShiroFilter.javanew file mode 100644index 0000000000..e5dea2de35--- /dev/null+++ b/server-core/src/main/java/io/onedev/server/security/DefaultShiroFilter.java@@ -0,0 +1,31 @@+package io.onedev.server.security;++import java.io.IOException;++import org.apache.shiro.subject.support.SubjectThreadState;+import org.apache.shiro.web.servlet.ShiroFilter;++import jakarta.inject.Singleton;+import jakarta.servlet.FilterChain;+import jakarta.servlet.ServletException;+import jakarta.servlet.ServletRequest;+import jakarta.servlet.ServletResponse;++@Singleton+public class DefaultShiroFilter extends ShiroFilter {++ @Override+ protected void executeChain(ServletRequest request, ServletResponse response, FilterChain chain)+ throws IOException, ServletException {+ // Shiro uses scoped values on Java 25+, while our authentication filters+ // replace the subject in ThreadContext. Restore that state after every request.+ var threadState = new SubjectThreadState(org.apache.shiro.SecurityUtils.getSubject());+ try {+ threadState.bind();+ super.executeChain(request, response, chain);+ } finally {+ threadState.restore();+ }+ }++}diff --git a/server-core/src/test/java/io/onedev/server/security/DefaultShiroFilterTest.java b/server-core/src/test/java/io/onedev/server/security/DefaultShiroFilterTest.javanew file mode 100644index 0000000000..d9873c41a7--- /dev/null+++ b/server-core/src/test/java/io/onedev/server/security/DefaultShiroFilterTest.java@@ -0,0 +1,142 @@+package io.onedev.server.security;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertSame;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++import java.io.IOException;+import java.util.Map;++import org.apache.shiro.util.ThreadContext;+import org.apache.shiro.web.mgt.DefaultWebSecurityManager;+import org.apache.shiro.web.subject.WebSubject;+import org.apache.shiro.web.subject.support.WebDelegatingSubject;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import jakarta.servlet.FilterChain;+import jakarta.servlet.ServletException;+import jakarta.servlet.ServletRequest;+import jakarta.servlet.ServletResponse;++public class DefaultShiroFilterTest {++ private final TestFilter filter = new TestFilter();++ private Map<Object, Object> originalResources;++ @BeforeEach+ public void clearThreadState() {+ originalResources = ThreadContext.getResources();+ ThreadContext.remove();+ }++ @AfterEach+ public void restoreThreadState() {+ ThreadContext.remove();+ ThreadContext.setResources(originalResources);+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ public void tokenSubjectDoesNotLeakToNextRequest(boolean fail) throws Exception {+ var tokenSubject = filter.subject("user:1", true);+ FilterChain tokenRequest = (request, response) -> {+ assertFalse(SecurityUtils.getSubject().isAuthenticated());+ // Token authentication replaces the request subject in ThreadContext.+ ThreadContext.bind(tokenSubject);+ assertSame(tokenSubject, SecurityUtils.getSubject());+ if (fail)+ throw new IOException("Request failed");+ };+ if (fail) {+ var exception = assertThrows(IOException.class, () -> filter.request(tokenRequest));+ assertEquals("Request failed", exception.getMessage());+ } else {+ filter.request(tokenRequest);+ }+ assertNull(ThreadContext.getSubject());+ assertNull(ThreadContext.getSecurityManager());++ // Both requests execute synchronously on the same worker thread.+ filter.request((request, response) -> {+ assertFalse(SecurityUtils.getSubject().isAuthenticated());+ assertEquals(SecurityUtils.PRINCIPAL_ANONYMOUS, SecurityUtils.getSubject().getPrincipal());+ });+ assertTrue(ThreadContext.getResources().isEmpty());+ }++ @Test+ public void preservesAuthenticatedRequestSubject() throws Exception {+ filter.requestSubject = filter.subject("user:2", true);+ filter.request((request, response) -> {+ assertSame(filter.requestSubject, SecurityUtils.getSubject());+ assertTrue(SecurityUtils.getSubject().isAuthenticated());+ });+ assertTrue(ThreadContext.getResources().isEmpty());+ }++ @Test+ public void restoresEnclosingThreadState() throws Exception {+ var enclosingSubject = filter.subject("user:3", true);+ ThreadContext.bind(enclosingSubject);+ ThreadContext.bind(filter.getSecurityManager());+ ThreadContext.put("enclosing", "value");+ var enclosingResources = ThreadContext.getResources();++ filter.request((request, response) -> {+ assertSame(filter.requestSubject, SecurityUtils.getSubject());+ assertFalse(SecurityUtils.getSubject().isAuthenticated());+ ThreadContext.bind(filter.subject("user:1", true));+ ThreadContext.put("request", "value");+ });+ assertEquals(enclosingResources, ThreadContext.getResources());+ }++ private static class TestFilter extends DefaultShiroFilter {++ private WebSubject requestSubject;++ private TestFilter() {+ setSecurityManager(new DefaultWebSecurityManager());+ requestSubject = subject(SecurityUtils.PRINCIPAL_ANONYMOUS, false);+ }++ private WebSubject subject(String principal, boolean authenticated) {+ return new WebDelegatingSubject(SecurityUtils.asPrincipals(principal), authenticated,+ null, null, false, null, null, getSecurityManager());+ }++ private void request(FilterChain chain) throws ServletException, IOException {+ // Keep Shiro's real doFilterInternal/SubjectCallable request lifecycle.+ doFilterInternal(null, null, chain);+ }++ @Override+ protected ServletRequest prepareServletRequest(ServletRequest request, ServletResponse response,+ FilterChain chain) {+ return request;+ }++ @Override+ protected ServletResponse prepareServletResponse(ServletRequest request, ServletResponse response,+ FilterChain chain) {+ return response;+ }++ @Override+ protected WebSubject createSubject(ServletRequest request, ServletResponse response) {+ return requestSubject;+ }++ @Override+ protected void updateSessionLastAccessTime(ServletRequest request, ServletResponse response) {+ }+ }+}