What exactly gets corrupted, the character or a bit?

A bit, not the whole character. For each character independently affected by the corruption rate, exactly one randomly chosen bit position (0 through 6) within that character's 7-bit code gets flipped. That's a much finer-grained, more realistic model of real-world bit corruption (a noisy line, a faulty memory cell) than replacing or scrambling whole characters.

How is this different from the list category's List Error Injector?

List Error Injector works at the list-item level: it swaps adjacent characters, drops a character, or duplicates a character within whole list items (like lines or comma-separated entries), simulating human-typo-style mistakes. This tool works at the bit level within individual characters, simulating hardware/transmission-style corruption instead of typing mistakes, and doesn't organize input into list items at all, it treats the whole input as one block of ASCII text.

Is this reproducible? What does 'Regenerate' do?

Yes, given the same input and corruption rate, the tool derives a seed from both plus a hidden counter, so results are reproducible by default but the 'Regenerate' button lets you draw a fresh, differently-seeded round of corruption without changing your input or rate.

Why is this useful for fuzz testing?

Parsers, protocol decoders, and validation logic that assume clean ASCII input can behave unpredictably (crashes, infinite loops, incorrect output) when fed corrupted data. Deliberately generating bit-level corrupted ASCII at a controlled rate gives you a fast way to build test cases that probe how robust your code actually is against the kind of subtle, single-bit errors that occur in the real world.

ASCII Error Injector - Seeded Bit-Level Corruption for Fuzz Testing

Overview

Introduction

Real-world data corruption rarely looks like neat, whole-character mistakes, it's often a single stray bit flipped by a noisy line, a faulty storage cell, or electrical interference.

This tool generates that kind of bit-level corruption on demand, at a rate you control, over strictly-validated ASCII text, giving you a fast way to build realistic fuzz-testing fixtures.

What Is ASCII Error Injector?

A seeded corruption generator: given a percentage rate, it independently decides for each character in your text whether to corrupt it, and if so, flips one randomly chosen bit within that character's 7-bit code.

It's distinct from typo-style corruption (character swaps, drops, duplicates), this tool works purely at the bit level within individual characters, modeling hardware or transmission-style errors instead of human typing mistakes.

How ASCII Error Injector Works

Input is validated as strict 7-bit ASCII, and the corruption rate is checked to be a number between 0 and 100.

For each character, a random draw decides (with probability equal to the rate) whether it's affected; if so, a random bit position (0-6) is chosen and XORed into that character's code, corrupting exactly one bit. The tool counts and reports how many characters were affected.

When To Use ASCII Error Injector

Use it to generate corrupted test input for a parser, protocol decoder, or checksum validator that's supposed to detect or tolerate bit-level errors.

It's also useful for demonstrating how fragile plain-text formats can be to even small amounts of transmission or storage corruption.

Often used alongside List Error Injector, ASCII Typo Generator and ASCII Bit Flipper.

Features

Advantages

Models realistic single-bit corruption per affected character, rather than whole-character replacement or scrambling.
Seeded and reproducible by default, with a one-click Regenerate button when you want a fresh corrupted variant.
Reports exactly how many characters were affected, so you know the actual corruption rate that was applied, not just the target rate.

Limitations

Only ever flips one bit per affected character; it doesn't model multi-bit corruption within a single character.
At very low corruption rates on short input, it's possible for 0 characters to be affected purely by chance, the rate is a probability per character, not a guaranteed count.

Examples

Corrupting at a low rate

Input

The quick brown fox

Output

The quicL brown fox

At a modest corruption rate, only a small number of characters are affected; here a single bit flip changed 'k' to an unrelated character.

No corruption at 0%

Input

Test data

Output

Test data

At a 0% corruption rate, every character is left untouched and the affected-character count is reported as 0.

Best Practices & Notes

Best Practices

Start with a low corruption rate (5-15%) to generate realistic, sparse errors rather than completely garbled output.
Use the Regenerate button to produce several different corrupted variants of the same input for a broader fuzz-test suite.

Developer Notes

Each character is independently corrupted with probability `corruptionRatePercent / 100`; when corrupted, a bit position in [0, 6] is chosen via `Math.floor(rand() * 7)` and XORed into the character's code. The `rand` source is injectable (defaulting to `Math.random`) so unit tests can supply a deterministic sequence, while the UI derives a seeded, hydration-safe `rand` from `mulberry32(seedFrom(...))` combining the input, rate, and a Regenerate counter.

ASCII Error Injector Use Cases

Fuzz-testing an ASCII parser or protocol decoder against realistic bit-level corruption
Generating corrupted test fixtures for a checksum or parity-check validator
Demonstrating how fragile plain text is to small amounts of transmission or storage errors

Common Mistakes

Setting the corruption rate to 100% and expecting fully scrambled output, each affected character only gets one bit flipped, so the text usually still resembles the original structurally.
Forgetting to record the seed/settings for a corrupted output you need to reproduce exactly later; use the same input and rate without clicking Regenerate to get the same result again.

Tips

Compare the affected-character count against your target rate to sanity-check that the randomness behaved as expected for your input length.
Pair with ASCII Typo Generator if you also want to simulate human-typing-style mistakes alongside bit-level corruption.

ASCII Error Injector