模糊测试简介

电玩女神 2022-12-27 07:34 147阅读 0赞

### 文章目录 ###

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

## 0. 前言 ##

来源：[Fuzzing: Breaking Things with Random Inputs][Fuzzing_ Breaking Things with Random Inputs]

建议阅读原文，我这里仅仅整理下思路。我敲的相关代码见：[fuzzing仓库][fuzzing]

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

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

## 1. 故事起源 ##

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

[作业][Link 1]重点如下：

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

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

## 2. 模糊测试事例 ##

参考连接：[Python中with用法详解][Python_with] | [with语句 – python官方文档][with_ _ python] |[subprocess – 子进程管理][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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM4ODE2OTI0_size_16_color_FFFFFF_t_70_pic_center]

[Fuzzing_ Breaking Things with Random Inputs]: https://www.fuzzingbook.org/html/Fuzzer.html
[fuzzing]: https://github.com/da1234cao/programming-language-entry-record/tree/master/fuzzing
[here]: https://blog.csdn.net/sinat_38816924/article/details/110664084
[Link 1]: http://pages.cs.wisc.edu/~bart/fuzz/CS736-Projects-f1988.pdf
[Python_with]: https://www.jellythink.com/archives/530
[with_ _ python]: https://docs.python.org/zh-cn/3/reference/compound_stmts.html#with
[subprocess _]: https://docs.python.org/zh-cn/3/library/subprocess.html
[bc]: http://c.biancheng.net/view/2680.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM4ODE2OTI0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/dafe8b5cc4b2417bad0b4b336acab982.png