Skip to content
Torzen home page
Sign in Get started
Menu
Get started Sign in

Features

Protection features included in every plan, grouped by topic. On Foundry we also build custom features and a virtualization VM for your product.

Code protection

You enable protection for selected functions, not for the whole file, so the performance cost applies only where it is needed.

  • Code mutation

    Replaces the instructions of selected functions with equivalent sequences that are harder to read.

    In every plan

  • Function virtualization

    Moves the logic of selected functions into a built-in interpreter whose instruction set is generated per file.

    In every plan

Protection settings in JSON, shared by the panel and the API
{
  "functions": [
    {
      "name": "LicenseManager::validate",
      "level": "virtualization"
    },
    { "name": "net::*", "level": "mutation" }
  ],
  "strings": "encrypt",
  "integrityChecks": true
}

Before

Placeholder for a real example

An excerpt of one function from a decompiler, before Torzen processes the file.

After

Placeholder for a real example

The same function after protection, exported with the same tool.

Data protection

Data that reveals how the program works is encrypted in the file and restored only while the program runs.

  • String encryption

    String literals are decrypted only at the moment they are used.

    In every plan

  • Resource encryption

    Resources embedded in the file are stored encrypted.

    In every plan

  • Import protection

    Hides the list of system functions the program calls.

    In every plan

Runtime protection

The protected program checks on its own whether its file or its code in memory has been changed.

  • Integrity checks

    Detects changes to the file and to code loaded in memory.

    In every plan

Licensing

Licensing is built into the protected file. You sign keys with your own private key, and verification works without contacting our servers.

  • Serial keys

    Verification of keys signed with your private key, built into the protected file.

    In every plan

  • Hardware binding

    A license works only on the computer it was issued for.

    In every plan

  • Offline activation

    Activation through a request file, with no internet connection.

    In every plan

Reading the license in your program
#include <torzen/license.h>

torzen_license_t license;
if (torzen_license_load("product.lic", &license) != TORZEN_OK) {
  show_activation_dialog();
}
printf("Licensed to %s until %s\n", license.owner, license.expires);

Working with the service

You point at functions by name from the symbol file or with markers in code, and save settings as profiles.

  • Symbol files

    Upload a PDB, dSYM or DWARF file with your binary and the service finds functions by name. Symbols are not included in the output.

    In every plan

  • Code markers

    C and C++ macros that mark regions to protect when symbols are not enough.

    In every plan

  • Protection profiles

    Settings saved in the panel and reused for later files and in the API.

    In every plan

Marking a code region with SDK macros
#include <torzen/markers.h>

bool LicenseManager::validate(const std::string& key) {
  TORZEN_PROTECT_BEGIN("license-check");
  const auto record = store_.find(key);
  const bool valid = record && record->expires > clock_.now();
  TORZEN_PROTECT_END();
  return valid;
}
Uploading a file through the API
curl https://app.torzen.re/api/v1/protections \
  -H "Authorization: Bearer $TORZEN_TOKEN" \
  -F "file=@build/Release/app.exe" \
  -F "symbols=@build/Release/app.pdb" \
  -F "settings=@torzen.json"

Placeholder for a panel screenshot

The job view in the panel: selected functions, protection levels and processing status. PNG, at least 1600 px wide, in both light and dark themes.