婚纱手机网站,怎样推广品牌,学习网页制作学什么,网站开发环境实验报告文章目录 对称加密非对称加密什么是数字签名HTTPS与CA⭐Gateway网关的过滤器链如何对自己的路径传输设定一个数字签名#xff1f;前端获取RSA公钥发送加密后对称密钥后端接收当前会话对称密钥并保存前端发送AES加密请求验证请求 如何实现URL的动态加密#xff1f; 再网络传递… 文章目录 对称加密非对称加密什么是数字签名HTTPS与CA⭐Gateway网关的过滤器链如何对自己的路径传输设定一个数字签名前端获取RSA公钥发送加密后对称密钥后端接收当前会话对称密钥并保存前端发送AES加密请求验证请求 如何实现URL的动态加密 再网络传递数据的时候为了防止数据被篡改我们会选择对数据进行加密数据加密分为对称加密和非对称加密。其中RSA和AESTLS等加密算法是比较常用的。 对称加密
对称加密是指加密和解密使用相同的密钥的加密方法。其基本流程包括以下步骤
密钥生成 双方协商生成一个共享密钥或由一方生成密钥并安全地传输给另一方。
加密 使用共享密钥对原始数据进行加密得到加密后的数据。
传输 将加密后的数据传输给另一方。
解密 接收方使用相同的共享密钥对加密数据进行解密得到原始数据。
非对称加密
非对称加密是指加密和解密使用不同的密钥的加密方法通常称为公钥和私钥。其基本流程包括以下步骤
密钥对生成 生成一对密钥一个是公钥另一个是私钥。公钥可以公开而私钥需要保密。
公钥分发 将公钥发送给需要加密数据的一方。
加密 使用公钥对原始数据进行加密得到加密后的数据。
传输 将加密后的数据传输给另一方。
解密 接收方使用私钥对加密数据进行解密得到原始数据。
结合使用
在实际应用中对称加密和非对称加密通常会结合使用以达到安全和效率的平衡。例如
使用非对称加密交换对称密钥。使用对称密钥进行数据加密和解密。
什么是数字签名
再上面我们了解了RSA对称加密那么当我们进行数据交换的时候如下
假设有AB两个人假设前面他们已经交换完毕了公钥。
那么此时当A使用B的公钥加密原始数据然后发送数据给B的时候它可以再数据的后面再携带上一个原始数据hash计算之后得到的hash值然后用自己的私钥进行加密。
A将数据发送到B之后由于数据使用的是B的公钥加密B可以用私钥解密之后得到A发送消息的原本内容然后B可以使用A的公钥对额外的数字签名进行校验因为它假设这个数据是A发送的那么用A的公钥就应该可以解密成功所以如果数据解密成功之后与A发送的原始消息经过一样的Hash运算之后相等那么说明没有被篡改而如果不一致那么就说明被篡改了。因为第三方是不知道A的私钥信息的所以他是用自己的私钥去加密得到的hash会与A进行hash之后的值不同从而判断数据被篡改了。
HTTPS与CA
https其实不是一个单独的协议而是数据传输的时候使用TLS/SSL进行了加密而已。而TLS就是一个非常典型的非对称加密其兼顾了AES和RSA的安全性和速度。
上面我们已经聊完了一个加密数据的交换过程那么如果有些人就是伪造了一些域名让你去访问怎么办呢
HTTPS (HTTP Secure) 是一个安全的 HTTP 通道它通过 SSL/TLS 协议来保证数据的安全传输。在 HTTPS 请求的过程中证书颁发机构 (CA, Certificate Authority) 扮演了重要的角色。以下是 CA 在保证 HTTPS 请求过程中数据安全交换的方式
证书颁发: CA 为服务器颁发一个数字证书。这个证书包含了服务器的公钥和一些识别服务器身份的信息。数字证书是由 CA 签名的以验证证书的真实性和完整性。
建立安全连接: 当客户端第一次连接到服务器时服务器会发送其数字证书给客户端。客户端会验证数字证书的合法性比如检查证书是否由一个受信任的 CA 签名检查证书是否在有效期内等。一旦证书验证通过客户端就能确认它是与正确的服务器进行通信而不是被中间人攻击。
密钥交换: 客户端和服务器会使用 SSL/TLS 协议中的密钥交换机制来协商一个会话密钥通常是一个对称密钥。一种常见的方法是客户端生成一个随机的对称密钥然后用服务器的公钥加密它再发送给服务器。服务器用自己的私钥解密得到对称密钥。
数据加密和传输: 一旦会话密钥被协商好客户端和服务器就会用这个密钥来加密和解密传输的数据。这样即使数据在传输过程中被截获攻击者也无法解读数据的内容因为他们没有会话密钥。
完整性校验: SSL/TLS 协议还提供了数据完整性校验。它会为传输的数据生成一个 MAC (Message Authentication Code)以确保数据在传输过程中没有被篡改。 其实前面的第一和第二随机数都是正常传输预主密钥的得到就是使用RSA了此时只有客户端和服务端知道预主密钥之后对第一和第二随机数使用预主密钥的加密就可以得到会话密钥此时加密交互完成。
并且会话密钥只应用在当前会话每个会话都会新生成一个所以安全性大大增加。
只有前面的得到预主密钥的过程用RSA其他地方都是AES因为非对称实在太慢了。
⭐Gateway网关的过滤器链
我们知道我们可以再Gateway网关中自定义过滤器并且实现Ordered接口来对过滤器的执行顺序进行排序。如下图我实现了三个自定义的全局过滤器。 并且当你实现全局过滤器接口的时候你必须实现如下方法
public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain)
其中exchange参数非常重要他就是你的请求以及对你请求的响应。而chain就是上面的过滤器链条。 而我们的过滤器链的作用其实就是对request和response这两个重要的类进行操作。
比如我可以使用exchange.mutate方法来对request和response进行修改。
exchange exchange.mutate().request(build - {try {build.uri(new URI(http://localhost:8080/v1/product?productId1)).build();} catch (URISyntaxException e) {throw new RuntimeException(e);}}
).build();如下是我修改request之前的请求体内容。 如下就是我修改URI之后的request请求体的内容。 在这里我们把这个reqeust给他修改有着重大意义这意味着只要对加密后的数据进行解密后去修改这个request中的内容我们就能再一次成功的将我们的请求路由到我们指定的路径。 而之后我们最终路由到的请求路径位置保存在了DefaultServerWebExchange的attributes中。 最后只要进入到ForwardRoutingFilter 在这里请求完成了最终的处理然后进行转发发送到对应的处理类去处理。
这时候我们看提供远程服务调用的类的调用栈即可。 如何对自己的路径传输设定一个数字签名
上面我们已经聊到了先使用RSA的方式传递对称密钥然后之后的请求使用AES来进行加密解密。这样子既保证了安全性也保证了请求的速度。
我就按照上面的说法简单的实现了一个数字签名大概方式如下
公钥获取
客户端首先通过一个特定的接口从服务器获取RSA公钥。对称密钥加密
客户端生成一个随机的对称密钥然后使用服务器的RSA公钥对这个对称密钥进行加密。发送加密的对称密钥
客户端将加密后的对称密钥发送到服务器。对称密钥解密
服务器使用自己的RSA私钥解密客户端发送的加密对称密钥从而得到原始的对称密钥。加密通信
从现在开始客户端和服务器都会使用这个对称密钥来加密和解密他们之间的通信。这包括URL的动态加密、请求和响应的加密解密以及数字签名的验证等。数字签名
为了确保数据的完整性和非否认性客户端和/或服务器可以使用对称密钥来生成和验证数字签名。
这样双方都可以确信接收到的数据没有被篡改并且确实来自预期的发送方。 URL动态加密
使用对称密钥对URL进行动态加密以保护URL中的敏感信息并防止未经授权的访问。
这个流程确保了客户端和服务器之间的通信安全防止数据被截获或篡改同时也提供了一个有效的机制来验证通信双方的身份。具体流程如下
我们首先需要做的第一步是提供一个接口让前端客户端去访问
并且获得到我们的公开的RSA公钥
然后前端拿到这个RSA公钥之后加密自己的对称密钥
然后再一次发送一个请求
这个请求携带的是通过RSA公钥加密过后的对称密钥
然后服务端收到这个对称密钥之后
通过RSA私钥解密可以得到原本的前端发送的对称密钥。
此时之后的URL动态加密所需要使用到的密钥
以及之后请求的数字签名的加密
都使用AES的方式
并且使用这个解密后的对称密钥进行加密解密前端获取RSA公钥
我们首先在gateway网关提供一个接口用于提供给前端获取RSA公钥
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;import javax.annotation.PostConstruct;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;/*** author: 张锦标* date: 2023/10/2 15:13* SecurityConfig的作用是返回公钥*/
Configuration
public class SecurityConfig {private KeyPair keyPair;PostConstructpublic void init() {// Generate RSA key pairKeyPairGenerator keyGen;try {keyGen KeyPairGenerator.getInstance(RSA);keyGen.initialize(2048);keyPair keyGen.genKeyPair();} catch (NoSuchAlgorithmException e) {throw new RuntimeException(Failed to generate RSA key pair, e);}}/*** 提供给前端获取RSA公钥* return*/Beanpublic RouterFunctionServerResponse publicKeyEndpoint() {return RouterFunctions.route().GET(/public-key, req - {String publicKey Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());return ServerResponse.ok().bodyValue(publicKey);}).build();}public KeyPair getKeyPair() {return keyPair;}}发送加密后对称密钥
前端使用得到的公钥对自己的对称密钥进行加密代码如下
package blossom.star.project.product;import org.junit.jupiter.api.Test;import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;//SpringBootTest
class RSA {Testvoid contextLoads() {}public static void main(String[] args) throws Exception {//TODO 2这里得到的是获取rsa的公钥之后对对称密钥进行加密之后就是使用这个对称密钥进行//数据的加解密// Replace with your RSA public keyString publicKeyPEM MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvXBSqSyOPb01/uOnhnFN8Hvaz1IQbXnxFzGp9rWBxRAI2p6o67Elr1SW68JnXx4swq7z0UYZSuszsoqwIrn8XF75bpJNKLkH7Bpe5AIf78zTihsCoPsx74FIaJTSiVCzWP9mCaDSVO2bPTwOvqMwQ7xlmTmN9QShCIJ6uBXaggB5aWdpkh/IsIsZXIlzFB5HxA8AYj3u0AyWZOpNS1fwq2Q7GPwWG7Zl7bCrUjIbG40k/Ef1BjdJBhQakMUq3ZqxLJP37Tk4FzW47bwD9AiSL4DAXTscHw1fNspd2qFZBN94h5Pxkxoc9ZBMWB2bFBdRb6zkEg0/2OwwIDAQAB ;// Replace with your symmetric keyString symmetricKey zhangjinbiao6666;// Converting PEM to PublicKeybyte[] decoded Base64.getDecoder().decode(publicKeyPEM);KeyFactory keyFactory KeyFactory.getInstance(RSA);X509EncodedKeySpec keySpec new X509EncodedKeySpec(decoded);PublicKey publicKey keyFactory.generatePublic(keySpec);// Encrypting symmetric keyCipher cipher Cipher.getInstance(RSA);cipher.init(Cipher.ENCRYPT_MODE, publicKey);byte[] encryptedSymmetricKey cipher.doFinal(symmetricKey.getBytes());String encryptedSymmetricKeyBase64 Base64.getEncoder().encodeToString(encryptedSymmetricKey);// Printing encrypted symmetric keySystem.out.println(encryptedSymmetricKeyBase64);}}后端接收当前会话对称密钥并保存
这里由于我没有前端不好操作我就直接暂时写死了但是具体的实现逻辑就是与前端制定一个唯一的会话id然后之后只要是同一个会话就可以使用同一个对称密钥这样子才能进一步保证安全而不是一直使用同一个对称密钥。
package blossom.star.project.gateway.filter;import blossom.star.framework.common.constant.HttpStatus;
import blossom.star.project.gateway.config.SecurityConfig;
import blossom.star.project.gateway.util.GatewayUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.MediaType;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;import javax.crypto.Cipher;
import java.nio.charset.StandardCharsets;
import java.util.Base64;/*** author 张锦标* 对称密钥保存过滤器* 当前过滤器首先会先获取请求头中的对称密钥* 如果有那么获取对称密钥并且保存到Redis中*/
//Component
public class SymmetricKeyFilter implements GlobalFilter, Ordered {Autowiredprivate SecurityConfig securityConfig;Autowiredprivate StringRedisTemplate stringRedisTemplate;//TODO 3这里会把加密好的对称密钥 解密 然后放入到redis中Overridepublic MonoVoid filter(ServerWebExchange exchange, GatewayFilterChain chain) {String encryptedSymmetricKey exchange.getRequest().getHeaders().getFirst(X-Encrypted-Symmetric-Key);if (encryptedSymmetricKey ! null) {try {Cipher cipher Cipher.getInstance(RSA);cipher.init(Cipher.DECRYPT_MODE, securityConfig.getKeyPair().getPrivate());byte[] decryptedKeyBytes cipher.doFinal(Base64.getDecoder().decode(encryptedSymmetricKey));//得到对称密钥String symmetricKey new String(decryptedKeyBytes, StandardCharsets.UTF_8);在非阻塞上下文中阻塞调用可能会导致线程饥饿TODO 需要优化一下这里 来确保每个请求可以唯一对应一个加密密钥//String sessionId exchange.getSession().block().getId();//stringRedisTemplate.opsForValue().set(sessionId, symmetricKey);String redisSymmetricKey symmetric:key:1;stringRedisTemplate.opsForValue().set(redisSymmetricKey, symmetricKey);} catch (Exception e) {e.printStackTrace();String responseBody there are something wrong occurs when decrypt your key!!!;GatewayUtil.responseMessage(exchange,responseBody);// 获取响应对象//ServerHttpResponse response exchange.getResponse();处理对称密钥出现了问题//response.setRawStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);//response.getHeaders().setContentType(MediaType.TEXT_PLAIN);//返回你想要的字符串//return response.writeWith(// Mono.just(response.bufferFactory().wrap(responseBody.getBytes())));}}return chain.filter(exchange);}Overridepublic int getOrder() {return -300;}}前端发送AES加密请求
比如这里的请求参数为productId1然后我们额外发送一个signaturewHYOLLkTn00DVrcmuCFzFQ
signature的值就是对这个参数productId1进行AES加密之后得到的数据。
然后我们再一次对String plaintext “productId1signaturewHYOLLkTn00DVrcmuCFzFQ”;来进行加密然后发送的请求以这个为参数。
也就是发送http://localhost:8080/v1/product/encrypt/8lPoJ5k/aHpfgKlxB5A9eUXqZ4MvgpFqN/SwDBVwDbERjBkQw62kfAmfsDW2Bngm
只要后端检测到这个路径有任何一点不对劲就会直接报错返回。
package blossom.star.project.product;import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;/*** author: 张锦标* date: 2023/10/2 17:32* AES类*/
public class AES {//1:首先让前端对请求路径传输进行AES的加密 密钥已经传递//比如productId1 ---》wHYOLLkTn00DVrcmuCFzFQ//如果有多个 就直接 的方式进行拼接然后AES加密即可//2signaturewHYOLLkTn00DVrcmuCFzFQ//3然后在对整个URL进行加密传输传输方式为 /encrypt // /5s7/98nWOXAJKujQ7nj66ZhohFdur/pPBzd3Y9kZqeIrZmPvTegG8// OYwY6IMr9dXtK9vmZvJoEEsWZTLLBCQ//其中 后面的就是我们aes加密后的url /encrypt用于表示进行前端的路由public static void main(String[] args) throws Exception {//TODO 1首先设定一下加密的内容 这里直接用java代码加密String plaintext productId1;//String plaintext productId1signaturewHYOLLkTn00DVrcmuCFzFQ;String symmetricKey zhangjinbiao6666; // Ensure this key has 16 bytesString encryptedText encryptUrl(plaintext, symmetricKey);System.out.println(encryptedText);}public static String encryptUrl(String url, String symmetricKey) throws Exception {SecretKeySpec keySpec new SecretKeySpec(symmetricKey.getBytes(StandardCharsets.UTF_8), AES);Cipher cipher Cipher.getInstance(AES);cipher.init(Cipher.ENCRYPT_MODE, keySpec);byte[] encryptedBytes cipher.doFinal(url.getBytes(StandardCharsets.UTF_8));return Base64.getEncoder().encodeToString(encryptedBytes);}}验证请求
而如果请求的参数被篡改了比如上面的productId2那么有如下图情况
此时验证请求是否被修改的方法就会报错 下面再验证请求是否被篡改的过程中代码写的可能有一点丑陋。
package blossom.star.project.gateway.filter;import blossom.star.framework.common.constant.HttpStatus;
import blossom.star.project.gateway.util.CryptoHelper;
import blossom.star.project.gateway.util.GatewayUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.core.Ordered;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;import java.net.URI;
import java.net.URISyntaxException;/*** author 张锦标* 当前类首先会解析加密后的URL* 当前类用于解析参数 如果参数解密后和signature不一样则返回* 并且会重新设定路由路径*/
Component
public class CryptoFilter implements GlobalFilter, Ordered {Autowiredprivate StringRedisTemplate stringRedisTemplate;Autowiredprivate CryptoHelper cryptoHelper;//TODO 4在这里对加密的URL进行解密//并且会得到路径的参数//然后对参数进行加密之后和signature比较判断是否被修改Overridepublic MonoVoid filter(ServerWebExchange exchange, GatewayFilterChain chain) {//String sessionId exchange.getSession().block().getId();String redisSymmetricKey symmetric:key: 1;//String symmetricKey stringRedisTemplate.opsForValue().get(sessionId);String symmetricKey stringRedisTemplate.opsForValue().get(redisSymmetricKey);if (symmetricKey null) {return GatewayUtil.responseMessage(exchange, this session has not symmetricKey!!!);}try {//URL动态加密 数字签名 signature//如果URL已加密则解密该URL//path:/v1/product/encrypt/WyYSV30Cor8QX/eWGsQ7yPD3EvNRRS0HF845UObKAdwHPKZByMa3250J/z2S4at//uri:http://localhost:8080/v1/product/encrypt/WyYSV30Cor8QX/eWGsQ7yPD3EvNRRS0HF845UObKAdwHPKZByMa3250J/z2S4atString encryptedUrl exchange.getRequest().getURI().toString();String path exchange.getRequest().getURI().getPath();String encryptPathParam path.substring(path.indexOf(/encrypt/) 9);String decryptedPathParam cryptoHelper.decryptUrl(encryptPathParam, symmetricKey);String decryptedUri encryptedUrl.substring(0, encryptedUrl.indexOf(/encrypt/)).concat(?).concat(decryptedPathParam);//这个方法直接修改的是exchange里面的requestexchange exchange.mutate().request(build - {try {build.uri(new URI(decryptedUri));} catch (URISyntaxException e) {throw new RuntimeException(e);}}).build();//TODO 需要前端这里首先按照前后端约定的加密方式进行一次加密//然后得到一个signature放在请求的末尾//然后对整个URL进行加密请求// 解析解密后的URL以获取解密的查询参数UriComponents uriComponents UriComponentsBuilder.fromUriString(decryptedUri).build();MultiValueMapString, String decryptedQueryParams uriComponents.getQueryParams();// 验证请求参数的签名String signature decryptedQueryParams.getFirst(signature);if (!cryptoHelper.verifySignature(decryptedQueryParams, signature, symmetricKey)) {return GatewayUtil.responseMessage(exchange,the param has something wrong!!!);}} catch (Exception e) {return GatewayUtil.responseMessage(exchange,the internal server occurs an error!!!);}return chain.filter(exchange);}Overridepublic int getOrder() {return -200;}
}package blossom.star.project.gateway.util;import org.springframework.context.annotation.Configuration;
import org.springframework.util.MultiValueMap;import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.List;
import java.util.Map;/*** author 张锦标* 密码学工具包*/
Configuration
public class CryptoHelper {public String decryptUrl(String encryptedUrl, String symmetricKey) throws Exception {SecretKeySpec keySpec new SecretKeySpec(symmetricKey.getBytes(StandardCharsets.UTF_8), AES);Cipher cipher Cipher.getInstance(AES);cipher.init(Cipher.DECRYPT_MODE, keySpec);byte[] decryptedBytes cipher.doFinal(Base64.getDecoder().decode(encryptedUrl));return new String(decryptedBytes, StandardCharsets.UTF_8);}//解析路径参数并且加密后判断是否和signature一样public boolean verifySignature(MultiValueMapString, String queryParams, String signature, String symmetricKey) throws Exception {StringBuilder sb new StringBuilder();for (Map.EntryString, ListString entry : queryParams.entrySet()) {//将签名本身从要验证的数据中排除if (!signature.equals(entry.getKey())) {sb.append(entry.getKey()).append().append(String.join(,, entry.getValue())).append();}}sb.setLength(sb.length()-1);String computedSignature encryptRequestParam(sb.toString(), symmetricKey);return computedSignature.equals(signature);}public static String encryptRequestParam(String requestParam, String symmetricKey) throws Exception {SecretKeySpec keySpec new SecretKeySpec(symmetricKey.getBytes(StandardCharsets.UTF_8), AES);Cipher cipher Cipher.getInstance(AES);cipher.init(Cipher.ENCRYPT_MODE, keySpec);byte[] encryptedBytes cipher.doFinal(requestParam.getBytes(StandardCharsets.UTF_8));return Base64.getEncoder().encodeToString(encryptedBytes);}
}如果请求的过程中请求的数据并没有被修改那么可以正确解析如下 如何实现URL的动态加密
动态加密其实在上面就已经说了。
可以发现我们发送的实际请求是下面这个/encrypt/后面的就是我们约定好的加密参数。
http://localhost:8080/v1/product/encrypt/WLB8EDs2LNTsUJpS/aANt0XqZ4MvgpFqN/SwDBVwDbERjBkQw62kfAmfsDW2Bngm
实际再处理过程中会去掉/encrypt他只是用于标识具体的加密参数位置而已。
