Code Instrumentation

def instrument_imports(include=None, exclude=None, enable_loader_override=True):
    """
    Context manager that instruments Python modules imported within the context.
    
    This is the recommended approach for most fuzzing scenarios as it automatically
    instruments libraries without requiring manual intervention.
    
    Args:
        include (list, optional): List of fully-qualified module names to instrument.
                                If provided, only these modules will be instrumented.
        exclude (list, optional): List of fully-qualified module names to exclude
                                from instrumentation.
        enable_loader_override (bool): Whether to enable experimental feature of
                                     instrumenting custom loaders (default: True).
    
    Returns:
        Context manager: Use with 'with' statement to enable instrumentation
    """

import atheris

# Basic usage - instrument all imported modules
with atheris.instrument_imports():
    import json
    import urllib.parse
    from xml.etree import ElementTree

def TestOneInput(data):
    # All the imported modules are now instrumented
    parsed = json.loads(data.decode('utf-8', errors='ignore'))
    # ...

# Selective instrumentation
with atheris.instrument_imports(include=['mypackage', 'mypackage.submodule']):
    import mypackage  # Will be instrumented
    import os        # Will NOT be instrumented

# Exclusion-based instrumentation  
with atheris.instrument_imports(exclude=['requests.sessions']):
    import requests  # Most of requests will be instrumented
    # except requests.sessions which is excluded

def instrument_func(func):
    """
    Instrument a specific Python function for coverage tracking.
    
    Can be used as a decorator or called directly on a function object.
    The function is instrumented in-place, affecting all call sites.
    
    Args:
        func (callable): Function to instrument
    
    Returns:
        callable: The same function, now instrumented
    """

import atheris

# As a decorator
@atheris.instrument_func
def my_function(x, y):
    if x > y:
        return x * 2
    else:
        return y * 2

# Direct instrumentation
def another_function(data):
    return process_data(data)

atheris.instrument_func(another_function)

# Instrumenting the test function itself (recommended)
@atheris.instrument_func
def TestOneInput(data):
    my_function(data[0], data[1])
    another_function(data[2:])

def instrument_all():
    """
    Instrument all currently loaded Python functions.
    
    This scans the entire Python interpreter and instruments every function
    it finds, including core Python functions and previously imported modules.
    This operation can be slow but provides comprehensive coverage.
    
    Note: This is an experimental feature.
    """

import atheris
import json
import sys

# Import modules first
import target_module

def TestOneInput(data):
    target_module.process(data)

# Instrument everything that's currently loaded
atheris.instrument_all()

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

def patch_code(code, trace_dataflow, nested=False):
    """
    Patch Python bytecode with instrumentation for coverage tracking.
    
    This is a low-level function used internally by other instrumentation methods.
    Most users should use the higher-level functions instead.
    
    Args:
        code (types.CodeType): Python code object to patch
        trace_dataflow (bool): Whether to trace dataflow (comparisons)
        nested (bool): Whether this is a nested code object (default: False)
    
    Returns:
        types.CodeType: New code object with instrumentation added
    """

#!/usr/bin/python3

import atheris
import sys

# Import system modules before instrumentation
import os
import sys

# Import and instrument target modules
with atheris.instrument_imports():
    import target_library
    from mypackage import mymodule

@atheris.instrument_func
def TestOneInput(data):
    # Instrumented test function
    target_library.parse(data)
    mymodule.process(data)

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

ERROR: no interesting inputs were found. Is the code instrumented for coverage? Exiting.

# This might cause "no interesting inputs" error
def TestOneInput(data):
    if len(data) < 10:
        return  # Early return with no instrumented code
    target_function(data)

# Better approach
@atheris.instrument_func  # Instrument the test function itself
def TestOneInput(data):
    if len(data) < 10:
        return  # Now this branch is instrumented
    target_function(data)

# Skip problematic modules
with atheris.instrument_imports(exclude=['numpy.core', 'matplotlib._internal']):
    import numpy
    import matplotlib.pyplot as plt

import atheris
import sys

with atheris.instrument_imports():
    import target_module

def TestOneInput(data):
    print(f"Testing with {len(data)} bytes")
    target_module.function(data)

# Run with limited iterations to verify coverage
# Command: python fuzzer.py -atheris_runs=10
atheris.Setup(sys.argv, TestOneInput)
atheris.Fuzz()