模糊测试（Fuzzing），是一种通过向目标系统提供非预期的输入并监视异常结果来发现软件漏洞的方法。
从字面上理解，模糊就是不确定，我们在遇到不确定的事情时，该怎么办呢？我们需要不断尝试可能的情况，直到最终确定下来。

我们需要关注的几个点：输入、非预期、监视异常结果、软件漏洞
模糊测试（fuzz testing）是一种安全测试方法，他介于完全的手工测试和完全的自动化测试之间。为什么是介于那两者之间？首先完全的手工测试即是渗透测试，测试人员可以模拟黑客恶意进入系统、查找漏洞，这对测试人员的要求比较高。能力强的测试人员可以发现比较多或者高质量的安全性问题，但是如果测试人员的能力不够，可能就不能找到足够多、威胁大的安全漏洞。所有渗透测试对人员能力的依赖性强，成本高，难以大规模的实施。
在模糊测试中，用随机坏数据（也称做 fuzz）攻击一个程序，然后等着观察哪里遭到了破坏。模糊测试的技巧在于，它是不符合逻辑的：自动模糊测试不去猜测哪个数据会导致破坏（就像人工测试员那样），而是将尽可能多的杂乱数据投入程序中。由这个测试验证过的失败模式通常对程序员来说是个彻底的震撼，因为任何按逻辑思考的人都不会想到这种失败。

模糊测试是一项简单的技术，但它却能揭示出程序中的重要 bug。它能够验证出现实世界中的错误模式并在您的软件发货前对潜在的应当被堵塞的攻击渠道进行提示。
输入：对于软件而言，只要你需要跟用户交互，你就需要为用户提供输入的地方，比如：输入框、按钮等，对于安全而言，用户的输入都是不可信的，因为存在用户输入的地方，那么对于用户输入的内容是不可预料的，一定会有我们考虑不全的情况存在，出现非预期的情况。
非预期：我们在设计一个功能的时候，是有预期的，比如用户评论功能，只允许用户提交 50 个字，当用户成功提交了 51 个字，那么这就是非预期的情况，我们把这种情况就叫做非预期的结果，导致这个结果的原因就是漏洞或者 bug。
监视异常结果：对于一个输入口，我们在输入各种参数进行测试时，如何知道参数是否有效，那么就需要监视参数提交的过程以及提交后产生的结果是否存在异常，这里的异常就是跟我们最初预期的结果有所不同，出现这种情况就需要我们重点关注了。
软件漏洞：这是模糊测试的最终目的，不只是软件的漏洞也可以是 bug，因为漏洞和 bug 都是软件设计之初非预期的情况。
其中输入是模糊测试关键，是模糊测试是否有效的灵魂，只有你的输入是软件设计之初未考虑到情况，是非预期的输入，那么你才能发现软件的问题所在。
在做渗透测试的时候，需要模糊测试的情况有很多，比如：遇到一个用户评论的地方，我们可以尝试用不同的 xss payload 来判断是否存在 xss 漏洞；遇到一个用户登陆的地方，我们可以尝试用不同的 sql 注入的 payload 测试是否存在 sql 注入漏洞。
模糊测试在什么时候用呢？

其实各种大型的 web 扫描器的原理也包含了模糊测试的功能，我们在对一个 web 网站做渗透测试的时候，有经验的人都不会直接用扫描器，而是先熟悉 web 网站有哪些功能，用户可以控制的参数有哪些，进行简单的手工尝试之后，如果发现有一处可能存在问题，但是由于自己尝试的 payload 不能成功验证漏洞的存在，正好，自己收集了一些同类漏洞的不同 payload 列表，将这个列表中的所有 payload 均尝试一遍，监视其产生的结果，确定该处是否存在安全漏洞。
模糊测试的过程可以是手工进行，但是手工多累，所以为了代替手工，可以写一个小脚本针对那一个指定的输入口，用指定的 payload 列表，进行尝试并将结果保存下来进行分析，而扫描器的原理就是将多个模糊测试案例综合起来，自动根据不同的接口用不同的 payload 列表进行尝试，并自动分析结果是否异常，输出报告，由于不同网站的技术栈不同，可能导致结果不准确，误报、漏报等情况。
由于扫描器会对所有接口尝试所有的 payload ，所以会导致网站的压力过大，对于一些会保存到数据库的功能，会给网站维护者增加非常多的垃圾数据，由于 payload 众多，扫描器为了减少扫描时间，会使用多线程来提升扫描速率，如果网站抗压能力不强，还有可能导致网站挂掉，所以在做渗透测试项目的时候，尽量不要使用大型的 web 扫描器。
payload 哪里来？

对于扫描器而言，payload 就是其核心，如果你没有经验，让你去创造 payload 可能会有点强人所难，那么我们可以做的是收集别人的 payload，然后供自己使用。
那么如何收集不同的 payload 呢？

1、github 有非常多的开源扫描器，其中或多或少都会有扫描器作者贡献的 payload，我们只需要把他们的 payload 收集起来，并且进行分类整理。
2、如果你有使用付费扫描器的权利，你可以自己搭建一个 web 服务器，用付费的扫描器对你的 web 服务器进行扫描，你把日志搞出来分析一下，就可以获得付费扫描器的 payload 了。
3、除了上面两种情况，还有非常多黑客自己专属扫描器以及自己专用 payload，那么你想要得到他们智慧的结晶，那么你就需要诱使他们来攻击你，让他们扫描你的网站，从而通过日志获取他们的 payload，这种情况可遇不可求。

文章目录
0. 前言
1. 故事起源
2. 模糊测试事例
3. 模糊测试框架的简单实现
3.1 Runner 类
3.2 Runner 类
4. 附录

0. 前言
来源：Fuzzing: Breaking Things with Random Inputs
建议阅读原文，我这里仅仅整理下思路。我敲的相关代码见：fuzzing仓库

在本章中，我们将从最简单的测试生成技术开始。随机文本生成的关键思想，也称为fuzzing，是将一串随机字符输入程序，以期发现失败。

要求：知道最简单的测试概念：here


1. 故事起源
模糊测试诞生于“ 1988年秋天的黑暗和暴风雨之夜”中。 巴顿·米勒教授坐在麦迪逊威斯康星州的公寓里，通过一条1200波特的电话线连接到他的大学计算机。 雷暴在线路上造成噪音，而该噪音又导致两端的UNIX命令获得错误的输入，并崩溃。 频繁的崩溃使他感到惊讶。当然，程序应该比这更强大吗？ 作为一名科学家，他想研究问题的严重程度及其原因。 因此，他为威斯康星大学麦迪逊分校的学生编写了一个编程练习，该练习将使他的学生创建第一个模糊测试器。
作业重点如下：

该项目的目标是在给定不可预测的输入流的情况下评估各种UNIX实用程序的健壮性。 首先，您将构建一个模糊发生器。 这是一个将输出随机字符流的程序。 其次，您将使用模糊发生器，并使用它来攻击尽可能多的UNIX实用程序，以试图破坏它们。

该作业抓住了模糊测试的本质：创建随机输入，并查看它们是否破坏东西。 只要让它运行足够长的时间，您就会看到。


2. 模糊测试事例
参考连接：Python中with用法详解 | with语句 – python官方文档 |subprocess – 子进程管理
我们的目标和上面类似：创建随机输入，测试bc应用。
# 生成一个指定范围内，随机长度，随机字母的字符串
import random
def fuzzer(min_length=5,max_length=15,char_start=ord('a'),char_range=26):
    str_length = random.randrange(min_length,max_length+1)
    out = ""
    for i in range(str_length):
        out += chr(random.randrange(char_start,char_start+char_range))
    return out

# 将生成的字符串写入文件
import os
import tempfile
basename = "input.txt"
tmp_dir = tempfile.mkdtemp()
FILE = os.path.join(tmp_dir,basename)

data = fuzzer()
with open(FILE,"w") as f:
    f.write(data)
print(open(FILE).read())

# 调用外部程序
import subprocess
program = "bc"
with open(FILE, "w") as f:
    f.write("2 + 2\n")
result = subprocess.run([program, FILE],
                        stdin=subprocess.DEVNULL,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.PIPE,
                        universal_newlines=True)  # Will be "text" in Python 3.7
# print(result)
print(result.stdout)
# print(result.returncode)
# print(result.stderr)

# 测试bc程序
trials = 50
program = "bc"
results = []
for i in range(trials):
    data = fuzzer(min_length=2,char_start=ord('0'))
    data += '\n'
    with open(FILE,"w") as f:
        f.write(data)
    result = subprocess.run([program, FILE],
                        stdin=subprocess.DEVNULL,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.PIPE,
                        universal_newlines=True)  # Will be "text" in Python 3.7
    results.append((data,result))
    
# 测试bc程序的结果分析，没有返回值为非0存在，即没有崩溃
# 如果有返回代码非0，断言
sum_suc = 0
for i in range(trials):
    (data,result) = results[i]
    assert result.returncode == 0
    if result.stderr == "":
        sum_suc += 1
        print(f"suc：{data}-->{result.stdout}")
    else:
        print(f"fail：{data}-->{result.stderr}")
print(sum_suc)



3. 模糊测试框架的简单实现
上面通过一个事例演示了模糊测试。但上面的代码是面向过程编程，在测试其他程序的时候，不好重复利用。下面我们思考如何写一个简单的模糊测试框架。比较明显的是，框架可以分为两部分：生成随机字符串；将字符串作为输入测试程序。好，下面我们实现这样的想法
3.1 Runner 类
我们首先介绍的是Runner的概念––其工作是使目标对象执行给定的输入。目标对象为指定的待测试程序。

让我们从Runner的基础类开始。 运行程序本质上提供了一种run(input)方法，该方法用于将输入(string)传递给目标对象。  run()返回一对（result，outcome）。 在这里，result是Runner特定的值，提供了Runner返回的详细信息； outcome是将结果分为三类的值：

Runner.PASS – the test passed.  The run produced correct results.
Runner.FAIL – the test failed.  The run produced incorrect results.
Runner.UNRESOLVED – the test neither passed nor failed.   This happens if the run could not take place – for instance, because the input was invalid.

# base runner class ： essentially provides a method run(input)，run() returns a pair (result, outcome)
# result是返回值的详细信息，outcome是三种分类之一
# 这个类是基类，下面通过继承覆盖，产生不同的子类
class Runner(object):
    # Test outcomes
    PASS = "PASS"
    FAIL = "FAIL"
    UNRESOLVED = "UNRESOLVED"
    def __init__(self):
        pass
    def run(self,inp):
        return(inp, self.UNRESOLVED)
    
    # 继承Runner类。打印输入
class PrintRunner(Runner):
    def run(self,inp):
        print(inp)
        return(inp, self.UNRESOLVED)
    
# 继承Runner类
# 把输入发送给程序；程序在创建对象的时候制定
class ProgramRunner(Runner):
    def __init__(self,program):
        self.program = program
    def run_process(self,inp=""):
        return subprocess.run(self.program,
                                input=inp,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE,
                                universal_newlines=True)
                                # text=True) 我的是3.6版本，还没有text
    def run(self,inp=""):
        result = self.run_process(inp)
        if result.returncode == 0:
            outcome = self.PASS
        elif result.outcome < 0:
            outcome = self.FAIL
        else:
            outcome = self.UNRESOLVED
        return (result,outcome)
    
# 继承ProgramRunner类
# 如果输入是二进制形式
class BinaryProgramRunner(ProgramRunner):
    def run_process(self,inp=""):
        return subprocess.run(self.program,
                            input=inp.encode(),
                            stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE)
    
# 测试下ProgramRunner
cat = ProgramRunner(program="cat")
(result,outcome) = cat.run("I am cat")
print(result)

3.2 Runner 类
Fuzzer 类主要是创建随机输入，用以喂给run()方法；
# Fuzzer基类：生成随机输入，并使用run方法运行
class Fuzzer(object):
    def __init__(self):
        pass
    def fuzz(self):
        return ""
    def run(self,runner=Runner()):
        return runner.run(self.fuzz())
    def runs(self,runner=PrintRunner(),trials=10):
        outcomes = []
        for i in range(trials):
            # outcomes.append(runner.run(self.fuzz()))
            outcomes.append(self.run(runner))
        return outcomes
    
# 随机模糊测试
class RandomFuzzer(Fuzzer):
    def __init__(self, min_length=10, max_length=100,char_start=32, char_range=32):
        self.min_length = min_length
        self.max_length = max_length
        self.char_start = char_start
        self.char_range = char_range
    def fuzz(self):
        str_len = random.randrange(self.min_length,self.max_length)
        out = ""
        for i in range(str_len):
            out += chr(random.randrange(self.char_start,self.char_start + self.char_range))
        return out

# 测试RandomFuzzer
random_fuzzer = RandomFuzzer(min_length=5,max_length=10,char_start=ord('a'),char_range=26)
# random_fuzzer.fuzz() # 可以随机生成字符串，很好
cat_runner = ProgramRunner("cat")
outcomes = random_fuzzer.runs(cat_runner,10)
print(outcomes)

# 上面的bc测试使用我们的基类
random_fuzzer = RandomFuzzer(min_length=2,max_length=6,char_start=ord('0'),char_range=10)
bc_runner = ProgramRunner("bc")
outcomes = random_fuzzer.runs(bc_runner,10)
print(outcomes)


4. 附录
模糊测试框架的UML图。
@startuml 2_break_thing_with_random_input

class Runner{
    PASS = "PASS"
    FAIL = "FAIL"
    UNRESOLVED = "UNRESOLVED"
    __init__(self)
    (inp, self.UNRESOLVED) run(self,inp)
}
note right of Runner
    Runner为基类（不是抽象类）
    使用inp作为输入
    返回结果和三种结果状态中的一种
    此时init和run方法啥也没干
end note


class ProgramRunner{
    program
    __init__(self,program)
    run_process(self,inp="")
    (result,outcome) run(self,inp="")
}
Runner <|-- ProgramRunner
note right of ProgramRunner
    ProgramRunner类继承Runner类
    init方法读取将要运行的程序名
    run方法读取输入，并调用run_process,将输入传递给run_process
    run_process使用子进程运行程序
end note


class Fuzzer{
    __init__(self)
    string fuzz(self)
    (result,outcome) run(self,runner=Runner())
    (result,outcome)[] runs(self,runner=PrintRunner(),trials)
}
Fuzzer ..> Runner
note right of Fuzzer
    Fuzzer是一个基础类
    fuzz方法生成测试的输入内容
    run方法使用Runner类生成的一个对象来运行被测试程序；
        被测试的程序使用fuzz方法生成的内容作为输入
    runs方法多次调用run方法，调用次数为trials
end note

class RandomFuzzer{
    __init__(self, min_length, max_length,char_start, char_range)
    string fuzz(self)
}
RandomFuzzer --|> Fuzzer
note right of RandomFuzzer
    RandomFuzzer继承Fuzzer类
    init方法读取参数：随机字符串的最小长度、最大长度、字符的开始值、字符的最大值
    fuzz根据参数的限制，随机生成字符串
end note
@enduml

文章目录
9.5. 模糊测试
9.5.1. Web Fuzz
9.5.2. Unicode Fuzz
9.5.3. WAF Bypass

9.5. 模糊测试
9.5.1. Web Fuzz

wfuzz
SecLists
fuzzdb
foospidy payloads
fuzzDicts Web Pentesting Fuzz 字典

9.5.2. Unicode Fuzz

utf16encode

9.5.3. WAF Bypass

abuse ssl bypass waf
wafninja

模糊测试

模糊测试 （fuzz testing, fuzzing）是一种软件测试技术。其核心思想是自动或半自动的生成随机数据输入到一个程序中，并监视程序异常，如崩溃，断言(assertion)失败，以发现可能的程序错误，比如内存泄漏。模糊测试常常用于检测软件或计算机系统的安全漏洞。

模糊测试的实现是一个非常简单的过程：

1、准备一份插入程序中的正确的文件。

2、用随机数据替换该文件的某些部分。

3、用程序打开文件。

4、观察破坏了什么。

可以用任意多种方式改变该随机数据。例如，可以将整个文件打乱，而不是仅替换其中的一部分，也可以将该文件限制为 ASCII 文本或非零字节。不管用什么方式进行分割，关键是将大量随机数据放入应用程序并观察出故障的是什么。

 

黑盒测试

黑盒测试也称功能测试，它是通过测试来检测每个功能是否都能正常使用。在测试中，把程序看作一个不能打开的黑盒子，在完全不考虑程序内部结构和内部特性的情况下，在程序接口进行测试，它只检查程序功能是否按照需求规格说明书的规定正常使用，程序是否能适当地接收输入数据而产生正确的输出信息。黑盒测试着眼于程序外部结构，不考虑内部逻辑结构，主要针对软件界面和软件功能进行测试。

黑盒测试是以用户的角度，从输入数据与输出数据的对应关系出发进行测试的。很明显，如果外部特性本身设计有问题或规格说明的规定有误，用黑盒测试方法是发现不了的。

以上是度娘的概念，简单来说，黑盒测试就是在不知道程序具体内容的情况下，按规定内的数据（格式）输入，检查是否能达到预期的经过程序正常处理的效果，找到出现非预期结果的那些错误。（一般不会穷举，所以没找到并不等于完全安全）

黑盒测试的主要作用:

黑盒测试法注重于测试软件的功能需求，主要试图发现下列几类错误。

1.功能不正确或遗漏；

2.界面错误；

3.输入和输出错误；

4.数据库访问错误；

5.性能错误；

6.初始化和终止错误等。

 

白盒测试

又称为透明盒测试、逻辑驱动测试
	
是测试被测单元内部如何工作的一种测试方案（单元测试）
	
根据程序内部逻辑结构及相关信息来设计和选择测试用例，对程序的逻辑结构进行测试
	

	
可覆盖全部代码、分支、条件和路径等 
	
白盒测试是一种测试用例设计方法，盒子指的是被测试的软件，白盒指的是盒子是可视的，你清楚盒子内部的东西以及里面是如何运作的。"白盒"法全面了解程序内部逻辑结构、对所有逻辑路径进行测试。"白盒"法是穷举路径测试。在使用这一方案时，测试者必须检查程序的内部结构，从检查程序的逻辑着手，得出测试数据。

 

渗透测试

渗透测试是通过模拟恶意黑客的攻击方法，来评估计算机网络系统安全的一种评估方法。这个过程包括对系统的任何弱点、技术缺陷或漏洞的主动分析，这个分析是从一个攻击者可能存在的位置来进行的，并且从这个位置有条件主动利用安全漏洞。

换句话来说，渗透测试是指渗透人员在不同的位置（比如从内网、从外网等位置）利用各种手段对某个特定网络进行测试，以期发现和挖掘系统中存在的漏洞，然后输出渗透测试报告，并提交给网络所有者。网络所有者根据渗透人员提供的渗透测试报告，可以清晰知晓系统中存在的安全隐患和问题。

打一个比方来解释渗透测试的必要性。假设你要修建一座金库，并且你按照建设规范将金库建好了。此时是否就可以将金库立即投入使用呢？肯定不是！因为还不清楚整个金库系统的安全性如何，是否能够确保存放在金库的贵重东西万无一失。那么此时该如何做？可以请一些行业中安全方面的专家对这个金库进行全面检测和评估，比如检查金库门是否容易被破坏，检查金库的报警系统是否在异常出现的时候及时报警，检查所有的门、窗、通道等重点易突破的部位是否牢不可破，检查金库的管理安全制度、视频安防监控系统、出入口控制等等。甚至会请专人模拟入侵金库，验证金库的实际安全性，期望发现存在的问题。 这个过程就好比是对金库的渗透测试。这里金库就像是我们的信息系统，各种测试、检查、模拟入侵就是渗透测试。

渗透测试方法分类

1、黑箱测试

黑箱测试又被称为所谓的“Zero-Knowledge Testing”，渗透者完全处于对系统一无所知的状态，通常这类型测试，最初的信息获取来自于DNS、Web、Email及各种公开对外的服务器。

2、白盒测试

白盒测试与黑箱测试恰恰相反，测试者可以通过正常渠道向被测单位取得各种资料，包括网络拓扑、员工资料甚至网站或其它程序的代码片断，也能够与单位的其它员工（销售、程序员、管理者……）进行面对面的沟通。这类测试的目的是模拟企业内部雇员的越权操作。

3、隐秘测试

隐秘测试是对被测单位而言的，通常情况下，接受渗透测试的单位网络管理部门会收到通知：在某些时段进行测试。因此能够监测网络中出现的变化。但隐秘测试则被测单位也仅有极少数人知晓测试的存在，因此能够有效地检验单位中的信息安全事件监控、响应、恢复做得是否到位。