Développement backend Java : création d'API sécurisées basées sur OAuth2

OAuth2 est l'un des protocoles d'authentification et d'autorisation largement utilisés dans les applications modernes. Il permet aux utilisateurs d'autoriser des applications tierces à accéder à leurs ressources tout en protégeant les informations sensibles des utilisateurs contre les fuites. Dans cet article, nous présenterons comment créer une API sécurisée basée sur OAuth2 à l'aide du développement backend Java.

1. Qu'est-ce qu'OAuth2 ?

OAuth2 est un protocole d'autorisation populaire conçu pour résoudre les problèmes d'autorisation inter-applications. Il permet aux utilisateurs d'autoriser des applications tierces à accéder à leurs ressources, telles que les comptes Google Drive ou Facebook, tout en protégeant les informations d'identification des utilisateurs contre toute compromission. OAuth2 contient 4 rôles : propriétaire de ressources, client, serveur d'autorisation et serveur de ressources. Le propriétaire de la ressource est l'utilisateur ou l'entité possédant la ressource protégée ; le client est l'application qui demande l'accès à la ressource ; le serveur d'autorisation est le serveur qui vérifie l'identité du propriétaire de la ressource et émet un jeton d'accès ; serveur qui stocke et fournit des ressources. OAuth2 émet un jeton via un serveur d'autorisation et le client utilise le jeton pour demander des ressources au serveur de ressources.

2. Processus OAuth2

Le processus OAuth2 comprend les étapes suivantes :

1. Le client fait une requête au serveur d'autorisation et inclut son identifiant et son URI de redirection.
2. Le serveur d'autorisation vérifie l'identité du client et demande au propriétaire de la ressource d'autoriser le client à accéder à ses ressources.
3. Les propriétaires de ressources autorisent les clients à accéder à leurs ressources.
4. Le serveur d'autorisation émet un jeton d'accès au client.
5. Le client utilise le jeton d'accès pour demander l'accès à la ressource depuis le serveur de ressources.
6. Le serveur de ressources vérifie que le jeton d'accès est valide et fournit la ressource.
7. Créer une API sécurisée basée sur OAuth2

Pour créer une API sécurisée, nous devons mettre en œuvre les étapes suivantes :

1. Créer un serveur OAuth2 : nous devons créer un serveur OAuth2 pour émettre des jetons d'accès, authentifier les identités des clients et autoriser les demandes.
2. Configurer Spring Security : Spring Security est le cadre de sécurité de l'écosystème Spring qui gère l'authentification et l'autorisation. Nous devons configurer le flux d'authentification et d'autorisation OAuth2 pour Spring Security.
3. Créer un client : nous devons créer un client pour demander l'accès au serveur de ressources et obtenir un jeton d'accès du serveur OAuth2.
4. Créer un serveur de ressources : nous devons créer un serveur de ressources pour stocker et servir les ressources protégées.
5. Vérifier le jeton d'accès : nous devons vérifier si le jeton d'accès est valide sur le serveur de ressources et fournir les ressources correspondantes en fonction de la portée du jeton.

Ce qui suit est un exemple OAuth2 basé sur le framework Java et Spring :

1. Créer un serveur OAuth2 :

@EnableAuthorizationServer
@Configuration
public class OAuth2AuthorizationConfig extends AuthorizationServerConfigurerAdapter {

private final PasswordEncoder passwordEncoder;
private final AuthenticationManager authenticationManager;
private final UserDetailsService userDetailsService;

@Autowired
public OAuth2AuthorizationConfig(
        PasswordEncoder passwordEncoder,
        AuthenticationManager authenticationManager,
        UserDetailsService userDetailsService
) {
    this.passwordEncoder = passwordEncoder;
    this.authenticationManager = authenticationManager;
    this.userDetailsService = userDetailsService;
}

@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    clients.inMemory()
            .withClient("client")
            .secret(passwordEncoder.encode("secret"))
            .authorizedGrantTypes("authorization_code")
            .scopes("read", "write", "trust")
            .redirectUris("http://localhost:8080/login/oauth2/code/");
}

@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
    endpoints.authenticationManager(authenticationManager)
            .userDetailsService(userDetailsService);
}

}

2. Configurer la sécurité Spring :

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
classe publique WebSecurityConfig étend WebSecurityConfigurerAdapter {

private final UserDetailsService userDetailsService;
private final PasswordEncoder passwordEncoder;

@Autowired
public WebSecurityConfig(
        UserDetailsService userDetailsService,
        PasswordEncoder passwordEncoder
) {
    this.userDetailsService = userDetailsService;
    this.passwordEncoder = passwordEncoder;
}

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.userDetailsService(userDetailsService)
            .passwordEncoder(passwordEncoder);
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .antMatchers("/oauth/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2Login();
}

}

3. Créer un client :

@RestController
Contrôleur client de classe publique {

private final OAuth2AuthorizedClientService authorizedClientService;

@Autowired
public ClientController(OAuth2AuthorizedClientService authorizedClientService) {
    this.authorizedClientService = authorizedClientService;
}

@GetMapping("/resource")
public ResponseEntity<String> getResource(OAuth2AuthenticationToken authentication) {
    OAuth2AuthorizedClient authorizedClient = authorizedClientService.loadAuthorizedClient(
            authentication.getAuthorizedClientRegistrationId(),
            authentication.getName()
    );
    HttpHeaders headers = new HttpHeaders();
    headers.setBearerAuth(authorizedClient.getAccessToken().getTokenValue());
    HttpEntity<String> entity = new HttpEntity<>(headers);
    ResponseEntity<String> response = new RestTemplate().exchange(
            "http://localhost:8081/resource",
            HttpMethod.GET,
            entity,
            String.class
    );
    return response;
}

}

4. serveur de ressources créé :

@RestController
classe publique ResourceController {

@GetMapping("/resource")
public ResponseEntity<String> getResource() {
    return ResponseEntity.ok("resource");
}

}

5. Vérifier le jeton d'accès :

@Configuration
@EnableResourceServer
classe publique ResourceServerConfig étend ResourceServerConfigurerAdapter {

@Override
public void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .antMatchers("/oauth/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer()
            .jwt();
}

}

4. Revue

Dans cet article, nous présentons le processus du protocole OAuth2 et fournissons un exemple basé sur le framework Java et Spring. En utilisant OAuth2, nous pouvons créer des API plus sécurisées et protéger les informations sensibles des utilisateurs contre les fuites. Lors du développement d'API, nous devons toujours prêter attention à la sécurité afin de protéger les données des utilisateurs et les ressources des applications.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!