change to KeyPair

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

@@ -16,8 +16,6 @@
 
 package org.dromara.hutool.crypto;
 
-import org.bouncycastle.crypto.BufferedBlockCipher;
-
 import java.util.Arrays;
 
 /**
@@ -93,7 +91,6 @@ public interface Cipher {
 		final byte[] buf = new byte[getOutputSize(in.length)];
 		int len = process(in, 0, in.length, buf, 0);
 		len += doFinal(buf, len);
-
 		if (len == buf.length) {
 			return buf;
 		}

hutool-crypto/src/main/java/org/dromara/hutool/crypto/asymmetric/AbstractAsymmetricCrypto.java

@@ -16,8 +16,7 @@
 
 package org.dromara.hutool.crypto.asymmetric;
 
-import java.security.PrivateKey;
+import java.security.KeyPair;
-import java.security.PublicKey;
 
 /**
  * 抽象的非对称加密对象，包装了加密和解密为Hex和Base64的封装
@@ -38,12 +37,10 @@ public abstract class AbstractAsymmetricCrypto<T extends AbstractAsymmetricCrypt
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
 	 *
 	 * @param algorithm  算法
-	 * @param privateKey 私钥
+	 * @param keyPair 密钥对，如果为{@code null}则生成随机的私钥和公钥
-	 * @param publicKey  公钥
-	 * @since 3.1.1
 	 */
-	public AbstractAsymmetricCrypto(final String algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	public AbstractAsymmetricCrypto(final String algorithm, final KeyPair keyPair) {
-		super(algorithm, privateKey, publicKey);
+		super(algorithm, keyPair);
 	}
 	// ------------------------------------------------------------------ Constructor end
 }

hutool-crypto/src/main/java/org/dromara/hutool/crypto/asymmetric/AsymmetricCrypto.java

@@ -25,10 +25,7 @@ import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
 import javax.crypto.IllegalBlockSizeException;
 import java.io.IOException;
-import java.security.Key;
+import java.security.*;
-import java.security.PrivateKey;
-import java.security.PublicKey;
-import java.security.SecureRandom;
 import java.security.spec.AlgorithmParameterSpec;
 
 /**
@@ -124,7 +121,7 @@ public class AsymmetricCrypto extends AbstractAsymmetricCrypto<AsymmetricCrypto>
 	 * @since 3.1.1
 	 */
 	public AsymmetricCrypto(final AsymmetricAlgorithm algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
-		this(algorithm.getValue(), privateKey, publicKey);
+		this(algorithm.getValue(), new KeyPair(publicKey, privateKey));
 	}
 
 	/**
@@ -151,9 +148,10 @@ public class AsymmetricCrypto extends AbstractAsymmetricCrypto<AsymmetricCrypto>
 	 */
 	public AsymmetricCrypto(final String algorithm, final byte[] privateKey, final byte[] publicKey) {
 		this(algorithm, //
-			KeyUtil.generatePrivateKey(algorithm, privateKey), //
+			new KeyPair(
-			KeyUtil.generatePublicKey(algorithm, publicKey)//
+				KeyUtil.generatePublicKey(algorithm, publicKey),
-		);
+				KeyUtil.generatePrivateKey(algorithm, privateKey)
+			));
 	}
 
 	/**
@@ -162,13 +160,11 @@ public class AsymmetricCrypto extends AbstractAsymmetricCrypto<AsymmetricCrypto>
 	 * 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
 	 *
-	 * @param algorithm  算法
+	 * @param algorithm 算法
-	 * @param privateKey 私钥
+	 * @param keyPair   密钥对，包含私钥和公钥，如果为{@code null}，则生成随机键值对
-	 * @param publicKey  公钥
-	 * @since 3.1.1
 	 */
-	public AsymmetricCrypto(final String algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	public AsymmetricCrypto(final String algorithm, final KeyPair keyPair) {
-		super(algorithm, privateKey, publicKey);
+		super(algorithm, keyPair);
 	}
 	// ------------------------------------------------------------------ Constructor end
 
@@ -244,8 +240,8 @@ public class AsymmetricCrypto extends AbstractAsymmetricCrypto<AsymmetricCrypto>
 	}
 
 	@Override
-	public AsymmetricCrypto init(final String algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	public AsymmetricCrypto init(final String algorithm, final KeyPair keyPair) {
-		super.init(algorithm, privateKey, publicKey);
+		super.init(algorithm, keyPair);
 		initCipher();
 		return this;
 	}
@@ -332,12 +328,9 @@ public class AsymmetricCrypto extends AbstractAsymmetricCrypto<AsymmetricCrypto>
 	 * @throws IOException               IO异常，不会被触发
 	 */
 	private byte[] doFinal(final byte[] data, final int maxBlockSize) throws IllegalBlockSizeException, BadPaddingException, IOException {
-		// 模长
-		final int dataLength = data.length;
-
 		// 不足分段
-		if (dataLength <= maxBlockSize) {
+		if (data.length <= maxBlockSize) {
-			return getCipher().doFinal(data, 0, dataLength);
+			return getCipher().doFinal(data, 0, data.length);
 		}
 
 		// 分段解密
@@ -350,9 +343,6 @@ public class AsymmetricCrypto extends AbstractAsymmetricCrypto<AsymmetricCrypto>
 	 * @param data         数据
 	 * @param maxBlockSize 最大分段的段大小，不能为小于1
 	 * @return 加密或解密后的数据
-	 * @throws IllegalBlockSizeException 分段异常
-	 * @throws BadPaddingException       padding错误异常
-	 * @throws IOException               IO异常，不会被触发
 	 */
 	@SuppressWarnings("resource")
 	private byte[] doFinalWithBlock(final byte[] data, final int maxBlockSize) throws IllegalBlockSizeException, BadPaddingException, IOException {

hutool-crypto/src/main/java/org/dromara/hutool/crypto/asymmetric/BaseAsymmetric.java

@@ -18,6 +18,7 @@ package org.dromara.hutool.crypto.asymmetric;
 
 import org.dromara.hutool.core.codec.binary.Base64;
 import org.dromara.hutool.core.lang.Assert;
+import org.dromara.hutool.core.util.ObjUtil;
 import org.dromara.hutool.crypto.CryptoException;
 import org.dromara.hutool.crypto.KeyUtil;
 
@@ -43,6 +44,10 @@ public class BaseAsymmetric<T extends BaseAsymmetric<T>> implements Serializable
 	 * 算法
 	 */
 	protected String algorithm;
+	/**
+	 * 锁
+	 */
+	protected Lock lock = new ReentrantLock();
 	/**
 	 * 公钥
 	 */
@@ -51,11 +56,6 @@ public class BaseAsymmetric<T extends BaseAsymmetric<T>> implements Serializable
 	 * 私钥
 	 */
 	protected PrivateKey privateKey;
-	/**
-	 * 锁
-	 */
-	protected final Lock lock = new ReentrantLock();
-
 	// ------------------------------------------------------------------ Constructor start
 
 	/**
@@ -64,13 +64,12 @@ public class BaseAsymmetric<T extends BaseAsymmetric<T>> implements Serializable
 	 * 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
 	 *
-	 * @param algorithm  算法
+	 * @param algorithm 算法
-	 * @param privateKey 私钥
+	 * @param keyPair   密钥对，包括私钥和公钥
-	 * @param publicKey  公钥
+	 * @since 6.0.0
-	 * @since 3.1.1
 	 */
-	public BaseAsymmetric(final String algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	public BaseAsymmetric(final String algorithm, final KeyPair keyPair) {
-		init(algorithm, privateKey, publicKey);
+		init(algorithm, keyPair);
 	}
 	// ------------------------------------------------------------------ Constructor end
 
@@ -79,15 +78,16 @@ public class BaseAsymmetric<T extends BaseAsymmetric<T>> implements Serializable
 	 * 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密（签名）或者解密（校验）
 	 *
-	 * @param algorithm  算法
+	 * @param algorithm 算法
-	 * @param privateKey 私钥
+	 * @param keyPair   密钥对，包括私钥和公钥
-	 * @param publicKey  公钥
 	 * @return this
 	 */
 	@SuppressWarnings("unchecked")
-	protected T init(final String algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	protected T init(final String algorithm, final KeyPair keyPair) {
 		this.algorithm = algorithm;
 
+		final PrivateKey privateKey = ObjUtil.apply(keyPair, KeyPair::getPrivate);
+		final PublicKey publicKey = ObjUtil.apply(keyPair, KeyPair::getPublic);
 		if (null == privateKey && null == publicKey) {
 			initKeys();
 		} else {
@@ -102,7 +102,7 @@ public class BaseAsymmetric<T extends BaseAsymmetric<T>> implements Serializable
 	}
 
 	/**
-	 * 生成公钥和私钥
+	 * 生成随机公钥和私钥
 	 *
 	 * @return this
 	 */
@@ -114,7 +114,20 @@ public class BaseAsymmetric<T extends BaseAsymmetric<T>> implements Serializable
 		return (T) this;
 	}
 
-	// --------------------------------------------------------------------------------- Getters and Setters
+	/**
+	 * 自定义锁，无需锁使用{@link org.dromara.hutool.core.thread.lock.NoLock}
+	 *
+	 * @param lock 自定义锁
+	 * @return this
+	 * @since 6.0.0
+	 */
+	@SuppressWarnings("unchecked")
+	public T setLock(final Lock lock) {
+		this.lock = lock;
+		return (T) this;
+	}
+
+	// region ----- getOrSetKeys
 
 	/**
 	 * 获得公钥
@@ -217,4 +230,5 @@ public class BaseAsymmetric<T extends BaseAsymmetric<T>> implements Serializable
 		}
 		throw new CryptoException("Unsupported key type: " + type);
 	}
+	// endregion
 }

hutool-crypto/src/main/java/org/dromara/hutool/crypto/asymmetric/ECIES.java

@@ -16,8 +16,7 @@
 
 package org.dromara.hutool.crypto.asymmetric;
 
-import java.security.PrivateKey;
+import java.security.KeyPair;
-import java.security.PublicKey;
 
 /**
  * ECIES（集成加密方案，elliptic curve integrate encrypt scheme）
@@ -95,12 +94,10 @@ public class ECIES extends AsymmetricCrypto{
 	 * 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
 	 *
-	 * @param privateKey 私钥
+	 * @param keyPair 密钥对，{@code null}表示随机生成
-	 * @param publicKey 公钥
-	 * @since 3.1.1
 	 */
-	public ECIES(final PrivateKey privateKey, final PublicKey publicKey) {
+	public ECIES(final KeyPair keyPair) {
-		super(ALGORITHM_ECIES, privateKey, publicKey);
+		super(ALGORITHM_ECIES, keyPair);
 	}
 
 	/**
@@ -109,12 +106,10 @@ public class ECIES extends AsymmetricCrypto{
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
 	 *
 	 * @param eciesAlgorithm 自定义ECIES算法，例如ECIESwithDESede/NONE/PKCS7Padding
-	 * @param privateKey 私钥
+	 * @param keyPair 密钥对，{@code null}表示随机生成
-	 * @param publicKey 公钥
-	 * @since 4.5.8
 	 */
-	public ECIES(final String eciesAlgorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	public ECIES(final String eciesAlgorithm, final KeyPair keyPair) {
-		super(eciesAlgorithm, privateKey, publicKey);
+		super(eciesAlgorithm, keyPair);
 	}
 	// ------------------------------------------------------------------ Constructor end
 }

hutool-crypto/src/main/java/org/dromara/hutool/crypto/asymmetric/RSA.java

@@ -21,6 +21,7 @@ import org.dromara.hutool.crypto.provider.GlobalProviderFactory;
 import org.dromara.hutool.crypto.KeyUtil;
 
 import java.math.BigInteger;
+import java.security.KeyPair;
 import java.security.NoSuchAlgorithmException;
 import java.security.PrivateKey;
 import java.security.PublicKey;
@@ -161,12 +162,10 @@ public class RSA extends AsymmetricCrypto {
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
 	 *
 	 * @param rsaAlgorithm 自定义RSA算法，例如RSA/ECB/PKCS1Padding
-	 * @param privateKey 私钥
+	 * @param  keyPair 密钥对，{@code null}表示随机生成
-	 * @param publicKey 公钥
-	 * @since 4.5.8
 	 */
-	public RSA(final String rsaAlgorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	public RSA(final String rsaAlgorithm, final KeyPair keyPair) {
-		super(rsaAlgorithm, privateKey, publicKey);
+		super(rsaAlgorithm, keyPair);
 	}
 	// ------------------------------------------------------------------ Constructor end
 

hutool-crypto/src/main/java/org/dromara/hutool/crypto/asymmetric/SM2.java

@@ -168,7 +168,7 @@ public class SM2 extends AbstractAsymmetricCrypto<SM2> {
 	 * @param publicKeyParams  公钥，可以为null
 	 */
 	public SM2(final ECPrivateKeyParameters privateKeyParams, final ECPublicKeyParameters publicKeyParams) {
-		super(ALGORITHM_SM2, null, null);
+		super(ALGORITHM_SM2, null);
 		this.privateKeyParams = privateKeyParams;
 		this.publicKeyParams = publicKeyParams;
 		this.init();

hutool-crypto/src/main/java/org/dromara/hutool/crypto/asymmetric/Sign.java

@@ -45,10 +45,13 @@ import java.util.Set;
 public class Sign extends BaseAsymmetric<Sign> {
 	private static final long serialVersionUID = 1L;
 
-	/** 签名，用于签名和验证 */
+	/**
+	 * 签名，用于签名和验证
+	 */
 	protected Signature signature;
 
 	// ------------------------------------------------------------------ Constructor start
+
 	/**
 	 * 构造，创建新的私钥公钥对
 	 *
@@ -71,9 +74,9 @@ public class Sign extends BaseAsymmetric<Sign> {
 	 * 构造 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
 	 *
-	 * @param algorithm {@link SignAlgorithm}
+	 * @param algorithm     {@link SignAlgorithm}
 	 * @param privateKeyStr 私钥Hex或Base64表示
-	 * @param publicKeyStr 公钥Hex或Base64表示
+	 * @param publicKeyStr  公钥Hex或Base64表示
 	 */
 	public Sign(final SignAlgorithm algorithm, final String privateKeyStr, final String publicKeyStr) {
 		this(algorithm.getValue(), SecureUtil.decode(privateKeyStr), SecureUtil.decode(publicKeyStr));
@@ -83,9 +86,9 @@ public class Sign extends BaseAsymmetric<Sign> {
 	 * 构造 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
 	 *
-	 * @param algorithm {@link SignAlgorithm}
+	 * @param algorithm  {@link SignAlgorithm}
 	 * @param privateKey 私钥
-	 * @param publicKey 公钥
+	 * @param publicKey  公钥
 	 */
 	public Sign(final SignAlgorithm algorithm, final byte[] privateKey, final byte[] publicKey) {
 		this(algorithm.getValue(), privateKey, publicKey);
@@ -96,7 +99,7 @@ public class Sign extends BaseAsymmetric<Sign> {
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
 	 *
 	 * @param algorithm {@link SignAlgorithm}
-	 * @param keyPair 密钥对（包括公钥和私钥）
+	 * @param keyPair   密钥对，{@code null}表示随机生成
 	 */
 	public Sign(final SignAlgorithm algorithm, final KeyPair keyPair) {
 		this(algorithm.getValue(), keyPair);
@@ -106,21 +109,9 @@ public class Sign extends BaseAsymmetric<Sign> {
 	 * 构造 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
 	 *
-	 * @param algorithm {@link SignAlgorithm}
+	 * @param algorithm        非对称加密算法
-	 * @param privateKey 私钥
-	 * @param publicKey 公钥
-	 */
-	public Sign(final SignAlgorithm algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
-		this(algorithm.getValue(), privateKey, publicKey);
-	}
-
-	/**
-	 * 构造 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
-	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
-	 *
-	 * @param algorithm 非对称加密算法
 	 * @param privateKeyBase64 私钥Base64
-	 * @param publicKeyBase64 公钥Base64
+	 * @param publicKeyBase64  公钥Base64
 	 */
 	public Sign(final String algorithm, final String privateKeyBase64, final String publicKeyBase64) {
 		this(algorithm, Base64.decode(privateKeyBase64), Base64.decode(publicKeyBase64));
@@ -132,26 +123,16 @@ public class Sign extends BaseAsymmetric<Sign> {
 	 * 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
 	 *
-	 * @param algorithm 算法
+	 * @param algorithm  算法
 	 * @param privateKey 私钥
-	 * @param publicKey 公钥
+	 * @param publicKey  公钥
 	 */
 	public Sign(final String algorithm, final byte[] privateKey, final byte[] publicKey) {
-		this(algorithm, //
+		this(algorithm,
-				KeyUtil.generatePrivateKey(algorithm, privateKey), //
+			new KeyPair(
-				KeyUtil.generatePublicKey(algorithm, publicKey)//
+				KeyUtil.generatePublicKey(algorithm, publicKey),
-		);
+				KeyUtil.generatePrivateKey(algorithm, privateKey)
-	}
+			));
-
-	/**
-	 * 构造 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
-	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
-	 *
-	 * @param algorithm 算法，见{@link SignAlgorithm}
-	 * @param keyPair 密钥对（包括公钥和私钥）
-	 */
-	public Sign(final String algorithm, final KeyPair keyPair) {
-		this(algorithm, keyPair.getPrivate(), keyPair.getPublic());
 	}
 
 	/**
@@ -161,26 +142,24 @@ public class Sign extends BaseAsymmetric<Sign> {
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做签名或验证
 	 *
 	 * @param algorithm 算法
-	 * @param privateKey 私钥
+	 * @param keyPair   密钥对，{@code null}表示随机生成
-	 * @param publicKey 公钥
 	 */
-	public Sign(final String algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	public Sign(final String algorithm, final KeyPair keyPair) {
-		super(algorithm, privateKey, publicKey);
+		super(algorithm, keyPair);
 	}
 	// ------------------------------------------------------------------ Constructor end
 
 	/**
 	 * 初始化
 	 *
-	 * @param algorithm 算法
+	 * @param algorithm  算法
-	 * @param privateKey 私钥
+	 * @param keyPair   密钥对，{@code null}表示随机生成
-	 * @param publicKey 公钥
 	 * @return this
 	 */
 	@Override
-	public Sign init(final String algorithm, final PrivateKey privateKey, final PublicKey publicKey) {
+	public Sign init(final String algorithm, final KeyPair keyPair) {
 		signature = SignUtil.createSignature(algorithm);
-		super.init(algorithm, privateKey, publicKey);
+		super.init(algorithm, keyPair);
 		return this;
 	}
 
@@ -201,10 +180,11 @@ public class Sign extends BaseAsymmetric<Sign> {
 	}
 
 	// --------------------------------------------------------------------------------- Sign and Verify
+
 	/**
 	 * 生成文件签名
 	 *
-	 * @param data 被签名数据
+	 * @param data    被签名数据
 	 * @param charset 编码
 	 * @return 签名
 	 * @since 5.7.0
@@ -227,7 +207,7 @@ public class Sign extends BaseAsymmetric<Sign> {
 	/**
 	 * 生成文件签名，并转为16进制字符串
 	 *
-	 * @param data 被签名数据
+	 * @param data    被签名数据
 	 * @param charset 编码
 	 * @return 签名
 	 * @since 5.7.0
@@ -295,7 +275,7 @@ public class Sign extends BaseAsymmetric<Sign> {
 	 * 生成签名，并转为16进制字符串<br>
 	 * 使用默认缓存大小，见 {@link IoUtil#DEFAULT_BUFFER_SIZE}
 	 *
-	 * @param data 被签名数据
+	 * @param data         被签名数据
 	 * @param bufferLength 缓存长度，不足1使用 {@link IoUtil#DEFAULT_BUFFER_SIZE} 做为默认值
 	 * @return 签名
 	 * @since 5.7.0
@@ -307,12 +287,12 @@ public class Sign extends BaseAsymmetric<Sign> {
 	/**
 	 * 生成签名
 	 *
-	 * @param data {@link InputStream} 数据流
+	 * @param data         {@link InputStream} 数据流
 	 * @param bufferLength 缓存长度，不足1使用 {@link IoUtil#DEFAULT_BUFFER_SIZE} 做为默认值
 	 * @return 签名bytes
 	 * @since 5.7.0
 	 */
-	public byte[] sign(final InputStream data, int bufferLength){
+	public byte[] sign(final InputStream data, int bufferLength) {
 		if (bufferLength < 1) {
 			bufferLength = IoUtil.DEFAULT_BUFFER_SIZE;
 		}

hutool-crypto/src/main/java/org/dromara/hutool/crypto/asymmetric/paillier/PaillierCrypto.java

@@ -60,23 +60,10 @@ public class PaillierCrypto extends AbstractAsymmetricCrypto<PaillierCrypto> {
 	 * 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
 	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
 	 *
-	 * @param keyPair 密钥对
+	 * @param keyPair 密钥对，{@code null}表示随机生成
 	 */
 	public PaillierCrypto(final KeyPair keyPair) {
-		this(keyPair.getPrivate(), keyPair.getPublic());
+		super(PaillierKey.ALGORITHM_NAME, keyPair);
-	}
-
-	/**
-	 * 构造
-	 * <p>
-	 * 私钥和公钥同时为空时生成一对新的私钥和公钥<br>
-	 * 私钥和公钥可以单独传入一个，如此则只能使用此钥匙来做加密或者解密
-	 *
-	 * @param privateKey 私钥
-	 * @param publicKey  公钥
-	 */
-	public PaillierCrypto(final PrivateKey privateKey, final PublicKey publicKey) {
-		super(PaillierKey.ALGORITHM_NAME, privateKey, publicKey);
 		this.spi = new PaillierCipherSpiImpl();
 	}
 

hutool-crypto/src/test/java/org/dromara/hutool/crypto/SignUtilTest.java

@@ -21,6 +21,7 @@ import org.dromara.hutool.crypto.bc.PemUtil;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import java.security.KeyPair;
 import java.security.PublicKey;
 
 public class SignUtilTest {
@@ -68,6 +69,6 @@ public class SignUtilTest {
 			"-----END CERTIFICATE-----";
 
 		final PublicKey key = (PublicKey) PemUtil.readPemKey(IoUtil.toUtf8Stream(publicKey));
-		new Sign(SignAlgorithm.SHA256withRSA, null, key);
+		new Sign(SignAlgorithm.SHA256withRSA, new KeyPair(key, null));
 	}
 }

hutool-crypto/src/test/java/org/dromara/hutool/crypto/asymmetric/RSATest.java

@@ -186,7 +186,7 @@ public class RSATest {
 				+ "wfMhrJksfeKbIaMjNLS9b8JynIaXg9iCiyOHmgkMl5gAbPoH/ULXqSKwzBw5mJ2GW1gBlyaSfV3AkA/RJC+adIjsRGg"//
 				+ "JOkiRjSmPpGv3FOhl9fsBPjupZBEIuoMWOC8GXK/73DHxwmfNmN7C9+sIi4RBcjEeQ5F5FHZ";
 
-		final RSA rsa = new RSA(PRIVATE_KEY, null);
+		final RSA rsa = new RSA(PRIVATE_KEY, (String) null);
 
 		final String a = "2707F9FD4288CEF302C972058712F24A5F3EC62C5A14AD2FC59DAB93503AA0FA17113A020EE4EA35EB53F" //
 				+ "75F36564BA1DABAA20F3B90FD39315C30E68FE8A1803B36C29029B23EB612C06ACF3A34BE815074F5EB5AA3A"//

hutool-poi/src/main/java/org/dromara/hutool/poi/excel/writer/ExcelWriter.java

@@ -1008,6 +1008,14 @@ public class ExcelWriter extends ExcelBase<ExcelWriter, ExcelWriteConfig> {
 	}
 	// endregion
 
+	// region ----- fill
+
+	public ExcelWriter fillRow(final Map<?, ?> rowMap){
+		return this;
+	}
+
+	// endregion
+
 	// region ----- writeCol
 
 	/**

hutool-poi/src/main/java/org/dromara/hutool/poi/excel/writer/TemplateContext.java

@@ -99,4 +99,11 @@ public class TemplateContext {
 			}
 		});
 	}
+
+	@Override
+	public String toString() {
+		return "TemplateContext{" +
+			"varMap=" + varMap +
+			'}';
+	}
 }

hutool-poi/src/test/java/org/dromara/hutool/poi/excel/writer/TemplateContextTest.java

@@ -12,6 +12,7 @@
 
 package org.dromara.hutool.poi.excel.writer;
 
+import org.dromara.hutool.core.lang.Console;
 import org.dromara.hutool.poi.excel.ExcelUtil;
 import org.junit.jupiter.api.Test;
 
@@ -20,5 +21,6 @@ public class TemplateContextTest {
 	void readTemplate() {
 		final ExcelWriter writer = ExcelUtil.getWriter("d:/test/template.xlsx");
 		final TemplateContext templateContext = new TemplateContext(writer.getSheet());
+		Console.log(templateContext);
 	}
 }