| |
| """Verify code-preserving inputs and native debug pairing without claiming scores.""" |
|
|
| import argparse, hashlib, json, shutil, subprocess |
| from pathlib import Path |
| import lief |
| from elftools.elf.elffile import ELFFile |
| from import_qualification_msvc import codeview |
|
|
|
|
| def sha(path): |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def elf_code(path): |
| with path.open("rb") as stream: |
| binary = ELFFile(stream) |
| return { |
| section.name: hashlib.sha256(section.data()).hexdigest() |
| for section in binary.iter_sections() |
| if section["sh_flags"] & 4 and section["sh_type"] != "SHT_NOBITS" |
| } |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--root", type=Path, required=True) |
| args = parser.parse_args() |
| base = args.root.resolve() / "staged/qualification-v2" |
| for platform in ["linux", "windows", "macos"]: |
| for path in sorted((base / platform).rglob("status.json")): |
| status = json.loads(path.read_text()) |
| original = base / status["binary"] |
| assert sha(original) == status["binary_sha256"] |
| stripped = ( |
| base / status["stripped"] |
| if status.get("stripped") |
| else original.with_name(original.name + ".stripped") |
| ) |
| if platform == "linux": |
| subprocess.run( |
| ["llvm-strip", "--strip-all", "-o", str(stripped), str(original)], |
| check=True, |
| ) |
| assert elf_code(original) == elf_code(stripped) and elf_code(original) |
| with stripped.open("rb") as stream: |
| elf = ELFFile(stream) |
| assert ( |
| not elf.has_dwarf_info(strict=True) |
| and elf.get_section_by_name(".symtab") is None |
| ) |
| status.update(debug_removed=True, symtab_removed=True) |
| elif platform == "macos": |
| if not stripped.exists(): |
| shutil.copy2(original, stripped) |
| subprocess.run( |
| ["llvm-strip", "--strip-all", str(stripped)], check=True |
| ) |
| before = lief.parse(str(original)) |
| after = lief.parse(str(stripped)) |
|
|
| def sections(binary): |
| return { |
| ( |
| s.segment_name, |
| s.name, |
| s.virtual_address, |
| s.size, |
| ): hashlib.sha256(bytes(s.content)).hexdigest() |
| for s in binary.sections |
| if s.segment_name != "__DWARF" |
| } |
|
|
| assert sections(before) == sections(after) |
| assert not [s for s in after.sections if s.segment_name == "__DWARF"] |
| uuids = subprocess.check_output( |
| [ |
| "xcrun", |
| "dwarfdump", |
| "--uuid", |
| str(original), |
| str(original) + ".dSYM", |
| ], |
| text=True, |
| ).splitlines() |
| assert len(uuids) == 2 and uuids[0].split()[1] == uuids[1].split()[1] |
| status.update( |
| debug_removed=True, |
| runtime_sections_equal=True, |
| dsym_uuid=uuids[0].split()[1], |
| ) |
| else: |
| assert ( |
| stripped.exists() |
| ), "Use the native evidence importer to remove the PE debug directory" |
| assert not list(lief.PE.parse(str(stripped)).debug) |
|
|
| def sections(binary): |
| return { |
| (s.name, s.virtual_address): hashlib.sha256( |
| bytes(s.content) |
| ).hexdigest() |
| for s in binary.sections |
| if int(s.characteristics) & 0x20000000 |
| } |
|
|
| assert sections(lief.PE.parse(str(original))) == sections( |
| lief.PE.parse(str(stripped)) |
| ) |
| guid, age = codeview(original)[1] |
| assert (guid, age) == (status["pdb_guid"], status["pdb_age"]) |
| status.update( |
| stripped=str(stripped.relative_to(base)), |
| stripped_sha256=sha(stripped), |
| code_sections_equal=True, |
| ) |
| status["remaining_gates"] = [ |
| gate |
| for gate in status["remaining_gates"] |
| if "input strip" not in gate and "code-section parity" not in gate |
| ] |
| path.write_text(json.dumps(status, indent=2)) |
| print( |
| platform, |
| status["project"], |
| status["optimization"], |
| "verified", |
| flush=True, |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
