spring-security-taglibs

Spring Security 3.2 CSRF deshabilitado para URLs específicas

Question

Habilité CSRF en mi aplicación Spring MVC usando Spring Security 3.2.

Mi spring-security.xml

<http>
 <intercept-url pattern="/**/verify"  requires-channel="https"/>
 <intercept-url pattern="/**/login*"  requires-channel="http"/>
 ...
 ...
 <csrf />
</http>

Intentando deshabilitar CSRF para solicitudes que contienen ''verificar'' en la URL de solicitud.

MySecurityConfig.java

@Configuration
@EnableWebSecurity
public class MySecurityConfig extends WebSecurityConfigurerAdapter {

private CsrfMatcher csrfRequestMatcher = new CsrfMatcher();

@Override
public void configure(HttpSecurity http) throws Exception {

    http.csrf().requireCsrfProtectionMatcher(csrfRequestMatcher);

}

class CsrfMatcher implements RequestMatcher {
    @Override
    public boolean matches(HttpServletRequest request) {

        if (request.getRequestURL().indexOf("verify") != -1)
            return false;
        else if (request.getRequestURL().indexOf("homePage") != -1)         
            return false;

        return true;
    }
}

}

El filtro de Csrf valida el token CSRF que se envía desde "verificar" y se emite una excepción de token no válido (403) cuando estoy enviando una solicitud a https desde http. ¿Cómo puedo deshabilitar la autenticación del token csrf en tal escenario?

Answer 1

Espero que mi respuesta pueda ayudar a alguien más. Encontré esta pregunta buscando Cómo deshabilitar CSFR para URL específicas en Spring Boot .

Utilicé la solución descrita aquí: http://blog.netgloo.com/2014/09/28/spring-boot-enable-the-csrf-check-selectively-only-for-some-requests/

Esta es la configuración de Spring Security que me permite deshabilitar el control CSFR en algunas URL:

@Configuration
@EnableWebMvcSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

  @Override
  protected void configure(HttpSecurity http) throws Exception {

    // Build the request matcher for CSFR protection
    RequestMatcher csrfRequestMatcher = new RequestMatcher() {

      // Disable CSFR protection on the following urls:
      private AntPathRequestMatcher[] requestMatchers = {
          new AntPathRequestMatcher("/login"),
          new AntPathRequestMatcher("/logout"),
          new AntPathRequestMatcher("/verify/**")
      };

      @Override
      public boolean matches(HttpServletRequest request) {
        // If the request match one url the CSFR protection will be disabled
        for (AntPathRequestMatcher rm : requestMatchers) {
          if (rm.matches(request)) { return false; }
        }
        return true;
      } // method matches

    }; // new RequestMatcher

    // Set security configurations
    http
      // Disable the csrf protection on some request matches
      .csrf()
        .requireCsrfProtectionMatcher(csrfRequestMatcher)
        .and()
      // Other configurations for the http object
      // ...

    return;
  } // method configure


  @Autowired
  public void configureGlobal(AuthenticationManagerBuilder auth) 
      throws Exception {

    // Authentication manager configuration  
    // ...

  }

}

Funciona con Spring Boot 1.2.2 (y Spring Security 3.2.6).

Answer 2

Estoy usando Spring Security v4.1. Después de una gran cantidad de lecturas y pruebas, deshabilito la función de seguridad crcf para URL específicas utilizando la configuración xml.

<beans:beans xmlns="http://www.springframework.org/schema/security"
             xmlns:beans="http://www.springframework.org/schema/beans"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:util="http://www.springframework.org/schema/util"
             xsi:schemaLocation="
    http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-4.1.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <http pattern="/files/**" security="none" create-session="stateless"/>

    <http>
        <intercept-url pattern="/admin/**" access="hasAuthority(''GenericUser'')" />
        <intercept-url pattern="/**" access="permitAll" />
        <form-login 
            login-page="/login" 
            login-processing-url="/login"
            authentication-failure-url="/login"
            default-target-url="/admin/"
            password-parameter="password"
            username-parameter="username"
        />
        <logout delete-cookies="JSESSIONID" logout-success-url="/login" logout-url="/admin/logout" />
        <http-basic />
        <csrf request-matcher-ref="csrfMatcher"/>
    </http>

    <beans:bean id="csrfMatcher" class="org.springframework.security.web.util.matcher.OrRequestMatcher">
        <beans:constructor-arg>
            <util:list value-type="org.springframework.security.web.util.matcher.RequestMatcher">
                <beans:bean class="org.springframework.security.web.util.matcher.AntPathRequestMatcher">
                    <beans:constructor-arg name="pattern" value="/rest/**"/>
                    <beans:constructor-arg name="httpMethod" value="POST"/>
                </beans:bean>
                <beans:bean class="org.springframework.security.web.util.matcher.AntPathRequestMatcher">
                    <beans:constructor-arg name="pattern" value="/rest/**"/>
                    <beans:constructor-arg name="httpMethod" value="PUT"/>
                </beans:bean>
                <beans:bean class="org.springframework.security.web.util.matcher.AntPathRequestMatcher">
                    <beans:constructor-arg name="pattern" value="/rest/**"/>
                    <beans:constructor-arg name="httpMethod" value="DELETE"/>
                </beans:bean>
            </util:list>
        </beans:constructor-arg>
    </beans:bean>

    //...

</beans:bean>

Con la configuración anterior habilito la seguridad crcf solo para las solicitudes POST | PUT | DELETE de todas las urls que comienzan con /rest/ .

Answer 3

Sé que esta no es una respuesta directa, pero las personas (como yo) generalmente no especifican la versión de Spring cuando buscan este tipo de preguntas. Entonces, desde la seguridad de primavera existe un método que permite ignorar algunas rutas:

Lo siguiente asegurará que la protección CSRF ignore:

1. Cualquier GET, HEAD, TRACE, OPTIONS (este es el valor predeterminado)
2. También declaramos explícitamente ignorar cualquier solicitud que comience con "/ sockjs /"

http .csrf() .ignoringAntMatchers("/sockjs/**") .and() ...

Answer 4

Temporalmente esta simple línea podría ser útil:

<http pattern="/home/test**" security="none" />

Answer 5

Use security = "none". por ejemplo en spring-security-config.xml

<security:intercept-url pattern="/*/verify" security="none" />