Protect the code that matters
Dhaedalida hardens 64-bit Windows applications with code virtualization, per-string encryption and a self-defending packer — ship software that's built to resist cracking.
No account required · 30-day evaluation · Windows 64-bit .exe
Trusted by development teams in over 40 countries
Defense in depth for your binaries
Multiple protection layers work together, so no single technique is a single point of failure.
Code Virtualization
Selected functions are rebuilt as a self-contained virtual machine embedded in your executable — the original instructions no longer exist in the file to be disassembled.
String Encryption
License prompts, URLs and keys are stored encrypted and decrypted only for an instant inside the VM — a strings scan reveals no plaintext.
Application Packer
The whole program is compressed and encrypted behind a self-unpacking loader — on disk the shipped file contains no readable code or data.
Tamper Resistance
Composable hardening layers — anti-tamper, import protection, debugger and sandbox resistance — so a patched or probed build refuses to run.
Three steps to a protected release
Mark what matters — in code
Add the marker SDK (one source file) and bracket sensitive functions with VMStart() / VMEnd(). They're harmless no-ops in a normal build.
Detected automatically
Open your .exe in DhaedalidaGui. Marked functions light up pre-selected — with or without debug symbols, even in a stripped release build.
Protect in a couple of clicks
Tick the protections you want and click Protect. A live log streams progress and a hardened yourapp.protected.exe is written. In CI, the command-line engine takes targets from a list file.
Watch your code transform
The same function — a license check — as it passes through the protection pipeline. Step through each stage.
verify_license: ; as a disassembler sees it push rbp mov rbp, rsp mov rax, [rcx] ; rax = *key movabs rdx, 0x004100414C4C4844 ; "DHLLA" magic cmp rax, rdx jne .reject call check_expiry test al, al je .reject mov eax, 1 ; return true pop rbp ret .reject: xor eax, eax ; return false pop rbp ret
Original. Your compiled function — clean, linear, trivial to read and patch.
verify_license: ; same result, unrecognizable push rbp lea r11, [rip + .L9c] ; opaque target mov rbp, rsp xor r9d, r9d mov rax, [rcx] add r9, 0x5D3 ; decoy op (never read) rol rax, 11 ; substituted compare xor rax, 0x9E3779B1 jmp r11 ; non-linear control flow .L9c: test r9, r9 ; opaque predicate (always 0) jnz .L9c xor rax, 0x9E3779B1 ror rax, 11 ; ... verify continues
Obfuscated. Encrypted constants, decoy operations, opaque predicates and non-linear control flow — always on, nothing to configure, and automated analysis can't simplify it away.
verify_license: ; native body removed push dh_vm_ctx ; enter Dhaedalida VM mov rsi, vm_bytecode + 0x4A19 jmp dh_vm_enter ; ---- per-build bytecode (unique ISA) ---- db 7F C3 09 E1 ; h_push_imm load *key db 5A 8D 44 F2 ; h_xor_rot decode magic db B0 1E 9C 63 ; h_cmp_pred verify key db D7 28 AB 05 ; h_vcall check_expiry db 91 2B 6E D3 ; h_vexit -> bool result
Virtualized. The logic is gone — replaced by bytecode for a virtual machine whose instruction set is generated uniquely for this build.
Built for software you sell
Wherever your product's value lives inside the binary, that's what Dhaedalida protects.
Anti-piracy
Protect license checks, activation and serial-key validation so paid software can't be trivially cracked and redistributed for free.
IP protection
Safeguard proprietary algorithms, business logic and pricing engines — the trade secrets that live inside your binary.
Anti-tampering
Ship software that runs as authored and refuses to run if it has been modified — protecting both you and your users.
Crypto & licensing routines
Shield cryptographic code, key handling and integrity checks from inspection and modification.