It seems you aren't alone on the internet either: https://gchq.github.io/CyberChef/#recipe=Fletcher-64_Checksum()&input=YWJjZGVmZ2g (I'll submit an issue for them too)

The easiest way to demonstrate this is with your examples, where the upper 2 bytes (4 nibbles) are all 0's, when they should be filled with data like Wikipedia: https://en.wikipedia.org/wiki/Fletcher%27s_checksum#Test_vectors

The problem is that you are only using byte-sized chunks for the sums instead of uint16 or uint32 chunks, respectively.

Here is an example of a proper implementation:

import array

def get_fletcher64(data_bytes: bytes) -> dict:
    """
    Accepts bytes as input.
    Returns the Fletcher64 checksum value in decimal and hexadecimal format.
    32-bit implementation (64-bit checksum)
    """
    sum1, sum2 = int(), int()
    data = array.array('I', str.encode(data_bytes))
    print(len(data))
    for index in range(len(data)):
        sum1 = (sum1 + data[index]) % 4294967295
        sum2 = (sum2 + sum1) % 4294967295
    result = (sum2 << 32) | sum1
    return {"Fletcher64_dec": result, "Fletcher64_hex": hex(result)}

Which returns the proper value when using the wikipedia test string.

test_string_input = 'abcdefgh'
checksum_result = FletcherChecksumStr.get_fletcher64(test_string_input)
print(checksum_result)

2
{'Fletcher64_dec': 3543817411021686982, 'Fletcher64_hex': '0x312e2b28cccac8c6'}

• This doesn't work for strings/bytes where the length isn't a multiple of the checksum size,
• The above is using signed int, and not unsigned int, which will run into overflow issues.

I'll leave the above as an exercise for the reader 😉

Hi!

All modulo operations used to truncate the length of each integer to fit in a certain numbers of bit are wrong. For example:

for index in range(len(data)): sum1 = (sum1 + data[index]) % 255

Should be corrected to:

for index in range(len(data)): sum1 = (sum1 + data[index]) % 256

Because the modulo operation in the form of (A % B) is going to let A be in the range of 0 to B - 1. Using modulo % 255 for modulo will limit integers up to the value of 254 instead of 255 as desired.

The same applies to all other values.