Builder (bus-crypto 6.3.1 API)

java.lang.Object
- org.aoju.bus.crypto.Builder

```
public class Builder
extends Object
```
加密解密模块，实现了对JDK中加密解密算法的封装安全相关工具／密钥工具类加密分为三种： 1、对称加密(symmetric)，例如：AES、DES等 2、非对称加密(asymmetric)，例如：RSA、DSA等 3、摘要加密(digest)，例如：MD5、SHA-1、SHA-256、HMAC等

Since:

JDK 1.8+

Version:

6.3.1

Author:

Kimi Liu

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`CERT_TYPE_X509` Certification类型：X.509
`static int`	`DEFAULT_KEY_SIZE` 默认密钥字节数
`static org.bouncycastle.asn1.ASN1ObjectIdentifier`	`ID_SM2_PUBLIC_KEY_PARAM` SM2国密算法公钥参数的Oid标识
`static String`	`KEY_TYPE_JKS` Java密钥库(Java Key Store，JKS)KEY_STORE
`static String`	`KEY_TYPE_PKCS12` PKCS12是公钥加密标准，它规定了可包含所有私钥、公钥和证书。其以二进制格式存储，也称为 PFX 文件
`static String`	`SM2_DEFAULT_CURVE` SM2默认曲线
`static org.bouncycastle.crypto.params.ECDomainParameters`	`SM2_DOMAIN_PARAMS` SM2推荐曲线参数（来自https://github.com/ZZMarquis/gmhelper）

Constructor Summary

Constructors
Constructor and Description

Builder()

Constructors
Constructor and Description
`Builder()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`addProvider(Provider provider)` 增加加密解密的算法提供者，默认优先使用，例如：
`static byte[]`	`changeC1C2C3ToC1C3C2(byte[] c1c2c3, org.bouncycastle.crypto.params.ECDomainParameters ecDomainParameters)` bc加解密使用旧标c1\|\|c2\|\|c3,此方法在加密后调用,将结果转化为c1\|\|c3\|\|c2
`static byte[]`	`changeC1C3C2ToC1C2C3(byte[] c1c3c2, org.bouncycastle.crypto.params.ECDomainParameters ecDomainParameters)` bc加解密使用旧标c1\|\|c3\|\|c2,此方法在解密前调用,将密文转化为c1\|\|c2\|\|c3再去解密
`static boolean`	`checkpw(String password, String hashed)` 验证密码是否与Bcrypt加密后的密文匹配
`static Cipher`	`createCipher(String algorithm)` 创建`Cipher`
`static MacEngine`	`createHmacSm3Engine(byte[] key)` 创建HmacSM3算法的`MacEngine`
`static Mac`	`createMac(String algorithm)` 创建`Mac`
`static MessageDigest`	`createMessageDigest(String algorithm)` 创建`MessageDigest`
`static KeySpec`	`createOpenSSHPrivateKeySpec(byte[] key)` 创建`OpenSSHPrivateKeySpec`
`static KeySpec`	`createOpenSSHPublicKeySpec(byte[] key)` 创建`OpenSSHPublicKeySpec`
`static Signature`	`createSignature(String algorithm)` 创建`Signature`
`static org.bouncycastle.asn1.ASN1Object`	`decode(InputStream in)` 读取ASN.1数据流为`ASN1Object`
`static byte[]`	`decode(String key)` 解码字符串密钥，可支持的编码如下：
`static PublicKey`	`decodeECPoint(byte[] encodeByte, String curveName)` 解码恢复EC压缩公钥,支持Base64和Hex编码,（基于BouncyCastle）
`static PublicKey`	`decodeECPoint(String encode, String curveName)` 解码恢复EC压缩公钥,支持Base64和Hex编码,（基于BouncyCastle）见：https://www.cnblogs.com/xinzhao/p/8963724.html
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`decodePrivateKeyParams(byte[] privateKeyBytes)` 尝试解析转换各种类型私钥为`ECPrivateKeyParameters`，支持包括： D值 PKCS#8 PKCS#1
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`decodePublicKeyParams(byte[] publicKeyBytes)` 尝试解析转换各种类型公钥为`ECPublicKeyParameters`，支持包括： Q值 X.509 PKCS#1
`static byte[]`	`decrypt(String algorithm, String key, byte[] content)` 数据解密
`static InputStream`	`decrypt(String algorithm, String key, InputStream inputStream)` 数据解密
`static String`	`decrypt(String algorithm, String key, String content, Charset charset)` 数据解密
`static Digester`	`digester(org.aoju.bus.core.lang.Algorithm algorithm)` 新建摘要器
`static Digester`	`digester(String algorithm)` 新建摘要器
`static byte[]`	`encode(org.bouncycastle.asn1.ASN1Encodable... elements)` 编码为DER格式
`static byte[]`	`encode(String asn1Encoding, org.bouncycastle.asn1.ASN1Encodable... elements)` 编码为指定ASN1格式
`static void`	`encode(String asn1Encoding, OutputStream out, org.bouncycastle.asn1.ASN1Encodable... elements)` 编码为指定ASN1格式
`static byte[]`	`encodeECPrivateKey(PrivateKey privateKey)` 只获取私钥里的d，32字节
`static byte[]`	`encodeECPublicKey(PublicKey publicKey)` 编码压缩EC公钥（基于BouncyCastle），即Q值见：https://www.cnblogs.com/xinzhao/p/8963724.html
`static byte[]`	`encodeECPublicKey(PublicKey publicKey, boolean isCompressed)` 编码压缩EC公钥（基于BouncyCastle），即Q值见：https://www.cnblogs.com/xinzhao/p/8963724.html
`static byte[]`	`encrypt(String algorithm, String key, byte[] content)` 数据加密
`static InputStream`	`encrypt(String algorithm, String key, InputStream inputStream)` 数据加密
`static String`	`encrypt(String algorithm, String key, String content, Charset charset)` 数据加密
`static SecretKey`	`generateDESKey(String algorithm, byte[] key)` 生成 `SecretKey`
`static SecretKey`	`generateKey(String algorithm)` 生成 `SecretKey`，仅用于对称加密和摘要算法密钥生成
`static SecretKey`	`generateKey(String algorithm, byte[] key)` 生成 `SecretKey`，仅用于对称加密和摘要算法密钥生成
`static SecretKey`	`generateKey(String algorithm, int keySize)` 生成 `SecretKey`，仅用于对称加密和摘要算法密钥生成当指定keySize<0时，AES默认长度为128，其它算法不指定。
`static SecretKey`	`generateKey(String algorithm, int keySize, SecureRandom random)` 生成 `SecretKey`，仅用于对称加密和摘要算法密钥生成当指定keySize<0时，AES默认长度为128，其它算法不指定。
`static SecretKey`	`generateKey(String algorithm, KeySpec keySpec)` 生成 `SecretKey`，仅用于对称加密和摘要算法
`static KeyPair`	`generateKeyPair(String algorithm)` 生成用于非对称加密的公钥和私钥，仅用于非对称加密密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
`static KeyPair`	`generateKeyPair(String algorithm, AlgorithmParameterSpec params)` 生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
`static KeyPair`	`generateKeyPair(String algorithm, byte[] seed, AlgorithmParameterSpec param)` 生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
`static KeyPair`	`generateKeyPair(String algorithm, int keySize)` 生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
`static KeyPair`	`generateKeyPair(String algorithm, int keySize, byte[] seed)` 生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
`static KeyPair`	`generateKeyPair(String algorithm, int keySize, byte[] seed, AlgorithmParameterSpec... params)` 生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
`static KeyPair`	`generateKeyPair(String algorithm, int keySize, SecureRandom random, AlgorithmParameterSpec... params)` 生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
`static SecretKey`	`generatePBEKey(String algorithm, char[] key)` 生成PBE `SecretKey`
`static PrivateKey`	`generatePrivateKey(KeyStore keyStore, String alias, char[] password)` 生成私钥，仅用于非对称加密
`static PrivateKey`	`generatePrivateKey(String algorithm, byte[] key)` 生成私钥，仅用于非对称加密采用PKCS#8规范，此规范定义了私钥信息语法和加密私钥语法算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
`static PrivateKey`	`generatePrivateKey(String algorithm, KeySpec keySpec)` 生成私钥，仅用于非对称加密算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
`static PublicKey`	`generatePublicKey(String algorithm, byte[] key)` 生成公钥，仅用于非对称加密采用X509证书规范算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
`static PublicKey`	`generatePublicKey(String algorithm, KeySpec keySpec)` 生成公钥，仅用于非对称加密算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
`static PrivateKey`	`generateRSAPrivateKey(byte[] key)` 生成RSA私钥，仅用于非对称加密采用PKCS#8规范，此规范定义了私钥信息语法和加密私钥语法算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
`static PublicKey`	`generateRSAPublicKey(byte[] key)` 生成RSA公钥，仅用于非对称加密采用X509证书规范算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
`static String`	`getAlgorithmAfterWith(String algorithm)` 获取用于密钥生成的算法获取XXXwithXXX算法的后半部分算法，如果为ECDSA或SM2，返回算法为EC
`static Certificate`	`getCertificate(KeyStore keyStore, String alias)` 获得 Certification
`static CertificateFactory`	`getCertificateFactory(String type)` 获取`CertificateFactory`
`static String`	`getDumpStr(InputStream in)` 获取ASN1格式的导出格式，一般用于调试
`static KeyFactory`	`getKeyFactory(String algorithm)` 获取`KeyFactory`
`static KeyGenerator`	`getKeyGenerator(String algorithm)` 获取`KeyGenerator`
`static KeyPair`	`getKeyPair(KeyStore keyStore, char[] password, String alias)` 从KeyStore中获取私钥公钥
`static KeyPair`	`getKeyPair(String type, InputStream in, char[] password, String alias)` 从KeyStore中获取私钥公钥
`static KeyPairGenerator`	`getKeyPairGenerator(String algorithm)` 获取`KeyPairGenerator`
`static String`	`getMainAlgorithm(String algorithm)` 获取主体算法名，例如RSA/ECB/PKCS1Padding的主体算法是RSA
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`getPublicParams(org.bouncycastle.crypto.params.ECPrivateKeyParameters privateKeyParameters)` 根据私钥参数获取公钥参数
`static PublicKey`	`getRSAPublicKey(BigInteger modulus, BigInteger publicExponent)` 获得RSA公钥对象
`static PublicKey`	`getRSAPublicKey(PrivateKey privateKey)` 通过RSA私钥生成RSA公钥
`static PublicKey`	`getRSAPublicKey(String modulus, String publicExponent)` 获得RSA公钥对象
`static SecretKeyFactory`	`getSecretKeyFactory(String algorithm)` 获取`SecretKeyFactory`
`static String`	`hashpw(String password)` 生成Bcrypt加密后的密文
`static HMac`	`hmac(org.aoju.bus.core.lang.Algorithm algorithm, byte[] key)` 创建HMac对象，调用digest方法可获得hmac值
`static HMac`	`hmac(org.aoju.bus.core.lang.Algorithm algorithm, SecretKey key)` 创建HMac对象，调用digest方法可获得hmac值
`static HMac`	`hmac(org.aoju.bus.core.lang.Algorithm algorithm, String key)` 创建HMac对象，调用digest方法可获得hmac值
`static HMac`	`hmacMd5()` HmacMD5加密器，生成随机KEY 例： HmacMD5加密：hmacMd5().digest(data) HmacMD5加密并转为16进制字符串：hmacMd5().digestHex(data)
`static HMac`	`hmacMd5(byte[] key)` HmacMD5加密器例： HmacMD5加密：hmacMd5(key).digest(data) HmacMD5加密并转为16进制字符串：hmacMd5(key).digestHex(data)
`static HMac`	`hmacMd5(String key)` HmacMD5加密器例： HmacMD5加密：hmacMd5(key).digest(data) HmacMD5加密并转为16进制字符串：hmacMd5(key).digestHex(data)
`static HMac`	`hmacSha1()` HmacSHA1加密器，生成随机KEY 例： HmacSHA1加密：hmacSha1().digest(data) HmacSHA1加密并转为16进制字符串：hmacSha1().digestHex(data)
`static HMac`	`hmacSha1(byte[] key)` HmacSHA1加密器例： HmacSHA1加密：hmacSha1(key).digest(data) HmacSHA1加密并转为16进制字符串：hmacSha1(key).digestHex(data)
`static HMac`	`hmacSha1(String key)` HmacSHA1加密器例： HmacSHA1加密：hmacSha1(key).digest(data) HmacSHA1加密并转为16进制字符串：hmacSha1(key).digestHex(data)
`static HMac`	`hmacSha256()` HmacSHA256加密器，生成随机KEY 例： HmacSHA256加密：hmacSha256().digest(data) HmacSHA256加密并转为16进制字符串：hmacSha256().digestHex(data)
`static HMac`	`hmacSha256(byte[] key)` HmacSHA256加密器例： HmacSHA256加密：hmacSha256(key).digest(data) HmacSHA256加密并转为16进制字符串：hmacSha256(key).digestHex(data)
`static HMac`	`hmacSha256(String key)` HmacSHA256加密器例： HmacSHA256加密：hmacSha256(key).digest(data) HmacSHA256加密并转为16进制字符串：hmacSha256(key).digestHex(data)
`static MD5`	`md5()` MD5加密例：
`static byte[]`	`md5(byte[] data)` 计算32位MD5摘要值
`static byte[]`	`md5(File file)` 计算32位MD5摘要值
`static byte[]`	`md5(InputStream data)` 计算32位MD5摘要值
`static byte[]`	`md5(String data)` 计算32位MD5摘要值，使用UTF-8编码
`static byte[]`	`md5(String data, String charset)` 计算32位MD5摘要值
`static String`	`md5Hex(byte[] data)` 计算32位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex(File file)` 计算32位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex(InputStream data)` 计算32位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex(String data)` 计算32位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex(String data, Charset charset)` 计算32位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex(String data, String charset)` 计算32位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex16(byte[] data)` 计算16位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex16(File file)` 计算16位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex16(InputStream data)` 计算16位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex16(String data)` 计算16位MD5摘要值，并转为16进制字符串
`static String`	`md5Hex16(String data, Charset charset)` 计算16位MD5摘要值，并转为16进制字符串
`static String`	`md5HexTo16(String md5Hex)` 32位MD5转16位MD5
`static Certificate`	`readCertificate(String type, InputStream in)` 读取Certification文件 Certification为证书文件 see: http://snowolf.iteye.com/blog/391931
`static Certificate`	`readCertificate(String type, InputStream in, char[] password, String alias)` 读取Certification文件 Certification为证书文件 see: http://snowolf.iteye.com/blog/391931
`static KeyStore`	`readJKSKeyStore(File keyFile, char[] password)` 读取密钥库(Java Key Store，JKS) KeyStore文件 KeyStore文件用于数字证书的密钥对保存 see: http://snowolf.iteye.com/blog/391931
`static KeyStore`	`readJKSKeyStore(InputStream in, char[] password)` 读取密钥库(Java Key Store，JKS) KeyStore文件 KeyStore文件用于数字证书的密钥对保存 see: http://snowolf.iteye.com/blog/391931
`static KeyStore`	`readKeyStore(String type, File keyFile, char[] password)` 读取KeyStore文件 KeyStore文件用于数字证书的密钥对保存 see: http://snowolf.iteye.com/blog/391931
`static KeyStore`	`readKeyStore(String type, InputStream in, char[] password)` 读取KeyStore文件 KeyStore文件用于数字证书的密钥对保存 see: http://snowolf.iteye.com/blog/391931
`static byte[]`	`readPem(InputStream keyStream)` 从pem流中读取公钥或私钥
`static Key`	`readPemKey(InputStream keyStream)` 从pem文件中读取公钥或私钥根据类型返回`PublicKey` 或者 `PrivateKey`
`static org.bouncycastle.util.io.pem.PemObject`	`readPemObject(InputStream keyStream)` 读取pem文件中的信息，包括类型、头信息和密钥内容
`static org.bouncycastle.util.io.pem.PemObject`	`readPemObject(Reader reader)` 读取pem文件中的信息，包括类型、头信息和密钥内容
`static KeyStore`	`readPKCS12KeyStore(File keyFile, char[] password)` 读取PKCS12 KeyStore文件 KeyStore文件用于数字证书的密钥对保存
`static KeyStore`	`readPKCS12KeyStore(InputStream in, char[] password)` 读取PKCS12 KeyStore文件 KeyStore文件用于数字证书的密钥对保存
`static PrivateKey`	`readPrivateKey(InputStream pemStream)` 读取PEM格式的私钥
`static PublicKey`	`readPublicKey(InputStream pemStream)` 读取PEM格式的公钥
`static PublicKey`	`readPublicKeyFromCert(InputStream in)` 读取X.509 Certification文件中的公钥 Certification为证书文件 see: https://www.cnblogs.com/yinliang/p/10115519.html
`static PrivateKey`	`readSm2PemPrivateKey(InputStream keyStream)` 读取OpenSSL生成的ANS1格式的Pem私钥文件，必须为PKCS#1格式
`static Certificate`	`readX509Certificate(InputStream in)` 读取X.509 Certification文件 Certification为证书文件 see: http://snowolf.iteye.com/blog/391931
`static Certificate`	`readX509Certificate(InputStream in, char[] password, String alias)` 读取X.509 Certification文件 Certification为证书文件 see: http://snowolf.iteye.com/blog/391931
`static RSA`	`rsa()` 创建RSA算法对象生成新的私钥公钥对
`static RSA`	`rsa(byte[] privateKey, byte[] publicKey)` 创建RSA算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
`static RSA`	`rsa(String privateKey, String publicKey)` 创建RSA算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个,如此则只能使用此钥匙来做加密或者解密
`static byte[]`	`rsAsn1ToPlain(byte[] rsDer)` BC的SM3withSM2签名得到的结果的rs是asn1格式的,这个方法转化成直接拼接r\|\|s
`static byte[]`	`rsPlainToAsn1(byte[] sign)` BC的SM3withSM2验签需要的rs是asn1格式的，这个方法将直接拼接r\|\|s的字节数组转化成asn1格式
`static Digester`	`sha1()` SHA1加密例： SHA1加密：sha1().digest(data) SHA1加密并转为16进制字符串：sha1().digestHex(data)
`static byte[]`	`sha1(byte[] data)` 计算SHA-1摘要值
`static byte[]`	`sha1(File file)` 计算SHA-1摘要值
`static byte[]`	`sha1(InputStream data)` 计算SHA-1摘要值
`static byte[]`	`sha1(String data)` 计算sha1摘要值，使用UTF-8编码
`static byte[]`	`sha1(String data, String charset)` 计算SHA-1摘要值
`static String`	`sha1Hex(byte[] data)` 计算SHA-1摘要值，并转为16进制字符串
`static String`	`sha1Hex(File file)` 计算SHA-1摘要值，并转为16进制字符串
`static String`	`sha1Hex(InputStream data)` 计算SHA-1摘要值，并转为16进制字符串
`static String`	`sha1Hex(String data)` 计算SHA-1摘要值，并转为16进制字符串
`static String`	`sha1Hex(String data, String charset)` 计算SHA-1摘要值，并转为16进制字符串
`static Digester`	`sha256()` SHA256加密例： SHA256加密：sha256().digest(data) SHA256加密并转为16进制字符串：sha256().digestHex(data)
`static byte[]`	`sha256(byte[] data)` 计算SHA-256摘要值
`static byte[]`	`sha256(File file)` 计算SHA-256摘要值
`static byte[]`	`sha256(InputStream data)` 计算SHA-256摘要值
`static byte[]`	`sha256(String data)` 计算sha256摘要值，使用UTF-8编码
`static byte[]`	`sha256(String data, String charset)` 计算SHA-256摘要值
`static String`	`sha256Hex(byte[] data)` 计算SHA-1摘要值，并转为16进制字符串
`static String`	`sha256Hex(File file)` 计算SHA-256摘要值，并转为16进制字符串
`static String`	`sha256Hex(InputStream data)` 计算SHA-256摘要值，并转为16进制字符串
`static String`	`sha256Hex(String data)` 计算SHA-256摘要值，并转为16进制字符串
`static String`	`sha256Hex(String data, String charset)` 计算SHA-256摘要值，并转为16进制字符串
`static Sign`	`sign(org.aoju.bus.core.lang.Algorithm algorithm)` 创建签名算法对象生成新的私钥公钥对
`static Sign`	`sign(org.aoju.bus.core.lang.Algorithm algorithm, byte[] privateKey, byte[] publicKey)` 创建Sign算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
`static Sign`	`sign(org.aoju.bus.core.lang.Algorithm algorithm, String privateKey, String publicKey)` 创建签名算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个,如此则只能使用此钥匙来做签名或验证
`static String`	`signParams(org.aoju.bus.core.lang.Algorithm algorithm, Map<?,?> params, String... other)` 对参数做签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
`static String`	`signParams(org.aoju.bus.core.lang.Algorithm algorithm, Map<?,?> params, String separator, String keyValueSeparator, boolean isIgnoreNull, String... other)` 对参数做签名参数签名为对Map参数按照key的顺序排序后拼接为字符串,然后根据提供的签名算法生成签名字符串
`static String`	`signParams(Crypto crypto, Map<?,?> params, String... other)` 对参数做签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
`static String`	`signParams(Crypto crypto, Map<?,?> params, String separator, String keyValueSeparator, boolean isIgnoreNull, String... other)` 对参数做签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串
`static String`	`signParamsMd5(Map<?,?> params, String... other)` 对参数做md5签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
`static String`	`signParamsSha1(Map<?,?> params, String... other)` 对参数做Sha1签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
`static String`	`signParamsSha256(Map<?,?> params, String... other)` 对参数做Sha256签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
`static SM2`	`sm2()` 创建SM2算法对象生成新的私钥公钥对
`static SM2`	`sm2(byte[] privateKey, byte[] publicKey)` 创建SM2算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
`static SM2`	`sm2(org.bouncycastle.crypto.params.ECPrivateKeyParameters privateKeyParams, org.bouncycastle.crypto.params.ECPublicKeyParameters publicKeyParams)` 创建SM2算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
`static SM2`	`sm2(PrivateKey privateKey, PublicKey publicKey)` 创建SM2算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
`static SM2`	`sm2(String privateKey, String publicKey)` 创建SM2算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个,如此则只能使用此钥匙来做加密或者解密
`static SM3`	`sm3()` SM3加密例： SM3加密：sm3().digest(data) SM3加密并转为16进制字符串：sm3().digestHex(data)
`static SM3`	`sm3(byte[] salt)` SM3加密，可以传入盐
`static String`	`sm3(File dataFile)` SM3加密文件，生成16进制SM3字符串
`static String`	`sm3(InputStream data)` SM3加密，生成16进制SM3字符串
`static String`	`sm3(String data)` SM3加密，生成16进制SM3字符串
`static SM4`	`sm4()` SM4加密,生成随机KEY 注意解密时必须使用相同 `SM4`对象或者使用相同KEY 例：
`static SM4`	`sm4(byte[] key)` SM4加密例：
`static org.bouncycastle.crypto.params.ECDomainParameters`	`toDomainParams(org.bouncycastle.jce.spec.ECParameterSpec parameterSpec)` 构建ECDomainParameters对象
`static org.bouncycastle.crypto.params.ECDomainParameters`	`toDomainParams(String curveName)` 构建ECDomainParameters对象
`static org.bouncycastle.crypto.params.ECDomainParameters`	`toDomainParams(org.bouncycastle.asn1.x9.X9ECParameters x9ECParameters)` 构建ECDomainParameters对象
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toParams(BigInteger x, BigInteger y, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toParams(BigInteger d, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toParams(byte[] xBytes, byte[] yBytes, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toParams(byte[] d, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.AsymmetricKeyParameter`	`toParams(Key key)` 密钥转换为AsymmetricKeyParameter
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toParams(PrivateKey privateKey)` 私钥转换为 `ECPrivateKeyParameters`
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toParams(PublicKey publicKey)` 公钥转换为 `ECPublicKeyParameters`
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toParams(String dHex, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toParams(String xHex, String yHex, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static String`	`toPem(String type, byte[] content)` 将私钥或公钥转换为PEM格式的字符串
`static byte[]`	`toPkcs1(PrivateKey privateKey)` Java中的PKCS#8格式私钥转换为OpenSSL支持的PKCS#1格式
`static byte[]`	`toPkcs1(PublicKey publicKey)` Java中的X.509格式公钥转换为OpenSSL支持的PKCS#1格式
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toPrivateParams(BigInteger d, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toPrivateParams(byte[] d, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toPrivateParams(PrivateKey privateKey)` 私钥转换为 `ECPrivateKeyParameters`
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toPrivateParams(String d, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toPublicParams(BigInteger x, BigInteger y, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toPublicParams(byte[] xBytes, byte[] yBytes, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toPublicParams(byte[] pointEncoded, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toPublicParams(org.bouncycastle.math.ec.ECPoint point, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toPublicParams(PublicKey publicKey)` 公钥转换为 `ECPublicKeyParameters`
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toPublicParams(String pointEncoded, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toPublicParams(String x, String y, org.bouncycastle.crypto.params.ECDomainParameters domainParameters)` 转换为ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toSm2Params(BigInteger d)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toSm2Params(byte[] d)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toSm2Params(byte[] xBytes, byte[] yBytes)` 转换为SM2的ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toSm2Params(String d)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toSm2Params(String xHex, String yHex)` 转换为SM2的ECPublicKeyParameters
`static PrivateKey`	`toSm2PrivateKey(org.bouncycastle.asn1.sec.ECPrivateKey privateKey)` 将SM2算法的`ECPrivateKey` 转换为 `PrivateKey`
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toSm2PrivateParams(BigInteger d)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toSm2PrivateParams(byte[] d)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPrivateKeyParameters`	`toSm2PrivateParams(String d)` 转换为 ECPrivateKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toSm2PublicParams(byte[] q)` 转换为 ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toSm2PublicParams(byte[] xBytes, byte[] yBytes)` 转换为SM2的ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toSm2PublicParams(String q)` 转换为 ECPublicKeyParameters
`static org.bouncycastle.crypto.params.ECPublicKeyParameters`	`toSm2PublicParams(String x, String y)` 转换为SM2的ECPublicKeyParameters
`static void`	`writePemObject(org.bouncycastle.util.io.pem.PemObjectGenerator pemObject, OutputStream keyStream)` 写出pem密钥（私钥、公钥、证书）
`static void`	`writePemObject(org.bouncycastle.util.io.pem.PemObjectGenerator pemObject, Writer writer)` 写出pem密钥（私钥、公钥、证书）
`static void`	`writePemObject(String type, byte[] content, OutputStream keyStream)` 写出pem密钥（私钥、公钥、证书）
`static void`	`writePemObject(String type, byte[] content, Writer writer)` 写出pem密钥（私钥、公钥、证书）

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - KEY_TYPE_JKS
```
public static final String KEY_TYPE_JKS
```
    Java密钥库(Java Key Store，JKS)KEY_STORE
    
    See Also:
    
    Constant Field Values
  - KEY_TYPE_PKCS12
```
public static final String KEY_TYPE_PKCS12
```
    PKCS12是公钥加密标准，它规定了可包含所有私钥、公钥和证书。其以二进制格式存储，也称为 PFX 文件
    
    See Also:
    
    Constant Field Values
  - CERT_TYPE_X509
```
public static final String CERT_TYPE_X509
```
    Certification类型：X.509
    
    See Also:
    
    Constant Field Values
  - DEFAULT_KEY_SIZE
```
public static final int DEFAULT_KEY_SIZE
```
    默认密钥字节数
```
 RSA/DSA
 Default Keysize 1024
 Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).
 
```
    See Also:
    
    Constant Field Values
  - SM2_DEFAULT_CURVE
```
public static final String SM2_DEFAULT_CURVE
```
    SM2默认曲线
```
 Default SM2 curve
 
```
    See Also:
    
    Constant Field Values
  - SM2_DOMAIN_PARAMS
```
public static final org.bouncycastle.crypto.params.ECDomainParameters SM2_DOMAIN_PARAMS
```
    SM2推荐曲线参数（来自https://github.com/ZZMarquis/gmhelper）
  - ID_SM2_PUBLIC_KEY_PARAM
```
public static final org.bouncycastle.asn1.ASN1ObjectIdentifier ID_SM2_PUBLIC_KEY_PARAM
```
    SM2国密算法公钥参数的Oid标识
- Constructor Detail
  - Builder
```
public Builder()
```
- Method Detail
  - md5
```
public static MD5 md5()
```
    MD5加密例：
```
 MD5加密：md5().digest(data)
 MD5加密并转为16进制字符串：md5().digestHex(data)
 
```
    Returns:
    
    Digester
  - md5
```
public static byte[] md5(byte[] data)
```
    计算32位MD5摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要
  - md5
```
public static byte[] md5(String data,
                         String charset)
```
    计算32位MD5摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    charset - 编码
    
    Returns:
    
    MD5摘要
  - md5
```
public static byte[] md5(String data)
```
    计算32位MD5摘要值，使用UTF-8编码
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要
  - md5
```
public static byte[] md5(InputStream data)
```
    计算32位MD5摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要
  - md5
```
public static byte[] md5(File file)
```
    计算32位MD5摘要值
    
    Parameters:
    
    file - 被摘要文件
    
    Returns:
    
    MD5摘要
  - md5Hex
```
public static String md5Hex(byte[] data)
```
    计算32位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex
```
public static String md5Hex(String data,
                            String charset)
```
    计算32位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    charset - 编码
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex
```
public static String md5Hex(String data,
                            Charset charset)
```
    计算32位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    charset - 编码
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex
```
public static String md5Hex(String data)
```
    计算32位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex
```
public static String md5Hex(InputStream data)
```
    计算32位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex
```
public static String md5Hex(File file)
```
    计算32位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    file - 被摘要文件
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex16
```
public static String md5Hex16(byte[] data)
```
    计算16位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex16
```
public static String md5Hex16(String data,
                              Charset charset)
```
    计算16位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    charset - 编码
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex16
```
public static String md5Hex16(String data)
```
    计算16位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex16
```
public static String md5Hex16(InputStream data)
```
    计算16位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要的16进制表示
  - md5Hex16
```
public static String md5Hex16(File file)
```
    计算16位MD5摘要值，并转为16进制字符串
    
    Parameters:
    
    file - 被摘要文件
    
    Returns:
    
    MD5摘要的16进制表示
  - md5HexTo16
```
public static String md5HexTo16(String md5Hex)
```
    32位MD5转16位MD5
    
    Parameters:
    
    md5Hex - 32位MD5
    
    Returns:
    
    16位MD5
  - sha1
```
public static Digester sha1()
```
    SHA1加密例： SHA1加密：sha1().digest(data) SHA1加密并转为16进制字符串：sha1().digestHex(data)
    
    Returns:
    
    Digester
  - sha1
```
public static byte[] sha1(byte[] data)
```
    计算SHA-1摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-1摘要
  - sha1
```
public static byte[] sha1(String data,
                          String charset)
```
    计算SHA-1摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    charset - 编码
    
    Returns:
    
    SHA-1摘要
  - sha1
```
public static byte[] sha1(String data)
```
    计算sha1摘要值，使用UTF-8编码
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要
  - sha1
```
public static byte[] sha1(InputStream data)
```
    计算SHA-1摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-1摘要
  - sha1
```
public static byte[] sha1(File file)
```
    计算SHA-1摘要值
    
    Parameters:
    
    file - 被摘要文件
    
    Returns:
    
    SHA-1摘要
  - sha1Hex
```
public static String sha1Hex(byte[] data)
```
    计算SHA-1摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-1摘要的16进制表示
  - sha1Hex
```
public static String sha1Hex(String data,
                             String charset)
```
    计算SHA-1摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    charset - 编码
    
    Returns:
    
    SHA-1摘要的16进制表示
  - sha1Hex
```
public static String sha1Hex(String data)
```
    计算SHA-1摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-1摘要的16进制表示
  - sha1Hex
```
public static String sha1Hex(InputStream data)
```
    计算SHA-1摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-1摘要的16进制表示
  - sha1Hex
```
public static String sha1Hex(File file)
```
    计算SHA-1摘要值，并转为16进制字符串
    
    Parameters:
    
    file - 被摘要文件
    
    Returns:
    
    SHA-1摘要的16进制表示
  - sha256
```
public static Digester sha256()
```
    SHA256加密例： SHA256加密：sha256().digest(data) SHA256加密并转为16进制字符串：sha256().digestHex(data)
    
    Returns:
    
    Digester
  - sha256
```
public static byte[] sha256(byte[] data)
```
    计算SHA-256摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-256摘要
  - sha256
```
public static byte[] sha256(String data,
                            String charset)
```
    计算SHA-256摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    charset - 编码
    
    Returns:
    
    SHA-256摘要
  - sha256
```
public static byte[] sha256(String data)
```
    计算sha256摘要值，使用UTF-8编码
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    MD5摘要
  - sha256
```
public static byte[] sha256(InputStream data)
```
    计算SHA-256摘要值
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-256摘要
  - sha256
```
public static byte[] sha256(File file)
```
    计算SHA-256摘要值
    
    Parameters:
    
    file - 被摘要文件
    
    Returns:
    
    SHA-256摘要
  - sha256Hex
```
public static String sha256Hex(byte[] data)
```
    计算SHA-1摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-256摘要的16进制表示
  - sha256Hex
```
public static String sha256Hex(String data,
                               String charset)
```
    计算SHA-256摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    charset - 编码
    
    Returns:
    
    SHA-256摘要的16进制表示
  - sha256Hex
```
public static String sha256Hex(String data)
```
    计算SHA-256摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-256摘要的16进制表示
  - sha256Hex
```
public static String sha256Hex(InputStream data)
```
    计算SHA-256摘要值，并转为16进制字符串
    
    Parameters:
    
    data - 被摘要数据
    
    Returns:
    
    SHA-256摘要的16进制表示
  - sha256Hex
```
public static String sha256Hex(File file)
```
    计算SHA-256摘要值，并转为16进制字符串
    
    Parameters:
    
    file - 被摘要文件
    
    Returns:
    
    SHA-256摘要的16进制表示
  - hmac
```
public static HMac hmac(org.aoju.bus.core.lang.Algorithm algorithm,
                        String key)
```
    创建HMac对象，调用digest方法可获得hmac值
    
    Parameters:
    
    algorithm - Algorithm
    
    key - 密钥，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmac
```
public static HMac hmac(org.aoju.bus.core.lang.Algorithm algorithm,
                        byte[] key)
```
    创建HMac对象，调用digest方法可获得hmac值
    
    Parameters:
    
    algorithm - Algorithm
    
    key - 密钥，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmac
```
public static HMac hmac(org.aoju.bus.core.lang.Algorithm algorithm,
                        SecretKey key)
```
    创建HMac对象，调用digest方法可获得hmac值
    
    Parameters:
    
    algorithm - Algorithm
    
    key - 密钥SecretKey，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmacMd5
```
public static HMac hmacMd5(String key)
```
    HmacMD5加密器例： HmacMD5加密：hmacMd5(key).digest(data) HmacMD5加密并转为16进制字符串：hmacMd5(key).digestHex(data)
    
    Parameters:
    
    key - 加密密钥，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmacMd5
```
public static HMac hmacMd5(byte[] key)
```
    HmacMD5加密器例： HmacMD5加密：hmacMd5(key).digest(data) HmacMD5加密并转为16进制字符串：hmacMd5(key).digestHex(data)
    
    Parameters:
    
    key - 加密密钥，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmacMd5
```
public static HMac hmacMd5()
```
    HmacMD5加密器，生成随机KEY 例： HmacMD5加密：hmacMd5().digest(data) HmacMD5加密并转为16进制字符串：hmacMd5().digestHex(data)
    
    Returns:
    
    HMac
  - hmacSha1
```
public static HMac hmacSha1(String key)
```
    HmacSHA1加密器例： HmacSHA1加密：hmacSha1(key).digest(data) HmacSHA1加密并转为16进制字符串：hmacSha1(key).digestHex(data)
    
    Parameters:
    
    key - 加密密钥，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmacSha1
```
public static HMac hmacSha1(byte[] key)
```
    HmacSHA1加密器例： HmacSHA1加密：hmacSha1(key).digest(data) HmacSHA1加密并转为16进制字符串：hmacSha1(key).digestHex(data)
    
    Parameters:
    
    key - 加密密钥，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmacSha1
```
public static HMac hmacSha1()
```
    HmacSHA1加密器，生成随机KEY 例： HmacSHA1加密：hmacSha1().digest(data) HmacSHA1加密并转为16进制字符串：hmacSha1().digestHex(data)
    
    Returns:
    
    HMac
  - hmacSha256
```
public static HMac hmacSha256(String key)
```
    HmacSHA256加密器例： HmacSHA256加密：hmacSha256(key).digest(data) HmacSHA256加密并转为16进制字符串：hmacSha256(key).digestHex(data)
    
    Parameters:
    
    key - 加密密钥，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmacSha256
```
public static HMac hmacSha256(byte[] key)
```
    HmacSHA256加密器例： HmacSHA256加密：hmacSha256(key).digest(data) HmacSHA256加密并转为16进制字符串：hmacSha256(key).digestHex(data)
    
    Parameters:
    
    key - 加密密钥，如果为null生成随机密钥
    
    Returns:
    
    HMac
  - hmacSha256
```
public static HMac hmacSha256()
```
    HmacSHA256加密器，生成随机KEY 例： HmacSHA256加密：hmacSha256().digest(data) HmacSHA256加密并转为16进制字符串：hmacSha256().digestHex(data)
    
    Returns:
    
    HMac
  - rsa
```
public static RSA rsa()
```
    创建RSA算法对象生成新的私钥公钥对
    
    Returns:
    
    RSA
  - rsa
```
public static RSA rsa(String privateKey,
                      String publicKey)
```
    创建RSA算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个,如此则只能使用此钥匙来做加密或者解密
    
    Parameters:
    
    privateKey - 私钥Base64
    
    publicKey - 公钥Base64
    
    Returns:
    
    RSA
  - rsa
```
public static RSA rsa(byte[] privateKey,
                      byte[] publicKey)
```
    创建RSA算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
    
    Parameters:
    
    privateKey - 私钥
    
    publicKey - 公钥
    
    Returns:
    
    RSA
  - sign
```
public static Sign sign(org.aoju.bus.core.lang.Algorithm algorithm)
```
    创建签名算法对象生成新的私钥公钥对
    
    Parameters:
    
    algorithm - 签名算法
    
    Returns:
    
    Sign
  - sign
```
public static Sign sign(org.aoju.bus.core.lang.Algorithm algorithm,
                        String privateKey,
                        String publicKey)
```
    创建签名算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个,如此则只能使用此钥匙来做签名或验证
    
    Parameters:
    
    algorithm - 签名算法
    
    privateKey - 私钥Base64
    
    publicKey - 公钥Base64
    
    Returns:
    
    Sign
  - sign
```
public static Sign sign(org.aoju.bus.core.lang.Algorithm algorithm,
                        byte[] privateKey,
                        byte[] publicKey)
```
    创建Sign算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
    
    Parameters:
    
    algorithm - 算法枚举
    
    privateKey - 私钥
    
    publicKey - 公钥
    
    Returns:
    
    Sign
  - digester
```
public static Digester digester(org.aoju.bus.core.lang.Algorithm algorithm)
```
    新建摘要器
    
    Parameters:
    
    algorithm - 签名算法
    
    Returns:
    
    Digester
  - digester
```
public static Digester digester(String algorithm)
```
    新建摘要器
    
    Parameters:
    
    algorithm - 签名算法
    
    Returns:
    
    Digester
  - sm2
```
public static SM2 sm2()
```
    创建SM2算法对象生成新的私钥公钥对
    
    Returns:
    
    SM2
  - sm2
```
public static SM2 sm2(String privateKey,
                      String publicKey)
```
    创建SM2算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个,如此则只能使用此钥匙来做加密或者解密
    
    Parameters:
    
    privateKey - 私钥Hex或Base64表示
    
    publicKey - 公钥Hex或Base64表示
    
    Returns:
    
    SM2
  - sm2
```
public static SM2 sm2(byte[] privateKey,
                      byte[] publicKey)
```
    创建SM2算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
    
    Parameters:
    
    privateKey - 私钥，必须使用PKCS#8规范
    
    publicKey - 公钥，必须使用X509规范
    
    Returns:
    
    SM2
  - sm2
```
public static SM2 sm2(PrivateKey privateKey,
                      PublicKey publicKey)
```
    创建SM2算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
    
    Parameters:
    
    privateKey - 私钥
    
    publicKey - 公钥
    
    Returns:
    
    SM2
  - sm2
```
public static SM2 sm2(org.bouncycastle.crypto.params.ECPrivateKeyParameters privateKeyParams,
                      org.bouncycastle.crypto.params.ECPublicKeyParameters publicKeyParams)
```
    创建SM2算法对象私钥和公钥同时为空时生成一对新的私钥和公钥私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
    
    Parameters:
    
    privateKeyParams - 私钥参数
    
    publicKeyParams - 公钥参数
    
    Returns:
    
    SM2
  - sm3
```
public static SM3 sm3()
```
    SM3加密例： SM3加密：sm3().digest(data) SM3加密并转为16进制字符串：sm3().digestHex(data)
    
    Returns:
    
    SM3
  - sm3
```
public static String sm3(String data)
```
    SM3加密，生成16进制SM3字符串
    
    Parameters:
    
    data - 数据
    
    Returns:
    
    SM3字符串
  - sm3
```
public static SM3 sm3(byte[] salt)
```
    SM3加密，可以传入盐
    
    Parameters:
    
    salt - 加密盐
    
    Returns:
    
    SM3
  - sm3
```
public static String sm3(InputStream data)
```
    SM3加密，生成16进制SM3字符串
    
    Parameters:
    
    data - 数据
    
    Returns:
    
    SM3字符串
  - sm3
```
public static String sm3(File dataFile)
```
    SM3加密文件，生成16进制SM3字符串
    
    Parameters:
    
    dataFile - 被加密文件
    
    Returns:
    
    SM3字符串
  - sm4
```
public static SM4 sm4()
```
    SM4加密,生成随机KEY 注意解密时必须使用相同 SM4对象或者使用相同KEY 例：
```
 SM4加密：sm4().encrypt(data)
 SM4解密：sm4().decrypt(data)
 
```
    Returns:
    
    SM4
  - sm4
```
public static SM4 sm4(byte[] key)
```
    SM4加密例：
```
 SM4加密：sm4(key).encrypt(data)
 SM4解密：sm4(key).decrypt(data)
 
```
    Parameters:
    
    key - 密钥
    
    Returns:
    
    SM4
  - encrypt
```
public static byte[] encrypt(String algorithm,
                             String key,
                             byte[] content)
```
    数据加密
    
    Parameters:
    
    algorithm - 加密算法
    
    key - 密钥, 字符串使用,分割格式: 私钥,公钥,类型
    
    content - 需要加密的内容
    
    Returns:
    
    加密结果
  - encrypt
```
public static String encrypt(String algorithm,
                             String key,
                             String content,
                             Charset charset)
```
    数据加密
    
    Parameters:
    
    algorithm - 解密算法
    
    key - 密钥, 字符串使用,分割格式: 私钥,公钥,类型
    
    content - 需要加密的内容
    
    charset - 字符集
    
    Returns:
    
    加密结果
  - encrypt
```
public static InputStream encrypt(String algorithm,
                                  String key,
                                  InputStream inputStream)
```
    数据加密
    
    Parameters:
    
    algorithm - 加密算法
    
    key - 密钥, 字符串使用,分割格式: 私钥,公钥,类型
    
    inputStream - 需要加密的内容
    
    Returns:
    
    加密结果
  - decrypt
```
public static byte[] decrypt(String algorithm,
                             String key,
                             byte[] content)
```
    数据解密
    
    Parameters:
    
    algorithm - 加密算法
    
    key - 密钥, 字符串使用,分割格式: 私钥,公钥,类型
    
    content - 需要解密的内容
    
    Returns:
    
    解密结果
  - decrypt
```
public static String decrypt(String algorithm,
                             String key,
                             String content,
                             Charset charset)
```
    数据解密
    
    Parameters:
    
    algorithm - 解密算法
    
    key - 密钥, 字符串使用,分割格式: 私钥,公钥,类型
    
    content - 需要解密的内容
    
    charset - 字符集
    
    Returns:
    
    解密结果
  - decrypt
```
public static InputStream decrypt(String algorithm,
                                  String key,
                                  InputStream inputStream)
```
    数据解密
    
    Parameters:
    
    algorithm - 解密算法
    
    key - 密钥, 字符串使用,分割格式: 私钥,公钥,类型
    
    inputStream - 需要解密的内容
    
    Returns:
    
    解密结果
  - encode
```
public static byte[] encode(org.bouncycastle.asn1.ASN1Encodable... elements)
```
    编码为DER格式
    
    Parameters:
    
    elements - ASN.1元素
    
    Returns:
    
    编码后的bytes
  - encode
```
public static byte[] encode(String asn1Encoding,
                            org.bouncycastle.asn1.ASN1Encodable... elements)
```
    编码为指定ASN1格式
    
    Parameters:
    
    asn1Encoding - 编码格式，见ASN1Encoding，可选DER、BER或DL
    
    elements - ASN.1元素
    
    Returns:
    
    编码后的bytes
  - encode
```
public static void encode(String asn1Encoding,
                          OutputStream out,
                          org.bouncycastle.asn1.ASN1Encodable... elements)
```
    编码为指定ASN1格式
    
    Parameters:
    
    asn1Encoding - 编码格式，见ASN1Encoding，可选DER、BER或DL
    
    out - 输出流
    
    elements - ASN.1元素
  - decode
```
public static org.bouncycastle.asn1.ASN1Object decode(InputStream in)
```
    读取ASN.1数据流为ASN1Object
    
    Parameters:
    
    in - ASN.1数据
    
    Returns:
    
    ASN1Object
  - getDumpStr
```
public static String getDumpStr(InputStream in)
```
    获取ASN1格式的导出格式，一般用于调试
    
    Parameters:
    
    in - ASN.1数据
    
    Returns:
    
    ASN1Object的字符串表示形式
    
    See Also:
    
    ASN1Dump.dumpAsString(Object)
  - encodeECPrivateKey
```
public static byte[] encodeECPrivateKey(PrivateKey privateKey)
```
    只获取私钥里的d，32字节
    
    Parameters:
    
    privateKey - PublicKey，必须为org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey
    
    Returns:
    
    压缩得到的X
  - encodeECPublicKey
```
public static byte[] encodeECPublicKey(PublicKey publicKey)
```
    编码压缩EC公钥（基于BouncyCastle），即Q值见：https://www.cnblogs.com/xinzhao/p/8963724.html
    
    Parameters:
    
    publicKey - PublicKey，必须为org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey
    
    Returns:
    
    压缩得到的Q
  - encodeECPublicKey
```
public static byte[] encodeECPublicKey(PublicKey publicKey,
                                       boolean isCompressed)
```
    编码压缩EC公钥（基于BouncyCastle），即Q值见：https://www.cnblogs.com/xinzhao/p/8963724.html
    
    Parameters:
    
    publicKey - PublicKey，必须为org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey
    
    isCompressed - 是否压缩
    
    Returns:
    
    得到的Q
  - decode
```
public static byte[] decode(String key)
```
    解码字符串密钥，可支持的编码如下：
```
 1. Hex（16进制）编码
 1. Base64编码
 
```
    Parameters:
    
    key - 被解码的密钥字符串
    
    Returns:
    
    密钥
  - decodeECPoint
```
public static PublicKey decodeECPoint(String encode,
                                      String curveName)
```
    解码恢复EC压缩公钥,支持Base64和Hex编码,（基于BouncyCastle）见：https://www.cnblogs.com/xinzhao/p/8963724.html
    
    Parameters:
    
    encode - 压缩公钥
    
    curveName - EC曲线名
    
    Returns:
    
    公钥
  - decodeECPoint
```
public static PublicKey decodeECPoint(byte[] encodeByte,
                                      String curveName)
```
    解码恢复EC压缩公钥,支持Base64和Hex编码,（基于BouncyCastle）
    
    Parameters:
    
    encodeByte - 压缩公钥
    
    curveName - EC曲线名，例如SM2_DOMAIN_PARAMS
    
    Returns:
    
    公钥
  - toDomainParams
```
public static org.bouncycastle.crypto.params.ECDomainParameters toDomainParams(org.bouncycastle.jce.spec.ECParameterSpec parameterSpec)
```
    构建ECDomainParameters对象
    
    Parameters:
    
    parameterSpec - ECParameterSpec
    
    Returns:
    
    ECDomainParameters
  - toDomainParams
```
public static org.bouncycastle.crypto.params.ECDomainParameters toDomainParams(String curveName)
```
    构建ECDomainParameters对象
    
    Parameters:
    
    curveName - Curve名称
    
    Returns:
    
    ECDomainParameters
  - toDomainParams
```
public static org.bouncycastle.crypto.params.ECDomainParameters toDomainParams(org.bouncycastle.asn1.x9.X9ECParameters x9ECParameters)
```
    构建ECDomainParameters对象
    
    Parameters:
    
    x9ECParameters - X9ECParameters
    
    Returns:
    
    ECDomainParameters
  - toSm2Params
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toSm2Params(String d)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    Returns:
    
    ECPrivateKeyParameters
  - toParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toParams(String dHex,
                                                                             org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    dHex - 私钥d值16进制字符串
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPrivateKeyParameters
  - toSm2Params
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toSm2Params(byte[] d)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    Returns:
    
    ECPrivateKeyParameters
  - toParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toParams(byte[] d,
                                                                             org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPrivateKeyParameters
  - toSm2Params
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toSm2Params(BigInteger d)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    Returns:
    
    ECPrivateKeyParameters
  - toParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toParams(BigInteger d,
                                                                             org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPrivateKeyParameters
  - toParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toParams(BigInteger x,
                                                                            BigInteger y,
                                                                            org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    x - 公钥X
    
    y - 公钥Y
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPublicKeyParameters
  - toSm2Params
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toSm2Params(String xHex,
                                                                               String yHex)
```
    转换为SM2的ECPublicKeyParameters
    
    Parameters:
    
    xHex - 公钥X
    
    yHex - 公钥Y
    
    Returns:
    
    ECPublicKeyParameters
  - toParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toParams(String xHex,
                                                                            String yHex,
                                                                            org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    xHex - 公钥X
    
    yHex - 公钥Y
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPublicKeyParameters
  - toSm2Params
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toSm2Params(byte[] xBytes,
                                                                               byte[] yBytes)
```
    转换为SM2的ECPublicKeyParameters
    
    Parameters:
    
    xBytes - 公钥X
    
    yBytes - 公钥Y
    
    Returns:
    
    ECPublicKeyParameters
  - toParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toParams(byte[] xBytes,
                                                                            byte[] yBytes,
                                                                            org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    xBytes - 公钥X
    
    yBytes - 公钥Y
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPublicKeyParameters
  - toParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toParams(PublicKey publicKey)
```
    公钥转换为 ECPublicKeyParameters
    
    Parameters:
    
    publicKey - 公钥，传入null返回null
    
    Returns:
    
    ECPublicKeyParameters或null
  - toParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toParams(PrivateKey privateKey)
```
    私钥转换为 ECPrivateKeyParameters
    
    Parameters:
    
    privateKey - 私钥，传入null返回null
    
    Returns:
    
    ECPrivateKeyParameters或null
  - toPkcs1
```
public static byte[] toPkcs1(PrivateKey privateKey)
```
    Java中的PKCS#8格式私钥转换为OpenSSL支持的PKCS#1格式
    
    Parameters:
    
    privateKey - PKCS#8格式私钥
    
    Returns:
    
    PKCS#1格式私钥
  - toPkcs1
```
public static byte[] toPkcs1(PublicKey publicKey)
```
    Java中的X.509格式公钥转换为OpenSSL支持的PKCS#1格式
    
    Parameters:
    
    publicKey - X.509格式公钥
    
    Returns:
    
    PKCS#1格式公钥
  - signParams
```
public static String signParams(Crypto crypto,
                                Map<?,?> params,
                                String... other)
```
    对参数做签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
    
    Parameters:
    
    crypto - 对称加密算法
    
    params - 参数
    
    other - 其它附加参数字符串(例如密钥)
    
    Returns:
    
    签名
  - signParams
```
public static String signParams(Crypto crypto,
                                Map<?,?> params,
                                String separator,
                                String keyValueSeparator,
                                boolean isIgnoreNull,
                                String... other)
```
    对参数做签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串
    
    Parameters:
    
    crypto - 对称加密算法
    
    params - 参数
    
    separator - entry之间的连接符
    
    keyValueSeparator - kv之间的连接符
    
    isIgnoreNull - 是否忽略null的键和值
    
    other - 其它附加参数字符串(例如密钥)
    
    Returns:
    
    签名
  - signParamsMd5
```
public static String signParamsMd5(Map<?,?> params,
                                   String... other)
```
    对参数做md5签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
    
    Parameters:
    
    params - 参数
    
    other - 其它附加参数字符串(例如密钥)
    
    Returns:
    
    签名
  - signParamsSha1
```
public static String signParamsSha1(Map<?,?> params,
                                    String... other)
```
    对参数做Sha1签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
    
    Parameters:
    
    params - 参数
    
    other - 其它附加参数字符串(例如密钥)
    
    Returns:
    
    签名
  - signParamsSha256
```
public static String signParamsSha256(Map<?,?> params,
                                      String... other)
```
    对参数做Sha256签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
    
    Parameters:
    
    params - 参数
    
    other - 其它附加参数字符串(例如密钥)
    
    Returns:
    
    签名
  - signParams
```
public static String signParams(org.aoju.bus.core.lang.Algorithm algorithm,
                                Map<?,?> params,
                                String... other)
```
    对参数做签名参数签名为对Map参数按照key的顺序排序后拼接为字符串，然后根据提供的签名算法生成签名字符串拼接后的字符串键值对之间无符号，键值对之间无符号，忽略null值
    
    Parameters:
    
    algorithm - 摘要算法
    
    params - 参数
    
    other - 其它附加参数字符串(例如密钥)
    
    Returns:
    
    签名
  - signParams
```
public static String signParams(org.aoju.bus.core.lang.Algorithm algorithm,
                                Map<?,?> params,
                                String separator,
                                String keyValueSeparator,
                                boolean isIgnoreNull,
                                String... other)
```
    对参数做签名参数签名为对Map参数按照key的顺序排序后拼接为字符串,然后根据提供的签名算法生成签名字符串
    
    Parameters:
    
    algorithm - 摘要算法
    
    params - 参数
    
    separator - entry之间的连接符
    
    keyValueSeparator - kv之间的连接符
    
    isIgnoreNull - 是否忽略null的键和值
    
    other - 其它附加参数字符串(例如密钥)
    
    Returns:
    
    签名
  - toParams
```
public static org.bouncycastle.crypto.params.AsymmetricKeyParameter toParams(Key key)
```
    密钥转换为AsymmetricKeyParameter
    
    Parameters:
    
    key - PrivateKey或者PublicKey
    
    Returns:
    
    ECPrivateKeyParameters或者ECPublicKeyParameters
  - getPublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters getPublicParams(org.bouncycastle.crypto.params.ECPrivateKeyParameters privateKeyParameters)
```
    根据私钥参数获取公钥参数
    
    Parameters:
    
    privateKeyParameters - 私钥参数
    
    Returns:
    
    公钥参数
  - toSm2PublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toSm2PublicParams(byte[] q)
```
    转换为 ECPublicKeyParameters
    
    Parameters:
    
    q - 公钥Q值
    
    Returns:
    
    ECPublicKeyParameters
  - toSm2PublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toSm2PublicParams(String q)
```
    转换为 ECPublicKeyParameters
    
    Parameters:
    
    q - 公钥Q值
    
    Returns:
    
    ECPublicKeyParameters
  - toSm2PublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toSm2PublicParams(String x,
                                                                                     String y)
```
    转换为SM2的ECPublicKeyParameters
    
    Parameters:
    
    x - 公钥X
    
    y - 公钥Y
    
    Returns:
    
    ECPublicKeyParameters
  - toSm2PublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toSm2PublicParams(byte[] xBytes,
                                                                                     byte[] yBytes)
```
    转换为SM2的ECPublicKeyParameters
    
    Parameters:
    
    xBytes - 公钥X
    
    yBytes - 公钥Y
    
    Returns:
    
    ECPublicKeyParameters
  - toPublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toPublicParams(String x,
                                                                                  String y,
                                                                                  org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    x - 公钥X
    
    y - 公钥Y
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPublicKeyParameters，x或y为null则返回null
  - toPublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toPublicParams(byte[] xBytes,
                                                                                  byte[] yBytes,
                                                                                  org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    xBytes - 公钥X
    
    yBytes - 公钥Y
    
    domainParameters - ECDomainParameters曲线参数
    
    Returns:
    
    ECPublicKeyParameters
  - toPublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toPublicParams(BigInteger x,
                                                                                  BigInteger y,
                                                                                  org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    x - 公钥X
    
    y - 公钥Y
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPublicKeyParameters
  - toPublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toPublicParams(String pointEncoded,
                                                                                  org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    pointEncoded - 被编码的曲线坐标点
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPublicKeyParameters
  - toPublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toPublicParams(byte[] pointEncoded,
                                                                                  org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    pointEncoded - 被编码的曲线坐标点
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPublicKeyParameters
  - toPublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toPublicParams(org.bouncycastle.math.ec.ECPoint point,
                                                                                  org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为ECPublicKeyParameters
    
    Parameters:
    
    point - 曲线坐标点
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPublicKeyParameters
  - toPublicParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters toPublicParams(PublicKey publicKey)
```
    公钥转换为 ECPublicKeyParameters
    
    Parameters:
    
    publicKey - 公钥，传入null返回null
    
    Returns:
    
    ECPublicKeyParameters或null
  - toSm2PrivateParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toSm2PrivateParams(String d)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值16进制字符串
    
    Returns:
    
    ECPrivateKeyParameters
  - toSm2PrivateParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toSm2PrivateParams(byte[] d)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    Returns:
    
    ECPrivateKeyParameters
  - toSm2PrivateParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toSm2PrivateParams(BigInteger d)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    Returns:
    
    ECPrivateKeyParameters
  - toPrivateParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toPrivateParams(String d,
                                                                                    org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值16进制字符串
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPrivateKeyParameters
  - toPrivateParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toPrivateParams(byte[] d,
                                                                                    org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPrivateKeyParameters
  - toPrivateParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toPrivateParams(BigInteger d,
                                                                                    org.bouncycastle.crypto.params.ECDomainParameters domainParameters)
```
    转换为 ECPrivateKeyParameters
    
    Parameters:
    
    d - 私钥d值
    
    domainParameters - ECDomainParameters
    
    Returns:
    
    ECPrivateKeyParameters
  - toPrivateParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters toPrivateParams(PrivateKey privateKey)
```
    私钥转换为 ECPrivateKeyParameters
    
    Parameters:
    
    privateKey - 私钥，传入null返回null
    
    Returns:
    
    ECPrivateKeyParameters或null
  - toSm2PrivateKey
```
public static PrivateKey toSm2PrivateKey(org.bouncycastle.asn1.sec.ECPrivateKey privateKey)
```
    将SM2算法的ECPrivateKey 转换为 PrivateKey
    
    Parameters:
    
    privateKey - ECPrivateKey
    
    Returns:
    
    PrivateKey
  - generateKey
```
public static SecretKey generateKey(String algorithm)
```
    生成 SecretKey，仅用于对称加密和摘要算法密钥生成
    
    Parameters:
    
    algorithm - 算法，支持PBE算法
    
    Returns:
    
    SecretKey
  - createOpenSSHPrivateKeySpec
```
public static KeySpec createOpenSSHPrivateKeySpec(byte[] key)
```
    创建OpenSSHPrivateKeySpec
    
    Parameters:
    
    key - 私钥，需为PKCS#1格式
    
    Returns:
    
    OpenSSHPrivateKeySpec
  - createOpenSSHPublicKeySpec
```
public static KeySpec createOpenSSHPublicKeySpec(byte[] key)
```
    创建OpenSSHPublicKeySpec
    
    Parameters:
    
    key - 公钥，需为PKCS#1格式
    
    Returns:
    
    OpenSSHPublicKeySpec
  - decodePrivateKeyParams
```
public static org.bouncycastle.crypto.params.ECPrivateKeyParameters decodePrivateKeyParams(byte[] privateKeyBytes)
```
    尝试解析转换各种类型私钥为ECPrivateKeyParameters，支持包括：
    - D值
    - PKCS#8
    - PKCS#1
    Parameters:
    
    privateKeyBytes - 私钥
    
    Returns:
    
    ECPrivateKeyParameters
  - decodePublicKeyParams
```
public static org.bouncycastle.crypto.params.ECPublicKeyParameters decodePublicKeyParams(byte[] publicKeyBytes)
```
    尝试解析转换各种类型公钥为ECPublicKeyParameters，支持包括：
    - Q值
    - X.509
    - PKCS#1
    Parameters:
    
    publicKeyBytes - 公钥
    
    Returns:
    
    ECPublicKeyParameters
  - generateKey
```
public static SecretKey generateKey(String algorithm,
                                    int keySize)
```
    生成 SecretKey，仅用于对称加密和摘要算法密钥生成当指定keySize<0时，AES默认长度为128，其它算法不指定。
    
    Parameters:
    
    algorithm - 算法，支持PBE算法
    
    keySize - 密钥长度，<0表示不设定密钥长度，即使用默认长度
    
    Returns:
    
    SecretKey
  - generateKey
```
public static SecretKey generateKey(String algorithm,
                                    int keySize,
                                    SecureRandom random)
```
    生成 SecretKey，仅用于对称加密和摘要算法密钥生成当指定keySize<0时，AES默认长度为128，其它算法不指定。
    
    Parameters:
    
    algorithm - 算法，支持PBE算法
    
    keySize - 密钥长度，<0表示不设定密钥长度，即使用默认长度
    
    random - 随机数生成器，null表示默认
    
    Returns:
    
    SecretKey
  - generateKey
```
public static SecretKey generateKey(String algorithm,
                                    byte[] key)
```
    生成 SecretKey，仅用于对称加密和摘要算法密钥生成
    
    Parameters:
    
    algorithm - 算法
    
    key - 密钥，如果为null 自动生成随机密钥
    
    Returns:
    
    SecretKey
  - generateDESKey
```
public static SecretKey generateDESKey(String algorithm,
                                       byte[] key)
```
    生成 SecretKey
    
    Parameters:
    
    algorithm - DES算法，包括DES、DESede等
    
    key - 密钥
    
    Returns:
    
    SecretKey
  - generatePBEKey
```
public static SecretKey generatePBEKey(String algorithm,
                                       char[] key)
```
    生成PBE SecretKey
    
    Parameters:
    
    algorithm - PBE算法，包括：PBEWithMD5AndDES、PBEWithSHA1AndDESede、PBEWithSHA1AndRC2_40等
    
    key - 密钥
    
    Returns:
    
    SecretKey
  - generateKey
```
public static SecretKey generateKey(String algorithm,
                                    KeySpec keySpec)
```
    生成 SecretKey，仅用于对称加密和摘要算法
    
    Parameters:
    
    algorithm - 算法
    
    keySpec - KeySpec
    
    Returns:
    
    SecretKey
  - generateRSAPrivateKey
```
public static PrivateKey generateRSAPrivateKey(byte[] key)
```
    生成RSA私钥，仅用于非对称加密采用PKCS#8规范，此规范定义了私钥信息语法和加密私钥语法算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
    
    Parameters:
    
    key - 密钥，必须为DER编码存储
    
    Returns:
    
    RSA私钥 PrivateKey
  - generatePublicKey
```
public static PublicKey generatePublicKey(String algorithm,
                                          byte[] key)
```
    生成公钥，仅用于非对称加密采用X509证书规范算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
    
    Parameters:
    
    algorithm - 算法
    
    key - 密钥，必须为DER编码存储
    
    Returns:
    
    公钥 PublicKey
  - generatePrivateKey
```
public static PrivateKey generatePrivateKey(String algorithm,
                                            byte[] key)
```
    生成私钥，仅用于非对称加密采用PKCS#8规范，此规范定义了私钥信息语法和加密私钥语法算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
    
    Parameters:
    
    algorithm - 算法，如RSA、EC、SM2等
    
    key - 密钥，PKCS#8格式
    
    Returns:
    
    私钥 PrivateKey
  - generatePrivateKey
```
public static PrivateKey generatePrivateKey(String algorithm,
                                            KeySpec keySpec)
```
    生成私钥，仅用于非对称加密算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
    
    Parameters:
    
    algorithm - 算法，如RSA、EC、SM2等
    
    keySpec - KeySpec
    
    Returns:
    
    私钥 PrivateKey
  - generatePrivateKey
```
public static PrivateKey generatePrivateKey(KeyStore keyStore,
                                            String alias,
                                            char[] password)
```
    生成私钥，仅用于非对称加密
    
    Parameters:
    
    keyStore - KeyStore
    
    alias - 别名
    
    password - 密码
    
    Returns:
    
    私钥 PrivateKey
  - generateRSAPublicKey
```
public static PublicKey generateRSAPublicKey(byte[] key)
```
    生成RSA公钥，仅用于非对称加密采用X509证书规范算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
    
    Parameters:
    
    key - 密钥，必须为DER编码存储
    
    Returns:
    
    公钥 PublicKey
  - generateKeyPair
```
public static KeyPair generateKeyPair(String algorithm,
                                      AlgorithmParameterSpec params)
```
    生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
    
    Parameters:
    
    algorithm - 非对称加密算法
    
    params - AlgorithmParameterSpec
    
    Returns:
    
    KeyPair
  - generateKeyPair
```
public static KeyPair generateKeyPair(String algorithm,
                                      byte[] seed,
                                      AlgorithmParameterSpec param)
```
    生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
    
    Parameters:
    
    algorithm - 非对称加密算法
    
    param - AlgorithmParameterSpec
    
    seed - 种子
    
    Returns:
    
    KeyPair
  - generatePublicKey
```
public static PublicKey generatePublicKey(String algorithm,
                                          KeySpec keySpec)
```
    生成公钥，仅用于非对称加密算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyFactory
    
    Parameters:
    
    algorithm - 算法
    
    keySpec - KeySpec
    
    Returns:
    
    公钥 PublicKey
  - generateKeyPair
```
public static KeyPair generateKeyPair(String algorithm)
```
    生成用于非对称加密的公钥和私钥，仅用于非对称加密密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
    
    Parameters:
    
    algorithm - 非对称加密算法
    
    Returns:
    
    KeyPair
  - generateKeyPair
```
public static KeyPair generateKeyPair(String algorithm,
                                      int keySize)
```
    生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
    
    Parameters:
    
    algorithm - 非对称加密算法
    
    keySize - 密钥模（modulus ）长度
    
    Returns:
    
    KeyPair
  - generateKeyPair
```
public static KeyPair generateKeyPair(String algorithm,
                                      int keySize,
                                      byte[] seed)
```
    生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
    
    Parameters:
    
    algorithm - 非对称加密算法
    
    keySize - 密钥模（modulus ）长度
    
    seed - 种子
    
    Returns:
    
    KeyPair
  - generateKeyPair
```
public static KeyPair generateKeyPair(String algorithm,
                                      int keySize,
                                      byte[] seed,
                                      AlgorithmParameterSpec... params)
```
    生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
    对于非对称加密算法，密钥长度有严格限制，具体如下：
    RSA：
```
 RS256、PS256：2048 bits
 RS384、PS384：3072 bits
 RS512、RS512：4096 bits
 
```
    EC（Elliptic Curve）：
```
 EC256：256 bits
 EC384：384 bits
 EC512：512 bits
 
```
    Parameters:
    
    algorithm - 非对称加密算法
    
    keySize - 密钥模（modulus ）长度（单位bit）
    
    seed - 种子
    
    params - AlgorithmParameterSpec
    
    Returns:
    
    KeyPair
  - generateKeyPair
```
public static KeyPair generateKeyPair(String algorithm,
                                      int keySize,
                                      SecureRandom random,
                                      AlgorithmParameterSpec... params)
```
    生成用于非对称加密的公钥和私钥密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
    对于非对称加密算法，密钥长度有严格限制，具体如下：
    RSA：
```
 RS256、PS256：2048 bits
 RS384、PS384：3072 bits
 RS512、RS512：4096 bits
 
```
    EC（Elliptic Curve）：
```
 EC256：256 bits
 EC384：384 bits
 EC512：512 bits
 
```
    Parameters:
    
    algorithm - 非对称加密算法
    
    keySize - 密钥模（modulus ）长度（单位bit）
    
    random - SecureRandom 对象，创建时可选传入seed
    
    params - AlgorithmParameterSpec
    
    Returns:
    
    KeyPair
  - getKeyPairGenerator
```
public static KeyPairGenerator getKeyPairGenerator(String algorithm)
```
    获取KeyPairGenerator
    
    Parameters:
    
    algorithm - 非对称加密算法
    
    Returns:
    
    KeyPairGenerator
  - getKeyFactory
```
public static KeyFactory getKeyFactory(String algorithm)
```
    获取KeyFactory
    
    Parameters:
    
    algorithm - 非对称加密算法
    
    Returns:
    
    KeyFactory
  - readJKSKeyStore
```
public static KeyStore readJKSKeyStore(File keyFile,
                                       char[] password)
```
    读取密钥库(Java Key Store，JKS) KeyStore文件 KeyStore文件用于数字证书的密钥对保存 see: http://snowolf.iteye.com/blog/391931
    
    Parameters:
    
    keyFile - 证书文件
    
    password - 密码
    
    Returns:
    
    KeyStore
  - getSecretKeyFactory
```
public static SecretKeyFactory getSecretKeyFactory(String algorithm)
```
    获取SecretKeyFactory
    
    Parameters:
    
    algorithm - 对称加密算法
    
    Returns:
    
    KeyFactory
  - readPKCS12KeyStore
```
public static KeyStore readPKCS12KeyStore(File keyFile,
                                          char[] password)
```
    读取PKCS12 KeyStore文件 KeyStore文件用于数字证书的密钥对保存
    
    Parameters:
    
    keyFile - 证书文件
    
    password - 密码
    
    Returns:
    
    KeyStore
  - readPKCS12KeyStore
```
public static KeyStore readPKCS12KeyStore(InputStream in,
                                          char[] password)
```
    读取PKCS12 KeyStore文件 KeyStore文件用于数字证书的密钥对保存
    
    Parameters:
    
    in - InputStream 如果想从文件读取.keystore文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    password - 密码
    
    Returns:
    
    KeyStore
  - readKeyStore
```
public static KeyStore readKeyStore(String type,
                                    File keyFile,
                                    char[] password)
```
    读取KeyStore文件 KeyStore文件用于数字证书的密钥对保存 see: http://snowolf.iteye.com/blog/391931
    
    Parameters:
    
    type - 类型
    
    keyFile - 证书文件
    
    password - 密码，null表示无密码
    
    Returns:
    
    KeyStore
  - getKeyGenerator
```
public static KeyGenerator getKeyGenerator(String algorithm)
```
    获取KeyGenerator
    
    Parameters:
    
    algorithm - 对称加密算法
    
    Returns:
    
    KeyGenerator
  - getKeyPair
```
public static KeyPair getKeyPair(String type,
                                 InputStream in,
                                 char[] password,
                                 String alias)
```
    从KeyStore中获取私钥公钥
    
    Parameters:
    
    type - 类型
    
    in - InputStream 如果想从文件读取.keystore文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    password - 密码
    
    alias - 别名
    
    Returns:
    
    KeyPair
  - getMainAlgorithm
```
public static String getMainAlgorithm(String algorithm)
```
    获取主体算法名，例如RSA/ECB/PKCS1Padding的主体算法是RSA
    
    Parameters:
    
    algorithm - XXXwithXXX算法
    
    Returns:
    
    主体算法名
  - getAlgorithmAfterWith
```
public static String getAlgorithmAfterWith(String algorithm)
```
    获取用于密钥生成的算法获取XXXwithXXX算法的后半部分算法，如果为ECDSA或SM2，返回算法为EC
    
    Parameters:
    
    algorithm - XXXwithXXX算法
    
    Returns:
    
    算法
  - readJKSKeyStore
```
public static KeyStore readJKSKeyStore(InputStream in,
                                       char[] password)
```
    读取密钥库(Java Key Store，JKS) KeyStore文件 KeyStore文件用于数字证书的密钥对保存 see: http://snowolf.iteye.com/blog/391931
    
    Parameters:
    
    in - InputStream 如果想从文件读取.keystore文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    password - 密码
    
    Returns:
    
    KeyStore
  - readKeyStore
```
public static KeyStore readKeyStore(String type,
                                    InputStream in,
                                    char[] password)
```
    读取KeyStore文件 KeyStore文件用于数字证书的密钥对保存 see: http://snowolf.iteye.com/blog/391931
    
    Parameters:
    
    type - 类型
    
    in - InputStream 如果想从文件读取.keystore文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    password - 密码，null表示无密码
    
    Returns:
    
    KeyStore
  - getKeyPair
```
public static KeyPair getKeyPair(KeyStore keyStore,
                                 char[] password,
                                 String alias)
```
    从KeyStore中获取私钥公钥
    
    Parameters:
    
    keyStore - KeyStore
    
    password - 密码
    
    alias - 别名
    
    Returns:
    
    KeyPair
  - readX509Certificate
```
public static Certificate readX509Certificate(InputStream in,
                                              char[] password,
                                              String alias)
```
    读取X.509 Certification文件 Certification为证书文件 see: http://snowolf.iteye.com/blog/391931
    
    Parameters:
    
    in - InputStream 如果想从文件读取.cer文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    password - 密码
    
    alias - 别名
    
    Returns:
    
    KeyStore
  - readPublicKeyFromCert
```
public static PublicKey readPublicKeyFromCert(InputStream in)
```
    读取X.509 Certification文件中的公钥 Certification为证书文件 see: https://www.cnblogs.com/yinliang/p/10115519.html
    
    Parameters:
    
    in - InputStream 如果想从文件读取.cer文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    Returns:
    
    KeyStore
  - readX509Certificate
```
public static Certificate readX509Certificate(InputStream in)
```
    读取X.509 Certification文件 Certification为证书文件 see: http://snowolf.iteye.com/blog/391931
    
    Parameters:
    
    in - InputStream 如果想从文件读取.cer文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    Returns:
    
    KeyStore
  - readCertificate
```
public static Certificate readCertificate(String type,
                                          InputStream in,
                                          char[] password,
                                          String alias)
```
    读取Certification文件 Certification为证书文件 see: http://snowolf.iteye.com/blog/391931
    
    Parameters:
    
    type - 类型，例如X.509
    
    in - InputStream 如果想从文件读取.cer文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    password - 密码
    
    alias - 别名
    
    Returns:
    
    KeyStore
  - readCertificate
```
public static Certificate readCertificate(String type,
                                          InputStream in)
```
    读取Certification文件 Certification为证书文件 see: http://snowolf.iteye.com/blog/391931
    
    Parameters:
    
    type - 类型，例如X.509
    
    in - InputStream 如果想从文件读取.cer文件，使用 FileKit.getInputStream(java.io.File) 读取
    
    Returns:
    
    Certificate
  - getCertificate
```
public static Certificate getCertificate(KeyStore keyStore,
                                         String alias)
```
    获得 Certification
    
    Parameters:
    
    keyStore - KeyStore
    
    alias - 别名
    
    Returns:
    
    Certificate
  - getCertificateFactory
```
public static CertificateFactory getCertificateFactory(String type)
```
    获取CertificateFactory
    
    Parameters:
    
    type - 类型，例如X.509
    
    Returns:
    
    KeyPairGenerator
  - getRSAPublicKey
```
public static PublicKey getRSAPublicKey(PrivateKey privateKey)
```
    通过RSA私钥生成RSA公钥
    
    Parameters:
    
    privateKey - RSA私钥
    
    Returns:
    
    RSA公钥，null表示私钥不被支持
  - getRSAPublicKey
```
public static PublicKey getRSAPublicKey(String modulus,
                                        String publicExponent)
```
    获得RSA公钥对象
    
    Parameters:
    
    modulus - Modulus
    
    publicExponent - Public Exponent
    
    Returns:
    
    公钥
  - readPem
```
public static byte[] readPem(InputStream keyStream)
```
    从pem流中读取公钥或私钥
    
    Parameters:
    
    keyStream - pem流
    
    Returns:
    
    密钥bytes
  - getRSAPublicKey
```
public static PublicKey getRSAPublicKey(BigInteger modulus,
                                        BigInteger publicExponent)
```
    获得RSA公钥对象
    
    Parameters:
    
    modulus - Modulus
    
    publicExponent - Public Exponent
    
    Returns:
    
    公钥
  - readPrivateKey
```
public static PrivateKey readPrivateKey(InputStream pemStream)
```
    读取PEM格式的私钥
    
    Parameters:
    
    pemStream - pem流
    
    Returns:
    
    PrivateKey
  - readPublicKey
```
public static PublicKey readPublicKey(InputStream pemStream)
```
    读取PEM格式的公钥
    
    Parameters:
    
    pemStream - pem流
    
    Returns:
    
    PublicKey
  - readPemKey
```
public static Key readPemKey(InputStream keyStream)
```
    从pem文件中读取公钥或私钥根据类型返回PublicKey 或者 PrivateKey
    
    Parameters:
    
    keyStream - pem流
    
    Returns:
    
    Key，null表示无法识别的密钥类型
  - writePemObject
```
public static void writePemObject(String type,
                                  byte[] content,
                                  OutputStream keyStream)
```
    写出pem密钥（私钥、公钥、证书）
    
    Parameters:
    
    type - 密钥类型（私钥、公钥、证书）
    
    content - 密钥内容，需为PKCS#1格式
    
    keyStream - pem流
  - writePemObject
```
public static void writePemObject(String type,
                                  byte[] content,
                                  Writer writer)
```
    写出pem密钥（私钥、公钥、证书）
    
    Parameters:
    
    type - 密钥类型（私钥、公钥、证书）
    
    content - 密钥内容，需为PKCS#1格式
    
    writer - pemWriter
  - readPemObject
```
public static org.bouncycastle.util.io.pem.PemObject readPemObject(InputStream keyStream)
```
    读取pem文件中的信息，包括类型、头信息和密钥内容
    
    Parameters:
    
    keyStream - pem流
    
    Returns:
    
    PemObject
  - readPemObject
```
public static org.bouncycastle.util.io.pem.PemObject readPemObject(Reader reader)
```
    读取pem文件中的信息，包括类型、头信息和密钥内容
    
    Parameters:
    
    reader - pem Reader
    
    Returns:
    
    PemObject
  - readSm2PemPrivateKey
```
public static PrivateKey readSm2PemPrivateKey(InputStream keyStream)
```
    读取OpenSSL生成的ANS1格式的Pem私钥文件，必须为PKCS#1格式
    
    Parameters:
    
    keyStream - 私钥pem流
    
    Returns:
    
    PrivateKey
  - toPem
```
public static String toPem(String type,
                           byte[] content)
```
    将私钥或公钥转换为PEM格式的字符串
    
    Parameters:
    
    type - 密钥类型（私钥、公钥、证书）
    
    content - 密钥内容
    
    Returns:
    
    PEM内容
  - writePemObject
```
public static void writePemObject(org.bouncycastle.util.io.pem.PemObjectGenerator pemObject,
                                  OutputStream keyStream)
```
    写出pem密钥（私钥、公钥、证书）
    
    Parameters:
    
    pemObject - pem对象，包括密钥和密钥类型等信息
    
    keyStream - pem流
  - writePemObject
```
public static void writePemObject(org.bouncycastle.util.io.pem.PemObjectGenerator pemObject,
                                  Writer writer)
```
    写出pem密钥（私钥、公钥、证书）
    
    Parameters:
    
    pemObject - pem对象，包括密钥和密钥类型等信息
    
    writer - pemWriter
  - hashpw
```
public static String hashpw(String password)
```
    生成Bcrypt加密后的密文
    
    Parameters:
    
    password - 明文密码
    
    Returns:
    
    加密后的密文
  - checkpw
```
public static boolean checkpw(String password,
                              String hashed)
```
    验证密码是否与Bcrypt加密后的密文匹配
    
    Parameters:
    
    password - 明文密码
    
    hashed - hash值（加密后的值）
    
    Returns:
    
    是否匹配
  - changeC1C2C3ToC1C3C2
```
public static byte[] changeC1C2C3ToC1C3C2(byte[] c1c2c3,
                                          org.bouncycastle.crypto.params.ECDomainParameters ecDomainParameters)
```
    bc加解密使用旧标c1||c2||c3,此方法在加密后调用,将结果转化为c1||c3||c2
    
    Parameters:
    
    c1c2c3 - 加密后的bytes,顺序为C1C2C3
    
    ecDomainParameters - ECDomainParameters
    
    Returns:
    
    加密后的bytes, 顺序为C1C3C2
  - changeC1C3C2ToC1C2C3
```
public static byte[] changeC1C3C2ToC1C2C3(byte[] c1c3c2,
                                          org.bouncycastle.crypto.params.ECDomainParameters ecDomainParameters)
```
    bc加解密使用旧标c1||c3||c2,此方法在解密前调用,将密文转化为c1||c2||c3再去解密
    
    Parameters:
    
    c1c3c2 - 加密后的bytes,顺序为C1C3C2
    
    ecDomainParameters - ECDomainParameters
    
    Returns:
    
    c1c2c3 加密后的bytes，顺序为C1C2C3
  - rsAsn1ToPlain
```
public static byte[] rsAsn1ToPlain(byte[] rsDer)
```
    BC的SM3withSM2签名得到的结果的rs是asn1格式的,这个方法转化成直接拼接r||s
    
    Parameters:
    
    rsDer - rs in asn1 format
    
    Returns:
    
    sign result in plain byte array
  - rsPlainToAsn1
```
public static byte[] rsPlainToAsn1(byte[] sign)
```
    BC的SM3withSM2验签需要的rs是asn1格式的，这个方法将直接拼接r||s的字节数组转化成asn1格式
    
    Parameters:
    
    sign - 字节数组
    
    Returns:
    
    Rs结果为asn1格式
  - createHmacSm3Engine
```
public static MacEngine createHmacSm3Engine(byte[] key)
```
    创建HmacSM3算法的MacEngine
    
    Parameters:
    
    key - 密钥
    
    Returns:
    
    MacEngine
  - addProvider
```
public static void addProvider(Provider provider)
```
    增加加密解密的算法提供者，默认优先使用，例如：
```
 addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
 
```
    Parameters:
    
    provider - 算法提供者
  - createCipher
```
public static Cipher createCipher(String algorithm)
```
    创建Cipher
    
    Parameters:
    
    algorithm - 算法
    
    Returns:
    
    Cipher
  - createMessageDigest
```
public static MessageDigest createMessageDigest(String algorithm)
```
    创建MessageDigest
    
    Parameters:
    
    algorithm - 算法
    
    Returns:
    
    MessageDigest
  - createMac
```
public static Mac createMac(String algorithm)
```
    创建Mac
    
    Parameters:
    
    algorithm - 算法
    
    Returns:
    
    Mac
  - createSignature
```
public static Signature createSignature(String algorithm)
```
    创建Signature
    
    Parameters:
    
    algorithm - 算法
    
    Returns:
    
    Signature

Class Builder

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

KEY_TYPE_JKS

KEY_TYPE_PKCS12

CERT_TYPE_X509

DEFAULT_KEY_SIZE

SM2_DEFAULT_CURVE

SM2_DOMAIN_PARAMS

ID_SM2_PUBLIC_KEY_PARAM

Constructor Detail

Builder

Method Detail

md5

md5

md5

md5

md5

md5

md5Hex

md5Hex

md5Hex

md5Hex

md5Hex

md5Hex

md5Hex16

md5Hex16

md5Hex16

md5Hex16

md5Hex16

md5HexTo16

sha1

sha1

sha1

sha1

sha1

sha1

sha1Hex

sha1Hex

sha1Hex

sha1Hex

sha1Hex

sha256

sha256

sha256

sha256

sha256

sha256

sha256Hex

sha256Hex

sha256Hex

sha256Hex

sha256Hex

hmac

hmac

hmac

hmacMd5

hmacMd5

hmacMd5

hmacSha1

hmacSha1

hmacSha1

hmacSha256

hmacSha256

hmacSha256

rsa

rsa

rsa

sign

sign

sign

digester

digester

sm2

sm2

sm2

sm2