PELock Software Protection & Software License Key System

Software copy protection against cracking & reverse engineering with anti-cracking & anti-debugging techniques. Software license key system with time trial options.

Software protection system

PELock is a software security solution designed for protection of any 32 bit Windows applications against cracking, tampering and reverse engineering analysis.

PELock comes with a built-in licensing system, you can use it to easily add license key system for your application. You can also set various time-trial limitations for the protected application, e.g. 30 days trial.

You can closely integrate the protection and licensing features using dedicated SDK with hundreds of examples for C/C++, Delphi, Lazarus, Freepascal, PureBasic, PowerBASIC, D, Assembler with full source codes.

You can protect any compiled application file for Windows as long as it's compatible with Portable Executable format, no matter what programming language or development environment was used to create it.

Supported file formats Extensions
Applications EXE
Screensavers SCR
Dynamic Link Libraries DLL
ActiveX controls OCX
Control Panel extensions CPL
Borland library packages BPL DPL
Audio codecs ACM
DirectShow filters AX

Why protect software?

Software piracy

It happens very often that just after software release it's possible to find illegal serial numbers, cracks, patches or key generators (keygens) for the application.

Google search crack for phrase...

Usually the reason behind this are weak registration schemes, but even the most sophisticated license key verification algorithms like digital signatures or strong cryptography aren't the problem for crackers if the application file is not protected against modifications and patching of its compiled code.

Protections Weak points Attack vectors
A text field with a key Serial number
  • Simple key generation algorithms
  • The use of incorrect cryptographic algorithms
  • Weak methods of registration keys verification
  • Key verification only at one place in the application
  • Application file itself is not protected against tampering
key generator keygen crack
Binary script Registration file
  • Too simple binary structure of the key makes it possible to generate unauthorized keys
  • Even the most complex algorithms can be patched
key generator patch crack
USB Dongle Hardware key
  • Using of only one function to check the hardware key (aka dongle) presence e.g. IsDonglePresent()
  • Advanced hardware key features are not used at all
  • Weak and outdated application encryption systems (envelope)
emulator patch crack
Calculator Checksum
  • Code can be patched only in the memory without any file modification
  • Checksum can be patched or updated
  • Checksum verification code can be removed
loader patch crack
Calculator Exe-Packer
  • It doesn't protect anything, it's just a compression like a ZIP or RAR archive
  • It can be fairly easily unpacked
  • Files can be patched without unpacking using inline patching
  • Processes can be patched using debug loaders
unpacker inline patch debug loader
World Online verification
  • Network communication can be monitored using network sniffers
  • Way too simple verification checks
  • Proper cryptography is not used
proxy patch crack

Can you say that your software is protected in all aspects? PELock gives you solutions for all of the above threats, so you don't have to design, implement and test your own protections using your customers systems as a playground for your experimental methods.

Intellectual property theft

Unprotected software is highly vulnerable to reverse engineering analysis, and by using specialized reverse engineering tools it's possible to gather many information about compiled application. It's possible to recover fragments of original source codes, e.g. secret algorithms, and in proper conditions it's even possible to restore entire source code of the application.

Unfair competition can take advantage of the technical knowledge obtained in the process of reverse engineering to clone functionality of your software, these are not things taken from movies about hackers but the harsh reality that can affect any software maker.

Game hacks

Computer games are exposed to hacks, those are applications that can modify internal games code and algorithms to give unfair advantage over other players in online battles and tournaments.

Such an example of a game hack can be popular modification among FPS games called wallhack, it allows you to see other players position through the walls. Another popular modification is called aimbot, it's an automated bot that can perfectly aim gun at your opponents and fire.

Using game hacks can effectively discourage other honest players to the game, thus the game itself can lose popularity.

Conclusions

Losses for software developers may be huge, for both large and small companies, and it can hurt even more if you are an independent software developer, so you should also think of the proper software protection already in software design process.

Custom protections are not always really secure and safe, it pays to use verified solution such as PELock, that is using the latest technical achievements in the field of software protection, and at the same time guaranteeing maximum level of compatibility and stability.

What is required to protect the application?

All you need to protect your software with PELock is the compiled application file. If you have access to the source codes it's highly recommended to use PELock SDK system functions to introduce additional protections and to use license key system functions.

SDK & usage examples

SDK provides dedicated macros and functions, which are responsible for communication between the protected application and the additional protection code.

The more SDK features you will use, the better protection and application integration will be, and so the application cracking or rebuilding will be more difficult for the attacker. SDK and its usage examples are available in many programming languages e.g.:

C & C++ Programming Languages

C & C++

Are you programming in C or C++? PELock has hundreds usage examples and SDK compatible with many popular compilers and programming environments including Visual C++, Intel C++ Compiler, GCC, MinGW, G++, Clang, C++Builder, Watcom C++, LCC, Pelles C, Digital Mars.

Delphi & Pascal Programming Languages

Delphi & Pascal

If you're building software in Delphi, no matter the version, you will find many usage examples and an additional component that makes PELock SDK usage even easier. You will also find usage examples for the Lazarus IDE and FreePascal compiler.

PureBasic Programming Language

PureBasic

PureBasic is a modern version of BASIC language with an excellent code optimization, many built-in language functions and devoted fan base. PELock fully supports this programming language and provides dedicated SDK with hundreds of usage examples.

PowerBASIC Programming Language

PowerBASIC

PowerBASIC is an another version of BASIC language, dedicated to building GUI and console Windows applications with huge developers community. PELock fully supports this programming language and provides dedicated SDK with hundreds of usage examples.

Assembler

Assembler

Are you coding in assembler for 32 bit processors in x86 architecture with MASM compiler? SDK provides everything that's available to HLL languages and an additional protections available exclusively for the assembler code.

D Programming Language

D

D programming language gains more and more popularity, it's flexible, provides plenty of features and great compilation speed. It's used and supported by such companies as Facebook. PELock provides dedicated SDK and many of the usage examples for the D language.

How protection process looks like?

Protection process is fully automated (it can be run from the command line) and consists of rebuilding, modification and encryption of the compiled software, its code, data structures, and adding to it an additional protection code.

Application and protection code integration example

Below you can find sample usage of the basic encryption macros from the licensing system. Code between those two markers is encrypted in the protection process and after the startup, the code is decrypted and executed only if the valid license key was found, which contains the decryption keys. After the code is executed it gets re-encrypted again.

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include "pelock.h"

int main(int argc, char *argv[])
{
	// code between DEMO_START and DEMO_END will be encrypted
	// in protected file and will not be available without license key
	DEMO_START

	printf("Hello world from the full version of my software!");

	DEMO_END

	printf("\n\nPress any key to exit . . .");

	getch();

	return 0;
}
procedure TfrmMain.FormShow(Sender: TObject);
begin

  {$I DEMO_START.INC}

  lblInfo.Caption := 'Hello world from registered version';

  {$I DEMO_END.INC}

end;
import std.stdio;
import std.string;
import core.stdc.stdio;
import core.sys.windows.windows;
import PELock;

int main(string args[])
{
	// code between DEMO_START and DEMO_END will be encrypted
	// in protected file and will not be available without license key
	mixin(DEMO_START);

	writef("Hello world from the full version of my software!");

	mixin(DEMO_END);

	writef("\n\nPress any key to exit . . .");

	getchar();

	return 0;
}
#COMPILE EXE
%USEMACROS = 1

#INCLUDE "win32api.inc"
#INCLUDE "pelock.inc"

FUNCTION PBMAIN () AS LONG

    ' code between DEMO_START and DEMO_END will be encrypted
    ' in protected file and will not be available without license key
    DEMO_START

    MSGBOX "Hello world from the full version of my software!"

    DEMO_END

END FUNCTION
IncludePath "..\..\..\..\..\SDK\English\PureBasic\"
XIncludeFile "pelock.pb"

; start

    ; code between DEMO_START and DEMO_END will be encrypted
    ; in protected file and will not be available without license key
    DEMO_START

    MessageRequester("PELock", "Hello world from the full version of my software!")

    DEMO_END

Protected & unprotected application differences

After the protection, application code is modified to protect it from the reverse engineering analysis and rebuilding to its original state in which it would be possible to analyze or modify its code and data. Code, data and additional application resources are encrypted using strong cryptographic algorithms and multilayer polymorphic encryption. The protection code itself is transformed into highly secure form using innovative metamorphic engine. It makes the analysis of the entire protection extremely technically difficult and time consuming task, even for reverse engineering professionals.

It's worth to mention that after the protection, application code is strictly integrated with the protection code, if the attacker tries to remove the protection code, the application itself will remain safe and it will be impossible to run and use it.

Software licensing

PELock provides feature rich license key system, it lets you to control the software features using license key settings.

With built-in license key menager you can easily add and manage license keys and users for your software, generate and verify license keys, block illegally shared keys.

License key system provides many API functions that can be used to read the name of the registered user from the key, verify key validity or read an additional integer values and other data saved in the license key.

License key system usage example

Below you will find usage example of how to read additional integer values stored in the license key that can be used anyway you want in your software:

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include "pelock.h"

int main(int argc, char *argv[])
{
	unsigned int nNumberOfItems = 0;

	// code between DEMO_START and DEMO_END will be encrypted
	// in protected file and will not be available without license key
	DEMO_START

	printf("Hello world from the full version of my software!\n");

	// read key integer value, you can use it however you want
	// you can store up to 16 integer values in license key
	nNumberOfItems = GetKeyInteger(5);

	printf("You can store up to %u items in the database\n", nNumberOfItems);

	DEMO_END

	printf("\n\nPress any key to exit . . .");

	getch();

	return 0;
}
procedure TfrmMain.FormShow(Sender: TObject);
begin

  {$I DEMO_START.INC}

  lblInfo.Caption := 'Hello world from registered version';

  // read integer from the license key (indexes from 1-16)
  lblLicenses.Caption := 'License count: ' + IntToStr(GetKeyInteger(1));

  {$I DEMO_END.INC}

end;
import std.stdio;
import std.string;
import core.stdc.stdio;
import core.sys.windows.windows;
import PELock;

int main(string args[])
{
	// initialize PELock class
	PELock myPELock = new PELock;

	uint nNumberOfItems = 0;

	// code between DEMO_START and DEMO_END will be encrypted
	// in protected file and will not be available without license key
	mixin(DEMO_START);

	writef("Hello world from the full version of my software!\n");

	// read key integer value, you can use it however you want
	// you can store up to 16 integer values in license key
	nNumberOfItems = myPELock.GetKeyInteger(5);

	writef("You can store up to %d items in the database\n", nNumberOfItems);

	mixin(DEMO_END);

	writef("\n\nPress any key to exit . . .");

	getchar();

	return 0;
}
#COMPILE EXE
%USEMACROS = 1

#INCLUDE "win32api.inc"
#INCLUDE "pelock.inc"

FUNCTION PBMAIN () AS LONG

    DIM nNumberOfItems AS LONG

    nNumberOfItems = 0

    ' code between DEMO_START and DEMO_END will be encrypted
    ' in protected file and will not be available without license key
    DEMO_START

    MSGBOX "Hello world from the full version of my software!"

    ' read key integer value, you can use it however you want
    ' you can store up to 16 integer values in license key
    nNumberOfItems = GetKeyInteger(5)

    MSGBOX "You can store up to " & STR$(nNumberOfItems) & " items in the database"

    DEMO_END

END FUNCTION
IncludePath "..\..\..\..\..\SDK\Polish\PureBasic\"
XIncludeFile "pelock.pb"

; start

    nNumberOfItems.l = 0

    ; code between DEMO_START and DEMO_END will be encrypted
    ; in protected file and will not be available without license key
    DEMO_START

    MessageRequester("PELock", "Hello world from the full version of my software!")

    ; read key integer value, you can use it however you want
    ; you can store up to 16 integer values in license key
    nNumberOfItems = GetKeyInteger(5)

    MessageRequester("PELock", "You can store up to " + Str(nNumberOfItems) + " items in the database")

    DEMO_END

License keys are generated using strong cryptographic algorithms like RSA-2048. It's impossible to create unauthorized license keys without the protection project file.

Virtual DLL libraries

PELock has a built-in binder for additional application DLL libraries, it's possible to merge your main application EXE file with any number of extra DLL libraries into single output EXE file.

If your application uses or requires an additional DLL libraries you can hide them inside the protected application, no third party will be able to view it, nor any other program will have access to it, because the whole loading process is emulated in the memory and nothing is written to disk, and it's completely transparent to the application working.

Configuration flexibility

For proper application protection you don't have to change any of the default settings. But if you want, take a look at the Options tab, you'll find variety of additional configuration settings that allow you to adjust the protection to the smallest detail to suit your needs.

Discover hundreds of extra PELock features, so that you will not need to use any other protection tools for your application.

All options are described in detail in the help file, do not be afraid to experiment, with just one click you can restore all default settings.

Compatibility & stability

PELock has been tested for all available 32 and 64 bit versions of the Windows operating system. And I'm not talking here only about the latest two or three versions of Windows.

Both the PELock and the protection code added to the applications are compatible with:

Windows 10
Windows 8.1
Windows 8
Windows 7
Windows Vista
Windows XP
Windows Server 2012
Windows Server 2008
Windows Server 2003
Windows 2000
Windows NT 4
Windows ME
Windows 98
Windows 95

Guaranteed stability

Making PELock compatible with all of the Windows versions required thousand hours of work, analysis, testing and bug fixes. Do you know any other software compatible with both the latest and the oldest Windows operating systems? All of them.

Thanks to this enormous effort — PELock guarantees stable work of your protected software regardless of the conditions, in which it will be launched.

Protection against exploits & 0day vulnerabilities

PELock fully supports applications that make use of the latest anti-exploitation mitigation methods built-in new Windows versions and integrated with the applications by using special compiler options. Mitigation features are properly handled and fully functional for the protected applications.

As a result, your application will be protected both against cracking, but also you will not have to give up the extra security against exploits and 0day vulnerabilities.

Compatibility with antivirus software

Other protection makers won't tell you that, but often those systems are incompatible in some ways with the antivirus software. In those cases, antivirus software can wrongly detect protected application as an unknown threat, it's called false-positive detection.

The reason behind this lies in wrong detection methods used by the antivirus software, often caused by an additional encryption of protected application files that can lead to troubles with some antivirus software systems.

Compatibility with antivirus software

This problem has been deeply analyzed, tested and solved in PELock, through proper rebuilding of the protected application file, so its code, data and internal structure does not arouse any objections within the antivirus software.

Questions?

If you would like to ask me about PELock, something's not clear mail me. I'll be happy to answer all of your questions.