Utilisation de Spring Security OAuth pour une autorisation sécurisée dans le développement d'API Java-javaDidacticiel-php.cn

Une exigence courante dans le développement d'API Java est d'implémenter des fonctions d'authentification et d'autorisation des utilisateurs. Afin de fournir des services API plus sécurisés et plus fiables, la fonction d'autorisation est devenue particulièrement importante. Spring Security OAuth est un excellent framework open source qui peut nous aider à implémenter des fonctions d'autorisation dans les API Java. Cet article explique comment utiliser Spring Security OAuth pour une autorisation sécurisée.

Qu'est-ce que Spring Security OAuth ?

Spring Security OAuth est une extension du framework Spring Security, qui peut nous aider à implémenter les fonctions d'authentification et d'autorisation OAuth.

OAuth est un standard ouvert permettant d'autoriser des applications tierces à accéder à des ressources. Cela peut nous aider à réaliser le découplage de la logique métier et à sécuriser les applications. Le processus d'autorisation OAuth comprend généralement les rôles suivants :

Utilisateur : le propriétaire de la ressource ;
Client : l'application qui s'applique à accéder aux ressources utilisateur ;
Serveur d'autorisation : le serveur qui gère l'autorisation des utilisateurs ; : stocke le serveur de ressources utilisateur ;

Processus d'autorisation

Spring Security OAuth implémente quatre points de terminaison dans le processus d'autorisation OAuth :

/oauth/authorize : le point de terminaison d'autorisation du serveur d'autorisation ; le point de terminaison du jeton du serveur d'autorisation ;

/oauth/confirm_access : le point de terminaison permettant au client de confirmer l'autorisation ;
/oauth/error : le point de terminaison pour les informations d'erreur du serveur d'autorisation
Spring Security OAuth implémente les quatre modes d'autorisation d'OAuth ; 2.0 :

Mode code d'autorisation : le scénario d'utilisation est que l'autorisation de l'utilisateur est requise au démarrage de l'application ;

Mode mot de passe : le scénario d'utilisation est que le client gère les informations d'identification de l'utilisateur de manière indépendante

Mode simplifié : le scénario d'utilisation est ; que le client s'exécute dans le navigateur et ne nécessite pas le client Protection côté client des informations d'identification de l'utilisateur ;
Mode client : le scénario d'utilisation est que le client ne nécessite pas d'autorisation de l'utilisateur et que le jeton d'accès demandé représente uniquement le client lui-même ;
Ajouter une dépendance Spring Security OAuth

<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.4.RELEASE</version>
</dependency>

Copier après la connexion

Configurez le serveur d'autorisation

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    TokenStore tokenStore;

    @Autowired
    AuthenticationManager authenticationManager;

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
            .withClient("client")
            .secret("{noop}secret")
            .authorizedGrantTypes("client_credentials", "password")
            .scopes("read", "write")
            .accessTokenValiditySeconds(3600)
            .refreshTokenValiditySeconds(7200);
    }

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

Copier après la connexion

Configurer le serveur de ressources

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

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

    @Override
    public void configure(ResourceServerSecurityConfigurer config) throws Exception {
        config.resourceId("my_resource_id");
    }
}

Copier après la connexion

Configurer la sécurité Web

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user")
            .password("{noop}password")
            .roles("USER");
    }

    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

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

Copier après la connexion

Implement UserDetailsService

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        if ("user".equals(username)) {
            return new User("user", "{noop}password",
                    AuthorityUtils.createAuthorityList("ROLE_USER"));
        } else {
            throw new UsernameNotFoundException("username not found");
        }
    }
}

Copier après la connexion

Implémentation de l'API

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

    @GetMapping("/greeting")
    public String getGreeting() {
        return "Hello, World!";
    }
}

Copier après la connexion

Test du processus d'autorisation

http://localhost:8080/oauth/authorize?response_type=code&client_id=client&redirect_uri=http://localhost:8080&scope=read

Copier après la connexion

Ensuite, nous obtenons le jeton d'accès en utilisant le modèle de mot de passe :

curl -X POST 
  http://localhost:8080/oauth/token 
  -H 'content-type: application/x-www-form-urlencoded' 
  -d 'grant_type=password&username=user&password=password&client_id=client&client_secret=secret'

Copier après la connexion

Vous recevrez une réponse JSON contenant le jeton d'accès et le jeton d'actualisation :

{
    "access_token":"...",
    "token_type":"bearer",
    "refresh_token":"...",
    "expires_in":3600,
    "scope":"read"
}

Copier après la connexion

Vous pouvez maintenant utiliser ce jeton d'accès pour accéder au service API :

curl -X GET 
  http://localhost:8080/api/greeting 
  -H 'authorization: Bearer xxx'

Copier après la connexion

où xxx est votre jeton d'accès. Vous recevrez une réponse JSON contenant le message d'accueil « Hello, World ! ».

Dans cet article, nous expliquons comment utiliser Spring Security OAuth pour une autorisation sécurisée. Spring Security OAuth est un framework très puissant qui peut nous aider à mettre en œuvre tous les rôles dans le processus d'autorisation OAuth. Dans les applications pratiques, nous pouvons choisir différents modes d'autorisation et configurations de service en fonction de différentes exigences de sécurité.

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!