Oauth2协议

转x33g5p2x  于2021-11-17 转载在 其他  
字(12.1k)|赞(0)|评价(0)|浏览(331)

Oauth2简介

第三方认证技术方案最主要是解决认证协议的通用标准问题，因为要实现跨系统认证，各系统之间要遵循一定的接口协议。

OAUTH协议为用户资源的授权提供了一个安全的、开放而又简易的标准。同时，任何第三方都可以使用OAUTH认证服务，任何服务提供商都可以实现自身的OAUTH认证服务，因而OAUTH是开放的。业界提供了OAUTH的多种实现如PHP、JavaScript，Java，Ruby等各种语言开发包，大大节约了程序员的时间，因而OAUTH是简易的。互联网很多服务如Open API，很多大公司如Google，Yahoo，Microsoft等都提供了OAUTH认证服务，这些都足以说明OAUTH标准逐渐成为开放资源授权的标准。

Oauth协议目前发展到2.0版本，1.0版本过于复杂，2.0版本已得到广泛应用。

参考：https://baike.baidu.com/item/oAuth/7153134?fr=aladdin

Oauth 协议：https://tools.ietf.org/html/rfc6749

下边分析一个Oauth2认证的例子，网站使用微信认证的过程：

1.用户进入网站的登录页面，点击微信的图标以微信账号登录系统，用户是自己在微信里信息的资源拥有者。

点击“微信”出现一个二维码，此时用户扫描二维码，开始给网站授权。

2.资源拥有者同意给客户端授权

资源拥有者扫描二维码表示资源拥有者同意给客户端授权，微信会对资源拥有者的身份进行验证，验证通过后，微信会询问用户是否给授权网站访问自己的微信数据，用户点击“确认登录”表示同意授权，微信认证服务器会颁发一个授权码，并重定向到网站。

  1. 客户端获取到授权码，请求认证服务器申请令牌

此过程用户看不到，客户端应用程序请求认证服务器，请求携带授权码。

  1. 认证服务器向客户端响应令牌

认证服务器验证了客户端请求的授权码，如果合法则给客户端颁发令牌，令牌是客户端访问资源的通行证。此交互过程用户看不到，当客户端拿到令牌后，用户在网站看到已经登录成功。

  1. 客户端请求资源服务器的资源

客户端携带令牌访问资源服务器的资源。网站携带令牌请求访问微信服务器获取用户的基本信息。

  1. 资源服务器返回受保护资源

资源服务器校验令牌的合法性，如果合法则向用户响应资源信息内容。

注意：资源服务器和认证服务器可以是一个服务也可以分开的服务，如果是分开的服务资源服务器通常要请求认证服务器来校验令牌的合法性。

Oauth2.0认证流程如下：

引自Oauth2.0协议rfc6749 https://tools.ietf.org/html/rfc6749

角色

客户端

本身不存储资源，需要通过资源拥有者的授权去请求资源服务器的资源，比如：Android客户端、Web客户端（浏览器端）、微信客户端等。

资源拥有者

通常为用户，也可以是应用程序，即该资源的拥有者。

授权服务器（也称认证服务器）

用来对资源拥有的身份进行认证、对访问资源进行授权。客户端要想访问资源需要通过认证服务器由资源拥有者授权后方可访问。

资源服务器

存储资源的服务器，比如，网站用户管理服务器存储了网站用户信息，网站相册服务器存储了用户的相册信息，微信的资源服务存储了微信的用户信息等。客户端最终访问资源服务器获取资源信息。

常用术语

  • 客户凭证(client Credentials)：客户端的clientId和密码用于认证客户
  • 令牌(tokens)：授权服务器在接收到客户请求后，颁发的访问令牌
  • 作用域(scopes)：客户请求访问令牌时，由资源拥有者额外指定的细分权限(permission)

令牌类型

  • 授权码：仅用于授权码授权类型，用于交换获取访问令牌和刷新令牌
  • 访问令牌：用于代表一个用户或服务直接去访问受保护的资源
  • 刷新令牌：用于去授权服务器获取一个刷新访问令牌
  • BearerToken：不管谁拿到Token都可以访问资源，类似现金
  • Proof of Possession(PoP) Token：可以校验client是否对Token有明确的拥有权

特点

优点：

​ 更安全，客户端不接触用户密码，服务器端更易集中保护

​ 广泛传播并被持续采用

​ 短寿命和封装的token

​ 资源服务器和授权服务器解耦

​ 集中式授权，简化客户端

​ HTTP/JSON友好，易于请求和传递token

​ 考虑多种客户端架构场景

​ 客户可以具有不同的信任级别

缺点：

协议框架太宽泛，造成各种实现的兼容性和互操作性差

​ 不是一个认证协议，本身并不能告诉你任何用户信息。

授权模式

授权码模式（Authorization Code）

简化授权模式（Implicit）

密码模式（Resource Owner PasswordCredentials）

同一个大型项目里面获取资源

客户端模式（Client Credentials）


刷新令牌
docker就是客户端模式，去授权服务器进行授权，拿到令牌后，直接下载对应的镜像

刷新令牌----令牌过期

Spring Security Oauth2

授权服务器

  • Authorize Endpoint：授权端点，进行授权
  • Token Endpoint：令牌端点，经过授权拿到对应的Token
  • Introspection Endpoint：校验端点，校验Token的合法性
  • Revocation Endpoint：撤销端点，撤销授权

Spring Security Oauth2架构

流程：

  1. 用户访问,此时没有Token。Oauth2RestTemplate会报错，这个报错信息会被Oauth2ClientContextFilter捕获并重定向到认证服务器
  2. 认证服务器通过Authorization Endpoint进行授权，并通过AuthorizationServerTokenServices生成授权码并返回给客户端
  3. 客户端拿到授权码去认证服务器通过Token Endpoint调用AuthorizationServerTokenServices生成Token并返回给客户端
  4. 客户端拿到Token去资源服务器访问资源，一般会通过Oauth2AuthenticationManager调用ResourceServerTokenServices进行校验。校验通过可以获取资源。

Spring Security Oauth2授权码模式

创建项目

添加依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.    <modelVersion>4.0.0</modelVersion>
  4.    <parent>
  5.       <groupId>org.springframework.boot</groupId>
  6.       <artifactId>spring-boot-starter-parent</artifactId>
  7.       <version>2.2.2.RELEASE</version>
  8.       <relativePath/> <!-- lookup parent from repository -->
  9.    </parent>
  10.    <groupId>com.yjxxt</groupId>
  11.    <artifactId>springsecurityoauth2demo</artifactId>
  12.    <version>0.0.1-SNAPSHOT</version>
  13.    <name>springsecurityoauth2demo</name>
  14.    <description>Demo project for Spring Boot</description>
  16.    <properties>
  17.       <java.version>1.8</java.version>
  18.       <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
  19.    </properties>
  21.    <dependencies>
  22.       <dependency>
  23.          <groupId>org.springframework.cloud</groupId>
  24.          <artifactId>spring-cloud-starter-oauth2</artifactId>
  25.       </dependency>
  26.       <dependency>
  27.          <groupId>org.springframework.cloud</groupId>
  28.          <artifactId>spring-cloud-starter-security</artifactId>
  29.       </dependency>
  30.       <dependency>
  31.          <groupId>org.springframework.boot</groupId>
  32.          <artifactId>spring-boot-starter-web</artifactId>
  33.       </dependency>
  34.       <dependency>
  35.          <groupId>org.springframework.boot</groupId>
  36.          <artifactId>spring-boot-starter-test</artifactId>
  37.          <scope>test</scope>
  38.       </dependency>
  39.    </dependencies>
  41.    <dependencyManagement>
  42.       <dependencies>
  43.          <dependency>
  44.             <groupId>org.springframework.cloud</groupId>
  45.             <artifactId>spring-cloud-dependencies</artifactId>
  46.             <version>${spring-cloud.version}</version>
  47.             <type>pom</type>
  48.             <!--只有在引入的时候才会生效-->
  49.             <scope>import</scope>
  50.          </dependency>
  51.       </dependencies>
  52.    </dependencyManagement>
  54.    <build>
  55.       <plugins>
  56.          <plugin>
  57.             <groupId>org.springframework.boot</groupId>
  58.             <artifactId>spring-boot-maven-plugin</artifactId>
  59.          </plugin>
  60.       </plugins>
  61.    </build>
  63. </project>

编写配置类

SecurityConfig.java----安全配置

  1. @Configuration
  2. @EnableWebSecurity
  3. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  5.    @Bean
  6.    public PasswordEncoder passwordEncoder() {
  7.       return new BCryptPasswordEncoder();
  8.    }
  10.    @Override
  11.    public void configure(HttpSecurity http) throws Exception {
  12.       http.csrf()
  13.             .disable()
  14.             .authorizeRequests()
  15.             .antMatchers("/oauth/**", "/login/**", "/logout/**")
  16.             .permitAll()
  17.             .anyRequest()
  18.             .authenticated()
  19.             .and()
  20.             .formLogin()
  21.             .permitAll();
  22.    }
  23. }

AuthorizationServerConfig.java----认证服务器配置

  1. @Configuration
  2. @EnableAuthorizationServer
  3. public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
  5.     @Autowired
  6.     private PasswordEncoder passwordEncoder;
  8.     @Override
  9.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  10.     //放在内存中
  11.         clients.inMemory()
  12.                 //配置client_id--客户端id
  13.                 .withClient("admin")
  14.                 //配置client-secret---秘钥---出于安全考虑，最好加密一下
  15.                 .secret(passwordEncoder.encode("112233"))
  16.                 //配置redirect_uri，用于授权成功后跳转
  17.                 //这里重定向uri是用来获取授权码的
  18.                 .redirectUris("http://www.baidu.com")
  19.                 //配置申请的权限范围---可以细分，这里是全部
  20.                 .scopes("all")
  21.                 //配置grant_type，表示授权类型--这里是授权码模式
  22.                 .authorizedGrantTypes("authorization_code");
  23.     }
  24. }

ResourceServerConfig.java----资源服务器配置

  1. @Configuration
  2. @EnableResourceServer
  3. public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
  5.     @Override
  6.     public void configure(HttpSecurity http) throws Exception {
  7.         http.authorizeRequests()
  8.                 .anyRequest()
  9.                 .authenticated()
  10.                 .and()
  11.                 .requestMatchers()
  12.                 .antMatchers("/user/**");//配置需要保护的资源路径
  13.     }
  14. }

这里把客户端，授权服务器，资源服务器都放在了一起，正式环境下，客户端，授权服务器，资源服务器都属于不同的服务器

编写实体类

User.java

  1. /** * 用户类 */
  2. public class User implements UserDetails {
  4.     private String username;
  5.     private String password;
  6.     private List<GrantedAuthority> authorities;
  8.     public User(String username, String password, List<GrantedAuthority> authorities) {
  9.         this.username = username;
  10.         this.password = password;
  11.         this.authorities = authorities;
  12.     }
  14.     @Override
  15.     public Collection<? extends GrantedAuthority> getAuthorities() {
  16.         return authorities;
  17.     }
  19.     @Override
  20.     public String getPassword() {
  21.         return password;
  22.     }
  24.     @Override
  25.     public String getUsername() {
  26.         return username;
  27.     }
  29.     @Override
  30.     public boolean isAccountNonExpired() {
  31.         return true;
  32.     }
  34.     @Override
  35.     public boolean isAccountNonLocked() {
  36.         return true;
  37.     }
  39.     @Override
  40.     public boolean isCredentialsNonExpired() {
  41.         return true;
  42.     }
  44.     @Override
  45.     public boolean isEnabled() {
  46.         return true;
  47.     }
  48. }

编写Service

UserService.java

  1. @Service
  2. public class UserService implements UserDetailsService {
  4.    @Autowired
  5.    private PasswordEncoder passwordEncoder;
  7.    @Override
  8.    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  9.       String password = passwordEncoder.encode("123456");
  10.       return new User("admin",password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
  11.    }
  12. }

编写Controller

UserController.java

  1. //资源
  2. @RestController
  3. @RequestMapping("/user")
  4. public class UserController {
  6.    @GetMapping("/getCurrentUser")
  7.    public Object getCurrentUser(Authentication authentication) {
  8.       return authentication.getPrincipal();
  9.    }
  10. }

测试

获取授权码

http://localhost:8080/oauth/authorize?response_type=code&client_id=admin&redirect_uri=http://www.baidu.com&scope=all

  1. http://localhost:8080/oauth/authorize?
  2. response_type=code&client_id=admin&redirect_uri=http://www.baidu.com&scope=all

注意，如果一直出现用户名和密码错误，请查看自己创建的user类，是否在对应getUname,getUpwd方法中返回了正确的用户名和密码

输入账户密码

点击授权获取授权码

根据授权码获取令牌（POST请求）

  1. localhost/oauth/token

  • grant_type：授权类型，填写authorization_code，表示授权码模式
  • code：授权码，就是刚刚获取的授权码，注意：授权码只使用一次就无效了，需要重新申请。
  • client_id:客户端标识
  • redirect_uri：申请授权码时的跳转url，一定和申请授权码时用的redirect_uri一致。
  • scope:授权范围。

认证失败服务端返回 401 Unauthorized

注意：此时无法请求到令牌，访问服务器会报错

出现这个错误，找找是不是body请求体某个参数的key写错了，或者其他地方写错了

无论本次获取token成功与否，授权码都只能使用一次，使用一次后就无效了，需要重新申请。

通过授权码获取到的token如下:

根据token去资源服务器拿资源

拿到返回的资源信息:

如果修改token就会报错

Spring Security Oauth2 密码模式

在上面的代码中进行适当的修改即可

SecurityConfig.java

  1. @Configuration
  2. @EnableWebSecurity
  3. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  5.    @Bean
  6.    public PasswordEncoder passwordEncoder() {
  7.       return new BCryptPasswordEncoder();
  8.    }
  10. //用于密码模式
  11.    @Bean
  12.    @Override
  13.    public AuthenticationManager authenticationManagerBean() throws Exception {
  14.       return super.authenticationManagerBean();
  15.    }
  17.    @Override
  18.    public void configure(HttpSecurity http) throws Exception {
  19.       http.csrf()
  20.             .disable()
  21.             .authorizeRequests()
  22.             .antMatchers("/oauth/**", "/login/**", "/logout/**")
  23.             .permitAll()
  24.             .anyRequest()
  25.             .authenticated()
  26.             .and()
  27.             .formLogin()
  28.             .permitAll();
  29.    }
  30. }

AuthorizationServerConfig.java

  1. /** * 授权服务器配置 */
  2. @Configuration
  3. @EnableAuthorizationServer
  4. public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
  6.     @Autowired
  7.     private PasswordEncoder passwordEncoder;
  9.     @Autowired
  10.     private AuthenticationManager authenticationManager;
  12.     @Autowired
  13.     private UserService userService;
  15.     /** * 使用密码模式需要配置 */
  16.     @Override
  17.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
  18.         endpoints.authenticationManager(authenticationManager)
  19.                 .userDetailsService(userService);
  20.     }
  22.     @Override
  23.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  24.         clients.inMemory()
  25.                 //配置client_id
  26.                 .withClient("admin")
  27.                 //配置client-secret
  28.                 .secret(passwordEncoder.encode("112233"))
  29.                 //配置访问token的有效期
  30.                 .accessTokenValiditySeconds(3600)
  31.                 //配置刷新token的有效期
  32.                 .refreshTokenValiditySeconds(864000)
  33.                 //配置redirect_uri，用于授权成功后跳转
  34.                 .redirectUris("http://www.baidu.com")
  35.                 //配置申请的权限范围
  36.                 .scopes("all")
  37.                 //配置grant_type，表示授权类型
  38.                 //可以同时指定多个
  39.                 .authorizedGrantTypes("authorization_code","password");
  40.     }
  41. }

测试：

下面的认证输入的是用户id和秘钥

密码登录输入的就是我们自定义用户时，设置的用户名和密码

访问请求获取令牌

  1. http://localhost:8080/oauth/token

获取到令牌

拿着令牌请求资源

在Redis中存储token

之前的代码我们将token直接存在内存中，这在生产环境中是不合理的，下面我们将其改造成存储在Redis中

添加依赖及配置

pom.xml

  1. <!--redis 依赖-->
  2. <dependency>
  3.    <groupId>org.springframework.boot</groupId>
  4.    <artifactId>spring-boot-starter-data-redis</artifactId>
  5. </dependency>
  6. <!-- commons-pool2 对象池依赖 -->
  7. <dependency>
  8.    <groupId>org.apache.commons</groupId>
  9.    <artifactId>commons-pool2</artifactId>
  10. </dependency>

application.properties

  1. # Redis配置
  2. spring.redis.host=192.168.10.100
  3. #如果redis设置了密码登录，不要忘记配置

编写Redis配置类

RedisConfig.java

  1. /** * 使用redis存储token的配置 * @author zhoubin * @since 1.0.0 */
  2. @Configuration
  3. public class RedisConfig {
  4.    @Autowired
  5.    private RedisConnectionFactory redisConnectionFactory;
  7.    @Bean
  8.    public TokenStore redisTokenStore(){
  9.       return new RedisTokenStore(redisConnectionFactory);
  10.    }
  12. }

在认证服务器配置中指定令牌的存储策略为Redis

  1. /** * 授权服务器配置 * @author zhoubin * @since 1.0.0 */
  2. @Configuration
  3. @EnableAuthorizationServer
  4. public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
  6.     @Autowired
  7.     private PasswordEncoder passwordEncoder;
  9.     @Autowired
  10.     private AuthenticationManager authenticationManager;
  12.     @Autowired
  13.     private UserService userService;
  15.     @Autowired
  16.     @Qualifier("redisTokenStore")
  17.     private TokenStore tokenStore;
  19.     /** * 使用密码模式需要配置 */
  20.     @Override
  21.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
  22.         endpoints.authenticationManager(authenticationManager)
  23.                 .userDetailsService(userService)
  24.                 .tokenStore(tokenStore);
  25.     }
  27.     @Override
  28.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  29.         clients.inMemory()
  30.                 //配置client_id
  31.                 .withClient("admin")
  32.                 //配置client-secret
  33.                 .secret(passwordEncoder.encode("112233"))
  34.                 //配置访问token的有效期
  35.                 .accessTokenValiditySeconds(3600)
  36.                 //配置刷新token的有效期
  37.                 .refreshTokenValiditySeconds(864000)
  38.                 //配置redirect_uri，用于授权成功后跳转
  39.                 .redirectUris("http://www.baidu.com")
  40.                 //配置申请的权限范围
  41.                 .scopes("all")
  42.                 //配置grant_type，表示授权类型
  43.                 .authorizedGrantTypes("password");
  44.     }
  45. }

测试：

使用密码模式请求token

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/m0_53157173/article/details/121354073

内容来源于网络，如有侵权，请联系作者删除！

运维服务器网络

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com