乐于分享
好东西不私藏
当前位置：夜雨聆风 > 技术教程 > 软件教程 > 跨平台底层网络库libdnet源码分析系列(十三)

跨平台底层网络库libdnet源码分析系列(十三)

当前时间： 2026-03-30 13:16:46 更新时间： 2026-03-30 分类：软件教程 评论(0)

跨平台底层网络库libdnet源码分析系列(十三)

源码分析mettle后门工具学习 所使用的依赖库

Windows内核分支深度分析与限制分析

目录

  1. Windows平台架构概述
  2. 内核分支实现深度分析
  3. 网络接口管理模块
  4. IP与路由模块
  5. ARP模块
  6. 防火墙模块
  7. 以太网模块限制
  8. Windows平台限制详解
  9. 各平台实现对比
  10. 变通方案与最佳实践
  11. 附录：完整代码示例

Windows平台架构概述

1.1 平台选择机制

libdnet通过编译时条件编译选择特定平台的实现：

  1. // include/dnet/os.h
  2. #ifdef _WIN32
  3. #include<winsock2.h>
  4. #include<windows.h>
  5. typedefintptr_tdnet_socket_t;
  6. #else
  7. #include<sys/socket.h>
  8. #include<netinet/in.h>
  9. typedefintdnet_socket_t;
  10. #endif

1.2 Windows特定文件清单

模块
Windows实现文件
替代实现
网络接口
 intf-win32.c intf-bsd.c

, intf-linux.c
IP
 ip-win32.c ip.c

 (通用)
路由
 route-win32.c route-bsd.c

, route-linux.c
ARP
 arp-win32.c arp-bsd.c

, arp-linux.c
防火墙
 fw-pktfilter.c fw-ipfw.c

, fw-pf.c, fw-ipf.c, fw-ipchains.c
以太网
 eth-win32.c

 (存根)
 eth-bsd.c

, eth-linux.c, eth-dlpi.c

1.3 核心设计理念

  1. 零依赖设计：不依赖WinPcap/Npcap，使用原生Windows API
  2. 版本兼容性：通过动态加载支持Windows XP到Windows 11
  3. 权限要求：部分功能需要管理员权限（原始套接字、路由表修改）
  4. Unicode处理：正确处理宽字符（ wchar_t）与多字节字符的转换

内核分支实现深度分析

2.1 Windows内核网络架构

libdnet在Windows上的实现直接利用Windows内核提供的网络API，架构层次如下：

  1. ┌─────────────────────────────────────────┐
  2. │        libdnet用户态API                 │
  3. ├─────────────────────────────────────────┤
  4. │WindowsSockets2(Winsock2)│
  5. ├─────────────────────────────────────────┤
  6. │   IP Helper API (iphlpapi.dll)│
  7. │-GetAdaptersAddresses│
  8. │-GetIpForwardTable/2│
  9. │-GetIpNetTable│
  10. ├─────────────────────────────────────────┤
  11. │Windows网络驱动(ndis.sys)│
  12. ├─────────────────────────────────────────┤
  13. │网络接口卡驱动│
  14. └─────────────────────────────────────────┘

2.2 数据结构映射

2.2.1 网络接口结构

  1. // intf-win32.c
  2. struct intf_handle {
  3. struct ifcombo ifcombo[MIB_IF_TYPE_MAX];// 按类型分组的接口索引
  4.     IP_ADAPTER_ADDRESSES *iftable;// Windows接口表
  5. };
  7. struct ifcombo {
  8. struct{
  9.         DWORD ipv4;// IPv4接口索引
  10.         DWORD ipv6;// IPv6接口索引
  11. }*idx;
  12. int cnt;// 数量
  13. int max;// 容量
  14. };

关键设计点：

  • 将Windows的 IP_ADAPTER_ADDRESSES结构映射到libdnet的 intf_entry
  • 使用 ifcombo数组按接口类型（以太网、PPP、环回等）分组
  • 支持IPv4和IPv6双栈

2.2.2 路由表结构

  1. // route-win32.c
  2. struct route_handle {
  3.     HINSTANCE iphlpapi;// iphlpapi.dll模块句柄
  4.     MIB_IPFORWARDTABLE *ipftable;// IPv4路由表（XP/2003）
  5.     MIB_IPFORWARD_TABLE2 *ipftable2;// IPv4/IPv6路由表（Vista+）
  6. };

版本兼容策略：

  • 动态加载 GetIpForwardTable2（仅Vista+可用）
  • 保留旧版 GetIpForwardTable以支持XP/2003

网络接口管理模块

3.1 GetAdaptersAddresses深度解析

3.1.1 完整实现代码

  1. // intf-win32.c:220-268
  2. staticint
  3. _refresh_tables(intf_t*intf)
  4. {
  5.     IP_ADAPTER_ADDRESSES *p;
  6.     DWORD ret;
  7.     ULONG len;
  9.     p = NULL;
  10.     len =16384;// 初始大缓冲区，避免Windows 2003的bug
  12. do{
  13.         free(p);
  14.         p = malloc(len);
  15. if(p == NULL)
  16. return(-1);
  18.         ret =GetAdaptersAddresses(
  19.             AF_UNSPEC,// IPv4和IPv6
  20.             GAA_FLAG_INCLUDE_PREFIX |// 包含前缀信息
  21.             GAA_FLAG_SKIP_ANYCAST |
  22.             GAA_FLAG_SKIP_MULTICAST,
  23.             NULL,
  24.             p,
  25. &len
  26. );
  27. }while(ret == ERROR_BUFFER_OVERFLOW);
  29. if(ret != NO_ERROR){
  30.         free(p);
  31. return(-1);
  32. }
  33.     intf->iftable = p;
  35. // 映射Windows索引到libdnet索引
  36. for(p = intf->iftable; p != NULL; p = p->Next){
  37. int type;
  38.         type = _if_type_canonicalize(p->IfType);
  39. if(type < MIB_IF_TYPE_MAX)
  40.             _ifcombo_add(&intf->ifcombo[type], p->IfIndex, p->Ipv6IfIndex);
  41. else
  42. return(-1);
  43. }
  44. return(0);
  45. }

3.1.2 Windows 2003缓冲区Bug处理

问题描述： 在Windows 2003上， GetAdaptersAddresses的行为异常：

  • 首次调用缓冲区不足：返回 ERROR_BUFFER_OVERFLOW
  • 后续调用缓冲区不足：返回 ERROR_INVALID_PARAMETER

解决方案：

  1. // 首次调用使用大缓冲区（16KB）
  2. len =16384;
  3. do{
  4. // ...
  5. }while(ret == ERROR_BUFFER_OVERFLOW);

3.1.3 宽字符转换处理

  1. // intf-win32.c:40-48
  2. staticchar* strncpy_wchar(char*dst, PWCHAR src,size_t n)
  3. {
  4. size_t wlen = wcslen(src)+2;
  5. char*tmp = calloc(1, wlen);
  6. WideCharToMultiByte(CP_ACP,0, src,-1, tmp, wlen, NULL, NULL);
  7.     strncpy(dst, tmp, n);
  8.     free(tmp);
  9. return dst;
  10. }

调用示例：

  1. // 转换友好名称
  2. strncpy_wchar(friendly_name, a->FriendlyName, MAX_INTERFACE_NAME_LEN);
  4. // 转换驱动描述
  5. strncpy_wchar(entry->driver_name, a->Description,sizeof(entry->driver_name));

3.2 接口类型标准化

3.2.1 Windows MIB类型到libdnet类型的映射

  1. // intf-win32.c:50-72
  2. staticchar*
  3. _ifcombo_name(int type)
  4. {
  5. char*name ="eth";// 默认以太网
  7. if(type == IF_TYPE_ISO88025_TOKENRING){
  8.         name ="tr";
  9. }elseif(type == IF_TYPE_PPP){
  10.         name ="ppp";
  11. }elseif(type == IF_TYPE_SOFTWARE_LOOPBACK){
  12.         name ="lo";
  13. }elseif(type == IF_TYPE_TUNNEL){
  14.         name ="tun";
  15. }
  16. return(name);
  17. }

3.2.2 接口标志映射

  1. // intf-win32.c:164-172
  2. entry->intf_flags =0;
  3. if(a->OperStatus==IfOperStatusUp)
  4.     entry->intf_flags |= INTF_FLAG_UP;
  5. if(a->IfType== IF_TYPE_SOFTWARE_LOOPBACK)
  6.     entry->intf_flags |= INTF_FLAG_LOOPBACK;
  7. else
  8.     entry->intf_flags |= INTF_FLAG_MULTICAST;

3.3 前缀长度查找

Windows XP/Vista前缀信息存储方式不同：

  1. // intf-win32.c:196-202
  2. bits =0;
  3. for(prefix = a->FirstPrefix; prefix != NULL; prefix = prefix->Next){
  4. if(prefix->Address.lpSockaddr->sa_family == addr->Address.lpSockaddr->sa_family){
  5.         bits =(unsignedshort) prefix->PrefixLength;
  6. break;
  7. }
  8. }

Vista及以后：使用 OnLinkPrefixLength成员

IP与路由模块

4.1 IP模块：原始套接字实现

4.1.1 完整源码分析

  1. // ip-win32.c:24-49
  2. ip_t*
  3. ip_open(void)
  4. {
  5.     BOOL on;
  6. ip_t*ip;
  8. if((ip = calloc(1,sizeof(*ip)))!= NULL){
  9. // 初始化Winsock
  10. if(WSAStartup(MAKEWORD(2,2),&ip->wsdata)!=0){
  11.             free(ip);
  12. return(NULL);
  13. }
  15. // 创建原始套接字
  16. if((ip->fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW))==
  17.             INVALID_SOCKET)
  18. return(ip_close(ip));
  20. // 设置包含IP头选项
  21.         on = TRUE;
  22. if(setsockopt(ip->fd, IPPROTO_IP, IP_HDRINCL,
  23. (constchar*)&on,sizeof(on))== SOCKET_ERROR){
  24. SetLastError(ERROR_NETWORK_ACCESS_DENIED);
  25. return(ip_close(ip));
  26. }
  27.         ip->sin.sin_family = AF_INET;
  28.         ip->sin.sin_port = htons(666);
  29. }
  30. return(ip);
  31. }

4.1.2 IP头包含选项

  1. // 设置IP_HDRINCL允许应用构建完整IP头
  2. setsockopt(ip->fd, IPPROTO_IP, IP_HDRINCL,&on,sizeof(on));

作用：应用层提供完整IP头，系统不再自动添加

4.1.3 数据包发送

  1. // ip-win32.c:51-63
  2. ssize_t
  3. ip_send(ip_t*ip,constvoid*buf,size_t len)
  4. {
  5. struct ip_hdr *hdr =(struct ip_hdr *)buf;
  7.     ip->sin.sin_addr.s_addr = hdr->ip_src;
  9. if((len = sendto(ip->fd,(constchar*)buf, len,0,
  10. (struct sockaddr *)&ip->sin,sizeof(ip->sin)))!= SOCKET_ERROR)
  11. return(len);
  13. return(-1);
  14. }

4.2 路由模块：动态API加载

4.2.1 模块初始化

  1. // route-win32.c:36-47
  2. route_t*
  3. route_open(void)
  4. {
  5. route_t*r;
  7.     r = calloc(1,sizeof(route_t));
  8. if(r == NULL)
  9. return NULL;
  11. // 获取iphlpapi.dll模块句柄
  12.     r->iphlpapi =GetModuleHandle("iphlpapi.dll");
  14. return r;
  15. }

4.2.2 版本兼容的路由表遍历

  1. // route-win32.c:256-270
  2. int
  3. route_loop(route_t*r, route_handler callback,void*arg)
  4. {
  5.     GETIPFORWARDTABLE2 GetIpForwardTable2;
  7. // 动态加载GetIpForwardTable2（仅Vista+）
  8. GetIpForwardTable2= NULL;
  9. if(r->iphlpapi != NULL)
  10. GetIpForwardTable2=(GETIPFORWARDTABLE2)
  11. GetProcAddress(r->iphlpapi,"GetIpForwardTable2");
  13. if(GetIpForwardTable2== NULL)
  14. return route_loop_getipforwardtable(r, callback, arg);// XP/2003
  15. else
  16. return route_loop_getipforwardtable2(GetIpForwardTable2, r, callback, arg);// Vista+
  17. }

4.2.3 IPv4路由表读取（XP/2003）

  1. // route-win32.c:142-197
  2. staticint
  3. route_loop_getipforwardtable(route_t*r, route_handler callback,void*arg)
  4. {
  5. struct route_entry entry;
  6. intf_t*intf;
  7.     ULONG len;
  8. int i, ret;
  10. // 动态调整缓冲区大小
  11. for(len =sizeof(r->ipftable[0]);;){
  12. if(r->ipftable)
  13.             free(r->ipftable);
  14.         r->ipftable = malloc(len);
  15. if(r->ipftable == NULL)
  16. return(-1);
  17.         ret =GetIpForwardTable(r->ipftable,&len, FALSE);
  18. if(ret == NO_ERROR)
  19. break;
  20. elseif(ret != ERROR_INSUFFICIENT_BUFFER)
  21. return(-1);
  22. }
  24.     intf = intf_open();
  26.     ret =0;
  27. for(i =0; i <(int)r->ipftable->dwNumEntries; i++){
  28. // 填充路由条目
  29.         entry.route_dst.addr_type = ADDR_TYPE_IP;
  30.         entry.route_dst.addr_bits = IP_ADDR_BITS;
  31.         entry.route_gw.addr_type = ADDR_TYPE_IP;
  32.         entry.route_gw.addr_bits = IP_ADDR_BITS;
  34.         entry.route_dst.addr_ip = r->ipftable->table[i].dwForwardDest;
  35.         addr_mtob(&r->ipftable->table[i].dwForwardMask, IP_ADDR_LEN,
  36. &entry.route_dst.addr_bits);
  37.         entry.route_gw.addr_ip = r->ipftable->table[i].dwForwardNextHop;
  38.         entry.metric = r->ipftable->table[i].dwForwardMetric1;
  40. // 查找接口名称
  41.         entry.intf_name[0]='\0';
  42. if(intf_get_index(intf,&intf_entry,
  43.             AF_INET, r->ipftable->table[i].dwForwardIfIndex)==0){
  44.             strlcpy(entry.intf_name, intf_entry.intf_name,
  45. sizeof(entry.intf_name));
  46. }
  48. if((ret =(*callback)(&entry, arg))!=0)
  49. break;
  50. }
  52.     intf_close(intf);
  53. return ret;
  54. }

4.2.4 IPv4/IPv6路由表读取（Vista+）

  1. // route-win32.c:199-254
  2. staticint
  3. route_loop_getipforwardtable2(GETIPFORWARDTABLE2 GetIpForwardTable2,
  4. route_t*r, route_handler callback,void*arg)
  5. {
  6. struct route_entry entry;
  7. intf_t*intf;
  8.     ULONG i;
  9. int ret;
  11. // 获取IPv4和IPv6路由表
  12.     ret =GetIpForwardTable2(AF_UNSPEC,&r->ipftable2);
  13. if(ret != NO_ERROR)
  14. return(-1);
  16.     intf = intf_open();
  18.     ret =0;
  19. for(i =0; i < r->ipftable2->NumEntries; i++){
  20. struct intf_entry intf_entry;
  21.         MIB_IPFORWARD_ROW2 *row;
  22.         MIB_IPINTERFACE_ROW ifrow;
  23.         ULONG metric;
  25.         row =&r->ipftable2->Table[i];
  27. // 填充路由条目（支持IPv4和IPv6）
  28.         addr_ston((struct sockaddr *)&row->DestinationPrefix.Prefix,
  29. &entry.route_dst);
  30.         entry.route_dst.addr_bits = row->DestinationPrefix.PrefixLength;
  31.         addr_ston((struct sockaddr *)&row->NextHop,&entry.route_gw);
  33. // 查找接口名称
  34.         entry.intf_name[0]='\0';
  35. if(intf_get_index(intf,&intf_entry,
  36.             row->DestinationPrefix.Prefix.si_family,
  37.             row->InterfaceIndex)==0){
  38.             strlcpy(entry.intf_name, intf_entry.intf_name,
  39. sizeof(entry.intf_name));
  40. }
  42. // 计算度量值（接口度量 + 路由度量）
  43.         ifrow.Family= row->DestinationPrefix.Prefix.si_family;
  44.         ifrow.InterfaceLuid= row->InterfaceLuid;
  45.         ifrow.InterfaceIndex= row->InterfaceIndex;
  46. if(GetIpInterfaceEntry(&ifrow)!= NO_ERROR){
  47. return(-1);
  48. }
  49.         metric = ifrow.Metric+ row->Metric;
  50. if(metric < INT_MAX)
  51.             entry.metric = metric;
  52. else
  53.             entry.metric = INT_MAX;
  55. if((ret =(*callback)(&entry, arg))!=0)
  56. break;
  57. }
  59.     intf_close(intf);
  60. return ret;
  61. }

4.3 路由条目添加与删除

4.3.1 添加路由

  1. // route-win32.c:49-76
  2. int
  3. route_add(route_t*route,conststruct route_entry *entry)
  4. {
  5.     MIB_IPFORWARDROW ipfrow;
  6. struct addr net;
  8.     memset(&ipfrow,0,sizeof(ipfrow));
  10. // 查找最佳接口
  11. if(GetBestInterface(entry->route_gw.addr_ip,
  12. &ipfrow.dwForwardIfIndex)!= NO_ERROR)
  13. return(-1);
  15. // 计算网络地址
  16. if(addr_net(&entry->route_dst,&net)<0||
  17.         net.addr_type != ADDR_TYPE_IP)
  18. return(-1);
  20.     ipfrow.dwForwardDest = net.addr_ip;
  21.     addr_btom(entry->route_dst.addr_bits,
  22. &ipfrow.dwForwardMask, IP_ADDR_LEN);
  23.     ipfrow.dwForwardNextHop = entry->route_gw.addr_ip;
  24.     ipfrow.dwForwardType =4;// 下一条不是最终目的地
  25.     ipfrow.dwForwardProto =3;// MIB_PROTO_NETMGMT
  27. if(CreateIpForwardEntry(&ipfrow)!= NO_ERROR)
  28. return(-1);
  30. return(0);
  31. }

4.3.2 删除路由

  1. // route-win32.c:78-101
  2. int
  3. route_delete(route_t*route,conststruct route_entry *entry)
  4. {
  5.     MIB_IPFORWARDROW ipfrow;
  6.     DWORD mask;
  8. if(entry->route_dst.addr_type != ADDR_TYPE_IP ||
  9. GetBestRoute(entry->route_dst.addr_ip,
  10.         IP_ADDR_ANY,&ipfrow)!= NO_ERROR)
  11. return(-1);
  13.     addr_btom(entry->route_dst.addr_bits,&mask, IP_ADDR_LEN);
  15. // 验证路由条目匹配
  16. if(ipfrow.dwForwardDest != entry->route_dst.addr_ip ||
  17.         ipfrow.dwForwardMask != mask){
  18.         errno = ENXIO;
  19. SetLastError(ERROR_NO_DATA);
  20. return(-1);
  21. }
  22. if(DeleteIpForwardEntry(&ipfrow)!= NO_ERROR)
  23. return(-1);
  25. return(0);
  26. }

ARP模块

5.1 ARP表操作完整实现

  1. // arp-win32.c:96-132
  2. int
  3. arp_loop(arp_t*arp, arp_handler callback,void*arg)
  4. {
  5. struct arp_entry entry;
  6.     ULONG len;
  7. int i, ret;
  9. // 动态调整缓冲区大小
  10. for(len =sizeof(arp->iptable[0]);;){
  11. if(arp->iptable)
  12.             free(arp->iptable);
  13.         arp->iptable = malloc(len);
  14. if(arp->iptable == NULL)
  15. return(-1);
  16.         ret =GetIpNetTable(arp->iptable,&len, FALSE);
  17. if(ret == NO_ERROR)
  18. break;
  19. elseif(ret != ERROR_INSUFFICIENT_BUFFER)
  20. return(-1);
  21. }
  22.     entry.arp_pa.addr_type = ADDR_TYPE_IP;
  23.     entry.arp_pa.addr_bits = IP_ADDR_BITS;
  24.     entry.arp_ha.addr_type = ADDR_TYPE_ETH;
  25.     entry.arp_ha.addr_bits = ETH_ADDR_BITS;
  27. for(i =0; i <(int)arp->iptable->dwNumEntries; i++){
  28. // 跳过非以太网条目
  29. if(arp->iptable->table[i].dwPhysAddrLen != ETH_ADDR_LEN)
  30. continue;
  31.         entry.arp_pa.addr_ip = arp->iptable->table[i].dwAddr;
  32.         memcpy(&entry.arp_ha.addr_eth,
  33.             arp->iptable->table[i].bPhysAddr, ETH_ADDR_LEN);
  35. if((ret =(*callback)(&entry, arg))!=0)
  36. return(ret);
  37. }
  38. return(0);
  39. }

5.2 添加静态ARP条目

  1. // arp-win32.c:30-50
  2. int
  3. arp_add(arp_t*arp,conststruct arp_entry *entry)
  4. {
  5.     MIB_IPFORWARDROW ipfrow;
  6.     MIB_IPNETROW iprow;
  8. // 查找出接口
  9. if(GetBestRoute(entry->arp_pa.addr_ip,
  10.         IP_ADDR_ANY,&ipfrow)!= NO_ERROR)
  11. return(-1);
  13.     iprow.dwIndex = ipfrow.dwForwardIfIndex;
  14.     iprow.dwPhysAddrLen = ETH_ADDR_LEN;
  15.     memcpy(iprow.bPhysAddr,&entry->arp_ha.addr_eth, ETH_ADDR_LEN);
  16.     iprow.dwAddr = entry->arp_pa.addr_ip;
  17.     iprow.dwType =4;// 静态条目
  19. if(CreateIpNetEntry(&iprow)!= NO_ERROR)
  20. return(-1);
  22. return(0);
  23. }

5.3 删除ARP条目

  1. // arp-win32.c:52-71
  2. int
  3. arp_delete(arp_t*arp,conststruct arp_entry *entry)
  4. {
  5.     MIB_IPFORWARDROW ipfrow;
  6.     MIB_IPNETROW iprow;
  8. if(GetBestRoute(entry->arp_pa.addr_ip,
  9.         IP_ADDR_ANY,&ipfrow)!= NO_ERROR)
  10. return(-1);
  12.     memset(&iprow,0,sizeof(iprow));
  13.     iprow.dwIndex = ipfrow.dwForwardIfIndex;
  14.     iprow.dwAddr = entry->arp_pa.addr_ip;
  16. if(DeleteIpNetEntry(&iprow)!= NO_ERROR){
  17.         errno = ENXIO;
  18. return(-1);
  19. }
  20. return(0);
  21. }

防火墙模块

6.1 PktFilter驱动通信

Windows防火墙模块通过命名管道与第三方驱动通信：

  1. // fw-pktfilter.c:277-313
  2. staticchar*
  3. call_pipe(constchar*msg,int len)
  4. {
  5.     HANDLE *pipe;
  6.     DWORD i;
  7. char*reply, status;
  9. // 等待命名管道
  10. if(!WaitNamedPipe(PKTFILTER_PIPE, NMPWAIT_USE_DEFAULT_WAIT)||
  11. (pipe =CreateFile(PKTFILTER_PIPE, GENERIC_READ | GENERIC_WRITE,
  12. 0, NULL, OPEN_EXISTING,0, NULL))== INVALID_HANDLE_VALUE){
  13. return(NULL);
  14. }
  15.     reply = NULL;
  17. // 发送消息
  18. if(WriteFile(pipe, msg, len,&i, NULL)){
  19. // 读取响应
  20. if(ReadFile(pipe,&status,sizeof(status),&i, NULL)){
  21. if(status == FILTER_FAILURE){
  22. ReadFile(pipe,&status,sizeof(status),&i, NULL);
  23. }elseif(status == FILTER_MESSAGE){
  24. // 获取消息长度
  25. if(ReadFile(pipe,&len,4,&i, NULL)){
  26. // 获取消息
  27.                     reply = calloc(1, len +1);
  28. if(!ReadFile(pipe, reply, len,&i, NULL)){
  29.                         free(reply);
  30.                         reply = NULL;
  31. }
  32. }
  33. }elseif(status == FILTER_SUCCESS)
  34.                 reply = strdup("");/* XXX */
  35. }
  36. }
  37. CloseHandle(pipe);
  38. return(reply);
  39. }

6.2 防火墙规则格式化

  1. // fw-pktfilter.c:214-275
  2. staticint
  3. format_rule(conststruct fw_rule *rule,char*buf,int len)
  4. {
  5. char tmp[128];
  7.     strlcpy(buf,(rule->fw_op == FW_OP_ALLOW)?"pass ":"block ", len);
  8.     strlcat(buf,(rule->fw_dir == FW_DIR_IN)?"in ":"out ", len);
  9.     snprintf(tmp,sizeof(tmp),"on %s ", rule->fw_device);
  10.     strlcat(buf, tmp, len);
  11. if(rule->fw_proto !=0){
  12.         snprintf(tmp,sizeof(tmp),"proto %d ", rule->fw_proto);
  13.         strlcat(buf, tmp, len);
  14. }
  15. // 源地址
  16. if(rule->fw_src.addr_type != ADDR_TYPE_NONE){
  17.         snprintf(tmp,sizeof(tmp),"from %s ",
  18.             addr_ntoa(&rule->fw_src));
  19.         strlcat(buf, tmp, len);
  20. }else
  21.         strlcat(buf,"from any ", len);
  23. // 源端口（TCP/UDP）
  24. if(rule->fw_proto == IP_PROTO_TCP || rule->fw_proto == IP_PROTO_UDP){
  25. if(rule->fw_sport[0]== rule->fw_sport[1])
  26.             snprintf(tmp,sizeof(tmp),"port = %d ",
  27.                 rule->fw_sport[0]);
  28. else
  29.             snprintf(tmp,sizeof(tmp),"port %d >< %d ",
  30.                 rule->fw_sport[0]-1, rule->fw_sport[1]+1);
  31.         strlcat(buf, tmp, len);
  32. }
  33. // 目的地址
  34. if(rule->fw_dst.addr_type != ADDR_TYPE_NONE){
  35.         snprintf(tmp,sizeof(tmp),"to %s ",
  36.             addr_ntoa(&rule->fw_dst));
  37.         strlcat(buf, tmp, len);
  38. }else
  39.         strlcat(buf,"to any ", len);
  41. // 目的端口（TCP/UDP）或ICMP类型/代码
  42. if(rule->fw_proto == IP_PROTO_TCP || rule->fw_proto == IP_PROTO_UDP){
  43. if(rule->fw_dport[0]== rule->fw_dport[1])
  44.             snprintf(tmp,sizeof(tmp),"port = %d",
  45.                 rule->fw_dport[0]);
  46. else
  47.             snprintf(tmp,sizeof(tmp),"port %d >< %d",
  48.                 rule->fw_dport[0]-1, rule->fw_dport[1]+1);
  49.         strlcat(buf, tmp, len);
  50. }elseif(rule->fw_proto == IP_PROTO_ICMP){
  51. if(rule->fw_sport[1]){
  52.             snprintf(tmp,sizeof(tmp),"icmp-type %d",
  53.                 rule->fw_sport[0]);
  54.             strlcat(buf, tmp, len);
  55. if(rule->fw_dport[1]){
  56.                 snprintf(tmp,sizeof(tmp)," code %d",
  57.                     rule->fw_dport[0]);
  58.                 strlcat(buf, tmp, len);
  59. }
  60. }
  61. }
  62. return(strlen(buf));
  63. }

以太网模块限制

7.1 Windows以太网存根实现

  1. // eth-win32.c:20-51
  2. eth_t*
  3. eth_open(constchar*device)
  4. {
  5. return(NULL);// Windows原生不支持
  6. }
  8. ssize_t
  9. eth_send(eth_t*eth,constvoid*buf,size_t len)
  10. {
  11. return(-1);
  12. }
  14. eth_t*
  15. eth_close(eth_t*eth)
  16. {
  17. return(NULL);
  18. }
  20. int
  21. eth_get(eth_t*eth,eth_addr_t*ea)
  22. {
  23. return(-1);
  24. }
  26. int
  27. eth_set(eth_t*eth,consteth_addr_t*ea)
  28. {
  29. return(-1);
  30. }

原因：Windows内核不提供直接访问以太网层的API

7.2 变通方案

方案1：使用WinPcap/Npcap

  1. // 需要安装WinPcap或Npcap
  2. #include<pcap.h>
  4. eth_t*eth_open_winpcap(constchar*device){
  5. char errbuf[PCAP_ERRBUF_SIZE];
  6. pcap_t*pcap = pcap_open_live(device,65535,1,1000, errbuf);
  7. return(eth_t*)pcap;
  8. }

方案2：原始套接字（有限功能）

  1. // 只能发送IP层及以上的数据包
  2. SOCKET sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
  3. setsockopt(sock, IPPROTO_IP, IP_HDRINCL,&on,sizeof(on));

Windows平台限制详解

8.1 权限限制

8.1.1 原始套接字限制

Windows版本
原始套接字支持
要求
Windows XP
完整支持
管理员权限
Windows Vista/7
有限支持
管理员权限，某些功能受限
Windows 8/10/11
严格限制
仅允许发送，禁止接收

代码示例：

  1. // ip-win32.c:40-43
  2. if(setsockopt(ip->fd, IPPROTO_IP, IP_HDRINCL,
  3. (constchar*)&on,sizeof(on))== SOCKET_ERROR){
  4. SetLastError(ERROR_NETWORK_ACCESS_DENIED);// 权限不足
  5. return(ip_close(ip));
  6. }

8.1.2 防火墙限制

Windows防火墙默认阻止原始套接字操作，需要：

  1. 以管理员身份运行
  2. 配置防火墙规则
  3. 部分操作需要完全禁用防火墙（不推荐）

8.2 功能限制

8.2.1 缺失功能对比

功能
Linux
BSD/macOS
Windows
说明
以太网帧发送
✅
✅
❌
需要WinPcap/Npcap
以太网帧接收
✅
✅
❌
需要WinPcap/Npcap
原始IP发送
✅
✅
✅
需要管理员权限
原始IP接收
✅
✅
⚠️
Windows 8+受限
路由表读取
✅
✅
✅
使用IP Helper API
路由表修改
✅
✅
✅
需要管理员权限
ARP表读取
✅
✅
✅
使用IP Helper API
ARP缓存操作
✅
✅
✅
需要管理员权限
防火墙规则
✅
✅
⚠️
需要第三方驱动
接口枚举
✅
✅
✅
使用IP Helper API

8.2.2 IPv6支持差异

  • Linux/BSD：原生支持IPv6的所有功能
  • Windows：仅部分API支持IPv6（如 GetIpForwardTable2）

8.3 性能限制

8.3.1 API调用开销

Windows IP Helper API通过系统调用访问内核数据，比Linux的直接 /proc文件访问更慢。

性能对比：

  1. Linux(读取/proc/net/route):~100μs
  2. Windows(GetIpForwardTable):~500μs -1ms

8.3.2 内存分配模式

  1. // Windows：每次调用需要重新分配缓冲区
  2. for(len =sizeof(table[0]);;){
  3.     free(table);
  4.     table = malloc(len);
  5.     ret =GetIpForwardTable(table,&len, FALSE);
  6. if(ret == NO_ERROR)break;
  7. }
  9. // Linux：可以直接读取固定大小的文件
  10. FILE*fp = fopen("/proc/net/route","r");
  11. while(fgets(line,sizeof(line), fp)){
  12. // 解析行
  13. }

8.4 安全限制

8.4.1 UAC (用户账户控制)

  • 提示用户提升权限时可能被拒绝
  • 某些环境下完全禁用UAC以使用libdnet

8.4.2 反病毒软件

原始套接字操作可能被标记为可疑行为：

  • 关闭实时扫描
  • 添加白名单

8.4.3 企业策略

企业环境可能：

  • 禁用原始套接字
  • 强制启用防火墙
  • 禁止未签名驱动

各平台实现对比

9.1 网络接口管理对比

特性
Linux (intf-linux.c)
BSD (intf-bsd.c)
Windows (intf-win32.c)
数据源
/proc/net/if, ioctl
sysctl, ioctl
GetAdaptersAddresses
IPv4/IPv6
✅
✅
✅
MAC地址
✅
✅
✅
MTU
✅
✅
✅
接口标志
✅
✅
✅
动态更新
✅
✅
⚠️ (需重新调用)
代码复杂度
低
中
高

9.2 IP模块对比

特性
Linux (ip.c)
BSD (ip.c)
Windows (ip-win32.c)
套接字类型
socket(AFINET, SOCKRAW)
socket(AFINET, SOCKRAW)
socket(AFINET, SOCKRAW)
IP头包含
setsockopt(IP_HDRINCL)
setsockopt(IP_HDRINCL)
setsockopt(IP_HDRINCL)
发送
sendto()
sendto()
sendto()
接收
recv()
recv()
❌ (Windows 8+)
权限要求
CAPNETRAW
root
管理员

9.3 路由模块对比

特性
Linux (route-linux.c)
BSD (route-bsd.c)
Windows (route-win32.c)
数据源
Netlink套接字
路由套接字
GetIpForwardTable/2
IPv4
✅
✅
✅
IPv6
✅
✅
✅ (仅Vista+)
动态更新
✅
✅
⚠️ (需重新调用)
修改权限
CAPNETADMIN
root
管理员
接口查询
✅
✅
✅

9.4 ARP模块对比

特性
Linux (arp-linux.c)
BSD (arp-bsd.c)
Windows (arp-win32.c)
数据源
/proc/net/arp
sysctl
GetIpNetTable
静态条目
✅
✅
✅
动态更新
✅
✅
⚠️ (需重新调用)
修改权限
CAPNETADMIN
root
管理员

9.5 防火墙模块对比

特性
Linux (fw-ipchains/ipfw)
BSD (fw-ipfw/pf/ipf)
Windows (fw-pktfilter)
实现方式
setsockopt
ioctl/sysctl
命名管道
IPv4
✅
✅
⚠️ (需第三方驱动)
IPv6
⚠️
✅
❌
状态跟踪
⚠️
✅
⚠️
驱动依赖
内置
内置
需要安装PktFilter

变通方案与最佳实践

10.1 以太网功能实现

方案1：WinPcap/Npcap（推荐）

  1. #include<pcap.h>
  3. typedefstruct{
  4. pcap_t*pcap;
  5. char device[256];
  6. }eth_winpcap_t;
  8. eth_winpcap_t*eth_open_winpcap(constchar*device){
  9. eth_winpcap_t*e = calloc(1,sizeof(*e));
  10. char errbuf[PCAP_ERRBUF_SIZE];
  12.     e->pcap = pcap_open_live(device,65535,1,1000, errbuf);
  13. if(e->pcap == NULL){
  14.         free(e);
  15. return NULL;
  16. }
  17.     strncpy(e->device, device,sizeof(e->device)-1);
  18. return e;
  19. }
  21. int eth_send_winpcap(eth_winpcap_t*e,const u_char *buf,int len){
  22. return pcap_sendpacket(e->pcap, buf, len);
  23. }
  25. void eth_close_winpcap(eth_winpcap_t*e){
  26. if(e){
  27.         pcap_close(e->pcap);
  28.         free(e);
  29. }
  30. }

方案2：NDIS用户模式驱动

开发自定义NDIS驱动（复杂，不推荐用于普通应用）

10.2 权限提升方案

自动请求管理员权限

  1. #include<shellapi.h>
  3. int restart_as_admin(){
  4.     SHELLEXECUTEINFO sei ={0};
  5.     sei.cbSize =sizeof(sei);
  6.     sei.lpVerb ="runas";// 请求管理员权限
  7.     sei.lpFile =GetCommandLine();
  8.     sei.hwnd = NULL;
  9.     sei.nShow = SW_NORMAL;
  11. if(!ShellExecuteEx(&sei)){
  12.         DWORD dwError =GetLastError();
  13. if(dwError == ERROR_CANCELLED){
  14.             printf("用户取消了权限提升请求\n");
  15. return-1;
  16. }
  17. }
  18. return0;
  19. }

运行时权限检查

  1. int is_admin(){
  2.     BOOL isAdmin = FALSE;
  3.     PSID adminGroup = NULL;
  5. // 获取管理员组SID
  6.     SID_IDENTIFIER_AUTHORITY auth = SECURITY_NT_AUTHORITY;
  7. if(AllocateAndInitializeSid(&auth,2, SECURITY_BUILTIN_DOMAIN_RID,
  8.         DOMAIN_ALIAS_RID_ADMINS,0,0,0,0,0,0,&adminGroup)){
  9. if(!CheckTokenMembership(NULL, adminGroup,&isAdmin)){
  10.             isAdmin = FALSE;
  11. }
  12. FreeSid(adminGroup);
  13. }
  15. return isAdmin;
  16. }

10.3 性能优化建议

10.3.1 缓存接口信息

  1. typedefstruct{
  2.     IP_ADAPTER_ADDRESSES *iftable;
  3. time_t last_update;
  4. time_t cache_timeout;
  5. }intf_cache_t;
  7. intf_cache_t*intf_cache_create(int timeout){
  8. intf_cache_t*cache = calloc(1,sizeof(*cache));
  9.     cache->cache_timeout = timeout;
  10. return cache;
  11. }
  13. int intf_cache_refresh(intf_cache_t*cache){
  14. time_t now = time(NULL);
  16. // 检查是否需要刷新
  17. if(cache->iftable &&(now - cache->last_update)< cache->cache_timeout){
  18. return0;// 使用缓存
  19. }
  21. // 刷新缓存
  22. if(cache->iftable) free(cache->iftable);
  24.     ULONG len =16384;
  25.     IP_ADAPTER_ADDRESSES *p;
  26. do{
  27.         free(p);
  28.         p = malloc(len);
  29. if(GetAdaptersAddresses(AF_UNSPEC,
  30.             GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_ANYCAST,
  31.             NULL, p,&len)!= ERROR_BUFFER_OVERFLOW){
  32. break;
  33. }
  34. }while(1);
  36.     cache->iftable = p;
  37.     cache->last_update = now;
  38. return0;
  39. }

10.3.2 批量操作优化

  1. // 批量添加路由
  2. int route_batch_add(route_t*r,struct route_entry *entries,int count){
  3. int i, failed =0;
  5. for(i =0; i < count; i++){
  6. if(route_add(r,&entries[i])<0){
  7.             failed++;
  8. }
  9. }
  10. return failed;
  11. }

10.4 错误处理增强

  1. #include<stdio.h>
  3. void print_winsock_error(){
  4. int err =WSAGetLastError();
  5. char*msg = NULL;
  7. FormatMessageA(
  8.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
  9.         FORMAT_MESSAGE_FROM_SYSTEM |
  10.         FORMAT_MESSAGE_IGNORE_INSERTS,
  11.         NULL,
  12.         err,
  13.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  14. (LPSTR)&msg,
  15. 0,
  16.         NULL
  17. );
  19. if(msg){
  20.         fprintf(stderr,"Winsock错误 %d: %s\n", err, msg);
  21. LocalFree(msg);
  22. }else{
  23.         fprintf(stderr,"Winsock错误 %d: 未知错误\n", err);
  24. }
  25. }
  27. void print_iphlpapi_error(DWORD err){
  28. char*msg = NULL;
  30. FormatMessageA(
  31.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
  32.         FORMAT_MESSAGE_FROM_SYSTEM |
  33.         FORMAT_MESSAGE_IGNORE_INSERTS,
  34.         NULL,
  35.         err,
  36.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  37. (LPSTR)&msg,
  38. 0,
  39.         NULL
  40. );
  42. if(msg){
  43.         fprintf(stderr,"IP Helper API错误 %d: %s\n", err, msg);
  44. LocalFree(msg);
  45. }else{
  46.         fprintf(stderr,"IP Helper API错误 %d: 未知错误\n", err);
  47. }
  48. }

附录：完整代码示例

A.1 Windows平台网络工具完整示例

  1. /*
  2.  * libdnet Windows网络工具完整示例
  3.  * 功能：枚举接口、路由表、ARP表
  4.  */
  6. #include<stdio.h>
  7. #include<winsock2.h>
  8. #include"dnet.h"
  10. // 打印接口信息
  11. staticint print_interface(conststruct intf_entry *entry,void*arg){
  12.     printf("\n[%s]\n", entry->intf_name);
  13.     printf("  Flags: 0x%04X", entry->intf_flags);
  14. if(entry->intf_flags & INTF_FLAG_UP) printf(" UP");
  15. if(entry->intf_flags & INTF_FLAG_LOOPBACK) printf(" LOOPBACK");
  16. if(entry->intf_flags & INTF_FLAG_MULTICAST) printf(" MULTICAST");
  17.     printf("\n");
  19. if(entry->intf_mtu !=0)
  20.         printf("  MTU: %d\n", entry->intf_mtu);
  22. if(entry->intf_addr.addr_type == ADDR_TYPE_IP)
  23.         printf("  IP: %s/%d\n", addr_ntoa(&entry->intf_addr), entry->intf_addr.addr_bits);
  25. if(entry->intf_link_addr.addr_type == ADDR_TYPE_ETH)
  26.         printf("  MAC: %s\n", addr_ntoa(&entry->intf_link_addr));
  28. return0;
  29. }
  31. // 打印路由表
  32. staticint print_route(conststruct route_entry *entry,void*arg){
  33.     printf("%-18s %-18s %-10s %5d\n",
  34.         addr_ntoa(&entry->route_dst),
  35.         addr_ntoa(&entry->route_gw),
  36.         entry->intf_name,
  37.         entry->metric);
  38. return0;
  39. }
  41. // 打印ARP表
  42. staticint print_arp(conststruct arp_entry *entry,void*arg){
  43.     printf("%-18s %-18s\n",
  44.         addr_ntoa(&entry->arp_pa),
  45.         addr_ntoa(&entry->arp_ha));
  46. return0;
  47. }
  49. int main(void){
  50.     WSADATA wsaData;
  51. intf_t*intf;
  52. route_t*route;
  53. arp_t*arp;
  55. // 初始化Winsock
  56. if(WSAStartup(MAKEWORD(2,2),&wsaData)!=0){
  57.         fprintf(stderr,"WSAStartup失败\n");
  58. return1;
  59. }
  61.     printf("=== libdnet Windows网络工具 ===\n");
  63. // 枚举接口
  64.     printf("\n1. 网络接口:\n");
  65. if((intf = intf_open())!= NULL){
  66.         intf_loop(intf, print_interface, NULL);
  67.         intf_close(intf);
  68. }
  70. // 枚举路由表
  71.     printf("\n2. 路由表:\n");
  72.     printf("%-18s %-18s %-10s %5s\n","目标","网关","接口","度量");
  73.     printf("------------------ ------------------ ---------- -----\n");
  74. if((route = route_open())!= NULL){
  75.         route_loop(route, print_route, NULL);
  76.         route_close(route);
  77. }
  79. // 枚举ARP表
  80.     printf("\n3. ARP表:\n");
  81.     printf("%-18s %-18s\n","IP地址","MAC地址");
  82.     printf("------------------ ------------------\n");
  83. if((arp = arp_open())!= NULL){
  84.         arp_loop(arp, print_arp, NULL);
  85.         arp_close(arp);
  86. }
  88. WSACleanup();
  89. return0;
  90. }

A.2 跨平台抽象层

  1. /*
  2.  * 平台特定头文件
  3.  */
  5. #ifdef _WIN32
  6. #include<winsock2.h>
  7. #include<windows.h>
  8. #include<iphlpapi.h>
  9. #pragma comment(lib,"ws2_32.lib")
  10. #pragma comment(lib,"iphlpapi.lib")
  11. #else
  12. #include<sys/socket.h>
  13. #include<netinet/in.h>
  14. #include<arpa/inet.h>
  15. #include<unistd.h>
  16. #endif
  18. /*
  19.  * 平台特定宏
  20.  */
  22. #ifdef _WIN32
  23. #define SOCKET_INVALID INVALID_SOCKET
  24. #define socket_close closesocket
  25. #define socket_errno WSAGetLastError()
  26. #define sleep_ms(ms)Sleep(ms)
  27. #else
  28. #define SOCKET_INVALID -1
  29. #define socket_close close
  30. #define socket_errno errno
  31. #define sleep_ms(ms) usleep((ms)*1000)
  32. #endif
  34. /*
  35.  * 初始化函数
  36.  */
  38. #ifdef _WIN32
  39. int network_init(void){
  40.     WSADATA wsaData;
  41. returnWSAStartup(MAKEWORD(2,2),&wsaData);
  42. }
  44. void network_cleanup(void){
  45. WSACleanup();
  46. }
  47. #else
  48. int network_init(void){
  49. return0;// Linux/macOS无需初始化
  50. }
  52. void network_cleanup(void){
  53. // 无需清理
  54. }
  55. #endif

总结

Windows平台关键限制

  1. 以太网层访问：完全不支持，必须依赖WinPcap/Npcap
  2. 原始套接字接收：Windows 8+严格限制
  3. 权限要求：大部分功能需要管理员权限
  4. 第三方防火墙：需要安装额外驱动
  5. API性能：比Linux直接访问 /proc慢

设计哲学

libdnet在Windows上采用零依赖的设计理念：

  • 完全使用Windows原生API
  • 通过IP Helper API实现大部分功能
  • 对于不可实现的功能（如以太网），提供存根实现
  • 通过动态加载实现版本兼容

适用场景

场景
推荐方案
简单网络工具
libdnet原生实现
需要以太网功能
libdnet + WinPcap/Npcap
高性能包捕获
直接使用WinPcap/Npcap
防火墙管理
使用Windows防火墙API

最佳实践

  1. 权限检查：运行时检查并提示用户提升权限
  2. 错误处理：使用 GetLastError()和 FormatMessage()提供详细错误信息
  3. 版本兼容：使用动态加载支持旧版本Windows
  4. 缓存机制：缓存接口信息减少API调用开销
  5. Unicode支持：正确处理宽字符与多字节字符转换

  • 公众号:安全狗的自我修养

  • vx:2207344074

  • http://gitee.com/haidragon

  • http://github.com/haidragon

  • bilibili:haidragonx