rsa加密返回
package com.csw.encryptiontechnology.utils.rsa.jiaMi;
import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside // 表示自定義自己的注解Sensitive
@JsonSerialize(using = SensitiveInfoSerialize.class) // 該注解使用序列化的方式
public @interface RSAEncrypted {
}
package com.csw.encryptiontechnology.utils.rsa.jiaMi;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
@Slf4j
@Component
public class RSAUtils {
public static String publicKeyStr;
public static String privateKeyStr;
public RSAUtils(@Value("${rsa.secretKey.publicKey}") String publicKeyStr,
@Value("${rsa.secretKey.privateKey}") String privateKeyStr) {
RSAUtils.publicKeyStr = publicKeyStr;
RSAUtils.privateKeyStr = privateKeyStr;
}
private static final Logger logger = LoggerFactory.getLogger(RSAUtils.class);
private static int kEY_LENGTH = 1024;
public static void main(String[] args) {
try {
// 創(chuàng)建密鑰對生成器，指定 RSA 算法
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
// 設(shè)置密鑰長度
keyPairGenerator.initialize(kEY_LENGTH);
// 生成密鑰對
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 獲取公鑰和私鑰
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();
// 將公鑰和私鑰轉(zhuǎn)換為 Base64 編碼的字符串以便輸出
String publicKeyStr = Base64.getEncoder().encodeToString(publicKey.getEncoded());
String privateKeyStr = Base64.getEncoder().encodeToString(privateKey.getEncoded());
System.out.println("公鑰：" + publicKeyStr);
System.out.println("私鑰：" + privateKeyStr);
//測試加密和解密1
String s = encrypt("張三安徽的人123456", publicKeyStr);
System.out.println("加密后]" + s);
String decrypt = decrypt(s, privateKeyStr);
System.out.println("解密后]" + decrypt);
} catch (Exception e) {
e.printStackTrace();
}
}
public static String encrypt(String plainText, String publicKeyStr) throws NoSuchAlgorithmException, InvalidKeySpecException, Exception {
byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
PublicKey publicKey = keyFactory.generatePublic(keySpec);
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());
return Base64.getEncoder().encodeToString(encryptedBytes);
}
public static String decrypt(String encryptedText, String privateKeyStr) throws NoSuchAlgorithmException, InvalidKeySpecException, Exception {
byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyStr);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] encryptedBytes = Base64.getDecoder().decode(encryptedText);
byte[] decryptedBytes = cipher.doFinal(encryptedBytes);
return new String(decryptedBytes);
}
public static String encrypt(String plainText) throws NoSuchAlgorithmException, InvalidKeySpecException, Exception {
return encrypt(plainText, publicKeyStr);
}
public static String decrypt(String encryptedText) throws NoSuchAlgorithmException, InvalidKeySpecException, Exception {
return decrypt(encryptedText, privateKeyStr);
}
}
package com.csw.encryptiontechnology.utils.rsa.jiaMi;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import java.io.IOException;
import java.util.Objects;
public class SensitiveInfoSerialize extends JsonSerializer<String> implements ContextualSerializer {
/**
* 步驟一
* 方法來源于ContextualSerializer，獲取屬性上的注解屬性,同時(shí)返回一個(gè)合適的序列化器
*/
@Override
public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
// 獲取自定義注解
RSAEncrypted annotation = beanProperty.getAnnotation(RSAEncrypted.class);
// 注解不為空，且標(biāo)注的字段為String
if (Objects.nonNull(annotation) && Objects.equals(String.class, beanProperty.getType().getRawClass())) {
//自定義情況，返回本序列化器，將順利進(jìn)入到該類中的serialize方法中
return this;
}
// 注解為空，字段不為String，尋找合適的序列化器進(jìn)行處理
return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
}
/**
* 步驟二
* 方法來源于JsonSerializer<String>：指定返回類型為String類型，serialize()將修改后的數(shù)據(jù)返回
*/
@Override
public void serialize(String str, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
// 定義策略不為空，返回策略處理過的字符串
try {
jsonGenerator.writeString(RSAUtils.encrypt(str, RSAUtils.publicKeyStr));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
脫敏返回
package com.csw.encryptiontechnology.utils.rsa.tuoMin;
import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@JacksonAnnotationsInside
@JsonSerialize(using = DesensitizationJsonSerializable.class)
public @interface Desensitization {
/**
* 脫敏策略
*
* @return
*/
DesensitizationStrategy value();
}
package com.csw.encryptiontechnology.utils.rsa.tuoMin;
import cn.hutool.core.util.DesensitizedUtil;
import java.util.function.Function;
public enum DesensitizationStrategy {
//收獲，保留前三后四，其他的替換為*
PHONE(s -> DesensitizedUtil.desensitized(s, DesensitizedUtil.DesensitizedType.MOBILE_PHONE)),
// 郵箱，保留前一位即@和后面的部分，其他的替換為*
EMAIL(s -> DesensitizedUtil.desensitized(s, DesensitizedUtil.DesensitizedType.EMAIL)),
// 身份證號，保留前一位和后2位，其他的替換為*
ID_CARD(s -> DesensitizedUtil.desensitized(s, DesensitizedUtil.DesensitizedType.ID_CARD)),
// 地址，保留前四位，其他的替換為*
ADDRESS(s -> DesensitizedUtil.desensitized(s, DesensitizedUtil.DesensitizedType.ADDRESS)),
// 銀行卡，保留前后四位，其他的替換為*
BANK_CARD(s -> DesensitizedUtil.desensitized(s, DesensitizedUtil.DesensitizedType.BANK_CARD)),
// 姓名，保留前一位，其他的替換為*
NAME(s -> DesensitizedUtil.desensitized(s, DesensitizedUtil.DesensitizedType.CHINESE_NAME)),
// 密碼，統(tǒng)一替換為 ******
PASSWORD(s -> "******");
private final Function<String, String> desensitization;
DesensitizationStrategy(Function<String, String> desensitization) {
this.desensitization = desensitization;
}
public Function<String, String> getDesensitization() {
return desensitization;
}
}
package com.csw.encryptiontechnology.utils.rsa.tuoMin;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import java.io.IOException;
import java.util.Objects;
public class DesensitizationJsonSerializable extends JsonSerializer<String> implements ContextualSerializer {
//脫敏策略
private DesensitizationStrategy desensitizationStrategy;
@Override
public void serialize(String s, JsonGenerator gen, SerializerProvider serializers) throws IOException {
// 使用脫敏策略將字符串處理后序列化到j(luò)son中
gen.writeString(desensitizationStrategy.getDesensitization().apply(s));
}
@Override
public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {
// 獲取屬性上的 Desensitization 注解
Desensitization annotation = property.getAnnotation(Desensitization.class);
// 注解不為空 && 屬性類型必須是字符串類型
if (Objects.nonNull(annotation) && Objects.equals(String.class, property.getType().getRawClass())) {
//設(shè)置脫敏策略
this.desensitizationStrategy = annotation.value();
return this;
}
// 返回默認(rèn)的序列化器
return prov.findValueSerializer(property.getType(), property);
}
}
