mirror of
https://github.com/spoopyghosty0/frameport.git
synced 2026-10-24 05:01:48 +02:00
216 lines
10 KiB
Python
216 lines
10 KiB
Python
"""Embedded loader redirection, independent of any game or device."""
|
|
import json
|
|
import shutil
|
|
import struct
|
|
import subprocess
|
|
import zipfile
|
|
|
|
import pytest
|
|
from test_agent import load_agent
|
|
from test_patches import _analysis
|
|
|
|
from frameport.analysis import detect
|
|
from frameport.analysis import static_openxr as sx
|
|
from frameport.apk.workspace import ApkWorkspace
|
|
from frameport.core.events import Reporter
|
|
from frameport.patches import base
|
|
from frameport.patches.frame import static_openxr_loader as patch
|
|
|
|
|
|
@pytest.fixture
|
|
def embedded(tmp_path):
|
|
# A real ELF layout with synthetic strings; change only e_machine to model an arm64 game.
|
|
compiler = shutil.which("cc")
|
|
if not compiler:
|
|
pytest.skip("needs host C compiler")
|
|
strings = [f"/{p}/etc/openxr/1/active_runtime{abi}.json"
|
|
for p in ("product", "odm", "oem", "vendor", "system") for abi in ("", ".aarch64", ".arm64-v8a")]
|
|
strings += list(sx.BROKERS) + ["RuntimeManifestFile", "xrNegotiateLoaderRuntimeInterface", "unrelated"]
|
|
src = tmp_path / "embedded.c"
|
|
src.write_text("const char *strings[] = {" + ",".join(json.dumps(s) for s in strings) + "};")
|
|
out = tmp_path / "embedded.so"
|
|
subprocess.run([compiler, "-shared", "-fPIC", str(src), "-o", str(out)], check=True)
|
|
data = bytearray(out.read_bytes())
|
|
struct.pack_into("<H", data, 18, 183) # EM_AARCH64
|
|
return bytes(data)
|
|
|
|
|
|
def test_detection_and_byte_stable_rewrite(embedded):
|
|
assert sx.detected("libengine.so", embedded)
|
|
assert not sx.detected("libopenxr_loader.so", embedded)
|
|
assert not sx.detected("libengine.so", embedded.replace(b"RuntimeManifestFile", b"X" * 19))
|
|
wrong_arch = bytearray(embedded)
|
|
struct.pack_into("<H", wrong_arch, 18, 62)
|
|
assert not sx.detected("libengine.so", bytes(wrong_arch))
|
|
fixed, count = sx.rewrite(embedded)
|
|
assert count == 17
|
|
assert len(fixed) == len(embedded)
|
|
expected = embedded
|
|
for old in sx.paths(embedded) + list(sx.BROKERS):
|
|
new = sx.MANIFEST if old.startswith("/") else old.replace("org.khronos", "org.fp_null")
|
|
expected = expected.replace(old.encode() + b"\0", new.encode().ljust(len(old) + 1, b"\0"))
|
|
assert fixed == expected # all other bytes, offsets and ELF metadata are identical
|
|
assert sx.rewrite(fixed) == (fixed, 0)
|
|
assert not sx.paths(fixed)
|
|
assert detect.ANALYSIS_VERSION >= 23
|
|
|
|
|
|
def test_patch_and_adapter_without_overport(tmp_path, monkeypatch, embedded):
|
|
inner = tmp_path / "inner.so"
|
|
inner.write_bytes(b"unmodified Khronos loader")
|
|
monkeypatch.setattr(patch.overport, "ensure_runtime_lib", lambda *args: inner)
|
|
apk = tmp_path / "in.apk"
|
|
with zipfile.ZipFile(apk, "w") as z:
|
|
z.writestr("lib/arm64-v8a/libengine.so", embedded)
|
|
a = _analysis(extra={"static_openxr_loader": ["libengine.so"]})
|
|
selection = {patch.StaticOpenXRLoader.id: {}, "frame.adapter": {}}
|
|
p = patch.StaticOpenXRLoader()
|
|
assert p.detect(a).recommended
|
|
assert not p.applies(_analysis())
|
|
with ApkWorkspace(apk) as ws:
|
|
ctx = base.ApkContext(ws, a, {}, Reporter(), selection)
|
|
assert p.apply(ctx)
|
|
assert base.get("frame.adapter").apply(ctx)
|
|
assert ws.read_lib("libopenxr_loader_original.so") == inner.read_bytes()
|
|
assert ws.has(ws.lib("libframe_settings.so"))
|
|
assert all(ok for _, ok, _ in p.validate(ctx))
|
|
assert all(ok for _, ok, _ in base.get("frame.adapter").validate(ctx))
|
|
assert not p.apply(ctx)
|
|
assert not base.get("frame.adapter").apply(ctx)
|
|
out = ws.write(tmp_path / "out.apk")
|
|
with ApkWorkspace(out) as ws:
|
|
ctx.ws = ws
|
|
assert not p.apply(ctx)
|
|
ws.put(ws.lib("libengine.so"), embedded)
|
|
assert not p.validate(ctx)[0][1]
|
|
|
|
|
|
def test_manifest_repair_and_launcher_upgrade(tmp_path, monkeypatch):
|
|
a = load_agent(monkeypatch, tmp_path)
|
|
root = tmp_path / "game"
|
|
a.write_openxr_runtime_manifest(str(root), False)
|
|
assert not root.exists()
|
|
a.write_openxr_runtime_manifest(str(root), True)
|
|
target = root / "lepton-data/external/fp_openxr_runtime.json"
|
|
manifest = json.loads(target.read_text())
|
|
assert manifest["runtime"]["library_path"] == patch.SHIM
|
|
victim = tmp_path / "victim"
|
|
victim.write_text("untouched")
|
|
target.unlink()
|
|
target.symlink_to(victim)
|
|
a.write_openxr_runtime_manifest(str(root), True)
|
|
assert victim.read_text() == "untouched"
|
|
assert not target.is_symlink()
|
|
anchor = tmp_path / "anchors/com.example.game"
|
|
anchor.mkdir(parents=True)
|
|
a.write_launcher(str(anchor), str(root), "com.example.game", "Test", 123, "/lepton", {}, static_openxr=True)
|
|
text = (anchor / "launch.sh").read_text()
|
|
assert " _openxr_manifest com.example.game\n" in text
|
|
assert a.set_openxr_manifest_line(text, "com.example.game", True) == text
|
|
assert "_openxr_manifest" not in a.set_openxr_manifest_line(text, "com.example.game", False)
|
|
subprocess.run(["bash", "-n", str(anchor / "launch.sh")], check=True)
|
|
|
|
|
|
def test_runtime_shim_host(tmp_path):
|
|
import os
|
|
from pathlib import Path
|
|
|
|
root = Path(__file__).resolve().parents[1]
|
|
headers = next((root / "native/.cache").glob("openxr-*/openxr/openxr.h"), None)
|
|
cc = shutil.which("cc")
|
|
if not headers or not cc:
|
|
pytest.skip("needs cached OpenXR headers and host C compiler")
|
|
src = root / "native/xrruntime"
|
|
inc = str(headers.parent.parent)
|
|
subprocess.run([cc, "-shared", "-fPIC", "-I", inc, str(src / "test_bridge.c"),
|
|
"-o", str(tmp_path / "libopenxr_loader_generic.so")], check=True)
|
|
exe = tmp_path / "shim_test"
|
|
subprocess.run([cc, "-Wall", "-Wextra", "-Werror", "-Wno-missing-field-initializers", "-I", inc,
|
|
str(src / "xrruntime.c"), str(src / "test.c"), "-ldl", "-lpthread", "-o", str(exe)], check=True)
|
|
env = dict(os.environ, LD_LIBRARY_PATH=str(tmp_path))
|
|
subprocess.run([str(exe)], env=env, check=True)
|
|
(tmp_path / "libopenxr_loader_generic.so").unlink()
|
|
subprocess.run([str(exe), "missing"], env=env, check=True)
|
|
|
|
|
|
def test_composed_khronos_paths(tmp_path, embedded):
|
|
# Rebuild the fixture with Khronos platform_utils.hpp's actual fragment table.
|
|
# This is also the layout in OVRPort's unmodified Khronos loader.
|
|
|
|
from frameport.analysis import elf
|
|
|
|
cc = shutil.which("cc")
|
|
src = tmp_path / "composed.c"
|
|
strings = list(sx.PARTITIONS) + [sx.SUBDIR, "/active_runtime.json", "/active_runtime.aarch64.json"]
|
|
strings += list(sx.BROKERS) + ["RuntimeManifestFile", "xrNegotiateLoaderRuntimeInterface"]
|
|
src.write_text("const char *strings[] = {" + ",".join(json.dumps(s) for s in strings) + "};")
|
|
out = tmp_path / "composed.so"
|
|
subprocess.run([cc, "-shared", "-fPIC", str(src), "-o", str(out)], check=True)
|
|
buf = bytearray(out.read_bytes())
|
|
struct.pack_into("<H", buf, 18, 183)
|
|
data = bytes(buf)
|
|
assert sx.composed(data) and sx.detected("libgame.so", data)
|
|
fixed, count = sx.rewrite(data)
|
|
assert count == 8 and len(fixed) == len(data)
|
|
assert sx.redirected(fixed) and sx.rewrite(fixed) == (fixed, 0)
|
|
expected = data
|
|
for old, new in [(p, "/sd") for p in sx.PARTITIONS] + [(sx.SUBDIR, "card/fp/")] + [
|
|
(p, p.replace("org.khronos", "org.fp_null")) for p in sx.BROKERS]:
|
|
expected, _ = elf.replace_rodata_string(expected, old, new)
|
|
assert fixed == expected
|
|
assert "/sd" + "card/fp/" + "1" + "/active_runtime.json" == sx.COMPOSED_MANIFEST
|
|
|
|
|
|
def test_game_loader_skips_implicit_layers(tmp_path):
|
|
# GitHub #254: the game's loader and FrameBridge's inner loader both loaded Valve's implicit layer; its two
|
|
# chains called each other until the stack ran out. Only the inner loader may see implicit layers.
|
|
cc = shutil.which("cc")
|
|
if not cc:
|
|
pytest.skip("needs host C compiler")
|
|
src = tmp_path / "layers.c"
|
|
strings = list(sx.PARTITIONS) + [sx.SUBDIR, "/active_runtime.json", "/active_runtime.aarch64.json"]
|
|
strings += ["/vendor/etc", "/system/etc", sx.IMPLICIT_LAYERS, "/api_layers/explicit.d",
|
|
"openxr/1/api_layers/implicit.d/"]
|
|
strings += list(sx.BROKERS) + ["RuntimeManifestFile", "xrNegotiateLoaderRuntimeInterface"]
|
|
src.write_text("const char *strings[] = {" + ",".join(json.dumps(s) for s in strings) + "};")
|
|
out = tmp_path / "layers.so"
|
|
subprocess.run([cc, "-shared", "-fPIC", str(src), "-o", str(out)], check=True)
|
|
buf = bytearray(out.read_bytes())
|
|
struct.pack_into("<H", buf, 18, 183)
|
|
data = bytes(buf)
|
|
fixed, count = sx.rewrite(data)
|
|
assert count == 9 and len(fixed) == len(data)
|
|
assert not sx.implicit_layers(fixed) and sx.redirected(fixed) and sx.rewrite(fixed) == (fixed, 0)
|
|
assert b"/api_layers/explicit.d\0" in fixed and b"openxr/1/api_layers/implicit.d/\0" in fixed
|
|
# a build from before the fix (runtime already redirected, layers not) is no longer "redirected" and gets them
|
|
old = fixed.replace(sx.NO_IMPLICIT_LAYERS.encode() + b"\0\0", sx.IMPLICIT_LAYERS.encode() + b"\0")
|
|
assert not sx.redirected(old) and sx.rewrite(old) == (fixed, 1)
|
|
assert patch.StaticOpenXRLoader.revision >= 2
|
|
|
|
|
|
def test_analysis_records_embedded_loader(tmp_path, embedded, quest_manifest):
|
|
apk = tmp_path / "analyze.apk"
|
|
with zipfile.ZipFile(apk, "w") as z:
|
|
z.writestr("AndroidManifest.xml", quest_manifest)
|
|
z.writestr("lib/arm64-v8a/libengine.so", embedded)
|
|
assert detect.analyze(apk).extra["static_openxr_loader"] == ["libengine.so"]
|
|
|
|
|
|
def test_triage_only_when_chain_absent():
|
|
from frameport.validate.triage import triage
|
|
|
|
line = "RuntimeManifestFile::FindManifestFiles - using global runtime file /vendor/etc/openxr/1/active_runtime.json"
|
|
assert "static-openxr-loader-bypass" in {f.id for f in triage(line, "RUNNING").findings}
|
|
for chain in ("FrameBridge: settings read", "fp_xrruntime: negotiated"):
|
|
assert "static-openxr-loader-bypass" not in {f.id for f in triage(line + "\n" + chain, "RUNNING").findings}
|
|
|
|
|
|
def test_heuristic_selects_chain_without_game_specific_rules():
|
|
from frameport.recommend.engine import suggest
|
|
|
|
a = _analysis(package="com.example.othergame", engine="Other", libs=["libengine.so"],
|
|
extra={"static_openxr_loader": ["libengine.so"], "vr_kind": "openxr"})
|
|
r = suggest(a, use_catalog=False)
|
|
assert {"frame.static_openxr_loader", "frame.adapter"} <= r.patches.keys()
|
|
assert not r.as_is
|