Configurando Spring Security

Hoy vamos intentar hacer un pequeño tutorial que muestre cómo configurar Spring Security en nuestros proyectos Java.

Spring Security es un framework que permitirá gestionar todo lo relativo a la seguridad de nuestra aplicación web, desde el protocolo de seguridad, hasta los roles que necesitan los usuarios para acceder a los diferentes recursos de la aplicación.

Toda la información necesaria, se puede obtener leyendo la documentación oficial de Spring. Por supuesto, la cantidad de información que aparece ahí es enorme, lo que hace tedioso su lectura. Además, para una configuración básica, no nos hace falta saber cómo configurar Spring Security para que, por ejemplo, se autentique contra un LDAP o un CAS. Por eso, intentaremos hacer un resumen y explicaremos solamente la configuración básica, dejando para otros artículos, otras configuraciones más complicadas.

Antes de continuar, hay que decir que Spring Security puede llegar a facilitar mucho las cosas dependiendo de nuestras necesidades. Se podría decir que Spring Security es declarativo y apenas hace falta programar nada y todo se configura mediante un fichero de configuración. Esto llega a tal punto que incluso no es necesario crear una página de Login, ya que Spring Security lo hace por ti. Lo único que hay que enseñarle es a recuperar los datos del usuario que se está intentando loguear en nuestra aplicación. Obviamente, si nuestra aplicación lo requiere o necesitamos personalizar algunos aspectos, Spring Security también te lo permitirá indicándoselo en el fichero de configuración.

Lo primero que debemos hacer es incluir las dependencias adecuadas en nuestro pom.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

 <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-core</artifactId>
        <version>3.0.5.RELEASE</version>
        <type>jar</type>
        <scope>compile</scope>
 </dependency>
 <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-web</artifactId>
        <version>3.0.5.RELEASE</version>
        <type>jar</type>
        <scope>compile</scope>
 </dependency>
 <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-config</artifactId>
        <version>3.0.5.RELEASE</version>
        <type>jar</type>
        <scope>compile</scope>
 </dependency>

El siguiente paso es habilitar Spring Security. Básicamente bastaría con ir creando filtros en el web.xml de nuestra aplicación, pero se puede convertir en ineficiente e ilegible si se empiezan a crear muchos filtros. Por lo tanto, la forma correcta de usar Spring Security, es añadiendo un único filtro en el web.xml. Así, éste delegará en los filtros que se creen en el fichero de configuración de Spring Security de la siguiente forma:

1
2
3
4
5
6
7
8
9

<filter>
     <filter-name>springSecurityFilterChain</filter-name>
     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
 
<filter-mapping>
     <filter-name>springSecurityFilterChain</filter-name>
     <url-pattern>/*</url-pattern>
</filter-mapping>

A continuación es necesario crear el archivo de configuración de Spring Security, que llamaremos spring-security.xml.

Existen dos formas de configurar Spring Security: una 100% manual y otra algo más automática. La forma manual consiste en definir todos los filtros necesarios para su correcto funcionamiento.
La otra forma, que es la que mostraremos, consiste en usar el elemento http. Este elemento configurará por nosotros todos los filtros obligatorios, beans y la cadena de seguridad. Si además se le pone el atributo auto-config a true, configurará todos los filtros restantes necesarios para el funcionamiento.

El primero de los beans que se crea es el springSecurityFilterChain, que es el encargado de gestionar los diferentes filtros de la cadena de seguridad.

Obviamente, se pueden personalizar los filtros que se configuran automáticamente e incluso añadir los nuestros propios. Esto se realiza anidando un nuevo elemento en el http. Con el custom-filter, se pueden añadir nuevos filtros, así como posicionarlos donde sea necesario en la cadena de seguridad. Es posible que alguno de los nuevos filtros entren en conflicto con algunos de los existentes. Esto ocurrirá si estamos sobreescribiendo un filtro existente, con lo cual, habrá que poner el atributo auto-config a false.

Se define también el filtro de autenticación (authenticationProcessingFilter), que será el que permita generar la sesión, el token, etc en el SecurityContext. Probablemente, con los valores por defecto sería suficiente, pero es interesante definirlo para poder configurar una serie de propiedades importantes.

La primera y fundamental es el AuthenticationManager. Este bean, entre otras cosas, es el encargado de recuperar la información de usuario que se está intentando loguear en el sistema. Esto lo consigue mediante un provider que es necesario definir. Este provider es el que proporciona al AuthenticationManager los detalles de nuestro usuario. Así, el provider construye un objeto UsernamePasswordAuthenticationToken si la contraseña es la correcta y se lo pasa al AuthenticationManager. Éste será el que se encargue de rellenar el SecurityContextHolder. Se pueden definir varios providers según sea necesario, e incluso definir uno propio.

Otra propiedad del AuthenticationManager es authenticationSuccessHandler. De la forma mostrada, indicando SavedRequestAwareAuthenticationSuccessHandler, se redirigirá a la página que se solicitaba originalmente antes de la autenticación. Se proporciona el default por si no estaba pidiendo ninguna página en concreto.

Como habíamos dicho, utilizaremos el elemento http por ser en principio más cómodo. Si fuera necesario añadir más elementos de este tipo, para cada uno de ellos será necesario indicarle el atributo pattern, ya que de no existir, se asume el universal (pattern=”/**”), lo que capturaría todas las peticiones.
Nota: en las urls no incluir el contextPath (nombre de la app).

A continuación, se muestra un ejemplo del fichero completo (descarga):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:sec="http://www.springframework.org/schema/security"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.0.xsd">
 
 
    <bean id="authenticationProcessingFilter" class="org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter">
        <property name="authenticationManager" ref="authenticationManager" />
        <property name="filterProcessesUrl" value="/j_spring_security_check" />
        <property name="authenticationSuccessHandler">
            <bean class="org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler">
                <property name="defaultTargetUrl" value="/pages/home" />
            </bean>
        </property>
        <property name="authenticationFailureHandler">
            <bean class="org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler">
                <property name="defaultFailureUrl" value="/pages/errorlogin" />
            </bean>
        </property>
    </bean>
 
    <bean id="authenticationManager" class="org.springframework.security.authentication.ProviderManager">
        <property name="providers">
            <list>
                <ref bean="myAuthenticationProvider" />
            </list>
        </property>
    </bean>
 
    <bean id="myAuthenticationProvider" class="com.cleventy.spring.filter.MyAuthenticationProvider">
        <property name="userDetailsService" ref="myUserDetailsService" />
    </bean>
 
    <bean id="myUserDetailsService" class="com.cleventy.spring.filter.MyUserDetailsService" />
 
    <sec:http auto-config="true" use-expressions="true" access-denied-page="/pages/denied"
        authentication-manager-ref="authenticationManager">
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/user/*" access="hasRole('USER')" />
        <sec:form-login login-page="/login" default-target-url="/user" />
        <sec:logout invalidate-session="true" delete-cookies="JSESSIONID" logout-success-url="/" logout-url="/j_spring_security_logout" />
    </sec:http>
 
</beans>

Como se puede ver en el ejemplo anterior, es posible también definir roles de usuario que tendrán acceso a ciertos patrones de URL. Se configurará declarativamente en el spring-security.xml, pero también será necesario asignar el rol correspondiente al usuario programáticamente una vez que el login haya sido satisfactorio. El proceso, por lo tanto, sería el siguiente. El UserDetailsService recupera de base de datos la información del usuario que se quiere loguear, creando un objeto de tipo UserDetails. Entre los detalles de ese usuario, se encuentran los “authorities”, es decir, los posibles roles que tendrá el usuario. Por lo tanto, en el momento de recuperación y creación de ese objeto, es necesario también indicar los roles correctos. De esta forma, el AuthenticationProvider ya tendrá todos los datos necesarios para crear el UsernamePasswordAuthenticationToken y el AuthenticationManager sabrá si el usuario puede o no acceder a la url que solicita. Veamos la implementación de un provider de ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

 
public class MyAuthenticationProvider implements AuthenticationProvider {
 
    private UserDetailsService userDetailsService;
 
    public void setUserDetailsService(UserDetailsService userDetailsService) {
 
        this.userDetailsService = userDetailsService;
    }
 
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
 
        UserDetails userDetails = this.userDetailsService.loadUserByUsername(authentication.getName());
        if (userDetails != null && new BasicPasswordEncryptor().checkPassword(authentication.getCredentials().toString(),
                        userDetails.getPassword())) {
            return new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
        }
 
        throw new BadCredentialsException("Bad credentials");
    }
}

Ya estamos terminando. Resta añadir el archivo recién creado al contexto para que se cargue. Esto se realiza como cualquier otro archivo de configuración.

1
2
3
4
5
6
7

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:applicationContext.xml
            classpath:spring-security.xml    
        </param-value>
    </context-param>

Se podría decir que ya tenemos todo configurado. Como habíamos comentado al principio, Spring Security incluso te genera una página de login, pero si lo que queremos es adaptar la nuestra, simplemente debemos seguir unas simples convenciones

• el atributo action debe tener el valor “j_spring_security_check”:

  <form action="j_spring_security_check" method="post"></form>

• el atributo name del input para el usuario debe ser “j_username”:

  <input type="text" name="j_username" />

• el atributo name del input para el password debe ser “j_password”:

  <input type="password" name="j_password" />

Obviamente, también es posible personalizar cada uno de estos nombres preestablecidos.

Por último, y para terminar este tutorial, un usuario tiene que poder salir de la página y eliminar la sesión actual. Para esto, hay que configurar el LogoutFilter. En el spring-security.xml hay que incluir las siguientes líneas:

1

<sec:logout invalidate-session="true" delete-cookies="JSESSIONID" logout-success-url="/" logout url="/j_spring_security_logout" />

De esta forma en nuestro html, debemos definir un enlace como el siguiente para que Spring Security se encargue de todo:

<a href="j_spring_security_logout">Logout</a>

Hasta aquí este tutorial. Ha sido un poco denso, pero con paciencia podremos realizar unaconfiguración básica de Spring Security en poco tiempo.

« Tutorial Amazon EC2: Cómo configurar el sistema de caché xCache para Prestashop. Renovarse o morir: ¿ha llegado el momento de renovar mi página web? »