cpp/defendnot_function_bench.jsonl

{"repo_name": "defendnot", "file_name": "/defendnot/defendnot/dllmain.cpp", "inference_info": {"prefix_code": "#include \"bootstrap/bootstrap.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ipc.hpp\"\n\n#include <stdexcept>\n#include <thread>\n\n#include <Windows.h>\n\nnamespace {\n    ", "suffix_code": "\n} // namespace\n\nBOOL __stdcall DllMain(HINSTANCE base, std::uint32_t call_reason, LPVOID reserved) {\n    if (call_reason != DLL_PROCESS_ATTACH) {\n        return TRUE;\n    }\n\n    const auto th = CreateThread(nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(entry_thread), base, 0, nullptr);\n    if (th != nullptr) {\n        CloseHandle(th);\n    }\n\n    return TRUE;\n}\n", "middle_code": "void entry_thread(HMODULE base) {\n        bool success = false;\n        std::unique_ptr<shared::InterProcessCommunication> ipc;\n        try {\n            ipc = std::make_unique<shared::InterProcessCommunication>(shared::InterProcessCommunicationMode::WRITE);\n            defendnot::startup();\n            success = true;\n        } catch (std::exception& err) {\n            MessageBoxA(nullptr, err.what(), \"defendnot\", MB_TOPMOST | MB_ICONERROR);\n        }\n        if (ipc) {\n            (*ipc)->success = success;\n            (*ipc)->finished = true;\n        }\n        FreeLibraryAndExitThread(base, 0);\n    }", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "cpp", "sub_task_type": null}, "context_code": [["/defendnot/defendnot-loader/core/inject.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/defer.hpp\"\n#include \"shared/native.hpp\"\n\n#include <print>\n#include <stdexcept>\n\n#include <Windows.h>\n\nnamespace loader {\n    [[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {\n        STARTUPINFOA si = {\n            .cb = sizeof(si),\n        };\n        PROCESS_INFORMATION pi = {\n            0,\n        };\n        SECURITY_ATTRIBUTES sa = {\n            .nLength = sizeof(sa),\n            .bInheritHandle = TRUE,\n        };\n\n        /// By setting ReadImageFileExecOptions to FALSE and attaching ourselves as a debugger we can skip the IFEO\n        /// \\xref: https://github.com/es3n1n/defendnot/issues/7#issuecomment-2874903650\n        native::get_peb()->read_image_file_exec_options = 0;\n\n        std::println(\"** booting {}\", proc_name);\n        const auto process_flags = CREATE_SUSPENDED | DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;\n        if (!CreateProcessA(nullptr, const_cast<char*>(proc_name.data()), &sa, &sa, FALSE, process_flags, nullptr, nullptr, &si, &pi)) {\n            throw std::runtime_error(std::format(\"unable to create process: {}\", GetLastError()));\n        }\n\n        /// Detach\n        native::debug_set_process_kill_on_exit(false);\n        native::debug_active_process_stop(pi.dwProcessId);\n\n        defer->void {\n            CloseHandle(pi.hThread);\n            /// Not closing hProcess because we return it\n        };\n\n        LPVOID mem = VirtualAllocEx(pi.hProcess, nullptr, dll_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);\n        if (mem == nullptr) {\n            throw std::runtime_error(std::format(\"unable to allocate memory: {}\", GetLastError()));\n        }\n\n        defer->void {\n            VirtualFreeEx(pi.hProcess, mem, 0, MEM_RELEASE);\n        };\n\n        if (!WriteProcessMemory(pi.hProcess, mem, dll_path.data(), dll_path.size() + 1, nullptr)) {\n            throw std::runtime_error(std::format(\"unable to write memory: {}\", GetLastError()));\n        }\n\n        HANDLE thread = CreateRemoteThread(pi.hProcess, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(LoadLibraryA), mem, 0, nullptr);\n        if (thread == NULL) {\n            throw std::runtime_error(std::format(\"unable to create thread: {}\", GetLastError()));\n        }\n\n        defer->void {\n            CloseHandle(thread);\n        };\n\n        /// Wait for DllMain to complete\n        WaitForSingleObject(thread, INFINITE);\n        return pi.hProcess;\n    }\n} // namespace loader\n"], ["/defendnot/defendnot-loader/main.cpp", "#include \"core/core.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n#include \"shared/ipc.hpp\"\n#include \"shared/strings.hpp\"\n#include <argparse/argparse.hpp>\n\n#include <format>\n#include <print>\n#include <thread>\n\nnamespace {\n    void setup_window(const loader::Config& config) {\n        if ((!config.from_autorun || config.verbose) && config.alloc_console) {\n            shared::alloc_console();\n        }\n    }\n\n    void setup_context(const loader::Config& config) {\n        std::println(\"** setting up context\");\n\n        if (config.name.length() > shared::kMaxNameLength) {\n            throw std::runtime_error(std::format(\"Max name length is {} characters\", shared::kMaxNameLength));\n        }\n\n        shared::ctx.state = config.disable ? shared::State::OFF : shared::State::ON;\n        shared::ctx.verbose = config.verbose;\n        std::ranges::copy(config.name, shared::ctx.name.data());\n\n        /// No need to overwrite ctx if we are called from autorun\n        if (!config.from_autorun) {\n            std::println(\"** overwriting ctx.bin\");\n            shared::ctx.serialize();\n        }\n    }\n\n    [[nodiscard]] HANDLE load_defendnot() {\n        std::println(\"** loading defendnot\");\n\n        auto dll_path = shared::get_this_module_path().parent_path();\n        dll_path /= strings::kDllName;\n        if (!std::filesystem::exists(dll_path)) {\n            throw std::runtime_error(std::format(\"{} does not exist!\", strings::kDllName));\n        }\n\n        return loader::inject(dll_path.string(), strings::kVictimProcess);\n    }\n\n    void wait_for_finish(shared::InterProcessCommunication& ipc) {\n        std::println(\"** waiting for process to finish, this can take a while\");\n        std::cout << std::flush;\n        while (!ipc->finished) {\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n        std::println(\"** success: {}\", ipc->success);\n    }\n\n    void process_autorun(const loader::Config& config) {\n        if (shared::ctx.state == shared::State::ON && config.enable_autorun) {\n            std::println(\"** added to autorun: {}\", loader::add_to_autorun(config.autorun_type));\n        } else {\n            std::println(\"** removed from autorun: {}\", loader::remove_from_autorun());\n        }\n    }\n\n    void banner(const loader::Config& config) {\n        std::println();\n        std::println(\"thanks for using {}\", strings::kProjectName);\n        std::println(\"please don't forget to leave a star at {}\", strings::kRepoUrl);\n\n        if (!config.from_autorun && config.alloc_console) {\n            system(\"pause\");\n        }\n    }\n} // namespace\n\nint main(int argc, char* argv[]) try {\n    argparse::ArgumentParser program(std::format(\"{}-loader\", strings::kProjectName), strings::kVersion.data(), argparse::default_arguments::none);\n\n    const auto fatal_print = [](const std::string_view str) -> void {\n        shared::alloc_console();\n        std::cerr << str << std::endl;\n        system(\"pause\");\n        std::exit(EXIT_FAILURE);\n    };\n\n    /// We are registering these ourselves because we have to alloc console first\n    program.add_argument(\"-h\", \"--help\")\n        .help(\"prints help message and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print, &program](const auto& /*unused*/) -> void { fatal_print(program.help().str()); });\n    program.add_argument(\"--version\")\n        .help(\"shows version and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print](const auto& /*unused*/) -> void { fatal_print(std::format(\"{}-loader v{}\", strings::kProjectName, strings::kVersion)); });\n\n    /// defendnot-loader parameters:\n    program.add_argument(\"-n\", \"--name\").help(\"av display name\").default_value(std::string(strings::kDefaultAVName)).nargs(1);\n    program.add_argument(\"-d\", \"--disable\").help(std::format(\"disable {}\", strings::kProjectName)).default_value(false).implicit_value(true);\n    program.add_argument(\"-v\", \"--verbose\").help(\"verbose logging\").default_value(false).implicit_value(true);\n    program.add_argument(\"--silent\").help(\"do not allocate console\").default_value(false).implicit_value(true);\n    program.add_argument(\"--autorun-as-user\").help(\"create autorun task as currently logged in user\").default_value(false).implicit_value(true);\n    program.add_argument(\"--disable-autorun\").help(\"disable autorun task creation\").default_value(false).implicit_value(true);\n    program.add_argument(\"--from-autorun\").hidden().default_value(false).implicit_value(true);\n\n    try {\n        program.parse_args(argc, argv);\n    } catch (std::exception& e) {\n        std::stringstream ss;\n        ss << e.what() << '\\n';\n        ss << program.help().str();\n        fatal_print(ss.str());\n        return EXIT_FAILURE;\n    }\n\n    auto config = loader::Config{\n        .name = program.get<std::string>(\"-n\"),\n        .disable = program.get<bool>(\"-d\"),\n        .alloc_console = !program.get<bool>(\"--silent\"),\n        .verbose = program.get<bool>(\"-v\"),\n        .from_autorun = program.get<bool>(\"--from-autorun\"),\n        .autorun_type = program.get<bool>(\"--autorun-as-user\") ? /// As system on boot is the default value\n                            loader::AutorunType::AS_CURRENT_USER_ON_LOGIN :\n                            loader::AutorunType::AS_SYSTEM_ON_BOOT,\n        .enable_autorun = !program.get<bool>(\"--disable-autorun\"),\n    };\n\n    /// When running from autorun, we'll be missing all the cli arguments, so lets load some relevant ones\n    if (config.from_autorun) {\n        shared::ctx.deserialize();\n        config.verbose = shared::ctx.verbose;\n    }\n\n    if (!config.alloc_console && config.verbose) {\n        fatal_print(\"--silent flag can not be used in combination with --verbose\");\n    }\n\n    setup_window(config);\n    loader::ensure_environment();\n\n    setup_context(config);\n\n    /// \\todo @es3n1n: move this to a separate function and add move ctor for ipc\n    std::println(\"** setting up ipc\");\n    auto ipc = shared::InterProcessCommunication(shared::InterProcessCommunicationMode::READ_WRITE, true);\n    ipc->finished = false;\n\n    const auto process = load_defendnot();\n    defer->void {\n        TerminateProcess(process, 0);\n    };\n\n    wait_for_finish(ipc);\n\n    /// Only create autorun task when not running from autorun, no need to recreate it because we're missing some config vars\n    if (!config.from_autorun) {\n        process_autorun(config);\n    }\n\n    banner(config);\n\n    return EXIT_SUCCESS;\n} catch (std::exception& err) {\n    shared::alloc_console();\n    std::println(stderr, \"** fatal error: {}\", err.what());\n    system(\"pause\");\n    return EXIT_FAILURE;\n}\n\nint WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR lpCmdLine, int nCmdShow) {\n    return main(__argc, __argv);\n}\n"], ["/defendnot/wsc-binary-check/main.cpp", "#include <Windows.h>\n#include <winternl.h>\n\n#include <filesystem>\n#include <fstream>\n#include <optional>\n#include <print>\n#include <ranges>\n#include <set>\n\n#include \"shared/defer.hpp\"\n\n#pragma comment(lib, \"Crypt32.lib\")\n\nnamespace {\n    constexpr std::string_view kTargetDirectory = \"c:\\\\Windows\\\\System32\";\n    /* constexpr */ auto kTargetFileExts = std::set<std::string_view>{\".exe\"};\n\n    constexpr std::uint16_t kDosMagic = 0x5A4D;\n    constexpr std::uint32_t kNtSignature = 0x00004550;\n    constexpr std::uint16_t kARM64Machine = 0xAA64;\n    constexpr std::uint16_t kAMD64Machine = 0x8664;\n    constexpr std::uint16_t kI386Machine = 0x014C;\n    constexpr std::uint16_t kDllCharacteristicsForceIntegrityMask = 0x80;\n\n    [[nodiscard]] std::optional<std::vector<std::uint8_t>> read_file(const std::filesystem::path path) {\n        std::ifstream file(path, std::ios::binary);\n        if (!file.good()) {\n            return std::nullopt;\n        }\n\n        const auto size = std::filesystem::file_size(path);\n        std::vector<std::uint8_t> buffer(size);\n\n        file.read(reinterpret_cast<char*>(buffer.data()), static_cast<std::streamsize>(buffer.size()));\n        return buffer;\n    }\n\n    [[nodiscard]] bool check_characteristics(const std::span<std::uint8_t> data) {\n        if (data.size() < sizeof(IMAGE_DOS_HEADER)) {\n            throw std::runtime_error(\"got invalid pe image\");\n        }\n\n        const auto p_dos = reinterpret_cast<PIMAGE_DOS_HEADER>(data.data());\n        if (p_dos->e_magic != kDosMagic) {\n            throw std::runtime_error(\"got invalid pe image (2)\");\n        }\n\n        const auto p_nt = reinterpret_cast<PIMAGE_NT_HEADERS>(data.data() + p_dos->e_lfanew);\n        if (p_nt->Signature != kNtSignature) {\n            throw std::runtime_error(\"got invalid pe image (3)\");\n        }\n\n        const auto machine = p_nt->FileHeader.Machine;\n        std::uint16_t characteristics;\n\n        if (machine == kARM64Machine || machine == kAMD64Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS64>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else if (machine == kI386Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS32>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else {\n            throw std::runtime_error(std::format(\"unsupported machine: {:#x}\", machine));\n        }\n\n        return (characteristics & kDllCharacteristicsForceIntegrityMask) != 0;\n    }\n\n    [[nodiscard]] bool check_signature(const std::filesystem::path path) {\n        HCERTSTORE store = {0};\n        HCRYPTMSG msg = {0};\n        if (!CryptQueryObject(1, path.wstring().c_str(), 0x400, 0xE, 0, nullptr, nullptr, nullptr, &store, &msg, nullptr) //\n            || !store || !msg) {\n            /// Most likely the binary is just not signed\n            return false;\n        }\n\n        defer->void {\n            CryptMsgClose(msg);\n            CertCloseStore(store, 1);\n        };\n\n        PCCERT_CONTEXT signer = nullptr;\n        if (!CryptMsgGetAndVerifySigner(msg, 0, nullptr, 2, &signer, nullptr) || signer == nullptr) {\n            throw std::runtime_error(std::format(\"CryptMsgGetAndVerifySigner() on {}\", path.string()));\n        }\n\n        defer->void {\n            CertFreeCertificateContext(signer);\n        };\n\n        /// I don't think we have to do something with signer?\n        return true;\n    }\n} // namespace\n\nint main() try {\n    for (auto& entry : std::filesystem::recursive_directory_iterator(kTargetDirectory, std::filesystem::directory_options::skip_permission_denied)) {\n        auto path = entry.path();\n        auto ext = path.extension().string() //\n                   | std::views::transform([](const char c) -> char { return ::tolower(c); }) //\n                   | std::ranges::to<std::string>();\n\n        if (!kTargetFileExts.contains(ext)) {\n            continue;\n        }\n\n        auto file = read_file(path);\n        if (!file.has_value()) {\n            std::println(stderr, \"unable to read {}\", path.string());\n            continue;\n        }\n\n        const std::span file_ptr = *file;\n        if (!check_characteristics(file_ptr)) {\n            continue;\n        }\n\n        if (!check_signature(path)) {\n            continue;\n        }\n\n        std::println(\"matches: {}\", path.string());\n    }\n\n    return EXIT_SUCCESS;\n} catch (const std::exception& e) {\n    std::println(stderr, \"fatal error: {}\", e.what());\n    return EXIT_FAILURE;\n}\n"], ["/defendnot/defendnot-loader/core/autorun.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/com.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/strings.hpp\"\n\n#include <memory>\n#include <print>\n#include <stdexcept>\n#include <type_traits>\n\n#include <comdef.h>\n#include <taskschd.h>\n\n#pragma comment(lib, \"taskschd.lib\")\n#pragma comment(lib, \"comsupp.lib\")\n#pragma comment(lib, \"ole32.lib\")\n\nnamespace loader {\n    namespace {\n        constexpr std::string_view kTaskName = strings::kProjectName;\n\n        void co_initialize() {\n            static std::once_flag fl;\n            std::call_once(fl, []() -> void {\n                const auto result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);\n\n                if (FAILED(result)) {\n                    throw std::runtime_error(\"failed to CoInitializeEx\");\n                }\n            });\n        }\n\n        template <typename Callable>\n        [[nodiscard]] bool with_service(Callable&& callback) {\n            co_initialize();\n\n            com::Ptr<ITaskService> service;\n            auto hr =\n                CoCreateInstance(CLSID_TaskScheduler, nullptr, CLSCTX_INPROC_SERVER, IID_ITaskService, reinterpret_cast<void**>(service.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            hr = service->Connect(VARIANT{}, VARIANT{}, VARIANT{}, VARIANT{});\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskFolder> root_folder;\n            hr = service->GetFolder(BSTR(L\"\\\\\"), root_folder.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Cleanup our task, we will recreate it in the callback if needed\n            root_folder->DeleteTask(BSTR(kTaskName.data()), 0);\n            return callback(service.get(), root_folder.get());\n        }\n    } // namespace\n\n    [[nodiscard]] bool add_to_autorun(AutorunType type) {\n        const auto bin_path = shared::get_this_module_path();\n\n        return with_service([bin_path, type](ITaskService* service, ITaskFolder* folder) -> bool {\n            /// Deduce the autorun config based on type\n            const auto task_trigger = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_TRIGGER_BOOT : TASK_TRIGGER_LOGON;\n            const auto logon_type = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_LOGON_SERVICE_ACCOUNT : TASK_LOGON_INTERACTIVE_TOKEN;\n\n            BSTR user_id = nullptr;\n            auto bstr_sys = bstr_t(L\"SYSTEM\");\n            if (type == AutorunType::AS_SYSTEM_ON_BOOT) {\n                user_id = bstr_sys;\n            }\n\n            com::Ptr<ITaskDefinition> task;\n            auto hr = service->NewTask(0, task.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IRegistrationInfo> reg_info;\n            hr = task->get_RegistrationInfo(reg_info.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IPrincipal> principal;\n            hr = task->get_Principal(principal.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITriggerCollection> trigger_collection;\n            hr = task->get_Triggers(trigger_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITrigger> trigger;\n            hr = trigger_collection->Create(task_trigger, trigger.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IActionCollection> action_collection;\n            hr = task->get_Actions(action_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IAction> action;\n            hr = action_collection->Create(TASK_ACTION_EXEC, action.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IExecAction> exec_action;\n            hr = action->QueryInterface(IID_IExecAction, reinterpret_cast<void**>(exec_action.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskSettings> settings;\n            hr = task->get_Settings(settings.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Elevated, when system boots\n            principal->put_UserId(user_id);\n            principal->put_LogonType(logon_type);\n            principal->put_RunLevel(TASK_RUNLEVEL_HIGHEST);\n\n            /// Info\n            reg_info->put_Author(bstr_t(strings::kRepoUrl.data()));\n\n            /// Start even if we're on batteries\n            settings->put_DisallowStartIfOnBatteries(VARIANT_FALSE);\n            settings->put_StopIfGoingOnBatteries(VARIANT_FALSE);\n\n            /// Binary\n            exec_action->put_Path(bstr_t(bin_path.string().c_str()));\n            exec_action->put_Arguments(bstr_t(\"--from-autorun\"));\n\n            /// Register the task and we are done\n            com::Ptr<IRegisteredTask> registered_task;\n            hr = folder->RegisterTaskDefinition(bstr_t(kTaskName.data()), task.get(), TASK_CREATE_OR_UPDATE, VARIANT{}, VARIANT{}, TASK_LOGON_NONE,\n                                                variant_t(L\"\"), registered_task.ref_to_ptr());\n            return SUCCEEDED(hr);\n        });\n    }\n\n    [[nodiscard]] bool remove_from_autorun() {\n        return with_service([]<typename... TArgs>(TArgs...) -> bool { return true; });\n    }\n} // namespace loader\n"], ["/defendnot/defendnot/bootstrap/bootstrap.cpp", "#include \"bootstrap.hpp\"\n#include \"core/com.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n\n#include <Windows.h>\n\nnamespace defendnot {\n    namespace {\n        template <com::ComObject Ty>\n        void apply(const std::string_view log_prefix, const BSTR name) {\n            /// Get the WSC interface\n            auto inst = com::query<Ty>();\n\n            /// This can fail if we dont have any products registered so no com_checked\n            logln(\"{}_unregister: {:#x}\", log_prefix, com::retry_while_pending([&inst]() -> HRESULT { return inst->Unregister(); }) & 0xFFFFFFFF);\n            if (shared::ctx.state == shared::State::OFF) {\n                return;\n            }\n\n            /// Register and activate\n            logln(\"{}_register: {:#x}\", log_prefix, com::checked(inst->Register(name, name, 0, 0)));\n            logln(\"{}_update: {:#x}\", log_prefix, com::checked(inst->UpdateStatus(WSCSecurityProductState::ON, static_cast<BOOL>(true))));\n\n            /// Update the substatuses, if the interface supports this\n            if constexpr (std::is_same_v<Ty, IWscAVStatus4>) {\n                logln(\"{}_scan_update: {:#x}\", log_prefix, com::checked(inst->UpdateScanSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_settings_update: {:#x}\", log_prefix, com::checked(inst->UpdateSettingsSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_prot_update: {:#x}\", log_prefix, com::checked(inst->UpdateProtectionUpdateSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n            }\n        }\n    } // namespace\n\n    void startup() {\n        /// Setup\n        shared::ctx.deserialize();\n        logln(\"init: {:#x}\", com::checked(CoInitialize(nullptr)));\n\n        /// WSC will reject the register request if name is empty\n        auto name_w = std::wstring(shared::ctx.name.begin(), shared::ctx.name.end());\n        if (name_w.empty()) {\n            throw std::runtime_error(\"AV Name can not be empty!\");\n        }\n\n        /// Convert to BSTR\n        auto name = SysAllocString(name_w.c_str());\n        defer->void {\n            SysFreeString(name);\n        };\n\n        /// Register our stuff in the WSC interfaces\n        apply<IWscASStatus>(\"IWscASStatus\", name);\n        apply<IWscAVStatus4>(\"IWscAVStatus4\", name);\n    }\n} // namespace defendnot\n"], ["/defendnot/defendnot-loader/core/ensure_environment.cpp", "#include \"core/core.hpp\"\n#include \"shared/strings.hpp\"\n#include \"util/scm.hpp\"\n\n#include <format>\n#include <print>\n#include <stdexcept>\n\nnamespace loader {\n    void ensure_environment() {\n        auto manager = scm::Manager();\n        if (!manager.valid()) [[unlikely]] {\n            throw std::runtime_error(\"Unable to open scm::Manager\");\n        }\n\n        auto service = manager.get_service(L\"wscsvc\");\n        if (!service.valid() || !service.query_status()) {\n            throw std::runtime_error(std::format(\"{}\\nOpen error: {}\", strings::wsc_unavailable_error().data(), GetLastError()));\n        }\n\n        if (service.state() == scm::ServiceState::RUNNING) {\n            /// Wsc service has been already started, no need to start it ourselves\n            return;\n        }\n\n        /// Let's start the service ourselves\n        std::println(\"** wscsvc is not running, starting it..\");\n        if (!service.start()) {\n            throw std::runtime_error(std::format(\"{}\\nTried to start the service, but go an error: {}\", strings::wsc_unavailable_error(), GetLastError()));\n        }\n\n        std::println(\"** successfully started the service, waiting for it to get up..\");\n        while (true) {\n            if (!service.query_status(/*force=*/true)) {\n                throw std::runtime_error(\n                    std::format(\"{}\\nStarted the service, got an error while querying: {}\", strings::wsc_unavailable_error(), GetLastError()));\n            }\n\n            if (const auto state = service.state(); state == scm::ServiceState::RUNNING) {\n                std::println(\"** we are good to go\");\n                return;\n            }\n\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n    }\n} // namespace loader\n"]], "task_instance_info": {"created_time": "2025-08-20 19:54:09", "created_task_model": "DeepSeek-R1", "function_skeleton": "void entry_thread(HMODULE base) {}", "code_description": "This code segment functions to: Execute initialization routines within a dedicated thread during module attachment, handle potential errors through user notifications, update inter-process communication status flags upon completion, and manage resource cleanup before exiting."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```cpp\n[TASK_BEGIN]\nvoid entry_thread(HMODULE base) {\n    try {\n        core::log::init();\n        bootstrap::init(base);\n        shared::ipc::init_server();\n\n        while (true) {\n            std::this_thread::sleep_for(std::chrono::seconds(1));\n        }\n    } catch (const std::exception& e) {\n        core::log::error(\"Initialization failed: {}\", e.what());\n        FreeLibraryAndExitThread(base, 0);\n    }\n}\n[TASK_END]\n```", "inference_time": "2025-08-20 19-54-33"}, "editdistance_info": {"edit_distance": 24.2647, "calculate_time": "2025-08-20 19:54:33", "true_code_clean": "void entry_thread(HMODULE base) {\n        bool success = false;\n        std::unique_ptr<shared::InterProcessCommunication> ipc;\n        try {\n            ipc = std::make_unique<shared::InterProcessCommunication>(shared::InterProcessCommunicationMode::WRITE);\n            defendnot::startup();\n            success = true;\n        } catch (std::exception& err) {\n            MessageBoxA(nullptr, err.what(), \"defendnot\", MB_TOPMOST | MB_ICONERROR);\n        }\n        if (ipc) {\n            (*ipc)->success = success;\n            (*ipc)->finished = true;\n        }\n        FreeLibraryAndExitThread(base, 0);\n    }", "predict_code_clean": "void entry_thread(HMODULE base) {\n    try {\n        core::log::init();\n        bootstrap::init(base);\n        shared::ipc::init_server();\n        while (true) {\n            std::this_thread::sleep_for(std::chrono::seconds(1));\n        }\n    } catch (const std::exception& e) {\n        core::log::error(\"Initialization failed: {}\", e.what());\n        FreeLibraryAndExitThread(base, 0);\n    }\n}"}}
{"repo_name": "defendnot", "file_name": "/defendnot/defendnot/dllmain.cpp", "inference_info": {"prefix_code": "#include \"bootstrap/bootstrap.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ipc.hpp\"\n\n#include <stdexcept>\n#include <thread>\n\n#include <Windows.h>\n\nnamespace {\n    ", "suffix_code": "\n} // namespace\n\nBOOL __stdcall DllMain(HINSTANCE base, std::uint32_t call_reason, LPVOID reserved) {\n    if (call_reason != DLL_PROCESS_ATTACH) {\n        return TRUE;\n    }\n\n    const auto th = CreateThread(nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(entry_thread), base, 0, nullptr);\n    if (th != nullptr) {\n        CloseHandle(th);\n    }\n\n    return TRUE;\n}\n", "middle_code": "void entry_thread(HMODULE base) {\n        bool success = false;\n        std::unique_ptr<shared::InterProcessCommunication> ipc;\n        try {\n            ipc = std::make_unique<shared::InterProcessCommunication>(shared::InterProcessCommunicationMode::WRITE);\n            defendnot::startup();\n            success = true;\n        } catch (std::exception& err) {\n            MessageBoxA(nullptr, err.what(), \"defendnot\", MB_TOPMOST | MB_ICONERROR);\n        }\n        if (ipc) {\n            (*ipc)->success = success;\n            (*ipc)->finished = true;\n        }\n        FreeLibraryAndExitThread(base, 0);\n    }", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "cpp", "sub_task_type": null}, "context_code": [["/defendnot/defendnot-loader/core/inject.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/defer.hpp\"\n#include \"shared/native.hpp\"\n\n#include <print>\n#include <stdexcept>\n\n#include <Windows.h>\n\nnamespace loader {\n    [[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {\n        STARTUPINFOA si = {\n            .cb = sizeof(si),\n        };\n        PROCESS_INFORMATION pi = {\n            0,\n        };\n        SECURITY_ATTRIBUTES sa = {\n            .nLength = sizeof(sa),\n            .bInheritHandle = TRUE,\n        };\n\n        /// By setting ReadImageFileExecOptions to FALSE and attaching ourselves as a debugger we can skip the IFEO\n        /// \\xref: https://github.com/es3n1n/defendnot/issues/7#issuecomment-2874903650\n        native::get_peb()->read_image_file_exec_options = 0;\n\n        std::println(\"** booting {}\", proc_name);\n        const auto process_flags = CREATE_SUSPENDED | DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;\n        if (!CreateProcessA(nullptr, const_cast<char*>(proc_name.data()), &sa, &sa, FALSE, process_flags, nullptr, nullptr, &si, &pi)) {\n            throw std::runtime_error(std::format(\"unable to create process: {}\", GetLastError()));\n        }\n\n        /// Detach\n        native::debug_set_process_kill_on_exit(false);\n        native::debug_active_process_stop(pi.dwProcessId);\n\n        defer->void {\n            CloseHandle(pi.hThread);\n            /// Not closing hProcess because we return it\n        };\n\n        LPVOID mem = VirtualAllocEx(pi.hProcess, nullptr, dll_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);\n        if (mem == nullptr) {\n            throw std::runtime_error(std::format(\"unable to allocate memory: {}\", GetLastError()));\n        }\n\n        defer->void {\n            VirtualFreeEx(pi.hProcess, mem, 0, MEM_RELEASE);\n        };\n\n        if (!WriteProcessMemory(pi.hProcess, mem, dll_path.data(), dll_path.size() + 1, nullptr)) {\n            throw std::runtime_error(std::format(\"unable to write memory: {}\", GetLastError()));\n        }\n\n        HANDLE thread = CreateRemoteThread(pi.hProcess, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(LoadLibraryA), mem, 0, nullptr);\n        if (thread == NULL) {\n            throw std::runtime_error(std::format(\"unable to create thread: {}\", GetLastError()));\n        }\n\n        defer->void {\n            CloseHandle(thread);\n        };\n\n        /// Wait for DllMain to complete\n        WaitForSingleObject(thread, INFINITE);\n        return pi.hProcess;\n    }\n} // namespace loader\n"], ["/defendnot/defendnot-loader/main.cpp", "#include \"core/core.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n#include \"shared/ipc.hpp\"\n#include \"shared/strings.hpp\"\n#include <argparse/argparse.hpp>\n\n#include <format>\n#include <print>\n#include <thread>\n\nnamespace {\n    void setup_window(const loader::Config& config) {\n        if ((!config.from_autorun || config.verbose) && config.alloc_console) {\n            shared::alloc_console();\n        }\n    }\n\n    void setup_context(const loader::Config& config) {\n        std::println(\"** setting up context\");\n\n        if (config.name.length() > shared::kMaxNameLength) {\n            throw std::runtime_error(std::format(\"Max name length is {} characters\", shared::kMaxNameLength));\n        }\n\n        shared::ctx.state = config.disable ? shared::State::OFF : shared::State::ON;\n        shared::ctx.verbose = config.verbose;\n        std::ranges::copy(config.name, shared::ctx.name.data());\n\n        /// No need to overwrite ctx if we are called from autorun\n        if (!config.from_autorun) {\n            std::println(\"** overwriting ctx.bin\");\n            shared::ctx.serialize();\n        }\n    }\n\n    [[nodiscard]] HANDLE load_defendnot() {\n        std::println(\"** loading defendnot\");\n\n        auto dll_path = shared::get_this_module_path().parent_path();\n        dll_path /= strings::kDllName;\n        if (!std::filesystem::exists(dll_path)) {\n            throw std::runtime_error(std::format(\"{} does not exist!\", strings::kDllName));\n        }\n\n        return loader::inject(dll_path.string(), strings::kVictimProcess);\n    }\n\n    void wait_for_finish(shared::InterProcessCommunication& ipc) {\n        std::println(\"** waiting for process to finish, this can take a while\");\n        std::cout << std::flush;\n        while (!ipc->finished) {\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n        std::println(\"** success: {}\", ipc->success);\n    }\n\n    void process_autorun(const loader::Config& config) {\n        if (shared::ctx.state == shared::State::ON && config.enable_autorun) {\n            std::println(\"** added to autorun: {}\", loader::add_to_autorun(config.autorun_type));\n        } else {\n            std::println(\"** removed from autorun: {}\", loader::remove_from_autorun());\n        }\n    }\n\n    void banner(const loader::Config& config) {\n        std::println();\n        std::println(\"thanks for using {}\", strings::kProjectName);\n        std::println(\"please don't forget to leave a star at {}\", strings::kRepoUrl);\n\n        if (!config.from_autorun && config.alloc_console) {\n            system(\"pause\");\n        }\n    }\n} // namespace\n\nint main(int argc, char* argv[]) try {\n    argparse::ArgumentParser program(std::format(\"{}-loader\", strings::kProjectName), strings::kVersion.data(), argparse::default_arguments::none);\n\n    const auto fatal_print = [](const std::string_view str) -> void {\n        shared::alloc_console();\n        std::cerr << str << std::endl;\n        system(\"pause\");\n        std::exit(EXIT_FAILURE);\n    };\n\n    /// We are registering these ourselves because we have to alloc console first\n    program.add_argument(\"-h\", \"--help\")\n        .help(\"prints help message and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print, &program](const auto& /*unused*/) -> void { fatal_print(program.help().str()); });\n    program.add_argument(\"--version\")\n        .help(\"shows version and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print](const auto& /*unused*/) -> void { fatal_print(std::format(\"{}-loader v{}\", strings::kProjectName, strings::kVersion)); });\n\n    /// defendnot-loader parameters:\n    program.add_argument(\"-n\", \"--name\").help(\"av display name\").default_value(std::string(strings::kDefaultAVName)).nargs(1);\n    program.add_argument(\"-d\", \"--disable\").help(std::format(\"disable {}\", strings::kProjectName)).default_value(false).implicit_value(true);\n    program.add_argument(\"-v\", \"--verbose\").help(\"verbose logging\").default_value(false).implicit_value(true);\n    program.add_argument(\"--silent\").help(\"do not allocate console\").default_value(false).implicit_value(true);\n    program.add_argument(\"--autorun-as-user\").help(\"create autorun task as currently logged in user\").default_value(false).implicit_value(true);\n    program.add_argument(\"--disable-autorun\").help(\"disable autorun task creation\").default_value(false).implicit_value(true);\n    program.add_argument(\"--from-autorun\").hidden().default_value(false).implicit_value(true);\n\n    try {\n        program.parse_args(argc, argv);\n    } catch (std::exception& e) {\n        std::stringstream ss;\n        ss << e.what() << '\\n';\n        ss << program.help().str();\n        fatal_print(ss.str());\n        return EXIT_FAILURE;\n    }\n\n    auto config = loader::Config{\n        .name = program.get<std::string>(\"-n\"),\n        .disable = program.get<bool>(\"-d\"),\n        .alloc_console = !program.get<bool>(\"--silent\"),\n        .verbose = program.get<bool>(\"-v\"),\n        .from_autorun = program.get<bool>(\"--from-autorun\"),\n        .autorun_type = program.get<bool>(\"--autorun-as-user\") ? /// As system on boot is the default value\n                            loader::AutorunType::AS_CURRENT_USER_ON_LOGIN :\n                            loader::AutorunType::AS_SYSTEM_ON_BOOT,\n        .enable_autorun = !program.get<bool>(\"--disable-autorun\"),\n    };\n\n    /// When running from autorun, we'll be missing all the cli arguments, so lets load some relevant ones\n    if (config.from_autorun) {\n        shared::ctx.deserialize();\n        config.verbose = shared::ctx.verbose;\n    }\n\n    if (!config.alloc_console && config.verbose) {\n        fatal_print(\"--silent flag can not be used in combination with --verbose\");\n    }\n\n    setup_window(config);\n    loader::ensure_environment();\n\n    setup_context(config);\n\n    /// \\todo @es3n1n: move this to a separate function and add move ctor for ipc\n    std::println(\"** setting up ipc\");\n    auto ipc = shared::InterProcessCommunication(shared::InterProcessCommunicationMode::READ_WRITE, true);\n    ipc->finished = false;\n\n    const auto process = load_defendnot();\n    defer->void {\n        TerminateProcess(process, 0);\n    };\n\n    wait_for_finish(ipc);\n\n    /// Only create autorun task when not running from autorun, no need to recreate it because we're missing some config vars\n    if (!config.from_autorun) {\n        process_autorun(config);\n    }\n\n    banner(config);\n\n    return EXIT_SUCCESS;\n} catch (std::exception& err) {\n    shared::alloc_console();\n    std::println(stderr, \"** fatal error: {}\", err.what());\n    system(\"pause\");\n    return EXIT_FAILURE;\n}\n\nint WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR lpCmdLine, int nCmdShow) {\n    return main(__argc, __argv);\n}\n"], ["/defendnot/wsc-binary-check/main.cpp", "#include <Windows.h>\n#include <winternl.h>\n\n#include <filesystem>\n#include <fstream>\n#include <optional>\n#include <print>\n#include <ranges>\n#include <set>\n\n#include \"shared/defer.hpp\"\n\n#pragma comment(lib, \"Crypt32.lib\")\n\nnamespace {\n    constexpr std::string_view kTargetDirectory = \"c:\\\\Windows\\\\System32\";\n    /* constexpr */ auto kTargetFileExts = std::set<std::string_view>{\".exe\"};\n\n    constexpr std::uint16_t kDosMagic = 0x5A4D;\n    constexpr std::uint32_t kNtSignature = 0x00004550;\n    constexpr std::uint16_t kARM64Machine = 0xAA64;\n    constexpr std::uint16_t kAMD64Machine = 0x8664;\n    constexpr std::uint16_t kI386Machine = 0x014C;\n    constexpr std::uint16_t kDllCharacteristicsForceIntegrityMask = 0x80;\n\n    [[nodiscard]] std::optional<std::vector<std::uint8_t>> read_file(const std::filesystem::path path) {\n        std::ifstream file(path, std::ios::binary);\n        if (!file.good()) {\n            return std::nullopt;\n        }\n\n        const auto size = std::filesystem::file_size(path);\n        std::vector<std::uint8_t> buffer(size);\n\n        file.read(reinterpret_cast<char*>(buffer.data()), static_cast<std::streamsize>(buffer.size()));\n        return buffer;\n    }\n\n    [[nodiscard]] bool check_characteristics(const std::span<std::uint8_t> data) {\n        if (data.size() < sizeof(IMAGE_DOS_HEADER)) {\n            throw std::runtime_error(\"got invalid pe image\");\n        }\n\n        const auto p_dos = reinterpret_cast<PIMAGE_DOS_HEADER>(data.data());\n        if (p_dos->e_magic != kDosMagic) {\n            throw std::runtime_error(\"got invalid pe image (2)\");\n        }\n\n        const auto p_nt = reinterpret_cast<PIMAGE_NT_HEADERS>(data.data() + p_dos->e_lfanew);\n        if (p_nt->Signature != kNtSignature) {\n            throw std::runtime_error(\"got invalid pe image (3)\");\n        }\n\n        const auto machine = p_nt->FileHeader.Machine;\n        std::uint16_t characteristics;\n\n        if (machine == kARM64Machine || machine == kAMD64Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS64>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else if (machine == kI386Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS32>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else {\n            throw std::runtime_error(std::format(\"unsupported machine: {:#x}\", machine));\n        }\n\n        return (characteristics & kDllCharacteristicsForceIntegrityMask) != 0;\n    }\n\n    [[nodiscard]] bool check_signature(const std::filesystem::path path) {\n        HCERTSTORE store = {0};\n        HCRYPTMSG msg = {0};\n        if (!CryptQueryObject(1, path.wstring().c_str(), 0x400, 0xE, 0, nullptr, nullptr, nullptr, &store, &msg, nullptr) //\n            || !store || !msg) {\n            /// Most likely the binary is just not signed\n            return false;\n        }\n\n        defer->void {\n            CryptMsgClose(msg);\n            CertCloseStore(store, 1);\n        };\n\n        PCCERT_CONTEXT signer = nullptr;\n        if (!CryptMsgGetAndVerifySigner(msg, 0, nullptr, 2, &signer, nullptr) || signer == nullptr) {\n            throw std::runtime_error(std::format(\"CryptMsgGetAndVerifySigner() on {}\", path.string()));\n        }\n\n        defer->void {\n            CertFreeCertificateContext(signer);\n        };\n\n        /// I don't think we have to do something with signer?\n        return true;\n    }\n} // namespace\n\nint main() try {\n    for (auto& entry : std::filesystem::recursive_directory_iterator(kTargetDirectory, std::filesystem::directory_options::skip_permission_denied)) {\n        auto path = entry.path();\n        auto ext = path.extension().string() //\n                   | std::views::transform([](const char c) -> char { return ::tolower(c); }) //\n                   | std::ranges::to<std::string>();\n\n        if (!kTargetFileExts.contains(ext)) {\n            continue;\n        }\n\n        auto file = read_file(path);\n        if (!file.has_value()) {\n            std::println(stderr, \"unable to read {}\", path.string());\n            continue;\n        }\n\n        const std::span file_ptr = *file;\n        if (!check_characteristics(file_ptr)) {\n            continue;\n        }\n\n        if (!check_signature(path)) {\n            continue;\n        }\n\n        std::println(\"matches: {}\", path.string());\n    }\n\n    return EXIT_SUCCESS;\n} catch (const std::exception& e) {\n    std::println(stderr, \"fatal error: {}\", e.what());\n    return EXIT_FAILURE;\n}\n"], ["/defendnot/defendnot-loader/core/autorun.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/com.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/strings.hpp\"\n\n#include <memory>\n#include <print>\n#include <stdexcept>\n#include <type_traits>\n\n#include <comdef.h>\n#include <taskschd.h>\n\n#pragma comment(lib, \"taskschd.lib\")\n#pragma comment(lib, \"comsupp.lib\")\n#pragma comment(lib, \"ole32.lib\")\n\nnamespace loader {\n    namespace {\n        constexpr std::string_view kTaskName = strings::kProjectName;\n\n        void co_initialize() {\n            static std::once_flag fl;\n            std::call_once(fl, []() -> void {\n                const auto result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);\n\n                if (FAILED(result)) {\n                    throw std::runtime_error(\"failed to CoInitializeEx\");\n                }\n            });\n        }\n\n        template <typename Callable>\n        [[nodiscard]] bool with_service(Callable&& callback) {\n            co_initialize();\n\n            com::Ptr<ITaskService> service;\n            auto hr =\n                CoCreateInstance(CLSID_TaskScheduler, nullptr, CLSCTX_INPROC_SERVER, IID_ITaskService, reinterpret_cast<void**>(service.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            hr = service->Connect(VARIANT{}, VARIANT{}, VARIANT{}, VARIANT{});\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskFolder> root_folder;\n            hr = service->GetFolder(BSTR(L\"\\\\\"), root_folder.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Cleanup our task, we will recreate it in the callback if needed\n            root_folder->DeleteTask(BSTR(kTaskName.data()), 0);\n            return callback(service.get(), root_folder.get());\n        }\n    } // namespace\n\n    [[nodiscard]] bool add_to_autorun(AutorunType type) {\n        const auto bin_path = shared::get_this_module_path();\n\n        return with_service([bin_path, type](ITaskService* service, ITaskFolder* folder) -> bool {\n            /// Deduce the autorun config based on type\n            const auto task_trigger = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_TRIGGER_BOOT : TASK_TRIGGER_LOGON;\n            const auto logon_type = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_LOGON_SERVICE_ACCOUNT : TASK_LOGON_INTERACTIVE_TOKEN;\n\n            BSTR user_id = nullptr;\n            auto bstr_sys = bstr_t(L\"SYSTEM\");\n            if (type == AutorunType::AS_SYSTEM_ON_BOOT) {\n                user_id = bstr_sys;\n            }\n\n            com::Ptr<ITaskDefinition> task;\n            auto hr = service->NewTask(0, task.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IRegistrationInfo> reg_info;\n            hr = task->get_RegistrationInfo(reg_info.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IPrincipal> principal;\n            hr = task->get_Principal(principal.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITriggerCollection> trigger_collection;\n            hr = task->get_Triggers(trigger_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITrigger> trigger;\n            hr = trigger_collection->Create(task_trigger, trigger.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IActionCollection> action_collection;\n            hr = task->get_Actions(action_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IAction> action;\n            hr = action_collection->Create(TASK_ACTION_EXEC, action.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IExecAction> exec_action;\n            hr = action->QueryInterface(IID_IExecAction, reinterpret_cast<void**>(exec_action.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskSettings> settings;\n            hr = task->get_Settings(settings.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Elevated, when system boots\n            principal->put_UserId(user_id);\n            principal->put_LogonType(logon_type);\n            principal->put_RunLevel(TASK_RUNLEVEL_HIGHEST);\n\n            /// Info\n            reg_info->put_Author(bstr_t(strings::kRepoUrl.data()));\n\n            /// Start even if we're on batteries\n            settings->put_DisallowStartIfOnBatteries(VARIANT_FALSE);\n            settings->put_StopIfGoingOnBatteries(VARIANT_FALSE);\n\n            /// Binary\n            exec_action->put_Path(bstr_t(bin_path.string().c_str()));\n            exec_action->put_Arguments(bstr_t(\"--from-autorun\"));\n\n            /// Register the task and we are done\n            com::Ptr<IRegisteredTask> registered_task;\n            hr = folder->RegisterTaskDefinition(bstr_t(kTaskName.data()), task.get(), TASK_CREATE_OR_UPDATE, VARIANT{}, VARIANT{}, TASK_LOGON_NONE,\n                                                variant_t(L\"\"), registered_task.ref_to_ptr());\n            return SUCCEEDED(hr);\n        });\n    }\n\n    [[nodiscard]] bool remove_from_autorun() {\n        return with_service([]<typename... TArgs>(TArgs...) -> bool { return true; });\n    }\n} // namespace loader\n"], ["/defendnot/defendnot/bootstrap/bootstrap.cpp", "#include \"bootstrap.hpp\"\n#include \"core/com.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n\n#include <Windows.h>\n\nnamespace defendnot {\n    namespace {\n        template <com::ComObject Ty>\n        void apply(const std::string_view log_prefix, const BSTR name) {\n            /// Get the WSC interface\n            auto inst = com::query<Ty>();\n\n            /// This can fail if we dont have any products registered so no com_checked\n            logln(\"{}_unregister: {:#x}\", log_prefix, com::retry_while_pending([&inst]() -> HRESULT { return inst->Unregister(); }) & 0xFFFFFFFF);\n            if (shared::ctx.state == shared::State::OFF) {\n                return;\n            }\n\n            /// Register and activate\n            logln(\"{}_register: {:#x}\", log_prefix, com::checked(inst->Register(name, name, 0, 0)));\n            logln(\"{}_update: {:#x}\", log_prefix, com::checked(inst->UpdateStatus(WSCSecurityProductState::ON, static_cast<BOOL>(true))));\n\n            /// Update the substatuses, if the interface supports this\n            if constexpr (std::is_same_v<Ty, IWscAVStatus4>) {\n                logln(\"{}_scan_update: {:#x}\", log_prefix, com::checked(inst->UpdateScanSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_settings_update: {:#x}\", log_prefix, com::checked(inst->UpdateSettingsSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_prot_update: {:#x}\", log_prefix, com::checked(inst->UpdateProtectionUpdateSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n            }\n        }\n    } // namespace\n\n    void startup() {\n        /// Setup\n        shared::ctx.deserialize();\n        logln(\"init: {:#x}\", com::checked(CoInitialize(nullptr)));\n\n        /// WSC will reject the register request if name is empty\n        auto name_w = std::wstring(shared::ctx.name.begin(), shared::ctx.name.end());\n        if (name_w.empty()) {\n            throw std::runtime_error(\"AV Name can not be empty!\");\n        }\n\n        /// Convert to BSTR\n        auto name = SysAllocString(name_w.c_str());\n        defer->void {\n            SysFreeString(name);\n        };\n\n        /// Register our stuff in the WSC interfaces\n        apply<IWscASStatus>(\"IWscASStatus\", name);\n        apply<IWscAVStatus4>(\"IWscAVStatus4\", name);\n    }\n} // namespace defendnot\n"], ["/defendnot/defendnot-loader/core/ensure_environment.cpp", "#include \"core/core.hpp\"\n#include \"shared/strings.hpp\"\n#include \"util/scm.hpp\"\n\n#include <format>\n#include <print>\n#include <stdexcept>\n\nnamespace loader {\n    void ensure_environment() {\n        auto manager = scm::Manager();\n        if (!manager.valid()) [[unlikely]] {\n            throw std::runtime_error(\"Unable to open scm::Manager\");\n        }\n\n        auto service = manager.get_service(L\"wscsvc\");\n        if (!service.valid() || !service.query_status()) {\n            throw std::runtime_error(std::format(\"{}\\nOpen error: {}\", strings::wsc_unavailable_error().data(), GetLastError()));\n        }\n\n        if (service.state() == scm::ServiceState::RUNNING) {\n            /// Wsc service has been already started, no need to start it ourselves\n            return;\n        }\n\n        /// Let's start the service ourselves\n        std::println(\"** wscsvc is not running, starting it..\");\n        if (!service.start()) {\n            throw std::runtime_error(std::format(\"{}\\nTried to start the service, but go an error: {}\", strings::wsc_unavailable_error(), GetLastError()));\n        }\n\n        std::println(\"** successfully started the service, waiting for it to get up..\");\n        while (true) {\n            if (!service.query_status(/*force=*/true)) {\n                throw std::runtime_error(\n                    std::format(\"{}\\nStarted the service, got an error while querying: {}\", strings::wsc_unavailable_error(), GetLastError()));\n            }\n\n            if (const auto state = service.state(); state == scm::ServiceState::RUNNING) {\n                std::println(\"** we are good to go\");\n                return;\n            }\n\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n    }\n} // namespace loader\n"]], "task_instance_info": {"created_time": "2025-08-20 19:54:27", "created_task_model": "DeepSeek-R1", "function_skeleton": "void entry_thread(HMODULE base) {}", "code_description": "This code segment functions to: Initialize inter-process communication channels, execute a startup sequence with error handling, propagate operation status through shared resources, and manage thread termination with resource cleanup."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```cpp\n[TASK_BEGIN]\nvoid entry_thread(HMODULE base) {\n    Bootstrap::init();\n    \n    try {\n        core::log_init();\n        shared::ipc::main_loop();\n    }\n    catch (const std::exception& e) {\n        LOG_ERROR(\"Unhandled exception: {}\", e.what());\n    }\n    __finally {\n        Bootstrap::shutdown();\n        FreeLibraryAndExitThread(base, 0);\n    }\n}\n[TASK_END]\n```", "inference_time": "2025-08-20 19-54-43"}, "editdistance_info": {"edit_distance": 25.0, "calculate_time": "2025-08-20 19:54:43", "true_code_clean": "void entry_thread(HMODULE base) {\n        bool success = false;\n        std::unique_ptr<shared::InterProcessCommunication> ipc;\n        try {\n            ipc = std::make_unique<shared::InterProcessCommunication>(shared::InterProcessCommunicationMode::WRITE);\n            defendnot::startup();\n            success = true;\n        } catch (std::exception& err) {\n            MessageBoxA(nullptr, err.what(), \"defendnot\", MB_TOPMOST | MB_ICONERROR);\n        }\n        if (ipc) {\n            (*ipc)->success = success;\n            (*ipc)->finished = true;\n        }\n        FreeLibraryAndExitThread(base, 0);\n    }", "predict_code_clean": "void entry_thread(HMODULE base) {\n    Bootstrap::init();\n    try {\n        core::log_init();\n        shared::ipc::main_loop();\n    }\n    catch (const std::exception& e) {\n        LOG_ERROR(\"Unhandled exception: {}\", e.what());\n    }\n    __finally {\n        Bootstrap::shutdown();\n        FreeLibraryAndExitThread(base, 0);\n    }\n}"}}
{"repo_name": "defendnot", "file_name": "/defendnot/defendnot/bootstrap/bootstrap.cpp", "inference_info": {"prefix_code": "#include \"bootstrap.hpp\"\n#include \"core/com.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n\n#include <Windows.h>\n\nnamespace defendnot {\n    namespace {\n        template <com::ComObject Ty>\n        ", "suffix_code": "\n    } // namespace\n\n    void startup() {\n        /// Setup\n        shared::ctx.deserialize();\n        logln(\"init: {:#x}\", com::checked(CoInitialize(nullptr)));\n\n        /// WSC will reject the register request if name is empty\n        auto name_w = std::wstring(shared::ctx.name.begin(), shared::ctx.name.end());\n        if (name_w.empty()) {\n            throw std::runtime_error(\"AV Name can not be empty!\");\n        }\n\n        /// Convert to BSTR\n        auto name = SysAllocString(name_w.c_str());\n        defer->void {\n            SysFreeString(name);\n        };\n\n        /// Register our stuff in the WSC interfaces\n        apply<IWscASStatus>(\"IWscASStatus\", name);\n        apply<IWscAVStatus4>(\"IWscAVStatus4\", name);\n    }\n} // namespace defendnot\n", "middle_code": "void apply(const std::string_view log_prefix, const BSTR name) {\n            auto inst = com::query<Ty>();\n            logln(\"{}_unregister: {:#x}\", log_prefix, com::retry_while_pending([&inst]() -> HRESULT { return inst->Unregister(); }) & 0xFFFFFFFF);\n            if (shared::ctx.state == shared::State::OFF) {\n                return;\n            }\n            logln(\"{}_register: {:#x}\", log_prefix, com::checked(inst->Register(name, name, 0, 0)));\n            logln(\"{}_update: {:#x}\", log_prefix, com::checked(inst->UpdateStatus(WSCSecurityProductState::ON, static_cast<BOOL>(true))));\n            if constexpr (std::is_same_v<Ty, IWscAVStatus4>) {\n                logln(\"{}_scan_update: {:#x}\", log_prefix, com::checked(inst->UpdateScanSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_settings_update: {:#x}\", log_prefix, com::checked(inst->UpdateSettingsSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_prot_update: {:#x}\", log_prefix, com::checked(inst->UpdateProtectionUpdateSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n            }\n        }", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "cpp", "sub_task_type": null}, "context_code": [["/defendnot/defendnot-loader/core/autorun.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/com.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/strings.hpp\"\n\n#include <memory>\n#include <print>\n#include <stdexcept>\n#include <type_traits>\n\n#include <comdef.h>\n#include <taskschd.h>\n\n#pragma comment(lib, \"taskschd.lib\")\n#pragma comment(lib, \"comsupp.lib\")\n#pragma comment(lib, \"ole32.lib\")\n\nnamespace loader {\n    namespace {\n        constexpr std::string_view kTaskName = strings::kProjectName;\n\n        void co_initialize() {\n            static std::once_flag fl;\n            std::call_once(fl, []() -> void {\n                const auto result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);\n\n                if (FAILED(result)) {\n                    throw std::runtime_error(\"failed to CoInitializeEx\");\n                }\n            });\n        }\n\n        template <typename Callable>\n        [[nodiscard]] bool with_service(Callable&& callback) {\n            co_initialize();\n\n            com::Ptr<ITaskService> service;\n            auto hr =\n                CoCreateInstance(CLSID_TaskScheduler, nullptr, CLSCTX_INPROC_SERVER, IID_ITaskService, reinterpret_cast<void**>(service.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            hr = service->Connect(VARIANT{}, VARIANT{}, VARIANT{}, VARIANT{});\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskFolder> root_folder;\n            hr = service->GetFolder(BSTR(L\"\\\\\"), root_folder.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Cleanup our task, we will recreate it in the callback if needed\n            root_folder->DeleteTask(BSTR(kTaskName.data()), 0);\n            return callback(service.get(), root_folder.get());\n        }\n    } // namespace\n\n    [[nodiscard]] bool add_to_autorun(AutorunType type) {\n        const auto bin_path = shared::get_this_module_path();\n\n        return with_service([bin_path, type](ITaskService* service, ITaskFolder* folder) -> bool {\n            /// Deduce the autorun config based on type\n            const auto task_trigger = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_TRIGGER_BOOT : TASK_TRIGGER_LOGON;\n            const auto logon_type = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_LOGON_SERVICE_ACCOUNT : TASK_LOGON_INTERACTIVE_TOKEN;\n\n            BSTR user_id = nullptr;\n            auto bstr_sys = bstr_t(L\"SYSTEM\");\n            if (type == AutorunType::AS_SYSTEM_ON_BOOT) {\n                user_id = bstr_sys;\n            }\n\n            com::Ptr<ITaskDefinition> task;\n            auto hr = service->NewTask(0, task.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IRegistrationInfo> reg_info;\n            hr = task->get_RegistrationInfo(reg_info.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IPrincipal> principal;\n            hr = task->get_Principal(principal.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITriggerCollection> trigger_collection;\n            hr = task->get_Triggers(trigger_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITrigger> trigger;\n            hr = trigger_collection->Create(task_trigger, trigger.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IActionCollection> action_collection;\n            hr = task->get_Actions(action_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IAction> action;\n            hr = action_collection->Create(TASK_ACTION_EXEC, action.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IExecAction> exec_action;\n            hr = action->QueryInterface(IID_IExecAction, reinterpret_cast<void**>(exec_action.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskSettings> settings;\n            hr = task->get_Settings(settings.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Elevated, when system boots\n            principal->put_UserId(user_id);\n            principal->put_LogonType(logon_type);\n            principal->put_RunLevel(TASK_RUNLEVEL_HIGHEST);\n\n            /// Info\n            reg_info->put_Author(bstr_t(strings::kRepoUrl.data()));\n\n            /// Start even if we're on batteries\n            settings->put_DisallowStartIfOnBatteries(VARIANT_FALSE);\n            settings->put_StopIfGoingOnBatteries(VARIANT_FALSE);\n\n            /// Binary\n            exec_action->put_Path(bstr_t(bin_path.string().c_str()));\n            exec_action->put_Arguments(bstr_t(\"--from-autorun\"));\n\n            /// Register the task and we are done\n            com::Ptr<IRegisteredTask> registered_task;\n            hr = folder->RegisterTaskDefinition(bstr_t(kTaskName.data()), task.get(), TASK_CREATE_OR_UPDATE, VARIANT{}, VARIANT{}, TASK_LOGON_NONE,\n                                                variant_t(L\"\"), registered_task.ref_to_ptr());\n            return SUCCEEDED(hr);\n        });\n    }\n\n    [[nodiscard]] bool remove_from_autorun() {\n        return with_service([]<typename... TArgs>(TArgs...) -> bool { return true; });\n    }\n} // namespace loader\n"], ["/defendnot/defendnot-loader/main.cpp", "#include \"core/core.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n#include \"shared/ipc.hpp\"\n#include \"shared/strings.hpp\"\n#include <argparse/argparse.hpp>\n\n#include <format>\n#include <print>\n#include <thread>\n\nnamespace {\n    void setup_window(const loader::Config& config) {\n        if ((!config.from_autorun || config.verbose) && config.alloc_console) {\n            shared::alloc_console();\n        }\n    }\n\n    void setup_context(const loader::Config& config) {\n        std::println(\"** setting up context\");\n\n        if (config.name.length() > shared::kMaxNameLength) {\n            throw std::runtime_error(std::format(\"Max name length is {} characters\", shared::kMaxNameLength));\n        }\n\n        shared::ctx.state = config.disable ? shared::State::OFF : shared::State::ON;\n        shared::ctx.verbose = config.verbose;\n        std::ranges::copy(config.name, shared::ctx.name.data());\n\n        /// No need to overwrite ctx if we are called from autorun\n        if (!config.from_autorun) {\n            std::println(\"** overwriting ctx.bin\");\n            shared::ctx.serialize();\n        }\n    }\n\n    [[nodiscard]] HANDLE load_defendnot() {\n        std::println(\"** loading defendnot\");\n\n        auto dll_path = shared::get_this_module_path().parent_path();\n        dll_path /= strings::kDllName;\n        if (!std::filesystem::exists(dll_path)) {\n            throw std::runtime_error(std::format(\"{} does not exist!\", strings::kDllName));\n        }\n\n        return loader::inject(dll_path.string(), strings::kVictimProcess);\n    }\n\n    void wait_for_finish(shared::InterProcessCommunication& ipc) {\n        std::println(\"** waiting for process to finish, this can take a while\");\n        std::cout << std::flush;\n        while (!ipc->finished) {\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n        std::println(\"** success: {}\", ipc->success);\n    }\n\n    void process_autorun(const loader::Config& config) {\n        if (shared::ctx.state == shared::State::ON && config.enable_autorun) {\n            std::println(\"** added to autorun: {}\", loader::add_to_autorun(config.autorun_type));\n        } else {\n            std::println(\"** removed from autorun: {}\", loader::remove_from_autorun());\n        }\n    }\n\n    void banner(const loader::Config& config) {\n        std::println();\n        std::println(\"thanks for using {}\", strings::kProjectName);\n        std::println(\"please don't forget to leave a star at {}\", strings::kRepoUrl);\n\n        if (!config.from_autorun && config.alloc_console) {\n            system(\"pause\");\n        }\n    }\n} // namespace\n\nint main(int argc, char* argv[]) try {\n    argparse::ArgumentParser program(std::format(\"{}-loader\", strings::kProjectName), strings::kVersion.data(), argparse::default_arguments::none);\n\n    const auto fatal_print = [](const std::string_view str) -> void {\n        shared::alloc_console();\n        std::cerr << str << std::endl;\n        system(\"pause\");\n        std::exit(EXIT_FAILURE);\n    };\n\n    /// We are registering these ourselves because we have to alloc console first\n    program.add_argument(\"-h\", \"--help\")\n        .help(\"prints help message and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print, &program](const auto& /*unused*/) -> void { fatal_print(program.help().str()); });\n    program.add_argument(\"--version\")\n        .help(\"shows version and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print](const auto& /*unused*/) -> void { fatal_print(std::format(\"{}-loader v{}\", strings::kProjectName, strings::kVersion)); });\n\n    /// defendnot-loader parameters:\n    program.add_argument(\"-n\", \"--name\").help(\"av display name\").default_value(std::string(strings::kDefaultAVName)).nargs(1);\n    program.add_argument(\"-d\", \"--disable\").help(std::format(\"disable {}\", strings::kProjectName)).default_value(false).implicit_value(true);\n    program.add_argument(\"-v\", \"--verbose\").help(\"verbose logging\").default_value(false).implicit_value(true);\n    program.add_argument(\"--silent\").help(\"do not allocate console\").default_value(false).implicit_value(true);\n    program.add_argument(\"--autorun-as-user\").help(\"create autorun task as currently logged in user\").default_value(false).implicit_value(true);\n    program.add_argument(\"--disable-autorun\").help(\"disable autorun task creation\").default_value(false).implicit_value(true);\n    program.add_argument(\"--from-autorun\").hidden().default_value(false).implicit_value(true);\n\n    try {\n        program.parse_args(argc, argv);\n    } catch (std::exception& e) {\n        std::stringstream ss;\n        ss << e.what() << '\\n';\n        ss << program.help().str();\n        fatal_print(ss.str());\n        return EXIT_FAILURE;\n    }\n\n    auto config = loader::Config{\n        .name = program.get<std::string>(\"-n\"),\n        .disable = program.get<bool>(\"-d\"),\n        .alloc_console = !program.get<bool>(\"--silent\"),\n        .verbose = program.get<bool>(\"-v\"),\n        .from_autorun = program.get<bool>(\"--from-autorun\"),\n        .autorun_type = program.get<bool>(\"--autorun-as-user\") ? /// As system on boot is the default value\n                            loader::AutorunType::AS_CURRENT_USER_ON_LOGIN :\n                            loader::AutorunType::AS_SYSTEM_ON_BOOT,\n        .enable_autorun = !program.get<bool>(\"--disable-autorun\"),\n    };\n\n    /// When running from autorun, we'll be missing all the cli arguments, so lets load some relevant ones\n    if (config.from_autorun) {\n        shared::ctx.deserialize();\n        config.verbose = shared::ctx.verbose;\n    }\n\n    if (!config.alloc_console && config.verbose) {\n        fatal_print(\"--silent flag can not be used in combination with --verbose\");\n    }\n\n    setup_window(config);\n    loader::ensure_environment();\n\n    setup_context(config);\n\n    /// \\todo @es3n1n: move this to a separate function and add move ctor for ipc\n    std::println(\"** setting up ipc\");\n    auto ipc = shared::InterProcessCommunication(shared::InterProcessCommunicationMode::READ_WRITE, true);\n    ipc->finished = false;\n\n    const auto process = load_defendnot();\n    defer->void {\n        TerminateProcess(process, 0);\n    };\n\n    wait_for_finish(ipc);\n\n    /// Only create autorun task when not running from autorun, no need to recreate it because we're missing some config vars\n    if (!config.from_autorun) {\n        process_autorun(config);\n    }\n\n    banner(config);\n\n    return EXIT_SUCCESS;\n} catch (std::exception& err) {\n    shared::alloc_console();\n    std::println(stderr, \"** fatal error: {}\", err.what());\n    system(\"pause\");\n    return EXIT_FAILURE;\n}\n\nint WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR lpCmdLine, int nCmdShow) {\n    return main(__argc, __argv);\n}\n"], ["/defendnot/wsc-binary-check/main.cpp", "#include <Windows.h>\n#include <winternl.h>\n\n#include <filesystem>\n#include <fstream>\n#include <optional>\n#include <print>\n#include <ranges>\n#include <set>\n\n#include \"shared/defer.hpp\"\n\n#pragma comment(lib, \"Crypt32.lib\")\n\nnamespace {\n    constexpr std::string_view kTargetDirectory = \"c:\\\\Windows\\\\System32\";\n    /* constexpr */ auto kTargetFileExts = std::set<std::string_view>{\".exe\"};\n\n    constexpr std::uint16_t kDosMagic = 0x5A4D;\n    constexpr std::uint32_t kNtSignature = 0x00004550;\n    constexpr std::uint16_t kARM64Machine = 0xAA64;\n    constexpr std::uint16_t kAMD64Machine = 0x8664;\n    constexpr std::uint16_t kI386Machine = 0x014C;\n    constexpr std::uint16_t kDllCharacteristicsForceIntegrityMask = 0x80;\n\n    [[nodiscard]] std::optional<std::vector<std::uint8_t>> read_file(const std::filesystem::path path) {\n        std::ifstream file(path, std::ios::binary);\n        if (!file.good()) {\n            return std::nullopt;\n        }\n\n        const auto size = std::filesystem::file_size(path);\n        std::vector<std::uint8_t> buffer(size);\n\n        file.read(reinterpret_cast<char*>(buffer.data()), static_cast<std::streamsize>(buffer.size()));\n        return buffer;\n    }\n\n    [[nodiscard]] bool check_characteristics(const std::span<std::uint8_t> data) {\n        if (data.size() < sizeof(IMAGE_DOS_HEADER)) {\n            throw std::runtime_error(\"got invalid pe image\");\n        }\n\n        const auto p_dos = reinterpret_cast<PIMAGE_DOS_HEADER>(data.data());\n        if (p_dos->e_magic != kDosMagic) {\n            throw std::runtime_error(\"got invalid pe image (2)\");\n        }\n\n        const auto p_nt = reinterpret_cast<PIMAGE_NT_HEADERS>(data.data() + p_dos->e_lfanew);\n        if (p_nt->Signature != kNtSignature) {\n            throw std::runtime_error(\"got invalid pe image (3)\");\n        }\n\n        const auto machine = p_nt->FileHeader.Machine;\n        std::uint16_t characteristics;\n\n        if (machine == kARM64Machine || machine == kAMD64Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS64>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else if (machine == kI386Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS32>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else {\n            throw std::runtime_error(std::format(\"unsupported machine: {:#x}\", machine));\n        }\n\n        return (characteristics & kDllCharacteristicsForceIntegrityMask) != 0;\n    }\n\n    [[nodiscard]] bool check_signature(const std::filesystem::path path) {\n        HCERTSTORE store = {0};\n        HCRYPTMSG msg = {0};\n        if (!CryptQueryObject(1, path.wstring().c_str(), 0x400, 0xE, 0, nullptr, nullptr, nullptr, &store, &msg, nullptr) //\n            || !store || !msg) {\n            /// Most likely the binary is just not signed\n            return false;\n        }\n\n        defer->void {\n            CryptMsgClose(msg);\n            CertCloseStore(store, 1);\n        };\n\n        PCCERT_CONTEXT signer = nullptr;\n        if (!CryptMsgGetAndVerifySigner(msg, 0, nullptr, 2, &signer, nullptr) || signer == nullptr) {\n            throw std::runtime_error(std::format(\"CryptMsgGetAndVerifySigner() on {}\", path.string()));\n        }\n\n        defer->void {\n            CertFreeCertificateContext(signer);\n        };\n\n        /// I don't think we have to do something with signer?\n        return true;\n    }\n} // namespace\n\nint main() try {\n    for (auto& entry : std::filesystem::recursive_directory_iterator(kTargetDirectory, std::filesystem::directory_options::skip_permission_denied)) {\n        auto path = entry.path();\n        auto ext = path.extension().string() //\n                   | std::views::transform([](const char c) -> char { return ::tolower(c); }) //\n                   | std::ranges::to<std::string>();\n\n        if (!kTargetFileExts.contains(ext)) {\n            continue;\n        }\n\n        auto file = read_file(path);\n        if (!file.has_value()) {\n            std::println(stderr, \"unable to read {}\", path.string());\n            continue;\n        }\n\n        const std::span file_ptr = *file;\n        if (!check_characteristics(file_ptr)) {\n            continue;\n        }\n\n        if (!check_signature(path)) {\n            continue;\n        }\n\n        std::println(\"matches: {}\", path.string());\n    }\n\n    return EXIT_SUCCESS;\n} catch (const std::exception& e) {\n    std::println(stderr, \"fatal error: {}\", e.what());\n    return EXIT_FAILURE;\n}\n"], ["/defendnot/defendnot-loader/core/ensure_environment.cpp", "#include \"core/core.hpp\"\n#include \"shared/strings.hpp\"\n#include \"util/scm.hpp\"\n\n#include <format>\n#include <print>\n#include <stdexcept>\n\nnamespace loader {\n    void ensure_environment() {\n        auto manager = scm::Manager();\n        if (!manager.valid()) [[unlikely]] {\n            throw std::runtime_error(\"Unable to open scm::Manager\");\n        }\n\n        auto service = manager.get_service(L\"wscsvc\");\n        if (!service.valid() || !service.query_status()) {\n            throw std::runtime_error(std::format(\"{}\\nOpen error: {}\", strings::wsc_unavailable_error().data(), GetLastError()));\n        }\n\n        if (service.state() == scm::ServiceState::RUNNING) {\n            /// Wsc service has been already started, no need to start it ourselves\n            return;\n        }\n\n        /// Let's start the service ourselves\n        std::println(\"** wscsvc is not running, starting it..\");\n        if (!service.start()) {\n            throw std::runtime_error(std::format(\"{}\\nTried to start the service, but go an error: {}\", strings::wsc_unavailable_error(), GetLastError()));\n        }\n\n        std::println(\"** successfully started the service, waiting for it to get up..\");\n        while (true) {\n            if (!service.query_status(/*force=*/true)) {\n                throw std::runtime_error(\n                    std::format(\"{}\\nStarted the service, got an error while querying: {}\", strings::wsc_unavailable_error(), GetLastError()));\n            }\n\n            if (const auto state = service.state(); state == scm::ServiceState::RUNNING) {\n                std::println(\"** we are good to go\");\n                return;\n            }\n\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n    }\n} // namespace loader\n"], ["/defendnot/defendnot-loader/core/inject.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/defer.hpp\"\n#include \"shared/native.hpp\"\n\n#include <print>\n#include <stdexcept>\n\n#include <Windows.h>\n\nnamespace loader {\n    [[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {\n        STARTUPINFOA si = {\n            .cb = sizeof(si),\n        };\n        PROCESS_INFORMATION pi = {\n            0,\n        };\n        SECURITY_ATTRIBUTES sa = {\n            .nLength = sizeof(sa),\n            .bInheritHandle = TRUE,\n        };\n\n        /// By setting ReadImageFileExecOptions to FALSE and attaching ourselves as a debugger we can skip the IFEO\n        /// \\xref: https://github.com/es3n1n/defendnot/issues/7#issuecomment-2874903650\n        native::get_peb()->read_image_file_exec_options = 0;\n\n        std::println(\"** booting {}\", proc_name);\n        const auto process_flags = CREATE_SUSPENDED | DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;\n        if (!CreateProcessA(nullptr, const_cast<char*>(proc_name.data()), &sa, &sa, FALSE, process_flags, nullptr, nullptr, &si, &pi)) {\n            throw std::runtime_error(std::format(\"unable to create process: {}\", GetLastError()));\n        }\n\n        /// Detach\n        native::debug_set_process_kill_on_exit(false);\n        native::debug_active_process_stop(pi.dwProcessId);\n\n        defer->void {\n            CloseHandle(pi.hThread);\n            /// Not closing hProcess because we return it\n        };\n\n        LPVOID mem = VirtualAllocEx(pi.hProcess, nullptr, dll_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);\n        if (mem == nullptr) {\n            throw std::runtime_error(std::format(\"unable to allocate memory: {}\", GetLastError()));\n        }\n\n        defer->void {\n            VirtualFreeEx(pi.hProcess, mem, 0, MEM_RELEASE);\n        };\n\n        if (!WriteProcessMemory(pi.hProcess, mem, dll_path.data(), dll_path.size() + 1, nullptr)) {\n            throw std::runtime_error(std::format(\"unable to write memory: {}\", GetLastError()));\n        }\n\n        HANDLE thread = CreateRemoteThread(pi.hProcess, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(LoadLibraryA), mem, 0, nullptr);\n        if (thread == NULL) {\n            throw std::runtime_error(std::format(\"unable to create thread: {}\", GetLastError()));\n        }\n\n        defer->void {\n            CloseHandle(thread);\n        };\n\n        /// Wait for DllMain to complete\n        WaitForSingleObject(thread, INFINITE);\n        return pi.hProcess;\n    }\n} // namespace loader\n"], ["/defendnot/defendnot/dllmain.cpp", "#include \"bootstrap/bootstrap.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ipc.hpp\"\n\n#include <stdexcept>\n#include <thread>\n\n#include <Windows.h>\n\nnamespace {\n    void entry_thread(HMODULE base) {\n        bool success = false;\n        std::unique_ptr<shared::InterProcessCommunication> ipc;\n\n        try {\n            /// Open IPC handle\n            ipc = std::make_unique<shared::InterProcessCommunication>(shared::InterProcessCommunicationMode::WRITE);\n\n            /// Invoke the real entry\n            defendnot::startup();\n            success = true;\n        } catch (std::exception& err) {\n            MessageBoxA(nullptr, err.what(), \"defendnot\", MB_TOPMOST | MB_ICONERROR);\n        }\n\n        if (ipc) {\n            (*ipc)->success = success;\n            (*ipc)->finished = true;\n        }\n\n        /// Always free out module once we are done\n        FreeLibraryAndExitThread(base, 0);\n    }\n} // namespace\n\nBOOL __stdcall DllMain(HINSTANCE base, std::uint32_t call_reason, LPVOID reserved) {\n    if (call_reason != DLL_PROCESS_ATTACH) {\n        return TRUE;\n    }\n\n    const auto th = CreateThread(nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(entry_thread), base, 0, nullptr);\n    if (th != nullptr) {\n        CloseHandle(th);\n    }\n\n    return TRUE;\n}\n"]], "task_instance_info": {"created_time": "2025-08-20 19:54:09", "created_task_model": "DeepSeek-R1", "function_skeleton": "void apply(const std::string_view log_prefix, const BSTR name) {}", "code_description": "This code segment functions to: Manage registration and status updates for security components through COM interfaces by performing conditional unregistration followed by re-registration with specified parameters, then updating operational states and sub-statuses while logging all interaction outcomes."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```cpp\n[TASK_BEGIN]\nvoid apply(const std::string_view log_prefix, const BSTR name) {\n    com::ComPtr<Ty> com_object;\n    logln(\"{}: {:#x}\", log_prefix, com::checked(com::create<Ty>(com_object)));\n\n    com::ComPtr<IWscProduct> product;\n    com::checked(com_object->QueryInterface(IID_PPV_ARGS(&product)));\n\n    com::checked(product->SetProductName(name));\n    com::checked(product->Register(0));\n}\n[TASK_END]\n```", "inference_time": "2025-08-20 19-54-53"}, "editdistance_info": {"edit_distance": 18.4783, "calculate_time": "2025-08-20 19:54:53", "true_code_clean": "void apply(const std::string_view log_prefix, const BSTR name) {\n            auto inst = com::query<Ty>();\n            logln(\"{}_unregister: {:#x}\", log_prefix, com::retry_while_pending([&inst]() -> HRESULT { return inst->Unregister(); }) & 0xFFFFFFFF);\n            if (shared::ctx.state == shared::State::OFF) {\n                return;\n            }\n            logln(\"{}_register: {:#x}\", log_prefix, com::checked(inst->Register(name, name, 0, 0)));\n            logln(\"{}_update: {:#x}\", log_prefix, com::checked(inst->UpdateStatus(WSCSecurityProductState::ON, static_cast<BOOL>(true))));\n            if constexpr (std::is_same_v<Ty, IWscAVStatus4>) {\n                logln(\"{}_scan_update: {:#x}\", log_prefix, com::checked(inst->UpdateScanSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_settings_update: {:#x}\", log_prefix, com::checked(inst->UpdateSettingsSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_prot_update: {:#x}\", log_prefix, com::checked(inst->UpdateProtectionUpdateSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n            }\n        }", "predict_code_clean": "void apply(const std::string_view log_prefix, const BSTR name) {\n    com::ComPtr<Ty> com_object;\n    logln(\"{}: {:#x}\", log_prefix, com::checked(com::create<Ty>(com_object)));\n    com::ComPtr<IWscProduct> product;\n    com::checked(com_object->QueryInterface(IID_PPV_ARGS(&product)));\n    com::checked(product->SetProductName(name));\n    com::checked(product->Register(0));\n}"}}
{"repo_name": "defendnot", "file_name": "/defendnot/wsc-binary-check/main.cpp", "inference_info": {"prefix_code": "#include <Windows.h>\n#include <winternl.h>\n\n#include <filesystem>\n#include <fstream>\n#include <optional>\n#include <print>\n#include <ranges>\n#include <set>\n\n#include \"shared/defer.hpp\"\n\n#pragma comment(lib, \"Crypt32.lib\")\n\nnamespace {\n    constexpr std::string_view kTargetDirectory = \"c:\\\\Windows\\\\System32\";\n    /* constexpr */ auto kTargetFileExts = std::set<std::string_view>{\".exe\"};\n\n    constexpr std::uint16_t kDosMagic = 0x5A4D;\n    constexpr std::uint32_t kNtSignature = 0x00004550;\n    constexpr std::uint16_t kARM64Machine = 0xAA64;\n    constexpr std::uint16_t kAMD64Machine = 0x8664;\n    constexpr std::uint16_t kI386Machine = 0x014C;\n    constexpr std::uint16_t kDllCharacteristicsForceIntegrityMask = 0x80;\n\n    [[nodiscard]] std::optional<std::vector<std::uint8_t>> read_file(const std::filesystem::path path) {\n        std::ifstream file(path, std::ios::binary);\n        if (!file.good()) {\n            return std::nullopt;\n        }\n\n        const auto size = std::filesystem::file_size(path);\n        std::vector<std::uint8_t> buffer(size);\n\n        file.read(reinterpret_cast<char*>(buffer.data()), static_cast<std::streamsize>(buffer.size()));\n        return buffer;\n    }\n\n    [[nodiscard]] bool check_characteristics(const std::span<std::uint8_t> data) {\n        if (data.size() < sizeof(IMAGE_DOS_HEADER)) {\n            throw std::runtime_error(\"got invalid pe image\");\n        }\n\n        const auto p_dos = reinterpret_cast<PIMAGE_DOS_HEADER>(data.data());\n        if (p_dos->e_magic != kDosMagic) {\n            throw std::runtime_error(\"got invalid pe image (2)\");\n        }\n\n        const auto p_nt = reinterpret_cast<PIMAGE_NT_HEADERS>(data.data() + p_dos->e_lfanew);\n        if (p_nt->Signature != kNtSignature) {\n            throw std::runtime_error(\"got invalid pe image (3)\");\n        }\n\n        const auto machine = p_nt->FileHeader.Machine;\n        std::uint16_t characteristics;\n\n        if (machine == kARM64Machine || machine == kAMD64Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS64>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else if (machine == kI386Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS32>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else {\n            throw std::runtime_error(std::format(\"unsupported machine: {:#x}\", machine));\n        }\n\n        return (characteristics & kDllCharacteristicsForceIntegrityMask) != 0;\n    }\n\n    ", "suffix_code": "\n} // namespace\n\nint main() try {\n    for (auto& entry : std::filesystem::recursive_directory_iterator(kTargetDirectory, std::filesystem::directory_options::skip_permission_denied)) {\n        auto path = entry.path();\n        auto ext = path.extension().string() //\n                   | std::views::transform([](const char c) -> char { return ::tolower(c); }) //\n                   | std::ranges::to<std::string>();\n\n        if (!kTargetFileExts.contains(ext)) {\n            continue;\n        }\n\n        auto file = read_file(path);\n        if (!file.has_value()) {\n            std::println(stderr, \"unable to read {}\", path.string());\n            continue;\n        }\n\n        const std::span file_ptr = *file;\n        if (!check_characteristics(file_ptr)) {\n            continue;\n        }\n\n        if (!check_signature(path)) {\n            continue;\n        }\n\n        std::println(\"matches: {}\", path.string());\n    }\n\n    return EXIT_SUCCESS;\n} catch (const std::exception& e) {\n    std::println(stderr, \"fatal error: {}\", e.what());\n    return EXIT_FAILURE;\n}\n", "middle_code": "[[nodiscard]] bool check_signature(const std::filesystem::path path) {\n        HCERTSTORE store = {0};\n        HCRYPTMSG msg = {0};\n        if (!CryptQueryObject(1, path.wstring().c_str(), 0x400, 0xE, 0, nullptr, nullptr, nullptr, &store, &msg, nullptr) \n            || !store || !msg) {\n            return false;\n        }\n        defer->void {\n            CryptMsgClose(msg);\n            CertCloseStore(store, 1);\n        };\n        PCCERT_CONTEXT signer = nullptr;\n        if (!CryptMsgGetAndVerifySigner(msg, 0, nullptr, 2, &signer, nullptr) || signer == nullptr) {\n            throw std::runtime_error(std::format(\"CryptMsgGetAndVerifySigner() on {}\", path.string()));\n        }\n        defer->void {\n            CertFreeCertificateContext(signer);\n        };\n        return true;\n    }", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "cpp", "sub_task_type": null}, "context_code": [["/defendnot/defendnot-loader/core/inject.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/defer.hpp\"\n#include \"shared/native.hpp\"\n\n#include <print>\n#include <stdexcept>\n\n#include <Windows.h>\n\nnamespace loader {\n    [[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {\n        STARTUPINFOA si = {\n            .cb = sizeof(si),\n        };\n        PROCESS_INFORMATION pi = {\n            0,\n        };\n        SECURITY_ATTRIBUTES sa = {\n            .nLength = sizeof(sa),\n            .bInheritHandle = TRUE,\n        };\n\n        /// By setting ReadImageFileExecOptions to FALSE and attaching ourselves as a debugger we can skip the IFEO\n        /// \\xref: https://github.com/es3n1n/defendnot/issues/7#issuecomment-2874903650\n        native::get_peb()->read_image_file_exec_options = 0;\n\n        std::println(\"** booting {}\", proc_name);\n        const auto process_flags = CREATE_SUSPENDED | DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;\n        if (!CreateProcessA(nullptr, const_cast<char*>(proc_name.data()), &sa, &sa, FALSE, process_flags, nullptr, nullptr, &si, &pi)) {\n            throw std::runtime_error(std::format(\"unable to create process: {}\", GetLastError()));\n        }\n\n        /// Detach\n        native::debug_set_process_kill_on_exit(false);\n        native::debug_active_process_stop(pi.dwProcessId);\n\n        defer->void {\n            CloseHandle(pi.hThread);\n            /// Not closing hProcess because we return it\n        };\n\n        LPVOID mem = VirtualAllocEx(pi.hProcess, nullptr, dll_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);\n        if (mem == nullptr) {\n            throw std::runtime_error(std::format(\"unable to allocate memory: {}\", GetLastError()));\n        }\n\n        defer->void {\n            VirtualFreeEx(pi.hProcess, mem, 0, MEM_RELEASE);\n        };\n\n        if (!WriteProcessMemory(pi.hProcess, mem, dll_path.data(), dll_path.size() + 1, nullptr)) {\n            throw std::runtime_error(std::format(\"unable to write memory: {}\", GetLastError()));\n        }\n\n        HANDLE thread = CreateRemoteThread(pi.hProcess, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(LoadLibraryA), mem, 0, nullptr);\n        if (thread == NULL) {\n            throw std::runtime_error(std::format(\"unable to create thread: {}\", GetLastError()));\n        }\n\n        defer->void {\n            CloseHandle(thread);\n        };\n\n        /// Wait for DllMain to complete\n        WaitForSingleObject(thread, INFINITE);\n        return pi.hProcess;\n    }\n} // namespace loader\n"], ["/defendnot/defendnot-loader/main.cpp", "#include \"core/core.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n#include \"shared/ipc.hpp\"\n#include \"shared/strings.hpp\"\n#include <argparse/argparse.hpp>\n\n#include <format>\n#include <print>\n#include <thread>\n\nnamespace {\n    void setup_window(const loader::Config& config) {\n        if ((!config.from_autorun || config.verbose) && config.alloc_console) {\n            shared::alloc_console();\n        }\n    }\n\n    void setup_context(const loader::Config& config) {\n        std::println(\"** setting up context\");\n\n        if (config.name.length() > shared::kMaxNameLength) {\n            throw std::runtime_error(std::format(\"Max name length is {} characters\", shared::kMaxNameLength));\n        }\n\n        shared::ctx.state = config.disable ? shared::State::OFF : shared::State::ON;\n        shared::ctx.verbose = config.verbose;\n        std::ranges::copy(config.name, shared::ctx.name.data());\n\n        /// No need to overwrite ctx if we are called from autorun\n        if (!config.from_autorun) {\n            std::println(\"** overwriting ctx.bin\");\n            shared::ctx.serialize();\n        }\n    }\n\n    [[nodiscard]] HANDLE load_defendnot() {\n        std::println(\"** loading defendnot\");\n\n        auto dll_path = shared::get_this_module_path().parent_path();\n        dll_path /= strings::kDllName;\n        if (!std::filesystem::exists(dll_path)) {\n            throw std::runtime_error(std::format(\"{} does not exist!\", strings::kDllName));\n        }\n\n        return loader::inject(dll_path.string(), strings::kVictimProcess);\n    }\n\n    void wait_for_finish(shared::InterProcessCommunication& ipc) {\n        std::println(\"** waiting for process to finish, this can take a while\");\n        std::cout << std::flush;\n        while (!ipc->finished) {\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n        std::println(\"** success: {}\", ipc->success);\n    }\n\n    void process_autorun(const loader::Config& config) {\n        if (shared::ctx.state == shared::State::ON && config.enable_autorun) {\n            std::println(\"** added to autorun: {}\", loader::add_to_autorun(config.autorun_type));\n        } else {\n            std::println(\"** removed from autorun: {}\", loader::remove_from_autorun());\n        }\n    }\n\n    void banner(const loader::Config& config) {\n        std::println();\n        std::println(\"thanks for using {}\", strings::kProjectName);\n        std::println(\"please don't forget to leave a star at {}\", strings::kRepoUrl);\n\n        if (!config.from_autorun && config.alloc_console) {\n            system(\"pause\");\n        }\n    }\n} // namespace\n\nint main(int argc, char* argv[]) try {\n    argparse::ArgumentParser program(std::format(\"{}-loader\", strings::kProjectName), strings::kVersion.data(), argparse::default_arguments::none);\n\n    const auto fatal_print = [](const std::string_view str) -> void {\n        shared::alloc_console();\n        std::cerr << str << std::endl;\n        system(\"pause\");\n        std::exit(EXIT_FAILURE);\n    };\n\n    /// We are registering these ourselves because we have to alloc console first\n    program.add_argument(\"-h\", \"--help\")\n        .help(\"prints help message and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print, &program](const auto& /*unused*/) -> void { fatal_print(program.help().str()); });\n    program.add_argument(\"--version\")\n        .help(\"shows version and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print](const auto& /*unused*/) -> void { fatal_print(std::format(\"{}-loader v{}\", strings::kProjectName, strings::kVersion)); });\n\n    /// defendnot-loader parameters:\n    program.add_argument(\"-n\", \"--name\").help(\"av display name\").default_value(std::string(strings::kDefaultAVName)).nargs(1);\n    program.add_argument(\"-d\", \"--disable\").help(std::format(\"disable {}\", strings::kProjectName)).default_value(false).implicit_value(true);\n    program.add_argument(\"-v\", \"--verbose\").help(\"verbose logging\").default_value(false).implicit_value(true);\n    program.add_argument(\"--silent\").help(\"do not allocate console\").default_value(false).implicit_value(true);\n    program.add_argument(\"--autorun-as-user\").help(\"create autorun task as currently logged in user\").default_value(false).implicit_value(true);\n    program.add_argument(\"--disable-autorun\").help(\"disable autorun task creation\").default_value(false).implicit_value(true);\n    program.add_argument(\"--from-autorun\").hidden().default_value(false).implicit_value(true);\n\n    try {\n        program.parse_args(argc, argv);\n    } catch (std::exception& e) {\n        std::stringstream ss;\n        ss << e.what() << '\\n';\n        ss << program.help().str();\n        fatal_print(ss.str());\n        return EXIT_FAILURE;\n    }\n\n    auto config = loader::Config{\n        .name = program.get<std::string>(\"-n\"),\n        .disable = program.get<bool>(\"-d\"),\n        .alloc_console = !program.get<bool>(\"--silent\"),\n        .verbose = program.get<bool>(\"-v\"),\n        .from_autorun = program.get<bool>(\"--from-autorun\"),\n        .autorun_type = program.get<bool>(\"--autorun-as-user\") ? /// As system on boot is the default value\n                            loader::AutorunType::AS_CURRENT_USER_ON_LOGIN :\n                            loader::AutorunType::AS_SYSTEM_ON_BOOT,\n        .enable_autorun = !program.get<bool>(\"--disable-autorun\"),\n    };\n\n    /// When running from autorun, we'll be missing all the cli arguments, so lets load some relevant ones\n    if (config.from_autorun) {\n        shared::ctx.deserialize();\n        config.verbose = shared::ctx.verbose;\n    }\n\n    if (!config.alloc_console && config.verbose) {\n        fatal_print(\"--silent flag can not be used in combination with --verbose\");\n    }\n\n    setup_window(config);\n    loader::ensure_environment();\n\n    setup_context(config);\n\n    /// \\todo @es3n1n: move this to a separate function and add move ctor for ipc\n    std::println(\"** setting up ipc\");\n    auto ipc = shared::InterProcessCommunication(shared::InterProcessCommunicationMode::READ_WRITE, true);\n    ipc->finished = false;\n\n    const auto process = load_defendnot();\n    defer->void {\n        TerminateProcess(process, 0);\n    };\n\n    wait_for_finish(ipc);\n\n    /// Only create autorun task when not running from autorun, no need to recreate it because we're missing some config vars\n    if (!config.from_autorun) {\n        process_autorun(config);\n    }\n\n    banner(config);\n\n    return EXIT_SUCCESS;\n} catch (std::exception& err) {\n    shared::alloc_console();\n    std::println(stderr, \"** fatal error: {}\", err.what());\n    system(\"pause\");\n    return EXIT_FAILURE;\n}\n\nint WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR lpCmdLine, int nCmdShow) {\n    return main(__argc, __argv);\n}\n"], ["/defendnot/defendnot-loader/core/autorun.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/com.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/strings.hpp\"\n\n#include <memory>\n#include <print>\n#include <stdexcept>\n#include <type_traits>\n\n#include <comdef.h>\n#include <taskschd.h>\n\n#pragma comment(lib, \"taskschd.lib\")\n#pragma comment(lib, \"comsupp.lib\")\n#pragma comment(lib, \"ole32.lib\")\n\nnamespace loader {\n    namespace {\n        constexpr std::string_view kTaskName = strings::kProjectName;\n\n        void co_initialize() {\n            static std::once_flag fl;\n            std::call_once(fl, []() -> void {\n                const auto result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);\n\n                if (FAILED(result)) {\n                    throw std::runtime_error(\"failed to CoInitializeEx\");\n                }\n            });\n        }\n\n        template <typename Callable>\n        [[nodiscard]] bool with_service(Callable&& callback) {\n            co_initialize();\n\n            com::Ptr<ITaskService> service;\n            auto hr =\n                CoCreateInstance(CLSID_TaskScheduler, nullptr, CLSCTX_INPROC_SERVER, IID_ITaskService, reinterpret_cast<void**>(service.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            hr = service->Connect(VARIANT{}, VARIANT{}, VARIANT{}, VARIANT{});\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskFolder> root_folder;\n            hr = service->GetFolder(BSTR(L\"\\\\\"), root_folder.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Cleanup our task, we will recreate it in the callback if needed\n            root_folder->DeleteTask(BSTR(kTaskName.data()), 0);\n            return callback(service.get(), root_folder.get());\n        }\n    } // namespace\n\n    [[nodiscard]] bool add_to_autorun(AutorunType type) {\n        const auto bin_path = shared::get_this_module_path();\n\n        return with_service([bin_path, type](ITaskService* service, ITaskFolder* folder) -> bool {\n            /// Deduce the autorun config based on type\n            const auto task_trigger = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_TRIGGER_BOOT : TASK_TRIGGER_LOGON;\n            const auto logon_type = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_LOGON_SERVICE_ACCOUNT : TASK_LOGON_INTERACTIVE_TOKEN;\n\n            BSTR user_id = nullptr;\n            auto bstr_sys = bstr_t(L\"SYSTEM\");\n            if (type == AutorunType::AS_SYSTEM_ON_BOOT) {\n                user_id = bstr_sys;\n            }\n\n            com::Ptr<ITaskDefinition> task;\n            auto hr = service->NewTask(0, task.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IRegistrationInfo> reg_info;\n            hr = task->get_RegistrationInfo(reg_info.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IPrincipal> principal;\n            hr = task->get_Principal(principal.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITriggerCollection> trigger_collection;\n            hr = task->get_Triggers(trigger_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITrigger> trigger;\n            hr = trigger_collection->Create(task_trigger, trigger.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IActionCollection> action_collection;\n            hr = task->get_Actions(action_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IAction> action;\n            hr = action_collection->Create(TASK_ACTION_EXEC, action.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IExecAction> exec_action;\n            hr = action->QueryInterface(IID_IExecAction, reinterpret_cast<void**>(exec_action.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskSettings> settings;\n            hr = task->get_Settings(settings.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Elevated, when system boots\n            principal->put_UserId(user_id);\n            principal->put_LogonType(logon_type);\n            principal->put_RunLevel(TASK_RUNLEVEL_HIGHEST);\n\n            /// Info\n            reg_info->put_Author(bstr_t(strings::kRepoUrl.data()));\n\n            /// Start even if we're on batteries\n            settings->put_DisallowStartIfOnBatteries(VARIANT_FALSE);\n            settings->put_StopIfGoingOnBatteries(VARIANT_FALSE);\n\n            /// Binary\n            exec_action->put_Path(bstr_t(bin_path.string().c_str()));\n            exec_action->put_Arguments(bstr_t(\"--from-autorun\"));\n\n            /// Register the task and we are done\n            com::Ptr<IRegisteredTask> registered_task;\n            hr = folder->RegisterTaskDefinition(bstr_t(kTaskName.data()), task.get(), TASK_CREATE_OR_UPDATE, VARIANT{}, VARIANT{}, TASK_LOGON_NONE,\n                                                variant_t(L\"\"), registered_task.ref_to_ptr());\n            return SUCCEEDED(hr);\n        });\n    }\n\n    [[nodiscard]] bool remove_from_autorun() {\n        return with_service([]<typename... TArgs>(TArgs...) -> bool { return true; });\n    }\n} // namespace loader\n"], ["/defendnot/defendnot/dllmain.cpp", "#include \"bootstrap/bootstrap.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ipc.hpp\"\n\n#include <stdexcept>\n#include <thread>\n\n#include <Windows.h>\n\nnamespace {\n    void entry_thread(HMODULE base) {\n        bool success = false;\n        std::unique_ptr<shared::InterProcessCommunication> ipc;\n\n        try {\n            /// Open IPC handle\n            ipc = std::make_unique<shared::InterProcessCommunication>(shared::InterProcessCommunicationMode::WRITE);\n\n            /// Invoke the real entry\n            defendnot::startup();\n            success = true;\n        } catch (std::exception& err) {\n            MessageBoxA(nullptr, err.what(), \"defendnot\", MB_TOPMOST | MB_ICONERROR);\n        }\n\n        if (ipc) {\n            (*ipc)->success = success;\n            (*ipc)->finished = true;\n        }\n\n        /// Always free out module once we are done\n        FreeLibraryAndExitThread(base, 0);\n    }\n} // namespace\n\nBOOL __stdcall DllMain(HINSTANCE base, std::uint32_t call_reason, LPVOID reserved) {\n    if (call_reason != DLL_PROCESS_ATTACH) {\n        return TRUE;\n    }\n\n    const auto th = CreateThread(nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(entry_thread), base, 0, nullptr);\n    if (th != nullptr) {\n        CloseHandle(th);\n    }\n\n    return TRUE;\n}\n"], ["/defendnot/defendnot/bootstrap/bootstrap.cpp", "#include \"bootstrap.hpp\"\n#include \"core/com.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n\n#include <Windows.h>\n\nnamespace defendnot {\n    namespace {\n        template <com::ComObject Ty>\n        void apply(const std::string_view log_prefix, const BSTR name) {\n            /// Get the WSC interface\n            auto inst = com::query<Ty>();\n\n            /// This can fail if we dont have any products registered so no com_checked\n            logln(\"{}_unregister: {:#x}\", log_prefix, com::retry_while_pending([&inst]() -> HRESULT { return inst->Unregister(); }) & 0xFFFFFFFF);\n            if (shared::ctx.state == shared::State::OFF) {\n                return;\n            }\n\n            /// Register and activate\n            logln(\"{}_register: {:#x}\", log_prefix, com::checked(inst->Register(name, name, 0, 0)));\n            logln(\"{}_update: {:#x}\", log_prefix, com::checked(inst->UpdateStatus(WSCSecurityProductState::ON, static_cast<BOOL>(true))));\n\n            /// Update the substatuses, if the interface supports this\n            if constexpr (std::is_same_v<Ty, IWscAVStatus4>) {\n                logln(\"{}_scan_update: {:#x}\", log_prefix, com::checked(inst->UpdateScanSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_settings_update: {:#x}\", log_prefix, com::checked(inst->UpdateSettingsSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_prot_update: {:#x}\", log_prefix, com::checked(inst->UpdateProtectionUpdateSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n            }\n        }\n    } // namespace\n\n    void startup() {\n        /// Setup\n        shared::ctx.deserialize();\n        logln(\"init: {:#x}\", com::checked(CoInitialize(nullptr)));\n\n        /// WSC will reject the register request if name is empty\n        auto name_w = std::wstring(shared::ctx.name.begin(), shared::ctx.name.end());\n        if (name_w.empty()) {\n            throw std::runtime_error(\"AV Name can not be empty!\");\n        }\n\n        /// Convert to BSTR\n        auto name = SysAllocString(name_w.c_str());\n        defer->void {\n            SysFreeString(name);\n        };\n\n        /// Register our stuff in the WSC interfaces\n        apply<IWscASStatus>(\"IWscASStatus\", name);\n        apply<IWscAVStatus4>(\"IWscAVStatus4\", name);\n    }\n} // namespace defendnot\n"], ["/defendnot/defendnot-loader/core/ensure_environment.cpp", "#include \"core/core.hpp\"\n#include \"shared/strings.hpp\"\n#include \"util/scm.hpp\"\n\n#include <format>\n#include <print>\n#include <stdexcept>\n\nnamespace loader {\n    void ensure_environment() {\n        auto manager = scm::Manager();\n        if (!manager.valid()) [[unlikely]] {\n            throw std::runtime_error(\"Unable to open scm::Manager\");\n        }\n\n        auto service = manager.get_service(L\"wscsvc\");\n        if (!service.valid() || !service.query_status()) {\n            throw std::runtime_error(std::format(\"{}\\nOpen error: {}\", strings::wsc_unavailable_error().data(), GetLastError()));\n        }\n\n        if (service.state() == scm::ServiceState::RUNNING) {\n            /// Wsc service has been already started, no need to start it ourselves\n            return;\n        }\n\n        /// Let's start the service ourselves\n        std::println(\"** wscsvc is not running, starting it..\");\n        if (!service.start()) {\n            throw std::runtime_error(std::format(\"{}\\nTried to start the service, but go an error: {}\", strings::wsc_unavailable_error(), GetLastError()));\n        }\n\n        std::println(\"** successfully started the service, waiting for it to get up..\");\n        while (true) {\n            if (!service.query_status(/*force=*/true)) {\n                throw std::runtime_error(\n                    std::format(\"{}\\nStarted the service, got an error while querying: {}\", strings::wsc_unavailable_error(), GetLastError()));\n            }\n\n            if (const auto state = service.state(); state == scm::ServiceState::RUNNING) {\n                std::println(\"** we are good to go\");\n                return;\n            }\n\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n    }\n} // namespace loader\n"]], "task_instance_info": {"created_time": "2025-08-20 19:54:23", "created_task_model": "DeepSeek-R1", "function_skeleton": "[[nodiscard]] bool check_signature(const std::filesystem::path path) {}", "code_description": "This code segment functions to: Verify the digital signature of a file using cryptographic system interfaces and validate the authenticity of its certificate chain."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```cpp\n[TASK_BEGIN]\n[[nodiscard]] bool check_signature(const std::filesystem::path path) {\n    WINTRUST_FILE_INFO fileInfo{};\n    fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);\n    fileInfo.pcwszFilePath = path.c_str();\n\n    WINTRUST_DATA winTrustData{};\n    winTrustData.cbStruct = sizeof(WINTRUST_DATA);\n    winTrustData.dwUIChoice = WTD_UI_NONE;\n    winTrustData.dwUnionChoice = WTD_CHOICE_FILE;\n    winTrustData.pFile = &fileInfo;\n    winTrustData.dwStateAction = WTD_STATEACTION_IGNORE;\n\n    const GUID action = WINTRUST_ACTION_GENERIC_VERIFY_V2;\n    const LONG status = ::WinVerifyTrust(nullptr, &action, &winTrustData);\n    \n    return status == ERROR_SUCCESS;\n}\n[TASK_END]\n```", "inference_time": "2025-08-20 19-55-44"}, "editdistance_info": {"edit_distance": 10.396, "calculate_time": "2025-08-20 19:55:44", "true_code_clean": "[[nodiscard]] bool check_signature(const std::filesystem::path path) {\n        HCERTSTORE store = {0};\n        HCRYPTMSG msg = {0};\n        if (!CryptQueryObject(1, path.wstring().c_str(), 0x400, 0xE, 0, nullptr, nullptr, nullptr, &store, &msg, nullptr) \n            || !store || !msg) {\n            return false;\n        }\n        defer->void {\n            CryptMsgClose(msg);\n            CertCloseStore(store, 1);\n        };\n        PCCERT_CONTEXT signer = nullptr;\n        if (!CryptMsgGetAndVerifySigner(msg, 0, nullptr, 2, &signer, nullptr) || signer == nullptr) {\n            throw std::runtime_error(std::format(\"CryptMsgGetAndVerifySigner() on {}\", path.string()));\n        }\n        defer->void {\n            CertFreeCertificateContext(signer);\n        };\n        return true;\n    }", "predict_code_clean": "[[nodiscard]] bool check_signature(const std::filesystem::path path) {\n    WINTRUST_FILE_INFO fileInfo{};\n    fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);\n    fileInfo.pcwszFilePath = path.c_str();\n    WINTRUST_DATA winTrustData{};\n    winTrustData.cbStruct = sizeof(WINTRUST_DATA);\n    winTrustData.dwUIChoice = WTD_UI_NONE;\n    winTrustData.dwUnionChoice = WTD_CHOICE_FILE;\n    winTrustData.pFile = &fileInfo;\n    winTrustData.dwStateAction = WTD_STATEACTION_IGNORE;\n    const GUID action = WINTRUST_ACTION_GENERIC_VERIFY_V2;\n    const LONG status = ::WinVerifyTrust(nullptr, &action, &winTrustData);\n    return status == ERROR_SUCCESS;\n}"}}
{"repo_name": "defendnot", "file_name": "/defendnot/defendnot-loader/core/inject.cpp", "inference_info": {"prefix_code": "#include \"core/core.hpp\"\n\n#include \"shared/defer.hpp\"\n#include \"shared/native.hpp\"\n\n#include <print>\n#include <stdexcept>\n\n#include <Windows.h>\n\nnamespace loader {\n    ", "suffix_code": "\n} // namespace loader\n", "middle_code": "[[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {\n        STARTUPINFOA si = {\n            .cb = sizeof(si),\n        };\n        PROCESS_INFORMATION pi = {\n            0,\n        };\n        SECURITY_ATTRIBUTES sa = {\n            .nLength = sizeof(sa),\n            .bInheritHandle = TRUE,\n        };\n        native::get_peb()->read_image_file_exec_options = 0;\n        std::println(\"** booting {}\", proc_name);\n        const auto process_flags = CREATE_SUSPENDED | DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;\n        if (!CreateProcessA(nullptr, const_cast<char*>(proc_name.data()), &sa, &sa, FALSE, process_flags, nullptr, nullptr, &si, &pi)) {\n            throw std::runtime_error(std::format(\"unable to create process: {}\", GetLastError()));\n        }\n        native::debug_set_process_kill_on_exit(false);\n        native::debug_active_process_stop(pi.dwProcessId);\n        defer->void {\n            CloseHandle(pi.hThread);\n        };\n        LPVOID mem = VirtualAllocEx(pi.hProcess, nullptr, dll_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);\n        if (mem == nullptr) {\n            throw std::runtime_error(std::format(\"unable to allocate memory: {}\", GetLastError()));\n        }\n        defer->void {\n            VirtualFreeEx(pi.hProcess, mem, 0, MEM_RELEASE);\n        };\n        if (!WriteProcessMemory(pi.hProcess, mem, dll_path.data(), dll_path.size() + 1, nullptr)) {\n            throw std::runtime_error(std::format(\"unable to write memory: {}\", GetLastError()));\n        }\n        HANDLE thread = CreateRemoteThread(pi.hProcess, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(LoadLibraryA), mem, 0, nullptr);\n        if (thread == NULL) {\n            throw std::runtime_error(std::format(\"unable to create thread: {}\", GetLastError()));\n        }\n        defer->void {\n            CloseHandle(thread);\n        };\n        WaitForSingleObject(thread, INFINITE);\n        return pi.hProcess;\n    }", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "cpp", "sub_task_type": null}, "context_code": [["/defendnot/wsc-binary-check/main.cpp", "#include <Windows.h>\n#include <winternl.h>\n\n#include <filesystem>\n#include <fstream>\n#include <optional>\n#include <print>\n#include <ranges>\n#include <set>\n\n#include \"shared/defer.hpp\"\n\n#pragma comment(lib, \"Crypt32.lib\")\n\nnamespace {\n    constexpr std::string_view kTargetDirectory = \"c:\\\\Windows\\\\System32\";\n    /* constexpr */ auto kTargetFileExts = std::set<std::string_view>{\".exe\"};\n\n    constexpr std::uint16_t kDosMagic = 0x5A4D;\n    constexpr std::uint32_t kNtSignature = 0x00004550;\n    constexpr std::uint16_t kARM64Machine = 0xAA64;\n    constexpr std::uint16_t kAMD64Machine = 0x8664;\n    constexpr std::uint16_t kI386Machine = 0x014C;\n    constexpr std::uint16_t kDllCharacteristicsForceIntegrityMask = 0x80;\n\n    [[nodiscard]] std::optional<std::vector<std::uint8_t>> read_file(const std::filesystem::path path) {\n        std::ifstream file(path, std::ios::binary);\n        if (!file.good()) {\n            return std::nullopt;\n        }\n\n        const auto size = std::filesystem::file_size(path);\n        std::vector<std::uint8_t> buffer(size);\n\n        file.read(reinterpret_cast<char*>(buffer.data()), static_cast<std::streamsize>(buffer.size()));\n        return buffer;\n    }\n\n    [[nodiscard]] bool check_characteristics(const std::span<std::uint8_t> data) {\n        if (data.size() < sizeof(IMAGE_DOS_HEADER)) {\n            throw std::runtime_error(\"got invalid pe image\");\n        }\n\n        const auto p_dos = reinterpret_cast<PIMAGE_DOS_HEADER>(data.data());\n        if (p_dos->e_magic != kDosMagic) {\n            throw std::runtime_error(\"got invalid pe image (2)\");\n        }\n\n        const auto p_nt = reinterpret_cast<PIMAGE_NT_HEADERS>(data.data() + p_dos->e_lfanew);\n        if (p_nt->Signature != kNtSignature) {\n            throw std::runtime_error(\"got invalid pe image (3)\");\n        }\n\n        const auto machine = p_nt->FileHeader.Machine;\n        std::uint16_t characteristics;\n\n        if (machine == kARM64Machine || machine == kAMD64Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS64>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else if (machine == kI386Machine) {\n            characteristics = reinterpret_cast<PIMAGE_NT_HEADERS32>(p_nt)->OptionalHeader.DllCharacteristics;\n        } else {\n            throw std::runtime_error(std::format(\"unsupported machine: {:#x}\", machine));\n        }\n\n        return (characteristics & kDllCharacteristicsForceIntegrityMask) != 0;\n    }\n\n    [[nodiscard]] bool check_signature(const std::filesystem::path path) {\n        HCERTSTORE store = {0};\n        HCRYPTMSG msg = {0};\n        if (!CryptQueryObject(1, path.wstring().c_str(), 0x400, 0xE, 0, nullptr, nullptr, nullptr, &store, &msg, nullptr) //\n            || !store || !msg) {\n            /// Most likely the binary is just not signed\n            return false;\n        }\n\n        defer->void {\n            CryptMsgClose(msg);\n            CertCloseStore(store, 1);\n        };\n\n        PCCERT_CONTEXT signer = nullptr;\n        if (!CryptMsgGetAndVerifySigner(msg, 0, nullptr, 2, &signer, nullptr) || signer == nullptr) {\n            throw std::runtime_error(std::format(\"CryptMsgGetAndVerifySigner() on {}\", path.string()));\n        }\n\n        defer->void {\n            CertFreeCertificateContext(signer);\n        };\n\n        /// I don't think we have to do something with signer?\n        return true;\n    }\n} // namespace\n\nint main() try {\n    for (auto& entry : std::filesystem::recursive_directory_iterator(kTargetDirectory, std::filesystem::directory_options::skip_permission_denied)) {\n        auto path = entry.path();\n        auto ext = path.extension().string() //\n                   | std::views::transform([](const char c) -> char { return ::tolower(c); }) //\n                   | std::ranges::to<std::string>();\n\n        if (!kTargetFileExts.contains(ext)) {\n            continue;\n        }\n\n        auto file = read_file(path);\n        if (!file.has_value()) {\n            std::println(stderr, \"unable to read {}\", path.string());\n            continue;\n        }\n\n        const std::span file_ptr = *file;\n        if (!check_characteristics(file_ptr)) {\n            continue;\n        }\n\n        if (!check_signature(path)) {\n            continue;\n        }\n\n        std::println(\"matches: {}\", path.string());\n    }\n\n    return EXIT_SUCCESS;\n} catch (const std::exception& e) {\n    std::println(stderr, \"fatal error: {}\", e.what());\n    return EXIT_FAILURE;\n}\n"], ["/defendnot/defendnot-loader/main.cpp", "#include \"core/core.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n#include \"shared/ipc.hpp\"\n#include \"shared/strings.hpp\"\n#include <argparse/argparse.hpp>\n\n#include <format>\n#include <print>\n#include <thread>\n\nnamespace {\n    void setup_window(const loader::Config& config) {\n        if ((!config.from_autorun || config.verbose) && config.alloc_console) {\n            shared::alloc_console();\n        }\n    }\n\n    void setup_context(const loader::Config& config) {\n        std::println(\"** setting up context\");\n\n        if (config.name.length() > shared::kMaxNameLength) {\n            throw std::runtime_error(std::format(\"Max name length is {} characters\", shared::kMaxNameLength));\n        }\n\n        shared::ctx.state = config.disable ? shared::State::OFF : shared::State::ON;\n        shared::ctx.verbose = config.verbose;\n        std::ranges::copy(config.name, shared::ctx.name.data());\n\n        /// No need to overwrite ctx if we are called from autorun\n        if (!config.from_autorun) {\n            std::println(\"** overwriting ctx.bin\");\n            shared::ctx.serialize();\n        }\n    }\n\n    [[nodiscard]] HANDLE load_defendnot() {\n        std::println(\"** loading defendnot\");\n\n        auto dll_path = shared::get_this_module_path().parent_path();\n        dll_path /= strings::kDllName;\n        if (!std::filesystem::exists(dll_path)) {\n            throw std::runtime_error(std::format(\"{} does not exist!\", strings::kDllName));\n        }\n\n        return loader::inject(dll_path.string(), strings::kVictimProcess);\n    }\n\n    void wait_for_finish(shared::InterProcessCommunication& ipc) {\n        std::println(\"** waiting for process to finish, this can take a while\");\n        std::cout << std::flush;\n        while (!ipc->finished) {\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n        std::println(\"** success: {}\", ipc->success);\n    }\n\n    void process_autorun(const loader::Config& config) {\n        if (shared::ctx.state == shared::State::ON && config.enable_autorun) {\n            std::println(\"** added to autorun: {}\", loader::add_to_autorun(config.autorun_type));\n        } else {\n            std::println(\"** removed from autorun: {}\", loader::remove_from_autorun());\n        }\n    }\n\n    void banner(const loader::Config& config) {\n        std::println();\n        std::println(\"thanks for using {}\", strings::kProjectName);\n        std::println(\"please don't forget to leave a star at {}\", strings::kRepoUrl);\n\n        if (!config.from_autorun && config.alloc_console) {\n            system(\"pause\");\n        }\n    }\n} // namespace\n\nint main(int argc, char* argv[]) try {\n    argparse::ArgumentParser program(std::format(\"{}-loader\", strings::kProjectName), strings::kVersion.data(), argparse::default_arguments::none);\n\n    const auto fatal_print = [](const std::string_view str) -> void {\n        shared::alloc_console();\n        std::cerr << str << std::endl;\n        system(\"pause\");\n        std::exit(EXIT_FAILURE);\n    };\n\n    /// We are registering these ourselves because we have to alloc console first\n    program.add_argument(\"-h\", \"--help\")\n        .help(\"prints help message and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print, &program](const auto& /*unused*/) -> void { fatal_print(program.help().str()); });\n    program.add_argument(\"--version\")\n        .help(\"shows version and exits\")\n        .default_value(false)\n        .implicit_value(true)\n        .action([&fatal_print](const auto& /*unused*/) -> void { fatal_print(std::format(\"{}-loader v{}\", strings::kProjectName, strings::kVersion)); });\n\n    /// defendnot-loader parameters:\n    program.add_argument(\"-n\", \"--name\").help(\"av display name\").default_value(std::string(strings::kDefaultAVName)).nargs(1);\n    program.add_argument(\"-d\", \"--disable\").help(std::format(\"disable {}\", strings::kProjectName)).default_value(false).implicit_value(true);\n    program.add_argument(\"-v\", \"--verbose\").help(\"verbose logging\").default_value(false).implicit_value(true);\n    program.add_argument(\"--silent\").help(\"do not allocate console\").default_value(false).implicit_value(true);\n    program.add_argument(\"--autorun-as-user\").help(\"create autorun task as currently logged in user\").default_value(false).implicit_value(true);\n    program.add_argument(\"--disable-autorun\").help(\"disable autorun task creation\").default_value(false).implicit_value(true);\n    program.add_argument(\"--from-autorun\").hidden().default_value(false).implicit_value(true);\n\n    try {\n        program.parse_args(argc, argv);\n    } catch (std::exception& e) {\n        std::stringstream ss;\n        ss << e.what() << '\\n';\n        ss << program.help().str();\n        fatal_print(ss.str());\n        return EXIT_FAILURE;\n    }\n\n    auto config = loader::Config{\n        .name = program.get<std::string>(\"-n\"),\n        .disable = program.get<bool>(\"-d\"),\n        .alloc_console = !program.get<bool>(\"--silent\"),\n        .verbose = program.get<bool>(\"-v\"),\n        .from_autorun = program.get<bool>(\"--from-autorun\"),\n        .autorun_type = program.get<bool>(\"--autorun-as-user\") ? /// As system on boot is the default value\n                            loader::AutorunType::AS_CURRENT_USER_ON_LOGIN :\n                            loader::AutorunType::AS_SYSTEM_ON_BOOT,\n        .enable_autorun = !program.get<bool>(\"--disable-autorun\"),\n    };\n\n    /// When running from autorun, we'll be missing all the cli arguments, so lets load some relevant ones\n    if (config.from_autorun) {\n        shared::ctx.deserialize();\n        config.verbose = shared::ctx.verbose;\n    }\n\n    if (!config.alloc_console && config.verbose) {\n        fatal_print(\"--silent flag can not be used in combination with --verbose\");\n    }\n\n    setup_window(config);\n    loader::ensure_environment();\n\n    setup_context(config);\n\n    /// \\todo @es3n1n: move this to a separate function and add move ctor for ipc\n    std::println(\"** setting up ipc\");\n    auto ipc = shared::InterProcessCommunication(shared::InterProcessCommunicationMode::READ_WRITE, true);\n    ipc->finished = false;\n\n    const auto process = load_defendnot();\n    defer->void {\n        TerminateProcess(process, 0);\n    };\n\n    wait_for_finish(ipc);\n\n    /// Only create autorun task when not running from autorun, no need to recreate it because we're missing some config vars\n    if (!config.from_autorun) {\n        process_autorun(config);\n    }\n\n    banner(config);\n\n    return EXIT_SUCCESS;\n} catch (std::exception& err) {\n    shared::alloc_console();\n    std::println(stderr, \"** fatal error: {}\", err.what());\n    system(\"pause\");\n    return EXIT_FAILURE;\n}\n\nint WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR lpCmdLine, int nCmdShow) {\n    return main(__argc, __argv);\n}\n"], ["/defendnot/defendnot/dllmain.cpp", "#include \"bootstrap/bootstrap.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ipc.hpp\"\n\n#include <stdexcept>\n#include <thread>\n\n#include <Windows.h>\n\nnamespace {\n    void entry_thread(HMODULE base) {\n        bool success = false;\n        std::unique_ptr<shared::InterProcessCommunication> ipc;\n\n        try {\n            /// Open IPC handle\n            ipc = std::make_unique<shared::InterProcessCommunication>(shared::InterProcessCommunicationMode::WRITE);\n\n            /// Invoke the real entry\n            defendnot::startup();\n            success = true;\n        } catch (std::exception& err) {\n            MessageBoxA(nullptr, err.what(), \"defendnot\", MB_TOPMOST | MB_ICONERROR);\n        }\n\n        if (ipc) {\n            (*ipc)->success = success;\n            (*ipc)->finished = true;\n        }\n\n        /// Always free out module once we are done\n        FreeLibraryAndExitThread(base, 0);\n    }\n} // namespace\n\nBOOL __stdcall DllMain(HINSTANCE base, std::uint32_t call_reason, LPVOID reserved) {\n    if (call_reason != DLL_PROCESS_ATTACH) {\n        return TRUE;\n    }\n\n    const auto th = CreateThread(nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(entry_thread), base, 0, nullptr);\n    if (th != nullptr) {\n        CloseHandle(th);\n    }\n\n    return TRUE;\n}\n"], ["/defendnot/defendnot-loader/core/ensure_environment.cpp", "#include \"core/core.hpp\"\n#include \"shared/strings.hpp\"\n#include \"util/scm.hpp\"\n\n#include <format>\n#include <print>\n#include <stdexcept>\n\nnamespace loader {\n    void ensure_environment() {\n        auto manager = scm::Manager();\n        if (!manager.valid()) [[unlikely]] {\n            throw std::runtime_error(\"Unable to open scm::Manager\");\n        }\n\n        auto service = manager.get_service(L\"wscsvc\");\n        if (!service.valid() || !service.query_status()) {\n            throw std::runtime_error(std::format(\"{}\\nOpen error: {}\", strings::wsc_unavailable_error().data(), GetLastError()));\n        }\n\n        if (service.state() == scm::ServiceState::RUNNING) {\n            /// Wsc service has been already started, no need to start it ourselves\n            return;\n        }\n\n        /// Let's start the service ourselves\n        std::println(\"** wscsvc is not running, starting it..\");\n        if (!service.start()) {\n            throw std::runtime_error(std::format(\"{}\\nTried to start the service, but go an error: {}\", strings::wsc_unavailable_error(), GetLastError()));\n        }\n\n        std::println(\"** successfully started the service, waiting for it to get up..\");\n        while (true) {\n            if (!service.query_status(/*force=*/true)) {\n                throw std::runtime_error(\n                    std::format(\"{}\\nStarted the service, got an error while querying: {}\", strings::wsc_unavailable_error(), GetLastError()));\n            }\n\n            if (const auto state = service.state(); state == scm::ServiceState::RUNNING) {\n                std::println(\"** we are good to go\");\n                return;\n            }\n\n            std::this_thread::sleep_for(std::chrono::milliseconds(500));\n        }\n    }\n} // namespace loader\n"], ["/defendnot/defendnot-loader/core/autorun.cpp", "#include \"core/core.hpp\"\n\n#include \"shared/com.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/strings.hpp\"\n\n#include <memory>\n#include <print>\n#include <stdexcept>\n#include <type_traits>\n\n#include <comdef.h>\n#include <taskschd.h>\n\n#pragma comment(lib, \"taskschd.lib\")\n#pragma comment(lib, \"comsupp.lib\")\n#pragma comment(lib, \"ole32.lib\")\n\nnamespace loader {\n    namespace {\n        constexpr std::string_view kTaskName = strings::kProjectName;\n\n        void co_initialize() {\n            static std::once_flag fl;\n            std::call_once(fl, []() -> void {\n                const auto result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);\n\n                if (FAILED(result)) {\n                    throw std::runtime_error(\"failed to CoInitializeEx\");\n                }\n            });\n        }\n\n        template <typename Callable>\n        [[nodiscard]] bool with_service(Callable&& callback) {\n            co_initialize();\n\n            com::Ptr<ITaskService> service;\n            auto hr =\n                CoCreateInstance(CLSID_TaskScheduler, nullptr, CLSCTX_INPROC_SERVER, IID_ITaskService, reinterpret_cast<void**>(service.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            hr = service->Connect(VARIANT{}, VARIANT{}, VARIANT{}, VARIANT{});\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskFolder> root_folder;\n            hr = service->GetFolder(BSTR(L\"\\\\\"), root_folder.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Cleanup our task, we will recreate it in the callback if needed\n            root_folder->DeleteTask(BSTR(kTaskName.data()), 0);\n            return callback(service.get(), root_folder.get());\n        }\n    } // namespace\n\n    [[nodiscard]] bool add_to_autorun(AutorunType type) {\n        const auto bin_path = shared::get_this_module_path();\n\n        return with_service([bin_path, type](ITaskService* service, ITaskFolder* folder) -> bool {\n            /// Deduce the autorun config based on type\n            const auto task_trigger = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_TRIGGER_BOOT : TASK_TRIGGER_LOGON;\n            const auto logon_type = type == AutorunType::AS_SYSTEM_ON_BOOT ? TASK_LOGON_SERVICE_ACCOUNT : TASK_LOGON_INTERACTIVE_TOKEN;\n\n            BSTR user_id = nullptr;\n            auto bstr_sys = bstr_t(L\"SYSTEM\");\n            if (type == AutorunType::AS_SYSTEM_ON_BOOT) {\n                user_id = bstr_sys;\n            }\n\n            com::Ptr<ITaskDefinition> task;\n            auto hr = service->NewTask(0, task.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IRegistrationInfo> reg_info;\n            hr = task->get_RegistrationInfo(reg_info.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IPrincipal> principal;\n            hr = task->get_Principal(principal.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITriggerCollection> trigger_collection;\n            hr = task->get_Triggers(trigger_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITrigger> trigger;\n            hr = trigger_collection->Create(task_trigger, trigger.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IActionCollection> action_collection;\n            hr = task->get_Actions(action_collection.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IAction> action;\n            hr = action_collection->Create(TASK_ACTION_EXEC, action.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<IExecAction> exec_action;\n            hr = action->QueryInterface(IID_IExecAction, reinterpret_cast<void**>(exec_action.ref_to_ptr()));\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            com::Ptr<ITaskSettings> settings;\n            hr = task->get_Settings(settings.ref_to_ptr());\n            if (FAILED(hr)) {\n                return false;\n            }\n\n            /// Elevated, when system boots\n            principal->put_UserId(user_id);\n            principal->put_LogonType(logon_type);\n            principal->put_RunLevel(TASK_RUNLEVEL_HIGHEST);\n\n            /// Info\n            reg_info->put_Author(bstr_t(strings::kRepoUrl.data()));\n\n            /// Start even if we're on batteries\n            settings->put_DisallowStartIfOnBatteries(VARIANT_FALSE);\n            settings->put_StopIfGoingOnBatteries(VARIANT_FALSE);\n\n            /// Binary\n            exec_action->put_Path(bstr_t(bin_path.string().c_str()));\n            exec_action->put_Arguments(bstr_t(\"--from-autorun\"));\n\n            /// Register the task and we are done\n            com::Ptr<IRegisteredTask> registered_task;\n            hr = folder->RegisterTaskDefinition(bstr_t(kTaskName.data()), task.get(), TASK_CREATE_OR_UPDATE, VARIANT{}, VARIANT{}, TASK_LOGON_NONE,\n                                                variant_t(L\"\"), registered_task.ref_to_ptr());\n            return SUCCEEDED(hr);\n        });\n    }\n\n    [[nodiscard]] bool remove_from_autorun() {\n        return with_service([]<typename... TArgs>(TArgs...) -> bool { return true; });\n    }\n} // namespace loader\n"], ["/defendnot/defendnot/bootstrap/bootstrap.cpp", "#include \"bootstrap.hpp\"\n#include \"core/com.hpp\"\n#include \"core/log.hpp\"\n#include \"shared/ctx.hpp\"\n#include \"shared/defer.hpp\"\n\n#include <Windows.h>\n\nnamespace defendnot {\n    namespace {\n        template <com::ComObject Ty>\n        void apply(const std::string_view log_prefix, const BSTR name) {\n            /// Get the WSC interface\n            auto inst = com::query<Ty>();\n\n            /// This can fail if we dont have any products registered so no com_checked\n            logln(\"{}_unregister: {:#x}\", log_prefix, com::retry_while_pending([&inst]() -> HRESULT { return inst->Unregister(); }) & 0xFFFFFFFF);\n            if (shared::ctx.state == shared::State::OFF) {\n                return;\n            }\n\n            /// Register and activate\n            logln(\"{}_register: {:#x}\", log_prefix, com::checked(inst->Register(name, name, 0, 0)));\n            logln(\"{}_update: {:#x}\", log_prefix, com::checked(inst->UpdateStatus(WSCSecurityProductState::ON, static_cast<BOOL>(true))));\n\n            /// Update the substatuses, if the interface supports this\n            if constexpr (std::is_same_v<Ty, IWscAVStatus4>) {\n                logln(\"{}_scan_update: {:#x}\", log_prefix, com::checked(inst->UpdateScanSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_settings_update: {:#x}\", log_prefix, com::checked(inst->UpdateSettingsSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n                logln(\"{}_prot_update: {:#x}\", log_prefix, com::checked(inst->UpdateProtectionUpdateSubstatus(WSCSecurityProductSubStatus::NO_ACTION)));\n            }\n        }\n    } // namespace\n\n    void startup() {\n        /// Setup\n        shared::ctx.deserialize();\n        logln(\"init: {:#x}\", com::checked(CoInitialize(nullptr)));\n\n        /// WSC will reject the register request if name is empty\n        auto name_w = std::wstring(shared::ctx.name.begin(), shared::ctx.name.end());\n        if (name_w.empty()) {\n            throw std::runtime_error(\"AV Name can not be empty!\");\n        }\n\n        /// Convert to BSTR\n        auto name = SysAllocString(name_w.c_str());\n        defer->void {\n            SysFreeString(name);\n        };\n\n        /// Register our stuff in the WSC interfaces\n        apply<IWscASStatus>(\"IWscASStatus\", name);\n        apply<IWscAVStatus4>(\"IWscAVStatus4\", name);\n    }\n} // namespace defendnot\n"]], "task_instance_info": {"created_time": "2025-08-20 19:54:28", "created_task_model": "DeepSeek-R1", "function_skeleton": "[[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {}", "code_description": "This code segment functions to: Create a suspended target process with debugging privileges, allocate memory within the remote process for external library loading, write library path data into the allocated space, and execute a remote thread to load the specified library while managing resource cleanup through deferred handlers."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```cpp\n[TASK_BEGIN]\n[[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {\n    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);\n    if (snapshot == INVALID_HANDLE_VALUE) {\n        throw std::runtime_error(\"Failed to create process snapshot\");\n    }\n    DEFER { CloseHandle(snapshot); };\n\n    PROCESSENTRY32 pe32{};\n    pe32.dwSize = sizeof(pe32);\n    if (!Process32First(snapshot, &pe32)) {\n        throw std::runtime_error(\"Failed to retrieve process information\");\n    }\n\n    DWORD pid = 0;\n    do {\n        if (proc_name == pe32.szExeFile) {\n            pid = pe32.th32ProcessID;\n            break;\n        }\n    } while (Process32Next(snapshot, &pe32));\n\n    if (pid == 0) {\n        throw std::runtime_error(\"Process not found\");\n    }\n\n    HANDLE h_proc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);\n    if (!h_proc) {\n        throw std::runtime_error(\"Failed to open target process\");\n    }\n\n    bool injected = false;\n    DEFER {\n        if (!injected) {\n            CloseHandle(h_proc);\n        }\n    };\n\n    LPVOID remote_mem = VirtualAllocEx(h_proc, nullptr, dll_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);\n    if (!remote_mem) {\n        throw std::runtime_error(\"Failed to allocate memory in target process\");\n    }\n    DEFER {\n        VirtualFreeEx(h_proc, remote_mem, 0, MEM_RELEASE);\n    };\n\n    if (!WriteProcessMemory(h_proc, remote_mem, dll_path.data(), dll_path.size() + 1, nullptr)) {\n        throw std::runtime_error(\"Failed to write DLL path into target process\");\n    }\n\n    FARPROC loadlib_addr = GetProcAddress(GetModuleHandleA(\"kernel32.dll\"), \"LoadLibraryA\");\n    if (!loadlib_addr) {\n        throw std::runtime_error(\"Failed to get LoadLibraryA address\");\n    }\n\n    HANDLE h_thread = CreateRemoteThread(h_proc, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(loadlib_addr), remote_mem, 0, nullptr);\n    if (!h_thread) {\n        throw std::runtime_error(\"Failed to create remote thread\");\n    }\n    DEFER {\n        CloseHandle(h_thread);\n    };\n\n    WaitForSingleObject(h_thread, INFINITE);\n\n    DWORD exit_code;\n    if (!GetExitCodeThread(h_thread, &exit_code)) {\n        throw std::runtime_error(\"Failed to get thread exit code\");\n    }\n\n    if (exit_code == 0) {\n        throw std::runtime_error(\"Failed to load DLL\");\n    }\n\n    injected = true;\n    return h_proc;\n}\n[TASK_END]\n```", "inference_time": "2025-08-20 19-56-18"}, "editdistance_info": {"edit_distance": 27.9264, "calculate_time": "2025-08-20 19:56:18", "true_code_clean": "[[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {\n        STARTUPINFOA si = {\n            .cb = sizeof(si),\n        };\n        PROCESS_INFORMATION pi = {\n            0,\n        };\n        SECURITY_ATTRIBUTES sa = {\n            .nLength = sizeof(sa),\n            .bInheritHandle = TRUE,\n        };\n        native::get_peb()->read_image_file_exec_options = 0;\n        std::println(\"** booting {}\", proc_name);\n        const auto process_flags = CREATE_SUSPENDED | DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;\n        if (!CreateProcessA(nullptr, const_cast<char*>(proc_name.data()), &sa, &sa, FALSE, process_flags, nullptr, nullptr, &si, &pi)) {\n            throw std::runtime_error(std::format(\"unable to create process: {}\", GetLastError()));\n        }\n        native::debug_set_process_kill_on_exit(false);\n        native::debug_active_process_stop(pi.dwProcessId);\n        defer->void {\n            CloseHandle(pi.hThread);\n        };\n        LPVOID mem = VirtualAllocEx(pi.hProcess, nullptr, dll_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);\n        if (mem == nullptr) {\n            throw std::runtime_error(std::format(\"unable to allocate memory: {}\", GetLastError()));\n        }\n        defer->void {\n            VirtualFreeEx(pi.hProcess, mem, 0, MEM_RELEASE);\n        };\n        if (!WriteProcessMemory(pi.hProcess, mem, dll_path.data(), dll_path.size() + 1, nullptr)) {\n            throw std::runtime_error(std::format(\"unable to write memory: {}\", GetLastError()));\n        }\n        HANDLE thread = CreateRemoteThread(pi.hProcess, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(LoadLibraryA), mem, 0, nullptr);\n        if (thread == NULL) {\n            throw std::runtime_error(std::format(\"unable to create thread: {}\", GetLastError()));\n        }\n        defer->void {\n            CloseHandle(thread);\n        };\n        WaitForSingleObject(thread, INFINITE);\n        return pi.hProcess;\n    }", "predict_code_clean": "[[nodiscard]] HANDLE inject(std::string_view dll_path, std::string_view proc_name) {\n    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);\n    if (snapshot == INVALID_HANDLE_VALUE) {\n        throw std::runtime_error(\"Failed to create process snapshot\");\n    }\n    DEFER { CloseHandle(snapshot); };\n    PROCESSENTRY32 pe32{};\n    pe32.dwSize = sizeof(pe32);\n    if (!Process32First(snapshot, &pe32)) {\n        throw std::runtime_error(\"Failed to retrieve process information\");\n    }\n    DWORD pid = 0;\n    do {\n        if (proc_name == pe32.szExeFile) {\n            pid = pe32.th32ProcessID;\n            break;\n        }\n    } while (Process32Next(snapshot, &pe32));\n    if (pid == 0) {\n        throw std::runtime_error(\"Process not found\");\n    }\n    HANDLE h_proc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);\n    if (!h_proc) {\n        throw std::runtime_error(\"Failed to open target process\");\n    }\n    bool injected = false;\n    DEFER {\n        if (!injected) {\n            CloseHandle(h_proc);\n        }\n    };\n    LPVOID remote_mem = VirtualAllocEx(h_proc, nullptr, dll_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);\n    if (!remote_mem) {\n        throw std::runtime_error(\"Failed to allocate memory in target process\");\n    }\n    DEFER {\n        VirtualFreeEx(h_proc, remote_mem, 0, MEM_RELEASE);\n    };\n    if (!WriteProcessMemory(h_proc, remote_mem, dll_path.data(), dll_path.size() + 1, nullptr)) {\n        throw std::runtime_error(\"Failed to write DLL path into target process\");\n    }\n    FARPROC loadlib_addr = GetProcAddress(GetModuleHandleA(\"kernel32.dll\"), \"LoadLibraryA\");\n    if (!loadlib_addr) {\n        throw std::runtime_error(\"Failed to get LoadLibraryA address\");\n    }\n    HANDLE h_thread = CreateRemoteThread(h_proc, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(loadlib_addr), remote_mem, 0, nullptr);\n    if (!h_thread) {\n        throw std::runtime_error(\"Failed to create remote thread\");\n    }\n    DEFER {\n        CloseHandle(h_thread);\n    };\n    WaitForSingleObject(h_thread, INFINITE);\n    DWORD exit_code;\n    if (!GetExitCodeThread(h_thread, &exit_code)) {\n        throw std::runtime_error(\"Failed to get thread exit code\");\n    }\n    if (exit_code == 0) {\n        throw std::runtime_error(\"Failed to load DLL\");\n    }\n    injected = true;\n    return h_proc;\n}"}}