#define WIN32_LEAN_AND_MEAN
#include
#include
#include
#include "aesphm.h"

using namespace CryptoPP;

// WARNING: EXTREMELY SENSITIVE INFORMATION!
#define ACCOUNT_PHRASE_SIZE (XXX + 8 + 20)
static byte accountphrase[ACCOUNT_PHRASE_SIZE] = {

// 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"rn", 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: %srn", passphraseText);

// Inputs
ConstByteArrayParameter passphrase(const_cast(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: %srn", password);
printf("Password Hex: (%u bytes)rn", result.messageLength);
PrintHex(output, result.messageLength);
printf("rn");

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

delete[] passphraseText;
delete[] output;

return 0;
}