Introducción a Spring Security

Hoy vamos a considerar los siguientes aspectos de Spring Security: · Objetos principales. · El proceso de autenticación. · Integración con el proyecto Spring Security. Spring Security es una framework de tipo Springt para Java Enterprise, que propone un mecanismo de autenticación y autorización, y otras características de seguridad para las aplicaciones empresariales construidas utilizando Spring. El proyecto fue iniciado por Ben Alex a finales de 2003 con el nombre de "Acegi Security" primera versión fue lanzada en 2004. Posteriormente, el proyecto fue retomado por Spring y se convirtió en su proyecto oficial afiliado. Por primera vez se presenta en público con su nuevo nombre "Spring Security" en abril de 2008.

Elementos principales:

· SecurityContextHolder: contiene información sobre el contexto de seguridad actual de la aplicación, que contiene información detallada acerca del usuario que está trabajando actualmente con la aplicación. SecurityContextHolder utiliza ThreadLocal para almacenar esta información, que significa que el contexto de seguridad siempre está disponible para la ejecución de los métodos en el mismo hilo de ejecución (Thread). Para cambiar eso, se puede utilizar un método estático SecurityContextHolder.setStrategyName (estrategia de cadena).
· SecurityContext contiene un objeto de autenticación, es decir, la información de seguridad asociada con la sesión del usuario.
· Authentication - desde punto de vista Spring Security es un usuario (Principal)
· GrantedAuthority representa la autorización dada al usuario de la aplicación, por ejemplo ROLE_ANONYMOUS, ROLE_USER, ROLE_ADMIN.
· UserDetails nos pasa la información necesaria para construir un objeto de autenticación desde los objetos DAO u otras fuentes de información sobre la seguridad. Contiene el nombre de usuario, contraseña: los flags isAccountNonExpired, isAccountNonLocked, isCredentialsNonExpired, IsEnabled y los roles del usuario.
· UserDetailsService, la interfaz utilizada para crear el objeto UserDetails  (que realiza el unico metodo de este interfaz)

UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;

Este método permite de recibir datos de objetos y forman un objeto UserDetails que será utilizado en el contexto de Spring Security.

El proceso de autenticación:

(1) El usuario se tiene que registrar con un nombre (login o correo electrónico) y la contraseña. Nombre de usuario y la contraseña se asocian con una instancia de clase UsernamePasswordAuthenticationToken (una instancia de la interfaz de autenticación) después de que se transfiere a la AuthenticationManager para la verificación.

(2) Si la contraseña no corresponde a la aquella registrada por este usuario, una excepción  BadCredentialsException será lanzada con el mensaje "Credentials non valid".

(3) Si la autenticación es ok, nos devuelve un objeto de la clase Authentication .

(4) A continuación, se crea el contexto de seguridad para cada usuario y el metodo SetAuthentication SecurityContextHolder.getContext será llamado, y el objeto devuelto por AuthenticationManager sera transmitido a este método.

Para integrar Spring Security en su proyecto (Maven):

1. pom.xml

<properties> 
       <spring.version>3.1.4.RELEASE</spring.version> 
</properties> 
<!-- Spring Security --> 
<dependency> 
       <groupId>org.springframework.security</groupId> 
       <artifactId>spring-security-core</artifactId>           
<version>${spring.version}</version> 
</dependency>   
<dependency> 
       <groupId>org.springframework.security</groupId> 
        <artifactId>spring-security-web</artifactId>           
<version>${spring.version}</version> 
</dependency> 
<dependency> 
        <groupId>org.springframework.security</groupId> 
       <artifactId>spring-security-config</artifactId>           
<version>${spring.version}</version> 
</dependency>

2. web.xml

<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>

2. l'XML du Spring avec le réglage de securité:

<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" 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"> <http access-denied-page="/error403.jsp"> <intercept-url pattern="/index*" access="ROLE_USER,ROLE_ANONYMOUS"/> <intercept-url pattern="/add*" access="ROLE_USER"/> <intercept-url pattern="/delete/*" access="ROLE_ADMIN"/> <form-login login-page="/login.jsp" default-target-url="/index" authentication-failure-url="/login.jsp?error=true"/> <logout logout-url="/logout" logout-success-url="/index"/> <anonymous username="guest" granted-authority="ROLE_ANONYMOUS"/> <remember-me/> </http> <authentication-manager> <authentication-provider> <user-service> <user name="admin" password="pass" authorities="ROLE_ADMIN,ROLE_USER"/> <user name="user1" password="1111" authorities="ROLE_USER"/> <user name="user2" password="2222" disabled="true" authorities="ROLE_USER"/> </user-service> </authentication-provider> </authentication-manager> </beans:beans>

Explicación: Se entiende que la página login.jsp contiene un formulario con la acción = "/ j_spring_security_check" con el una check box "_ spring_security_remember_me" nombre de usuario y contraseña ( "j_username" y "j_password"). Son los valores que nos pide Spring Security, sino los parámetros de login no serán transferidos al contexto de seguridad. Después de una autenticación exitosa, el usuario sera redirigido a la página / índice principal del proyecto que ya aplica las reglas de autorización

Sólo los usuarios con derechos ROLE_USER tendrán acceso a esta página principal del proyecto y también a la pagina de "añadir", y sólo a aquellos con derechos de administrador tendrá acceso a la página de "eliminar". El resto de los usuarios van a obtener los derechos de ROLE_ANONYMOUS o GUEST y no van a poder ni ver según que información, ni añadir, ni eliminar. También el acceso autorizado puede ser "atornillado" a los métodos del código Java, para hacer esto hay que añadir el siguiente elemento security.xml :

<global-method-security secured-annotations="enabled" />

O en el código mismo :

public interface AdminService { @Secured("ROLE_ADMIN") public Account editAccount(Account account); }

También podemos utilizar una BD para obtener las contraseñas para el usuario (una manera común para guardar la información sobre login):

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://localhost:3306/<yourDataBaseName>" /> <property name="username" value="root" /> <property name="password" value="password" /> </bean> <authentication-provider> <jdbc-user-service data-source-ref="dataSource" users-by-username-query="select username, password, enabled from users where username = ?" authorities-by-username-query="select u.username, au.authority from users u, authorities au where u.id = au.user_id and u.username = ?" /> </authentication-provider> </beans>

Si las contraseñas son encriptadas - podemos verificarlas también:

<authentication-manager> <authentication-provider> <password-encoder hash="sha"/> <user-service> <user name="jimi" password="d7e6351eaa13189a5a3641bab846c8e8c69ba39f" authorities="ROLE_USER, ROLE_ADMIN" /> <user name="bob" password="4e7421b1b8765d8f9406d87e7cc6aa784c4ab97f" authorities="ROLE_USER" /> </user-service> </authentication-provider> </authentication-manager> <password-encoder hash="sha"> <salt-source user-property="username"/> </password-encoder>