注入Dll 阻止任务管理器结束进程 -- Win 10/11

已于 2024-05-24 23:15:33 修改
阅读量653 收藏 2
点赞数 2
分类专栏： Windows 基础编程 文章标签： windows c++ 微软
于 2023-10-05 19:49:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59075481/article/details/133004370
版权

任务管理器通过 NtQuerySystemInformation 获取进程信息，通过 TerminateProcess 以及 EndTask 等函数终止进程，我们可以通过挂钩途径中的多个R3函数实现在任务管理器中保护进程。网上有很多通过挂钩 TerminalProcess 来拦截终止功能的教程。这里从查找进程信息阶段拦截实现保护/隐身目标进程。

2024.05.24：近期有读者指出该代码不能够做到拦截的效果，我将抽空核实是否能够拦截，并研究解决方法。

这里需要注意的是，通过挂钩 SHParseDisplayName 可以进一步阻止右键菜单中的打开文件路径操作。

NtQuerySystemInformation 的定义如下：

NTSTATUS WINAPI NtQuerySystemInformation(
    _In_       SYSTEM_INFORMATION_CLASS SystemInformationClass,
    _In_ _Out_ PVOID SystemInformation,
    _In_       ULONG SystemInformationLength,
    _Out_opt_  PULONG ReturnLength
);

其中，第一个参数是一个结构体，包含进程的信息，结构体是根据 ProcessHacker 网站的资料获得的：

typedef struct _SYSTEM_PROCESS_INFORMATION
{
    ULONG            NextEntryOffset; // 指向下一个结构体的指针
    ULONG            ThreadCount; // 本进程的总线程数
    ULONG            Reserved1[6]; // 保留
    LARGE_INTEGER    CreateTime; // 进程的创建时间
    LARGE_INTEGER    UserTime; // 在用户层的使用时间
    LARGE_INTEGER    KernelTime; // 在内核层的使用时间
    UNICODE_STRING   ImageName; // 进程名
    KPRIORITY        BasePriority; // 
    ULONG            ProcessId; // 进程ID
    ULONG            InheritedFromProcessId;
    ULONG            HandleCount; // 进程的句柄总数
    ULONG            Reserved2[2]; // 保留
    VM_COUNTERS      VmCounters;
    IO_COUNTERS      IoCounters;
    SYSTEM_THREAD_INFORMATION Threads[5]; // 子线程信息数组
}SYSTEM_PROCESS_INFORMATION, * PMY_SYSTEM_PROCESS_INFORMATION;

可以看出该接口返回的结构体包含链表结构，我们可以通过断链方法隐藏进程，或者通过记录查找到的进程信息，在联合挂钩 NtOpenProcess 等函数来保护进程。

// 一下记录最近20条的模式其实可以用栈来实现
DWORD pid[20] = { 0 };// 只记录最近的20个目标进程
int cnt = 0;// 计数
NTSTATUS WINAPI HookedNtQuerySystemInformation(
    _In_       SYSTEM_INFORMATION_CLASS SystemInformationClass,
    _In_ _Out_ PVOID SystemInformation,
    _In_       ULONG SystemInformationLength,
    _Out_opt_  PULONG ReturnLength
) {
    bool flag = false;
    // 先正常调用原函数，获取返回值
    NTSTATUS status = ((__NtQuerySystemInformation)fpNtQuerySystemInformation)(SystemInformationClass,
        SystemInformation,
        SystemInformationLength,
        ReturnLength);
    // 判断是否是进程信息和调用是否成功
    if (SystemInformationClass == SystemProcessInformation && NT_SUCCESS(status)) {
        //MY_SYSTEM_PROCESS_INFORMATION pCurrent = NULL;
        PMY_SYSTEM_PROCESS_INFORMATION pNext = (PMY_SYSTEM_PROCESS_INFORMATION)SystemInformation;

        // 单链表循环
        do
        {
            pNext = (PMY_SYSTEM_PROCESS_INFORMATION)((PUCHAR)pNext + pNext->NextEntryOffset);

            if (!wcsncmp(pNext->ImageName.Buffer, L"Notepad.exe", pNext->ImageName.Length))
            {
                flag = false;
                for (int i = 1; i <= cnt; i++)
                {
                    if (pid[i] == (DWORD)pNext->InheritedFromProcessId)
                        flag = true;
                }

                if (flag == false && cnt < 19)
                {
                    pid[++cnt] = (DWORD)pNext->InheritedFromProcessId;
                    pid[0] = cnt;
                }
                else if (flag == false && cnt >= 19)// 记录满了就清零
                {
                    cnt = 0;
                    pid[++cnt] = (DWORD)pNext->InheritedFromProcessId;
                    pid[0] = cnt;
                }
            }
        } while (pNext->NextEntryOffset != 0);
    }
    // 正常返回
    return status;
}

其他部分不在详细叙述，给出完整代码，需要注意的是，该挂钩只适用于 Taskmgr 不适用于procexp 等程序。

对于窗口程序，需要挂钩 SendMessageTimeout 函数，过滤其发出的 SC_CLOSE 消息，挂钩 NtOpenProcess 和 NtOpenThread 可以阻止 ZwTerminateProcess 等函数，因为我们返回无效句柄。

完整代码：

#include "pch.h"
#include "detours.h"
#include <winternl.h>
#include <ShlObj.h>
#include <TlHelp32.h>

#pragma comment(lib, "detours.lib")


void StartHookingFunction();
void UnmappHookedFunction();


typedef struct _VM_COUNTERS
{
    SIZE_T        PeakVirtualSize;
    SIZE_T        VirtualSize;
    ULONG         PageFaultCount;
    SIZE_T        PeakWorkingSetSize;
    SIZE_T        WorkingSetSize;
    SIZE_T        QuotaPeakPagedPoolUsage;
    SIZE_T        QuotaPagedPoolUsage;
    SIZE_T        QuotaPeakNonPagedPoolUsage;
    SIZE_T        QuotaNonPagedPoolUsage;
    SIZE_T        PagefileUsage;
    SIZE_T        PeakPagefileUsage;
} VM_COUNTERS;

// 线程信息结构体
typedef struct _MY_SYSTEM_THREAD_INFORMATION
{
    LARGE_INTEGER   KernelTime;
    LARGE_INTEGER   UserTime;
    LARGE_INTEGER   CreateTime;
    ULONG           WaitTime;
    PVOID           StartAddress;
    CLIENT_ID       ClientId;
    KPRIORITY       Priority;
    KPRIORITY       BasePriority;
    ULONG           ContextSwitchCount;
    LONG            State;// 状态,是THREAD_STATE枚举类型中的一个值
    LONG            WaitReason;//等待原因, KWAIT_REASON中的一个值
} MY_SYSTEM_THREAD_INFORMATION, * PMY_SYSTEM_THREAD_INFORMATION;


typedef struct _MY_UNICODE_STRING
{
    USHORT Length;
    USHORT MaximumLength;
    PWSTR  Buffer;
} MY_UNICODE_STRING, * PMY_UNICODE_STRING;


typedef struct _MY_SYSTEM_PROCESS_INFORMATION
{
    ULONG            NextEntryOffset; // 指向下一个结构体的指针
    ULONG            ThreadCount; // 本进程的总线程数
    ULONG            Reserved1[6]; // 保留
    LARGE_INTEGER    CreateTime; // 进程的创建时间
    LARGE_INTEGER    UserTime; // 在用户层的使用时间
    LARGE_INTEGER    KernelTime; // 在内核层的使用时间
    MY_UNICODE_STRING   ImageName; // 进程名
    KPRIORITY        BasePriority; // 
    ULONG            ProcessId; // 进程ID
    ULONG            InheritedFromProcessId;
    ULONG            HandleCount; // 进程的句柄总数
    ULONG            Reserved2[2]; // 保留
    VM_COUNTERS      VmCounters;
    IO_COUNTERS      IoCounters;
    SYSTEM_THREAD_INFORMATION Threads[5]; // 子线程信息数组
}MY_SYSTEM_PROCESS_INFORMATION, * PMY_SYSTEM_PROCESS_INFORMATION;

#define STDAPICALLTYPE __stdcall

// 定义一个指针函数类型
typedef NTSTATUS(WINAPI* __NtQuerySystemInformation)(
    _In_       SYSTEM_INFORMATION_CLASS SystemInformationClass,
    _In_ _Out_ PVOID SystemInformation,
    _In_       ULONG SystemInformationLength,
    _Out_opt_  PULONG ReturnLength
    );

typedef HANDLE (WINAPI* __OpenProcess)(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL  bInheritHandle,
    _In_ DWORD dwProcessId
    );

typedef HANDLE (WINAPI* __OpenThread)(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL  bInheritHandle,
    _In_ DWORD dwThreadId
);

typedef LRESULT (WINAPI* __SendMessageW)(
    _In_   HWND   hWnd,
    _In_   UINT   Msg,
    _In_   WPARAM wParam,
    _In_   LPARAM lParam
);

typedef LRESULT(WINAPI* __SendMessageTimeoutW)(
    _In_       HWND       hWnd,
    _In_       UINT       Msg,
    _In_       WPARAM     wParam,
    _In_       LPARAM     lParam,
    _In_       UINT       fuFlags,
    _In_       UINT       uTimeout,
    _Out_opt_  PDWORD_PTR lpdwResult
);

typedef HRESULT (STDAPICALLTYPE* __SHParseDisplayName)(
    _In_            PCWSTR           pszName,
    _In_opt_        IBindCtx* pbc,
    _Out_           PIDLIST_ABSOLUTE* ppidl,
    _In_            SFGAOF           sfgaoIn,
    _Out_opt_       SFGAOF* psfgaoOut
);

typedef BOOL (WINAPI* __EndTask)(
    _In_ HWND hWnd,
    _In_ BOOL fShutDown,
    _In_ BOOL fForce
);

// 定义一个存放原函数的指针
PVOID fpNtQuerySystemInformation = NULL;
PVOID fpOpenProcess = NULL;
PVOID fpOpenThread = NULL;
PVOID fpSendMessageTimeout = NULL;
PVOID fpSendMessage = NULL;
PVOID fpSHParseDisplayName = NULL;
PVOID fpEndTask = NULL;

// 全局变量
DWORD pid[20]{};
int cnt = 0;

NTSTATUS WINAPI HookedNtQuerySystemInformation(
    _In_       SYSTEM_INFORMATION_CLASS SystemInformationClass,
    _In_ _Out_ PVOID SystemInformation,
    _In_       ULONG SystemInformationLength,
    _Out_opt_  PULONG ReturnLength
);

HANDLE WINAPI HookedOpenProcess(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL  bInheritHandle,
    _In_ DWORD dwProcessId
);

HANDLE WINAPI HookedOpenThread(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL  bInheritHandle,
    _In_ DWORD dwThreadId
);

LRESULT WINAPI HookedSendMessageW(
    _In_   HWND   hWnd,
    _In_   UINT   Msg,
    _In_   WPARAM wParam,
    _In_   LPARAM lParam
    );

LRESULT WINAPI HookedSendMessageTimeout(
    _In_       HWND       hWnd,
    _In_       UINT       Msg,
    _In_       WPARAM     wParam,
    _In_       LPARAM     lParam,
    _In_       UINT       fuFlags,
    _In_       UINT       uTimeout,
    _Out_opt_  PDWORD_PTR lpdwResult
);

HRESULT STDAPICALLTYPE HookedSHParseDisplayName(
    _In_            PCWSTR           pszName,
    _In_opt_        IBindCtx* pbc,
    _Out_           PIDLIST_ABSOLUTE* ppidl,
    _In_            SFGAOF           sfgaoIn,
    _Out_opt_       SFGAOF* psfgaoOut
);

BOOL WINAPI HookedEndTask(
    _In_ HWND hWnd,
    _In_ BOOL fShutDown,
    _In_ BOOL fForce
);

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    DisableThreadLibraryCalls(hModule);
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        StartHookingFunction();
        break;
    case DLL_THREAD_ATTACH:
        break;
    case DLL_THREAD_DETACH:
        break;
    case DLL_PROCESS_DETACH:
        UnmappHookedFunction();
        break;
    }
    return TRUE;
}

void StartHookingFunction()
{
    //开始事务
    DetourTransactionBegin();
    //更新线程信息  
    DetourUpdateThread(GetCurrentThread());

    fpNtQuerySystemInformation =
        DetourFindFunction(
            "ntdll.dll",
            "NtQuerySystemInformation");
    fpOpenProcess =
        DetourFindFunction(
            "kernel32.dll",
            "OpenProcess");
    fpOpenThread =
        DetourFindFunction(
            "kernel32.dll",
            "OpenThread");
    fpSendMessage =
        DetourFindFunction(
            "user32.dll",
            "SendMessageW");
    fpSendMessageTimeout =
        DetourFindFunction(
            "user32.dll",
            "SendMessageTimeoutW");
    fpSHParseDisplayName =
        DetourFindFunction(
            "shell32.dll",
            "SHParseDisplayName");
    fpEndTask =
        DetourFindFunction(
            "user32.dll",
            "EndTask");
    //将拦截的函数附加到原函数的地址上,这里可以拦截多个函数。
    DetourAttach(&(PVOID&)fpNtQuerySystemInformation,
        HookedNtQuerySystemInformation);
    DetourAttach(&(PVOID&)fpOpenProcess,
        HookedOpenProcess);
    DetourAttach(&(PVOID&)fpOpenThread,
        HookedOpenThread);
    DetourAttach(&(PVOID&)fpSendMessage,
        HookedSendMessageW);
    DetourAttach(&(PVOID&)fpSendMessageTimeout,
        HookedSendMessageTimeout);
    DetourAttach(&(PVOID&)fpSHParseDisplayName,
        HookedSHParseDisplayName);
    DetourAttach(&(PVOID&)fpSHParseDisplayName,
        HookedSHParseDisplayName);
    DetourAttach(&(PVOID&)fpEndTask,
        HookedEndTask);
    //结束事务
    DetourTransactionCommit();
}

void UnmappHookedFunction()
{
    //开始事务
    DetourTransactionBegin();
    //更新线程信息 
    DetourUpdateThread(GetCurrentThread());

    //将拦截的函数从原函数的地址上解除，这里可以解除多个函数。
    DetourDetach(&(PVOID&)fpNtQuerySystemInformation,
        HookedNtQuerySystemInformation);
    DetourDetach(&(PVOID&)fpOpenProcess,
        HookedOpenProcess);
    DetourDetach(&(PVOID&)fpOpenThread,
        HookedOpenThread);
    DetourDetach(&(PVOID&)fpSendMessage,
        HookedSendMessageW);
    DetourDetach(&(PVOID&)fpSendMessageTimeout,
        HookedSendMessageTimeout);
    DetourDetach(&(PVOID&)fpSHParseDisplayName,
        HookedSHParseDisplayName);
    DetourDetach(&(PVOID&)fpEndTask,
        HookedEndTask);
    //结束事务
    DetourTransactionCommit();
}


// 定义一个Hook函数,隐藏指定进程名程序
NTSTATUS WINAPI HookedNtQuerySystemInformation(
    _In_       SYSTEM_INFORMATION_CLASS SystemInformationClass,
    _In_ _Out_ PVOID SystemInformation,
    _In_       ULONG SystemInformationLength,
    _Out_opt_  PULONG ReturnLength
) {
    bool flag = false;
    // 先正常调用原函数，获取返回值
    NTSTATUS status = ((__NtQuerySystemInformation)fpNtQuerySystemInformation)(SystemInformationClass,
        SystemInformation,
        SystemInformationLength,
        ReturnLength);
    // 判断是否是进程信息和调用是否成功
    if (SystemInformationClass == SystemProcessInformation && NT_SUCCESS(status)) {
        //MY_SYSTEM_PROCESS_INFORMATION pCurrent = NULL;
        PMY_SYSTEM_PROCESS_INFORMATION pNext = (PMY_SYSTEM_PROCESS_INFORMATION)SystemInformation;

        // 单链表循环
        do
        {
            //pCurrent = pNext;
            pNext = (PMY_SYSTEM_PROCESS_INFORMATION)((PUCHAR)pNext + pNext->NextEntryOffset);

            if (!wcsncmp(pNext->ImageName.Buffer, L"Notepad.exe", pNext->ImageName.Length))
            {
                flag = false;
                for (int i = 1; i <= cnt; i++)
                {
                    if (pid[i] == (DWORD)pNext->InheritedFromProcessId)
                        flag = true;
                    //pid = (DWORD)pNext->UniqueProcessId;
                }

                if (flag == false && cnt < 19)
                {
                    pid[++cnt] = (DWORD)pNext->InheritedFromProcessId;
                    pid[0] = cnt;
                    //ListProcessThreads((DWORD)pNext->UniqueProcessId);
                }
                else if (flag == false && cnt >= 19)
                {
                    cnt = 0;
                    pid[++cnt] = (DWORD)pNext->InheritedFromProcessId;
                    pid[0] = cnt;
                    //ListProcessThreads((DWORD)pNext->UniqueProcessId);
                }
            }
        } while (pNext->NextEntryOffset != 0);
    }
    // 正常返回
    return status;
}

HANDLE WINAPI HookedOpenProcess(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL  bInheritHandle,
    _In_ DWORD dwProcessId
)
{
    if ((int)pid[0] > 1) {
        for (int i = (int)pid[0]; i >= 1; i--) {
            if (dwProcessId == pid[i])
            {
                SetLastError(5);
                return NULL;
            } 
        }
        return ((__OpenProcess)fpOpenProcess)(dwDesiredAccess, bInheritHandle, dwProcessId);
    }
    else if ((int)pid[0] == 1) {
        if (dwProcessId == pid[1])
        {
            SetLastError(5);
            return NULL;
        }
        else
        {
            return ((__OpenProcess)fpOpenProcess)(dwDesiredAccess, bInheritHandle, dwProcessId);
        }
    }
    else
    {
        return ((__OpenProcess)fpOpenProcess)(dwDesiredAccess, bInheritHandle, dwProcessId);
    }
}

HANDLE WINAPI HookedOpenThread(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL  bInheritHandle,
    _In_ DWORD dwThreadId
)
{
    DWORD dwProtectedTid = 0;
    HWND hTargetWnd = FindWindowW(L"Notepad", NULL);
    if (hTargetWnd != NULL)
    {
        dwProtectedTid = GetWindowThreadProcessId(hTargetWnd, NULL);
    }

    if (dwProtectedTid != 0 && dwThreadId == dwProtectedTid)
    {
        SetLastError(5);
        return NULL;
    }
    return ((__OpenThread)fpOpenThread)(dwDesiredAccess, bInheritHandle, dwThreadId);
}

LRESULT WINAPI HookedSendMessageW(
    _In_   HWND   hWnd,
    _In_   UINT   Msg,
    _In_   WPARAM wParam,
    _In_   LPARAM lParam
)
{
    //DWORD curprocid = 0;
    
    if (hWnd == 0)
        return E_FAIL;

    if ((hWnd == HWND_BROADCAST ) && (Msg == WM_DESTROY || Msg == WM_QUIT || Msg == WM_CLOSE))
    {
        SetLastError(5);
        return E_FAIL;
    }

    if (hWnd != NULL)
    {
        int Target = NULL;
        WCHAR ClassName[500]{};
        Target = GetClassNameW(hWnd, ClassName, sizeof(ClassName) / sizeof(WCHAR));
        if (!wcscmp(ClassName, L"Notepad"))
        {
            SetLastError(5);
            return E_FAIL;
        }
        else return ((__SendMessageW)fpSendMessage)(hWnd, Msg, wParam, lParam);
    }
    return ((__SendMessageW)fpSendMessage)(hWnd, Msg, wParam, lParam);
}

LRESULT WINAPI HookedSendMessageTimeout(
    _In_       HWND       hWnd,
    _In_       UINT       Msg,
    _In_       WPARAM     wParam,
    _In_       LPARAM     lParam,
    _In_       UINT       fuFlags,
    _In_       UINT       uTimeout,
    _Out_opt_  PDWORD_PTR lpdwResult
)
{
    if (hWnd != NULL)
    {
        int Target = NULL;
        WCHAR ClassName[500]{};
        Target = GetClassNameW(hWnd, ClassName, sizeof(ClassName) / sizeof(WCHAR));
        if (!wcscmp(ClassName, L"Notepad") && Msg == WM_SYSCOMMAND && wParam == SC_CLOSE)
        {
            return S_FALSE;
        }
    }
    return ((__SendMessageTimeoutW)fpSendMessageTimeout)
        (hWnd, Msg, wParam, lParam, fuFlags, uTimeout, lpdwResult);
}

HRESULT STDAPICALLTYPE HookedSHParseDisplayName(
    _In_            PCWSTR               pszName,
    _In_opt_        IBindCtx*            pbc,
    _Out_           PIDLIST_ABSOLUTE*    ppidl,
    _In_            SFGAOF               sfgaoIn,
    _Out_opt_       SFGAOF*              psfgaoOut
)
{
    if (wcsstr(pszName, L"Notepad.exe"))
        return ((__SHParseDisplayName)fpSHParseDisplayName)
        (L"C:\\Windows\\explorer.exe", pbc, ppidl, sfgaoIn, psfgaoOut);
    else 
        return ((__SHParseDisplayName)fpSHParseDisplayName)
        (pszName, pbc, ppidl, sfgaoIn, psfgaoOut);
}


BOOL WINAPI HookedEndTask(
    _In_ HWND hWnd,
    _In_ BOOL fShutDown,
    _In_ BOOL fForce
)
{
    int Target = NULL;
    WCHAR ClassName[500]{};
    Target = GetClassNameW(hWnd, ClassName, sizeof(ClassName) / sizeof(WCHAR));

    if (Target != NULL && !wcscmp(ClassName, L"Notepad"))
    {
        SetLastError(5);
        return FALSE;
    }
    else return ((__EndTask)fpEndTask)(hWnd, fShutDown, fForce);
}

程序运行效果如下图所示：

转载请注明出处：Detours挂钩实现进程保护(任务管理器) 

发布于：2023.10.05，更新于：2023.10.14, 2024.05.24.

python dll注入监听_HOOK -- DLL的远程注入技术详解(1)
weixin_30894765的博客
02-19 1236
DLL的远程注入技术是目前Win32病毒广泛使用的一种技术。使用这种技术的病毒体通常位于一个DLL中，在系统启动的时候，一个EXE程序会将这个DLL加载至某些系统进程(如Explorer.exe)中运行。这样一来，普通的进程管理器就很难发现这种病毒了，而且即使发现了也很难清除，因为只要病毒寄生的进程不终止运行，那么这个DLL就不会在内存中卸载，用户也就无法在资源管理器中删除这个DLL文件，真可谓一...
任务管理器的进程列表中隐藏当前进程
08-21
难得的支持2000 2003 xp vista win7 隐藏进程的源代码，解决只能在win98下隐藏进程的难题。
【Windows】在任务管理器中隐藏进程
最新发布
溡漪幽博客
10-02 1091
本篇利用 hook NtQuerySystemInformation 并进行断链的方法实现进程隐身，实测支持 taskmgr.exe 的任意多进程隐身。可以删除 dllmain 里面的hook 函数以及所有输出字符串。从外部进程通过注入远程线程的方式来实现动态调整隐身策略。本文发布于：2024.10.02。在此前的一篇，我们已经介绍过了。
使用HOOK拦截任务管理器中直接杀进程的消息
05-08
这是本人在网上搜索到的资料,跟大家分享,感谢那个提供源码的网友. 大家都知道,在任务管理器进程标签中直接杀进程,是直接杀,不交给用户处理.很多人都在为了防止自己的进程被误杀而苦苦思索,但是一般的拦截消息的方法又几乎都不管用. 在这里,给大家一个Delphi的源码,使用HOOK进行拦截处理任务管理器来实现. 在附件的文档中包含了源码,共分为两个部分:exe测试部分,Dll部分(HookDll,unithook). 我已经亲自编译测试过,可以实现拦截任务管理器的消息. 再次感谢那个网友(没有记住名...)! PS:附件中的Word是使用Office2010保存的docx格式,如果您不能打开我这个文档,可以在我的资源目录下找这个补丁安装上就可以了. FileFormatConverters_Office_doc_to_docx 这个是微软提供的,可以使Office2003等早期版本打开新的docx格式文档. 感谢大家光临!
使用dll注入技术给windows任务管理器增加功能
错位竞争，单点突破。
12-10 4060
本文参考：http://www.pediy.com/kssd/index.html 另dll注入参考我的另一篇博文：http://blog.csdn.net/anda0109/article/details/41309973 dll注入技术参考我的博文，本文主要是修改应用程序界面和功能的实现，其步骤如下： 1、使用spy++找到要修改的窗口的控件ID。 2、使用windows API找到控
任务管理器的远程线程注入：实现隐藏自身程序（个人学习笔记）
jinganggiao的博客
12-29 976
一、总体思路 1.遍历进程找到任务管理器，在该进程申请空间(申请空间strlen 不包括\0，后面写入路径时需要\0，所以申请内存时应该稍大,内存属性设置为 MEM_COMMIT 提交至进程内存)，写入dll路径，运行dll 2.dll:hook任务管理器遍历进程函数并HOOK 3.判断进程名称是否为自身进程 4.判断为自身进程时 通过返回值等其他手段隐藏自身 实现代码： EXE #include <stdio.h> #include <windows.h> #incl
基于dll注入 读取任务管理器中指定进程的详细信息
felicityWSH的博客
02-17 779
基于dll注入 读取任务管理器中指定进程的详细信息
如何防止第三方DLL注入自己的进程？
shada的专栏
07-14 379
设置 (0x1) 以防止进程加载未由 Microsoft、Windows 应用商店和 Windows 硬件质量实验室 (WHQL) 签名的图像;测试结论是没有起到作用，这是因为SetProcessMitigationPolicy是在程序启动后调用的，调用前就已经被注入了。设置 (0x1) 以防止进程加载未由 Windows 应用商店签名的图像;设置 (0x1) 以防止进程加载未由 Microsoft 签名的图像;这个结构包含用于加载映像的进程缓解策略设置，具体取决于映像的签名。
win7 64位dll注入可注入系统进程不蓝屏
12-11
4. **注入DLL**：在新创建的远程线程的入口点，我们将调用LdrLoadDll来加载DLL。提供DLL路径和适当的加载标志。 5. **清理和控制**：成功注入后，我们需要确保注入线程正常结束，可能还需要清理一些资源，例如关闭...
任务管理器进程不结束C# DLL调用
11-27
任务管理器进程不结束,移植与C++ C# DLL调用 可以调用，win7测试通过64为
结束进程中DLL
02-27
结束进程中DLL
进程防杀 HOOK ，防止任务管理杀死程序
11-30
进程防杀技术主要涉及到计算机系统中的进程管理和保护机制，尤其是如何在面对恶意操作或系统工具如任务管理器的干预时，保持程序的持续运行。在本文中，我们将深入探讨HOOK技术及其在进程保护中的应用。 HOOK是...
阻止EDR注入dll
记录学习，一起进步
04-04 996
阻止EDR进行dll注入的探索
c# 钩子函数拦截任务管理器的关闭消息详情实现介绍.docx
06-09
代码解释： 在窗体加载时，使用SetWindowsHookEx来设置钩子函数，该函数会返回钩子句柄 设置钩子函数的委托Callback，如果拦截到任务管理器关闭消息，则在控制台输出一条信息，并返回IntPtr.Zero来拦截消息 在窗体关闭时，调用UnhookWindowsHookEx来卸载钩子 使用DllImport引入Windows API，包括SetWindowsHookEx、UnhookWindowsHookEx、CallNextHookEx、GetShellWindow等函数 需要注意的是，使用钩子函数来拦截系统消息是一种涉及到系统底层的技术操作，应该谨慎使用。少量的、恰当使用的钩子函数不会对系统造成影响，但是如果使用不当可能会影响系统稳定性和安全。
关闭使用某个DLL的进程
CodeArhat的专栏
06-20 4050
列出使用abc.dll的进程ID  tasklist /m abc.dll 强制关闭指定PID的进程： taskkill /f /pid 1234
DLL注入和API拦截
jaken99的专栏
07-28 1178
在 Windows中，每个进程有自己的私有地址空间。当我们用指针来引用内存的时候，指针的值表示的是进程自己的地址空间中的一个内存地址。进程不能创建一个指针来引用属于其它进程的内存。因此，如果进程有一个缺陷会覆盖随机地址处的内存，那么这个缺陷不会影响到其它进程所使用的内存。      独立的地址空间对开发人员和用户都是非常有利的。对开发人员来说，系统更有可能捕获错误的内存读/写。对用户来说，操作系
windows下面hook系统api实现禁止任务管理器关闭程序
nanjun520的专栏
07-28 7622
为了保护我们的进程不被人随便强制关闭，我们需要一种机制来实现，网上大概有几种方式：1.写一个驱动程序，在驱动程序里面hook系统的api来实现，例如ssdt方式，等等。2.就是在应用层挂钩系统api，这种方式也就远程注入，全局钩子啊等等，只是网上也有很多，不过很多在xp上是正常的到了win7 64就失效了。还有最简单的就是启动两个进程相互监视对方，(这个可能看起来不专业)。 网上方法很多，我写这个
DLL 注入进程
10-23 820
进程注入有很多方式，其中有一种利用远程线程技术来实现进程的注入。这个方式能实现主要是因为  DLL 动态加载的函数原型和线程函数的原型非常相像，所以这两个函数的指针式可以兼容的。 HMODULE LoadLibrary( LPCTSTR lpFileName);DWORD WINAPI ThreadProc(LPVOID lpParameter);在 调用 HANDLE C
易语言结束进程中的DLL
07-21
易语言结束进程中的DLL源码,结束进程中的DLL,提升进程权限,列表,表项,取模块路径,列调用的模块,结束进程中DLL,Module32First,ExtractIconA,打开进程,获取线程,打开令牌,恢复权限,获取令牌特权,CreateToolhelp32Snapshot,Module32Next,关闭句柄,VirtualAllocEx
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

涟幽516

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值