java encrypt 加密种类
1,pom
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.1.0</version>
</dependency>
2,非对称加密
package club.mydlq.encrypt;
import cn.hutool.core.codec.Base64;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import java.io.UnsupportedEncodingException;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* 非对称加密
*/
public class AsymmetricEncryptionExample {
/**
* RSA 公钥加密,私钥解密
*
* @param data 加密数据
* @param privateKeyString 私钥字符串
* @param publicKeyString 公钥字符串
* @throws UnsupportedEncodingException
*/
public static void rsaEncrypt1(String data, String privateKeyString, String publicKeyString) throws UnsupportedEncodingException {
// 将公、私钥字符串转换成公、私钥对象
PrivateKey privateKey = SecureUtil.generatePrivateKey("RSA", Base64.decode(privateKeyString));
PublicKey publicKey = SecureUtil.generatePublicKey("RSA", Base64.decode(publicKeyString));
// 获取字符串byte数组
byte[] bytes = data.getBytes("UTF-8");
// 创建 RSA 对象
RSA rsa = new RSA();
// 设置公钥,然后执行公钥加密
rsa.setPublicKey(publicKey);
byte[] encrypt = rsa.encrypt(bytes, KeyType.PublicKey);
// 设置私钥,然后执行私钥解密
rsa.setPrivateKey(privateKey);
byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
// 输出解密的内容
System.out.println("公钥加密,私钥解密,解密内容:" + new String(decrypt));
}
/**
* RSA 私钥加密,公钥解密
*
* @param data 加密数据
* @param privateKeyString 私钥字符串
* @param publicKeyString 公钥字符串
* @throws UnsupportedEncodingException
*/
public static void rsaEncrypt2(String data, String privateKeyString, String publicKeyString) throws UnsupportedEncodingException {
// 将公、私钥字符串转换成公、私钥对象
PrivateKey privateKey = SecureUtil.generatePrivateKey("RSA", Base64.decode(privateKeyString));
PublicKey publicKey = SecureUtil.generatePublicKey("RSA", Base64.decode(publicKeyString));
// 获取字符串byte数组
byte[] bytes = data.getBytes("UTF-8");
// 创建 RSA 对象
RSA rsa = new RSA();
// 设置私钥,然后执行私钥加密
rsa.setPrivateKey(privateKey);
byte[] encrypt = rsa.encrypt(bytes, KeyType.PrivateKey);
// 设置公钥,然后执行公钥解密
rsa.setPublicKey(publicKey);
byte[] decrypt = rsa.decrypt(encrypt, KeyType.PublicKey);
// 输出解密的内容
System.out.println("私钥加密,公钥解密,解密内容:" + new String(decrypt));
}
public static void main(String[] args) throws UnsupportedEncodingException {
/* 生成钥匙对 */
KeyPair pair = SecureUtil.generateKeyPair("RSA");
PrivateKey privateKey = pair.getPrivate();
PublicKey publicKey = pair.getPublic();
// 将公钥私钥转换成 Base64 字符串
String privateKeyString = Base64.encode(privateKey.getEncoded());
String publicKeyString = Base64.encode(publicKey.getEncoded());
/* 设置要加密的内容 */
String data = "测试数据";
/* RSA 公钥加密,私钥解密 */
rsaEncrypt1(data, privateKeyString, publicKeyString);
/* RSA 私钥加密,公钥解密 */
rsaEncrypt2(data, privateKeyString, publicKeyString);
}
}
3,摘要加密
package club.mydlq.encrypt;
import cn.hutool.crypto.digest.DigestUtil;
/**
* 摘要加密
*/
public class DigesterEncryption {
/**
* MD2 加密
* @param data 加密内容
*/
public static void md2Encrypt(String data) {
String md2String = DigestUtil.md5Hex(data);
System.out.println("MD2加密后的字符串:" + md2String);
}
/**
* MD5 加密
* @param data 加密内容
*/
public static void md5Encrypt(String data) {
String md5String = DigestUtil.md5Hex(data);
System.out.println("MD5加密后的字符串:" + md5String);
}
/**
* SHA-1 加密
* @param data 加密内容
*/
public static void sha1Encrypt(String data) {
String sha1String = DigestUtil.sha1Hex(data);
System.out.println("SHA1加密后的字符串:" + sha1String);
}
/**
* SHA-256 加密
* @param data 加密内容
*/
public static void sha256Encrypt(String data) {
String sha256String = DigestUtil.sha256Hex(data);
System.out.println("SHA256加密后的字符串:" + sha256String);
}
public static void main(String[] args) {
/* 设置要加密的内容 */
String data = "测试数据";
/* MD2加密 */
md2Encrypt(data);
/* MD5加密 */
md5Encrypt(data);
/* SHA1加密 */
sha1Encrypt(data);
/* SHA256加密 */
sha256Encrypt(data);
}
}
4,对称加密
package club.mydlq.encrypt;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import java.io.UnsupportedEncodingException;
/**
* 对称加密
*/
public class SymmetricalEncryptionExample {
/**
* AES 加密、解密
*
* @param data 加密数据
*/
public static void aesEncrypt(String data, String secret) {
// 随机生成密钥
byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue(), secret.getBytes()).getEncoded();
// 创建 AES 对象
SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, key);
// 加密
String encrypt = aes.encryptHex(data);
// 解密
String decrypt = aes.decryptStr(encrypt);
System.out.println("AES 加密后的串:" + encrypt + "AES 解密的数据:" + decrypt);
}
/**
* DES 加密、解密
*
* @param data 加密数据
*/
public static void desEncrypt(String data, String secret) {
// 随机生成密钥
byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DES.getValue(), secret.getBytes()).getEncoded();
// 创建 DES 对象
SymmetricCrypto des = new SymmetricCrypto(SymmetricAlgorithm.DES, key);
// 加密
String encrypt = des.encryptHex(data);
// 解密
String decrypt = des.decryptStr(encrypt);
System.out.println("DES 加密后的串:" + encrypt + "DES 解密的数据:" + decrypt);
}
/**
* DESede 加密、解密
*
* @param data 加密数据
*/
public static void desedeEncrypt(String data, String secret) {
// 随机生成密钥
byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DESede.getValue(), secret.getBytes()).getEncoded();
// 创建 DESede 对象
SymmetricCrypto desede = new SymmetricCrypto(SymmetricAlgorithm.DESede, key);
// 加密
String encrypt = desede.encryptHex(data);
// 解密
String decrypt = desede.decryptStr(encrypt);
System.out.println("DESede 加密后的串:" + encrypt + "DESede 解密的数据:" + decrypt);
}
/**
* Blowfish 加密、解密
*
* @param data 加密数据
*/
public static void blowfishEncrypt(String data, String secret) {
// 随机生成密钥
byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.Blowfish.getValue(), secret.getBytes()).getEncoded();
// 创建 Blowfish 对象
SymmetricCrypto blowfish = new SymmetricCrypto(SymmetricAlgorithm.Blowfish, key);
// 加密
String encrypt = blowfish.encryptHex(data);
// 解密
String decrypt = blowfish.decryptStr(encrypt);
System.out.println("Blowfish 加密后的串:" + encrypt + "Blowfish 解密的数据:" + decrypt);
}
/**
* RC2 加密、解密
*
* @param data 加密数据
*/
public static void rc2Encrypt(String data, String secret) {
// 随机生成密钥
byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.RC2.getValue(), secret.getBytes()).getEncoded();
// 创建 RC2 对象
SymmetricCrypto rc2 = new SymmetricCrypto(SymmetricAlgorithm.RC2, key);
// 加密
String encrypt = rc2.encryptHex(data);
// 解密
String decrypt = rc2.decryptStr(encrypt);
System.out.println("RC2 加密后的串:" + encrypt + "RC2 解密的数据:" + decrypt);
}
/**
* ARCFOUR 加密、解密
*
* @param data 加密数据
*/
public static void arcfourEncrypt(String data, String secret) {
// 随机生成密钥
byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.ARCFOUR.getValue(), secret.getBytes()).getEncoded();
// 创建 ARCFOUR 对象
SymmetricCrypto arcfour = new SymmetricCrypto(SymmetricAlgorithm.ARCFOUR, key);
// 加密
String encrypt = arcfour.encryptHex(data);
// 解密
String decrypt = arcfour.decryptStr(encrypt);
System.out.println("ARCFOUR 加密后的串:" + encrypt + "ARCFOUR 解密的数据:" + decrypt);
}
public static void main(String[] args) throws UnsupportedEncodingException {
/* 设置要加密的内容 */
String data = "测试数据";
String secret1 = "abcdefghijklmnop";
String secret2 = "abcdefghijklmnopqrstuvwx";
/* AES加密 */
aesEncrypt(data, secret1);
/* DES加密 */
desEncrypt(data, secret1);
/* RC2加密 */
rc2Encrypt(data, secret1);
/* Blowfish加密 */
blowfishEncrypt(data, secret1);
/* ARCFOUR加密 */
arcfourEncrypt(data, secret1);
/* DESede加密 */
desedeEncrypt(data, secret2);
}
}
5,签名
package club.mydlq.encrypt;
import cn.hutool.core.codec.Base64;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.Sign;
import cn.hutool.crypto.asymmetric.SignAlgorithm;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* 签名
*/
public class SignExample {
/**
* RSA 私钥签名
*
* @param data 签名数据
* @param privateKeyString 私钥字符串
*/
public static String rsaSign(String data, String privateKeyString) {
// 将私钥字符串转换成私钥对象
PrivateKey privateKey = SecureUtil.generatePrivateKey("RSA", Base64.decode(privateKeyString));
// 设置签名对象以及加密算法
Sign sign = SecureUtil.sign(SignAlgorithm.MD5withRSA);
// 设置私钥,然后执行签名
sign.setPrivateKey(privateKey);
byte[] bytes = sign.sign(data.getBytes());
// 将签名转换为 Base64 字符串,然后返回
return Base64.encode(bytes);
}
/**
* RSA 公钥验签
*
* @param data 签名数据
* @param publicKeyString 公钥
* @param signString 签名
* @return 是否验证成功
*/
public static boolean rsaSignVerify(String data, String publicKeyString, String signString) {
// 将公钥字符串转换成公钥对象
PublicKey publicKey = SecureUtil.generatePublicKey("RSA", Base64.decode(publicKeyString));
// 设置签名对象以及加密算法
Sign sign = SecureUtil.sign(SignAlgorithm.MD5withRSA);
// 将签名字符串转换成 byte 数组
byte[] bytes = Base64.decode(signString);
// 设置公钥,然后执行验签
sign.setPublicKey(publicKey);
return sign.verify(data.getBytes(), bytes);
}
public static void main(String[] args) {
/* 生成钥匙对 */
KeyPair pair = SecureUtil.generateKeyPair("RSA");
PrivateKey privateKey = pair.getPrivate();
PublicKey publicKey = pair.getPublic();
// 将公钥私钥转换成 Base64 字符串
String privateKeyString = Base64.encode(privateKey.getEncoded());
String publicKeyString = Base64.encode(publicKey.getEncoded());
/* 设置要加密的内容 */
String data = "测试数据";
/* RSA 私钥签名,公钥验签 */
String sign = rsaSign(data, privateKeyString);
boolean verify = rsaSignVerify(data, publicKeyString, sign);
System.out.println("签名验证结果:" + verify);
}
}