Skip to content
KitploitKITPLOIT
工具博客
提交
工具博客
提交

黑客、渗透测试和网络安全工具,武装您的安全武器库!

Kitploit 是一个黑客、网络安全和渗透测试工具的目录。发现最新的项目更新,查找漏洞、分析系统、自动化测试并加强你的安全。

··订阅源·联系·隐私·© 2026 Kitploit

工具目录

分类

查看所有分类
Loading categories
工具/GitHubGitHub/mdsadiqmd/av-chaos-monkey
Web安全网络安全渗透测试云安全DevSecOps混沌工程
GitHubmdsadiqmd/av-chaos-monkey

AV-Chaos-Monkey

Chaos Monkey,但用于音视频测试(webRTC和UDP)

查看仓库
526个月前Kitploit 审核通过

最受欢迎

查看全部 →

发现我们社区最常用的工具。

探索所有工具

浏览我们的工具集合

查看所有工具 →
分享

AV Chaos Monkey

分布式混沌工程平台,用于对视频会议系统进行负载测试。模拟超过1500个WebRTC参与者,传输H.264/Opus流,并注入网络混沌尖峰,以验证系统在降级条件下的韧性

架构

image
  1. 媒体处理管道:

    • FFmpeg 在启动时将输入视频转换为 H.264 Annex-B 和 Ogg/Opus
    • NAL Reader 解析 H.264 流(SPS/PPS/IDR/Slices)
    • Opus Reader 从 Ogg 容器中提取 20ms 音频帧
    • 帧数据缓存在内存中,所有参与者共享(零拷贝)
    • 相比每个参与者独立编码,CPU 降低约 90%
  2. 控制平面:

    • HTTP 服务(:8080)通过 REST API 管理测试生命周期
    • 尖峰调度器分配混沌事件(均匀/随机/前载/后载/遗留)
    • 网络降级器应用混沌:丢包(1-25%)、抖动(10-50ms)、码率降低(30-80%)、丢帧(10-60%)
    • 加载的混沌配置应用到参与者池
  3. 参与者池:

    • 基于 participant_id % total_partitions = partition_id 自动跨 Pod 分区
    • 每个参与者生成 RTP 流(PT=96 视频,PT=111 音频)
    • 参与者 ID 嵌入 RTP 扩展头(ID=1)
    • 池大小:1-100(本地),100-500(Docker),500-1500(Kubernetes)
  4. Kubernetes 自动配置:

    • Pod 从 Pod 名称自动检测分区 ID:orchestrator-3 → PARTITION_ID=3
    • 端口分配:base_port + (partition_id × 10000) + participant_index
    • 示例:分区 0 使用 5000-14999,分区 1 使用 15000-24999
    • StatefulSet 有 10 个副本,每个处理约 150 个参与者
    • 资源:每个 Pod 1-4 CPU,2-4Gi 内存
    • 根据宿主机规格自动配置
  5. UDP 中继链(仅 Kubernetes):

    root@kitploit:~
    Orchestrator Pods (10×) → UDP :5000 → udp-relay Pod (Python)
    → Length-Prefixed TCP :5001 → kubectl port-forward 15001:5001
    → tools/udp-relay (Go) → UDP :5002 → Your Receiver
    
    • 原因:kubectl port-forward 仅支持 TCP,不支持 UDP
    • 集群内中继:Python 脚本从所有 Pod 聚合 UDP,以带 2 字节长度前缀的 TCP 流形式传输
    • 本地中继:Go 工具将 TCP 流转换回 UDP 数据包
    • 将 1500 个参与者流聚合为单个连接
  6. WebRTC 基础设施:

    • Coturn StatefulSet:3 个初始副本,HPA 根据负载在 1-10 间伸缩(约 500 参与者/副本)
    • coturn-lb 服务:在副本间负载均衡 TURN 流量
    • webrtc-connector:可选的代理层(Deployment + HPA 2-10 副本),处理 SDP 信令
    • Docker 模式:单个 Coturn 容器用于本地测试
    • 端口:3478(TURN),49152-65535(中继范围)
    • 凭据:webrtc/webrtc123
  7. 客户端集成:

    • UDP 接收器:通过中继链接收来自所有参与者的聚合 RTP 流
    • WebRTC 接收器:通过 TURN 服务器进行 SDP 交换,建立 1:1 WebRTC 连接
    • 两者都将流转发给你正在测试的视频通话系统(SFU/MCU/Mesh)
  8. 可观测性栈(可选):

    • Prometheus:每 5 秒从所有编排器 Pod 的 /metrics 端点抓取数据
    • Grafana:通过预配置仪表盘(admin/admin)可视化指标
    • 暴露的指标:参与者数量、发送数据包数、发送字节数、活跃尖峰数、丢包率%、抖动、MOS 评分
    • 访问:Prometheus :30090,Grafana :30030(NodePort)
    • 编排器 Pod 带有自动发现注解:prometheus.io/scrape: "true"

核心概念

参与者模拟

每个虚拟参与者生成真实的媒体流:

  • 视频:来自实际视频文件的 H.264 NAL 单元,按 RFC 6184 封装
  • 音频:来自 Ogg 容器的 Opus 帧,按 RFC 7587 封装
  • RTP:符合标准的头部,包含参与者 ID 扩展
  • 时序:帧级精确时序(30fps 视频,20ms 音频数据包)

混沌注入

五种尖峰类型模拟现实网络条件:

  • 丢包:在应用层丢弃 RTP 数据包(1-100%)
  • 网络抖动:增加延迟变化(基础延迟 + 高斯抖动)
  • 码率降低:限制视频编码码率(减少 30-80%)
  • 丢帧:跳过视频帧(丢弃率 10-60%)
  • 带宽限制:限制总吞吐量

分布策略

尖峰按可配置策略分布在测试持续时间内:

  • 均匀:带抖动的均匀间隔(可预测的负载)
  • 随机:不可预测的时机(真实的混沌)
  • 前载:早期密集尖峰(恢复测试)
  • 后载:基线后引入混沌(对比测试)
  • 遗留:固定间隔计时器(运行时注入)

分区

Kubernetes 部署使用参与者分区进行水平扩展:

  • 每个 Pod 处理 participant_id % total_partitions == partition_id
  • 端口分配:base_port + (partition_id * 10000) + participant_index
  • 在 1-10 个 Pod 间自动负载分配
  • 可扩展到 1500+ 参与者(每个 Pod 150 个)

运行系统

1. 本地开发(原生 Go)

最佳用途:开发、调试、小规模测试(1-100 参与者)

root@kitploit:~
# 启动编排器
go run cmd/main.go

# 另一个终端:启动 UDP 接收器
go run examples/go/udp_receiver.go 5002

# 编辑 config/config.json 设置 num_participants: 10
# 运行混沌测试
go run tools/chaos-test/main.go -config config/config.json

执行过程:

  • 单个编排器进程监听 :8080
  • 参与者向 127.0.0.1:5002 发送 UDP
  • 通过 HTTP API 注入混沌尖峰
  • 每 2 秒显示实时指标

配置(config/config.json):

root@kitploit:~
{
  "base_url": "http://localhost:8080",
  "media_path": "public/rick-roll.mp4",
  "num_participants": 10,
  "duration_seconds": 300,
  "spikes": {
    "count": 20,
    "interval_seconds": 5,
    "types": { "rtp_packet_loss": {...}, "network_jitter": {...} }
  },
  "spike_distribution": {
    "strategy": "random",
    "min_spacing_seconds": 5,
    "jitter_percent": 15
  }
}

2. Docker Compose(容器化)

最佳用途:隔离测试、CI/CD、中规模测试(100-500 参与者)

前提条件:

  • Docker Desktop 分配 8-16GB 内存
  • 已安装 docker-compose
root@kitploit:~
# 构建并启动编排器容器
./scripts/start_everything.sh build

# 另一个终端:启动 UDP 接收器
go run examples/go/udp_receiver.go 5002

# 编辑 config/config.json 设置 num_participants: 100
# 运行混沌测试(目标为容器)
go run tools/chaos-test/main.go -config config/config.json

资源限制(编辑 docker-compose.yaml):

root@kitploit:~
services:
  orchestrator:
    deploy:
      resources:
        limits:
          cpus: "14.0"
          memory: 6G  # 增加以容纳更多参与者

扩缩指南:

Docker 内存最大参与者数CPU 核心数
8 GB~1004
16 GB~2508
24 GB~40012
32 GB~50014

3. 使用 Nix 的 Kubernetes(生产规模)

最佳用途:大规模测试(500-1500 参与者)、水平扩展、生产验证

前提条件:

  • 启用 flakes 的 Nix
  • Docker Desktop 或 kind 集群
  • 配置好的 kubectl

第一步:进入 Nix 环境

root@kitploit:~
# Nix 提供:Go、Docker、kubectl、kind、ffmpeg
nix develop

# 或使用 direnv 自动激活
echo "use flake" > .envrc
direnv allow

第二步:部署到 Kubernetes

root@kitploit:~
# 自动部署并优化设置(检测系统资源)
./scripts/start_everything.sh run -config config/config.json

# 或指定自定义媒体文件
./scripts/start_everything.sh run --media=path/to/video.mp4 -config config/config.json

执行过程:

  1. 使用 Nix 提供的 Go 工具链构建 Docker 镜像
  2. 创建/使用 kind 集群
  3. 部署包含 10 个编排器 Pod 的 StatefulSet
  4. 部署 UDP 中继 Pod
  5. 设置 UDP 中继的 kubectl port-forward
  6. 启动本地 TCP→UDP 中继
  7. 跨所有 Pod 运行混沌测试

第三步:接收聚合的 UDP 流

选项 A:UDP 接收器(推荐用于 Kubernetes)

root@kitploit:~
# 接收来自所有 1500 个参与者的聚合流
go run ./examples/go/udp_receiver.go 5002

选项 B:WebRTC 接收器(多个参与者)

root@kitploit:~
# 通过 WebRTC 连接最多 150 个参与者
go run ./examples/go/webrtc_receiver.go http://localhost:8080 <test_id> 150

架构流程:

root@kitploit:~
1500 个参与者分布在 10 个 Pod 上
  → 每个 Pod:150 个参与者
  → 按 participant_id % 10 分区
  → 全部向 udp-relay:5000 发送 UDP
  → UDP 中继聚合 → TCP :5001
  → kubectl port-forward 15001:5001
  → 本地中继转换 TCP → UDP :5002
  → 你的接收器获取全部 1500 个流

注意:start_everything.sh 脚本会自动设置:

  • kubectl port-forward(udp-relay 15001:5001)
  • 本地 TCP→UDP 中继(tools/udp-relay)
  • 你只需运行接收器

手动 Kubernetes 设置

root@kitploit:~
# 构建并加载镜像
docker build -t chaos-monkey-orchestrator:latest .
kind load docker-image chaos-monkey-orchestrator:latest

# 部署
kubectl apply -f k8s/orchestrator/orchestrator.yaml
kubectl apply -f k8s/udp-relay/udp-relay.yaml

# 等待 Pod 就绪
kubectl wait --for=condition=ready pod -l app=orchestrator --timeout=300s

# 端口转发 UDP 中继
kubectl port-forward udp-relay 15001:5001 &

# 启动本地 TCP→UDP 中继
go run tools/udp-relay/main.go &

# 另一个终端:启动接收器
go run ./examples/go/udp_receiver.go 5002

# 另一个终端:运行混沌测试
go run tools/chaos-test/main.go -config config/config.json

清理

root@kitploit:~
# 删除 Kubernetes 资源
./scripts/cleanup.sh

# 或删除整个集群
kind delete cluster --name av-chaos-monkey

使用 Nix 的跨平台构建

root@kitploit:~
# 为 Linux x86_64 构建(最常见)
nix build .#packages.x86_64-linux.av-chaos-monkey

# 为 ARM64 构建(Raspberry Pi、AWS Graviton)
nix build .#packages.aarch64-linux.av-chaos-monkey

# 为 macOS Intel 构建
nix build .#packages.x86_64-darwin.av-chaos-monkey

# 为 macOS Apple Silicon 构建
nix build .#packages.aarch64-darwin.av-chaos-monkey

# 二进制文件位置
./result/bin/main

API 参考

测试生命周期

root@kitploit:~
# 创建测试
POST /api/v1/test/create
{
  "test_id": "optional_id",
  "num_participants": 100,
  "video": {...},
  "audio": {...},
  "duration_seconds": 600,
  "spikes": [...],
  "spike_distribution": {
    "strategy": "even",
    "min_spacing_seconds": 5,
    "jitter_percent": 15
  }
}

# 启动测试
POST /api/v1/test/{test_id}/start

# 获取指标
GET /api/v1/test/{test_id}/metrics

# 停止测试
POST /api/v1/test/{test_id}/stop

WebRTC 信令

root@kitploit:~
# 获取 SDP 提议
GET /api/v1/test/{test_id}/sdp/{participant_id}

# 设置 SDP 应答
POST /api/v1/test/{test_id}/sdp/{participant_id}
{"sdp_answer": "v=0..."}

混沌注入

root@kitploit:~
# 注入尖峰
POST /api/v1/test/{test_id}/spike
{
  "spike_id": "unique_id",
  "type": "rtp_packet_loss",
  "duration_seconds": 30,
  "participant_ids": [1001, 1002],
  "params": {"loss_percentage": "15"}
}

配置

尖峰类型

类型参数效果
rtp_packet_lossloss_percentage (0-100)在 RTP 层丢弃数据包
network_jitterbase_latency_ms, jitter_std_dev_ms添加延迟变化
bitrate_reducenew_bitrate_kbps限制视频编码码率
frame_dropdrop_percentage (0-100)跳过视频帧
bandwidth_limitbandwidth_kbps限制总吞吐量

分布配置

root@kitploit:~
{
  "spike_distribution": {
    "strategy": "even",
    "min_spacing_seconds": 5,
    "jitter_percent": 15,
    "respect_min_offset": true
  }
}

客户端集成

UDP 接收器(Go)

root@kitploit:~
# 提供的接收器,包含 RTP 解析
go run examples/go/udp_receiver.go 5002

输出:

root@kitploit:~
Listening for RTP packets on UDP port 0.0.0.0:5002
Packet #100 from 127.0.0.1:xxxxx:
  Participant ID: 1001
  Payload Type: 96 (H.264 video)
  Sequence: 1234
  Timestamp: 90000
  SSRC: 1001000
  Payload Size: 1200 bytes

═══════════════════════════════════════════════════════════
                    PACKET STATISTICS                       
═══════════════════════════════════════════════════════════
Duration: 60s
Total Packets: 180000 (3000 pkt/s)
Total Bytes: 450 MB (60 Mbps)

Media Type Breakdown:
  Video (H.264): 120000 packets (66.7%)
  Audio (Opus):  60000 packets (33.3%)

Unique Streams (SSRCs): 1500
Unique Participants: 1500

WebRTC 接收器(Go)

root@kitploit:~
# 单个参与者
go run ./examples/go/webrtc_receiver.go http://localhost:8080 <test_id>

# 多个参与者(最多 150)
go run ./examples/go/webrtc_receiver.go http://localhost:8080 <test_id> 150

# 示例(使用实际测试 ID)
go run ./examples/go/webrtc_receiver.go http://localhost:8080 chaos_test_1770831684 150

注意:WebRTC 需要 1:1 连接。对于 Kubernetes,建议使用 UDP 接收器,它会自动聚合所有参与者。

自定义集成

RTP 数据包格式:

root@kitploit:~
 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|V=2|P|X|  CC   |M|     PT      |       sequence number         |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                           timestamp                           |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|           synchronization source (SSRC) identifier            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|  Extension ID=1 | Length=4    |    Participant ID (uint32)    |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         H.264/Opus Payload                    |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

负载类型:

  • 96: H.264 视频(RFC 6184)
  • 111: Opus 音频(RFC 7587)

参与者 ID 提取:

root@kitploit:~
// Extension bit set?
if (packet[0] & 0x10) != 0 {
    offset := 12 + int(packet[0]&0x0F)*4  // Skip CSRC
    extID := binary.BigEndian.Uint16(packet[offset:])
    if extID == 1 {
        participantID := binary.LittleEndian.Uint32(packet[offset+4:])
    }
}

性能

资源需求

参与者数内存CPU带宽
1002GB2 核250 Mbps
5006GB8 核1.2 Gbps
100012GB16 核2.5 Gbps
150018GB24 核3.7 Gbps

Kubernetes 伸缩

  • 自动伸缩:根据参与者数量计算最佳 Pod 数量
  • Pod 容量:每个 Pod 150 个参与者(可配置)
  • 最大 Pod 数:10(StatefulSet 限制)
  • 端口范围:每个分区 10,000 个端口

吞吐量

每个参与者(1280x720@30fps + Opus):

  • 视频:~2.5 Mbps(H.264)
  • 音频:~128 Kbps(Opus)
  • 总计:~2.6 Mbps
  • 数据包:~90 视频 + 50 音频 = 140 pkt/s

监控

Prometheus 指标

root@kitploit:~
# 暴露在 /metrics 端点
av_chaos_monkey_participants_total
av_chaos_monkey_packets_sent_total
av_chaos_monkey_bytes_sent_total
av_chaos_monkey_spikes_active
av_chaos_monkey_packet_loss_percent
av_chaos_monkey_jitter_ms

Grafana 仪表盘

root@kitploit:~
# Docker 模式:启动监控栈
docker-compose --profile monitoring up

# Kubernetes 模式:部署监控
kubectl apply -f k8s/monitoring/prometheus-rbac.yaml
kubectl apply -f k8s/monitoring/prometheus.yaml
kubectl apply -f k8s/monitoring/grafana.yaml

# 访问 Grafana
# Docker:http://localhost:3000
# Kubernetes:http://localhost:30030(NodePort)
# 默认凭据:admin/admin

# 访问 Prometheus
# Docker:http://localhost:9091
# Kubernetes:http://localhost:30090(NodePort)

Kubernetes 自动发现:

  • 编排器 Pod 带有注解 prometheus.io/scrape: "true"
  • Prometheus 每 5 秒从所有 Pod 抓取 /metrics
  • Grafana 预配置了 Prometheus 数据源
  • 仪表盘在启动时自动部署

实时统计

root@kitploit:~
# 获取测试指标
curl http://localhost:8080/api/v1/test/{test_id}/metrics | jq

# 输出
{
  "aggregate": {
    "total_frames_sent": 45000,
    "total_packets_sent": 180000,
    "total_bitrate_kbps": 250000,
    "avg_jitter_ms": 12.5,
    "avg_packet_loss": 2.3,
    "avg_mos_score": 4.1
  }
}

故障排除

未收到 UDP 数据包

root@kitploit:~
# 检查 UDP 目标配置
kubectl logs orchestrator-0 | grep "UDP transmission enabled"

# 验证 UDP 中继是否运行
kubectl get pod udp-relay

# 检查端口转发
ps aux | grep "kubectl port-forward"

# 测试 UDP 连通性
nc -u -z localhost 5002

WebRTC 连接失败

root@kitploit:~
# 检查 TURN 服务器
kubectl get svc coturn-lb

# 验证 ICE 候选
kubectl logs orchestrator-0 | grep "ICE"

# 测试 TURN 连通性
turnutils_uclient -v -u webrtc -w webrtc123 <turn-server>:3478

高内存使用

root@kitploit:~
# 检查每个 Pod 的参与者数量
kubectl exec orchestrator-0 -- curl -s http://localhost:8080/api/v1/test/{test_id}/metrics | jq '.participants | length'

# 减少参与者数量或增加 Pod 数量
go run tools/k8s-start/main.go -replicas 10 -participants 1000

# 增加 Docker 内存(Docker Desktop)
# 设置 → 资源 → 内存 → 16GB

UDP 接收器中的丢包

单个 UDP 套接字无法处理 3000+ 并发流而不导致内核缓冲区溢出。解决方案:

  • 使用 UDP 中继(在转发前聚合)
  • 增加套接字缓冲区:setsockopt(SO_RCVBUF, 8MB)
  • 将基线丢包视为测量误差

许可证

BSD 3-Clause License

贡献

欢迎贡献!关键领域:

  • 额外的尖峰类型(CPU 限制、内存压力)
  • 更多分布策略(波浪、突发)
  • 增强指标(MOS 计算、RTCP 反馈)
  • 客户端库(Python、Rust、TypeScript)

参考

  • RFC 3550 - RTP:实时应用传输协议
  • RFC 6184 - H.264 视频的 RTP 负载格式
  • RFC 7587 - Opus 的 RTP 负载格式
  • WebRTC 规范
下载工具