首页 > Python资料 博客日记
AES、RSA加解密工具类
2024-07-09 05:00:05Python资料围观160次
Python资料网推荐AES、RSA加解密工具类这篇文章给大家，欢迎收藏Python资料网享受知识的乐趣
一、AES加解密工具类
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.lang3.RandomStringUtils;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
/**
* <p>
* <code>AESUtils</code>
* </p>
* Description: AES工具类
*
* @date 2024/01/11 下午 05:01
*/
public class AESUtils {
public static void main(String[] args) throws Exception {
String data = "{\n" +
" \"code\": 10000,\n" +
" \"result\": {\n" +
" \"maxid\": 70714\n" +
" }\n" +
"}";
String seed = RandomStringUtils.randomAlphanumeric(30);
System.out.println("==>seed：" + seed);
System.out.println("-------------------");
String iv = RandomStringUtils.randomAlphanumeric(16);
System.out.println("==>iv：" + iv);
System.out.println("--------------------");
String encryptedData = AESUtils.encrypt(data, seed, iv);
System.out.println("==>encryptedData：" + encryptedData);
System.out.println("--------------------");
String decryptData = AESUtils.decrypt(encryptedData, seed, iv);
System.out.println("==>decryptData：" + decryptData);
System.out.println("-------------------");
}
/**
* 生成AES密钥
*
* @param seed 种子
* @return 返回AES密钥
* @throws NoSuchAlgorithmException 异常信息
*/
private static byte[] generateKey(String seed) throws Exception {
SecureRandom secureRandom = new SecureRandom();
secureRandom.setSeed(seed.getBytes(StandardCharsets.UTF_8));
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(128, secureRandom);
SecretKey secretKey = keyGenerator.generateKey();
return secretKey.getEncoded();
}
/**
* AES加密
*
* @param content 需要加密的内容
* @param seed 种子
* @param iv 偏移量，必须16位
* @return 返回加密后的内容
* @throws Exception 异常信息
*/
public static String encrypt(String content, String seed, String iv) throws Exception {
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
byte[] byteContent = content.getBytes(StandardCharsets.UTF_8);
SecretKeySpec secretKeySpec = new SecretKeySpec(generateKey(seed), "AES");
IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));
cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
return Base64.encode(cipher.doFinal(byteContent));
}
/**
* AES解密
*
* @param encryptedData 需要解密的内容
* @param seed 种子
* @param iv 偏移量，必须16位
* @return 返回解密后的内容
* @throws Exception 异常信息
*/
public static String decrypt(String encryptedData, String seed, String iv) throws Exception {
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
byte[] byteContent = Base64.decode(encryptedData);
SecretKeySpec secretKeySpec = new SecretKeySpec(generateKey(seed), "AES");
IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
return new String(cipher.doFinal(byteContent), StandardCharsets.UTF_8);
}
}
二、RSA加解密工具类
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.lang3.RandomStringUtils;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
/**
* <p>
* <code>RSAUtils</code>
* </p>
* Description:RSA工具类
*
* @date 2024/01/11 下午 02:59
*/
public class RSAUtils {
// 秘钥长度，应该为1024的整数倍，越大越慢，>=2048是安全的，<1024是不安全的
private static final int KEY_SIZE = 2048;
// 加密算法RSA
private static final String KEY_ALGORITHM = "RSA";
// 签名算法
private static final String SIGNATURE_ALGORITHM = "SHA256withRSA";
// 获取公钥的key
private static final String PUBLIC_KEY = "RSAPublicKey";
// 获取私钥的key
private static final String PRIVATE_KEY = "RSAPrivateKey";
// RSA最大加密明文大小
private static final int MAX_ENCRYPT_BLOCK = KEY_SIZE / 8 - 11;
// RSA最大解密密文大小
private static final int MAX_DECRYPT_BLOCK = KEY_SIZE / 8;
public static void main(String[] args) throws Exception {
// String seed = "$nN%^mT75*%jx^(Rbp)(Ydfp";
String seed = RandomStringUtils.randomAlphanumeric(30);
System.out.println("seed：" + seed);
System.out.println("----------------");
Map<String, String> keyPair = RSAUtils.genKeyPair(seed);
String publicKey = keyPair.get(PUBLIC_KEY);
String privateKey = keyPair.get(PRIVATE_KEY);
System.out.println("publicKey：" + publicKey);
System.out.println("privateKey：" + privateKey);
System.out.println("-----------------");
String data = "部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。\r\n" +
"部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。\r\n" +
"部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。\r\n" +
"部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。\r\n" +
"部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。\r\n" +
"部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。\r\n" +
"部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。\r\n" +
"部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。\r\n" +
"部署 (Deployment) 用来描述期望应用达到的目标状态，主要用来描述无状态应用，副本的数量和状态由其背后的控制器来维护，确保状态与定义的期望状态一致。您可以增加副本数量来满足更高负载；回滚部署的版本来消除程序的错误修改；创建自动伸缩器来弹性应对不同场景下的负载。";
String publicEncrypt = RSAUtils.encryptByPublicKey(data, publicKey);
System.out.println("公钥加密后的数据：" + publicEncrypt);
String privateDecrypt = RSAUtils.decryptByPrivateKey(publicEncrypt, privateKey);
System.out.println("私钥解密后的数据：" + privateDecrypt);
System.out.println("--------------------");
String privateKeyEncrypt = RSAUtils.encryptByPrivateKey(data, privateKey);
System.out.println("私钥加密后的数据：" + privateKeyEncrypt);
String publicDecrypt = RSAUtils.decryptByPublicKey(privateKeyEncrypt, publicKey);
System.out.println("公钥解密后的数据：" + publicDecrypt);
System.out.println("-------------------");
String singData = RSAUtils.sign("111", privateKey);
System.out.println("私钥签名后的数据：" + singData);
boolean isSign = RSAUtils.verify("111", publicKey, singData);
System.out.println("签名是否正确：" + isSign);
System.out.println("------------------");
}
/**
* 生成公钥和私钥
*
* @param seed 种子
* @return
* @throws Exception
*/
public static Map<String, String> genKeyPair(String seed) throws Exception {
// 如果指定seed，那么secureRandom结果是一样的，所以生成的公私钥也永远不会变
SecureRandom secureRandom = new SecureRandom();
secureRandom.setSeed(seed.getBytes());
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
keyPairGen.initialize(KEY_SIZE, secureRandom);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
Map<String, String> keyMap = new HashMap<>(2);
keyMap.put(PUBLIC_KEY, Base64.encode(publicKey.getEncoded()));
keyMap.put(PRIVATE_KEY, Base64.encode(privateKey.getEncoded()));
return keyMap;
}
/**
* 对数据进行签名
*
* @param data 待签名的数据
* @param privateKey 私钥
* @return 对数据生成签名
* @throws Exception
*/
public static String sign(String data, String privateKey) throws Exception {
byte[] keyBytes = Base64.decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initSign(privateK);
signature.update(data.getBytes(StandardCharsets.UTF_8));
return Base64.encode(signature.sign());
}
/**
* 验签
*
* @param data 签名之前的数据
* @param publicKey 公钥
* @param sign 签名之后的数据
* @return 验签是否成功
* @throws Exception
*/
public static boolean verify(String data, String publicKey, String sign) throws Exception {
byte[] keyBytes = Base64.decode(publicKey);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey publicK = keyFactory.generatePublic(keySpec);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initVerify(publicK);
signature.update(data.getBytes(StandardCharsets.UTF_8));
return signature.verify(Base64.decode(sign));
}
/**
* 用私钥对数据进行解密
*
* @param encryptedData 使用公钥加密过的数据
* @param privateKey 私钥
* @return 解密后的数据
* @throws Exception
*/
public static String decryptByPrivateKey(String encryptedData, String privateKey) throws Exception {
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
byte[] keyBytes = Base64.decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, privateK);
byte[] dataBytes = Base64.decode(encryptedData);
int inputLen = dataBytes.length;
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段解密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
cache = cipher.doFinal(dataBytes, offSet, MAX_DECRYPT_BLOCK);
} else {
cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_DECRYPT_BLOCK;
}
return new String(out.toByteArray(), StandardCharsets.UTF_8);
}
}
/**
* 公钥解密
*
* @param encryptedData 使用私钥加密过的数据
* @param publicKey 公钥
* @return 解密后的数据
* @throws Exception
*/
public static String decryptByPublicKey(String encryptedData, String publicKey) throws Exception {
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
byte[] keyBytes = Base64.decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key publicK = keyFactory.generatePublic(x509KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, publicK);
byte[] dataBytes = Base64.decode(encryptedData);
int inputLen = dataBytes.length;
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段解密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
cache = cipher.doFinal(dataBytes, offSet, MAX_DECRYPT_BLOCK);
} else {
cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_DECRYPT_BLOCK;
}
return new String(out.toByteArray(), StandardCharsets.UTF_8);
}
}
/**
* 公钥加密
*
* @param data 需要加密的数据
* @param publicKey 公钥
* @return 使用公钥加密后的数据
* @throws Exception
*/
public static String encryptByPublicKey(String data, String publicKey) throws Exception {
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
byte[] keyBytes = Base64.decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key publicK = keyFactory.generatePublic(x509KeySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicK);
byte[] dataBytes = data.getBytes();
int inputLen = dataBytes.length;
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(dataBytes, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
return Base64.encode(out.toByteArray());
}
}
/**
* 私钥加密
*
* @param data 待加密的数据
* @param privateKey 私钥
* @return 使用私钥加密后的数据
* @throws Exception
*/
public static String encryptByPrivateKey(String data, String privateKey) throws Exception {
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
byte[] keyBytes = Base64.decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateK);
byte[] dataBytes = data.getBytes(StandardCharsets.UTF_8);
int inputLen = dataBytes.length;
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(dataBytes, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
return Base64.encode(out.toByteArray());
}
}
}
版权声明：本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！
标签：
相关文章
最新发布
- 【Python】selenium安装+Microsoft Edge驱动器下载配置流程
- Python 中自动打开网页并点击[自动化脚本],Selenium
- Anaconda基础使用
- 【Python】成功解决 TypeError: ‘＜‘ not supported between instances of ‘str’ and ‘int’
- manim边学边做--三维的点和线
- CPython是最常用的Python解释器之一，也是Python官方实现。它是用C语言编写的，旨在提供一个高效且易于使用的Python解释器。
- Anaconda安装配置Jupyter（2024最新版）
- Python中读取Excel最快的几种方法！
- Python某城市美食商家爬虫数据可视化分析和推荐查询系统毕业设计论文开题报告
- 如何使用 Python 批量检测和转换 JSONL 文件编码为 UTF-8
点击排行
- 版本匹配指南：Numpy版本和Python版本的对应关系
- 版本匹配指南：PyTorch版本、torchvision 版本和Python版本的对应关系
- Python 可视化 web 神器：streamlit、Gradio、dash、nicegui；低代码 Python Web 框架：PyWebIO
- 相关性分析——Pearson相关系数+热力图(附data和Python完整代码)
- Anaconda版本和Python版本对应关系（持续更新...）
- Python与PyTorch的版本对应
- Windows上安装 Python 环境并配置环境变量 （超详细教程）
- Python pyinstaller打包exe最完整教程
本站推荐
