exploitarium is a researcher-maintained archive consolidating dozens of public proof-of-concept writeups across browsers, libraries, and server software, intended for authorized defensive study and open disclosure.

exploitarium is not a tool in the executable sense; it is a curated GitHub repository, written primarily in Python and currently standing at roughly 5,100 stars, that consolidates the public vulnerability research output of a single researcher into one browsable archive. Each folder corresponds to one vulnerability finding, preserving the original README and tracked files from a former standalone PoC repository or entering the archive directly as a self-contained research entry. For defenders, vulnerability managers, and students of disclosure practice, the value is not in running anything but in reading: the repository documents a strikingly broad range of memory-safety bugs, logic flaws, and chain primitives across widely deployed software, with enough per-entry context to inform patch triage. The author's own framing in the ABUSE section is unambiguous — good-faith, open-disclosure research only — and this writeup treats the archive purely as documentary evidence for authorized defensive work.

The scope is what makes the archive notable. The contents table lists roughly forty entries spanning June and July 2026, covering everything from core infrastructure libraries like libssh2, c-ares, curl, nghttp2, and libarchive, through system-level components such as OpenSSH agent locking, OpenVPN Connect, QEMU, and SystemInformer, up to full applications including Firefox, Ghidra, Gitea, Gogs, Nextcloud, NodeBB, MyBB, Flowise, Discourse, and RustDesk. There are also media-parsing findings for FFmpeg, VLC, ImageMagick, Pillow, and 7-Zip, plus web-framework items like the nextjs-unstable-cache-object-argument-collision entry. Read as a corpus, it sketches a map of where a single disciplined researcher with an automated fuzzing workflow finds bugs in 2026: parsing boundaries, permission checks, IPC surfaces, and inter-tool delegation chains.

Internally, the repository is organized as a strict one-folder-per-finding structure. The naming convention is dense but informative — a target, a component or primitive, and a suffix describing the artifact class, such as -calc-poc for calculator-demonstrating proofs, -rce-poc for remote-code-execution proofs, -lpe-poc for local privilege escalation, or -chain-poc for multi-stage compositions. Entries like firefox-152.0.5-backup-nss-rce-poc and docker-cp-copyout-destination-escape give patch managers immediate signal: if a specific Firefox point release or docker cp behavior appears in the archive, the corresponding vendor advisory and update channel are the correct response. Nothing here needs to be executed to extract that defensive value.

A distinctive and unusually rigorous section is the Consolidation Check. When the author folded twelve former standalone repositories into this archive, they verified the migration by comparing each old repository's HEAD tree against the matching folder using Git tree data rather than a filesystem diff. The check required identical relative paths, identical Git object types, identical tree modes including executable bits, and identical Git blob IDs — meaning byte-identical files. The result: twelve repositories and ninety-six tracked entries with zero mismatches, verified from fresh GitHub clones on June 23, 2026 before the originals were removed. For anyone citing this research, that procedure provides strong provenance guarantees that the archived PoC folders are faithful copies of what was originally disclosed, not silent rewrites.

The repository also distinguishes provenance classes. Former standalone repos are listed with their source commit hashes — for example objdump-dlx-calc-poc pinned at 7df01e4e and vlc-vp9-reschange-crash-poc at fae72b82 — while direct entries such as c-ares-tcp-uaf-calc-poc, discord-activity-stock-client-rce-poc, and openssh-agent-lock-provider-bypass exist only in this repository's own commit history. Repository-level metadata like stars, issues, and pull requests stayed behind in the original histories, which the author acknowledges. This means anyone doing historical research on the older findings should treat the commit hashes as the canonical pointer to the pre-consolidation discussion, since issue threads and community review are not mirrored here.

The most analytically interesting part of the README is the AI disclosure statement, which is candid to a degree rarely seen in security repositories. The author states that their entire fuzzing workflow was automated with GPT-5.3, while emphasizing that the actual PoC code was hand-typed rather than generated, with one exception where AI assistance was used for RustDesk research involving less-familiar territory. The README files themselves are described as AI-formatted but human-reviewed for accuracy. The author's empirical claim is notable for the research community: a state-of-the-art model is not required, and decent human oversight plus a well-designed workflow matters more than model quality. That observation has real implications for how defenders should think about the coming scale of AI-assisted vulnerability discovery — the bottleneck is workflow design, not compute budget.

The statement also corrects an attribution: the objdump out-of-bounds write finding was independently reached first by another researcher, and the author explicitly redirects credit to 4D4J/objdump-Out-Of-Bounds-write, noting that the earlier work includes a better proof. That kind of proactive attribution hygiene strengthens the archive's credibility, because it signals the author cares about the disclosure record being accurate rather than merely voluminous. The objdump-dlx-calc-poc folder in this archive is correspondingly the largest single entry at forty-one tracked files, suggesting substantial supporting material around the DLX disassembler parsing path.

From a defensive triage perspective, the archive functions best as a cross-reference index. Entries that reference specific CVE identifiers, such as libssh2-cve-2026-55200-poc, map directly to advisory tracking; others, like systeminformer-phsvc-trusted-host-lpe-poc or qemu-cxl-type3-mailbox-escape-poc, point at named components where maintainers should be consulted for subsequent fixes. Several entries describe privilege or permission boundaries — rustdesk-session-permission-pocs alone tracks seventeen entries, and gogs-admin-csrf-git-hook-rce-poc and mybb-limited-acp-to-admin describe authorization-model failures — which is exactly the class of bug that patch-diffing and changelog review will surface without any need to touch the proofs themselves.

For vulnerability researchers, the archive doubles as a methodology exhibit. The naming taxonomy encodes the impact class the author chose to demonstrate — crash-only proofs like vlc-vp9-reschange-crash-poc sit beside full remote-execution demonstrations and multi-stage chains like 7zip-rar5-motw-chain-poc, which appears to compose a RAR5 parsing issue with a Mark-of-the-Web bypass. Studying which demonstration class the author selected for each bug class is itself educational: it reflects a deliberate calibration between proving impact and minimizing weaponization potential, since a calculator proof demonstrates code execution without providing anything operationally useful to an attacker beyond what coordinated disclosure already published.

There is no license noted in the repository metadata, which matters for anyone considering reuse of the contained material; the research writeups and code should be treated as read-and-reference rather than assumed-licensed for redistribution. The repo has no listed topics and its default branch is main, consistent with a personal research archive rather than a product. The only interaction surface is the folder browsing and the cited external repositories, so operational risk of consuming the archive is minimal — the risk lies entirely in what a reader does with proofs against systems they do not own, which the ABUSE section correctly forecloses.

In an authorized workflow, the sensible pattern is: clone or browse bikini/exploitarium as a reading list; for each entry touching software in your inventory, pull the corresponding vendor advisory and patch; and use the per-folder README files — AI-formatted but author-reviewed — to understand the root cause so you can write better detection logic and regression tests. The archive is a mirror of a researcher's disclosure output, verified byte-for-byte against its predecessors, and that is precisely the artifact class that defenders, educators, and patch-management teams get the most mileage from without ever executing a line of it.

Educational analysis for authorized security professionals. Use only in controlled, authorized environments.

Related coverage

• Viper for adversary simulation and red team operations


• usbrubberducky-payloads for studying keystroke injection payloads


• passbolt_api for team-oriented, end-to-end encrypted credential management