Npcap 是由著名的Nmap项目开发的用于Windows平台的数据包捕获和注入库，是对已不再维护的WinPcap的一个全面升级。它提供了更快的速度、更高的稳定性和更强的安全性，是网络监控和数据分析领域的必备工具。
Npcap 是一款高性能的网络捕获和数据包分析库，作为 Nmap 项目的一部分，Npcap 可用于捕获、发送和分析网络数据包。本章将介绍如何使用 Npcap 库来实现半开放扫描功能。TCP SYN 半开放扫描是一种常见且广泛使用的端口扫描技术，用于探测目标主机端口的开放状态。由于这种方法并不完成完整的 TCP 三次握手过程，因此具有更高的隐蔽性和扫描效率。

nmap

nmap（Network Mapper）是一款开源免费的针对大型网络的端口扫描工具，nmap可以检测目标主机是否在线、主机端口开放情况、检测主机运行的服务类型及版本信息、检测操作系统与设备类型等信息。本文主要介绍nmap工具安装和基本使用方法。

nmap主要功能

（1）检测主机是否在线。例如，列出响应TCP和/或ICMP请求或打开特定端口的主机。
（2）扫描指定主机/主机列表端口开放状态，枚举目标主机上的开放端口，常用。
（3）检测主机运行服务类型及版本，检测远程设备上的网络服务以确定应用程序名称和版本号。
（4）检测操作系统版本和设备类型 ，确定网络设备的操作系统和硬件特性。
（5）可与脚本进行脚本交互，使用Nmap脚本引擎（NSE）和Lua编程语言。

nmap工具下载和安装

  （1）nmap官方下载路径：https://nmap.org/download.html
  （2）按照操作系统类型下载相应软件安装。
  （3）Windows软件执行.exe软件安装。
  （4）Linux系统下载的rpm软件安装，上传到root用户目录下执行rpm命令完成安装：rpm -ivh nmap-7.80-1.x86_64.rpm

使用Npcap库开发简单的扫描功能

首先，若使用

1. Nmap

复制代码

对目标主机进行

1. SYN

复制代码

扫描，只需要执行

1. nmap -sS 39.97.203.57

复制代码

命令即可，等待一段时间则可获取到目标主机常规开放端口状态，若要扫描特定端口开放状态仅需要指定

1. -p

复制代码

参数并携带扫描区间即可，如下命令所示；

1. ┌──(lyshark㉿kali)-[~]
   
2. └─$ sudo nmap -sS 39.97.203.57
   
3. Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-08-08 15:28 CST
   
4. Nmap scan report for 39.97.203.57
   
5. Host is up (0.0038s latency).
   
6. Not shown: 997 filtered tcp ports (no-response)
   
7. PORT     STATE SERVICE
   
8. 80/tcp   open  http
   
9. 443/tcp  open  https
   
10. 1935/tcp open  rtmp
    
11. 
    
12. ┌──(lyshark㉿kali)-[~]
    
13. └─$ sudo nmap -sS -v 39.97.203.57 -p 1-2000
    
14. Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-08-08 15:32 CST
    
15. Scanning 39.97.203.57 [2000 ports]
    
16. Discovered open port 80/tcp on 39.97.203.57
    
17. Discovered open port 443/tcp on 39.97.203.57
    
18. Discovered open port 1935/tcp on 39.97.203.57
    
19. Completed SYN Stealth Scan at 15:32, 7.42s elapsed (2000 total ports)
    
20. Nmap scan report for 39.97.203.57
    
21. Host is up (0.0039s latency).
    
22. Not shown: 1997 filtered tcp ports (no-response)
    
23. PORT     STATE SERVICE
    
24. 80/tcp   open  http
    
25. 443/tcp  open  https
    
26. 1935/tcp open  rtmp

复制代码

Npcap库的配置非常简单，读者仅需要去到官网下载，初次使用还需安装Npcap 1.79 installer驱动程序，并下载Npcap SDK 1.13对应的开发工具包，如下图所示；

接着，读者需要自行解压SDK开发工具包，并配置VC++目录包含目录与库目录，如下图所示；

在进行开发之前，我们需要先定义三个结构体变量，首先定义eth_header数据包头，以太网包头（Ethernet Frame Header）用于传输控制信息和数据，它是数据链路层的一部分，负责在局域网中实现数据的可靠传输。
接着定义ip_header数据包头，IP头（IP Header）用于传输控制信息和数据，IP头是网络层的一部分，负责实现跨越不同网络的数据传输。
最后定义tcp_header数据包头，TCP头（TCP Header）用于传输控制信息和数据，TCP头是传输层的一部分，负责在主机之间提供可靠的、面向连接的通信。
若要发送TCP数据包，必须要构造一个完整的通信协议头，将以太网数据包头、IP数据包头、TCP数据包头封装起来即可，其定义部分如下所示，其中每一个变量均对应于协议的每一个参数。

1. #include <winsock2.h>
   
2. #include <Windows.h>
   
3. #include <pcap.h>
   
4. 
   
5. #pragma comment(lib,"ws2_32.lib")
   
6. #pragma comment(lib, "packet.lib")
   
7. #pragma comment(lib, "wpcap.lib")
   
8. 
   
9. // 以太网头部结构体
   
10. struct eth_header
    
11. {
    
12.   uint8_t dest[6];   // 目的MAC地址 (6字节)
    
13.   uint8_t src[6];    // 源MAC地址 (6字节)
    
14.   uint16_t type;     // 以太网类型字段，表示上层协议 (2字节)
    
15. };
    
16. 
    
17. // IPv4头部结构体
    
18. struct ip_header
    
19. {
    
20.   uint8_t ihl : 4,     // 头部长度 (4位)，表示IP头部的长度，以32位字为单位
    
21.       version : 4; // 版本 (4位)，IPv4的版本号为4
    
22.   uint8_t tos;        // 服务类型 (1字节)
    
23.   uint16_t tot_len;   // 总长度 (2字节)，表示整个IP数据报的长度，以字节为单位
    
24.   uint16_t id;        // 标识 (2字节)，用于标识数据报片段
    
25.   uint16_t frag_off;  // 片段偏移 (2字节)，用于数据报片段
    
26.   uint8_t ttl;        // 生存时间 (1字节)，表示数据报在网络中的生存时间
    
27.   uint8_t protocol;   // 协议 (1字节)，表示上层协议 (例如，TCP为6，UDP为17)
    
28.   uint16_t check;     // 头部校验和 (2字节)，用于检验头部的完整性
    
29.   uint32_t saddr;     // 源地址 (4字节)，表示发送方的IPv4地址
    
30.   uint32_t daddr;     // 目的地址 (4字节)，表示接收方的IPv4地址
    
31. };
    
32. 
    
33. // TCP头部结构体
    
34. struct tcp_header
    
35. {
    
36.   uint16_t source;    // 源端口号 (2字节)
    
37.   uint16_t dest;      // 目的端口号 (2字节)
    
38.   uint32_t seq;       // 序号 (4字节)，表示数据段的序列号
    
39.   uint32_t ack_seq;   // 确认号 (4字节)，表示期望接收的下一个序列号
    
40.   uint16_t res1 : 4,  // 保留位 (4位)，通常设为0
    
41.   doff : 4,   // 数据偏移 (4位)，表示TCP头部的长度，以32位字为单位
    
42.   fin : 1,    // FIN标志 (1位)，表示发送方没有更多数据
    
43.   syn : 1,    // SYN标志 (1位)，表示同步序号，用于建立连接
    
44.   rst : 1,    // RST标志 (1位)，表示重置连接
    
45.   psh : 1,    // PSH标志 (1位)，表示推送数据
    
46.   ack : 1,    // ACK标志 (1位)，表示确认字段有效
    
47.   urg : 1,    // URG标志 (1位)，表示紧急指针字段有效
    
48.   res2 : 2;   // 保留位 (2位)，通常设为0
    
49.   uint16_t window;    // 窗口大小 (2字节)，表示接收方的缓冲区大小
    
50.   uint16_t check;     // 校验和 (2字节)，用于检验TCP头部和数据的完整性
    
51.   uint16_t urg_ptr;   // 紧急指针 (2字节)，表示紧急数据的偏移量
    
52. };
    
53. 
    
54. unsigned short checksum(void *b, int len)
    
55. {
    
56.   unsigned short *buf = (unsigned short *)b;
    
57.   unsigned int sum = 0;
    
58.   unsigned short result;
    
59. 
    
60.   for (sum = 0; len > 1; len -= 2)
    
61.     sum += *buf++;
    
62.   if (len == 1)
    
63.     sum += *(unsigned char*)buf;
    
64.   sum = (sum >> 16) + (sum & 0xFFFF);
    
65.   sum += (sum >> 16);
    
66.   result = ~sum;
    
67.   return result;
    
68. }

复制代码

接着需要实现两个通用函数，其中EnumAdapters用于枚举当前系统中所有的网卡信息，并输出其下标号与网卡描述信息，BindAdapters函数则用于根据用户传入的下标号对网卡进行动态绑定，函数中通过循环的方式查找网卡下标若匹配则将下标所对应的句柄存储到temp_adapter变量内，最后通过pcap_open_live实现对网卡的打开。

1. // 枚举当前网卡
   
2. int EnumAdapters()
   
3. {
   
4.   pcap_if_t *allAdapters;
   
5.   pcap_if_t *ptr;
   
6.   int index = 0;
   
7.   char errbuf[PCAP_ERRBUF_SIZE];
   
8. 
   
9.   // 获取本地机器设备列表
   
10.   if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, NULL, &allAdapters, errbuf) != -1)
    
11.   {
    
12.     // 打印网卡信息列表
    
13.     for (ptr = allAdapters; ptr != NULL; ptr = ptr->next)
    
14.     {
    
15.       ++index;
    
16.       if (ptr->description)
    
17.       {
    
18.         printf("[ %d ] \t [ %s ] \n", index - 1, ptr->description);
    
19.       }
    
20.     }
    
21.   }
    
22. 
    
23.   pcap_freealldevs(allAdapters);
    
24.   return index;
    
25. }
    
26. 
    
27. // 根据编号绑定到对应网卡
    
28. pcap_t* BindAdapters(int nChoose)
    
29. {
    
30.   pcap_if_t *adapters, *temp_adapter;
    
31.   char errbuf[PCAP_ERRBUF_SIZE];
    
32.   pcap_t *handle = NULL;
    
33. 
    
34.   if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, NULL, &adapters, errbuf) == -1)
    
35.   {
    
36.     return NULL;
    
37.   }
    
38. 
    
39.   // 遍历找到指定的网卡
    
40.   temp_adapter = adapters;
    
41.   for (int x = 0; x < nChoose - 1 && temp_adapter != NULL; ++x)
    
42.   {
    
43.     temp_adapter = temp_adapter->next;
    
44.   }
    
45. 
    
46.   // 若找不到绑定设备则释放句柄
    
47.   if (temp_adapter == NULL)
    
48.   {
    
49.     pcap_freealldevs(adapters);
    
50.     return NULL;
    
51.   }
    
52. 
    
53.   // 打开指定的网卡
    
54.   handle = pcap_open_live(temp_adapter->name, 65534, PCAP_OPENFLAG_PROMISCUOUS, 1000, errbuf);
    
55.   if (handle == NULL)
    
56.   {
    
57.     pcap_freealldevs(adapters);
    
58.     return NULL;
    
59.   }
    
60. 
    
61.   pcap_freealldevs(adapters);
    
62.   return handle;
    
63. }

复制代码

抓包回调函数packet_handler由pcap_loop调用，当启用抓包后若句柄返回数据则会通过回调函数通知用户，用户获取到数据包header后，通过逐层解析即可得到所需要的字段，若要实现SYN快速探测则需要判断tcph标志，若标志被返回则可通过RST断开会话，并以此节约扫描时间。
如下代码，定义了一个网络数据包回调函数 packet_handler，用于处理通过 pcap 库捕获的网络数据包。函数首先打印数据包的长度，然后解析以太网头部以检查其类型是否为 IP（0x0800）。如果是 IP 数据包，进一步解析 IP 头部并打印相关信息，包括 IP 版本、头长度、源 IP 地址和目标 IP 地址。随后检查 IP 数据包的协议字段是否为 TCP（6），若是，则解析 TCP 头部并打印源端口、目标端口、序列号、确认号、头部长度、标志、窗口大小、校验和及紧急指针等信息。

1. // 网络数据包回调函数
   
2. void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data)
   
3. {
   
4.   // 打印数据包长度
   
5.   printf("数据包长度：%d\n", header->len);
   
6. 
   
7.   // 以太网头部
   
8.   struct eth_header *eth = (struct eth_header *)(pkt_data);
   
9. 
   
10.   // 检查以太网类型是否为 IP（0x0800）
    
11.   if (ntohs(eth->type) == 0x0800)
    
12.   {
    
13.     // IP 头部
    
14.     struct ip_header *iph = (struct ip_header *)(pkt_data + sizeof(struct eth_header));
    
15. 
    
16.     // 打印 IP 头部信息
    
17.     printf("IP 版本: %d | ", iph->version);
    
18.     printf("IP 头长度: %d | ", iph->ihl * 4);
    
19.     printf("源IP地址: %s | ", inet_ntoa(*(struct in_addr *)&iph->saddr));
    
20.     printf("目标IP地址: %s\n", inet_ntoa(*(struct in_addr *)&iph->daddr));
    
21. 
    
22.     // 检查协议是否为 TCP（6）
    
23.     if (iph->protocol == 6)
    
24.     {
    
25.       // TCP 头部
    
26.       struct tcp_header *tcph = (struct tcp_header *)(pkt_data + sizeof(struct eth_header) + iph->ihl * 4);
    
27. 
    
28.       // 打印 TCP 头部信息
    
29.       printf("源端口: %d | ", ntohs(tcph->source));
    
30.       printf("目标端口: %d | ", ntohs(tcph->dest));
    
31.       printf("序列号: %u | ", ntohl(tcph->seq));
    
32.       printf("确认号: %u | ", ntohl(tcph->ack_seq));
    
33.       printf("包头长度: %d | ", tcph->doff * 4);
    
34.       printf("标志: ");
    
35.       if (tcph->fin) printf("FIN ");
    
36.       if (tcph->syn) printf("SYN ");
    
37.       if (tcph->rst) printf("RST ");
    
38.       if (tcph->psh) printf("PSH ");
    
39.       if (tcph->ack) printf("ACK ");
    
40.       if (tcph->urg) printf("URG ");
    
41.       printf("\n");
    
42.       printf("窗体长度: %d | ", ntohs(tcph->window));
    
43.       printf("校验和: 0x%04x | ", ntohs(tcph->check));
    
44.       printf("紧急数据指针: %d\n", ntohs(tcph->urg_ptr));
    
45.     }
    
46.   }
    
47.   printf("\n");
    
48. }

复制代码

最后来看下主函数是如何实现的，首先通过调用EnumAdapters函数获取到网卡编号，并调用BindAdapters(4)函数绑定到指定的网卡之上，套接字的创建依然采用原生API接口来实现，只不过在调用sendto发送数据包时我们需要自行构建一个符合SYN扫描条件的数据包，在构建数据包时，以太网数据包用于指定网卡MAC地址等信息，IP数据包头则用于指定IP地址等信息，TCP数据包头则用于指定端口号信息，并仅需将tcph->syn = 1;设置为1，通过checksum计算校验和，并将校验好的packet包通过sendto函数发送到对端主机，如下所示；

1. int main(int argc, char* argv[])
   
2. {
   
3.   pcap_if_t *alldevs;
   
4.   pcap_t *adhandle;
   
5.   int i = 0;
   
6. 
   
7.   EnumAdapters();
   
8. 
   
9.   adhandle = BindAdapters(4);
   
10. 
    
11.   // 创建套接字
    
12.   SOCKET sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
    
13.   if (sock == INVALID_SOCKET)
    
14.   {
    
15.     return -1;
    
16.   }
    
17. 
    
18.   // 设置套接字属性
    
19.   int one = 1;
    
20.   if (setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one)) == SOCKET_ERROR)
    
21.   {
    
22.     return -1;
    
23.   }
    
24. 
    
25.   // ---------------------------------------------------------------
    
26.   // 构建网络数据包
    
27.   // ---------------------------------------------------------------
    
28. 
    
29.   char packet[4096];
    
30.   memset(packet, 0, 4096);
    
31. 
    
32.   struct eth_header *eth = (struct eth_header *)packet;
    
33.   struct ip_header *iph = (struct ip_header *)(packet + sizeof(struct eth_header));
    
34.   struct tcp_header *tcph = (struct tcp_header *)(packet + sizeof(struct eth_header) + sizeof(struct ip_header));
    
35. 
    
36.   // ---------------------------------------------------------------
    
37.   // 构建以太网数据包头
    
38.   // ---------------------------------------------------------------
    
39.   memset(eth->dest, 0xff, 6);  // 目标MAC地址
    
40.   memset(eth->src, 0x00, 6);   // 原MAC地址
    
41.   eth->type = htons(0x0800);   // IPv4
    
42. 
    
43.   // ---------------------------------------------------------------
    
44.   // 构建IP数据包头
    
45.   // ---------------------------------------------------------------
    
46.   iph->ihl = 5;
    
47.   iph->version = 4;
    
48.   iph->tos = 0;
    
49.   iph->tot_len = sizeof(struct ip_header) + sizeof(struct tcp_header);
    
50.   iph->id = htons(54321);
    
51.   iph->frag_off = 0;
    
52.   iph->ttl = 255;
    
53.   iph->protocol = IPPROTO_TCP;
    
54.   iph->check = 0;
    
55.   iph->saddr = inet_addr("192.168.1.1");   // 原始IP地址
    
56.   iph->daddr = inet_addr("39.97.203.57");  // 目标IP地址
    
57. 
    
58.   // ---------------------------------------------------------------
    
59.   // 构建TCP数据包头
    
60.   // ---------------------------------------------------------------
    
61.   tcph->source = htons(12345);           // 原始TCP端口
    
62.   tcph->dest = htons(80);                // 目标TCP端口
    
63.   tcph->seq = 0;
    
64.   tcph->ack_seq = 0;
    
65.   tcph->doff = 5; // TCP 头部长度
    
66.   tcph->fin = 0;
    
67.   tcph->syn = 1;
    
68.   tcph->rst = 0;
    
69.   tcph->psh = 0;
    
70.   tcph->ack = 0;
    
71.   tcph->urg = 0;
    
72.   tcph->window = htons(5840);    // 分配Windows窗体数
    
73.   tcph->check = 0;               // 现在保留校验和0，稍后用伪标头填充
    
74.   tcph->urg_ptr = 0;
    
75. 
    
76.   // ---------------------------------------------------------------
    
77.   // 计算校验和
    
78.   // ---------------------------------------------------------------
    
79. 
    
80.   // 计算IP校验和
    
81.   iph->check = checksum((unsigned short *)packet, iph->tot_len);
    
82. 
    
83.   // TCP 校验和
    
84.   struct
    
85.   {
    
86.     uint32_t src_addr;
    
87.     uint32_t dst_addr;
    
88.     uint8_t placeholder;
    
89.     uint8_t protocol;
    
90.     uint16_t tcp_length;
    
91.     struct tcp_header tcp;
    
92.   } pseudo_header;
    
93. 
    
94.   pseudo_header.src_addr = iph->saddr;
    
95.   pseudo_header.dst_addr = iph->daddr;
    
96.   pseudo_header.placeholder = 0;
    
97.   pseudo_header.protocol = IPPROTO_TCP;
    
98.   pseudo_header.tcp_length = htons(sizeof(struct tcp_header));
    
99.   memcpy(&pseudo_header.tcp, tcph, sizeof(struct tcp_header));
    
100. 
     
101.   tcph->check = checksum((unsigned short *)&pseudo_header, sizeof(pseudo_header));
     
102. 
     
103.   // ---------------------------------------------------------------
     
104.   // 发送数据包
     
105.   // ---------------------------------------------------------------
     
106. 
     
107.   struct sockaddr_in dest;
     
108.   dest.sin_family = AF_INET;
     
109.   dest.sin_addr.s_addr = iph->daddr;
     
110. 
     
111.   if (sendto(sock, packet, iph->tot_len, 0, (struct sockaddr *)&dest, sizeof(dest)) == SOCKET_ERROR)
     
112.   {
     
113.     return -1;
     
114.   }
     
115. 
     
116.   // ---------------------------------------------------------------
     
117.   // 启用抓包
     
118.   // ---------------------------------------------------------------
     
119. 
     
120.   pcap_loop(adhandle, 10, packet_handler, NULL);
     
121. 
     
122.   pcap_close(adhandle);
     
123.   closesocket(sock);
     
124.   pcap_freealldevs(alldevs);
     
125. 
     
126.   system("pause");
     
127.   return 0;
     
128. }

复制代码

读者可自行编译并运行上述代码，当执行成功后则可看到数据包的方向及标志类型，如下图所示。

到此这篇关于使用Npcap库开发简单的扫描功能的文章就介绍到这了,更多相关Npcap库开发扫描功能内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！