From 1625e256475bce3c75bcd989bab02b0d45300394 Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Mon, 16 Jan 2023 15:09:03 +0800 Subject: [PATCH 1/9] =?UTF-8?q?Mybatis=E5=A2=9E=E5=BC=BA=EF=BC=8C=E4=BD=BF?= =?UTF-8?q?dao=E5=B1=82=E5=AE=9E=E7=8E=B0=E5=AF=B9=E8=A1=A8=E5=AD=97?= =?UTF-8?q?=E6=AE=B5=E7=9A=84=E5=8A=A0=E8=A7=A3=E5=AF=86=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 8 ++ .../src/main/resources/application.yml | 13 ++ .../java/com/ruoyi/test/EncryptUnitTest.java | 35 +++++ ruoyi-common/pom.xml | 6 + .../ruoyi/common/annotation/EncryptField.java | 43 ++++++ .../com/ruoyi/common/encrypt/IEncryptor.java | 46 +++++++ .../com/ruoyi/common/enums/AlgorithmType.java | 36 +++++ .../com/ruoyi/common/enums/EncodeType.java | 26 ++++ .../java/com/ruoyi/demo/domain/TestDemo.java | 4 + .../framework/config/EncryptorConfig.java | 39 ++++++ .../properties/EncryptorProperties.java | 49 +++++++ .../encrypt/EncryptedFieldsCacheHelper.java | 33 +++++ .../framework/encrypt/EncryptorManager.java | 125 ++++++++++++++++++ .../encrypt/MybatisDecryptInterceptor.java | 103 +++++++++++++++ .../encrypt/MybatisEncryptInterceptor.java | 112 ++++++++++++++++ .../encrypt/encryptor/AesEncryptor.java | 74 +++++++++++ .../encrypt/encryptor/Base64Encryptor.java | 54 ++++++++ .../encrypt/encryptor/RsaEncryptor.java | 76 +++++++++++ .../encrypt/encryptor/Sm2Encryptor.java | 78 +++++++++++ .../encrypt/encryptor/Sm4Encryptor.java | 77 +++++++++++ 20 files changed, 1037 insertions(+) create mode 100644 ruoyi-admin/src/test/java/com/ruoyi/test/EncryptUnitTest.java create mode 100644 ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java create mode 100644 ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java create mode 100644 ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java create mode 100644 ruoyi-common/src/main/java/com/ruoyi/common/enums/EncodeType.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/EncryptorProperties.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCacheHelper.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java diff --git a/pom.xml b/pom.xml index 30d5132c8..49f68734a 100644 --- a/pom.xml +++ b/pom.xml @@ -36,6 +36,7 @@ 2.14.2 2.3.1 1.18.24 + 1.72 1.33 @@ -252,6 +253,13 @@ ${snakeyaml.version} + + + org.bouncycastle + bcprov-jdk15to18 + ${bouncycastle.version} + + com.ruoyi diff --git a/ruoyi-admin/src/main/resources/application.yml b/ruoyi-admin/src/main/resources/application.yml index 77c68e496..5b5a31423 100644 --- a/ruoyi-admin/src/main/resources/application.yml +++ b/ruoyi-admin/src/main/resources/application.yml @@ -183,6 +183,19 @@ mybatis-plus: updateStrategy: NOT_NULL # 字段验证策略之 select,在 select 的时候的字段验证策略既 wrapper 根据内部 entity 生成的 where 条件 where-strategy: NOT_NULL +# 数据加密 +mybatis-encryptor: + # 是否开启加密 + enabled: true + # 默认加密算法 + algorithm: aes + # 安全秘钥。对称算法的秘钥。如：AES，SM4 + password: QBcc3SHK2G4ijyfl5XQ7@2g!N2j2jRDR +# # 公私钥。非对称算法的公私钥，如：SM2，RSA +# publicKey: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCDt41GIcWvY6/tpjOLoWY78Oy00uWcNbMRG/8DRoS79/h2D+pV8uxV+0ezaN+fBFCZnK8TdJcPeU4EnNRUh/8HEY33KFvZ700n+Gj5BHUUDKzx3UVFNuF49UI/yoJ8rz6VQQHO79KK89VwmSMO77Tfee1ofe0STY6IwMt/MwaoKwIDAQAB +# privateKey: MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIO3jUYhxa9jr+2mM4uhZjvw7LTS5Zw1sxEb/wNGhLv3+HYP6lXy7FX7R7No358EUJmcrxN0lw95TgSc1FSH/wcRjfcoW9nvTSf4aPkEdRQMrPHdRUU24Xj1Qj/KgnyvPpVBAc7v0orz1XCZIw7vtN957Wh97RJNjojAy38zBqgrAgMBAAECgYAkXx4qvI6rFNryw88+Am6JpMioUghHb2ioE9QCYomqohnA+DocS71JLN8qwo3lijp7gJGzzKEeC8Aoc+oKAZfBQQwPP0K/ql+NcLdlqNAr+XyzkZrLJD/BfluQ6mXI23tjonWnPPZ1Et9HC3zXRQPiuh7Ff6UoqatTMI3OIbSyuQJBAPbaJpVYmIsWJdpvaAC6hcGgR/vbG9yX8VphPn8/2wsm2MmQrRkUoKkudE/veX3KQjGikDwo9+bT6aBl+nn2DUUCQQCImSGZFNcGqhMLyRGVogP6fh0YZSEQAhFbZ69nQmplqbie+dREhODH5Vs5F0C2aL5iSR/UaIDkNEA1auX7x56vAkAFWjON927PTTqi4tmBconl6eDFsDmJbe34xLUDM1I/iqcWr8FhEtZs9Knm9c1PkewfgWPZOhYt9hhRtwRYUqJ1AkAPvQ0I9US9KNVe80DKa8tnjiZODEDd9k8HqA+mpxlZM0/pSUGyz1iSz5NOJaa4HaNp8aDwOUY4hOis/u8Wrm5TAkEA00YeUsaXlMyMF/5pjols44tXb54AjAC2mH66pz9JsKg7pKpWVOpEV5rMY58CGZHWau69vGLZnCd1coeMw77YAQ== +# # 编码方式，base64/hex。默认base64 + encode: base64 # Swagger配置 swagger: diff --git a/ruoyi-admin/src/test/java/com/ruoyi/test/EncryptUnitTest.java b/ruoyi-admin/src/test/java/com/ruoyi/test/EncryptUnitTest.java new file mode 100644 index 000000000..ad69cfbf7 --- /dev/null +++ b/ruoyi-admin/src/test/java/com/ruoyi/test/EncryptUnitTest.java @@ -0,0 +1,35 @@ +package com.ruoyi.test; + +import com.ruoyi.demo.domain.TestDemo; +import com.ruoyi.demo.mapper.TestDemoMapper; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.boot.test.context.SpringBootTest; + +import javax.annotation.Resource; + +/** + * 加密单元测试案例 + * + * @author 老马 + * @date 2023-01-12 08:53 + */ +@SpringBootTest +@DisplayName("加密测试") +public class EncryptUnitTest { + + @Resource + private TestDemoMapper demoMapper; + + @Test + public void testCrypt() { + TestDemo demo = new TestDemo(); + demo.setTestKey("测试的key"); + demo.setValue("测试的value"); + this.demoMapper.insert(demo); + System.out.println(demo); + TestDemo testDemo = this.demoMapper.selectById(demo.getId()); + System.out.println(testDemo); + } + +} diff --git a/ruoyi-common/pom.xml b/ruoyi-common/pom.xml index f88534367..5195cd05a 100644 --- a/ruoyi-common/pom.xml +++ b/ruoyi-common/pom.xml @@ -148,6 +148,12 @@ lock4j-redisson-spring-boot-starter + + + org.bouncycastle + bcprov-jdk15to18 + + diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java b/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java new file mode 100644 index 000000000..492332bfc --- /dev/null +++ b/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java @@ -0,0 +1,43 @@ +package com.ruoyi.common.annotation; + +import com.ruoyi.common.enums.AlgorithmType; +import com.ruoyi.common.enums.EncodeType; +import java.lang.annotation.*; + +/** + * 字段加密注解 + * + * @author 老马 + */ +@Documented +@Inherited +@Target({ElementType.FIELD}) +@Retention(RetentionPolicy.RUNTIME) +public @interface EncryptField { + + /** + * 加密算法 + */ + AlgorithmType algorithm() default AlgorithmType.AES; + + /** + * 秘钥。AES、SM4需要 + */ + String password() default ""; + + /** + * 公钥。RSA、SM2需要 + */ + String publicKey() default ""; + + /** + * 公钥。RSA、SM2需要 + */ + String privateKey() default ""; + + /** + * 编码方式。对加密算法为BASE64的不起作用 + */ + EncodeType encode() default EncodeType.BASE64; + +} diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java new file mode 100644 index 000000000..50204cfbd --- /dev/null +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java @@ -0,0 +1,46 @@ +package com.ruoyi.common.encrypt; + +import com.ruoyi.common.enums.AlgorithmType; +import com.ruoyi.common.enums.EncodeType; + +/** + * 加解者 + * + * @author 老马 + * @date 2023-01-10 16:08 + */ +public interface IEncryptor { + + /** + * 获得当前算法 + * + * @return com.ruoyi.common.enums.AlgorithmType + * @author 老马 + * @date 2023/1/11 11:18 + */ + AlgorithmType algorithm(); + + /** + * 加密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String 加密后的字符串 + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/10 16:38 + */ + String encrypt(String value, EncodeType encodeType) throws Exception; + + /** + * 解密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String 解密后的字符串 + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/10 16:38 + */ + String decrypt(String value, EncodeType encodeType) throws Exception; +} diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java new file mode 100644 index 000000000..6b8a5a5db --- /dev/null +++ b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java @@ -0,0 +1,36 @@ +package com.ruoyi.common.enums; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +/** + * 算法名称 + * + * @author 老马 + */ +@Getter +@AllArgsConstructor +public enum AlgorithmType { + /** + * base64 + */ + BASE64("base64"), + /** + * aes + */ + AES("aes"), + /** + * rsa + */ + RSA("rsa"), + /** + * sm2 + */ + SM2("sm2"), + /** + * sm4 + */ + SM4("sm4"); + + private final String algorithm; +} diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/enums/EncodeType.java b/ruoyi-common/src/main/java/com/ruoyi/common/enums/EncodeType.java new file mode 100644 index 000000000..da50773b1 --- /dev/null +++ b/ruoyi-common/src/main/java/com/ruoyi/common/enums/EncodeType.java @@ -0,0 +1,26 @@ +package com.ruoyi.common.enums; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +/** + * 编码类型 + * + * @author 老马 + * @date 2023-01-11 11:39 + */ +@Getter +@AllArgsConstructor +public enum EncodeType { + /** + * base64编码 + */ + BASE64("base64"), + + /** + * 16进制编码 + */ + HEX("hex"); + + private final String encode; +} diff --git a/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java b/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java index dc19ce2c7..4a4769f71 100644 --- a/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java +++ b/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java @@ -1,7 +1,9 @@ package com.ruoyi.demo.domain; import com.baomidou.mybatisplus.annotation.*; +import com.ruoyi.common.annotation.EncryptField; import com.ruoyi.common.core.domain.BaseEntity; +import com.ruoyi.common.enums.AlgorithmType; import lombok.Data; import lombok.EqualsAndHashCode; @@ -44,11 +46,13 @@ public class TestDemo extends BaseEntity { /** * key键 */ + @EncryptField(algorithm=AlgorithmType.SM2, privateKey = "MIGTAgEAMBMGByqGSM49AgEGCCqBHM9VAYItBHkwdwIBAQQgZSlOvw8FBiH+aFJWLYZP/VRjg9wjfRarTkGBZd/T3N+gCgYIKoEcz1UBgi2hRANCAAR5DGuQwJqkxnbCsP+iPSDoHWIF4RwcR5EsSvT8QPxO1wRkR2IhCkzvRb32x2CUgJFdvoqVqfApFDPZzShqzBwX", publicKey = "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEeQxrkMCapMZ2wrD/oj0g6B1iBeEcHEeRLEr0/ED8TtcEZEdiIQpM70W99sdglICRXb6KlanwKRQz2c0oaswcFw==") private String testKey; /** * 值 */ + @EncryptField(algorithm=AlgorithmType.AES, password = "10rfylhtccpuyke5") private String value; /** diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java new file mode 100644 index 000000000..135936ae8 --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java @@ -0,0 +1,39 @@ +package com.ruoyi.framework.config; + +import com.ruoyi.framework.config.properties.EncryptorProperties; +import com.ruoyi.framework.encrypt.EncryptorManager; +import com.ruoyi.framework.encrypt.MybatisDecryptInterceptor; +import com.ruoyi.framework.encrypt.MybatisEncryptInterceptor; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +/** + * 加解密配置 + * + * @author 老马 + * @date 2023-01-11 10:03 + */ +@Configuration +public class EncryptorConfig { + + @Bean + @ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") + public EncryptorManager mybatisCryptHandler(EncryptorProperties properties) { + EncryptorManager encryptorManager = new EncryptorManager(); + encryptorManager.registAndGetEncryptor(properties); + return encryptorManager; + } + + @Bean + @ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") + public MybatisEncryptInterceptor mybatisEncryptInterceptor(EncryptorProperties properties) { + return new MybatisEncryptInterceptor(); + } + + @Bean + @ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") + public MybatisDecryptInterceptor mybatisDecryptInterceptor(EncryptorProperties properties) { + return new MybatisDecryptInterceptor(); + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/EncryptorProperties.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/EncryptorProperties.java new file mode 100644 index 000000000..d34949d37 --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/EncryptorProperties.java @@ -0,0 +1,49 @@ +package com.ruoyi.framework.config.properties; + +import com.ruoyi.common.enums.AlgorithmType; +import com.ruoyi.common.enums.EncodeType; +import lombok.Data; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.stereotype.Component; + +/** + * 加解密属性配置类 + * + * @author 老马 + * @date 2023-01-10 16:52 + */ +@Data +@Component +@ConfigurationProperties(prefix = "mybatis-encryptor") +public class EncryptorProperties { + + /** + * 过滤开关 + */ + private Boolean enabled; + + /** + * 默认算法 + */ + private AlgorithmType algorithm; + + /** + * 安全秘钥 + */ + private String password; + + /** + * 公钥 + */ + private String publicKey; + + /** + * 私钥 + */ + private String privateKey; + + /** + * 编码方式，base64/hex + */ + private EncodeType encode; +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCacheHelper.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCacheHelper.java new file mode 100644 index 000000000..53b92496d --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCacheHelper.java @@ -0,0 +1,33 @@ +package com.ruoyi.framework.encrypt; + +import com.ruoyi.common.annotation.EncryptField; + +import java.lang.reflect.Field; +import java.util.Arrays; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.stream.Collectors; + +/** + * 类加密字段缓存类 + * + * @author 老马 + * @date 2023-01-12 11:07 + */ +public class EncryptedFieldsCacheHelper { + private static final Map, Set> ENCRYPTED_FIELD_CACHE = new ConcurrentHashMap<>(); + + public static Set get(Class sourceClazz) { + return ENCRYPTED_FIELD_CACHE.computeIfAbsent(sourceClazz, clazz -> { + Field[] declaredFields = clazz.getDeclaredFields(); + Set fieldSet = Arrays.stream(declaredFields).filter(field -> + field.isAnnotationPresent(EncryptField.class) && field.getType() == String.class) + .collect(Collectors.toSet()); + for (Field field : fieldSet) { + field.setAccessible(true); + } + return fieldSet; + }); + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java new file mode 100644 index 000000000..04b8d30d3 --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java @@ -0,0 +1,125 @@ +package com.ruoyi.framework.encrypt; + +import com.ruoyi.common.encrypt.IEncryptor; +import com.ruoyi.common.utils.StringUtils; +import com.ruoyi.framework.config.properties.EncryptorProperties; +import com.ruoyi.framework.encrypt.encryptor.*; +import lombok.extern.slf4j.Slf4j; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +/** + * 加密管理类 + * + * @author 老马 + * @date 2023-01-11 10:07 + */ +@Slf4j +public class EncryptorManager { + + /** + * 缓存加密器 + */ + Map encryptorMap = new ConcurrentHashMap<>(); + + + /** + * 注册加密执行者到缓存 + * + * @param properties 加密执行者需要的相关配置参数 + * @author 老马 + * @date 2023/1/11 15:09 + */ + public IEncryptor registAndGetEncryptor(EncryptorProperties properties) { + String encryptorKey = this.getEncryptorKeyFromProperties(properties); + if(encryptorMap.containsKey(encryptorKey)){ + return encryptorMap.get(encryptorKey); + } + switch (properties.getAlgorithm()) { + case BASE64: + encryptorMap.put(encryptorKey, new Base64Encryptor()); + break; + case AES: + encryptorMap.put(encryptorKey, new AesEncryptor(properties.getPassword())); + break; + case RSA: + encryptorMap.put(encryptorKey, new RsaEncryptor(properties.getPrivateKey(), properties.getPublicKey())); + break; + case SM2: + encryptorMap.put(encryptorKey, new Sm2Encryptor(properties.getPrivateKey(), properties.getPublicKey())); + break; + case SM4: + encryptorMap.put(encryptorKey, new Sm4Encryptor(properties.getPassword())); + break; + default: + AesEncryptor defaultEncryptor = new AesEncryptor(properties.getPassword()); + encryptorMap.put(encryptorKey, defaultEncryptor); + } + return encryptorMap.get(encryptorKey); + } + + /** + * 移除缓存中的加密执行者 + * + * @param properties 加密执行者需要的相关配置参数 + * @author 老马 + * @date 2023/1/11 15:55 + */ + public void removeEncryptor(EncryptorProperties properties) { + this.encryptorMap.remove(getEncryptorKeyFromProperties(properties)); + } + + /** + * 根据配置进行加密。会进行本地缓存对应的算法和对应的秘钥信息。 + * + * @param value 待加密的值 + * @param properties 加密相关的配置信息 + * @return java.lang.String 加密后的结果 + * @author 老马 + * @date 2023/1/11 16:46 + */ + public String encrypt(String value, EncryptorProperties properties) { + try { + IEncryptor encryptor = this.registAndGetEncryptor(properties); + return encryptor.encrypt(value, properties.getEncode()); + }catch (Exception e) { + log.error("字段加密异常,原样返回。异常信息：【{}】", e.getMessage()); + return value; + } + } + + /** + * 根据配置进行解密 + * + * @param value 待解密的值 + * @param properties 加密相关的配置信息 + * @return java.lang.String + * @author 老马 + * @date 2023/1/11 17:43 + */ + public String decrypt(String value, EncryptorProperties properties) { + try{ + IEncryptor encryptor = this.registAndGetEncryptor(properties); + return encryptor.decrypt(value, properties.getEncode()); + }catch (Exception e) { + log.error("字段解密异常,原样返回。异常信息：【{}】", e.getMessage()); + return value; + } + } + + + /** + * 从配置内容中提取缓存的KEY + * + * @param properties 加密相关的配置信息 + * @return java.lang.String + * @author 老马 + * @date 2023/1/11 17:39 + */ + private String getEncryptorKeyFromProperties(EncryptorProperties properties) { + return properties.getAlgorithm().getAlgorithm()+ StringUtils.defaultString(properties.getPassword()) + + StringUtils.defaultString(properties.getPublicKey()) + StringUtils.defaultString(properties.getPrivateKey()); + } + +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java new file mode 100644 index 000000000..39136f256 --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java @@ -0,0 +1,103 @@ +package com.ruoyi.framework.encrypt; + +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.exceptions.ExceptionUtil; +import com.ruoyi.common.annotation.EncryptField; +import com.ruoyi.common.utils.StringUtils; +import com.ruoyi.common.utils.spring.SpringUtils; +import com.ruoyi.framework.config.properties.EncryptorProperties; +import lombok.extern.slf4j.Slf4j; +import org.apache.ibatis.executor.resultset.ResultSetHandler; +import org.apache.ibatis.plugin.*; + +import java.lang.reflect.Field; +import java.sql.Statement; +import java.util.*; + +/** + * 出参解密拦截器 + * + * @author 老马 + * @date 2023-01-12 13:47 + */ +@Slf4j +@Intercepts({@Signature( + type = ResultSetHandler.class, + method = "handleResultSets", + args = {Statement.class}) +}) +public class MybatisDecryptInterceptor implements Interceptor { + + private final EncryptorManager encryptorManager = SpringUtils.getBean(EncryptorManager.class); + private final EncryptorProperties defaultProperties = SpringUtils.getBean(EncryptorProperties.class); + + @Override + public Object intercept(Invocation invocation) throws Throwable { + // 获取执行mysql执行结果 + Object result = invocation.proceed(); + if (result == null) { + return null; + } + decryptHandler(result); + return result; + } + + /** + * 解密对象 + * + * @param sourceObject 待加密对象 + */ + private void decryptHandler (Object sourceObject) { + if (sourceObject instanceof Map) { + ((Map) sourceObject).values().forEach(this::decryptHandler); + return; + } + if (sourceObject instanceof List) { + // 判断第一个元素是否含有注解。如果没有直接返回，提高效率 + Object firstItem = ((List) sourceObject).get(0); + if(CollectionUtil.isEmpty(EncryptedFieldsCacheHelper.get(firstItem.getClass()))) { + return; + } + ((List) sourceObject).forEach(this::decryptHandler); + return; + } + Set fields = EncryptedFieldsCacheHelper.get(sourceObject.getClass()); + try { + for (Field field : fields) { + field.set(sourceObject, this.decryptField(String.valueOf(field.get(sourceObject)), field)); + } + } catch (Exception e) { + log.error("处理加密字段时出错：{}", ExceptionUtil.getSimpleMessage(e)); + } + } + + /** + * 字段值进行加密。通过字段的批注注册新的加密算法 + * + * @param value 待加密的值 + * @param field 待加密字段 + * @return 加密后结果 + */ + private String decryptField(String value, Field field) { + EncryptField encryptField = field.getAnnotation(EncryptField.class); + EncryptorProperties properties = new EncryptorProperties(); + properties.setEnabled(true); + properties.setAlgorithm(encryptField.algorithm()); + properties.setEncode(encryptField.encode()); + properties.setPassword(StringUtils.isEmpty(encryptField.password())?defaultProperties.getPassword():encryptField.password()); + properties.setPrivateKey(StringUtils.isEmpty(encryptField.privateKey())?defaultProperties.getPrivateKey():encryptField.privateKey()); + properties.setPublicKey(StringUtils.isEmpty(encryptField.publicKey())?defaultProperties.getPublicKey():encryptField.publicKey()); + this.encryptorManager.registAndGetEncryptor(properties); + return this.encryptorManager.decrypt(value, properties); + } + + @Override + public Object plugin(Object target) { + return Plugin.wrap(target, this); + } + + @Override + public void setProperties(Properties properties) { + + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java new file mode 100644 index 000000000..f5e5f1d87 --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java @@ -0,0 +1,112 @@ +package com.ruoyi.framework.encrypt; + +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.exceptions.ExceptionUtil; +import cn.hutool.core.util.ObjectUtil; +import com.ruoyi.common.annotation.EncryptField; +import com.ruoyi.common.utils.StringUtils; +import com.ruoyi.common.utils.spring.SpringUtils; +import com.ruoyi.framework.config.properties.EncryptorProperties; +import lombok.extern.slf4j.Slf4j; +import org.apache.ibatis.executor.parameter.ParameterHandler; +import org.apache.ibatis.plugin.Interceptor; +import org.apache.ibatis.plugin.Intercepts; +import org.apache.ibatis.plugin.Invocation; +import org.apache.ibatis.plugin.Signature; + +import java.lang.reflect.Field; +import java.sql.PreparedStatement; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Set; + +/** + * 入参加密拦截器 + * + * @author 老马 + * @date 2023-01-10 16:42 + */ +@Slf4j +@Intercepts({@Signature( + type = ParameterHandler.class, + method = "setParameters", + args = {PreparedStatement.class}) +}) +public class MybatisEncryptInterceptor implements Interceptor { + + private final EncryptorManager encryptorManager = SpringUtils.getBean(EncryptorManager.class); + private final EncryptorProperties defaultProperties = SpringUtils.getBean(EncryptorProperties.class); + + @Override + public Object intercept(Invocation invocation) throws Throwable { + return invocation; + } + + @Override + public Object plugin(Object target) { + if (target instanceof ParameterHandler) { + // 进行加密操作 + ParameterHandler parameterHandler = (ParameterHandler) target; + Object parameterObject = parameterHandler.getParameterObject(); + if(ObjectUtil.isNotNull(parameterObject) && !(parameterObject instanceof String)){ + this.encryptHandler(parameterObject); + } + } + return target; + } + + /** + * 加密对象 + * + * @param sourceObject 待加密对象 + */ + private void encryptHandler (Object sourceObject) { + if (sourceObject instanceof Map) { + ((Map) sourceObject).values().forEach(this::encryptHandler); + return; + } + if (sourceObject instanceof List) { + // 判断第一个元素是否含有注解。如果没有直接返回，提高效率 + Object firstItem = ((List) sourceObject).get(0); + if(CollectionUtil.isEmpty(EncryptedFieldsCacheHelper.get(firstItem.getClass()))) { + return; + } + ((List) sourceObject).forEach(this::encryptHandler); + return; + } + Set fields = EncryptedFieldsCacheHelper.get(sourceObject.getClass()); + try { + for (Field field : fields) { + field.set(sourceObject, this.encryptField(String.valueOf(field.get(sourceObject)), field)); + } + } catch (Exception e) { + log.error("处理加密字段时出错：{}", ExceptionUtil.getSimpleMessage(e)); + } + } + + /** + * 字段值进行加密。通过字段的批注注册新的加密算法 + * + * @param value 待加密的值 + * @param field 待加密字段 + * @return 加密后结果 + */ + private String encryptField(String value, Field field) { + EncryptField encryptField = field.getAnnotation(EncryptField.class); + EncryptorProperties properties = new EncryptorProperties(); + properties.setEnabled(true); + properties.setAlgorithm(encryptField.algorithm()); + properties.setEncode(encryptField.encode()); + properties.setPassword(StringUtils.isEmpty(encryptField.password())?defaultProperties.getPassword():encryptField.password()); + properties.setPrivateKey(StringUtils.isEmpty(encryptField.privateKey())?defaultProperties.getPrivateKey():encryptField.privateKey()); + properties.setPublicKey(StringUtils.isEmpty(encryptField.publicKey())?defaultProperties.getPublicKey():encryptField.publicKey()); + this.encryptorManager.registAndGetEncryptor(properties); + return this.encryptorManager.encrypt(value, properties); + } + + + @Override + public void setProperties(Properties properties) { + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java new file mode 100644 index 000000000..bcfcadfb9 --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java @@ -0,0 +1,74 @@ +package com.ruoyi.framework.encrypt.encryptor; + +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.crypto.SecureUtil; +import cn.hutool.crypto.symmetric.AES; +import com.ruoyi.common.encrypt.IEncryptor; +import com.ruoyi.common.enums.AlgorithmType; +import com.ruoyi.common.enums.EncodeType; +import java.nio.charset.StandardCharsets; + +/** + * AES算法实现 + * + * @author 老马 + * @date 2023-01-06 11:39 + */ +public class AesEncryptor implements IEncryptor { + + private AES aes = null; + + public AesEncryptor(String password) { + aes = SecureUtil.aes(password.getBytes(StandardCharsets.UTF_8)); + } + + /** + * 获得当前算法 + * + * @return com.ruoyi.common.enums.AlgorithmType + * @author 老马 + * @date 2023/1/11 11:18 + */ + @Override + public AlgorithmType algorithm() { + return AlgorithmType.AES; + } + + /** + * 加密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String encrypt(String value, EncodeType encodeType) throws Exception { + if(ObjectUtil.isNotNull(this.aes)) { + if(encodeType == EncodeType.HEX) { + return aes.encryptHex(value); + }else { + return aes.encryptBase64(value); + } + } + return value; + } + + /** + * 解密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String decrypt(String value,EncodeType encodeType) throws Exception { + if(ObjectUtil.isNotNull(this.aes)) { + return this.aes.decryptStr(value); + } + return value; + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java new file mode 100644 index 000000000..aee34efaf --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java @@ -0,0 +1,54 @@ +package com.ruoyi.framework.encrypt.encryptor; + +import cn.hutool.core.codec.Base64; +import com.ruoyi.common.encrypt.IEncryptor; +import com.ruoyi.common.enums.AlgorithmType; +import com.ruoyi.common.enums.EncodeType; + +/** + * Base64算法实现。不建议在生产环境使用 + * + * @author 老马 + * @date 2023-01-06 10:00 + */ +public class Base64Encryptor implements IEncryptor { + /** + * 获得当前算法 + * + * @return com.ruoyi.common.enums.AlgorithmType + * @author 老马 + * @date 2023/1/11 11:18 + */ + @Override + public AlgorithmType algorithm() { + return AlgorithmType.BASE64; + } + + /** + * 加密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String encrypt(String value, EncodeType encodeType) throws Exception { + return Base64.encode(value); + } + + /** + * 解密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String decrypt(String value, EncodeType encodeType) throws Exception { + return Base64.decodeStr(value); + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java new file mode 100644 index 000000000..369ad789b --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java @@ -0,0 +1,76 @@ +package com.ruoyi.framework.encrypt.encryptor; + +import cn.hutool.core.codec.Base64; +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.crypto.SecureUtil; +import cn.hutool.crypto.asymmetric.KeyType; +import cn.hutool.crypto.asymmetric.RSA; +import com.ruoyi.common.encrypt.IEncryptor; +import com.ruoyi.common.enums.AlgorithmType; +import com.ruoyi.common.enums.EncodeType; + + +/** + * RSA算法实现 + * + * @author 老马 + * @date 2023-01-06 09:37 + */ +public class RsaEncryptor implements IEncryptor { + + private RSA rsa = null; + + public RsaEncryptor(String privateKey, String publicKey) { + this.rsa = SecureUtil.rsa(Base64.decode(privateKey), Base64.decode(publicKey)); + } + + /** + * 获得当前算法 + * + * @return com.ruoyi.common.enums.AlgorithmType + * @author 老马 + * @date 2023/1/11 11:18 + */ + @Override + public AlgorithmType algorithm() { + return AlgorithmType.RSA; + } + + /** + * 加密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String encrypt(String value, EncodeType encodeType) throws Exception { + if(ObjectUtil.isNotNull(this.rsa)) { + if (encodeType == EncodeType.HEX) { + return rsa.encryptHex(value, KeyType.PublicKey); + } else { + return rsa.encryptBase64(value, KeyType.PublicKey); + } + } + return value; + } + + /** + * 解密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String decrypt(String value, EncodeType encodeType) throws Exception { + if(ObjectUtil.isNotNull(this.rsa)) { + return this.rsa.decryptStr(value, KeyType.PrivateKey); + } + return value; + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java new file mode 100644 index 000000000..89c30246b --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java @@ -0,0 +1,78 @@ +package com.ruoyi.framework.encrypt.encryptor; + + +import cn.hutool.core.codec.Base64; +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.crypto.SmUtil; +import cn.hutool.crypto.asymmetric.KeyType; +import cn.hutool.crypto.asymmetric.SM2; +import com.ruoyi.common.encrypt.IEncryptor; +import com.ruoyi.common.enums.AlgorithmType; +import com.ruoyi.common.enums.EncodeType; + +/** + * sm2算法实现 + * + * @author 老马 + * @date 2023-01-06 17:13 + */ +public class Sm2Encryptor implements IEncryptor { + + private SM2 sm2 = null; + + public Sm2Encryptor(String privateKey, String publicKey) { + sm2 = SmUtil.sm2(Base64.decode(privateKey), Base64.decode(publicKey)); + } + + /** + * 获得当前算法 + * + * @return com.ruoyi.common.enums.AlgorithmType + * @author 老马 + * @date 2023/1/11 11:18 + */ + @Override + public AlgorithmType algorithm() { + return AlgorithmType.SM2; + } + + /** + * 加密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String encrypt(String value, EncodeType encodeType) throws Exception { + if(ObjectUtil.isNotNull(this.sm2)) { + if (encodeType == EncodeType.HEX) { + return sm2.encryptHex(value, KeyType.PublicKey); + } else { + return sm2.encryptBase64(value, KeyType.PublicKey); + } + } + return value; + } + + /** + * 解密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String decrypt(String value, EncodeType encodeType) throws Exception { + if(ObjectUtil.isNotNull(this.sm2)) { + return this.sm2.decryptStr(value, KeyType.PrivateKey); + } + return value; + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java new file mode 100644 index 000000000..248e9874d --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java @@ -0,0 +1,77 @@ +package com.ruoyi.framework.encrypt.encryptor; + +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.crypto.SmUtil; +import cn.hutool.crypto.symmetric.SM4; +import com.ruoyi.common.encrypt.IEncryptor; +import com.ruoyi.common.enums.AlgorithmType; +import com.ruoyi.common.enums.EncodeType; + +import java.nio.charset.StandardCharsets; + +/** + * sm4算法实现 + * + * @author 老马 + * @date 2023-01-06 17:40 + */ +public class Sm4Encryptor implements IEncryptor { + + private SM4 sm4 = null; + + public Sm4Encryptor(String password) { + this.sm4 = SmUtil.sm4(password.getBytes(StandardCharsets.UTF_8)); + } + + /** + * 获得当前算法 + * + * @return com.ruoyi.common.enums.AlgorithmType + * @author 老马 + * @date 2023/1/11 11:18 + */ + @Override + public AlgorithmType algorithm() { + return AlgorithmType.SM4; + } + + /** + * 加密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String encrypt(String value, EncodeType encodeType) throws Exception { + if(ObjectUtil.isNotNull(this.sm4)) { + if (encodeType == EncodeType.HEX) { + return sm4.encryptHex(value); + } else { + return sm4.encryptBase64(value); + } + } + return value; + } + + /** + * 解密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/10 16:38 + */ + @Override + public String decrypt(String value, EncodeType encodeType) throws Exception { + if(ObjectUtil.isNotNull(this.sm4)) { + return this.sm4.decryptStr(value); + } + return value; + } +} From c437089b2911ac81baa527dafd2b90ecd1bb2e1b Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Mon, 16 Jan 2023 16:16:15 +0800 Subject: [PATCH 2/9] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=A6=82=E4=B8=8B?= =?UTF-8?q?=EF=BC=9A=201.=E6=A0=BC=E5=BC=8F=E5=8C=96=E4=BB=A3=E7=A0=81=202?= =?UTF-8?q?.mybatis=E7=9A=84=E4=B8=A4=E4=B8=AA=E6=8B=A6=E6=88=AA=E5=99=A8?= =?UTF-8?q?=E7=B1=BB=E4=BB=8EEncryptorConfig=E5=8E=BB=E6=8E=89=EF=BC=8C?= =?UTF-8?q?=E9=87=87=E7=94=A8=E6=B3=A8=E8=A7=A3=E5=BD=A2=E5=BC=8F=E6=B3=A8?= =?UTF-8?q?=E5=85=A5=203.=E9=94=99=E8=AF=AF=E6=97=A5=E5=BF=97=E8=AE=B0?= =?UTF-8?q?=E5=BD=95=E9=87=87=E7=94=A8=E6=97=A5=E5=BF=97=E6=A1=86=E6=9E=B6?= =?UTF-8?q?=E6=9D=A5=E5=A4=84=E7=90=86=E5=BC=82=E5=B8=B8=E5=86=85=E5=AE=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ruoyi/test/EncryptUnitTest.java | 2 + .../ruoyi/common/annotation/EncryptField.java | 1 + .../com/ruoyi/common/encrypt/IEncryptor.java | 48 +++++------ .../com/ruoyi/common/enums/AlgorithmType.java | 4 + .../java/com/ruoyi/demo/domain/TestDemo.java | 2 +- .../framework/config/EncryptorConfig.java | 14 ---- .../framework/encrypt/EncryptorManager.java | 84 +++++++++---------- .../encrypt/MybatisDecryptInterceptor.java | 14 ++-- .../encrypt/MybatisEncryptInterceptor.java | 16 ++-- .../encrypt/encryptor/AesEncryptor.java | 13 +-- .../encrypt/encryptor/RsaEncryptor.java | 4 +- .../encrypt/encryptor/Sm2Encryptor.java | 4 +- .../encrypt/encryptor/Sm4Encryptor.java | 4 +- 13 files changed, 106 insertions(+), 104 deletions(-) diff --git a/ruoyi-admin/src/test/java/com/ruoyi/test/EncryptUnitTest.java b/ruoyi-admin/src/test/java/com/ruoyi/test/EncryptUnitTest.java index ad69cfbf7..b049232ab 100644 --- a/ruoyi-admin/src/test/java/com/ruoyi/test/EncryptUnitTest.java +++ b/ruoyi-admin/src/test/java/com/ruoyi/test/EncryptUnitTest.java @@ -1,5 +1,6 @@ package com.ruoyi.test; +import cn.dev33.satoken.annotation.SaIgnore; import com.ruoyi.demo.domain.TestDemo; import com.ruoyi.demo.mapper.TestDemoMapper; import org.junit.jupiter.api.DisplayName; @@ -15,6 +16,7 @@ import javax.annotation.Resource; * @date 2023-01-12 08:53 */ @SpringBootTest +@SaIgnore @DisplayName("加密测试") public class EncryptUnitTest { diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java b/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java index 492332bfc..9cb9596f7 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java @@ -2,6 +2,7 @@ package com.ruoyi.common.annotation; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; + import java.lang.annotation.*; /** diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java index 50204cfbd..fae0327c1 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java @@ -12,35 +12,35 @@ import com.ruoyi.common.enums.EncodeType; public interface IEncryptor { /** - * 获得当前算法 - * - * @return com.ruoyi.common.enums.AlgorithmType - * @author 老马 - * @date 2023/1/11 11:18 - */ + * 获得当前算法 + * + * @return com.ruoyi.common.enums.AlgorithmType + * @author 老马 + * @date 2023/1/11 11:18 + */ AlgorithmType algorithm(); /** - * 加密 - * - * @param value 待加密字符串 - * @param encodeType 加密后的编码格式 - * @return java.lang.String 加密后的字符串 - * @throws Exception 抛出异常 - * @author 老马 - * @date 2023/1/10 16:38 - */ + * 加密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String 加密后的字符串 + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/10 16:38 + */ String encrypt(String value, EncodeType encodeType) throws Exception; /** - * 解密 - * - * @param value 待加密字符串 - * @param encodeType 加密后的编码格式 - * @return java.lang.String 解密后的字符串 - * @throws Exception 抛出异常 - * @author 老马 - * @date 2023/1/10 16:38 - */ + * 解密 + * + * @param value 待加密字符串 + * @param encodeType 加密后的编码格式 + * @return java.lang.String 解密后的字符串 + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/10 16:38 + */ String decrypt(String value, EncodeType encodeType) throws Exception; } diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java index 6b8a5a5db..610658fa9 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java @@ -15,18 +15,22 @@ public enum AlgorithmType { * base64 */ BASE64("base64"), + /** * aes */ AES("aes"), + /** * rsa */ RSA("rsa"), + /** * sm2 */ SM2("sm2"), + /** * sm4 */ diff --git a/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java b/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java index 4a4769f71..66c2b365e 100644 --- a/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java +++ b/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java @@ -52,7 +52,7 @@ public class TestDemo extends BaseEntity { /** * 值 */ - @EncryptField(algorithm=AlgorithmType.AES, password = "10rfylhtccpuyke5") + @EncryptField(algorithm = AlgorithmType.AES, password = "10rfylhtccpuyke5") private String value; /** diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java index 135936ae8..ebc23241d 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java @@ -2,8 +2,6 @@ package com.ruoyi.framework.config; import com.ruoyi.framework.config.properties.EncryptorProperties; import com.ruoyi.framework.encrypt.EncryptorManager; -import com.ruoyi.framework.encrypt.MybatisDecryptInterceptor; -import com.ruoyi.framework.encrypt.MybatisEncryptInterceptor; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @@ -24,16 +22,4 @@ public class EncryptorConfig { encryptorManager.registAndGetEncryptor(properties); return encryptorManager; } - - @Bean - @ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") - public MybatisEncryptInterceptor mybatisEncryptInterceptor(EncryptorProperties properties) { - return new MybatisEncryptInterceptor(); - } - - @Bean - @ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") - public MybatisDecryptInterceptor mybatisDecryptInterceptor(EncryptorProperties properties) { - return new MybatisDecryptInterceptor(); - } } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java index 04b8d30d3..0f269a589 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java @@ -25,15 +25,15 @@ public class EncryptorManager { /** - * 注册加密执行者到缓存 - * - * @param properties 加密执行者需要的相关配置参数 - * @author 老马 - * @date 2023/1/11 15:09 - */ + * 注册加密执行者到缓存 + * + * @param properties 加密执行者需要的相关配置参数 + * @author 老马 + * @date 2023/1/11 15:09 + */ public IEncryptor registAndGetEncryptor(EncryptorProperties properties) { String encryptorKey = this.getEncryptorKeyFromProperties(properties); - if(encryptorMap.containsKey(encryptorKey)){ + if (encryptorMap.containsKey(encryptorKey)) { return encryptorMap.get(encryptorKey); } switch (properties.getAlgorithm()) { @@ -60,65 +60,65 @@ public class EncryptorManager { } /** - * 移除缓存中的加密执行者 - * - * @param properties 加密执行者需要的相关配置参数 - * @author 老马 - * @date 2023/1/11 15:55 - */ + * 移除缓存中的加密执行者 + * + * @param properties 加密执行者需要的相关配置参数 + * @author 老马 + * @date 2023/1/11 15:55 + */ public void removeEncryptor(EncryptorProperties properties) { this.encryptorMap.remove(getEncryptorKeyFromProperties(properties)); } /** - * 根据配置进行加密。会进行本地缓存对应的算法和对应的秘钥信息。 - * - * @param value 待加密的值 - * @param properties 加密相关的配置信息 - * @return java.lang.String 加密后的结果 - * @author 老马 - * @date 2023/1/11 16:46 - */ + * 根据配置进行加密。会进行本地缓存对应的算法和对应的秘钥信息。 + * + * @param value 待加密的值 + * @param properties 加密相关的配置信息 + * @return java.lang.String 加密后的结果 + * @author 老马 + * @date 2023/1/11 16:46 + */ public String encrypt(String value, EncryptorProperties properties) { try { IEncryptor encryptor = this.registAndGetEncryptor(properties); return encryptor.encrypt(value, properties.getEncode()); - }catch (Exception e) { - log.error("字段加密异常,原样返回。异常信息：【{}】", e.getMessage()); + } catch (Exception e) { + log.error("字段加密异常,原样返回", e); return value; } } /** - * 根据配置进行解密 - * - * @param value 待解密的值 - * @param properties 加密相关的配置信息 - * @return java.lang.String - * @author 老马 - * @date 2023/1/11 17:43 - */ + * 根据配置进行解密 + * + * @param value 待解密的值 + * @param properties 加密相关的配置信息 + * @return java.lang.String + * @author 老马 + * @date 2023/1/11 17:43 + */ public String decrypt(String value, EncryptorProperties properties) { - try{ + try { IEncryptor encryptor = this.registAndGetEncryptor(properties); return encryptor.decrypt(value, properties.getEncode()); - }catch (Exception e) { - log.error("字段解密异常,原样返回。异常信息：【{}】", e.getMessage()); + } catch (Exception e) { + log.error("字段解密异常,原样返回", e); return value; } } /** - * 从配置内容中提取缓存的KEY - * - * @param properties 加密相关的配置信息 - * @return java.lang.String - * @author 老马 - * @date 2023/1/11 17:39 - */ + * 从配置内容中提取缓存的KEY + * + * @param properties 加密相关的配置信息 + * @return java.lang.String + * @author 老马 + * @date 2023/1/11 17:39 + */ private String getEncryptorKeyFromProperties(EncryptorProperties properties) { - return properties.getAlgorithm().getAlgorithm()+ StringUtils.defaultString(properties.getPassword()) + + return properties.getAlgorithm().getAlgorithm() + StringUtils.defaultString(properties.getPassword()) + StringUtils.defaultString(properties.getPublicKey()) + StringUtils.defaultString(properties.getPrivateKey()); } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java index 39136f256..e1e5efb0d 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java @@ -9,6 +9,8 @@ import com.ruoyi.framework.config.properties.EncryptorProperties; import lombok.extern.slf4j.Slf4j; import org.apache.ibatis.executor.resultset.ResultSetHandler; import org.apache.ibatis.plugin.*; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.stereotype.Component; import java.lang.reflect.Field; import java.sql.Statement; @@ -26,6 +28,8 @@ import java.util.*; method = "handleResultSets", args = {Statement.class}) }) +@ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") +@Component public class MybatisDecryptInterceptor implements Interceptor { private final EncryptorManager encryptorManager = SpringUtils.getBean(EncryptorManager.class); @@ -47,7 +51,7 @@ public class MybatisDecryptInterceptor implements Interceptor { * * @param sourceObject 待加密对象 */ - private void decryptHandler (Object sourceObject) { + private void decryptHandler(Object sourceObject) { if (sourceObject instanceof Map) { ((Map) sourceObject).values().forEach(this::decryptHandler); return; @@ -55,7 +59,7 @@ public class MybatisDecryptInterceptor implements Interceptor { if (sourceObject instanceof List) { // 判断第一个元素是否含有注解。如果没有直接返回，提高效率 Object firstItem = ((List) sourceObject).get(0); - if(CollectionUtil.isEmpty(EncryptedFieldsCacheHelper.get(firstItem.getClass()))) { + if (CollectionUtil.isEmpty(EncryptedFieldsCacheHelper.get(firstItem.getClass()))) { return; } ((List) sourceObject).forEach(this::decryptHandler); @@ -84,9 +88,9 @@ public class MybatisDecryptInterceptor implements Interceptor { properties.setEnabled(true); properties.setAlgorithm(encryptField.algorithm()); properties.setEncode(encryptField.encode()); - properties.setPassword(StringUtils.isEmpty(encryptField.password())?defaultProperties.getPassword():encryptField.password()); - properties.setPrivateKey(StringUtils.isEmpty(encryptField.privateKey())?defaultProperties.getPrivateKey():encryptField.privateKey()); - properties.setPublicKey(StringUtils.isEmpty(encryptField.publicKey())?defaultProperties.getPublicKey():encryptField.publicKey()); + properties.setPassword(StringUtils.isEmpty(encryptField.password()) ? defaultProperties.getPassword() : encryptField.password()); + properties.setPrivateKey(StringUtils.isEmpty(encryptField.privateKey()) ? defaultProperties.getPrivateKey() : encryptField.privateKey()); + properties.setPublicKey(StringUtils.isEmpty(encryptField.publicKey()) ? defaultProperties.getPublicKey() : encryptField.publicKey()); this.encryptorManager.registAndGetEncryptor(properties); return this.encryptorManager.decrypt(value, properties); } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java index f5e5f1d87..b3afc187c 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java @@ -13,6 +13,8 @@ import org.apache.ibatis.plugin.Interceptor; import org.apache.ibatis.plugin.Intercepts; import org.apache.ibatis.plugin.Invocation; import org.apache.ibatis.plugin.Signature; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.stereotype.Component; import java.lang.reflect.Field; import java.sql.PreparedStatement; @@ -33,6 +35,8 @@ import java.util.Set; method = "setParameters", args = {PreparedStatement.class}) }) +@ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") +@Component public class MybatisEncryptInterceptor implements Interceptor { private final EncryptorManager encryptorManager = SpringUtils.getBean(EncryptorManager.class); @@ -49,7 +53,7 @@ public class MybatisEncryptInterceptor implements Interceptor { // 进行加密操作 ParameterHandler parameterHandler = (ParameterHandler) target; Object parameterObject = parameterHandler.getParameterObject(); - if(ObjectUtil.isNotNull(parameterObject) && !(parameterObject instanceof String)){ + if (ObjectUtil.isNotNull(parameterObject) && !(parameterObject instanceof String)) { this.encryptHandler(parameterObject); } } @@ -61,7 +65,7 @@ public class MybatisEncryptInterceptor implements Interceptor { * * @param sourceObject 待加密对象 */ - private void encryptHandler (Object sourceObject) { + private void encryptHandler(Object sourceObject) { if (sourceObject instanceof Map) { ((Map) sourceObject).values().forEach(this::encryptHandler); return; @@ -69,7 +73,7 @@ public class MybatisEncryptInterceptor implements Interceptor { if (sourceObject instanceof List) { // 判断第一个元素是否含有注解。如果没有直接返回，提高效率 Object firstItem = ((List) sourceObject).get(0); - if(CollectionUtil.isEmpty(EncryptedFieldsCacheHelper.get(firstItem.getClass()))) { + if (CollectionUtil.isEmpty(EncryptedFieldsCacheHelper.get(firstItem.getClass()))) { return; } ((List) sourceObject).forEach(this::encryptHandler); @@ -98,9 +102,9 @@ public class MybatisEncryptInterceptor implements Interceptor { properties.setEnabled(true); properties.setAlgorithm(encryptField.algorithm()); properties.setEncode(encryptField.encode()); - properties.setPassword(StringUtils.isEmpty(encryptField.password())?defaultProperties.getPassword():encryptField.password()); - properties.setPrivateKey(StringUtils.isEmpty(encryptField.privateKey())?defaultProperties.getPrivateKey():encryptField.privateKey()); - properties.setPublicKey(StringUtils.isEmpty(encryptField.publicKey())?defaultProperties.getPublicKey():encryptField.publicKey()); + properties.setPassword(StringUtils.isEmpty(encryptField.password()) ? defaultProperties.getPassword() : encryptField.password()); + properties.setPrivateKey(StringUtils.isEmpty(encryptField.privateKey()) ? defaultProperties.getPrivateKey() : encryptField.privateKey()); + properties.setPublicKey(StringUtils.isEmpty(encryptField.publicKey()) ? defaultProperties.getPublicKey() : encryptField.publicKey()); this.encryptorManager.registAndGetEncryptor(properties); return this.encryptorManager.encrypt(value, properties); } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java index bcfcadfb9..d3efa2444 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java @@ -6,6 +6,7 @@ import cn.hutool.crypto.symmetric.AES; import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; + import java.nio.charset.StandardCharsets; /** @@ -45,14 +46,14 @@ public class AesEncryptor implements IEncryptor { */ @Override public String encrypt(String value, EncodeType encodeType) throws Exception { - if(ObjectUtil.isNotNull(this.aes)) { - if(encodeType == EncodeType.HEX) { + if (ObjectUtil.isNotNull(this.aes)) { + if (encodeType == EncodeType.HEX) { return aes.encryptHex(value); - }else { + } else { return aes.encryptBase64(value); } } - return value; + return value; } /** @@ -65,8 +66,8 @@ public class AesEncryptor implements IEncryptor { * @date 2023/1/10 16:38 */ @Override - public String decrypt(String value,EncodeType encodeType) throws Exception { - if(ObjectUtil.isNotNull(this.aes)) { + public String decrypt(String value, EncodeType encodeType) throws Exception { + if (ObjectUtil.isNotNull(this.aes)) { return this.aes.decryptStr(value); } return value; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java index 369ad789b..4b0eea799 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java @@ -47,7 +47,7 @@ public class RsaEncryptor implements IEncryptor { */ @Override public String encrypt(String value, EncodeType encodeType) throws Exception { - if(ObjectUtil.isNotNull(this.rsa)) { + if (ObjectUtil.isNotNull(this.rsa)) { if (encodeType == EncodeType.HEX) { return rsa.encryptHex(value, KeyType.PublicKey); } else { @@ -68,7 +68,7 @@ public class RsaEncryptor implements IEncryptor { */ @Override public String decrypt(String value, EncodeType encodeType) throws Exception { - if(ObjectUtil.isNotNull(this.rsa)) { + if (ObjectUtil.isNotNull(this.rsa)) { return this.rsa.decryptStr(value, KeyType.PrivateKey); } return value; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java index 89c30246b..7e3727253 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java @@ -48,7 +48,7 @@ public class Sm2Encryptor implements IEncryptor { */ @Override public String encrypt(String value, EncodeType encodeType) throws Exception { - if(ObjectUtil.isNotNull(this.sm2)) { + if (ObjectUtil.isNotNull(this.sm2)) { if (encodeType == EncodeType.HEX) { return sm2.encryptHex(value, KeyType.PublicKey); } else { @@ -70,7 +70,7 @@ public class Sm2Encryptor implements IEncryptor { */ @Override public String decrypt(String value, EncodeType encodeType) throws Exception { - if(ObjectUtil.isNotNull(this.sm2)) { + if (ObjectUtil.isNotNull(this.sm2)) { return this.sm2.decryptStr(value, KeyType.PrivateKey); } return value; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java index 248e9874d..f028e90fc 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java @@ -47,7 +47,7 @@ public class Sm4Encryptor implements IEncryptor { */ @Override public String encrypt(String value, EncodeType encodeType) throws Exception { - if(ObjectUtil.isNotNull(this.sm4)) { + if (ObjectUtil.isNotNull(this.sm4)) { if (encodeType == EncodeType.HEX) { return sm4.encryptHex(value); } else { @@ -69,7 +69,7 @@ public class Sm4Encryptor implements IEncryptor { */ @Override public String decrypt(String value, EncodeType encodeType) throws Exception { - if(ObjectUtil.isNotNull(this.sm4)) { + if (ObjectUtil.isNotNull(this.sm4)) { return this.sm4.decryptStr(value); } return value; From 3fd825cf0c74d89d8df107fefd03bd0f981144d3 Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Mon, 16 Jan 2023 16:38:08 +0800 Subject: [PATCH 3/9] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=A6=82=E4=B8=8B?= =?UTF-8?q?=EF=BC=9A=201.=E9=BB=98=E8=AE=A4=E5=8A=A0=E5=AF=86=E7=AE=97?= =?UTF-8?q?=E6=B3=95=E4=BF=AE=E6=94=B9=E4=B8=BABase64=EF=BC=8C=E5=B9=B6?= =?UTF-8?q?=E4=B8=94=E9=BB=98=E8=AE=A4=E5=85=B3=E9=97=AD=E8=AF=A5=E5=8A=9F?= =?UTF-8?q?=E8=83=BD=202.=E5=8A=A0=E5=AF=86=E9=85=8D=E7=BD=AE=E7=B1=BB?= =?UTF-8?q?=E4=B8=AD=E7=9A=84=E6=B3=A8=E8=A7=A3=E7=A7=BB=E5=88=B0=E7=B1=BB?= =?UTF-8?q?=E4=B8=8A=203.=E9=94=99=E8=AF=AF=E6=97=A5=E5=BF=97=E8=AE=B0?= =?UTF-8?q?=E5=BD=95=E9=87=87=E7=94=A8=E6=97=A5=E5=BF=97=E6=A1=86=E6=9E=B6?= =?UTF-8?q?=E6=9D=A5=E5=A4=84=E7=90=86=E5=BC=82=E5=B8=B8=E5=86=85=E5=AE=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ruoyi-admin/src/main/resources/application.yml | 8 ++++---- .../com/ruoyi/common/annotation/EncryptField.java | 2 +- .../ruoyi/framework/config/EncryptorConfig.java | 14 +++++++++++++- .../ruoyi/framework/encrypt/EncryptorManager.java | 2 +- .../encrypt/MybatisDecryptInterceptor.java | 12 +++++------- .../encrypt/MybatisEncryptInterceptor.java | 7 +------ 6 files changed, 25 insertions(+), 20 deletions(-) diff --git a/ruoyi-admin/src/main/resources/application.yml b/ruoyi-admin/src/main/resources/application.yml index 5b5a31423..8eee2bdc2 100644 --- a/ruoyi-admin/src/main/resources/application.yml +++ b/ruoyi-admin/src/main/resources/application.yml @@ -186,16 +186,16 @@ mybatis-plus: # 数据加密 mybatis-encryptor: # 是否开启加密 - enabled: true + enabled: false # 默认加密算法 - algorithm: aes + algorithm: base64 # 安全秘钥。对称算法的秘钥。如：AES，SM4 - password: QBcc3SHK2G4ijyfl5XQ7@2g!N2j2jRDR +# password: QBcc3SHK2G4ijyfl5XQ7@2g!N2j2jRDR # # 公私钥。非对称算法的公私钥，如：SM2，RSA # publicKey: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCDt41GIcWvY6/tpjOLoWY78Oy00uWcNbMRG/8DRoS79/h2D+pV8uxV+0ezaN+fBFCZnK8TdJcPeU4EnNRUh/8HEY33KFvZ700n+Gj5BHUUDKzx3UVFNuF49UI/yoJ8rz6VQQHO79KK89VwmSMO77Tfee1ofe0STY6IwMt/MwaoKwIDAQAB # privateKey: MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIO3jUYhxa9jr+2mM4uhZjvw7LTS5Zw1sxEb/wNGhLv3+HYP6lXy7FX7R7No358EUJmcrxN0lw95TgSc1FSH/wcRjfcoW9nvTSf4aPkEdRQMrPHdRUU24Xj1Qj/KgnyvPpVBAc7v0orz1XCZIw7vtN957Wh97RJNjojAy38zBqgrAgMBAAECgYAkXx4qvI6rFNryw88+Am6JpMioUghHb2ioE9QCYomqohnA+DocS71JLN8qwo3lijp7gJGzzKEeC8Aoc+oKAZfBQQwPP0K/ql+NcLdlqNAr+XyzkZrLJD/BfluQ6mXI23tjonWnPPZ1Et9HC3zXRQPiuh7Ff6UoqatTMI3OIbSyuQJBAPbaJpVYmIsWJdpvaAC6hcGgR/vbG9yX8VphPn8/2wsm2MmQrRkUoKkudE/veX3KQjGikDwo9+bT6aBl+nn2DUUCQQCImSGZFNcGqhMLyRGVogP6fh0YZSEQAhFbZ69nQmplqbie+dREhODH5Vs5F0C2aL5iSR/UaIDkNEA1auX7x56vAkAFWjON927PTTqi4tmBconl6eDFsDmJbe34xLUDM1I/iqcWr8FhEtZs9Knm9c1PkewfgWPZOhYt9hhRtwRYUqJ1AkAPvQ0I9US9KNVe80DKa8tnjiZODEDd9k8HqA+mpxlZM0/pSUGyz1iSz5NOJaa4HaNp8aDwOUY4hOis/u8Wrm5TAkEA00YeUsaXlMyMF/5pjols44tXb54AjAC2mH66pz9JsKg7pKpWVOpEV5rMY58CGZHWau69vGLZnCd1coeMw77YAQ== # # 编码方式，base64/hex。默认base64 - encode: base64 +# encode: base64 # Swagger配置 swagger: diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java b/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java index 9cb9596f7..d44eb293c 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/annotation/EncryptField.java @@ -19,7 +19,7 @@ public @interface EncryptField { /** * 加密算法 */ - AlgorithmType algorithm() default AlgorithmType.AES; + AlgorithmType algorithm() default AlgorithmType.BASE64; /** * 秘钥。AES、SM4需要 diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java index ebc23241d..7d5d21a76 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/config/EncryptorConfig.java @@ -2,6 +2,8 @@ package com.ruoyi.framework.config; import com.ruoyi.framework.config.properties.EncryptorProperties; import com.ruoyi.framework.encrypt.EncryptorManager; +import com.ruoyi.framework.encrypt.MybatisDecryptInterceptor; +import com.ruoyi.framework.encrypt.MybatisEncryptInterceptor; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @@ -13,13 +15,23 @@ import org.springframework.context.annotation.Configuration; * @date 2023-01-11 10:03 */ @Configuration +@ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") public class EncryptorConfig { @Bean - @ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") public EncryptorManager mybatisCryptHandler(EncryptorProperties properties) { EncryptorManager encryptorManager = new EncryptorManager(); encryptorManager.registAndGetEncryptor(properties); return encryptorManager; } + + @Bean + public MybatisEncryptInterceptor mybatisEncryptInterceptor(EncryptorProperties properties) { + return new MybatisEncryptInterceptor(); + } + + @Bean + public MybatisDecryptInterceptor mybatisDecryptInterceptor(EncryptorProperties properties) { + return new MybatisDecryptInterceptor(); + } } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java index 0f269a589..0221a1ef5 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java @@ -53,7 +53,7 @@ public class EncryptorManager { encryptorMap.put(encryptorKey, new Sm4Encryptor(properties.getPassword())); break; default: - AesEncryptor defaultEncryptor = new AesEncryptor(properties.getPassword()); + Base64Encryptor defaultEncryptor = new Base64Encryptor(); encryptorMap.put(encryptorKey, defaultEncryptor); } return encryptorMap.get(encryptorKey); diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java index e1e5efb0d..6d99f09c3 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java @@ -1,7 +1,6 @@ package com.ruoyi.framework.encrypt; import cn.hutool.core.collection.CollectionUtil; -import cn.hutool.core.exceptions.ExceptionUtil; import com.ruoyi.common.annotation.EncryptField; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.common.utils.spring.SpringUtils; @@ -9,12 +8,13 @@ import com.ruoyi.framework.config.properties.EncryptorProperties; import lombok.extern.slf4j.Slf4j; import org.apache.ibatis.executor.resultset.ResultSetHandler; import org.apache.ibatis.plugin.*; -import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; -import org.springframework.stereotype.Component; import java.lang.reflect.Field; import java.sql.Statement; -import java.util.*; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Set; /** * 出参解密拦截器 @@ -28,8 +28,6 @@ import java.util.*; method = "handleResultSets", args = {Statement.class}) }) -@ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") -@Component public class MybatisDecryptInterceptor implements Interceptor { private final EncryptorManager encryptorManager = SpringUtils.getBean(EncryptorManager.class); @@ -71,7 +69,7 @@ public class MybatisDecryptInterceptor implements Interceptor { field.set(sourceObject, this.decryptField(String.valueOf(field.get(sourceObject)), field)); } } catch (Exception e) { - log.error("处理加密字段时出错：{}", ExceptionUtil.getSimpleMessage(e)); + log.error("处理解密字段时出错", e); } } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java index b3afc187c..a8334f46f 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java @@ -1,7 +1,6 @@ package com.ruoyi.framework.encrypt; import cn.hutool.core.collection.CollectionUtil; -import cn.hutool.core.exceptions.ExceptionUtil; import cn.hutool.core.util.ObjectUtil; import com.ruoyi.common.annotation.EncryptField; import com.ruoyi.common.utils.StringUtils; @@ -13,8 +12,6 @@ import org.apache.ibatis.plugin.Interceptor; import org.apache.ibatis.plugin.Intercepts; import org.apache.ibatis.plugin.Invocation; import org.apache.ibatis.plugin.Signature; -import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; -import org.springframework.stereotype.Component; import java.lang.reflect.Field; import java.sql.PreparedStatement; @@ -35,8 +32,6 @@ import java.util.Set; method = "setParameters", args = {PreparedStatement.class}) }) -@ConditionalOnProperty(value = "mybatis-encryptor.enabled", havingValue = "true") -@Component public class MybatisEncryptInterceptor implements Interceptor { private final EncryptorManager encryptorManager = SpringUtils.getBean(EncryptorManager.class); @@ -85,7 +80,7 @@ public class MybatisEncryptInterceptor implements Interceptor { field.set(sourceObject, this.encryptField(String.valueOf(field.get(sourceObject)), field)); } } catch (Exception e) { - log.error("处理加密字段时出错：{}", ExceptionUtil.getSimpleMessage(e)); + log.error("处理加密字段时出错", e); } } From 3969ccff8c4325432238421be879359280031848 Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Tue, 17 Jan 2023 11:11:27 +0800 Subject: [PATCH 4/9] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=A6=82=E4=B8=8B?= =?UTF-8?q?=EF=BC=9A=201.EncryptorManager=E4=BF=AE=E6=94=B9=E4=B8=BA?= =?UTF-8?q?=E9=87=87=E7=94=A8=E5=8F=8D=E5=B0=84=E5=88=9B=E5=BB=BA=E7=B1=BB?= =?UTF-8?q?=202.IEncryptor=E6=8E=A5=E5=8F=A3=E4=B8=AD=E5=A2=9E=E5=8A=A0?= =?UTF-8?q?=E5=88=9D=E5=A7=8B=E5=8C=96=E6=96=B9=E6=B3=95=203.=E5=A2=9E?= =?UTF-8?q?=E5=8A=A0=E5=8A=A0=E5=AF=86=E4=B8=8A=E4=B8=8B=E6=96=87=E5=AF=B9?= =?UTF-8?q?=E8=B1=A1=E7=94=A8=E6=9D=A5=E9=9A=94=E7=A6=BB=E6=89=B9=E6=B3=A8?= =?UTF-8?q?=E5=92=8C=E9=85=8D=E7=BD=AE=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ruoyi/common/encrypt/EncryptContext.java | 34 +++++++++++++++++++ .../com/ruoyi/common/encrypt/IEncryptor.java | 10 ++++++ .../com/ruoyi/common/enums/AlgorithmType.java | 12 +++---- .../com/ruoyi/common/enums/EncodeType.java | 10 ++---- .../java/com/ruoyi/demo/domain/TestDemo.java | 4 ++- .../framework/encrypt/EncryptorManager.java | 32 ++++++----------- .../encrypt/encryptor/AesEncryptor.java | 28 ++++++++++++--- .../encrypt/encryptor/Base64Encryptor.java | 13 +++++++ .../encrypt/encryptor/RsaEncryptor.java | 24 ++++++++++--- .../encrypt/encryptor/Sm2Encryptor.java | 24 ++++++++++--- .../encrypt/encryptor/Sm4Encryptor.java | 27 ++++++++++++--- 11 files changed, 166 insertions(+), 52 deletions(-) create mode 100644 ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java new file mode 100644 index 000000000..c74914095 --- /dev/null +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java @@ -0,0 +1,34 @@ +package com.ruoyi.common.encrypt; + +import com.ruoyi.common.enums.EncodeType; +import lombok.Data; + +/** + * 加密上下文。用于encryptor传递必要的参数。 + * 隔离配置和注解 + * + * @author 老马 + * @date 2023-01-17 08:31 + */ +@Data +public class EncryptContext { + /** + * 安全秘钥 + */ + private String password; + + /** + * 公钥 + */ + private String publicKey; + + /** + * 私钥 + */ + private String privateKey; + + /** + * 编码方式，base64/hex + */ + private EncodeType encode; +} diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java index fae0327c1..946d55121 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java @@ -20,6 +20,16 @@ public interface IEncryptor { */ AlgorithmType algorithm(); + /** + * 初始化加密者 + * + * @param context 加密上下文 + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/17 09:01 + */ + void init(EncryptContext context) throws Exception; + /** * 加密 * diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java index 610658fa9..8d99e5cec 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java @@ -14,27 +14,27 @@ public enum AlgorithmType { /** * base64 */ - BASE64("base64"), + BASE64("com.ruoyi.framework.encrypt.encryptor.Base64Encryptor"), /** * aes */ - AES("aes"), + AES("com.ruoyi.framework.encrypt.encryptor.AesEncryptor"), /** * rsa */ - RSA("rsa"), + RSA("com.ruoyi.framework.encrypt.encryptor.RsaEncryptor"), /** * sm2 */ - SM2("sm2"), + SM2("com.ruoyi.framework.encrypt.encryptor.Sm2Encryptor"), /** * sm4 */ - SM4("sm4"); + SM4("com.ruoyi.framework.encrypt.encryptor.Sm4Encryptor"); - private final String algorithm; + private final String clazz; } diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/enums/EncodeType.java b/ruoyi-common/src/main/java/com/ruoyi/common/enums/EncodeType.java index da50773b1..24cdab63a 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/enums/EncodeType.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/enums/EncodeType.java @@ -1,26 +1,20 @@ package com.ruoyi.common.enums; -import lombok.AllArgsConstructor; -import lombok.Getter; - /** * 编码类型 * * @author 老马 * @date 2023-01-11 11:39 */ -@Getter -@AllArgsConstructor public enum EncodeType { /** * base64编码 */ - BASE64("base64"), + BASE64, /** * 16进制编码 */ - HEX("hex"); + HEX; - private final String encode; } diff --git a/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java b/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java index 66c2b365e..e32843a44 100644 --- a/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java +++ b/ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java @@ -46,12 +46,14 @@ public class TestDemo extends BaseEntity { /** * key键 */ - @EncryptField(algorithm=AlgorithmType.SM2, privateKey = "MIGTAgEAMBMGByqGSM49AgEGCCqBHM9VAYItBHkwdwIBAQQgZSlOvw8FBiH+aFJWLYZP/VRjg9wjfRarTkGBZd/T3N+gCgYIKoEcz1UBgi2hRANCAAR5DGuQwJqkxnbCsP+iPSDoHWIF4RwcR5EsSvT8QPxO1wRkR2IhCkzvRb32x2CUgJFdvoqVqfApFDPZzShqzBwX", publicKey = "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEeQxrkMCapMZ2wrD/oj0g6B1iBeEcHEeRLEr0/ED8TtcEZEdiIQpM70W99sdglICRXb6KlanwKRQz2c0oaswcFw==") +// @EncryptField(algorithm=AlgorithmType.SM2, privateKey = "MIGTAgEAMBMGByqGSM49AgEGCCqBHM9VAYItBHkwdwIBAQQgZSlOvw8FBiH+aFJWLYZP/VRjg9wjfRarTkGBZd/T3N+gCgYIKoEcz1UBgi2hRANCAAR5DGuQwJqkxnbCsP+iPSDoHWIF4RwcR5EsSvT8QPxO1wRkR2IhCkzvRb32x2CUgJFdvoqVqfApFDPZzShqzBwX", publicKey = "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEeQxrkMCapMZ2wrD/oj0g6B1iBeEcHEeRLEr0/ED8TtcEZEdiIQpM70W99sdglICRXb6KlanwKRQz2c0oaswcFw==") + @EncryptField(algorithm = AlgorithmType.RSA, privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBANBBEeueWlXlkkj2+WY5l+IWe42d8b5K28g+G/CFKC/yYAEHtqGlCsBOrb+YBkG9mPzmuYA/n9k0NFIc8E8yY5vZQaroyFBrTTWEzG9RY2f7Y3svVyybs6jpXSUs4xff8abo7wL1Y/wUaeatTViamxYnyTvdTmLm3d+JjRij68rxAgMBAAECgYAB0TnhXraSopwIVRfmboea1b0upl+BUdTJcmci412UjrKr5aE695ZLPkXbFXijVu7HJlyyv94NVUdaMACV7Ku/S2RuNB70M7YJm8rAjHFC3/i2ZeIM60h1Ziy4QKv0XM3pRATlDCDNhC1WUrtQCQSgU8kcp6eUUppruOqDzcY04QJBAPm9+sBP9CwDRgy3e5+V8aZtJkwDstb0lVVV/KY890cydVxiCwvX3fqVnxKMlb+x0YtH0sb9v+71xvK2lGobaRECQQDVePU6r/cCEfpc+nkWF6osAH1f8Mux3rYv2DoBGvaPzV2BGfsLed4neRfCwWNCKvGPCdW+L0xMJg8+RwaoBUPhAkAT5kViqXxFPYWJYd1h2+rDXhMdH3ZSlm6HvDBDdrwlWinr0Iwcx3iSjPV93uHXwm118aUj4fg3LDJMCKxOwBxhAkByrQXfvwOMYygBprRBf/j0plazoWFrbd6lGR0f1uI5IfNnFRPdeFw1DEINZ2Hw+6zEUF44SqRMC+4IYJNc02dBAkBCgy7RvfyV/A7N6kKXxTHauY0v6XwSSvpeKtRJkbIcRWOdIYvaHO9L7cklj3vIEdwjSUp9K4VTBYYlmAz1xh03", publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDQQRHrnlpV5ZJI9vlmOZfiFnuNnfG+StvIPhvwhSgv8mABB7ahpQrATq2/mAZBvZj85rmAP5/ZNDRSHPBPMmOb2UGq6MhQa001hMxvUWNn+2N7L1csm7Oo6V0lLOMX3/Gm6O8C9WP8FGnmrU1YmpsWJ8k73U5i5t3fiY0Yo+vK8QIDAQAB") private String testKey; /** * 值 */ + //@EncryptField(algorithm = AlgorithmType.SM4, password = "10rfylhtccpuyke5") @EncryptField(algorithm = AlgorithmType.AES, password = "10rfylhtccpuyke5") private String value; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java index 0221a1ef5..bf9b1ddcd 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java @@ -1,9 +1,11 @@ package com.ruoyi.framework.encrypt; +import cn.hutool.core.util.ReflectUtil; +import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; +import com.ruoyi.common.utils.BeanCopyUtils; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.framework.config.properties.EncryptorProperties; -import com.ruoyi.framework.encrypt.encryptor.*; import lombok.extern.slf4j.Slf4j; import java.util.Map; @@ -36,26 +38,14 @@ public class EncryptorManager { if (encryptorMap.containsKey(encryptorKey)) { return encryptorMap.get(encryptorKey); } - switch (properties.getAlgorithm()) { - case BASE64: - encryptorMap.put(encryptorKey, new Base64Encryptor()); - break; - case AES: - encryptorMap.put(encryptorKey, new AesEncryptor(properties.getPassword())); - break; - case RSA: - encryptorMap.put(encryptorKey, new RsaEncryptor(properties.getPrivateKey(), properties.getPublicKey())); - break; - case SM2: - encryptorMap.put(encryptorKey, new Sm2Encryptor(properties.getPrivateKey(), properties.getPublicKey())); - break; - case SM4: - encryptorMap.put(encryptorKey, new Sm4Encryptor(properties.getPassword())); - break; - default: - Base64Encryptor defaultEncryptor = new Base64Encryptor(); - encryptorMap.put(encryptorKey, defaultEncryptor); + EncryptContext encryptContext = BeanCopyUtils.copy(properties, EncryptContext.class); + IEncryptor encryptor = ReflectUtil.newInstance(properties.getAlgorithm().getClazz()); + try { + encryptor.init(encryptContext); + } catch (Exception e) { + log.error("加密执行者注册失败。", e); } + encryptorMap.put(encryptorKey, encryptor); return encryptorMap.get(encryptorKey); } @@ -118,7 +108,7 @@ public class EncryptorManager { * @date 2023/1/11 17:39 */ private String getEncryptorKeyFromProperties(EncryptorProperties properties) { - return properties.getAlgorithm().getAlgorithm() + StringUtils.defaultString(properties.getPassword()) + + return properties.getAlgorithm() + StringUtils.defaultString(properties.getPassword()) + StringUtils.defaultString(properties.getPublicKey()) + StringUtils.defaultString(properties.getPrivateKey()); } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java index d3efa2444..8b343a559 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java @@ -1,8 +1,11 @@ package com.ruoyi.framework.encrypt.encryptor; +import cn.hutool.core.util.ArrayUtil; import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.util.StrUtil; import cn.hutool.crypto.SecureUtil; import cn.hutool.crypto.symmetric.AES; +import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; @@ -19,10 +22,6 @@ public class AesEncryptor implements IEncryptor { private AES aes = null; - public AesEncryptor(String password) { - aes = SecureUtil.aes(password.getBytes(StandardCharsets.UTF_8)); - } - /** * 获得当前算法 * @@ -35,6 +34,27 @@ public class AesEncryptor implements IEncryptor { return AlgorithmType.AES; } + /** + * 初始化加密者 + * + * @param context 加密上下文 + * @author 老马 + * @date 2023/1/17 09:01 + */ + @Override + public void init(EncryptContext context) throws Exception { + String password = context.getPassword(); + if (StrUtil.isBlank(password)) { + throw new RuntimeException("aes没有获得秘钥信息"); + } + // aes算法的秘钥要求是16位、24位、32位 + int[] array = {16, 24, 32}; + if(!ArrayUtil.contains(array, password.length())) { + throw new RuntimeException("aes秘钥长度应该为16位、24位、32位，实际为"+password.length()+"位"); + } + aes = SecureUtil.aes(context.getPassword().getBytes(StandardCharsets.UTF_8)); + } + /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java index aee34efaf..54b7a3ddd 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java @@ -1,6 +1,7 @@ package com.ruoyi.framework.encrypt.encryptor; import cn.hutool.core.codec.Base64; +import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; @@ -24,6 +25,18 @@ public class Base64Encryptor implements IEncryptor { return AlgorithmType.BASE64; } + /** + * 初始化加密者 + * + * @param context 加密上下文 + * @author 老马 + * @date 2023/1/17 09:01 + */ + @Override + public void init(EncryptContext context) { + // 无需初始化 + } + /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java index 4b0eea799..573c9e809 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java @@ -5,9 +5,11 @@ import cn.hutool.core.util.ObjectUtil; import cn.hutool.crypto.SecureUtil; import cn.hutool.crypto.asymmetric.KeyType; import cn.hutool.crypto.asymmetric.RSA; +import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; +import com.ruoyi.common.utils.StringUtils; /** @@ -20,10 +22,6 @@ public class RsaEncryptor implements IEncryptor { private RSA rsa = null; - public RsaEncryptor(String privateKey, String publicKey) { - this.rsa = SecureUtil.rsa(Base64.decode(privateKey), Base64.decode(publicKey)); - } - /** * 获得当前算法 * @@ -36,6 +34,24 @@ public class RsaEncryptor implements IEncryptor { return AlgorithmType.RSA; } + /** + * 初始化加密者 + * + * @param context 加密上下文 + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/17 09:01 + */ + @Override + public void init(EncryptContext context) throws Exception { + String privateKey = context.getPrivateKey(); + String publicKey = context.getPublicKey(); + if (StringUtils.isAnyEmpty(privateKey, publicKey)) { + throw new RuntimeException("rsa公私钥均需要提供，公钥加密，私钥解密。"); + } + this.rsa = SecureUtil.rsa(Base64.decode(privateKey), Base64.decode(publicKey)); + } + /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java index 7e3727253..5ecae00bc 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java @@ -6,9 +6,11 @@ import cn.hutool.core.util.ObjectUtil; import cn.hutool.crypto.SmUtil; import cn.hutool.crypto.asymmetric.KeyType; import cn.hutool.crypto.asymmetric.SM2; +import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; +import com.ruoyi.common.utils.StringUtils; /** * sm2算法实现 @@ -20,10 +22,6 @@ public class Sm2Encryptor implements IEncryptor { private SM2 sm2 = null; - public Sm2Encryptor(String privateKey, String publicKey) { - sm2 = SmUtil.sm2(Base64.decode(privateKey), Base64.decode(publicKey)); - } - /** * 获得当前算法 * @@ -36,6 +34,24 @@ public class Sm2Encryptor implements IEncryptor { return AlgorithmType.SM2; } + /** + * 初始化加密者 + * + * @param context 加密上下文 + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/17 09:01 + */ + @Override + public void init(EncryptContext context) throws Exception { + String privateKey = context.getPrivateKey(); + String publicKey = context.getPublicKey(); + if (StringUtils.isAnyEmpty(privateKey, publicKey)) { + throw new RuntimeException("sm2公私钥均需要提供，公钥加密，私钥解密。"); + } + this.sm2 = SmUtil.sm2(Base64.decode(privateKey), Base64.decode(publicKey)); + } + /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java index f028e90fc..1b83a0464 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java @@ -1,8 +1,10 @@ package com.ruoyi.framework.encrypt.encryptor; import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.util.StrUtil; import cn.hutool.crypto.SmUtil; import cn.hutool.crypto.symmetric.SM4; +import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; @@ -19,10 +21,6 @@ public class Sm4Encryptor implements IEncryptor { private SM4 sm4 = null; - public Sm4Encryptor(String password) { - this.sm4 = SmUtil.sm4(password.getBytes(StandardCharsets.UTF_8)); - } - /** * 获得当前算法 * @@ -35,6 +33,27 @@ public class Sm4Encryptor implements IEncryptor { return AlgorithmType.SM4; } + /** + * 初始化加密者 + * + * @param context 加密上下文 + * @throws Exception 抛出异常 + * @author 老马 + * @date 2023/1/17 09:01 + */ + @Override + public void init(EncryptContext context) throws Exception { + String password = context.getPassword(); + if (StrUtil.isBlank(password)) { + throw new RuntimeException("sm4没有获得秘钥信息"); + } + // sm4算法的秘钥要求是16位长度 + if (16 != password.length()) { + throw new RuntimeException("sm4秘钥长度应该为16位，实际为" + password.length() + "位"); + } + this.sm4 = SmUtil.sm4(password.getBytes(StandardCharsets.UTF_8)); + } + /** * 加密 * From f688f1570ede3f6e3226d1aee58bfeca368875b1 Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Tue, 17 Jan 2023 17:31:15 +0800 Subject: [PATCH 5/9] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=A6=82=E4=B8=8B?= =?UTF-8?q?=EF=BC=9A=201.=E6=B7=B1=E6=8B=B7=E8=B4=9D=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E4=B8=BAset=E5=BD=A2=E5=BC=8F=202.=E5=8A=A0=E5=AF=86=E6=89=A7?= =?UTF-8?q?=E8=A1=8C=E8=80=85=E4=BB=8E=E5=9F=BA=E7=B1=BB=E7=BB=A7=E6=89=BF?= =?UTF-8?q?=EF=BC=8C=E5=BC=BA=E5=88=B6=E6=9E=84=E9=80=A0=E6=96=B9=E6=B3=95?= =?UTF-8?q?=E5=B8=A6=E5=8F=82=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ruoyi/common/encrypt/EncryptContext.java | 2 + .../com/ruoyi/common/encrypt/IEncryptor.java | 10 ----- .../framework/encrypt/EncryptorManager.java | 28 +++++++++++--- .../encrypt/encryptor/AbstractEncryptor.java | 16 ++++++++ .../encrypt/encryptor/AesEncryptor.java | 38 ++++++++----------- .../encrypt/encryptor/Base64Encryptor.java | 20 +++------- .../encrypt/encryptor/RsaEncryptor.java | 31 ++++++--------- .../encrypt/encryptor/Sm2Encryptor.java | 31 ++++++--------- .../encrypt/encryptor/Sm4Encryptor.java | 37 +++++++----------- 9 files changed, 97 insertions(+), 116 deletions(-) create mode 100644 ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AbstractEncryptor.java diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java index c74914095..2a1543ae8 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java @@ -1,6 +1,7 @@ package com.ruoyi.common.encrypt; import com.ruoyi.common.enums.EncodeType; +import lombok.Builder; import lombok.Data; /** @@ -11,6 +12,7 @@ import lombok.Data; * @date 2023-01-17 08:31 */ @Data +@Builder public class EncryptContext { /** * 安全秘钥 diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java index 946d55121..fae0327c1 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/IEncryptor.java @@ -20,16 +20,6 @@ public interface IEncryptor { */ AlgorithmType algorithm(); - /** - * 初始化加密者 - * - * @param context 加密上下文 - * @throws Exception 抛出异常 - * @author 老马 - * @date 2023/1/17 09:01 - */ - void init(EncryptContext context) throws Exception; - /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java index bf9b1ddcd..aaa0105ea 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java @@ -1,11 +1,12 @@ package com.ruoyi.framework.encrypt; +import cn.hutool.core.util.ObjectUtil; import cn.hutool.core.util.ReflectUtil; import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; -import com.ruoyi.common.utils.BeanCopyUtils; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.framework.config.properties.EncryptorProperties; +import jodd.util.ClassLoaderUtil; import lombok.extern.slf4j.Slf4j; import java.util.Map; @@ -38,13 +39,22 @@ public class EncryptorManager { if (encryptorMap.containsKey(encryptorKey)) { return encryptorMap.get(encryptorKey); } - EncryptContext encryptContext = BeanCopyUtils.copy(properties, EncryptContext.class); - IEncryptor encryptor = ReflectUtil.newInstance(properties.getAlgorithm().getClazz()); + EncryptContext encryptContext = EncryptContext.builder() + .password(properties.getPassword()) + .privateKey(properties.getPrivateKey()) + .publicKey(properties.getPublicKey()) + .encode(properties.getEncode()) + .build(); + Class clazz = null; try { - encryptor.init(encryptContext); - } catch (Exception e) { - log.error("加密执行者注册失败。", e); + clazz = ClassLoaderUtil.loadClass(properties.getAlgorithm().getClazz()); + } catch (ClassNotFoundException e) { + log.error("没有找到配置中指定的加密执行者", e); } + if(ObjectUtil.isNull(clazz)) { + return null; + } + IEncryptor encryptor = ReflectUtil.newInstance(clazz, encryptContext); encryptorMap.put(encryptorKey, encryptor); return encryptorMap.get(encryptorKey); } @@ -72,6 +82,9 @@ public class EncryptorManager { public String encrypt(String value, EncryptorProperties properties) { try { IEncryptor encryptor = this.registAndGetEncryptor(properties); + if(ObjectUtil.isNull(encryptor)){ + return value; + } return encryptor.encrypt(value, properties.getEncode()); } catch (Exception e) { log.error("字段加密异常,原样返回", e); @@ -91,6 +104,9 @@ public class EncryptorManager { public String decrypt(String value, EncryptorProperties properties) { try { IEncryptor encryptor = this.registAndGetEncryptor(properties); + if(ObjectUtil.isNull(encryptor)){ + return value; + } return encryptor.decrypt(value, properties.getEncode()); } catch (Exception e) { log.error("字段解密异常,原样返回", e); diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AbstractEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AbstractEncryptor.java new file mode 100644 index 000000000..16f898646 --- /dev/null +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AbstractEncryptor.java @@ -0,0 +1,16 @@ +package com.ruoyi.framework.encrypt.encryptor; + +import com.ruoyi.common.encrypt.EncryptContext; +import com.ruoyi.common.encrypt.IEncryptor; + +/** + * 所有加密执行者的基类 + * + * @author 老马 + * @date 2023-01-17 16:52 + */ +public abstract class AbstractEncryptor implements IEncryptor { + public AbstractEncryptor(EncryptContext context) throws Exception{ + //子类必须实现带参数的构造方法 + } +} diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java index 8b343a559..8b52a60f2 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java @@ -6,7 +6,6 @@ import cn.hutool.core.util.StrUtil; import cn.hutool.crypto.SecureUtil; import cn.hutool.crypto.symmetric.AES; import com.ruoyi.common.encrypt.EncryptContext; -import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; @@ -18,10 +17,24 @@ import java.nio.charset.StandardCharsets; * @author 老马 * @date 2023-01-06 11:39 */ -public class AesEncryptor implements IEncryptor { +public class AesEncryptor extends AbstractEncryptor { private AES aes = null; + public AesEncryptor(EncryptContext context) throws Exception{ + super(context); + String password = context.getPassword(); + if (StrUtil.isBlank(password)) { + throw new RuntimeException("aes没有获得秘钥信息"); + } + // aes算法的秘钥要求是16位、24位、32位 + int[] array = {16, 24, 32}; + if(!ArrayUtil.contains(array, password.length())) { + throw new RuntimeException("aes秘钥长度应该为16位、24位、32位，实际为"+password.length()+"位"); + } + aes = SecureUtil.aes(context.getPassword().getBytes(StandardCharsets.UTF_8)); + } + /** * 获得当前算法 * @@ -34,27 +47,6 @@ public class AesEncryptor implements IEncryptor { return AlgorithmType.AES; } - /** - * 初始化加密者 - * - * @param context 加密上下文 - * @author 老马 - * @date 2023/1/17 09:01 - */ - @Override - public void init(EncryptContext context) throws Exception { - String password = context.getPassword(); - if (StrUtil.isBlank(password)) { - throw new RuntimeException("aes没有获得秘钥信息"); - } - // aes算法的秘钥要求是16位、24位、32位 - int[] array = {16, 24, 32}; - if(!ArrayUtil.contains(array, password.length())) { - throw new RuntimeException("aes秘钥长度应该为16位、24位、32位，实际为"+password.length()+"位"); - } - aes = SecureUtil.aes(context.getPassword().getBytes(StandardCharsets.UTF_8)); - } - /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java index 54b7a3ddd..34e895966 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java @@ -2,7 +2,6 @@ package com.ruoyi.framework.encrypt.encryptor; import cn.hutool.core.codec.Base64; import com.ruoyi.common.encrypt.EncryptContext; -import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; @@ -12,7 +11,12 @@ import com.ruoyi.common.enums.EncodeType; * @author 老马 * @date 2023-01-06 10:00 */ -public class Base64Encryptor implements IEncryptor { +public class Base64Encryptor extends AbstractEncryptor { + + public Base64Encryptor(EncryptContext context) throws Exception { + super(context); + } + /** * 获得当前算法 * @@ -25,18 +29,6 @@ public class Base64Encryptor implements IEncryptor { return AlgorithmType.BASE64; } - /** - * 初始化加密者 - * - * @param context 加密上下文 - * @author 老马 - * @date 2023/1/17 09:01 - */ - @Override - public void init(EncryptContext context) { - // 无需初始化 - } - /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java index 573c9e809..a12af5a26 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java @@ -6,7 +6,6 @@ import cn.hutool.crypto.SecureUtil; import cn.hutool.crypto.asymmetric.KeyType; import cn.hutool.crypto.asymmetric.RSA; import com.ruoyi.common.encrypt.EncryptContext; -import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; import com.ruoyi.common.utils.StringUtils; @@ -18,10 +17,20 @@ import com.ruoyi.common.utils.StringUtils; * @author 老马 * @date 2023-01-06 09:37 */ -public class RsaEncryptor implements IEncryptor { +public class RsaEncryptor extends AbstractEncryptor { private RSA rsa = null; + public RsaEncryptor(EncryptContext context) throws Exception { + super(context); + String privateKey = context.getPrivateKey(); + String publicKey = context.getPublicKey(); + if (StringUtils.isAnyEmpty(privateKey, publicKey)) { + throw new RuntimeException("rsa公私钥均需要提供，公钥加密，私钥解密。"); + } + this.rsa = SecureUtil.rsa(Base64.decode(privateKey), Base64.decode(publicKey)); + } + /** * 获得当前算法 * @@ -34,24 +43,6 @@ public class RsaEncryptor implements IEncryptor { return AlgorithmType.RSA; } - /** - * 初始化加密者 - * - * @param context 加密上下文 - * @throws Exception 抛出异常 - * @author 老马 - * @date 2023/1/17 09:01 - */ - @Override - public void init(EncryptContext context) throws Exception { - String privateKey = context.getPrivateKey(); - String publicKey = context.getPublicKey(); - if (StringUtils.isAnyEmpty(privateKey, publicKey)) { - throw new RuntimeException("rsa公私钥均需要提供，公钥加密，私钥解密。"); - } - this.rsa = SecureUtil.rsa(Base64.decode(privateKey), Base64.decode(publicKey)); - } - /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java index 5ecae00bc..fbbe284c8 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java @@ -7,7 +7,6 @@ import cn.hutool.crypto.SmUtil; import cn.hutool.crypto.asymmetric.KeyType; import cn.hutool.crypto.asymmetric.SM2; import com.ruoyi.common.encrypt.EncryptContext; -import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; import com.ruoyi.common.utils.StringUtils; @@ -18,10 +17,20 @@ import com.ruoyi.common.utils.StringUtils; * @author 老马 * @date 2023-01-06 17:13 */ -public class Sm2Encryptor implements IEncryptor { +public class Sm2Encryptor extends AbstractEncryptor { private SM2 sm2 = null; + public Sm2Encryptor(EncryptContext context) throws Exception { + super(context); + String privateKey = context.getPrivateKey(); + String publicKey = context.getPublicKey(); + if (StringUtils.isAnyEmpty(privateKey, publicKey)) { + throw new RuntimeException("sm2公私钥均需要提供，公钥加密，私钥解密。"); + } + this.sm2 = SmUtil.sm2(Base64.decode(privateKey), Base64.decode(publicKey)); + } + /** * 获得当前算法 * @@ -34,24 +43,6 @@ public class Sm2Encryptor implements IEncryptor { return AlgorithmType.SM2; } - /** - * 初始化加密者 - * - * @param context 加密上下文 - * @throws Exception 抛出异常 - * @author 老马 - * @date 2023/1/17 09:01 - */ - @Override - public void init(EncryptContext context) throws Exception { - String privateKey = context.getPrivateKey(); - String publicKey = context.getPublicKey(); - if (StringUtils.isAnyEmpty(privateKey, publicKey)) { - throw new RuntimeException("sm2公私钥均需要提供，公钥加密，私钥解密。"); - } - this.sm2 = SmUtil.sm2(Base64.decode(privateKey), Base64.decode(publicKey)); - } - /** * 加密 * diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java index 1b83a0464..e9b747f5b 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java @@ -5,7 +5,6 @@ import cn.hutool.core.util.StrUtil; import cn.hutool.crypto.SmUtil; import cn.hutool.crypto.symmetric.SM4; import com.ruoyi.common.encrypt.EncryptContext; -import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.enums.AlgorithmType; import com.ruoyi.common.enums.EncodeType; @@ -17,10 +16,23 @@ import java.nio.charset.StandardCharsets; * @author 老马 * @date 2023-01-06 17:40 */ -public class Sm4Encryptor implements IEncryptor { +public class Sm4Encryptor extends AbstractEncryptor { private SM4 sm4 = null; + public Sm4Encryptor(EncryptContext context) throws Exception { + super(context); + String password = context.getPassword(); + if (StrUtil.isBlank(password)) { + throw new RuntimeException("sm4没有获得秘钥信息"); + } + // sm4算法的秘钥要求是16位长度 + if (16 != password.length()) { + throw new RuntimeException("sm4秘钥长度应该为16位，实际为" + password.length() + "位"); + } + this.sm4 = SmUtil.sm4(password.getBytes(StandardCharsets.UTF_8)); + } + /** * 获得当前算法 * @@ -33,27 +45,6 @@ public class Sm4Encryptor implements IEncryptor { return AlgorithmType.SM4; } - /** - * 初始化加密者 - * - * @param context 加密上下文 - * @throws Exception 抛出异常 - * @author 老马 - * @date 2023/1/17 09:01 - */ - @Override - public void init(EncryptContext context) throws Exception { - String password = context.getPassword(); - if (StrUtil.isBlank(password)) { - throw new RuntimeException("sm4没有获得秘钥信息"); - } - // sm4算法的秘钥要求是16位长度 - if (16 != password.length()) { - throw new RuntimeException("sm4秘钥长度应该为16位，实际为" + password.length() + "位"); - } - this.sm4 = SmUtil.sm4(password.getBytes(StandardCharsets.UTF_8)); - } - /** * 加密 * From 79d90d0d738b60c7fd9ef75d299e0b0f9560428b Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Tue, 17 Jan 2023 17:52:38 +0800 Subject: [PATCH 6/9] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=A6=82=E4=B8=8B?= =?UTF-8?q?=EF=BC=9A=201.=E8=B0=83=E6=95=B4=E6=89=A7=E8=A1=8C=E8=80=85?= =?UTF-8?q?=E7=9A=84=E7=9B=AE=E5=BD=95=E7=BB=93=E6=9E=84=E4=BB=8Efw?= =?UTF-8?q?=E7=A7=BB=E5=8A=A8=E5=88=B0common=E4=B8=AD=202.=E4=BF=AE?= =?UTF-8?q?=E6=94=B9=E5=91=BD=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ruoyi/common/encrypt/EncryptContext.java | 1 - .../common}/encrypt/encryptor/AbstractEncryptor.java | 2 +- .../ruoyi/common}/encrypt/encryptor/AesEncryptor.java | 2 +- .../common}/encrypt/encryptor/Base64Encryptor.java | 2 +- .../ruoyi/common}/encrypt/encryptor/RsaEncryptor.java | 2 +- .../ruoyi/common}/encrypt/encryptor/Sm2Encryptor.java | 2 +- .../ruoyi/common}/encrypt/encryptor/Sm4Encryptor.java | 2 +- .../java/com/ruoyi/common/enums/AlgorithmType.java | 10 +++++----- ...eldsCacheHelper.java => EncryptedFieldsCache.java} | 2 +- .../com/ruoyi/framework/encrypt/EncryptorManager.java | 11 +++++------ .../framework/encrypt/MybatisDecryptInterceptor.java | 4 ++-- .../framework/encrypt/MybatisEncryptInterceptor.java | 4 ++-- 12 files changed, 21 insertions(+), 23 deletions(-) rename {ruoyi-framework/src/main/java/com/ruoyi/framework => ruoyi-common/src/main/java/com/ruoyi/common}/encrypt/encryptor/AbstractEncryptor.java (88%) rename {ruoyi-framework/src/main/java/com/ruoyi/framework => ruoyi-common/src/main/java/com/ruoyi/common}/encrypt/encryptor/AesEncryptor.java (98%) rename {ruoyi-framework/src/main/java/com/ruoyi/framework => ruoyi-common/src/main/java/com/ruoyi/common}/encrypt/encryptor/Base64Encryptor.java (96%) rename {ruoyi-framework/src/main/java/com/ruoyi/framework => ruoyi-common/src/main/java/com/ruoyi/common}/encrypt/encryptor/RsaEncryptor.java (98%) rename {ruoyi-framework/src/main/java/com/ruoyi/framework => ruoyi-common/src/main/java/com/ruoyi/common}/encrypt/encryptor/Sm2Encryptor.java (98%) rename {ruoyi-framework/src/main/java/com/ruoyi/framework => ruoyi-common/src/main/java/com/ruoyi/common}/encrypt/encryptor/Sm4Encryptor.java (98%) rename ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/{EncryptedFieldsCacheHelper.java => EncryptedFieldsCache.java} (96%) diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java index 2a1543ae8..3340ecdc1 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/EncryptContext.java @@ -12,7 +12,6 @@ import lombok.Data; * @date 2023-01-17 08:31 */ @Data -@Builder public class EncryptContext { /** * 安全秘钥 diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AbstractEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AbstractEncryptor.java similarity index 88% rename from ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AbstractEncryptor.java rename to ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AbstractEncryptor.java index 16f898646..aaea4ac33 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AbstractEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AbstractEncryptor.java @@ -1,4 +1,4 @@ -package com.ruoyi.framework.encrypt.encryptor; +package com.ruoyi.common.encrypt.encryptor; import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AesEncryptor.java similarity index 98% rename from ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java rename to ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AesEncryptor.java index 8b52a60f2..af1b14693 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/AesEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AesEncryptor.java @@ -1,4 +1,4 @@ -package com.ruoyi.framework.encrypt.encryptor; +package com.ruoyi.common.encrypt.encryptor; import cn.hutool.core.util.ArrayUtil; import cn.hutool.core.util.ObjectUtil; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Base64Encryptor.java similarity index 96% rename from ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java rename to ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Base64Encryptor.java index 34e895966..75f664217 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Base64Encryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Base64Encryptor.java @@ -1,4 +1,4 @@ -package com.ruoyi.framework.encrypt.encryptor; +package com.ruoyi.common.encrypt.encryptor; import cn.hutool.core.codec.Base64; import com.ruoyi.common.encrypt.EncryptContext; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/RsaEncryptor.java similarity index 98% rename from ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java rename to ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/RsaEncryptor.java index a12af5a26..d09abef55 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/RsaEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/RsaEncryptor.java @@ -1,4 +1,4 @@ -package com.ruoyi.framework.encrypt.encryptor; +package com.ruoyi.common.encrypt.encryptor; import cn.hutool.core.codec.Base64; import cn.hutool.core.util.ObjectUtil; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm2Encryptor.java similarity index 98% rename from ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java rename to ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm2Encryptor.java index fbbe284c8..0ed177b3c 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm2Encryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm2Encryptor.java @@ -1,4 +1,4 @@ -package com.ruoyi.framework.encrypt.encryptor; +package com.ruoyi.common.encrypt.encryptor; import cn.hutool.core.codec.Base64; diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm4Encryptor.java similarity index 98% rename from ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java rename to ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm4Encryptor.java index e9b747f5b..cf999c278 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/encryptor/Sm4Encryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm4Encryptor.java @@ -1,4 +1,4 @@ -package com.ruoyi.framework.encrypt.encryptor; +package com.ruoyi.common.encrypt.encryptor; import cn.hutool.core.util.ObjectUtil; import cn.hutool.core.util.StrUtil; diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java index 8d99e5cec..474a5ef08 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java @@ -14,27 +14,27 @@ public enum AlgorithmType { /** * base64 */ - BASE64("com.ruoyi.framework.encrypt.encryptor.Base64Encryptor"), + BASE64("com.ruoyi.common.encrypt.encryptor.Base64Encryptor"), /** * aes */ - AES("com.ruoyi.framework.encrypt.encryptor.AesEncryptor"), + AES("com.ruoyi.common.encrypt.encryptor.AesEncryptor"), /** * rsa */ - RSA("com.ruoyi.framework.encrypt.encryptor.RsaEncryptor"), + RSA("com.ruoyi.common.encrypt.encryptor.RsaEncryptor"), /** * sm2 */ - SM2("com.ruoyi.framework.encrypt.encryptor.Sm2Encryptor"), + SM2("com.ruoyi.common.encrypt.encryptor.Sm2Encryptor"), /** * sm4 */ - SM4("com.ruoyi.framework.encrypt.encryptor.Sm4Encryptor"); + SM4("com.ruoyi.common.encrypt.encryptor.Sm4Encryptor"); private final String clazz; } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCacheHelper.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCache.java similarity index 96% rename from ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCacheHelper.java rename to ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCache.java index 53b92496d..e9d2a68ab 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCacheHelper.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptedFieldsCache.java @@ -15,7 +15,7 @@ import java.util.stream.Collectors; * @author 老马 * @date 2023-01-12 11:07 */ -public class EncryptedFieldsCacheHelper { +public class EncryptedFieldsCache { private static final Map, Set> ENCRYPTED_FIELD_CACHE = new ConcurrentHashMap<>(); public static Set get(Class sourceClazz) { diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java index aaa0105ea..3faa7ea4a 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java @@ -39,12 +39,11 @@ public class EncryptorManager { if (encryptorMap.containsKey(encryptorKey)) { return encryptorMap.get(encryptorKey); } - EncryptContext encryptContext = EncryptContext.builder() - .password(properties.getPassword()) - .privateKey(properties.getPrivateKey()) - .publicKey(properties.getPublicKey()) - .encode(properties.getEncode()) - .build(); + EncryptContext encryptContext = new EncryptContext(); + encryptContext.setPassword(properties.getPassword()); + encryptContext.setPrivateKey(properties.getPrivateKey()); + encryptContext.setPublicKey(properties.getPublicKey()); + encryptContext.setEncode(properties.getEncode()); Class clazz = null; try { clazz = ClassLoaderUtil.loadClass(properties.getAlgorithm().getClazz()); diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java index 6d99f09c3..1cdb58e1f 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java @@ -57,13 +57,13 @@ public class MybatisDecryptInterceptor implements Interceptor { if (sourceObject instanceof List) { // 判断第一个元素是否含有注解。如果没有直接返回，提高效率 Object firstItem = ((List) sourceObject).get(0); - if (CollectionUtil.isEmpty(EncryptedFieldsCacheHelper.get(firstItem.getClass()))) { + if (CollectionUtil.isEmpty(EncryptedFieldsCache.get(firstItem.getClass()))) { return; } ((List) sourceObject).forEach(this::decryptHandler); return; } - Set fields = EncryptedFieldsCacheHelper.get(sourceObject.getClass()); + Set fields = EncryptedFieldsCache.get(sourceObject.getClass()); try { for (Field field : fields) { field.set(sourceObject, this.decryptField(String.valueOf(field.get(sourceObject)), field)); diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java index a8334f46f..4fd5289e0 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java @@ -68,13 +68,13 @@ public class MybatisEncryptInterceptor implements Interceptor { if (sourceObject instanceof List) { // 判断第一个元素是否含有注解。如果没有直接返回，提高效率 Object firstItem = ((List) sourceObject).get(0); - if (CollectionUtil.isEmpty(EncryptedFieldsCacheHelper.get(firstItem.getClass()))) { + if (CollectionUtil.isEmpty(EncryptedFieldsCache.get(firstItem.getClass()))) { return; } ((List) sourceObject).forEach(this::encryptHandler); return; } - Set fields = EncryptedFieldsCacheHelper.get(sourceObject.getClass()); + Set fields = EncryptedFieldsCache.get(sourceObject.getClass()); try { for (Field field : fields) { field.set(sourceObject, this.encryptField(String.valueOf(field.get(sourceObject)), field)); From 8320608cb9ed804d07f41ca0a385bdb97d1f9979 Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Tue, 17 Jan 2023 17:55:36 +0800 Subject: [PATCH 7/9] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=A6=82=E4=B8=8B?= =?UTF-8?q?=EF=BC=9A=201.=E5=8E=BB=E6=8E=89=E6=97=A0=E7=94=A8=E7=9A=84?= =?UTF-8?q?=E6=8A=9B=E5=87=BA=E5=BC=82=E5=B8=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ruoyi/common/encrypt/encryptor/AbstractEncryptor.java | 2 +- .../java/com/ruoyi/common/encrypt/encryptor/AesEncryptor.java | 2 +- .../com/ruoyi/common/encrypt/encryptor/Base64Encryptor.java | 2 +- .../java/com/ruoyi/common/encrypt/encryptor/RsaEncryptor.java | 2 +- .../java/com/ruoyi/common/encrypt/encryptor/Sm2Encryptor.java | 2 +- .../java/com/ruoyi/common/encrypt/encryptor/Sm4Encryptor.java | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AbstractEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AbstractEncryptor.java index aaea4ac33..5e7ce73d0 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AbstractEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AbstractEncryptor.java @@ -10,7 +10,7 @@ import com.ruoyi.common.encrypt.IEncryptor; * @date 2023-01-17 16:52 */ public abstract class AbstractEncryptor implements IEncryptor { - public AbstractEncryptor(EncryptContext context) throws Exception{ + public AbstractEncryptor(EncryptContext context) { //子类必须实现带参数的构造方法 } } diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AesEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AesEncryptor.java index af1b14693..f0d3a3069 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AesEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/AesEncryptor.java @@ -21,7 +21,7 @@ public class AesEncryptor extends AbstractEncryptor { private AES aes = null; - public AesEncryptor(EncryptContext context) throws Exception{ + public AesEncryptor(EncryptContext context) { super(context); String password = context.getPassword(); if (StrUtil.isBlank(password)) { diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Base64Encryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Base64Encryptor.java index 75f664217..bd5038e4b 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Base64Encryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Base64Encryptor.java @@ -13,7 +13,7 @@ import com.ruoyi.common.enums.EncodeType; */ public class Base64Encryptor extends AbstractEncryptor { - public Base64Encryptor(EncryptContext context) throws Exception { + public Base64Encryptor(EncryptContext context) { super(context); } diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/RsaEncryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/RsaEncryptor.java index d09abef55..40d767c06 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/RsaEncryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/RsaEncryptor.java @@ -21,7 +21,7 @@ public class RsaEncryptor extends AbstractEncryptor { private RSA rsa = null; - public RsaEncryptor(EncryptContext context) throws Exception { + public RsaEncryptor(EncryptContext context) { super(context); String privateKey = context.getPrivateKey(); String publicKey = context.getPublicKey(); diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm2Encryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm2Encryptor.java index 0ed177b3c..71f0620ca 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm2Encryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm2Encryptor.java @@ -21,7 +21,7 @@ public class Sm2Encryptor extends AbstractEncryptor { private SM2 sm2 = null; - public Sm2Encryptor(EncryptContext context) throws Exception { + public Sm2Encryptor(EncryptContext context) { super(context); String privateKey = context.getPrivateKey(); String publicKey = context.getPublicKey(); diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm4Encryptor.java b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm4Encryptor.java index cf999c278..f30afdce6 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm4Encryptor.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/encrypt/encryptor/Sm4Encryptor.java @@ -20,7 +20,7 @@ public class Sm4Encryptor extends AbstractEncryptor { private SM4 sm4 = null; - public Sm4Encryptor(EncryptContext context) throws Exception { + public Sm4Encryptor(EncryptContext context) { super(context); String password = context.getPassword(); if (StrUtil.isBlank(password)) { From 0775fd8169bd5e73a80fd17186742169d4f0bc58 Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Tue, 17 Jan 2023 20:38:58 +0800 Subject: [PATCH 8/9] =?UTF-8?q?=E6=9E=9A=E4=B8=BE=E7=B1=BB=E9=87=87?= =?UTF-8?q?=E7=94=A8class=E7=B1=BB=E6=9B=BF=E6=8D=A2=E5=AD=97=E7=AC=A6?= =?UTF-8?q?=E4=B8=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ruoyi/common/enums/AlgorithmType.java | 14 ++++++++------ .../ruoyi/framework/encrypt/EncryptorManager.java | 12 +----------- 2 files changed, 9 insertions(+), 17 deletions(-) diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java index 474a5ef08..eb9b830a0 100644 --- a/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java +++ b/ruoyi-common/src/main/java/com/ruoyi/common/enums/AlgorithmType.java @@ -1,5 +1,7 @@ package com.ruoyi.common.enums; +import com.ruoyi.common.encrypt.IEncryptor; +import com.ruoyi.common.encrypt.encryptor.*; import lombok.AllArgsConstructor; import lombok.Getter; @@ -14,27 +16,27 @@ public enum AlgorithmType { /** * base64 */ - BASE64("com.ruoyi.common.encrypt.encryptor.Base64Encryptor"), + BASE64(Base64Encryptor.class), /** * aes */ - AES("com.ruoyi.common.encrypt.encryptor.AesEncryptor"), + AES(AesEncryptor.class), /** * rsa */ - RSA("com.ruoyi.common.encrypt.encryptor.RsaEncryptor"), + RSA(RsaEncryptor.class), /** * sm2 */ - SM2("com.ruoyi.common.encrypt.encryptor.Sm2Encryptor"), + SM2(Sm2Encryptor.class), /** * sm4 */ - SM4("com.ruoyi.common.encrypt.encryptor.Sm4Encryptor"); + SM4(Sm4Encryptor.class); - private final String clazz; + private final Class clazz; } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java index 3faa7ea4a..d929cc2cd 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/EncryptorManager.java @@ -6,7 +6,6 @@ import com.ruoyi.common.encrypt.EncryptContext; import com.ruoyi.common.encrypt.IEncryptor; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.framework.config.properties.EncryptorProperties; -import jodd.util.ClassLoaderUtil; import lombok.extern.slf4j.Slf4j; import java.util.Map; @@ -44,16 +43,7 @@ public class EncryptorManager { encryptContext.setPrivateKey(properties.getPrivateKey()); encryptContext.setPublicKey(properties.getPublicKey()); encryptContext.setEncode(properties.getEncode()); - Class clazz = null; - try { - clazz = ClassLoaderUtil.loadClass(properties.getAlgorithm().getClazz()); - } catch (ClassNotFoundException e) { - log.error("没有找到配置中指定的加密执行者", e); - } - if(ObjectUtil.isNull(clazz)) { - return null; - } - IEncryptor encryptor = ReflectUtil.newInstance(clazz, encryptContext); + IEncryptor encryptor = ReflectUtil.newInstance(properties.getAlgorithm().getClazz(), encryptContext); encryptorMap.put(encryptorKey, encryptor); return encryptorMap.get(encryptorKey); } From d5ba003e486e7b5239b3df7dc4c9e4918d859874 Mon Sep 17 00:00:00 2001 From: mayuanfei Date: Tue, 7 Mar 2023 14:14:03 +0800 Subject: [PATCH 9/9] =?UTF-8?q?=E4=BF=AE=E5=A4=8Dbug:=E5=BD=93=E6=9F=A5?= =?UTF-8?q?=E8=AF=A2=E7=9A=84=E5=88=97=E8=A1=A8=E4=B8=BA=E7=A9=BA=E6=97=B6?= =?UTF-8?q?,=E8=A7=A3=E5=AF=86=E6=96=B9=E6=B3=95=E6=8A=A5=E6=95=B0?= =?UTF-8?q?=E7=BB=84=E8=B6=8A=E7=95=8C=E7=9A=84=E5=BC=82=E5=B8=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ruoyi/framework/encrypt/MybatisDecryptInterceptor.java | 7 ++++++- .../ruoyi/framework/encrypt/MybatisEncryptInterceptor.java | 7 ++++++- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java index abd02c3bc..e316c759f 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisDecryptInterceptor.java @@ -12,6 +12,7 @@ import lombok.AllArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.apache.ibatis.executor.resultset.ResultSetHandler; import org.apache.ibatis.plugin.*; +import org.springframework.util.CollectionUtils; import java.lang.reflect.Field; import java.sql.Statement; @@ -60,8 +61,12 @@ public class MybatisDecryptInterceptor implements Interceptor { return; } if (sourceObject instanceof List) { + List sourceList = (List) sourceObject; + if(CollectionUtils.isEmpty(sourceList)) { + return; + } // 判断第一个元素是否含有注解。如果没有直接返回，提高效率 - Object firstItem = ((List) sourceObject).get(0); + Object firstItem = sourceList.get(0); if (CollectionUtil.isEmpty(encryptorManager.getFieldCache(firstItem.getClass()))) { return; } diff --git a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java index 0907e089e..cd8a7d928 100644 --- a/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java +++ b/ruoyi-framework/src/main/java/com/ruoyi/framework/encrypt/MybatisEncryptInterceptor.java @@ -16,6 +16,7 @@ import org.apache.ibatis.plugin.Interceptor; import org.apache.ibatis.plugin.Intercepts; import org.apache.ibatis.plugin.Invocation; import org.apache.ibatis.plugin.Signature; +import org.springframework.util.CollectionUtils; import java.lang.reflect.Field; import java.sql.PreparedStatement; @@ -71,8 +72,12 @@ public class MybatisEncryptInterceptor implements Interceptor { return; } if (sourceObject instanceof List) { + List sourceList = (List) sourceObject; + if(CollectionUtils.isEmpty(sourceList)) { + return; + } // 判断第一个元素是否含有注解。如果没有直接返回，提高效率 - Object firstItem = ((List) sourceObject).get(0); + Object firstItem = sourceList.get(0); if (CollectionUtil.isEmpty(encryptorManager.getFieldCache(firstItem.getClass()))) { return; }