mirror of
https://github.com/NohamR/macho-diff.git
synced 2026-07-11 19:10:09 +00:00
143 lines
4.0 KiB
Python
143 lines
4.0 KiB
Python
"""
|
|
CLI module for the macho-diff tool.
|
|
"""
|
|
import argparse
|
|
import os
|
|
import sys
|
|
|
|
import lief
|
|
|
|
from macho_diff.helpers import (
|
|
parse_functions,
|
|
compare_instructions,
|
|
generate_batch_patches,
|
|
)
|
|
|
|
lief.logging.disable()
|
|
|
|
|
|
def parse_args():
|
|
"""Parse command line arguments."""
|
|
parser = argparse.ArgumentParser(description="Mach-O binary visual diff tool")
|
|
parser.add_argument("src", help="Path to the original/source Mach-O binary")
|
|
parser.add_argument("patched", help="Path to the patched Mach-O binary")
|
|
parser.add_argument(
|
|
"-b",
|
|
"--batch",
|
|
action="store_true",
|
|
help="Generate a batch patch file representing the differences.",
|
|
)
|
|
return parser.parse_args()
|
|
|
|
|
|
def load_binary(filepath):
|
|
"""Load a Mach-O binary from the given file path."""
|
|
if not os.path.isfile(filepath):
|
|
print(f"Error: File not found: '{filepath}'", file=sys.stderr)
|
|
return None
|
|
try:
|
|
fat = lief.MachO.parse(filepath)
|
|
return fat.at(0) if fat else None
|
|
except Exception as e: # pylint: disable=broad-exception-caught
|
|
print(f"Error parsing binary '{filepath}': {e}", file=sys.stderr)
|
|
return None
|
|
|
|
|
|
def read_file_raw(filepath):
|
|
"""Read the raw bytes of a file."""
|
|
try:
|
|
with open(filepath, "rb") as f:
|
|
return f.read()
|
|
except OSError as e:
|
|
print(f"Error reading file '{filepath}': {e}", file=sys.stderr)
|
|
return None
|
|
|
|
|
|
def process_diffs(args, binary_src, src_raw, functions_src, functions_patched):
|
|
"""Process and print the differences between functions."""
|
|
diff_count = 0
|
|
all_batch_patches = []
|
|
|
|
for addr, src_data in functions_src.items():
|
|
patched_data = functions_patched.get(addr)
|
|
if not patched_data:
|
|
continue
|
|
|
|
if src_data["checksum"] != patched_data["checksum"]:
|
|
if args.batch:
|
|
patches = generate_batch_patches(
|
|
binary_src, src_raw, addr, src_data["data"], patched_data["data"]
|
|
)
|
|
if patches:
|
|
all_batch_patches.append((src_data["name"], patches))
|
|
else:
|
|
print(
|
|
f"\n[DIFF] {src_data['name']} @ {hex(addr)} size={src_data['size']}"
|
|
)
|
|
compare_instructions(
|
|
binary_src, addr, src_data["data"], patched_data["data"]
|
|
)
|
|
diff_count += 1
|
|
|
|
return diff_count, all_batch_patches
|
|
|
|
|
|
def print_batch_patches(binary_src, all_batch_patches):
|
|
"""Print the batch patches."""
|
|
cputype_name = binary_src.header.cpu_type.name
|
|
print("\nBatch Patches:" + "\n" + "=" * 40)
|
|
print(f"{cputype_name}:\n")
|
|
|
|
for _, patches in all_batch_patches:
|
|
for find_str, replace_str in patches:
|
|
print(find_str)
|
|
print("to")
|
|
print(replace_str)
|
|
print()
|
|
print("=" * 40)
|
|
|
|
|
|
def main():
|
|
"""Main entry point for the CLI."""
|
|
args = parse_args()
|
|
|
|
print(f"Loading '{args.src}'...")
|
|
binary_src = load_binary(args.src)
|
|
if not binary_src:
|
|
return
|
|
|
|
print(f"Loading '{args.patched}'...")
|
|
binary_patched = load_binary(args.patched)
|
|
if not binary_patched:
|
|
return
|
|
|
|
print("Reading file contents...")
|
|
src_raw = read_file_raw(args.src)
|
|
if not src_raw:
|
|
return
|
|
patched_raw = read_file_raw(args.patched)
|
|
if not patched_raw:
|
|
return
|
|
|
|
print("Parsing functions (this might take a moment)...")
|
|
functions_src = parse_functions(binary_src, src_raw)
|
|
functions_patched = parse_functions(binary_patched, patched_raw)
|
|
|
|
print(
|
|
f"Found {len(functions_src)} functions in source binary "
|
|
f"and {len(functions_patched)} in patched binary."
|
|
)
|
|
|
|
diff_count, all_batch_patches = process_diffs(
|
|
args, binary_src, src_raw, functions_src, functions_patched
|
|
)
|
|
|
|
if args.batch:
|
|
print_batch_patches(binary_src, all_batch_patches)
|
|
|
|
print(f"\nTotal diffs: {diff_count}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|