Fix merge + remove PAK check

Author: trongthu3212

src/Mods.cpp

@@ -36,7 +36,7 @@ Mods::Mods() {
     m_mods.emplace_back(LooseFileLoader::get());
 
 #if defined(MHWILDS)
-    m_mods.emplace_back(FaultyFileDetector::get_existing_instance());
+    m_mods.emplace_back(FaultyFileDetector::get());
 #endif
 
     m_mods.emplace_back(VR::get());

src/REFramework.cpp

@@ -31,6 +31,7 @@ extern "C" {
 #include "utility/Thread.hpp"
 
 #include "Mods.hpp"
+#include "mods/FaultyFileDetector.hpp"
 #include "mods/LooseFileLoader.hpp"
 #include "mods/PluginLoader.hpp"
 #include "mods/VR.hpp"
@@ -560,11 +561,18 @@ REFramework::REFramework(HMODULE reframework_module)
         auto& loader = LooseFileLoader::get(); // Initialize this really early
         auto &integrity_bypass = IntegrityCheckBypass::get_shared_instance();
 
+#if defined(MHWILDS)
+        auto& faulty_file_detector = FaultyFileDetector::get();
+#endif
+
         const auto config_path = get_persistent_dir(REFrameworkConfig::REFRAMEWORK_CONFIG_NAME.data()).string();
         if (fs::exists(utility::widen(config_path))) {
             utility::Config cfg{ config_path };
             loader->on_config_load(cfg);
             integrity_bypass->on_config_load(cfg);
+#if defined(MHWILDS)
+            faulty_file_detector->on_config_load(cfg);
+#endif
         }
 
         if (loader->is_enabled()) {

src/mods/FaultyFileDetector.cpp

@@ -31,8 +31,6 @@ const char *faulty_reason_to_string(FaultyFileDetector::FaultyReason reason) {
             return "Missing file";
         case FaultyFileDetector::FaultyReason::Invalid:
             return "Invalid file";
-        case FaultyFileDetector::FaultyReason::ShouldBeEncrypted:
-            return "PAK should be encrypted";
         default:
             return "Unknown reason";
     }
@@ -532,7 +530,6 @@ void FaultyFileDetector::on_draw_ui() {
         {FaultyReason::Unknown, {"Unknown", ImVec4(0.8f, 0.8f, 0.8f, 1.0f)}},
         {FaultyReason::MissingFile, {"Missing File", ImVec4(1.0f, 1.0f, 0.0f, 1.0f)}},
         {FaultyReason::Invalid, {"Invalid File", ImVec4(1.0f, 0.5f, 0.0f, 1.0f)}},
-        {FaultyReason::ShouldBeEncrypted, {"Should Be Encrypted", ImVec4(1.0f, 0.0f, 0.0f, 1.0f)}},
     };
 
     if (ImGui::TreeNode("Show recent##ShowRecentFaultyFiles")) {
@@ -575,243 +572,14 @@ void FaultyFileDetector::on_draw_ui() {
     }
 }
 
-void FaultyFileDetector::on_pak_load_result(bool success, std::wstring_view pak_name) {
-    FaultyBufferEntry faulty_entry{};
-    if (success) {
-        faulty_entry = detect_if_success_pak_still_suspicious(pak_name);
-    } else {
-        faulty_entry = determine_pak_faulty_tier(pak_name);
-    }
-    if (faulty_entry.tier != FaultyTier::None) {
-        if (s_instance == nullptr) {
-            faulty_entry.filename = std::wstring{pak_name};
-            s_buffered_faulties.push_back(faulty_entry);
-        } else {
-            s_instance->try_add_to_faulty_list(pak_name, faulty_entry.tier, faulty_entry.reason);
-        }
-    }
-}
-
-std::optional<int> FaultyFileDetector::extract_patch_version_from_pak_name(std::wstring_view pak_name) {
-    auto pak_name_copy = std::wstring{pak_name};
-    std::wsmatch match;
-
-    if (std::regex_match(pak_name_copy, match, s_extract_patch_version_regex)) {
-        if (match.size() >= 3) {
-            try {
-                return std::stoi(match[2].str());
-            } catch (const std::exception& e) {
-                spdlog::warn("[FaultyFileDetector]: Failed to parse patch version from PAK name: {}", utility::narrow(pak_name));
-            }
-        }
-    }
-
-    return std::nullopt;
-}
-
-bool FaultyFileDetector::check_is_stock_patch_pak(std::wstring_view pak_name) {
-    cache_patch_version();
-
-    auto version_opt = extract_patch_version_from_pak_name(pak_name);
-    if (version_opt.has_value()) {
-        int pak_version = version_opt.value();
-        if (s_patch_version_cached && pak_version <= s_patch_version) {
-            return true;
-        }
-    }
-    return false;
-}
-
-FaultyFileDetector::FaultyBufferEntry FaultyFileDetector::detect_if_success_pak_still_suspicious(std::wstring_view pak_name) {
-    struct PAKHeaderSimple {
-        char signature[4];
-        uint8_t major_version;
-        uint8_t minor_version;
-        uint8_t flags;
-    };
-
-    enum PAKFlags : uint8_t {
-        Encrypted = 1 << 3,
-    };
-
-    const char *signature = "KPKA";
-
-    auto game = utility::get_executable();
-    auto game_path_opt = utility::get_module_path(game);
-
-    FaultyFileDetector::FaultyBufferEntry result{};
-
-    if (game_path_opt.has_value()) {
-        auto game_path = std::filesystem::path(game_path_opt.value()).parent_path();
-        auto pak_path = game_path / pak_name;
-
-        if (!std::filesystem::exists(pak_path)) {
-            result.tier = FaultyFileDetector::FaultyTier::Severe;
-            result.reason = FaultyFileDetector::FaultyReason::MissingFile;
-
-            return result;
-        } else {
-            // Read PAK header
-            std::ifstream pak_file_stream{pak_path, std::ios::binary};
-            if (!pak_file_stream.is_open()) {
-                spdlog::warn("[FaultyFileDetector]: Failed to open PAK file for reading: {}", utility::narrow(pak_path.wstring()));
-                result.tier = FaultyFileDetector::FaultyTier::Warning;
-                result.reason = FaultyFileDetector::FaultyReason::MissingFile;
-
-                return result;
-            } else {
-                PAKHeaderSimple header{};
-                pak_file_stream.read(reinterpret_cast<char*>(&header), sizeof(PAKHeaderSimple));
-
-                if (!pak_file_stream) {
-                    spdlog::warn("[FaultyFileDetector]: Failed to read PAK header from file: {}", utility::narrow(pak_path.wstring()));
-                    result.tier = FaultyFileDetector::FaultyTier::Warning;
-                    result.reason = FaultyFileDetector::FaultyReason::MissingFile;
-                    return result;
-                }
-
-                if (std::memcmp(header.signature, signature, 4) != 0) {
-                    spdlog::warn("[FaultyFileDetector]: Invalid PAK signature in file: {}", utility::narrow(pak_path.wstring()));
-                    result.tier = FaultyFileDetector::FaultyTier::Severe;
-                    result.reason = FaultyFileDetector::FaultyReason::Invalid;
-                    return result;
-                }
-
-                if (pak_name.contains(L"patch")) {
-                    bool is_stock_patch = check_is_stock_patch_pak(pak_name);
-                    if (is_stock_patch) {
-                        // Stock patch PAK should be encrypted (put it as warning for now)
-                        if (!(header.flags & PAKFlags::Encrypted)) {
-                            spdlog::warn("[FaultyFileDetector]: Stock patch PAK is not encrypted: {}", utility::narrow(pak_path.wstring()));
-                            result.tier = FaultyFileDetector::FaultyTier::Warning;
-                            result.reason = FaultyFileDetector::FaultyReason::ShouldBeEncrypted;
-                            return result;
-                        }
-                    }
-                }
-
-                return result;
-            }
-        }
-    } else {
-        return result;
-    }
-}
-
-FaultyFileDetector::FaultyBufferEntry FaultyFileDetector::determine_pak_faulty_tier(std::wstring_view pak_name) {
-    FaultyFileDetector::FaultyBufferEntry result{};
-
-    if (pak_name.contains(L"dlc")) {
-        result.tier = FaultyTier::Severe;
-        result.reason = FaultyReason::Invalid;
-        
-        return result;
-    }
-    
-    auto patch_position_in_name = pak_name.find(L"patch");
-
-    if (patch_position_in_name != std::wstring_view::npos) {
-        cache_patch_version();
-
-        auto game_module = utility::get_executable();
-        auto game_path_opt = utility::get_module_path(game_module);
-
-        if (game_path_opt.has_value()) {
-            auto game_path = std::filesystem::path(game_path_opt.value()).parent_path();
-            auto filename_before_patch = pak_name.substr(0, std::max<int>(0, (int)patch_position_in_name - 1));
-
-            auto patch_target_pak = game_path / filename_before_patch;
-            if (!std::filesystem::exists(patch_target_pak)) {
-                // Target patch PAK does not exist, false positive
-                return result;
-            } else {
-                // Target patch PAK exists, check if its existence is necessary first
-                bool is_stock_patch_pak = check_is_stock_patch_pak(pak_name);
-
-                if (is_stock_patch_pak) {
-                    result.tier = FaultyTier::Severe;
-
-                    if (std::filesystem::exists(game_path / pak_name)) {
-                        result.reason = FaultyReason::Invalid;
-                    } else {
-                        result.reason = FaultyReason::MissingFile;
-                    }
-
-                    return result;
-                } else {
-                    // The PAK is probably in modded PAK range, if it does not exist then its fine
-                    auto pak_path = game_path / pak_name;
-                    if (std::filesystem::exists(pak_path)) {
-                        result.tier = FaultyTier::Severe;
-                        result.reason = FaultyReason::Invalid;
-
-                        return result;
-                    } else {
-                        return result;
-                    }
-                }
-            }
-        }
-    } else {
-        result.tier = FaultyTier::Severe;
-        result.reason = FaultyReason::Invalid;
-    }
-
-    return result;
-}
-
-void FaultyFileDetector::cache_patch_version() {
-    if (s_patch_version_cached) {
-        return;
-    }
-    
-    const wchar_t *patch_version_prefix = L"/Environment/Package/PatchVersion:";
-
-    auto argument_count_method = sdk::find_method_definition("via.Application", "getArgumentCount");
-    if (argument_count_method == nullptr) {
-        spdlog::warn("[FaultyFileDetector]: Failed to find via.Application::getArgumentCount method for patch version detection");
-        return;
-    }
-
-    int argument_count = argument_count_method->call<int>();
-    for (int i = 0; i < argument_count; i++) {
-        auto argument_value_method = sdk::find_method_definition("via.Application", "getArgument");
-        if (argument_value_method == nullptr) {
-            spdlog::warn("[FaultyFileDetector]: Failed to find via.Application::getArgument method for patch version detection");
-            return;
-        }
-
-        auto arg_value_obj = argument_value_method->call<SystemString*>(sdk::get_thread_context(), i);
-        if (arg_value_obj != nullptr) {
-            auto arg_str = utility::re_string::get_view(arg_value_obj);
-            spdlog::info("[FaultyFileDetector]: Detected argument: {}", utility::narrow(arg_str));
-            if (arg_str.starts_with(patch_version_prefix)) {
-                auto version_str = arg_str.substr(wcslen(patch_version_prefix));
-                try {
-                    s_patch_version = std::stoi(utility::narrow(version_str));
-                    s_patch_version_cached = true;
-
-                    spdlog::info("[FaultyFileDetector]: Detected patch version: {}", s_patch_version);
-                } catch (const std::exception& e) {
-                    spdlog::warn("[FaultyFileDetector]: Failed to parse patch version from argument: {}", utility::narrow(arg_str));
-                }
-                break;
-            }
-        } else {
-            spdlog::warn("[FaultyFileDetector]: Argument value at index {} is null", i);
-        }
-    }
-}
-
 void FaultyFileDetector::early_init() {
     if (g_faulty_detector_instance == nullptr) {
         g_faulty_detector_instance = std::make_unique<FaultyFileDetector>();
     }
 
-    IntegrityCheckBypass::add_pak_load_result_listener(&FaultyFileDetector::on_pak_load_result);
     g_faulty_detector_instance->initialize_impl();
 }
 
-std::shared_ptr<FaultyFileDetector>& FaultyFileDetector::get_existing_instance() {
+std::shared_ptr<FaultyFileDetector>& FaultyFileDetector::get() {
     return g_faulty_detector_instance;
 }

src/mods/FaultyFileDetector.hpp

@@ -25,7 +25,6 @@ class FaultyFileDetector : public Mod {
         Unknown = 0,
         MissingFile = 1,
         Invalid = 2,
-        ShouldBeEncrypted = 3,
     };
 
     struct FaultyBufferEntry {
@@ -44,7 +43,7 @@ class FaultyFileDetector : public Mod {
     void on_draw_ui() override;
 
     static void early_init();
-    static std::shared_ptr<FaultyFileDetector>& get_existing_instance();
+    static std::shared_ptr<FaultyFileDetector>& get();
 
 private:
     static sdk::Resource* create_resource_hook_wrapper(sdk::ResourceManager *resource_manager, void* type_info, wchar_t* name);