C++ Hard'n'Fast

Win32 XP Key Recovery Utility

Willem Fourie — Wed, 31 May 2006 13:08:00 GMT

Following my prior post:

Recover your XP product key from the registry using C#,

I have had many requests to provide the same code in unmanaged C++ - so here goes:

// KeyDecoder.h

#pragma once
#ifndef byte
typedef unsigned char byte;
#endif // byte
class KeyDecoder
{
public:
  enum Key { XP, Office10, Office11 };
  static int DecodeProductKey(KeyDecoder::Key key, char* pDecodedKey);
protected:
  static byte* GetRegistryDigitalProductId(KeyDecoder::Key key);
  static char* DecodeProductKey(byte* digitalProductId);
};

and:

// KeyDecoder.cpp

#include "StdAfx.h"
#include "keydecoder.h"
int KeyDecoder::DecodeProductKey(KeyDecoder::Key key, char* pKey)
{
  byte* pEncodedPID = GetRegistryDigitalProductId(key);
  int keyLen = 0;
  if(pEncodedPID)
  {
    char* pDecodedPID = DecodeProductKey(pEncodedPID);
    if(pDecodedPID)
    {
      keyLen = (int)::strlen(pDecodedPID);
      if(pKey)
      {
        ::strcpy(pKey, pDecodedPID);
      }
      delete[] pDecodedPID;
    }
  }
  return keyLen + 1;
}
char* KeyDecoder::DecodeProductKey(byte* digitalProductId)
{
  // Offset of first byte of encoded product key in 
  //  'DigitalProductIdxxx" REG_BINARY value. Offset = 34H.
  const int keyStartIndex = 52;
  // Offset of last byte of encoded product key in 
  //  'DigitalProductIdxxx" REG_BINARY value. Offset = 43H.
  const int keyEndIndex = keyStartIndex + 15;
  // Possible alpha-numeric characters in product key.
  char digits[] = 
  {
    'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'M', 'P', 'Q', 'R', 
    'T', 'V', 'W', 'X', 'Y', '2', '3', '4', '6', '7', '8', '9',
  };
  // Length of decoded product key
  const int decodeLength = 29;
  // Length of decoded product key in byte-form.
  // Each byte represents 2 chars.
  const int decodeStringLength = 15;
  // Array of containing the decoded product key.
  char* pDecodedChars = new char[decodeLength + 1];
  ::memset(pDecodedChars, 0, decodeLength + 1); 
  // Extract byte 52 to 67 inclusive.
  byte hexPid[keyEndIndex - keyStartIndex + 1];
  for (int i = keyStartIndex; i <= keyEndIndex; i++)
  {
    hexPid[i - keyStartIndex] = digitalProductId[i];
  }
  for (int i = decodeLength - 1; i >= 0; i--)
  {
    // Every sixth char is a separator.
    if ((i + 1) % 6 == 0)
    {
      *(pDecodedChars + i) = '-';
    }
    else
    {
      // Do the actual decoding.
      int digitMapIndex = 0;
      for (int j = decodeStringLength - 1; j >= 0; j--)
      {
        int byteValue = (digitMapIndex << 8) | hexPid[j];
        hexPid[j] = (byte)(byteValue / 24);
        digitMapIndex = byteValue % 24;
        *(pDecodedChars + i) = digits[digitMapIndex];
      }
    }
  }
  return pDecodedChars;
}
byte* KeyDecoder::GetRegistryDigitalProductId(KeyDecoder::Key key)
{
  HKEY hKey = 0;
  LONG lResult = 0L;
  const char* pPIDName = "DigitalProductId";
  byte* pPID = 0;
  switch(key)
  {
    case KeyDecoder::Key::XP:
      lResult = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
        0, KEY_QUERY_VALUE, &hKey);
      break;
    case KeyDecoder::Key::Office10:
      break;
    case KeyDecoder::Key::Office11:
      break;
  }
  if(lResult == ERROR_SUCCESS)
  {
    DWORD cbData = 0;
    DWORD dwType = 0;
    lResult = ::RegQueryValueEx(hKey, pPIDName, 0, &dwType, 0, &cbData);
    if(lResult == ERROR_SUCCESS)
    {
      pPID = new byte[cbData];
      lResult = ::RegQueryValueEx(hKey, pPIDName, 0, &dwType, pPID, &cbData);
      if(lResult != ERROR_SUCCESS)
      {
        delete[] pPID;
        pPID = 0;
      }
    }
  }
  if(hKey)
  {
    ::RegCloseKey(hKey);
  }
  return pPID;
}

This provides the same functionality as the C# code in the prior post.

XPKey is a standard Win32 console application that pops up a message box containing the decoded XP product key. It also copies the product key to the clipboard. You can download the executable here:

Download XPKey Console Application,

and the VC source-code and project file here:

Download XPKey Source Code.

The C++ application is provided for VS2003, but should convert without problems to VS2005. It uses only standard Win32 calls - no MFC/ATL/STL etc.

Integrating fingerprint and RFID readers in AD/AM applications

Willem Fourie — Mon, 31 Oct 2005 00:35:00 GMT

An interesting adventure - if anyone is interested in how to do this contact me. We used the following devices:

SAGEM MSO-series fingerprint reader

pcPRox RFID reader

ADAM primarily, with some AD integration to hold the fingerprint-minutae data

What made this interesting was writing the application entirely in 'Unmanaged' C++ and integrating the SAGEM SDK (MorphoSmart API) and the pcProxlib API SDK. Both these APIs are provided as native C++ DLLs and ultimately drove our decision to go the complete C++ route. Some useful techniques for using the ADSI ('ADs...') calls and the various AD/AM COM objects was (painfully) learnt.

We are currently building a C#-interop wrapper for the various SDKs to make life a lot easier...

User input idle detection in MFC applications

Willem Fourie — Mon, 31 Oct 2005 00:29:00 GMT

We needed to write an application that would automatically execute a time-out action, the time-out being a prescribed length of time that has expired without any user input occurring during that period.

Not as easy as it sounds. One way to do it is to setup a set of system-hooks using the message hook APIs provided by Win32. I personally did not like this approach for the following reasons:

Using system-hooks is intrusive and reduces overall system performance.
Its more work, because the hooks provide callbacks for all the windows/processes running and they would have to be filtered.
There may be security and credentials constraints setting system-wide hooks while running the application as a user with certain permissions.

I discovered a little gem: the Win32 (user.lib) GetLastInputInfo function which returns a data structure containing the system tick-count when the last user input was detected. User input is defined as any captured mouse event or application keyboard event. One problem with this very easy to use function is that if specific inputs have to recognized, eg only mouse events, this function cannot be used.

The following code-excerpt provides a means of detecting an application user-input idle timeout. The example is an MFC application, and uses a timer event to periodically poll for the last user input time:

void CMyWindow::OnTimer(UINT nIDEvent)

{

// timer event for polling for user-idle timeout.

if(nIDEvent == TIMEOUT_TIMER_ID)

{

// Get the last input event info.

LASTINPUTINFO li;

li.cbSize = sizeof(LASTINPUTINFO);

::GetLastInputInfo(&li);

// Calculate the time elapsed in seconds.

DWORD te = ::GetTickCount();

int elapsed = (te - li.dwTime) / 1000;

// Test against a preset timeout period in

// seconds.

if(Application()->TimeOut() < elapsed)

{

// Call a function or set an application flag

// that can be acted on outside this function.

OnTimeout();

}

BTW, this API is only available in WIN 2000 onwards - correct your stdafx.h file as follows, to ensure correct compilation and linking:

#define WINVER 0x0500
#define _WIN32_WINNT 0x0500