【自研网关系列】数字签名和url动态加密

喔喔咿哈哈

已于 2024-05-10 15:05:37 修改

阅读量552

点赞数 25

分类专栏：自研网关文章标签： java 后端面试开源 github

于 2024-05-10 15:00:47 首次发布

本文链接：https://blog.csdn.net/m0_63208096/article/details/138666594

版权

自研网关专栏收录该内容

14 篇文章 1 订阅

订阅专栏

🌈Yu-Gateway：：基于 Netty 构建的自研 API 网关，采用 Java 原生实现，整合 Nacos 作为注册配置中心。其设计目标是为微服务架构提供高性能、可扩展的统一入口和基础设施，承载请求路由、安全控制、流量治理等核心网关职能。

🌈项目代码地址：https://github.com/YYYUUU42/YuGateway-master

如果该项目对你有帮助，可以在 github 上点个 ⭐ 喔 🥰🥰

🌈自研网关系列：可以点开专栏，参看完整的文档

1、加密算法

在网络传递数据的时候，为了防止数据被篡改，我们会对数据进行加密，数据加密分为对此加密和非对称加密。其中 RSA 和 AES，TLS 等加密算法是比较常用的。

这里就参考 https 解决 http 的明文风险，来完成这块的加密内容

1.1、对称加密

对称加密是指加密和解密使用相同的密钥的加密方法，基本流程包括以下步骤

密钥生成
- 双方协商生成一个共享密钥，或由一方生成密钥并安全地传输到另一方

加密
- 使用共享密钥对原始数据进行加密，得到加密后的数据
传输
- 将加密后的数据传输给另一方
加密
- 接收方使用相同的共享密钥对加密数据进行解密，得到原始数据

1.2、非对称加密

非对称加密是指加密和解密使用不同的密钥的加密方法，通常称为公钥和密钥

密钥对生成
- 生产一对秘钥，一个是公钥，另一个私钥。公钥可以公开，而私钥需要保密

公钥分发
- 将公钥发送给需要加密数据的一方
加密
- 使用公钥对原始数据进行加密，得到加密后的数据
传输
- 将加密后数据传输给另一方
解密
- 接受方使用私钥对数据进行解密，得到原始数据

1.3、混合加密

HTTPS 采用的是对称加密和非对称加密结合的「混合加密」方式：

在通信建立前采用非对称加密的方式交换「会话秘钥」，后续就不再使用非对称加密。
在通信过程中全部使用对称加密的「会话秘钥」的方式加密明文数据。

采用「混合加密」的方式的原因：

对称加密只使用一个密钥，运算速度快，密钥必须保密，无法做到安全的密钥交换。
非对称加密使用两个密钥：公钥和私钥，公钥可以任意分发而私钥保密，解决了密钥交换问题但速度慢。

1.4、摘要算法 + 数字签名

为了保证传输的内容不被篡改，我们需要对内容计算出一个「指纹」，然后同内容一起传输给对方。

对方收到后，先是对内容也计算出一个「指纹」，然后跟发送方发送的「指纹」做一个比较，如果「指纹」相同，说明内容没有被篡改，否则就可以判断出内容被篡改了。

那么，在计算机里会用摘要算法（哈希函数）来计算出内容的哈希值，也就是内容的「指纹」，这个哈希值是唯一的，且无法通过哈希值推导出内容。

通过哈希算法可以确保内容不会被篡改，但是并不能保证「内容 + 哈希值」不会被中间人替换，因为这里缺少对客户端收到的消息是否来源于服务端的证明。

那为了避免这种情况，计算机里会用非对称加密算法来解决，共有两个密钥：

一个是公钥，这个是可以公开给所有人的
一个是私钥，这个必须由本人管理，不可泄露

这两个密钥可以双向加解密的，比如可以用公钥加密内容，然后用私钥解密，也可以用私钥加密内容，公钥解密内容。

流程的不同，意味着目的也不相同：

公钥加密，私钥解密：这个目的是为了保证内容传输的安全，因为被公钥加密的内容，其他人是无法解密的，只有持有私钥的人，才能解密出实际的内容
私钥加密，公钥解密：个目的是为了保证消息不会被冒充，因为私钥是不可泄露的，如果公钥能正常解密出私钥加密的内容，就能证明这个消息是来源于持有私钥身份的人发送的

一般我们不会用非对称加密来加密实际的传输内容，因为非对称加密的计算比较耗费性能的。

1.5、RSA 和 AES

加密的基本思想是将数据转换成一种掩盖了原始含义的形式，只有经过适当授权的人才能解密。使用相同或不同的密钥对数据进行加解密，如果加密和解密使用相同的密钥，则称该过程是对称的。如果使用不同的密钥，则该过程被定义为非对称的。

当今使用最广泛的两种加密算法是 AES 和 RSA。两者都非常有效和安全，但它们通常以不同的方式使用。

AES

AES 算法依次对每个 128 位数据块应用一系列数学变换。由于这种方法的计算要求较低，AES 可用于笔记本电脑和智能手机等消费类设备上进行数据加密，以及快速加密大量数据。

AES 是一种对称算法，它使用相同的 128、192 或 256 位密钥进行加密和解密。128、192 或 256 位的密钥可以理解为分别对应16、24和32个字节的16进制字符串密钥，AES 系统的安全性会随密钥长度呈指数增长。

即使使用 128 位密钥，通过对 2128 个可能的密钥值进行暴力枚举，来尝试破解 AES加密后的数据的任务也是个非常计算密集型的任务。事实上，AES 从未被破解，并且根据当前的技术趋势，预计在未来几年内仍将保持安全。

RSA

RSA 以麻省理工学院的科学家（Rivest、Shamir 和 Adleman）的名字命名，于1977 年首次公布。它是一种非对称算法，它使用公开的已知密钥进行加密，但需要另外一个不同的密钥进行解密，这个不同的密钥只有预期的接收者知道。

AES 和 RSA 混合使用

AES 算法的一个主要问题是，作为一种对称算法，它要求加密方和解密方使用相同的密钥。这就产生了一个关键的密钥管理问题——如何将非常重要的密钥分发给分布在世界各地的授权接收者，而不会冒在传输途中某个地方考虑不周导致密钥泄露的巨大风险？答案是结合 AES 和 RSA 加密的优势。

在包括互联网在内的许多现代通信环境中，大量交换的数据都通过快速 AES 算法进行加密。为了获得解密数据所需的密钥，授权接收者发布一个公钥，同时保留一个只有他们知道的相关私钥。然后，发送方使用该公钥对他们自己的 AES 密钥进行RSA加密传输给接收方，接收方使用私钥解密得到AES密钥，再用该密钥对数据进行解密。

2、网关实战

根据上述知识，就可以通过RSA 和 AES 混合使用来实现 url 动态加密了，依然用 debug 的方式来讲解。由于没有前端，所以就用后端模拟前端加密，手动把加密后信息通过 postman 发送给后端。由于代码较多，就不展示全部代码了

2.1、公钥获取

这里主要目的是为每个用户生成一个 RSA 密钥对，并将私钥安全地存储在服务器端（这里是 Redis），然后将公钥返回给客户端。这样，客户端可以使用公钥进行加密操作，而只有拥有私钥的服务器才能解密，这是一种常见的公钥加密应用场景。

生成 RSA 密钥对：调用了 RSAUtil 类的 getKeyPair 方法，生成了一个 RSA 密钥对，包括公钥和私钥。
从请求的 Cookie 中获取 token：从 HTTP 请求的 Cookie 中获取 token。
从 token 中获取 userId：使用 JWTUtil 的 getClaimByToken 方法从 token 中获取用户的 ID。
将 RSA 私钥存储到 Redis 中：首先，创建了一个 JedisUtil 对象用于操作 Redis。然后，构造了一个特定格式的 key，该 key 包含了用户的 ID 和一个前缀security:key。接着，将 RSA 私钥和一个过期时间一起存储到 Redis 中。这里使用了 Redis 的 ZSet 数据结构，因为 ZSet 可以为每个元素设置一个分数，这里用来表示过期时间。
返回 RSA 公钥：最后，返回了生成的 RSA 公钥。

在许多安全应用中，每个用户都需要一对独特的公钥和私钥。这是因为：

私钥是保密的，只有用户自己知道。如果其他人知道了用户的私钥，他们就可以冒充用户进行操作，这会导致安全问题。
公钥是公开的，任何人都可以获取。公钥用于加密信息，只有对应的私钥才能解密这些信息。这样，即使别人获取了加密后的信息，也无法解密，因为他们没有私钥。
如果所有用户都使用同一对公钥和私钥，那么一旦这对密钥被泄露，所有用户的信息都会被暴露。而如果每个用户都有自己的公钥和私钥，即使某个用户的密钥被泄露，也只会影响到该用户，不会影响到其他用户。

/**
 * 给前端发送 RSA 公钥
 */
@ApiInvoker(path = "/http-server/public-key")
@GetMapping("/http-server/public-key")
public String getRSASecretKey(HttpServletRequest request) {
	//获得秘钥
	RSAUtil.KeyPairInfo keyPair = RSAUtil.getKeyPair();
	
    //通过 token 得到 userId
	Cookie token = Stream.of(request.getCookies())
			.filter(cookie -> cookie.getName().equals(FilterConst.COOKIE_KEY))
			.findFirst()
			.orElse(null);

	if (ObjectUtils.isEmpty(token)) {
		throw new RuntimeException("token is empty");
	}
	String userId = String.valueOf(Objects.requireNonNull(JWTUtil.getClaimByToken(token.getValue(), FilterConst.TOKEN_SECRET)).get(FilterConst.TOKEN_USERID_KEY));
	if (StringUtils.isEmpty(userId)) {
		throw new RuntimeException("parse token failed");
	}

	//将 RSA 私钥放进 redis（ZSet） 中
	// 这里使用 ZSet 数据结构来记录后端为不同用户生成的 RSA私钥，因为不同用户创建私钥的时间不同导致过期时间不同，hash无法为内部元素设置过期时间
	JedisUtil jedis = new JedisUtil();
	
    //security:key:{userId}    rsa:key:{rsa-privateKey}     {rsa-expireTime}
	String securityKey = FilterConst.SECURITY_KEY_PREFIX + ":" + userId;
	String rsaPrivateKey = FilterConst.RSA_PRIVATE_KEY_PREFIX + ":" + keyPair.getPrivateKey();
	long rsaExpireTime = System.currentTimeMillis() + FilterConst.RSA_PRIVATE_KEY_EXPIRE_TIME;
	
    if (!jedis.addScoreSet(securityKey, rsaPrivateKey, rsaExpireTime)) {
		throw new RuntimeException("save rsa-private-key into redis failed");
	}

	log.info("save rsa-privateKey into redis success, key: {}, expire: {}", FilterConst.RSA_PRIVATE_KEY_PREFIX, FilterConst.RSA_PRIVATE_KEY_EXPIRE_TIME);
	jedis.setExpire(FilterConst.RSA_PRIVATE_KEY_PREFIX, FilterConst.RSA_PRIVATE_KEY_EXPIRE_TIME);
	
    log.info("create rsa-publicKey: {}, rsa-privateKey: {}", keyPair.getPublicKey(), keyPair.getPrivateKey());
	
    return keyPair.getPublicKey();
}

这里返回的就是 RSA 公钥

2.2、用公钥进行加密

这里主要功能是使用 RSA 公钥对一个对称密钥进行加密，String symmetricKey = "yu123456" 就是我们的公钥，用公钥加密技术来安全地传输对称密钥，然后使用对称密钥进行数据加密。

/**
 * 模拟前端对自己得到的 RSA 公钥进行加密
 */
@ApiInvoker(path = "/http-server/encrypt-symmetric-key")
@GetMapping("/http-server/encrypt-symmetric-key")
public String getEncryptSymmetricKey(HttpServletRequest request) throws Exception {
	String publicKeyPEM = request.getHeader("RSA-secret-key");
	String symmetricKey = "yu123456";
    
	byte[] decoded = Base64.getDecoder().decode(publicKeyPEM);
	KeyFactory keyFactory = KeyFactory.getInstance("RSA");
	X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decoded);
	PublicKey publicKey = keyFactory.generatePublic(keySpec);
    
	byte[] publicKeyBytes = publicKey.getEncoded();
	String publicKeyBase64 = Base64.getEncoder().encodeToString(publicKeyBytes);
    
	Cipher cipher = Cipher.getInstance("RSA");
	cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    
	return RSAUtil.encryptPublicKey(symmetricKey, publicKeyBase64);
}

将刚刚的 RSA 公钥放进请求头RSA-secret-key中，再发送请求，得到含有对称密钥的 RSA 公钥

2.3、对 url 进行加密

首先就是定义一个对称密钥，就是前面通过RSA加密传递的对称密钥
然后就是需要传递的信息
用需要传递的信息进行 AES 加密，得到一个数字签名
需要传递的信息加上数字签名，形成最终的 url 加密后信息

/**
 * 模拟前端对 url 进行加密测试
 */
@ApiInvoker(path = "/http-server/encrypt-url")
@GetMapping("/http-server/encrypt-url")
public String getEncryptURL(HttpServletRequest request) throws Exception {
	String symmetricPublicKey = "symmetric:key:yu123456";
	StringBuilder builder = new StringBuilder();
	String plainText = "userId=1";
	
    builder.append(plainText);
	builder.append("&signature=");
	builder.append(CryptoHelper.encryptParams(plainText, symmetricPublicKey));
	
    return CryptoHelper.encryptParams(builder.toString(), symmetricPublicKey);
}

2.4、url 动态加密请求实现

将上述加密后信息添加到请求路径中就变成

http://127.0.0.1:8888/http-server/v1/userId/encrypt/VWWXTp7npNdELumZ8Fm+V8O1U4NUakpu4zgom/9CcYZKsiW84TN4nQWTGMBngX1O

添加一些请求头

从请求头得到包含对称密钥的 RSA 秘钥，这个秘钥会和存在 Redis 中的私钥进行匹配，解密得到 AES 对称密钥

这里还会根据 Redis 中的私钥进行判断，看是否超过过期时间。

虽然使是用 set 存储，但在 Redis 中用 zset 存储的，所以得到的还是最新的私钥

解密完 RSA 秘钥得到 ASE 对称密钥后，会把这个秘钥存储到 Redis 中

然后就到了处理加密的 URL和验证 URL 的完整性部分了

首先还是会有白名单部分的

然后就根据 Cookie 中的 token 得到 userId，再通过 userId 得到刚刚存储到 Redis 中的 AES 密钥，通过 AES 密钥对加密 url 进行解密

更新前

解密后更新

当然也会通过数字签名验证信息是否有被修改

public static boolean verifySignature(MultiValueMap<String, String> queryParams, String signature, String symmetricKey) {
	StringBuilder builder = new StringBuilder();
	for (Map.Entry<String, List<String>> entry : queryParams.entrySet()) {
		if (!"signature".equals(entry.getKey())) {
			builder.append(entry.getKey()).append("=").append(String.join(",", entry.getValue())).append("&");
		}
	}
	builder.setLength(builder.length() - 1);
	String computedSignature = encryptParams(builder.toString(), symmetricKey).replace("+", " ");
	return computedSignature.equals(signature);
}

最终得到原始路径