1 概要

本文主要是讲 AI 时代下的红队安全工具的开发,以及如何把安全工具接到大语言模型里。涉及到 MCP 客户端的结合,分布式的 MSF 的命令的执行,如何独立的 session 管理,代码优化的思路及调试等内容。以红队安全工具开发的细节处理为初始点,让初学者也能玩转 MCP。

2 前言

因为现在的写代码的过程和两三年前由很大不同,此前,我们要实现某个功能,或者说研究一些后渗透免杀相关的知识,我们可能是手动地去抄一些代码,然后根据自己的一些理解,然后再去做一些修改拼接。但是现在有了 AI 之后,我觉得学习的重点可能要稍微地调整一下,至少在红队做一些工具的开发时,这个思路是应该要和以前有一些不同。


我们首先要理解一些基础的概念,而不是纠结具体的代码的具体语法。假设你是 BYPASS UAC,比如说你是要通过复制 TOKEN ,还是说是借助 com 接口的方式,那么这些基础的概念得理解。比如说 com 接口是什么东西,你首先你得知道它有这么个东西能实现这样一个绕过 UAC,或者说你知道 UAC 本身它是个什么东西,比如说绕过了 UAC 能对你产生什么样的好处,这些最基础的概念现在是学安全中,反而是一个重点知识内容,至于代码技术细节也好,我个人感觉现在都可以交给 AI 去做了。

3 初识 AI 开发的基础案例:Shellcode加载器

3.1 细节

来一个简单一点的,编写一个 shellcode 加载器,首先 shellcode 加载器是什么,是你需要提前学习的基本概念,也就是说 AI 编程并不能够让你实现一个从 0 到 1 。
1、AI 核心作用是帮你补充你不知道的细节。你只能说你提前你自己知道这个东西能从 0 到1,但是其中有一些细节你可能不太清楚,就比如我忘记了 go 语言调用 Windows 的什么 API 的语法,然后或者说需要库的加载器细节,那么这个时候我就需要去问一下 AI 他这边具体怎么去写。
2、那么我们首先来让他先帮我们写一个 shellcode,我们说 shellcode 加载器,它总共分为两个部分,一个是 shellcode,一个是加载器。如果说你在我之前的学习你自己去学,你下来自学的时候,你认为 shellcode 加载器它是一个整体的话,那么这就是你概念上的认知偏差。那么这时候你让 AI 直接生成出来一个 shellcode 的加载器,会导致生成的代码出现很多小错误。

3.2 提问

提问: 1、帮我生成一段二进制的字节码在 main.go 中

过程中可以看到 AI 还用了 encoding、 binary 这些包,这似乎不是我想要的,我们改个表述,让他去使用一个原生的 BYTE 字节类型,然后或者说一些连续的二进制字符串,我只期望拿到最原始的。

提问 2、使用 golang 中原生的二进制字符串生成一段二进制的字节码在 main.go 中

第一次提问时它用了一个第三方库去实现生成二进制字节码,但是平时大家用 MSF 去生成一段 shellcode,其实应该也能够发现,就是 msfvenom 在生成一段构源的 shellcode 的时候,也能发现其最终输出的是二进制字符串形式的 shellcode。

3.3 思考

接下来的核心的是让 AI 实现把 shellcode 加载到内存中去,我们怎么去问他?假如想高效提问需要思考哪些问题
1)从技术层面看,如果说让他直接加载到内存讲道理也是可以的, go 语言应该是有相应的方法,比如说通过指针的操作,但是单纯的指针操作不会去修改内存属性,这也是个问题。那么修改内存属性我们就又得还是得去调用 Windows 的 API
2)但是即使是成功将 shellcode 加载在一个内存空间中,是否允许一段内存直接的有执行的权限?这个不管是你是学安全上还是从程序语言的代码上去理解,我个人觉得概率都是比较小的,或者说写起来比较难操作的,所以说这个时候我们还是得用到操作系统提供的一些 API (比如 Virtual protect) 这样一些东西去实现。
3)我们说 go 语言里面它肯定是有任何一个编程语言,它肯定是有支持内存的操作,这个是无可厚非,都没问题。那么这个时候我们需要提前了解的知识有哪些?也就是说 shellcode 加载进内存中,还要让它执行,也就是说我们在学习,不管是你是配学习 payload 编写,还是说学习 MSF 的一些木马生成,你这个时候都需要了解。
4)底层逻辑依赖计算机基础知识,内存它原来不是说加载进去就能够执行的,内存它是有执行属性的,内存它也是有空间的,这些是虽然说是属于计算机的基础知识,但是我觉得这个在 AI 层面,尤其是你要去问 AI,你要知道可能会产生什么问题,或者说你要知道会有什么问题的时候,你得提前去学习这些基础知识。

​

接下来让他使用 Windows 的 API,把这部分二进制切片写进去。

3.4 提问

提问 3、帮我使用 Windows 的 API 将 main.go 加载进一个新的可读、可写、可执行的内存中,并且启动一个线程去执行它

package main

import (
    "fmt"
    "syscall"
    "unsafe"
)

func main() {
    // 定义有效的 x64 汇编机器代码
    bytecode := []byte{
        0x48, 0x31, 0xC0, // xor rax, rax
        0x48, 0xFF, 0xC0, // inc rax
        0xC3, // ret
    }

    fmt.Println("Step 1: 定义字节码完成")

    // 获取 kernel32.dll 的句柄
    kernel32 := syscall.NewLazyDLL("kernel32.dll")
    virtualAlloc := kernel32.NewProc("VirtualAlloc")
    createThread := kernel32.NewProc("CreateThread")
    waitForSingleObject := kernel32.NewProc("WaitForSingleObject")

    fmt.Println("Step 2: 加载 Windows API 函数完成")

    // 分配可读、可写、可执行的内存
    addr, _, err := virtualAlloc.Call(0, uintptr(len(bytecode)), 0x3000, 0x40)
    if addr == 0 {
        panic("VirtualAlloc failed: " + err.Error())
    }
    fmt.Printf("Step 3: 分配内存完成,地址: 0x%x\n", addr)

    // 将字节码拷贝到分配的内存中
    mem := (*[1 << 30]byte)(unsafe.Pointer(addr))[:len(bytecode):len(bytecode)]
    copy(mem, bytecode)
    fmt.Println("Step 4: 拷贝字节码到内存完成")

    // 创建线程执行字节码
    thread, _, err := createThread.Call(0, 0, addr, 0, 0, 0)
    if thread == 0 {
        panic("CreateThread failed: " + err.Error())
    }
    fmt.Printf("Step 5: 创建线程完成,线程句柄: 0x%x\n", thread)

    // 等待线程执行完成
    _, _, _ = waitForSingleObject.Call(thread, 0xFFFFFFFF)
    fmt.Println("Step 6: 线程执行完成")
}

可以看到,它在进程内存中分配一块具有读写执行权限的内存区域,将一段 x64 汇编字节码写入该内存,然后创建新线程执行这段字节码,最后等待线程执行完毕。本质上是模拟了 “Shellcode 加载执行” 的核心逻辑。基础的周期是可以做到的,例如调用库,创建线程再等待执行。

4 宏观方向:锚定核心概念与机制细节

提问的内容,就是我们对 shellcode 加载器的宏观原理的掌控,也就说要详细地去学习一些安全理论上的一些知识,或者说一些安全的上的一些宏观的结构,不然可能就不知道怎么去问 AI,比如说我就知道 shellcode 加载器基本的执行过程就是把内容放在一个内存,并启动一个线程去执行它,这样就实现一个加载器。这样完全就可以获取一个可运行的初始版本了。
需求的核心是“把内容写入内存并执行就可以了”,执行方式与内存规划存在多种方案,比如修改原有二进制数据属性无需新内存,也可通过进程注入、APC、启动线程/进程等方式实现,只需要把这些宏观的概念搞清楚就行,然后比如说这些细节上的代码,你可能就不是那么需要的去做了。

4.1 Windows API 是核心

如果说你涉及到 Windows 操作系统的后渗透提权、免杀操作时,Windows API 是核心。比如说得知道它可以实现注册表操作、内存进程管理,还是窗口控制等功能,开发时只需知道 API 能实现的功能,就能生成对应代码,多数编程语言都是通用的,与具体语法是无关的。

4.2 代码检查与AI进阶辅助

然后至于说代码检查,如今是完全可以自动完成语法检查,也可以自动运行。AI 给我生成了一个入门级的代码,从权限上看,这段代码直接用0x40(可读可写可执行),这样内存一分配就有执行权限是容易被杀毒软件检测的。从内存操作方式上看,它替代了 C 语言的memcpy或手动 for 循环,但从线程执行逻辑上看是完整实现了核心流程。
生成的代码其实并不重要,重要的是这个案例的过程中,想一想我们接触到的哪些构语言相关的东西?比如我只要知道有 Windows API 的函数就行,这和 go 语言是没什么关系的,其他编程语言它也都是这样写,那么我只要看懂赋值关系基本就能读懂代码。
所以从代码层面,是红队开发也好,还是说安全工具的一些开发也好,实际上对你的代码上的要求并不是很高,或者说那你只需要知道最基础的就行,只要知道宏观原理,就可以让 AI 帮你去写了。

4.3 利用机制细节才是核心竞争力

提问的重点是什么,比如涉及到的概念,比如说我要知道什么叫做 Windows api,我要知道有这个东西可以可以操作内存,会申请一个新的内存,还有属性这些特别小的机制上的细节,这种机制上的细节是非常重要的。比如说假设我这个 AI 它比较笨,我提问的时候少了某些要点,它可能就直接把它放到一个不能够执行的一段内存中去,然后去执行它,这个时候它肯定会报错的。常见的错误码5,无执行权限,那么这个时候你就得知道这个需要库的加载器,内存是有权限机制上的小细节。
利用训练集的机制,生成更完善的代码。比如说我要写一个 go 语言的提权小工具,我得知道可以把 winlogon 这类高权限进程的 TOKEN,然后通过构造进程结构体并挂载这个 TOKEN,就能创建出 SYSTEM 权限的 cmd 。因为有些 AI 在学习的时候是在网上去收集的别人写的一些文章去做的训练,最终形成这样一个大语言模型,训练的数据源于公开内容,可能别人写的文章他就没有去讲这些小细节,但是你自己又需要知道,不然就会报各种各样的错误,或者说报各种各样的问题,这个时候其实就是什么你的经验理解,或者说你对于机制上细节的把握能不能够做到这么细,我如果了解核心原理,生成出来的东西我提前预判了,它也可能会有什么些什么一些错误,但我先给它限制条件搞定,这样的话 AI 会按照你的限制条件一步一步写下去,就能让 AI 直接生成更精准的代码。

接下来就完全依靠 AI 开发一个后渗透阶段能用的工具,以 MCP 结合 Metasploit 为例。

5 进阶开发案例:MCP 结合 Metasploit 的代码实现

把安全工具接到大语言模型里,比如在 vscode 的 CLINE 里实现控制 MSF,这样我仅需在对话框说我想要执行的操作,AI 则会自动化进行命令的操作。使用者不需要去记住那些命令和参数的细节,即使你是一个小白,你只需要有一个思路,然后告诉大语言模型,让大语言模型来帮助你自动化输入命令,就达到了我们的目的。
我的操作端:物理机的 vscode 远程连接,代码保存端与运行端:Kali 的 vscode,用物理机远程开发运行命令也会发布 kali 执行,结果可以回显到本地 vscode。

初始版本

优化后的完整项目代码已在 gitee msf-mcp: metasploit与mcp结合的服务端
1、main.py
初始的版本只有
run_command()函数

from pymetasploit3.msfrpc import MsfRpcClient
from mcp.server.fastmcp import FastMCP
# Initialize FastMCP server
mcp = FastMCP("Mytest")

client = MsfRpcClient('123',port=55552)

#client.console.console('2').destory
@mcp.tool()
def run_command(cmd: str) -> str:
    """
    这是渗透测试工具metasploitframework的交互式命令行

    Args:
        cmd: 运行metasploitframework命令的内容,确保内容是一次性就能达到效果的。
        
    return:
        返回命令执行结果
    """
    cid = client.consoles.console().cid
    # Write to console
    client.consoles.console(cid).write(cmd)
    while True:
        if not client.consoles.console(cid).is_busy():
            break

    readcontent = client.consoles.console(cid).read()
    client.consoles.console(cid).destroy
    return readcontent
    
if __name__ == "__main__":
    # Initialize and run the server
    mcp.run(transport='stdio')

client = MsfRpcClient('123',port=55552) ,密码123,连接的参数返回到对象 client。MSF 的机制是 RPC 服务默认是绑定在 127.0.0.1 上的 55552 端口,而不是 0.0.0.0(所有网卡),意味着只有 Kali 本机(127.0.0.1)能访问 55552 端口的 RPC 服务。即使我想把 RPC 绑定到 0.0.0.0(允许远程连接),测试后发现也是有问题的,所以这里用 MsfRpcClient()来实现。
@mcp.tool() 就是把一个 Python 中的一个函数注册成一个工具,方便大语言模型去做一个调用
client.consoles.console(cid).write(cmd) 传入参数 cmd 的值就相当于 MSF 控制台内执行的命令
mcp.run(transport='stdio') 最后再使用 stdio 模式把整个文件当做一个完整的代码去运行,而不是一个服务器。

run_command()函数构建了一个基础的模型框架
其次为了解决 console 会话管理机制的问题,增加了函数
run_command_oneline()、destroy_console_bycid() 、generate_console_bycid(),在模型优化思路部分会展开说明

从零部署此项目的步骤

1、在 msf 控制台,通过加载插件 msgrpc 的方式,启动 GRPC 的连接。这里生成的 MCP 远程客户端名称是 127.0.0.1:55552

┌──(root㉿kali)-[~]
└─# msfconsole
msf6 > load -l                    
msf6 > load msgrpc Pass=123
[*] MSGRPC Service:  127.0.0.1:55552
[*] MSGRPC Username: msf
[*] MSGRPC Password: 123
[*] Successfully loaded plugin: msgrpc

2、kali 安装 vscode 编辑器,安装插件 Cline

3、配置 cline_mcp_settings.json 文件

{
  "mcpServers": {
    "Mytest":{
      "command": "/root/.local/bin/uv",       # 用绝对路径
      "args": [
                "--directory",
                "/root/msftest/msf_mcp",
                "run",
                "main.py"
            ]
    }
  }
}

4、配置好大语言模型 Cline 的 api 和 approve 值设置就行

5、kali 安装 UV 工具
UV 工具和 pip 类似,但具备环境隔离能力,克隆指定代码后会自动配置环境和依赖

curl -LsSf https://astral.sh/uv/install.sh | sh
uv help       #出现帮助列表则安装成功

克隆 metasploit 与 mcp 结合的服务端代码

git clone https://gitee.com/cutecuteyu/msf-mcp.git

自动配置环境和两个依赖 (mcp 和 pymetasploit3)

uv sync

模型的测试1

假如我是一个做渗透测试的一个初学者,现在我想让 MSF 去设做生成一个监听器,但是我不太清楚命令具体怎么去做,但是我知道大概监听是怎么去做的?

提问:帮我生成一个 64 位的 windows 的 meterpreter 的反向监听器,要求是 stageless 版本,ip地址 0.0.0.0,端口号使用 4444


这里手动中断了程序的执行,并提供一个正确的引导给 AI,可以看到调用了代码中的
run_command() 函数,待执行的 cmd 命令为 use exploit/multi/handler,点击 Approve 按钮确认执行该命令

结果显示执行成功,并且 AI 引导我做下一步执行设置 payload 的操作,点击 Approve 按钮确认执行该命令


而后 AI 提示成功启动了监听,并结束了这段对话

从结果看,AI 虽然成功传入 cmd 执行了正确的监听器代码,但是手工查看 jobs 列表却为空 ,这是第一个问题。

模型的优化思路及解决方案

我们回头思考主要问题出现在哪里,因为在初始代码里,每一次调用函数,都会重新生成 cid,调用完成后立即 console 的一个会话销毁。初始函数设计为,从一次性执行,到读取结果搭配,最后销毁会话的闭环,没有保留会话状态。那就会涉及到会话的管理上的一点小问题。
下图为初始版本的函数
run_command(cmd: str)

思路1

如何优化,第一个思路,不改代码,把生成监听的所有命令统一放到一个 cmd 里执行,msf 是支持把命令拼接成带 \n 的字符串的,结果确实是可以实现一个会话执行多个命令,但这并不是最佳选择。

再次手工在 msf 查看一下,创建监听器却是是成功了,但从AI对话框的结果来看,jobs 命令的结果没成功。

思路2

第二个思路,修复代码。实际结合 思路1 来看看,修复的关键在于复用会话。要实现一个完整的业务线,如果说分行执行 cmd 的话,需要把 cid 在函数外面,或者说单独做成一个独立的参数去做一个会话管理。
1、对此,增加函数
destroy_console_bycid() 、 generate_console_bycid()

就是在调用 run_command_oneline(cmd: str,cid:str) cid 之前,
在调用任何的
run_command 之前,都先调用 generate_console_bycid() 先生成一个会话 cid,然后之后的话我们就把这个 Cid 。 AI 自然知道它下一次再用的时候,它就知道这个 cid 该填什么东西,然后包括命令。
2、修改旧函数
run_command() ,新增函数 run_command_oneline()

run_command(),接收的参数还是 cmd,只不过把 cid 改成了改成了单独拿出来管理, 就是文中 模型测试1 的效果。run_command_oneline(),场景是在你确保在一行命令完成之后就不再使用该会话的,就会调用这个函数.
两函数的区别在于
run_command()在不用到该会话的时候,就把会话销毁 。那么如果说 cmd 命令是需要是一行一行的运行,run_command_oneline()就不会直接销毁会话,而是返回 cid,用完了之后再去单独调函数 destroy_console_bycid() 销毁 cid。

8 模型的测试2

提问:帮我生成一个64位的windows的meterpreter的反向监听器,要求是stageless版本,注意是msfconsole的监听,不是payload

完成引导,提供 host 和 port 信息

将要操作模块也没问题,点击 Approve 按钮确认执行该命令结果如下

自动选择了payload,点击 Approve 按钮确认执行该命令结果如下

点击 Approve 按钮确认执行该命令结果如下

结果可以看到,模型按照要求成功自动创建了一个监听器,过程中我只需手工鼠标点 approve 按钮确定执行该命令即可,那么还有无其他提升空间呢?比如说后渗透阶段提权 getshell 的功能?

9 模型的测试3

提问:当前有一个活跃的meterpreter会话(ID:1)进入到这个会话 然后尝试好似用metasploitframework console中的功能或者模块进行提权

结果是,过程中调用的 cmd 是
session -i 2 ,可成功进入 session,但提权初始阶段 AI 尝试调用命令为 getsystem,失败了,推测可能是进入 session 界面后由 msf6> 变成了 meterpreter> 的原因或者是 pymetasploit3 包的原因,也有可能是我虚拟机之间连接不稳定的原因。

想一想怎么去单独写一个会话管理相关的函数,我只要让这个大语言模型知道,只要是会话相关的内容的话,我就单独的去执行。或者说涉及到后渗透的部分都单独去执行。

10 模型的优化思路

测试后发现可通过增加函数,单独管理 session 会话,让提权阶段可操作命令。对此单独新增 session 会话处理的功能,新增了4个函数,如下

list_all_shell():结果是 session 列表,即所有 session
get_a_shell():大模型不会选择,给个提示方便让用户自己选择
write_to_shell(): 用于执行一些命令,但不支持bg命令,如果要打exp,可让模型新开一个会话实现
stop_shell():用于主动关掉当前 session

11 模型的测试4

提问:请列举出当前msf的所有获得的session

调用了 list_all_shell 函数,展示了列表,只有一个 2

调用了 get_a_shell 函数,我选择第0个,也就是session 2

调用了函数 write_to_shell ,执行了一个基础命令 sysinfo

结果是成功在 session 列表进入指定 session 执行命令,至此实现了分布式的 MSF 的一个命令的执行,也实现了独立的 session 管理。

展望

其实还可以实现更多的东西,比如 exp 的独立管理,比如结合上项目 pymetasploit3的 client.modules.use,完成 exp 的管理,同理 exploit 换成 payload 独立管理 payload。

最重点是如果要写这种 MCP,涉及到大语言模型的注释一定要写好。比如 规定流程 B函数得先用 A函数、函数用途、参数返回值和返回类型,一定要得特别详细,也就是说大语言模型它得获取这些信息来决定当前提问需要调用哪个函数。实现一个 MCP,这样的话你就可以在各种各样的 MCP 的客户端,比如 Cline、Cherry Studio、Claude Desktop 这一类客户端来实现。

结语

综合来说,红队安全工具的开发甚至接到大语言模型,都是一个打破传统攻防边界、优化红队作业模式的关键探索,更是网络安全攻防体系向智能化演进的必然方向。AI 可以让你有新的感悟,它会结合多个公开数据信息来回答你,错误的引导可能会指向新的结局,明白提问要点的核心,利用好机制细节才能做到精准开发。

​

参考文献

https://github.com/GH05TCREW/MetasploitMCP
https://xz.aliyun.com/news/18314
https://docs.metasploit.com
https://github.com/DanMcInerney/pymetasploit3/blob/master/example_usage.py

​