# StegoForge hides payloads in images, audio, documents and packets, then looks for them again

> StegoForge is an MIT licensed Python toolkit that embeds encrypted payloads across image, video, audio, document, binary and network carriers, and ships detection engines to find hidden data in suspicious files. It suits a CTF player or forensics practitioner, and its machine learning detector downloads ONNX weights from HuggingFace on first run unless you plan for that.

**Nour833/StegoForge** — The ultimate steganography and digital forensics toolkit. Hide and extract data across images, audio, video, documents, and network packets, or run 11 advanced detection engines to uncover hidden payloads.

- Repository: https://github.com/Nour833/StegoForge
- Stars: 604 · Forks: 81
- Language: Python
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/nour833-stegoforge

## One tool for the hide side and the hunt side

StegoForge describes itself as a hybrid of steganography, digital forensics and covert communications, and the project description calls it a toolkit for hiding and extracting data across images, audio, video, documents and network packets, or for running detection engines to uncover hidden payloads.

That dual nature is the design. The embed side writes a secret into a carrier file so the carrier still looks like what it is. The detect side runs analysis engines over a file you did not create and reports anomalies. The README makes the point in plain terms: StegoForge takes your secret message or file and weaves it into the pixels of a photo, the soundwaves of a song, or the frames of a video, and to everyone else it looks like a regular file.

So the audience is a person who needs both halves of the workflow, which in practice means a CTF player, a security researcher, or a forensics practitioner examining a suspicious file. The project ships a CTF mode described in the README as one command, all relevant detectors, and a ranked report.

The repository layout reflects the split. There is a core/ directory, a detect/ directory, a protocol/ directory, a models/ directory, a web/ directory, a stegoforge.py entry point, a setup.py, and a stegoforge.spec, which is the PyInstaller specification for the standalone binaries.

## The carrier matrix is where the engineering went

The feature tree in the README is the clearest technical description of the project, and it is organised by carrier type rather than by algorithm.

Image carriers cover PNG, JPEG, BMP, GIF and WebP, with LSB and adaptive LSB embedding at one to four bit depth with content-aware cost ordering, a DCT mode for JPEG with a perceptual budget, a fingerprint mode that is PRNU aware, and support for alpha and palette channels. Video carriers are MP4 and WebM, with keyframe embedding ranked by block cost and a motion mode that uses temporal and texture masks. Audio carriers are WAV, FLAC, MP3 and OGG, with sample LSB, phase coding, and a spectrogram art mode that hides a visible picture in the spectrum domain.

Document carriers are TXT, PDF, DOCX and XLSX. The Unicode whitespace mode inserts zero width space, zero width non-joiner and zero width joiner characters at ranked points, the linguistic mode is key-aware synonym substitution, PDF mode injects into objects, streams and metadata, and Office XML mode uses custom XML parts and streams.

Binary carriers are ELF and PE executables and libraries, embedding into slack and notes regions with a two bit masked region cost. Network covert channels work at the TCP field level, in ip_id, tcp_seq and ttl, and there is a timing channel that encodes into inter-packet delay.

That last group is the one to think about twice. A tool that encodes data into packet header fields and inter-packet timing is a research instrument, and using it on a network you are not authorised to test is a different matter entirely.

## Payloads are encrypted with AES-256-GCM and a password stretched by Argon2

Embedding alone leaves a payload readable by anyone who knows the method, so the crypto layer sits underneath it. StegoForge uses AES-256-GCM with Argon2, and the quick start shows the encryption step reported when you encode.

The encode command in the quick start takes a carrier, a payload, a key and optionally a method and a target platform.

```bash
stegoforge encode -c photo.png -p secret.pdf -k "my-pass"
```

So an encode reports how much it embedded, where the output went, and a statistical profile of the result against a baseline. That last line is a claim about detectability rather than a guarantee, and the tool also offers a capacity command that reports the capacity and stealth score of a carrier, so you can check before you commit.

Around the crypto there are three features that handle the awkward cases. Decoy mode gives a dual-payload plausible deniability, where a second payload is embedded so that a forced disclosure yields something innocuous. Wet-paper wrapping is a Reed-Solomon resilience wrapper, which is how a payload survives a channel that damages it. Platform profiles are social-media aware method selection and simulation, and the encode command can simulate Twitter recompression and test whether the payload survives it.

The dependency list backs the crypto and the media work: cryptography, argon2-cffi and reedsolo for the cryptography, Pillow, numpy, scipy, pydub, av and imageio-ffmpeg for media, pypdf, python-docx and openpyxl for documents, scapy for the network channels, piexif for EXIF, and onnxruntime for the machine learning detectors.

## The detection side reports per-engine skips, not just a verdict

The ctf command runs the detectors over a file you have not seen before, and its output shows something that a simple yes or no tool would hide: engines that did not apply are reported as skipped.

```bash
stegoforge ctf -f suspicious.mp3
```

A chi-square LSB anomaly check on an MP3 is skipped because the method does not apply to that format, which is the correct behaviour and also the honest one. The project description counts eleven detection engines, and the CTF mode is documented as one command, all relevant detectors, and a ranked report.

The blind extractor is the notable part. It reports where a payload was found, audio-lsb at depth one, and that the blob is AES encrypted, then writes the extracted bytes to a file. It can locate a payload whose key it does not have, which is exactly what a forensic examiner needs and exactly what a hide-and-seek game rewards.

For everyday use there are two more commands worth knowing. The diff command compares an original against a stego output and produces a pixel heatmap, which is the fastest way to see where two images differ. And the web command starts a local interface, which the README is explicit about, with no data ever leaving your machine.

## Installing it: a standalone binary or the Python package

There are two install paths, and the project makes the argument for the binary in unusually blunt terms: StegoForge is a complex Python framework, but you should not have to deal with broken environments when doing active forensics, so the maintainers compiled zero-dependency native executables that resolve their own AI and media requirements.

The binary path is a download from the releases page for your OS, with no pip install and no PATH configuration, and the guidance is simply to execute it.

The source path is the usual Python sequence.

```bash
git clone https://github.com/Nour833/StegoForge.git
cd StegoForge
pip install -r requirements.txt
pip install -r requirements-web.txt
pip install -e .
```

The two requirements files are read by setup.py and concatenated into install_requires, which is why both installs are needed for a source checkout. The console entry point is declared as stegoforge=stegoforge:app, and the package requires Python 3.10 or newer, matching the badge in the README. The web interface is a Flask application, started with the web command, which the README says deploys automatically at http://localhost:5000.

The quickest way to see the tool working is the quick start sequence, and each line has a comment explaining the intent.

```bash
stegoforge encode -c photo.png -p secret.pdf -k "my-pass"
stegoforge decode -f photo_stego.png -k "my-pass"
stegoforge ctf -f suspicious.mp3
stegoforge capacity -c photo.png --depth 2
```

There is also a batch command that embeds a secret into every carrier in a folder, and a way to keep the key out of your shell history by exporting STEGOFORGE_KEY and letting the decode command read it from the environment.

## The first run reaches out to HuggingFace for the detector weights

There is a caveat in the installation notes that deserves attention, because it changes what you need before you start.

The note on the machine learning architecture says StegoForge implements true machine learning steganalysis, and that the very first time you boot the engine it silently interfaces with HuggingFace to download the ONNX CNN weights directly into your ~/.stegoforge/models cache.

Silently is the operative word. A workstation that is offline, air gapped, or under a strict egress policy will not boot the engine cleanly on the first run, and nothing in the quick start sequence warns you about that network dependency. If you are working on a case, the first thing to do is trigger that download on a connected machine and confirm what ends up in the cache directory.

The runtime list in requirements.txt confirms the approach: onnxruntime for the inference, certifi for the TLS trust store that the download needs, and numpy and scipy for the statistical work the other engines do.

Everything else in the tool stays local. The web interface is described as a local deployment with no data leaving your machine, and the local SSE streaming in the web UI is how the interface reports progress without a server round trip to anywhere.

## Version history, licence and the shape of the codebase

StegoForge is MIT licensed, with the LICENSE file at the repository root, so the code can be used, modified and redistributed in a commercial product without copyleft obligations. The README also carries an MIT badge.

The releases are recent but not continuous. The listed versions are v1.1.5 on 2026-04-26, v1.1.4 on the same day, and v1.1.0 on 2026-04-19, and the last push was on 2026-04-26. The repository is not archived. A CHANGELOG.md is at the root, and the setup.py project metadata points at it as the changelog location.

The version number is read from core/version.py rather than hard-coded, which is a small sign of care in the packaging.

The Python version floor of 3.10 is worth noting for a security tool that gets copied between machines, and the presence of a tests/ directory, a MANIFEST.in, and a pyproject-style dependency split between core and web requirements tells you the project separates the analysis core from the optional web layer.

One boundary to keep in mind when you evaluate it. The toolset covers a lot of carriers and a lot of methods, but the README does not claim complete support for every container, and the detection side skips engines that do not apply to a given format, as the ctf output shows. Anyone relying on it for a specific file type should test that type first.

## Conclusion

StegoForge fits a CTF competitor, a security researcher or a forensics practitioner who needs one tool that both hides payloads and hunts for them, and who is comfortable on a machine with network access for the first run. It does not fit an offline or air gapped analysis workstation without preparation, since the first boot pulls ONNX CNN weights from HuggingFace into ~/.stegoforge/models, and it does not fit a defender who only needs detection, since the hide and find halves share one large dependency set. Before adopting it, decide whether you want the Python package or the zero dependency standalone binary, read the CHANGELOG.md for the version history behind v1.1.5, and confirm that the carriers you care about are covered, since the method and format support is broad but it is not complete for every container.

## FAQ

### Do I need to install Python to use StegoForge?

No, if you use the standalone binaries. The project publishes zero-dependency native executables on the releases page that resolve their own AI and media requirements, with no pip install and no PATH configuration. Building from source needs Python 3.10 or newer.

### Does StegoForge work offline?

Not on the first run. The documentation states that the first time you boot the engine it downloads ONNX CNN weights from HuggingFace into the ~/.stegoforge/models cache, so that download has to happen on a connected machine before an offline analysis session.

### What can StegoForge hide data in?

Images in PNG, JPEG, BMP, GIF and WebP, video in MP4 and WebM, audio in WAV, FLAC, MP3 and OGG, documents in TXT, PDF, DOCX and XLSX, ELF and PE binaries, and network packets through TCP field channels and inter-packet timing.

### How is the payload protected when embedding?

The payload is encrypted with AES-256-GCM, with Argon2 in the dependency list for password handling. There is also a Reed-Solomon wet-paper wrapper for resilience and a decoy mode that embeds a second plausible payload.

## Sources

- [Issues](https://github.com/Nour833/StegoForge/issues)
- [License: MIT](https://github.com/Nour833/StegoForge/blob/main/LICENSE)
- [Nour833/StegoForge on GitHub](https://github.com/Nour833/StegoForge)
- [README](https://github.com/Nour833/StegoForge/blob/main/README.md)
- [Releases](https://github.com/Nour833/StegoForge/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nour833-stegoforge