ALOM

🔒 Security

UBER

🤔 Problématiques :

Comment sécuriser les données ?
Comment authentifier les utilisateurs ?

🎚️ Niveaux de sécurité

Physique : Contrôle d'accès, biométrie
Hardware : Encryption des disques
Middleware : Firewalls (blocage d'IP/Ports), VPN (réseaux privés virtuels)
Software : Authentification/Autorisation
Data : Hashage / Chiffrement

HTTPS

HTTPS fournit un tunnel de communications sécurisé

Encryption des données via un algorithme asymétrique

Certificat validant l'identité du site + clé publique

HTTPS

⚠️ HTTPS

Chiffre les données entre le client et le serveur
Ne permet pas de valider l'identité de l'utilisateur

Software Security

Authentication (authentification)
Authorization (autorisation)

Authentication

Vérification de l'identité d'un "principal" (un user, un device, un système qui veut effectuer une action)

Authorization

Décider si un "principal" peut faire une action en particulier. (contrôle d'accès)

Authentification en HTTP

Utilisation du header

Authorization: <type> <credentials>

Authorization: Basic QXNoOnBhc3N3b3Jk

Authorization: Bearer QXNoOnBhc3N3b3Jk

Authentification en HTTP

Authorization: Basic QXNoOnBhc3N3b3Jk

Les logins/mots de passe (ou tokens) transitent dans les headers

C'est pour ça que l'on doit utiliser HTTPS !

En servlets

Utilisation des servlet filters

En

spring-security

Authentification (validation des credentials)
Utilisation d'un Cookie HTTP pour identifiant de session
Stockage de "principal" en session côté serveur
Logout : suppression de la session
Protection contre le vol de session (CSRF & Session Fixation)
Protection contre les appels venant de sources inconnues (CORS)

#### spring-security

```xml
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-security</artifactId>
                </dependency>
                ```

Le simple fait d'ajouter spring security au classpath sécurise toutes les routes d'une application et
                ajoute une page de login par défaut.

---

#### spring-security

⚠️ Les points listés dans ces slides sont pour Spring Boot 3 et Spring Security 6 (état de l'art)

⚠️ Pour d'anciennes version de Spring Boot (2), les configuration sont différentes, mais les grands principes sont les mêmes

---

#### spring-security

2 _Beans_ importants :

Un bean de type `SecurityFilterChain` permet de configurer les règles de sécurité :

* routes à protéger
                * écran de login

Spring Security utilise des `AuthenticationProvider` pour valider les login/mdp ou tokens, et charger des rôles d'accès.

---

#### spring-security

##### `SecurityFilterChain`

```java
@Configuration
public class SecurityConfig {

@Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(Customizer.withDefaults())
            .authorizeHttpRequests(authorize -> {
               authorize.requestMatchers("/unsecured/**").permitAll();
               authorize.requestMatchers("/api/**").authenticated();
               authorize.requestMatchers("/api/admin/**").hasRole("ADMIN");
               authorize.anyRequest().authenticated();
            })
            .httpBasic(Customizer.withDefaults())
            .formLogin(Customizer.withDefaults());
        return http.build();
    }
}
                ```

---

#### spring-security

##### `AuthenticationProvider`

Par défaut, Spring Security initialise un `DaoAuthenticationProvider`, qui s'appuie sur un `UserDetailsService`.

```java
@Configuration
public class SecurityConfig {

@Bean
	public UserDetailsService userDetailsService() {
		UserDetails userDetails = User.withDefaultPasswordEncoder()
			.username("user")
			.password("password")
			.roles("USER")
			.build();

return new InMemoryUserDetailsManager(userDetails);
	}
}

---

#### spring-security

Récupération des utilisateurs via un `UserDetailsService`.
                Par défaut, un `UserDetailsService` *in-memory* est créé à partir des properties:
                * `spring.security.user.name`
                * `spring.security.user.password`
                * `spring.security.user.roles`

---
                #### spring-security

Configuration d'un `UserDetailsService` avec un Bean Spring.
                Un `UserDetailsService` doit retourner des `UserDetails`.

```java
@Autowired
private TrainerService trainerService;

@Bean
@Override
public UserDetailsService userDetailsService() {
    return username -> Optional.ofNullable(trainerService.getTrainer(username))
            .orElseThrow(() -> new BadCredentialsException("No such user"));
}
                ```

spring-security

Page de login

spring-security

Sécurisation des services REST par défaut

Username : user
Password : loggué sur la console

Using generated security password: 112eb169-1567-42fe-bf0e-7c7bc94a5afa

spring-security

Personalisation de la sécurisation des services REST

Username : spring.security.user.name
Password : spring.security.user.password

#### spring-security

##### Gestion des rôles.

Un user a des `GrantedAuthority`.

Une `GrantedAuthority` = un *rôle*.

A positionner par les `AuthenticationProvider`, ou par le `UserDetailsService`, dans les objets `UserDetails`.

```java
UserDetails userDetails = User.withDefaultPasswordEncoder()
			.username("user")
			.password("password")
			.roles("USER") // ici ! crée un GrantedAuthority("ROLE_USER")
			.build();

```

---

#### spring-security

##### Gestion des rôles.

Autorisations au niveau des méthodes (contrôleur, ou service).

##### Annotations JSR-250 (standard Java, dans `jakarta.annotation-api`)

```java
                @Configuration
                @EnableMethodSecurity(jsr250Enabled = true)
                public class MethodSecurityConfig {
                }
                ```

```java
                @RolesAllowed("TRAINER") // sans le "ROLE_"
                ModelAndView myTrainerMethod(){...}
                ```
                ```java
                @RolesAllowed("ADMIN")
                ModelAndView myAdminMethod(){...}
                ```

---

#### spring-security

##### Gestion des rôles.

Autorisations au niveau des méthodes (contrôleur, ou service).

##### Annotations Spring Security [doc](https://docs.spring.io/spring-security/reference/servlet/authorization/method-security.html)

`@PreAuthorize`, `@PostAuthorize`, `@PreFilter`, `@PostFilter`.

```java
                @Configuration
                @EnableMethodSecurity
                public class MethodSecurityConfig {
                }
                ```

```java
                @PreAuthorize("hasRole('TRAINER')") // sans le "ROLE_"
                ModelAndView myTrainerMethod(){...}
                ```
                ```java
                @PostAuthorize("returnObject.name == authentication.name")
                Trainer someMethod(){...}
                ```

TP

Security 🔒