ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-05-09 23:51:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

fixcode

Browse Source
This commit is contained in:
Looly 2024-08-15 09:50:23 +08:00
parent 776a8cbba5
commit a07317fee4
4 changed files with 91 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
hutool-crypto/src/main/java/org/dromara/hutool/crypto/Cipher.java
View File

@ -49,8 +49,9 @@ public interface Cipher {
void init(CipherMode mode, Parameters parameters);
/**
* 根据输入长度，获取输出长度，输出长度与算法相关<br>
* 输出长度只针对本次输入关联，即len长度的数据对应输出长度加doFinal的长度
* 返回输出缓冲区为了保存下一个update或doFinal操作的结果所需的长度（以字节为单位）<br>
* 下一个update或doFinal调用的实际输出长度可能小于此方法返回的长度。<br>
* 一般为块大小对应的输出大小
*
* @param len 输入长度
* @return 输出长度，-1表示非块加密
@ -58,7 +59,8 @@ public interface Cipher {
int getOutputSize(int len);
/**
* 执行运算，可以是加密运算或解密运算
* 执行运算，可以是加密运算或解密运算<br>
* 此方法主要处理一块数据，一块数据处理完毕后，应调用{@link #doFinal(byte[], int)}处理padding等剩余数据。
*
* @param in 输入数据
* @param inOff 输入数据开始位置
@ -82,7 +84,8 @@ public interface Cipher {
int doFinal(byte[] out, int outOff);
/**
* 处理数据，并返回最终结果
* 处理数据，并返回最终结果<br>
* 此方法用于完整处理一块数据并返回。
*
* @param in 输入数据
* @return 结果数据
@ -92,12 +95,15 @@ public interface Cipher {
}
/**
* 处理数据，并返回最终结果
* 处理数据，并返回最终结果<br>
* 此方法用于完整处理一块数据并返回。
*
* @param in 输入数据
* @param inOffset 输入开始的 input中的偏移量
* @param inputLen 输入长度
* @return 结果数据
* @see #process(byte[], int, int, byte[], int)
* @see #doFinal(byte[], int)
*/
default byte[] processFinal(final byte[] in, final int inOffset, final int inputLen) {
final byte[] buf = new byte[getOutputSize(in.length)];

19
hutool-crypto/src/main/java/org/dromara/hutool/crypto/JceCipher.java
View File

@ -66,6 +66,16 @@ public class JceCipher extends SimpleWrapper<javax.crypto.Cipher> implements Cip
return this.raw.getOutputSize(len);
}
/**
* 返回新缓冲区中的初始化向量（IV）<br>
* 这在创建随机IV的情况下，或在基于密码的加密或解密的上下文中是有用的，其中IV是从用户提供的密码导出的。
*
* @return 新缓冲区中的初始化向量，如果基础算法不使用IV，或者尚未设置IV，则为null。
*/
public byte[] getIV() {
return this.raw.getIV();
}
@Override
public void init(final CipherMode mode, final Parameters parameters) {
Assert.isInstanceOf(JceParameters.class, parameters, "Only support JceParameters!");
@ -120,6 +130,15 @@ public class JceCipher extends SimpleWrapper<javax.crypto.Cipher> implements Cip
}
}
@Override
public byte[] processFinal(final byte[] in) {
try {
return this.raw.doFinal(in);
} catch (final Exception e) {
throw new CryptoException(e);
}
}
@Override
public byte[] processFinal(final byte[] data, final int inOffset, final int inputLen) {
try {

26
hutool-crypto/src/main/java/org/dromara/hutool/crypto/symmetric/SymmetricCrypto.java
View File

@ -294,6 +294,32 @@ public class SymmetricCrypto implements SymmetricEncryptor, SymmetricDecryptor,
return HexUtil.encodeStr(update(data));
}
/**
* 完成多部分加密或解密操作，具体取决于此密码的初始化方式。
*
* @return 带有结果的新缓冲区
*/
public byte[] doFinal() {
final Cipher cipher = this.cipher.getRaw();
lock.lock();
try {
return cipher.doFinal();
} catch (final Exception e) {
throw new CryptoException(e);
} finally {
lock.unlock();
}
}
/**
* 完成多部分加密或解密操作，具体取决于此密码的初始化方式。
*
* @return 带有结果的新缓冲区
*/
public String doFinalHex() {
return HexUtil.encodeStr(doFinal());
}
// --------------------------------------------------------------------------------- Encrypt
@Override

60
hutool-crypto/src/test/java/org/dromara/hutool/crypto/symmetric/SymmetricTest.java
View File

@ -13,20 +13,17 @@
package org.dromara.hutool.crypto.symmetric;
import org.dromara.hutool.core.io.IoUtil;
import org.dromara.hutool.core.text.StrUtil;
import org.dromara.hutool.core.util.CharsetUtil;
import org.dromara.hutool.core.util.RandomUtil;
import org.dromara.hutool.core.text.StrUtil;
import org.dromara.hutool.crypto.CipherMode;
import org.dromara.hutool.crypto.KeyUtil;
import org.dromara.hutool.crypto.Mode;
import org.dromara.hutool.crypto.Padding;
import org.dromara.hutool.crypto.SecureUtil;
import org.junit.jupiter.api.Assertions;
import org.dromara.hutool.crypto.*;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* 对称加密算法单元测试
*
@ -49,14 +46,14 @@ public class SymmetricTest {
// 解密
final byte[] decrypt = aes.decrypt(encrypt);
Assertions.assertEquals(content, StrUtil.str(decrypt, CharsetUtil.UTF_8));
assertEquals(content, StrUtil.str(decrypt, CharsetUtil.UTF_8));
// 加密为16进制表示
final String encryptHex = aes.encryptHex(content);
// 解密为字符串
final String decryptStr = aes.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assertions.assertEquals(content, decryptStr);
assertEquals(content, decryptStr);
}
@Test
@ -74,14 +71,14 @@ public class SymmetricTest {
// 解密
final byte[] decrypt = aes.decrypt(encrypt);
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
assertEquals(content, StrUtil.utf8Str(decrypt));
// 加密为16进制表示
final String encryptHex = aes.encryptHex(content);
// 解密为字符串
final String decryptStr = aes.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assertions.assertEquals(content, decryptStr);
assertEquals(content, decryptStr);
}
@Test
@ -95,14 +92,14 @@ public class SymmetricTest {
// 解密
final byte[] decrypt = aes.decrypt(encrypt);
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
assertEquals(content, StrUtil.utf8Str(decrypt));
// 加密为16进制表示
final String encryptHex = aes.encryptHex(content);
// 解密为字符串
final String decryptStr = aes.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assertions.assertEquals(content, decryptStr);
assertEquals(content, decryptStr);
}
@Test
@ -113,7 +110,7 @@ public class SymmetricTest {
// 加密为16进制表示
final String encryptHex = aes.encryptHex(content);
Assertions.assertEquals("cd0e3a249eaf0ed80c330338508898c4bddcfd665a1b414622164a273ca5daf7b4ebd2c00aaa66b84dd0a237708dac8e", encryptHex);
assertEquals("cd0e3a249eaf0ed80c330338508898c4bddcfd665a1b414622164a273ca5daf7b4ebd2c00aaa66b84dd0a237708dac8e", encryptHex);
}
@Test
@ -126,7 +123,7 @@ public class SymmetricTest {
final String encryptHex = crypto.encryptHex(content);
final String data = crypto.decryptStr(encryptHex);
Assertions.assertEquals(content, data);
assertEquals(content, data);
}
@Test
@ -136,11 +133,16 @@ public class SymmetricTest {
// 加密为16进制表示
aes.setMode(CipherMode.ENCRYPT);
final String randomData = aes.updateHex(content.getBytes(StandardCharsets.UTF_8));
aes.setMode(CipherMode.ENCRYPT);
final String randomData2 = aes.updateHex(content.getBytes(StandardCharsets.UTF_8));
Assertions.assertEquals(randomData2, randomData);
Assertions.assertEquals(randomData, "cd0e3a249eaf0ed80c330338508898c4");
final String randomData = aes.encryptHex(content.getBytes(StandardCharsets.UTF_8));
assertEquals("cd0e3a249eaf0ed80c330338508898c4bddcfd665a1b414622164a273ca5daf7b4ebd2c00aaa66b84dd0a237708dac8e", randomData);
/// 分段加密，update时只是生成部分密文
String randomData2 = aes.updateHex(content.getBytes(StandardCharsets.UTF_8));
assertEquals("cd0e3a249eaf0ed80c330338508898c4", randomData2);
// doFinal后生成剩余内容
randomData2 += aes.doFinalHex();
assertEquals(randomData, randomData2);
}
@ -153,7 +155,7 @@ public class SymmetricTest {
final String encryptHex = aes.encryptHex(content);
// 解密
final String decryptStr = aes.decryptStr(encryptHex);
Assertions.assertEquals(content, decryptStr);
assertEquals(content, decryptStr);
}
@Test
@ -167,7 +169,7 @@ public class SymmetricTest {
final ByteArrayOutputStream contentStream = new ByteArrayOutputStream();
aes.decrypt(IoUtil.toStream(encryptStream), contentStream, true);
Assertions.assertEquals(content, StrUtil.utf8Str(contentStream.toByteArray()));
assertEquals(content, StrUtil.utf8Str(contentStream.toByteArray()));
}
@Test
@ -181,7 +183,7 @@ public class SymmetricTest {
final String encryptHex = aes.encryptHex(content);
// 解密
final String decryptStr = aes.decryptStr(encryptHex);
Assertions.assertEquals(content, decryptStr);
assertEquals(content, decryptStr);
}
@Test
@ -195,12 +197,12 @@ public class SymmetricTest {
final byte[] encrypt = des.encrypt(content);
final byte[] decrypt = des.decrypt(encrypt);
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
assertEquals(content, StrUtil.utf8Str(decrypt));
final String encryptHex = des.encryptHex(content);
final String decryptStr = des.decryptStr(encryptHex);
Assertions.assertEquals(content, decryptStr);
assertEquals(content, decryptStr);
}
@Test
@ -214,12 +216,12 @@ public class SymmetricTest {
final byte[] encrypt = des.encrypt(content);
final byte[] decrypt = des.decrypt(encrypt);
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
assertEquals(content, StrUtil.utf8Str(decrypt));
final String encryptHex = des.encryptHex(content);
final String decryptStr = des.decryptStr(encryptHex);
Assertions.assertEquals(content, decryptStr);
assertEquals(content, decryptStr);
}
@Test
@ -228,8 +230,8 @@ public class SymmetricTest {
final String key = "CompleteVictory";
final String encrypt = Vigenere.encrypt(content, key);
Assertions.assertEquals("zXScRZ]KIOMhQjc0\\bYRXZOJK[Vi", encrypt);
assertEquals("zXScRZ]KIOMhQjc0\\bYRXZOJK[Vi", encrypt);
final String decrypt = Vigenere.decrypt(encrypt, key);
Assertions.assertEquals(content, decrypt);
assertEquals(content, decrypt);
}
}