fix(test): reverse jsonHexToInt length check

Author: Little-Peony

common/src/main/java/org/tron/common/utils/ByteArray.java

@@ -152,12 +152,6 @@ public static BigInteger hexToBigInteger(String input) {
   }
 
   public static long jsonHexToLong(String x) throws JsonRpcInvalidParamsException {
-    // Constants for input length validation to prevent DDoS attacks
-    int MAX_HEX_LONG_LENGTH = 20; // For 64-bit long values (18 chars for 0x7FFFFFFFFFFFFFFF) + safety buffer
-    if (x == null || x.length() > MAX_HEX_LONG_LENGTH) {
-      throw new JsonRpcInvalidParamsException("Input cannot be null or too long");
-    }
-
     if (!x.startsWith("0x")) {
       throw new JsonRpcInvalidParamsException("Incorrect hex syntax");
     }
@@ -166,12 +160,6 @@ public static long jsonHexToLong(String x) throws JsonRpcInvalidParamsException
   }
 
   public static int jsonHexToInt(String x) throws Exception {
-    // Constants for input length validation to prevent DDoS attacks
-    int MAX_HEX_INT_LENGTH = 12; // For 32-bit int values (10 chars for 0x7FFFFFFF) + safety buffer 
-    if (x == null || x.length() > MAX_HEX_INT_LENGTH) {
-      throw new Exception("Incorrect string length");
-    }
-
     if (!x.startsWith("0x")) {
       throw new Exception("Incorrect hex syntax");
     }

framework/src/main/java/org/tron/core/services/jsonrpc/JsonRpcApiUtil.java

@@ -58,9 +58,9 @@
 public class JsonRpcApiUtil {
   /**
    * Maximum allowed length for block identifiers to prevent DDoS attacks.
-   * Supports block hashes (66 chars) + safety buffer.
+   * Supports block hashes (66 chars) + safety enough buffer.
    */
-  private static final int MAX_BLOCK_IDENTIFIER_LENGTH = 128;
+  private static final int MAX_BLOCK_IDENTIFIER_LENGTH = 512;
 
   public static byte[] convertToTronAddress(byte[] address) {
     byte[] newAddress = new byte[21];

framework/src/test/java/org/tron/common/utils/ByteArrayTest.java

@@ -23,12 +23,10 @@
 import static org.junit.Assert.fail;
 import static org.tron.common.utils.ByteArray.fromHex;
 import static org.tron.common.utils.ByteArray.jsonHexToInt;
-import static org.tron.common.utils.ByteArray.jsonHexToLong;
 
 import lombok.extern.slf4j.Slf4j;
 import org.bouncycastle.util.encoders.Hex;
 import org.junit.Test;
-import org.tron.core.exception.jsonrpc.JsonRpcInvalidParamsException;
 
 @Slf4j
 public class ByteArrayTest {
@@ -117,130 +115,4 @@ public void testFromHexWithPrefix() {
     String input1 = "1A3";
     assertEquals("01A3", fromHex(input1));
   }
-
-  @Test
-  public void testJsonHexToLong_ValidInputs() {
-    try {
-      // Test basic hex conversion
-      assertEquals(26L, jsonHexToLong("0x1A"));
-      assertEquals(255L, jsonHexToLong("0xFF"));
-      assertEquals(0L, jsonHexToLong("0x0"));
-      assertEquals(1L, jsonHexToLong("0x1"));
-
-      // Test large values
-      assertEquals(4294967295L, jsonHexToLong("0xFFFFFFFF"));
-
-      // Test maximum long value
-      assertEquals(Long.MAX_VALUE, jsonHexToLong("0x7FFFFFFFFFFFFFFF"));
-    } catch (JsonRpcInvalidParamsException e) {
-      fail("Exception should not have been thrown for valid hex strings: " + e.getMessage());
-    }
-  }
-
-  @Test
-  public void testJsonHexToLong_InvalidInputs() {
-    // Test null input
-    assertThrows(JsonRpcInvalidParamsException.class, () -> jsonHexToLong(null));
-
-    // Test missing 0x prefix
-    assertThrows(JsonRpcInvalidParamsException.class, () -> jsonHexToLong("1A"));
-
-    // Test too long input (DDoS protection)
-    StringBuilder tooLongStr = new StringBuilder("0x");
-    for (int i = 0; i < 20; i++) {
-      tooLongStr.append("F");
-    }
-    String tooLongHex = tooLongStr.toString(); // 22 characters total, exceeds MAX_HEX_LONG_LENGTH
-    assertThrows(JsonRpcInvalidParamsException.class, () -> jsonHexToLong(tooLongHex));
-
-    // Test invalid hex characters
-    assertThrows(NumberFormatException.class, () -> jsonHexToLong("0xGG"));
-  }
-
-  @Test
-  public void testJsonHexToInt_ValidInputs() {
-    try {
-      // Test basic hex conversion
-      assertEquals(26, jsonHexToInt("0x1A"));
-      assertEquals(255, jsonHexToInt("0xFF"));
-      assertEquals(0, jsonHexToInt("0x0"));
-      assertEquals(1, jsonHexToInt("0x1"));
-
-      // Test maximum int value
-      assertEquals(Integer.MAX_VALUE, jsonHexToInt("0x7FFFFFFF"));
-
-      // Test large values
-      assertEquals(65535, jsonHexToInt("0xFFFF"));
-    } catch (Exception e) {
-      fail("Exception should not have been thrown for valid hex strings: " + e.getMessage());
-    }
-  }
-
-  @Test
-  public void testJsonHexToInt_InvalidInputs() {
-    // Test null input
-    assertThrows(Exception.class, () -> jsonHexToInt(null));
-
-    // Test missing 0x prefix
-    assertThrows(Exception.class, () -> jsonHexToInt("1A"));
-
-    // Test too long input (DDoS protection)
-    StringBuilder tooLongStr = new StringBuilder("0x");
-    for (int i = 0; i < 12; i++) {
-      tooLongStr.append("F");
-    }
-    String tooLongHex = tooLongStr.toString(); // 14 characters total, exceeds MAX_HEX_INT_LENGTH
-    assertThrows(Exception.class, () -> jsonHexToInt(tooLongHex));
-
-    // Test invalid hex characters
-    assertThrows(NumberFormatException.class, () -> jsonHexToInt("0xGG"));
-  }
-
-  @Test
-  public void testJsonHexToLong_EdgeCases() {
-    try {
-      // Test minimum length valid input
-      assertEquals(0L, jsonHexToLong("0x0"));
-
-      // Test a long hex string that's within limits but doesn't overflow
-      assertEquals(4095L, jsonHexToLong("0xFFF")); // 3 F's = 4095, safe value
-
-      // Test length validation - this should pass length check
-      assertEquals(1048575L, jsonHexToLong("0xFFFFF")); // 5 F's = 1048575, safe value
-    } catch (JsonRpcInvalidParamsException e) {
-      fail("Exception should not have been thrown for edge case inputs: " + e.getMessage());
-    }
-  }
-
-  @Test
-  public void testJsonHexToInt_EdgeCases() {
-    try {
-      // Test minimum length valid input
-      assertEquals(0, jsonHexToInt("0x0"));
-
-      // Test a hex string that's within limits but doesn't overflow
-      assertEquals(4095, jsonHexToInt("0xFFF")); // 3 F's = 4095, safe value
-
-      // Test length validation - this should pass length check
-      assertEquals(1048575, jsonHexToInt("0xFFFFF")); // 5 F's = 1048575, safe value
-    } catch (Exception e) {
-      fail("Exception should not have been thrown for edge case inputs: " + e.getMessage());
-    }
-  }
-
-  @Test
-  public void testJsonHexToLong_OverflowHandling() {
-    // Test that Long.parseLong properly handles overflow by throwing NumberFormatException
-    // This tests values that pass length validation but cause overflow
-    assertThrows(NumberFormatException.class,
-        () -> jsonHexToLong("0x8000000000000000")); // Long.MAX_VALUE + 1
-  }
-
-  @Test
-  public void testJsonHexToInt_OverflowHandling() {
-    // Test that Integer.parseInt properly handles overflow by throwing NumberFormatException
-    // This tests values that pass length validation but cause overflow
-    assertThrows(NumberFormatException.class,
-        () -> jsonHexToInt("0x80000000")); // Integer.MAX_VALUE + 1
-  }
 }