Protect for Delphi is a native Delphi component specially designed to protect your software against piracy. It is part of a registration system that manages the whole registration process.  As distinctive features, it provides strong encryption for maximum security and it does not read/write information to registry. Extended capabilities of your software can be remote activated by the registration key, on user demand.  Simple to use, requires no extra programming skill. Only one line of code is needed to achieve full protection for Windows 95 and Windows 98 programs.  (No distribution of .vxd's is needed, .vxd coded internally)

 

• Developer: the person/institution that built the application to protect.
• User: the person/institution that use the protected program.
• Registration Code: the digital fingerprint generated automatically by the protected program  by means of which the Developer can register a certain User.  (It is known by both parts and automatically generated by the protected program on first execution)
• Registration Key: The key that unlocks the protected program. Only the developer can generate it. (It's what the user wants to know in order to be considered a registered user.)
• Application Key: It is the key that is used to cipher de registration code, so only the developer could 'read it'.  It's generated automatically when a TProt4Delphi component is put on a form. (see below)

License Agreement

This code is shareware. No warranties, express or implied, are provided. The author is not responsible for any problems caused by this component. Use it at your own risk. The author provides no support whatsoever, and is not obligated to any person or corporation for anything related to this software. The author reserves all rights concerning this code. You are free to evaluate it and distribute it for evaluation purposes, if you do not modify any part of it and you distribute all the files as a whole. This code cannot be sold for any purposes, or included in a commercial collection, without the express written consent of the author.
This License Agreement applies to demo version only, please read the the registration section for more information.
By installing these files on your computer, you agree to all above conditions.
 

 Quick start:

This section guides you on a step by step process for a quick start. If you wish to copy protect your software and then read the documentation, this section could be of some help. Read all questions in order and follow the indicated steps.
 

  Windows 95 or Windows 98 Operative system.
  4 Mb hard disk space.
  Delphi 4 installed. (A version for Delphi 3 is available, just contact the author)
 

How to install the component ?

1) Unzip the file (Prot4Dph.zip) to some directory, for example
  C:\Protect4Delphi\

2) From the Delphi IDE do: File -> Open.  Search the directory where files were unzipped.
(C:\Protect4Delphi\   in the example)
(Go to C:\Protect4Delphi\Bin directory)
Then, select the file Protect4DelphiV40Demo.dpk  and press OK.
A window with Compile, Add, Remove, Install  buttons should appear.
Press Install. The component should go to the components palette.

3) Add the installation directory to Delphi Library Path. From Delphi IDE do: Tools->Environment options->Library. Press the ellipsis button (...) of item "Library Path:"
Write down the complete installation path and press 'Add' button.
 
 

Installation Pack contains:

\Bin
  KeyGenerator.exe          (Key Generator)
  Prot4Delphi2.dcu
  Prot4Delphi3.dcu
  Prot4Delphi4.dcu
  Prot4Delphi5.dcu
  Prot4Delphi6.dcu
  Prot4Delphi7.dcu
  Prot4Delphi8Cipher.dcu
  Prot4Delphi8KeySchedule.dcu
  Prot4Delphi8SBoxes.dcu
  Prot4Delphi8StaticTable.dcu
  UProt4Delphi.dcu
  UProt4DelphiDefs.dcu
  Protect4DelphiV40Demo.dpk        (Delphi Package)
  Protect4DelphiV40Demo.bpl         (Delphi package library)
  Protect4DelphiV40Demo.dcp         (Delphi compiled package)
  Protect4DelphiV40Demo.dcu         (Delphi compiled unit)
  Protect4DelphiV40Demo.res
  Protect4DelphiV40Demo.dof
\Doc
  Protect for Delphi (English).doc          (Word Pad documentation)
  Protect for Delphi (English).htm          (Hypertext documentation)
  Protect for Delphi (Spanish).doc         (Word Pad documentation)
  Protect for Delphi (Spanish).htm         (Hypertext documentation)
\Demos\Standard          (Standard demo)
  Main.pas
  Main.dfm
  UDefaultRegistration.pas
  UDefaultRegistration.dfm
  Simple.dpr
  Simple.res
\Demos\Custom                  (Custom demo)
  Main.pas
  Main.dfm
  Custom.dpr
  Custom.res
  MyID0010857.uid
 

How do I protect a program ?

It's very simple, just follow this 3 steps:

• Put a Prot4Delphi component in the main form of the application. To do that, go to the components palette and select the page Prot4Delphi.

That page should contain the component icon that looks like this: 
Select this icon with a left mouse click and then click on the main form.
The component should appear on the form.
 (When Prot4Delphi is put on a form,  (what has been done in this step), an application key, that depends of the project name, is automatically generated .
The application key can be modified arbitrarily but it should be different for each   project.
The existence of this key is VERY important for system security, so it should not be revealed to any user.
You can set the application key manually, by setting the property ApplicationKey.
Valid keys are, for example:
 

MyProject7345h

AnotherProject

AnotherValidAppKey

AnApplication247

 (see below for more info about this point)
 
• Insert the following code in the pascal unit.

   Add below implementation:
     uses UDefaultRegistration;

   Add to the FormCreate event handler:
     TRegistrationForm.CheckAndShowIfNotReg(Prot4Delphi1);

  Code will look like this:
 

unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, UProt4Delphi;

type
  TForm1 = class(TForm)
    Prot4Delphi1: TProt4Delphi;
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;

implementation
{$R *.DFM}

uses UDefaultRegistration;

procedure TForm1.FormCreate(Sender: TObject);
begin
   TRegistrationForm.CheckAndShowIfNotReg(Prot4Delphi1);
   if not Prot4Delphi1.IsRegistered then Application.Terminate;
end;
end.

 

• Compile and execute the program. (Press F9 in Delphi IDE)

How   do I  distribute  the  protected program ?
 

Once protected, the program is ready to work. The compilation process, generates a executable that contains the protection code internally.
You need to distribute NO additional files, relative to the protection.

 

A dialog window will appear, indicating that a not registered copy of the program is running, and showing the registration code.  (This is the default behavior if you have completed the steps above. Other possible behaviors are described later)

The dialog window looks like this:
(Color highlighting is only indicative)
 

  Figure 1

The violet arrow in the upper part points to the registration code.
The user should send this code in order to get the registration key that unlocks the software.
 

Once the developer obtained the registration code from the user, the Key Generator can be run to generate the registration key.
The Key Generator is a program (KeyGenerator.exe) included in the distribution pack.

It looks like this:
 (Color highlighting is only indicative)
 

• The application key, can be consulted in the following way:  In Delphi IDE open the project of the protected program.  Open the main form.  Select TProt4Delphi component with a mouse click.  Press F11 key to see the object inspector.  The property ApplicationKey, contains the EXACT text of the Application Key.  It is VERY IMPORTANT to enter this key EXACTLY.

• The registration code is the code sent by the user. It is VERY IMPORTANT to enter this code EXACTLY.

Anyway, invalid characters are not accepted by the Key Generator.
Note: The number zero is NOT present in a valid registration code. If the user sends a code that contains zeroes, they should be replaced by the O character.
Once registration code is entered, the key generator reports the protected program first execution date (underlined in orange), and the unique copy identifier (if you selected that distribution feature).
 
• Optionally, it is possible to enable additional features of the protected program, with a certain expiration date. This is done with the section  "Additional features" (yellow marked)

In figure 2, features 1,3 and 8 are showed with expiration date of 31 days.

Once minimal input is entered (points 1 y 2) the Generate Key button, will generate the registration key, and show it in red characters.
The registration key depends strongly of every input data. As a proof of this, see how it changes when you modify just one of the enabled optional features.

The registration key (in red characters) is what should be sent to the user in order to validate his/her copy of the protected program.
The registration code and registration key are designed specially to allow its phone transmission. Both codes are 24 characters in length, and it is built with normal symbols, which allows transmission over almost any media.  (Voice, Fax, e-mail, etc.)
Each position of the code is one of 42 distinct symbols, giving such an amazing number of combinations (42^24) that simple guess is almost impossible.

If all the data is correct, the developer sends the registration key to the user.
 
 

The dialog showed to the user when the protected program is executed (figure 1), is used to enter the registration key.

The user should type the registration key in the edit control marked with red.
' Register!!'  button (marked light green) is used to accept the input.

If the registration key matches the registration code, registration is achieved correctly. Once this process is completed, the program will run normally.
If the registration key is not correct, the protection system will show the registration dialog each time the protected program is run.

If the software is registered correctly, the user will not know about protection. If the program is always run on the computer that was registered, the protection will be transparent to the user, but if it's moved to another computer (digital fingerprint change), it will return to the 'not registered' state.
 

It is possible to enable different unlock levels using the Key Generator "Additional features" section.
The key generator can generate different keys for each set of enabled features, as was  explained earlier. The component exports the list of features enabled by the key, in its property SupportedCapabilities
This property can be read runtime by the program to take specific actions for each enabled/disabled feature.
 

Protect for Delphi is a fully customizable invisible component. Registered and not registered messages can be modified runtime/design time. Source code of  Standard Registration Form is included in all versions, and can be freely modified and distributed.
This gives the user the ability to support different languages, although no translation utility is built inside the component.
 
 

Working samples are in this folders:

\Demos\Standard
 Simple.dpr      (Standard demo)
\Demos\Custom
 Custom.dpr     (Custom demo)

To open: In Delphi IDE do (menu) File -> Open -> (go to installation folder) -> (select one of the folders from above) -> (select a .dpr) -> Open.
Compile and run, pressing F9 key.
 

What is the pay method for Protect for Delphi ?
What about support and future upgrades ?

Available pay methods are credit card or money order.
There are two registration options:

 1)  Full version. (component, key generator, ID generator)  No nag-screens.
      Full features enabled. Registration needed for "Key generator"  and "ID Generator".
      Get special offers (at very low price) for future upgrades.

2)  NEW !!!
     Full version with source code. (component, key generator, ID generator, +Source code!!!).
     No nag-screens. Full features enabled. Source code included !!!!
     Receive two months of free technical support, and free upgrades for a year.
 

To register please visit this Web-Site:

            http://www.getsoftware.com/cgi/products.gs?vendor=346
 
 or directly to option 1)

            http://www.getsoftware.com/cgi/verify.gs?cart=1554
 

Additional Section:

When activated, the component generates a digital fingerprint of the first hard disk connected to the computer where the protected program is running.
This fingerprint is ciphered and showed on the standard registration form.
To the developer the registration code contains the following information:
 
•   Serial number of the first hard disk connected to user computer.
            (Unique for each device)
•   Protected program first execution date, on user computer.
•   Unique copy identifier.
            (Number of copy that was distributed to the user)

For the user no part of this information is available, because the registration code is ciphered with the application key, which is only known by the developer.

The key generator, that is part of the system, can generate all the possible Registration Keys. For example, it is possible to generate a full working registration key with all features enabled and no expiration date.
Of course, more restrictive keys are also possible.
The maximum number of supported features is 32, and can be enabled independently.
The key generator validates the Registration Code sent by the user and shows associated data: First execution and unique identifier.
If a copy identifier is present, the registration key enables only the copy with that copy identifier.
(For this option to be valid, a unique copy identifier must be distributed with the protected program. See “Generating unique copy identifiers”)
The first execution date, allows to know how many days the user executed the program in demo version, if you provide a license of this kind.

As noted earlier, the standard behavior can be customized, programming some properties of the component.
To see a custom example open the project:
   \Demos\Custom\Custom.dpr
It is a project that does not use the standard registration form.
 

• Methods

procedure Start;
function TrailPeriodHasExpired: Boolean;
procedure SetRegistrationKey(RegKey: string);

 

• Main

ApplicationKey string
IsRegistered Boolean
CheckSecurityEachNSeconds Integer
MessageNotRegistered string
MessageRegistered string
RegistrationCode       string
 
• Additional

TrialDays Integer
SupportedCapabilities[Number : Integer] Boolean
HardExitProgramOnCheckSecurityFailure Boolean
HardExitWindowsOnCheckSecurityFailure Boolean
UniqueIDShortFilename string (only 4 characters used)
UniqueCopyIdentifier (*) Integer (only lower 26 bits used)
 
• Events

OnNotRegistered     TNotifyEvent
OnRegistered     TNotifyEvent
 
 

Methods

Start:  Must be called somewhere to initialize the component.
            IMPORTANT: If not called, protection will not work
            (Unless you have followed the steps of quick start section)

TrailPeriodHasExpired: Is the trial period finished ?

SetRegistrationKey: Sets the registration key.

Properties

ApplicationKey:  It is the key selected by the developer to name each of the Delphi projects that wants to be copy protected. Must not be revealed to any used.

IsRegistered: Is software registered ?

CheckSecurityEachNSeconds:  Number of seconds between additional checks for security. If its above zero, the component checks the registration state each N seconds after startup. Where N is the value set.

MessageNotRegistered: Not registered message. Strongly ciphered to avoid illegal modification.

MessageRegistered: Registered message. Strongly ciphered to avoid illegal modification.

TrialDays: Trial days of protected program.

SupportedCapabilities[Number : Integer]: Additional features enabled/disabled by registration key. Allows the developer to enable gradually certain features of the protected program.

HardExitProgramOnCheckSecurityFailure: If set to true and additional security fails, the program is aborted abruptly.

HardExitWindowsOnCheckSecurityFailure: If set to true and additional security fails, the operative system is closed abruptly.
(WARNING!!  This security setting is VERY EXTREME.
Any open application at the moment of security failure will be closed without saving associated data. Computer will automatic turn-off, if possible.
USE WITH CAUTION)

UniqueIDShortFilename: Up to 4 characters or numbers that form de header of ".uid" files.
".uid" files are used to store unique copy identifiers.
Correct setting example: MYID
WARNING!: If a not empty value is set, the protected program searches a unique copy identifier with this format:
MYIDNumber.UID in the same directory where the executable is running.
If it is not found, the program aborts execution with a message.
If it is found and the file is not corrupt, the "Unique Copy Identifier" is set to the value ciphered in the .uid file.

UniqueCopyIdentifier: It is the identification number of the protected program copy actually running.
 

If the developer distributes the software, unique copy identifiers are not needed. However, when the distribution is made in a massive way, or by means of a not trusted distributor, unique copy identifiers could be of great help.
Let see the sequential distribution process, when the developer is in charge of that task:

A user  (A) executes a copy of the protected program, this generates a registration code.
He sends this code and the license payment to the developer.
The developer validates the registration code as correct, and sends the registration key.
This process is repeated for all users, one copy at the time, and generates no distribution problems. (Excepting the fact that you cannot sell more than one copy at the time)

 

The process is completely different when copies are distributed in a massive way:
The developer sends a quantity (say 1000) of copies of the protected program to the distributor.
Suppose the distributor has sold 500 copies the first day. The developer will receive the registration queries from the users. Remember that each query has an associated registration code, so we could think that no problem arises.
However, if a certain user is not honest, he could install the protected program on many computers and ask for all the registration keys.
At this point, if copy identifiers are not used, the developer has no way to verify whether a user is trying to get more keys than allowed, or every user is asking for his key.

Of course, the developer knows the quantity of copies sold, but an efficient control cannot be based on that number, because it does not reveal how keys  where distributed among the users.The ideal situation would be that each user could ask only for his registration key, but no other.
If control is made using only the total number of copies sold, this situation could happen:

 

• A user ask for 30 registration keys (at distinct times, with a false identity)

He is asking for the key that belongs to him (remember he paid for only 1 license) and 29 'additional keys'.
• The developer verifies that registration codes are valid. He also knows that the number of copies sold was 500. The developer thinks there are 470 (500 minus 30) users that are not registered, so he waits for 470 registration queries.

(From the users who paid their license the first day)
• As he does not have any reason to suspect, he sends the 30 reg. keys to the cheater. This is a big problem:

The cheater received 30 registration keys, but paid just for one.
Some users that paid for his license will not receive their key.
 

Unique copy identifiers are designed to solve the problem presented in the section above. Basically, they are .uid files that enumerate the copies of the protected program and must be distributed with it.
Valid names for this file are, for example:
 MyID0000001.uid
 MyID0000002.uid
 MyID0010857.uid

If the protected program is distributed with a copy identifier, the registration code contains the copy number information.This allows to know which copy of the protected program is being registered.
The problematic situation presented before is completely saved:
Remember that 1000 copies were distributed and 500 were sold the first day.
 

• A user ask for 30 registration keys (at distinct times, with a false identity)

He is asking for the key that belongs to him (remember he paid for 1 license) and 29 'additional keys'.
• When the first registration query arrives, the developer verifies the authenticity of the registration code, he writes down the IDENTIFIER of the copy being registered and validates it. (The frustrated cheater gets the key for which he has paid)

• When additional queries from the frustrated cheater arrive, each with a distinct registration code, the key generator REPORTS A COPY IDENTIFIER THAT WAS REGISTERED PREVIOUSLY. All the registration codes are different BUT they are related to the same copy identifier.(The cheater has only one copy identifier because he just bought one  license)

The developer notes this abnormal situation and informs the user that is not possible to register more than one copy of the program per license.
(The frustrated cheater DOES NOT get the keys he has not paid for)
 
• When registration queries from other users arrive, the generator reports a copy identifier that is not registered already, so users can be validated normally.

 

To generate the unique copy identifiers, the developer has to run the unique copy identifier generator that comes with the package.
It is called IDGenerator.exe and looks like this:
 (Color highlighting is only indicative)

This generator requires:

1) Application key (marked blue)
2) Unique Identificator file header (marked light green)
3) A values interval (marked red)
4) A directory to store all the identifiers.
Once all data is correct, press the 'Generate Unique ID Files' button to start the generation of identifiers, that are stored on the selected directory.
The stop button stops the generation.
In the example, the interval goes from 1 to 500, so 500 files are generated with this names: MYID.1uid, MYID2.uid, MYID3.uid, ... , MYID500.uid
A distinct .uid should be distributed with the protected program.

In this way, the developer controls the registration of each copy of his program. Each time a query is processed, he must write down the number of copy that is being registered.
If the copy number is already on the list, validation should not continue.
If the copy number is not on his list, validation can be completed successfully. That simple.
 

Additional notes:
 

• Note that the custom demo project use a unique identificator. If this file: MYID0010857.uid is modified or deleted, the program will exit with an error.

• This protection system does NOT hides nor writes information in Windows registry.

 
• The registration code is formed with the digital fingerprint of the first hard disk connected to the user computer, plus the information about first execution, plus the copy identification number.

The digital fingerprint of the disk (serial number + physical characteristics)
DOES NOT depend on disk formatting or contents. This information
is get using a Virtual Device (.vxd) which is internally contained.
This feature simplify both the component and the protected program installation, making unnecessary to distribute the vxd.
Moreover, maximum security is achieved on device identification.
 
• The system allows the user to do an unlimited quantity of backup copies.

All of them will run only in the computer where the program was originally registered.
(The file named  'ProtectedProgramName'.KEY must be located in the same path of the protected program)

• The user can modify the hardware excepting hard disk. The protected program is 'attached' to the disk from which registration was made.

• The protected program MUST run on a computer with hard disk.

The digital fingerprint is relative to the first hard disk connected to the computer.
 
• The registration code and registration key can contain the following characters:

   'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
   'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '.', '1', '2', '3',
   '4', '5', '6', '7', '8', '9', ':', '+', '-', '#','=', '$'
 
 

IMPORTANT: Demo version limitations
 

1) The demo version pack does NOT include the unique identificators file generator.

2) The messages 'registered', 'not registered' show up with this additional text, that cannot be removed:

This program was copy protected using a Demo version of Protect for Delphi
A protection of this kind is NOT ALLOWED for commercial use.
(C)opyright 2000, by Reinaldo Yañez.
e-mail: rya@labs.df.uba.ar, ryaayr@yahoo.com

3) In the Delphi IDE, when a project containing a TProt4Delphi component is open, this message will be showed:
'Reminder: Prot4Delphi component is NOT registered.'
the message repeats each 30 seconds.

4) The property CheckSecurityEachNSeconds is not connected.
    Security is verified each 60 seconds.

5) The property SupportedCapabilities returns correctly only the first 2 features (Feature 0 and Feature 1). The other features are returned as NOT SUPPORTED.
The key generator can set only this two features.

(C)opyright  2000, Reinaldo Yañez Arrey.
Buenos Aires, Argentina.
rya@labs.df.uba.ar
ryaayr@yahoo.com
 
 

About the author:

 Actually I am a physics student at Buenos Aires University. I am working for a company that is dedicated to the development of control software.
At job, I program in Delphi and C. For my own projects I also program in C++ and assembler.
 My e-mail address is:  rya@labs.df.uba.ar  or ryaayr@yahoo.com.

The system I present was developed based on the need to distribute my own software. Some years ago, when old DOS was used, I created a similar copy protection system, that ciphered the final .exe.
When I began to program in Delphi (which, by the way I consider extraordinary) I could not distribute my soft without some 'copyright fear'.
Now I feel I built the right tool.

The only problem is that I do not have the time to make the driver to make it work on Windows NT. I will be probably on exams on February 2000, so I think I will have no extra time.
I realize now that documentation is not so well designed as it should be, so I apologize. However, I wish it could be of some help.

Note: This component uses industrial strength encryption. I have designed a 64 block cipher with 384 (max.) bits of key. It has 128 KBytes of randomly-generated S-BOXES. (I do not believe so much in human made S-BOXES).
 
 

License Agreement  This code is shareware. No warranties, express or implied, are provided. The author is not responsible for any problems caused by this component. Use it at your own risk. The author provides no support whatsoever, and is not obligated to any person or corporation for anything related to this software. The author reserves all rights concerning this code. You are free to evaluate it and distribute it for evaluation purposes, if you do not modify any part of it and you distribute all the files as a whole. This code cannot be sold for any purposes, or included in a commercial collection, without the express written consent of the author.  This License Agreement applies to demo version only, please read the the registration section for more information.  By installing these files on your computer, you agree to all above conditions.

 

(C)opyright  2000, Reinaldo Yañez Arrey.
Buenos Aires, Argentina.
rya@labs.df.uba.ar
ryaayr@yahoo.com