src/safety/fuzz.zig

Página generada desde zkit@zkit-0.0.0-_fk2iAa4BQCqGFKJeeY9WvMQClX5kiZQ2iOZrVsxVyyN (src/root.zig). No se edita a mano: bun run docs:gen la regenera y bun run docs:check falla si difiere.

zkit.safety.fuzz — barridos deterministas y puente a std.testing.fuzz para parsers de entrada no confiable.

Un parser de wire o contenedor tiene un único contrato de seguridad verificable sin conocer el formato: para CUALQUIER entrada devuelve un resultado o un error — nunca pánico, nunca lectura fuera de límites, nunca leak. Estas utilidades generan las entradas que más a menudo rompen ese contrato, a partir de un ejemplo válido (semilla):

• truncations: todos los prefijos (el caso "llegó medio mensaje").
• bitFlips: cada bit invertido, uno a uno (longitudes y tipos corruptos).
• byteSubstitutions: cada byte sustituido por los valores frontera (0x00, 0x01, 0x3f, 0x40, 0x7f, 0x80, 0xbf, 0xc0, 0xfe, 0xff): los que cambian la longitud de un varint o el signo de un campo.
• randomMutations: mutaciones aleatorias reproducibles (semilla fija) sobre el corpus: inserciones, borrados, duplicados y splices.
• fuzzBytes: el mismo callback bajo std.testing.fuzz — en zig build test corre el corpus; con zig build test --fuzz es fuzzing guiado por cobertura.

El callback recibe los bytes y hace lo que quiera con el resultado (típicamente _ = parse(x) catch {};). Un pánico dentro tumba el test (y señala el caso); un leak lo detecta std.testing.allocator si el parser lo usa. Para fallos de reserva usa además checkAllAllocationFailures.

safety.fuzz.checkAllAllocationFailuresCopiar enlace

const · línea 30

pub const checkAllAllocationFailures = std.testing.checkAllAllocationFailures

Re-export: ejecuta test_fn fallando cada reserva en turno (no leaks ni estados corruptos en ningún camino de error.OutOfMemory).

safety.fuzz.interesting_bytesCopiar enlace

const · línea 32

pub const interesting_bytes = [_]u8{ 0x00, 0x01, 0x3f, 0x40, 0x7f, 0x80, 0xbf, 0xc0, 0xfe, 0xff }

Sin ///.

safety.fuzz.truncationsCopiar enlace

fn · línea 35

pub fn truncations(input: []const u8, ctx: anytype, comptime func: fn (@TypeOf(ctx), []const u8) void) !void

func(ctx, input[0..n]) para todo n en 0..=input.len.

safety.fuzz.bitFlipsCopiar enlace

fn · línea 40

pub fn bitFlips(gpa: std.mem.Allocator, input: []const u8, ctx: anytype, comptime func: fn (@TypeOf(ctx), []const u8) void) !void

func sobre cada variante de input con un único bit invertido.

safety.fuzz.byteSubstitutionsCopiar enlace

fn · línea 54

pub fn byteSubstitutions(gpa: std.mem.Allocator, input: []const u8, ctx: anytype, comptime func: fn (@TypeOf(ctx), []const u8) void) !void

func sobre cada variante con un byte sustituido por un valor frontera.

safety.fuzz.randomMutationsCopiar enlace

fn · línea 70

pub fn randomMutations( gpa: std.mem.Allocator, seed: u64, iterations: usize, corpus: []const []const u8, ctx: anytype, comptime func: fn (@TypeOf(ctx), []const u8) void, ) !void

iterations entradas derivadas del corpus por mutación aleatoria reproducible (misma seed ⇒ mismas entradas). Longitud máxima: 4x la semilla más larga + 64.

safety.fuzz.fuzzBytesCopiar enlace

fn · línea 141

pub fn fuzzBytes(ctx: anytype, comptime func: fn (@TypeOf(ctx), []const u8) void, corpus: []const []const u8) !void

Puente a std.testing.fuzz: el callback recibe un slice (hasta 4 KiB) generado por el Smith. Sin --fuzz corre el corpus y la entrada vacía.