别人绕过我的网关直接调用资源服务怎么办？使用 Sa-Token 解决：网关转发鉴权、RPC调用鉴权

一、需求场景

在微服务项目中，我们的子服务一般不能通过外网直接访问，必须通过网关转发才是一个合法的请求，这种子服务与外网的隔离一般分为两种：

1. 物理隔离：子服务部署在指定的内网环境中，只有网关对外网开放。
2. 逻辑隔离：子服务与网关同时暴露在外网，但是子服务会有一个权限拦截层保证只接受网关发送来的请求，绕过网关直接访问子服务会被提示：无效请求。

这种鉴权需求牵扯到两个环节：网关转发鉴权、服务内部调用鉴权

Sa-Token提供两种解决方案：
1. 使用 OAuth2.0 模式的凭证式，将 Client-Token 用作各个服务的身份凭证进行权限校验。
2. 使用 Same-Token 模块提供的身份校验能力，完成服务间的权限认证。

本篇主要讲解方案二 Same-Token 模块的整合步骤，其鉴权流程与 OAuth2.0 类似，不过使用方式上更加简洁。

Sa-Token 是一个轻量级 java 权限认证框架，主要解决登录认证、权限认证、单点登录、OAuth2、微服务网关鉴权 等一系列权限相关问题。
Gitee 开源地址：https://gitee.com/dromara/sa-token

二、网关转发鉴权

1、引入依赖

在网关处引入的依赖为（此处以 SpringCloud Gateway 为例）：

<!-- Sa-Token 权限认证（Reactor响应式集成）, 在线文档：https://sa-token.com -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-reactor-spring-boot-starter</artifactId>
    <version>1.34.0</version>
</dependency>

<!-- Sa-Token 整合 Redis （使用 jackson 序列化方式） -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-dao-redis-jackson</artifactId>
    <version>1.34.0</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Gradle 方式：

// Sa-Token 权限认证（Reactor响应式集成），在线文档：https://sa-token.com
implementation 'cn.dev33:sa-token-reactor-spring-boot-starter:1.34.0'

// Sa-Token 整合 Redis （使用 jackson 序列化方式）
implementation 'cn.dev33:sa-token-dao-redis-jackson:1.34.0'
implementation 'org.apache.commons:commons-pool2'
1
2
3
4
5
6

在子服务引入的依赖为：

<!-- Sa-Token 权限认证, 在线文档：https://sa-token.com -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-spring-boot-starter</artifactId>
    <version>1.34.0</version>
</dependency>

<!-- Sa-Token 整合 Redis （使用 jackson 序列化方式） -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-dao-redis-jackson</artifactId>
    <version>1.34.0</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Gradle 方式：

// Sa-Token 权限认证，在线文档：https://sa-token.com
implementation 'cn.dev33:sa-token-spring-boot-starter:1.34.0'

// Sa-Token 整合 Redis （使用 jackson 序列化方式）
implementation 'cn.dev33:sa-token-dao-redis-jackson:1.34.0'
implementation 'org.apache.commons:commons-pool2'
1
2
3
4
5
6

2、网关处添加Same-Token

为网关添加全局过滤器：

/**
 * 全局过滤器，为请求添加 Same-Token 
 */
@Component
public class ForwardAuthFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest newRequest = exchange
                .getRequest()
                .mutate()
                // 为请求追加 Same-Token 参数 
                .header(SaSameUtil.SAME_TOKEN, SaSameUtil.getToken())
                .build();
        ServerWebExchange newExchange = exchange.mutate().request(newRequest).build();
        return chain.filter(newExchange);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

此过滤器会为 Request 请求头追加 Same-Token 参数，这个参数会被转发到子服务

3、在子服务里校验参数

在子服务添加过滤器校验参数

/**
 * Sa-Token 权限认证 配置类 
 */
@Configuration
public class SaTokenConfigure implements WebMvcConfigurer {
    // 注册 Sa-Token 全局过滤器 
    @Bean
    public SaServletFilter getSaServletFilter() {
        return new SaServletFilter()
                .addInclude("/**")
                .addExclude("/favicon.ico")
                .setAuth(obj -> {
                    // 校验 Same-Token 身份凭证   —— 以下两句代码可简化为：SaSameUtil.checkCurrentRequestToken(); 
                    String token = SaHolder.getRequest().getHeader(SaSameUtil.SAME_TOKEN);
                    SaSameUtil.checkToken(token);
                })
                .setError(e -> {
                    return SaResult.error(e.getMessage());
                })
                ;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

启动网关与子服务，访问测试：

如果通过网关转发，可以正常访问，直接访问子服务会提示：无效Same-Token：xxx

三、RPC调用鉴权

有时候我们需要在一个服务调用另一个服务的接口，这也是需要添加Same-Token作为身份凭证的

在服务里添加 Same-Token 流程与网关类似，我们以RPC框架 Feign 为例：

1、首先在调用方添加 FeignInterceptor

/**
 * feign拦截器, 在feign请求发出之前，加入一些操作 
 */
@Component
public class FeignInterceptor implements RequestInterceptor {
    // 为 Feign 的 RCP调用 添加请求头Same-Token 
    @Override
    public void apply(RequestTemplate requestTemplate) {
        requestTemplate.header(SaSameUtil.SAME_TOKEN, SaSameUtil.getToken());
    }
}
1
2
3
4
5
6
7
8
9
10
11

2、在调用接口里使用此 Interceptor

/**
 * 服务调用 
 */
@FeignClient(
        name = "sp-home",               // 服务名称 
        configuration = FeignInterceptor.class,     // 请求拦截器 （关键代码）
        fallbackFactory = SpCfgInterfaceFallback.class  // 服务降级处理 
        )   
public interface SpCfgInterface {

    // 获取server端指定配置信息 
    @RequestMapping("/SpConfig/getConfig")
    public String getConfig(@RequestParam("key")String key);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

被调用方的代码无需更改（按照网关转发鉴权处的代码注册全局过滤器），保持启动测试即可

四、Same-Token 模块详解

Same-Token —— 专门解决同源系统互相调用时的身份认证校验，它的作用不仅局限于微服务调用场景。

基本使用流程为：服务调用方获取Token，提交到请求中，被调用方取出Token进行校验：Token一致则校验通过，否则拒绝服务。

首先我们预览一下此模块的相关API：

// 获取当前Same-Token
SaSameUtil.getToken();

// 判断一个Same-Token是否有效
SaSameUtil.isValid(token);

// 校验一个Same-Token是否有效 (如果无效则抛出异常)
SaSameUtil.checkToken(token);

// 校验当前Request提供的Same-Token是否有效 (如果无效则抛出异常)
SaSameUtil.checkCurrentRequestToken();

// 刷新一次Same-Token (注意集群环境中不要多个服务重复调用) 
SaSameUtil.refreshToken();

// 在 Request 上储存 Same-Token 时建议使用的key
SaSameUtil.SAME_TOKEN;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1、疑问：这个Token保存在什么地方？有没有泄露的风险？Token为永久有效还是临时有效？

Same-Token 默认随 Sa-Token 数据一起保存在Redis中，理论上不会存在泄露的风险，每个Token默认有效期只有一天

2、如何主动刷新Same-Token，例如：五分钟、两小时刷新一次？

Same-Token 刷新间隔越短，其安全性越高，每个Token的默认有效期为一天，在一天后再次获取会自动产生一个新的Token

需要注意的一点是：Same-Token默认的自刷新机制，并不能做到高并发可用，多个服务一起触发Token刷新可能会造成毫秒级的短暂服务失效，其只能适用于 项目开发阶段 或 低并发业务场景

因此在微服务架构下，我们需要有专门的机制主动刷新Same-Token，保证其高可用

例如，我们可以专门起一个服务，使用定时任务来刷新Same-Token

/**
 * Same-Token，定时刷新
 */
@Configuration
public class SaSameTokenRefreshTask {
    // 从 0 分钟开始 每隔 5 分钟执行一次 Same-Token  
    @Scheduled(cron = "0 0/5 * * * ? ")
    public void refreshToken(){
        SaSameUtil.refreshToken();
    }
}
1
2
3
4
5
6
7
8
9
10
11

以上的cron表达式刷新间隔可以配置为五分钟、十分钟 或 两小时，只要低于Same-Token的有效期（默认为一天）即可。

3、如果网关携带token转发的请求在落到子服务的节点上时，恰好刷新了token，导致鉴权未通过怎么办？

Same-Token 模块在每次刷新 Token 时，旧 Token 会被作为次级 Token 存储起来，
只要网关携带的 Token 符合新旧 Token 其一即可通过认证，直至下一次刷新，新 Token 再次作为次级 Token 将此替换掉。

五、在 Dubbo 中集成 Same-Token

Same-Token 不仅可以为 Feign 提供调用鉴权操作，在 dubbo 的 RPC 调用时也可以使用 Same-Token 进行鉴权，提供这个能力的正是 sa-token-context-dubbo 插件。

1、先说说要解决的问题

在 Dubbo 的整个调用链中，代码被分为 Consumer 端和 Provider 端，为方便理解我们可以称其为 [调用端] 和 [被调用端]。

RPC 模式的调用，可以让我们像调用本地方法一样完成服务通信，然而这种便利下却隐藏着两个问题：

• 上下文环境的丢失。
• 上下文参数的丢失。

这种问题作用在 Sa-Token 框架上就是，在 [ 被调用端 ] 调用 Sa-Token 相关API会抛出异常：无效上下文。

所以本插件的目的也就是解决上述两个问题：

• 在 [ 被调用端 ] 提供以 Dubbo 为基础的上下文环境
• 在 RPC 调用时将 Token 传递至 [ 被调用端 ]，同时在调用结束时将 Token 回传至 [ 调用端 ]。

2、引入插件

在项目已经引入 Dubbo 的基础上，继续添加依赖（Consumer 端和 Provider 端都需要引入）：

<!-- Sa-Token 整合 Dubbo -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-context-dubbo</artifactId>
    <version>1.34.0</version>
</dependency>
1
2
3
4
5
6

Gradle 方式

// Sa-Token 整合 Dubbo
implementation 'cn.dev33:sa-token-context-dubbo:1.34.0'
1
2

然后我们就可以愉快的做到以下事情：

1. 在 [ 被调用端 ] 安全的调用 Sa-Token 相关 API。
2. 在 [ 调用端 ] 登录的会话，其登录状态可以自动传递到 [ 被调用端 ] 。
3. 在 [ 被调用端 ] 登录的会话，其登录状态也会自动回传到 [ 调用端 ] 。

但是我们仍具有以下限制：

1. [ 调用端 ] 与 [ 被调用端 ] 的 SaStorage 数据无法互通。
2. [ 被调用端 ] 执行的 SaResponse.setHeader()、setStatus() 等代码无效。

应该合理避开以上 API 的使用。

3、dubbo 的 RPC调用鉴权

下面我们演示一下在 Dubbo 中如何集成 Same-Token 模块。其实思路和 Feign 模式一致，在 [ 调用端 ] 追加 Same-Token 参数，在 [ 被调用端 ] 校验这个 Same-Token 参数：

• 校验通过：调用成功。
• 校验不通过：调用失败，抛出异常。

我们有两种方式完成整合。

方式一、使用配置（推荐）

直接在 application.yml 配置即可：

sa-token: 
    # 打开 RPC 调用鉴权 
    check-same-token: true
1
2
3

# 打开 RPC 调用鉴权 
sa-token.check-same-token=true
1
2

方式二、自建 Dubbo 过滤器校验

此方式略显繁琐，好处是除了Same-Token，我们还可以添加其它自定义参数 (attachment)。

1、在 [ 调用端 ] 的 \resources\META-INF\dubbo\ 目录新建 org.apache.dubbo.rpc.Filter 文件

dubboConsumerFilter=com.pj.DubboConsumerFilter
1

新建 DubboConsumerFilter.java 过滤器

package com.pj;

import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;

import cn.dev33.satoken.same.SaSameUtil;

/**
 * Sa-Token 整合 Dubbo Consumer端过滤器 
 */
@Activate(group = {CommonConstants.CONSUMER}, order = -10000)
public class DubboConsumerFilter implements Filter {

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {

        // 追加 Same-Token 参数 
        RpcContext.getContext().setAttachment(SaSameUtil.SAME_TOKEN, SaSameUtil.getToken());

        // 如果有其他自定义附加数据，如租户
        // RpcContext.getContext().setAttachment("tenantContext", tenantContext);

        // 开始调用
        return invoker.invoke(invocation);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2、在 [ 被调用端 ] 的 \resources\META-INF\dubbo\ 目录新建 org.apache.dubbo.rpc.Filter 文件

dubboProviderFilter=com.pj.DubboProviderFilter
1

新建 DubboProviderFilter.java 过滤器

package com.pj;

import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;

import cn.dev33.satoken.same.SaSameUtil;

/**
 * Sa-Token 整合 Dubbo Provider端过滤器 
 */
@Activate(group = {CommonConstants.PROVIDER}, order = -10000)
public class DubboProviderFilter implements Filter {

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {

        // 取出 Same-Token 进行校验 
        String sameToken = invocation.getAttachment(SaSameUtil.SAME_TOKEN);
        SaSameUtil.checkToken(sameToken);

        // 取出其他自定义附加数据
        // TenantContext tenantContext = invocation.getAttachment("tenantContext");

        // 开始调用
        return invoker.invoke(invocation);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

然后我们就可以进行安全的 RPC 调用了，不带有 Same-Token 参数的调用都会抛出异常，无法调用成功。

---

参考资料

• Sa-Token 文档：https://sa-token.com
• Gitee 仓库地址：https://gitee.com/dromara/sa-token
• GitHub 仓库地址：https://github.com/dromara/sa-token