Luigi Auriemma

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include "aesphm.h"

using namespace CryptoPP;

// WARNING: EXTREMELY SENSITIVE INFORMATION!
#define ACCOUNT_PHRASE_SIZE (XXX + 8 + 20)
static byte accountphrase[ACCOUNT_PHRASE_SIZE] = {
   <Contents of "phrase" for user>
   // Cipher Text (18 bytes+)
   // IV Seed (8 bytes)
   // Digest (20 bytes)
};

byte *GetRegistryValue(HKEY hKey, const char *key, const char *value, size_t &size)
{
   LONG status;
   HKEY hSubKey;
   byte *result = NULL;

   char *tempKey = _strdup(key);
   char *subSubKey = strchr(tempKey, '\\');
   if (subSubKey)
      *(subSubKey++) = '\0';

   if((status = RegOpenKeyExA(hKey, tempKey, 0, KEY_WOW64_64KEY | KEY_QUERY_VALUE, &hSubKey)) == ERROR_SUCCESS)
   {
      if (subSubKey && *subSubKey)
         result = GetRegistryValue(hSubKey, subSubKey, value, size);
      else
      {
         // Get the size of the value.
         DWORD valueSize = 0;
         status = RegQueryValueExA(hSubKey, value, NULL, NULL, NULL, &valueSize);
         if (status == ERROR_SUCCESS)
         {
            BYTE *valueData = new BYTE[valueSize];
            memset(valueData, 0x00, valueSize);

            status = RegQueryValueExA(hSubKey, value, NULL, NULL, valueData, &valueSize);
            if (status == ERROR_SUCCESS)
            {
               result = valueData;
               size = (size_t)valueSize;
            }
            else
            {
               delete[] valueData;
            }
         }
      }
   }
   else
   {
      printf("Could not open key \"%s\"\r\n", tempKey);
   }

   delete[] tempKey;

   return result;
}

void AppendData(byte *&data, size_t &size, const byte *input, size_t inputSize)
{
   size_t tempSize;
   byte *temp;
   if (data == NULL)
   {
      tempSize = inputSize;
      temp = new byte[tempSize];
      memcpy(temp, input, tempSize);
   }
   else
   {
      tempSize = size + inputSize;
      temp = new byte[tempSize];
      memcpy(temp, data, size);
      memcpy(temp + size, input, inputSize);
      delete[] data;
   }

   data = temp;
   size = tempSize;
}

char *GetPassPhraseText()
{
   size_t size = 0;
   byte *data = NULL;

   size_t productIdSize = 0;
   byte *productId = GetRegistryValue(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion", "ProductId", productIdSize);
   AppendData(data, size, productId, productIdSize - 1);
   delete[] productId;

   size_t machineGuidSize = 0;
   byte *machineGuid = GetRegistryValue(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Cryptography", "MachineGuid", machineGuidSize);
   AppendData(data, size, machineGuid, machineGuidSize - 1);
   delete[] machineGuid;

   size_t ioSize = 0;
   byte *io = GetRegistryValue(HKEY_CURRENT_USER, "Software\\Valve\\Half-Life\\Settings", "io", ioSize);
   AppendData(data, size, io, ioSize - 1);
   delete[] io;

   const byte nullByte[1] = { 0x00 };
   AppendData(data, size, nullByte, 1);

   return (char *)data;
}

void PrintHex(const byte *data, size_t datasize)
{
   for (size_t i = 0; i < datasize; i++)
   {
      if (i != 0)
         printf(" ");
      printf("%02X", data[i]);
   }
}

int main(int argc, char *argv[])
{
   char *passphraseText = GetPassPhraseText();
   printf("Passphrase: %s\r\n", passphraseText);

   // Inputs
   ConstByteArrayParameter passphrase(const_cast<const char *>(passphraseText));
   ConstByteArrayParameter input(accountphrase, ACCOUNT_PHRASE_SIZE);
   // Output
   size_t outputsize = ACCOUNT_PHRASE_SIZE - 8 - 20;
   byte *output = new byte[outputsize];
   memset(output, 0x00, outputsize);

   // Processing
   DecodingResult result = AESPHM::Decrypt(passphrase, output, input);

   // Display
   if (result.isValidCoding)
   {
      char *password = new char[result.messageLength + 1];
      memcpy(password, output, result.messageLength);
      password[result.messageLength] = '\0';

      printf("Password: %s\r\n", password);
      printf("Password Hex: (%u bytes)\r\n", result.messageLength);
      PrintHex(output, result.messageLength);
      printf("\r\n");

      delete[] password;
   }
   else
   {
      printf("Password decryption failed.\r\n");
   }

   delete[] passphraseText;
   delete[] output;

   return 0;
}

// Decrypt random padding (less 1 byte) to output.
decryptor.ProcessString(output, input.begin()+1, paddingLen-1);
// Decrypt actual data to output.
decryptor.ProcessString(output, payload, payloadLen);