fix(crypto): strengthen signature length validation

actuator/src/main/java/org/tron/core/utils/TransactionUtil.java

@@ -223,9 +223,12 @@ public TransactionSignWeight getTransactionSignWeight(Transaction trx) {
         tswBuilder.setPermission(permission);
         if (trx.getSignatureCount() > 0) {
           List<ByteString> approveList = new ArrayList<>();
+          // Read-only introspection: pass checkMaxSignatureSize=false so a historical tx
+          // committed with a sig above MAX_SIGNATURE_SIZE is still resolvable
           long currentWeight = TransactionCapsule.checkWeight(permission, trx.getSignatureList(),
               Sha256Hash.hash(CommonParameter.getInstance()
-                  .isECKeyCryptoEngine(), trx.getRawData().toByteArray()), approveList);
+                  .isECKeyCryptoEngine(), trx.getRawData().toByteArray()), approveList,
+              false);
           tswBuilder.addAllApprovedList(approveList);
           tswBuilder.setCurrentWeight(currentWeight);
         }

chainbase/src/main/java/org/tron/common/utils/ForkController.java

@@ -216,6 +216,10 @@ public static ForkController instance() {
     return ForkControllerEnum.INSTANCE.getInstance();
   }
 
+  public static boolean signatureMaxSizeChecked() {
+    return instance().pass(ForkBlockVersionEnum.VERSION_4_8_2);
+  }
+
   private enum ForkControllerEnum {
     INSTANCE;
 

chainbase/src/main/java/org/tron/core/capsule/BlockCapsule.java

@@ -35,6 +35,7 @@
 import org.tron.common.crypto.SignUtils;
 import org.tron.common.parameter.CommonParameter;
 import org.tron.common.utils.ByteArray;
+import org.tron.common.utils.ForkController;
 import org.tron.common.utils.Sha256Hash;
 import org.tron.common.utils.Time;
 import org.tron.core.capsule.utils.MerkleTree;
@@ -185,9 +186,14 @@ private Sha256Hash getRawHash() {
   public boolean validateSignature(DynamicPropertiesStore dynamicPropertiesStore,
       AccountStore accountStore) throws ValidateSignatureException {
     try {
+      ByteString witnessSig = block.getBlockHeader().getWitnessSignature();
+      if (!SignUtils.isValidLength(witnessSig.size(),
+          ForkController.signatureMaxSizeChecked())) {
+        throw new ValidateSignatureException(
+            "Witness signature size is " + witnessSig.size());
+      }
       byte[] sigAddress = SignUtils.signatureToAddress(getRawHash().getBytes(),
-          TransactionCapsule.getBase64FromByteString(
-              block.getBlockHeader().getWitnessSignature()),
+          TransactionCapsule.getBase64FromByteString(witnessSig),
           CommonParameter.getInstance().isECKeyCryptoEngine());
       byte[] witnessAccountAddress = block.getBlockHeader().getRawData().getWitnessAddress()
           .toByteArray();

chainbase/src/main/java/org/tron/core/capsule/TransactionCapsule.java

@@ -230,7 +230,7 @@ public static long getWeight(Permission permission, byte[] address) {
    *  @see ForkController#init(org.tron.core.ChainBaseManager)
    */
   public static long checkWeight(Permission permission, List<ByteString> sigs, byte[] hash,
-      List<ByteString> approveList)
+      List<ByteString> approveList, boolean checkMaxSignatureSize)
       throws SignatureException, PermissionException, SignatureFormatException {
     long currentWeight = 0;
     if (sigs.size() > permission.getKeysCount()) {
@@ -240,9 +240,8 @@ public static long checkWeight(Permission permission, List<ByteString> sigs, byt
     }
     HashMap addMap = new HashMap();
     for (ByteString sig : sigs) {
-      if (sig.size() < 65) {
-        throw new SignatureFormatException(
-            "Signature size is " + sig.size());
+      if (!SignUtils.isValidLength(sig.size(), checkMaxSignatureSize)) {
+        throw new SignatureFormatException("Signature size is " + sig.size());
       }
       String base64 = TransactionCapsule.getBase64FromByteString(sig);
       byte[] address = SignUtils
@@ -487,7 +486,8 @@ public static boolean validateSignature(Transaction transaction,
       throw new PermissionException("permission isn't exit");
     }
     checkPermission(permissionId, permission, contract);
-    long weight = checkWeight(permission, transaction.getSignatureList(), hash, null);
+    long weight = checkWeight(permission, transaction.getSignatureList(), hash, null,
+        ForkController.signatureMaxSizeChecked());
     if (weight >= permission.getThreshold()) {
       return true;
     }
@@ -604,7 +604,7 @@ public void addSign(byte[] privateKey, AccountStore accountStore)
     if (this.transaction.getSignatureCount() > 0) {
       checkWeight(permission, this.transaction.getSignatureList(),
           this.getTransactionId().getBytes(),
-          approveList);
+          approveList, true);
       if (approveList.contains(ByteString.copyFrom(address))) {
         throw new PermissionException(encode58Check(address) + " had signed!");
       }
@@ -620,8 +620,9 @@ public void addSign(byte[] privateKey, AccountStore accountStore)
         .signHash(getTransactionId().getBytes())));
     this.transaction = this.transaction.toBuilder().addSignature(sig).build();
   }
-
-  private static void checkPermission(int permissionId, Permission permission, Transaction.Contract contract) throws PermissionException {
+
+  private static void checkPermission(int permissionId, Permission permission,
+      Transaction.Contract contract) throws PermissionException {
     if (permissionId != 0) {
       if (permission.getType() != PermissionType.Active) {
         throw new PermissionException("Permission type is error");
@@ -703,7 +704,7 @@ public boolean validateSignature(AccountStore accountStore,
         }
       }
       isVerified = true;
-    }  
+    }
     return true;
   }
 

common/src/main/java/org/tron/core/config/Parameter.java

@@ -69,6 +69,11 @@ public class ChainConstant {
     public static final int MAX_VOTE_NUMBER = 30;
     public static final int SOLIDIFIED_THRESHOLD = 70; // 70%
     public static final int PRIVATE_KEY_LENGTH = 64;
+    public static final int MIN_SIGNATURE_SIZE = 65;
+    // Canonical ECDSA signature is 65 bytes (r||s||v). 68 = 65 + up to 3 trailing
+    // padding bytes; this window accommodates historical non-canonical encodings
+    // observed on chain. Long-term goal is to tighten this back to a strict 65.
+    public static final int MAX_SIGNATURE_SIZE = 68;
     public static final int BLOCK_SIZE = 2_000_000;
     public static final long CLOCK_MAX_DELAY = 3600000; // 3600 * 1000 ms
     public static final int BLOCK_PRODUCE_TIMEOUT_PERCENT = 50; // 50%

consensus/src/main/java/org/tron/consensus/pbft/PbftMessageHandle.java

@@ -28,9 +28,9 @@
 import org.tron.consensus.base.Param;
 import org.tron.consensus.base.Param.Miner;
 import org.tron.consensus.dpos.MaintenanceManager;
+import org.tron.common.utils.ForkController;
 import org.tron.consensus.pbft.message.PbftBaseMessage;
 import org.tron.consensus.pbft.message.PbftMessage;
-import org.tron.core.ChainBaseManager;
 import org.tron.protos.Protocol.PBFTMessage.DataType;
 
 @Slf4j(topic = "pbft")
@@ -72,8 +72,6 @@ public List<ByteString> load(String s) throws Exception {
   private PbftMessageAction pbftMessageAction;
   @Setter
   private MaintenanceManager maintenanceManager;
-  @Autowired
-  private ChainBaseManager chainBaseManager;
 
   @PostConstruct
   public void init() {
@@ -129,7 +127,7 @@ public void onPrePrepare(PbftMessage message) {
       PbftMessage paMessage = message.buildPrePareMessage(miner);
       forwardMessage(paMessage);
       try {
-        paMessage.analyzeSignature();
+        paMessage.analyzeSignature(ForkController.signatureMaxSizeChecked());
       } catch (SignatureException e) {
         logger.error("", e);
       }
@@ -175,7 +173,7 @@ public synchronized void onPrepare(PbftMessage message) {
           doneMsg.put(message.getNo(), cmMessage);
           forwardMessage(cmMessage);
           try {
-            cmMessage.analyzeSignature();
+            cmMessage.analyzeSignature(ForkController.signatureMaxSizeChecked());
           } catch (SignatureException e) {
             logger.error("", e);
           }
@@ -316,4 +314,4 @@ public void run() {
       }
     }, 10, 1000);
   }
-}
+}

consensus/src/main/java/org/tron/consensus/pbft/message/PbftBaseMessage.java

@@ -1,17 +1,20 @@
 package org.tron.consensus.pbft.message;
 
+import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
 import java.io.IOException;
 import java.security.SignatureException;
 import java.util.stream.Collectors;
 import org.bouncycastle.util.encoders.Hex;
 import org.tron.common.crypto.ECKey;
+import org.tron.common.crypto.SignUtils;
 import org.tron.common.overlay.message.Message;
 import org.tron.common.utils.ByteUtil;
 import org.tron.common.utils.Sha256Hash;
 import org.tron.common.utils.StringUtil;
 import org.tron.core.capsule.TransactionCapsule;
 import org.tron.core.exception.P2pException;
+import org.tron.core.store.DynamicPropertiesStore;
 import org.tron.protos.Protocol.PBFTMessage;
 import org.tron.protos.Protocol.PBFTMessage.DataType;
 import org.tron.protos.Protocol.SRL;
@@ -94,10 +97,15 @@ public DataType getDataType() {
 
   public abstract String getNo();
 
-  public void analyzeSignature() throws SignatureException {
+  public void analyzeSignature(boolean checkMaxSignatureSize)
+      throws SignatureException {
+    ByteString signature = getPbftMessage().getSignature();
+    if (!SignUtils.isValidLength(signature.size(), checkMaxSignatureSize)) {
+      throw new SignatureException("PBFT signature size is " + signature.size());
+    }
     byte[] hash = Sha256Hash.hash(true, getPbftMessage().getRawData().toByteArray());
     publicKey = ECKey.signatureToAddress(hash, TransactionCapsule
-        .getBase64FromByteString(getPbftMessage().getSignature()));
+        .getBase64FromByteString(signature));
   }
 
   @Override

crypto/src/main/java/org/tron/common/crypto/SignUtils.java

@@ -5,9 +5,15 @@
 import org.tron.common.crypto.ECKey.ECDSASignature;
 import org.tron.common.crypto.sm2.SM2;
 import org.tron.common.crypto.sm2.SM2.SM2Signature;
+import org.tron.core.config.Parameter.ChainConstant;
 
 public class SignUtils {
 
+  public static boolean isValidLength(int size, boolean checkMaxSignatureSize) {
+    return size >= ChainConstant.MIN_SIGNATURE_SIZE
+        && (!checkMaxSignatureSize || size <= ChainConstant.MAX_SIGNATURE_SIZE);
+  }
+
   public static SignInterface getGeneratedRandomSign(
       SecureRandom secureRandom, boolean isECKeyCryptoEngine) {
     if (isECKeyCryptoEngine) {

framework/src/main/java/org/tron/core/Wallet.java

@@ -505,6 +505,16 @@ public GrpcAPI.Return broadcastTransaction(Transaction signedTransaction) {
     trx.setTime(System.currentTimeMillis());
     Sha256Hash txID = trx.getTransactionId();
     try {
+      for (ByteString sig : signedTransaction.getSignatureList()) {
+        if (!SignUtils.isValidLength(sig.size(), true)) {
+          String info = "Signature size is " + sig.size();
+          logger.warn("Broadcast transaction {} has failed, {}.", txID, info);
+          return builder.setResult(false).setCode(response_code.SIGERROR)
+              .setMessage(ByteString.copyFromUtf8("Validate signature error: " + info))
+              .build();
+        }
+      }
+
       if (tronNetDelegate.isBlockUnsolidified()) {
         logger.warn("Broadcast transaction {} has failed, block unsolidified.", txID);
         return builder.setResult(false).setCode(response_code.BLOCK_UNSOLIDIFIED)
@@ -644,7 +654,8 @@ public TransactionApprovedList getTransactionApprovedList(Transaction trx) {
           byte[] hash = Sha256Hash.hash(CommonParameter
               .getInstance().isECKeyCryptoEngine(), trx.getRawData().toByteArray());
           for (ByteString sig : trx.getSignatureList()) {
-            if (sig.size() < 65) {
+            // Read-only path: skip the upper bound so historical txs stay resolvable.
+            if (!SignUtils.isValidLength(sig.size(), false)) {
               throw new SignatureFormatException(
                   "Signature size is " + sig.size());
             }

framework/src/main/java/org/tron/core/net/messagehandler/PbftDataSyncHandler.java

@@ -19,8 +19,10 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.tron.common.crypto.ECKey;
+import org.tron.common.crypto.SignUtils;
 import org.tron.common.es.ExecutorServiceManager;
 import org.tron.common.utils.ByteArray;
+import org.tron.common.utils.ForkController;
 import org.tron.common.utils.Sha256Hash;
 import org.tron.consensus.base.Param;
 import org.tron.core.ChainBaseManager;
@@ -173,6 +175,10 @@ private class ValidPbftSignTask implements Callable<Boolean> {
     @Override
     public Boolean call() throws Exception {
       try {
+        if (!SignUtils.isValidLength(sign.size(), ForkController.signatureMaxSizeChecked())) {
+          logger.error("viewN {} pbft signature size {} is invalid", viewN, sign.size());
+          return false;
+        }
         byte[] srAddress = ECKey.signatureToAddress(dataHash,
             TransactionCapsule.getBase64FromByteString(sign));
         if (!srSet.contains(ByteString.copyFrom(srAddress))) {

framework/src/main/java/org/tron/core/net/messagehandler/PbftMsgHandler.java

@@ -7,6 +7,7 @@
 import java.util.concurrent.locks.Lock;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.tron.common.utils.ForkController;
 import org.tron.consensus.base.Param;
 import org.tron.consensus.pbft.PbftManager;
 import org.tron.consensus.pbft.message.PbftBaseMessage;
@@ -50,7 +51,7 @@ public void processMessage(PeerConnection peer, PbftMessage msg) throws Exceptio
         && currentEpoch - msg.getEpoch() > expireEpoch) {
       return;
     }
-    msg.analyzeSignature();
+    msg.analyzeSignature(ForkController.signatureMaxSizeChecked());
     String key = buildKey(msg);
     Lock lock = striped.get(key);
     try {
@@ -79,4 +80,4 @@ private String buildKey(PbftBaseMessage msg) {
     return msg.getKey() + msg.getPbftMessage().getRawData().getMsgType().toString();
   }
 
-}
+}

framework/src/main/java/org/tron/core/net/messagehandler/TransactionsMsgHandler.java

@@ -1,5 +1,6 @@
 package org.tron.core.net.messagehandler;
 
+import com.google.protobuf.ByteString;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -13,6 +14,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.tron.common.crypto.SignUtils;
 import org.tron.common.es.ExecutorServiceManager;
 import org.tron.common.utils.Sha256Hash;
 import org.tron.core.ChainBaseManager;
@@ -142,6 +144,12 @@ private void check(PeerConnection peer, TransactionsMessage msg) throws P2pExcep
         throw new P2pException(TypeEnum.BAD_TRX,
             "tx " + item.getHash() + " contract size should be greater than 0");
       }
+      for (ByteString sig : trx.getSignatureList()) {
+        if (!SignUtils.isValidLength(sig.size(), true)) {
+          throw new P2pException(TypeEnum.BAD_TRX,
+              "tx " + item.getHash() + " signature size is " + sig.size());
+        }
+      }
     }
   }
 

framework/src/main/java/org/tron/core/net/service/relay/RelayService.java

@@ -152,10 +152,16 @@ public boolean checkHelloMessage(HelloMessage message, Channel channel) {
 
     boolean flag;
     try {
+      ByteString signature = msg.getSignature();
+      if (!SignUtils.isValidLength(signature.size(), true)) {
+        logger.warn("HelloMessage from {}, signature size {} is invalid.",
+            channel.getInetAddress(), signature.size());
+        return false;
+      }
       Sha256Hash hash = Sha256Hash.of(CommonParameter
           .getInstance().isECKeyCryptoEngine(), ByteArray.fromLong(msg.getTimestamp()));
       String sig =
-          TransactionCapsule.getBase64FromByteString(msg.getSignature());
+          TransactionCapsule.getBase64FromByteString(signature);
       byte[] sigAddress = SignUtils.signatureToAddress(hash.getBytes(), sig,
           Args.getInstance().isECKeyCryptoEngine());
       if (manager.getDynamicPropertiesStore().getAllowMultiSign() != 1) {

framework/src/test/java/org/tron/core/ForkControllerTest.java

@@ -77,6 +77,26 @@ public void testPass() {
     Assert.assertTrue(flag);
   }
 
+  @Test
+  public void testSignatureMaxSizeChecked() {
+    Parameter.ForkBlockVersionEnum forkVersion = Parameter.ForkBlockVersionEnum.VERSION_4_8_2;
+    dynamicPropertiesStore.saveLatestBlockHeaderTimestamp(forkVersion.getHardForkTime());
+
+    byte[] stats = new byte[5];
+    dynamicPropertiesStore.statsByVersion(forkVersion.getValue(), stats);
+    Assert.assertFalse(ForkController.signatureMaxSizeChecked());
+
+    stats[0] = 1;
+    stats[1] = 1;
+    stats[2] = 1;
+    dynamicPropertiesStore.statsByVersion(forkVersion.getValue(), stats);
+    Assert.assertFalse(ForkController.signatureMaxSizeChecked());
+
+    stats[3] = 1;
+    dynamicPropertiesStore.statsByVersion(forkVersion.getValue(), stats);
+    Assert.assertTrue(ForkController.signatureMaxSizeChecked());
+  }
+
   @Test
   public void testReset() {
     List<ByteString> list = new ArrayList<>();