author2 a plusieurs rôles de base:
Propriétaire de la ressource: l'utilisateur
Client: mais application
tripartite Serveur d'autorisation: utilisé pour vérifier que les informations fournies par l'utilisateur sont correctes, et renvoyer un jeton
Serveur de ressources: le serveur qui fournit les ressources à l'utilisateur
Mode d'autorisation:
Mode code d'autorisation: la fonction la plus complète et le processus le plus rigoureux. Le serveur client interagit avec le serveur d'autorisation. La connexion à une plate-forme tierce courante en Chine est réalisée à l'aide de cette fonction.
Mode simplifié: sans la participation du serveur client, demander directement un token auprès du serveur d'autorisation dans le navigateur.En général, le site Web est une page purement statique, et cette méthode peut être utilisée.
Mode mot de passe: indiquez directement au client le nom d'utilisateur et le mot de passe, et le client utilise les informations pour demander un jeton auprès du serveur d'autorisation.
Mode client: le client utilise son propre nom au lieu du nom de l'utilisateur pour demander l'autorisation du serveur.
Ensuite, démarrez springboot integration author2, github: https://github.com/fengqing11/springboot-oauth2 pour
créer un projet avec les dépendances suivantes:
Étant donné que le protocole oauth dans springboot est en fait terminé sur la base de la sécurité de printemps, des dépendances de sécurité de printemps doivent être ajoutées.
- Le jeton est stocké sur le serveur de cache de redis. En même temps, redis a une fonction d'expiration, qui est très appropriée pour le stockage de jetons, donc redis en dépend également.
<? xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns: xsi = "http: //www.w3 .org / 2001 / XMLSchema-instance "
xsi: schemaLocation =" http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd ">
<modelVersion> 4.0.0 </modelVersion><groupId> org.sang </groupId>
<artifactId> oauth2 </artifactId>
<version> 0.0.1-SNAPSHOT </version>
<packaging> pot </packaging><name> oauth2 </name>
<description> Projet de démonstration pour Spring Boot </description><parent>
<groupId> org.springframework.boot </groupId>
<artifactId> spring-boot-starter-parent </artifactId>
<version> 2.0.3.RELEASE </version>
<relativePath /> <! - recherche parent du référentiel ->
</parent><properties>
<project.build.sourceEncoding> UTF-8 </project.build.sourceEncoding>
<project.reporting.outputEncoding> UTF-8 </project.reporting.outputEncoding>
<java.version> 1.8 </java.version >
</properties><dependencies>
<dependency>
<groupId> org.springframework.boot </groupId>
<artifactId> spring-boot-starter-security </artifactId>
</dependency>
<dependency>
<groupId> org.springframework.boot </ groupId >
<artifactId> spring-boot-starter-web </artifactId>
</dependency>
<dependency>
<groupId> org.springframework.boot </groupId>
<artifactId> spring-boot-starter-data-redis </artifactId>
</dependency>
<dependency>
<groupId> org.springframework.security.oauth </groupId>
<artifactId> spring-security-oauth2 </artifactId>
<version> 2.3.3.RELEASE </version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId> org.springframework.boot < / groupId>
<artifactId> spring-boot-maven-plugin </artifactId>
</plugin>
</plugins>
</build>
</project>
Fichier de configuration:
spring.redis.database = 0
spring.redis.host = localhost
spring.redis.port = 6379
spring.redis.password =
spring.redis.jedis.pool.max-active = 8
spring.redis.jedis.pool.max- idle = 8
spring.redis.jedis.pool.max-wait = -1ms
spring.redis.jedis.pool.min-idle = 0
Configurer le serveur d'autorisation: le
serveur d'autorisation et le serveur de ressources peuvent être le même serveur ou des serveurs différents, et le même serveur est utilisé ici.
Séparez le serveur d'autorisation et le serveur de ressources par différentes configurations.
Héritez de AuthorizationServerConfigurerAdapter pour terminer la configuration du serveur d'autorisation, puis activez le serveur d'autorisation via l'annotation @EnableAuthorizationServer.
L'objet AuthenticationManager est utilisé pour prendre en charge le mode d'autorisation de mot de passe.
L'objet RedisConnectionFactory est utilisé pour terminer la mise en cache Redis.
L'objet UserDetailsService prend en charge l'actualisation du jeton.
La méthode allowedGrantTypes () configure le mode d'autorisation comme mot de passe et refresh_token. En fait, il n'y a pas de refresh_token dans l'oauth standard, mais il est classé comme un dans la sécurité de printemps. Par conséquent, refresh_token est nécessaire pour réaliser l'actualisation de access_token.
La méthode accessTokenValiditySeconds () définit l'heure d'expiration du jeton.
La méthode resourceIds () configure les ID de ressource.
La méthode secret () configure le mot de passe crypté, le texte brut est 123.
package org.sang.oauth2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.security.authentication.AuthenticationManager;
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.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStore;@Configuration
@EnableAuthorizationServer
classe publique AuthorizationServerConfig
étend AuthorizationServerConfigurerAdapter { @Autowired AuthenticationManager authenticationManager; @Autowired RedisConnectionFactory redisConnectionFactory; @Autowired UserDetailsService userDetailsService; @Bean PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } @Override public void configure (clients ClientDetailsServiceConfigurer) lève l'exception { clients.inMemory () .withClient ("mot de passe")
.authorizedGrantTypes ("password", "refresh_token")
.accessTokenValiditySeconds (1800)
.resourceIds ("rid")
.scopes ("all")
.secret ("$ 2a $ 10 $ RMuFXGQ5AtH4wOvkUqilvuecpqXceoxb)"
}
@Override
public void configure (AuthorizationServerEndpointsConfigurer endpoints)
lève l'exception { endpoints.tokenStore (nouveau RedisTokenStore (redisConnectionFactory)) .authenticationManager (authenticationManager) .userDetailsService (userDetailsService);
lève Exception { security.allowFormAuthenticationForClients (); } }
Configurer le serveur de ressources:
héritez de ResourceServerConfigurerAdapter et utilisez l'annotation @EnableResourceServer pour activer la configuration du serveur de ressources.
resourceId () pour configurer l'ID de ressource, où l'id doit être le même que l'ID de ressource du serveur d'autorisation.
La méthode stateless () définit ces ressources uniquement en fonction de la vérification des jetons.
package org.sang.oauth2;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;@Configuration
@EnableResourceServer
classe publique ResourceServerConfig
étend ResourceServerConfigurerAdapter { @Override public void configure (ressources ResourceServerSecurityConfigurer) lève Exception { resources.resourceId ("rid"). Stateless (true); } @Override public void configure (HttpSecurity http) lève l'exception { http.authorizeRequests () .antMatchers ("/ admin / **"). HasRole ("admin") .antMatchers ("/ user / **"). HasRole ( "utilisateur") .anyRequest (). authenticated (); } }
Configurer la sécurité: il
n'y a aucune différence par rapport à la précédente. La seule différence est qu'il y a deux autres annotations @bean. Ces deux Beans seront injectés dans le serveur d'autorisation pour utilisation.
La configuration HttpSecurity configure ici principalement l'URL de / oauth / **, et ce type de requête est directement libéré. Il existe également un HttpSecurity dans la configuration du serveur de ressources, où HttpSecurity est prioritaire sur HttpSecurity du serveur de ressources.
package org.sang.oauth2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;@Configuration
classe publique WebSecurityConfig étend WebSecurityConfigurerAdapter { @Bean @Override public AuthenticationManager authenticationManagerBean () jette une exception { return super.authenticationManagerBean (); } @Bean @Override protected UserDetailsService userDetailsService () { return super.userDetailsService (); } @Override protected void configure (AuthenticationManagerBuilder auth) lève l'exception { auth.inMemoryAuthentication () .withUser ("admin") .password ("$ 2a $ 10 $ RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRs"
.roles ("admin") .and
()
.withUser ("sang")
.password ("$ 2a $ 10 $ RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq")
.roles ("utilisateur");
}
@Override
protected void configure (HttpSecurity http) lève l'exception { http.antMatcher ("/ oauth / **"). AuthorizeRequests ( ) .antMatchers ("/ oauth / **"). PermitAll () .and (). Csrf () .disable (); } }
Accès POST après le démarrage du serveur: http://127.0.0.1:8080/oauth/token?username=sang&password=123&grant_type=password&client_id=password&scope=all&client_secret=123
Les paramètres sont écrits sur l'url, ce qui est pratique, mais c'est aussi une demande de publication:
Paramètres de la demande:
nom d'utilisateur: nom d'utilisateur
mot de passe: masque
grant_type: mode d'autorisation
id_client: id du serveur de ressources
portée: étendue du serveur de ressources
client_secret: mot de passe du serveur de ressources
Contenu de retour:
access_token: est le token
token_type:
refresh_token: utilisé pour actualiser le token, il peut être utilisé pour actualiser le token, à condition que le token n'ait pas expiré
expires_in: l'heure d'expiration du token, actualisez à nouveau pour constater que l'implémentation n'est pas à 1800, cela réduit la
portée:
Accès au jeton d'actualisation: http://127.0.0.1:8080/oauth/token?grant_type=refresh_token&refresh_token=6bef362e-a96c-48af-a310-b9623d7c69a4&client_id=password&client_secret=123
Pour accéder aux ressources, visitez: http: // localhost: 8080 / user / hello? Access_token = cf4d8b09-3fe1-4671-91f3-4703d6e75c91
À ce stade, un système d'authentification oauth en mode mot de passe a été construit.
-fin-