Spring Boot 인터페이스 데이터 암호화 및 복호화는 이렇게 설계해야 합니다~

오늘의 기사에서는 인터페이스 암호화 및 암호 해독과 관련된 인터페이스 보안 문제에 대해 설명합니다.

제품 및 프런트엔드 학생들의 외부 요구 사항을 충족한 후 관련 기술 솔루션을 정리했습니다. 주요 요구 사항은 다음과 같습니다.

• 이전 비즈니스 로직에 영향을 주지 않고 가능한 한 변경을 최소화합니다.
• 시간의 긴급성을 고려하여 대칭 암호화 방식을 채택할 수 있으며 서비스는 Android, IOS 및 H5에 연결되어야 합니다. 또한 H5 저장소 키의 보안이 상대적으로 낮다는 점을 고려하여 두 세트의 키가 할당됩니다. H5, Android 및 IOS용
• 필수 하위 버전 인터페이스와 호환되며 나중에 개발되는 새로운 인터페이스는 호환될 필요가 없습니다.
• 인터페이스에는 암호화 및 암호 해독이 필요한 GET 및 POST라는 두 가지 인터페이스가 있습니다. 요구 사항 분석:

서버, 클라이언트 및 H5 통합 암호화 및 암호 해독을 가로채기 위해 인터넷에 성숙한 솔루션이 있거나 다른 서비스에 구현된 암호화 및 암호 해독 프로세스를 따를 수 있습니다.

AES를 사용하여 암호화를 완화하세요. H5 최종 스토리지 키의 보안이 상대적으로 낮다는 점을 고려하면 H5에 적합합니다. Android 및 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;
}
}

Call: localhost:8080/user/list

쿼리 결과 다음과 같이 문제 없습니다.

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

현재 ControllerAdvice는 주로 요청 및 응답 본문을 가로채는 데 사용됩니다. 요청을 암호화하고 SecretResponseAdvice로 응답을 암호화합니다(실제 상황은 좀 더 복잡하며 프로젝트에 GET 유형 요청이 있습니다. 필터는 다양한 요청 암호 해독 처리에 맞게 사용자 정의됩니다).

그렇습니다. 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, 코드 데모가 준비되었습니다. 사용해 보겠습니다.

请求方法：
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시간이 걸렸습니다. , 그런 다음 모든 인터페이스를 통합해야 합니다. 오후에 완료되어야 하며 H5와 Android 반 친구들에게 내일 아침에 공동 디버깅을 하라고 지시할 것입니다. 그 때 정말 부주의해서 차를 뒤집으셨는데... )

다음날 안드로이드 측에서 자세히 살펴보니 암호화 및 복호화에 문제가 있다고 보고되었습니다. , userType 및 RegisterTime에 문제가 있습니다. '이게 무슨 문제일까요?'라고 생각하기 시작했습니다. 1초 이후 초기 포지셔닝은 응답 본문의 JSON.toJSONString에 문제가 있어야 한다는 것이었습니다.

String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o)),

Debug 중단점 디버깅입니다. 물론 문제를 일으킨 것은 JSON.toJSONString(o) 단계였습니다. JSON 변환 중 고급 JSON 변환 원하는 직렬화 형식을 생성하도록 특성을 구성할 수 있습니까? FastJson은 직렬화 중에 오버로딩 방법을 제공합니다. "SerializerFeature" 매개변수 중 하나를 찾아 생각해 보세요. 이 매개변수는 직렬화를 위해 구성될 수 있으며 그 중 상대적으로 관련이 있다고 생각합니다.

WriteEnumUsingToString,
WriteEnumUsingName,
UseISO8601DateFormat

, 기본값은 WriteEnumUsingName(열거형 이름)을 사용하는 것입니다. 다른 WriteEnumUsingToString은 이론적으로 원하는 대로 변환할 수 있는 re-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을 사용하여 직렬화를 했다는 글이 생각났다. 글쎄요, 그냥 Jackson을 사용하여 구현하세요. 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은 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部分的请求加密，以及后面加解密惨遭跨域问题，后面有空再和大家聊聊。

위 내용은 Spring Boot 인터페이스 데이터 암호화 및 복호화는 이렇게 설계해야 합니다~의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!