分布式/微服务/架构

 所有文章
分布式 ID 生成方案探讨 MySQL 建表参考 RPC 协议中的数据签名验签和加解密方案探讨 关于服务间调用循环依赖的一些思考 如何部署服务 灰度发布 日志级别 数据库分库分表指南 关于对账的一些理解 缓存 MySQL 初始化数据的一些方案 一个可扩展的 MQ 消息设计

一个简单可靠的 Dubbo 请求/响应数据签名方案

背景

数据签名可以用来校验数据的合法性。

我在使用 Dubbo 的过程中，遇到了以下一些校验请求/响应来源合法性的方案：

方案1

在请求的 attatchment 中写入一个约定的key-value键值对，服务方发现有该键值对则认为合法，否则认为不合法。

该方案，毫无意义。

方案2

对于部分字段，使用双方约定的密钥，生成签名（一般是用一个哈希算法，也可以用公私钥的方式进行签名，这里不具体讲）。

例如约定每个请求中都带上一个 appId 和时间戳字段，签名计算方式如下：

签名 = MD5(appId值 + 时间戳 + 密钥值)

该方案问题如下：

  • 服务端没有限制时间戳只能是最近一段时间内的，所以无法提前拦截不合理的请求重放。
  • 签名没有包含业务字段，所以坏人截获到一个请求后，修改业务字段后，重新发起请求，服务端校验签名会通过。

方案3

将业务数据请求和响应字段固定化，增加字符串类型的 extra 字段用于以后的扩展，这种情况下 extra 中一般是个 JSON 格式的字符串。

将所有的字段按照约定的顺序组装在一起，使用双方约定的密钥，生成签名。

该方案的问题：

  • 字段固化，扩展性差。虽然增加了 extra 字段以保证扩展性，但是 extra 的维护会非常麻烦。

方案4

通过反射的形式拿到所有的字段，对所有的字段值按照字段名排序，然后组装在一起，使用双方约定的密钥，生成签名。

该方案的问题：

  • 组装是以字符串的形式进行组装，这意味着客户端和服务端对于相同字段转字符串的方式必须相同。这对于复杂类型有一定的挑战。比如某个字段是 UserInfo 类型，内部有 name、mail 等字段，客户端和服务端要必须保证对该对象转字符串的结果是相同的。最理想的方案是复杂类型内部的字段再进行一次排序。这增加了实现的复杂度。
  • 该方案中，若某字段值为 null，则字段名和字段值都不要用于签名，否则在新增字段的场景中服务上线会有问题。因为在Dubbo 中对协议新增字段后，服务端和客户端无法同时上线，无论是服务端先上线还是客户端先上线，都会导致服务端验签名失败。
  • 上面这一点，导致了新增字段不能有默认值。

上面的几个方案都或多或少有些问题。为了避免上面那些问题，我尝试设计了下面这一方案。

网上暂未找到类似的方案，如有类似，说明正好想到一块了。

一个简单可靠的方案

实现一个简单可靠的签名机制有两个思路：

思路1: 让 Dubbo 自身支持对请求/响应数据的签名验证。在 Dubbo 中，网络传输的是 Java 对象序列化后的二进制数据，可以对这个二进制数据进行签名。这其实是对 Dubbo 协议的修改。

思路2: 把 Dubbo 协议类比网络中的tcp/ip 层，业务代码是 http 层。将签名放在 http 层。上面介绍的几个方案其实都是这个思路。

思路1需要对 Dubbo 本身的实现进行侵入性修改，本文不考虑。

我们看下思路2如何实现。

步骤1：设计基础字段

@Data
public class SignedDataContainer implements Serializable {

    // 调用方标识，会分配密钥
    private String appId;
    // 时间戳（单位秒）
    private Long timestamp;
    // 业务数据（使用 json 序列化）
    private String bizData;
    // 签名
    private String sign;

}

bizData 存放业务数据，业务上要扩展，直接在 bizData 中扩展即可。

SignedDataContainer 类本身被设计为不能扩展，也不需要扩展，

步骤2: 设计生成签名、验证签名的方式

在 SignedDataContainer 中新增以下方法：

/**
 * 生成 timestamp、sign
 *
 * @param secretKey 密钥
 */
public void generateSign(String secretKey) {
    this.timestamp = System.currentTimeMillis()/1000;
    this.sign = buildSign(secretKey);
}

/**
 * 校验签名
 *
 * @param secretKey 密钥
 * @return 校验结果
 */
public boolean checkSign(String secretKey) {
    return Objects.equals(this.sign, buildSign(secretKey));
}

/**
 * 生成签名
 * @param secretKey 密钥
 * @return 签名
 */
private String buildSign(String secretKey) {
    String data = String.format("appId=%s&timestamp=%s&bizData=%s&secretKey=%s",
            appId == null ? "" : appId,
            timestamp,
            bizData,
            secretKey == null ? "" : secretKey);
    // 使用 sha256 算法签名，基于 Guava 库 Hashing 类
    return Hashing.sha256().newHasher().putString(data, Charsets.UTF_8).hash().toString();
}

SignedDataContainer 类中 sign 字段之外的所有字段都参与了签名，所以数据合法性是能保证的。

步骤3: 让 bizData 更好用

到目前，bizData 被设计成 JSON 字符串，这对开发并不友好。如果能直接反序列化为实际的业务类，那么该方案更容易被人接受。

我们将业务类用泛型进行抽象，基于 gson 库提供序列化和反序列化方法：

public class SignedDataContainer<T> implements Serializable {

    // 调用方标识，会分配密钥
    private String appId;
    // 时间戳（单位秒）
    private Long timestamp;
    // 业务数据（使用 json 序列化）
    private String bizData;
    // 签名
    private String sign;

    /**
     * 将 bizData 反序列化为业务类对象
     *
     * @param clz 业务类类型
     * @return 业务类对象
     */
    public T fetchBizData(Class<T> clz) {
        Gson gson = new Gson();
        if (bizData == null) {
            return null;
        }
        return gson.fromJson(this.bizData, clz);
    }

    /**
     * 将 bizData 反序列化为业务类对象
     *
     * @param typeToken 业务类本身若有泛型（例如List&lt;String&gt;），则需要使用 TypeToken 机制反序列化
     * @return 业务类对象
     */
    public T fetchBizData(TypeToken<T> typeToken) {
        Gson gson = new Gson();
        if (bizData == null) {
            return null;
        }
        return gson.fromJson(this.bizData, typeToken.getType());
    }

    /**
     * 将业务类对象序列化为 bizData
     * @param obj
     */
    public void storeBizData(T obj) {
        Gson gson = new Gson();
        if (obj == null) {
            return;
        }
        this.bizData = gson.toJson(obj);
    }

    // 省略其他方法

步骤4: 增强字段校验

Dubbo 支持对请求类中的 @NotNull 等注解修饰的字段进行校验。现在我们将业务数据以字符串的形式放到 bizData 中了，那么可以将 bizData 反序列化为业务类，然后对业务类进行字段校验。

可以自定义一个校验工具类：

import org.hibernate.validator.messageinterpolation.ParameterMessageInterpolator;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import java.util.Set;

public class ValidatorUtil {

     private final static Validator validator = Validation.byDefaultProvider()
             .configure()
             .messageInterpolator(new ParameterMessageInterpolator())
             .buildValidatorFactory()
             .getValidator();

    /**
     * 对象内部的字段校验
     *
     * @param obj
     * @param <T>
     */
     public static <T> void validate(T obj) {
         if (obj == null) {
             throw new RuntimeException("不能为null");
         }
         Set<ConstraintViolation<T>> constraintViolations = validator.validate(obj);
         for(ConstraintViolation<T> item : constraintViolations) {
             throw new RuntimeException(item.getMessage());
         }
     }

}

使用示例：

import lombok.Data;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import javax.validation.constraints.NotBlank;

public class ValidatorUtilTest {

    @Data
    public static class UserInfo {
        @NotBlank(message = "name 不能为空")
        private String name;
    }


    @Test
    public void test_validate() {
        UserInfo userInfo = new UserInfo();

        // 因为 name 没有值，校验不通过，抛异常
        try {
            ValidatorUtil.validate(userInfo);
            Assertions.fail();
        } catch (RuntimeException ex) {
            Assertions.assertEquals("name 不能为空", ex.getMessage());
        }

        // 通过设值，让校验通过
        userInfo.setName("李白");
        ValidatorUtil.validate(userInfo);
    }

}

步骤5：增加时间校验，防止重放

这个比较简单，加一下范围限制就行。例如限制客户端传入的时间戳只能在服务端当前时间前后 5 分钟之内。

使用示例

示例1

SignedDataContainer<Long> signedDataContainer = new SignedDataContainer<>();
signedDataContainer.storeBizData(123L);
Long bizData = signedDataContainer.fetchBizData(Long.class);
Assertions.assertEquals(123L, bizData);

示例2

SignedDataContainer<Void> signedDataContainer = new SignedDataContainer<>();
signedDataContainer.storeBizData(null);
Object obj = signedDataContainer.fetchBizData(Void.class);
Assertions.assertNull(obj);

示例3

SignedDataContainer<List<String>> signedDataContainer = new SignedDataContainer<>();
signedDataContainer.storeBizData(Lists.newArrayList("123", "456"));
List<String> bizData = signedDataContainer.fetchBizData(new TypeToken<List<String>>(){});
System.out.println(bizData);
Assertions.assertEquals(2, bizData.size());
Assertions.assertEquals("123", bizData.get(0));
Assertions.assertEquals("456", bizData.get(1));

示例4

String appId = "appId-test";
String secretKey = "sk-test";
SignedDataContainer<String> signedDataContainer = new SignedDataContainer<>();
signedDataContainer.setAppId(appId);
signedDataContainer.storeBizData("hello");
signedDataContainer.generateSign(secretKey);
Assertions.assertTrue(signedDataContainer.checkSign(secretKey));
Assertions.assertFalse(signedDataContainer.checkSign(secretKey + "111"));

更多基于单测的示例和 Dubbo 示例，见 https://github.com/letiantian/dubbo-sign-demo 。


( 本文完 )

转载请注明出处   |   关于   |   苏ICP备19034720号-1
文章目录