Reg_Crypt markers allow selecting parts of the code that should be executed only in case the module is registered, and the registration key allows deciphering the crypted section. Enigma Protector supports 16 types of Reg_Crypt markers. Each marker can be used to select any number of the code parts. Note that the application has to be restarted after registration for the Reg_Crypt markers to work correctly. Restarting is not needed if you use the standard Registration Dialog.

The principle of work: after the module is protected, the code inside the begin/end markers will be encrypted and the execution of the code will be impossible. If you try to run the protected module, the code inside the markers will not be executed, but other functionality will stay the same. If a valid registration key is stored in the system, the loader checks what sections can be decrypted with this key, and if succeeds, the necessary encrypted section will be decrypted. I.e. if the registration key was generated with Section 1 unlocked, the reg_crypt_begin1/reg_crypt_end1 marker will be decrypted. To register the module, use internal Enigma API functions or perform registration by means of key files, or use the standard Registration Dialog. For detailed information on the registration key generator see Creating Keys.

Content

Show/Hide Delphi marker content

// Take enigma_ide.pas from the folder EnigmaSDK\Delphi
uses 
  enigma_ide;
    
procedure Test;
begin
  // Replace XX on a marker number from 01 to 16
  EP_Marker('reg_crypt_beginXX');
  // Put here code for protection
  
  EP_Marker('reg_crypt_endXX');
end;

// DEPRECATED
reg_crypt_beginXX.inc
asm
  DB $EB, $08, $52, $47, $43, $52, $42, $XX, $00, $00
end;

reg_crypt_endXX.inc
asm
  DB $EB, $08, $52, $47, $43, $52, $45, $XX, $00, $00
end;

Show/Hide C++ marker content

// Take enigma_ide.h from the folder EnigmaSDK\VC
#include "enigma_ide.h"

#pragma optimize("", off)
void test()
{
    // Replace XX on a marker number from 01 to 16
    EP_Marker("reg_crypt_beginXX");
    
    // Put here code for protection
    
    
    EP_Marker("reg_crypt_endXX");
}
#pragma optimize("", on)

// DEPRECATED
reg_crypt_beginXX.inc
__asm
  {
    DB 0xEB, 0x08, 0x52, 0x47, 0x43, 0x52, 0x42, 0xXX, 0x00, 0x00
  }

reg_crypt_endXX.inc
__asm
  {
    DB 0xEB, 0x08, 0x52, 0x47, 0x43, 0x52, 0x45, 0xXX, 0x00, 0x00
  }

Show/Hide C++ x64 marker content

// Take enigma_ide.h from the folder EnigmaSDK\VC
#include "enigma_ide.h"

#pragma optimize("", off)
void test()
{
    EP_Marker("reg_crypt_begin1");
    
    // Put here code for protection
    
    
    EP_Marker("reg_crypt_end1");
}
#pragma optimize("", on)

Show/Hide Visual Basic marker content

Call VarPtr("REG_CRYPT_BEGINXX")

Call VarPtr("REG_CRYPT_ENDXX")

Examples

Show/Hide Delphi marker example

// Take enigma_ide.pas from the folder EnigmaSDK\Delphi
uses
  enigma_ide;

type
  TRegType = (rtUnregistered, rtSingle, rtSite, rtCompany, rtPrivate); // user-defined type of type of module registration

function GetRegistrationType : TRegType; // function returns the type of module registration
begin
  Result := rtUnregistered; // module is Unregistered

  EP_Marker('reg_crypt_begin1'); // begin marker of reg_crypt1 pair
  if EP_RegLoadAndCheckKey then // check validity of registration key
  begin
    Result := rtSingle; // module has Single license
    Exit; // exit from subroutine
  end;  
  EP_Marker('reg_crypt_end1'); // end marker of reg_crypt1 pair

  EP_Marker('reg_crypt_begin2'); // begin marker of reg_crypt2 pair
  if EP_RegLoadAndCheckKey then // check validity of registration key
  begin
    Result := rtSite; // module has Site license
    Exit; // exit from subroutine
  end;
  EP_Marker('reg_crypt_end2'); // end marker of reg_crypt2 pair

  EP_Marker('reg_crypt_begin3'); // begin marker of reg_crypt3 pair
  if EP_RegLoadAndCheckKey then // check validity of registration key
  begin
    Result := rtCompany; // module has Company license
    Exit; // exit from subroutine
  end;
  EP_Marker('reg_crypt_end3'); // end marker of reg_crypt3 pair

  EP_Marker('reg_crypt_begin4'); // begin marker of reg_crypt4 pair
  if EP_RegLoadAndCheckKey then // check validity of registration key
  begin
    Result := rtPrivate; // module has Private license
    Exit; // exit from subroutine
  end;
  EP_Marker('reg_crypt_end4'); // end marker of reg_crypt4 pair  
  
  //DEPRECATED
  {$I include\reg_crypt_begin1.inc} // begin marker of reg_crypt1 pair
  if EP_RegLoadAndCheckKey then // check validity of registration key
  begin
    Result := rtSingle; // module has Single license
    Exit; // exit from subroutine
  end;
  {$I include\reg_crypt_end1.inc} // end marker of reg_crypt1 pair

  {$I include\reg_crypt_begin2.inc} // begin marker of reg_crypt2 pair
  if EP_RegLoadAndCheckKey then // check validity of registration key
  begin
    Result := rtSite; // module has Site license
    Exit; // exit from subroutine
  end;
  {$I include\reg_crypt_end2.inc} // end marker of reg_crypt2 pair

  {$I include\reg_crypt_begin3.inc} // begin marker of reg_crypt3 pair
  if EP_RegLoadAndCheckKey then // check validity of registration key
  begin
    Result := rtCompany; // module has Company license
    Exit; // exit from subroutine
  end;
  {$I include\reg_crypt_end3.inc} // end marker of reg_crypt3 pair

  {$I include\reg_crypt_begin4.inc} // begin marker of reg_crypt4 pair
  if EP_RegLoadAndCheckKey then // check validity of registration key
  begin
    Result := rtPrivate; // module has Private license
    Exit; // exit from subroutine
  end;
  {$I include\reg_crypt_end4.inc} // end marker of reg_crypt4 pair

end;

Show/Hide C++ marker example

// Take enigma_ide.h from the folder EnigmaSDK\VC
#include "enigma_ide.h"

// user-defined constants of module type registration
#define rtUnregistered  0
#define rtSingle        1
#define rtSite          2
#define rtCompany       3
#define rtPrivate       4
//---------------------------------------------------------------------------

#pragma optimize("", off)
int GetRegistrationType () // function returns the type of module registration
{

  EP_Marker('reg_crypt_begin1'); // begin marker of reg_crypt1 pair
  if (EP_RegLoadAndCheckKey()){
    return rtSingle; // module has Single license
  };
  EP_Marker('reg_crypt_end1'); // end marker of reg_crypt1 pair

  EP_Marker('reg_crypt_begin2'); // begin marker of reg_crypt2 pair
  if (EP_RegLoadAndCheckKey()){
    return rtSite; // module has Site license
  };
  EP_Marker('reg_crypt_end2'); // end marker of reg_crypt2 pair

  EP_Marker('reg_crypt_begin3'); // begin marker of reg_crypt3 pair
  if (EP_RegLoadAndCheckKey()){
    return rtCompany; // module has Company license
  };
  EP_Marker('reg_crypt_end3'); // end marker of reg_crypt3 pair

  EP_Marker('reg_crypt_begin4'); // begin marker of reg_crypt4 pair
  if (EP_RegLoadAndCheckKey()){
    return rtPrivate; // module has Private license
  };
  EP_Marker('reg_crypt_end4'); // end marker of reg_crypt4 pair

  //DEPRECATED
  #include "include\reg_crypt_begin1.inc" // begin marker of reg_crypt1 pair
  if (EP_RegLoadAndCheckKey()){
    return rtSingle; // module has Single license
  };
  #include "include\reg_crypt_end1.inc" // end marker of reg_crypt1 pair

  #include "include\reg_crypt_begin2.inc" // begin marker of reg_crypt2 pair
  if (EP_RegLoadAndCheckKey()){
    return rtSite; // module has Site license
  };
  #include "include\reg_crypt_end2.inc" // end marker of reg_crypt2 pair

  #include "include\reg_crypt_begin3.inc" // begin marker of reg_crypt3 pair
  if (EP_RegLoadAndCheckKey()){
    return rtCompany; // module has Company license
  };
  #include "include\reg_crypt_end3.inc" // end marker of reg_crypt3 pair

  #include "include\reg_crypt_begin4.inc" // begin marker of reg_crypt4 pair
  if (EP_RegLoadAndCheckKey()){
    return rtPrivate; // module has Private license
  };
  #include "include\reg_crypt_end4.inc" // end marker of reg_crypt4 pair

  return rtUnregistered; // module is Unregistered
};
#pragma optimize("", on)

Show/Hide Visual Basic marker example

  Call VarPtr("REG_CRYPT_BEGIN1")
  MsgBox "Section #1 is unlocked by key!"
  Call VarPtr("REG_CRYPT_END1")
  Call VarPtr("REG_CRYPT_BEGIN2")
  MsgBox "Section #2 is unlocked by key!"
  Call VarPtr("REG_CRYPT_END2")
  Call VarPtr("REG_CRYPT_BEGIN3")
  MsgBox "Section #3 is unlocked by key!"
  Call VarPtr("REG_CRYPT_END3")
  Call VarPtr("REG_CRYPT_BEGIN4")
  MsgBox "Section #4 is unlocked by key!"
  Call VarPtr("REG_CRYPT_END4")
  Call VarPtr("REG_CRYPT_BEGIN5")
  MsgBox "Section #5 is unlocked by key!"
  Call VarPtr("REG_CRYPT_END5")
  MsgBox "If you did not see any message then this application is not registered or key does not unlock any section!"

See markers examples in the installation folder, Examples\MarkersRegCrypt subfolder.

Help

Markers Reg_Crypt

Content

Examples