Java Suisse: Un aperçu de Spring Security

Aujourd’hui on va considérer des aspects suivants de Spring Security:

· objets principaux.

· Le processus d'authentification.

· Intégration de Spring Security au projet.

Spring Security est un framework Java / JavaEE, fournit un mécanisme d'authentification et d'autorisation, et d'autres fonctions de sécurité pour les applications d'entreprise construit en utilisant le framework Spring. Le projet a été lancé par Ben Alex à la fin de 2003 sous le nom de «Acegi sécurité», première version est sorti en 2004. Par la suite, le projet a été absorbé par Spring et est devenu son projet officiel affilié. Pour la première fois publiquement présenté sous un nouveau nom Spring Security 2.0.0 en Avril de 2008.

Objets Principaux :

· SecurityContextHolder : contient des informations sur le contexte de sécurité actuel de l'application, qui contient des informations détaillées sur l'utilisateur qui travaille actuellement avec l'application. Par défaut SecurityContextHolder utilise ThreadLocal pour stocker ces informations, ce qui signifie que le contexte de sécurité est toujours disponible pour l'exécution de méthodes dans le même fil. Pour changer ca, vous pouvez utiliser une méthode statique SecurityContextHolder.setStrategyName (String strategy).

· SecurityContext, contient un objet d'authentification, i.e. les informations de sécurité associée à la demande de l'utilisateur.

· Authentication représente un utilisateur (Principal) du point de vue du Spring Security.

· GrantedAuthority represente l'autorisation donnée a l’utilisateur d’application, par exemple ROLE_ANONYMOUS, ROLE_USER, ROLE_ADMIN.

· UserDetails fournit les informations nécessaires pour construire l'objet d'authentification à partir d'objets d'application DAO ou d'autres sources d'information sur la sécurité. Il contient le nom d’utilisateur, mot de passe est les flags: isAccountNonExpired, isAccountNonLocked, isCredentialsNonExpired, isEnabled et Collection des droits (rôles) de l'utilisateur.

· UserDetailsService, l’interface utilisée pour créer l'objet UserDetails (qui réalise le seul méthode de cette interface)

UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;

Il permet de recevoir des données d’objet utilisateur et former un objet UserDetails qui sera utilisé dans le contexte de sécurité Spring.

Le processus d'authentification:

(1) L'utilisateur sera invité à se connecter et fournir son nom (login ou e-mail) et mot de passe. Nom d'utilisateur et mot de passe seront associés à une classe UsernamePasswordAuthenticationToken instance (une instance de l'interface d'authentification), après il serait transféré a l'AuthenticationManager pour la vérification.

(2) Si le mot de passe ne correspond pas au nom d'utilisateur, BadCredentialsException sera jetée avec le message « Bad credentials ».

(3) Si l'authentification est ok, un objet de la class Authentication entièrement rempli sera retourné.

(4) Ensuite le contexte de sécurité serait créé pour chaque utilisateur el le méthode SetAuthentication SecurityContextHolder.getContext () (...) sera appelé, où l'objet retourné par AuthenticationManager serait transmit.

Pour intégrer Spring Security dans votre projet :

1. pom.xml

<spring.version>3.1.4.RELEASE</spring.version>

</properties>

<groupId>org.springframework.security</groupId>

<artifactId>spring-security-core</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework.security</groupId>

<artifactId>spring-security-web</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework.security</groupId>

<artifactId>spring-security-config</artifactId>

<version>${spring.version}</version>

</dependency>

2. web.xml

<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 sécurité:

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

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

<remember-me/>

</http>

<authentication-manager>

<authentication-provider>

<user-service>

</user-service>

</authentication-provider>

</authentication-manager>

</beans:beans>

Explication:

Il est entendu que la page login.jsp contient une forme d'action = « / j_spring_security_check » avec le nom d'utilisateur et mot de passe («j_username» et «j_password»), ainsi que un check box « _ spring_security_remember_me ». Il sont les valeurs particulières demandés par Spring Security, autrement les paramètres ne seront pas transférés dans un contexte de sécurité. Une fois l'authentification réussie, l'utilisateur sera redirigé vers la page / index qui applique déjà des règles d'autorisation. Si vous ne spécifiez pas la forme et l'URL pour http-spring-security, la valeur par défaut sera utilisé ou l'authentification par défaut peut être aussi forcée en utilisant le flag <http-basic />.

A la page principal /index juste des utilisateurs avec le ROLE_USER, ainsi que les clients (toutes les connexions qui ne passent pas d'authentification pour obtenir le nom GUEST et ROLE_ANONYMOUS) seront permis à l’accéder.

Juste les utilisateurs avec des droits ROLE_USER vont avoir l’accès a la page « add », et juste ceux avec des droits ADMIN vont avoir l’accès a la page « supprimer » .

Aussi l'accès autorisé peut être « vissé » aux méthodes, pour faire ça il faut ajouter l'élément suivant security.xml:

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

Ainsi que dans le code:

public interface AdminService {

@Secured("ROLE_ADMIN")

public Account editAccount(Account account);

}

Solution ORM (communication avec DB pour obtenir les mots de passes pour l'utilisateur):

Aussi l'accès autorisé peut être « vissé » aux méthodes, pour faire ça il faut ajouter l'élément suivant security.xml:

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

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

Il peut également être vérifié les mots de passe cryptés:

<authentication-manager>

<authentication-provider>

<password-encoder hash="sha"/>

<user-service>

</user-service>

</authentication-provider>

</authentication-manager>

<password-encoder hash="sha">

<salt-source user-property="username"/>

</password-encoder>

Java Suisse

vendredi 12 mai 2017

Un aperçu de Spring Security

Objets Principaux :

Le processus d'authentification:

Aucun commentaire:

Enregistrer un commentaire