Automating the work around fuzzing
Fuzzing can expose faults that static review and HTTP testing miss, but teams often need specialists to choose targets, write harnesses and sort useful crashes from noise. Bright Security’s STAR Fuzzer aims to remove that setup and triage burden. It uses AI agents to select security-critical functions and create verified harnesses, then relies on an evolutionary search engine to exercise compiled code and find faults.
The product is now available as a mode of Bright STAR. Its reported first-month results include ten published findings across eight projects, among them the Crystal standard library, htop and RIOT OS. Before launch, the company also ran a two-day automated research campaign: 45% of the projects tested had High or Critical issues, and 37% of the vulnerable projects were part of Google’s OSS-Fuzz program.
Each confirmed issue comes with a byte-exact input that reproduces it. Bright Security says it replays findings in a fresh container before filing them, giving maintainers concrete evidence to investigate and a payload they can use to check a fix.
What the automation changes
Tools such as AFL++ and libFuzzer have established fuzzing workflows, and Google’s OSS-Fuzz has shown the value of running them at scale. But conventional fuzzers still depend on engineers to build and maintain a harness for each target, then manually assess the resulting crashes. STAR Fuzzer’s bet is that automating those surrounding tasks can make dynamic testing practical across more of a codebase.
Its approach also reaches code that standard dynamic application security testing may not exercise. DAST sends requests to a running application, usually over HTTP. That’s useful for testing externally reachable behavior, but it can leave lower-level parsing and processing functions untouched. STAR Fuzzer instead tests selected functions directly, without requiring a running application.
AI has a limited but specific role in this design. Agents select targets, generate harnesses and help assess reachability and impact. The search itself isn’t an LLM reasoning about source code. It runs the compiled target, observes what happens and favors inputs that reach new code or otherwise score well against its fitness signals.
That distinction matters for defects that don’t match familiar vulnerability patterns. A model reviewing code can suggest likely trouble spots, but it can’t directly observe how a particular build behaves under millions of inputs. A fuzzer can reveal concrete runtime effects, including sanitizer reports, out-of-bounds access and resource exhaustion.
Search built around structured inputs
STAR Fuzzer communicates with targets through a small harness over IPC. Bright Security says this lets it test software written in C, C++, Rust, Go, Java, Kotlin, Crystal, Node and other languages that can accept input and report results. The company lists additional support for .NET and Python.
Rather than requiring a custom grammar or dictionary for every target, its parsing layer turns seed inputs into typed trees of fields and can serialize those trees back to the original bytes exactly. The fuzzer can mutate meaningful fields while preserving much of the input’s structure. That can help it get past basic framing and validation checks, where arbitrary byte changes are often rejected, and spend more executions on deeper logic.
The engine uses an evolutionary process. Each candidate carries an ordered sequence of mutations; candidates run, receive scores and change over successive epochs. Mutations that improve results are kept, while unproductive changes can be rolled back and candidates can be combined. Because the mutation history can be replayed, Bright Security says results can be regenerated from a logged random seed.
The company cites its libxml2 harness as one measure of search reach: a run of five million executions reached about 13,600 code regions. Coverage feedback helps the system retain inputs that reach new regions and use them as starting points for further exploration.
Findings include small inputs with large effects
The published examples span parsers, image handling, operating-system utilities and other code that processes untrusted data. Several illustrate why checking input length alone can be misleading: the dangerous behavior may depend on how a field is interpreted or on the size of data after decoding.
- TwelveMonkeys: A DDS reader used the mipMapCount header field to size an uncapped array. A 38-byte file could trigger an allocation of several gigabytes (CWE-789). The issue, GHSA-fwp7-38wp-mmxw, was fixed in version 3.15.0.
- Fider: Upload validation checked an image’s compressed size before decoding it. A 436 KB PNG could expand to about 562 MB, and an authenticated user could trigger the behavior (CWE-409). Bright Security says STAR Fuzzer found the issue in about 12 minutes. GHSA-7cw3-7xh9-529r was fixed in version 0.38.0.
- Crystal standard library: In XML handling, an allowlist omitted ENTITY_DECL, allowing a field in libxml2’s xmlEntity structure to be read as an xmlNs pointer (CWE-843). A separate YAML issue caused YAML::Any#hash to overflow the stack on a self-referencing anchor and alias cycle. An 88-byte input could produce an uncatchable SIGSEGV (CWE-674). Both issues were fixed in Crystal 1.21.1.
- htop: A missing bounds check in the /proc/PID/stat parser caused an out-of-bounds read at field 22 (CWE-125). The fix is recorded as #2101.
- universal-ctags: foreachEntriesInScope had a null-pointer member access (CWE-476), fixed in commit 780bd7a and tracked as #4497.
- scrimage: An uncapped width-times-height pixel count let a 35-byte GIF prompt allocation attempts of about 2 GB, with a second variant exceeding 8 GB (CWE-789). The fix shipped in version 4.6.8 as #893.
- RIOT OS: In link_format.c, _dirlist_cb checked bounds after writing, allowing a NUL byte one position beyond the buffer (CWE-193). A fix was submitted in PR #22879.
- libsolv: Two findings were assigned CVE-2026-104621 and CVE-2026-104622. Bright Security says details remain under embargo.
These cases also show why a reproducer is operationally useful. Fider’s check did measure upload size, but it measured the compressed file; the TwelveMonkeys field looked like metadata rather than an allocation limit. In Crystal, a type allowlist appeared complete, while the YAML code failed on a cyclic structure rather than a tree. A precise input gives maintainers a way to confirm the behavior directly.
Where teams may find it useful
STAR Fuzzer is aimed at software that handles untrusted input beneath the web layer: file uploads, images, documents, archives, parsers, serialization code and binary protocols. Bright Security also identifies embedded and IoT firmware, desktop applications and backend services as potential targets. Teams can use it to exercise functions flagged by static analysis, or to test code produced at high speed, including AI-generated code.
The tool runs in the customer’s environment and doesn’t require a cloud scanner, authentication or a live application. In persistent mode, Bright Security reports harness execution is about 51 times faster than starting a new process for every input. Findings can be delivered in a pull request with the affected file and function, plus the payload needed to reproduce the behavior.
STAR Fuzzer doesn’t replace DAST: the two methods test different paths through software. DAST examines a running application from the outside, while fuzzing targets selected functions directly. Bright Security says its STAR platform supports both workflows.
STAR Fuzzer is available now through Bright STAR. Its early results point to a practical shift in fuzzing access: automating target selection, harness construction and verification could let more teams test code that has traditionally required dedicated fuzzing expertise. The useful measure will be whether that automation keeps producing reproducible findings across the less visible input-handling code where small malformed files can cause outsized failures.
Bright Security’s research methodology and results are described in Part I and in Bar Hofesh’s Back to the Fuzzer II: Finding the Bugs LLMs Miss. Product details are available at brightsec.com/fuzzer.