Skip to content

Latest commit

 

History

History
113 lines (82 loc) · 3.81 KB

README.md

File metadata and controls

113 lines (82 loc) · 3.81 KB

Fuzzer

fuzzer is a versatile string fuzzing library for Golang that allows the generation of random data based on tokens embedded in strings. It supports a range of token types for generating random strings, numbers, UUIDs, and custom user-defined functions. Additionally, it can load data from a directory into memory for use in fuzzing.

Features

  • Randomized Data Generation: Generate strings, integers, floats, and UUIDs with simple tokens.
  • Custom Functions: Define and use custom functions for generating specialized data.
  • In-Memory Data Cache: Load data from files into memory and access them during fuzzing.
  • Data Encoding: Encode data as Binary, Base32, Base64, Base85, Hex, or URL-encoded strings.

Installation

go get github.com/toxyl/fuzzer

Usage

Initialization

Before using the fuzzer, initialize it with an optional data directory and a map of custom functions:

import (
    "github.com/toxyl/fuzzer"
)

func main() {
    userFns := map[string]func(args ...string) string{
        "customFn": func(args ...string) string {
            return "custom output"
        },
    }
    fuzzer.Init("data_dir", userFns)
}

Fuzzing a String

After initialization, use the Fuzz function to generate a randomized output based on the provided string:

output := fuzzer.Fuzz("[sl:10] [su:5] [i:4] [f:6.2] [$customFn:arg1;arg2]")

Available Tokens

The following tokens can be used within strings passed to Fuzz():

  • UUIDs and Hashes

    • [UUID] or [#UUID] - Generates a random UUID (e.g., xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx).
    • [#56] - Generates a random 56-character hash.

  • Random Numbers

    • [i:6] - Random integer with a 6-character length (zero-padded).
    • [f:6.2] - Random float with a 6-character integer part and a 2-character fractional part.
    • [10:500] - Random integer between 10 and 500 (inclusive, can include negative values).
    • [0.5:5.5] - Random float between 0.5 and 5.5 (inclusive, can include negative values).

  • Random Strings

    • [sl:6] - Random lowercase string with 6 characters (a-z).
    • [su:6] - Random uppercase string with 6 characters (A-Z).
    • [s:6] - Random mixed-case string with 6 characters (a-z, A-Z).
    • [al:6] - Random lowercase alphanumeric string with 6 characters (a-z, 0-9).
    • [au:6] - Random uppercase alphanumeric string with 6 characters (A-Z, 0-9).
    • [a:6] - Random mixed-case alphanumeric string with 6 characters (a-z, A-Z, 0-9).

  • Lists and Ranges

    • [10..500] - Generates a comma-separated list of all integers from 10 to 500 (inclusive).
    • [a,b,c] - Randomly selects a value from the given list.

  • In-Memory Cache

    • [:path] - Reads a random line from the specified path in the in-memory cache. If the path is a directory, a random file from that directory will be used.

  • User Functions

    • [$fn:arg1;arg2;...;argN] - Executes a user-defined function fn with the specified arguments.

  • Data Encoding

    • [bin:data] - Encodes data as binary.
    • [b32:data] - Encodes data as Base32.
    • [b64:data] - Encodes data as Base64.
    • [b85:data] - Encodes data as Base85.
    • [hex:data] - Encodes data as hexadecimal.
    • [url:data] - Encodes data as URL (percent-encoding).

Custom Functions

Use custom functions for more complex data generation:

userFns := map[string]func(args ...string) string{
    "greet": func(args ...string) string {
        return "Hello, " + strings.Join(args, " ")
    },
}

fuzzer.Init("", userFns)

output := fuzzer.Fuzz("[$greet:John;Doe]")
fmt.Println(output) // Output: Hello, John Doe

Examples

Run the test suite for examples that illustrate the use of different tokens and custom functions:

go test -v ./...

License

This project is released into the public domain under the UNLICENSE.