mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
* 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>
191 lines
7.5 KiB
Python
Executable File
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
|