com.siashan.toolkit.crypt.SecureUtil Maven / Gradle / Ivy

Go to download
package com.siashan.toolkit.crypt;

import com.siashan.toolkit.crypt.symmetric.Mode;
import com.siashan.toolkit.crypt.symmetric.Padding;
import com.siashan.toolkit.crypt.symmetric.SymmetricAlgorithm;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import java.io.File;
import java.io.InputStream;
import java.security.*;
import java.security.cert.Certificate;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.KeySpec;

/**
 * 安全相关工具类

 * 加密分为三种：

 * 1、对称加密（symmetric），例如：AES、DES等

 * 2、非对称加密（asymmetric），例如：RSA、DSA等

 * 3、摘要加密（digest），例如：MD5、SHA-1、SHA-256、HMAC等

 *
 * @author siashan
 * @since 1.0.7
 */
public final class SecureUtil {

	/**
	 * 默认密钥字节数
	 *
	 * 	 * 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.genKey(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.genKey(algorithm, keySize);
	}

	/**
	 * 生成 {@link SecretKey}，仅用于对称加密和摘要算法密钥生成
	 *
	 * @param algorithm 算法
	 * @param key       密钥，如果为{@code null} 自动生成随机密钥
	 * @return {@link SecretKey}
	 */
	public static SecretKey generateKey(String algorithm, byte[] key) {
		return KeyUtil.genKey(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.genKey(algorithm, keySpec);
	}

	/**
	 * 生成私钥，仅用于非对称加密

	 * 算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
	 *
	 * @param algorithm 算法
	 * @param key       密钥
	 * @return 私钥 {@link PrivateKey}
	 */
	public static PrivateKey generatePrivateKey(String algorithm, byte[] key) {
		return KeyUtil.generatePrivateKey(algorithm, key);
	}

	/**
	 * 生成私钥，仅用于非对称加密

	 * 算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
	 *
	 * @param algorithm 算法
	 * @param keySpec   {@link KeySpec}
	 * @return 私钥 {@link PrivateKey}
	 * @since 3.1.1
	 */
	public static PrivateKey generatePrivateKey(String algorithm, KeySpec keySpec) {
		return KeyUtil.generatePrivateKey(algorithm, keySpec);
	}

	/**
	 * 生成私钥，仅用于非对称加密
	 *
	 * @param keyStore {@link KeyStore}
	 * @param alias    别名
	 * @param password 密码
	 * @return 私钥 {@link PrivateKey}
	 */
	public static PrivateKey generatePrivateKey(KeyStore keyStore, String alias, char[] password) {
		return KeyUtil.generatePrivateKey(keyStore, alias, password);
	}

	/**
	 * 生成公钥，仅用于非对称加密

	 * 算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
	 *
	 * @param algorithm 算法
	 * @param key       密钥
	 * @return 公钥 {@link PublicKey}
	 */
	public static PublicKey generatePublicKey(String algorithm, byte[] key) {
		return KeyUtil.generatePublicKey(algorithm, key);
	}

	/**
	 * 生成公钥，仅用于非对称加密

	 * 算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
	 *
	 * @param algorithm 算法
	 * @param keySpec   {@link KeySpec}
	 * @return 公钥 {@link PublicKey}
	 * @since 3.1.1
	 */
	public static PublicKey generatePublicKey(String algorithm, KeySpec keySpec) {
		return KeyUtil.generatePublicKey(algorithm, keySpec);
	}

	/**
	 * 生成用于非对称加密的公钥和私钥，仅用于非对称加密

	 * 密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
	 *
	 * @param algorithm 非对称加密算法
	 * @return {@link KeyPair}
	 */
	public static KeyPair generateKeyPair(String algorithm) {
		return KeyUtil.generateKeyPair(algorithm);
	}

	/**
	 * 生成用于非对称加密的公钥和私钥

	 * 密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
	 *
	 * @param algorithm 非对称加密算法
	 * @param keySize   密钥模（modulus ）长度
	 * @return {@link KeyPair}
	 */
	public static KeyPair generateKeyPair(String algorithm, int keySize) {
		return KeyUtil.generateKeyPair(algorithm, keySize);
	}

	/**
	 * 生成用于非对称加密的公钥和私钥

	 * 密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
	 *
	 * @param algorithm 非对称加密算法
	 * @param keySize   密钥模（modulus ）长度
	 * @param seed      种子
	 * @return {@link KeyPair}
	 */
	public static KeyPair generateKeyPair(String algorithm, int keySize, byte[] seed) {
		return KeyUtil.generateKeyPair(algorithm, keySize, seed);
	}

	/**
	 * 生成用于非对称加密的公钥和私钥

	 * 密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
	 *
	 * @param algorithm 非对称加密算法
	 * @param params    {@link AlgorithmParameterSpec}
	 * @return {@link KeyPair}
	 * @since 4.3.3
	 */
	public static KeyPair generateKeyPair(String algorithm, AlgorithmParameterSpec params) {
		return KeyUtil.generateKeyPair(algorithm, params);
	}

	/**
	 * 生成用于非对称加密的公钥和私钥

	 * 密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
	 *
	 * @param algorithm 非对称加密算法
	 * @param seed      种子
	 * @param params    {@link AlgorithmParameterSpec}
	 * @return {@link KeyPair}
	 * @since 4.3.3
	 */
	public static KeyPair generateKeyPair(String algorithm, byte[] seed, AlgorithmParameterSpec params) {
		return KeyUtil.generateKeyPair(algorithm, seed, params);
	}

	/**
	 * 获取用于密钥生成的算法

	 * 获取XXXwithXXX算法的后半部分算法，如果为ECDSA或SM2，返回算法为EC
	 *
	 * @param algorithm XXXwithXXX算法
	 * @return 算法
	 */
	public static String getAlgorithmAfterWith(String algorithm) {
		return KeyUtil.getAlgorithmAfterWith(algorithm);
	}











	/**
	 * 读取Certification文件

	 * Certification为证书文件

	 * see: http://snowolf.iteye.com/blog/391931
	 *
	 * @param type 类型，例如X.509
	 * @param in   {@link InputStream} 如果想从文件读取.cer文件，使用  读取
	 * @return {@link Certificate}
	 */
	public static Certificate readCertificate(String type, InputStream in) {
		return KeyUtil.readCertificate(type, in);
	}

	/**
	 * 获得 Certification
	 *
	 * @param keyStore {@link KeyStore}
	 * @param alias    别名
	 * @return {@link Certificate}
	 */
	public static Certificate getCertificate(KeyStore keyStore, String alias) {
		return KeyUtil.getCertificate(keyStore, alias);
	}


	// ------------------------------------------------------------------- 非称加密算法





	// ------------------------------------------------------------------- UUID



	/**
	 * 增加加密解密的算法提供者，默认优先使用，例如：
	 *
	 * 	 * addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
	 * 
	 *
	 * @param provider 算法提供者
	 * @since 4.1.22
	 */
	public static void addProvider(Provider provider) {
		Security.insertProviderAt(provider, 0);
	}





	// ------------------------- 新增方法------------------
	/**
	 * 生成一个新的重新设置大小的数组

	 * 调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，其它位置补充0，缩小则截断
	 *
	 * @param bytes   原数组
	 * @param newSize 新的数组大小
	 * @return 调整后的新数组
	 * @since 4.6.7
	 */
	public static byte[] resize(byte[] bytes, int newSize) {
		if (newSize < 0) {
			return bytes;
		}
		final byte[] newArray = new byte[newSize];
		if (newSize > 0 && isNotEmpty(bytes)) {
			System.arraycopy(bytes, 0, newArray, 0, Math.min(bytes.length, newSize));
		}
		return newArray;
	}

	/**
	 * 数组是否为非空
	 *
	 * @param array 数组
	 * @return 是否为非空
	 */
	public static boolean isNotEmpty(byte[] array) {
		return false == isEmpty(array);
	}

	/**
	 * 数组是否为空
	 *
	 * @param array 数组
	 * @return 是否为空
	 */
	public static boolean isEmpty(byte[] array) {
		return array == null || array.length == 0;
	}


	/**
	 * 创建Cipter对象
	 *
	 * @param algorithm  加密算法
	 * @return Cipter对象
	 */
	public static Cipher createCipher(String algorithm) {
		// TODO  bcprov-jdk15to18  用法
		final Provider provider = BouncyCastleProvider.INSTANCE.getProvider();
		Cipher cipher;
		try {
			cipher = (null == provider) ? Cipher.getInstance(algorithm) : Cipher.getInstance(algorithm, provider);
		} catch (Exception e) {
			throw new CryptException(e);
		}
		return cipher;
	}


	/**
	 * 创建Cipter对象
	 *
	 * @param algorithm  加密算法
	 * @param mode  加密模式
	 * @param padding 填充模式
	 * @return Cipter对象
	 */
	public static Cipher createCipher(SymmetricAlgorithm algorithm, Mode mode, Padding padding) {
		return createCipher(fmtAlgorithm(algorithm.name(),mode.name(),padding.name()));
	}



	/**
	 * 格式化算法
	 *
	 * @param algorithm  算法（如：AES，DES）
	 * @param mode    加密工作模式
	 * @param padding    填充模式
	 * @return 算法
	 */
	public static String fmtAlgorithm(SymmetricAlgorithm algorithm, Mode mode, Padding padding) {
		return String.format("%s/%s/%s", algorithm.name(), mode.name(), padding.name());
	}

	/**
	 * 格式化算法
	 *
	 * @param algorithm  算法（如：AES，DES）
	 * @param mode    加密工作模式
	 * @param padding    填充模式
	 * @return 算法
	 */
	private static String fmtAlgorithm(String algorithm, String mode, String padding) {
		return String.format("%s/%s/%s", algorithm, mode, padding);
	}

}