Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
cn.hutool.crypto.SecureUtil Maven / Gradle / Ivy
package cn.hutool.crypto;
import java.io.File;
import java.io.InputStream;
import java.security.KeyPair;
import java.security.KeyStore;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.Security;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.KeySpec;
import java.util.Map;
import javax.crypto.Cipher;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.lang.Validator;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.HexUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.asymmetric.AsymmetricAlgorithm;
import cn.hutool.crypto.asymmetric.RSA;
import cn.hutool.crypto.asymmetric.Sign;
import cn.hutool.crypto.asymmetric.SignAlgorithm;
import cn.hutool.crypto.digest.DigestAlgorithm;
import cn.hutool.crypto.digest.Digester;
import cn.hutool.crypto.digest.HMac;
import cn.hutool.crypto.digest.HmacAlgorithm;
import cn.hutool.crypto.digest.MD5;
import cn.hutool.crypto.symmetric.AES;
import cn.hutool.crypto.symmetric.DES;
import cn.hutool.crypto.symmetric.DESede;
import cn.hutool.crypto.symmetric.RC4;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
/**
* 安全相关工具类
* RSA/DSA
* Default Keysize 1024
* Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).
*
*/
public static final int DEFAULT_KEY_SIZE = KeyUtil.DEFAULT_KEY_SIZE;
/**
* 生成 {@link SecretKey}，仅用于对称加密和摘要算法密钥生成
*
* @param algorithm 算法，支持PBE算法
* @return {@link SecretKey}
*/
public static SecretKey generateKey(String algorithm) {
return KeyUtil.generateKey(algorithm);
}
/**
* 生成 {@link SecretKey}，仅用于对称加密和摘要算法密钥生成
*
* @param algorithm 算法，支持PBE算法
* @param keySize 密钥长度
* @return {@link SecretKey}
* @since 3.1.2
*/
public static SecretKey generateKey(String algorithm, int keySize) {
return KeyUtil.generateKey(algorithm, keySize);
}
/**
* 生成 {@link SecretKey}，仅用于对称加密和摘要算法密钥生成
*
* @param algorithm 算法
* @param key 密钥，如果为{@code null} 自动生成随机密钥
* @return {@link SecretKey}
*/
public static SecretKey generateKey(String algorithm, byte[] key) {
return KeyUtil.generateKey(algorithm, key);
}
/**
* 生成 {@link SecretKey}
*
* @param algorithm DES算法，包括DES、DESede等
* @param key 密钥
* @return {@link SecretKey}
*/
public static SecretKey generateDESKey(String algorithm, byte[] key) {
return KeyUtil.generateDESKey(algorithm, key);
}
/**
* 生成PBE {@link SecretKey}
*
* @param algorithm PBE算法，包括：PBEWithMD5AndDES、PBEWithSHA1AndDESede、PBEWithSHA1AndRC2_40等
* @param key 密钥
* @return {@link SecretKey}
*/
public static SecretKey generatePBEKey(String algorithm, char[] key) {
return KeyUtil.generatePBEKey(algorithm, key);
}
/**
* 生成 {@link SecretKey}，仅用于对称加密和摘要算法
*
* @param algorithm 算法
* @param keySpec {@link KeySpec}
* @return {@link SecretKey}
*/
public static SecretKey generateKey(String algorithm, KeySpec keySpec) {
return KeyUtil.generateKey(algorithm, keySpec);
}
/**
* 生成私钥，仅用于非对称加密
* AES加密：aes().encrypt(data)
* AES解密：aes().decrypt(data)
*
*
* @return {@link AES}
*/
public static AES aes() {
return new AES();
}
/**
* AES加密
* AES加密：aes(key).encrypt(data)
* AES解密：aes(key).decrypt(data)
*
*
* @param key 密钥
* @return {@link SymmetricCrypto}
*/
public static AES aes(byte[] key) {
return new AES(key);
}
/**
* DES加密，生成随机KEY。注意解密时必须使用相同 {@link DES}对象或者使用相同KEY
* DES加密：des().encrypt(data)
* DES解密：des().decrypt(data)
*
*
* @return {@link DES}
*/
public static DES des() {
return new DES();
}
/**
* DES加密
* DES加密：des(key).encrypt(data)
* DES解密：des(key).decrypt(data)
*
*
* @param key 密钥
* @return {@link DES}
*/
public static DES des(byte[] key) {
return new DES(key);
}
/**
* DESede加密（又名3DES、TripleDES），生成随机KEY。注意解密时必须使用相同 {@link DESede}对象或者使用相同KEY
* DESede加密：desede().encrypt(data)
* DESede解密：desede().decrypt(data)
*
*
* @return {@link DESede}
* @since 3.3.0
*/
public static DESede desede() {
return new DESede();
}
/**
* DESede加密（又名3DES、TripleDES）
* DESede加密：desede(key).encrypt(data)
* DESede解密：desede(key).decrypt(data)
*
*
* @param key 密钥
* @return {@link DESede}
* @since 3.3.0
*/
public static DESede desede(byte[] key) {
return new DESede(key);
}
// ------------------------------------------------------------------- 摘要算法
/**
* MD5加密
* MD5加密：md5().digest(data)
* MD5加密并转为16进制字符串：md5().digestHex(data)
*
*
* @return {@link Digester}
*/
public static MD5 md5() {
return new MD5();
}
/**
* MD5加密，生成16进制MD5字符串null生成随机密钥
* @return {@link HMac}
* @since 3.3.0
*/
public static HMac hmac(HmacAlgorithm algorithm, String key) {
return new HMac(algorithm, StrUtil.utf8Bytes(key));
}
/**
* 创建HMac对象，调用digest方法可获得hmac值
*
* @param algorithm {@link HmacAlgorithm}
* @param key 密钥，如果为null生成随机密钥
* @return {@link HMac}
* @since 3.0.3
*/
public static HMac hmac(HmacAlgorithm algorithm, byte[] key) {
return new HMac(algorithm, key);
}
/**
* 创建HMac对象，调用digest方法可获得hmac值
*
* @param algorithm {@link HmacAlgorithm}
* @param key 密钥{@link SecretKey}，如果为null生成随机密钥
* @return {@link HMac}
* @since 3.0.3
*/
public static HMac hmac(HmacAlgorithm algorithm, SecretKey key) {
return new HMac(algorithm, key);
}
/**
* HmacMD5加密器null生成随机密钥
* @return {@link HMac}
* @since 3.3.0
*/
public static HMac hmacMd5(String key) {
return hmacMd5(StrUtil.utf8Bytes(key));
}
/**
* HmacMD5加密器null生成随机密钥
* @return {@link HMac}
*/
public static HMac hmacMd5(byte[] key) {
return new HMac(HmacAlgorithm.HmacMD5, key);
}
/**
* HmacMD5加密器，生成随机KEYnull生成随机密钥
* @return {@link HMac}
* @since 3.3.0
*/
public static HMac hmacSha1(String key) {
return hmacSha1(StrUtil.utf8Bytes(key));
}
/**
* HmacSHA1加密器null生成随机密钥
* @return {@link HMac}
*/
public static HMac hmacSha1(byte[] key) {
return new HMac(HmacAlgorithm.HmacSHA1, key);
}
/**
* HmacSHA1加密器，生成随机KEY
* addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
*
*
* @param provider 算法提供者
* @since 4.1.22
*/
public static void addProvider(Provider provider) {
Security.insertProviderAt(provider, 0);
}
/**
* 解码字符串密钥，可支持的编码如下：
*
*
* 1. Hex（16进制）编码
* 1. Base64编码
*
*
* @param key 被解码的密钥字符串
* @return 密钥
* @since 4.3.3
*/
public static byte[] decode(String key) {
return Validator.isHex(key) ? HexUtil.decodeHex(key) : Base64.decode(key);
}
/**
* 创建{@link Cipher}
*
* @param algorithm 算法
* @since 4.5.2
*/
public static Cipher createCipher(String algorithm) {
final Provider provider = GlobalBouncyCastleProvider.INSTANCE.getProvider();
Cipher cipher;
try {
cipher = (null == provider) ? Cipher.getInstance(algorithm) : Cipher.getInstance(algorithm, provider);
} catch (Exception e) {
throw new CryptoException(e);
}
return cipher;
}
/**
* 创建{@link MessageDigest}
*
* @param algorithm 算法
* @since 4.5.2
*/
public static MessageDigest createMessageDigest(String algorithm) {
final Provider provider = GlobalBouncyCastleProvider.INSTANCE.getProvider();
MessageDigest messageDigest;
try {
messageDigest = (null == provider) ? MessageDigest.getInstance(algorithm) : MessageDigest.getInstance(algorithm, provider);
} catch (NoSuchAlgorithmException e) {
throw new CryptoException(e);
}
return messageDigest;
}
/**
* 创建{@link Mac}
*
* @param algorithm 算法
* @since 4.5.13
*/
public static Mac createMac(String algorithm) {
final Provider provider = GlobalBouncyCastleProvider.INSTANCE.getProvider();
Mac mac;
try {
mac = (null == provider) ? Mac.getInstance(algorithm) : Mac.getInstance(algorithm, provider);
} catch (NoSuchAlgorithmException e) {
throw new CryptoException(e);
}
return mac;
}
/**
* RC4算法
*
* @param key 密钥
* @return {@link RC4}
*/
public static RC4 rc4(String key) {
return new RC4(key);
}
/**
* 强制关闭Bouncy Castle库的使用，全局有效
*
* @since 4.5.2
*/
public static void disableBouncyCastle() {
GlobalBouncyCastleProvider.setUseBouncyCastle(false);
}
}
