diff options
Diffstat (limited to 'research/executables/claude-ai-slop/checksum_bruteforce.py')
| -rw-r--r-- | research/executables/claude-ai-slop/checksum_bruteforce.py | 367 |
1 files changed, 367 insertions, 0 deletions
diff --git a/research/executables/claude-ai-slop/checksum_bruteforce.py b/research/executables/claude-ai-slop/checksum_bruteforce.py new file mode 100644 index 0000000..3cfa7cf --- /dev/null +++ b/research/executables/claude-ai-slop/checksum_bruteforce.py @@ -0,0 +1,367 @@ +#!/usr/bin/env python3 +""" +Comprehensive checksum bruteforce tool for the MEL protocol +Usage: python checksum_bruteforce.py <hex_file> +""" + +import sys +import struct +from typing import List, Tuple, Dict + +def parse_hex_line(hex_string: str) -> List[int]: + """Parse a hex string into list of bytes""" + hex_clean = hex_string.strip().replace(' ', '') + return [int(hex_clean[i:i+2], 16) for i in range(0, len(hex_clean), 2)] + +def bytes_to_hex(bytes_list: List[int]) -> str: + """Convert bytes to hex string""" + return ''.join(f'{b:02x}' for b in bytes_list) + +class ChecksumTester: + def __init__(self): + self.algorithms = [ + self.simple_sum, + self.sum_with_carry, + self.twos_complement, + self.ones_complement, + self.xor_checksum, + self.crc16_ccitt, + self.crc16_ibm, + self.fletcher16, + self.modsum_256, + self.internet_checksum, + ] + + def simple_sum(self, data: List[int]) -> int: + """Simple sum of all bytes""" + return sum(data) & 0xFFFF + + def sum_with_carry(self, data: List[int]) -> int: + """Sum with end-around carry""" + s = sum(data) + while s > 0xFFFF: + s = (s & 0xFFFF) + (s >> 16) + return s + + def twos_complement(self, data: List[int]) -> int: + """Two's complement of sum""" + s = sum(data) + return (~s + 1) & 0xFFFF + + def ones_complement(self, data: List[int]) -> int: + """One's complement of sum""" + s = sum(data) + return (~s) & 0xFFFF + + def xor_checksum(self, data: List[int]) -> int: + """XOR of all bytes, extended to 16-bit""" + result = 0 + for b in data: + result ^= b + return result + + def crc16_ccitt(self, data: List[int], poly: int = 0x1021) -> int: + """CRC-16 CCITT""" + crc = 0xFFFF + for byte in data: + crc ^= (byte << 8) + for _ in range(8): + if crc & 0x8000: + crc = (crc << 1) ^ poly + else: + crc <<= 1 + crc &= 0xFFFF + return crc + + def crc16_ibm(self, data: List[int]) -> int: + """CRC-16 IBM/ANSI""" + return self.crc16_ccitt(data, 0x8005) + + def fletcher16(self, data: List[int]) -> int: + """Fletcher-16 checksum""" + sum1 = sum2 = 0 + for byte in data: + sum1 = (sum1 + byte) % 255 + sum2 = (sum2 + sum1) % 255 + return (sum2 << 8) | sum1 + + def modsum_256(self, data: List[int]) -> int: + """Sum modulo 256, extended to 16-bit""" + return sum(data) % 256 + + def internet_checksum(self, data: List[int]) -> int: + """Internet/TCP checksum""" + # Pad to even length + if len(data) % 2: + data = data + [0] + + s = 0 + for i in range(0, len(data), 2): + s += (data[i] << 8) + data[i+1] + + while s >> 16: + s = (s & 0xFFFF) + (s >> 16) + + return (~s) & 0xFFFF + +def test_parametric_algorithms(data: List[int], expected: int) -> List[str]: + """Test algorithms with various parameters""" + matches = [] + + # Test sum with different initial values + for init_val in range(0, 0x10000, 0x1000): + result = (init_val + sum(data)) & 0xFFFF + if result == expected: + matches.append(f"Sum + 0x{init_val:04x}") + + # Test sum with different modulo values + for mod_val in [0xFF, 0x100, 0x101, 0x1FF, 0x200, 0xFFFF, 0x10000]: + if mod_val > 0: + result = sum(data) % mod_val + if result == expected: + matches.append(f"Sum mod 0x{mod_val:x}") + + # Test XOR with different patterns + for pattern in [0x00, 0xFF, 0xAA, 0x55, 0x5A, 0xA5]: + result = 0 + for byte in data: + result ^= (byte ^ pattern) + if (result & 0xFFFF) == expected: + matches.append(f"XOR with pattern 0x{pattern:02x}") + + # Test rotation-based checksums + for shift in range(1, 16): + result = 0 + for byte in data: + result = ((result << shift) | (result >> (16 - shift))) & 0xFFFF + result ^= byte + if result == expected: + matches.append(f"Rotate-XOR shift {shift}") + + return matches + +def analyze_file(filename: str): + """Analyze a file of hex data to find checksum patterns""" + with open(filename, 'r') as f: + lines = [line.strip() for line in f if line.strip()] + + print(f"Analyzing {filename} with {len(lines)} entries") + + tester = ChecksumTester() + algorithm_matches = {} + + # Test first 10 entries to find patterns + for i, line in enumerate(lines[:10]): + bytes_data = parse_hex_line(line) + if len(bytes_data) < 3: + continue + + # Assume last 2 bytes are checksum + payload = bytes_data[:-2] + checksum_be = (bytes_data[-2] << 8) | bytes_data[-1] + checksum_le = bytes_data[-2] | (bytes_data[-1] << 8) + + print(f"\nEntry {i}:") + print(f" Payload: {bytes_to_hex(payload)}") + print(f" Checksum BE: 0x{checksum_be:04x}") + print(f" Checksum LE: 0x{checksum_le:04x}") + + # Test standard algorithms for both byte orders + for checksum, order in [(checksum_be, "BE"), (checksum_le, "LE")]: + print(f" Testing {order} interpretation:") + for algo in tester.algorithms: + result = algo(payload) + if result == checksum: + algo_name = f"{algo.__name__}_{order}" + algorithm_matches[algo_name] = algorithm_matches.get(algo_name, 0) + 1 + print(f" ✓ {algo.__name__}: 0x{result:04x}") + else: + print(f" ✗ {algo.__name__}: 0x{result:04x}") + + # Test parametric algorithms + param_matches = test_parametric_algorithms(payload, checksum) + for match in param_matches: + print(f" ✓ {match}") + key = f"{match}_{order}" + algorithm_matches[key] = algorithm_matches.get(key, 0) + 1 + + # Summary of algorithms that work consistently + print(f"\n{'='*50}") + print("SUMMARY - Algorithms with multiple matches:") + for algo, count in sorted(algorithm_matches.items(), key=lambda x: x[1], reverse=True): + if count > 1: + print(f" {algo}: {count} matches") + + return algorithm_matches + +def brute_force_unknown_algorithm(filename: str, max_entries: int = 5): + """Brute force approach for completely unknown algorithms""" + with open(filename, 'r') as f: + lines = [line.strip() for line in f if line.strip()][:max_entries] + + print(f"Brute forcing {len(lines)} entries...") + + # Collect all data points + data_points = [] + for line in lines: + bytes_data = parse_hex_line(line) + payload = bytes_data[:-2] + checksum_le = bytes_data[-2] | (bytes_data[-1] << 8) + data_points.append((payload, checksum_le)) + + # Try to find a mathematical relationship + # This is a simplified approach - in practice you'd want more sophisticated analysis + + # Check if it's a linear relationship: checksum = a * sum(payload) + b + if len(data_points) >= 2: + payload_sums = [sum(payload) for payload, _ in data_points] + checksums = [checksum for _, checksum in data_points] + + print(f"Payload sums: {[f'0x{s:x}' for s in payload_sums[:5]]}") + print(f"Checksums: {[f'0x{c:04x}' for c in checksums[:5]]}") + + # Try to solve for linear relationship + if len(set(payload_sums)) > 1: # Need different sums to solve + sum1, sum2 = payload_sums[0], payload_sums[1] + check1, check2 = checksums[0], checksums[1] + + if sum1 != sum2: + # Solve: check1 = a * sum1 + b, check2 = a * sum2 + b + a = (check2 - check1) / (sum2 - sum1) + b = check1 - a * sum1 + + print(f"Testing linear relationship: checksum = {a:.3f} * sum + {b:.3f}") + + # Verify with all data points + matches = 0 + for payload, expected in data_points: + predicted = int(a * sum(payload) + b) & 0xFFFF + if predicted == expected: + matches += 1 + print(f" ✓ Linear match: sum={sum(payload)}, expected=0x{expected:04x}, predicted=0x{predicted:04x}") + else: + print(f" ✗ Linear miss: sum={sum(payload)}, expected=0x{expected:04x}, predicted=0x{predicted:04x}") + + if matches == len(data_points): + print(f"🎉 FOUND LINEAR RELATIONSHIP! checksum = {a:.3f} * sum(payload) + {b:.3f}") + +def generate_test_vectors(base_hex: str, variations: int = 10): + """Generate test vectors by modifying a base message""" + base_bytes = parse_hex_line(base_hex) + payload = base_bytes[:-2] + + print(f"Generating {variations} test vectors from base:") + print(f"Base: {base_hex}") + + # Generate variations by changing single bytes + for i in range(min(variations, len(payload))): + modified = payload.copy() + modified[i] = (modified[i] + 1) % 256 # Increment one byte + + # You would calculate the correct checksum here and append it + # For now, we'll just show the modified payload + print(f"Variation {i}: {bytes_to_hex(modified)} + [CHECKSUM_TO_CALCULATE]") + +def test_specific_algorithms(data: List[int], expected: int) -> Dict[str, int]: + """Test specific algorithms that might be used in embedded systems""" + results = {} + + # Test sum with various bit operations + s = sum(data) + + # Basic variations + results["sum_low16"] = s & 0xFFFF + results["sum_high16"] = (s >> 16) & 0xFFFF + results["sum_rotated"] = ((s << 8) | (s >> 8)) & 0xFFFF + results["sum_inverted"] = (~s) & 0xFFFF + results["sum_twos_comp"] = (-s) & 0xFFFF + + # With different initial values (common in embedded systems) + for init in [0x0000, 0x5555, 0xAAAA, 0xFFFF, 0x1234, 0x4321]: + results[f"sum_init_{init:04x}"] = (s + init) & 0xFFFF + results[f"xor_init_{init:04x}"] = (s ^ init) & 0xFFFF + + # Byte-wise operations + byte_xor = 0 + byte_sum = 0 + for b in data: + byte_xor ^= b + byte_sum += b + + results["byte_xor"] = byte_xor + results["byte_xor_16bit"] = (byte_xor << 8) | byte_xor + results["byte_sum_mod256"] = byte_sum % 256 + results["byte_sum_mod255"] = byte_sum % 255 + + # Position-weighted sums + pos_sum = sum(i * b for i, b in enumerate(data)) + results["position_weighted"] = pos_sum & 0xFFFF + + # Polynomial checksums (simplified) + poly_result = 0 + for b in data: + poly_result = ((poly_result << 1) ^ b) & 0xFFFF + results["poly_shift_xor"] = poly_result + + # Return only matches + return {name: value for name, value in results.items() if value == expected} + +def main(): + if len(sys.argv) != 2: + print("Usage: python checksum_bruteforce.py <hex_file>") + print("\nThis tool will:") + print("1. Test standard checksum algorithms") + print("2. Try parametric variations") + print("3. Attempt to find mathematical relationships") + print("4. Generate test vectors for validation") + sys.exit(1) + + filename = sys.argv[1] + + try: + # Main analysis + print("=" * 60) + print("COMPREHENSIVE CHECKSUM ANALYSIS") + print("=" * 60) + + matches = analyze_file(filename) + + print("\n" + "=" * 60) + print("BRUTE FORCE UNKNOWN ALGORITHMS") + print("=" * 60) + + brute_force_unknown_algorithm(filename, max_entries=10) + + print("\n" + "=" * 60) + print("SPECIFIC EMBEDDED ALGORITHMS") + print("=" * 60) + + # Test first entry with specific algorithms + with open(filename, 'r') as f: + first_line = f.readline().strip() + + bytes_data = parse_hex_line(first_line) + payload = bytes_data[:-2] + checksum_le = bytes_data[-2] | (bytes_data[-1] << 8) + + specific_matches = test_specific_algorithms(payload, checksum_le) + if specific_matches: + print("Specific algorithm matches found:") + for name, value in specific_matches.items(): + print(f" ✓ {name}: 0x{value:04x}") + else: + print("No specific algorithm matches found") + + print("\n" + "=" * 60) + print("TEST VECTOR GENERATION") + print("=" * 60) + + generate_test_vectors(first_line, 5) + + except FileNotFoundError: + print(f"Error: File '{filename}' not found") + except Exception as e: + print(f"Error: {e}") + +if __name__ == "__main__": + main()
\ No newline at end of file |