上司はインターフェースの暗号化と復号化の一時的なタスクを失いましたが、私は3日間働き、ステーションをクリーンアップできると感じています

この日、私は2つか2つのコードを終えたばかりで、携帯電話を取り出して釣りをし、リラックスしようとしていました。上司が私に向かって歩いて「優しい」笑顔を見せているのが見えました。インターフェースは全体として暗号化されています。あなたはこの分野でより多くの経験を持っているので、私はあなたのためにそれを手配します。テストが今週中に機能するかどうか見てみましょう...ええと、私は私の頭の揺れるまばらな長い髪に触れました、私はそれを愛しているように感じます。

製品とフロントエンドの学生の外部ニーズを満たした後、関連する技術ソリューションを整理しました。主な要件は次のとおりです。

以前のビジネスロジックに影響を与えることなく、変更をできるだけ少なくします。
時間の緊急性を考慮して、対称暗号化方式を採用することができます。サービスは、Android、IOS、H5の3つの端末に接続する必要があります。また、H5端末のストレージキーのセキュリティが比較的低いことを考慮すると、H5、Android、IOSに分かれています。2セットのキー。
下位バージョンのインターフェースと互換性を持たせるために、新しく開発されたインターフェースは互換性である必要はありません。
このインターフェースには、GETとPOSTの2つのインターフェースがあり、暗号化と復号化が必要です。

要件分析：

サーバー、クライアント、およびH5の統合された傍受の暗号化と復号化。インターネット上には成熟したソリューションがあり、他のサービスで実装されている暗号化と復号化のプロセスに従って実装することもできます。
H5側のストレージキーのセキュリティが比較的低くなることを考慮して、AESを使用して暗号化を緩和すると、H5、Android、およびIOSに2セットのキーが割り当てられます。
今回は、クライアントとサーバーの全体的な変換が含まれます。話し合いの後、新しいインターフェイスには、区別するために/securityApi/というプレフィックスが一律に付けられます。

この要件に従って問題を単純に復元するには、後で使用する2つのオブジェクトを定義します。

ユーザークラス：

@Data
public class User {
    private Integer id;
    private String name;
    private UserType userType = UserType.COMMON;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime registerTime;
}
复制代码

ユーザータイプ列挙クラス：

@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum UserType {
    VIP("VIP用户"),
    COMMON("普通用户");
    private String code;
    private String type;

    UserType(String type) {
        this.code = name();
        this.type = type;
    }
}
复制代码

簡単なユーザーリストクエリの例を作成します。

@RestController
@RequestMapping(value = {"/user", "/securityApi/user"})
public class UserController {
    @RequestMapping("/list")
    ResponseEntity<List<User>> listUser() {
        List<User> users = new ArrayList<>();
        User u = new User();
        u.setId(1);
        u.setName("boyka");
        u.setRegisterTime(LocalDateTime.now());
        u.setUserType(UserType.COMMON);
        users.add(u);
        ResponseEntity<List<User>> response = new ResponseEntity<>();
        response.setCode(200);
        response.setData(users);
        response.setMsg("用户列表查询成功");
        return response;
    }
}
复制代码

電話：localhost：8080 / user / list

クエリ結果は次のとおりですが、問題ありません。

{
	"code": 200,
	"data": [{
		"id": 1,
		"name": "boyka",
		"userType": {
			"code": "COMMON",
			"type": "普通用户"
		},
		"registerTime": "2022-03-24 23:58:39"
	}],
	"msg": "用户列表查询成功"
}
复制代码

現在、ControllerAdviceは主にリクエストとレスポンスの本文をインターセプトするために使用され、主にリクエストを暗号化するためのSecretRequestAdviceとレスポンスを暗号化するためのSecretResponseAdviceを定義します（実際の状況はもう少し複雑になり、プロジェクトにはGETタイプのリクエストがあります、およびカスタムフィルタは、さまざまな要求復号化処理に使用されます）。

さて、インターネット上でControllerAdviceを使用した例はたくさんありますが、2つのコアメソッドを紹介します。大物は一目でそれを知っていると思います。多くのことを言う必要はありません。上記のコード：

SecretRequestAdviceリクエストの復号化：

/**
 * @description:
 * @author: boykaff
 * @date: 2022-03-25-0025
 */
@ControllerAdvice
@Order(Ordered.HIGHEST_PRECEDENCE)
@Slf4j
public class SecretRequestAdvice extends RequestBodyAdviceAdapter {
    @Override
    public boolean supports(MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        //如果支持加密消息，进行消息解密。
        String httpBody;
        if (Boolean.TRUE.equals(SecretFilter.secretThreadLocal.get())) {
            httpBody = decryptBody(inputMessage);
        } else {
            httpBody = StreamUtils.copyToString(inputMessage.getBody(), Charset.defaultCharset());
        }
        //返回处理后的消息体给messageConvert
        return new SecretHttpMessage(new ByteArrayInputStream(httpBody.getBytes()), inputMessage.getHeaders());
    }

    /**
     * 解密消息体
     *
     * @param inputMessage 消息体
     * @return 明文
     */
    private String decryptBody(HttpInputMessage inputMessage) throws IOException {
        InputStream encryptStream = inputMessage.getBody();
        String requestBody = StreamUtils.copyToString(encryptStream, Charset.defaultCharset());
        // 验签过程
        HttpHeaders headers = inputMessage.getHeaders();
        if (CollectionUtils.isEmpty(headers.get("clientType"))
                || CollectionUtils.isEmpty(headers.get("timestamp"))
                || CollectionUtils.isEmpty(headers.get("salt"))
                || CollectionUtils.isEmpty(headers.get("signature"))) {
            throw new ResultException(SECRET_API_ERROR, "请求解密参数错误，clientType、timestamp、salt、signature等参数传递是否正确传递");
        }

        String timestamp = String.valueOf(Objects.requireNonNull(headers.get("timestamp")).get(0));
        String salt = String.valueOf(Objects.requireNonNull(headers.get("salt")).get(0));
        String signature = String.valueOf(Objects.requireNonNull(headers.get("signature")).get(0));
        String privateKey = SecretFilter.clientPrivateKeyThreadLocal.get();
        ReqSecret reqSecret = JSON.parseObject(requestBody, ReqSecret.class);
        String data = reqSecret.getData();
        String newSignature = "";
        if (!StringUtils.isEmpty(privateKey)) {
            newSignature = Md5Utils.genSignature(timestamp + salt + data + privateKey);
        }
        if (!newSignature.equals(signature)) {
            // 验签失败
            throw new ResultException(SECRET_API_ERROR, "验签失败，请确认加密方式是否正确");
        }

        try {
            String decrypt = EncryptUtils.aesDecrypt(data, privateKey);
            if (StringUtils.isEmpty(decrypt)) {
                decrypt = "{}";
            }
            return decrypt;
        } catch (Exception e) {
            log.error("error: ", e);
        }
        throw new ResultException(SECRET_API_ERROR, "解密失败");
    }
}
复制代码

暗号化されたSecretResponseAdvice応答：

@ControllerAdvice
public class SecretResponseAdvice implements ResponseBodyAdvice {
    private Logger logger = LoggerFactory.getLogger(SecretResponseAdvice.class);

    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        // 判断是否需要加密
        Boolean respSecret = SecretFilter.secretThreadLocal.get();
        String secretKey = SecretFilter.clientPrivateKeyThreadLocal.get();
        // 清理本地缓存
        SecretFilter.secretThreadLocal.remove();
        SecretFilter.clientPrivateKeyThreadLocal.remove();
        if (null != respSecret && respSecret) {
            if (o instanceof ResponseBasic) {
                // 外层加密级异常
                if (SECRET_API_ERROR == ((ResponseBasic) o).getCode()) {
                    return SecretResponseBasic.fail(((ResponseBasic) o).getCode(), ((ResponseBasic) o).getData(), ((ResponseBasic) o).getMsg());
                }
                // 业务逻辑
                try {
                    String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o), secretKey);
                    // 增加签名
                    long timestamp = System.currentTimeMillis() / 1000;
                    int salt = EncryptUtils.genSalt();
                    String dataNew = timestamp + "" + salt + "" + data + secretKey;
                    String newSignature = Md5Utils.genSignature(dataNew);
                    return SecretResponseBasic.success(data, timestamp, salt, newSignature);
                } catch (Exception e) {
                    logger.error("beforeBodyWrite error:", e);
                    return SecretResponseBasic.fail(SECRET_API_ERROR, "", "服务端处理结果数据异常");
                }
            }
        }
        return o;
    }
}
复制代码

OK，代码Demo撸好了，试运行一波：

请求方法：
localhost:8080/secret/user/list

header:
Content-Type:application/json
signature:55efb04a83ca083dd1e6003cde127c45
timestamp:1648308048
salt:123456
clientType:ANDORID

body体:
// 原始请求体
{
	"page": 1,
	"size": 10
}
// 加密后的请求体
{
	"data": "1ZBecdnDuMocxAiW9UtBrJzlvVbueP9K0MsIxQccmU3OPG92oRinVm0GxBwdlXXJ"
}

// 加密响应体：
{
    "data": "fxHYvnIE54eAXDbErdrDryEsIYNvsOOkyEKYB1iBcre/QU1wMowHE2BNX/je6OP3NlsCtAeDqcp7J1N332el8q2FokixLvdxAPyW5Un9JiT0LQ3MB8p+nN23pTSIvh9VS92lCA8KULWg2nViSFL5X1VwKrF0K/dcVVZnpw5h227UywP6ezSHjHdA+Q0eKZFGTEv3IzNXWqq/otx5fl1gKQ==",
    "code": 200,
    "signature": "aa61f19da0eb5d99f13c145a40a7746b",
    "msg": "",
    "timestamp": 1648480034,
    "salt": 632648
}

// 解密后的响应体：
{
	"code": 200,
	"data": [{
		"id": 1,
		"name": "boyka",
		"registerTime": "2022-03-27T00:19:43.699",
		"userType": "COMMON"
	}],
	"msg": "用户列表查询成功",
	"salt": 0
}
复制代码

OK，客户端请求加密-》发起请求-》服务端解密-》业务处理-》服务端响应加密-》客户端解密展示，看起来没啥问题，实际是头天下午花了2小时碰需求，差不多花1小时写好demo测试，然后对所有接口统一进行了处理，整体一下午赶脚应该行了吧，告诉H5和安卓端同学明儿上午联调（不小的大家到这个时候发现猫腻没有，当时确实疏忽了，翻了大车......）

次日，安卓端反馈，你这个加解密有问题，解密后的数据格式和之前不一样，仔细一看，擦，这个userType和registerTime是不对劲，开始思考：这个能是哪儿的问题呢？1s之后，初步定位，应该是响应体的JSON.toJSONString的问题：

String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o)),
复制代码

Debug断点调试，果然，是JSON.toJSONString(o)这一步骤转换出了问题，那JSON转换时是不是有高级属性可以配置生成想要的序列化格式呢？FastJson在序列化时提供重载方法，找到其中一个"SerializerFeature"参数可以琢磨一下，这个参数是可以对序列化进行配置的，它提供了很多配置类型，其中感觉这几个比较沾边：

WriteEnumUsingToString,
WriteEnumUsingName,
UseISO8601DateFormat
复制代码

对枚举类型来说，默认是使用的WriteEnumUsingName(枚举的Name)，另一种WriteEnumUsingToString是重新toString方法，理论上可以转换成想要的样子，即这个样子：

@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum UserType {
    VIP("VIP用户"),
    COMMON("普通用户");
    private String code;
    private String type;

    UserType(String type) {
        this.code = name();
        this.type = type;
    }

    @Override
    public String toString() {
        return "{" +
                "\"code\":\"" + name() + '\"' +
                ", \"type\":\"" + type + '\"' +
                '}';
    }
}
复制代码

结果转换出来的数据是字符串类型"{"code":"COMMON", "type":"普通用户"}"，这个方法好像行不通，还有什么好办法呢？思前想后，看文章开始定义的User和UserType类，标记数据序列化格式@JsonFormat，再突然想起之前看到过的一些文章，SpringMVC底层默认是使用Jackson进行序列化的，那好了，就用Jacksong实施呗，将SecretResponseAdvice中的序列化方法替换一下：

 String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o), secretKey);
 换为：
 String data =EncryptUtils.aesEncrypt(new ObjectMapper().writeValueAsString(o), secretKey);

复制代码

重新运行一波，走起：

{
	"code": 200,
	"data": [{
		"id": 1,
		"name": "boyka",
		"userType": {
			"code": "COMMON",
			"type": "普通用户"
		},
		"registerTime": {
			"month": "MARCH",
			"year": 2022,
			"dayOfMonth": 29,
			"dayOfWeek": "TUESDAY",
			"dayOfYear": 88,
			"monthValue": 3,
			"hour": 22,
			"minute": 30,
			"nano": 453000000,
			"second": 36,
			"chronology": {
				"id": "ISO",
				"calendarType": "iso8601"
			}
		}
	}],
	"msg": "用户列表查询成功"
}
复制代码

解密后的userType枚举类型和非加密版本一样了，舒服了，== 好像还不对，registerTime怎么变成这个样子了？原本是"2022-03-24 23:58:39"这种格式的，Jackson之LocalDateTime转换，无需改实体类这篇文章讲到了这个问题，并提出了一种解决方案，不过用在我们目前这个需求里面，就是有损改装了啊，不太可取，遂去Jackson官网上查找一下相关文档，当然Jackson也提供了ObjectMapper的序列化配置，重新再初始化配置ObjectMpper对象：

String DATE_TIME_FORMATTER = "yyyy-MM-dd HH:mm:ss";
ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder()
                            .findModulesViaServiceLoader(true)
                            .serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(
                                    DateTimeFormatter.ofPattern(DATE_TIME_FORMATTER)))
                            .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(
                                    DateTimeFormatter.ofPattern(DATE_TIME_FORMATTER)))
                            .build();
复制代码

转换结果：

{
	"code": 200,
	"data": [{
		"id": 1,
		"name": "boyka",
		"userType": {
			"code": "COMMON",
			"type": "普通用户"
		},
		"registerTime": "2022-03-29 22:57:33"
	}],
	"msg": "用户列表查询成功"
}
复制代码

OK，和非加密版的终于一致了，完了吗？感觉还是可能存在些什么问题，首先业务代码的时间序列化需求不一样，有"yyyy-MM-dd hh:mm:ss"的，也有"yyyy-MM-dd"的，还可能其他配置思考不到位的，导致和之前非加密版返回数据不一致的问题，到时候联调测出来了也麻烦，有没有一劳永逸的办法呢？同事一句话点亮我，看一下spring框架自身是怎么序列化的，照着配置应该就行嘛，好像有点道理，不从0开始分析源码了，敢兴趣的朋友可以看看这篇文章源码分析Spring MVC源码(三) ----- @RequestBody和@ResponseBody原理解析，感觉写可以。

跟着执行链路，找到具体的响应序列化，重点就是RequestResponseBodyMethodProcessor，

protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
        // 获取响应的拦截器链并执行beforeBodyWrite方法，也就是执行了我们自定义的SecretResponseAdvice中的beforeBodyWrite啦
		body = this.getAdvice().beforeBodyWrite(body, returnType, selectedMediaType, converter.getClass(), inputMessage, outputMessage);
		if (body != null) {
		    // 执行响应体序列化工作
			if (genericConverter != null) {
				genericConverter.write(body, (Type)targetType, selectedMediaType, outputMessage);
			} else {
				converter.write(body, selectedMediaType, outputMessage);
			}
    }
复制代码

进而通过实例化的AbstractJackson2HttpMessageConverter对象找到执行序列化的核心方法

-> AbstractGenericHttpMessageConverter:
	
	public final void write(T t, @Nullable Type type, @Nullable MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        ...
		this.writeInternal(t, type, outputMessage);
		outputMessage.getBody().flush();
     
    }
	-> 找到Jackson序列化 AbstractJackson2HttpMessageConverter:
	// 从spring容器中获取并设置的ObjectMapper实例
	protected ObjectMapper objectMapper;
	
	protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        MediaType contentType = outputMessage.getHeaders().getContentType();
        JsonEncoding encoding = this.getJsonEncoding(contentType);
        JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);

		this.writePrefix(generator, object);
		Object value = object;
		Class<?> serializationView = null;
		FilterProvider filters = null;
		JavaType javaType = null;
		if (object instanceof MappingJacksonValue) {
			MappingJacksonValue container = (MappingJacksonValue)object;
			value = container.getValue();
			serializationView = container.getSerializationView();
			filters = container.getFilters();
		}

		if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
			javaType = this.getJavaType(type, (Class)null);
		}

		ObjectWriter objectWriter = serializationView != null ? this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer();
		if (filters != null) {
			objectWriter = objectWriter.with(filters);
		}

		if (javaType != null && javaType.isContainerType()) {
			objectWriter = objectWriter.forType(javaType);
		}

		SerializationConfig config = objectWriter.getConfig();
		if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) && config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
			objectWriter = objectWriter.with(this.ssePrettyPrinter);
		}
        // 重点进行序列化
		objectWriter.writeValue(generator, value);
		this.writeSuffix(generator, object);
		generator.flush();
    }
复制代码

那么，可以看出SpringMVC在进行响应序列化的时候是从容器中获取的ObjectMapper实例对象，并会根据不同的默认配置条件进行序列化，那处理方法就简单了，我也可以从Spring容器拿数据进行序列化啊。SecretResponseAdvice进行如下进一步改造：


@ControllerAdvice
public class SecretResponseAdvice implements ResponseBodyAdvice {

    @Autowired
    private ObjectMapper objectMapper;
     
      @Override
    public Object beforeBodyWrite(....) {
        .....
        String dataStr =objectMapper.writeValueAsString(o);
        String data = EncryptUtils.aesEncrypt(dataStr, secretKey);
        .....
    }
 }
复制代码

经测试，响应数据和非加密版万全一致啦，还有GET部分的请求加密，以及后面加解密惨遭跨域问题，后面有空再和大家聊聊。

上司はインターフェースの暗号化と復号化の一時的なタスクを失いましたが、私は3日間働き、ステーションをクリーンアップできると感じています

おすすめ