Création d’un projet Spring + hibernate + web service REST + Spring security. 5 – Sécurisation du Web Service

Voici donc le dernier billet de la série. Après avoir vu comment créer le projet et ses objets métiers, créer les DAO, créer les services, et créer un web service REST, voyons maintenant comment sécuriser ce web service.

Il faut d’abord commencer par modifier le web.xml de l’application pour qu’il ressemble à ceci :

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
	<context-param>
	  <param-name>contextConfigLocation</param-name>
	  <param-value>/WEB-INF/applicationContext.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<!-- Rest WS -->
	<servlet>
	  <servlet-name>rest</servlet-name>
	  <servlet-class>
	    com.noelios.restlet.ext.spring.RestletFrameworkServlet
	  </servlet-class>
	</servlet>
	
	<servlet-mapping>
	  <servlet-name>rest</servlet-name>
	  <url-pattern>/rest/*</url-pattern>
	</servlet-mapping>
	
	<!-- Security -->
	<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>
</web-app>

On déclare donc un filtre qui intercepte toutes les urls de l’application.

Toute la configuration se situe maintenant au niveau de Spring. On déclare donc un fichier « applicationContext-security.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"
	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 auto-config="true" use-expressions="true">
		<intercept-url pattern="/**" access="isAuthenticated()" requires-channel="http" />
		<form-login/>
	</http>
	
	<!-- Encodeur md5, pour permettre la lecture de l'empreinte du mdp -->
	<beans:bean id="myPassEncoder" class="org.springframework.security.authentication.encoding.Md5PasswordEncoder"/>
	
	<beans:bean id="saltSource" class="org.springframework.security.authentication.dao.ReflectionSaltSource">
		<beans:property name="userPropertyToUse" value="getUsername"/>
	</beans:bean>



	<beans:bean id="daoAuthenticationProvider" class="org.springframework.security.authentication.dao.DaoAuthenticationProvider">
		<beans:property name="userDetailsService" ref="userService" />
		<beans:property name="passwordEncoder" ref="myPassEncoder"/>
		<beans:property name="saltSource" ref="saltSource"/>
	</beans:bean>
	
	
	<beans:bean id="org.springframework.security.authenticationManager"
		class="org.springframework.security.authentication.ProviderManager">
		<beans:property name="providers">
			<beans:list>
				<beans:ref local="daoAuthenticationProvider" />
			</beans:list>
		</beans:property>
	</beans:bean>	

</beans:beans>

Les 4 premières lignes du fichier indiquent que l’accès à toutes les urls de l’application (/**) est réservé à des utilisateur authentifiés.
La ligne suivante permet de déclarer le PasswordEncoder dont j’avais parlé ici. Ici, on utilise MD5, qui n’est pas le plus sécurisé, mais qui suffit pour la démo.
La ligne d’après crée le SaltSource dont j’avais également parlé ici. La propriété « userPropertyToUse » permet d’indiquer quel propriété de l’utilisateur va être utilisée pour faire le « salt ». Ici, on indique que c’est username. Concrètement, cela signifie que pour un utilisateur dont le login est « test » et donc le mot de passe choisi est « kikoo », le mot de passe enregistré en base sera le hash MD5 de : « kikoo{test} ».
On déclare ensuite le bean fournisseur de l’authentification. Ici, il s’agit d’un DaoAuthenticationProvider, puisque les utilisateurs sont stockés en base. On lui injecte le service des utilisateurs (qui doit obligatoirement implémenter UserDetailsService), le PasswordEncoder et le SaltSource.
Enfin, on déclare un ProviderManager auquel on injecte le bean précédent.

C’est tout ce dont il y a besoin pour la sécurité.
Voyons maintenant comment tester l’application. Pour ma part, j’ai lancé l’application web sur un serveur tomcat. Pour les opérations GET, on peut tout simplement utiliser un navigateur qui va diriger vers la page de login, il faut alors s’authentifier et on est redirigé vers la page qui nous renvoie le XML.
Par exemple :

Pour les autres méthodes (PUT, DELETE, POST), on peut utiliser un client REST. Personnellement, j’ai utilisé un client REST pour firefox.
A noter que pour se logger avec le client REST, il faut commencer par envoyer une requête POST sur « j_spring_security_check » contenant les login et mot de passe.
La configuration à utiliser est la suivante :
URL : http://localhost:8080/JFreeNote/j_spring_security_check
Paramètres du header : Content-Type: application/x-www-form-urlencoded
Corps : j_username=test&j_password=test

Voici un lien pour télécharger la totalité du projet : http://blog.le-guevel.com/wp-content/uploads/2011/05/JFreeNote.zip
La base de données peut-être créée à partir du fichier SQL qui se trouve dans le dossier « bdd ». Il insère un utilisateur dont les login/mot de passe sont test/test
Il s’agit d’un projet eclipse, mais il peut aussi bien être utilisé avec un autre IDE.
En espérant que ça puisse aider des gens