模糊测试之书-八-

模糊测试之书（八）

原文：exploringjs.com/ts/book/index.html

译者：飞龙

协议：CC BY-NC-SA 4.0

基于语法的灰盒模糊测试

原文：www.fuzzingbook.org/html/GreyboxGrammarFuzzer.html

在本章中，我们介绍了对我们句法模糊测试技术的扩展，所有这些扩展都利用了 现有输入的 句法部分。

我们展示了如何在模糊测试期间利用输入片段的字典。想法是将这样的字典集成到 变异器 中，然后注入这些片段（通常是关键字和其他重要项）到种群中。
我们展示了如何将解析和模糊测试与语法结合。这允许在保持句法正确性的同时变异现有输入，并在生成新输入的同时重用现有输入的片段。正如本章所展示的，基于语言的解析和生成组合在实践中取得了高度成功：LangFuzz 模糊器为 JavaScript 解释器找到了超过 2,600 个漏洞。
在前面的章节中，我们以黑盒方式使用语法——也就是说，我们使用它们来生成输入，而不考虑正在测试的程序。在本章中，我们介绍了基于变异的 语法灰盒模糊测试：利用 正在测试的程序反馈 来引导测试生成向特定目标的技术。正如词汇灰盒模糊测试一样，这种反馈主要是 覆盖率，允许我们引导基于语法的测试向未覆盖的代码部分。这部分灵感来自 AFLSmart 模糊器，它结合了解析和变异模糊测试。

from [bookutils](https://github.com/uds-se/fuzzingbook//tree/master/notebooks/shared/bookutils) import YouTubeVideo
YouTubeVideo('hSGzcjUj7Vs')

先决条件

我们基于关于灰盒模糊测试（无语法）的章节的几个概念。
如标题所示，你应该知道如何使用语法进行模糊测试语法章节。

概述

要使用本章提供的代码，请编写

>>> from fuzzingbook.GreyboxGrammarFuzzer import <identifier>

然后利用以下功能。

本章介绍了受 LangFuzz 和 AFLSmart 模糊器启发的基于语言的灰盒模糊测试的高级方法。

使用字典进行模糊测试

与随机变异字符串不同，DictMutator 类允许从字典中插入标记，从而提高模糊测试器的性能。字典以字符串列表的形式提供，从中随机选择元素并插入，除了给定的变异，如删除或插入单个字节。

>>> dict_mutator = DictMutator(["<a>", "</a>", "<a/>", "='a'"])
>>> seeds = ["<html><head><title>Hello</title></head><body>World<br/></body></html>"]
>>> for i in range(10):
>>>     print(dict_mutator.mutate(seeds[0]))
<html><head><title>Hello</title></head><body>World<br/>>/body></html>
<html><head><title>Hello</title></head><body>World<br/></body></ht7ml>
<html><head><title>Hello</title></hgad><body>World<br/></body></html>
<html><head><title>Hello</title></head><body>World<br/<a/>></body></html>
<html><head><title>Hello</title></head><body>World<br+></body></html>
<html><head><title>Hello</title></qhead><body>World<br/></body></html>
<html><head><title>Hello</title></head><body>World<br='a'/></body></html>
<html><head><title>Hello</title></head><body>Wormd<br/></body></html>
<html><head><title>Hello</title></head><body>Wyorld<br/></body></html>
<html><head><title>Hello<</a>/title></head><body>World<br/></body></html>

这个 DictMutator 可以作为 GreyboxFuzzer 的参数使用：

>>> runner = FunctionCoverageRunner(my_parser)
>>> dict_fuzzer = GreyboxFuzzer(seeds, dict_mutator, PowerSchedule())
>>> dict_fuzzer_outcome = dict_fuzzer.runs(runner, trials=5)

使用字典中的关键字变换字符串">字典变换器 <a xlink:href="#" xlink:title="init(self, dictionary: List[str]) -> None:

构造函数。dictionary 是要使用的关键字列表。">init() <a xlink:href="#" xlink:title="insert_from_dictionary(self, s: str) -> str:

返回插入字典中关键字后的字符串 insert_from_dictionary() 变换器 <a xlink:href="GreyboxFuzzer.html" xlink:title="class Mutator:

变换字符串">变换器 <a xlink:href="GreyboxFuzzer.html" xlink:title="class Mutator:

构造函数">init() DictMutator->Mutator 图例图例 • public_method() • private_method() • overloaded_method() 将鼠标悬停在名称上以查看文档

使用输入片段进行模糊测试

LangFuzzer 类引入了一个 语言感知 模糊器，可以重新组合现有输入中的片段——灵感来源于高效的 LangFuzz 模糊器。其核心是一个 FragmentMutator 类，该类将一个 解析器 作为参数：

>>> parser = EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS)
>>> mutator = FragmentMutator(parser)

模糊器本身使用种子列表、上述 FragmentMutator 和一个功率计划进行初始化：

>>> seeds = ["<html><head><title>Hello</title></head><body>World<br/></body></html>"]
>>> schedule = PowerSchedule()
>>> lang_fuzzer = LangFuzzer(seeds, mutator, schedule)
>>> for i in range(10):
>>>     print(lang_fuzzer.fuzz())
<html><head><title>Hello</title></head><body>World<br/></body></html>
<html><head><title>Hello</title></head>World<br/></body></html>
<html>World<body>World<br/></body></html>
<html><title>Hello</title></head><title>World<br/></body></html>
<html><head><title><head>World</head></title></head>World<br/></body></html>
<html><body>World<br/></body><body>World<br/></body></html>

Exception ignored in: <bound method IPythonKernel._clean_thread_parent_frames of <ipykernel.ipkernel.IPythonKernel object at 0x103912720>>
Traceback (most recent call last):
  File "/Users/zeller/.local/lib/python3.12/site-packages/ipykernel/ipkernel.py", line 775, in _clean_thread_parent_frames
    def _clean_thread_parent_frames(

  File "Timeout.ipynb", line 43, in timeout_handler
    }

TimeoutError: 

<html><body>WorldHello</body>

Exception ignored in: <bound method IPythonKernel._clean_thread_parent_frames of <ipykernel.ipkernel.IPythonKernel object at 0x103912720>>
Traceback (most recent call last):
  File "/Users/zeller/.local/lib/python3.12/site-packages/ipykernel/ipkernel.py", line 775, in _clean_thread_parent_frames
    def _clean_thread_parent_frames(

  File "Timeout.ipynb", line 43, in timeout_handler
    }

TimeoutError: 

<html><head><title>Hello</title></head><body><head><head>World</head></title></head><body>World<br/></body><br/></body></html>
<html><head><title></title></head><body>World<br/></body></html>
<html><head><title>Hello</title></head><body><head><title><head>World</head></title></head><body>World<br/></body><br/><br/></body></html>

黑盒模糊器正在变异输入片段。大致基于 LangFuzz。">LangFuzzer <a xlink:href="#" xlink:title="create_candidate(self) -> GreyboxFuzzer.Seed:

返回由模糊种群中的种子生成的输入">create_candidate() AdvancedMutationFuzzer <a xlink:href="GreyboxFuzzer.html" xlink:title="class AdvancedMutationFuzzer:

基于变异的模糊的基础类。">AdvancedMutationFuzzer <a xlink:href="GreyboxFuzzer.html" xlink:title="init(self, seeds: List[str], mutator: GreyboxFuzzer.Mutator, schedule: GreyboxFuzzer.PowerSchedule) -> None:

构造函数。

seeds - 要变异的（输入）字符串列表。

mutator - 要应用的变异器。

schedule - 要应用的功率计划。">init() <a xlink:href="GreyboxFuzzer.html" xlink:title="fuzz(self) -> str:

返回每个种子一次，然后生成新的输入">fuzz() LangFuzzer->AdvancedMutationFuzzer Fuzzer <a xlink:href="Fuzzer.html" xlink:title="class Fuzzer:

模糊器的基类">Fuzzer <a xlink:href="Fuzzer.html" xlink:title="init(self) -> None:

构造函数">init() <a xlink:href="Fuzzer.html" xlink:title="fuzz(self) -> str:

返回模糊输入">fuzz() <a xlink:href="Fuzzer.html" xlink:title="run(self, runner: Fuzzer.Runner = <Fuzzer.Runner object>) -> Tuple[subprocess.CompletedProcess, str]:

使用模糊输入运行runner">run() <a xlink:href="Fuzzer.html" xlink:title="runs(self, runner: Fuzzer.Runner = <Fuzzer.PrintRunner object>, trials: int = 10) -> List[Tuple[subprocess.CompletedProcess, str]]:

使用模糊输入，运行runner，共trials次">runs() AdvancedMutationFuzzer->Fuzzer 片段突变器 <a xlink:href="#" xlink:title="class FragmentMutator:

使用来自池的输入片段突变输入">片段突变器 <a xlink:href="#" xlink:title="init(self, parser):

初始化突变器">init() <a xlink:href="#" xlink:title="add_to_fragment_pool(self, seed: SeedWithStructure) -> None:

将种子的所有片段添加到片段池中">add_to_fragment_pool() <a xlink:href="#" xlink:title="add_fragment(self, fragment: DerivationTree) -> None:

递归地将片段添加到片段池中">add_fragment() <a xlink:href="#" xlink:title="count_nodes(self, fragment: DerivationTree) -> int:

返回片段中的节点数">count_nodes() <a xlink:href="#" xlink:title="delete_fragment(self, seed: SeedWithStructure) -> SeedWithStructure:

删除一个随机片段">delete_fragment() <a xlink:href="#" xlink:title="is_excluded(self, symbol: str) -> bool:

如果一个片段以特定内容开始，则返回 true

符号及其所有后代可以被排除">is_excluded() <a xlink:href="#" xlink:title="mutate(self, seed: SeedWithStructure) -> SeedWithStructure:

实现结构感知的变异。缓存种子。">mutate() <a xlink:href="#" xlink:title="recursive_delete(self, fragment: DerivationTree) -> DerivationTree:

递归查找要删除的片段">recursive_delete() <a xlink:href="#" xlink:title="recursive_swap(self, fragment: DerivationTree) -> DerivationTree:

递归查找要交换的片段。">recursive_swap() <a xlink:href="#" xlink:title="swap_fragment(self, seed: SeedWithStructure) -> SeedWithStructure:

用具有相同符号的另一个片段替换随机片段">swap_fragment() Mutator <a xlink:href="GreyboxFuzzer.html" xlink:title="class Mutator:

变异字符串">Mutator <a xlink:href="GreyboxFuzzer.html" xlink:title="init(self) -> None:

Constructor">init() FragmentMutator->Mutator 图例图例 • 公共方法() • 私有方法() • 重载方法() 将鼠标悬停在名称上以查看文档

基于输入区域的模糊测试

GreyboxGrammarFuzzer 类使用两个突变体：

一个 树突变体（一个 RegionMutator 对象），它可以解析现有字符串以识别该字符串中的区域以进行交换或删除。
一个 字节突变体 用于应用位和字符级别的突变。

>>> tree_mutator = RegionMutator(parser)
>>> byte_mutator = Mutator()

GreyboxGrammarFuzzer 类的调度可以是一个常规的 PowerSchedule 对象。然而，AFLSmartSchedule 提供了一个更复杂的调度，它将更多能量分配给具有更高有效性的种子。

>>> schedule = AFLSmartSchedule(parser)

GreyboxGrammarFuzzer 构造函数接受一组种子以及两个突变体和调度：

>>> aflsmart_fuzzer = GreyboxGrammarFuzzer(seeds, byte_mutator, tree_mutator, schedule)

由于它依赖于代码覆盖率，它通常与 FunctionCoverageRunner 结合使用：

>>> runner = FunctionCoverageRunner(my_parser)
>>> aflsmart_outcome = aflsmart_fuzzer.runs(runner, trials=5)

使用语法的灰盒模糊测试器。">GreyboxGrammarFuzzer <a xlink:href="#" xlink:title="init(self, seeds: List[str], byte_mutator: GreyboxFuzzer.Mutator, tree_mutator: FragmentMutator, schedule: GreyboxFuzzer.PowerSchedule) -> None:

构造函数。

seeds - 要变异的输入集合。

byte_mutator - 字节级别的变异器。

tree_mutator = 树级别的变异器。

schedule - 功率调度。">init() <a xlink:href="#" xlink:title="create_candidate(self) -> str:

返回由结构变异生成的输入。

种子在种群中的变异。">create_candidate() GreyboxFuzzer <a xlink:href="GreyboxFuzzer.html" xlink:title="class GreyboxFuzzer:

覆盖率引导的变异模糊测试。">GreyboxFuzzer <a xlink:href="GreyboxFuzzer.html" xlink:title="run(self, runner: MutationFuzzer.FunctionCoverageRunner) -> Tuple[Any, str]:

在跟踪覆盖率的同时运行函数(inp)。">

如果达到新的覆盖率，

将输入添加到种群并添加其覆盖率到种群覆盖率。">run() GreyboxGrammarFuzzer->GreyboxFuzzer AdvancedMutationFuzzer <a xlink:href="GreyboxFuzzer.html" xlink:title="class AdvancedMutationFuzzer:

基于变异的模糊测试的基础类。">AdvancedMutationFuzzer <a xlink:href="GreyboxFuzzer.html" xlink:title="init(self, seeds: List[str], mutator: GreyboxFuzzer.Mutator, schedule: GreyboxFuzzer.PowerSchedule) -> None:

构造函数。

seeds - 要变异的（输入）字符串列表。

mutator - 要应用的变异器。

schedule - 要应用的动力计划。">init() <a xlink:href="GreyboxFuzzer.html" xlink:title="fuzz(self) -> str:

返回每个种子一次，然后生成新的输入">fuzz() GreyboxFuzzer->AdvancedMutationFuzzer Fuzzer <a xlink:href="Fuzzer.html" xlink:title="class Fuzzer:

模糊器的基类。">Fuzzer <a xlink:href="Fuzzer.html" xlink:title="init(self) -> None:

构造函数">init() <a xlink:href="Fuzzer.html" xlink:title="fuzz(self) -> str:

返回模糊输入">fuzz() <a xlink:href="Fuzzer.html" xlink:title="run(self, runner: Fuzzer.Runner = <Fuzzer.Runner object>) -> Tuple[subprocess.CompletedProcess, str]:

使用模糊输入运行runner，trials次">runs() AdvancedMutationFuzzer->Fuzzer AFLSmartSchedule <a xlink:href="#" xlink:title="class AFLSmartSchedule:

定义如何将模糊测试时间分配给种群。">AFLSmartSchedule <a xlink:href="#" xlink:title="init(self, parser: Parser.EarleyParser, exponent: float = 1.0):

构造函数">init() <a xlink:href="#" xlink:title="assignEnergy(self, population: Sequence[GreyboxFuzzer.Seed]):

按有效性程度分配指数能量">assignEnergy() <a xlink:href="#" xlink:title="degree_of_validity(self, seed: GreyboxFuzzer.Seed) -> float:

返回可解析的种子比例">degree_of_validity() <a xlink:href="#" xlink:title="parsable(self, seed: GreyboxFuzzer.Seed) -> str:

返回可解析的子串">parsable() PowerSchedule <a xlink:href="GreyboxFuzzer.html" xlink:title="class PowerSchedule:

定义如何将模糊测试时间分配给种群。">PowerSchedule <a xlink:href="GreyboxFuzzer.html" xlink:title="init(self) -> None:

构造函数">init() AFLSmartSchedule->PowerSchedule RegionMutator <a xlink:href="#" xlink:title="class RegionMutator:

使用来自池的输入片段突变输入">RegionMutator <a xlink:href="#" xlink:title="add_to_fragment_pool(self, seed: SeedWithRegions) -> None:

在种子文件中标记片段和区域">add_to_fragment_pool() <a xlink:href="#" xlink:title="delete_fragment(self, seed: SeedWithRegions) -> SeedWithRegions:

删除一个随机区域">delete_fragment() <a xlink:href="#" xlink:title="swap_fragment(self, seed: SeedWithRegions) -> SeedWithRegions:

选择一个随机区域并将其与片段交换

以相同的符号开始">swap_fragment() FragmentMutator <a xlink:href="#" xlink:title="class FragmentMutator:

使用池中的输入片段突变输入">FragmentMutator <a xlink:href="#" xlink:title="init(self, parser):

初始化突变体">init() <a xlink:href="#" xlink:title="add_to_fragment_pool(self, seed: SeedWithStructure) -> None:

将种子片段的所有片段添加到片段池中">add_to_fragment_pool() <a xlink:href="#" xlink:title="add_fragment(self, fragment: DerivationTree) -> None:

递归地将片段添加到片段池中">add_fragment() <a xlink:href="#" xlink:title="count_nodes(self, fragment: DerivationTree) -> int:

返回片段中的节点数">count_nodes() <a xlink:href="#" xlink:title="delete_fragment(self, seed: SeedWithStructure) -> SeedWithStructure:

删除一个随机片段">delete_fragment() <a xlink:href="#" xlink:title="is_excluded(self, symbol: str) -> bool:

如果一个片段以特定的开头返回 true

符号及其所有后代可以被排除">is_excluded() <a xlink:href="#" xlink:title="mutate(self, seed: SeedWithStructure) -> SeedWithStructure:

实现结构感知变异。缓存种子。">mutate() <a xlink:href="#" xlink:title="recursive_delete(self, fragment: DerivationTree) -> DerivationTree:

递归查找要删除的片段">recursive_delete() <a xlink:href="#" xlink:title="recursive_swap(self, fragment: DerivationTree) -> DerivationTree:

递归查找要交换的片段。">recursive_swap() <a xlink:href="#" xlink:title="swap_fragment(self, seed: SeedWithStructure) -> SeedWithStructure:

用具有相同符号的另一个随机片段替换">swap_fragment() RegionMutator->FragmentMutator Mutator <a xlink:href="GreyboxFuzzer.html" xlink:title="class Mutator:

修改字符串">Mutator <a xlink:href="GreyboxFuzzer.html" xlink:title="init(self) -> None:

构造函数">init() FragmentMutator->Mutator 图例图例 • public_method() • private_method() • overloaded_method() 将鼠标悬停在名称上以查看文档

背景

首先，我们回忆一些用于变异模糊器的基本成分。

Seed。一个种子是一个输入，模糊器通过应用一系列变异来生成新的输入。
Mutator。一个 变异器 实现了一组变异操作，这些操作应用于输入产生略微修改后的输入。
PowerSchedule。一个 功率计划 将能量分配给一个种子。具有更高能量的种子在整个模糊测试活动中被模糊测试的频率更高。
AdvancedMutationFuzzer。我们的 变异黑盒模糊器 通过对输入群体中的种子进行变异来生成输入。
GreyboxFuzzer。我们的 灰盒模糊器 动态地向种子群体中添加输入，以增加覆盖率。
FunctionCoverageRunner。我们的 功能覆盖率运行器 收集给定 Python 函数执行的覆盖率信息。

让我们尝试对这些概念有一个感觉。

import [bookutils.setup](https://github.com/uds-se/fuzzingbook//tree/master/notebooks/shared/bookutils)

from [typing](https://docs.python.org/3/library/typing.html) import List, Set, Dict, Sequence, cast

from Fuzzer import Fuzzer
from GreyboxFuzzer import Mutator, Seed, PowerSchedule
from GreyboxFuzzer import AdvancedMutationFuzzer, GreyboxFuzzer
from MutationFuzzer import FunctionCoverageRunner

以下命令对输入 "Hello World" 应用了变异。

Mutator().mutate("Hello World")

'Lello World'

默认功率计划将能量均匀分配到所有种子。让我们检查这是否有效。

我们从三个种子中选择了 10k 次。正如我们在 hits 计数器中看到的那样，每个种子大约有三分之一的概率被选中。

population = [Seed("A"), Seed("B"), Seed("C")]
schedule = PowerSchedule()
hits = {
    "A": 0,
    "B": 0,
    "C": 0
}

for i in range(10000):
    seed = schedule.choose(population)
    hits[seed.data] += 1

hits

{'A': 3387, 'B': 3255, 'C': 3358}

在解释功能覆盖率运行器之前，让我们以 Python 的 HTML 解析器为例导入...

from [html.parser](https://docs.python.org/3/library/html.parser.html) import HTMLParser

...并创建一个 包装函数，将每个输入传递给一个新的解析器对象。

def my_parser(inp: str) -> None:
    parser = HTMLParser()
    parser.feed(inp)

FunctionCoverageRunner 构造函数接受一个 Python function 来执行。run() 函数接受一个输入，将其传递给 Python function，并收集这次执行的覆盖率信息。coverage() 函数返回一个包含元组 (function name, line number) 的列表，表示 Python function 中每个已覆盖的语句。

runner = FunctionCoverageRunner(my_parser)
runner.run("Hello World")
cov = runner.coverage()

list(cov)[:5]  # Print 5 statements covered in HTMLParser

[('my_parser', 3),
 ('goahead', 163),
 ('updatepos', 47),
 ('goahead', 245),
 ('reset', 100)]

我们的灰盒模糊器需要一个种子种群、突变器和功率计划。让我们从一个“空”的种子语料库开始生成 5000 个模糊输入。

import [time](https://docs.python.org/3/library/time.html)
import [random](https://docs.python.org/3/library/random.html)

n = 5000
seed_input = " "  # empty seed
runner = FunctionCoverageRunner(my_parser)
fuzzer = GreyboxFuzzer([seed_input], Mutator(), PowerSchedule())

start = time.time()
fuzzer.runs(runner, trials=n)
end = time.time()

"It took the fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)

'It took the fuzzer 0.98 seconds to generate and execute 5000 inputs.'

"During this fuzzing campaign, we covered %d statements." % len(runner.coverage())

'During this fuzzing campaign, we covered 79 statements.'

使用字典进行模糊测试

为了模糊我们的 HTML 解析器，可能有必要向突变模糊器告知输入中的重要关键词——即重要的 HTML 关键词。一般思路是拥有一个 预定义的有用输入字典，然后在突变输入时插入这些输入。

这个概念在以下图中得到了说明。在突变输入时，我们可能会插入字典中给出的关键词（红色）。

为了实现这个概念，我们将我们的突变器扩展到考虑字典中的关键词。

class DictMutator(Mutator):
  """Mutate strings using keywords from a dictionary"""

    def __init__(self, dictionary: List[str]) -> None:
  """Constructor. `dictionary` is the list of keywords to use."""
        super().__init__()
        self.dictionary = dictionary
        self.mutators.append(self.insert_from_dictionary)

    def insert_from_dictionary(self, s: str) -> str:
  """Returns s with a keyword from the dictionary inserted"""
        pos = random.randint(0, len(s))
        random_keyword = random.choice(self.dictionary)
        return s[:pos] + random_keyword + s[pos:]

让我们尝试添加一些 HTML 标签和属性，看看使用 DictMutator 的覆盖率是否增加。

runner = FunctionCoverageRunner(my_parser)
dict_mutator = DictMutator(["<a>", "</a>", "<a/>", "='a'"])
dict_fuzzer = GreyboxFuzzer([seed_input], dict_mutator, PowerSchedule())

start = time.time()
dict_fuzzer.runs(runner, trials=n)
end = time.time()

"It took the fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)

'It took the fuzzer 2.78 seconds to generate and execute 5000 inputs.'

显然，这需要更长的时间。根据我们的经验，这意味着覆盖了更多的代码：

"During this fuzzing campaign, we covered %d statements." % len(runner.coverage())

'During this fuzzing campaign, we covered 108 statements.'

模糊器在覆盖率的比较方面如何？

from Coverage import population_coverage

import [matplotlib.pyplot](https://matplotlib.org/) as plt

_, dict_cov = population_coverage(dict_fuzzer.inputs, my_parser)
_, fuzz_cov = population_coverage(fuzzer.inputs, my_parser)
line_dict, = plt.plot(dict_cov, label="With Dictionary")
line_fuzz, = plt.plot(fuzz_cov, label="Without Dictionary")
plt.legend(handles=[line_dict, line_fuzz])
plt.xlim(0, n)
plt.title('Coverage over time')
plt.xlabel('# of inputs')
plt.ylabel('lines covered');

总结。 通知模糊器关于重要关键词的信息已经大大有助于快速实现大量覆盖率。

试试看。 打开这一章作为 Jupyter notebook，并将其他与 HTML 相关的关键词添加到字典中，以查看覆盖率的差异是否实际上增加了（在相同的 5k 生成测试输入预算下）。

阅读。 AFL 的作者 Michał Zalewski 写了几篇关于使用字典制作语法和从空气中拉出 JPEG 的优秀博客文章！

使用输入片段进行模糊测试

虽然字典有助于将重要关键词注入种子输入，但它们不允许保持生成输入的结构完整性。相反，我们需要让模糊器意识到 输入结构。我们可以使用语法来做到这一点。我们的第一个方法

解析种子输入，
将它们反汇编成输入片段，并
根据语法的规则重新组装这些片段以生成新的文件。

这种解析和 模糊测试 的组合可以非常强大。例如，我们可以交换输入中现有的子结构：

我们还可以用新生成的子结构替换现有的子结构：

所有这些操作都在推导树上进行，这些树可以随时解析成字符串并生成字符串。

解析和重新组合 JavaScript，或如何在四周内赚取 50,000 美元

在“使用代码片段进行模糊测试”[Holler et al, 2012]中，Holler、Herzig 和 Zeller 将这些步骤应用于模糊测试 JavaScript 解释器。他们使用 JavaScript 语法来

解析（有效的）JavaScript 输入到解析树，
将它们反汇编成片段（子树），
重新组合这些片段，使其再次成为有效的 JavaScript 程序，
将这些程序输入到 JavaScript 解释器中进行执行。

与大多数模糊测试场景一样，目标是使 JavaScript 解释器崩溃。以下是一个 LangFuzz 生成的 JavaScript 代码示例（来自[Holler et al, 2012]），它导致 Mozilla JavaScript 解释器崩溃：

var  haystack  =  "foo";
var  re_text  =  "^foo";
haystack  +=  "x";
re_text  +=  "(x)";
var  re  =  new  RegExp(re_text);
re.test(haystack);
RegExp.input  =  Number();
print(RegExp.$1);

从 JavaScript 解释器的崩溃中，通常可以构建一个利用，不仅会使解释器崩溃，而且会在攻击者的控制下执行代码。因此，这样的崩溃是严重的缺陷，这也是为什么如果你报告它们，你会得到漏洞赏金。

在运行他的LangFuzz工具的前四周内，该论文的第一作者 Christian Holler 获得了超过 50,000 美元的漏洞赏金。到目前为止，LangFuzz 已经在 Mozilla Firefox、Google Chrome 和 Microsoft Edge 的 JavaScript 浏览器中发现了超过 2,600 个漏洞。如果你使用这些浏览器中的任何一个（比如在你的 Android 手机上），解析和模糊测试的组合在使你的浏览会话更安全方面做出了重大贡献。

（请注意，这些是 Holler 和 Zeller，他们是这本书的共同作者。如果你曾经想知道为什么我们会在基于语法的模糊测试上花费几章内容，那是因为我们在它上面有一些很好的经验。）

解析和重新组合 HTML

在这本书中，让我们先专注于 HTML 输入。为了为我们的 Python HTMLParser生成有效的 HTML 输入，我们首先应该定义一个简单的语法。它允许定义带有属性的 HTML 标签。我们的上下文无关语法不要求开标签和闭标签必须匹配。然而，我们将看到这样的上下文相关特性可以在派生的输入片段中保持，因此也在生成的输入中。

import [string](https://docs.python.org/3/library/string.html)

from Grammars import is_valid_grammar, srange, Grammar

XML_TOKENS: Set[str] = {"<id>", "<text>"}

XML_GRAMMAR: Grammar = {
    "<start>": ["<xml-tree>"],
    "<xml-tree>": ["<text>",
                   "<xml-open-tag><xml-tree><xml-close-tag>",
                   "<xml-openclose-tag>",
                   "<xml-tree><xml-tree>"],
    "<xml-open-tag>":      ["<<id>>", "<<id> <xml-attribute>>"],
    "<xml-openclose-tag>": ["<<id>/>", "<<id> <xml-attribute>/>"],
    "<xml-close-tag>":     ["</<id>>"],
    "<xml-attribute>":     ["<id>=<id>", "<xml-attribute> <xml-attribute>"],
    "<id>":                ["<letter>", "<id><letter>"],
    "<text>":              ["<text><letter_space>", "<letter_space>"],
    "<letter>":            srange(string.ascii_letters + string.digits +
                                  "\"" + "'" + "."),
    "<letter_space>":      srange(string.ascii_letters + string.digits +
                                  "\"" + "'" + " " + "\t"),
}

assert is_valid_grammar(XML_GRAMMAR)

为了将输入解析成推导树，我们使用 Earley 解析器。

from Parser import EarleyParser, Parser
from GrammarFuzzer import display_tree, DerivationTree

让我们在一个简单的 HTML 输入上运行解析器，并显示所有可能的解析树。解析树表示根据给定语法的输入结构。

from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import display

parser = EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS)

for tree in parser.parse("<html>Text</html>"):
    display(display_tree(tree))

posted @ 2025-12-13 18:14 绝不原创的飞龙阅读(0) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

模糊测试之书-八-

模糊测试之书（八）

基于语法的灰盒模糊测试

概述

使用字典进行模糊测试

使用输入片段进行模糊测试

基于输入区域的模糊测试

背景

使用字典进行模糊测试

使用输入片段进行模糊测试

解析和重新组合 JavaScript，或如何在四周内赚取 50,000 美元

解析和重新组合 HTML

构建片段池

基于片段的变异

基于片段的模糊测试

与 Greybox Fuzzing 集成

基于输入区域的模糊

确定符号区域

基于区域的变异

与 Greybox Fuzzing 集成

关注有效种子

矿化种子

经验教训

背景

下一步

练习

练习 1：大型灰盒模糊器对决

如何引用这篇作品

减少导致失败的输入

概述

为什么缩减？

手动输入缩减

Delta Debugging

测验

基于语法的输入简化

词汇简化与句法规则

基于语法的简化方法

通过替换子树进行简化

通过替代扩展进行简化

一些辅助工具

简化策略

寻找子树

替代展开

两种策略结合

简化策略

深度优先策略

比较策略

经验教训

下一步

背景

练习

练习 1：基于变异的模糊测试与缩减

练习 2：通过生产进行缩减

练习 3：大规模缩减竞赛

如何引用本作品

公告