Spring Security OAuth2.0认证授权（二）

已于 2022-08-28 19:40:19 修改
阅读量1.1k 收藏 3
点赞数 1
分类专栏： 其他技术 文章标签： spring java http
于 2022-05-03 15:15:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56697114/article/details/123970556
版权

目录

1、分布式认证方案

1、基于session的认证方式

2、基于token的认证方式

 2、OAuth2.0

1、授权服务器配置

2、授权码模式

 3、简化模式

 4、密码模式

5、客户端模式

6、资源服务

 7、JWT令牌

1、令牌结构

 2、配置JWT令牌服务

 8、完善环境配置

1、分布式认证方案

1、基于session的认证方式

在分布式的环境下，基于session的认证会出现一个问题，每个应用服务都需要在session中存储用户身份信息，通过负载均衡将本地的请求分配到另一个应用服务需要将session信息带过去，否则会重新认证。

 

2、基于token的认证方式

基于token的认证方式，服务端不用存储认证数据，易维护扩展性强， 客户端可以把token 存在任意地方，并且可以实现web和app统一认证机制。其缺点也很明显，token由于自包含信息，因此一般数据量较大，而且每次请求都需要传递，因此比较占带宽。另外，token的签名验签操作也会给cpu带来额外的处理负担。

流程描述：

  1. 用户通过接入方（应用）登录，接入方采取OAuth2.0方式在统一认证服务(UAA)中认证。
  2. 认证服务(UAA)调用验证该用户的身份是否合法，并获取用户权限信息。
  3. 认证服务(UAA)获取接入方权限信息，并验证接入方是否合法。
  4. 若登录用户以及接入方都合法，认证服务生成jwt令牌返回给接入方，其中jwt中包含了用户权限及接入方权限。
  5. 后续，接入方携带jwt令牌对API网关内的微服务资源进行访问。
  6. API网关对令牌解析、并验证接入方的权限是否能够访问本次请求的微服务。
  7. 如果接入方的权限没问题，API网关将原请求header中附加解析后的明文Token，并将请求转发至微服务。
  8. 微服务收到请求，明文token中包含登录用户的身份和权限信息。因此后续微服务自己可以干两件事：1，用户授权拦截（看当前用户是否有权访问该资源）2，将用户信息存储进当前线程上下文（有利于后续业务逻辑随时获取当前用户信息）

 2、OAuth2.0

OAuth（开放授权）是一个开放标准，允许用户授权第三方应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方应用或分享他们数据的所有内容。

OAuth2.0的服务提供方涵盖两个服务，即授权服务 (Authorization Server，也叫认证服务) 和资源服务 (ResourceServer)，使用 Spring Security OAuth2 的时候你可以选择把它们在同一个应用程序中实现，也可以选择建立使用同一个授权服务的多个资源服务。

授权服务 (Authorization Server）应包含对接入端以及登入用户的合法性进行验证并颁发token等功能，对令牌的请求端点由 Spring MVC 控制器进行实现，下面是配置一个认证服务必须要实现的endpoints：

  • AuthorizationEndpoint 服务于认证请求。默认 URL：  /oauth/authorize 。
  • TokenEndpoint 服务于访问令牌的请求。默认 URL：  /oauth/token 。资源服务 (Resource Server)，应包含对资源的保护功能，对非法请求进行拦截，对请求中token进行解析鉴权等，下面的过滤器用于实现 OAuth 2.0 资源服务：
  • OAuth2AuthenticationProcessingFilter 用来对请求给出的身份令牌解析鉴权。

分别创建uaa授权服务（也可叫认证服务）和order订单资源服务。

OAauth2.0包括以下角色：

  • 客户端

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

  • 资源拥有者

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

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

用于服务提供商对资源拥有的身份进行认证、对访问资源进行授权，认证成功后会给客户端发放令牌（access_token），作为客户端访问资源服务器的凭据。

  • 资源服务器

存储资源的服务器。

现在还有一个问题，服务提供商能允许随便一个客户端就接入到它的授权服务器吗？答案是否定的，服务提供商会给准入的接入方一个身份，用于接入时的凭据:

client_id：客户端标识

client_secret：客户端秘钥

因此，准确来说，授权服务器对两种OAuth2.0中的两个角色进行认证授权，分别是资源拥有者、客户端。

父工程

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <modules>
        <module>uaa</module>
        <module>order</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.springboot</groupId>
    <artifactId>springboot-test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-test</name>
    <description>Demo project for Spring Boot</description>
    <packaging>pom</packaging>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.interceptor</groupId>
                <artifactId>javax.interceptor-api</artifactId>
                <version>1.2</version>
            </dependency>

            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.47</version>
            </dependency>

            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.0</version>
            </dependency>

            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.25</version>
            </dependency>

            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-jwt</artifactId>
                <version>1.0.9.RELEASE</version>
            </dependency>

            <dependency>
                <groupId>org.springframework.security.oauth.boot</groupId>
                <artifactId>spring-security-oauth2-autoconfigure</artifactId>
                <version>2.1.3.RELEASE</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

 uaa

    <dependencies>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <dependency>
            <groupId>com.netflix.hystrix</groupId>
            <artifactId>hystrix-javanica</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</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-freemarker</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-commons</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-security</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-jwt</artifactId>
        </dependency>

        <dependency>
            <groupId>javax.interceptor</groupId>
            <artifactId>javax.interceptor-api</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>
spring.application.name=uaa-service
server.port=53020
spring.main.allow-bean-definition-overriding = true

logging.level.root = debug
logging.level.org.springframework.web = info

spring.http.encoding.enabled = true
spring.http.encoding.charset = UTF-8
spring.http.encoding.force = true
server.tomcat.remote_ip_header = x-forwarded-for
server.tomcat.protocol_header = x-forwarded-proto
server.use-forward-headers = true
server.servlet.context-path = /uaa

spring.freemarker.enabled = true
spring.freemarker.suffix = .html
spring.freemarker.request-context-attribute = rc
spring.freemarker.content-type = text/html
spring.freemarker.charset = UTF-8
spring.mvc.throw-exception-if-no-handler-found = true
spring.resources.add-mappings = false

spring.datasource.url = jdbc:mysql://localhost:3306/my
spring.datasource.username = root
spring.datasource.password = mysql
spring.datasource.driver-class-name = com.mysql.jdbc.Driver

eureka.client.serviceUrl.defaultZone = http://localhost:53000/eureka/
eureka.instance.preferIpAddress = true
eureka.instance.instance-id = ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance_id:${server.port}}
management.endpoints.web.exposure.include = refresh,health,info,env

feign.hystrix.enabled = true
feign.compression.request.enabled = true
feign.compression.request.mime-types[0] = text/xml
feign.compression.request.mime-types[1] = application/xml
feign.compression.request.mime-types[2] = application/json
feign.compression.request.min-request-size = 2048
feign.compression.response.enabled = true

@SpringBootApplication
@EnableDiscoveryClient
@EnableHystrix
@EnableFeignClients(basePackages = {"com.security.uaa"})
public class UaaServer{

    public static void main(String[] args) {
        SpringApplication.run(UaaServer.class,args);
    }
}

order

    <dependencies>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.interceptor</groupId>
            <artifactId>javax.interceptor-api</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>
spring.application.name=order-service
server.port=53021
spring.main.allow-bean-definition-overriding = true

logging.level.root = debug
logging.level.org.springframework.web = info
spring.http.encoding.enabled = true
spring.http.encoding.charset = UTF-8
spring.http.encoding.force = true
server.tomcat.remote_ip_header = x-forwarded-for
server.tomcat.protocol_header = x-forwarded-proto
server.use-forward-headers = true
server.servlet.context-path = /order


spring.freemarker.enabled = true
spring.freemarker.suffix = .html
spring.freemarker.request-context-attribute = rc
spring.freemarker.content-type = text/html
spring.freemarker.charset = UTF-8
spring.mvc.throw-exception-if-no-handler-found = true
spring.resources.add-mappings = false


eureka.client.serviceUrl.defaultZone = http://localhost:53000/eureka/
eureka.instance.preferIpAddress = true
eureka.instance.instance-id = ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance_id:${server.port}}
management.endpoints.web.exposure.include = refresh,health,info,env

feign.hystrix.enabled = true
feign.compression.request.enabled = true
feign.compression.request.mime-types[0] = text/xml
feign.compression.request.mime-types[1] = application/xml
feign.compression.request.mime-types[2] = application/json
feign.compression.request.min-request-size = 2048
feign.compression.response.enabled = true
@SpringBootApplication
@EnableDiscoveryClient
public class OrderServer {

    public static void main(String[] args) {
        SpringApplication.run(OrderServer.class,args);
    }
}

1、授权服务器配置

可以用 @EnableAuthorizationServer 注解并继承AuthorizationServerConfigurerAdapter来配置OAuth2.0 授权服务器。

@Configuration
@EnableAuthorizationServer
public class AuthorizationServer extends
      AuthorizationServerConfigurerAdapter {
        
 }

AuthorizationServerConfigurerAdapter要求配置以下几个类，这几个类是由Spring创建的独立的配置对象，它们会被Spring传入AuthorizationServerConfigurer中进行配置。

  • ClientDetailsServiceConfigurer ：用来配置客户端详情服务（ClientDetailsService），客户端详情信息在这里进行初始化，你能够把客户端详情信息写死在这里或者是通过数据库来存储调取详情信息。
  • AuthorizationServerEndpointsConfigurer ：用来配置令牌（token）的访问端点和令牌服务(tokenservices)。
  • AuthorizationServerSecurityConfigurer ：用来配置令牌端点的安全约束。

配置客户端详细信息：

ClientDetailsServiceConfigurer 能够使用内存或者JDBC来实现客户端详情服务（ClientDetailsService），ClientDetailsService负责查找ClientDetails，而ClientDetails有几个重要的属性如下列表：

  • clientId ：（必须的）用来标识客户的Id。
  • secret ：（需要值得信任的客户端）客户端安全码，如果有的话。
  • scope ：用来限制客户端的访问范围，如果为空（默认）的话，那么客户端拥有全部的访问范围。
  • authorizedGrantTypes ：此客户端可以使用的授权类型，默认为空。
  • authorities ：此客户端可以使用的权限（基于Spring Security authorities）。

管理令牌：

AuthorizationServerTokenServices 接口定义了一些操作使得你可以对令牌进行一些必要的管理，令牌可以被用来加载身份信息，里面包含了这个令牌的相关权限。

自己可以创建 AuthorizationServerTokenServices 这个接口的实现，则需要继承 DefaultTokenServices 这个类，里面包含了一些有用实现，你可以使用它来修改令牌的格式和令牌的存储。

下面有几个版本，它们都实现了TokenStore接口：

  1. InMemoryTokenStore ：这个版本的实现是被默认采用的，它可以完美的工作在单服务器上（即访问并发量压力不大的情况下，并且它在失败的时候不会进行备份），大多数的项目都可以使用这个版本的实现来进行尝试，你可以在开发的时候使用它来进行管理，因为不会被保存到磁盘中，所以更易于调试。
  2. JdbcTokenStore ：这是一个基于JDBC的实现版本，令牌会被保存进关系型数据库。使用这个版本的实现时，你可以在不同的服务器之间共享令牌信息，使用这个版本的时候请注意把"spring-jdbc"这个依赖加入到你的classpath当中。
  3. JwtTokenStore ：这个版本的全称是 JSON Web Token（JWT），它可以把令牌相关的数据进行编码（因此对于后端服务来说，它不需要进行存储，这将是一个重大优势），但是它有一个缺点，那就是撤销一个已经授权令牌将会非常困难，所以它通常用来处理一个生命周期较短的令牌以及撤销刷新令牌（refresh_token）。另外一个缺点就是这个令牌占用的空间会比较大，如果你加入了比较多用户凭证信息。JwtTokenStore 不会保存任何数据，但是它在转换令牌值以及授权信息方面与DefaultTokenServices 所扮演的角色是一样的。

令牌访问端点配置：

AuthorizationServerEndpointsConfigurer 通过设定以下属性决定支持的授权类型（Grant Types）:

  1. authenticationManager ：认证管理器，当你选择了资源所有者密码（password）授权类型的时候，请设置这个属性注入一个 AuthenticationManager 对象。
  2. userDetailsService ：如果你设置了这个属性的话，那说明你有一个自己的 UserDetailsService 接口的实现，或者你可以把这个东西设置到全局域上面去（例如 GlobalAuthenticationManagerConfigurer 这个配置对象），当你设置了这个之后，那么 "refresh_token" 即刷新令牌授权类型模式的流程中就会包含一个检查，用来确保这个账号是否仍然有效，假如说你禁用了这个账户的话。
  3. authorizationCodeServices ：这个属性是用来设置授权码服务的（即 AuthorizationCodeServices 的实例对象），主要用于 "authorization_code" 授权码类型模式。
  4. implicitGrantService ：这个属性用于设置隐式授权模式，用来管理隐式授权模式的状态。
  5. tokenGranter ：当你设置了这个东西（即 TokenGranter 接口实现），那么授权将会交由你来完全掌控，并且会忽略掉上面的这几个属性，这个属性一般是用作拓展用途的，即标准的四种授权模式已经满足不了你的需求的时候，才会考虑使用这个。

配置授权端点的URL（Endpoint URLs）：

AuthorizationServerEndpointsConfigurer 这个配置对象有一个叫做 pathMapping() 的方法用来配置端点URL链接，它有两个参数：

  • 第一个参数： String 类型的，这个端点URL的默认链接。
  • 第二个参数： String 类型的，你要进行替代的URL链接。

以上的参数都将以 "/" 字符为开始的字符串，框架的默认URL链接如下列表，可以作为这个 pathMapping() 方法的第一个参数：

  • /oauth/authorize ：授权端点。
  • /oauth/token ：令牌端点。
  • /oauth/confirm_access ：用户确认授权提交端点。
  • /oauth/error ：授权服务错误信息端点。
  • /oauth/check_token ：用于资源服务访问的令牌解析端点。
  • /oauth/token_key ：提供公有密匙的端点，如果你使用JWT令牌的话。

需要注意的是授权端点这个URL应该被Spring Security保护起来只供授权用户访问.

在AuthorizationServer配置令牌访问端点

@Configuration
public class TokenConfig {

    //令牌存储策略
    @Bean
    public TokenStore tokenStore(){

        //内存方式，生成普通令牌
        return new InMemoryTokenStore();
    }
}
@Configuration
@EnableAuthorizationServer
public class AuthorizationServer extends AuthorizationServerConfigurerAdapter {


    @Autowired
    private TokenStore tokenStore;

    @Autowired
    private ClientDetailsService clientDetailsService;

    @Autowired
    private AuthorizationCodeServices authorizationCodeServices;

    @Autowired
    private AuthenticationManager authenticationManager;

    //配置客户端详细信息服务
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {

        clients.inMemory()//使用内存方式
                .withClient("c1")//client_id
                .secret(new BCryptPasswordEncoder().encode("secret"))//客户端密钥
                .resourceIds("res1")//资源列表
                //该client允许的授权类型 authorization_code,password,refresh_token,implicit,client_credentials
                .authorizedGrantTypes("authorization_code",
                        "password","client_credentials","implicit","refresh_token")
                .scopes("all")//允许的授权范围
                .autoApprove(false)//false跳转到授权页面 true 不用跳转直接给令牌
                .redirectUris("http://www.baidu.com");//验证回调地址
                //可配置多个客户端
                //.and()
                //.....对应上方

    }

    //令牌管理服务
    @Bean
    public AuthorizationServerTokenServices tokenService(){
        DefaultTokenServices service = new DefaultTokenServices();
        service.setClientDetailsService(clientDetailsService);//客户端信息服务
        service.setSupportRefreshToken(true);//是否产生刷新令牌
        service.setTokenStore(tokenStore);//令牌存储策略
        service.setAccessTokenValiditySeconds(7200);// 令牌默认有效期2小时
        service.setRefreshTokenValiditySeconds(259200);// 刷新令牌默认有效期3天
        return service;
    }

    //令牌访问端点
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints){
        endpoints
                .authenticationManager(authenticationManager)//认证管理器，密码模式需要
                .authorizationCodeServices(authorizationCodeServices)//授权码服务，授权码模式需要
                .tokenServices(tokenService())//令牌管理服务
                .allowedTokenEndpointRequestMethods(HttpMethod.POST);//允许post提交
    }

    @Bean
    public AuthorizationCodeServices anAuthorizationCodeServices(){
        //设置授权码模式的授权码如何存取，暂时采用内存方式
        return new InMemoryAuthorizationCodeServices();
    }

    //令牌访问端点安全策略
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        //tokenkey这个endpoint当使用JwtToken且使用非对称加密时，资源服务用于获取公钥而开放的，这里指这个endpoint完全公开。
        security.tokenKeyAccess("permitAll()")
                .checkTokenAccess("permitAll()")//checkToken这个endpoint完全公开
                .allowFormAuthenticationForClients();// 允许表单认证（申请令牌）
    }
}
@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true,prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    //认证管理器
    @Bean
    public AuthenticationManager authenticationManager() throws Exception {
        return super.authenticationManager();
    }


    //密码编码器
    @Bean
    public PasswordEncoder passwordEncoder(){
        //无加密方式
        return NoOpPasswordEncoder.getInstance();
    }

    //安全拦截机制
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable().//屏蔽CSRF,使security 不再限制CSRF
                authorizeRequests().
                antMatchers("/r/r1").hasAnyAuthority("p1").//访问/r/r1必须具有p1权限
                antMatchers("/r/r2").hasAnyAuthority("p2").
                antMatchers("login").permitAll().
                anyRequest().authenticated().
                and().
                formLogin();

    }
}

授权服务配置总结：授权服务配置分成三大块，可以关联记忆。

  • 既然要完成认证，它首先得知道客户端信息从哪儿读取，因此要进行客户端详情配置。
  • 既然要颁发token，那必须得定义token的相关endpoint，以及token如何存取，以及客户端支持哪些类型的token。
  • 既然暴露除了一些endpoint，那对这些endpoint可以定义一些安全上的约束等。

2、授权码模式

 （1）资源拥有者打开客户端，客户端要求资源拥有者给予授权，它将浏览器被重定向到授权服务器，重定向时会附加客户端的身份信息。如：

  •  client_id ：客户端准入标识。
  • response_type ：授权码模式固定为code。
  • scope ：客户端权限。
  • redirect_uri ：跳转uri，当授权码申请成功后会跳转到此地址，并在后边带上code参数（授权码）。

（ 2）浏览器出现向授权服务器授权页面，之后将用户同意授权。

（3）授权服务器将授权码（AuthorizationCode）转经浏览器发送给client(通过redirect_uri)。

（4）客户端拿着授权码向授权服务器索要访问access_token，请求如下：

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

（5）授权服务器返回令牌(access_token)

这种模式是四种模式中最安全的一种模式。一般用于client是Web服务器端应用或第三方的原生App调用资源服务的时候。因为在这种模式中access_token不会经过浏览器或移动端的App，而是直接从服务端去交换，这样就最大限度的减小了令牌泄漏的风险。

 3、简化模式

 （1）资源拥有者打开客户端，客户端要求资源拥有者给予授权，它将浏览器被重定向到授权服务器，重定向时会附加客户端的身份信息。如：

参数描述同授权码模式 ，注意response_type=token，说明是简化模式。

（2）浏览器出现向授权服务器授权页面，之后将用户同意授权。

（3）授权服务器将授权码将令牌（access_token）以Hash的形式存放在重定向uri的fargment中发送给浏览器。

注：fragment 主要是用来标识 URI 所标识资源里的某个资源，在 URI 的末尾通过 （#）作为 fragment 的开头，其中 # 不属于 fragment 的值。https://domain/index#L18这个 URI 中  L18 就是 fragment 的值。大家只需要知道js通过响应浏览器地址栏变化的方式能获取到fragment 就行了。

一般来说，简化模式由于没有服务器端的第三方单页面应用，因为没有服务器端就无法接收授权码。

 4、密码模式

（1）资源拥有者将用户名、密码发送给客户端

（2）客户端拿着资源拥有者的用户名、密码向授权服务器请求令牌（access_token）

  • client_id ：客户端准入标识。
  • client_secret ：客户端秘钥。
  • grant_type ：授权类型，填写password表示密码模式
  • username ：资源拥有者用户名。
  • password ：资源拥有者密码。 

（3）授权服务器将令牌（access_token）发送给client

这种模式十分简单，但是却意味着直接将用户敏感信息泄漏给了client，因此这就说明这种模式只能用于client是我们自己开发的情况下。因此密码模式一般用于我们自己开发的，第一方原生App或第一方单页面应用。

5、客户端模式

（1）客户端向授权服务器发送自己的身份信息，并请求令牌（access_token）

（2）确认客户端身份无误后，将令牌（access_token）发送给client，请求如下：

  • client_id ：客户端准入标识。
  • client_secret ：客户端秘钥。
  • grant_type ：授权类型，填写client_credentials表示客户端模式

这种模式是最方便但最不安全的模式。因此这就要求我们对client完全的信任，而client本身也是安全的。因此这种模式一般用来提供给我们完全信任的服务器端服务。比如，合作方系统对接，拉取一组用户信息。 

6、资源服务

@EnableResourceServer 注解到一个 @Configuration 配置类上，并且必须使用 ResourceServerConfigurer 这个配置对象来进行配置（可以选择继承自 ResourceServerConfigurerAdapter 然后覆写其中的方法，参数就是这个对象的实例），下面是一些可以配置的属性：

ResourceServerSecurityConfigurer中主要包括：

  • tokenServices ：ResourceServerTokenServices 类的实例，用来实现令牌服务。
  • tokenStore ：TokenStore类的实例，指定令牌如何访问，与tokenServices配置可选
  • resourceId ：这个资源服务的ID，这个属性是可选的，但是推荐设置并在授权服务中进行验证。
  • 其他的拓展属性例如 tokenExtractor 令牌提取器用来提取请求中的令牌。

HttpSecurity配置这个与Spring Security类似：

  • 请求匹配器，用来设置需要进行保护的资源路径，默认的情况下是保护资源服务的全部路径。
  • 通过 http.authorizeRequests()来设置受保护资源的访问规则
  • 其他的自定义权限保护规则通过 HttpSecurity 来进行配置。

@EnableResourceServer 注解自动增加了一个类型为 OAuth2AuthenticationProcessingFilter 的过滤器链

ResourceServerTokenServices 是组成授权服务的另一半，如果你的授权服务和资源服务在同一个应用程序上的话，你可以使用 DefaultTokenServices ，这样的话，你就不用考虑关于实现所有必要的接口的一致性问题。

如果你的资源服务器是分离开的，那么你就必须要确保能够有匹配授权服务提供的ResourceServerTokenServices，它知道如何对令牌进行解码。 

令牌解析方法： 使用 DefaultTokenServices 在资源服务器本地配置令牌存储、解码、解析方式 使用RemoteTokenServices 资源服务器通过 HTTP 请求来解码令牌，每次都请求授权服务器端点 /oauth/check_token

在资源 服务配置RemoteTokenServices ，在ResouceServerConfig中配置：

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    public static final String RESOURCE_ID="res1";

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId(RESOURCE_ID)//资源 id
                .tokenServices(tokenServices())//验证令牌服务
                .stateless(true);
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)//session不用记录
                .and()
                .authorizeRequests()
                .antMatchers("/**").access("#oauth2.hasScope('all')");
    }

    //资源服务令牌解析服务
    @Bean
    public ResourceServerTokenServices tokenServices(){
        //使用远程服务请求授权服务器校验token,必须指定校验token 的url、client_id，client_secret
        RemoteTokenServices services = new RemoteTokenServices();
        services.setCheckTokenEndpointUrl("http://localhost:53020/uaa/oauth/check_token");
        services.setClientId("c1");
        services.setClientSecret("secret");
        return services;
    }
}

 

 7、JWT令牌

JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简介的、自包含的协议格式，用于在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。JWT可以使用HMAC算法或使用RSA的公钥/私钥对来签名，防止被篡改。

JWT令牌的优点：

  • jwt基于json，非常方便解析。
  • 可以在令牌中自定义丰富的内容，易扩展。
  • 通过非对称加密算法及数字签名技术，JWT防止篡改，安全性高。
  • 资源服务使用JWT可不依赖认证服务即可完成授权。

缺点：

  • JWT令牌较长，占存储空间比较大。

1、令牌结构

JWT令牌由三部分组成，每部分中间使用点（.）分隔，比如：xxxxx.yyyyy.zzzzz

  • Header

头部包括令牌的类型（即JWT）及使用的哈希算法（如HMAC SHA256或RSA）

一个例子如下：下边是Header部分的内容

 将上边的内容使用Base64Url编码，得到一个字符串就是JWT令牌的第一部分。

  • Payload

第二部分是负载，内容也是一个json对象，它是存放有效信息的地方，它可以存放jwt提供的现成字段，比如：iss（签发者）,exp（过期时间戳）, sub（面向的用户）等，也可自定义字段。此部分不建议存放敏感信息，因为此部分可以解码还原原始内容。

最后将第二部分负载使用Base64Url编码，得到一个字符串就是JWT令牌的第二部分。

一个例子：

  • Signature

第三部分是签名，此部分用于防止jwt内容被篡改。这个部分使用base64url将前两部分进行编码，编码后使用点（.）连接组成字符串，最后使用header中声明签名算法进行签名。

一个例子： 

 2、配置JWT令牌服务

@Configuration
public class TokenConfig {

    private String SIGNING_KEY = "uaa123";

    @Bean
    public TokenStore tokenStore(){
        //JWT令牌存储方案
        return new JwtTokenStore(accessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter accessTokenConverter(){
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey(SIGNING_KEY);//对称秘钥，资源服务器使用该秘钥来验证
        return converter;
    }

//    //令牌存储策略
//    @Bean
//    public TokenStore tokenStore(){
//
//        //内存方式，生成普通令牌
//        return new InMemoryTokenStore();
//    }
}
    @Autowired
    private JwtAccessTokenConverter accessTokenConverter;

    //令牌管理服务
    @Bean
    public AuthorizationServerTokenServices tokenService(){
        DefaultTokenServices service = new DefaultTokenServices();
        service.setClientDetailsService(clientDetailsService);//客户端信息服务
        service.setSupportRefreshToken(true);//是否产生刷新令牌
        service.setTokenStore(tokenStore);//令牌存储策略

        //令牌增强
        TokenEnhancerChain chain = new TokenEnhancerChain();
        chain.setTokenEnhancers(Arrays.asList(accessTokenConverter));
        service.setTokenEnhancer(chain);

        service.setAccessTokenValiditySeconds(7200);// 令牌默认有效期2小时
        service.setRefreshTokenValiditySeconds(259200);// 刷新令牌默认有效期3天
        return service;
    }

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Autowired
    private TokenStore tokenStore;

    public static final String RESOURCE_ID="res1";

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId(RESOURCE_ID)//资源 id
//                .tokenServices(tokenServices())//验证令牌服务
                .tokenStore(tokenStore)
                .stateless(true);
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)//session不用记录
                .and()
                .authorizeRequests()
                .antMatchers("/**").access("#oauth2.hasScope('all')");
    }

    //资源服务令牌解析服务
//    @Bean
//    public ResourceServerTokenServices tokenServices(){
//        //使用远程服务请求授权服务器校验token,必须指定校验token 的url、client_id，client_secret
//        RemoteTokenServices services = new RemoteTokenServices();
//        services.setCheckTokenEndpointUrl("http://localhost:53020/uaa/oauth/check_token");
//        services.setClientId("c1");
//        services.setClientSecret("secret");
//        return services;
//    }
}

 8、完善环境配置

截止目前客户端信息和授权码仍然存储在内存中，生产环境中通过会存储在数据库中，下边完善环境的配置：

建2张表：oauth_code（存储授权码）

DROP TABLE IF EXISTS `oauth_client_details`;
        CREATE TABLE `oauth_client_details`  (
        `client_id` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '客户端标
        识',
        `resource_ids` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
        COMMENT '接入资源列表',
        `client_secret` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
        COMMENT '客户端秘钥',
        `scope` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
        `authorized_grant_types` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT
        NULL,
        `web_server_redirect_uri` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT
        NULL,
        `authorities` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
        `access_token_validity` int(11) NULL DEFAULT NULL,
        `refresh_token_validity` int(11) NULL DEFAULT NULL,
        `additional_information` longtext CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
        `create_time` timestamp(0) NOT NULL DEFAULT CURRENT_TIMESTAMP(0) ON UPDATE
        CURRENT_TIMESTAMP(0),
        `archived` tinyint(4) NULL DEFAULT NULL,
        `trusted` tinyint(4) NULL DEFAULT NULL,
        `autoapprove` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
        PRIMARY KEY (`client_id`) USING BTREE
        ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '接入客户端信息'
        ROW_FORMAT = Dynamic;
        INSERT INTO `oauth_client_details` VALUES ('c1', 'res1',
        '$2a$10$NlBC84MVb7F95EXYTXwLneXgCca6/GipyWR5NHm8K0203bSQMLpvm', 'ROLE_ADMIN,ROLE_USER,ROLE_API',
        'client_credentials,password,authorization_code,implicit,refresh_token', 'http://www.baidu.com',
        NULL, 7200, 259200, NULL, '2019-09-09 16:04:28', 0, 0, 'false');
        INSERT INTO `oauth_client_details` VALUES ('c2', 'res2',
        '$2a$10$NlBC84MVb7F95EXYTXwLneXgCca6/GipyWR5NHm8K0203bSQMLpvm', 'ROLE_API',
        'client_credentials,password,authorization_code,implicit,refresh_token', 'http://www.baidu.com',
        NULL, 31536000, 2592000, NULL, '2019-09-09 21:48:51', 0, 0, 'false');
DROP TABLE IF EXISTS `oauth_code`;
        CREATE TABLE `oauth_code`  (
          `create_time` timestamp(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
          `code` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
          `authentication` blob NULL,
          INDEX `code_index`(`code`) USING BTREE
        ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

 

但盼风雨来 能留你在此
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpClient获取OAuth2.0中的code
09-20
通过httpclient post去获取,response返回码是302，返回的code放在header的Location中。 请求的时候client_id，response_type，redirect_uri，state拼接在url后面，account和password放在body表单（x-www-form-urlencoded）中
spring security oauth2.0 （讲义+代码）
03-10
总而言之，通过学习Spring Security OAuth2.0，开发者能够掌握一套完整的认证授权解决方案，从而为Web应用和API提供安全的访问控制。这个讲义结合代码的实践学习将帮助你深入理解并熟练运用这些概念。
Spring Security OAuth2：整合jwt
乌龟的专栏
08-12 805
接着上一篇博客：https://www.cnblogs.com/wwjj4811/p/14505081.html 1|0JWT介绍 JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种紧凑且独立的方式，用于在各方之间作为JSON对象安全地传输信息。此信息可以通过数字签名进行验证和信任。JWT可以使用秘密（使用HMAC算法）或使用RSA或ECDSA的公钥/私钥对进行签名，防止被篡改 1|1构成 JWT 有三部分构成：头部、有效载荷、签名 头部：包含令牌的类
Spring Security 与 JWT、OAuth 2.0 整合详解：构建安全可靠的认证与授权机制
最新发布
微笑听雨
06-13 4869
将 JWT（JSON Web Token）与 OAuth 2.0 整合到 Spring Security 中可以为应用程序提供强大的认证和授权功能。以下是详细的整合步骤和代码示例。
spring security 安全框架改造统一登录oauth2.0方式
itbigboy的博客
08-16 2055
，在统一登录页面输入用户名和密码，点击登录，统一登录平台负责校验账号和密码，完成后，会返回给你这边一个code,并执行回调路径打开我们的登录页（也可以不打开页面，就算打开也是为了拿到code,然后立马发送获取token的请求），然后我们拿着code去统一登录端换取token,(继上次改造统一登录之后，这次又接到改造任务，这次的项目结构略有不同，不再有web.xml文件，也不是集成的含有拦截器的jar包，而是oauth2.0的。首先是，摒弃我们的登录页面，vue项目启动的时候，自动跳转到统一登录页（.....
8. Spring Security 5.1之 OAuth 2.0 Login
极客星云-CSDN博客
04-14 6866
OAuth 2.0 Login实现了用例：“使用Google登录”或“使用GitHub登录”。
Spring Security OAuth2 Login学习及浅析
daiwuliang的博客
06-11 3381
概述 OAuth2是一个授权框架的标准，Spring Security对OAuth2.0的支持加以改造适配，支持用户使用已有的其他系统账户登陆应用（框架中默认支持包括GitHub, Facebook, Google, Okta）。 OAuth2.0 Login Spring Security OAuth2.0 Login是基于OAuth2.0协议和OpenID Connect Core1.0协议，按照其中的授权码模式实现。 使用GitHub账号登陆 GitHub中注册应用 设置地址为：https://git
Spring Security OAuth2 实现登录互踢
冷冷的博客
04-30 7576
背景说明 一个账号只能一处登录，类似的业务需求在现有后管类系统是非常常见的。 但在原有的 spring security oauth2 令牌方法流程（所谓的登录）无法满足类似的需求。 我们先来看 TokenEndpoint 的方法流程 客户端 带参访问 /oauth/token 接口，最后去调用 TokenGranter TokenGranter 根据不同的授权类型，获取用户认证信息 并去调用...
Spring Security#OAuth2
来啊 快活啊
06-20 4832
Congiurer ClientDetailsServiceConfigurer AuthorizationServerSecurityConfigure AuthorizationServerEndpointsConfigurer ResourceServerSecurityConfigurer HttpSecurity Authorization Server ClientDetailsServ
Spring Security Oauth2.0认证授权专题
06-19
Spring boot+Spring Security Oauth2.0，Sprint cloud+Spring Security Oauth2集成。四种认证方式。附带有代码，和案例，案例，还有视频链接。我保证看完就回，如果视频链接失效，评论回复我，我单独再给你一份。
Spring Security Oauth2.0 实现短信验证码登录示例
08-28
Spring Security Oauth2.0 是一个基于 Spring Security 框架的授权和身份验证机制，提供了强大的安全功能和灵活的配置选项。Oauth2.0 是一种 industry-standard 授权协议，提供了多种授权方式，例如授权码流程、...
视频配套笔记_Spring Security OAuth2.0认证授权_v1.1.rar
04-30
这个压缩包文件"视频配套笔记_Spring Security OAuth2.0认证授权_v1.1.rar"包含了对这一主题的详细解释和实例代码，旨在帮助开发者深入理解和应用OAuth2.0与Spring Security的集成。 首先，Spring Security是Spring...
Spring Cloud Alibaba 集成 Spring Security OAuth2.0 实现认证和授权
11-14
分布式系统的认证和授权 分布式架构采用 Spring Cloud Alibaba 认证和授权采用 Spring Security OAuth2.0 实现方法级权限控制 网关采用 gateway 中间件 服务注册和发现采用 nacos
如何用Spring Security OAuth2 实现登录互踢，面试必学
QQ2352108083的博客
05-07 1346
背景说明 一个账号只能一处登录，类似的业务需求在现有后管类系统是非常常见的。 但在原有的 spring security oauth2 令牌方法流程（所谓的登录）无法满足类似的需求。 我们先来看TokenEndpoint的方法流程 客户端 带参访问 /oauth/token 接口，最后去调用TokenGranter 另外要注意：突破高薪Java架构项目经验永远是核心，如果你没...
Spring Security+Oauth2+JWT实现用户登录逻辑，以及使用login接口登录成功返回token获取
z132411的博客
05-07 4600
目录 pom引入 配置Spring Security 1.实现UserDetailsService接口 2.登录成功处理 3.登录失败处理 4.登出处理 5.没有权限处理设置 6.匿名用户访问处理 7.指定加密方式 8.WebSecurityConfig配置 oauth2处理 配置授权服务器 配置资源服务器 jwt配置 jwt转换器 jwt扩展存储 本文整合了前两篇文章，再结合Oauth2实现了单点登录的基本处理。 之前的文章： SpringBoot整合Spring
SpringBoot集成SpringSecurity5和OAuth2 — 1、基于内存的OAuth2认证服务器
Mr_XiMu的博客
05-21 2364
SpringBoot集成SpringSecurity5和OAuth2 — 1、基于内存的OAuth2认证服务器
Spring Authorization Server实现Oauth2
Glory丶笨小孩
06-07 1231
Spring Authorization Server 实现Oauth2认证
Spring Security OAuth2.0(2):基于session的认证方式
不积跬步，无以至千里
07-06 773
它的交互流程是，用户认证成功后，在服务端生成用户相关的数据保存在session(当前会话)中，发给客户端的session_id存放到cookie中，这样用户客户端请求时带上session_id就可以验证服务器端是否存在session数据，以此完成用户的合法验证，当用户退出系统或session过期销毁时，客户端的session_id也就无效了。在上面，在登录成功会将用户存入session，在访问资源时getSession获取用户身份信息，在登出时，使session 无效已完成会话。(3) 编写登录认证接口。
拥抱 Spring 全新 OAuth 解决方案：spring-authorization-server 该怎么玩？
m0_71777195的博客
01-08 3313
真实原因：原先是因为个人原因，需要研究新版鉴权服务，看到了，使用过程中，想着能不能整合新版本cloud，因此此处先以springboot搭建，后续再替换为springcloud2021。官方原因：原先使用，而该项目已经逐渐被淘汰，虽然网上还是有不少该方案，但秉着技术要随时代更新，从而使用Spring 团队正式宣布停止维护，该项目将不会再进行任何的迭代至此，的基础使用已完成，总体上和原大差不差，个别配置项不同。
springsecurity oauth2.0认证流程
05-12
Spring Security OAuth2.0是基于Spring Security的框架，用于实现OAuth2.0协议。下面是OAuth2.0的认证流程： 1. 客户端向认证服务器发送认证请求，其中包括客户端ID和客户端密钥。 2. 认证服务器验证客户端的身份，并向客户端发送访问令牌请求。 3. 客户端向认证服务器发送访问令牌请求，其中包括客户端ID、客户端密钥和授权码。 4. 认证服务器验证客户端的身份和授权码，并向客户端发送访问令牌。 5. 客户端使用访问令牌请求资源服务器。 6. 资源服务器验证访问令牌的有效性，并向客户端发送请求数据。 具体来说，Spring Security OAuth2.0的认证流程如下： 1. 客户端向认证服务器发送认证请求。 2. 认证服务器验证客户端的身份，并向客户端发送授权码。 3. 客户端使用授权码向认证服务器发送访问令牌请求。 4. 认证服务器验证客户端的身份和授权码，并向客户端发送访问令牌。 5. 客户端使用访问令牌请求资源服务器。 6. 资源服务器验证访问令牌的有效性，并向客户端发送请求数据。 以上是Spring Security OAuth2.0的认证流程。在实现认证流程时，需要配置OAuth2.0相关的参数，如客户端ID、客户端密钥、授权码、访问令牌等。同时，还需要实现相关的接口和方法，如UserDetailsService、ClientDetailsService等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值