boofuzz中文翻译第四章（三）

4.5.4 控制台-GUI日志记录

class boofuzz.FuzzLoggerCurses(web_port=26000, web_address='localhost', window_height=40,
window_width=130, auto_scroll=True, max_log_lines=500,
wait_on_quit=True, min_refresh_rate=1000, bytes_to_str=<function
hex_to_hexstr>)

继承自 IFuzzLogger
此类使用curses格式化FuzzLogger数据以适用于控制台GUI。在Windows上尚未进行测试。
INDENT_SIZE = 2
close_test()
在测试完成后调用。可用于通知操作员或保存测试日志。
参数:无
类型:无
返回值:无
返回类型:无
close_test_case()
在测试用例完成后调用。可用于通知操作员或保存测试用例日志。
参数:无
类型:无
返回值:无
返回类型:无
log_check(description)
记录对被测试系统的检查。也称为“检测检查”。
参数:description (str) – 接收到的数据。
返回值:无
返回类型:无
log_error(description=‘’, indent_size=2)
记录一个内部错误。这将通知操作员测试未成功完成。
参数:description (str) – 接收到的数据。
返回值:无
返回类型:无
log_fail(description=‘’, indent_size=2)
记录一个未通过的检查。这将标记一个模糊测试用例为潜在的错误或异常。
参数:description (str) – 可选的补充数据。
返回值:无
返回类型:无
log_info(description)
用于记录测试信息的通用方法
参数:description (str) – 信息。
返回值:无
返回类型:无

**open_test_step(description) **

打开一个测试步骤 - 例如，“模糊测试”，“预模糊”，“响应检查”。

参数:description – 模糊测试步骤的描述。

返回值:无

请注意，由于原文中存在一些格式问题（例如参数列表的格式），在翻译时我尽量保持了原文的结构和风格。

4.5.5 FuzzLogger Object

class boofuzz.FuzzLogger(fuzz_loggers=None)

继承自 IFuzzLogger
接收一个 IFuzzLogger 对象列表，并将记录的数据多路复用到每个对象。
FuzzLogger 还维护了失败和错误数据的摘要。
参数
fuzz_loggers (IFuzzLogger 列表) – 要发送日志数据的 IFuzzLogger 对象。

close_test()

用途： 在测试完成后调用，用于通知操作员或保存测试日志。

参数： 无。

返回值：无。

close_test_case()

用途： 在测试用例完成后调用，用于通知操作员或保存测试用例日志。

参数：无。

返回值： 无。

failure_summary()

用途： 根据 fuzz logger（模糊测试日志）的结果返回测试的摘要字符串，通常是多行的总结信息。

返回值：测试摘要字符串，可能是多行的。

log_check(description)

用途：记录对被测试系统的检查，也称为“检测检查”。

参数：

description (str)：关于检查的描述。

返回值： 无。

log_error(description)

用途：记录一个内部错误，通知操作员测试没有成功完成。

参数：

description (str)：关于错误的描述。

返回值： 无。

log_fail(description=‘’)

用途： 记录一个检查失败的情况。这将标记一个模糊测试案例为潜在的 bug 或异常。

参数：

description (str)：一个可选的补充数据，用于描述失败的情况。

返回值：无。

log_info(description)

用途： 用于记录测试信息的通用方法。

参数：

• description (str)：要记录的信息。

返回值： 无。

log_pass(description=‘’)

用途：记录某个检查通过的情况。

参数：

• description (str)：一个可选的补充数据，用于描述通过的情况。

返回值： 无

log_recv(data)

用途：记录从目标系统接收到的数据，通常用于日志记录。

参数：

• data (bytes)：接收到的数据。

返回值：无。
返回类型：无
log_send(data)

记录数据作为即将发送到目标的。
参数：data (bytes) – 发送的数据
返回值：无
返回类型：无
Perperty most_recent_test_id
返回一个值（例如字符串），代表最近的测试用例。
**open_test_case(test_case_id, name, index, *args, kwargs)
打开一个测试用例 - 例如，一个 fuzzing 变异。
参数

• test_case_id – 测试用例名称/编号。应该是唯一的。
• name (str) – 对于测试用例的人类可读和唯一的名称。
• index (int) – 测试用例的数字索引

返回值:无
open_test_step(description)
打开一个测试步骤 - 例如，“Fuzzing”, “Pre-fuzz”, “Response Check.”
参数

description – fuzzing 步骤的描述。

返回值:无

4.6 协议定义

对于旧式的 Spike 风格静态协议定义格式，请参见静态协议定义函数。这里描述的非静态协议定义是较新的（但仍然有些实验性质）方法。
请参阅快速入门指南，了解如何使用 boofuzz 以及一个基本的协议定义示例。

4.6.1 概述

请求是消息，块是消息内的片段，而原语是构成块/请求的元素（字节、字符串、数字、校验和等）。
4.6.2 示例
以下是一个 HTTP 消息的示例。它演示了如何使用请求、块和几个原语：

req = Request("HTTP-Request", children=(
Block("Request-Line", children=(
Group("Method", values=["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT",
"OPTIONS", "TRACE"]),
Delim("space-1", " "),
String("URI", "/index.html"),
Delim("space-2", " "),
String("HTTP-Version", "HTTP/1.1"),
Static("CRLF", "\r\n"),
)),
Block("Host-Line", children=(
String("Host-Key", "Host:"),
Delim("space", " "),
String("Host-Value", "example.com"),
Static("CRLF", "\r\n"),
)),
Static("CRLF", "\r\n"),
))

4.6.3 请求

boofuzz.Request(name=None, children=None)

顶级容器。可以包含任何块结构或原语。
基本上可以将其视为一个超级块、根块、父块或您喜欢的任何其他别名。
参数

• name (str, 可选) – 此请求的名称
• children (boofuzz.Fuzzable, 可选) – 此请求的子项，默认为 None

4.6.4 块

Block

boofuzz.Block(name=None, default_value=None, request=None, children=None, group=None, encoder=None,
dep=None, dep_value=None, dep_values=None, dep_compare='==', *args, **kwargs)

基本构建块。可以包含原语、大小调整器、校验和或其他块。
参数

• name (str, 可选) – 名称，用于后续引用。名称应始终提供，如果没有，则会给出默认名称，默认为 None
• default_value (Any, 可选) – 当元素未被模糊测试时使用的值 - 通常应表示有效值，默认为 None
• request (boofuzz.Request, 可选) – 此块所属的请求，默认为 None
• children (boofuzz.Fuzzable, 可选) – 此块的子项，默认为 None
• group (str, 可选) – 与该块关联的组的名称，默认为 None
• encoder (callable, 可选) – 可选的函数指针，用于在返回前传递渲染后的数据，默认为 None
• dep (str, 可选) – 此块依赖的特定值的可选原语，默认为 None
• dep_value (Any, 可选) – 字段“dep”必须包含的值，以便块被渲染，默认为 None
• dep_values (list, 可选) – 字段“dep”可能包含的值，以便块被渲染，默认为 None
• dep_compare (str, 可选) – 应用于依赖关系的比较方法（==, !=, >, >=, <, <=），默认为 None

校验和

boofuzz.Checksum(name=None, block_name=None, request=None, algorithm='crc32', length=0, endian='<',
ipv4_src_block_name=None, ipv4_dst_block_name=None, *args, **kwargs)

绑定到具有指定名称的块的校验和。
可以通过 algorithm 参数按名称选择算法，或者可以使用 algorithm 参数指定自定义函数。
length 字段仅对自定义算法必要。使用自己的自定义校验和函数时，返回值应为数据的计算校验和。
函数签名：<function_name>(data_bytes)。返回一个表示为 bytes 类型的数字。
支持递归校验和；校验和字段本身将渲染为所有零，以便进行校验和或长度计算。
参数

• name (str, 可选) – 名称，用于后续引用。名称应始终提供，如果没有，则会给出默认名称，默认为 None
• block_name (str) – 目标块的名称，用于校验和计算。
• request (boofuzz.Request, 可选) – 此块所属的请求
• algorithm (str, 函数定义名称, 可选) – 要使用的校验和算法，来自此列表，默认为 crc32 (crc32, crc32c, adler32, md5, sha1, ipv4, udp)。请参阅上面的自定义校验和函数示例。
• length (int, 可选) – 校验和长度，默认自动计算。使用自定义算法时必须手动指定，默认为 0
• endian (chr, 可选) – 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >），默认为 LITTLE_ENDIAN
• ipv4_src_block_name (str, 可选) – 对于 'udp' 算法是必需的。产生 IPv4 源地址的块的名称，默认为 None

• ipv4_dst_block_name (str, 可选) – 对于‘udp’算法是必需的。产生IPv4目的地址的块的名称，默认为None
• fuzzable (bool, 可选) – 启用/禁用此块的模糊测试，默认为true

Repeat

boofuzz.Repeat(name=None, block_name=None, request=None, min_reps=0, max_reps=25, step=1,
variable=None, default_value=None, *args, **kwargs)

重复指定块的渲染内容，从min_reps循环到max_reps，按step计数。
默认情况下，它不会渲染任何内容。这个块修饰符对于模糊测试表项中的溢出很有用。这个块修饰符必须在它所应用的块之后。
参数

• name (str, 可选) – 名称，用于后续引用。名称应该始终提供，如果没有，则会给出一个默认名称，默认为None
• block_name (str, 可选) – 要重复的块的名称
• request (boofuzz.Request, 可选) – 此块所属的请求，默认为None
• min_reps (int, 可选) – 块重复的最小次数，默认为0
• max_reps (int, 可选) – 块重复的最大次数，默认为None
• step (int, 可选) – min和max reps之间的步数，默认为1
• variable (Boofuzz Integer Primitive, 可选) – 重复次数将由此变量派生，禁用模糊测试，默认为None
• default_value (Raw) – 当元素未被模糊测试时使用的值 - 应该通常代表一个有效值，默认为None
• fuzzable (bool, 可选) – 启用/禁用此块的模糊测试，默认为true

Size

boofuzz.Size(name=None, block_name=None, request=None, offset=0, length=4, endian='<',
output_format='binary', inclusive=False, signed=False, math=None, *args, **kwargs)

创建一个绑定到指定名称的块的大小器。允许大小器调整其父块或祖父块的大小。
参数

• name (str, 可选) – 名称，用于后续引用。名称应该始终提供，如果没有，则会给出一个默认名称，默认为None
• block_name (str, 可选) – 应用大小器的块的名称。
• request (boofuzz.Request, 可选) – 此块所属的请求。
• offset (int, 可选) – 计算大小值的偏移，默认为0
• length (int, 可选) – 大小器的长度，默认为4
• endian (chr, 可选) – 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >），默认为LITTLE_ENDIAN
• output_format (str, 可选) – 输出格式，“binary”或“ascii”，默认为binary
• inclusive (bool, 可选) – 大小器是否计算自己的长度？默认为False
• signed (bool, 可选) – 使大小器有符号还是无符号（仅适用于format=”ascii”），默认为False
• math (def , 可选) – 将在此函数中定义的数学操作应用于大小，默认为None
• fuzzable (bool, 可选) – 启用/禁用此块的模糊测试，默认为true

Aligned

boofuzz.Aligned(name=None, modulus=1, request=None, pattern=b'\x00', *args, **kwargs)

一个可模糊测试的块，它将其内容对齐到一定数量的字节
参数

• name (str, 可选) – 名称，用于后续引用。名称应该始终提供，如果没有，则会给出一个默认名称，默认为None
• modulus (int, 可选) – 将子内容的填充长度填充到这么多字节，默认为1
• request (boofuzz.Request, 可选) – 此块所属的请求
• pattern (bytes, 可选) – 使用这些字节填充
• fuzzable (bool, 可选) – 启用/禁用此块的模糊测试，默认为true

4.6.5 原语

Static

boofuzz.Static(name=None, default_value=None, *args, **kwargs)

静态原语在模糊测试时是固定的，不会被改变。
参数

• name (str, 可选) – 名称，用于后续引用。名称应该始终提供，如果没有，则会给出一个默认名称，默认为None
• default_value (Raw, 可选) – 原始静态数据

简单

boofuzz.Simple(name=None, default_value=None, fuzz_values=None, *args, **kwargs)

只有手动指定的模糊值的简单字节值。
参数

• name (str, 可选) – 名称，用于后续引用。名称应该始终提供，如果没有，则会给出一个默认名称，默认为None
• default_value (Raw, 可选) – 原始静态数据
• fuzz_values (list, 可选) – 模糊值列表，默认为None。如果为空，Simple等同于Static。
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

Delim

boofuzz.Delim(name=None, default_value=' ', *args, **kwargs)

代表一个分隔符，如：:、\r、\n、空格、=、>、<等。变异包括重复、替换和排除。
参数

• name (str, 可选) – 名称，用于后续引用。应始终提供名称，如果没有，则会给出一个默认名称，默认为None
• default_value (char, 可选) – 当元素未被模糊测试时使用的值 - 应通常代表一个有效值。
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

Group

boofuzz.Group(name=None, values=None, default_value=None, encoding='ascii', *args, **kwargs)

这个原语代表一个静态值列表，在变异时逐一遍历每个值。
你可以将一个块绑定到一个组原语，以指定该块应该循环遍历组内每个值的所有可能变异。组原语对于例如表示有效操作码列表很有用。
参数

• name (str, 可选) – 名称，用于后续引用。应始终提供名称，如果没有，则会给出一个默认名称，默认为None
• values (bytes列表或str列表) – 此组可能接受的可能原始值列表。
• default_value (str, 可选) – 当元素未被模糊测试时使用的值 - 应通常代表一个有效值，默认为None
• encoding (str, 可选) – 字符串编码，例如：utf_16_le用于Microsoft Unicode，默认为ascii
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

RandomData

boofuzz.RandomData(name=None, default_value='', min_length=0, max_length=1, max_mutations=25,
step=None, *args, **kwargs)

生成随机数据块的同时保留原始副本。
可以指定随机长度范围。对于静态长度，请将最小/最大长度设置为相同。
参数

• name (str, 可选) – 名称，用于后续引用。应始终提供名称，如果没有，则会给出一个默认名称，默认为None
• default_value (str或bytes, 可选) – 当元素未被模糊测试时使用的值 - 应通常代表一个有效值，默认为None
• min_length (int, 可选) – 随机块的最小长度，默认为0
• max_length (int, 可选) – 随机块的最大长度，默认为1
• max_mutations (int, 可选) – 在恢复默认值之前进行的变异次数，默认为25
• step (int, 可选) – 如果不是None，则为最小和最大重复之间的步数，否则随机，默认为None
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

String

boofuzz.String(name=None, default_value='', size=None, padding=b'\x00', encoding='utf-8', max_len=None,
*args, **kwargs)

循环遍历一个“坏”字符串库的原语。
类变量‘fuzz_library’包含一个全局跨所有实例的智能模糊值列表。变量‘this_library’包含特定于实例化原语的模糊值。这允许我们避免在每个实例化原语之间复制近70MB的fuzz_library数据结构。
参数

• name (str, 可选) – 名称，用于后续引用。应始终提供名称，如果没有，则会给出一个默认名称，默认为None
• default_value (str) – 当元素未被模糊测试时使用的值 - 应通常代表一个有效值。
• size (int, 可选) – 此字段的静态大小，对于动态请留空，默认为None
• padding (chr, 可选) – 用作填充以填充静态字段大小的值，默认为“\x00”
• encoding (str, 可选) – 字符串编码，例如：utf_16_le用于Microsoft Unicode，默认为ascii
• max_len (int, 可选) – 最大字符串长度，默认为None
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

FromFile

boofuzz.FromFile(name=None, default_value=b'', filename=None, max_len=0, *args, **kwargs)

从文件中循环遍历一系列“坏”值。
接受文件名并打开文件以读取用于模糊测试过程的值。文件名可能包含通配符字符。
参数

• name (str, 可选) – 名称，用于后续引用。应始终提供名称，如果没有，则会给出一个默认名称，默认为None
• default_value (bytes) – 默认字节值
• filename (str) – 加载所有模糊值的文件名模式
• max_len (int, 可选) – 最大字符串长度，默认为0
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

Mirror

boofuzz.Mirror(name=None, primitive_name=None, request=None, *args, **kwargs)

用于与另一个原语保持更新的原语。
参数

• name (str, 可选) – 名称，用于后续引用。应始终提供名称，如果没有，则会给出一个默认名称，默认为None
• primitive_name (str) – 目标原语的名称。
• request (boofuzz.Request) – 此原语所属的请求。
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

BitField

boofuzz.BitField(name=None, default_value=0, width=8, max_num=None, endian='<',output_format='binary', signed=False, full_range=False, *args, **kwargs)

位字段原语代表一个可变长度的数字，并用于定义所有其他整数类型。
参数

• name (str, 可选) – 名称，用于后续引用。应始终提供名称，如果没有，则会给出一个默认名称，默认为None
• default_value (int, 可选) – 默认整数值，默认为0
• width (int, 可选) – 位宽，默认为8位
• max_num (int, 可选) – 最大迭代数，默认为None
• endian (char, 可选) – 位字段的字节序（小端序: <, 大端序: >），默认为小端序
• output_format (str, 可选) – 输出格式，“binary”或“ascii”，默认为binary
• signed (bool, 可选) – 使大小为有符号还是无符号（仅适用于format=”ascii”时），默认为False
• full_range (bool, 可选) – 如果启用，则字段会变异通过所有可能的值，默认为False
• fuzz_values (list, 可选) – 添加到正常变异的自定义模糊值列表，默认为None
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

Byte

boofuzz.Byte(*args, **kwargs)

字节大小的位字段原语。
参数

• name (str, 可选) – 名称，用于后续引用。应始终提供名称，如果没有，则会给出一个默认名称，默认为None
• default_value (int, 可选) – 默认整数值，默认为0
• max_num (int, 可选) – 最大迭代数，默认为None
• endian (char, 可选) – 位字段的字节序（小端序: <, 大端序: >），默认为小端序
• output_format (str, 可选) – 输出格式，“binary”或“ascii”，默认为binary
• signed (bool, 可选) – 使大小为有符号还是无符号（仅适用于format=”ascii”时），默认为False
• full_range (bool, 可选) – 如果启用，则字段会变异通过所有可能的值，默认为False
• fuzz_values (list, 可选) – 添加到正常变异的自定义模糊值列表，默认为None
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

Bytes

boofuzz.Bytes(name: str = None, default_value: bytes = b'', size: int = None, padding: bytes = b'\x00', max_len: int = None, *args, **kwargs)

原语，用于模糊测试具有任意长度的二进制字节字符串。
参数

• name (str, 可选) – 名称，用于之后引用。应始终提供名称，如果没有，则会给出默认名称，默认为None
• default_value (bytes, 可选) – 当元素未被模糊测试时使用的值 - 应通常代表一个有效值，默认为b””
• size (int, 可选) – 此字段的静态大小，留空为动态，默认为None
• padding (chr, 可选) – 用作填充以填充静态字段大小的值，默认为b”x00”
• max_len (int, 可选) – 最大字符串长度，默认为None
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

Word

boofuzz.Word(*args, **kwargs)*

2字节大小的位字段原语。
参数

• name (str, 可选) – 名称，用于之后引用。应始终提供名称，如果没有，则会给出默认名称，默认为None
• default_value (int, 可选) – 默认整数值，默认为0
• max_num (int, 可选) – 最大迭代数，默认为None
• endian (char, 可选) – 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >），默认为LITTLE_ENDIAN
• output_format (str, 可选) – 输出格式，“binary”或“ascii”，默认为binary
• signed (bool, 可选) – 使大小为有符号还是无符号（仅适用于format=”ascii”），默认为False
• full_range (bool, 可选) – 如果启用，字段将变异通过所有可能的值，默认为False
• fuzz_values (list, 可选) – 添加到正常变异的自定义模糊值列表，默认为None
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

DWord

boofuzz.DWord(*args, **kwargs)*

4字节大小的位字段原语。
参数

• name (str, 可选) – 名称，用于之后引用。应始终提供名称，如果没有，则会给出默认名称，默认为None
• default_value (int, 可选) – 默认整数值，默认为0
• max_num (int, 可选) – 最大迭代数，默认为None
• endian (char, 可选) – 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >），默认为LITTLE_ENDIAN
• output_format (str, 可选) – 输出格式，“binary”或“ascii”，默认为binary
• signed (bool, 可选) – 使大小为有符号还是无符号（仅适用于format=”ascii”），默认为False
• full_range (bool, 可选) – 如果启用，字段将变异通过所有可能的值，默认为False
• fuzz_values (list, 可选) – 添加到正常变异的自定义模糊值列表，默认为None
• fuzzable (bool, 可选) – 启用/禁用此原语的模糊测试，默认为true

QWord

boofuzz.QWord(*args, **kwargs)

8字节大小的位字段原语。
参数

• name (str, 可选) – 名称，用于之后引用。应始终提供名称，如果没有，则会给出默认名称，默认为None
• default_value (int, 可选) – 默认整数值，默认为0
• max_num (int, 可选) – 最大迭代数，默认为None
• endian (char, 可选) – 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >），默认为LITTLE_ENDIAN
• output_format (str, 可选) – 输出格式，“binary”或“ascii”，默认为binary
• signed (bool, 可选) – 使大小为有符号还是无符号（仅适用于format=”ascii”），默认为False
• full_range (bool, 可选) – 如果启用，字段将变异通过所有可能的值，默认为False
• fuzz_values (列表，可选) – 添加到正常变异中的自定义模糊值列表，默认为None
• fuzzable (布尔值，可选) – 启用/禁用此原语的模糊测试，默认为true

4.6.6 创建自己的块/原语

现在我知道你在想：“有那么多甜美的原语和块可用，我还能需要什么？然而，我被快乐所驱使，想要贡献我自己的甜块！”
要创建自己的块/原语：

1. 创建一个继承自Fuzzable或FuzzableBlock的对象

2. 重写mutations和/或encode。

3. 可选：创建一个伴随的静态原语函数。参见boofuzz的__init__.py文件中的示例。

4. ???

5. 获利！

如果你的块依赖于对其他块的引用，就像校验和或长度字段依赖于消息的其他部分一样，请参阅Size源代码，了解如何避免递归问题，并请小心。😃

class boofuzz.Fuzzable(name=None, default_value=None, fuzzable=True, fuzz_values=None)

继承自：object
所有原语和块的父类。
创建新的可模糊类型时，通常会覆盖mutations()和/或encode()。
mutations()是一个生成器函数，产生变异，通常是字节类型。
encode()是一个函数，它接受一个值并对其进行编码。值来自mutations()或default_value。FuzzableBlock类型还可以编码由子节点生成的数据。
实现者可能还想覆盖num_mutations() - 默认实现手动耗尽mutations()以获得数量。
其余的方法由boofuzz用于处理模糊测试，并且通常不被覆盖。
参数

• name (str, 可选) - 名称，用于后续引用。应始终提供名称，如果没有，则会给出默认名称，默认为None
• default_value (Any, 可选) - 当元素未被模糊测试时使用的值 - 应通常代表一个有效值。可以是静态值，或是一个ReferenceValueTestCaseSession，默认为None
• fuzzable (bool, 可选) - 启用此原语的模糊测试，默认为True
• fuzz_values (list, 可选) - 添加到正常变异的自定义模糊值列表，默认为None

Property context_path
描述到此元素路径的点分隔字符串。在对象附加到Req后配置。

encode(value, mutation_context)
将一个值编码/渲染/序列化为字节（字节字符串）。
如果mutations()产生字节，则为可选。
示例：使用mutations()产生字符串，并使用encode()将它们编码为UTF-8。
默认行为：返回值。
参数

• value – 要编码的值。类型应与mutations()产生的类型匹配。
• mutation_context (MutationContext) – 当前突变的上下文，如果有的话。

返回值:编码/序列化的值。
返回类型:bytes
Property fuzzable
如果为False，则在正常模糊测试中不应突变此元素。
get_mutations()
迭代突变。由boofuzz框架使用。
产生
Mutation列表 – 突变
get_num_mutations()
get_value(mutation_context=None)
获取当前适用值的辅助方法。
这要么是默认值，要么是根据mutation_context指示的活动突变值。
参数:

mutation_context (MutationContext) 

返回值：

mutations(default_value)

生成此元素的突变值的生成器。
值可以是普通值，也可以是接受“默认值”并对其进行突变的可调用函数。当默认值或“正常”值影响模糊值时使用函数。函数的使用是因为“正常”值有时是动态的，在生成时并不知道。
每个突变应该是一个预先渲染的值。也就是说，它必须适合传递给encode()。
默认：空迭代器。
参数

default_value 

Property name
元素名称，每个实例应该是唯一的。
返回类型:str
name_counter = 0
num_mutations(default_value)
返回此元素的总突变数（不包括“fuzz_values”）。
默认实现耗尽mutations()生成器，这是低效的。如果你能更有效地提供值，或者耗尽mutations()生成器有副作用，请覆盖。
参数

default_value - 如果突变数依赖于默认值，请使用。由FuzzableWrapper提供。注意：通常良好的行为是对于给定的默认值长度，突变数是一致的。

返回值:这个原始类型可以采取的突变形式的数量
返回类型:int
original_value(test_case_context=None)
元素的原始，未突变的值。
参数

test_case_context (ProtocolSession) – 用于解析ReferenceValueTestCaseSession类型默认值。

返回值：
Property qualified_name
用点分隔的名称，描述请求名称和请求内元素的路径。
示例：“request1.block1.block2.node1”
render(mutation_context=None)
在应用突变后渲染（如果适用）。
Property request
对附加此对象的请求的引用。
stop_mutations()
停止在当前运行的mutations()调用上产生突变。
由boofuzz用于在元素已经引起多次失败时停止模糊测试。
返回值:None
返回类型:NoneType

class boofuzz.FuzzableBlock(name=None, request=None, children=None, *args, **kwargs)

继承自 Fuzzable
设计为具有子元素的可突变类型。
FuzzableBlock重写了以下方法，改变了基于FuzzableBlock的任何类型的默认行为：

1. mutations() 遍历所有子节点产生的突变。

2. num_mutations() 汇总每个子节点代表的突变。

3. encode() 调用get_child_data()。
   FuzzableBlock添加了以下方法:///

4. get_child_data() 渲染并连接所有子节点。

5. push() 添加一个额外的子节点；通常仅在内部使用。
   参数
   • name (str, 可选) – 名称，用于之后引用。应始终提供名称，如果没有提供，则会赋予一个默认名称，默认为 None
   • request (boofuzz.Request, 可选) – 此块所属的请求，默认为 None
   • children (boofuzz.Fuzzable, 可选) – 子节点列表（通常给 FuzzableBlock 类型），默认为 None
   encode(value, mutation_context)
   接受一个值并将其编码/渲染/序列化为字节（字节字符串）。
   如果 mutations() 产生字节，则为可选。
   示例：使用 mutations() 产生字符串，并使用 encode() 将其编码为 UTF-8。
   默认行为：返回值。
   参数
   • value – 要编码的值。类型应与 mutations() 产生的类型匹配
   • mutation_context (MutationContext) – 当前变异的上下文，如果有。
   返回
   编码/序列化的值。
   返回类型
   bytes
   get_child_data(mutation_context)
   获取此节点的子节点或引用数据。
   对于从消息结构中引用其他数据的块（例如大小、校验和、块）。参见 FuzzableBlock 示例。
   参数
   mutation_context (MutationContext) – 变异上下文。
   返回
   子节点数据。
   返回类型
   bytes
   mutations(default_value, skip_elements=None)
   生成此元素的变异值的生成器。
   值可以是普通值或可调用函数，这些函数接受一个“默认值”并对其进行变异。当默认值或“正常”值影响变异值时使用函数。函数被使用是因为“正常”值有时是动态的，在生成时并不知道。
   每次变异应为预渲染的值。也就是说，它必须适合传递给 encode()。
   默认：空迭代器。
   参数
   default_value –
   4.6. 协议定义 63boofuzz 文档，发布 0.4.1
   num_mutations(default_value=None)
   返回此元素的总变异次数（不包括“fuzz_values”）。
   默认实现耗尽 mutations() 生成器，这是低效的。如果可以更有效地提供值，或者耗尽 mutations() 生成器有副作用，请重写。
   参数
   default_value – 如果变异次数取决于默认值，请使用。由 FuzzableWrapper 提供。注意：通常，对于给定的默认值长度，具有恒定数量的变异是一个好习惯。
   返回
   此基本类型可以采取的变异形式数量
   返回类型
   int
   push(item)
   将一个子元素推送到此块的堆栈上。
   参数
   item (Fuzzable) – 某些包装的 Fuzzable 元素
   返回：None

4.7 静态协议定义

通过 boofuzz 中的静态函数定义协议是从 Spike 继承的。参见协议定义函数，了解一种更新的、尽管仍是实验性的格式。
参见快速入门指南，了解如何在一般情况下使用 boofuzz。
请求是消息，块是消息中的块，而原语是构成块/请求的元素（字节、字符串、数字、校验和等）。

4.7.1 请求操作

boofuzz.s_initialize(name)

初始化一个新的块请求。在此调用之后生成的所有块/原语都适用于命名请求。使用 s_switch() 在工厂之间切换。
参数

name (str) – 请求的名称
boofuzz.s_get(name=None)

返回指定名称的请求，如果没有指定名称，则返回当前请求。使用此方法从全局函数样式请求操作切换到直接对象操作。示例：

req = s_get("HTTP BASIC")
print(req.num_mutations())

选定的请求也被设置为默认当前。（即：隐含 s_switch(name)）。
参数

name (str) – （可选，默认为 None）要返回的请求名称，如果没有名称，则为当前请求。

返回类型:blocks.Request
返回:所请求的请求。

boofuzz.s_num_mutations()

确定我们将进行的重复次数。
返回类型:int
返回:此原语可以采取的变异形式数量。

boofuzz.s_switch(name)

将当前请求更改为由“name”指定的请求。
参数

name (str) – 请求的名称

4.7.2 块操作

boofuzz.s_block(name=None, group=None, encoder=None, dep=None, dep_value=None, dep_values=None,
dep_compare='==')

在当前请求下打开一个新的块。返回的实例支持“with”接口，因此它将自动为您关闭：

with s_block("header"):
    s_static("\x00\x01")
    if s_block_start("body"):
       ...

参数

• name (str, optional) – 打开的块的名称
• group (str, optional) – (可选, 默认=None) 与此块关联的组的名称
• encoder (Function Pointer, optional) – (可选, 默认=None) 可选的函数指针，用于在返回之前传递渲染的数据
• dep (str, optional) – (可选, 默认=None) 此块依赖的特定值的可选基本类型
• dep_value (Mixed, optional) – (可选, 默认=None) 字段“dep”必须包含的值，以便渲染块
• dep_values (List of Mixed Types, optional) – (可选, 默认=None) 字段“dep”可能包含的值，以便渲染块
• dep_compare (str, optional) – (可选, 默认=”==”) 用于依赖关系的比较方法 (==, !=, >, >=, <, <=)

boofuzz.s_block_start(name=None, *args, **kwargs)

在当前请求下打开一个新的块。此例程总是返回一个实例，因此您可以使用缩进来美化您的模糊器：

if s_block_start("header"):
    s_static("\x00\x01")
    if s_block_start("body"):
    ...
s_block_close()

:note 建议使用 s_block 而不是这个函数直接 :see s_block

boofuzz.s_block_end(name=None)

关闭最后打开的块。可选地指定要关闭的块的名称（纯粹出于美观目的）。
参数

name (str) – (可选, 默认=None) 要关闭的块的名称。
boofuzz.s_checksum(block_name=None, algorithm='crc32', length=0, endian='<', fuzzable=True, name=None,
ipv4_src_block_name=None, ipv4_dst_block_name=None)

绑定到指定名称的块的校验和。
可以通过名称选择算法参数指定的算法，或者可以使用算法参数指定自定义函数。
长度字段仅对自定义算法必要。
支持递归校验和；校验和字段本身将渲染为所有零，以便进行校验和或长度计算。
参数

• block_name (str, optional) – 校验和计算的目标块的名称。
• algorithm (str, function, optional) – 要使用的校验和算法。(crc32, crc32c,
adler32, md5, sha1, ipv4, udp) 传递一个函数以使用自定义算法。此函数必须接受并返回字节类型的数据，默认为 crc32
• length (int, optional) – 校验和的长度，默认自动计算。使用自定义算法时必须手动指定，默认为 0
• endian (chr, optional) – 位字段的字节序 (LITTLE_ENDIAN: <,
BIG_ENDIAN: >), 默认为 LITTLE_ENDIAN
• fuzzable (bool, optional) – 启用/禁用模糊测试。
• name (str, optional) – 用于后续引用的名称。应始终提供名称，如果没有，则会给出默认名称，默认为 None
• ipv4_src_block_name (str, optional) – ‘udp’算法所必需。产生 IPv4 源地址的块的名称，默认为 None
• ipv4_dst_block_name (str, optional) – ‘udp’算法所必需。产生 IPv4 目的地址的块的名称，默认为 None
boofuzz.s_repeat(block_name=None, min_reps=0, max_reps=25, step=1, variable=None, fuzzable=True,
name=None)

重复指定块的渲染内容，从 min_reps 循环到 max_reps，每次计数步长。默认情况下不渲染任何内容。此块修饰符对于模糊测试表项中的溢出很有用。此块修饰符必须在它所应用的块之后使用。

别名：s_repeater()
参数

• block_name (str) – (可选, 默认=None) 要重复的块的名称
• min_reps (int) – (可选, 默认=0) 块重复的最小次数
• max_reps (int) – (可选, 默认=25) 块重复的最大次数
• step (int) – (可选, 默认=1) 最小和最大重复次数之间的步数
• variable (Sulley Integer Primitive) – (可选, 默认=None) 一个整数原语将指定重复次数
• fuzzable (bool) – (可选, 默认=True) 启用/禁用此原语的模糊测试
• name (str) – (可选, 默认=None) 指定名称可直接访问一个原语

boofuzz.s_size(block_name=None, offset=0, length=4, endian='<', output_format='binary', inclusive=False,
signed=False, math=None, fuzzable=True, name=None)

创建一个绑定到指定名称的块的大小器。您不能为任何当前打开的块创建大小器。

别名：s_sizer()
参数

• block_name (str, optional) – 应用大小器的块的名称。
• offset (int, optional) – 计算大小值的偏移量，默认为 0
• length (int, optional) – 大小器的长度，默认为 4
• endian (chr, optional) – 位字段的字节序 (LITTLE_ENDIAN: <,
BIG_ENDIAN: >), 默认为 LITTLE_ENDIAN
• output_format (str, optional) – 输出格式，“binary”或“ascii”，默认为 binary
• inclusive (bool, optional) – 大小器是否计算自己的长度？默认为 False
• signed (bool, optional) – 使大小有符号还是无符号（仅适用于 format=”ascii”），默认为 False
• math (def , optional) – 将在此函数中定义的数学运算应用于大小，默认为 None
• fuzzable (bool) – (可选, 默认=True) 启用/禁用此大小器的模糊测试
• name (str) – 此大小器字段的名称

boofuzz.s_update(name, value)

更新当前打开请求中命名原语的值。
参数

• name (str) – 我们希望更新的对象的名称
• value (Mixed) – 更新后的值int – 默认整数值
• endian (chr) – （可选，默认为LITTLE_ENDIAN）位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >）
• output_format (str) – （可选，默认为"binary"）输出格式，"binary" 或 "ascii"
• signed (bool) – （可选，默认为False）使大小为有符号与无符号（仅适用于format="ascii"时）
• full_range (bool) – 可4.7.3 原始定义

boofuzz.s_binary(value, name=None)

将变量格式的二进制字符串解析为静态值，并将其推送到当前块栈上。
参数

• value (str) – 变量格式的二进制字符串
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型

boofuzz.s_delim(value=' ', fuzzable=True, name=None)

将一个分隔符推送到当前块栈上。
参数

• value (Character) – (可选，默认为" ")原始值
• fuzzable (bool) – (可选，默认为True) 启用/禁用此原始数据类型的模糊测试
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型

boofuzz.s_group(name=None, values=None, default_value=None)

此原始数据类型代表一个静态值列表，在变异时依次遍历每个值。你可以将一个块绑定到一个组原始数据类型，以指定该块应该循环遍历组内每个值的所有可能变异。组原始数据类型例如用于表示有效操作码的列表很有用。
参数

• name (str) – (可选，默认为None) 组的名称
• values (List 或原始数据) – (可选，默认为None) 此组可以采用的可能原始值列表。
• default_value (str 或 bytes) – (可选，默认为None) 在 fuzzing() 完成时指定一个值

boofuzz.s_lego(lego_type, value=None, options=())

Lego 是预先构建的块… TODO: 完成此文档
参数

• lego_type (str) – 表示 lego 的函数
• value – 原始值
• options – 传递给 lego 的选项。

boofuzz.s_random(value='', min_length=0, max_length=1, num_mutations=25, fuzzable=True, step=None,
name=None)

生成随机数据块的同时保留原始数据的副本。可以指定随机长度范围。对于静态长度，请将最小/最大长度设置为相同。
参数

• value (str 或 bytes) – (可选，默认为"") 原始值
• min_length (int) – (可选，默认为0) 随机块的最小长度
• max_length (int) – (可选，默认为1) 随机块的最大长度
• num_mutations (int) – (可选，默认为25) 在恢复默认值之前要进行的变异次数
• fuzzable (bool) – (可选，默认为True) 启用/禁用此原始数据类型的模糊测试
• step (int) – (可选，默认为None) 如果非空，则为最小和最大重复之间的步数，否则随机
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型

boofuzz.s_static(value=None, name=None)

将静态值推送到当前块栈上。
另见
别名：s_dunno(), s_raw(), s_unknown()
参数

• value (Raw) – 原始静态数据
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型

boofuzz.s_string(value='', size=None, padding=b'\x00', encoding='ascii', fuzzable=True, max_len=None,
name=None)

将字符串推送到当前块栈上。
参数

• value (str) – (可选，默认为"") 默认字符串值
• size (int) – (可选，默认为None) 此字段的静态大小，对于动态大小则留空。
• padding (Character) – (可选，默认为"0x00") 用作填充静态字段大小的值。
• encoding (str) – (可选，默认为"ascii") 字符串编码，例如：utf_16_le 用于 Microsoft Unicode。
• fuzzable (bool) – (可选，默认为True) 启用/禁用此原始数据类型的模糊测试
• max_len (int) – (可选，默认为None) 最大字符串长度
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型

boofuzz.s_from_file(value=b'', filename=None, encoding='ascii', fuzzable=True, max_len=0, name=None)

从文件中推送值到当前块栈上。
参数

• value (bytes) – (可选，默认为b"") 默认字节值
• filename (str) – (可选，默认为None) 加载所有模糊值的文件名模式
• encoding (str) – (已弃用，默认为"ascii") 字符串编码，例如：utf_16_le 用于 Microsoft Unicode。
• fuzzable (bool) – (可选，默认为True) 启用/禁用此原始数据类型的模糊测试
• max_len (int) – (可选，默认为0) 最大字符串长度
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型

boofuzz.s_bit_field(value=0, width=8, endian='<', output_format='binary', signed=False, full_range=False,
fuzzable=True, name=None, fuzz_values=None)

将可变长度的位字段推送到当前块栈上。
别名：s_bit(), s_bits()
参数

• value (int) – (可选，默认为0) 默认整数值
• width (int) – (可选，默认为8) 位字段的宽度
• endian (Character) – (可选，默认为LITTLE_ENDIAN) 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >）
• output_format (str) – (可选，默认为binary) 输出格式，“binary”或“ascii”
• signed (bool) – (可选，默认为False) 使大小为有符号与无符号（仅适用于format=”ascii”时）
• full_range (bool) – (可选，默认为False) 如果启用，字段将通过所有可能的值进行变异。
• fuzzable (bool) – (可选，默认为True) 启用/禁用此原始数据类型的模糊测试
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型
• fuzz_values (list) – 添加到正常变异中的自定义模糊值列表。

boofuzz.s_byte(value=0, endian='<', output_format='binary', signed=False, full_range=False, fuzzable=True,
name=None, fuzz_values=None)

将一个字节推送到当前块栈上。
别名：s_char()
参数

• value (int|byte) – (可选，默认为0) 默认整数值
• endian (Character) – (可选，默认为LITTLE_ENDIAN) 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >）
• output_format (str) – (可选，默认为binary) 输出格式，“binary”或“ascii”
• signed (bool) – (可选，默认为False) 使大小为有符号与无符号（仅适用于format=”ascii”时）
• full_range (bool) – (可选，默认为False) 如果启用，字段将通过所有可能的值进行变异。
• fuzzable (bool) – (可选，默认为True) 启用/禁用此原始数据类型的模糊测试
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型
• fuzz_values (list) – 添加到正常变异中的自定义模糊值列表。

boofuzz.s_bytes(value=b'', size=None, padding=b'\x00', fuzzable=True, max_len=None, name=None)

将任意长度的字节字段推送到当前块栈上。
参数

• value (bytes) – (可选，默认为b"") 默认二进制值
• size (int) – (可选，默认为None) 此字段的静态大小，对于动态大小则留空。
• padding (chr) – (可选，默认为b"0x00") 用作填充静态字段大小的值。
• fuzzable (bool) – (可选，默认为True) 启用/禁用此原始数据类型的模糊测试
• max_len (int) – (可选，默认为None) 最大字符串长度
• name (str) – (可选，默认为None) 指定名称可以直接访问一个原始数据类型

boofuzz.s_word(value=0, endian='<', output_format='binary', signed=False, full_range=False, fuzzable=True,
name=None, fuzz_values=None)

将一个字压入当前块栈。
别名：s_short()
参数
• value ((可选，默认值=0) int) – 默认整数值
• endian (chr) – (可选，默认值=LITTLE_ENDIAN) 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >）
• output_format (str) – (可选，默认值=binary) 输出格式，“binary”或“ascii”
• signed (bool) – (可选，默认值=False) 使大小为有符号与无符号（仅适用于format=”ascii”时）
• full_range (bool) – (可选，默认值=False) 如果启用，字段将通过所有可能的值变异。
• fuzzable (bool) – (可选，默认值=True) 启用/禁用此原语的模糊测试
• name (str) – (可选，默认值=None) 指定名称可以直接访问原语
• fuzz_values (list) – 添加到正常变异的自定义模糊值列表。
boofuzz.s_dword(value=0, endian=‘<’, output_format=‘binary’, signed=False, full_range=False, fuzzable=True,
name=None, fuzz_values=None)
将一个双字压入当前块栈。
参见
别名：s_long(), s_int()
参数

• value ((可选，默认值=0) int) – 默认整数值
• endian (Character) – (可选，默认值=LITTLE_ENDIAN) 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >）
• output_format (str) – (可选，默认值=binary) 输出格式，“binary”或“ascii”
• signed (bool) – (可选，默认值=False) 使大小为有符号与无符号（仅适用于format=”ascii”时）
• full_range (bool) – (可选，默认值=False) 如果启用，字段将通过所有可能的值变异。
• fuzzable (bool) – (可选，默认值=True) 启用/禁用此原语的模糊测试
• name (str) – (可选，默认值=None) 指定名称可以直接访问原语
• fuzz_values (list) – 添加到正常变异的自定义模糊值列表。

boofuzz.s_qword(value=0, endian='<', output_format='binary', signed=False, full_range=False, fuzzable=True,
name=None, fuzz_values=None)

将一个四字压入当前块栈。
别名：s_double()
参数

• value ((可选，默认值=0) int) – 默认整数值
• endian (Character) – (可选，默认值=LITTLE_ENDIAN) 位字段的字节序（LITTLE_ENDIAN: <, BIG_ENDIAN: >）
• output_format (str) – (可选，默认值=binary) 输出格式，“binary”或“ascii”
• signed (bool) – (可选，默认值=False) 使大小为有符号与无符号（仅适用于format=”ascii”时）
• full_range (bool) – (可选，默认值=False) 如果启用，字段将通过所有可能的值变异。
• fuzzable (bool) – (可选，默认值=True) 启用/禁用此原语的模糊测试
• name (str) – (可选，默认值=None) 指定名称可以直接访问原语
• fuzz_values (list) – 添加到正常变异的自定义模糊值列表。

4.8 其他模块

4.8.1 测试用例会话引用

class boofuzz.ProtocolSessionReference(name: str, default_value)

继承自 object
指的是在单个测试用例上下文中接收到或生成的动态值。
将此对象作为原语的default_value参数传递，并确保使用回调设置引用的值，例如post_test_case_callbacks（参见Session）。
参数

• name (str) – 指向测试用例会话键。必须在协议定义中需要该值时在ProtocolSession中设置。参见Session。
• default_value – 默认值，如果元素必须在测试用例上下文之外渲染，或者有时用于生成 ///

请注意，由于原文中存在一些不完整的句子和未完成的段落，翻译也相应地保留了这些不完整性。

4.8.2 测试用例上下文

class boofuzz.ProtocolSession(session_variables=NOTHING, previous_message=None,current_message=None)

继承自：object
包含一个session_variables字典，用于存储特定于单个模糊测试用例的数据。
通常，session_variables中的值会在回调函数中设置，例如post_test_case_callbacks（参见Session）。变量可以在后续的回调函数中使用，或者由ProtocolSessionReference对象使用。

4.8.3 辅助工具

boofuzz.helpers.calculate_four_byte_padding(string, character='\x00')
boofuzz.helpers.crc16(string, value=0)
# CRC-16多项式：p(x) = x**16 + x**15 + x**2 + 1
# @param string: 要计算crc的数据。@param value: 初始CRC值。
boofuzz.helpers.crc32(string)
boofuzz.helpers.format_log_msg(msg_type, description=None, data=None, indent_size=2, timestamp=None,
truncated=False, format_type='terminal')
boofuzz.helpers.format_msg(msg, indent_level, indent_size, timestamp=None)
boofuzz.helpers.get_boofuzz_version(boofuzz_class)

解析__init__.py以获取版本字符串，并像‘v0.0.0’一样返回它。
参数

boofuzz_class (class) – 与__init__类在同一目录中的任何boofuzz类。

返回类型:str
返回:Boofuzz版本作为字符串

boofuzz.helpers.get_max_udp_size()

使用Crazy CTypes魔法执行getsockopt()，以平台无关的方式确定最大UDP负载大小。
自版本0.2.0起弃用：请使用UDPSocketConnection.max_payload()代替。
返回:当前平台支持的最大UDP数据包长度
返回类型:int

boofuzz.helpers.get_time_stamp()
boofuzz.helpers.hex_str(s)

基于s返回一个十六进制格式化的字符串。
参数

s (bytes) – 某些字符串。

返回:代表s的十六进制格式化字符串。
返回类型:str

boofuzz.helpers.hex_to_hexstr(input_bytes)

将input_bytes渲染为ASCII编码的十六进制字节，后跟最佳努力的utf-8渲染。
参数

input_bytes (bytes) – 任意字节

返回:可打印的字符串
返回类型:str

boofuzz.helpers.ip_str_to_bytes(ip)

将IP字符串转换为四字节的字节。
参数

ip – IP地址字符串，例如‘127.0.0.1’

返回：4字节表示的ip，例如b’’
返回类型：bytes
：raises ValueError如果ip不是一个合法的IP地址。

boofuzz.helpers.ipv4_checksum(msg)

返回msg的IPv4校验和。
@param msg: 要计算校验和的消息。
返回:msg的IPv4校验和。
返回类型:int

boofuzz.helpers.mkdir_safe(directory_name, file_included=False)

创建directory_name及其子目录。如果file_included为true，则移除路径的最后一个元素。

boofuzz.helpers.parse_target(target_name)
boofuzz.helpers.parse_test_case_name(test_case)

将测试用例名称解析为消息路径和变异名称列表。
示例
输入：“message1:[message1.first_byte:2, message1.second_byte:1, message1.third_byte:2]”
输出：[“message1”], [“message1.first_byte:2”, “message1.second_byte:1”, “message1.third_byte:2”]
返回:消息路径（消息名称列表）和变异名称列表。

boofuzz.helpers.path_exists(path)

为了避免文件被导入时污染，使用os

boofuzz.helpers.pause_for_signal()

以一种仍能接收信号的方式暂停当前线程，例如来自Ctrl+C的SIGINT。
实现说明：
• Linux使用signal.pause()
• Windows使用循环，每次休眠1毫秒，允许信号相对较快地中断线程。
返回:None
返回类型:None

boofuzz.helpers.str_to_bytes(value, encoding='utf-8', errors='replace')

boofuzz.helpers.udp_checksum(msg, src_addr, dst_addr)

返回msg的UDP校验和。
请记住，UDP校验和涉及创建一种伪IP头。这个头需要源和目的IP地址，这个函数将它们作为参数。
如果msg太大，校验和是未定义的，这个方法会为了校验和计算而截断它。
注意，这意味着校验和将是无效的。这种宽松的错误检查是为了支持有时生成巨大、无效数据包的模糊测试。
参数

• msg (bytes) – 要计算校验和的消息。
• src_addr (bytes) – 源IP地址 – 4字节。
• dst_addr (bytes) – 目的IP地址 – 4字节。

返回:msg的UDP校验和。
返回类型:int

boofuzz.helpers.uuid_bin_to_str(uuid)

将二进制UUID转换为人类可读的字符串。
@param uuid: 表示UUID的字节。

boofuzz.helpers.uuid_str_to_bin(uuid)

将UUID字符串转换为二进制形式。
预期的字符串输入格式与uuid_bin_to_str()的输出格式相同。
来自Core Impacket。
参数

uuid (str) – 要转换为字节的UUID字符串。

返回:UUID作为字节。
返回类型:bytes

4.8.4 IP常量

此文件包含IPv4协议的常量。

版本0.2.0变更：ip_constants已移至connections子包中。完整路径现在是boofuzz.connections.ip_constants。

boofuzz.connections.ip_constants.UDP_MAX_LENGTH_THEORETICAL = 65535
# 基于UDP数据包格式的限制，UDP数据包的理论最大长度。警告！在IPv4的上下文中，UDP数据包实际上不能这么长！
boofuzz.connections.ip_constants.UDP_MAX_PAYLOAD_IPV4_THEORETICAL = 65507
# 基于UDP和IPv4数据包格式的限制，UDP负载的理论最大长度。警告！一些系统可能会设置比这更小的负载限制。

4.8.5 PED-RPC

Boofuzz提供了一个RPC原语，用于在远程机器上托管监控器。主boofuzz实例充当客户端，连接到（远程）运行的RPC服务器实例，透明地调用在服务器实例上调用的函数，并将结果作为Python对象返回。一般来说，通过RPC接口传递的数据需要能够被pickle。
请注意，PED-RPC不提供任何形式的身份验证或授权。建议只在受信任的网络上运行它。

class boofuzz.monitors.pedrpc.Client(host, port)

继承自：object
on_new_server(new_server)
在子类中覆盖此方法，以便在RPC服务器重新启动时收到通知。

class boofuzz.monitors.pedrpc.Server(host, port)

继承自：object
主要的PED-RPC服务器类。要实现RPC服务器，请继承此类。调用serve_forever开始监听RPC命令。

serve_forever()
stop()

4.8.6 DCE-RPC

boofuzz.utils.dcerpc.bind(uuid, version)

生成绑定到指定接口所需的数据。

boofuzz.utils.dcerpc.bind_ack(data)

确保数据是绑定确认，并且…

boofuzz.utils.dcerpc.request(opnum, data)

返回一个列表，其中包含必要的5k分片块，以制作RPC请求。

4.8.7 崩溃分拣

class boofuzz.utils.crash_binning.CrashBinStruct
#继承自：object
class boofuzz.utils.crash_binning.CrashBinning
#继承自：object
@todo: 添加MySQL导入/导出。
bins = {}
crash_synopsis(crash=None)
#对于提供的崩溃，生成并返回一个报告，其中包含违规地址周围的反汇编，违规线程的ID，调用栈和SEH展开。如果没有指定崩溃，则调用last_crash_synopsis()，它返回关于最后记录的崩溃的相同信息。
@see: crash_synopsis()
@type crash: CrashBinStruct @param crash: (可选，默认为None) 要生成报告的Crash对象
@rtype: str @return: 崩溃报告
export_file(file_name)
#将整个对象结构转储到磁盘。
@see: import_file()
@type file_name: str @param file_name: 要导出到的文件名
@rtype: CrashBinning @return: self
import_file(file_name)
#从磁盘加载整个对象结构。
@see: export_file()
@type file_name: str @param file_name: 要导入的文件名
@rtype: CrashBinning @return: self
last_crash = None
last_crash_synopsis()
#对于最后记录的崩溃，生成并返回一个报告，其中包含违规地址周围的反汇编，违规线程的ID，调用栈和SEH展开。
@see: crash_synopsis()
@rtype: String @return: 崩溃报告
pydbg = None
record_crash(pydbg, extra=None)
#给定一个假设当前时间已经“崩溃”的PyDbg实例（例如访问违规），记录各种细节，如违规地址周围的反汇编，违规线程的ID，调用栈和SEH展开。将记录的数据存储在内部字典中，按异常地址进行分拣。
@type pydbg: 
  pydbg @param pydbg: 
    # PyDbg实例 @type extra: Mixed @param extra: (可选，默认为None) 你想与这个分拣一起存储的任何额外数据

4.8.8 EventHook

class boofuzz.event_hook.EventHook

继承自：object
一个使用+=和-=注册事件的EventHook。
基于spassig在此处的解决方案：http://stackoverflow.com/a/1094423/461834

**fire(*args, kwargs)
按顺序调用每个事件处理程序。

@param args: 转发到事件处理程序。@param kwargs: 转发到事件处理程序。
@return: None

4.9 更新日志

4.9.1 即将推出

功能

• 移除six兼容性模块
• 移除Python 2兼容性代码。
• 移除在类中指定对象继承。
• 添加在特定IP地址上监听的Web UI。
• 添加Python 3.11兼容性。

修复

• 在文件写入时指定编码，而不是假设默认编码
• 将默认值的类型从字符串更改为字节，用于FromFile。
• s_update原语已过时。
• 现在支持的最低Python版本是3.7。

4.9.2 v0.4.1

功能

• 添加了使用NETCONFConnection类对NETCONF服务器进行模糊测试的支持。
• 添加了对Python 3.10的支持和测试。
• 添加了Session参数db_filename以修改日志数据库的位置。

修复

• 修复了启用Web应用的检查。
• 文档化了禁用Web应用的可能性。
• 正确初始化从FuzzableBlock继承的所有子请求。
• 为Bytes原语的参数添加了类型检查，以防止不正确的使用。
• 修复了s_binary初始化中的TypeError。
• 移除多余的unicode字符串。

4.9.3 v0.4.0

功能

• 模糊测试CLI - 使用main_helper()使用boofuzz的通用模糊测试CLI与您的脚本一起使用。
• 组合模糊测试 - 现在默认一次模糊测试多个突变。
• 现在可以通过名称指定和重新运行测试用例。
• 为Session实现了视觉请求图渲染功能。
• 向Web UI添加了：运行时，执行速度，当前测试用例名称。
• 添加了简单的自定义校验和和示例用法。
• 添加了仅使用指定值进行模糊测试的Simple原语。
• 添加了支持IEEE 754编码的Float原语。
• 添加了s_float/Float使用的示例。

修复

• 澄清了Checksum原语的自定义校验和函数的文档。
• String和RandomData原语现在使用本地和独立的random实例。
• 现在支持的最低Python版本是3.6。
• 修复了模糊日志中的两个内存泄漏。

4.9.4 v0.3.0

功能

• 内存优化：高效的变异生成和智能字符串重用 - 减少内存消耗几个数量级。
• 对齐块：将内容长度对齐到一定数量的字节的倍数。
• 相对名称：现在解决Checksum，Size等的名称引用为绝对和相对名称。块和原语名称不再需要在消息中全局唯一，它们只需要在块内

局部唯一。

• 在消息之间传递数据：回调现在有一个TestCaseContext对象，可以保存稍后在测试用例中使用的数据。TestCaseSessionReference可以作为协议定义中的默认值传递。它引用的名称必须在协议中到达该消息时已保存。
• 可重写的模糊测试：为新的模糊原语定义更简单的定义。参见static.py以获取非常简单的原语示例。
• 协议定义：现在可以使用面向对象的方法而不是静态方法定义协议。
• 独立的变异和编码步骤：将启用多个变异和代码覆盖率反馈。
• Procmon：额外的调试步骤。对旧接口的部分向后兼容。
• ProcessMonitorLocal允许将procmon作为模糊器进程的一部分运行。
• 网络监控器：改进了网络接口发现（支持Linux）。
4.9. 更新日志 79boofuzz文档，发布0.4.1
• 添加了使用UnixSocketConnection类对Unix套接字进行模糊测试的支持。
• 为ProtocolSession添加了元数据以支持回调 - current_message, previous_message。
• 所有原语参数现在都是可选的关键字参数。

修复

• 多个网络界面修复。
• 多种重构和简化。
• 从Group原语中减少重复项。
• 网络监控器：修复了data_bytes计算和PcapThread同步。
• 修复了使用网络监控器时的崩溃问题。
• 现在可以通过传递一个空的日志列表使会话“静默”。
• 进程监控器：修复了Thread.isAlive以兼容Python 3.9。
• 当设置了max_len或size时，正确截断字符串原语的值。
• 当设置了max_len或size时，字符串原语不再生成重复项。
• 大幅提高了字符串到字节的转换速度。

4.9.5 v0.2.1
功能

• 添加了简单的TFTP模糊测试示例。
修复
• 修复了当发送的数据超过套接字支持时UDPSocketConnection数据截断的问题。
• 修复了procmon stop_commands的执行。
• 修复了TCP和SSL服务器连接。

4.9.6 v0.2.0
功能

• 重写了SocketConnection类，并将其拆分为按套接字类型划分的单独类。
• SocketConnection现在已弃用。请使用从BaseSocketConnection派生的类。
• 添加了在原始第2层和第3层连接上接收数据的支持。
• 第2层和第3层连接现在可以使用任意大小的有效载荷/MTU。
• 将与连接相关的模块移动到新的connections子模块。
• 添加了在给定时间或计数内重复发送数据包的功能。
• 添加了可选的超时和阈值以退出无限连接重试。
80 第4章. 公共协议库boofuzz文档，发布0.4.1
• 重新设计了Monitors，统一了接口。破坏性变更：session不再有netmon_options和procmon_options。
• SessionInfo的属性已重命名；procmon_results和netmon_results已被弃用，现在是monitor_results和monitor_data的别名。
• 新的BoofuzzFailure异常类型允许回调方法发出应停止当前测试用例的失败信号。
• 添加了process monitor的capture_output选项以捕获目标进程的stderr/stdout。
• 添加了每次启动或重启目标时调用的post-start-target回调。
• 添加了优雅停止PED-RPC Server的方法。
• 添加了新的boofuzz徽标和favicon到文档和web界面。
• 添加了FileConnection以将消息转储到文件。
• 移除了已弃用的session参数fuzz_data_logger, log_level, logfile, logfile_level和log()。
• 移除了已弃用的日志器FuzzLoggerFile。
• crc32c不再是必需的包。如果需要，请手动安装。

修复

• 修复了当输出为ascii时s_size块的大小。
• 修复了Python 3.8和Windows上的tornado问题。
• 修复了各种潜在的类型错误。
• 将requests文件夹重命名为request_definitions，因为它遮蔽了Python模块requests的名称。
• 示例已更新到当前的Boofuzz版本。
• 修改了serial_connection单元测试的计时，以提高测试的可靠性。
• 重构了旧的单元测试。
• 修复了网络监控器与Python 3的兼容性。
• 控制台GUI的次要优化。
• 修复了如果使用块，则crash_threshold_element处理的问题。
• 修复了许多bug，这些bug导致失败不会停止测试用例评估。