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 cn.hutool.core.codec.Base64;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.lang.Validator;
import cn.hutool.core.util.HexUtil;
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.PBKDF2;
import cn.hutool.crypto.symmetric.RC4;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import cn.hutool.crypto.symmetric.ZUC;
import cn.hutool.crypto.symmetric.fpe.FPE;
import org.bouncycastle.crypto.AlphabetMapper;
import javax.crypto.Cipher;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
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;
/**
* 安全相关工具类
* 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字符串
* 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 算法
* @return {@link Cipher}
* @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 算法
* @return {@link MessageDigest}
* @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 算法
* @return {@link Mac}
* @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;
}
/**
* 创建{@link Signature}
*
* @param algorithm 算法
* @return {@link Signature}
* @since 5.7.0
*/
public static Signature createSignature(String algorithm) {
final Provider provider = GlobalBouncyCastleProvider.INSTANCE.getProvider();
Signature signature;
try {
signature = (null == provider) ? Signature.getInstance(algorithm) : Signature.getInstance(algorithm, provider);
} catch (NoSuchAlgorithmException e) {
throw new CryptoException(e);
}
return signature;
}
/**
* 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);
}
/**
* PBKDF2加密密码
*
* @param password 密码
* @param salt 盐
* @return 盐，一般为16位
* @since 5.6.0
*/
public static String pbkdf2(char[] password, byte[] salt) {
return new PBKDF2().encryptHex(password, salt);
}
/**
* FPE(Format Preserving Encryption)实现，支持FF1和FF3-1模式。
*
* @param mode FPE模式枚举，可选FF1或FF3-1
* @param key 密钥，{@code null}表示随机密钥，长度必须是16bit、24bit或32bit
* @param mapper Alphabet字典映射，被加密的字符范围和这个映射必须一致，例如手机号、银行卡号等字段可以采用数字字母字典表
* @param tweak Tweak是为了解决因局部加密而导致结果冲突问题，通常情况下将数据的不可变部分作为Tweak
* @return {@link FPE}
* @since 5.7.12
*/
public static FPE fpe(FPE.FPEMode mode, byte[] key, AlphabetMapper mapper, byte[] tweak) {
return new FPE(mode, key, mapper, tweak);
}
/**
* 祖冲之算法集（ZUC-128算法）实现，基于BouncyCastle实现。
*
* @param key 密钥
* @param iv 加盐，长度16bytes，{@code null}是随机加盐
* @return {@link ZUC}
* @since 5.7.12
*/
public static ZUC zuc128(byte[] key, byte[] iv) {
return new ZUC(ZUC.ZUCAlgorithm.ZUC_128, key, iv);
}
/**
* 祖冲之算法集（ZUC-256算法）实现，基于BouncyCastle实现。
*
* @param key 密钥
* @param iv 加盐，长度25bytes，{@code null}是随机加盐
* @return {@link ZUC}
* @since 5.7.12
*/
public static ZUC zuc256(byte[] key, byte[] iv) {
return new ZUC(ZUC.ZUCAlgorithm.ZUC_256, key, iv);
}
}
