diff --git a/java-checks-test-sources/default/src/main/java/checks/spring/SpringSecurityDisableCSRFCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/spring/SpringSecurityDisableCSRFCheckSample.java index 4b411e1df3f..767077f5d7b 100644 --- a/java-checks-test-sources/default/src/main/java/checks/spring/SpringSecurityDisableCSRFCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/spring/SpringSecurityDisableCSRFCheckSample.java @@ -1,17 +1,26 @@ package checks.spring; +import javax.servlet.Filter; import javax.servlet.http.HttpServletRequest; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import org.springframework.security.config.Customizer; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer; import org.springframework.security.config.annotation.web.configurers.CsrfConfigurer; import org.springframework.security.config.annotation.web.configurers.LogoutConfigurer; +import org.springframework.security.config.annotation.web.configurers.SessionManagementConfigurer; +import org.springframework.security.config.annotation.web.configurers.oauth2.server.resource.OAuth2ResourceServerConfigurer; +import org.springframework.security.config.http.SessionCreationPolicy; import org.springframework.security.web.SecurityFilterChain; +import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; import org.springframework.security.web.util.matcher.RequestMatcher; +import static org.springframework.security.config.Customizer.withDefaults; +import static org.springframework.security.config.http.SessionCreationPolicy.STATELESS; + @EnableWebSecurity public class SpringSecurityDisableCSRFCheckSample extends WebSecurityConfigurerAdapter { @@ -60,4 +69,464 @@ public SecurityFilterChain filterChainCSRF(HttpSecurity http) throws Exception { return http.build(); } } + + @Bean + SecurityFilterChain statelessResourceServer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable) + .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) + .authorizeHttpRequests(auth -> auth.anyRequest().authenticated()) + .oauth2ResourceServer(o -> o.jwt(withDefaults())); + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerLambda(HttpSecurity http) throws Exception { + http.securityMatcher("/api/**"); + http.csrf(c -> c.disable()); + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerFluent(HttpSecurity http) throws Exception { + return http.csrf().disable() + .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and() + .oauth2ResourceServer().jwt().and().and().build(); + } + + @Bean + SecurityFilterChain statelessFalseMatcher(HttpSecurity http) throws Exception { + http.csrf(c -> c.requireCsrfProtectionMatcher(request -> false)); + http.csrf(c -> c.requireCsrfProtectionMatcher(request -> { return (false); })); + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain resourceServerWithoutStateless(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain statelessBasic(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.httpBasic(); + return http.build(); + } + + @Bean + SecurityFilterChain statelessCustomFilter(HttpSecurity http, Filter filter) throws Exception { + http.addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class); + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerBasic(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.httpBasic(); + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerFormLogin(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.formLogin(); + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerOauthLogin(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.oauth2Login(); + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerRememberMe(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.rememberMe(); + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerX509(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.x509(withDefaults()); + return http.build(); + } + + @Bean + SecurityFilterChain statelessPartialExemptions(HttpSecurity http) throws Exception { + http.csrf(c -> c.ignoringAntMatchers("/ignored")); // Noncompliant +// ^^^^^^^^^^^^^^^^^^^ + http.csrf(c -> c.requireCsrfProtectionMatcher(request -> request.isSecure())); // Noncompliant +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain differentReceivers(HttpSecurity http, HttpSecurity other) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + other.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + other.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain disabledResourceServer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.oauth2ResourceServer().disable(); + return http.build(); + } + + @Bean + SecurityFilterChain overriddenSessionPolicy(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.ALWAYS)); + return http.build(); + } + + @Bean + SecurityFilterChain conditionalSessionPolicy(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + + http.oauth2ResourceServer(o -> o.jwt()); + http.sessionManagement(s -> { if (System.currentTimeMillis() > 0) s.sessionCreationPolicy(SessionCreationPolicy.STATELESS); }); + return http.build(); + } + + @Bean + SecurityFilterChain deferredSessionPolicy(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + + http.oauth2ResourceServer(o -> o.jwt()); + http.sessionManagement(s -> { Runnable deferred = () -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS); }); + return http.build(); + } + + @Bean + SecurityFilterChain aliasedBuilder(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + HttpSecurity alias = http; + alias.httpBasic(); + return http.build(); + } + + @Bean + SecurityFilterChain disabledResourceServerReference(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(AbstractHttpConfigurer::disable); + return http.build(); + } + + @Bean + SecurityFilterChain disabledSessionManagement(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.sessionManagement().disable(); + return http.build(); + } + + @Bean + SecurityFilterChain earlyReturnSessionPolicy(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + + http.oauth2ResourceServer(o -> o.jwt()); + http.sessionManagement(s -> { if (System.currentTimeMillis() > 0) return; s.sessionCreationPolicy(SessionCreationPolicy.STATELESS); }); + return http.build(); + } + + @Bean + SecurityFilterChain escapedSessionConfigurer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> { s.sessionCreationPolicy(SessionCreationPolicy.STATELESS); makeStateful(s); }); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + void makeStateful(SessionManagementConfigurer session) { + session.sessionCreationPolicy(SessionCreationPolicy.ALWAYS); + } + + @Bean + SecurityFilterChain disabledSessionReference(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.sessionManagement(AbstractHttpConfigurer::disable); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain opaqueSessionCustomizer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.sessionManagement(this::makeStateful); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain escapedResourceServerConfigurer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> { o.jwt(); removeResourceServer(o); }); + return http.build(); + } + + void removeResourceServer(OAuth2ResourceServerConfigurer resourceServer) { + resourceServer.disable(); + } + + @Bean + SecurityFilterChain escapedFluentSessionConfigurer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> makeStateful(s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain escapedLegacySessionConfigurer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + makeStateful(http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain escapedFluentResourceServerConfigurer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> removeResourceServer(o.jwt().and())); + return http.build(); + } + + @Bean + SecurityFilterChain sharedOtherBuilder(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.getSharedObject(HttpSecurity.class) + .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) + .oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain deferredMatcherPolicy(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.securityMatcher(request -> { + try { + return http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) == null; + } catch (Exception exception) { + return false; + } + }); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain statelessStaticImport(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); + http.sessionManagement(s -> s.sessionCreationPolicy(STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain statelessCsrfLast(HttpSecurity http) throws Exception { + http.oauth2ResourceServer(o -> o.jwt()); + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.csrf(AbstractHttpConfigurer::disable); + return http.build(); + } + + @Bean + SecurityFilterChain statelessDisabledBrowserAuthentication(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable) + .httpBasic(AbstractHttpConfigurer::disable) + .formLogin(f -> f.disable()) + .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) + .oauth2ResourceServer(o -> o.jwt()); + http.rememberMe().disable(); + http.oauth2Login(AbstractHttpConfigurer::disable); + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerDefaultBasic(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.httpBasic(withDefaults()); + return http.build(); + } + + @Bean + SecurityFilterChain statelessResourceServerConfiguredBasic(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + http.httpBasic(b -> b.realmName("api")); + return http.build(); + } + + @Bean + SecurityFilterChain neverSessionPolicy(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.NEVER)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain builderPassedToHelper(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + configureCommon(http); + return http.build(); + } + + void configureCommon(HttpSecurity http) throws Exception { + http.httpBasic(); + } + + SecurityFilterChain notABean(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + void notAFilterChain(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + } + + @Bean + SecurityFilterChain csrfConfigurerVariable(HttpSecurity http) throws Exception { + CsrfConfigurer csrf = http.csrf(); + csrf.disable(); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + private SecurityFilterChain cachedChain; + private static final SessionCreationPolicy POLICY = SessionCreationPolicy.STATELESS; + + @Bean + SecurityFilterChain statelessDefaultResourceServer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(withDefaults()); + return http.build(); + } + + @Bean + SecurityFilterChain opaqueResourceServerCustomizer(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(resourceServerCustomizer()); + return http.build(); + } + + Customizer> resourceServerCustomizer() { + return o -> o.jwt(); + } + + @Bean + SecurityFilterChain returnsAnotherChain(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return cachedChain; + } + + @Bean + SecurityFilterChain statelessNotFalseMatchers(HttpSecurity http) throws Exception { + http.csrf(c -> c.requireCsrfProtectionMatcher(request -> true)); // Noncompliant +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + http.csrf(c -> c.requireCsrfProtectionMatcher(request -> { boolean secure = request.isSecure(); return false; })); // Noncompliant +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + + @Bean + SecurityFilterChain constantSessionPolicy(HttpSecurity http) throws Exception { + http.csrf(AbstractHttpConfigurer::disable); // Noncompliant +// ^^^^^^^ + http.sessionManagement(s -> s.sessionCreationPolicy(POLICY)); + http.oauth2ResourceServer(o -> o.jwt()); + return http.build(); + } + } diff --git a/java-checks/src/main/java/org/sonar/java/checks/spring/SpringSecurityDisableCSRFCheck.java b/java-checks/src/main/java/org/sonar/java/checks/spring/SpringSecurityDisableCSRFCheck.java index eecfec9f3b6..f0cd554348a 100644 --- a/java-checks/src/main/java/org/sonar/java/checks/spring/SpringSecurityDisableCSRFCheck.java +++ b/java-checks/src/main/java/org/sonar/java/checks/spring/SpringSecurityDisableCSRFCheck.java @@ -16,18 +16,34 @@ */ package org.sonar.java.checks.spring; +import java.util.ArrayList; +import java.util.List; import org.sonar.check.Rule; import org.sonar.java.checks.methods.AbstractMethodDetection; +import org.sonar.java.model.ExpressionUtils; +import org.sonar.java.model.LiteralUtils; import org.sonar.plugins.java.api.semantic.MethodMatchers; +import org.sonar.plugins.java.api.semantic.Symbol; +import org.sonar.plugins.java.api.tree.BaseTreeVisitor; +import org.sonar.plugins.java.api.tree.BlockTree; +import org.sonar.plugins.java.api.tree.ExpressionTree; +import org.sonar.plugins.java.api.tree.IdentifierTree; +import org.sonar.plugins.java.api.tree.LambdaExpressionTree; import org.sonar.plugins.java.api.tree.MemberSelectExpressionTree; import org.sonar.plugins.java.api.tree.MethodInvocationTree; import org.sonar.plugins.java.api.tree.MethodReferenceTree; +import org.sonar.plugins.java.api.tree.MethodTree; +import org.sonar.plugins.java.api.tree.ReturnStatementTree; import org.sonar.plugins.java.api.tree.Tree; @Rule(key = "S4502") public class SpringSecurityDisableCSRFCheck extends AbstractMethodDetection { private static final String CSRF_CONFIGURER_CLASS = "org.springframework.security.config.annotation.web.configurers.CsrfConfigurer"; + private static final String HTTP_SECURITY = "org.springframework.security.config.annotation.web.builders.HttpSecurity"; + private static final String SESSION_CONFIGURER = "org.springframework.security.config.annotation.web.configurers.SessionManagementConfigurer"; + private static final String SESSION_POLICY = "org.springframework.security.config.http.SessionCreationPolicy"; + private static final String RESOURCE_SERVER = "org.springframework.security.config.annotation.web.configurers.oauth2.server.resource.OAuth2ResourceServerConfigurer"; private static final String MESSAGE = "Make sure disabling Spring Security's CSRF protection is safe here."; private static final MethodMatchers DISALLOWED_METHODS = MethodMatchers.create() @@ -36,6 +52,27 @@ public class SpringSecurityDisableCSRFCheck extends AbstractMethodDetection { .withAnyParameters() .build(); + private static final MethodMatchers DISABLE = MethodMatchers.create() + .ofSubTypes("org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer") + .names("disable").addWithoutParametersMatcher().build(); + private static final MethodMatchers SESSION_CREATION_POLICY = MethodMatchers.create() + .ofSubTypes(SESSION_CONFIGURER) + .names("sessionCreationPolicy").addParametersMatcher(SESSION_POLICY).build(); + private static final MethodMatchers OAUTH2_RESOURCE_SERVER = MethodMatchers.create() + .ofTypes(HTTP_SECURITY).names("oauth2ResourceServer").withAnyParameters().build(); + private static final MethodMatchers SESSION_MANAGEMENT = MethodMatchers.create() + .ofTypes(HTTP_SECURITY).names("sessionManagement").withAnyParameters().build(); + private static final MethodMatchers GET_SHARED_OBJECT = MethodMatchers.create() + .ofSubTypes("org.springframework.security.config.annotation.AbstractConfiguredSecurityBuilder") + .names("getSharedObject").addParametersMatcher("java.lang.Class").build(); + private static final MethodMatchers DEFAULT_CUSTOMIZER = MethodMatchers.create() + .ofTypes("org.springframework.security.config.Customizer").names("withDefaults").addWithoutParametersMatcher().build(); + private static final MethodMatchers BROWSER_AUTHENTICATION = MethodMatchers.create() + .ofTypes(HTTP_SECURITY).names("httpBasic", "formLogin", "rememberMe", "oauth2Login", "x509", "jee", "saml2Login") + .withAnyParameters().build(); + private static final MethodMatchers REQUIRE_CSRF_MATCHER = MethodMatchers.create() + .ofTypes(CSRF_CONFIGURER_CLASS).names("requireCsrfProtectionMatcher") + .addParametersMatcher("org.springframework.security.web.util.matcher.RequestMatcher").build(); @Override protected MethodMatchers getMethodInvocationMatchers() { @@ -46,7 +83,7 @@ protected MethodMatchers getMethodInvocationMatchers() { protected void onMethodInvocationFound(MethodInvocationTree mit) { if (mit.methodSelect().is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree selectExpression = (MemberSelectExpressionTree) mit.methodSelect(); - if (selectExpression.expression().symbolType().is(CSRF_CONFIGURER_CLASS)) { + if (selectExpression.expression().symbolType().is(CSRF_CONFIGURER_CLASS) && !isSafeDisabling(mit)) { reportIssue(selectExpression.identifier(), MESSAGE); } } @@ -55,8 +92,181 @@ protected void onMethodInvocationFound(MethodInvocationTree mit) { @Override protected void onMethodReferenceFound(MethodReferenceTree methodReferenceTree) { var typeArgs = methodReferenceTree.symbolType().typeArguments(); - if (typeArgs.size() == 1 && typeArgs.get(0).is(CSRF_CONFIGURER_CLASS)) { + if (typeArgs.size() == 1 && typeArgs.get(0).is(CSRF_CONFIGURER_CLASS) + && !(DISABLE.matches(methodReferenceTree) && isStatelessResourceServer(methodReferenceTree))) { reportIssue(methodReferenceTree.method(), MESSAGE); } } + + private static boolean isSafeDisabling(MethodInvocationTree invocation) { + return (DISABLE.matches(invocation) || isAlwaysFalseMatcher(invocation)) && isStatelessResourceServer(invocation); + } + + private static boolean isAlwaysFalseMatcher(MethodInvocationTree invocation) { + if (!REQUIRE_CSRF_MATCHER.matches(invocation)) { + return false; + } + ExpressionTree matcher = ExpressionUtils.skipParentheses(invocation.arguments().get(0)); + if (!(matcher instanceof LambdaExpressionTree lambda)) { + return false; + } + Tree body = lambda.body(); + if (body instanceof BlockTree block && block.body().size() == 1 && block.body().get(0) instanceof ReturnStatementTree returned) { + body = returned.expression(); + } + return body instanceof ExpressionTree expression && LiteralUtils.isFalse(ExpressionUtils.skipParentheses(expression)); + } + + private static boolean isStatelessResourceServer(Tree disabling) { + MethodTree method = (MethodTree) ExpressionUtils.getParentOfType(disabling, Tree.Kind.METHOD); + if (method == null || method.block() == null + || !method.symbol().returnType().type().isSubtypeOf("org.springframework.security.web.SecurityFilterChain") + || !method.symbol().metadata().isAnnotatedWith("org.springframework.context.annotation.Bean") + || method.block().body().stream().anyMatch(statement -> !statement.is(Tree.Kind.EXPRESSION_STATEMENT, Tree.Kind.RETURN_STATEMENT))) { + return false; + } + var builders = method.parameters().stream().filter(parameter -> parameter.symbol().type().is(HTTP_SECURITY)).toList(); + if (builders.size() != 1) { + return false; + } + Symbol builder = builders.get(0).symbol(); + if (!builder.equals(builderOf(disabling)) || builder.usages().stream().anyMatch(usage -> !isReceiverUsage(usage))) { + return false; + } + List invocations = new ArrayList<>(); + List escapingConfigurers = new ArrayList<>(); + method.block().accept(new BaseTreeVisitor() { + @Override + public void visitMethodInvocation(MethodInvocationTree invocation) { + invocations.add(invocation); + super.visitMethodInvocation(invocation); + } + + @Override + public void visitLambdaExpression(LambdaExpressionTree lambda) { + lambda.parameters().stream() + .filter(parameter -> parameter.symbol().type().is(SESSION_CONFIGURER) || parameter.symbol().type().is(RESOURCE_SERVER)) + .filter(parameter -> parameter.symbol().usages().stream().anyMatch(usage -> !isReceiverUsage(usage))) + .forEach(parameter -> escapingConfigurers.add(parameter.simpleName())); + super.visitLambdaExpression(lambda); + } + }); + var returns = method.block().body().stream().filter(statement -> statement.is(Tree.Kind.RETURN_STATEMENT)).toList(); + if (returns.size() != 1 || !builder.equals(builderOf(((ReturnStatementTree) returns.get(0)).expression()))) { + return false; + } + if (escapingConfigurers.stream().anyMatch(identifier -> builder.equals(builderOf(identifier)))) { + return false; + } + var configuration = invocations.stream().filter(invocation -> builder.equals(builderOf(invocation))).toList(); + return configuration.stream().anyMatch(invocation -> OAUTH2_RESOURCE_SERVER.matches(invocation) && !isConditional(invocation)) + && configuration.stream().noneMatch(invocation -> BROWSER_AUTHENTICATION.matches(invocation) && !isDisabledConfigurer(invocation)) + && configuration.stream().noneMatch(SpringSecurityDisableCSRFCheck::hasUnresolvedRequiredCustomizer) + && configuration.stream().noneMatch(invocation -> DISABLE.matches(invocation) && isRequiredConfigurerReceiver(invocation)) + && configuration.stream().anyMatch(SpringSecurityDisableCSRFCheck::isStatelessPolicy) + && configuration.stream().noneMatch(invocation -> SESSION_CREATION_POLICY.matches(invocation) && !isStatelessPolicy(invocation)); + } + + private static boolean isReceiverUsage(IdentifierTree identifier) { + Tree expression = ExpressionUtils.skipParenthesesUpwards(identifier); + boolean receiver = false; + while (expression.parent() instanceof MemberSelectExpressionTree select && select.expression() == expression + && select.parent() instanceof MethodInvocationTree invocation && invocation.methodSelect() == select) { + receiver = true; + expression = ExpressionUtils.skipParenthesesUpwards(invocation); + } + return receiver && (expression.parent().is(Tree.Kind.EXPRESSION_STATEMENT, Tree.Kind.LAMBDA_EXPRESSION) + || (expression.parent().is(Tree.Kind.RETURN_STATEMENT) + && ((ExpressionTree) expression).symbolType().isSubtypeOf("org.springframework.security.web.SecurityFilterChain"))); + } + + private static boolean hasUnresolvedRequiredCustomizer(MethodInvocationTree invocation) { + return (OAUTH2_RESOURCE_SERVER.matches(invocation) || SESSION_MANAGEMENT.matches(invocation)) && invocation.arguments().stream() + .map(ExpressionUtils::skipParentheses) + .anyMatch(argument -> !argument.is(Tree.Kind.LAMBDA_EXPRESSION) + && !(argument instanceof MethodInvocationTree customizer && DEFAULT_CUSTOMIZER.matches(customizer))); + } + + /** + * Whether a configurer call such as {@code httpBasic} only disables that configurer, in one of the three forms + * {@code httpBasic().disable()}, {@code httpBasic(AbstractHttpConfigurer::disable)} or {@code httpBasic(c -> c.disable())}. + */ + private static boolean isDisabledConfigurer(MethodInvocationTree invocation) { + if (invocation.arguments().isEmpty()) { + return invocation.parent() instanceof MemberSelectExpressionTree select + && select.parent() instanceof MethodInvocationTree disable + && disable.methodSelect() == select + && DISABLE.matches(disable); + } + ExpressionTree customizer = ExpressionUtils.skipParentheses(invocation.arguments().get(0)); + if (customizer instanceof MethodReferenceTree reference) { + return DISABLE.matches(reference); + } + return customizer instanceof LambdaExpressionTree lambda + && lambda.parameters().size() == 1 + && lambda.body() instanceof MethodInvocationTree body + && DISABLE.matches(body) + && body.methodSelect() instanceof MemberSelectExpressionTree select + && select.expression() instanceof IdentifierTree receiver + && receiver.symbol().equals(lambda.parameters().get(0).symbol()); + } + + private static boolean isRequiredConfigurerReceiver(MethodInvocationTree invocation) { + return invocation.methodSelect() instanceof MemberSelectExpressionTree select + && (select.expression().symbolType().is(RESOURCE_SERVER) || select.expression().symbolType().is(SESSION_CONFIGURER)); + } + + private static boolean isStatelessPolicy(MethodInvocationTree invocation) { + if (!SESSION_CREATION_POLICY.matches(invocation) || isConditional(invocation)) { + return false; + } + ExpressionTree policy = ExpressionUtils.skipParentheses(invocation.arguments().get(0)); + if (policy instanceof MemberSelectExpressionTree select) { + policy = select.identifier(); + } + return policy instanceof IdentifierTree identifier + && identifier.symbol().owner().type().is(SESSION_POLICY) && "STATELESS".equals(identifier.name()); + } + + private static boolean isConditional(Tree tree) { + for (Tree parent = tree.parent(); parent != null && !parent.is(Tree.Kind.METHOD); parent = parent.parent()) { + if (parent instanceof LambdaExpressionTree lambda && lambda.body() instanceof BlockTree block + && block.body().stream().anyMatch(statement -> !statement.is(Tree.Kind.EXPRESSION_STATEMENT))) { + return true; + } + if (parent instanceof LambdaExpressionTree lambda + && !(lambda.symbolType().is("org.springframework.security.config.Customizer") + && lambda.parent().parent() instanceof MethodInvocationTree invocation + && invocation.methodSelect() instanceof MemberSelectExpressionTree select && select.expression().symbolType().is(HTTP_SECURITY))) { + return true; + } + if (parent.is(Tree.Kind.IF_STATEMENT, Tree.Kind.CONDITIONAL_EXPRESSION, Tree.Kind.CONDITIONAL_AND, Tree.Kind.CONDITIONAL_OR, + Tree.Kind.SWITCH_STATEMENT, Tree.Kind.SWITCH_EXPRESSION, Tree.Kind.FOR_STATEMENT, Tree.Kind.FOR_EACH_STATEMENT, + Tree.Kind.WHILE_STATEMENT, Tree.Kind.DO_STATEMENT, Tree.Kind.TRY_STATEMENT)) { + return true; + } + } + return false; + } + + private static Symbol builderOf(Tree tree) { + if (tree instanceof MethodReferenceTree reference) { + return builderOf(ExpressionUtils.getParentOfType(reference, Tree.Kind.METHOD_INVOCATION)); + } + if (tree instanceof MethodInvocationTree invocation && !GET_SHARED_OBJECT.matches(invocation) + && invocation.methodSelect() instanceof MemberSelectExpressionTree select) { + return builderOf(select.expression()); + } + if (tree instanceof IdentifierTree identifier) { + if (identifier.symbolType().is(HTTP_SECURITY)) { + return identifier.symbol(); + } + Tree declaration = identifier.symbol().declaration(); + Tree lambda = declaration == null ? null : ExpressionUtils.getParentOfType(declaration, Tree.Kind.LAMBDA_EXPRESSION); + if (lambda instanceof LambdaExpressionTree expression && expression.parameters().contains(declaration)) { + return builderOf(ExpressionUtils.getParentOfType(lambda, Tree.Kind.METHOD_INVOCATION)); + } + } + return null; + } } diff --git a/java-checks/src/test/java/org/sonar/java/checks/spring/SpringSecurityDisableCSRFCheckTest.java b/java-checks/src/test/java/org/sonar/java/checks/spring/SpringSecurityDisableCSRFCheckTest.java index 68a07dd14eb..dd8b9a4b17b 100644 --- a/java-checks/src/test/java/org/sonar/java/checks/spring/SpringSecurityDisableCSRFCheckTest.java +++ b/java-checks/src/test/java/org/sonar/java/checks/spring/SpringSecurityDisableCSRFCheckTest.java @@ -23,19 +23,22 @@ class SpringSecurityDisableCSRFCheckTest { + private static final String SAMPLE = "checks/spring/SpringSecurityDisableCSRFCheckSample.java"; + private static final SpringSecurityDisableCSRFCheck CHECK = new SpringSecurityDisableCSRFCheck(); + @Test void test() { CheckVerifier.newVerifier() - .onFile(mainCodeSourcesPath("checks/spring/SpringSecurityDisableCSRFCheckSample.java")) - .withCheck(new SpringSecurityDisableCSRFCheck()) + .onFile(mainCodeSourcesPath(SAMPLE)) + .withCheck(CHECK) .verifyIssues(); } @Test void test_without_semantic() { CheckVerifier.newVerifier() - .onFile(mainCodeSourcesPath("checks/spring/SpringSecurityDisableCSRFCheckSample.java")) - .withCheck(new SpringSecurityDisableCSRFCheck()) + .onFile(mainCodeSourcesPath(SAMPLE)) + .withCheck(CHECK) .withoutSemantic() .verifyNoIssues(); }