more fixes

Author: abenso

fuzzing/fuzz_local/zxformat_fuzzer.cpp

@@ -117,5 +117,168 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
         array_to_hexstr_uppercase(buffer, sizeof(buffer), data, (size > 64) ? 64 : size);
     }
 
+    // Test bip32_to_str
+    if (size >= 20) {
+        char bip32Buffer[256];
+        uint32_t path[5];
+        const uint8_t pathLen = (data[0] % 5) + 1;
+        
+        for (uint8_t i = 0; i < pathLen && static_cast<size_t>(i) * 4 + 4 <= size - 1; i++) {
+            memcpy(&path[i], data + 1 + static_cast<size_t>(i) * 4, sizeof(uint32_t));
+        }
+        
+        bip32_to_str(bip32Buffer, sizeof(bip32Buffer), path, pathLen);
+        bip32_to_str(bip32Buffer, 10, path, pathLen);
+        bip32_to_str(bip32Buffer, 5, path, pathLen);
+        bip32_to_str(bip32Buffer, sizeof(bip32Buffer), path, 0);
+        bip32_to_str(bip32Buffer, sizeof(bip32Buffer), path, 6);
+    }
+    
+    // Test str_to_int8
+    if (size > 2) {
+        char str[16];
+        const size_t str_len = (size > 15) ? 15 : size;
+        memcpy(str, data, str_len);
+        str[str_len] = '\0';
+        
+        const char *end = str + str_len;
+        char error = 0;
+        str_to_int8(str, end, &error);
+        str_to_int8(str, end, NULL);
+    }
+    
+    // Test number_inplace_trimming
+    if (size > 8) {
+        char numberStr[128];
+        const size_t copy_len = (size > 127) ? 127 : size;
+        memcpy(numberStr, data, copy_len);
+        numberStr[copy_len] = '\0';
+        
+        const uint8_t non_trimmed = data[0] % 10;
+        number_inplace_trimming(numberStr, non_trimmed);
+        
+        // Test with decimal point
+        strcpy(numberStr, "123.456000");
+        number_inplace_trimming(numberStr, 2);
+        
+        strcpy(numberStr, "0.000000");
+        number_inplace_trimming(numberStr, 0);
+    }
+    
+    // Test hexstr_to_array
+    if (size >= 4) {
+        uint8_t outputArray[128];
+        char hexStr[256];
+        
+        // Create a valid hex string from data
+        const size_t hexLen = (size > 127) ? 127 : size;
+        array_to_hexstr(hexStr, sizeof(hexStr), data, hexLen);
+        
+        hexstr_to_array(outputArray, sizeof(outputArray), hexStr, strlen(hexStr));
+        hexstr_to_array(outputArray, 10, hexStr, strlen(hexStr));
+        hexstr_to_array(outputArray, sizeof(outputArray), hexStr, 3);
+    }
+    
+    // Test to_uppercase and to_lowercase
+    if (size >= 1) {
+        uint8_t letter = data[0];
+        to_uppercase(&letter);
+        
+        letter = data[0];
+        to_lowercase(&letter);
+        
+        to_uppercase(NULL);
+        to_lowercase(NULL);
+    }
+    
+    // Test array_to_uppercase and array_to_lowercase
+    if (size >= 4) {
+        uint8_t upperArray[64];
+        uint8_t lowerArray[64];
+        const size_t array_len = (size > 64) ? 64 : size;
+        
+        memcpy(upperArray, data, array_len);
+        memcpy(lowerArray, data, array_len);
+        
+        array_to_uppercase(upperArray, array_len);
+        array_to_lowercase(lowerArray, array_len);
+        
+        array_to_uppercase(NULL, array_len);
+        array_to_lowercase(NULL, array_len);
+    }
+    
+    // Test pageStringHex
+    if (size >= 16) {
+        char hexOutput[128];
+        const uint16_t hexOutputLen = sizeof(hexOutput);
+        
+        const uint16_t inValueLen = (size > 256) ? 256 : size;
+        const uint8_t pageIdx = data[0] % 10;
+        uint8_t pageCount = 0;
+        
+        pageStringHex(hexOutput, hexOutputLen, (const char*)data, inValueLen, pageIdx, &pageCount);
+        pageStringHex(hexOutput, 10, (const char*)data, inValueLen, pageIdx, &pageCount);
+        pageStringHex(hexOutput, 1, (const char*)data, inValueLen, pageIdx, &pageCount);
+        pageStringHex(hexOutput, hexOutputLen, (const char*)data, 0, pageIdx, &pageCount);
+    }
+    
+    // Test formatBufferData
+    if (size >= 8) {
+        char formattedOutput[256];
+        const uint16_t outputLen = sizeof(formattedOutput);
+        
+        const uint64_t dataLen = (size > 500) ? 500 : size;
+        const uint8_t pageIdx = data[0] % 10;
+        uint8_t pageCount = 0;
+        
+        formatBufferData(data, dataLen, formattedOutput, outputLen, pageIdx, &pageCount);
+        formatBufferData(data, dataLen, formattedOutput, 10, pageIdx, &pageCount);
+        formatBufferData(data, 501, formattedOutput, outputLen, pageIdx, &pageCount);
+        
+        // Test with non-ASCII data
+        uint8_t nonAsciiData[64];
+        for (size_t i = 0; i < 64 && i < size; i++) {
+            nonAsciiData[i] = data[i] | 0x80;
+        }
+        formatBufferData(nonAsciiData, 64, formattedOutput, outputLen, pageIdx, &pageCount);
+    }
+    
+    // Test uint64_from_BEarray
+    if (size >= 8) {
+        uint8_t beArray[8];
+        memcpy(beArray, data, 8);
+        
+        uint64_t result = uint64_from_BEarray(beArray);
+        
+        // Test with different patterns
+        if (size >= 16) {
+            memcpy(beArray, data + 8, 8);
+            const uint64_t result2 = uint64_from_BEarray(beArray);
+            // Use results to avoid dead store warning
+            if (result > result2) {
+                result = result2;
+            }
+        }
+        
+        // Test with all zeros
+        memset(beArray, 0, 8);
+        const uint64_t zeroResult = uint64_from_BEarray(beArray);
+        if (zeroResult != 0) {
+            result = zeroResult;
+        }
+        
+        // Test with all ones
+        memset(beArray, 0xFF, 8);
+        const uint64_t onesResult = uint64_from_BEarray(beArray);
+        if (onesResult != 0xFFFFFFFFFFFFFFFF) {
+            result = onesResult;
+        }
+        
+        // Force use of result
+        if (result == 0) {
+            beArray[0] = 0;
+        }
+    }
+    
     return 0;
 }

include/zxformat.h

@@ -126,12 +126,20 @@ __Z_INLINE int8_t str_to_int8(const char *start, const char *end, char *error) {
     }
 
     int64_t value = 0;
-    int multiplier = 1;
-    for (const char *s = end - 1; s >= start; s--) {
-        int delta = (*s - '0');
+    const int64_t max_value = INT64_MAX;
+    
+    for (const char *s = start; s < end; s++) {
+        int64_t delta = (*s - '0');
         if (delta >= 0 && delta <= 9) {
-            value += (delta * multiplier);
-            multiplier *= 10;
+            // Check for overflow before multiplication and addition
+            if (value > (max_value - delta) / 10) {
+                if (error != NULL) {
+                    *error = 1;
+                }
+                return 0;
+            }
+            
+            value = value * 10 + delta;
         } else {
             if (error != NULL) {
                 *error = 1;