这日，刚撸完2行代码，正准备掏出手机摸鱼放松放松，只见老大朝我走过来，并露出一个”善意“的微笑，兴伟呀，xx项目有于安全问题，需要对接口整体进行加密处理，你这方面比较有经验，就给你安排上了哈，看这周内提测行不...，额，摸摸头上飘摇着而稀疏的长发，感觉我爱了。
和产品、前端同学对外需求后，梳理了相关技术方案， 主要的需求点如下：
- 尽量少改动，不影响之前的业务逻辑；
- 考虑到时间紧迫性，可采用对称性加密方式，服务需要对接安卓、ios、h5三端，另外考虑到h5端存储密钥安全性相对来说会低一些，故分针对h5和安卓、ios分配两套密钥；
- 要兼容低版本的接口，后面新开发的接口可不用兼容；
- 接口有get和post两种接口，需要都要进行加解密；
需求解析：
- 服务端、客户端和h5统一拦截加解密，网上有成熟方案，也可以按其他服务中实现的加解密流程来搞；
- 使用aes放松加密，考虑到h5端存储密钥安全性相对来说会低一些，故分针对h5和安卓、ios分配两套密钥；
- 本次涉及客户端和服务端的整体改造，经讨论，新接口统一加 /secret/ 前缀来区分
按本次需求来简单还原问题，定义两个对象，后面用得着，
用户类：
@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", "/secret/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类型请求，自定义了一个filter进行不同的请求解密处理)。
好了，网上的controlleradvice使用示例非常多，我这把两个核心方法给大家展示看看，相信大佬们一看就晓得了，不需多言。上代码：
secretrequestadvice请求解密：
@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官网上查找一下相关文档，当然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 源码的话，就应该知道spring框架自身是怎么序列化的，照着配置应该就行嘛，好像有点道理，我这里不从0开始分析源码了。
跟着执行链路，找到具体的响应序列化，重点就是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部分的请求加密，以及后面加解密惨遭跨域问题，后面有空再和大家聊聊。
总结
到此这篇关于springboot接口数据加解密的文章就介绍到这了,更多相关springboot接口数据加解密内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
