Scribd Logo
Importer

Bienvenue sur Scribd !

  • 9 vues

    SpringSecurity

    Transféré par

    Mohamedamine Houidi

    Droits d'auteur :

    © All Rights Reserved
    Téléchargez comme TXT, PDF, TXT ou lisez en ligne sur Scribd

    SpringSecurity

    Transféré par

    Mohamedamine Houidi
    9 vues3 pages

    Copyright

    © © All Rights Reserved

    Formats disponibles

    TXT, PDF, TXT ou lisez en ligne sur Scribd

    Avez-vous trouvé ce document utile ?

    Ce contenu est-il inapproprié ?

    Droits d'auteur :

    © All Rights Reserved
    Téléchargez comme TXT, PDF, TXT ou lisez en ligne sur Scribd
    Télécharger au format txt, pdf ou txt
    9 vues3 pages

    SpringSecurity

    Transféré par

    Mohamedamine Houidi

    Droits d'auteur :

    © All Rights Reserved
    Téléchargez comme TXT, PDF, TXT ou lisez en ligne sur Scribd
    Télécharger au format txt, pdf ou txt
    sur 3

    Spring Security est un puissant framework pour sécuriser les applications Spring.

    Voici un exemple pour intégrer Spring Security dans votre projet Spring Boot. Cet
    exemple implémente une authentification simple en mémoire (avec utilisateurs et
    rôles) et protège vos endpoints REST.

    ---

    ### Étape 1 : Ajouter Spring Security au projet

    1. Accédez à [Spring Initializr](https://start.spring.io).


    2. Ajoutez **Spring Security** comme dépendance.
    3. Importez le projet ou ajoutez la dépendance suivante dans `pom.xml` si elle
    n'existe pas :
    ```xml
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    ```

    ---

    ### Étape 2 : Configurer Spring Security

    #### Classe de configuration


    Créez une classe pour configurer Spring Security :
    ```java
    package com.example.demo.config;

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.core.userdetails.User;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    import org.springframework.security.crypto.password.PasswordEncoder;
    import org.springframework.security.provisioning.InMemoryUserDetailsManager;
    import org.springframework.security.web.SecurityFilterChain;

    @Configuration
    public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws
    Exception {
    http
    .csrf().disable() // Désactiver CSRF pour simplifier les tests des APIs
    .authorizeHttpRequests(authorize -> authorize
    .requestMatchers("/api/public/**").permitAll() // Accessible à tous
    .anyRequest().authenticated() // Authentification requise pour le
    reste
    )
    .httpBasic(); // Utiliser HTTP Basic Authentication pour simplifier

    return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {
    UserDetails user = User
    .withUsername("user")
    .password(passwordEncoder.encode("password"))
    .roles("USER")
    .build();

    UserDetails admin = User


    .withUsername("admin")
    .password(passwordEncoder.encode("admin"))
    .roles("ADMIN")
    .build();

    return new InMemoryUserDetailsManager(user, admin);


    }

    @Bean
    public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder(); // Encodeur pour sécuriser les mots de
    passe
    }
    }
    ```

    ---

    ### Étape 3 : Créer des Endpoints REST sécurisés

    Ajoutez un contrôleur avec des endpoints sécurisés :


    ```java
    package com.example.demo.controller;

    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;

    @RestController
    @RequestMapping("/api")
    public class DemoController {

    @GetMapping("/public")
    public String publicEndpoint() {
    return "This is a public endpoint, accessible to everyone!";
    }

    @GetMapping("/user")
    public String userEndpoint() {
    return "This is a user-protected endpoint, accessible to authenticated
    users!";
    }

    @GetMapping("/admin")
    public String adminEndpoint() {
    return "This is an admin-protected endpoint, accessible to admins only!";
    }
    }
    ```

    ---
    ### Étape 4 : Testez l'application

    1. **Lancez l'application.**
    2. Accédez aux endpoints avec Postman ou cURL :
    - **Endpoint public** :
    ```bash
    curl http://localhost:8080/api/public
    ```
    Réponse : `"This is a public endpoint, accessible to everyone!"`

    - **Endpoint utilisateur** (authentification requise) :


    ```bash
    curl -u user:password http://localhost:8080/api/user
    ```
    Réponse : `"This is a user-protected endpoint, accessible to authenticated
    users!"`

    - **Endpoint admin** (authentification avec rôle admin) :


    ```bash
    curl -u admin:admin http://localhost:8080/api/admin
    ```
    Réponse : `"This is an admin-protected endpoint, accessible to admins only!"`

    ---

    ### Étape 5 : Étendre la configuration


    Pour des besoins plus complexes, vous pouvez :
    - Connecter à une base de données avec **Spring Data JPA**.
    - Intégrer **JWT** pour les APIs REST.
    - Ajouter **OAuth2** pour la gestion des identités externes (Google, GitHub, etc.).

    Si vous avez besoin d’exemples supplémentaires, n’hésitez pas à demander ! 😊

    Vous aimerez peut-être aussi