精华内容
下载资源
问答
  • 2020-01-17 14:24:49

    1. 用 户 态 进 程 检 测 方 法
    该 方 法 利 用 WindowsAPI检测进程。但是在实际应用中,该方法几乎无法检测到 Rootkit隐藏进程。
    用户态可以通过CreateToolhelp32Snapshot,Process32FirstProcess32Next遍历进程。
    或者通过通过psapi.dll提供的EnumProcesses来枚举进程。
    也可以使用Native API 中的ZwQuerySystemInformation的SystemProcessesAndThreadsInformation系统调用枚举进程。

     

    2. 内核态函数进程检测方法
    该方法利用内 核导出函数 ZwQuerySystemInformation等检测进 程.但 是 该 方 法 无 法 检 测 到 对 ZwQuerySystemInformation的输出进行劫持或者对进程链表采取 断链操作的隐藏进程。

     

    3. 遍历 EPROCESS双向链表进程检测方法.
    进程由 EPROCESS结构体描述,EPROCESS通过 其成员 ActiveProcessLinks够成双向链表.该方法 通过遍历此链表检测进程.但是该方法无法检测到 对进程链表采取断链操作的隐藏进程。

     

    4. 遍历句柄表进程检测方法
    所有进程的句 柄保存在 PspCidTable句柄表里.同时,系统在创 建一个新进程时,会把新进程的句柄复制到csrss. exe进程的句柄表中.因此,该方法遍历这两份句柄 表中的任意一份即可检测进程.但是该方法无法检 测到对句柄表进行擦除操作的隐藏进程。

     

    5. 搜索内存进程检测方法
    该方法遍历虚拟 内存或物理内存数据,把匹配进程对象特征信息的 内存区域视为 EPROCESS结构,从而获取对应进 程信息.但是该方法无法检测到擦除内存中进程特 征信息的隐藏进程。

     

    6. 基于 HSC(Hook System Call)的进程检测方法
    该方法根据进程执行系统调用的行为特征,通过劫持系统调用,检测进程.但是该方法无法检测到只通过中断调用或 调用门进入系统内核的隐藏进程.

     

    7. 遍历调度线程表进程检测方法.系统为每 个处理器维护了不同状态的线程列表.该方法通过 遍历这些线程列表获得操作系统中的线程信息,进 而解析出进程信息.但是,在不同 Windows系统版 本中,线程列表存在较大差异,使得该方法兼容性 差,实现难度大.

     

    8. 基 于 线 程 调 度 的 进 程 检 测 方 法. SwapContext是线程调度的核心函数.该方法通过 劫持此函数获取将要被换入和换出的线程,进而解析出所属进程.但是该方法对操作系统性能影响较大,因为这个函数调用频率非常高。

     

    9. 基于交叉视图的进程检测方法
    为检测隐藏 进程,通常采用交叉视图的方法获取可靠进程列表 和非可靠 进 程 列 表,通 过 对 比 两 张 列 表 检 测 隐 藏 进程.
    其中非可靠进程列表可以通过用户态进程遍历得到。
    可靠进程列表可以在内核中劫持内核入口点,在劫持例程中获取EPROCESS结构列表,获取进程ID。
    内核入口点有:KiFastCallEntry,IDT,GDT
    为降低对操作系统性能的影响,并非劫持所有IDT 和 GDT 中的服务例 程,仅仅对异常中断服务例程和 GDT 中的调用门 进行劫持.

     

    参考链接:http://journal.bit.edu.cn/zr/ch/reader/create_pdf.aspx?file_no=20150521&year_id=2015&quarter_id=5&falg=1

    更多相关内容
  • 隐藏进程4种方法
  • c# 隐藏进程代码,win10 win7 任务管理器中隐藏进程
  • win7 win8 win10 64位下 进程隐藏工具 亲测可用 win7 win8 win10 64位下 进程隐藏工具 亲测可用 win7 win8 win10 64位下 进程隐藏工具 亲测可用
  • 隐藏进程 'hideProcess' 在 Windows2k/Windows7(x86/x64 位)上从任务管理器中隐藏一个进程! 您的流程可以将其注入到其他流程中,只要您喜欢。 该示例使用 SetWindowsHookEx 和 CBT 挂钩(dll 导出 CBTProc)将其...
  • C#C++保护自身进程无法被任务管理器结束,WIN7 3264测试可用源码 C#C++保护自身进程无法被任务管理器结束,WIN7 3264测试可用源码 C#C++保护自身进程无法被任务管理器结束,WIN7 3264测试可用源码
  • windows守护进程

    千次阅读 2021-01-12 17:04:03
    1、windows没有fork函数,无法创建僵尸进程,使用打开非子进程的方式打开外部进程---打开外部进程 2、守护进程应该是单例的进程---》单例进程 3、守护进程应该是存在一个子线程不断的判断是否存在守护目标,若不...

    一、逻辑分析

    1、windows没有fork函数,无法创建僵尸进程,使用打开非子进程的方式打开外部进程---打开外部进程

    2、守护进程应该是单例的进程---》单例进程

    3、守护进程应该是存在一个子线程不断的判断是否存在守护目标,若不存在(异常退出)则启动守护目标

    4、当守护目标正常退出时,需要关闭守护进程

    (1)、直接kill掉守护进程(守护进程没有做成病毒进程(系统进程)---记录下这里没找到方法)

    (2)、进程间通讯实现关闭守护进程---有很多的方法博主使用的是命名管道

    二、守护线程

    #pragma once
    
    #include <QThread>
    
    class HiDaemon : public QThread
    {
    	Q_OBJECT
    public:
    	HiDaemon(QObject *parent = nullptr);
    	~HiDaemon();
    
    public slots:
    	void start();
    	void stop();
    
    private:
    	void run();
    
    private:
    	volatile bool			m_bRunning;
    
    	QString					m_strFilePath;
    	QString					m_strProducerName;
    };
    
    #include "HiDaemon.h"
    #include <windows.h>
    #include "tlhelp32.h"
    #include "tchar.h"
    #include "HiDaemonDef.h"
    #include "HiUtils.h"
    #include <QMessageBox>
    
    HiDaemon::HiDaemon(QObject *parent)
    	: QThread(parent)
    	, m_bRunning(false)
    	, m_strProducerName("")  // 这里自定义默认值
    {
    	m_strFilePath = QApplication::applicationDirPath();
    
    	QStringList strList = QApplication::arguments();
    	if (strList.size() > 1)
    	{
    		m_strProducerName = strList.at(1);
    	}
    }
    
    HiDaemon::~HiDaemon()
    {
    }
    
    void HiDaemon::start()
    {
    	if (m_bRunning)
    	{
    		return;
    	}
    	m_bRunning = true;
    
    	QThread::start();
    }
    
    void HiDaemon::stop()
    {
    	m_bRunning = false;
    	wait(1000);
    }
    
    void HiDaemon::run()
    {
    	STARTUPINFOA si;
    	//进程对象
    	PROCESS_INFORMATION pi;
    	//初始化 
    	ZeroMemory(&si, sizeof(si));
    	si.cb = sizeof(si);
    	ZeroMemory(&pi, sizeof(pi));
    
    	//构造cmd执行守护进程的字符串
    	char pCmd[MAX_PATH_NUM] = { 0 };
    
    	{
    		QFileInfo file(m_strFilePath + QDir::separator() + m_strProducerName);
    
    		QString strFilePath = file.filePath();
    		strcat_s(pCmd, strFilePath.toStdString().c_str());
    	}
    	
    	while (m_bRunning)
    	{
    		//检查守护程序是否存在
    		pi.hProcess = GetProcessHandleByName(m_strProducerName);
    
    		if (pi.hProcess == nullptr)
    		{
    			// 创建子进程,判断是否执行成功
    			if (CreateProcessA(NULL, pCmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
    			{
    				// 创建失败
    			}
    		}
    
    		if (pi.hProcess != nullptr)
    		{
    			//无限等待子进程退出
    			WaitForSingleObject(pi.hProcess, INFINITE);
    			CloseHandle(pi.hProcess);
    			CloseHandle(pi.hThread);
    		}
    		
    
    		Sleep(100);
    	}
    }
    

    二、命名管道实时通讯

    #pragma once
    #include <windows.h>
    #include <QThread>
    
    //
    //HANDLE CreateNamedPipe(
    //	LPCTSTR lpName,								// pipe name
    //	DWORD dwOpenMode,							// pipe open mode
    //	DWORD dwPipeMode,							// pipe-specific modes
    //	DWORD nMaxInstances,						// maximum number of instances
    //	DWORD nOutBufferSize,						// output buffer size
    //	DWORD nInBufferSize,						// input buffer size
    //	DWORD nDefaultTimeOut,						// time-out interval
    //	LPSECURITY_ATTRIBUTES lpSecurityAttributes  // SD
    //  );
    //
    
    class HiNamePipeServer : public QThread
    {
    	Q_OBJECT
    public:
    	HiNamePipeServer(QObject *parent = nullptr);
    	~HiNamePipeServer();
    
    	void start();
    	void stop();
    
    private slots:
    	void onParse();
    
    private:
    	void creatPipe();
    	void run();
    
    signals:
    	void parse();
    	void stopDaemon();
    
    private:
    	HANDLE						 m_pHandle;
    	HANDLE						 m_pEvent;
    	volatile bool				 m_bRunning;
    	char						 m_readbuffer[100];
    	DWORD						 m_readLenth;
    	bool						 m_resetStarted;
    	QString						 m_strFilePath;
    	QString						 m_strProducerName;
    };
    #include "HiNamePipeServer.h"
    #include <windows.h>
    #include <QDebug>
    #include "HiDaemonDef.h"
    #include "HiUtils.h"
    HiNamePipeServer::HiNamePipeServer(QObject *parent)
    	: QThread(parent)
    	, m_bRunning(false)
    	, m_pHandle(nullptr)
    	, m_resetStarted(false)
    {
    	creatPipe();
    	connect(this, &HiNamePipeServer::parse, this, &HiNamePipeServer::onParse, Qt::DirectConnection);
    	m_strFilePath = QApplication::applicationDirPath();
    
    	QStringList strList = QApplication::arguments();
    	if (strList.size() > 1)
    	{
    		m_strProducerName = strList.at(1);
    	}
    }
    
    HiNamePipeServer::~HiNamePipeServer()
    {
    	if (m_pHandle)
    	{
    		CloseHandle(m_pHandle);
    	}
    	CloseHandle(m_pEvent);
    }
    
    void HiNamePipeServer::start()
    {
    	if (m_bRunning)
    	{
    		return;
    	}
    	m_bRunning = true;
    	QThread::start();
    }
    
    void HiNamePipeServer::stop()
    {
    	m_bRunning = false;
    }
    
    void HiNamePipeServer::onParse()
    {
    	QString strMsg = m_readbuffer;
    
    	QStringList paramList = strMsg.split(WRITE_SPACER);
    	if (paramList.size() != 2)
    	{
    		return;
    	}
    	
    	PipeWriteType writeType = PipeWriteType(paramList.at(0).toInt());
    
    	switch (writeType)
    	{
    	case PipeWriteType_ClientExit:
    	{
    		emit stopDaemon();
    		qApp->quit();
    		break;
    	}
    	case PipeWriteType_ClinetRestart:
    	{
    		if (m_resetStarted == false)
    		{
    			m_resetStarted = true;
    			KillProcess(m_strProducerName);
    		}
    		break;
    	}
    	default:
    		break;
    	}
    
    }
    
    void HiNamePipeServer::creatPipe()
    {
    	m_pHandle = CreateNamedPipe(PIPE_NAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, PIPE_MAXINSTANCES, 0, 0, 1000, NULL);
    	if (INVALID_HANDLE_VALUE == m_pHandle)
    	{
    		CloseHandle(m_pHandle);
    		// 创建管道失败
    		m_pHandle = nullptr;
    	}
    }
    
    void HiNamePipeServer::run()
    {
    	// 这里暂时同步调用,可以考虑使用异步设置超时事件
    	while (m_bRunning)
    	{
    		OVERLAPPED  ovlap;
    		ZeroMemory(&ovlap, sizeof(OVERLAPPED));
    		//2. 创建管道连接
    		if (!ConnectNamedPipe(m_pHandle, &ovlap))
    		{
    			if (ERROR_IO_PENDING != GetLastError())
    			{
    				Sleep(100);
    				continue;
    			}
    		}
    
    		// 这个等待可能非常的久
    		if (ReadFile(m_pHandle, m_readbuffer, 100, &m_readLenth, NULL) == TRUE)
    		{
    			emit parse();
    		}
    		DisconnectNamedPipe(m_pHandle);
    	}
    }
    

    管道读取线程是阻塞的

    三、主函数

    #include <stdio.h>
    #include <stdlib.h>
    #include <io.h>
    #include <iostream>
    #include <string>
    #include <QString>
    #include <QApplication>
    #include "HiNamePipeServer.h"
    #include "HiDaemon.h"
    #include <QObject>
    #include "HiSingleApplication.h"
    
    LPCTSTR szAppClassName = TEXT("HiDaemon");
    LPCTSTR szAppWindowName = TEXT("HiDaemon");
    
    
    // HANDLE hProcess = ::OpenProcess(PROCESS_TERMINATE, FALSE, dwProcessID);
    // ::TerminateProcess(hProcess, 0);
    // CloseHandle(hProcess);
    
    using namespace std;
    
    // 隐藏DOS黑窗口
    #ifdef _MSC_VER
    #pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
    #endif
    
    int main(int argc, char* argv[])
    {
    	HiSingleApplication a(argc, argv);
    	// 这里应该传入的产品类型,不同的产品,启动后可能动作不一致
    	QCoreApplication::setOrganizationName("EnlightV");
    	QCoreApplication::setApplicationName("HiDaemon");
    	if (a.isRunning())
    	{
    		return 0;
    	}
    
    	HiDaemon *daemon = new HiDaemon;
    	HiNamePipeServer *server = new HiNamePipeServer;
    
    	QObject::connect(server, &HiNamePipeServer::stopDaemon, daemon, &HiDaemon::stop, Qt::DirectConnection);
    
    	daemon->start();
    	server->start();
    
    	a.exec();
    
    	return 0;
    }

    四、应用程序启动守护进程

    // 获取守护进程句柄
    HANDLE GetProcessHandleByName(const QString &name)
    {
    	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    	if (INVALID_HANDLE_VALUE == hSnapshot)
    	{
    		return NULL;
    	}
    	PROCESSENTRY32 pe = { sizeof(pe) };
    	BOOL fOk;
    	for (fOk = Process32First(hSnapshot, &pe); fOk; fOk = Process32Next(hSnapshot, &pe))
    	{
    		if (QString::fromWCharArray(pe.szExeFile) == name)
    		{
    			CloseHandle(hSnapshot);
    			return GetProcessHandle(pe.th32ProcessID);
    		}
    	}
    	return NULL;
    }
    
    //tempPath 是自定义的一个可写目录
    void StartDaemon(const QString &tempPath)
    {
    	// 1、检测守护进程是否已经启动了
    	if (GetProcessHandleByName(DAEMON_NAME) != nullptr)
    	{
    		return;
    	}
    
    	QString batFile = tempPath + QDir::separator() + "StartDaemon.bat";
    	if (QFile(batFile).exists())
    	{
    		QFile(batFile).remove();
    	}
    
    	QFile file(batFile);
    	if (file.open(QFile::ReadWrite))
    	{
    		QString strParam = QString("@echo off \n start /d  \"%1\" HiDaemond.exe  \"%2\" \n exit").arg(QCoreApplication::applicationDirPath()).arg(QFileInfo(QCoreApplication::applicationFilePath()).fileName());
    		file.write(strParam.toLocal8Bit());
    		file.close();
    
    		QProcess p;
    		p.start("cmd.exe", QStringList() << "/c" << batFile);
    		if (p.waitForStarted())
    		{
    			p.waitForFinished(2000);
    			return;
    		}
    	}
    	else
    	{
    		QString strAppPath = QApplication::applicationDirPath();
    		QStringList arguments;
    		{
    			QFileInfo file(QApplication::applicationFilePath());
    			arguments.append(file.fileName());
    		}
    		QFileInfo deamonFile(strAppPath + QDir::separator() + DAEMON_NAME);
    		if (deamonFile.exists())
    		{
    			std::wstring operate = QString("runas").toStdWString();//临时提升管理员权限
    			std::wstring path = QCoreApplication::applicationDirPath().toStdWString();
    			std::wstring appName = QFileInfo(QCoreApplication::applicationFilePath()).fileName().toStdWString();;
    			std::wstring file = deamonFile.filePath().toStdWString();
    			int ret = (int)ShellExecute(NULL, operate.c_str(), file.c_str(), appName.c_str(), path.c_str(), SW_SHOWNORMAL);
    		}
    
    	}
    }
    

    五、主端关闭时候,通讯给守护进程自行关闭

    #pragma once
    
    #include <windows.h>
    
    class HiNamePipeClient
    {
    public:
    	static HiNamePipeClient* getInstance();
    	void writeFile(PipeWriteType type,  const QString & param = QString());
    
    protected:
    	HiNamePipeClient();
    	~HiNamePipeClient();
    
    private:
    	bool openPipe();
    
    private:
    	HANDLE  m_pHandle;
    };
    
    inline HiNamePipeClient *pipeClient()
    {
    	return HiNamePipeClient::getInstance();
    }
    #include "HiNamePipeClient.h"
    #include "guard.h"
    
    enum PipeWriteType
    {
    	PipeWriteType_ClientExit = 0,							// 客户端正常退出
    	PipeWriteType_ClinetRestart,							// 客户端重启
    };
    
    HiNamePipeClient* HiNamePipeClient::getInstance()
    {
    	static HiNamePipeClient instance;
    	return &instance;
    }
    
    void HiNamePipeClient::writeFile(PipeWriteType type, const QString & param)
    {
    #if HIRENDER_C_SERIES
    	if (openPipe())
    	{
    		DWORD dwWriteLen = 0;
    		QString strParam = QString("%1#%2").arg((int)type).arg(param);
    		if (WriteFile(m_pHandle, strParam.toStdString().c_str(), strParam.length(), &dwWriteLen, NULL))
    		{
    			// 写入成功
    		}
    		CloseHandle(m_pHandle);
    		m_pHandle = nullptr;	
    	}
    	Sleep(200);
    #endif
    }
    
    HiNamePipeClient::HiNamePipeClient()
    	: m_pHandle(nullptr)
    {
    
    }
    
    HiNamePipeClient::~HiNamePipeClient()
    {
    
    }
    
    bool HiNamePipeClient::openPipe()
    {
    	if (m_pHandle)
    	{
    		CloseHandle(m_pHandle);
    	}
    	if (!WaitNamedPipe(PIPE_NAME, PIPE_TIMEOUT))
    	{
    		// 当前没有可利用的命名管道实例!
    		return false;
    	}
    
    	m_pHandle = CreateFile(PIPE_NAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    	if (INVALID_HANDLE_VALUE == m_pHandle)
    	{
    		// "打开命名管道失败!
    		m_pHandle = NULL;
    		return false;
    	}
    	return true;
    }
    

    六、强制关闭守护进程(提供方法、博主程序中未使用)

    
    bool KillProcess(QString ProcessName)
    {
    	QProcess p;
    	QString c = "taskkill /im " + ProcessName + " /f";    //exeFileName为要杀死的进程名
    	p.execute(c);
    	p.close();
    	return true;
    }

     

    展开全文
  • 本节例子教程讲述的是在64位 win7系统进行驱动隐藏进程, 毕竟现在网络上能在64位win7系统里进行驱动隐藏进程的非常少 所以独立团有必要在驱动模块里加入强大的64位系统驱动隐藏进程功能 隐藏后的效果如下: ...

    前面我学习过 32位系统里进行驱动隐藏进程,http://bbs.dult.cn/thread-10701-1-1.html
    来防止破解或被游戏检测到辅助
    本节例子教程讲述的是在64位 win7系统进行驱动隐藏进程,
    毕竟现在网络上能在64位win7系统里进行驱动隐藏进程的非常少
    所以独立团有必要在驱动模块里加入强大的64位系统驱动隐藏进程功能
    隐藏后的效果如下:
    X64位驱动保护
    可以看见64位win7系统里的任务管理器里已经找不到我们的程序(驱动保护例子.exe)进程名了
    成功的隐藏了,驱动隐藏了后,就连OD和CE都无法找到我们的程序进程名,也就无法附加我们辅助程序的进程了,
    无法进行破坏我们程序了!
    源码下载:http://bbs.dult.cn/forum.php?mod=viewthread&tid=11723

    展开全文
  • 介绍了注册表,文件,进程,DLL/SYS,窗口的隐藏方法
  • 软件功能: 1.隐藏进程,系统任务管理器及一些其他任务管理器无法查到 2.恢复隐藏的进程,可恢复被隐藏的进程 3....本人只测试了Windows7/32位,可隐藏/保护进程,隐藏进程貌似只对任务管理器有效..(不过也不一定,大家可以
  • hook_进程隐藏

    2012-07-16 09:13:08
    windowsxp/7 进程隐藏 驱动 Hook ZwQuerySystemInformation 来实现进程隐藏的一种比较古老的技术,希望对初学者有用。
  • win7进程隐藏工具

    热门讨论 2011-12-24 00:12:16
    win7进程隐藏工具 win7进程隐藏工具
  • 使用与xp, win7等各种windows平台,而且不用注入API方式,免除杀毒软件误判之忧. 方法非常简单,就是使用最普通的往进程的窗口发送消息的办法.
  • 隐藏进程之内核版

    千次阅读 2019-04-09 21:48:33
    隐藏进程之内核版实现 隐藏进程通常出现在恶意程序中,隐藏的进程能让任务管理器、procexp等3环的程序无法找到它,那么如何实现隐藏进程呢? 由于对这方面还是很感兴趣,今天就来研究一下内核层的隐藏进程,首先在...

    隐藏进程之内核版实现

    隐藏进程通常出现在恶意程序中,隐藏的进程能让任务管理器、procexp等3环的程序无法找到它,那么如何实现隐藏进程呢?

    由于对这方面还是很感兴趣,今天就来研究一下内核层的隐藏进程,首先在用户层3环,如任务管理器、procexp遍历进程都是使用CreateToolhelp32Snapshot()API创建快照遍历查找的,使用快照的API在内核中就是通过访问一个双向链表的数据结构来得到每一个进程的信息的,那么我们只要把需要隐藏的进程信息从这个链表中干掉,就能完成隐藏的目的。

    每个进程在内核中都有一个内核对象,内核对象的信息被保存在一个名为_EPROCESS的结构体中,首先进行双机调试,在这我调试的是WIN7虚拟机,在windbg调试器中输入dt _eprocess指令即可查看_EPROCESS结构体
    在这里插入图片描述

    在这里要注意的是偏移0xb8的一个字段:
    +0x0b8 ActiveProcessLinks : _LIST_ENTRY
    这个字段记录的就是当前系统上的活动进程链表, 通过遍历这条链表就能得到当前系统上的所有进程。
    在隐藏进程时还需要关注的一个字段是在偏移为0x16c处的一个字段:
    +0x16c ImageFileName : [15] UChar
    这个字段记录的当前进程的名称字符串的地址。
    当然上面这两个的字段的偏移并不是固定的,在不同版本的系统中偏移有可能不同,所以使用时要查看该系统的字段偏移。

    _LIST_ENTRY是一个双向链表,分别指向下一节点和上一节点
    在这里插入图片描述

    系统通过这个链表把每个进程都链接在了一起,假设现在系统中只有3个进程,那么链接关系大体如下图
    在这里插入图片描述

    那么从上图中可以看出只要操作_LIST_ENTRY这个双向链表,我们就可以遍历系统上的全部进程。在隐藏进程中,我们只要通过链表操作,对比进程名称,找到我们想隐藏的程序,把它从这个链表中删除。
    在这通过一个宏:
    PsGetCurrentProcess()
    作用是可获取当前进程的内核对象,可得到当前第一个节点。主要代码如下

            //进程名称
    		char* ProcName = NULL;
    		ProcName = (char*)pInputBuff;		
    		//获取当前进程对象
    		PEPROCESS NowProc = PsGetCurrentProcess();
    		//获取进程对象内的当前活动进程链表
    		LIST_ENTRY* pNowList = (LIST_ENTRY*)((ULONG)NowProc + 0xb8);
    		//临时链表
    		LIST_ENTRY* pTempList = pNowList;
    		//遍历链表
    		while (pNowList != pTempList->Flink)
    		{
    			//相对进程对象偏移0x16c保存的是ImageFileName,
    			//当前相对进程对象偏移是0xb8,需要减去
    			//对比是否为目标进程			
    			if (!strcmp(ProcName, (char*)
    				((ULONG)pTempList - 0xb8 + 0x16c)))
    			{
    				//把找到的进程从链表中删除
    				(pTempList->Blink)->Flink = pTempList->Flink;
    				(pTempList->Flink)->Blink = pTempList->Blink;
    				
    				pTempList->Flink = pTempList->Blink = NULL;
    				KdPrint(("成功删除程序链表节点\n"));
    
    				break;
    			}
    			pTempList = pTempList->Flink;
    		}
    

    亲测有效,我隐藏的是记事本notepad.exe,在任务管理器中确实找不到这个进程,在procexp也没有,见图
    在这里插入图片描述
    使用内核级工具PCHunter查看进程
    在这里插入图片描述
    上图PCHunter中notepad.exe确实存在,还把该程序标称红色,说明是危险程序,因为PCHunter检测出他是隐藏的程序所以标红,这也说明PCHunter功能非常强大!
    到此内核版隐藏进程就成功了,但它并不就是无敌了,PCHunter能找到隐藏的进程的因为它遍历进程方法与任务管理器的方式不同,它是通过内核级API进行暴力枚举,通过PsLookupProcessByProcessId这个API,其原理是输入一个PID返回该进程的EPROCESS结构的引用指针,那么for循环假设给定PID是遍历0~10万,那么PID只要在这个范围的的进程就无所遁形都会被找出来,这就是传说中的暴力枚举进程!

    具体源码:

    内核层:

    #include <ntifs.h>
    #define IOCTL_BASE 0x800
    #define MY_CTL_CODE(code)       \
    		CTL_CODE( \
    		FILE_DEVICE_UNKNOWN, \
    		IOCTL_BASE+(code), \
    		METHOD_OUT_DIRECT, \
    		0 \
    		)
    #define DF_GET_PROC_HIDE MY_CTL_CODE(7)
    
    //卸载驱动
    void UnLoad(DRIVER_OBJECT* obj)
    {
    	KdPrint(("驱动已卸载\n"));
    	UNICODE_STRING userName;
    	RtlInitUnicodeString(&userName,
    		L"\\DosDevices\\MyFristDriver_User");
    	//删除符号链接
    	IoDeleteSymbolicLink(&userName);
    	//删除设备对象
    	IoDeleteDevice(obj->DeviceObject);
    }
    
    NTSTATUS InCreate(DEVICE_OBJECT *Device, IRP *irp);
    NTSTATUS InClose(DEVICE_OBJECT *Device, IRP *irp);
    NTSTATUS DeviceCtrl(DEVICE_OBJECT* device, IRP* irp);
    
    //驱动入口
    NTSTATUS DriverEntry(DRIVER_OBJECT* driver, UNICODE_STRING* path)
    {
    	path;
    	KdPrint(("驱动已加载\n"));
    	DbgBreakPoint();
    	
    	//1.创建一个设备对象
    	DEVICE_OBJECT* DeviceObj = NULL;
    	UNICODE_STRING deviceName;
    	RtlInitUnicodeString(&deviceName,
    		L"\\Device\\MyFristDriver");
    	NTSTATUS status = IoCreateDevice(
    		driver,
    		0,
    		&deviceName,
    		FILE_DEVICE_UNKNOWN,
    		0, 0,
    		&DeviceObj);
    	if (status != STATUS_SUCCESS)
    		return status;
    	driver->Flags |= DO_DIRECT_IO;//直接IO
    
    	//2.绑定一个符号链接
    	UNICODE_STRING userName;
    	RtlInitUnicodeString(&userName,
    		L"\\DosDevices\\MyFristDriver_User");
    	IoCreateSymbolicLink(&userName, &deviceName);
    
    
    	//调用派遣函数
    	driver->MajorFunction[IRP_MJ_CREATE] = InCreate;
    	driver->MajorFunction[IRP_MJ_CLOSE] = InClose;
    	driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DeviceCtrl;
    
    	driver->DriverUnload = UnLoad;
    	return STATUS_SUCCESS;
    }
    
    NTSTATUS InCreate(DEVICE_OBJECT *Device, IRP *irp)
    {
    	Device;
    	KdPrint(("调用了创建派遣函数\n"));
    	irp->IoStatus.Status = STATUS_SUCCESS;
    	irp->IoStatus.Information = 0;
    	IoCompleteRequest(irp, IO_NO_INCREMENT);
    	return STATUS_SUCCESS;
    }
    NTSTATUS InClose(DEVICE_OBJECT *Device, IRP *irp)
    {
    	Device;
    	KdPrint(("调用了关闭派遣函数\n"));
    	irp->IoStatus.Status = STATUS_SUCCESS;
    	irp->IoStatus.Information = 0;
    	IoCompleteRequest(irp, IO_NO_INCREMENT);
    	return STATUS_SUCCESS;
    }
    
    
    
    //通过控制码方式通讯
    NTSTATUS DeviceCtrl(DEVICE_OBJECT* device, IRP* irp)
    {
    	KdPrint(("已进入控制码通讯\n"));	
    	device;
    	NTSTATUS status = STATUS_SUCCESS;
    	ULONG complateSize = 0;
    	HANDLE hFile = NULL;
    	irp->IoStatus.Status = STATUS_SUCCESS;
    
    	//1.获取IO栈位置
    	IO_STACK_LOCATION* pIoStack = 
    		IoGetCurrentIrpStackLocation(irp);
    
    	//2.获取传入的参数
    	//2.1 IO设备控制码
    	ULONG ctrlCode = 
    		pIoStack->Parameters.DeviceIoControl.IoControlCode;
    
    	//2.2 输入缓冲区的字节数
    	ULONG inputSize = pIoStack->
    			Parameters.DeviceIoControl.InputBufferLength;
    
    	//2.3获取输入缓冲区
    	PVOID pInputBuff = irp->AssociatedIrp.SystemBuffer;
    
    	//选择控制码
        switch (ctrlCode)
    	{
    	//HideProcess
    	case DF_GET_PROC_HIDE:
    	{		
    		//进程名称
    		char* ProcName = NULL;
    		ProcName = (char*)pInputBuff;		
    		//获取当前进程对象
    		PEPROCESS NowProc = PsGetCurrentProcess();
    		//获取进程对象内的当前活动进程链表
    		LIST_ENTRY* pNowList = (LIST_ENTRY*)((ULONG)NowProc + 0xb8);
    		//临时链表
    		LIST_ENTRY* pTempList = pNowList;
    		//遍历链表
    		while (pNowList != pTempList->Flink)
    		{
    			//相对进程对象偏移0x16c保存的是ImageFileName,
    			//当前相对进程对象偏移是0xb8,需要减去			
    			if (!strcmp(ProcName, (char*)
    				((ULONG)pTempList - 0xb8 + 0x16c)))
    			{
    				//把找到的进程从链表中删除
    				(pTempList->Blink)->Flink = pTempList->Flink;
    				(pTempList->Flink)->Blink = pTempList->Blink;
    				
    				pTempList->Flink = pTempList->Blink = NULL;
    				KdPrint(("成功删除程序链表节点\n"));				
    				break;
    			}
    			pTempList = pTempList->Flink;
    		}
    	}
    	break;
    	
    	irp->IoStatus.Status = STATUS_SUCCESS;
    	irp->IoStatus.Information = inputSize;
    	IoCompleteRequest(irp, IO_NO_INCREMENT);
    	return status;
    	}
    	
    

    用户层:

    
    #include <windows.h>
    #define IOCTL_BASE 0x800
    #define MY_CTL_CODE(code)       \
    		CTL_CODE( \
    		FILE_DEVICE_UNKNOWN, \
    		IOCTL_BASE+(code), \
    		METHOD_OUT_DIRECT, \
    		0 \
    		)
    #define DF_GET_PROC_HIDE MY_CTL_CODE(7)
    
    	
    //隐藏进程
    void HideProc(HANDLE hSys, DWORD size)
    {
    	//要隐藏进程的字符
    	char pBuff[128] = { 0 };
    	int inputSize = strlen("notepad.exe") + 1;	
    	memcpy(pBuff, "notepad.exe", inputSize);
    	
    	//调用设备控制码函数
    	BOOL nRet = DeviceIoControl(
    		hSys,
    		DF_GET_PROC_HIDE,
    		(LPVOID)pBuff,
    		inputSize,
    		NULL,
    		0,
    		&size,
    		NULL);
    	if (!nRet)
    	{
    		printf("调用隐藏程序控制码失败%d\n", GetLastError());
    		return;
    	}
    	printf("隐藏程序成功!\n");
    }
    	
    	
    int main()
    {
    	//打开该驱动
    	HANDLE hSys = CreateFile(
    		L"\\??\\MyFristDriver_User",
    		GENERIC_ALL,
    		FILE_SHARE_READ,
    		NULL,
    		OPEN_EXISTING,
    		FILE_ATTRIBUTE_NORMAL,
    		NULL);
    	if (hSys==INVALID_HANDLE_VALUE)
    	{
    		printf("打开驱动失败 %d\n", GetLastError());
    		getchar();
    		return 0;
    	}
    	else printf("打开驱动成功\n");
    	DWORD size = 0;
    
    	//调用隐藏进程函数
    	HideProc(hSys, size);
    
    	getchar();
    	CloseHandle(hSys);
    }
    
    
    展开全文
  • 进程隐藏技术

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

    千次阅读 2021-10-24 11:03:03
    Win7桌面知识简介
  • 遇到win7系统电脑隐藏应用程序怎么办?下面是具体步骤:具体操作步骤:1.进入系统后,按下“Win + R”快捷键打开运行,然后输入“regedit”并按下回车键打开注册表;2.打开注册表编辑器后,在左侧展开到“HKEY_LOCAL...
  • 驱动层SSDT 隐藏进程

    千次阅读 2013-11-27 21:19:59
    闲着没事,便想在熟悉下之前看过的驱动编程相关知识,于是就写了这个简单的驱动曾隐藏进程程序。 要点: 在驱动层隐藏,主要还是使用SSDT挂钩的方法,相关知识,可以到网上查找,在隐藏进程时,为了能够隐藏多个...
  • 进程隐藏学习总结

    千次阅读 2016-05-08 15:11:54
    怎么隐藏进程 工具/原料 HideToolz 步骤/方法 1 在百度上面搜索HideToolz ,打开第一个搜索结果,点击进入下载。把HideToolz 下载到你的电脑里面。 2 鼠标双击打开该压缩包,再直接双击该软件即可打开该软件了。...
  • 理论题 —— Windows 7基础知识

    千次阅读 2021-04-12 22:18:42
    2.关于Windows7的“任务栏”,以下描述正确的是________。 答案:D A.显示系统的所有功能 B.只显示当前活动程序窗口名 C.只显示正在后台工作的程序窗口名 D.便于实现程序窗口之间的切换 3.以下不属于典型Windows
  • Windows守护进程简单示例

    千次阅读 2018-12-28 15:41:47
    @描述:一个简单的Windows守护进程的例子(C++版本) @作者:kikaylee @日期:2016-05-13 10:30 */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;Wind...
  • 其实这个东西windows7 应该是没有问题的 但是听说windows10 是不行的 除了要摘链 还是去搞掉一张表 这个比较麻烦 还有一点要注意的是 我们这里的进程 结构体 不一定是其它系统的结构体 因为windows 不同的版本 ...
  • 研究其他作者写的文章,也是hook ZwQuerySystemInformation 隐藏进程,可是我怎么测试都没有通过,不能隐藏进程,在网上也试了其他隐藏进程的代码,也不行。唉,那就只有自己动手啦~~~ 既然hook ...
  • Qt编写守护进程

    2019-03-02 14:56:06
    本篇文章提供一个软件实现守护进程的办法,原理就是udp通信,单独写个守护进程程序,专门负责检测主程序是否存在,不存在则启动。主程序只需要启动live类监听端口,收到hello就回复ok就行。 为了使得兼容任意程序,...
  • 打开windows7资源管理器(Windows Explorer),左侧是一个导航窗格,包括:收藏夹,库,家庭组,计算机,网络。这些项目链接到文件夹,硬盘或者其他电脑系统。 但是,不是每一个Windows 7用户都需要这些项目。...
  • 网上的都不能用啊…全是未完成...ListView_GetItemText宏只是对当前进程有效,对远程进程是无效的,但是label之类的控件gettext对远程进程是有效的,具体的可以看《Windows via C/C++》中文第5版第579面(只是记得有这
  • fx进程隐藏工具,可以隐藏任意进程的工具,经该工具隐藏进程,在windows任务管理器中是看不到的,支持winxp/win7(32位) 打开软件,输入要隐藏进程名称,一行一个,支持*和?字符,要以隐藏方式启动软件,需在软件...
  • 木马攻击获得Windows7的权限

    千次阅读 2022-04-03 13:09:49
    Windows常见攻击手段就不可以不讲它,因为它是Windows常见攻击手段里必不可少的一员。他就是木马攻击,首先先说一下他的概述:它是指隐藏在正常程序中的一段具有特殊功能的恶意代码,是具备破坏和删除文件、发送...
  • 内核层 inlinehook 隐藏进程

    千次阅读 2013-12-17 20:48:57
    上次是SSDT HOOK 方式 隐藏... 这次是InlineHook 方式隐藏进程,这里inline hook的原理就不做详细介绍了,网上相关资源较多,撸主主要参考看雪的某大牛的“详谈内核三步走Inline Hook实现”(http://bbs.pediy.com/s

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,595
精华内容 26,238
关键字:

windows7 如何隐藏进程