Skip to content

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.java
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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) {
+ }
+ }
+}