fix: mb_kmp::searchOne now ignores inaccessible pages

Author: std-microblock

include/blook/memo.h

@@ -270,27 +270,24 @@ class MemoryRange : public Pointer {
       return !(*this == other);
     }
 
-    inline uint8_t operator*() {
+    inline bool is_readable() const { return try_read().has_value(); }
+
+    inline std::optional<uint8_t> try_read() const {
       if (cache->buffer
               .empty() || /* !(cache->offset ∈ [ptr, ptr+cache->size]) */
           cache->offset > ptr.offset() ||
           cache->offset + cache->buffer.size() <= ptr.offset()) {
-        /**
-         *         cache = std::make_shared<CacheBuffer>(
-ptr.read(nullptr, bufSize),
-ptr.offset()
-);
-         *
-         */
         cache->buffer.resize(std::min(bufSize, size));
         if (!ptr.read(std::span(cache->buffer.data(), cache->buffer.size())))
-          throw std::runtime_error("Failed to read memory");
+          return {};
         cache->offset = ptr.offset();
       }
 
       return cache->buffer[ptr.offset() - cache->offset];
     }
 
+    inline uint8_t operator*() { return try_read().value(); }
+
     using value_type = uint8_t;
     using difference_type = std::ptrdiff_t;
     using pointer = uint8_t *;
@@ -316,8 +313,7 @@ ptr.offset()
   template <class Scanner = memory_scanner::mb_kmp>
   inline std::optional<Pointer>
   find_one(const std::vector<uint8_t> pattern) const {
-    const auto span = std::span<uint8_t>((uint8_t *)_offset, _size);
-    std::optional<size_t> res = Scanner::searchOne(span, pattern);
+    std::optional<size_t> res = Scanner::searchOne((uint8_t*)_offset, _size, pattern);
     return res.and_then([this](const auto val) {
       return std::optional<Pointer>(Pointer(this->proc, this->_offset + val));
     });

include/blook/memory_scanner/mb_kmp.h

@@ -1,19 +1,21 @@
 #pragma once
 
-#include <vector>
+#include <cstdint>
 #include <optional>
 #include <span>
-#include <cstdint>
+#include <vector>
+
 
 namespace blook {
 
-    namespace memory_scanner {
-        constexpr unsigned char ANYpattern = 0xBC;
+namespace memory_scanner {
+constexpr unsigned char ANYpattern = 0xBC;
 
-        class mb_kmp {
-        public:
-            static std::optional<size_t> searchOne(std::span<uint8_t>, const std::vector<uint8_t> &);
-        };
-    }
+class mb_kmp {
+public:
+  static std::optional<size_t> searchOne(uint8_t *data, size_t size,
+                                         const std::vector<uint8_t> &pattern);
+};
+} // namespace memory_scanner
 
-} // blook
+} // namespace blook

src/mb_kmp.cpp

@@ -3,6 +3,7 @@
 //
 
 #include "blook/memory_scanner/mb_kmp.h"
+#include "blook/memo.h"
 #include <vector>
 
 namespace blook {
@@ -31,17 +32,24 @@ namespace blook {
 
 
     std::optional<size_t>
-    memory_scanner::mb_kmp::searchOne(std::span<uint8_t> data, const std::vector<uint8_t> &pattern) {
-        if (data.size() == 0 || pattern.size() == 0 || pattern.size() > data.size())
+    memory_scanner::mb_kmp::searchOne(uint8_t* data, size_t size, const std::vector<uint8_t> &pattern) {
+        if (size == 0 || pattern.size() == 0 || pattern.size() > size)
             return {};
 
         std::vector<size_t> lps(pattern.size(), 0);
         ComputeLPSArray((void *) pattern.data(), pattern.size(), lps);
 
         size_t i = 0, j = 0;
-        char *dataa = (char *) data.data();
-        while (i < data.size()) {
-            if (*(data.data() + i) == *(pattern.data() + j) ||
+        while (i < size) {
+            // test if the page is accessible when switched page
+            if ((size_t)(data + i) % 0x1000 == 0 || i == 0) {
+                if(!blook::Pointer(data+i).try_read<int>(0)) {
+                    i += 0x1000 - ((size_t)(data + i) % 0x1000);
+                    continue;
+                }
+            }
+
+            if (*(data + i) == *(pattern.data() + j) ||
                 *(pattern.data() + j) == memory_scanner::ANYpattern) {
                 i++;
                 j++;

src/platform/windows/module.cpp

@@ -158,12 +158,6 @@ void *Module::inject(const std::string &dll_path, Module::InjectMethod method) {
 }
 
 std::optional<MemoryRange> Module::section(const std::string &name) {
-  //        if (!proc->is_self())
-  //            throw std::runtime_error("The operation can only be accomplished
-  //            for the "
-  //                                     "current process currently. "
-  //                                     "Inject your code into target process
-  //                                     first.");
 
   auto mod = base();