deadbyte-mcp 0.8.7

package/native/deadbyte-contain.cpp

@@ -0,0 +1,625 @@
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <userenv.h>
+#include <sddl.h>
+#include <aclapi.h>
+
+#include <cstdio>
+#include <cstdint>
+#include <filesystem>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#pragma comment(lib, "userenv.lib")
+#pragma comment(lib, "advapi32.lib")
+
+#ifndef PROCESS_CREATION_ALL_APPLICATION_PACKAGES_OPT_OUT
+#define PROCESS_CREATION_ALL_APPLICATION_PACKAGES_OPT_OUT 0x01
+#endif
+
+namespace fs = std::filesystem;
+
+enum class ContainerMode {
+  Lpac,
+  AppContainer,
+};
+
+static const char* BackendName(ContainerMode mode) {
+  return mode == ContainerMode::Lpac ? "windows-lpac" : "windows-appcontainer";
+}
+
+static bool IsLpacMode(ContainerMode mode) {
+  return mode == ContainerMode::Lpac;
+}
+
+class Handle {
+ public:
+  Handle() = default;
+  explicit Handle(HANDLE h) : h_(h) {}
+  ~Handle() { reset(); }
+  Handle(const Handle&) = delete;
+  Handle& operator=(const Handle&) = delete;
+  Handle(Handle&& other) noexcept : h_(other.release()) {}
+  Handle& operator=(Handle&& other) noexcept {
+    if (this != &other) reset(other.release());
+    return *this;
+  }
+  HANDLE get() const { return h_; }
+  HANDLE release() {
+    HANDLE h = h_;
+    h_ = nullptr;
+    return h;
+  }
+  void reset(HANDLE h = nullptr) {
+    if (h_ && h_ != INVALID_HANDLE_VALUE) CloseHandle(h_);
+    h_ = h;
+  }
+  explicit operator bool() const { return h_ && h_ != INVALID_HANDLE_VALUE; }
+
+ private:
+  HANDLE h_ = nullptr;
+};
+
+static std::runtime_error WinError(const char* what, DWORD code = GetLastError()) {
+  std::ostringstream os;
+  os << what << " failed win32=" << code;
+  return std::runtime_error(os.str());
+}
+
+static std::runtime_error HrError(const char* what, HRESULT hr) {
+  std::ostringstream os;
+  os << what << " failed hresult=0x" << std::hex << static_cast<unsigned long>(hr);
+  return std::runtime_error(os.str());
+}
+
+static std::wstring SidString(PSID sid) {
+  LPWSTR raw = nullptr;
+  if (!ConvertSidToStringSidW(sid, &raw)) throw WinError("ConvertSidToStringSidW");
+  std::wstring out(raw);
+  LocalFree(raw);
+  return out;
+}
+
+static std::string NarrowAscii(const std::wstring& value) {
+  std::string out;
+  out.reserve(value.size());
+  for (const wchar_t c : value) {
+    if (c < 0 || c > 0x7f) {
+      throw std::runtime_error("non-ASCII value cannot be narrowed safely");
+    }
+    out.push_back(static_cast<char>(c));
+  }
+  return out;
+}
+
+static std::wstring CurrentUserSidString() {
+  Handle token;
+  HANDLE rawToken = nullptr;
+  if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &rawToken)) {
+    throw WinError("OpenProcessToken");
+  }
+  token.reset(rawToken);
+
+  DWORD bytes = 0;
+  GetTokenInformation(token.get(), TokenUser, nullptr, 0, &bytes);
+  if (GetLastError() != ERROR_INSUFFICIENT_BUFFER || bytes == 0) {
+    throw WinError("GetTokenInformation(size)");
+  }
+  std::vector<unsigned char> buffer(bytes);
+  if (!GetTokenInformation(token.get(), TokenUser, buffer.data(), bytes, &bytes)) {
+    throw WinError("GetTokenInformation(TokenUser)");
+  }
+  const TOKEN_USER* user = reinterpret_cast<const TOKEN_USER*>(buffer.data());
+  return SidString(user->User.Sid);
+}
+
+static void ProtectCanaryForUserOnly(const std::wstring& path) {
+  const std::wstring userSidText = CurrentUserSidString();
+  PSID userSid = nullptr;
+  if (!ConvertStringSidToSidW(userSidText.c_str(), &userSid)) {
+    throw WinError("ConvertStringSidToSidW(user)");
+  }
+
+  BYTE systemBuffer[SECURITY_MAX_SID_SIZE] = {};
+  DWORD systemBytes = sizeof(systemBuffer);
+  if (!CreateWellKnownSid(WinLocalSystemSid, nullptr, systemBuffer, &systemBytes)) {
+    LocalFree(userSid);
+    throw WinError("CreateWellKnownSid(LocalSystem)");
+  }
+
+  EXPLICIT_ACCESSW entries[2] = {};
+  for (auto& entry : entries) {
+    entry.grfAccessPermissions = GENERIC_ALL;
+    entry.grfAccessMode = GRANT_ACCESS;
+    entry.grfInheritance = NO_INHERITANCE;
+    entry.Trustee.TrusteeForm = TRUSTEE_IS_SID;
+    entry.Trustee.TrusteeType = TRUSTEE_IS_USER;
+  }
+  entries[0].Trustee.ptstrName = static_cast<LPWSTR>(userSid);
+  entries[1].Trustee.ptstrName = reinterpret_cast<LPWSTR>(systemBuffer);
+
+  PACL acl = nullptr;
+  const DWORD aclStatus = SetEntriesInAclW(2, entries, nullptr, &acl);
+  if (aclStatus != ERROR_SUCCESS) {
+    LocalFree(userSid);
+    throw WinError("SetEntriesInAclW", aclStatus);
+  }
+
+  const DWORD secStatus = SetNamedSecurityInfoW(
+      const_cast<LPWSTR>(path.c_str()), SE_FILE_OBJECT,
+      DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION,
+      nullptr, nullptr, acl, nullptr);
+
+  LocalFree(acl);
+  LocalFree(userSid);
+  if (secStatus != ERROR_SUCCESS) throw WinError("SetNamedSecurityInfoW", secStatus);
+}
+
+static void ProtectCanaryForUserAndAllAppPackages(const std::wstring& path) {
+  const std::wstring userSidText = CurrentUserSidString();
+  PSID userSid = nullptr;
+  PSID appPackagesSid = nullptr;
+  if (!ConvertStringSidToSidW(userSidText.c_str(), &userSid)) {
+    throw WinError("ConvertStringSidToSidW(user)");
+  }
+  if (!ConvertStringSidToSidW(L"S-1-15-2-1", &appPackagesSid)) {
+    LocalFree(userSid);
+    throw WinError("ConvertStringSidToSidW(ALL_APPLICATION_PACKAGES)");
+  }
+
+  BYTE systemBuffer[SECURITY_MAX_SID_SIZE] = {};
+  DWORD systemBytes = sizeof(systemBuffer);
+  if (!CreateWellKnownSid(WinLocalSystemSid, nullptr, systemBuffer, &systemBytes)) {
+    LocalFree(appPackagesSid);
+    LocalFree(userSid);
+    throw WinError("CreateWellKnownSid(LocalSystem)");
+  }
+
+  EXPLICIT_ACCESSW entries[3] = {};
+  for (auto& entry : entries) {
+    entry.grfAccessMode = GRANT_ACCESS;
+    entry.grfInheritance = NO_INHERITANCE;
+    entry.Trustee.TrusteeForm = TRUSTEE_IS_SID;
+  }
+
+  entries[0].grfAccessPermissions = GENERIC_ALL;
+  entries[0].Trustee.TrusteeType = TRUSTEE_IS_USER;
+  entries[0].Trustee.ptstrName = static_cast<LPWSTR>(userSid);
+
+  entries[1].grfAccessPermissions = GENERIC_ALL;
+  entries[1].Trustee.TrusteeType = TRUSTEE_IS_USER;
+  entries[1].Trustee.ptstrName = reinterpret_cast<LPWSTR>(systemBuffer);
+
+  entries[2].grfAccessPermissions = GENERIC_READ;
+  entries[2].Trustee.TrusteeType = TRUSTEE_IS_GROUP;
+  entries[2].Trustee.ptstrName = static_cast<LPWSTR>(appPackagesSid);
+
+  PACL acl = nullptr;
+  const DWORD aclStatus = SetEntriesInAclW(3, entries, nullptr, &acl);
+  if (aclStatus != ERROR_SUCCESS) {
+    LocalFree(appPackagesSid);
+    LocalFree(userSid);
+    throw WinError("SetEntriesInAclW(AAP)", aclStatus);
+  }
+
+  const DWORD secStatus = SetNamedSecurityInfoW(
+      const_cast<LPWSTR>(path.c_str()), SE_FILE_OBJECT,
+      DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION,
+      nullptr, nullptr, acl, nullptr);
+
+  LocalFree(acl);
+  LocalFree(appPackagesSid);
+  LocalFree(userSid);
+  if (secStatus != ERROR_SUCCESS) {
+    throw WinError("SetNamedSecurityInfoW(AAP)", secStatus);
+  }
+}
+
+static void WriteCanary(const std::wstring& path) {
+  Handle h(CreateFileW(path.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_NEW,
+                       FILE_ATTRIBUTE_NORMAL, nullptr));
+  if (!h) throw WinError("CreateFileW(canary)");
+  static const char secret[] = "HOST-ONLY-CANARY\n";
+  DWORD written = 0;
+  if (!WriteFile(h.get(), secret, static_cast<DWORD>(sizeof(secret) - 1), &written, nullptr) ||
+      written != sizeof(secret) - 1) {
+    throw WinError("WriteFile(canary)");
+  }
+  h.reset();
+  ProtectCanaryForUserOnly(path);
+}
+
+static void WriteAapCanary(const std::wstring& path) {
+  Handle h(CreateFileW(path.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_NEW,
+                       FILE_ATTRIBUTE_NORMAL, nullptr));
+  if (!h) throw WinError("CreateFileW(AAP canary)");
+  static const char marker[] = "ALL-APPLICATION-PACKAGES-CANARY\n";
+  DWORD written = 0;
+  if (!WriteFile(h.get(), marker, static_cast<DWORD>(sizeof(marker) - 1), &written, nullptr) ||
+      written != sizeof(marker) - 1) {
+    throw WinError("WriteFile(AAP canary)");
+  }
+  h.reset();
+  ProtectCanaryForUserAndAllAppPackages(path);
+}
+
+static std::string ReadPipeBounded(HANDLE pipe) {
+  constexpr size_t kMaxResultBytes = 64ull * 1024ull;
+  std::string out;
+  char buffer[4096] = {};
+  for (;;) {
+    DWORD read = 0;
+    const BOOL ok = ReadFile(pipe, buffer, static_cast<DWORD>(sizeof(buffer)), &read, nullptr);
+    if (ok && read != 0) {
+      if (out.size() + read > kMaxResultBytes) {
+        throw std::runtime_error("containment result exceeds 64 KiB");
+      }
+      out.append(buffer, buffer + read);
+      continue;
+    }
+    if (ok && read == 0) break;
+    const DWORD error = GetLastError();
+    if (error == ERROR_BROKEN_PIPE) break;
+    throw WinError("ReadFile(result pipe)", error);
+  }
+  return out;
+}
+
+
+static const char* ChildExitName(DWORD code) {
+  switch (code) {
+    case 0xC0000142u: return "STATUS_DLL_INIT_FAILED";
+    case 0xC0000135u: return "STATUS_DLL_NOT_FOUND";
+    case 0xC0000005u: return "STATUS_ACCESS_VIOLATION";
+    default: return "UNKNOWN";
+  }
+}
+
+static std::wstring Quote(const std::wstring& value) {
+  return L"\"" + value + L"\"";
+}
+
+static std::wstring TempCanaryPath() {
+  wchar_t temp[MAX_PATH + 1] = {};
+  const DWORD n = GetTempPathW(MAX_PATH, temp);
+  if (n == 0 || n >= MAX_PATH) throw WinError("GetTempPathW");
+  wchar_t name[128] = {};
+  swprintf_s(name, L"deadbyte-host-canary-%lu-%llu.txt",
+             static_cast<unsigned long>(GetCurrentProcessId()),
+             static_cast<unsigned long long>(GetTickCount64()));
+  return (fs::path(temp) / name).wstring();
+}
+
+static std::wstring TempAapCanaryPath() {
+  wchar_t temp[MAX_PATH + 1] = {};
+  const DWORD n = GetTempPathW(MAX_PATH, temp);
+  if (n == 0 || n >= MAX_PATH) throw WinError("GetTempPathW");
+  wchar_t name[128] = {};
+  swprintf_s(name, L"deadbyte-aap-canary-%lu-%llu.txt",
+             static_cast<unsigned long>(GetCurrentProcessId()),
+             static_cast<unsigned long long>(GetTickCount64()));
+  return (fs::path(temp) / name).wstring();
+}
+
+static std::wstring ProfileName() {
+  wchar_t name[64] = {};
+  swprintf_s(name, L"Deadbyte.Mcp.V03.%lu.%llu",
+             static_cast<unsigned long>(GetCurrentProcessId()),
+             static_cast<unsigned long long>(GetTickCount64() & 0xFFFFFFu));
+  return name;
+}
+
+static PSID CreateEphemeralProfile(const std::wstring& name) {
+  PSID sid = nullptr;
+  HRESULT hr = CreateAppContainerProfile(name.c_str(), L"DEADBYTE MCP V0.3",
+                                         L"Ephemeral LPAC containment proof",
+                                         nullptr, 0, &sid);
+  if (hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS)) {
+    hr = DeriveAppContainerSidFromAppContainerName(name.c_str(), &sid);
+  }
+  if (FAILED(hr) || !sid) throw HrError("CreateAppContainerProfile", hr);
+  return sid;
+}
+
+static std::wstring AppContainerFolder(PSID sid) {
+  const std::wstring sidText = SidString(sid);
+  PWSTR raw = nullptr;
+  const HRESULT hr = GetAppContainerFolderPath(sidText.c_str(), &raw);
+  if (FAILED(hr) || !raw) throw HrError("GetAppContainerFolderPath", hr);
+  std::wstring out(raw);
+  CoTaskMemFree(raw);
+  return out;
+}
+
+static void SetJobLimits(HANDLE job) {
+  JOBOBJECT_EXTENDED_LIMIT_INFORMATION info{};
+  info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE |
+                                          JOB_OBJECT_LIMIT_ACTIVE_PROCESS |
+                                          JOB_OBJECT_LIMIT_PROCESS_MEMORY;
+  info.BasicLimitInformation.ActiveProcessLimit = 1;
+  info.ProcessMemoryLimit = 128ull * 1024ull * 1024ull;
+  if (!SetInformationJobObject(job, JobObjectExtendedLimitInformation, &info, sizeof(info))) {
+    throw WinError("SetInformationJobObject(extended)");
+  }
+
+  JOBOBJECT_BASIC_UI_RESTRICTIONS ui{};
+  ui.UIRestrictionsClass = JOB_OBJECT_UILIMIT_DESKTOP |
+                           JOB_OBJECT_UILIMIT_DISPLAYSETTINGS |
+                           JOB_OBJECT_UILIMIT_EXITWINDOWS |
+                           JOB_OBJECT_UILIMIT_GLOBALATOMS |
+                           JOB_OBJECT_UILIMIT_HANDLES |
+                           JOB_OBJECT_UILIMIT_READCLIPBOARD |
+                           JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS |
+                           JOB_OBJECT_UILIMIT_WRITECLIPBOARD;
+  if (!SetInformationJobObject(job, JobObjectBasicUIRestrictions, &ui, sizeof(ui))) {
+    throw WinError("SetInformationJobObject(ui)");
+  }
+}
+
+static std::string EscapeJson(const std::string& s) {
+  std::string out;
+  out.reserve(s.size() + 16);
+  for (unsigned char c : s) {
+    switch (c) {
+      case '\\': out += "\\\\"; break;
+      case '"': out += "\\\""; break;
+      case '\n': out += "\\n"; break;
+      case '\r': out += "\\r"; break;
+      case '\t': out += "\\t"; break;
+      default:
+        if (c < 0x20) {
+          char tmp[7] = {};
+          std::snprintf(tmp, sizeof(tmp), "\\u%04x", static_cast<unsigned int>(c));
+          out += tmp;
+        } else {
+          out.push_back(static_cast<char>(c));
+        }
+    }
+  }
+  return out;
+}
+
+int wmain(int argc, wchar_t** argv) {
+  ContainerMode mode = ContainerMode::Lpac;
+  const wchar_t* probeArg = nullptr;
+
+  if (argc == 2) {
+    probeArg = argv[1];
+  } else if (argc == 4 && wcscmp(argv[1], L"--mode") == 0) {
+    if (wcscmp(argv[2], L"lpac") == 0) {
+      mode = ContainerMode::Lpac;
+    } else if (wcscmp(argv[2], L"appcontainer") == 0) {
+      mode = ContainerMode::AppContainer;
+    } else {
+      std::fprintf(stderr, "deadbyte-contain: unknown mode\n");
+      return 64;
+    }
+    probeArg = argv[3];
+  } else {
+    std::fprintf(stderr,
+                 "usage: deadbyte-contain.exe [--mode lpac|appcontainer] "
+                 "<containment-probe.exe>\n");
+    return 64;
+  }
+
+  const bool lpacMode = IsLpacMode(mode);
+  const std::wstring sourceProbe = fs::absolute(probeArg).wstring();
+  const std::wstring profileName = ProfileName();
+  const std::wstring canaryPath = TempCanaryPath();
+  const std::wstring aapCanaryPath = TempAapCanaryPath();
+  PSID appSid = nullptr;
+  bool profileCreated = false;
+  bool cleanupOk = true;
+
+  try {
+    if (!fs::is_regular_file(fs::path(sourceProbe))) {
+      throw std::runtime_error("probe executable does not exist");
+    }
+
+    WriteCanary(canaryPath);
+    WriteAapCanary(aapCanaryPath);
+    appSid = CreateEphemeralProfile(profileName);
+    profileCreated = true;
+    const std::wstring sidText = SidString(appSid);
+    const std::wstring profileFolder = AppContainerFolder(appSid);
+    const fs::path runDir = fs::path(profileFolder) / L"deadbyte-v03";
+    fs::create_directories(runDir);
+
+    const fs::path probeCopy = runDir / L"containment-probe.exe";
+    const fs::path insidePath = runDir / L"inside-write.txt";
+    fs::remove(probeCopy);
+    fs::remove(insidePath);
+    if (!CopyFileW(sourceProbe.c_str(), probeCopy.c_str(), FALSE)) {
+      throw WinError("CopyFileW(probe)");
+    }
+
+    SECURITY_ATTRIBUTES pipeSa{};
+    pipeSa.nLength = sizeof(pipeSa);
+    pipeSa.bInheritHandle = TRUE;
+    HANDLE rawRead = nullptr;
+    HANDLE rawWrite = nullptr;
+    if (!CreatePipe(&rawRead, &rawWrite, &pipeSa, 0)) {
+      throw WinError("CreatePipe(result)");
+    }
+    Handle resultRead(rawRead);
+    Handle resultWrite(rawWrite);
+    if (!SetHandleInformation(resultRead.get(), HANDLE_FLAG_INHERIT, 0)) {
+      throw WinError("SetHandleInformation(result read)");
+    }
+
+    Handle job(CreateJobObjectW(nullptr, nullptr));
+    if (!job) throw WinError("CreateJobObjectW");
+    SetJobLimits(job.get());
+
+    SIZE_T attrBytes = 0;
+    const DWORD kAttributeCount = lpacMode ? 4u : 3u;
+    InitializeProcThreadAttributeList(nullptr, kAttributeCount, 0, &attrBytes);
+    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER || attrBytes == 0) {
+      throw WinError("InitializeProcThreadAttributeList(size)");
+    }
+    auto* attrs = reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(
+        HeapAlloc(GetProcessHeap(), 0, attrBytes));
+    if (!attrs) throw std::runtime_error("HeapAlloc(attribute list) failed");
+
+    auto freeAttrs = [&]() {
+      if (attrs) {
+        DeleteProcThreadAttributeList(attrs);
+        HeapFree(GetProcessHeap(), 0, attrs);
+        attrs = nullptr;
+      }
+    };
+
+    if (!InitializeProcThreadAttributeList(attrs, kAttributeCount, 0, &attrBytes)) {
+      const DWORD e = GetLastError();
+      freeAttrs();
+      throw WinError("InitializeProcThreadAttributeList", e);
+    }
+
+    SECURITY_CAPABILITIES caps{};
+    caps.AppContainerSid = appSid;
+    caps.Capabilities = nullptr;
+    caps.CapabilityCount = 0;
+    caps.Reserved = 0;
+    if (!UpdateProcThreadAttribute(attrs, 0, PROC_THREAD_ATTRIBUTE_SECURITY_CAPABILITIES,
+                                   &caps, sizeof(caps), nullptr, nullptr)) {
+      const DWORD e = GetLastError();
+      freeAttrs();
+      throw WinError("UpdateProcThreadAttribute(security capabilities)", e);
+    }
+
+    if (lpacMode) {
+      DWORD allPackagesPolicy = PROCESS_CREATION_ALL_APPLICATION_PACKAGES_OPT_OUT;
+      if (!UpdateProcThreadAttribute(attrs, 0,
+                                     PROC_THREAD_ATTRIBUTE_ALL_APPLICATION_PACKAGES_POLICY,
+                                     &allPackagesPolicy, sizeof(allPackagesPolicy), nullptr, nullptr)) {
+        const DWORD e = GetLastError();
+        freeAttrs();
+        throw WinError("UpdateProcThreadAttribute(LPAC)", e);
+      }
+    }
+
+    // V0.3.11 target evidence showed the token-level child-process policy
+    // kills this AppContainer before entrypoint execution (0xC0000142), even
+    // without suspended creation. Child control is therefore enforced by the
+    // atomic Job assignment below, with ACTIVE_PROCESS_LIMIT=1 and no breakaway.
+    HANDLE jobList[] = {job.get()};
+    if (!UpdateProcThreadAttribute(attrs, 0, PROC_THREAD_ATTRIBUTE_JOB_LIST,
+                                   jobList, sizeof(jobList), nullptr, nullptr)) {
+      const DWORD e = GetLastError();
+      freeAttrs();
+      throw WinError("UpdateProcThreadAttribute(job list)", e);
+    }
+
+    HANDLE inheritedHandles[] = {resultWrite.get()};
+    if (!UpdateProcThreadAttribute(attrs, 0, PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
+                                   inheritedHandles, sizeof(inheritedHandles), nullptr, nullptr)) {
+      const DWORD e = GetLastError();
+      freeAttrs();
+      throw WinError("UpdateProcThreadAttribute(handle list)", e);
+    }
+
+    STARTUPINFOEXW si{};
+    si.StartupInfo.cb = sizeof(si);
+    si.lpAttributeList = attrs;
+    PROCESS_INFORMATION pi{};
+
+    std::wstring command = Quote(probeCopy.wstring()) +
+                           L" --outside " + Quote(canaryPath) +
+                           L" --aap-canary " + Quote(aapCanaryPath) +
+                           L" --inside " + Quote(insidePath.wstring()) +
+                           L" --result-handle " +
+                           std::to_wstring(reinterpret_cast<uintptr_t>(resultWrite.get())) +
+                           L" --expect-lpac " + (lpacMode ? L"1" : L"0");
+    std::vector<wchar_t> mutableCommand(command.begin(), command.end());
+    mutableCommand.push_back(L'\0');
+
+    const DWORD creationFlags = EXTENDED_STARTUPINFO_PRESENT |
+                                CREATE_UNICODE_ENVIRONMENT | CREATE_NO_WINDOW;
+    const BOOL created = CreateProcessW(nullptr, mutableCommand.data(), nullptr, nullptr,
+                                        TRUE, creationFlags, nullptr, runDir.c_str(),
+                                        &si.StartupInfo, &pi);
+    const DWORD createError = created ? ERROR_SUCCESS : GetLastError();
+    freeAttrs();
+    if (!created) throw WinError("CreateProcessW(AppContainer)", createError);
+    resultWrite.reset();
+
+    Handle process(pi.hProcess);
+    Handle thread(pi.hThread);
+
+    bool timedOut = false;
+    DWORD wait = WaitForSingleObject(process.get(), 10000);
+    if (wait == WAIT_TIMEOUT) {
+      timedOut = true;
+      TerminateJobObject(job.get(), 92);
+      WaitForSingleObject(process.get(), 3000);
+    } else if (wait != WAIT_OBJECT_0) {
+      throw WinError("WaitForSingleObject");
+    }
+
+    DWORD exitCode = 0xFFFFFFFFu;
+    if (!GetExitCodeProcess(process.get(), &exitCode)) throw WinError("GetExitCodeProcess");
+    process.reset();
+    thread.reset();
+    job.reset();
+
+    const std::string childJson = ReadPipeBounded(resultRead.get());
+    resultRead.reset();
+    if (childJson.empty()) {
+      std::ostringstream os;
+      os << "AppContainer probe produced no result over inherited pipe; child_exit=" << exitCode
+         << " child_exit_hex=0x" << std::hex << exitCode
+         << " child_exit_name=" << ChildExitName(exitCode);
+      throw std::runtime_error(os.str());
+    }
+    if (childJson.front() != '{') {
+      std::ostringstream os;
+      os << "AppContainer probe result is not JSON; child_exit=" << exitCode;
+      throw std::runtime_error(os.str());
+    }
+
+    if (profileCreated) {
+      const HRESULT cleanupHr = DeleteAppContainerProfile(profileName.c_str());
+      cleanupOk = SUCCEEDED(cleanupHr);
+      profileCreated = false;
+    }
+    DeleteFileW(canaryPath.c_str());
+    DeleteFileW(aapCanaryPath.c_str());
+    if (appSid) {
+      FreeSid(appSid);
+      appSid = nullptr;
+    }
+
+    const bool launcherPass = !timedOut && exitCode == 0;
+    std::printf(
+        "{\"status\":\"%s\",\"backend\":\"%s\",\"mode\":\"%s\","
+        "\"appcontainer_sid\":\"%s\",\"job_assigned\":true,"
+        "\"job_assignment\":\"atomic-attribute\",\"active_process_limit\":1,"
+        "\"job_breakaway_enabled\":false,\"job_ui_restrictions\":true,"
+        "\"process_memory_limit_bytes\":134217728,"
+        "\"child_control\":\"job-active-process-limit\","
+        "\"child_process_policy\":\"not-used\",\"network_capabilities\":0,"
+        "\"result_channel\":\"inherited-handle\","
+        "\"timed_out\":%s,\"child_exit_code\":%lu,\"profile_cleanup_ok\":%s,"
+        "\"probe\":%s}\n",
+        launcherPass ? "passed" : "failed",
+        BackendName(mode),
+        lpacMode ? "lpac" : "appcontainer",
+        EscapeJson(NarrowAscii(sidText)).c_str(),
+        timedOut ? "true" : "false",
+        static_cast<unsigned long>(exitCode),
+        cleanupOk ? "true" : "false",
+        childJson.c_str());
+    return launcherPass ? 0 : 2;
+  } catch (const std::exception& e) {
+    if (profileCreated) {
+      DeleteAppContainerProfile(profileName.c_str());
+    }
+    DeleteFileW(canaryPath.c_str());
+    DeleteFileW(aapCanaryPath.c_str());
+    if (appSid) FreeSid(appSid);
+    std::fprintf(stderr, "deadbyte-contain: %s\n", e.what());
+    return 1;
+  }
+}