Soul源码阅读 - Waf插件

前言

Waf插件，是网关的用来对流量实现防火墙功能的核心实现。主要用来拦截非法请求，或者异常请求，并且给与相关的拒绝策略。

配置插件

插件设置

在soul控制台上设置：系统管理 --> 插件管理 --> waf 设置为开启状态。

16121700235661.jpg

配置选择器和规则

在soul控制台上设置：插件列表 --> waf

添加“选择器”
添加“规则”

选择器配置

条件：对匹配前缀”/http/“的请求都进行处理

规则配置

我们对非法客户端的请求进行拦截。如：127.0.0.1的客户端拒绝请求。

网关设置

在网关的pom.xml 文件中添加如下代码：

<dependency>
  <groupId>org.dromara</groupId>
  <artifactId>soul-spring-boot-starter-plugin-waf</artifactId>
  <version>${last.version}</version>
</dependency>

请求URL: GET http://127.0.0.1:9195/http/order/findById?id=1

GET http://127.0.0.1:9195/http/order/findById?id=1

HTTP/1.1 403 Forbidden
Content-Type: application/json
content-length: 64

{
  "code": 500,
  "message": " You are forbidden to visit",
  "data": null
}

Response code: 403 (Forbidden); Time: 184506ms; Content length: 64 bytes

我们看到，http response status：403。拒绝请求。返回的状态码为：500（在soul控制台上设置的）。

我们在规则配置里再增加一条规则，如下：

16121710625887.jpg

该规则配置，是当url的query param: id=1时拒绝请求，id为其它则通过。

请求URL：GET http://127.0.0.1:9195/http/order/findById?id=1 时，请求被拒绝：

GET http://127.0.0.1:9195/http/order/findById?id=1

HTTP/1.1 403 Forbidden
Content-Type: application/json
content-length: 64

{
  "code": 500,
  "message": " You are forbidden to visit",
  "data": null
}

Response code: 403 (Forbidden); Time: 3126ms; Content length: 64 bytes

请求URL：GET http://127.0.0.1:9195/http/order/findById?id=2 时，请求通过：

GET http://127.0.0.1:9195/http/order/findById?id=2

HTTP/1.1 200 OK
content-length: 0

<Response body is empty>

Response code: 200 (OK); Time: 3543ms; Content length: 0 bytes

源码分析

AbstractSoulPlugin类：wafPlugin的父类

public abstract class AbstractSoulPlugin implements SoulPlugin {
    // 处理web请求，并交由下一个plugin处理
    // 该方法，主要是验证选择器和规则是否match，然后交由不同的插件去处理不同的逻辑
    @Override
    public Mono<Void> execute(final ServerWebExchange exchange, final SoulPluginChain chain) {
        String pluginName = named();
        // 获取插件配置
        final PluginData pluginData = BaseDataCache.getInstance().obtainPluginData(pluginName);
        // 是否开启插件，没有开启则传递下一下插件去处理
        if (pluginData != null && pluginData.getEnabled()) {
            // 获取选择器
            final Collection<SelectorData> selectors = BaseDataCache.getInstance().obtainSelectorData(pluginName);
            if (CollectionUtils.isEmpty(selectors)) {
                return handleSelectorIsNull(pluginName, exchange, chain);
            }
            // 匹配选择器
            final SelectorData selectorData = matchSelector(exchange, selectors);
            if (Objects.isNull(selectorData)) {
                return handleSelectorIsNull(pluginName, exchange, chain);
            }
            selectorLog(selectorData, pluginName);
            // 获取规则列表
            final List<RuleData> rules = BaseDataCache.getInstance().obtainRuleData(selectorData.getId());
            if (CollectionUtils.isEmpty(rules)) {
                return handleRuleIsNull(pluginName, exchange, chain);
            }
            RuleData rule;
            // 如果是full，则获取最近的一个规则
            if (selectorData.getType() == SelectorTypeEnum.FULL_FLOW.getCode()) {
                //get last
                rule = rules.get(rules.size() - 1);
            } else {
                // 根据规则匹配
                rule = matchRule(exchange, rules);
            }
            if (Objects.isNull(rule)) {
                return handleRuleIsNull(pluginName, exchange, chain);
            }
            ruleLog(rule, pluginName);
            // 交由子类去处理
            return doExecute(exchange, chain, selectorData, rule);
        }
        // 交由下一个插件去处理
        return chain.execute(exchange);
    }

WafPlugin类:

public class WafPlugin extends AbstractSoulPlugin {

    @Override
    protected Mono<Void> doExecute(final ServerWebExchange exchange, final SoulPluginChain chain, final SelectorData selector, final RuleData rule) {
        // 获取Waf配置
        WafConfig wafConfig = Singleton.INST.get(WafConfig.class);
        // 如果没有匹配的选择器和规则
        if (Objects.isNull(selector) && Objects.isNull(rule)) {
            // 如果waf配置是black模式，则跳过。交由下一个插件处理
            if (WafModelEnum.BLACK.getName().equals(wafConfig.getModel())) {
                return chain.execute(exchange);
            }
            // 设置 403 status code
            exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
            // 设置 error 信息
            Object error = SoulResultWrap.error(HttpStatus.FORBIDDEN.value(), Constants.REJECT_MSG, null);
            // 返回response
            return WebFluxResultUtils.result(exchange, error);
        }
        // 获取规则配置信息
        String handle = rule.getHandle();
        WafHandle wafHandle = GsonUtils.getInstance().fromJson(handle, WafHandle.class);
        // 如规则为Null或者permission为空，交由下一个插件处理
        if (Objects.isNull(wafHandle) || StringUtils.isBlank(wafHandle.getPermission())) {
            log.error("waf handler can not configuration：{}", handle);
            return chain.execute(exchange);
        }
        // 如果permission是reject，则返回 403 status code
        if (WafEnum.REJECT.getName().equals(wafHandle.getPermission())) {
            exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
            Object error = SoulResultWrap.error(Integer.parseInt(wafHandle.getStatusCode()), Constants.REJECT_MSG, null);
            // 返回response
            return WebFluxResultUtils.result(exchange, error);
        }
        // 交由下一个插件处理
        return chain.execute(exchange);
    }
}

总结

今天学习waf插件的使用和源码分析，我们可以利用这个插件，防止恶意请求攻击。