文章总结： 本文深入分析SysWhispers4项目源码架构。该工具是第四代NT系统调用存根生成器，用于绕过EDR/AV用户态Hook，支持Windows7至1124H2及多架构。核心技术涵盖8种SSN解析方法、4种调用方式和8种规避技术。文章详细剖析项目目录结构、模块依赖、主脚本流程与参数设计，展示代码生成引擎实现逻辑，为红队和安全研究提供重要参考。 综合评分： 87 文章分类： 红队,安全工具,免杀,内网渗透,二进制安全

---

edr绕过工具 SysWhispers4 源码分析系列(三)

原创

haidragon haidragon

安全狗的自我修养

2026年3月12日 12:33 湖南

• 

  官网：http://securitytech.cc

三、SysWhispers4 项目整体结构与源码分析

本文档基于 SysWhispers4 项目完整源码，深入剖析项目架构、核心模块设计、代码生成机制以及数据流转换过程。SysWhispers4 是一个功能强大的 NT 系统调用存根生成器，代表了当前用户态绕过技术的最高水平。

1. SysWhispers4 项目介绍

1.1 项目定位与目标

SysWhispers4 是 SysWhispers 系列的第四代产品，专注于：

• 核心功能：生成 C/ASM 系统调用存根代码
• 主要用途：绕过 EDR/AV 的用户态 API Hook
• 支持范围：Windows 7 → Windows 11 24H2（包括 Server 版本）
• 架构支持：x64、x86、WoW64、ARM64
• 编译器支持：MSVC (MASM)、MinGW (GAS)、Clang

项目演进历程：

1. SysWhispers(2019)
2. └─基础 direct syscall 概念验证

4. SysWhispers2(2020)
5. └─增加Hell's Gate 动态 SSN 解析

7. SysWhispers3 (2022)
8. ├─ 支持 x86/WoW64
9. ├─ 引入间接调用和 egg 技术
10. └─ 初步的混淆功能

12. SysWhispers4 (2024-2025)
13. ├─ 8 种 SSN 解析方法
14. ├─ 4 种调用方式
15. ├─ 8 种规避技术
16. ├─ 64+ 个 NT 函数支持
17. └─ 完整的类型系统和运行时库

1.2 核心技术特性

从源码分析可见，SysWhispers4 的核心技术包括：

SSN 解析方法（8 种）

1. # 来自 models.py - ResolutionMethod 枚举
2. classResolutionMethod(str,Enum):
3. Static="static"# 静态表（内置 j00ru 数据）
4. FreshyCalls="freshycalls"# 按地址排序（Hook 免疫）
5. HellsGate="hells_gate"# 读取 opcode（快速但怕 Hook）
6. HalosGate="halos_gate"# 邻居扫描（±8 范围）
7. TartarusGate="tartarus"# 增强版（±16 范围 + 多 Hook 检测）
8. SyscallsFromDisk="from_disk"# 从 KnownDlls 加载干净 ntdll
9. RecycledGate="recycled"# FreshyCalls + opcode 验证
10. HWBreakpoint="hw_breakpoint"# 硬件断点 + VEH

调用方法（4 种）

1. # 来自 models.py - InvocationMethod 枚举
2. classInvocationMethod(str,Enum):
3. Embedded="embedded"# 直接 syscall（最快）
4. Indirect="indirect"# jmp gadget（RIP 在 ntdll）
5. Randomized="randomized"# 随机 gadget（反 RIP 追踪）
6. Egg="egg"# egg marker（无静态特征）

规避技术（8 种）

1. # 来自 models.py - GeneratorConfig
2. @dataclass
3. classGeneratorConfig:
4. obfuscate:      bool =False# 混淆函数名 + 乱序
5. encrypt_ssn:    bool =False# XOR 加密 SSN
6. stack_spoof:    bool =False# 伪造调用栈
7. etw_bypass:     bool =False# ETW 补丁
8. amsi_bypass:    bool =False# AMSI 补丁
9. unhook_ntdll:   bool =False# ntdll 重映射
10. anti_debug:     bool =False# 反调试检查
11. sleep_encrypt:  bool =False# 睡眠加密

1.3 使用场景

红队行动：

1. # 最大规避模式
2. python syswhispers.py --preset stealth \
3. --method randomized --resolve recycled \
4. --obfuscate --encrypt-ssn --stack-spoof \
5. --etw-bypass --amsi-bypass --unhook-ntdll \
6. --anti-debug --sleep-encrypt

安全研究：

1. # 学习模式 - 生成常见函数
2. python syswhispers.py --preset common\
3. --method embedded --resolve freshycalls

生产环境测试：

1. # 兼容性测试
2. python syswhispers.py --preset all \
3. --arch x64 --compiler msvc

2. 项目目录结构分析

2.1 完整目录树

1. SysWhispers4/
2. ├── syswhispers.py              # 主入口脚本（CLI 解析 + 流程控制）
3. ├── README.md                   # 项目文档
4. ├──.gitignore                  # Git 忽略规则
5. │
6. ├── core/# 核心模块包
7. │├── __init__.py            # 包初始化
8. │├── models.py              # 数据模型定义（134 行）
9. │├── generator.py           # 代码生成引擎（2341 行）
10. │├── obfuscator.py          # 混淆工具类（155 行）
11. │├── utils.py               # 通用工具函数（129 行）
12. │└── generator.py.bak       # 备份文件
13. │
14. ├── data/# 数据文件目录
15. │├── prototypes.json       # 函数原型定义（614 行）
16. │├── presets.json          # 函数预设组合（219 行）
17. │├── syscalls_nt_x64.json  # x64 SSN 表（16024 行）
18. │└── syscalls_nt_x86.json  # x86 SSN 表
19. │
20. ├── scripts/# 辅助脚本
21. │└── update_syscall_table.py # SSN 表更新工具
22. │
23. ├── examples/# 示例代码
24. │└── example_injection.c    # 注入示例
25. │
26. └── output/# 生成输出（运行时创建）
27. ├── SW4Syscalls_Types.h    # 类型定义头文件
28. ├── SW4Syscalls.h          # 函数声明头文件
29. ├── SW4Syscalls.c          # 运行时实现
30. └── SW4Syscalls.asm# MASM 汇编存根

2.2 模块依赖关系图

1. syswhispers.py (主入口)
2. │
3. ├─→ core.models          # 数据模型
4. │├─Architecture# 架构枚举
5. │├─Compiler# 编译器枚举
6. │├─InvocationMethod# 调用方式枚举
7. │├─ResolutionMethod# 解析方法枚举
8. │├─SyscallParam# 参数数据类
9. │├─SyscallPrototype# 函数原型数据类
10. │└─GeneratorConfig# 生成配置数据类
11. │
12. ├─→ core.generator        # 代码生成器
13. │├─SysWhispers4类# 主生成引擎
14. ││├─ _load_data()# 加载数据
15. ││├─ generate()# 执行生成
16. ││├─ _gen_types_header()# 生成类型头文件
17. ││├─ _gen_syscalls_header()# 生成声明头文件
18. ││├─ _gen_syscalls_c()# 生成 C 源文件
19. ││└─ _gen_asm_msvc()# 生成汇编存根
20. ││
21. │└─辅助方法
22. │├─ _c_freshycalls()# FreshyCalls 实现
23. │├─ _c_hellsgate()# Hell's Gate 实现
24. │├─ _c_halosgate()# Halo's Gate 实现
25. │├─ _c_tartarusgate()# Tartarus'Gate 实现
26. │├─ _c_egg_hatcher()# Egg 孵化逻辑
27. │└─...(50+个生成方法)
28. │
29. ├─→ core.obfuscator       # 混淆工具
30. │├─Obfuscator类
31. ││├─ random_prefix()# 随机前缀
32. ││├─ shuffle_functions()# 打乱函数顺序
33. ││├─ generate_xor_key()# 生成 XOR 密钥
34. ││├─ junk_nops()# 垃圾指令
35. ││└─ generate_egg()# 生成 egg 标记
36. ││
37. │└─加密/解密工具
38. │├─ xor_ssn()# SSN 加密
39. │└─ encrypt_string_c()# 字符串加密
40. │
41. ├─→ core.utils           # 工具函数
42. │├─ load_json()# JSON 加载
43. │├─ load_prototypes()# 加载函数原型
44. │├─ load_presets()# 加载预设
45. │├─ load_ssn_table_x64()# 加载 x64 SSN 表
46. │├─ load_ssn_table_x86()# 加载 x86 SSN 表
47. │├─ djb2_hash()# DJB2 哈希
48. │├─ ror13_hash()# ROR-13 哈希
49. │├─ crc32_hash()# CRC32 哈希
50. │├─ fnv1a_hash()# FNV-1a 哈希
51. │└─ banner()# 启动横幅
52. │
53. └─→ data/*.json          # 数据文件
54. ├─ prototypes.json             # 64 个函数原型
55. ├─ presets.json                # 7 个预设配置
56. ├─ syscalls_nt_x64.json        # x64 SSN 数据库
57. └─ syscalls_nt_x86.json        # x86 SSN 数据库

2.3 文件大小统计

| 文件 | 行数 | 大小 | 作用 | | — | — | — | — | | generator.py | 2341 | ~80KB | 代码生成核心逻辑 | | syswhispers.py | 422 | ~16KB | CLI 入口 + 流程控制 | | syscalls_nt_x64.json | 16024 | ~500KB | SSN 数据库 | | prototypes.json | 614 | ~25KB | 函数签名定义 | | models.py | 134 | ~5KB | 数据模型定义 | | obfuscator.py | 155 | ~6KB | 混淆加密工具 | | utils.py | 129 | ~5KB | 通用工具函数 | | presets.json | 219 | ~8KB | 函数组合预设 |

总计：约 20,000 行代码 + 数据

3. 主脚本 syswhispers.py 结构分析

3.1 整体架构

1. syswhispers.py 结构
2. ├──文档字符串（40行）# 使用说明 + 技术特性
3. ├──导入模块（15行）# Python 标准库 + 自定义模块
4. ├── CLI 辅助函数（3个）# 参数处理 + 验证
5. ├── build_parser()# 构建 argparse 解析器
6. ├── main()# 主流程控制
7. └── __main__ 入口# 程序启动点

3.2 详细代码流程

步骤 1：参数解析器构建

1. # syswhispers.py 第 108-200 行
2. def build_parser()-> argparse.ArgumentParser:
3. p = argparse.ArgumentParser(
4. prog="syswhispers.py",
5. description="SysWhispers4 -- NT syscall stub generator with advanced EDR evasion",
6. formatter_class=argparse.RawDescriptionHelpFormatter,
7. epilog="""..."""# 详细的使用说明
8. )

10. # 1. 函数选择参数组
11. sel = p.add_argument_group("Function selection")
12. sel.add_argument("-p","--preset",...)# 预设选择
13. sel.add_argument("-f","--functions",...)# 自定义函数列表

15. # 2. 架构/编译器参数组
16. tgt = p.add_argument_group("Target")
17. tgt.add_argument("-a","--arch",...)# x64/x86/arm64
18. tgt.add_argument("-c","--compiler",...)# msvc/mingw/clang

20. # 3. 技术参数组
21. tech = p.add_argument_group("Techniques")
22. tech.add_argument("-m","--method",...)# embedded/indirect/randomized/egg
23. tech.add_argument("-r","--resolve",...)# 8 种 SSN 解析方法

25. # 4. 规避选项参数组
26. eva = p.add_argument_group("Evasion / obfuscation")
27. eva.add_argument("--obfuscate",...)# 混淆
28. eva.add_argument("--encrypt-ssn",...)# SSN 加密
29. eva.add_argument("--stack-spoof",...)# 栈伪造
30. eva.add_argument("--etw-bypass",...)# ETW 绕过
31. eva.add_argument("--amsi-bypass",...)# AMSI 绕过
32. eva.add_argument("--unhook-ntdll",...)# ntdll 解钩
33. eva.add_argument("--anti-debug",...)# 反调试
34. eva.add_argument("--sleep-encrypt",...)# 睡眠加密

36. # 5. 输出选项
37. out = p.add_argument_group("Output")
38. out.add_argument("--prefix",...)# 符号前缀
39. out.add_argument("-o","--out-file",...)# 输出文件名
40. out.add_argument("--out-dir",...)# 输出目录

42. return p

参数分组设计优点：

• 逻辑清晰：相关参数归类到同一组
• 易于扩展：新增功能只需添加对应参数组
• 用户友好： --help 显示结构化信息

步骤 2：主流程控制

1. # syswhispers.py 第 280-420 行
2. def main()->None:
3. _print_banner()# 打印启动横幅
4. parser = build_parser()# 构建参数解析器
5. args = parser.parse_args()# 解析命令行参数

7. # ---- 特殊命令处理 ----
8. if args.list_functions:
9. # 列出所有支持的函数
10. proto = load_prototypes()
11. for name in sorted(proto):
12. print(f"  {name}")
13. return

15. if args.list_presets:
16. # 列出所有预设
17. presets = load_presets()
18. for name, data in presets.items():
19. print(f"  {name}: {data['description']}")
20. return

22. # ---- 输入验证 ----
23. ifnot args.preset andnot args.functions:
24. parser.error("Specify at least --preset or --functions.")

26. functions = _resolve_functions(args)# 展开预设 + 自定义函数
27. _validate_functions(functions)# 验证函数名有效性

29. # ---- 警告提示 ----
30. if args.resolve ==ResolutionMethod.Static:
31. print("  [i] Static resolution: using table from ...")

33. if args.etw_bypass:
34. print("  [!] ETW bypass enabled -- for authorized use only.\n")
35. # ... 其他警告

37. # ---- 构建配置对象 ----
38. prefix_clean = args.prefix.rstrip("_")
39. out_file = args.out_file if args.out_file isnotNoneelse f"{prefix_clean}Syscalls"

41. cfg =GeneratorConfig(
42. functions       = functions,
43. arch            =Architecture(args.arch),
44. compiler        =Compiler(args.compiler),
45. method          =InvocationMethod(args.method),
46. resolve         =ResolutionMethod(args.resolve),
47. prefix          = prefix_clean +"_",
48. out_file        = out_file,
49. out_dir         = args.out_dir,
50. obfuscate      = args.obfuscate,
51. encrypt_ssn     = args.encrypt_ssn,
52. stack_spoof     = args.stack_spoof,
53. etw_bypass      = args.etw_bypass,
54. amsi_bypass     = args.amsi_bypass,
55. unhook_ntdll    = args.unhook_ntdll,
56. anti_debug      = args.anti_debug,
57. sleep_encrypt   = args.sleep_encrypt,
58. syscall_table   = args.syscall_table,
59. )

61. # ---- 打印摘要信息 ----
62. print(f"  Functions  : {len(functions)}")
63. print(f"  Arch       : {cfg.arch}")
64. print(f"  Compiler   : {cfg.compiler}")
65. print(f"  Resolution : {cfg.resolve}")
66. print(f"  Method     : {cfg.method}")
67. if cfg.obfuscate:print("  Obfuscate : yes")
68. if cfg.encrypt_ssn:print("  Encrypt SSN: yes")
69. # ... 其他选项

71. # ---- 执行代码生成 ----
72. gen =SysWhispers4(cfg)# 创建生成器

74. try:
75. outputs = gen.generate()# 生成所有文件
76. exceptExceptionas exc:
77. print(f"[!] Generation failed: {exc}")
78. sys.exit(1)

80. gen.write_outputs(outputs)# 写入文件

82. # ---- 集成指南 ----
83. print("\n  [*] Integration guide:")
84. if cfg.compiler ==Compiler.MSVC:
85. print(f"      Add to MSVC project:")
86. print(f"        {out_base}_Types.h  {out_base}.h  {out_base}.c  {out_base}.asm")
87. else:
88. print(f"      Add to MinGW/Clang project:")
89. print(f"        {out_base}_Types.h  {out_base}.h  {out_base}.c  {out_base}_stubs.c")

91. # ---- 初始化提示 ----
92. if cfg.unhook_ntdll:
93. print(f"      Call {cfg.prefix}UnhookNtdll() BEFORE {cfg.prefix}Initialize()")
94. if cfg.etw_bypass:
95. print(f"      Optionally call {cfg.prefix}PatchEtw()")
96. # ... 其他提示

98. print("\n  [+] Done.")

主流程特点：

1. 分阶段处理：参数解析 → 验证 → 配置 → 生成 → 输出
2. 错误处理：每个阶段都有明确的错误检查和提示
3. 用户反馈：实时显示进度和警告信息
4. 集成指导：生成后提供详细的使用说明

3.3 关键函数详解

_resolve_functions() – 函数列表展开

1. # syswhispers.py 第 57-80 行
2. def _resolve_functions(args)-> list[str]:
3. """Expand preset names and/or comma-separated function lists."""
4. functions: list[str]=[]

6. # 1. 展开预设
7. if args.preset:
8. presets = load_presets()
9. for p in args.preset.split(","):
10. p = p.strip()
11. if p notin presets:
12. print(f"[!] Unknown preset '{p}'.")
13. sys.exit(1)
14. functions.extend(presets[p]["functions"])

16. # 2. 添加自定义函数
17. if args.functions:
18. for f in args.functions.split(","):
19. f = f.strip()
20. if f and f notin functions:
21. functions.append(f)

23. # 3. 去重并保持顺序
24. seen = set()
25. result =[]
26. for f in functions:
27. if f notin seen:
28. seen.add(f)
29. result.append(f)

31. return result

功能说明：

• 支持多个预设组合： --preset common,injection
• 支持预设 + 自定义混合： --preset common--functionsNtCreateThreadEx
• 自动去重并保持顺序

_validate_functions() – 函数名验证

1. # syswhispers.py 第 83-91 行
2. def _validate_functions(functions: list[str])->None:
3. known = set(load_prototypes().keys())
4. unknown =[f for f in functions if f notin known]

6. if unknown:
7. print(f"[!] Unknown function(s): {', '.join(unknown)}")
8. print(f"    Available: {', '.join(sorted(known))}")
9. sys.exit(1)

验证逻辑：

• 从 prototypes.json 加载已知函数列表
• 检查用户输入的函数名是否存在
• 提供友好的错误提示和可用函数列表

4. syscall 数据库结构分析

4.1 prototypes.json – 函数原型定义

文件结构：

1. {
2. "NtAllocateVirtualMemory":{
3. "return_type":"NTSTATUS",
4. "params":[
5. {
6. "name":"ProcessHandle",
7. "type":"HANDLE",
8. "annotation":"IN"
9. },
10. {
11. "name":"BaseAddress",
12. "type":"PVOID*",
13. "annotation":"IN OUT"
14. },
15. //...更多参数
16. ]
17. },

19. "NtCreateThreadEx":{
20. "return_type":"NTSTATUS",
21. "params":[
22. //...11个参数
23. ]
24. }

26. //...共64个函数
27. }

字段说明：

• return_type: 返回类型（通常是 NTSTATUS）
• params: 参数数组
• name: 参数名称
• type: 参数类型（C 语言类型）
• annotation: 方向注解（IN/OUT/OPTIONAL）

统计信息：

1. # 使用 utils.py 分析
2. import json

4. with open('data/prototypes.json')as f:
5. data = json.load(f)

7. print(f"总函数数：{len(data)}")# 64

9. # 按参数量统计
10. param_counts ={}
11. for func_name, func_data in data.items():
12. count = len(func_data.get('params',[]))
13. param_counts[count]= param_counts.get(count,0)+1

15. print("参数分布:")
16. for count, freq in sorted(param_counts.items()):
17. print(f"  {count}个参数：{freq}个函数")

输出结果：

1. 总函数数：64
2. 参数分布:
3. 2个参数：3个函数
4. 3个参数：5个函数
5. 4个参数：12个函数
6. 5个参数：15个函数
7. 6个参数：18个函数
8. 7个参数：7个函数
9. 8个参数：2个函数
10. 10个参数：1个函数
11. 11个参数：1个函数

4.2 presets.json – 函数组合预设

文件结构：

1. {
2. "common":{
3. "description":"Common functions for process/thread/memory operations",
4. "functions":[
5. "NtAllocateVirtualMemory",
6. "NtFreeVirtualMemory",
7. "NtWriteVirtualMemory",
8. //...25个函数
9. ]
10. },

12. "injection":{
13. "description":"Functions for process/shellcode injection",
14. "functions":[
15. "NtAllocateVirtualMemory",
16. "NtWriteVirtualMemory",
17. "NtCreateThreadEx",
18. //...20个函数
19. ]
20. },

22. //...共7个预设
23. }

预设列表：

| 预设名 | 函数数 | 用途 | | — | — | — | | common | 25 | 通用进程/线程/内存操作 | | injection | 20 | 进程注入（APC/线程/Section） | | evasion | 15 | AV/EDR 规避查询 | | token | 6 | Token 操作 | | stealth | 31 | 最大规避（injection + evasion） | | file_ops | 7 | 文件 I/O 操作 | | transaction | 7 | 事务回滚（Doppelgänging） | | all | 62 | 全部函数 |

使用示例：

1. # 单个预设
2. python syswhispers.py --preset common

4. # 多个预设组合
5. python syswhispers.py --preset injection,evasion

7. # 预设 + 自定义
8. python syswhispers.py --preset common --functions NtQueryInformationProcess

4.3 syscallsntx64.json – SSN 数据库

文件结构：

1. {
2. "_comment":"NT syscall numbers — generated by SysWhispers4/scripts/update_syscall_table.py",
3. "_source":"https://github.com/j00ru/windows-syscalls",
4. "_format":"FunctionName -> { build_key -> decimal_ssn }",

6. "_windows_builds":{
7. "xp_sp1":"Windows XP SP1",
8. "xp_sp2":"Windows XP SP2",
9. "2003_sp0":"Windows Server 2003 RTM",
10. "vista_sp0":"Windows Vista RTM",
11. "7_sp0":"Windows 7 RTM",
12. "7_sp1":"Windows 7 SP1",
13. "8.0":"Windows 8 RTM",
14. "8.1":"Windows 8.1 RTM",
15. "10240":"Windows 10 1507",
16. "10586":"Windows 10 1511",
17. //...共40个版本
18. "26100":"Windows 11 24H2",
19. "26200":"Windows 11 25H2"
20. },

22. "NtAllocateVirtualMemory":{
23. "xp_sp1":70,
24. "xp_sp2":70,
25. "vista_sp0":70,
26. "7_sp0":70,
27. "7_sp1":70,
28. "8.0":71,
29. "8.1":23,
30. "10240":24,
31. "10586":24,
32. //...
33. "22000":24,//Windows11
34. "26100":24//Windows1124H2
35. },

37. "NtCreateThreadEx":{
38. "vista_sp0":171,
39. "vista_sp1":171,
40. "7_sp0":171,
41. "7_sp1":171,
42. "8.0":172,
43. "8.1":119,
44. "10240":123,
45. //...
46. "26100":136
47. }

49. //...共400+个函数
50. }

数据特点：

1. 版本覆盖广：Windows XP → Windows 11 25H2（40+ 个版本）
2. 向后兼容：保留所有历史版本的 SSN
3. 自动更新：通过脚本从 j00ru 仓库同步

SSN 变化规律分析：

1. # 分析 SSN 稳定性
2. import json

4. with open('data/syscalls_nt_x64.json')as f:
5. data = json.load(f)

7. # 跳过元数据键
8. functions ={k: v for k, v in data.items()ifnot k.startswith('_')}

10. # 统计 SSN 变化次数
11. change_counts =[]
12. for func_name, builds in functions.items():
13. numeric_builds ={k: v for k, v in builds.items()if k.isdigit()}
14. if len(numeric_builds)>1:
15. ssns = list(numeric_builds.values())
16. changes = sum(1for i in range(len(ssns)-1)if ssns[i]!= ssns[i+1])
17. change_counts.append(changes)

19. print(f"平均每个函数 SSN 变化次数：{sum(change_counts)/len(change_counts):.2f}")
20. print(f"最大变化次数：{max(change_counts)}")

分析结果：

1. 平均每个函数 SSN 变化次数：2.3
2. 最大变化次数：8（某些频繁变动的函数）

4.4 数据加载工具 – utils.py

核心加载函数：

1. # utils.py
2. DATA_DIR =Path(__file__).parent.parent /"data"

4. def load_json(path:Path| str)->Any:
5. """通用 JSON 加载器"""
6. with open(path,"r", encoding="utf-8")as f:
7. return json.load(f)

9. def load_prototypes()-> dict:
10. """加载函数原型"""
11. return load_json(DATA_DIR /"prototypes.json")

13. def load_presets()-> dict:
14. """加载预设配置"""
15. return load_json(DATA_DIR /"presets.json")

17. def load_ssn_table_x64()-> dict:
18. """加载 x64 SSN 表"""
19. return load_json(DATA_DIR /"syscalls_nt_x64.json")

21. def load_ssn_table_x86()-> dict:
22. """加载 x86 SSN 表"""
23. path = DATA_DIR /"syscalls_nt_x86.json"
24. if path.exists():
25. return load_json(path)
26. return{}

哈希工具函数：

1. # utils.py - 用于函数名哈希查找
2. def djb2_hash(name: str)-> int:
3. """DJB2 哈希（用于运行时函数查找）"""
4. h =0x1505
5. for ch in name.encode("ascii"):
6. h&nbsp;=(((h&nbsp;<<5)+&nbsp;h)^&nbsp;ch)&0xFFFFFFFF
7. return&nbsp;h

9. def&nbsp;ror13_hash(name:&nbsp;str)->&nbsp;int:
10. """ROR-13 哈希（Metasploit 风格）"""
11. h&nbsp;=0
12. for&nbsp;ch&nbsp;in&nbsp;name.encode("ascii"):
13. h&nbsp;=(((h&nbsp;>>13)|(h&nbsp;<<19))&0xFFFFFFFF)+&nbsp;ch
14. return&nbsp;h&nbsp;&0xFFFFFFFF

16. def&nbsp;crc32_hash(name:&nbsp;str)->&nbsp;int:
17. """CRC32 哈希"""
18. crc&nbsp;=0xFFFFFFFF
19. for&nbsp;ch&nbsp;in&nbsp;name.encode("ascii"):
20. crc&nbsp;^=&nbsp;ch
21. for&nbsp;_&nbsp;in&nbsp;range(8):
22. if&nbsp;crc&nbsp;&1:
23. crc&nbsp;=(crc&nbsp;>>1)^0xEDB88320
24. else:
25. crc&nbsp;>>=1
26. return&nbsp;crc&nbsp;^0xFFFFFFFF

28. def&nbsp;fnv1a_hash(name:&nbsp;str)->&nbsp;int:
29. """FNV-1a 哈希"""
30. h&nbsp;=0x811C9DC5
31. for&nbsp;ch&nbsp;in&nbsp;name.encode("ascii"):
32. h&nbsp;=((h&nbsp;^&nbsp;ch)*0x01000193)&0xFFFFFFFF
33. return&nbsp;h

哈希算法选择：

• DJB2：默认使用（速度快、碰撞少）
• ROR-13：兼容 Metasploit/PEB Walker
• CRC32：标准校验和
• FNV-1a：另一种快速哈希

5. 模板生成机制深度剖析

5.1 代码生成器架构 – generator.py

SysWhispers4 类结构：

1. # generator.py
2. classSysWhispers4:
3. """Main code generation engine for SysWhispers4."""

5. def __init__(self, config:GeneratorConfig):
6. self.cfg = config                    # 生成配置
7. self.obf =Obfuscator(seed=...)# 混淆器
8. self._prototypes:List[...]=[]# 函数原型列表
9. self._ssn_x64: dict ={}# x64 SSN 缓存
10. self._ssn_x86: dict ={}# x86 SSN 缓存

12. def generate(self)->Dict[str, str]:
13. """生成所有输出文件"""
14. self._load_data()# 加载数据

16. outputs:Dict[str, str]={}

18. # 1. 生成类型头文件
19. types_fname = f"{cfg.out_file}_Types.h"
20. outputs[types_fname]= self._gen_types_header()

22. # 2. 生成声明头文件
23. hdr_fname = f"{cfg.out_file}.h"
24. outputs[hdr_fname]= self._gen_syscalls_header(types_fname)

26. # 3. 生成 C 源文件
27. c_fname = f"{cfg.out_file}.c"
28. outputs[c_fname]= self._gen_syscalls_c(hdr_fname)

30. # 4. 生成汇编存根
31. if cfg.compiler ==Compiler.MSVC:
32. asm_fname = f"{cfg.out_file}.asm"
33. outputs[asm_fname]= self._gen_asm_msvc()
34. else:
35. asm_fname = f"{cfg.out_file}_stubs.c"
36. outputs[asm_fname]= self._gen_asm_gas_inline()

38. return outputs

40. def write_outputs(self, outputs:Dict[str, str])->None:
41. """写入所有生成的文件"""
42. out_dir =Path(self.cfg.out_dir)
43. out_dir.mkdir(parents=True, exist_ok=True)

45. for fname, content in outputs.items():
46. fpath = out_dir / fname
47. fpath.write_text(content, encoding="utf-8")
48. print(f"  [+] Generated {fpath}")

5.2 数据加载流程

1. # generator.py 第 92-125 行
2. def _load_data(self)->None:
3. """加载并处理所有必需的数据"""

5. # 1. 加载函数原型
6. raw_proto = load_prototypes()

8. # 2. 加载 SSN 表
9. self._ssn_x64 = load_ssn_table_x64()
10. self._ssn_x86 = load_ssn_table_x86()

12. # 3. 可选：覆盖自定义 SSN 表
13. if self.cfg.syscall_table andPath(self.cfg.syscall_table).exists():
14. from.utils import load_json
15. self._ssn_x64 = load_json(self.cfg.syscall_table)

17. # 4. 构建原型对象列表
18. for fname in self.cfg.functions:
19. if fname notin raw_proto:
20. print(f"  [!] Warning: '{fname}' not found, skipping.")
21. continue

23. entry = raw_proto[fname]

25. # 解析参数
26. params =[
27. SyscallParam(
28. name=p["name"],
29. type=p["type"],
30. annotation=p.get("annotation",""),
31. )
32. for p in entry.get("params",[])
33. ]

35. # 创建原型对象
36. self._prototypes.append(
37. SyscallPrototype(
38. name=fname,
39. return_type=entry.get("return_type","NTSTATUS"),
40. params=params,
41. )
42. )

44. # 5. 可选：混淆函数顺序
45. if self.cfg.obfuscate:
46. self._prototypes =[
47. self._prototypes[i]
48. for i in self.obf.shuffle_functions(
49. list(range(len(self._prototypes)))
50. )
51. ]

数据流图：

1. JSON 数据文件
2. ↓
3. load_prototypes()→ dict[func_name:{return_type,params}]
4. load_ssn_table_x64()→ dict[func_name:{build: ssn}]
5. ↓
6. 过滤（只保留用户选择的函数）
7. ↓
8. 转换为SyscallPrototype对象
9. ↓
10. 可选：随机打乱顺序（obfuscate）
11. ↓
12. 存储到self._prototypes

5.3 类型头文件生成

1. # generator.py 第 199-300 行
2. def _gen_types_header(self)-> str:
3. """生成 SW4Syscalls_Types.h"""
4. p = self.cfg.prefix
5. guard = f"{p}SYSCALLS_TYPES_H"

7. return f"""\
8. /*
9. * {self.cfg.out_file}_Types.h -- generated by SysWhispers4
10. */
11. #pragma once
12. #ifndef {guard}
13. #define {guard}

15. #include&nbsp;<windows.h>
16. #include&nbsp;<winternl.h>

18. /* NT 宏定义 */
19. #ifndef&nbsp;NT_SUCCESS
20. # define NT_SUCCESS(Status) &nbsp;(((NTSTATUS)(Status)) >= 0)
21. #endif

23. /* 信息类枚举 */
24. typedef enum _PROCESSINFOCLASS {{
25. ProcessBasicInformation &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;= 0,
26. ProcessDebugPort &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;= 7,
27. ProcessWow64Information &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;= 26,
28. // ...
29. }} PROCESSINFOCLASS;

31. typedef enum _THREADINFOCLASS {{
32. ThreadBasicInformation &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; = 0,
33. ThreadTimes &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; = 1,
34. // ...
35. }} THREADINFOCLASS;

37. /* 结构体定义 */
38. typedef struct _PS_ATTRIBUTE {{
39. ULONG_PTR Attribute;
40. SIZE_T &nbsp; &nbsp;Size;
41. union {{
42. ULONG_PTR Value;
43. PVOID &nbsp; &nbsp; ValuePtr;
44. }};
45. PSIZE_T &nbsp;ReturnLength;
46. }} PS_ATTRIBUTE, *PPS_ATTRIBUTE;

48. // ... 更多类型定义

50. #endif&nbsp;/* {guard} */
51. """

生成的类型包括：

1. NT 宏： NT_SUCCESS, STATUS_SUCCESS 等
2. 信息类枚举： PROCESSINFOCLASS, THREADINFOCLASS 等
3. 结构体： PS_ATTRIBUTE_LIST, CLIENT_ID 等
4. 辅助类型： SSN_ENTRY, EXPORT 等内部使用的类型

5.4 声明头文件生成

1. # generator.py 第 302-400 行
2. def _gen_syscalls_header(self, types_header: str)-> str:
3. """生成 SW4Syscalls.h"""
4. p = self.cfg.prefix
5. guard = f"{p}SYSCALLS_H"

7. # 生成所有函数的原型声明
8. protos ="\n".join(
9. f"EXTERN_C {proto.c_prototype(prefix=p)}"
10. for proto in self._prototypes
11. )

13. # 根据启用的功能添加初始化函数
14. init_comment ={
15. ResolutionMethod.FreshyCalls:"FreshyCalls -- sorts ntdll Nt* exports by VA",
16. ResolutionMethod.HellsGate:"Hell's Gate  -- reads SSN from ntdll stub",
17. //...
18. }[self.cfg.resolve]

20. # 可选功能声明
21. egg_init =""
22. if self.cfg.method ==InvocationMethod.Egg:
23. egg_init = f"\nEXTERN_C BOOL {p}HatchEggs(VOID);"

25. etw_init =""
26. if self.cfg.etw_bypass:
27. etw_init = f"\nEXTERN_C BOOL {p}PatchEtw(VOID);"

29. //...其他可选功能

31. return f"""\
32. /*
33. * {self.cfg.out_file}.h -- generated by SysWhispers4
34. */
35. #pragma once
36. #ifndef {guard}
37. #define {guard}

39. #include "{types_header}"

41. #ifdef __cplusplus
42. extern "C" {{
43. #endif

45. /* 运行时初始化 */
46. EXTERN_C BOOL {p}Initialize(VOID);
47. {egg_init}{etw_init}...

49. /* 系统调用函数原型 */
50. {protos}

52. #ifdef __cplusplus
53. }}
54. #endif

56. #endif /* {guard} */
57. """

生成的内容包括：

1. 初始化函数： SW4_Initialize()
2. 可选功能函数： SW4_PatchEtw(), SW4_UnhookNtdll() 等
3. syscall 函数声明：所有选中的 NT 函数

5.5 C 源文件生成

1. # generator.py 第 402-800 行
2. def _gen_syscalls_c(self, header_file: str)-> str:
3. """生成 SW4Syscalls.c"""
4. p = self.cfg.prefix
5. n = len(self._prototypes)
6. func_names =[proto.name for proto in self._prototypes]
7. hashes =[djb2_hash(name)for name in func_names]

9. sections =[self._c_file_header(header_file)]
10. sections.append(self._c_constants(p, n, hashes, func_names))
11. sections.append(self._c_global_tables(p, n))
12. sections.append(self._c_hash_function(p))
13. sections.append(self._c_peb_ntdll(p))
14. sections.append(self._c_eat_scanner(p))

16. # 根据解析方法添加对应实现
17. if self.cfg.resolve ==ResolutionMethod.FreshyCalls:
18. sections.append(self._c_freshycalls(p, n))
19. elif self.cfg.resolve ==ResolutionMethod.HellsGate:
20. sections.append(self._c_hellsgate(p, n))
21. elif self.cfg.resolve ==ResolutionMethod.HalosGate:
22. sections.append(self._c_halosgate(p, n))
23. //...其他方法

25. # 根据调用方法添加辅助代码
26. if self.cfg.method in(InvocationMethod.Indirect,InvocationMethod.Randomized):
27. sections.append(self._c_gadget_finder(p, n))

29. if self.cfg.method ==InvocationMethod.Egg:
30. sections.append(self._c_egg_hatcher(p))

32. # 添加可选功能实现
33. if self.cfg.etw_bypass:
34. sections.append(self._c_etw_bypass(p))

36. if self.cfg.amsi_bypass:
37. sections.append(self._c_amsi_bypass(p))

39. if self.cfg.unhook_ntdll:
40. sections.append(self._c_unhook_ntdll(p))

42. if self.cfg.anti_debug:
43. sections.append(self._c_anti_debug(p))

45. if self.cfg.sleep_encrypt:
46. sections.append(self._c_sleep_encrypt(p))

48. # 最后添加 Initialize() 函数
49. sections.append(self._c_initialize(p))

51. return"\n\n".join(sections)

生成的 C 文件包含：

1. 常量定义：函数计数、哈希表、XOR 密钥等
2. 全局表：SSN 表、gadgets 池等
3. 工具函数：哈希计算、PEB 遍历、导出表扫描等
4. SSN 解析实现：根据选择的方法生成对应代码
5. 调用辅助代码：gadget 查找、egg 孵化等
6. 规避功能：ETW/AMSI 补丁、反调试等
7. 初始化函数：统一入口点

5.6 汇编存根生成

MASM 版本（x64）

1. # generator.py 第 1500-1600 行
2. def _gen_asm_msvc(self)-> str:
3. """为 MSVC/MASM 生成汇编存根"""
4. lines =[]

6. for proto in self._prototypes:
7. # 获取 SSN
8. if self.cfg.resolve ==ResolutionMethod.Static:
9. ssn = self._get_static_ssn(proto.name)
10. else:
11. ssn =0# 动态解析时占位

13. # 根据调用方法生成不同存根
14. if self.cfg.method ==InvocationMethod.Embedded:
15. lines.extend(self._gen_embedded_stub(proto, ssn))
16. elif self.cfg.method ==InvocationMethod.Indirect:
17. lines.extend(self._gen_indirect_stub(proto, ssn))
18. elif self.cfg.method ==InvocationMethod.Randomized:
19. lines.extend(self._gen_randomized_stub(proto, ssn))
20. elif self.cfg.method ==InvocationMethod.Egg:
21. lines.extend(self._gen_egg_stub(proto, ssn))

23. return"\n".join(lines)

25. def _gen_embedded_stub(self, proto, ssn):
26. """生成直接 syscall 存根"""
27. return[
28. f"{proto.name} PROC",
29. f"    mov r10, rcx",; x64 调用约定
30. f"    mov eax, 0x{ssn:X}",; SSN
31. f"    syscall",;进入内核
32. f"    ret",
33. f"{proto.name} ENDP"
34. ]

生成的 ASM 示例：

1. ; SW4Syscalls.asm
2. .code

4. NtAllocateVirtualMemory PROC
5. mov r10, rcx
6. mov eax,0x18
7. syscall
8. ret
9. NtAllocateVirtualMemory ENDP

11. NtCreateThreadEx PROC
12. mov r10, rcx
13. mov eax,0xC9
14. syscall
15. ret
16. NtCreateThreadEx ENDP

18. END

GAS 内联汇编版本（MinGW/Clang）

1. # generator.py 第 1602-1700 行
2. def _gen_asm_gas_inline(self)-> str:
3. """为 MinGW/Clang 生成 GAS 内联汇编存根"""
4. lines =[f'#include "{self.cfg.out_file}.h"']

6. for proto in self._prototypes:
7. ssn = self._get_static_ssn(proto.name)if self.cfg.resolve ==ResolutionMethod.Staticelse0

9. # 生成 C 函数包装 + 内联汇编
10. lines.append(f"\n{proto.c_signature(prefix=self.cfg.prefix)} {{")
11. lines.append(f"    __asm__ volatile (")
12. lines.append(f'        "mov $0x{ssn:X}, %%eax\\n"')
13. lines.append(f'        "mov %%rcx, %%r10\\n"')
14. lines.append(f'        "syscall\\n"')
15. lines.append(f'        : "=a"(rax)')
16. lines.append(f'        : "c"(arg1), "d"(arg2), "r8"(arg3), "r9"(arg4)')
17. lines.append(f'        : "r10", "r11", "rcx", "memory"')
18. lines.append(f"    );")
19. lines.append(f"}}")

21. return"\n".join(lines)

生成的 C 文件示例：

1. // SW4Syscalls_stubs.c
2. #include"SW4Syscalls.h"

4. NTSTATUS NTAPI SW4_NtAllocateVirtualMemory(
5. HANDLE ProcessHandle,
6. PVOID*BaseAddress,
7. ULONG_PTR ZeroBits,
8. PSIZE_T RegionSize,
9. ULONG AllocationType,
10. ULONG Protect
11. ){
12. NTSTATUS status;
13. __asm__ volatile(
14. "mov $0x18, %%eax\n"
15. "mov %%rcx, %%r10\n"
16. "syscall\n"
17. :"=a"(status)
18. :"c"(ProcessHandle),"d"(BaseAddress),"r8"(ZeroBits),"r9"(RegionSize),
19. "r"([rsp+0x28])(AllocationType),"r"([rsp+0x30])(Protect)
20. :"r10","r11","rcx","memory"
21. );
22. return status;
23. }

5.7 混淆器实现 – obfuscator.py

Obfuscator 类结构：

1. # obfuscator.py
2. classObfuscator:
3. def __init__(self, seed: int |None=None):
4. self._rng = random.Random(seed)# 可重复的随机性

6. # 1. 随机名称生成
7. def random_prefix(self, length: int =4)-> str:
8. """生成随机前缀"""
9. return"".join(...)+"_"

11. def random_name(self, base: str)-> str:
12. """生成随机函数名"""
13. suffix ="".join(...)
14. return f"_SW4_{suffix}_{base}"

16. # 2. 函数顺序打乱
17. def shuffle_functions(self, functions:List[str])->List[str]:
18. """随机打乱函数列表"""
19. shuffled = list(functions)
20. self._rng.shuffle(shuffled)
21. return shuffled

23. # 3. SSN 加密
24. def generate_xor_key(self)-> int:
25. """生成 32 位 XOR 密钥"""
26. return self._rng.randint(0x01010101,0xFEFEFEFE)

28. @staticmethod
29. def xor_ssn(ssn: int, key: int)-> int:
30. """XOR 加密单个 SSN"""
31. return ssn ^ key

33. # 4. 字符串加密
34. def generate_string_key(self)-> int:
35. """生成 8 位字符串加密密钥"""
36. return self._rng.randint(0x01,0xFE)

38. @staticmethod
39. def encrypt_string_c(s: str, key: int, var_name: str)-> str:
40. """生成加密字符串的 C 代码"""
41. encoded =[((b ^ key)&0xFF)for b in s.encode("ascii")]
42. encoded.append(key)# null terminator
43. # 返回 C 代码：加密数组 + 解密函数
44. return...

46. # 5. 垃圾指令生成
47. def junk_nops(self, count: int |None=None)-> str:
48. """生成无害的 x64 指令（MASM 语法）"""
49. ops =[
50. "nop",
51. "xchg ax, ax",
52. "lea r11, [r11]",
53. f"mov r11d, 0x{randint(0, 0xFF):02X}",
54. //...14种变体
55. ]
56. return"\n    ".join(self._rng.choices(ops, k=n))

58. # 6. Egg 值生成
59. def generate_egg(self)-> int:
60. """生成 64 位 egg 标记"""
61. whileTrue:
62. v = self._rng.randint(0x0101010101010101,0xFEFEFEFEFEFEFEFE)
63. raw = v.to_bytes(8,"little")
64. if b"\x0f\x05"notin raw:# 避免 syscall 字节序列
65. return v

混淆效果示例：

1. # 未混淆
2. NtAllocateVirtualMemory PROC
3. mov r10, rcx
4. mov eax,0x18
5. syscall
6. ret
7. NtAllocateVirtualMemory ENDP

9. # 混淆后（随机名 + 垃圾指令）
10. _SW4_X7k2_NtAllocateVirtualMemory PROC
11. push rbp
12. nop
13. xchg ax, ax
14. mov r11d,0xA3
15. pop rbp
16. mov r10, rcx
17. lea rsp,[rsp +00h]
18. mov eax,0x18
19. nop DWORD PTR [rax]
20. syscall
21. ret
22. _SW4_X7k2_NtAllocateVirtualMemory ENDP

6. 完整代码生成流程总结

6.1 从输入到输出的数据流

1. 用户输入（命令行参数）
2. ↓
3. syswhispers.py 解析
4. ├─函数选择(--preset /--functions)
5. ├─目标配置(--arch /--compiler)
6. ├─技术选择(--method /--resolve)
7. └─规避选项(--obfuscate /--encrypt-ssn /...)
8. ↓
9. GeneratorConfig对象
10. ↓
11. SysWhispers4生成器
12. ├─ _load_data()
13. │├─加载 prototypes.json →函数原型
14. │├─加载 syscalls_nt_x64.json → SSN 表
15. │└─过滤+转换→self._prototypes
16. │
17. ├─ generate()
18. │├─ _gen_types_header()→ SW4Syscalls_Types.h
19. │├─ _gen_syscalls_header()→ SW4Syscalls.h
20. │├─ _gen_syscalls_c()→ SW4Syscalls.c
21. │└─ _gen_asm_msvc()→ SW4Syscalls.asm
22. │
23. └─ write_outputs()
24. └─写入文件系统

6.2 生成文件清单

以典型命令为例：

1. python syswhispers.py --preset common\
2. --method embedded --resolve freshycalls \
3. --prefix SW4 --out-file SW4Syscalls

生成的文件：

1. SW4Syscalls_Types.h (~15KB)

• NT 类型定义
• 结构体/枚举声明
• 辅助宏

1. SW4Syscalls.h (~8KB)

• 函数原型声明（25 个）
• SW4_Initialize() 声明
• 可选功能声明

1. SW4Syscalls.c (~50KB)

• FreshyCalls 实现
• PEB 遍历代码
• 导出表扫描
• 哈希工具函数
• 初始化逻辑

1. SW4Syscalls.asm (~5KB)

• 25 个 syscall 存根
• 直接 syscall 实现

总计：~78KB 代码

6.3 编译集成

MSVC 项目集成

1. // main.cpp
2. #include"SW4Syscalls.h"

4. int main(){
5. // 1. 初始化（解析 SSN）
6. if(!SW4_Initialize()){
7. printf("Initialization failed\n");
8. return1;
9. }

11. // 2. 使用 syscall
12. PVOID base = NULL;
13. SIZE_T size =0x1000;
14. NTSTATUS status = SW4_NtAllocateVirtualMemory(
15. GetCurrentProcess(),
16. &base,
17. 0,
18. &size,
19. MEM_COMMIT,
20. PAGE_EXECUTE_READWRITE
21. );

23. if(NT_SUCCESS(status)){
24. printf("Allocated at %p\n", base);
25. }

27. return0;
28. }

编译命令：

1. cl /EHsc main.cpp SW4Syscalls.c /link SW4Syscalls.asm

MinGW 项目集成

1. g++-o main.exe main.cpp SW4Syscalls.c SW4Syscalls_stubs.c \
2. -masm=intel -Wno-unused-function

7. 架构设计亮点

7.1 模块化设计

优点：

• 高内聚：每个模块职责单一
• models.py：数据定义
• generator.py：代码生成
• obfuscator.py：混淆加密
• utils.py：工具函数
• 低耦合：模块间依赖清晰
• 通过配置对象传递参数
• 工具函数无状态
• 易扩展：新增功能只需添加对应模块
• 新 SSN 解析方法 → 添加 _c_newmethod()
• 新规避技术 → 添加对应 C 代码生成

7.2 配置驱动

GeneratorConfig 数据类：

1. @dataclass
2. classGeneratorConfig:
3. #  syscall 选择
4. functions:List[str]= field(default_factory=list)

6. # 目标选项
7. arch:Architecture=Architecture.x64
8. compiler:Compiler=Compiler.MSVC
9. method:InvocationMethod=InvocationMethod.Embedded
10. resolve:ResolutionMethod=ResolutionMethod.FreshyCalls

12. # 输出选项
13. out_file:    str ="SW4Syscalls"
14. out_dir:     str ="."
15. prefix:      str ="SW4"

17. # 规避选项
18. obfuscate:    bool =False
19. encrypt_ssn:  bool =False
20. stack_spoof:  bool =False
21. etw_bypass:   bool =False
22. amsi_bypass:  bool =False
23. unhook_ntdll: bool =False
24. anti_debug:   bool =False
25. sleep_encrypt: bool =False

27. # 内部数据
28. _prototypes:List[SyscallPrototype]= field(default_factory=list, repr=False)
29. _ssn_table:   dict = field(default_factory=dict, repr=False)

优势：

• 类型安全：所有配置项有明确类型
• 默认值：合理的默认配置
• 易序列化：可直接转为 JSON/dict
• 自文档化：配置项即文档

7.3 模板方法模式

代码生成策略：

1. def _gen_syscalls_c(self, header_file: str)-> str:
2. """模板方法 - 定义生成流程"""
3. sections =[]

5. # 固定部分（所有情况都生成）
6. sections.append(self._c_file_header(header_file))
7. sections.append(self._c_constants(p, n, hashes, func_names))
8. sections.append(self._c_global_tables(p, n))
9. sections.append(self._c_hash_function(p))
10. sections.append(self._c_peb_ntdll(p))
11. sections.append(self._c_eat_scanner(p))

13. # 可变部分（根据配置选择）
14. if self.cfg.resolve ==ResolutionMethod.FreshyCalls:
15. sections.append(self._c_freshycalls(p, n))
16. elif self.cfg.resolve ==ResolutionMethod.HellsGate:
17. sections.append(self._c_hellsgate(p, n))
18. # ...

20. # 组合所有部分
21. return"\n\n".join(sections)

优势：

• 代码复用：公共逻辑只写一次
• 灵活扩展：新增方法只需添加分支
• 维护简单：修改一处影响全局

7.4 数据与逻辑分离

数据文件（JSON）：

• prototypes.json：函数签名
• presets.json：函数组合
• syscalls_nt_x64.json：SSN 数据库

逻辑代码（Python）：

• generator.py：如何使用数据生成代码
• utils.py：如何加载和处理数据

优势：

• 易更新：SSN 表变化只需更新 JSON
• 可验证：数据文件格式规范，易校验
• 可共享：JSON 数据可被其他语言使用

---

总结

通过对 SysWhispers4 项目的完整源码分析，我们深入理解了：

架构层面

1. 模块化设计：清晰的职责划分，高内聚低耦合
2. 配置驱动：类型安全的配置对象，灵活的参数组合
3. 模板方法：复用公共逻辑，灵活扩展新功能
4. 数据分离：JSON 数据 + Python 逻辑，易维护更新

技术层面

1. 8 种 SSN 解析方法：从静态表到硬件断点，覆盖各种场景
2. 4 种调用方式：直接、间接、随机化、egg，满足不同需求
3. 8 种规避技术：ETW/AMSI 补丁、反调试、睡眠加密等
4. 多架构支持：x64/x86/ARM64，MSVC/MinGW/Clang

代码质量

1. 类型注解：完整的类型提示，便于 IDE 支持
2. 文档字符串：详细的模块和函数说明
3. 错误处理：完善的输入验证和异常捕获
4. 用户友好：清晰的错误提示和集成指南

学习价值

SysWhispers4 不仅是一个强大的安全工具，更是学习以下知识的绝佳案例：

• Windows Internals（系统调用机制）
• 代码生成技术（AST → 源代码）
• 软件架构设计（模块化、可扩展）
• 攻防对抗技术（EDR 绕过与检测）

---

参考资料：

• 项目源码： syswhispers.py, core/*.py, data/*.json

• 官方文档： README.md

• 技术参考：j00ru windows-syscalls 仓库

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

• vx:2207344074

• http://gitee.com/haidragon

• http://github.com/haidragon

• bilibili:haidragonx

• 

#

• 

---

免责声明：

本文所载程序、技术方法仅面向合法合规的安全研究与教学场景，旨在提升网络安全防护能力，具有明确的技术研究属性。

任何单位或个人未经授权，将本文内容用于攻击、破坏等非法用途的，由此引发的全部法律责任、民事赔偿及连带责任，均由行为人独立承担，本站不承担任何连带责任。

本站内容均为技术交流与知识分享目的发布，若存在版权侵权或其他异议，请通过邮件联系处理，具体联系方式可点击页面上方的联系我。

本文转载自：安全狗的自我修养 haidragon haidragon《edr绕过工具 SysWhispers4 源码分析系列(三)》