Skip to content

Play your Steam library's Windows games on a jailbroken PS5.

C++
29.5 KB
Raw Blame
#include "runtime/kit_manifest.h"
#if PLAYDEN_TEST_KIT_ADMISSION
#include "runtime/artifact_hash.h"
#include "runtime/kit_admission.h"
#endif

#include <cassert>
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <sstream>
#include <string>
#include <sys/stat.h>
#include <unistd.h>

namespace fs = std::filesystem;
using namespace playden::runtime;

namespace {

std::string HashBytes(std::string_view bytes) {
#if PLAYDEN_TEST_KIT_ADMISSION
  return *HashArtifactBytes(bytes);
#else
  std::uint64_t value = 1469598103934665603ULL;
  for (unsigned char byte : bytes) value = (value ^ byte) * 1099511628211ULL;
  std::ostringstream output;
  output << std::hex << std::setfill('0');
  for (unsigned index = 0; index < 4; ++index)
    output << std::setw(16) << (value + index * 0x9e3779b97f4a7c15ULL);
  return output.str();
#endif
}

std::optional<std::string> HashFile(const fs::path& path) {
#if PLAYDEN_TEST_KIT_ADMISSION
  return HashArtifactFile(path);
#else
  std::ifstream input(path, std::ios::binary);
  if (!input) return std::nullopt;
  return HashBytes(std::string(std::istreambuf_iterator<char>(input), {}));
#endif
}

void Write(const fs::path& path, const std::string& bytes, unsigned mode = 0644) {
  fs::create_directories(path.parent_path());
  std::ofstream(path, std::ios::binary) << bytes;
  ::chmod(path.c_str(), mode);
}

std::string Pe(bool pe64) {
  std::string bytes(512, '\0');
  bytes[0] = 'M'; bytes[1] = 'Z'; bytes[0x3c] = 0x80;
  bytes[0x80] = 'P'; bytes[0x81] = 'E';
  const unsigned machine = pe64 ? 0x8664 : 0x014c;
  bytes[0x84] = static_cast<char>(machine & 0xff);
  bytes[0x85] = static_cast<char>(machine >> 8);
  const unsigned magic = pe64 ? 0x020b : 0x010b;
  bytes[0x98] = static_cast<char>(magic & 0xff);
  bytes[0x99] = static_cast<char>(magic >> 8);
  return bytes;
}

std::string Quote(const std::string& text) { return "\"" + text + "\""; }

struct Fixture {
  fs::path root = fs::canonical(fs::temp_directory_path()) /
                  ("playden-kit-manifest-" + std::to_string(::getpid()));
  const std::string wrapper = std::string(40, 'a');
  const std::string wine = std::string(40, 'b');
  const std::string helper_revision = std::string(40, 'c');
  const std::string helper_base = std::string(40, 'd');
  const std::string foundation = std::string(40, 'e');
  const std::string dxvk_archive = std::string(64, 'f');
  KitAdmissionConfig trust;
  bool publication_guard = false;
  bool any_title_capability = false;
  std::string variant_fields;  // extra members of the first variant, e.g. ,"any_title":true
  std::string variant_title = "FAKE78001";
  std::string additional_variants;

  // Turns the variant into one shell for every game: template title FAKE78000, a FAKE78 rule
  // helper reading Playden's allow-list, and the capability.
  void MakeAnyTitle(const std::string& allow_list = "/data/playden/title-rule/allow-list",
                    const std::string& prefix = "FAKE78") {
    const auto helper = *HashFile(root / "titles/variant/lapy.elf");
    const auto protocol = *HashFile(root / "titles/variant/lapy_elevation_protocol.h");
    const std::string rule = "{\"prefix\":" + Quote(prefix) + ",\"allow_list\":" + Quote(allow_list) + "}";
    Write(root / "titles/variant/sce_sys/param.json", "{\"titleId\":\"FAKE78000\"}");
    Write(root / "titles/variant/lapy-manifest.json",
          "{\"schema\":\"lapy-owned-build/1\",\"mode\":\"elf-helper\",\"target_title\":" + Quote(prefix + "*") +
          ",\"title_rule\":" + rule + ",\"elf_sha256\":" + Quote(helper) + ",\"protocol_sha256\":" + Quote(protocol) +
          ",\"features\":[\"root_layout_probe_retry\",\"title_rule\"]}");
    Write(root / "titles/variant/native-title-build.json",
          "{\"schema\":\"prospero-win-native-title/1\",\"title_id\":\"FAKE78000\",\"any_title\":true,"
          "\"title_rule\":" + rule + ",\"source_revision\":" + Quote(wrapper) + ",\"source_dirty\":false,\"eboot_sha256\":" +
          Quote(*HashFile(root / "titles/variant/eboot.bin")) + "}");
    variant_title = "FAKE78000";
    variant_fields = ",\"any_title\":true";
    any_title_capability = true;
    trust.known_capabilities.push_back("title-any-id");
    RewriteManifest();
  }

  void SetPublicationMarkers(const std::string& fields,
                             const std::string& variant = "variant") {
    const auto path = root / "titles" / variant / "native-title-build.json";
    std::ifstream input(path);
    std::string text(std::istreambuf_iterator<char>(input), {});
    assert(!text.empty() && text.back() == '}');
    text.insert(text.size() - 1, fields);
    Write(path, text);
  }

  void AddSecondVariant() {
    fs::copy(root / "titles/variant", root / "titles/second", fs::copy_options::recursive);
    for (const char* file : {"lapy-manifest.json", "native-title-build.json", "sce_sys/param.json"}) {
      const auto path = root / "titles/second" / file;
      std::ifstream input(path);
      std::string text(std::istreambuf_iterator<char>(input), {});
      const auto at = text.find("FAKE78001");
      assert(at != std::string::npos);
      text.replace(at, 9, "FAKE78002");
      Write(path, text);
    }
    additional_variants =
        ",{\"id\":\"second\",\"title_id\":\"FAKE78002\",\"path\":\"titles/second\","
        "\"wrapper_revision\":" + Quote(wrapper) + ",\"helper_revision\":" + Quote(helper_revision) +
        ",\"helper_manifest\":\"titles/second/lapy-manifest.json\","
        "\"helper_protocol\":\"titles/second/lapy_elevation_protocol.h\","
        "\"native_build_manifest\":\"titles/second/native-title-build.json\"}";
  }

  Fixture() {
    fs::remove_all(root);
    const std::string runtime = "runtime/wine-wow64/artifact-e16";
    const char* core[] = {"ntdll.dll", "kernel32.dll", "kernelbase.dll",
                          "mmdevapi.dll", "dinput8.dll", "rsaenh.dll"};
    std::ostringstream inventory;
    inventory << '{';
    bool first = true;
    auto runtime_file = [&](const std::string& relative, const std::string& bytes,
                            unsigned mode = 0644) {
      Write(root / runtime / relative, bytes, mode);
      if (!first) inventory << ',';
      first = false;
      inventory << Quote(relative) << ':' << Quote(*HashFile(root / runtime / relative));
    };
    for (const char* name : core) {
      runtime_file("lib/wine/i386-windows/" + std::string(name), Pe(false));
      runtime_file("lib/wine/x86_64-windows/" + std::string(name), Pe(true));
    }
    runtime_file("lib/wine/x86_64-windows/wowprospero.dll", Pe(true));
    for (const char* name : {"ntdll.prx", "wineserver.prx", "win32u.prx",
                             "wineps5.prx", "libvulkan.prx", "wowprospero.prx"})
      runtime_file("lib/wine/x86_64-unix/" + std::string(name), "prx-" + std::string(name), 0755);
    inventory << '}';
    Write(root / runtime / "runtime-inventory.json", inventory.str());

    const fs::path bottle = root / "template/bottle";
    for (const char* name : core) {
      Write(bottle / "drive_c/windows/system32" / name, Pe(true));
      Write(bottle / "drive_c/windows/syswow64" / name, Pe(false));
    }
    Write(bottle / "drive_c/windows/system32/wowprospero.dll", Pe(true));
    const char* dxvk[] = {"d3d8.dll", "d3d9.dll", "d3d10core.dll", "d3d11.dll", "dxgi.dll"};
    for (const char* name : dxvk) {
      Write(bottle / "drive_c/windows/system32" / name, Pe(true));
      Write(bottle / "drive_c/windows/syswow64" / name, Pe(false));
    }
    fs::create_directories(bottle / "drive_c/users/prospero/Desktop");
    fs::create_directories(bottle / "drive_c/users/prospero/Documents");
    Write(bottle / "dosdevices/.pw-symlinks", "c:\t../drive_c\nz:\t/\n");
    WriteRegistry(true);
    Write(root / "recipes/steam-220-hl2-v1.json",
          "{\"id\":\"steam-220-hl2-v1\",\"version\":\"1\",\"requirements\":{\"audio\":\"ps5\"}}");
    Write(root / "titles/variant/eboot.bin", "eboot", 0755);
    Write(root / "titles/variant/lapy.elf", "helper", 0755);
    Write(root / "titles/variant/lapy_elevation_protocol.h", "protocol");
    Write(root / "titles/variant/sce_sys/param.json", "{\"titleId\":\"FAKE78001\"}");
    RefreshInnerManifests();

    trust.required_architecture = "x86_64+wow64-i386";
    trust.known_capabilities = {"wine-wow64", "ps5-audio"};
    trust.hash_file = HashFile;
    trust.hash_bytes = [](std::string_view bytes) -> std::optional<std::string> {
      return HashBytes(bytes);
    };
    RewriteManifest();
  }

  ~Fixture() { fs::remove_all(root); }

  void WriteRegistry(bool valid) {
    const std::string crypto64 =
        "[Software\\\\Microsoft\\\\Cryptography\\\\Defaults\\\\Provider Types\\\\Type 001]\n\"Name\"=\"Microsoft Enhanced Cryptographic Provider v1.0\"\n"
        "[Software\\\\Microsoft\\\\Cryptography\\\\Defaults\\\\Provider\\\\Microsoft Enhanced Cryptographic Provider v1.0]\n\"Image Path\"=\"C:\\\\windows\\\\system32\\\\rsaenh.dll\"\n\"Type\"=dword:00000001\n";
    const std::string crypto32 =
        "[Software\\\\Wow6432Node\\\\Microsoft\\\\Cryptography\\\\Defaults\\\\Provider Types\\\\Type 001]\n\"Name\"=\"Microsoft Enhanced Cryptographic Provider v1.0\"\n"
        "[Software\\\\Wow6432Node\\\\Microsoft\\\\Cryptography\\\\Defaults\\\\Provider\\\\Microsoft Enhanced Cryptographic Provider v1.0]\n\"Image Path\"=\"C:\\\\windows\\\\system32\\\\rsaenh.dll\"\n\"Type\"=dword:00000001\n";
    const std::string com =
        "[Software\\\\Classes\\\\Wow6432Node\\\\CLSID\\\\{BCDE0395-E52F-467C-8E3D-C4579291692E}]\n"
        "[Software\\\\Classes\\\\Wow6432Node\\\\CLSID\\\\{BCDE0395-E52F-467C-8E3D-C4579291692E}\\\\InprocServer32]\n@=\"C:\\\\windows\\\\system32\\\\mmdevapi.dll\"\n\"ThreadingModel\"=\"Both\"\n"
        "[Software\\\\Classes\\\\Wow6432Node\\\\CLSID\\\\{25E609E4-B259-11CF-BFC7-444553540000}]\n"
        "[Software\\\\Classes\\\\Wow6432Node\\\\CLSID\\\\{25E609E4-B259-11CF-BFC7-444553540000}\\\\InprocServer32]\n@=\"C:\\\\windows\\\\system32\\\\dinput8.dll\"\n\"ThreadingModel\"=\"Both\"\n";
    Write(root / "template/bottle/system.reg",
          std::string("[Software\\\\Microsoft\\\\Wow64\\\\x86]\n@=\"") +
              (valid ? "wowprospero.dll" : "wrong.dll") + "\"\n" + crypto64 + crypto32 + com);
    Write(root / "template/bottle/user.reg",
          "[Software\\\\Wine\\\\Drivers]\n\"Audio\"=\"ps5\"\n"
          "[Volatile Environment]\n\"USERNAME\"=\"prospero\"\n\"USERPROFILE\"=\"C:\\\\users\\\\prospero\"\n");
  }

  void RefreshInnerManifests(bool dirty = false) {
    const auto helper = *HashFile(root / "titles/variant/lapy.elf");
    const auto protocol = *HashFile(root / "titles/variant/lapy_elevation_protocol.h");
    Write(root / "titles/variant/lapy-manifest.json",
          "{\"schema\":\"lapy-owned-build/1\",\"mode\":\"elf-helper\",\"target_title\":\"FAKE78001\","
          "\"elf_sha256\":" + Quote(helper) + ",\"protocol_sha256\":" + Quote(protocol) +
          ",\"features\":[\"root_layout_probe_retry\"]}");
    Write(root / "titles/variant/native-title-build.json",
          "{\"schema\":\"prospero-win-native-title/1\",\"title_id\":\"FAKE78001\","
          "\"source_revision\":" + Quote(wrapper) + ",\"source_dirty\":" + (dirty ? "true" : "false") + ",\"eboot_sha256\":" +
          Quote(*HashFile(root / "titles/variant/eboot.bin")) + "}");
  }

  void RewriteRuntimeInventory() {
    const fs::path runtime = root / "runtime/wine-wow64/artifact-e16";
    std::ostringstream out; out << '{'; bool first = true;
    for (const auto& item : fs::recursive_directory_iterator(runtime)) {
      if (!item.is_regular_file() || item.path().filename() == "runtime-inventory.json") continue;
      if (!first) out << ','; first = false;
      out << Quote(fs::relative(item.path(), runtime).generic_string()) << ':' << Quote(*HashFile(item.path()));
    }
    out << '}'; Write(runtime / "runtime-inventory.json", out.str());
  }

  void RewriteManifest(std::string firmware = "12.02", std::string runtime_path =
                       "runtime/wine-wow64/artifact-e16") {
    std::vector<KitFile> entries;
    for (const auto& item : fs::recursive_directory_iterator(root)) {
      if (!item.is_regular_file() || item.path().filename() == "manifest.json") continue;
      const auto status = fs::status(item.path());
      entries.push_back({fs::relative(item.path(), root).generic_string(), item.file_size(),
                         *HashFile(item.path()), static_cast<unsigned>(status.permissions()) & 0777});
    }
    std::sort(entries.begin(), entries.end(), [](const auto& a, const auto& b) { return a.path < b.path; });
    std::ostringstream lines, files;
    files << '[';
    for (std::size_t i = 0; i < entries.size(); ++i) {
      const auto& e = entries[i];
      std::ostringstream mode; mode << std::oct << std::setw(4) << std::setfill('0') << e.mode;
      lines << e.path << '\t' << e.size << '\t' << e.sha256 << '\t' << mode.str() << '\n';
      if (i) files << ',';
      files << "{\"path\":" << Quote(e.path) << ",\"size\":" << e.size
            << ",\"sha256\":" << Quote(e.sha256) << ",\"mode\":" << Quote(mode.str()) << '}';
    }
    files << ']';
    auto source = [&](const char* name, const std::string& body) {
      return Quote(name) + ":{" + body + ",\"url\":\"https://example.invalid/source\"}";
    };
    std::ostringstream dxvk;
    dxvk << "{\"version\":\"2.6.2\",\"files\":{";
    for (const auto& pair : {std::pair{"x64", "system32"}, std::pair{"x32", "syswow64"}}) {
      if (pair.first == std::string("x32")) dxvk << ',';
      dxvk << Quote(pair.first) << ":{";
      bool first = true;
      for (const char* name : {"d3d8.dll", "d3d9.dll", "d3d10core.dll", "d3d11.dll", "dxgi.dll"}) {
        if (!first) dxvk << ','; first = false;
        dxvk << Quote(name) << ':' << Quote(*HashFile(root / "template/bottle/drive_c/windows" / pair.second / name));
      }
      dxvk << '}';
    }
    dxvk << "}}";
    const std::string sources = "{" +
      source("wrapper", "\"revision\":" + Quote(wrapper) + ",\"baseline_revision\":" + Quote(wrapper)) + "," +
      source("wine", "\"revision\":" + Quote(wine)) + "," +
      source("helper", "\"revision\":" + Quote(helper_revision) + ",\"base_revision\":" + Quote(helper_base)) + "," +
      source("foundation", "\"revision\":" + Quote(foundation)) + "," +
      source("sdk", "\"version\":\"0.42\"") + "," +
      source("dxvk", "\"version\":\"2.6.2\",\"archive_sha256\":" + Quote(dxvk_archive)) + "}";
    const std::string manifest =
      "{\"schema\":\"playden-prospero-kit/1\",\"kit_id\":\"kit-1\",\"firmware\":[" + Quote(firmware) +
      "],\"architecture\":\"x86_64+wow64-i386\",\"capabilities\":[" +
      (publication_guard ? "\"playden-publication-guard-v1\"," : "") + "\"ps5-audio\"," +
      (any_title_capability ? "\"title-any-id\"," : "") + "\"wine-wow64\"],"
      "\"sources\":" + sources + ",\"runtime\":{\"bundle_id\":\"wine-wow64\",\"artifact_revision\":\"artifact-e16\","
      "\"wine_revision\":" + Quote(wine) + ",\"path\":" + Quote(runtime_path) +
      ",\"inventory_manifest\":\"runtime/wine-wow64/artifact-e16/runtime-inventory.json\","
      "\"module_counts\":{\"i386-windows\":6,\"x86_64-windows\":7,\"x86_64-unix\":6}},"
      "\"template\":{\"path\":\"template/bottle\",\"user\":\"prospero\"},"
      "\"recipe\":{\"id\":\"steam-220-hl2-v1\",\"version\":\"1\",\"path\":\"recipes/steam-220-hl2-v1.json\",\"sha256\":" +
      Quote(*HashFile(root / "recipes/steam-220-hl2-v1.json")) + "},\"variants\":[{\"id\":\"variant\",\"title_id\":" + Quote(variant_title) + variant_fields + ","
      "\"path\":\"titles/variant\",\"wrapper_revision\":" + Quote(wrapper) + ",\"helper_revision\":" + Quote(helper_revision) +
      ",\"helper_manifest\":\"titles/variant/lapy-manifest.json\",\"helper_protocol\":\"titles/variant/lapy_elevation_protocol.h\","
      "\"native_build_manifest\":\"titles/variant/native-title-build.json\"}" + additional_variants + "],\"dxvk\":" + dxvk.str() +
      ",\"files\":" + files.str() + ",\"files_sha256\":" + Quote(HashBytes(lines.str())) + "}";
    Write(root / "manifest.json", manifest);
    trust.expected_manifest_sha256 = std::string(64, '0');
  }

  KitManifestResult Verify() const {
#if PLAYDEN_TEST_KIT_ADMISSION
    return VerifyInstalledKit(root, trust);
#else
    return VerifyKitManifest(root, trust);
#endif
  }
};

void CheckRejected(const KitManifestResult& result, KitManifestStatus status) {
  assert(!result.view);
  assert(result.status == status);
  assert(!result.reason.empty());
}

}  // namespace

int main() {
  const std::string guard = "playden-publication-guard-v1";
  // Independent reviewed source-provider provenance digest, not read from the kit.
  const std::string provider = "f14d5e3ecb31951e3cf5bfdc41972181a9be1d96ed0dc7cb3aeebb8e4aab844a";
  const std::string valid_guard_fields =
      ",\"managed_publication_guard\":" + Quote(guard) +
      ",\"managed_descriptor_required\":true,\"publication_provider_sha256\":" + Quote(provider);
  {
    Fixture fixture;
    fixture.trust.known_capabilities.push_back(guard);
    // Incomplete opt-in trust configuration must fail even for a legacy kit.
    CheckRejected(fixture.Verify(), KitManifestStatus::kUnsupportedKit);
    fixture.trust.publication_provider_sha256 = std::string(64, 'A');
    CheckRejected(fixture.Verify(), KitManifestStatus::kUnsupportedKit);
    fixture.trust.publication_provider_sha256 = provider;
    assert(fixture.Verify().status == KitManifestStatus::kVerified);
  }
  {
    Fixture fixture;
    fixture.publication_guard = true;
    fixture.SetPublicationMarkers(valid_guard_fields);
    fixture.RewriteManifest();
    fixture.trust.publication_provider_sha256 = provider;
    // Supplying a digest does not make the capability known: the kit is admitted without it.
    const auto result = fixture.Verify();
    assert(result.status == KitManifestStatus::kVerified);
    assert(result.ignored_capabilities == std::vector<std::string>{guard});
    assert(std::find(result.capabilities.begin(), result.capabilities.end(), guard) == result.capabilities.end());
  }
  {
    // One shell for every game is admitted with its capability and Playden's title rule.
    Fixture fixture;
    fixture.MakeAnyTitle();
    const auto result = fixture.Verify();
    assert(result.status == KitManifestStatus::kVerified && result.view);
    assert(result.view->variants.size() == 1 && result.view->variants[0].any_title &&
           result.view->variants[0].title_id == "FAKE78000");
    assert(KitVariantFor(*result.view, "FAKE78042") == &result.view->variants[0]);
  }
  {
    // A build that doesn't know the capability ignores it and so refuses the variant.
    Fixture fixture;
    fixture.MakeAnyTitle();
    fixture.trust.known_capabilities.pop_back();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    // Without the capability, or without Playden's allow-list or range, it is refused.
    Fixture without;
    without.MakeAnyTitle();
    without.any_title_capability = false;
    without.RewriteManifest();
    CheckRejected(without.Verify(), KitManifestStatus::kIntegrityFailure);
    Fixture other_list;
    other_list.MakeAnyTitle("/data/elsewhere/allow-list");
    CheckRejected(other_list.Verify(), KitManifestStatus::kIntegrityFailure);
    Fixture other_range;
    other_range.MakeAnyTitle("/data/playden/title-rule/allow-list", "FAKE7");
    CheckRejected(other_range.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    // The capability with only fixed titles, or an any-title shell listed as a fixed title.
    Fixture capability_only;
    capability_only.any_title_capability = true;
    capability_only.trust.known_capabilities.push_back("title-any-id");
    capability_only.RewriteManifest();
    CheckRejected(capability_only.Verify(), KitManifestStatus::kIntegrityFailure);
    Fixture unmarked;
    unmarked.MakeAnyTitle();
    unmarked.variant_fields.clear();
    unmarked.RewriteManifest();
    CheckRejected(unmarked.Verify(), KitManifestStatus::kIntegrityFailure);
    Fixture malformed;
    malformed.MakeAnyTitle();
    malformed.variant_fields = ",\"any_title\":\"yes\"";
    malformed.RewriteManifest();
    CheckRejected(malformed.Verify(), KitManifestStatus::kMalformed);
  }
  const std::vector<std::string> invalid_guard_fields = {
      "",
      ",\"managed_publication_guard\":true,\"managed_descriptor_required\":true,\"publication_provider_sha256\":" + Quote(provider),
      ",\"managed_publication_guard\":\"other\",\"managed_descriptor_required\":true,\"publication_provider_sha256\":" + Quote(provider),
      ",\"managed_publication_guard\":" + Quote(guard) + ",\"publication_provider_sha256\":" + Quote(provider),
      ",\"managed_publication_guard\":" + Quote(guard) + ",\"managed_descriptor_required\":false,\"publication_provider_sha256\":" + Quote(provider),
      ",\"managed_publication_guard\":" + Quote(guard) + ",\"managed_descriptor_required\":\"true\",\"publication_provider_sha256\":" + Quote(provider),
      ",\"managed_publication_guard\":" + Quote(guard) + ",\"managed_descriptor_required\":true",
      ",\"managed_publication_guard\":" + Quote(guard) + ",\"managed_descriptor_required\":true,\"publication_provider_sha256\":true",
      ",\"managed_publication_guard\":" + Quote(guard) + ",\"managed_descriptor_required\":true,\"publication_provider_sha256\":" + Quote(std::string(64, 'a')),
  };
  for (const auto& fields : invalid_guard_fields) {
    Fixture fixture;
    fixture.publication_guard = true;
    fixture.trust.known_capabilities.push_back(guard);
    fixture.trust.publication_provider_sha256 = provider;
    fixture.SetPublicationMarkers(fields);
    fixture.RewriteManifest();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    Fixture fixture;
    fixture.publication_guard = true;
    fixture.trust.known_capabilities.push_back(guard);
    fixture.trust.publication_provider_sha256 = provider;
    fixture.AddSecondVariant(); // First and second are legacy native-build manifests.
    fixture.SetPublicationMarkers(valid_guard_fields);
    fixture.RewriteManifest();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
    fixture.SetPublicationMarkers(valid_guard_fields, "second");
    fixture.RewriteManifest();
    const auto result = fixture.Verify();
    assert(result.status == KitManifestStatus::kVerified);
    assert(result.available_variant_ids == std::vector<std::string>({"variant", "second"}));
  }
  {
    Fixture fixture;
    const auto result = fixture.Verify();
    if (result.status != KitManifestStatus::kVerified)
      std::fprintf(stderr, "valid fixture rejected: %s\n", result.reason.c_str());
    assert(result.status == KitManifestStatus::kVerified);
    assert(result.view && result.view->kit_id == "kit-1" && result.view->template_audio_ps5);
    assert(result.available_variant_ids == std::vector<std::string>{"variant"});
    assert(result.capabilities == std::vector<std::string>({"ps5-audio", "wine-wow64"}));
    assert(result.artifacts.size() >= 2);
    // What the kit was built from is reported, whatever it is.
    assert(result.manifest_sha256 == *HashFile(fixture.root / "manifest.json"));
    assert(result.sources.at("wine").at("revision") == fixture.wine);
    assert(result.sources.at("wrapper").at("revision") == fixture.wrapper);
    assert(result.ignored_capabilities.empty() && !result.source_dirty);
  }
  {
    // A kit built from uncommitted changes, with a capability this build doesn't know.
    Fixture fixture;
    fixture.trust.known_capabilities = {"wine-wow64"};
    fixture.RefreshInnerManifests(true); fixture.RewriteManifest();
    const auto result = fixture.Verify();
    assert(result.status == KitManifestStatus::kVerified && result.source_dirty);
    assert(result.capabilities == std::vector<std::string>{"wine-wow64"});
    assert(result.ignored_capabilities == std::vector<std::string>{"ps5-audio"});
  }
  {
    // TypeName is descriptive: a real Wine registration selects this provider
    // independently for each view. The Base provider is also legitimate.
    Fixture fixture;
    const auto path = fixture.root / "template/bottle/system.reg";
    std::ifstream input(path);
    std::string registry(std::istreambuf_iterator<char>(input), {});
    const std::string enhanced = "Microsoft Enhanced Cryptographic Provider v1.0";
    const std::string base = "Microsoft Base Cryptographic Provider v1.0";
    for (unsigned i = 0; i < 2; ++i) {
      const auto pos = registry.find(enhanced);
      assert(pos != std::string::npos);
      registry.replace(pos, enhanced.size(), base);
    }
    Write(path, registry); fixture.RewriteManifest();
    assert(fixture.Verify().status == KitManifestStatus::kVerified);
  }
  {
    // An unregistered selected provider must not fall back to an unrelated
    // rsaenh registration that happens to be present elsewhere in the file.
    Fixture fixture;
    const auto path = fixture.root / "template/bottle/system.reg";
    std::ifstream input(path);
    std::string registry(std::istreambuf_iterator<char>(input), {});
    const auto pos = registry.find("Microsoft Enhanced Cryptographic Provider v1.0");
    assert(pos != std::string::npos);
    registry.replace(pos, std::string("Microsoft Enhanced Cryptographic Provider v1.0").size(),
                     "Absent Provider");
    Write(path, registry); fixture.RewriteManifest();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    Fixture fixture;
    const auto path = fixture.root / "template/bottle/system.reg";
    std::ifstream input(path);
    std::string registry(std::istreambuf_iterator<char>(input), {});
    const auto pos = registry.find("\"Name\"=");
    assert(pos != std::string::npos);
    registry.insert(pos, "\"Name\"=\"Ambiguous Provider\"\n");
    Write(path, registry); fixture.RewriteManifest();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    Fixture fixture;
    Write(fixture.root / "template/bottle/user.reg",
          "[Software\\\\Wine\\\\Drivers]\n\"Audio\"=\"ps5\"\n"
          "[Volatile Environment]\n\"USERNAME\"=\"other\"\n\"USERPROFILE\"=\"C:\\\\users\\\\other\"\n"
          "; expected prospero C:\\\\users\\\\prospero\n");
    fixture.RewriteManifest();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    // The kit says whether its template has PS5 audio even when its own recipe does not ask for it,
    // so Playden can check the other recipes it ships.
    Fixture fixture;
    Write(fixture.root / "recipes/steam-220-hl2-v1.json", "{\"id\":\"steam-220-hl2-v1\",\"version\":\"1\"}");
    fixture.RewriteManifest();
    auto result = fixture.Verify();
    assert(result.status == KitManifestStatus::kVerified && result.view->template_audio_ps5);
    Write(fixture.root / "template/bottle/user.reg",
          "[Volatile Environment]\n\"USERNAME\"=\"prospero\"\n\"USERPROFILE\"=\"C:\\\\users\\\\prospero\"\n");
    fixture.RewriteManifest();
    result = fixture.Verify();
    assert(result.status == KitManifestStatus::kVerified && !result.view->template_audio_ps5);
  }
  {
    Fixture fixture; Write(fixture.root / "unexpected.bin", "extra");
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    Fixture fixture;
    Write(fixture.root / "runtime/wine-wow64/artifact-e16/lib/wine/i386-windows/ntdll.dll", Pe(true));
    fixture.RewriteRuntimeInventory(); fixture.RewriteManifest();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    // A helper that differs from its own helper manifest is refused; a rebuilt one is used.
    Fixture fixture;
    Write(fixture.root / "titles/variant/lapy.elf", "other helper", 0755);
    fixture.RewriteManifest();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
    fixture.RefreshInnerManifests(); fixture.RewriteManifest();
    assert(fixture.Verify().status == KitManifestStatus::kVerified);
  }
  {
    // Any console firmware is admitted; the kit's list is only what it was tested on.
    Fixture fixture; fixture.RewriteManifest("99.99");
    assert(fixture.Verify().status == KitManifestStatus::kVerified);
  }
  {
    Fixture fixture; fixture.RewriteManifest("12.02", "../escape");
    CheckRejected(fixture.Verify(), KitManifestStatus::kMalformed);
  }
  {
    Fixture fixture;
    fs::create_symlink("recipes/steam-220-hl2-v1.json", fixture.root / "alias");
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    Fixture fixture; fixture.WriteRegistry(false); fixture.RewriteManifest();
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
#if PLAYDEN_TEST_KIT_ADMISSION
  {
    Fixture fixture;
    // Admission must bind real SHA-256 rather than trusting caller callbacks.
    fixture.trust.hash_file = [](const fs::path&) -> std::optional<std::string> {
      return std::nullopt;
    };
    fixture.trust.hash_bytes = [](std::string_view) -> std::optional<std::string> {
      return std::string(64, '0');
    };
    assert(fixture.Verify().status == KitManifestStatus::kVerified);
    Write(fixture.root / "titles/variant/eboot.bin", "changed", 0755);
    CheckRejected(fixture.Verify(), KitManifestStatus::kIntegrityFailure);
  }
  {
    Fixture fixture;
    // Kit files are not hashed at admission: the manifest's hashes name the version, so a
    // same-size edit without a new manifest is admitted as the version the manifest names.
    Write(fixture.root / "titles/variant/eboot.bin", "other", 0755);
    assert(fixture.Verify().status == KitManifestStatus::kVerified);
  }
  {
    Fixture fixture;
    const auto ancestor = fixture.root.parent_path() / (fixture.root.filename().string() + "-alias");
    fs::create_directory_symlink(fixture.root.parent_path(), ancestor);
    const auto result = VerifyInstalledKit(ancestor / fixture.root.filename(), fixture.trust);
    fs::remove(ancestor);
    CheckRejected(result, KitManifestStatus::kIntegrityFailure);
  }
#endif
  std::puts("runtime_kit_manifest_test: all assertions passed");
}