Documentation

Everything you need to protect your binaries with ChaosProtector.

Getting Started

ChaosProtector protects your Windows 32-bit (x86) and 64-bit (x86-64) PE executables (.exe) and dynamic-link libraries (.dll) from reverse engineering using code virtualization, obfuscation, and anti-tamper techniques. Follow these steps to protect your first binary.

Download ChaosProtector

Sign in with your Google account and download ChaosProtector from the Dashboard. The Trial plan is free and includes obfuscation and the full GUI application.

Open your executable

Launch ChaosProtectorGui.exe and click Open File to load your 32-bit or 64-bit PE executable or DLL. ChaosProtector will parse the binary and display all detected functions.

Select functions to protect

Use the function list to select which functions you want to virtualize. Focus on security-critical functions like license checks, cryptographic routines, and proprietary algorithms. Leave performance-critical code unprotected for the best balance of security and speed.

Configure protection options

Enable the protection features you need:

Code Virtualization — Basic and Pro
Base MBA obfuscation — all plans; control-flow flattening — Basic and Pro
String Encryption and integrity checks — Basic and Pro
IAT Destruction — all plans
Base Anti-Debug — all plans; advanced runtime checks — Pro
Anti-VM — Basic and Pro; advanced checks — Pro

Protect and test

Click Protect to generate the protected binary, then test it thoroughly before distribution. If the input references an existing PDB and PDB preservation is enabled, ChaosProtector copies that sidecar and updates the embedded path; it does not reconstruct missing symbols.

Command-Line Interface

ChaosProtector includes a CLI mode for automation and CI/CD integration. Use it to protect binaries in build scripts without the GUI.

ChaosProtectorGui.exe --file <path-to-exe> [options]

Options:
  --file <path>        Path to the PE executable to protect
  --virtualize         Enable code virtualization
  --anti-vm            Enable anti-VM detection
  --imports            Enable IAT destruction
  --strings            Enable string encryption
  --output <path>      Output path (default: <filename>.protected.exe)

Example: Protect an executable with all features enabled:

ChaosProtectorGui.exe --file MyApp.exe --virtualize --anti-vm --imports --strings

Best Practices

Selective protection: Only virtualize security-critical functions. Virtualizing your entire binary will significantly impact performance and increase file size.
Test thoroughly: Always test protected binaries before releasing. Code virtualization changes execution flow and may expose edge cases.
Preserve your original PDB: The --pdb workflow can copy an existing PDB referenced by the input and update the protected PE path. It cannot synthesize missing symbols or reconstruct virtualized functions, so retain the original build symbols securely.
Layer your defenses: Combine virtualization with string encryption, IAT destruction, and anti-VM detection for maximum protection.
Automate with CLI: Integrate ChaosProtector into your CI/CD pipeline using the CLI mode to protect every release build automatically.
CLion / MinGW-w64: Unstripped MinGW binaries are discovered automatically from embedded COFF symbols. If you strip the executable, generate a linker MAP file with the same basename (for example, app.exe and app.map) and keep it beside the PE while selecting functions. Functions that depend on unsafe GCC exception or unwind behavior remain visible but are marked unavailable for virtualization (fail-closed) instead of risking a broken output.

Supported Formats

ChaosProtector currently supports the following:

Platform: Windows
Architecture: x86 (32-bit) and x86-64 (64-bit)
Format: PE executables (.exe) and dynamic-link libraries (.dll)
Toolchains: Microsoft Visual C++ and CLion/MinGW-w64
Debug and symbol input: Preserves an existing PDB and supports automatic COFF and same-basename MAP discovery; it does not create missing symbols

Product

Resources

Stacks

Godot Engine Protection