So verwenden Sie das OAuth2-Framework der SpringBoot-Sicherheitsverwaltung

OAuth3-Einführung

OAuth ist ein offener Standard, der es Benutzern ermöglicht, Anwendungen von Drittanbietern Zugriff auf die privaten Ressourcen des Benutzers (wie Avatare, Fotos, Videos usw.) zu gewähren, die auf einer Website gespeichert sind. Bei diesem Vorgang ist es nicht erforderlich, Benutzernamen und Passwörter an Drittanwendungen weiterzugeben.

Der Zugriff auf Daten, die bei einem bestimmten Dienstanbieter gespeichert sind, erfolgt über einen Token anstelle eines Benutzernamens und eines Passworts. Jeder Token autorisiert eine bestimmte Website, für einen bestimmten Zeitraum auf bestimmte Ressourcen zuzugreifen.

OAuth ermöglicht es Benutzern, Drittanbieter-Websites zu autorisieren, flexibel auf bestimmte Informationen zuzugreifen, die auf anderen Ressourcenservern gespeichert sind, und nicht auf alle Informationen. Wenn sich ein Benutzer beispielsweise über QQ bei Zhihu anmelden möchte, ist Zhihu eine Drittanbieteranwendung. Wenn Zhihu auf einige grundlegende Informationen des Benutzers zugreifen möchte, benötigt es die Autorisierung des Benutzers, wenn der Benutzer Zhihu seinen QQ-Benutzer mitteilt Name und Passwort, dann kann Zhihu auf alle Daten des Benutzers zugreifen und nur der Benutzer kann die Berechtigung durch Ändern seines Passworts widerrufen. Diese Autorisierungsmethode birgt große Sicherheitsrisiken. Wenn Sie OAuth verwenden, kann dieses Problem gut gelöst werden.

Durch die Verwendung von Token können Benutzer Berechtigungen von Drittanbieteranwendungen flexibel autorisieren oder entziehen. OAuth 2 ist die nächste Version des OAuth-Protokolls, ist jedoch nicht abwärtskompatibel mit OAuth 1.0.

OAuth 2 konzentriert sich auf die Einfachheit für Client-Entwickler und bietet gleichzeitig spezielle Authentifizierungsprozesse für Webanwendungen, Desktop-Anwendungen, mobile Geräte und Wohnzimmergeräte. Die herkömmliche Anmeldeauthentifizierung für die Webentwicklung basiert im Allgemeinen auf der Sitzung. Die weitere Verwendung der Sitzung in einer Front-End- und Back-End-Architektur mit getrennten Front-End- und Back-End-Architekturen führt jedoch zu vielen Unannehmlichkeiten, da das mobile Endgerät (Android, IOS, WeChat-Applet usw.) dies nicht tut Unterstützt Cookies (WeChat-Applet) oder ist die Verwendung sehr unpraktisch. Diese Probleme können durch die Verwendung der OAuth 2-Authentifizierung gelöst werden.

OAuth3-Rolle

Verstehen Sie zunächst einige grundlegende Rollen in OAuth 2

• Ressourcenbesitzer: Benutzer, mit Ressourcen B. Avatare, Fotos, Videos usw.: Wird verwendet, um zu überprüfen, ob die vom Benutzer bereitgestellten Informationen korrekt sind, und um ein Token an die Drittanbieteranwendung zurückzugeben

• Ressource Server: Ein Server, der Benutzerressourcen wie Avatare und Fotos, Videos und andere Ressourcen bereitstellt

• Im Allgemeinen können der Autorisierungsserver und der Ressourcenserver derselbe Server sein .

OAuth3-Autorisierungsprozess

• Schritt 01: Der Client (Drittanbieteranwendung) fordert die Autorisierung vom Benutzer an.

Wenn der Benutzer auf der Dienstautorisierungsseite auf die Schaltfläche „Autorisierung zustimmen“ klickt, gibt der Server ein Autorisierungszertifikat an den Client zurück.

Schritt 03: Der Client bringt die Autorisierungslizenz zum Autorisierungsserver, um ein Token zu beantragen.

Schritt 04: Nachdem der Autorisierungsserver überprüft hat, dass die Informationen korrekt sind, stellt er das Token an den Client aus.

Schritt 05: Der Client bringt den Token zum Ressourcenserver, um auf Ressourcen zuzugreifen.

Schritt 06: Der Ressourcenserver öffnet die Ressource, nachdem er überprüft hat, dass das Token korrekt ist.

Autorisierungsmodus

Der Autorisierungsmodus des OAuth-Protokolls ist wie folgt in 4 Typen unterteilt

Autorisierung Code-Autorisierungsmodus Es handelt sich um die umfassendste Funktion und den strengsten Prozess unter den Autorisierungsmethoden, und sein Autorisierungscode ist der Schlüssel. Das Merkmal dieses Modus besteht darin, dass der Client-Server mit dem Autorisierungsserver interagiert. Gängige inländische Anmeldefunktionen von Drittanbieterplattformen übernehmen grundsätzlich diese Methode

Vereinfachter Modus: Vereinfachter Modus erfordert keine Beteiligung des Client-Servers. Sie beantragen ein Token direkt vom Autorisierungsserver im Browser. Wenn es sich um eine rein statische Seite handelt, können Sie diese Methode verwenden

#🎜🎜 #
• im Passwort In diesem Modus geben Benutzer ihren Benutzernamen und ihr Passwort direkt an den Client weiter, und der Client verwendet diese Informationen, um ein Zugriffstoken vom Autorisierungsserver anzufordern. Benutzer müssen wichtige Informationen über den Client kennen, z. B. ob die Client-Anwendung und der Dienstanbieter dasselbe Unternehmen sind

• Im Client-Modus autorisiert der Dienstanbieter kundenspezifisch und nicht benutzerspezifisch. Streng genommen kann der Client-Modus nicht als Lösung für die Probleme angesehen werden, die das OAuth-Protokoll löst. Für Entwickler ist es jedoch nützlich, diese Methode in einigen Front-End- und Back-End-Trennanwendungen oder bereitgestellten Authentifizierungs- und Autorisierungsservern zu verwenden Für mobile Endgeräte ist der Modus immer noch sehr praktisch. 🎜🎜#

  Übung

Hier stellen wir vor, wie man einen OAuth-Dienst in einem Authentifizierungsserver erstellt, der von einer Front-End- und Back-End-Trennanwendung (oder für mobile Endgeräte, WeChat-Applets, usw.), daher wird hauptsächlich der Passwortmodus eingeführt.

• 1. Erstellen Sie ein Projekt und fügen Sie Abhängigkeiten hinzu.

Erstellen Sie ein Spring Boot-Webprojekt und fügen Sie die folgenden Abhängigkeiten hinzu.

• <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>
    <exclusions>
      <exclusion>
        <groupId>io.lettuce</groupId>
        <artifactId>lettuce-core</artifactId>
      </exclusion>
    </exclusions>
  </dependency>
  <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth3</artifactId>
    <version>2.3.3.RELEASE</version>
  </dependency>

  Seit dem OAuth-Protokoll im Frühjahr Der Startvorgang erfolgt im Frühjahr auf der Grundlage der Sicherheit. Daher müssen Sie zunächst die Abhängigkeit von Spring Security hinzufügen, sodass OAuth 2-bezogene Abhängigkeiten hinzugefügt werden können. Das Token kann gleichzeitig auf dem Redis-Cache-Server gespeichert werden , Redis verfügt über Funktionen wie Ablauf, die sich sehr gut für die Token-Speicherung eignen, sodass auch Redis-Abhängigkeiten hinzugefügt werden.

Konfiguration application.properties

spring.redis.database=0
spring.redis.host=ip地址
spring.redis.port=6379
spring.redis.password=root
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

2. 配置授权服务器

授权服务器和资源服务器可以是同一台服务器，也可以是不同服务器，此处假设是同一台服务器，通过不同的配置分别开启授权服务器和资源服务器，首先是授权服务器：

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    @Autowired
    AuthenticationManager authenticationManager;
    @Autowired
    RedisConnectionFactory redisConnectionFactory;
    @Autowired
    UserDetailsService userDetailsService;
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("password")
                .authorizedGrantTypes("password", "refresh_token")
                .accessTokenValiditySeconds(1800)
                .resourceIds("rid")
                .scopes("all")
                .secret("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq");
    }
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(new RedisTokenStore(redisConnectionFactory))
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService);
    }
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.allowFormAuthenticationForClients();
    }
}

代码解释：

• 自定义类继承自 AuthorizationServerConfigurerAdapter ，完成对授权服务器的配置，然后通过 @EnableAuthorizationServer 注解开启授权服务器

• 注入 AuthenticationManager 用来支持 password 模式

• 注入 RedisConnectionFactory 用来完成 Redis 缓存，将令牌信息储存到 Redis 缓存中

• 注入 UserDetailsService 该对象为刷新 token 提供支持

• 在 configure(ClientDetailsServiceConfigurer clients) 方法中配置 password 授权模式，authorizedGrantTypes 表示 OAuth 2 中的授权模式为 password 和 refresh_token 两种，在标准的 OAuth 2 协议中，授权模式并不包括 refresh_token ，但是在 Spring Security 的实现中将其归为一种，因此如果要实现 access_token 的刷新，就需要添加这样一种授权模式；accessTokenValiditySeconds 方法配置了 access_token 的过期时间；resourceIds 配置了资源 id；secret 方法配置了加密后的密码，明文是 123

• configure(AuthorizationServerEndpointsConfigurer endpoints) 方法配置了令牌的存储，AuthenticationManager 和 UserDetailsService 主要用于支持 password 模式以及令牌的刷新

• configure(AuthorizationServerSecurityConfigurer security) 方法配置表示支持 client_id 和 client_secret 做登录认证

3. 配置资源服务器

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId("rid").stateless(true);
    }
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("admin")
                .antMatchers("/user/**").hasRole("user")
                .anyRequest().authenticated();
    }
}

代码解释：

• 自定义类继承自 ResourceServerConfigurerAdapter ，并添加 @EnableResourceServer 注解开启资源服务器配置

• resources.resourceId(“rid”).stateless(true); 配置资源 id，这里的资源 id 和授权服务器中的资源 id 一直，然后设置这些资源仅基于令牌认证

• configure(HttpSecurity http) 方法配置 HttpSecurity

4. 配置 Security

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    @Bean
    @Override
    protected UserDetailsService userDetailsService() {
        return super.userDetailsService();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("admin")
                .password("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq")
                .roles("admin")
                .and()
                .withUser("sang")
                .password("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq")
                .roles("user");
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.antMatcher("/oauth/**").authorizeRequests()
                .antMatchers("/oauth/**").permitAll()
                .and().csrf().disable();
    }
}

这里两个 Bean 将注入授权服务器配置类中使用，另外，这里的 HttpSecurity 配置主要是配置 /oauth/** 模式的 URL ，这一类的请求直接放行。在 Spring Security 配置和资源服务器配置中，一共涉及两个 HttpSecurity ，其中 Spring Security 中的配置优先级高于资源服务器中的配置，即请求地址先经过 Spring Security 的 HttpSecurity ，再经过资源服务器的 HttpSecurity。

5. 验证测试

首先创建三个简单的请求地址

@RestController
public class HelloController {
    @GetMapping("/admin/hello")
    public String admin() {
        return "Hello admin!";
    }
    @GetMapping("/user/hello")
    public String user() {
        return "Hello user!";
    }
    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }
}

根据前文的配置，要请求这三个地址，分别需要 admin 角色、user 角色以及登录后访问。

所有都配置完成后，启动 Redis 服务器，再启动 Spring Boot 项目，首先发送一个 POST 请求获取 token，请求地址如下（注意这里是一个 POST 请求，为了显示方便，将参数写在地址栏中）：http://localhost:8080/oauth/token?username=sang&password=123&grant_type=password&client_id=password&scope=all&client_secret=123

请求地址中包含的参数有用户名、密码、授权模式、客户端 id 、scope 以及客户端密码，基本就是授权服务器中所配置的数据，请求结果如图

其中 access_token 是获取其它资源时要用的令牌，refresh_token 用来刷新令牌，expires_in 表示 access_token 过期时间，当 access_token 过期后，使用 refresh_token 重新获取新的 access_token （前提是 refresh_token 未过期），请求地址（注意也是POST请求）：http://localhost:8080/oauth/token?grant_type=refresh_token&refresh_token=693b0e36-4515-442a-8c5d-90bade3c74d2&client_id=password&client_secret=123

获取新的 access_token 时需要携带上 refresh_token ，同事授权模式设置为 refresh_token ，在获取的结果中 access_token 会变化，同时 access_token 有效期也会变化，如图

接下来访问所有资源，携带上 access_token 参数即可，例如 /user/hello 接口：http://localhost:8080/user/hello?access_token=0497e4bc-df37-460e-8755-b813b9dbf36a，访问结果如图

Wenn illegal auf eine Ressource zugegriffen wird, beispielsweise wenn der Sang-Benutzer auf die Schnittstelle /admin/hello zugreift, sieht das Ergebnis wie in der Abbildung dargestellt aus.

An diesem Punkt verfügt das OAuth-Authentifizierungssystem über einen Passwortmodus erfolgreich etabliert.

Es gibt 4 Authentifizierungsmodi in OAuth. Entwickler müssen einen davon basierend auf der tatsächlichen Situation ihrer eigenen Entwicklung auswählen. Hier werden auch andere Autorisierungsmodi vorgestellt haben ihre eigenen Nutzungsszenarien.

Im Allgemeinen ist die Verwendung von Spring Security OAuth 2 noch relativ kompliziert und auch die Konfiguration ist relativ umständlich. Wenn das Anwendungsszenario des Entwicklers relativ einfach ist, kann er sein eigenes OAuth 2-Authentifizierungssystem gemäß dem hier vorgestellten Autorisierungsprozess erstellen .

Das obige ist der detaillierte Inhalt vonSo verwenden Sie das OAuth2-Framework der SpringBoot-Sicherheitsverwaltung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!