目录
Java：密码算法
1、base64算法
public class demo {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
public static void main(String[] args) throws UnsupportedEncodingException {
String str = "张三写java";
//编码
String encodedStr = Base64.getEncoder().encodeToString(str.getBytes(UTF8));
System.out.println("encodedStr:" + encodedStr);
//解码
byte[] decode = Base64.getDecoder().decode(encodedStr.getBytes(UTF8));
System.out.println("decode:"+ new String(decode,UTF8));
}
}结果：
注意：Base64 不是加密算法，而是一种编码方式。Base64 主要用于将二进制数据编码成文本格式，以便在文本协议中传输，如在电子邮件、XML、JSON 等中。它并不是为了提供加密或安全性而设计的。
URL编码
public class URLTest {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
public static void main(String[] args) throws UnsupportedEncodingException {
String str = "张三写java";
//编码
String encodedStr = URLEncoder.encode(str,UTF8);
System.out.println("编码:"+encodedStr);
//解码
String decode = URLDecoder.decode(encodedStr,UTF8);
System.out.println("解码后："+decode);
}
}结果：
MD5: Message-Digest Algorithm,结果占128位==>16个byte=>转成16进制字符后是32个
11111111--->ff
2、jdk原生api实现MD5
public class MD5Test {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
public static void main(String[] args) throws Exception {
String str = "张三写java";
String algorithm = "MD5";
//获取消息摘要算法对象
MessageDigest md = MessageDigest.getInstance(algorithm);
// 获取原始内容的字节数组
byte[] originalBytes = str.getBytes(UTF8);
//获取到摘要结果
byte[] digestBytes = md.digest(originalBytes);
//当originalBytes比较大的时候,循环的进行update()
//md.update(originalBytes);
//md.digest();
//把每一个字节转为16进制字符，最终再拼接起来这些16进制字符
String hexStr = converBytes(digestBytes);
System.out.println("hexStr:" + hexStr);
}
private static String converBytes(byte[] digestBytes) {
StringBuilder sb = new StringBuilder();
for (byte b : digestBytes) {
//获取b的补码的后8位
String hex = Integer.toHexString(((int)b)&0xff);
// 15-->Integer.toHexString (15&Oxff)-->f-->0f
// 16-- >Integer.toHexString(16&0xff)->10
if (hex.length() == 1){
hex = "0" + hex;
}
sb.append(hex);
}
return sb.toString();
}
}
代码封装，把上面公共部分提取出来
public class HexUtils {
/**
* @description 把字节数组转为16进制字符串，如果一个字节转为16进制字符后不足两位，则前面补0
* @author
* @date 2023-02-23 21:02:13
* @param digestBytes
* @return {@link String}
*/
public static String converBytes(byte[] digestBytes) {
StringBuilder sb = new StringBuilder();
for (byte b : digestBytes) {
//获取b的补码的后8位
String hex = Integer.toHexString(((int)b)&0xff);
// 15-->Integer.toHexString (15&Oxff)-->f-->0f
// 16-- >Integer.toHexString(16&0xff)->10
if (hex.length() == 1){
hex = "0" + hex;
}
sb.append(hex);
}
return sb.toString();
}
/**
* 把16进制字符串(一定是偶数位的，因为converBytes已经处理过)转为字节数组
* @param hexStr 16进制字符串
* @return
*/
public static byte[] converHex2Bytes(String hexStr) {
//一个字节可以转为2个16进制字符
int length = hexStr.length() / 2;
byte[] reault = new byte[length];
for (int i = 0; i < length; i++) {
//hexStr : abcd
//Integer.parseInt :把s转为10进制数，radix指定s是什么进制的数
//获取每个字节的高4位, hexStr.substring(2,3)=>c
int high4 = Integer.parseInt(hexStr.substring(i * 2,i * 2 + 1),16);
//获取每个字节的低4位，hexStr.substring( 3,4)=>d
int low4 = Integer.parseInt(hexStr.substring(i * 2 + 1,i * 2 + 2),16);
reault[i] = (byte) (high4* 16 + low4);
}
return reault;
}public class MessageDigestUtils {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
/**
* @description 执行信息再要
* @author
* @date 2023-02-23 21:09:55
* @param originContent 原始字符串
* @param algorithm 算法名字，如MD5
* @return {@link String}
*/
public static String doDigest(String originContent,String algorithm){
try {
//获取消息摘要算法对象
MessageDigest md = MessageDigest.getInstance(algorithm);
// 获取原始内容的字节数组
byte[] originalBytes = originContent.getBytes(UTF8);
//获取到摘要结果
byte[] digestBytes = md.digest(originalBytes);
//当originalBytes比较大的时候,循环的进行update()
//md.update(originalBytes);
//md.digest();
//把每一个字节转为16进制字符，最终再拼接起来这些16进制字符
String hexStr = HexUtils.converBytes(digestBytes);
return hexStr;
}catch (Exception e){
e.printStackTrace();
}
return null;
}
}3、使用codec依赖实现MD5加密
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.15</version>
</dependency>public class MD5Test {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
public static void main(String[] args) throws Exception {
String str = "张三写java";
System.out.println( "str:" + DigestUtils.md5Hex(str.getBytes(UTF8)));
}
}结果：
4、SHA加密
SHA(Secure Hash Algorithm) :安全散列算法
sha-256=>转成16进制字符后是64个
其他如sha-0,sha-1, sha-512
SHA-256加密：
public class Sha256Test {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
public static void main(String[] args) throws Exception {
String str = "张三写java";
String algorithm = "SHA-256";
//封装的类进行编码
String hexStr = MessageDigestUtils.doDigest(str,algorithm);
System.out.println("自己封装的str：" + hexStr);
System.out.println("codec的str:" + DigestUtils.sha256Hex(str.getBytes(UTF8)));
}
}结果：
SHA-512
public class SHA512Test {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
public static void main(String[] args) throws Exception {
String str = "张三写java";
String algorithm = "SHA-512";
//封装的类进行编码
String hexStr = MessageDigestUtils.doDigest(str,algorithm);
System.out.println("自己封装的str：" + hexStr);
System.out.println("codec的str:" + DigestUtils.sha512Hex(str.getBytes(UTF8)));
}
}
5、MAC算法加密
MAC(Message Authentication Code):消息认证码，是一种带有秘钥的hash函数
使用jdk实现在添加一个方法
/**
* @description 获取mac的消息摘要
* @author
* @date 2023-02-23 21:37:36
* @param originContent 原始内容
* @param algorithm mac算法的key
* @param key 算法名字，例如HmacMD5
* @return {@link String}
*/
public static String doMacDigest(String originContent,String algorithm,String key){
try {
//获取消息摘要算法对象
Mac mac = Mac.getInstance(algorithm);
//
SecretKey secretKey = new SecretKeySpec(key.getBytes(UTF8),algorithm);
mac.init(secretKey);
// 获取原始内容的字节数组
byte[] originalBytes = originContent.getBytes(UTF8);
//获取到摘要结果
byte[] digestBytes = mac.doFinal(originalBytes);
//当originalBytes比较大的时候,循环的进行update()
//md.update(originalBytes);
//md.digest();
//把每一个字节转为16进制字符，最终再拼接起来这些16进制字符
String hexStr = HexUtils.converBytes(digestBytes);
return hexStr;
}catch (Exception e){
e.printStackTrace();
}
return null;
}使用自己封装的方法及使用codec实现mac加密
public class MACTest {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
public static void main(String[] args) throws Exception {
String str = "张三写java";
String algorithm1 = "HmacMD5";
String algorithm2 = "HmacSHA256";
String algorithm3 = "HmacSHA512";
//指定秘钥, mac摘要和digest算法( md5 , sha)不同的地方就是加了盐
String key = "123";
//封装的类进行编码
String hexStr1 = MessageDigestUtils.doMacDigest(str,algorithm1,key);
String hexStr2 = MessageDigestUtils.doMacDigest(str,algorithm2,key);
String hexStr3 = MessageDigestUtils.doMacDigest(str,algorithm3,key);
System.out.println("HmacMD5：" + hexStr1);
System.out.println("HmacMD5：" + hexStr2);
System.out.println("HmacMD5：" + hexStr3);
String hmacMD5HexStr = new HmacUtils(HmacAlgorithms.HMAC_MD5,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
String hmacSHA256HexStr = new HmacUtils(HmacAlgorithms.HMAC_SHA_256,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
String hmacSHA512HexStr = new HmacUtils(HmacAlgorithms.HMAC_SHA_512,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
System.out.println("hmacMD5HexStr:"+ hmacMD5HexStr);
System.out.println("hmacSHA256HexStr:"+ hmacSHA256HexStr);
System.out.println("hmacSHA512HexStr:"+ hmacSHA512HexStr);
}
}结果：
6、对称加密
也叫单秘钥加密。所谓单秘钥，指的是加密和解密的过程使用相同的密钥,相比非对称加密，因只有一把钥匙，因而速度更快，更适合加解密大文件。
DES : data encryption standard，已经过时
AES : advanced encryption standard,替代des。
DES：使用Base64加密
public class DesTest {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
private static final String KEY = "12345678";
//加密模式
private static final String ALGORITHM = "DES";
/**
* 加密
* @param text 加密内容
* @return
*/
public static String encrypt(String text) throws Exception {
//获取示例
Cipher cipher = Cipher.getInstance(ALGORITHM);
//创建加密规则
SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
//加密模式规则
cipher.init(Cipher.ENCRYPT_MODE,secretKey);
byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
//1,使用Base64 2,转成16进制
return Base64.encodeBase64String(bytes);
}
/**
* 解密
* @param encodedText 加密后的字符串
* @return
* @throws Exception
*/
public static String decrypt(String encodedText) throws Exception {
//获取示例
Cipher cipher = Cipher.getInstance(ALGORITHM);
//创建加密规则
SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
//加密模式规则
cipher.init(Cipher.DECRYPT_MODE,secretKey);
byte[] bytes = cipher.doFinal(Base64.decodeBase64(encodedText.getBytes(UTF8)));
//1,使用Base64
return new String(bytes,UTF8);
}
public static void main(String[] args) throws Exception {
String str = "张三写java";
//加密
String encodedText = encrypt(str);
System.out.println("base64编码加密后的结果"+encodedText);
//解密
String decrypt = decrypt(encodedText);
System.out.println("des解密后的结果"+decrypt);
}
}结果：
AES：16进制加密模式
public class AesTest {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
//aes默认key的长度 16，24，32位
private static final String KEY = "12345678abcdefgh";
//加密模式
private static final String ALGORITHM = "AES";
/**
* 加密
* @param text 加密内容
* @return
*/
public static String encrypt(String text) throws Exception {
Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
//转成16进制
return HexUtils.converBytes(bytes);
}
/**
* 解密
* @param encodedText 16进制编码后的字符串
* @return
* @throws Exception
*/
public static String decrypt(String encodedText) throws Exception {
byte[] bytes = HexUtils.converHex2Bytes(encodedText);
Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
byte[] decryptedBytes = cipher.doFinal(bytes);
//2,转成16进制
return new String(decryptedBytes,UTF8);
}
/**
* 获取Cipher对象
* @param type 加密解密模式
* @param seed 密钥
* @return
* @throws Exception
*/
public static Cipher getCipher(int type,String seed) throws Exception{
//获取示例
Cipher cipher = Cipher.getInstance(ALGORITHM);
//创建加密规则
SecretKey secretKey = new SecretKeySpec(seed.getBytes(UTF8), ALGORITHM);
//加密模式规则
cipher.init(type,secretKey);
return cipher;
}
public static void main(String[] args) throws Exception {
String str = "张三写java";
//加密
String encodedText = encrypt(str);
System.out.println("16进制编码aes加密后的结果"+encodedText);
//解密
String decrypt = decrypt(encodedText);
System.out.println("aes解密后的结果"+decrypt);
}
} 
AES：16进制加密模式代码优化
public class AesTest {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
//aes默认key的长度 16，24，32位
private static final String KEY = "12345678";
//加密模式
private static final String ALGORITHM = "AES";
/**
* 加密
* @param text 加密内容
* @return
*/
public static String encrypt(String text) throws Exception {
Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
//转成16进制
return HexUtils.converBytes(bytes);
}
/**
* 解密
* @param encodedText 16进制编码后的字符串
* @return
* @throws Exception
*/
public static String decrypt(String encodedText) throws Exception {
byte[] bytes = HexUtils.converHex2Bytes(encodedText);
Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
byte[] decryptedBytes = cipher.doFinal(bytes);
//2,转成16进制
return new String(decryptedBytes,UTF8);
}
/**
* 获取Cipher对象
* @param type 加密解密模式
* @param seed 密钥
* @return
* @throws Exception
*/
public static Cipher getCipher(int type,String seed) throws Exception{
//获取示例
Cipher cipher = Cipher.getInstance(ALGORITHM);
//创建加密规则
//创建keyGenerator对象，可以根据传入的key生成一个指定长度的key
KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
//初始化secureRandom，并指定生成指定长度key的算法
SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
secureRandom.setSeed(seed.getBytes(UTF8));
keyGenerator.init(128,secureRandom);
//通过keyGenerator生成新的秘钥
SecretKey secretKey = keyGenerator.generateKey();
//获取到新秘钥的字节数组
byte[] encoded = secretKey.getEncoded();
SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, ALGORITHM);
//加密模式规则
cipher.init(type,secretKeySpec);
return cipher;
}
public static void main(String[] args) throws Exception {
String str = "张三写java";
//加密
String encodedText = encrypt(str);
System.out.println("16进制编码aes加密后的结果"+encodedText);
//解密
String decrypt = decrypt(encodedText);
System.out.println("aes解密后的结果"+decrypt);
}
}AES：base64加密模式
public class AesBase64Test {
//设置编码格式
private static final String UTF8 = StandardCharsets.UTF_8.name();
private static final String KEY = "12345678";
//加密模式
private static final String ALGORITHM = "AES";
/**
* 加密
* @param text 加密内容
* @return
*/
public static String encrypt(String text) throws Exception {
Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
//1,使用Base64 2,转成16进制
return Base64.encodeBase64String(bytes);
}
/**
* 解密
* @param encodedText 加密后的字符串
* @return
* @throws Exception
*/
public static String decrypt(String encodedText) throws Exception {
Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
byte[] bytes = cipher.doFinal(Base64.decodeBase64(encodedText.getBytes(UTF8)));
//1,使用Base64 2,转成16进制
return new String(bytes,UTF8);
}
public static Cipher getCipher(int type,String seed) throws Exception{
//获取示例
Cipher cipher = Cipher.getInstance(ALGORITHM);
//创建加密规则
//创建keyGenerator对象，可以根据传入的key生成一个指定长度的key
KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
//初始化secureRandom，并指定生成指定长度key的算法
SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
secureRandom.setSeed(seed.getBytes(UTF8));
keyGenerator.init(128,secureRandom);
//通过keyGenerator生成新的秘钥
SecretKey secretKey = keyGenerator.generateKey();
//获取到新秘钥的字节数组
byte[] encoded = secretKey.getEncoded();
SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, ALGORITHM);
//加密模式规则
cipher.init(type,secretKeySpec);
return cipher;
}
/**
* 测试
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
String str = "张三写java";
//加密
String encodedText = encrypt(str);
System.out.println("base64编码aes加密后的结果" + encodedText);
//解密
String decrypt = decrypt(encodedText);
System.out.println("aes解密后的结果" + decrypt);
}
}
7、非对称加密
定义：加密和解密使用的是两个不同的密钥(public key和private key).公钥可以给任何人，私钥总
是自己保留。
常见算法：RSA
应用场景：
1、加解密：可以使用公钥加密，对应的就是私钥解密;也可以使用私钥加密，对应的就是公钥解
密。
public class RSATest2 {
public static final String CHARSET = "UTF-8";
public static final String RSA_ALGORITHM = "RSA";
//生成密钥对，一般来说执行一次就行
public static Map<String, String> createKeys(int keySize) {
//为RSA算法创建一个KeyPairGenerator对象（KeyPairGenerator，密钥对生成器，用于生成公钥和私钥对）
KeyPairGenerator kpg;
try {
kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
} catch (NoSuchAlgorithmException e) {
throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
}
//初始化KeyPairGenerator对象,密钥长度
kpg.initialize(keySize);
//生成密匙对
KeyPair keyPair = kpg.generateKeyPair();
//得到公钥
Key publicKey = keyPair.getPublic();
String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded()); //返回一个publicKey经过二次加密后的字符串
//得到私钥
Key privateKey = keyPair.getPrivate();
String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded()); //返回一个privateKey经过二次加密后的字符串
Map<String, String> keyPairMap = new HashMap<String, String>();
keyPairMap.put("publicKey", publicKeyStr);
keyPairMap.put("privateKey", privateKeyStr);
return keyPairMap;
}
/**
* 得到公钥
*
* @param publicKey 密钥字符串（经过base64编码）
* @throws Exception
*/
public static RSAPublicKey getPublicKey(String publicKey) throws Exception {
//通过X509编码的Key指令获得公钥对象
KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
return key;
}
/**
* 得到私钥
*
* @param privateKey 密钥字符串（经过base64编码）
* @throws Exception
*/
public static RSAPrivateKey getPrivateKey(String privateKey) throws Exception {
//通过PKCS#8编码的Key指令获得私钥对象
KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
return key;
}
/**
* 公钥加密
*
* @param data
* @param publicKey
* @return
*/
public static String publicEncrypt(String data, RSAPublicKey publicKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
} catch (Exception e) {
throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
}
}
/**
* 私钥解密
*
* @param data
* @param privateKey
* @return
*/
public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength()), CHARSET);
} catch (Exception e) {
throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
}
}
/**
* 私钥加密
*
* @param data
* @param privateKey
* @return
*/
public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength()));
} catch (Exception e) {
throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
}
}
/**
* 公钥解密
*
* @param data
* @param publicKey
* @return
*/
public static String publicDecrypt(String data, RSAPublicKey publicKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, publicKey);
return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
} catch (Exception e) {
throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
}
}
private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
int maxBlock = 0;
if (opmode == Cipher.DECRYPT_MODE) {
maxBlock = keySize / 8;
} else {
maxBlock = keySize / 8 - 11;
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] buff;
int i = 0;
try {
while (datas.length > offSet) {
if (datas.length - offSet > maxBlock) {
buff = cipher.doFinal(datas, offSet, maxBlock);
} else {
buff = cipher.doFinal(datas, offSet, datas.length - offSet);
}
out.write(buff, 0, buff.length);
i++;
offSet = i * maxBlock;
}
} catch (Exception e) {
throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
}
byte[] resultDatas = out.toByteArray();
IOUtils.closeQuietly(out);
return resultDatas;
}
//测试
public static void main(String[] args) throws Exception {
//生成公私钥
Map<String, String> keyMap = RSATest2.createKeys(512);
//公钥
String publicKey = keyMap.get("publicKey");
//私钥
String privateKey = keyMap.get("privateKey");
System.out.println("公钥加密——私钥解密");
String str = "法外狂徒张三";
System.out.println("明文：" + str);
System.out.println("明文大小：" + str.getBytes().length);
//对内容进行公钥加密
String encodedData = RSATest2.publicEncrypt(str, RSATest2.getPublicKey(publicKey));
System.out.println("公钥加密密文：" + encodedData);
//用私钥对密文进行解密
String decodedData = RSATest2.privateDecrypt(encodedData, RSATest2.getPrivateKey(privateKey));
System.out.println("解密后文字: " + decodedData);
}
}2、数字签名
3、数字信封
4、数字证书
参考视频：密码学-java信息安全,摘要算法,对称加密(AES)/非对称加密(RSA),一应俱全_哔哩哔哩_bilibili
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
