| |
| """Import artifact-backed native MSVC evidence with PE/PDB identity checks.""" |
|
|
| import argparse, hashlib, json, re, shutil, struct, subprocess, tarfile, uuid |
| from pathlib import Path |
| import lief |
|
|
|
|
| def sha(p): |
| return hashlib.sha256(p.read_bytes()).hexdigest() |
|
|
|
|
| def text_sections(p): |
| b = lief.PE.parse(str(p)) |
| return { |
| (s.name, s.virtual_address): hashlib.sha256(bytes(s.content)).hexdigest() |
| for s in b.sections |
| if int(s.characteristics) & 0x20000000 |
| } |
|
|
|
|
| def codeview(p): |
| data = p.read_bytes() |
| pe = struct.unpack_from("<I", data, 0x3C)[0] |
| assert data[pe : pe + 4] == b"PE\0\0" |
| count = struct.unpack_from("<H", data, pe + 6)[0] |
| size = struct.unpack_from("<H", data, pe + 20)[0] |
| optional = pe + 24 |
| magic = struct.unpack_from("<H", data, optional)[0] |
| dirs = optional + (112 if magic == 0x20B else 96) |
| rva, total = struct.unpack_from("<II", data, dirs + 48) |
| sections = [] |
| for i in range(count): |
| at = optional + size + 40 * i |
| vsize, va, rsize, raw = struct.unpack_from("<IIII", data, at + 8) |
| sections.append((va, max(vsize, rsize), raw)) |
|
|
| def fileoff(addr): |
| return next( |
| raw + addr - va for va, length, raw in sections if va <= addr < va + length |
| ) |
|
|
| assert total and total % 28 == 0 |
| debug = fileoff(rva) |
| identities = [] |
| for at in range(debug, debug + total, 28): |
| kind, length, addr, raw = struct.unpack_from("<IIII", data, at + 12) |
| if kind == 2 and data[raw : raw + 4] == b"RSDS": |
| identities.append( |
| ( |
| str(uuid.UUID(bytes_le=data[raw + 4 : raw + 20])).upper(), |
| struct.unpack_from("<I", data, raw + 20)[0], |
| ) |
| ) |
| assert len(identities) == 1, identities |
| return dirs + 48, identities[0] |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--root", type=Path, required=True) |
| ap.add_argument("--plan", type=Path, required=True) |
| ap.add_argument("--projects", nargs="+", default=["detours", "winsparkle"]) |
| ap.add_argument("--modes", nargs="+", choices=["O0", "O2", "O2-noinline"]) |
| ap.add_argument("--evidence-root", type=Path) |
| ap.add_argument("--github-run", type=int, default=38208011147) |
| a = ap.parse_args() |
| r = a.root.resolve() |
| base = r / "staged/qualification-v2" |
| plan = json.loads(a.plan.read_text()) |
| evidence_root = a.evidence_root or r / "msvc-existing-evidence" |
| available = {c["project"] for c in plan["cells"] if c["platform"] == "windows"} |
| assert set(a.projects) <= available, "Unplanned Windows project" |
| audit = [] |
| for cell in plan["cells"]: |
| name = cell["project"] |
| if cell["platform"] != "windows" or name not in a.projects: |
| continue |
| for mode in cell["optimization_modes"]: |
| if a.modes and mode not in a.modes: |
| continue |
| src = evidence_root / name / mode |
| q = json.loads((src / "qualification.json").read_text(encoding="utf-8-sig")) |
| assert q["target"] == name and q["optimization"] == mode |
| assert q["project_procedure_records"] > 0 |
| replay = src / "preprocessed/source-map.json" |
| if replay.exists(): |
| provenance = json.loads( |
| (src / "build-provenance.json").read_text(encoding="utf-8-sig") |
| ) |
| assert provenance["source_revision"] == cell["source_revision"] |
| assert provenance["source_repository"] == cell["source_repository"] |
| assert provenance["optimization"] == mode |
| mappings = json.loads(replay.read_text(encoding="utf-8-sig")) |
| assert mappings and (src / "original.tar.gz").is_file() |
| for record in mappings: |
| path = src / "preprocessed" / record["preprocessed"] |
| assert path.is_file() and path.stat().st_size > 0 |
| flags = [flag.lower() for flag in record["preprocess_argv"]] |
| optimization_flags = [ |
| flag for flag in flags if re.fullmatch(r"[-/]o[d012sx]", flag) |
| ] |
| expected = "/od" if mode == "O0" else "/o2" |
| assert ( |
| optimization_flags and optimization_flags[-1] == expected |
| ), record["source"] |
| if mode in ["O0", "O2-noinline"]: |
| inline_flags = [ |
| flag |
| for flag in flags |
| if re.fullmatch(r"[-/]ob[0123]", flag) |
| ] |
| assert inline_flags and inline_flags[-1] == "/ob0", record[ |
| "source" |
| ] |
| assert "/gl" not in flags, "Unexpected LTCG compilation" |
| binary = src / "binary" / q["linked_image"] |
| pdb = src / "binary" / q["pdb"] |
| binary_digest = sha(binary) |
| out = base / "windows/x86_64" / mode / name |
| out.mkdir(parents=True, exist_ok=True) |
| native_guid, native_age = codeview(binary)[1] |
| summary = subprocess.check_output( |
| ["llvm-pdbutil", "dump", "-summary", str(pdb)], text=True |
| ) |
| pdb_guid = re.search(r"GUID:\s*\{([^}]+)\}", summary).group(1).upper() |
| pdb_age = int(re.search(r"Age:\s*(\d+)", summary).group(1)) |
| assert (native_guid, native_age) == (pdb_guid, pdb_age) |
| assert "Has Types: true" in summary and "Is stripped: false" in summary |
| before = text_sections(binary) |
| target = out / binary.name |
| shutil.copy2(binary, target) |
| shutil.copy2(pdb, out / pdb.name) |
| stripped = out / (binary.name + ".stripped") |
| data = bytearray(binary.read_bytes()) |
| offset, _ = codeview(binary) |
| struct.pack_into("<II", data, offset, 0, 0) |
| stripped.write_bytes(data) |
| assert not list(lief.PE.parse(str(stripped)).debug) |
| assert before == text_sections(stripped) |
| shutil.copy2( |
| src / "qualification.json", out / "upstream-qualification.json" |
| ) |
| shutil.copy2( |
| src / "project-procedures.json", out / "project-procedures.json" |
| ) |
| shutil.copy2(src / "build.log", out / "build.log") |
| (out / "pdb-summary.txt").write_text(summary) |
| if replay.exists(): |
| for file in [ |
| "build-provenance.json", |
| "compile_commands.json", |
| "original.tar.gz", |
| ]: |
| shutil.copy2(src / file, out / file) |
| with tarfile.open(out / "preprocessed.tar.gz", "w:gz") as archive: |
| archive.add(src / "preprocessed", arcname="preprocessed") |
| for file in ["CMakeCache.txt", "target-commands.txt"]: |
| if (src / file).is_file(): |
| shutil.copy2(src / file, out / file) |
| procedures = json.loads( |
| (src / "project-procedures.json").read_text(encoding="utf-8-sig") |
| ) |
| pe = lief.PE.parse(str(binary)) |
| identities = [] |
| for proc in procedures: |
| if not proc.get("project_owned") or proc["code_size"] <= 0: |
| continue |
| section, offset = proc["address"].split(":") |
| section_index = int(section, 16) - 1 |
| assert 0 <= section_index < len(pe.sections) |
| rva = pe.sections[section_index].virtual_address + int(offset) |
| section = pe.sections[section_index] |
| assert int(section.characteristics) & 0x20000000 |
| assert int(offset) + proc["code_size"] <= len( |
| section.content |
| ), "Unmapped PDB procedure" |
| identities.append( |
| { |
| **proc, |
| "binary_sha256": binary_digest, |
| "rva": rva, |
| "va": pe.optional_header.imagebase + rva, |
| "identity": [binary_digest, rva], |
| } |
| ) |
| assert identities |
| (out / "function-identities.json").write_text( |
| json.dumps(identities, indent=2) |
| ) |
| status = { |
| "state": "imported-pe-pdb-verified", |
| "project": name, |
| "platform": "windows", |
| "architecture": "x86_64", |
| "optimization": mode, |
| "source_repository": cell["source_repository"], |
| "source_revision": cell["source_revision"], |
| "binary": str(target.relative_to(base)), |
| "binary_sha256": sha(target), |
| "stripped": str(stripped.relative_to(base)), |
| "stripped_sha256": sha(stripped), |
| "pdb_sha256": sha(out / pdb.name), |
| "pdb_guid": native_guid, |
| "pdb_age": native_age, |
| "code_sections_equal": True, |
| "debug_directory_removed": True, |
| "project_owned_function_count": len(identities), |
| "project_ownership_method": q["project_ownership_method"], |
| "ownership_scope": "procedures in source-matched compilands; header-origin and dependency ownership need per-procedure verification", |
| "evidence_github_run": a.github_run, |
| "preprocessed_tu_count": len(mappings) if replay.exists() else 0, |
| "scoring_ready": False, |
| "remaining_gates": [ |
| "original source archive and preprocessed TU replay", |
| "full source-range identity correspondence", |
| "MSVC source/ABI type evaluation adapter", |
| ], |
| } |
| if replay.exists(): |
| status["effective_optimization_profile_verified"] = True |
| dependency_tus = [ |
| record |
| for record in mappings |
| if any( |
| marker in record["source"].replace("\\", "/").lower() |
| for marker in ["/.cpm-cache/", "/_deps/"] |
| ) |
| ] |
| status["external_dependency_preprocessed_tus"] = len(dependency_tus) |
| if dependency_tus: |
| status["remaining_gates"].append( |
| "fetched dependency source revisions, licenses and original archives" |
| ) |
| status["build_environment"] = provenance["environment"] |
| status["preprocessed_archive"] = str( |
| (out / "preprocessed.tar.gz").relative_to(base) |
| ) |
| status["build_provenance"] = str( |
| (out / "build-provenance.json").relative_to(base) |
| ) |
| status["remaining_gates"].remove( |
| "original source archive and preprocessed TU replay" |
| ) |
| (out / "status.json").write_text(json.dumps(status, indent=2)) |
| audit.append(status) |
| print(json.dumps(status), flush=True) |
| (r / f"audit/msvc-import-{a.github_run}.json").write_text( |
| json.dumps(audit, indent=2) |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
