Windows核心编程_HOOk SOCKET实现封包拦截

最新推荐文章于 2024-04-22 15:24:17 发布
最新推荐文章于 2024-04-22 15:24:17 发布
阅读量7.2k 收藏 47
点赞数 5
分类专栏： # Windows_核心编程 文章标签： socket c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bjbz_cxy/article/details/107829998
版权

Socket的HOOK技术是目前网络拦截程序的基础功能，还有浏览器的抓包工具都是通过拦截Socket函数实现的

浏览器也好，通讯软件也好，他们只是使用的通讯协议不一样，其最底层的全部都是通过封装Socket里的TCP/UDP实现的

如最常用的就是Send函数与Recv函数，一个是发送一个是接收，所以我们只需要通过Hook住Send和Recv函数就可以实现抓包功能

https://blog.csdn.net/bjbz_cxy/article/details/90574824 之前写的这篇文章里很详细的介绍了APIHOOK的原理以及实践，如果你对APIHOOK的理论知识不是很理解，那么建议你看完我写的这篇文章在学习本篇文章。

这里我先创建了一个基本的控制台程序：

#include <stdio.h>

int main(int argc, char* argv[])
{
    return 0;
}

在封装一个APIHOOK的类

这篇代码是通过我之前写的：https://blog.csdn.net/bjbz_cxy/article/details/90637158 这篇文章里的代码修改而来，去掉了汇编部分，用更简单的方法实现了

对上一篇文章里的代码进行了重构

class MyHookClass {
public:
 MyHookClass()
    {
       
    }
    ~MyHookClass()
    {
       
    }
    
}

准备工作，申请中间变量，用于保存一些函数信息，以供hook完后的复原操作，声明为保护，防止被开发人员手动修改

private:
    PROC m_pfnOld;//原API函数地址
    BYTE m_bOldBytes[5];//原api前5个字节的跳转地址
    BYTE m_bNewBytes[5];//新的跳转地址

第一步为APIHOOK类编写一个Hook函数

 BOOL Hook(char* szModuleName/*模块名*/, char* szFuncName/*函数名*/, PROC pHookFunc/*新的函数地址*/){

}

参数作用：

char* szModuleName HOOk的API属于哪个DLL模块里

char* szFuncName HOOK的APImingzi

PROC pHookFunc 新的函数地址

//第一步获取DLL句柄，Windows下操作任何设备以及应用模块都以句柄为钥匙，同时Windows内核也会记录每一次句柄操作的次数

 BOOL Hook(char* szModuleName/*模块名*/, char* szFuncName/*函数名*/, PROC pHookFunc/*新的函数地址*/)
    {
          m_pfnOld = GetProcAddress(GetModuleHandleA(szModuleName), szFuncName);
            if (!m_pfnOld)
            {
                return FALSE;
            }
    }

//第二步保存原API地址

DWORD dwNum = 0;
ReadProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);

//第三步取当前函数的地址 这一步将之前的APIHOOK里的汇编代码修改掉了，所以这里我需要说一下

  m_bNewBytes[0] = '\xe9';

 *(DWORD*)(m_bNewBytes + 1) = (DWORD)pHookFunc - (DWORD)m_pfnOld - 5;

之前的方式是这样的：

实际地址=我们的api地址-拦截的api地址-要写入的数据长度

//地址转换
			ULONG Api_MoPtr = JumpApiPtr - (ULONG)&Api;
			Api_MoPtr = Api_MoPtr - 5;
			//将地址写入到操作码的后四位
			char My_FuncPtr[5] = { 0 };

_asm
			{
				mov eax, Api_MoPtr			//获取刚刚获得的地址
				mov dword ptr[My_FuncPtr + 1], eax //将算出的地址保存到Arr后面4个字节
											  //注：一个函数地址占4个字节
			}

后来我发现其实这样写更直观和简单一点

  m_bNewBytes[0] = '\xe9';

 *(DWORD*)(m_bNewBytes + 1) = (DWORD)pHookFunc - (DWORD)m_pfnOld - 5;

最后一步写入到cll的地址下就可以啦

 WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);

完整的HOOK函数代码：

 BOOL Hook(char* szModuleName/*模块名*/, char* szFuncName/*函数名*/, PROC pHookFunc/*新的函数地址*/)
    {

      
      
            m_pfnOld = GetProcAddress(GetModuleHandleA(szModuleName), szFuncName);
            if (!m_pfnOld)
            {
                return FALSE;
            }


            DWORD dwNum = 0;
            ReadProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);

            m_bNewBytes[0] = '\xe9';

            *(DWORD*)(m_bNewBytes + 1) = (DWORD)pHookFunc - (DWORD)m_pfnOld - 5;

            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);
          

            return TRUE;
    }

除此之外，我们还要写一个复原和复位的函数，用于还原API和重新HOOK的功能

//复原
    void UnHook()
    {
        if (m_pfnOld != nullptr)
        {
            DWORD dwNum = 0;
            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);
        }
    }
    //重置
    bool ReHook()
    {
        if (m_pfnOld != nullptr)
        {
            DWORD dwNum = 0;

            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);
            return FALSE;
        }
        return TRUE;
    }

这两个函数用在调用里，因为比如是recv函数，如果直接修改跳转到我们的函数里了，那么我们是取不到任何数据的，所以我们需要在函数里调用UnHook函数把函数复原，然后在里面调用一次原生态的Recv获取到数据之后，在使用Rehook将其重置到我们的函数里。

完整代码：

class MyHookClass {
public:
    MyHookClass()
    {
        m_pfnOld = nullptr;
        ZeroMemory(m_bNewBytes, 5);
        ZeroMemory(m_bOldBytes, 5);
    }
    ~MyHookClass()
    {
        UnHook();
    }
  
    BOOL Hook(char* szModuleName/*模块名*/, char* szFuncName/*函数名*/, PROC pHookFunc/*新的函数地址*/)
    {

      
      
            m_pfnOld = GetProcAddress(GetModuleHandleA(szModuleName), szFuncName);
            if (!m_pfnOld)
            {
                return FALSE;
            }


            DWORD dwNum = 0;
            ReadProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);

            m_bNewBytes[0] = '\xe9';

            *(DWORD*)(m_bNewBytes + 1) = (DWORD)pHookFunc - (DWORD)m_pfnOld - 5;

            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);
          

            return TRUE;
    }
    //复原
    void UnHook()
    {
        if (m_pfnOld != nullptr)
        {
            DWORD dwNum = 0;
            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);
        }
    }
    //重置
    bool ReHook()
    {
        if (m_pfnOld != nullptr)
        {
            DWORD dwNum = 0;

            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);
            return FALSE;
        }
        return TRUE;
    }
private:
    PROC m_pfnOld;//原API函数地址
    BYTE m_bOldBytes[5];//原api前5个字节的跳转地址
    BYTE m_bNewBytes[5];//新的跳转地址
};

上面介绍的这个方法是最常用的方法，还有其它很多方法，如PE方式的HOOk

这个方法难度不是很大，技术点就在于APIHOOK的原理还有逻辑地址转换https://blog.csdn.net/bjbz_cxy/article/details/90574824 我在这篇文章中有很详细的介绍API HOOK

如果你想拦截其它程序的封包数据需要使用DLL注入的方式，注入到目标进程下就可以了，原因是因为内存保护，用户态下不能随便越过自己的内存区的。

实战：

这个是Recv函数的原型

int recv(_In_ SOCKET s, _Out_ char* buf, _In_ int len, _In_ int flags) ;

根据原型写一个我们自己的函数：

int recv1(_In_ SOCKET s, _Out_ char* buf, _In_ int len, _In_ int flags)

我们在写一个客户端/服务器程序

#include <winsock2.h>  
#include <WS2tcpip.h>
#include<stdio.h>
#include<iostream>
#include<cstring>
#include <Windows.h>

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

注意包含头文件的时候，Windows头文件要在Winsock2的下面，不然会出现很多类型错误的问题

其次是要注意一个问题，因为是DLL，如果我们在没调用任何Socket函数的情况下，ws2_32dll是不会载入到程序里的，所以如果我们在Socket之前调用了我们的APIHOOK是不会成功的，所以我们需要当目标程序在调用任何Socket函数后再去使用APIHOOK，因为动态库的特点就是需要时才会加载到内存

我直接把APIHOOK的代码放在一个程序下，也就是说HOOK当前程序下的Recv实现封包拦截功能，如果你想HOOK别人的程序可以参考我前面关于HOOK的文章，里面有详细的方法和代码

这个是客户端代码


int main(int argc, char* argv[])
{
    // hook windows api
    char szModuleName[MAXBYTE] = { 0 };//"user32.dll";
    char szFuncName[MAXBYTE] = { 0 };// "MessageBoxW";
    strcpy_s(szModuleName, MAXBYTE, "WS2_32.dll");
    strcpy_s(szFuncName, MAXBYTE, "recv");
    WORD sockVersion = MAKEWORD(2, 2);
    WSADATA data;
    if (WSAStartup(sockVersion, &data) != 0)
    {
        return 0;
    }
    sockaddr_in serAddr;
    serAddr.sin_family = AF_INET;
    serAddr.sin_port = htons(8888);
    inet_pton(AF_INET, "127.0.0.1", &serAddr.sin_addr);
    if (FALSE == g_MsgHook.Hook(szModuleName, szFuncName, (PROC)recv1)) {
        printf("error");
    }
    while (true)
    {
        SOCKET sclient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sclient == INVALID_SOCKET)
        {
            printf("invalid socket!");
            return 0;
        }
        if (connect(sclient, (sockaddr*)&serAddr, sizeof(serAddr)) == SOCKET_ERROR)
        {  //连接失败 
            printf("connect error !");
            closesocket(sclient);
            return 0;
        }
        send(sclient, "asd", strlen("asd"), 0);
        char recData[255] = {0};
        int ret = recv(sclient, recData, 12, 0);
        if (ret > 0) {
            recData[ret] = 0x00;
            printf(recData);
        }
        closesocket(sclient);
    }
    WSACleanup();

 
    return 0;
}

recv部分

这里我们复原后然后调用原生态的recv去读数据，这样既没有让原生态的recv失效，我们也能提前拿到数据，非常美哉

因为最开始用户态调用的recv是进入到recv1里了，然后我们在根据传递进来的socket参数(需要注意一点Sock通信中传递进来的数据会根据协议放在对应的缓冲区里，术语上叫做窗口，实际上只是一块内存缓冲区，如TCP窗口等等，如果不去调用recv函数读的话，我们是无法获取这块缓冲区的内容的，必须通过sock提供的接口,理论上来说recv读完缓冲区后会将缓冲区的内容清空)


MyHookClass g_MsgHook;

int recv1(_In_ SOCKET s, _Out_ char* buf, _In_ int len, _In_ int flags) {
    //重置recv函数
    g_MsgHook.UnHook();
    //用recv函数接收服务器消息
    recv(s, buf, 255, 0);
    //打印
    printf("hook:%s",buf);
    //重新挂钩
    g_MsgHook.ReHook();
    return 0;
 }

服务器：

// ConsoleApplication2.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <stdio.h>  
#include <winsock2.h>  

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

int main(int argc, char* argv[])
{
	//初始化WSA  
	WORD sockVersion = MAKEWORD(2, 2);
	WSADATA wsaData;
	if (WSAStartup(sockVersion, &wsaData) != 0)
	{
		return 0;
	}
	//创建套接字  
	SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (slisten == INVALID_SOCKET)
	{
		printf("socket error !");
		return 0;
	}
	//绑定IP和端口  
	sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(8888);
	sin.sin_addr.S_un.S_addr = INADDR_ANY;
	if (bind(slisten, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)
	{
		printf("bind error !");
	}
	//开始监听  
	if (listen(slisten, 5) == SOCKET_ERROR)
	{
		printf("listen error !");
		return 0;
	}
	//循环接收数据  
	SOCKET sClient;
	sockaddr_in remoteAddr;
	int nAddrlen = sizeof(remoteAddr);
	char revData[1024];
	while (true)
	{
		printf("等待连接...\n");
		sClient = accept(slisten, (SOCKADDR*)&remoteAddr, &nAddrlen);
		if (sClient == INVALID_SOCKET)
		{
			printf("accept error !");
			continue;
		}
		//接收数据  
		int ret = recv(sClient, revData, 255, 0);
		if (ret > 0)
		{
			revData[ret] = 0x00;
			printf(revData);
		}
		//发送数据  
		const char* sendData = "hello \n";
		send(sClient, sendData, strlen(sendData), 0);
	}
	closesocket(sClient);
	closesocket(slisten);
	WSACleanup();
	return 0;
}

先运行服务器程序，当有连接来的时候返回hello

看下我们的recv函数是否拦截成功：

成功HOOK到了

完整代码：

API HOOK：

class MyHookClass {
public:
    MyHookClass()
    {
        m_pfnOld = nullptr;
        ZeroMemory(m_bNewBytes, 5);
        ZeroMemory(m_bOldBytes, 5);
    }
    ~MyHookClass()
    {
        UnHook();
    }
  
    BOOL Hook(char* szModuleName/*模块名*/, char* szFuncName/*函数名*/, PROC pHookFunc/*新的函数地址*/)
    {

      
      
            m_pfnOld = GetProcAddress(GetModuleHandleA(szModuleName), szFuncName);
            if (!m_pfnOld)
            {
                return FALSE;
            }


            DWORD dwNum = 0;
            ReadProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);

            m_bNewBytes[0] = '\xe9';

            *(DWORD*)(m_bNewBytes + 1) = (DWORD)pHookFunc - (DWORD)m_pfnOld - 5;

            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);
          

            return TRUE;
    }
    //复原
    void UnHook()
    {
        if (m_pfnOld != nullptr)
        {
            DWORD dwNum = 0;
            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);
        }
    }
    //重置
    bool ReHook()
    {
        if (m_pfnOld != nullptr)
        {
            DWORD dwNum = 0;

            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);
            return FALSE;
        }
        return TRUE;
    }
private:
    PROC m_pfnOld;//原API函数地址
    BYTE m_bOldBytes[5];//原api前5个字节的跳转地址
    BYTE m_bNewBytes[5];//新的跳转地址
};

 

demo代码：

客户端：

// HookMessage.cpp: 定义控制台应用程序的入口点。
//



#include <stdio.h>



#include <winsock2.h>  
#include <WS2tcpip.h>
#include<stdio.h>
#include<iostream>
#include<cstring>

#include <Windows.h>
#pragma comment(lib,"ws2_32.lib") 
class MyHookClass {
public:
    MyHookClass()
    {
        m_pfnOld = nullptr;
        ZeroMemory(m_bNewBytes, 5);
        ZeroMemory(m_bOldBytes, 5);
    }
    ~MyHookClass()
    {
        UnHook();
    }
  
    BOOL Hook(char* szModuleName/*模块名*/, char* szFuncName/*函数名*/, PROC pHookFunc/*新的函数地址*/)
    {

      
      
            m_pfnOld = GetProcAddress(GetModuleHandleA(szModuleName), szFuncName);
            if (!m_pfnOld)
            {
                return FALSE;
            }


            DWORD dwNum = 0;
            ReadProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);

            m_bNewBytes[0] = '\xe9';

            *(DWORD*)(m_bNewBytes + 1) = (DWORD)pHookFunc - (DWORD)m_pfnOld - 5;

            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);
          

            return TRUE;
    }
    //复原
    void UnHook()
    {
        if (m_pfnOld != nullptr)
        {
            DWORD dwNum = 0;
            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bOldBytes, 5, &dwNum);
        }
    }
    //重置
    bool ReHook()
    {
        if (m_pfnOld != nullptr)
        {
            DWORD dwNum = 0;

            WriteProcessMemory(GetCurrentProcess(), m_pfnOld, m_bNewBytes, 5, &dwNum);
            return FALSE;
        }
        return TRUE;
    }
private:
    PROC m_pfnOld;//原API函数地址
    BYTE m_bOldBytes[5];//原api前5个字节的跳转地址
    BYTE m_bNewBytes[5];//新的跳转地址
};

MyHookClass g_MsgHook;

int recv1(_In_ SOCKET s, _Out_ char* buf, _In_ int len, _In_ int flags) {
    g_MsgHook.UnHook();
    recv(s, buf, 255, 0);
    printf("hook:%s",buf);
    g_MsgHook.ReHook();
    getchar();
    return 0;
 }
int main(int argc, char* argv[])
{
    // hook windows api
    char szModuleName[MAXBYTE] = { 0 };//"user32.dll";
    char szFuncName[MAXBYTE] = { 0 };// "MessageBoxW";
    strcpy_s(szModuleName, MAXBYTE, "WS2_32.dll");
    strcpy_s(szFuncName, MAXBYTE, "recv");
    WORD sockVersion = MAKEWORD(2, 2);
    WSADATA data;
    if (WSAStartup(sockVersion, &data) != 0)
    {
        return 0;
    }
    sockaddr_in serAddr;
    serAddr.sin_family = AF_INET;
    serAddr.sin_port = htons(8888);
    inet_pton(AF_INET, "127.0.0.1", &serAddr.sin_addr);
    if (FALSE == g_MsgHook.Hook(szModuleName, szFuncName, (PROC)recv1)) {
        printf("error");
    }
    while (true)
    {
        SOCKET sclient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sclient == INVALID_SOCKET)
        {
            printf("invalid socket!");
            return 0;
        }
        if (connect(sclient, (sockaddr*)&serAddr, sizeof(serAddr)) == SOCKET_ERROR)
        {  //连接失败 
            printf("connect error !");
            closesocket(sclient);
            return 0;
        }
        send(sclient, "asd", strlen("asd"), 0);
        char recData[255] = {0};
        int ret = recv(sclient, recData, 12, 0);
        if (ret > 0) {
            recData[ret] = 0x00;
            printf(recData);
        }
        closesocket(sclient);
    }
    WSACleanup();

 
    return 0;
}

服务器：

// ConsoleApplication2.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <stdio.h>  
#include <winsock2.h>  

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

int main(int argc, char* argv[])
{
	//初始化WSA  
	WORD sockVersion = MAKEWORD(2, 2);
	WSADATA wsaData;
	if (WSAStartup(sockVersion, &wsaData) != 0)
	{
		return 0;
	}
	//创建套接字  
	SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (slisten == INVALID_SOCKET)
	{
		printf("socket error !");
		return 0;
	}
	//绑定IP和端口  
	sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(8888);
	sin.sin_addr.S_un.S_addr = INADDR_ANY;
	if (bind(slisten, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)
	{
		printf("bind error !");
	}
	//开始监听  
	if (listen(slisten, 5) == SOCKET_ERROR)
	{
		printf("listen error !");
		return 0;
	}
	//循环接收数据  
	SOCKET sClient;
	sockaddr_in remoteAddr;
	int nAddrlen = sizeof(remoteAddr);
	char revData[1024];
	while (true)
	{
		printf("等待连接...\n");
		sClient = accept(slisten, (SOCKADDR*)&remoteAddr, &nAddrlen);
		if (sClient == INVALID_SOCKET)
		{
			printf("accept error !");
			continue;
		}
		//接收数据  
		int ret = recv(sClient, revData, 255, 0);
		if (ret > 0)
		{
			revData[ret] = 0x00;
			printf(revData);
		}
		//发送数据  
		const char* sendData = "hello \n";
		send(sClient, sendData, strlen(sendData), 0);
	}
	closesocket(sClient);
	closesocket(slisten);
	WSACleanup();
	return 0;
}

 

17岁boy想当攻城狮
关注
  • 5
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
封包拦截原代码+可运行程序
08-12
数据封包拦截原代码 带直接运行程序 c#.net原代码！
关于API HOOK拦截封包原理 .rar_api hook/_hook封包_封包 拦截_封包拦截_拦截封包
09-19
关于API HOOK拦截封包原理
天野学院X64Hook封包拦截发送工具
08-17
天野学院X64Hook封包拦截发送工具，可进行封包的拦截、发送、过滤等，针对X64游戏程序和安卓模拟器。无需代理软件、无需驱动。
SocketHook：套接字挂钩是基于EasyHook的注入器，可将流量重定向到本地服务器
02-06
套筒钩 该应用程序允许用户将任何调用重定向到任何进程的Windows API ，以便将其连接重定向到配置的本地端口。 开始吧 该挂钩原本是由REST API控制的，因此，任何类型的应用程序都可以“插入”该挂钩并发送注入指令。 制作了一个使用.NET Core 3.1和通用托管API的WPF应用程序，以展示该体系结构的潜力，您可以查看代码或。 可以使用常规CLI参数或使用应用程序工作目录上的json配置文件（或同时使用两者）来启动API。 这是json配置文件的两个示例： { " InjectToExe " : " C: \\ Users \\ User \\ Desktop \\
如何使用WINSOCK Api hook拦截修改socket数据包
令狐少侠
09-09 6578
在Windows网络数据通讯层，通过封包技术在客户端挡截游戏服务器发送来的游戏控制数 据包，分析数据包并修改数据包；同时还可以按照游戏数据包结构创建数据包，再模拟客户端发送给游戏服务器，这个过程其实就是一个封包的过程。 封包的技术是实现第二类游戏外挂的最核心的技术。封包技术涉及的知识很广泛，实现方法也很多，如挡截 WinSock 、挡截 API 函数、挡截消息、 VxD 驱动程序等。在此我们也不
使用Hook拦截socket函数解决虚拟局域网部分游戏联机找不到房间的问题——以文明6为例
PeaZomboss的博客
01-18 2842
许多游戏有局域网联机功能，为了能在互联网环境下实现联机，可以搭建虚拟局域网，但有时游戏中却找不到的房间，这通常是由于UDP广播没有被发送到虚拟局域网，本文以文明6这款游戏为例，使用Hook技术，拦截socket函数实现UDP广播的的转发，解决找不到房间的问题。
利用HOOK拦截封包原理(转载)
漠漠星的专栏
04-08 2769
利用HOOK拦截封包原理　　截获API是个很有用的东西，比如你想分析一下别人的程序是怎样工作的。这里我介绍一下一种我自己试验通过的方法。 　　首先，我们必须设法把自己的代码放到目标程序的进程空间里去。Windows Hook可以帮我们实现这一点。SetWindowsHookEx的声明如下： HHOOK SetWindowsHookEx( int idHook, // hook type HOOKP
截获 Windows socket API
12-07 1578
1前言本文主要介绍了如何实现替换Windows上的API函数，实现Windows API Hook（当然，对于socket的Hook只是其中的一种特例）。这种Hook API技术被广泛的采用在一些领域中，如屏幕取词，个人防火墙等。这种API Hook技术并不是很新，但是涉及的领域比较宽广，要想做好有一定的技术难度。本文是采集了不少达人的以前资料并结合自己的实验得出的心得体会，在这里进行总结发表
易语言编程-远程封包拦截与发送技术
热门推荐
hzw320的博客
10-16 1万+
我们前面学习了封包拦截的技术和发送技术,但都是用DLL的注入方式来进行拦截封包的 那么有没有一种可以不需要注入，就可以拦截到指定进程里的封包数据呢？ 答案是肯定的：有的 独立团论坛的Game-EC模块的最新版本就加入了远程封包功能，但是要正确使用模块里的命令稳定运行，需模块授权使用 这个功能可以实现不需要写DLL注入到进程， 就可以进行拦截和获取指定进程的封包数据和套接字信息 非常方便便捷，远程封...
SocketHook:用 C# 编写的 SocketHook
06-18
套接字挂钩 SocketHook 用 C# 编写，仅支持 Windows（32 位应用程序） 如何使用 运行 RegisterCOMObjects.bat（以管理员身份） 运行 HookAPI.exe 参数 p=<process> s=<bind> d=<forward> （bind_address 可以替换为 0.0.0.0，port 可以为空） 示例参数 HookAPI.exe p=program.exe s=0.0.0.0 d=127.0.0.1 HookAPI.exe p=program.exe s=192.168.0.1 d=192.168.0.2 HookAPI.exe p=program.exe s=192.168.0.1:8000 d=192.168.0.2 HookAPI.exe p=program.ex
APIHook.rar_APIHOOK_delphi 封包_封包_封包 delphi
09-22
攔截執行程序所發收的網路封包,可避免收到不必要的封包訊息
算法分析与设计：动态规划（数字三角形+导弹拦截问题）（C++可执行源码+完整算法分析）
06-12
题目 1：如下图所示的数字三角形。假设某个人从该三角形的顶部出发，在每一个结点处均可选择向左走或者向右走，一直走到底层。试设计一个算法，帮助该人从顶部走到底部，使其所走的所有数字之和最大。 题目 2：某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。输入导弹依次飞来的高度（雷达给出的高度数据是不大于 30000 的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
一个拦截socket 的hook
05-02
截取socket的hook源码.实现了截取所有windows的网络数据包。仅供学习参考
demo.rar_DEMO_hookapi 封包_防火墙_防火墙delphi
09-23
网络封包拦截HOOKAPI,可以用于防火墙。
【C】 初识C语言
努力学习C/C++
04-21 708
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
最新发布
我的博客
04-22 532
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
[C++]异常
m0_62327743的博客
04-19 378
[C++]异常
nf_register_net_hook和nf_register_hook的区别
05-05
`nf_register_net_hook` 和 `nf_register_hook` 都是Linux内核中用于注册netfilter钩子函数的函数，但是它们的作用范围不同。 `nf_register_net_hook` 用于注册网络命名空间中的netfilter钩子函数，而 `nf_register_hook` 用于注册全局的netfilter钩子函数。 在Linux内核中，一个系统可以包含多个网络命名空间，每个网络命名空间都有自己的netfilter钩子函数。因此，如果你需要在指定的网络命名空间中注册netfilter钩子函数，你应该使用 `nf_register_net_hook` 函数。 而如果你需要在全局范围内注册netfilter钩子函数，你可以使用 `nf_register_hook` 函数。但是需要注意的是，使用 `nf_register_hook` 函数注册的钩子函数会在所有网络命名空间中生效，因此可能会对系统的性能产生影响。 因此，如果你想要注册netfilter钩子函数，应该根据具体情况选择合适的函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

17岁boy想当攻城狮

感谢打赏

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

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

打赏作者

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

抵扣说明：

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

余额充值