atheris

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Atheris

Atheris is a coverage-guided Python fuzzer built on libFuzzer. It enables fuzzing of both pure Python code and Python C extensions with integrated AddressSanitizer support for detecting memory corruption issues.

Atheris 是一款基于 libFuzzer 的覆盖率引导型 Python 模糊测试工具，它支持对纯 Python 代码和 Python C 扩展进行模糊测试，并集成了 AddressSanitizer 以检测内存损坏问题。

When to Use

适用场景

Fuzzer	Best For	Complexity
Atheris	Python code and C extensions	Low-Medium
Hypothesis	Property-based testing	Low
python-afl	AFL-style fuzzing	Medium

Choose Atheris when:

Fuzzing pure Python code with coverage guidance
Testing Python C extensions for memory corruption
Integration with libFuzzer ecosystem is desired
AddressSanitizer support is needed

模糊测试工具	最佳适用场景	复杂度
Atheris	Python 代码和 C 扩展	中低
Hypothesis	属性化测试	低
python-afl	AFL 风格模糊测试	中

选择 Atheris 的场景：

对纯 Python 代码进行覆盖率引导的模糊测试
测试 Python C 扩展的内存损坏问题
需要与 libFuzzer 生态系统集成
需要 AddressSanitizer 支持

Quick Start

快速开始

python

import sys
import atheris

@atheris.instrument_func
def test_one_input(data: bytes):
    if len(data) == 4:
        if data[0] == 0x46:  # "F"
            if data[1] == 0x55:  # "U"
                if data[2] == 0x5A:  # "Z"
                    if data[3] == 0x5A:  # "Z"
                        raise RuntimeError("You caught me")

def main():
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()

Run:

bash

python fuzz.py

python

import sys
import atheris

@atheris.instrument_func
def test_one_input(data: bytes):
    if len(data) == 4:
        if data[0] == 0x46:  # "F"
            if data[1] == 0x55:  # "U"
                if data[2] == 0x5A:  # "Z"
                    if data[3] == 0x5A:  # "Z"
                        raise RuntimeError("You caught me")

def main():
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()

运行：

bash

python fuzz.py

Installation

安装

Atheris supports 32-bit and 64-bit Linux, and macOS. We recommend fuzzing on Linux because it's simpler to manage and often faster.

Atheris 支持 32 位和 64 位 Linux 以及 macOS。我们推荐在 Linux 上进行模糊测试，因为它更易于管理且通常速度更快。

Prerequisites

前置依赖

Python 3.7 or later
Recent version of clang (preferably latest release)
For Docker users: Docker Desktop

Python 3.7 或更高版本
最新版本的 clang（推荐使用最新发行版）
Docker 用户：Docker Desktop

Linux/macOS

bash

uv pip install atheris

bash

uv pip install atheris

Docker Environment (Recommended)

Docker 环境（推荐）

For a fully operational Linux environment with all dependencies configured:

dockerfile

undefined

以下是配置好所有依赖的完整 Linux 环境：

dockerfile

undefined

https://hub.docker.com/_/python

ARG PYTHON_VERSION=3.11

FROM python:$PYTHON_VERSION-slim-bookworm

RUN python --version

RUN apt update && apt install -y
ca-certificates
wget
&& rm -rf /var/lib/apt/lists/*

ARG PYTHON_VERSION=3.11

FROM python:$PYTHON_VERSION-slim-bookworm

RUN python --version

RUN apt update && apt install -y
ca-certificates
wget
&& rm -rf /var/lib/apt/lists/*

LLVM builds version 15-19 for Debian 12 (Bookworm)

https://apt.llvm.org/bookworm/dists/

ARG LLVM_VERSION=19

RUN echo "deb http://apt.llvm.org/bookworm/ llvm-toolchain-bookworm-$LLVM_VERSION main" > /etc/apt/sources.list.d/llvm.list RUN echo "deb-src http://apt.llvm.org/bookworm/ llvm-toolchain-bookworm-$LLVM_VERSION main" >> /etc/apt/sources.list.d/llvm.list RUN wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key > /etc/apt/trusted.gpg.d/apt.llvm.org.asc

RUN apt update && apt install -y
build-essential
clang-$LLVM_VERSION
&& rm -rf /var/lib/apt/lists/*

ENV APP_DIR "/app" RUN mkdir $APP_DIR WORKDIR $APP_DIR

ENV VIRTUAL_ENV "/opt/venv" RUN python -m venv $VIRTUAL_ENV ENV PATH "$VIRTUAL_ENV/bin:$PATH"

ARG LLVM_VERSION=19

RUN apt update && apt install -y
build-essential
clang-$LLVM_VERSION
&& rm -rf /var/lib/apt/lists/*

ENV APP_DIR "/app" RUN mkdir $APP_DIR WORKDIR $APP_DIR

ENV VIRTUAL_ENV "/opt/venv" RUN python -m venv $VIRTUAL_ENV ENV PATH "$VIRTUAL_ENV/bin:$PATH"

https://github.com/google/atheris/blob/master/native_extension_fuzzing.md#step-1-compiling-your-extension

ENV CC="clang-$LLVM_VERSION" ENV CFLAGS "-fsanitize=address,fuzzer-no-link" ENV CXX="clang++-$LLVM_VERSION" ENV CXXFLAGS "-fsanitize=address,fuzzer-no-link" ENV LDSHARED="clang-$LLVM_VERSION -shared" ENV LDSHAREDXX="clang++-$LLVM_VERSION -shared" ENV ASAN_SYMBOLIZER_PATH="/usr/bin/llvm-symbolizer-$LLVM_VERSION"

Allow Atheris to find fuzzer sanitizer shared libs

https://github.com/google/atheris#building-from-source

RUN LIBFUZZER_LIB=$($CC -print-file-name=libclang_rt.fuzzer_no_main-$(uname -m).a)
python -m pip install --no-binary atheris atheris

https://github.com/google/atheris/blob/master/native_extension_fuzzing.md#option-a-sanitizerlibfuzzer-preloads

ENV LD_PRELOAD "$VIRTUAL_ENV/lib/python3.11/site-packages/asan_with_fuzzer.so"

1. Skip memory allocation failures for now, they are common, and low impact (DoS)

2. https://github.com/google/atheris/blob/master/native_extension_fuzzing.md#leak-detection

ENV ASAN_OPTIONS "allocator_may_return_null=1,detect_leaks=0"

CMD ["/bin/bash"]


Build and run:
```bash
docker build -t atheris .
docker run -it atheris

ENV ASAN_OPTIONS "allocator_may_return_null=1,detect_leaks=0"

CMD ["/bin/bash"]


构建并运行：
```bash
docker build -t atheris .
docker run -it atheris

Verification

验证

bash

python -c "import atheris; print(atheris.__version__)"

bash

python -c "import atheris; print(atheris.__version__)"

Writing a Harness

编写测试用例（Harness）

Harness Structure for Pure Python

纯 Python 代码的测试用例结构

python

import sys
import atheris

@atheris.instrument_func
def test_one_input(data: bytes):
    """
    Fuzzing entry point. Called with random byte sequences.

    Args:
        data: Random bytes generated by the fuzzer
    """
    # Add input validation if needed
    if len(data) < 1:
        return

    # Call your target function
    try:
        your_target_function(data)
    except ValueError:
        # Expected exceptions should be caught
        pass
    # Let unexpected exceptions crash (that's what we're looking for!)

def main():
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()

python

import sys
import atheris

@atheris.instrument_func
def test_one_input(data: bytes):
    """
    模糊测试入口，接收随机字节序列作为输入。

    参数:
        data: 模糊测试器生成的随机字节
    """
    # 如有需要，添加输入验证
    if len(data) < 1:
        return

    # 调用目标函数
    try:
        your_target_function(data)
    except ValueError:
        # 捕获预期的异常
        pass
    # 让未预期的异常崩溃（这正是我们要找的问题！）

def main():
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()

Harness Rules

测试用例编写规则

Do	Don't
Use `@atheris.instrument_func` for coverage	Forget to instrument target code
Catch expected exceptions	Catch all exceptions indiscriminately
Use `atheris.instrument_imports()` for libraries	Import modules after `atheris.Setup()`
Keep harness deterministic	Use randomness or time-based behavior

See Also: For detailed harness writing techniques, patterns for handling complex inputs, and advanced strategies, see the fuzz-harness-writing technique skill.

建议做法	禁止做法
使用 `@atheris.instrument_func` 来统计覆盖率	忘记对目标代码进行插桩
捕获预期的异常	无差别捕获所有异常
对库使用 `atheris.instrument_imports()`	在 `atheris.Setup()` 之后导入模块
保持测试用例的确定性	使用随机性或基于时间的行为

另请参阅： 有关编写测试用例的详细技巧、处理复杂输入的模式以及高级策略，请查看 fuzz-harness-writing 技术文档。

Fuzzing Pure Python Code

对纯 Python 代码进行模糊测试

For fuzzing broader parts of an application or library, use instrumentation functions:

python

import atheris
with atheris.instrument_imports():
    import your_module
    from another_module import target_function

def test_one_input(data: bytes):
    target_function(data)

atheris.Setup(sys.argv, test_one_input)
atheris.Fuzz()

Instrumentation Options:

```
atheris.instrument_func
```
- Decorator for single function instrumentation
```
atheris.instrument_imports()
```
- Context manager for instrumenting all imported modules
```
atheris.instrument_all()
```
- Instrument all Python code system-wide

如需对应用或库的更广泛部分进行模糊测试，请使用插桩函数：

python

import atheris
with atheris.instrument_imports():
    import your_module
    from another_module import target_function

def test_one_input(data: bytes):
    target_function(data)

atheris.Setup(sys.argv, test_one_input)
atheris.Fuzz()

插桩选项：

```
atheris.instrument_func
```
- 用于单个函数插桩的装饰器
```
atheris.instrument_imports()
```
- 用于对所有导入模块进行插桩的上下文管理器
```
atheris.instrument_all()
```
- 对系统中所有 Python 代码进行插桩

Fuzzing Python C Extensions

对 Python C 扩展进行模糊测试

Python C extensions require compilation with specific flags for instrumentation and sanitizer support.

Python C 扩展需要使用特定标志编译，以支持插桩和 sanitizer。

Environment Configuration

环境配置

If using the provided Dockerfile, these are already configured. For local setup:

bash

export CC="clang"
export CFLAGS="-fsanitize=address,fuzzer-no-link"
export CXX="clang++"
export CXXFLAGS="-fsanitize=address,fuzzer-no-link"
export LDSHARED="clang -shared"

如果使用提供的 Dockerfile，这些配置已预先设置。本地设置请执行：

bash

export CC="clang"
export CFLAGS="-fsanitize=address,fuzzer-no-link"
export CXX="clang++"
export CXXFLAGS="-fsanitize=address,fuzzer-no-link"
export LDSHARED="clang -shared"

Example: Fuzzing cbor2

示例：对 cbor2 进行模糊测试

Install the extension from source:

bash

CBOR2_BUILD_C_EXTENSION=1 python -m pip install --no-binary cbor2 cbor2==5.6.4

The

--no-binary

flag ensures the C extension is compiled locally with instrumentation.

Create

cbor2-fuzz.py

python

import sys
import atheris

从源码安装扩展：

bash

CBOR2_BUILD_C_EXTENSION=1 python -m pip install --no-binary cbor2 cbor2==5.6.4

--no-binary

标志确保 C 扩展在本地编译并带有插桩。

创建

cbor2-fuzz.py

：

python

import sys
import atheris

_cbor2 ensures the C library is imported

_cbor2 确保导入 C 库

from _cbor2 import loads

def test_one_input(data: bytes): try: loads(data) except Exception: # We're searching for memory corruption, not Python exceptions pass

def main(): atheris.Setup(sys.argv, test_one_input) atheris.Fuzz()

if name == "main": main()


Run:
```bash
python cbor2-fuzz.py

Important: When running locally (not in Docker), you must set
LD_PRELOAD
manually.

from _cbor2 import loads

def test_one_input(data: bytes): try: loads(data) except Exception: # 我们要查找的是内存损坏，而非 Python 异常 pass

def main(): atheris.Setup(sys.argv, test_one_input) atheris.Fuzz()

if name == "main": main()


运行：
```bash
python cbor2-fuzz.py

重要提示： 在本地运行（非 Docker 环境）时，必须手动设置
LD_PRELOAD
。

Corpus Management

语料库管理

Creating Initial Corpus

创建初始语料库

bash

mkdir corpus

bash

mkdir corpus

Add seed inputs

添加种子输入

echo "test data" > corpus/seed1 echo '{"key": "value"}' > corpus/seed2


Run with corpus:
```bash
python fuzz.py corpus/

echo "test data" > corpus/seed1 echo '{"key": "value"}' > corpus/seed2


使用语料库运行：
```bash
python fuzz.py corpus/

Corpus Minimization

语料库最小化

Atheris inherits corpus minimization from libFuzzer:

bash

python fuzz.py -merge=1 new_corpus/ old_corpus/

See Also: For corpus creation strategies, dictionaries, and seed selection, see the fuzzing-corpus technique skill.

Atheris 继承了 libFuzzer 的语料库最小化功能：

bash

python fuzz.py -merge=1 new_corpus/ old_corpus/

另请参阅： 有关语料库创建策略、字典和种子选择，请查看 fuzzing-corpus 技术文档。

Running Campaigns

运行测试任务

Basic Run

基础运行

bash

python fuzz.py

bash

python fuzz.py

With Corpus Directory

带语料库目录运行

bash

python fuzz.py corpus/

bash

python fuzz.py corpus/

Common Options

常用选项

bash

undefined

bash

undefined

Run for 10 minutes

运行 10 分钟

python fuzz.py -max_total_time=600

Limit input size

限制输入大小

python fuzz.py -max_len=1024

Run with multiple workers

使用多进程运行

python fuzz.py -workers=4 -jobs=4

undefined

python fuzz.py -workers=4 -jobs=4

undefined

Interpreting Output

输出解读

Output	Meaning
`NEW cov: X`	Found new coverage, corpus expanded
`pulse cov: X`	Periodic status update
`exec/s: X`	Executions per second (throughput)
`corp: X/Yb`	Corpus size: X inputs, Y bytes total
`ERROR: libFuzzer`	Crash detected

输出内容	含义
`NEW cov: X`	发现新的覆盖率，语料库已扩展
`pulse cov: X`	定期状态更新
`exec/s: X`	每秒执行次数（吞吐量）
`corp: X/Yb`	语料库大小：X 个输入，总大小 Y 字节
`ERROR: libFuzzer`	检测到崩溃

Sanitizer Integration

Sanitizer 集成

AddressSanitizer (ASan)

AddressSanitizer is automatically integrated when using the provided Docker environment or when compiling with appropriate flags.

For local setup:

bash

export CFLAGS="-fsanitize=address,fuzzer-no-link"
export CXXFLAGS="-fsanitize=address,fuzzer-no-link"

Configure ASan behavior:

bash

export ASAN_OPTIONS="allocator_may_return_null=1,detect_leaks=0"

使用提供的 Docker 环境或使用适当标志编译时，AddressSanitizer 会自动集成。

本地设置请执行：

bash

export CFLAGS="-fsanitize=address,fuzzer-no-link"
export CXXFLAGS="-fsanitize=address,fuzzer-no-link"

配置 ASan 行为：

bash

export ASAN_OPTIONS="allocator_may_return_null=1,detect_leaks=0"

LD_PRELOAD Configuration

LD_PRELOAD 配置

For native extension fuzzing:

bash

export LD_PRELOAD="$(python -c 'import atheris; import os; print(os.path.join(os.path.dirname(atheris.__file__), "asan_with_fuzzer.so"))')"

See Also: For detailed sanitizer configuration, common issues, and advanced flags, see the address-sanitizer and undefined-behavior-sanitizer technique skills.

对原生扩展进行模糊测试时：

bash

export LD_PRELOAD="$(python -c 'import atheris; import os; print(os.path.join(os.path.dirname(atheris.__file__), "asan_with_fuzzer.so"))')"

另请参阅： 有关 sanitizer 详细配置、常见问题和高级标志，请查看 address-sanitizer 和 undefined-behavior-sanitizer 技术文档。

Common Sanitizer Issues

常见 Sanitizer 问题

Issue	Solution
`LD_PRELOAD` not set	Export `LD_PRELOAD` to point to `asan_with_fuzzer.so`
Memory allocation failures	Set `ASAN_OPTIONS=allocator_may_return_null=1`
Leak detection noise	Set `ASAN_OPTIONS=detect_leaks=0`
Missing symbolizer	Set `ASAN_SYMBOLIZER_PATH` to `llvm-symbolizer`

问题	解决方案
`LD_PRELOAD` 未设置	导出 `LD_PRELOAD` 指向 `asan_with_fuzzer.so`
内存分配失败	设置 `ASAN_OPTIONS=allocator_may_return_null=1`
内存泄漏检测噪音	设置 `ASAN_OPTIONS=detect_leaks=0`
缺少符号解析器	设置 `ASAN_SYMBOLIZER_PATH` 指向 `llvm-symbolizer`

Advanced Usage

高级用法

Tips and Tricks

技巧与窍门

Tip	Why It Helps
Use `atheris.instrument_imports()` early	Ensures all imports are instrumented for coverage
Start with small `max_len`	Faster initial fuzzing, gradually increase
Use dictionaries for structured formats	Helps fuzzer understand format tokens
Run multiple parallel instances	Better coverage exploration

技巧	优势
尽早使用 `atheris.instrument_imports()`	确保所有导入模块都被插桩以统计覆盖率
初始使用较小的 `max_len`	初始模糊测试速度更快，逐步增加
对结构化格式使用字典	帮助模糊测试器理解格式标记
运行多个并行实例	更好地探索覆盖率

Custom Instrumentation

自定义插桩

Fine-tune what gets instrumented:

python

import atheris

微调插桩范围：

python

import atheris

Instrument only specific modules

仅对特定模块进行插桩

with atheris.instrument_imports(): import target_module

Don't instrument test harness code

不对测试用例代码进行插桩

def test_one_input(data: bytes): target_module.parse(data)

undefined

def test_one_input(data: bytes): target_module.parse(data)

undefined

Performance Tuning

性能调优

Setting	Impact
`-max_len=N`	Smaller values = faster execution
`-workers=N -jobs=N`	Parallel fuzzing for faster coverage
`ASAN_OPTIONS=fast_unwind_on_malloc=0`	Better stack traces, slower execution

设置	影响
`-max_len=N`	值越小，执行速度越快
`-workers=N -jobs=N`	并行模糊测试，提升覆盖率速度
`ASAN_OPTIONS=fast_unwind_on_malloc=0`	堆栈跟踪更准确，但执行速度更慢

UndefinedBehaviorSanitizer (UBSan)

Add UBSan to catch additional bugs:

bash

export CFLAGS="-fsanitize=address,undefined,fuzzer-no-link"
export CXXFLAGS="-fsanitize=address,undefined,fuzzer-no-link"

Note: Modify flags in Dockerfile if using containerized setup.

添加 UBSan 以捕获更多错误：

bash

export CFLAGS="-fsanitize=address,undefined,fuzzer-no-link"
export CXXFLAGS="-fsanitize=address,undefined,fuzzer-no-link"

注意：如果使用容器化设置，请修改 Dockerfile 中的标志。

Real-World Examples

实际示例

Example: Pure Python Parser

示例：纯 Python 解析器

python

import sys
import atheris
import json

@atheris.instrument_func
def test_one_input(data: bytes):
    try:
        # Fuzz Python's JSON parser
        json.loads(data.decode('utf-8', errors='ignore'))
    except (ValueError, UnicodeDecodeError):
        pass

def main():
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()

python

import sys
import atheris
import json

@atheris.instrument_func
def test_one_input(data: bytes):
    try:
        # 对 Python 的 JSON 解析器进行模糊测试
        json.loads(data.decode('utf-8', errors='ignore'))
    except (ValueError, UnicodeDecodeError):
        pass

def main():
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()

Example: HTTP Request Parsing

示例：HTTP 请求解析

python

import sys
import atheris

with atheris.instrument_imports():
    from urllib3 import HTTPResponse
    from io import BytesIO

def test_one_input(data: bytes):
    try:
        # Fuzz HTTP response parsing
        fake_response = HTTPResponse(
            body=BytesIO(data),
            headers={},
            preload_content=False
        )
        fake_response.read()
    except Exception:
        pass

def main():
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()

python

import sys
import atheris

with atheris.instrument_imports():
    from urllib3 import HTTPResponse
    from io import BytesIO

def test_one_input(data: bytes):
    try:
        # 对 HTTP 响应解析进行模糊测试
        fake_response = HTTPResponse(
            body=BytesIO(data),
            headers={},
            preload_content=False
        )
        fake_response.read()
    except Exception:
        pass

def main():
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()

Troubleshooting

故障排除

Problem	Cause	Solution
No coverage increase	Poor seed corpus or target not instrumented	Add better seeds, verify `instrument_imports()`
Slow execution	ASan overhead or large inputs	Reduce `max_len` , use `ASAN_OPTIONS=fast_unwind_on_malloc=1`
Import errors	Modules imported before instrumentation	Move imports inside `instrument_imports()` context
Segfault without ASan output	Missing `LD_PRELOAD`	Set `LD_PRELOAD` to `asan_with_fuzzer.so` path
Build failures	Wrong compiler or missing flags	Verify `CC` , `CFLAGS` , and clang version

问题	原因	解决方案
覆盖率无提升	种子语料库质量差或目标代码未被插桩	添加更好的种子，验证 `instrument_imports()` 是否正确使用
执行速度慢	ASan 开销或输入过大	减小 `max_len` ，使用 `ASAN_OPTIONS=fast_unwind_on_malloc=1`
导入错误	模块在插桩前被导入	将导入操作移至 `instrument_imports()` 上下文内
出现段错误但无 ASan 输出	缺少 `LD_PRELOAD`	设置 `LD_PRELOAD` 为 `asan_with_fuzzer.so` 的路径
构建失败	编译器错误或缺少标志	验证 `CC` 、 `CFLAGS` 和 clang 版本

Related Skills

Skill	Use Case
fuzz-harness-writing	Detailed guidance on writing effective harnesses
address-sanitizer	Memory error detection during fuzzing
undefined-behavior-sanitizer	Catching undefined behavior in C extensions
coverage-analysis	Measuring and improving code coverage
fuzzing-corpus	Building and managing seed corpora

文档	适用场景
fuzz-harness-writing	编写高效测试用例的详细指南
address-sanitizer	模糊测试期间的内存错误检测
undefined-behavior-sanitizer	捕获 C 扩展中的未定义行为
coverage-analysis	测量并提升代码覆盖率
fuzzing-corpus	构建和管理种子语料库

Skill	When to Consider
hypothesis	Property-based testing with type-aware generation
python-afl	AFL-style fuzzing for Python when Atheris isn't available

工具	适用场景
hypothesis	支持类型感知生成的属性化测试
python-afl	当 Atheris 不可用时，用于 Python 的 AFL 风格模糊测试

主要外部资源

Atheris GitHub Repository Official repository with installation instructions, examples, and documentation for fuzzing both pure Python and native extensions.

Native Extension Fuzzing Guide Comprehensive guide covering compilation flags, LD_PRELOAD setup, sanitizer configuration, and troubleshooting for Python C extensions.

Continuously Fuzzing Python C Extensions Trail of Bits blog post covering CI/CD integration, ClusterFuzzLite setup, and real-world examples of fuzzing Python C extensions in continuous integration pipelines.

ClusterFuzzLite Python Integration Guide for integrating Atheris fuzzing into CI/CD pipelines using ClusterFuzzLite for automated continuous fuzzing.

Atheris GitHub 仓库 官方仓库，包含安装说明、示例以及对纯 Python 和原生扩展进行模糊测试的文档。

原生扩展模糊测试指南 全面指南，涵盖编译标志、LD_PRELOAD 设置、sanitizer 配置以及 Python C 扩展的故障排除。

持续模糊测试 Python C 扩展 Trail of Bits 博客文章，涵盖 CI/CD 集成、ClusterFuzzLite 设置以及在持续集成流水线中模糊测试 Python C 扩展的实际示例。

ClusterFuzzLite Python 集成 使用 ClusterFuzzLite 将 Atheris 模糊测试集成到 CI/CD 流水线的指南，实现自动化持续模糊测试。

Video Resources

视频资源

Videos and tutorials are available in the main Atheris documentation and libFuzzer resources.

视频和教程可在 Atheris 主文档和 libFuzzer 资源中找到。