deadbyte-mcp 0.15.72 → 0.15.75

package/native/deadbyte-desktop-uia-r199.cpp

@@ -0,0 +1,345 @@
+#include <windows.h>
+#include <UIAutomation.h>
+#include <cstdio>
+#include <cstdint>
+#include <cstdlib>
+#include <cerrno>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <cwctype>
+#include <oleauto.h>
+
+static constexpr size_t kMaxRequest = 8192;
+static constexpr int kMaxVisited = 2048;
+static constexpr int kMaxResultsHard = 16;
+
+struct Match {
+    LONG left{};
+    LONG top{};
+    LONG width{};
+    LONG height{};
+    int controlType{};
+    bool enabled{};
+    bool offscreen{};
+    std::vector<LONG> runtimeId;
+};
+
+struct Request {
+    HWND expectedHwnd{};
+    DWORD expectedPid{};
+    std::string kind;
+    int maxResults{8};
+    std::string queryUtf8;
+};
+
+static void fail(const char* message, int code = 2) {
+    std::fprintf(stderr, "deadbyte-desktop-uia: %s\n", message);
+    std::exit(code);
+}
+
+static bool parseUnsigned(const std::string& text, unsigned long long& out, int base = 10) {
+    if (text.empty()) return false;
+    char* end = nullptr;
+    errno = 0;
+    const auto v = std::strtoull(text.c_str(), &end, base);
+    if (errno != 0 || end == text.c_str() || *end != '\0') return false;
+    out = v;
+    return true;
+}
+
+static std::vector<std::string> readHeaderLines(const std::string& bytes, size_t count, size_t& offset) {
+    std::vector<std::string> lines;
+    offset = 0;
+    for (size_t i = 0; i < count; ++i) {
+        const auto pos = bytes.find('\n', offset);
+        if (pos == std::string::npos) fail("request header truncated");
+        std::string line = bytes.substr(offset, pos - offset);
+        if (!line.empty() && line.back() == '\r') line.pop_back();
+        lines.push_back(line);
+        offset = pos + 1;
+    }
+    return lines;
+}
+
+static std::string field(const std::string& line, const char* key) {
+    const std::string prefix = std::string(key) + "=";
+    if (line.rfind(prefix, 0) != 0) fail("request field order/name invalid");
+    return line.substr(prefix.size());
+}
+
+static Request readRequest() {
+    std::string bytes;
+    bytes.resize(kMaxRequest + 1);
+    const size_t got = std::fread(bytes.data(), 1, bytes.size(), stdin);
+    if (std::ferror(stdin)) fail("stdin read failed");
+    if (got > kMaxRequest) fail("request exceeds bound");
+    bytes.resize(got);
+
+    size_t offset = 0;
+    const auto lines = readHeaderLines(bytes, 6, offset);
+    if (lines[0] != "DEADBYTE_DESKTOP_UIA_V1") fail("request magic invalid");
+
+    Request r;
+    const auto hwndText = field(lines[1], "expected_hwnd");
+    const auto pidText = field(lines[2], "expected_pid");
+    r.kind = field(lines[3], "query_kind");
+    const auto maxText = field(lines[4], "max_results");
+    const auto queryBytesText = field(lines[5], "query_bytes");
+
+    unsigned long long hwndValue = 0, pidValue = 0, maxValue = 0, queryBytes = 0;
+    std::string h = hwndText;
+    if (h.rfind("0x", 0) == 0 || h.rfind("0X", 0) == 0) h = h.substr(2);
+    if (!parseUnsigned(h, hwndValue, 16) || hwndValue == 0) fail("expected_hwnd invalid");
+    if (!parseUnsigned(pidText, pidValue) || pidValue == 0 || pidValue > 0x7fffffffULL) fail("expected_pid invalid");
+    if (!parseUnsigned(maxText, maxValue) || maxValue < 1 || maxValue > kMaxResultsHard) fail("max_results invalid");
+    if (!parseUnsigned(queryBytesText, queryBytes) || queryBytes > 512) fail("query_bytes invalid");
+    if (offset + queryBytes != bytes.size()) fail("query payload length mismatch");
+
+    r.expectedHwnd = reinterpret_cast<HWND>(static_cast<uintptr_t>(hwndValue));
+    r.expectedPid = static_cast<DWORD>(pidValue);
+    r.maxResults = static_cast<int>(maxValue);
+    r.queryUtf8.assign(bytes.data() + offset, static_cast<size_t>(queryBytes));
+
+    const bool needsQuery = r.kind != "root";
+    if (needsQuery && r.queryUtf8.empty()) fail("query required");
+    if (!needsQuery && !r.queryUtf8.empty()) fail("root query must be empty");
+    if (r.kind != "root" && r.kind != "name_exact" && r.kind != "name_contains" &&
+        r.kind != "automation_id_exact" && r.kind != "control_type") fail("query_kind invalid");
+    return r;
+}
+
+static std::wstring utf8ToWide(const std::string& input) {
+    if (input.empty()) return {};
+    const int n = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input.data(),
+        static_cast<int>(input.size()), nullptr, 0);
+    if (n <= 0) fail("query UTF-8 invalid");
+    std::wstring out(static_cast<size_t>(n), L'\0');
+    if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input.data(),
+        static_cast<int>(input.size()), out.data(), n) != n) fail("query UTF-8 conversion failed");
+    return out;
+}
+
+static std::wstring lower(std::wstring s) {
+    std::transform(s.begin(), s.end(), s.begin(), [](wchar_t c) { return static_cast<wchar_t>(std::towlower(c)); });
+    return s;
+}
+
+static int controlTypeFromQuery(const std::string& q) {
+    struct Pair { const char* name; int id; };
+    static const Pair map[] = {
+        {"button", UIA_ButtonControlTypeId}, {"checkbox", UIA_CheckBoxControlTypeId},
+        {"combobox", UIA_ComboBoxControlTypeId}, {"edit", UIA_EditControlTypeId},
+        {"hyperlink", UIA_HyperlinkControlTypeId}, {"list", UIA_ListControlTypeId},
+        {"listitem", UIA_ListItemControlTypeId}, {"menu", UIA_MenuControlTypeId},
+        {"menuitem", UIA_MenuItemControlTypeId}, {"radio", UIA_RadioButtonControlTypeId},
+        {"tab", UIA_TabControlTypeId}, {"tabitem", UIA_TabItemControlTypeId},
+        {"text", UIA_TextControlTypeId}, {"toolbar", UIA_ToolBarControlTypeId},
+        {"tree", UIA_TreeControlTypeId}, {"treeitem", UIA_TreeItemControlTypeId},
+        {"document", UIA_DocumentControlTypeId}, {"window", UIA_WindowControlTypeId},
+        {"pane", UIA_PaneControlTypeId}, {"group", UIA_GroupControlTypeId}
+    };
+    for (const auto& item : map) if (q == item.name) return item.id;
+    return 0;
+}
+
+static bool matches(IUIAutomationElement* e, const Request& r, const std::wstring& queryWide, int queryControlType) {
+    if (r.kind == "root") return true;
+    if (r.kind == "control_type") {
+        CONTROLTYPEID type = 0;
+        return SUCCEEDED(e->get_CurrentControlType(&type)) && type == queryControlType;
+    }
+
+    BSTR raw = nullptr;
+    HRESULT hr = E_FAIL;
+    if (r.kind == "automation_id_exact") hr = e->get_CurrentAutomationId(&raw);
+    else hr = e->get_CurrentName(&raw);
+    if (FAILED(hr) || raw == nullptr) {
+        if (raw) SysFreeString(raw);
+        return false;
+    }
+    std::wstring value(raw, SysStringLen(raw));
+    SysFreeString(raw);
+    value = lower(std::move(value));
+    const auto query = lower(queryWide);
+    if (r.kind == "name_contains") return value.find(query) != std::wstring::npos;
+    return value == query;
+}
+
+// RuntimeId is an ephemeral bounded value, not a long-lived COM reference.
+static bool readRuntimeId(IUIAutomationElement* e, std::vector<LONG>& out) {
+    SAFEARRAY* ids = nullptr;
+    const HRESULT identityStatus = e->GetRuntimeId(&ids);
+    if (FAILED(identityStatus) || !ids) {
+        if (ids) SafeArrayDestroy(ids);
+        return false;
+    }
+    const UINT dims = SafeArrayGetDim(ids);
+    LONG low = 0, high = -1;
+    const bool boundsOk = dims == 1 &&
+        SUCCEEDED(SafeArrayGetLBound(ids, 1, &low)) &&
+        SUCCEEDED(SafeArrayGetUBound(ids, 1, &high));
+    const long long count = boundsOk ? static_cast<long long>(high) -
+        static_cast<long long>(low) + 1 : 0;
+    if (!boundsOk || count < 1 || count > 64) {
+        SafeArrayDestroy(ids); return false;
+    }
+    std::vector<LONG> candidate;
+    candidate.reserve(static_cast<size_t>(count));
+    for (long long j = 0; j < count; ++j) {
+        LONG i = static_cast<LONG>(static_cast<long long>(low) + j);
+        LONG value = 0;
+        if (FAILED(SafeArrayGetElement(ids, &i, &value))) {
+            SafeArrayDestroy(ids); return false;
+        }
+        candidate.push_back(value);
+    }
+    SafeArrayDestroy(ids);
+    out = std::move(candidate);
+    return true;
+}
+static bool captureMatch(IUIAutomationElement* e, Match& out) {
+    RECT rc{};
+    if (FAILED(e->get_CurrentBoundingRectangle(&rc))) return false;
+    if (rc.right <= rc.left || rc.bottom <= rc.top) return false;
+    BOOL offscreen = TRUE, enabled = FALSE;
+    e->get_CurrentIsOffscreen(&offscreen);
+    e->get_CurrentIsEnabled(&enabled);
+    if (offscreen) return false;
+    CONTROLTYPEID type = 0;
+    e->get_CurrentControlType(&type);
+    out.left = rc.left; out.top = rc.top;
+    out.width = rc.right - rc.left; out.height = rc.bottom - rc.top;
+    out.controlType = type; out.enabled = enabled != FALSE; out.offscreen = offscreen != FALSE;
+    return readRuntimeId(e, out.runtimeId);
+}
+
+static void walk(IUIAutomationTreeWalker* walker, IUIAutomationElement* parent, const Request& req,
+    const std::wstring& queryWide, int queryControlType, int depth, int& visited,
+    bool& truncated, std::vector<Match>& matchesOut) {
+    if (depth > 64 || visited >= kMaxVisited || static_cast<int>(matchesOut.size()) >= req.maxResults) return;
+    IUIAutomationElement* child = nullptr;
+    if (FAILED(walker->GetFirstChildElement(parent, &child)) || child == nullptr) return;
+    while (child != nullptr) {
+        ++visited;
+        if (visited >= kMaxVisited) truncated = true;
+        if (matches(child, req, queryWide, queryControlType)) {
+            Match m;
+            if (captureMatch(child, m)) matchesOut.push_back(m);
+        }
+        if (!truncated && static_cast<int>(matchesOut.size()) < req.maxResults) {
+            walk(walker, child, req, queryWide, queryControlType, depth + 1, visited, truncated, matchesOut);
+        }
+        IUIAutomationElement* next = nullptr;
+        walker->GetNextSiblingElement(child, &next);
+        child->Release();
+        child = next;
+        if (truncated || static_cast<int>(matchesOut.size()) >= req.maxResults) {
+            if (child) child->Release();
+            break;
+        }
+    }
+}
+
+static unsigned long long hwndNumber(HWND h) {
+    return static_cast<unsigned long long>(reinterpret_cast<uintptr_t>(h));
+}
+
+static int runSelftest() {
+    if (controlTypeFromQuery("button") != UIA_ButtonControlTypeId) return 2;
+    std::printf("{\"schema\":\"deadbyte.desktop-uia-selftest.v1\",\"status\":\"passed\"}\n");
+    return 0;
+}
+
+int wmain(int argc, wchar_t** argv) {
+    if (argc == 2 && std::wstring(argv[1]) == L"--selftest") return runSelftest();
+    const Request req = readRequest();
+
+    HWND fg = GetForegroundWindow();
+    DWORD pid = 0;
+    if (fg) GetWindowThreadProcessId(fg, &pid);
+    if (fg != req.expectedHwnd || pid != req.expectedPid) fail("foreground window identity changed", 3);
+
+    const HRESULT init = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    if (FAILED(init) && init != RPC_E_CHANGED_MODE) fail("CoInitializeEx failed", 4);
+    const bool uninit = SUCCEEDED(init);
+
+    IUIAutomation* automation = nullptr;
+    HRESULT hr = CoCreateInstance(CLSID_CUIAutomation, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&automation));
+    if (FAILED(hr) || !automation) {
+        if (uninit) CoUninitialize();
+        fail("CUIAutomation creation failed", 5);
+    }
+
+    IUIAutomationElement* root = nullptr;
+    hr = automation->ElementFromHandle(fg, &root);
+    if (FAILED(hr) || !root) {
+        automation->Release(); if (uninit) CoUninitialize();
+        fail("ElementFromHandle failed", 6);
+    }
+
+    std::vector<Match> found;
+    int visited = 0;
+    bool truncated = false;
+    const std::wstring queryWide = utf8ToWide(req.queryUtf8);
+    const int queryControlType = req.kind == "control_type" ? controlTypeFromQuery(req.queryUtf8) : 0;
+    if (req.kind == "control_type" && queryControlType == 0) {
+        root->Release(); automation->Release(); if (uninit) CoUninitialize();
+        fail("unsupported control_type query", 7);
+    }
+
+    if (req.kind == "root") {
+        ++visited;
+        RECT wr{};
+        if (GetWindowRect(fg, &wr)) {
+            const LONG vx = GetSystemMetrics(SM_XVIRTUALSCREEN);
+            const LONG vy = GetSystemMetrics(SM_YVIRTUALSCREEN);
+            const LONG vr = vx + GetSystemMetrics(SM_CXVIRTUALSCREEN);
+            const LONG vb = vy + GetSystemMetrics(SM_CYVIRTUALSCREEN);
+            const LONG left = (std::max)(wr.left, vx);
+            const LONG top = (std::max)(wr.top, vy);
+            const LONG right = (std::min)(wr.right, vr);
+            const LONG bottom = (std::min)(wr.bottom, vb);
+            if (right > left && bottom > top && IsWindowVisible(fg)) {
+                Match m;
+                m.left = left; m.top = top; m.width = right - left; m.height = bottom - top;
+                m.controlType = UIA_WindowControlTypeId;
+                m.enabled = IsWindowEnabled(fg) != FALSE;
+                m.offscreen = false;
+                found.push_back(m);
+            }
+        }
+    } else {
+        IUIAutomationTreeWalker* walker = nullptr;
+        hr = automation->get_ControlViewWalker(&walker);
+        if (FAILED(hr) || !walker) {
+            root->Release(); automation->Release(); if (uninit) CoUninitialize();
+            fail("ControlViewWalker unavailable", 8);
+        }
+        walk(walker, root, req, queryWide, queryControlType, 0, visited, truncated, found);
+        walker->Release();
+    }
+
+    std::printf("{\"schema\":\"deadbyte.desktop-uia-ground.v1\",\"foreground_hwnd\":\"0x%llx\",\"foreground_pid\":%lu,"
+                "\"query_kind\":\"%s\",\"visited\":%d,\"truncated\":%s,\"matches\":[",
+        hwndNumber(fg), static_cast<unsigned long>(pid), req.kind.c_str(), visited, truncated ? "true" : "false");
+    for (size_t i = 0; i < found.size(); ++i) {
+        if (i) std::printf(",");
+        const auto& m = found[i];
+        std::printf("{\"left\":%ld,\"top\":%ld,\"width\":%ld,\"height\":%ld,\"control_type\":%d,"
+                    "\"enabled\":%s,\"offscreen\":%s,\"runtime_id\":[",
+            m.left, m.top, m.width, m.height, m.controlType,
+            m.enabled ? "true" : "false", m.offscreen ? "true" : "false");
+        for (size_t j = 0; j < m.runtimeId.size(); ++j) {
+            if (j) std::printf(",");
+            std::printf("%ld", m.runtimeId[j]);
+        }
+        std::printf("]}");
+    }
+    std::printf("]}\n");
+
+    root->Release();
+    automation->Release();
+    if (uninit) CoUninitialize();
+    return 0;
+}

package/native/deadbyte-fs-read-r197.cpp

@@ -0,0 +1,174 @@
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#include <winternl.h>
+#include <bcrypt.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cwchar>
+#include <string>
+#include <vector>
+#include <algorithm>
+#pragma comment(lib, "bcrypt.lib")
+
+// A Windows-only experimental reader. Kernel resolution is anchored to an
+// already-open directory HANDLE. No reparse component is followed.
+// The caller must supply the independently authorized root and relative path.
+// This file is not a release authorization or production deployment.
+using NtCreateFilePtr=NTSTATUS (NTAPI *)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,
+ PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
+static constexpr ULONG kFileOpen=1, kFileDir=0x1, kFileNotDir=0x40;
+static constexpr ULONG kFileSync=0x20, kFileNoReparse=0x00200000, kObjNoReparse=0x1000;
+static void fail(const char* m,int exitCode=2){
+ std::fprintf(stderr,"R197_NATIVE_REFUSE=%s\n",m);std::exit(exitCode);
+}
+static bool noReparse(HANDLE h){
+ FILE_ATTRIBUTE_TAG_INFO t{};
+ return GetFileInformationByHandleEx(h,FileAttributeTagInfo,&t,sizeof(t)) &&
+   (t.FileAttributes&FILE_ATTRIBUTE_REPARSE_POINT)==0;
+}
+static unsigned long long parseNumber(const wchar_t* input){
+ if(!input||!*input)fail("missing_number");
+ for(const wchar_t* q=input;*q;++q)if(*q<L'0'||*q>L'9')fail("invalid_number");
+ wchar_t* end=nullptr;
+ errno=0;
+ const auto n=std::wcstoull(input,&end,10);
+ if(errno||!end||*end!=L'\0')fail("number_overflow");
+ return n;
+}
+static std::vector<std::wstring> split(const std::wstring& rel){
+ if(rel.empty()||rel.size()>1024||rel[0]==L'\\'||rel[0]==L'/'||rel.find(L':')!=std::wstring::npos)
+  fail("invalid_relative_path");
+ std::vector<std::wstring> result;size_t start=0;
+ for(size_t i=0;i<=rel.size();++i){
+  if(i==rel.size()||rel[i]==L'/'||rel[i]==L'\\'){
+   const auto s=rel.substr(start,i-start);
+   if(s.empty()||s==L"."||s==L".."||s.size()>255||s.back()==L'.'||s.back()==L' '||
+      s.find(L'\0')!=std::wstring::npos)fail("invalid_segment");
+   result.push_back(s);start=i+1;
+  }
+ }
+ if(result.empty()||result.size()>32)fail("segment_budget");
+ return result;
+}
+static std::string base64(const unsigned char* b,size_t n){
+ static constexpr char abc[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ std::string out;out.reserve(((n+2)/3)*4);
+ for(size_t i=0;i<n;i+=3){
+  const unsigned a=b[i],x=i+1<n?b[i+1]:0,y=i+2<n?b[i+2]:0;
+  out.push_back(abc[a>>2]);out.push_back(abc[((a&3)<<4)|(x>>4)]);
+  out.push_back(i+1<n?abc[((x&15)<<2)|(y>>6)]:'=');
+  out.push_back(i+2<n?abc[y&63]:'=');
+ }
+ return out;
+}
+static std::string hex(const unsigned char* b,size_t n){
+ static constexpr char chars[]="0123456789abcdef";
+ std::string out;out.reserve(n*2);
+ for(size_t i=0;i<n;++i){out.push_back(chars[b[i]>>4]);out.push_back(chars[b[i]&15]);}
+ return out;
+}
+static void seek(HANDLE h,unsigned long long pos){
+ LARGE_INTEGER p{};p.QuadPart=static_cast<LONGLONG>(pos);
+ if(!SetFilePointerEx(h,p,nullptr,FILE_BEGIN))fail("seek_failed");
+}
+static std::string hashAll(HANDLE h){
+ BCRYPT_ALG_HANDLE algorithm=nullptr;BCRYPT_HASH_HANDLE hash=nullptr;
+ if(BCryptOpenAlgorithmProvider(&algorithm,BCRYPT_SHA256_ALGORITHM,nullptr,0)<0)fail("hash_alg");
+ if(BCryptCreateHash(algorithm,&hash,nullptr,0,nullptr,0,0)<0)fail("hash_create");
+ seek(h,0);
+ std::vector<unsigned char> buffer(65536);
+ DWORD got=0;
+ for(;;){
+  if(!ReadFile(h,buffer.data(),static_cast<DWORD>(buffer.size()),&got,nullptr))fail("hash_read");
+  if(got==0)break;
+  if(BCryptHashData(hash,buffer.data(),got,0)<0)fail("hash_update");
+ }
+ unsigned char sum[32]{};
+ if(BCryptFinishHash(hash,sum,sizeof(sum),0)<0)fail("hash_finish");
+ BCryptDestroyHash(hash);BCryptCloseAlgorithmProvider(algorithm,0);
+ return hex(sum,sizeof(sum));
+}
+int wmain(int argc,wchar_t** argv){
+ if(argc!=6)fail("usage_root_relative_offset_length_hash");
+ const std::wstring root=argv[1];
+ if(root.size()<4||root.size()>2048||root[1]!=L':'||(root[2]!=L'\\'&&root[2]!=L'/'))
+  fail("root_must_be_absolute_drive_path");
+ const auto names=split(argv[2]);
+ const auto offset=parseNumber(argv[3]),requested=parseNumber(argv[4]);
+ if(requested>4*1024*1024ULL||offset>9007199254740991ULL)fail("range_budget");
+ if(std::wcscmp(argv[5],L"0")!=0&&std::wcscmp(argv[5],L"1")!=0)fail("invalid_hash_mode");
+ const bool wantHash=argv[5][0]==L'1';
+ const HANDLE rootHandle=CreateFileW(root.c_str(),FILE_READ_ATTRIBUTES|FILE_LIST_DIRECTORY|SYNCHRONIZE,
+  FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,nullptr,OPEN_EXISTING,
+  FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_OPEN_REPARSE_POINT,nullptr);
+ if(rootHandle==INVALID_HANDLE_VALUE)fail("open_root");
+ if(!noReparse(rootHandle))fail("root_reparse_or_unverified");
+ FILE_ID_INFO rootId{};if(!GetFileInformationByHandleEx(rootHandle,FileIdInfo,&rootId,sizeof(rootId)))
+  fail("root_identity_unavailable");
+ HMODULE ntdll=GetModuleHandleW(L"ntdll.dll");
+ auto nt=reinterpret_cast<NtCreateFilePtr>(GetProcAddress(ntdll,"NtCreateFile"));
+ if(!nt)fail("ntcreatefile_unavailable");
+ HANDLE parent=rootHandle;std::vector<HANDLE> chain;chain.reserve(names.size());
+ for(size_t i=0;i<names.size();++i){
+  const bool dir=i+1<names.size();
+  UNICODE_STRING name{};name.Buffer=const_cast<PWSTR>(names[i].c_str());
+  name.Length=static_cast<USHORT>(names[i].size()*sizeof(wchar_t));
+  name.MaximumLength=name.Length;
+  OBJECT_ATTRIBUTES oa{};oa.Length=sizeof(oa);oa.RootDirectory=parent;
+  oa.ObjectName=&name;oa.Attributes=OBJ_CASE_INSENSITIVE|kObjNoReparse;
+  IO_STATUS_BLOCK ios{};HANDLE next=nullptr;
+  const ULONG options=kFileSync|kFileNoReparse|(dir?kFileDir:kFileNotDir);
+  const ACCESS_MASK access=FILE_READ_ATTRIBUTES|SYNCHRONIZE|(dir?FILE_LIST_DIRECTORY:FILE_READ_DATA);
+  const NTSTATUS status=nt(&next,access,&oa,&ios,nullptr,FILE_ATTRIBUTE_NORMAL,
+   FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,kFileOpen,options,nullptr,0);
+  if(status<0||!next)fail("nt_open_component_refused",3);
+  chain.push_back(next);
+  if(!noReparse(next))fail("component_reparse_or_unverified",4);
+  FILE_ID_INFO id{};if(!GetFileInformationByHandleEx(next,FileIdInfo,&id,sizeof(id)))
+   fail("component_identity_unavailable",5);
+  parent=next;
+ }
+ const HANDLE leaf=chain.back();
+ FILE_ID_INFO identity{};
+ FILE_BASIC_INFO initialBasic{},finalBasic{};
+ FILE_STANDARD_INFO initialStandard{},finalStandard{};
+ if(!GetFileInformationByHandleEx(leaf,FileIdInfo,&identity,sizeof(identity)) ||
+    !GetFileInformationByHandleEx(leaf,FileBasicInfo,&initialBasic,sizeof(initialBasic)) ||
+    !GetFileInformationByHandleEx(leaf,FileStandardInfo,&initialStandard,sizeof(initialStandard)))
+  fail("file_identity_unavailable");
+ const auto fileSize=initialStandard.EndOfFile.QuadPart;
+ if(fileSize<0||fileSize>9007199254740991LL)fail("file_size_out_of_range");
+ if(offset>static_cast<unsigned long long>(fileSize))fail("offset_exceeds_size");
+ const auto length=static_cast<size_t>(std::min(requested,static_cast<unsigned long long>(fileSize)-offset));
+ std::vector<unsigned char> data(length);
+ seek(leaf,offset);
+ size_t read=0;
+ while(read<length){
+  DWORD got=0;
+  if(!ReadFile(leaf,data.data()+read,static_cast<DWORD>(length-read),&got,nullptr))
+   fail("range_read_failed");
+  if(got==0)fail("unexpected_range_eof");
+  read+=got;
+ }
+ const auto digest=wantHash?hashAll(leaf):std::string();
+ if(!GetFileInformationByHandleEx(leaf,FileBasicInfo,&finalBasic,sizeof(finalBasic))||
+    !GetFileInformationByHandleEx(leaf,FileStandardInfo,&finalStandard,sizeof(finalStandard)))
+  fail("file_postidentity_unavailable");
+ if(initialStandard.EndOfFile.QuadPart!=finalStandard.EndOfFile.QuadPart||
+    initialBasic.LastWriteTime.QuadPart!=finalBasic.LastWriteTime.QuadPart||
+    initialBasic.ChangeTime.QuadPart!=finalBasic.ChangeTime.QuadPart)
+  fail("file_mutated_during_read");
+ unsigned long long nativeId=0;
+ std::memcpy(&nativeId,identity.FileId.Identifier,sizeof(nativeId));
+ const auto encoded=base64(data.data(),data.size());
+ std::printf("{\"schema\":\"deadbyte.machine-fs-read-worker.v1\",\"bytes_read\":%llu,\"data_base64\":\"%s\",\"file_sha256\":",
+  static_cast<unsigned long long>(read),encoded.c_str());
+ if(wantHash)std::printf("\"%s\"",digest.c_str());else std::printf("null");
+ std::printf(",\"file_size\":%llu,\"file_dev\":\"%llu\",\"file_ino\":\"%llu\"}",
+   static_cast<unsigned long long>(fileSize),
+   static_cast<unsigned long long>(identity.VolumeSerialNumber & 0xffffffffULL),nativeId);
+ for(auto it=chain.rbegin();it!=chain.rend();++it)CloseHandle(*it);
+ CloseHandle(rootHandle);return 0;
+}