# aisino-encrypt
**Repository Path**: jackframe/aisino-encrypt
## Basic Information
- **Project Name**: aisino-encrypt
- **Description**: 对数据加密解密的封装，包含MD5，RSA，SHA，AES，DES，DH
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: release
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 1
- **Created**: 2021-09-15
- **Last Updated**: 2024-07-28
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# 加密算法工具类操作手册（v1.0-SNAPSHOT）
## 概述
该工具类中包含了
1.摘要加密算法（MD5、SHA1）
2.对称加密算法（AES、DES/DES3）
3.非对称加密算法（RSA、DH）
未引入任何依赖，java1.8以上环境即可导入并运行。
引入方式：
```xml
com.aisino.api
aisino-encrypt
0.1.0
```
引入后通过AisinoEncrypt.方法名()调用所需方法。
## 默认加密算法
默认加密算法为DES加密，默认的密钥为aisinodefkey(aisino default key)。
```java
/**
* 默认密钥
*/
public static final String DEFAULT_KEY = "aisinodefkey";
```
默认方法中的密钥不能进行修改。主要方法：
```java
/**
* 默认加密方法
* 默认为RSA加密
*
* @param content 需要加密的内容
* @return 返回加密后的内容
*/
String encrypt(String content);
/**
* 默认解密方法
* RSA解密
*
* @param ciphertext 密匙
* @return 返回解密后的内容
*/
String decrypt(String ciphertext)//ciphertext 需要解密的内容
```
具体使用方法如下：
```java
String content = "需要加密的内容";
String ciphertext = AisinoEncrypt.encrypt(content);//默认方法加密
System.out.println("encrypt: " + ciphertext);//输出加密后内容
String decrypt = AisinoEncrypt.decrypt(ciphertext);//默认方法解密
System.out.println("decrypt: " + decrypt);//输出解密后内容
```
控制台输出结果如下:
```html
encrypt: JcC7lRz7TIQabcOiWbM32sEB0BlbMTrm
decrypt: 需要加密的内容
```
## 摘要加密算法
摘要算法有MD5和SHA1两种，通过传入的Digest枚举类中的算法名（Digest.MD5 / Digest.SHA）来判断调用的哪个算法。主要方法：
```java
/**
* content 需要加密的内容
* digest Digest枚举类
**/
String encryptDigest(String content, Digest digest);
/**
* 摘要加密算法加密为不可逆过程，因此只提供matchDigest()方法
* 对加密后的内容与原文进行比对，返回为true则比对成功。
* context 加密前的内容
* ciphertext 加密后的内容
* digest Digest枚举类
**/
boolean matchDigest(String context, String ciphertext, Digest digest)
```
摘要加密算法加密为不可逆过程，因此只提供matchDigest()方法对加密后的内容与原文进行比对，返回为true则比对成功。
示例：
```java
String encryptDigest = AisinoEncrypt.encryptDigest("需要加密的内容", Digest.MD5);
boolean b = AisinoEncrypt.matchDigest(content, encryptDigest, Digest.MD5);
System.out.println("加密后：" + encryptDigest);
System.out.println("加密前后比较：" + b);
```
控制台输出：
```html
加密后：3d0bb45281e89215e19aea406ffdee08
加密前后比较：true
```
## 对称加密算法
对称加密算法（SymmetricEncrypt）包括AES、DES和3DES三种加密算法，通过
```java
AisinoEncrypt.encryptSymmetric(content,key,Symmetric.AES);
```
进行加密调用。
**注\*：密钥需按照要求传入**
**AES密钥位数为128/192/256位，字节长度为24/32/44，当长度为24时以==结尾，长度为44时以=结尾。**
**DES密钥位数为56位，字节长度为12，3DES密钥位数为112/168位，字节长度为32，且不能有特殊的标点符号。如 ！@#￥%……&*（）—+_,./?<>;':"|\~·等，但可以在末尾跟 “=” 符号。**
> **字节长度为字符串转换为字节后的长度**
该加密也提供默认的密钥生成方法，可以通过自动生成获得密钥，并将密钥保存并传入到对称加密算法中进行加解密。
主要方法：
```java
/**
* 生成对称加密算法的密钥
*
* @param symmetric 算法类型
* @return key 返回对称加密算法的密钥
*/
String initSymmetricKey(Symmetric symmetric);
/**
* 对称加密
*
* @param symmetric 加密类型
* @param content 需要加密的内容
* @param key 密匙
* @return 返回加密后的密文
*/
String encryptSymmetric(String content, String key, Symmetric symmetric);
/**
* 对称解密
*
* @param ciphertext 密文
* @param key 密钥
* @param symmetric 对称加密类型
* @return 返回解密后的内容
*/
String decryptSymmetric(String ciphertext, String key, Symmetric symmetric);
```
代码示例如下：
```java
//调用对称加密算法加密
String s = AisinoEncrypt.encryptSymmetric(content, "aisinosymmetricencrypt==", Symmetric.AES);
System.out.println("encrypt: " + s);
String s2 = AisinoEncrypt.decryptSymmetric(s, "aisinosymmetricencrypt==", Symmetric.AES);
System.out.println("decrypt: " + s2);
//如果不想自定义密钥，可通过方法生成对称加密默认密钥
String key = AisinoEncrypt.initSymmetricKey(Symmetric.AES);
System.out.println("key: " + key);
String s1 = AisinoEncrypt.encryptSymmetric(content, key, Symmetric.AES);
System.out.println("encrypt: " + s1);
String s3 = AisinoEncrypt.decryptSymmetric(s1, key, Symmetric.AES);
System.out.println("decrypt: " + s3);
```
控制台输出如下：
```html
encrypt: QUYACrYXFvnd6IKMIi9h5sBOMJxv63UuQTPRq8lPN8g=
decrypt: 需要加密的内容
key: lb+1Totf2nwwQI/65PiIhA==
encrypt: LzAxxrLptBaoY5qYS5XT+rWpZXu0CLMfx72zvPVldn4=
decrypt: 需要加密的内容
```
## 非对称加密算法
非对称加密算法中提供了RSA、DH和BCrypt算法，通过AisinoEncrypt.rsa()、AisinoEncrypt.dh()方法进行调用。需要注意的是，rsa和dh都需要密钥对（公钥 + 私钥）的方式对内容进行加密解密。同时也可以通过直接调用RSA、DH的方式进行加密。
**注：因非对称加密的密钥比较长，因此不推荐自己编写密钥，推荐使用提供的密钥生成工具生成密钥。**
### RSA
RSA算法需要构建密钥对(公钥+私钥)，这里以甲乙双方发送数据为模型
1.甲方在本地构建密钥对（公钥+私钥），并将公钥公布给乙方
2.甲方将数据用私钥进行加密，发送给乙方
3.乙方用甲方提供的公钥对数据进行解密
如果乙方向传送数据给甲方：
4.乙方用公钥对数据进行加密，然后传送给甲方
5.甲方用私钥对数据进行解密
**注*：（1）如果通过公钥加密则需要通过私钥解密，如果通过私钥加密则需要公钥进行解密。RSA的公钥最小长度为128，私钥最小长度为460**
**（2）RSA加密算法对于需要加密的明文长度有限制，如果密钥长度设置为512，则只能加密53个字节以下的明文，解密64个字节以下的密文。若设置为1024，则能加密117个字节以下的明文，解密128个字节以下的密文。RSA的密钥字节长度只能设置在512到1024之间！**
主要方法：
```java
/**
* 初始化密钥对
*
* @return Map 甲方密钥对的Map集合（公钥 + 私钥）
*/
Map initKey();
/**
* 传入密钥长度初始化密钥对
* @param keySize 密钥长度
* @return Map 甲方密钥对的Map集合（公钥 + 私钥）
*/
Map initKey(int keySize);
/**
* 私钥加密
*
* @param content 待加密数据
* @param key 密钥
* @return String 加密数据
*/
String encryptByPrivateKey(String content, String key);
/**
* 公钥加密
*
* @param content 待加密数据
* @param key 密钥
* @return String 加密数据
*/
String encryptByPublicKey(String content, String key);
/**
* 私钥解密
*
* @param ciphertext 待解密数据
* @param key 密钥
* @return String 解密数据
*/
String decryptByPrivateKey(String ciphertext, String key);
/**
* 公钥解密
*
* @param ciphertext 待解密数据
* @param key 密钥
* @return String 解密数据
*/
String decryptByPublicKey(String ciphertext, String key);
/**
* 取得私钥
*
* @param keyMap 密钥map
* @return String 私钥
*/
String getPrivateKey(Map keyMap);
/**
* 取得公钥
*
* @param keyMap 密钥map
* @return String 公钥
*/
String getPublicKey(Map keyMap);
```
RSA取出私钥和公钥：
```java
String publicKey = AisinoEncrypt.rsa().getPublicKey(keys1);
String privateKey = AisinoEncrypt.rsa().getPrivateKey(keys1);
System.out.println("publicKey: " + publicKey);
System.out.println("privateKey: " + privateKey);
```
控制台输出：
```html
publicKey: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJXxSoOda4wW3FVUkNqezGnvRPdXJYcdJLDt241sg/S0eFkEQ1SbuoBoQ1klSaHHKlO2hQHLo1kH8jZvMcj3lMECAwEAAQ==
privateKey: MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAlfFKg51rjBbcVVSQ2p7Mae9E91clhx0ksO3bjWyD9LR4WQRDVJu6gGhDWSVJoccqU7aFAcujWQfyNm8xyPeUwQIDAQABAkB6AUIOYfL2pEtYK11KZlgSApztXT2t+Sq3xHMXWirs2wPsAd44/cYMIPMtshBA1EbDBzAm+6XGocfEt8i2aIWhAiEA1U62SuV3L5DpCGq3z8xHHnS+ROfRoAhFLOSSVCtFBd0CIQCz8+87rXvwRLG+/pIzgncl3XZqaeYic4KX+GjOwwf2NQIhAMCWb6oRodmVaYEK8WixVGjgGMYX08E8llBhEujhpFEVAiBuuEDSxBwEqg9/B1znCnfKuWc5dCzft5h7bqD1znPgnQIhAI9yc1Ypv52MNv5WuT74hy8RZOksoNighNip6fIDILn2
```
RSA加密示例如下：
```java
/**
* 通过调用AisinoEncrypt.rsa()的方式进行RSA加密
*/
//初始化密钥对
Map keys1 = AisinoEncrypt.rsa().initKey();
System.out.println("AisinoEncrypt.rsa() keys1: " + keys1);
//公钥加密
String encryptByPublicKey1 = AisinoEncrypt.rsa().encryptByPublicKey(content, AisinoEncrypt.rsa().getPublicKey(keys1));
System.out.println("AisinoEncrypt.rsa() enctypt: " + encryptByPublicKey1);
//私钥解密
String decryptByPrivateKey1 = AisinoEncrypt.rsa().decryptByPrivateKey(encryptByPublicKey1, AisinoEncrypt.rsa().getPrivateKey(keys1));
System.out.println("AisinoEncrypt.rsa() decrypt: " + decryptByPrivateKey1);
//私钥加密
String encryptByPrivateKey1 = RSA.encryptByPrivateKey(content, RSA.getPrivateKey(keys1));
System.out.println("AisinoEncrypt.rsa() enctypt: " + encryptByPrivateKey1);
//公钥解密
String decryptByPublicKey1 = RSA.decryptByPublicKey(encryptByPrivateKey1, RSA.getPublicKey(keys1));
System.out.println("AisinoEncrypt.rsa() decrypt: " + decryptByPublicKey1);
/**
* 通过调用RSA类的方式进行RSA加密
*/
Map keys = RSA.initKey();
System.out.println("RSA keys1: " + keys1);
//公钥加密
String encryptByPublicKey = RSA.encryptByPublicKey(content, RSA.getPublicKey(keys));
System.out.println("RSA enctypt: " + encryptByPublicKey);
//私钥解密
String decryptByPrivateKey = RSA.decryptByPrivateKey(encryptByPublicKey, RSA.getPrivateKey(keys));
System.out.println("RSA decrypt: " + decryptByPrivateKey);
//私钥加密
String encryptByPrivateKey = RSA.encryptByPrivateKey(content, RSA.getPrivateKey(keys));
System.out.println("RSA enctypt: " + encryptByPrivateKey);
//公钥解密
String decryptByPublicKey = RSA.decryptByPublicKey(encryptByPrivateKey, RSA.getPublicKey(keys));
System.out.println("RSA decrypt: " + decryptByPublicKey);
```
控制台输出：
```html
AisinoEncrypt.rsa() keys1: {RSAPublicKey=Sun RSA public key, 512 bits
modulus: 7918666909438184385488567534062240807811750452911138970565579848285703717976930503097872640283851967651398593427512978982410856636678465776826376527385999
public exponent: 65537, RSAPrivateKey=sun.security.rsa.RSAPrivateCrtKeyImpl@fffdbf30}
AisinoEncrypt.rsa() enctypt: b5PusMHH0OWhiSxsyJQgQDRfiRDUa1NpiIdXCYDiWAYDGgN2O1FTouPmO5EE7wOk/ePqC8m8rPDVAIaLxCrzBw==
AisinoEncrypt.rsa() decrypt: 需要加密的内容
AisinoEncrypt.rsa() enctypt: QYAw6ciPaBtKHSYnVmsaIruJN6AW4fSEdSjKFr24KWx9lgFO5xMCpeX1hMLubam7LoMYLvnA07BeGPEgZGuHYQ==
AisinoEncrypt.rsa() decrypt: 需要加密的内容
RSA keys1: {RSAPublicKey=Sun RSA public key, 512 bits
modulus: 7918666909438184385488567534062240807811750452911138970565579848285703717976930503097872640283851967651398593427512978982410856636678465776826376527385999
public exponent: 65537, RSAPrivateKey=sun.security.rsa.RSAPrivateCrtKeyImpl@fffdbf30}
RSA enctypt: UqQAslEg0KSu/ffBdYalajzPWfsJ6/zP3uY+2VYbmWxvYRFuklTnts8sRbSR1RbadiIQKmKdM+KqDqxP/+Citg==
RSA decrypt: 需要加密的内容
RSA enctypt: qs6uLBlqZqfaxLZvWyuoo1D2usfQdPeN+M4M2KRcPK2rrIkb32eUTi2sJeP9iRt+Mptzmgog7B9tXIGRqxh1SQ==
RSA decrypt: 需要加密的内容
```
### DH
DH 算法是 Diffie和Hellman两位作者于1976年提出了一种的密钥交换协议。这种加密算法主要用于密钥的交换，能够实现了在非安全网络下通信双方密钥的安全建立，从而使通信双方能够使用这个密钥进行消息的加密解密，从而实现通信的安全。
1.甲方构建密钥对儿，将公钥公布给乙方，将私钥保留；双方约定数据加密算法；乙方通过甲方公钥构建密钥对儿，将公钥公布给甲方，将私钥保留。
2.甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给乙方加密后的数据；乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。
3.乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给甲方加密后的数据；甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。
主要方法:
```java
/**
* 甲方初始化并返回密钥对
*
* @return 返回生成的密钥对
*/
Map initKey();
/**
* 传入密钥长度以使甲方初始化并返回密钥对
* @param keySize 密钥长度
* @return 返回生成的密钥对
*/
Map initKey(int keySize);
/**
* 乙方根据甲方公钥初始化并返回密钥对
*
* @param key 甲方的公钥
* @return 返回乙方生成的密钥对
*/
Map initKey(String key);
/**
* 根据对方的公钥和自己的私钥生成 本地密钥,返回的是SecretKey对象的字节数组
*
* @param publicKey 公钥
* @param privateKey 私钥
* @return 返回SecretKey对象的字节数组
*/
String getSecretKeyBytes(String publicKey, String privateKey);
/**
* 从 Map 中取得公钥
*
* @param keyMap 密钥对
* @return 返回从 Map 中取得的公钥
*/
String getPublicKey(Map keyMap);
/**
* 从 Map 中取得私钥
*
* @param keyMap 密钥对
* @return 返回从 Map 中取得的私钥
*/
String getPrivateKey(Map keyMap);
/**
* DH 加密
*
* @param data 带加密数据
* @param publicKey 甲方公钥
* @param privateKey 乙方私钥
* @return 密文
*/
String encryptDH(String data, String publicKey, String privateKey);
/**
* DH 解密
*
* @param data 待解密数据
* @param publicKey 乙方公钥
* @param privateKey 甲方私钥
* @return 解密后的内容
*/
public static String decryptDH(String data, String publicKey, String privateKey);
```
DH加密示例如下：
```java
@Test
public void encryptDH(){
String content = "需要加密的内容";
/* Test DH */
// 甲方公钥
String senderPublicKey;
// 甲方私钥
String senderPrivateKey;
// 甲方本地密钥
String senderSecretKey;
// 乙方公钥
String receiverPublicKey;
// 乙方私钥
String receiverPrivateKey;
// 乙方本地密钥
String receiverSecretKey;
// 初始化密钥 并生成甲方密钥对
Map keyMap1 = AisinoEncrypt.dhEncrypt().initKey();
senderPublicKey = AisinoEncrypt.dhEncrypt().getPublicKey(keyMap1);
senderPrivateKey = AisinoEncrypt.dhEncrypt().getPrivateKey(keyMap1);
System.out.println("DH 甲方公钥 : " + senderPublicKey);
System.out.println("DH 甲方私钥 : " + senderPrivateKey);
// 乙方根据甲方公钥产生乙方密钥对
Map keyMap2 = AisinoEncrypt.dhEncrypt().initKey(senderPublicKey);
receiverPublicKey = AisinoEncrypt.dhEncrypt().getPublicKey(keyMap2);
receiverPrivateKey = AisinoEncrypt.dhEncrypt().getPrivateKey(keyMap2);
System.out.println("DH 乙方公钥 : " + receiverPublicKey);
System.out.println("DH 乙方私钥 : " + receiverPrivateKey);
// 对于甲方， 根据其私钥和乙方发过来的公钥， 生成其本地密钥secretKey1
senderSecretKey = AisinoEncrypt.dhEncrypt().getSecretKeyBytes(receiverPublicKey, senderPrivateKey);
System.out.println("DH 甲方 本地密钥 : " + senderSecretKey);
// 对于乙方， 根据其私钥和甲方发过来的公钥， 生成其本地密钥secretKey2
receiverSecretKey = AisinoEncrypt.dhEncrypt().getSecretKeyBytes(senderPublicKey, receiverPrivateKey);
System.out.println("DH 乙方 本地密钥 : " + receiverSecretKey);
// 测试数据加密和解密
System.out.println("加密前的数据: " + content);
// 甲方进行数据的加密
// 用的是甲方的私钥和乙方的公钥
String encryptDH = AisinoEncrypt.dhEncrypt().encryptDH(content, receiverPublicKey, senderPrivateKey);
System.out.println("加密后的数据: " + encryptDH);
// 乙方进行数据的解密
// 用的是乙方的私钥和甲方的公钥
String decryptDH = AisinoEncrypt.dhEncrypt().decryptDH(encryptDH, senderPublicKey, receiverPrivateKey);
System.out.println("解密后数据: " + decryptDH);
}
```
控制台输出：
```html
DH 甲方公钥 : MIIBpzCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIAA4GFAAKBgQDGdDUCHETkkDC/7GGohBKjUDO0eBRrO8d9IZKIne3c5Kr4mOytrRvBWFSH6SGB8yTCJqqC2tf5TvDY7kEk6PQW8XMtqRI0AZEMlHPpG1uRo12uvMEk03/YARz785YKGW1Vt8BFy1vrJIStC8i0h+DxdSzBY/cJ4OBTp4Ynt2Xd1g==
DH 甲方私钥 : MIIBZwIBADCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIABEMCQQDSrH0/EVSsgVipYJGABA9sajBfWkk56MAJauJ4tcDGKY130olUsaaBhkzoNgHzk4pwpTYKAj8xsAhzvn1inXBH
DH 乙方公钥 : MIIBpzCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIAA4GFAAKBgQDFKemcDu/FWN4fc7ESLqbSNUj6+eeBHiyo55tc1Sq5gFqoatET3MKUttKifCWGWRhmdQYBMjIXu83x/UobdEyG7rs166RroE7G7F/wDjBfT5/NUSZdImBwOB54eZjxcyvzY1SrwycZqhXZ3g51anujERZa+dryeNsdOZWoooYAug==
DH 乙方私钥 : MIIBZwIBADCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIABEMCQQCWRN3yc2CWqLLLH38ovypGM5594x8GaEMauSLwbVfLIdB/ztSfO3c23KCE06GonZ+0SbUVLEmGYLVqHLc2vxLv
DH 甲方 本地密钥 : T9ZoIMgETF4=
DH 乙方 本地密钥 : T9ZoIMgETF4=
加密前的数据: 需要加密的内容
加密后的数据: s5Y8S9gApyG5U6lSjAym5z1V1TYTdVBS
解密后数据: 需要加密的内容
```
直接调用DH类进行加密解密的方法和上面相同，就不再过多阐述。
## 获取密钥的字节长度
```java
/**
* 获取密钥的字节长度
*
* @param key 密钥
* @return 密钥字节长度
*/
int getKeyByteLength(String key);
```