fixcode

hutool-crypto/src/main/java/org/dromara/hutool/crypto/Cipher.java

@@ -49,8 +49,9 @@ public interface Cipher {
 	void init(CipherMode mode, Parameters parameters);
 
 	/**
-	 * 根据输入长度，获取输出长度，输出长度与算法相关<br>
+	 * 返回输出缓冲区为了保存下一个update或doFinal操作的结果所需的长度（以字节为单位）<br>
-	 * 输出长度只针对本次输入关联，即len长度的数据对应输出长度加doFinal的长度
+	 * 下一个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)];

hutool-crypto/src/main/java/org/dromara/hutool/crypto/JceCipher.java

@@ -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 {

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

@@ -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

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

@@ -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.*;
-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.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));
+		final String randomData = aes.encryptHex(content.getBytes(StandardCharsets.UTF_8));
-		aes.setMode(CipherMode.ENCRYPT);
+		assertEquals("cd0e3a249eaf0ed80c330338508898c4bddcfd665a1b414622164a273ca5daf7b4ebd2c00aaa66b84dd0a237708dac8e", randomData);
-		final String randomData2 = aes.updateHex(content.getBytes(StandardCharsets.UTF_8));
+
-		Assertions.assertEquals(randomData2, randomData);
+		/// 分段加密，update时只是生成部分密文
-		Assertions.assertEquals(randomData, "cd0e3a249eaf0ed80c330338508898c4");
+		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);
 	}
 }