Click here to Skip to main content
15,867,308 members
Articles / Programming Languages / C#

Copy Protection for Windows Applications (Part 4)

Rate me:
Please Sign up or sign in to vote.
4.97/5 (21 votes)
21 Sep 2009LGPL34 min read 110K   2.3K   127   63
Describes the implementation of a key registration, installation, and validation methodology for Windows applications
Image 1

Introduction

This is the fourth of a four part series of articles on a system that allows you to protect your software against unlicensed use. This series will follow the outline below:

  • Describe the architecture of the system
  • Describe the creation of the license key
  • Describe the process of installing a license key
  • Describe the process of validating an installation

Along the way, we will look at n-bit block feedback encryption (also known as cipher-block chaining; see the Wikipedia article), and an obfustication method that should suitably prevent any attempts to understand how the system works. To add to the difficulty of reverse engineering the system, the result will be a set of COM objects written in unmanaged C++. Interop can be used to invoke the appropriate methods from the .NET Framework.

Background

In part 3, we looked at the means by which license keys are installed, both directly and via the Microsoft Installer. Furthermore, we looked at how MSI files are edited using the Orca utility to accomplish the actual integration.

Disclaimer

Before we begin, your expectations need to be properly set. Specifically, no one reading this series should delude themselves into thinking this system, or any copy-protection mechanism for that matter, is ironclad. The question you should be asking yourself is not "can anyone crack this" but instead "does the person have the skills to do it and will they think it is a reasonable investment of their time to figure out how it works?" Remember: where there's a will, there's a way.

Validation

Validation, from a business perspective (relative to this topic), has one mandatory component and possibly a second:

  • Determine that the installed key is valid
  • Determine that the evaluation period hasn't expired, if applicable

The first item is rather simple as you may imagine. Bearing in mind that this is a COM object, here is the code:

C++
STDMETHODIMP CValidate::Validate(LONG lID1, LONG lID2, LONG lID3, VARIANT_BOOL* pbValid)
//----------------------------------------------------------------------------------------
// This method validates that there is an installed license key 
// matching the manufacturer and product IDs. 
// It also checks that the requested capabilities were licensed.
//----------------------------------------------------------------------------------------
{
   CHAR achKey[MAX_KEYLEN + 1];
   HRESULT hrReturn;

   *pbValid = VARIANT_FALSE;
   hrReturn = NBBF_CANT_RETRIEVE;

   if (RetrieveKey(achKey, sizeof(achKey), lID1, lID2))
   {
      hrReturn = S_OK;

      if (CheckKeyValues(achKey, lID1, lID2, lID3))
         *pbValid = VARIANT_TRUE;
   }

   return hrReturn;
}

As you can see, all we are doing is retrieving the key, if it exists, using the manufacturer and product IDs. Then we are checking the key values to see if they match.

It should be noted that we couldn't retrieve the key unless the manufacturer and product IDs matched. Therefore, this last action is essentially boiled down to confirming that the requested capabilities were properly licensed. We could replace the call to CheckKeyValues with some code, but it would require decoding the key and extrapolating the information first, so I opted to reuse an existing function instead.

The RetrieveKey function is one we haven't seen before. Let's take a look at it.

C++
bool _stdcall RetrieveKey(LPSTR lpstrKey, LONG szKey, LONG lManuID, LONG lProdID)
//----------------------------------------------------------------------------------------
// This function retrieves the license key from the registry. 
// Unlike InstallKey where we could have extracted the manufacturer and product IDs 
// from the license key, we do not (yet) know what the
// license key is so this is impossible to do.
//----------------------------------------------------------------------------------------
{
   CHAR achRegKey[MAX_KEYLEN+1];
   CHAR achRegValue[MAX_KEYLEN+1];
   CHAR achOverlay[MAX_KEYLEN+1];
   bool blnReturn;
   DWORD dwSzValue;
   HKEY hkRoot;
   DWORD dwDisp;
   DWORD dwType;

   //------------------------------------------------------------------------------------
   // See comments in InstallKey about the need to obfuscate 
   // the registry key name and the product key value.
   //-------------------------------------------------------------------------------------
   sprintf_s(achRegKey, sizeof(achRegKey), FMT_REGKEY, lProdID, lManuID);

   OverlayFromIDs(lManuID, lProdID, achOverlay);

   blnReturn = false;
   lpstrKey[0] = 0;
   dwType = REG_SZ;
   dwSzValue = sizeof(achRegValue);
   hkRoot = NULL;

   try
   {
      //---------------------------------------------------------------------------------
      // Generate the registry key name.
      //
      // Using exceptions for error handling is a bad practice generally 
      // but since this will never be used in a high-performance application 
      // we shouldn't be terribly concerned.
      //----------------------------------------------------------------------------------
      if (!In(achRegKey, achOverlay))
         throw 1;

      //----------------------------------------------------------------------------------
      // Query the registry.
      //----------------------------------------------------------------------------------
      if (RegCreateKeyExA(HKEY_LOCAL_MACHINE,
                     REGK_SOFTWARE_NBBF, 
                     0,
                     NULL,
                     REG_OPTION_NON_VOLATILE,
                     KEY_READ,
                     NULL,
                     &hkRoot,
                     &dwDisp) != ERROR_SUCCESS)
         throw 2;

      if (RegQueryValueExA(hkRoot,
                      achRegKey,
                      0,
                      &dwType,
                      (LPBYTE)achRegValue,
                      &dwSzValue) != ERROR_SUCCESS)
         throw 3;

      if (!Out(achRegValue, achOverlay))
         throw 4;

      strncat_s(lpstrKey, szKey, achRegValue, sizeof(achRegValue));
      blnReturn = true;
   }
   catch (int iCode)
   {
   }

   //-------------------------------------------------------------------------------------
   // Cleanup.
   //-------------------------------------------------------------------------------------
   if (hkRoot != NULL)
      RegCloseKey(hkRoot);

   return blnReturn;
}

If this code reminds you of the InstallKey code that we saw last time, it is not a coincidence since the only difference essentially is the use of RegQueryValueExA instead of RegSetValueExA.

Evaluation Periods

As a reminder from part 3, we store in the license key the year and the day of the year (rather than the month and day of the month) that the key was installed. This allows us to easily calculate the number of days elapsed. Here is the code, which is a tad more complex:

C++
STDMETHODIMP CValidate::Elapsed(LONG lID1, LONG lID2, LONG* plElapsed)
//----------------------------------------------------------------------------------------
// This method returns the number of days that have elapsed 
// since the license for the specified manufacturer and product IDs was installed.
//----------------------------------------------------------------------------------------
{
   CHAR achKey[MAX_KEYLEN + 1];
   HRESULT hrReturn;
   CHAR achPart[MAX_PARTLEN + 1];
   LONG lDate;
   LPSTR lpstrEnd;
   LONG lYear;
   LONG lDayOfYear;
   time_t tNow;
   struct tm tGmNow;

   if (!RetrieveKey(achKey, sizeof(achKey), lID1, lID2))
      hrReturn = NBBF_CANT_RETRIEVE;

   else
   {
      hrReturn = S_OK;

      //----------------------------------------------------------------------------------
      // Get the date from the installation data
      //----------------------------------------------------------------------------------
      memset(achPart, 0, sizeof(achPart));
      strncpy_s(achPart, sizeof(achPart), &achKey[OFF_DATE], MAX_PARTLEN);
      lDate = strtol(achPart, &lpstrEnd, BASE_HEX);
      lYear = PARTTOYEAR(lDate);
      lDayOfYear = PARTTOYEARDAY(lDate);

      //----------------------------------------------------------------------------------
      // Get the current UTC date
      //----------------------------------------------------------------------------------
      time(&tNow);
      gmtime_s(&tGmNow, &tNow);

      //----------------------------------------------------------------------------------
      // Calculate the number of days elapsed from the installation date until now
      //----------------------------------------------------------------------------------
      if (lYear == tGmNow.tm_year)
         lDayOfYear = tGmNow.tm_yday - lDayOfYear;

      else
      {
         //-------------------------------------------------------------------------------
         // If we're here, it's because the years are different.  
         // Therefore, calculate the number of days from the installation date 
         // until the end of the year, and then add the full
         // year's worth of days until we've accounted for all of the years.  
         // Finally, add the partial year's worth of days.
         //-------------------------------------------------------------------------------
         if ((lYear % CONV_YEARSPERLEAP) == 0)
            lDayOfYear = CONV_DAYSPERLEAPYEAR - lDayOfYear + 1;

         else
            lDayOfYear = CONV_DAYSPERYEAR - lDayOfYear + 1;

         while (lYear < tGmNow.tm_year)
         {
            lDayOfYear += ((lYear % CONV_YEARSPERLEAP) == 0) ? 
				CONV_DAYSPERLEAPYEAR : CONV_DAYSPERYEAR;
            lYear++;
         }

         lDayOfYear += tGmNow.tm_yday;
      }

      *plElapsed = lDayOfYear;
   }

   return hrReturn;
}

Purists will note that my "leap year determination" test is only 99% accurate since I don't take into consideration the fact that years divisible by 100 aren't leap years. My response is that if my code is still in use in the year 2100 I will happily fix it, but I doubt that'll happen. This coding technique is officially known in Computer Science circles as "a hack."

Summary

In this article, we looked at how installed license keys are validated for correctness. Having seen how license keys are installed, we realized that the validation routines are rather trivial in nature.

As a final note, I have made changes to code along the way that was already available for download in previous parts. The download for this part of the series contains the entire set of solutions and the test application; please delete any previous code you have and download it again to ensure that you have the correct version of the code.

That's it! This concludes the series; I hope this has been helpful and has been valuable in your application development travails.

History

  • September 20, 2009 - Initial version

License

This article, along with any associated source code and files, is licensed under The GNU Lesser General Public License (LGPLv3)


Written By
Sales
United States United States
Larry Salomon has been writing code since he started in Basic on a TRS-80 Model I computer (4K of RAM!) in 1980. Professionally, he started in the OS/2 arena in the late 80's until he switched to Windows development in 1996.

During his multi-decade career, he has coauthored two programming books and published an electronic magazine for just over 3 years. He has written applications in a variety of languages - C# is currently his favorite - and has a few applications available for sale on the Android Application Store.

Currently, Larry works in corporate software sales in the NYC area. You may follow him via his blog at http://larrysalomon.blogspot.com

Comments and Discussions

 
GeneralLink Error - please help [modified] Pin
Michael B Pliam9-Oct-09 7:13
Michael B Pliam9-Oct-09 7:13 
GeneralRe: Link Error - please help Pin
Foolomon9-Oct-09 7:19
Foolomon9-Oct-09 7:19 
GeneralRe: Link Error - please help [modified] Pin
Houdini_tx9-Oct-09 11:35
Houdini_tx9-Oct-09 11:35 
GeneralRe: Link Error - please help [modified] Pin
Gatlarf7-Oct-13 9:43
Gatlarf7-Oct-13 9:43 
GeneralA Question Pin
Houdini_tx4-Oct-09 9:18
Houdini_tx4-Oct-09 9:18 
GeneralRe: A Question Pin
Foolomon4-Oct-09 10:19
Foolomon4-Oct-09 10:19 
GeneralRe: A Question Pin
Houdini_tx4-Oct-09 12:12
Houdini_tx4-Oct-09 12:12 
GeneralRe: A Question [modified] Pin
Foolomon4-Oct-09 12:37
Foolomon4-Oct-09 12:37 
What compiler are you using? The code was written using VS2008, but there's nothing in there (save for the test application) that should require anything above VS2005.

Edit: I don't know why this is happening, but for some reason the shared.h file is not being found by the compiler. In the project settings for NbbfC, NbbfM and NbbfV you need to add the Nbbf/Shared directory (use the fully qualified directory name) to the Additional Include Directories setting.

modified on Sunday, October 4, 2009 6:54 PM

GeneralRe: A Question Pin
Houdini_tx4-Oct-09 13:17
Houdini_tx4-Oct-09 13:17 
GeneralRe: A Question Pin
Foolomon4-Oct-09 13:29
Foolomon4-Oct-09 13:29 
GeneralRe: A Question Pin
Houdini_tx8-Oct-09 6:42
Houdini_tx8-Oct-09 6:42 
GeneralRe: A Question Pin
Foolomon8-Oct-09 7:21
Foolomon8-Oct-09 7:21 
GeneralRe: A Question Pin
Houdini_tx8-Oct-09 9:48
Houdini_tx8-Oct-09 9:48 
GeneralVery well done, thanks... Pin
Bill Gord2-Oct-09 18:11
professionalBill Gord2-Oct-09 18:11 
GeneralRe: Very well done, thanks... Pin
Foolomon4-Oct-09 10:20
Foolomon4-Oct-09 10:20 
GeneralMy vote of 1 Pin
WebMaster1-Oct-09 2:01
WebMaster1-Oct-09 2:01 
GeneralRe: My vote of 1 Pin
Foolomon4-Oct-09 10:20
Foolomon4-Oct-09 10:20 
GeneralMy opinion of the article series Pin
Sternocera28-Sep-09 1:10
Sternocera28-Sep-09 1:10 
GeneralRe: My opinion of the article series Pin
Foolomon28-Sep-09 3:36
Foolomon28-Sep-09 3:36 
GeneralRe: My opinion of the article series Pin
Sternocera28-Sep-09 3:54
Sternocera28-Sep-09 3:54 
GeneralRe: My opinion of the article series Pin
Foolomon28-Sep-09 4:00
Foolomon28-Sep-09 4:00 
GeneralRe: My opinion of the article series Pin
Sternocera28-Sep-09 4:28
Sternocera28-Sep-09 4:28 
GeneralMy vote of 5 Pin
NetDave23-Sep-09 13:54
NetDave23-Sep-09 13:54 
GeneralRe: My vote of 5 Pin
Foolomon23-Sep-09 15:48
Foolomon23-Sep-09 15:48 
GeneralMy vote of 1 Pin
serzh8322-Sep-09 1:12
serzh8322-Sep-09 1:12 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.