deadbyte-mcp 0.8.7

package/native/deadbyte-exec.cpp

@@ -0,0 +1,966 @@
+#define WIN32_LEAN_AND_MEAN
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <aclapi.h>
+#include <sddl.h>
+#include <userenv.h>
+#include <bcrypt.h>
+
+#include <algorithm>
+#include <cwctype>
+#include <cstdio>
+#include <cstdint>
+#include <filesystem>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#pragma comment(lib, "userenv.lib")
+#pragma comment(lib, "advapi32.lib")
+#pragma comment(lib, "Ole32.lib")
+#pragma comment(lib, "bcrypt.lib")
+#pragma comment(lib, "Ws2_32.lib")
+
+namespace fs = std::filesystem;
+
+
+class SocketHandle {
+ public:
+  SocketHandle() = default;
+  explicit SocketHandle(SOCKET s) : s_(s) {}
+  ~SocketHandle() { reset(); }
+  SocketHandle(const SocketHandle&) = delete;
+  SocketHandle& operator=(const SocketHandle&) = delete;
+  SocketHandle(SocketHandle&& other) noexcept : s_(other.release()) {}
+  SocketHandle& operator=(SocketHandle&& other) noexcept {
+    if (this != &other) reset(other.release());
+    return *this;
+  }
+  SOCKET get() const { return s_; }
+  explicit operator bool() const { return s_ != INVALID_SOCKET; }
+  SOCKET release() { SOCKET out = s_; s_ = INVALID_SOCKET; return out; }
+  void reset(SOCKET next = INVALID_SOCKET) {
+    if (s_ != INVALID_SOCKET) closesocket(s_);
+    s_ = next;
+  }
+ private:
+  SOCKET s_ = INVALID_SOCKET;
+};
+
+class WinsockSession {
+ public:
+  WinsockSession() {
+    WSADATA data{};
+    const int error = WSAStartup(MAKEWORD(2, 2), &data);
+    if (error != 0) {
+      std::ostringstream os;
+      os << "WSAStartup failed with Winsock error " << error;
+      throw std::runtime_error(os.str());
+    }
+    started_ = true;
+  }
+  ~WinsockSession() { if (started_) WSACleanup(); }
+  WinsockSession(const WinsockSession&) = delete;
+  WinsockSession& operator=(const WinsockSession&) = delete;
+ private:
+  bool started_ = false;
+};
+
+struct LoopbackCanary {
+  SocketHandle listener;
+  unsigned short port = 0;
+  bool host_control_ok = false;
+};
+
+static std::runtime_error WsaError(const char* what, int error = WSAGetLastError()) {
+  std::ostringstream os;
+  os << what << " failed with Winsock error " << error;
+  return std::runtime_error(os.str());
+}
+
+static LoopbackCanary CreateLoopbackCanary() {
+  LoopbackCanary out{};
+  out.listener.reset(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+  if (!out.listener) throw WsaError("socket(loopback listener)");
+
+  BOOL exclusive = TRUE;
+  if (setsockopt(out.listener.get(), SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
+                 reinterpret_cast<const char*>(&exclusive), sizeof(exclusive)) == SOCKET_ERROR) {
+    throw WsaError("setsockopt(SO_EXCLUSIVEADDRUSE)");
+  }
+
+  sockaddr_in bindAddress{};
+  bindAddress.sin_family = AF_INET;
+  bindAddress.sin_port = htons(0);
+  bindAddress.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  if (bind(out.listener.get(), reinterpret_cast<const sockaddr*>(&bindAddress), sizeof(bindAddress)) == SOCKET_ERROR) {
+    throw WsaError("bind(loopback listener)");
+  }
+  if (listen(out.listener.get(), 2) == SOCKET_ERROR) throw WsaError("listen(loopback listener)");
+
+  sockaddr_in resolved{};
+  int resolvedBytes = sizeof(resolved);
+  if (getsockname(out.listener.get(), reinterpret_cast<sockaddr*>(&resolved), &resolvedBytes) == SOCKET_ERROR) {
+    throw WsaError("getsockname(loopback listener)");
+  }
+  out.port = ntohs(resolved.sin_port);
+  if (out.port == 0) throw std::runtime_error("loopback listener resolved invalid port");
+
+  SocketHandle control(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+  if (!control) throw WsaError("socket(loopback positive control)");
+  sockaddr_in target{};
+  target.sin_family = AF_INET;
+  target.sin_port = htons(out.port);
+  target.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  if (connect(control.get(), reinterpret_cast<const sockaddr*>(&target), sizeof(target)) == SOCKET_ERROR) {
+    throw WsaError("connect(loopback positive control)");
+  }
+  SocketHandle accepted(accept(out.listener.get(), nullptr, nullptr));
+  if (!accepted) throw WsaError("accept(loopback positive control)");
+  out.host_control_ok = true;
+  return out;
+}
+
+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_; }
+  explicit operator bool() const { return h_ && h_ != INVALID_HANDLE_VALUE; }
+  HANDLE release() { HANDLE out = h_; h_ = nullptr; return out; }
+  void reset(HANDLE next = nullptr) {
+    if (h_ && h_ != INVALID_HANDLE_VALUE) CloseHandle(h_);
+    h_ = next;
+  }
+ private:
+  HANDLE h_ = nullptr;
+};
+
+static std::runtime_error WinError(const char* what, DWORD error = GetLastError()) {
+  std::ostringstream os;
+  os << what << " failed with Win32 error " << error;
+  return std::runtime_error(os.str());
+}
+
+static std::runtime_error HrError(const char* what, HRESULT hr) {
+  std::ostringstream os;
+  os << what << " failed with HRESULT 0x" << std::hex << static_cast<unsigned long>(hr);
+  return std::runtime_error(os.str());
+}
+
+static std::wstring Quote(const std::wstring& value) {
+  return L"\"" + value + L"\"";
+}
+
+static std::string EscapeJson(const std::string& value) {
+  std::string out;
+  out.reserve(value.size() + 16);
+  for (unsigned char c : value) {
+    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>(c));
+          out += tmp;
+        } else {
+          out.push_back(static_cast<char>(c));
+        }
+    }
+  }
+  return out;
+}
+
+static std::string NarrowAscii(const std::wstring& value) {
+  std::string out;
+  out.reserve(value.size());
+  for (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 bool IsLowerHex64(const std::wstring& value) {
+  if (value.size() != 64) return false;
+  for (wchar_t c : value) {
+    if (!((c >= L'0' && c <= L'9') || (c >= L'a' && c <= L'f'))) return false;
+  }
+  return true;
+}
+
+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::wstring CurrentUserSidString() {
+  HANDLE rawToken = nullptr;
+  if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &rawToken)) throw WinError("OpenProcessToken");
+  Handle token(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 WriteTextNew(const std::wstring& path, const char* bytes, DWORD length) {
+  Handle h(CreateFileW(path.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, nullptr));
+  if (!h) throw WinError("CreateFileW(write)");
+  DWORD written = 0;
+  if (!WriteFile(h.get(), bytes, length, &written, nullptr) || written != length) throw WinError("WriteFile");
+}
+
+static void WriteBytesNew(const std::wstring& path, const std::vector<unsigned char>& bytes) {
+  Handle h(CreateFileW(path.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, nullptr));
+  if (!h) throw WinError("CreateFileW(input)");
+  DWORD written = 0;
+  if (!bytes.empty() && (!WriteFile(h.get(), bytes.data(), static_cast<DWORD>(bytes.size()), &written, nullptr) || written != static_cast<DWORD>(bytes.size()))) {
+    throw WinError("WriteFile(input)");
+  }
+}
+
+static std::vector<unsigned char> ReadFileBounded(const std::wstring& path, size_t limit) {
+  Handle h(CreateFileW(path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
+  if (!h) throw WinError("CreateFileW(read)");
+  LARGE_INTEGER size{};
+  if (!GetFileSizeEx(h.get(), &size) || size.QuadPart < 0 || static_cast<unsigned long long>(size.QuadPart) > limit) {
+    throw std::runtime_error("sandbox file exceeds limit");
+  }
+  std::vector<unsigned char> out(static_cast<size_t>(size.QuadPart));
+  DWORD read = 0;
+  if (!out.empty() && (!ReadFile(h.get(), out.data(), static_cast<DWORD>(out.size()), &read, nullptr) || read != static_cast<DWORD>(out.size()))) {
+    throw WinError("ReadFile");
+  }
+  return out;
+}
+
+static std::string ReadTextBounded(const std::wstring& path, size_t limit) {
+  const std::vector<unsigned char> bytes = ReadFileBounded(path, limit);
+  return std::string(bytes.begin(), bytes.end());
+}
+
+static std::vector<unsigned char> ReadStdinBounded(size_t limit) {
+  std::vector<unsigned char> out;
+  out.reserve(64 * 1024);
+  HANDLE input = GetStdHandle(STD_INPUT_HANDLE);
+  if (!input || input == INVALID_HANDLE_VALUE) throw WinError("GetStdHandle(stdin)");
+  unsigned char buffer[8192] = {};
+  for (;;) {
+    DWORD read = 0;
+    if (!ReadFile(input, buffer, sizeof(buffer), &read, nullptr)) {
+      const DWORD error = GetLastError();
+      if (error == ERROR_BROKEN_PIPE) break;
+      throw WinError("ReadFile(stdin)", error);
+    }
+    if (read == 0) break;
+    if (out.size() + read > limit) throw std::runtime_error("stdin import exceeds 1 MiB limit");
+    out.insert(out.end(), buffer, buffer + read);
+  }
+  return out;
+}
+
+static std::string Base64Encode(const std::vector<unsigned char>& bytes) {
+  static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  std::string out;
+  out.reserve(((bytes.size() + 2) / 3) * 4);
+  size_t i = 0;
+  while (i + 3 <= bytes.size()) {
+    const uint32_t n = (static_cast<uint32_t>(bytes[i]) << 16) |
+                       (static_cast<uint32_t>(bytes[i + 1]) << 8) |
+                       static_cast<uint32_t>(bytes[i + 2]);
+    out.push_back(table[(n >> 18) & 63]);
+    out.push_back(table[(n >> 12) & 63]);
+    out.push_back(table[(n >> 6) & 63]);
+    out.push_back(table[n & 63]);
+    i += 3;
+  }
+  if (i < bytes.size()) {
+    uint32_t n = static_cast<uint32_t>(bytes[i]) << 16;
+    out.push_back(table[(n >> 18) & 63]);
+    if (i + 1 < bytes.size()) {
+      n |= static_cast<uint32_t>(bytes[i + 1]) << 8;
+      out.push_back(table[(n >> 12) & 63]);
+      out.push_back(table[(n >> 6) & 63]);
+      out.push_back('=');
+    } else {
+      out.push_back(table[(n >> 12) & 63]);
+      out.push_back('=');
+      out.push_back('=');
+    }
+  }
+  return out;
+}
+
+static std::wstring TempPathWithPrefix(const wchar_t* prefix) {
+  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[160] = {};
+  swprintf_s(name, L"%s-%lu-%llu.txt", prefix,
+             static_cast<unsigned long>(GetCurrentProcessId()),
+             static_cast<unsigned long long>(GetTickCount64()));
+  return (fs::path(temp) / name).wstring();
+}
+
+static void WriteHostCanary(const std::wstring& path) {
+  static const char secret[] = "HOST-ONLY-CANARY\n";
+  WriteTextNew(path, secret, static_cast<DWORD>(sizeof(secret) - 1));
+  ProtectCanaryForUserOnly(path);
+}
+
+static void WriteAapCanary(const std::wstring& path) {
+  static const char marker[] = "ALL-APPLICATION-PACKAGES-CANARY\n";
+  WriteTextNew(path, marker, static_cast<DWORD>(sizeof(marker) - 1));
+  ProtectCanaryForUserAndAllAppPackages(path);
+}
+
+static std::wstring ProfileName() {
+  wchar_t name[80] = {};
+  swprintf_s(name, L"Deadbyte.Mcp.V06.%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.5",
+                                         L"Contained execution profile", 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 std::runtime_error BcryptError(const char* what, NTSTATUS status) {
+  std::ostringstream os;
+  os << what << " failed with NTSTATUS 0x" << std::hex << static_cast<unsigned long>(status);
+  return std::runtime_error(os.str());
+}
+
+static std::string HexLower(const std::vector<unsigned char>& bytes) {
+  static const char digits[] = "0123456789abcdef";
+  std::string out;
+  out.reserve(bytes.size() * 2);
+  for (unsigned char b : bytes) {
+    out.push_back(digits[(b >> 4) & 0x0f]);
+    out.push_back(digits[b & 0x0f]);
+  }
+  return out;
+}
+
+static std::string Sha256FileHex(const std::wstring& path) {
+  BCRYPT_ALG_HANDLE algorithm = nullptr;
+  BCRYPT_HASH_HANDLE hash = nullptr;
+  NTSTATUS status = BCryptOpenAlgorithmProvider(&algorithm, BCRYPT_SHA256_ALGORITHM, nullptr, 0);
+  if (status < 0) throw BcryptError("BCryptOpenAlgorithmProvider", status);
+  auto closeAlgorithm = [&]() {
+    if (hash) { BCryptDestroyHash(hash); hash = nullptr; }
+    if (algorithm) { BCryptCloseAlgorithmProvider(algorithm, 0); algorithm = nullptr; }
+  };
+
+  try {
+    DWORD objectBytes = 0;
+    DWORD copied = 0;
+    status = BCryptGetProperty(algorithm, BCRYPT_OBJECT_LENGTH,
+                               reinterpret_cast<PUCHAR>(&objectBytes), sizeof(objectBytes), &copied, 0);
+    if (status < 0 || copied != sizeof(objectBytes) || objectBytes == 0) throw BcryptError("BCryptGetProperty(object length)", status);
+    DWORD digestBytes = 0;
+    copied = 0;
+    status = BCryptGetProperty(algorithm, BCRYPT_HASH_LENGTH,
+                               reinterpret_cast<PUCHAR>(&digestBytes), sizeof(digestBytes), &copied, 0);
+    if (status < 0 || copied != sizeof(digestBytes) || digestBytes != 32) throw BcryptError("BCryptGetProperty(hash length)", status);
+
+    std::vector<unsigned char> object(objectBytes);
+    std::vector<unsigned char> digest(digestBytes);
+    status = BCryptCreateHash(algorithm, &hash, object.data(), static_cast<ULONG>(object.size()), nullptr, 0, 0);
+    if (status < 0) throw BcryptError("BCryptCreateHash", status);
+
+    Handle file(CreateFileW(path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
+                            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, nullptr));
+    if (!file) throw WinError("CreateFileW(worker registry hash)");
+    std::vector<unsigned char> buffer(64 * 1024);
+    for (;;) {
+      DWORD read = 0;
+      if (!ReadFile(file.get(), buffer.data(), static_cast<DWORD>(buffer.size()), &read, nullptr)) {
+        throw WinError("ReadFile(worker registry hash)");
+      }
+      if (read == 0) break;
+      status = BCryptHashData(hash, buffer.data(), read, 0);
+      if (status < 0) throw BcryptError("BCryptHashData", status);
+    }
+    status = BCryptFinishHash(hash, digest.data(), static_cast<ULONG>(digest.size()), 0);
+    if (status < 0) throw BcryptError("BCryptFinishHash", status);
+    const std::string out = HexLower(digest);
+    closeAlgorithm();
+    return out;
+  } catch (...) {
+    closeAlgorithm();
+    throw;
+  }
+}
+
+static std::string Sha256BytesHex(const std::vector<unsigned char>& bytes) {
+  BCRYPT_ALG_HANDLE algorithm = nullptr;
+  BCRYPT_HASH_HANDLE hash = nullptr;
+  NTSTATUS status = BCryptOpenAlgorithmProvider(&algorithm, BCRYPT_SHA256_ALGORITHM, nullptr, 0);
+  if (status < 0) throw BcryptError("BCryptOpenAlgorithmProvider(bytes)", status);
+  auto closeAlgorithm = [&]() {
+    if (hash) { BCryptDestroyHash(hash); hash = nullptr; }
+    if (algorithm) { BCryptCloseAlgorithmProvider(algorithm, 0); algorithm = nullptr; }
+  };
+  try {
+    DWORD objectBytes = 0, digestBytes = 0, copied = 0;
+    status = BCryptGetProperty(algorithm, BCRYPT_OBJECT_LENGTH, reinterpret_cast<PUCHAR>(&objectBytes), sizeof(objectBytes), &copied, 0);
+    if (status < 0 || objectBytes == 0) throw BcryptError("BCryptGetProperty(bytes object)", status);
+    status = BCryptGetProperty(algorithm, BCRYPT_HASH_LENGTH, reinterpret_cast<PUCHAR>(&digestBytes), sizeof(digestBytes), &copied, 0);
+    if (status < 0 || digestBytes != 32) throw BcryptError("BCryptGetProperty(bytes hash)", status);
+    std::vector<unsigned char> object(objectBytes), digest(digestBytes);
+    status = BCryptCreateHash(algorithm, &hash, object.data(), static_cast<ULONG>(object.size()), nullptr, 0, 0);
+    if (status < 0) throw BcryptError("BCryptCreateHash(bytes)", status);
+    if (!bytes.empty()) {
+      status = BCryptHashData(hash, const_cast<PUCHAR>(bytes.data()), static_cast<ULONG>(bytes.size()), 0);
+      if (status < 0) throw BcryptError("BCryptHashData(bytes)", status);
+    }
+    status = BCryptFinishHash(hash, digest.data(), static_cast<ULONG>(digest.size()), 0);
+    if (status < 0) throw BcryptError("BCryptFinishHash(bytes)", status);
+    const std::string out = HexLower(digest);
+    closeAlgorithm();
+    return out;
+  } catch (...) { closeAlgorithm(); throw; }
+}
+
+static std::unordered_map<std::string, std::string> ParseWorkerRegistryManifest(const std::wstring& path) {
+  const std::string text = ReadTextBounded(path, 64ull * 1024ull);
+  std::unordered_map<std::string, std::string> values;
+  std::istringstream lines(text);
+  std::string line;
+  while (std::getline(lines, line)) {
+    if (!line.empty() && line.back() == '\r') line.pop_back();
+    if (line.empty()) continue;
+    const size_t equals = line.find('=');
+    if (equals == std::string::npos || equals == 0 || equals + 1 >= line.size()) {
+      throw std::runtime_error("worker registry manifest malformed line");
+    }
+    const std::string key = line.substr(0, equals);
+    const std::string value = line.substr(equals + 1);
+    if (!values.emplace(key, value).second) throw std::runtime_error("worker registry manifest duplicate key");
+  }
+  if (values.size() != 12) throw std::runtime_error("worker registry manifest key count mismatch");
+  return values;
+}
+
+static const std::string& ManifestValue(const std::unordered_map<std::string, std::string>& values,
+                                        const std::string& key) {
+  const auto it = values.find(key);
+  if (it == values.end()) throw std::runtime_error("worker registry manifest missing key: " + key);
+  return it->second;
+}
+
+struct RegistryEvidence {
+  std::string manifest_sha256;
+  std::string selected_worker_sha256;
+};
+
+struct WorkerSpec {
+  const wchar_t* worker_id;
+  const wchar_t* executable;
+};
+
+static std::string InvocationRequestSha256(const std::wstring& challenge,
+                                           const std::wstring& operation,
+                                           const std::string& inputSha256,
+                                           const RegistryEvidence& registryEvidence,
+                                           const WorkerSpec& workerSpec) {
+  const std::string body =
+      std::string("{\"challenge\":\"") + NarrowAscii(challenge) +
+      "\",\"input_sha256\":\"" + inputSha256 +
+      "\",\"operation\":\"" + NarrowAscii(operation) +
+      "\",\"schema\":\"deadbyte.invocation.v1\",\"worker_id\":\"" + NarrowAscii(workerSpec.worker_id) +
+      "\",\"worker_manifest_sha256\":\"" + registryEvidence.manifest_sha256 +
+      "\",\"worker_source_sha256\":\"" + registryEvidence.selected_worker_sha256 + "\"}";
+  return Sha256BytesHex(std::vector<unsigned char>(body.begin(), body.end()));
+}
+
+static bool ResolveWorkerSpec(const std::wstring& operation, WorkerSpec* spec) {
+  if (operation == L"uppercase_ascii" || operation == L"lowercase_ascii") {
+    spec->worker_id = L"contained-transform-v1";
+    spec->executable = L"contained-transform-worker.exe";
+    return true;
+  }
+  if (operation == L"reverse_bytes") {
+    spec->worker_id = L"contained-reverse-v1";
+    spec->executable = L"contained-reverse-worker.exe";
+    return true;
+  }
+  return false;
+}
+
+
+static RegistryEvidence VerifyWorkerRegistryManifest(const fs::path& binDir,
+                                                       const std::wstring& operation,
+                                                       const WorkerSpec& selected) {
+  const fs::path manifestPath = binDir / L"WORKER-REGISTRY.txt";
+  const auto values = ParseWorkerRegistryManifest(manifestPath.wstring());
+  auto require = [&](const std::string& key, const std::string& expected) {
+    if (ManifestValue(values, key) != expected) throw std::runtime_error("worker registry manifest mismatch: " + key);
+  };
+  require("schema", "deadbyte.worker-registry.v1");
+  require("version", "0.6.0");
+  require("policy", "compile-time-operation-to-executable");
+  require("launcher.executable", "deadbyte-exec.exe");
+  require("operation.uppercase_ascii", "contained-transform-v1");
+  require("operation.lowercase_ascii", "contained-transform-v1");
+  require("operation.reverse_bytes", "contained-reverse-v1");
+  require("worker.contained-transform-v1.executable", "contained-transform-worker.exe");
+  require("worker.contained-reverse-v1.executable", "contained-reverse-worker.exe");
+
+  const fs::path launcherPath = binDir / L"deadbyte-exec.exe";
+  const fs::path transformPath = binDir / L"contained-transform-worker.exe";
+  const fs::path reversePath = binDir / L"contained-reverse-worker.exe";
+  require("launcher.sha256", Sha256FileHex(launcherPath.wstring()));
+  require("worker.contained-transform-v1.sha256", Sha256FileHex(transformPath.wstring()));
+  require("worker.contained-reverse-v1.sha256", Sha256FileHex(reversePath.wstring()));
+
+  const std::string operationKey = "operation." + NarrowAscii(operation);
+  require(operationKey, NarrowAscii(selected.worker_id));
+  const std::string workerPrefix = "worker." + NarrowAscii(selected.worker_id);
+  require(workerPrefix + ".executable", NarrowAscii(selected.executable));
+
+  RegistryEvidence evidence{};
+  evidence.manifest_sha256 = Sha256FileHex(manifestPath.wstring());
+  evidence.selected_worker_sha256 = ManifestValue(values, workerPrefix + ".sha256");
+  return evidence;
+}
+
+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)");
+  }
+}
+
+int wmain(int argc, wchar_t** argv) {
+  if (argc != 7 || wcscmp(argv[1], L"--operation") != 0 ||
+      wcscmp(argv[3], L"--challenge") != 0 || wcscmp(argv[5], L"--request-digest") != 0) {
+    std::fprintf(stderr, "deadbyte-exec: invalid fixed argument contract\n");
+    return 64;
+  }
+  const std::wstring operation = argv[2];
+  const std::wstring invocationChallenge = argv[4];
+  const std::wstring invocationRequestSha256 = argv[6];
+  if (!IsLowerHex64(invocationChallenge) || !IsLowerHex64(invocationRequestSha256)) {
+    std::fprintf(stderr, "deadbyte-exec: invalid invocation challenge/request digest\n");
+    return 64;
+  }
+  WorkerSpec workerSpec{};
+  if (!ResolveWorkerSpec(operation, &workerSpec)) {
+    std::fprintf(stderr, "deadbyte-exec: unsupported --operation\n");
+    return 64;
+  }
+  wchar_t selfPath[MAX_PATH + 1] = {};
+  const DWORD selfChars = GetModuleFileNameW(nullptr, selfPath, MAX_PATH);
+  if (selfChars == 0 || selfChars >= MAX_PATH) {
+    std::fprintf(stderr, "deadbyte-exec: GetModuleFileNameW failed\n");
+    return 65;
+  }
+  const fs::path binDir = fs::path(selfPath).parent_path();
+  const std::wstring sourceWorker = (binDir / workerSpec.executable).wstring();
+  const RegistryEvidence registryEvidence = VerifyWorkerRegistryManifest(binDir, operation, workerSpec);
+
+  const std::wstring profileName = ProfileName();
+  const std::wstring hostCanary = TempPathWithPrefix(L"deadbyte-v06-host-canary");
+  const std::wstring aapCanary = TempPathWithPrefix(L"deadbyte-v06-aap-canary");
+  PSID appSid = nullptr;
+  bool profileCreated = false;
+  bool cleanupOk = false;
+
+  try {
+    const std::vector<unsigned char> imported = ReadStdinBounded(1024ull * 1024ull);
+    const std::string importedSha256 = Sha256BytesHex(imported);
+    const std::string recomputedInvocation = InvocationRequestSha256(
+        invocationChallenge, operation, importedSha256, registryEvidence, workerSpec);
+    if (recomputedInvocation != NarrowAscii(invocationRequestSha256)) {
+      throw std::runtime_error("invocation request digest mismatch before worker launch");
+    }
+    WriteHostCanary(hostCanary);
+    WriteAapCanary(aapCanary);
+    WinsockSession winsock;
+    LoopbackCanary networkCanary = CreateLoopbackCanary();
+    if (!networkCanary.host_control_ok) throw std::runtime_error("loopback network positive control failed");
+
+    appSid = CreateEphemeralProfile(profileName);
+    profileCreated = true;
+    const std::wstring sidText = SidString(appSid);
+    const fs::path runDir = fs::path(AppContainerFolder(appSid)) / L"deadbyte-v06-exec";
+    fs::create_directories(runDir);
+
+    const fs::path workerCopy = runDir / workerSpec.executable;
+    const fs::path inputPath = runDir / L"import.bin";
+    const fs::path outputPath = runDir / L"export.bin";
+    const fs::path evidencePath = runDir / L"execution-proof.json";
+    fs::remove(workerCopy);
+    fs::remove(inputPath);
+    fs::remove(outputPath);
+    fs::remove(evidencePath);
+
+    if (!CopyFileW(sourceWorker.c_str(), workerCopy.c_str(), TRUE)) throw WinError("CopyFileW(worker)");
+    if (Sha256FileHex(workerCopy.wstring()) != registryEvidence.selected_worker_sha256) {
+      throw std::runtime_error("copied worker hash does not match verified worker registry manifest");
+    }
+    WriteBytesNew(inputPath.wstring(), imported);
+
+    Handle job(CreateJobObjectW(nullptr, nullptr));
+    if (!job) throw WinError("CreateJobObjectW");
+    SetJobLimits(job.get());
+
+    SIZE_T attrBytes = 0;
+    constexpr DWORD kAttributeCount = 2;
+    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;
+    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);
+    }
+
+    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);
+    }
+
+    STARTUPINFOEXW si{};
+    si.StartupInfo.cb = sizeof(si);
+    si.lpAttributeList = attrs;
+    PROCESS_INFORMATION pi{};
+
+    std::wstring command = Quote(workerCopy.wstring()) +
+                           L" --operation " + operation +
+                           L" --challenge " + invocationChallenge +
+                           L" --request-digest " + invocationRequestSha256 +
+                           L" --input " + Quote(inputPath.wstring()) +
+                           L" --output " + Quote(outputPath.wstring()) +
+                           L" --evidence " + Quote(evidencePath.wstring()) +
+                           L" --outside " + Quote(hostCanary) +
+                           L" --aap-canary " + Quote(aapCanary) +
+                           L" --network-probe-port " + std::to_wstring(networkCanary.port);
+    std::vector<wchar_t> mutableCommand(command.begin(), command.end());
+    mutableCommand.push_back(L'\0');
+
+    // AppContainer process creation needs a small amount of user environment
+    // bootstrap state.  In particular Microsoft documents LOCALAPPDATA as the
+    // root from which the AppContainer profile is exposed, and Chromium's
+    // Windows sandbox keeps LOCALAPPDATA when filtering target environments.
+    // Copy only this fixed bootstrap allowlist from the trusted host process;
+    // never pass arbitrary process.env values to the contained worker.
+    static constexpr const wchar_t* kEnvironmentAllowlist[] = {
+        L"Path", L"SystemDrive", L"SystemRoot", L"TEMP", L"TMP", L"LOCALAPPDATA"};
+
+    LPWCH rawHostEnvironment = GetEnvironmentStringsW();
+    if (!rawHostEnvironment) {
+      const DWORD e = GetLastError();
+      freeAttrs();
+      throw WinError("GetEnvironmentStringsW(contained worker)", e);
+    }
+
+    std::vector<std::wstring> environmentEntries;
+    bool localAppDataPresent = false;
+    for (const wchar_t* entry = rawHostEnvironment; *entry != L'\0'; entry += wcslen(entry) + 1) {
+      for (const wchar_t* allowedName : kEnvironmentAllowlist) {
+        const size_t nameChars = wcslen(allowedName);
+        if (_wcsnicmp(entry, allowedName, nameChars) == 0 && entry[nameChars] == L'=') {
+          environmentEntries.emplace_back(entry);
+          if (_wcsicmp(allowedName, L"LOCALAPPDATA") == 0) localAppDataPresent = true;
+          break;
+        }
+      }
+    }
+    FreeEnvironmentStringsW(rawHostEnvironment);
+    rawHostEnvironment = nullptr;
+
+    if (!localAppDataPresent) {
+      freeAttrs();
+      throw std::runtime_error("contained worker bootstrap environment missing LOCALAPPDATA");
+    }
+
+    const std::wstring runDirText = runDir.wstring();
+    if (runDirText.size() < 3 || runDirText[1] != L':' ||
+        !((runDirText[0] >= L'A' && runDirText[0] <= L'Z') ||
+          (runDirText[0] >= L'a' && runDirText[0] <= L'z'))) {
+      freeAttrs();
+      throw std::runtime_error("contained worker current directory is not a drive-qualified path");
+    }
+    const wchar_t driveLetter = static_cast<wchar_t>(towupper(runDirText[0]));
+    const std::wstring drivePrefix = std::wstring(L"=") + driveLetter + L":=";
+    environmentEntries.push_back(drivePrefix + runDirText);
+    std::sort(environmentEntries.begin(), environmentEntries.end(),
+              [](const std::wstring& a, const std::wstring& b) {
+                return _wcsicmp(a.c_str(), b.c_str()) < 0;
+              });
+
+    std::vector<wchar_t> workerEnvironment;
+    size_t environmentChars = 1;
+    for (const auto& entry : environmentEntries) environmentChars += entry.size() + 1;
+    workerEnvironment.reserve(environmentChars);
+    for (const auto& entry : environmentEntries) {
+      workerEnvironment.insert(workerEnvironment.end(), entry.begin(), entry.end());
+      workerEnvironment.push_back(L'\0');
+    }
+    workerEnvironment.push_back(L'\0');
+
+    const DWORD creationFlags = EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT | CREATE_NO_WINDOW;
+    const BOOL created = CreateProcessW(workerCopy.c_str(), mutableCommand.data(), nullptr, nullptr, FALSE,
+                                        creationFlags, workerEnvironment.data(), runDir.c_str(), &si.StartupInfo, &pi);
+    const DWORD createError = created ? ERROR_SUCCESS : GetLastError();
+    freeAttrs();
+    if (!created) throw WinError("CreateProcessW(contained worker)", createError);
+
+    Handle process(pi.hProcess);
+    Handle thread(pi.hThread);
+    bool timedOut = false;
+    const 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();
+
+    std::string proof = "{}";
+    if (fs::exists(evidencePath)) proof = ReadTextBounded(evidencePath.wstring(), 64ull * 1024ull);
+    if (!proof.empty() && proof.back() == '\n') proof.pop_back();
+    const std::vector<unsigned char> exported = fs::exists(outputPath)
+        ? ReadFileBounded(outputPath.wstring(), 1024ull * 1024ull)
+        : std::vector<unsigned char>{};
+
+    const HRESULT cleanupHr = DeleteAppContainerProfile(profileName.c_str());
+    cleanupOk = SUCCEEDED(cleanupHr);
+    profileCreated = false;
+    DeleteFileW(hostCanary.c_str());
+    DeleteFileW(aapCanary.c_str());
+    if (appSid) { FreeSid(appSid); appSid = nullptr; }
+
+    const bool pass = !timedOut && exitCode == 0 && proof != "{}";
+    const std::string encoded = Base64Encode(exported);
+    std::printf(
+        "{\"status\":\"%s\",\"backend\":\"windows-appcontainer\",\"mode\":\"appcontainer\","
+        "\"operation\":\"%s\",\"invocation_schema\":\"deadbyte.invocation.v1\","
+        "\"invocation_challenge\":\"%s\",\"invocation_request_sha256\":\"%s\","
+        "\"worker_registry\":\"compile-time-operation-to-executable\","
+        "\"worker_id\":\"%s\",\"worker_executable\":\"%s\","
+        "\"worker_manifest\":\"WORKER-REGISTRY.txt\",\"worker_manifest_sha256\":\"%s\","
+        "\"worker_manifest_verified\":true,\"worker_source_sha256\":\"%s\",\"appcontainer_sid\":\"%s\","
+        "\"network_capabilities\":0,\"network_policy\":\"zero-capabilities-plus-active-loopback-denial\","
+        "\"network_probe_schema\":\"deadbyte.network.loopback.v1\",\"network_probe_target\":\"127.0.0.1\","
+        "\"network_probe_port\":%u,\"network_probe_host_control_ok\":true,"
+        "\"job_assignment\":\"atomic-attribute\","
+        "\"job_breakaway_enabled\":false,\"job_ui_restrictions\":true,"
+        "\"active_process_limit\":1,\"process_memory_limit_bytes\":134217728,"
+        "\"child_control\":\"job-active-process-limit\",\"child_process_policy\":\"not-used\","
+        "\"import_transport\":\"host-stdin-to-profile-copy\","
+        "\"export_transport\":\"profile-copy-to-host-json\",\"workspace_mounted\":false,"
+        "\"worker_environment\":\"appcontainer-bootstrap-allowlist-plus-drive-cwd\","
+        "\"worker_localappdata_present\":true,"
+        "\"worker_environment_allowlist_exact\":true,"
+        "\"worker_drive_current_directory_set\":true,"
+        "\"timed_out\":%s,\"child_exit_code\":%lu,\"profile_cleanup_ok\":%s,"
+        "\"input_bytes\":%llu,\"output_bytes\":%llu,\"output_base64\":\"%s\",\"proof\":%s}\n",
+        pass ? "passed" : "failed",
+        EscapeJson(NarrowAscii(operation)).c_str(),
+        NarrowAscii(invocationChallenge).c_str(),
+        NarrowAscii(invocationRequestSha256).c_str(),
+        EscapeJson(NarrowAscii(workerSpec.worker_id)).c_str(),
+        EscapeJson(NarrowAscii(workerSpec.executable)).c_str(),
+        registryEvidence.manifest_sha256.c_str(),
+        registryEvidence.selected_worker_sha256.c_str(),
+        EscapeJson(NarrowAscii(sidText)).c_str(),
+        static_cast<unsigned>(networkCanary.port),
+        timedOut ? "true" : "false",
+        static_cast<unsigned long>(exitCode),
+        cleanupOk ? "true" : "false",
+        static_cast<unsigned long long>(imported.size()),
+        static_cast<unsigned long long>(exported.size()),
+        encoded.c_str(),
+        proof.c_str());
+    return pass ? 0 : 2;
+  } catch (const std::exception& e) {
+    if (profileCreated) DeleteAppContainerProfile(profileName.c_str());
+    DeleteFileW(hostCanary.c_str());
+    DeleteFileW(aapCanary.c_str());
+    if (appSid) FreeSid(appSid);
+    std::fprintf(stderr, "deadbyte-exec: %s\n", e.what());
+    return 1;
+  }
+}