1. 项目概述：为什么我们需要批量转换DLL为Shellcode？

在安全研究、红队评估甚至某些特定的软件调试场景里，我们常常需要将DLL文件加载到目标进程的内存中执行。传统的LoadLibraryAPI调用虽然简单，但它在磁盘上留下了DLL文件的痕迹，并且会被绝大多数安全软件（EDR/AV）的API钩子（Hook）所监控，一抓一个准。反射型DLL注入（Reflective DLL Injection, RDI）技术应运而生，它绕过了LoadLibrary，直接在内存中解析和执行DLL，实现了“无文件”落地，隐蔽性大大提升。

而sRDI（Shellcode Reflective DLL Injection）则将这一技术推向了更实用的层面。它把整个反射加载器（Reflective Loader）和DLL本身打包成一段位置无关的Shellcode。这意味着，你得到的不是一个需要复杂注入逻辑的DLL，而是一段可以直接用各种经典Shellcode注入技术（如VirtualAllocEx + WriteProcessMemory + CreateRemoteThread）投递的二进制数据块。这对于武器化、自动化以及集成到现有工具链中来说，是质的飞跃。

但是，sRDI官方提供的Python脚本ConvertToShellcode.py一次只能处理一个DLL。在实际工作中，我们面对的往往是成批的DLL：可能是多个功能模块、不同架构（x86/x64）的版本，或者是在迭代开发中需要反复测试的多个变体。手动一个个转换，不仅效率低下，还容易出错。因此，编写一个Python脚本来自动化、批量化地完成这个转换过程，就成了一个非常实际且迫切的需求。这个脚本能让我们专注于核心的逻辑和测试，而不是重复的转换操作。

2. 核心原理深度拆解：sRDI是如何工作的？

要写好批量转换脚本，不能只当个“调包侠”，必须深入理解sRDI的核心原理。这样在脚本出错或需要定制功能时，你才知道从哪里下手。

2.1 反射型DLL注入（RDI）的精髓

传统DLL注入的核心是让目标进程调用LoadLibraryA/W，系统加载器会做一系列事情：找到文件、映射到内存、解析导入表、重定位、调用DllMain。这个过程在用户态和内核态都有清晰的日志和事件可被监控。

RDI的思路是：“既然系统能做，我自己在内存里做一遍不行吗？” 它要求DLL内部包含一个特殊的导出函数，通常叫ReflectiveLoader。这个函数就是一个迷你的PE加载器，它的工作流程可以概括为：

1. 自举定位：首先，它需要找到自己（DLL数据）在内存中的起始位置。这通常通过一些汇编技巧获取当前指令指针（如call $+5; pop ebx/rax）来实现。
2. 解析自身PE头：把自己当成一个PE文件来解析，获取各种目录表（如导入表、重定位表）的地址。
3. 分配最终内存：按照PE头中的SizeOfImage，在进程内申请具有执行权限的内存块。
4. 复制节区并重定位：将DLL的各个节（.text, .data等）复制到新申请的内存中，并应用基址重定位（如果最终加载地址与DLL编译时预设的基址不同）。
5. 解析导入表：遍历导入表，手动调用GetProcAddress（或更底层的方法）来获取所有依赖函数的地址，并填充导入地址表（IAT）。
6. 调用DllMain：最后，跳转到DLL的入口点（DllMain）执行，完成初始化。

整个过程完全在内存中完成，不依赖系统的加载器，因此避开了许多监控点。

2.2 sRDI的巧妙设计：分离加载器与载荷

原始的RDI需要修改DLL源码，加入ReflectiveLoader函数并编译。sRDI做了一个非常聪明的解耦：

1. 通用Shellcode加载器：sRDI项目中的ShellcodeRDI组件，编译后生成一段位置无关的Shellcode（ShellcodeRDI_x64.bin等）。这段Shellcode就是一个通用的反射加载器。
2. DLL作为纯数据：待注入的DLL不需要任何特殊编译，它就是一个普通的、合法的PE文件。
3. 拼接与引导：转换过程（即ConvertToShellcode函数）的核心工作是将三部分在内存中拼接：
   • Shellcode加载器：通用的反射加载逻辑。
   • 目标DLL：原始的PE字节流。
   • 加载参数：一个数据结构，包含DLL在拼接块中的偏移量、导出函数哈希等信息。
4. 引导逻辑：在拼接后的Shellcode块开头，是一小段引导代码。它的唯一职责是计算DLL数据在内存中的当前位置，然后跳转到通用Shellcode加载器的入口，并将DLL信息作为参数传递给它。

这样设计的优势极其明显：

• 无需源码：任何DLL，无论是开源项目、第三方库还是自己用msfvenom生成的，都可以直接转换。
• 加载器统一且可优化：通用的加载器可以集中精力做优化、对抗检测（如抹除PE头），而不用每个DLL都带一份。
• 输出为纯Shellcode：最终产品是一段完整的、自包含的Shellcode，兼容性极强，可以无缝集成到任何支持Shellcode注入的框架中（如Cobalt Strike、Metasploit、自定义的加载器等）。

2.3 批量转换脚本的核心任务

理解了上述原理，我们的批量脚本任务就清晰了：

1. 遍历与筛选：找到指定目录下所有需要转换的DLL文件。
2. 架构识别：自动判断DLL是32位（x86）还是64位（x64），因为需要匹配对应架构的sRDI加载器Shellcode。
3. 调用核心转换函数：对于每个DLL，调用sRDI提供的ConvertToShellcode(dll_bytes)函数，传入DLL的二进制内容。
4. 输出管理：将生成的Shellcode保存为文件，并合理命名（如原文件名.bin或原文件名_x64.bin），同时可能需要生成一个记录转换结果的清单。
5. 错误处理与日志：处理转换过程中可能出现的错误（如文件损坏、非PE文件、架构不支持等），并提供清晰的日志输出。

3. 环境准备与工具链搭建

工欲善其事，必先利其器。在开始编写脚本前，我们需要一个可工作的sRDI Python环境。

3.1 获取sRDI项目

首先，从GitHub克隆官方仓库：

git clone https://github.com/monoxgas/sRDI.git cd sRDI

注意：sRDI项目包含C#和Native C组件，但对于我们使用Python脚本进行转换来说，最关键的是Python目录下的文件。我们主要使用ShellcodeRDI.py这个模块。

3.2 Python环境配置

项目建议使用Python 3。确保你的环境已安装。关键是要安装pefile这个Python库，sRDI的脚本依赖它来解析PE文件。

pip install pefile

检查Python/ShellcodeRDI.py文件，确保它存在。这个文件包含了我们需要的核心转换函数ConvertToShellcode。

3.3 理解项目结构

对于批量脚本编写，我们需要关注以下文件：

• Python/ShellcodeRDI.py: 核心模块，包含转换逻辑。
• Python/ConvertToShellcode.py: 官方提供的单文件转换示例脚本。这是我们学习和参考的蓝本。
• bin/目录: 这里存放着编译好的、不同架构的通用加载器Shellcode（ShellcodeRDI_x64.bin,ShellcodeRDI_x86.bin）。ShellcodeRDI.py模块会自动加载它们。

3.4 验证基础功能

在写批量脚本之前，先用官方脚本测试一个DLL，确保环境一切正常。

# 切换到Python目录 cd Python # 使用项目自带的测试DLL进行转换 python ConvertToShellcode.py ../bin/TestDLL_x64.dll

如果成功，会生成一个TestDLL_x64.bin文件。你可以用hexdump或xxd简单查看一下，它的开头应该是一段机器码（Shellcode），后面跟着DLL的数据。

4. 批量转换脚本的完整实现

现在，我们开始构建自己的批量转换工具。我将分步拆解，并解释每个环节的考量。

4.1 脚本框架与参数解析

一个健壮的脚本应该支持命令行参数，方便集成到自动化流程中。我们使用Python的argparse库。

#!/usr/bin/env python3 """ sRDI Batch DLL Converter - 批量将DLL转换为sRDI Shellcode Author: Your Name """ import argparse import os import sys import logging from pathlib import Path # 将sRDI的Python目录加入模块搜索路径，确保能导入ShellcodeRDI # 假设脚本放在sRDI项目的根目录，或者同级目录下有一个`srdi`文件夹 sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'Python')) try: from ShellcodeRDI import * except ImportError as e: logging.error(f"无法导入ShellcodeRDI模块: {e}") logging.error("请确保脚本在sRDI项目目录下运行，或已正确设置Python路径。") sys.exit(1) def main(): parser = argparse.ArgumentParser(description='批量转换DLL文件为sRDI Shellcode') parser.add_argument('input', help='输入路径，可以是一个DLL文件或一个包含DLL的目录') parser.add_argument('-o', '--output-dir', default='./output', help='输出目录，转换后的.bin文件将保存在此 (默认: ./output)') parser.add_argument('-r', '--recursive', action='store_true', help='递归搜索子目录中的DLL文件') parser.add_argument('-f', '--filter', default='*.dll', help='文件过滤模式 (默认: *.dll)') parser.add_argument('-p', '--prefix', default='', help='为输出的文件名添加前缀') parser.add_argument('-s', '--suffix', default='', help='为输出的文件名添加后缀') parser.add_argument('-v', '--verbose', action='store_true', help='输出详细信息') parser.add_argument('-l', '--log', help='将日志保存到指定文件') args = parser.parse_args() # 配置日志 log_level = logging.DEBUG if args.verbose else logging.INFO logging.basicConfig( level=log_level, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[] ) if args.log: logging.getLogger().addHandler(logging.FileHandler(args.log)) # 始终输出到控制台 console_handler = logging.StreamHandler() console_handler.setLevel(log_level) logging.getLogger().addHandler(console_handler) # 创建输出目录 output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # 收集要转换的文件列表 input_path = Path(args.input) dll_files = [] if input_path.is_file(): if input_path.suffix.lower() == '.dll': dll_files.append(input_path) else: logging.error(f"输入文件 {input_path} 不是DLL文件。") sys.exit(1) elif input_path.is_dir(): pattern = '**/' + args.filter if args.recursive else args.filter dll_files = list(input_path.glob(pattern)) if not dll_files: logging.warning(f"在目录 {input_path} 中未找到匹配 {args.filter} 的DLL文件。") sys.exit(0) else: logging.error(f"输入路径 {input_path} 不存在。") sys.exit(1) logging.info(f"找到 {len(dll_files)} 个待转换的DLL文件。") # 执行批量转换 success_count = batch_convert_srdi(dll_files, output_dir, args.prefix, args.suffix) logging.info(f"批量转换完成。成功: {success_count}, 失败: {len(dll_files) - success_count}") if __name__ == '__main__': main()

关键点解析：

• 路径处理：使用pathlib.Path，它是现代Python处理文件路径的推荐方式，比os.path更直观、更面向对象。
• 模块导入：通过修改sys.path来确保能正确导入sRDI项目内的ShellcodeRDI模块。这是脚本能否运行的关键。
• 灵活的输入：支持单个文件和整个目录的输入，并通过--recursive和--filter参数提供强大的文件筛选能力。
• 日志系统：使用Python内置的logging模块，可以方便地控制输出详细程度，并支持同时输出到控制台和文件，便于调试和审计。

4.2 核心转换函数batch_convert_srdi

这是脚本的心脏，负责遍历文件列表并执行转换。

def batch_convert_srdi(dll_path_list, output_dir, prefix='', suffix=''): """ 批量转换DLL为sRDI Shellcode。 Args: dll_path_list: Path对象的列表，每个代表一个DLL文件。 output_dir: Path对象，输出目录。 prefix: 输出文件名的前缀。 suffix: 输出文件名的后缀（在扩展名之前）。 Returns: 成功转换的文件数量。 """ success_count = 0 failed_files = [] for dll_path in dll_path_list: dll_name = dll_path.stem # 不带扩展名的文件名 dll_arch = None logging.info(f"正在处理: {dll_path}") try: # 1. 读取DLL文件 with open(dll_path, 'rb') as f: dll_buffer = f.read() if not dll_buffer: raise ValueError("DLL文件为空") # 2. 调用sRDI核心函数进行转换 # ConvertToShellcode 函数会自动识别DLL架构并选用正确的加载器 shellcode = ConvertToShellcode(dll_buffer) # 3. 构造输出文件名和路径 # 可以添加架构信息到文件名，便于区分 # 我们先尝试获取架构信息（可选，但很有用） try: # 使用pefile快速解析以获取架构（注意：这里仅用于命名，sRDI内部已做判断） import pefile pe = pefile.PE(data=dll_buffer, fast_load=True) if pe.FILE_HEADER.Machine == pefile.MACHINE_TYPE['IMAGE_FILE_MACHINE_I386']: dll_arch = 'x86' elif pe.FILE_HEADER.Machine == pefile.MACHINE_TYPE['IMAGE_FILE_MACHINE_AMD64']: dll_arch = 'x64' else: dll_arch = 'unknown' pe.close() except Exception as pe_err: logging.debug(f"无法解析 {dll_name} 的PE头以获取架构: {pe_err}") dll_arch = 'unknown' arch_suffix = f'_{dll_arch}' if dll_arch != 'unknown' else '' output_filename = f"{prefix}{dll_name}{suffix}{arch_suffix}.bin" output_path = output_dir / output_filename # 4. 保存Shellcode到文件 with open(output_path, 'wb') as f: f.write(shellcode) file_size_kb = len(shellcode) / 1024.0 logging.info(f" -> 成功转换: {output_path} ({file_size_kb:.2f} KB)") success_count += 1 except Exception as e: logging.error(f" -> 转换失败: {dll_path}. 错误: {e}") failed_files.append((dll_path, str(e))) continue # 打印失败摘要 if failed_files: logging.warning("\n=== 转换失败的文件摘要 ===") for f_path, err in failed_files: logging.warning(f" {f_path}: {err}") return success_count

关键点与避坑指南：

1. 二进制读取：必须使用'rb'模式打开DLL文件，确保读取的是原始字节，避免编码问题。
2. 错误处理：每个文件的转换都用try...except包裹，防止一个文件的失败导致整个批处理任务中止。记录所有失败的文件和原因，便于后续排查。
3. 架构信息：虽然sRDI的ConvertToShellcode函数内部会自动处理架构，但我们在输出文件名里加上架构信息（如_x64）是非常好的实践。这能让你一眼看出哪个Shellcode对应哪个架构的DLL，避免在注入时搞混（将x64的Shellcode注入到x32进程会导致崩溃）。
4. 使用pefile：我们临时导入pefile来快速读取PE头的Machine字段以判断架构。注意使用fast_load=True以提高速度，并且要在try块内，因为不是所有二进制文件都是有效的PE。
5. 文件大小：记录输出文件的大小，有助于你了解转换后的Shellcode体积，对于某些有空间限制的注入场景（如通过特定漏洞利用）很有参考价值。

4.3 增强功能：校验与报告

一个专业的脚本还应该提供一些额外的信息。

def batch_convert_srdi(dll_path_list, output_dir, prefix='', suffix=''): # ... [前面的代码保持不变] ... success_count = 0 failed_files = [] conversion_report = [] # 用于生成报告 for dll_path in dll_path_list: # ... [读取文件，调用ConvertToShellcode] ... # 在成功转换后，收集报告信息 report_info = { 'input': str(dll_path), 'output': str(output_path), 'input_size': len(dll_buffer), 'output_size': len(shellcode), 'architecture': dll_arch, 'status': 'SUCCESS' } conversion_report.append(report_info) except Exception as e: logging.error(f" -> 转换失败: {dll_path}. 错误: {e}") failed_files.append((dll_path, str(e))) conversion_report.append({ 'input': str(dll_path), 'output': 'N/A', 'error': str(e), 'status': 'FAILED' }) continue # ... [打印失败摘要] ... # 生成简易的CSV格式报告 report_path = output_dir / 'conversion_report.csv' try: with open(report_path, 'w', encoding='utf-8') as f: f.write('Input File,Output File,Input Size (bytes),Output Size (bytes),Architecture,Status,Error\n') for item in conversion_report: if item['status'] == 'SUCCESS': f.write(f"{item['input']},{item['output']},{item['input_size']},{item['output_size']},{item['architecture']},SUCCESS,\n") else: f.write(f"{item['input']},N/A,N/A,N/A,N/A,FAILED,\"{item.get('error', '')}\"\n") logging.info(f"详细转换报告已保存至: {report_path}") except Exception as report_err: logging.error(f"生成报告文件失败: {report_err}") return success_count

这个报告文件对于批量处理后的结果分析非常有用，你可以快速知道哪些成功了，输入输出体积变化如何，便于管理和归档。

5. 实战应用与进阶技巧

脚本写好了，我们来聊聊怎么用它，以及一些更深层次的技巧。

5.1 基础使用示例

假设你的DLL文件存放在C:\payloads\dlls目录下，包含mimikatz_x64.dll,seatbelt_x86.dll等。

# 切换到脚本所在目录（sRDI项目根目录） python batch_srdi.py C:\payloads\dlls -o C:\payloads\shellcodes -r -v

• -r: 递归搜索子目录。
• -v: 输出详细信息。
• 转换后的.bin文件将保存在C:\payloads\shellcodes目录，并附带架构后缀。

5.2 集成到武器化框架

批量转换的产出物（.bin文件）可以很方便地集成到其他工具中。例如，在Cobalt Strike的Aggressor Script中，你可以编写一个函数来读取这些.bin文件并用于注入。

// 这是一个Aggressor Script的简化示例 sub srdi_inject { local('$bin_path $pid $arch'); $bin_path = "path/to/your/converted_payload_x64.bin"; $pid = $1; // 目标进程ID $arch = "x64"; // 必须与bin文件架构匹配！ $data = readb($bin_path); // 读取shellcode $handle = openf(>SCRIPT); writeb($handle, $data); closef($handle); // 使用Cobalt Strike内置的注入命令（这里需要根据实际调整） binject($pid, $data, $arch); }

5.3 进阶技巧：内存中直接转换与传递

有时，你可能不想生成中间文件，而是希望在Python脚本中直接转换并传递给下一个阶段（如Socket发送、进程注入等）。我们的批量脚本可以很容易地修改为返回一个包含文件名和Shellcode字节流的字典列表。

def batch_convert_to_memory(dll_path_list): """ 批量转换DLL为Shellcode，但只保存在内存中返回。 适用于管道式或API化的集成场景。 """ results = [] for dll_path in dll_path_list: try: with open(dll_path, 'rb') as f: dll_buffer = f.read() shellcode = ConvertToShellcode(dll_buffer) results.append({ 'name': dll_path.name, 'path': str(dll_path), 'shellcode': shellcode, # 注意：这里保存的是完整的bytes对象 'size': len(shellcode) }) except Exception as e: logging.error(f"转换 {dll_path} 失败: {e}") results.append({'name': dll_path.name, 'error': str(e)}) return results

5.4 注意事项与排错

1. 架构匹配是生命线：这是最容易出错的地方。x64的Shellcode只能注入到x64进程，x86的Shellcode只能注入到x86进程。用我们的脚本生成带架构后缀的文件名，并在注入前仔细核对目标进程的架构（可以用Process Explorer或tasklist /fo csv /v查看）。注入错架构会导致目标进程立刻崩溃。
2. DLL的依赖性：sRDI只负责将DLL本身加载到内存。如果这个DLL依赖其他系统DLL（如user32.dll,gdi32.dll），反射加载器会尝试解析这些导入。但是，如果DLL依赖非系统路径的、特定的第三方DLL，这些DLL必须已经存在于目标进程的内存空间或系统的DLL搜索路径中，否则加载会失败。对于武器化DLL，应尽量静态编译或仅依赖核心系统库。
3. 杀软与EDR的对抗：虽然sRDI提高了隐蔽性，但现代EDR（终端检测与响应）会监控进程内存中可疑的PE映像、未签名的代码段执行等行为。单纯的sRDI转换可能不足以绕过高级防护。通常需要结合：
   • Shellcode加密/混淆：在转换后，对生成的.bin文件进行加密或编码。
   • 加载器（Loader）的对抗：使用更隐蔽的注入技术（如进程镂空、APC注入、线程劫持）、进行直接系统调用（Syscall）以绕过用户态钩子、抹除PE头等。
   • DLL本身的免杀处理：对原始DLL进行代码混淆、加壳或使用定制化的编译选项。
4. 调试与排查：如果转换后的Shellcode注入后没有反应或导致崩溃：
   • 首先检查架构：重复第1点。
   • 使用测试DLL：先用sRDI项目自带的TestDLL_x64.dll进行转换和注入测试。它能弹出一个简单的消息框。如果测试DLL工作，说明你的sRDI环境和注入器是好的，问题出在你的DLL上。
   • 查看DLL的导出函数：使用dumpbin /exports your.dll命令，确保DLL有导出函数（特别是如果你打算通过sRDI调用特定导出函数）。有些DLL可能只是运行时库，没有显式导出。
   • 在DllMain中简化逻辑：你的DLL可能在DllMain中执行了复杂的、依赖特定环境的初始化代码，这在反射加载时可能失败。尝试注释掉DllMain中的所有代码，只留一个return TRUE;，看是否能成功加载。

6. 脚本优化与扩展思路

基础的批量转换已经完成，但我们可以让它更强大。

6.1 并行处理加速

当需要转换的DLL数量非常多时，可以使用Python的concurrent.futures模块进行并行处理，充分利用多核CPU。

from concurrent.futures import ThreadPoolExecutor, as_completed def convert_single_dll(dll_path, output_dir, prefix, suffix): """包装单个DLL的转换逻辑，供线程池调用""" # 这里包含之前try块内的所有转换和保存逻辑 # 需要将日志记录改为线程安全的方式，或直接返回结果 # ... return (success, dll_path, output_path, error_msg) def batch_convert_parallel(dll_path_list, output_dir, prefix='', suffix='', max_workers=4): success_count = 0 with ThreadPoolExecutor(max_workers=max_workers) as executor: future_to_dll = {executor.submit(convert_single_dll, dll, output_dir, prefix, suffix): dll for dll in dll_path_list} for future in as_completed(future_to_dll): dll = future_to_dll[future] try: success, dll_path, output_path, error = future.result() if success: success_count += 1 logging.info(f"成功: {dll_path} -> {output_path}") else: logging.error(f"失败: {dll_path} - {error}") except Exception as exc: logging.error(f"{dll} 生成异常: {exc}") return success_count

注意：并行I/O（读写文件）可能受磁盘速度限制，提升有限。但对于CPU密集的PE解析和Shellcode生成部分，并行化会有明显收益。同时要注意线程安全，避免多个线程同时写同一个日志文件导致内容混乱。

6.2 集成Shellcode编码/加密

可以在转换流程中直接加入编码环节，实现“转换即加密”。

def simple_xor_encode(data, key=0xAA): """一个简单的XOR编码示例（仅用于演示，强度很低）""" return bytes([b ^ key for b in data]) def batch_convert_and_encode(dll_path_list, output_dir, encode_func=None, encode_suffix='_enc'): for dll_path in dll_path_list: # ... 读取DLL并转换得到shellcode ... if encode_func: shellcode = encode_func(shellcode) # 对shellcode进行编码 output_filename = f"{dll_path.stem}{encode_suffix}.bin" # ... 保存 ...

在实际红队操作中，你会使用更复杂的加密算法（如AES、RC4）和动态密钥。

6.3 生成C语言数组或.NET字节数组

为了方便将Shellcode嵌入到其他语言的源码中（如C/C++加载器、C#的byte[]），可以增加一个输出格式选项。

def shellcode_to_c_array(shellcode_bytes, variable_name="shellcode"): """将Shellcode字节流转换为C语言数组定义""" hex_str = ', '.join(f'0x{b:02x}' for b in shellcode_bytes) c_code = f"unsigned char {variable_name}[] = {{\n {hex_str}\n}};\n" c_code += f"unsigned int {variable_name}_len = {len(shellcode_bytes)};" return c_code def shellcode_to_csharp_array(shellcode_bytes, variable_name="shellcode"): """将Shellcode字节流转换为C#字节数组定义""" hex_str = ', '.join(f'0x{b:02x}' for b in shellcode_bytes) csharp_code = f"byte[] {variable_name} = new byte[] {{\n {hex_str}\n}};" return csharp_code

然后在批量转换循环中，除了保存.bin文件，也可以选择生成对应的.c或.cs代码片段文件。

通过以上步骤，我们不仅实现了一个功能完整的sRDI批量转换脚本，还深入理解了其背后的原理、实战中的注意事项以及可能的扩展方向。这个脚本能显著提升你在涉及反射式DLL注入场景下的工作效率，让你从重复劳动中解放出来，更专注于战术和技术的创新。记住，工具是死的，人是活的，理解原理才能灵活运用和排错。