Files
DroidDeck/tools/linuxfs/overlay/usr/local/bin/droiddeck-wine-pe
T
MaxsTechReviewandxXJsonDeruloXx ae9bac225d fix(game-env): keep x64 system DLLs that only x64 code loads in ARM64 prefixes (#2647)
* fix(game-env): keep x64 system DLLs that only x64 code loads in ARM64 prefixes

The foreign-architecture repair treated every plain x64 DLL in system32 of
an ARM64 prefix as broken and swapped in the ARM64 builtin. ARM64EC games
load x64 DLLs fine, so this broke native-only DLLs such as the Khronos
vulkan-1.dll loader (vulkan-1=n leaves Wine nothing to load) and native
runtimes that games depend on.

An x64 DLL is now foreign only when Proton's own ARM64 programs import it,
found from the import tables of the Proton build's ARM64 executables.
Prefixes the old rule already repaired get their native copy back. This
replaces the Visual C++ runtime name list.

* fix(game-env): keep the old rule when Proton's programs cannot be read, restore the newest backup across gaps

* fix(game-env): number new backups above the highest one, treat truncated import tables as unreadable

* fix(game-env): treat an import directory outside every section as unreadable

* fix(game-env): treat truncated data directories and section tables as unreadable

* perf(game-env): index foreign DLL backups per directory

* fix(game-env): count only ARM64 Proton programs as roots, cover x64 component DLLs across launches

---------

Co-authored-by: xXJsonDeruloXx <danielhimebauch@gmail.com>
2026-11-15 09:20:02 -05:00

191 lines
7.5 KiB
Python
Executable File

#!/usr/bin/python3
import os
from pathlib import Path
PE_MACHINES = {
"system32": ("aarch64-windows", frozenset((0xAA64, 0xA641))),
"syswow64": ("i386-windows", frozenset((0x14C,))),
}
def pe_machine(path):
try:
with open(path, "rb") as image:
head = image.read(64)
if head[:2] != b"MZ" or len(head) < 64:
return None
image.seek(int.from_bytes(head[60:64], "little"))
header = image.read(6)
except OSError:
return None
if header[:4] != b"PE\0\0" or len(header) < 6:
return None
return int.from_bytes(header[4:6], "little")
def pe_has_arm64ec_metadata(path):
try:
with open(path, "rb") as image:
image.seek(60)
raw = image.read(4)
if len(raw) != 4:
return False
pe_offset = int.from_bytes(raw, "little")
image.seek(pe_offset)
if image.read(4) != b"PE\0\0":
return False
coff = image.read(20)
if len(coff) != 20:
return False
section_count = int.from_bytes(coff[2:4], "little")
if section_count > 96:
return False
optional_size = int.from_bytes(coff[16:18], "little")
optional_offset = pe_offset + 24
image.seek(optional_offset)
optional = image.read(optional_size)
if len(optional) != optional_size or int.from_bytes(optional[:2], "little") != 0x20B:
return False
directory_count = int.from_bytes(optional[108:112], "little")
directory_offset = 112 + 10 * 8
if directory_count <= 10 or directory_offset + 8 > len(optional):
return False
load_config_rva = int.from_bytes(optional[directory_offset:directory_offset + 4], "little")
load_config_size = int.from_bytes(optional[directory_offset + 4:directory_offset + 8], "little")
if not load_config_rva or load_config_size < 0xD0:
return False
section_offset = optional_offset + optional_size
for index in range(section_count):
image.seek(section_offset + index * 40)
section = image.read(40)
if len(section) != 40:
return False
virtual_address = int.from_bytes(section[12:16], "little")
raw_size = int.from_bytes(section[16:20], "little")
raw_offset = int.from_bytes(section[20:24], "little")
relative = load_config_rva - virtual_address
if 0 <= relative <= raw_size - 0xD0:
image.seek(raw_offset + relative)
load_config = image.read(0xD0)
if len(load_config) != 0xD0 or int.from_bytes(load_config[:4], "little") < 0xD0:
return False
return int.from_bytes(load_config[0xC8:0xD0], "little") != 0
except (OSError, OverflowError, ValueError):
return False
return False
def pe_imports(path):
try:
with open(path, "rb") as source:
image = source.read()
except OSError:
return None
try:
if image[:2] != b"MZ":
return None
pe_offset = int.from_bytes(image[60:64], "little")
if image[pe_offset:pe_offset + 4] != b"PE\0\0":
return None
section_count = int.from_bytes(image[pe_offset + 6:pe_offset + 8], "little")
optional_size = int.from_bytes(image[pe_offset + 20:pe_offset + 22], "little")
optional = pe_offset + 24
magic = int.from_bytes(image[optional:optional + 2], "little")
directories = optional + (112 if magic == 0x20B else 96)
if directories > len(image):
return None
directory_count = int.from_bytes(image[directories - 4:directories], "little")
sections = []
for index in range(min(section_count, 96)):
entry = optional + optional_size + index * 40
if entry + 40 > len(image):
return None
sections.append((int.from_bytes(image[entry + 12:entry + 16], "little"),
max(int.from_bytes(image[entry + 8:entry + 12], "little"),
int.from_bytes(image[entry + 16:entry + 20], "little")),
int.from_bytes(image[entry + 20:entry + 24], "little")))
def offset(rva):
for address, size, raw in sections:
if address <= rva < address + size:
return rva - address + raw
return None
names = set()
for directory, step, field in ((1, 20, 12), (13, 32, 4)):
if directory >= directory_count:
continue
if directories + directory * 8 + 8 > len(image):
return None
rva = int.from_bytes(image[directories + directory * 8:directories + directory * 8 + 4], "little")
entry = offset(rva) if rva else None
if rva and entry is None:
return None
while entry is not None:
if entry + step > len(image):
return None
name_rva = int.from_bytes(image[entry + field:entry + field + 4], "little")
if not name_rva:
break
name = offset(name_rva)
end = image.find(b"\0", name) if name is not None else -1
if end < 0:
return None
names.add(image[name:end].decode("ascii", "replace").lower())
entry += step
return names
except (IndexError, ValueError):
return None
PROGRAM_IMPORTS = {}
def program_imports(builtins):
key = str(builtins)
if key not in PROGRAM_IMPORTS:
try:
files = {name.lower(): Path(builtins) / name for name in os.listdir(builtins)}
except OSError:
files = None
pending = [name for name in files or () if name.endswith(".exe") and pe_machine(files[name]) in (None, 0xAA64)]
seen = set()
while pending and files is not None:
name = pending.pop()
if name in seen:
continue
seen.add(name)
if name in files:
imports = pe_imports(files[name])
if imports is None:
files = None
else:
pending.extend(imports)
PROGRAM_IMPORTS[key] = None if files is None else frozenset(name for name in seen if name.endswith(".dll"))
return PROGRAM_IMPORTS[key]
def machine_compatible(path, machines, machine=None, builtins=None, name=None):
machine = pe_machine(path) if machine is None else machine
if machine == 0x8664 and 0xA641 in machines:
if pe_has_arm64ec_metadata(path):
return True
imported = program_imports(builtins) if builtins is not None else None
return imported is not None and (name or Path(path).name).lower() not in imported
if machine == 0x8664 and pe_has_arm64ec_metadata(path):
return False
return machine in machines
def proton_pe_machines(proton, env=None):
dist = Path(proton).parent / "files/lib/wine"
if (dist / "aarch64-unix").is_dir() and (env or {}).get("PROTON_USE_ARM64", "1") == "1":
return PE_MACHINES
if (dist / "x86_64-unix").is_dir():
return {
"system32": ("x86_64-windows", frozenset((0x8664,))),
"syswow64": PE_MACHINES["syswow64"],
}
return None