Refactoring code to be lazy with error checkign and begin to support taking in salt,guid,path from command line instead of using hardcoded values.

Author: nooperation

UserPreferencesExplorer/UserPreferencesExplorer.cpp

@@ -2,9 +2,11 @@
 #include <string>
 #include <fstream>
 #include <iostream>
-#include <openssl/evp.h>
 #include <Windows.h>
 
+#include <openssl/evp.h>
+#include <boost/algorithm/hex.hpp>
+
 #pragma comment(lib, "libeay32")
 
 /// <summary>
@@ -14,23 +16,20 @@
 /// <returns>Container of sequential bytes or empty container on error.</returns>
 std::vector<uint8_t> ReadAllBytes(const std::string &path)
 {
-    try
+    std::ifstream inStream(path, std::ios::binary | std::ios::ate);
+    auto fileSize = static_cast<size_t>(inStream.tellg());
+    if (fileSize == 0)
     {
-        std::ifstream inStream(path, std::ios::binary | std::ios::ate);
-        auto fileSize = static_cast<size_t>(inStream.tellg());
-        auto fileBytes = std::vector<uint8_t>(fileSize);
+        throw std::exception("File is empty");
+    }
 
-        inStream.seekg(0, std::ios::beg);
-        inStream.read(reinterpret_cast<char *>(&fileBytes[0]), fileSize);
-        inStream.close();
+    auto fileBytes = std::vector<uint8_t>(fileSize);
 
-        return fileBytes;
-    }
-    catch (const std::exception& ex)
-    {
-        std::cerr << "Failed to read file '" << path << "' - " << ex.what() << std::endl;
-        return std::vector<uint8_t>();
-    }
+    inStream.seekg(0, std::ios::beg);
+    inStream.read(reinterpret_cast<char *>(&fileBytes[0]), fileSize);
+    inStream.close();
+
+    return fileBytes;
 }
 
 /// <summary>
@@ -42,55 +41,40 @@ std::vector<uint8_t> ReadAllBytes(const std::string &path)
 /// <param name="initialization_vector">Initialization vector used for decryption.</param>
 /// <param name="out_plaintext">[out] Decrypted bytes.</param>
 /// <returns>True on success.</returns>
-bool Decrypt(
+std::vector<uint8_t> Decrypt(
     const std::vector<uint8_t> &cipherText,
     const std::vector<uint8_t> &key,
-    const std::vector<uint8_t> &initialization_vector,
-    std::vector<uint8_t> &out_plaintext)
+    const std::vector<uint8_t> &initialization_vector)
 {
-    out_plaintext.resize(cipherText.size());
-    int plaintext_length = 0;
-
+    auto out_plaintext = std::vector<uint8_t>(cipherText.size());
+    auto plaintext_length = 0;
     auto cipher = EVP_aes_256_cbc();
     auto ctx = EVP_CIPHER_CTX_new();
 
     EVP_CIPHER_CTX_init(ctx);
 
-    auto is_successful = EVP_DecryptInit_ex(ctx, cipher, nullptr, &key[0], &initialization_vector[0]);
-    if (is_successful == false)
+    if (!EVP_DecryptInit_ex(ctx, cipher, nullptr, &key[0], &initialization_vector[0]))
     {
-        std::cerr << "EVP_DecryptInit_ex - FAILED" << std::endl;
         EVP_CIPHER_CTX_free(ctx);
-        return false;
+        throw std::exception("EVP_DecryptInit_ex - FAILED");
     }
 
-    is_successful = EVP_DecryptUpdate(
-        ctx,
-        &out_plaintext[0],
-        &plaintext_length,
-        &cipherText[0],
-        static_cast<int>(cipherText.size())
-    );
-
-    if (is_successful == false)
+    if(!EVP_DecryptUpdate(ctx, &out_plaintext[0], &plaintext_length, &cipherText[0], static_cast<int>(cipherText.size())))
     {
-        std::cerr << "EVP_DecryptUpdate - FAILED" << std::endl;
         EVP_CIPHER_CTX_free(ctx);
-        return false;
+        throw std::exception("EVP_DecryptUpdate - FAILED");
     }
 
     auto additional_length = 0;
-    is_successful = EVP_DecryptFinal_ex(ctx, &out_plaintext[plaintext_length], &additional_length);
-    if (is_successful == false)
+    if (!EVP_DecryptFinal_ex(ctx, &out_plaintext[plaintext_length], &additional_length))
     {
-        std::cerr << "EVP_DecryptFinal_ex - FAILED" << std::endl;
         EVP_CIPHER_CTX_free(ctx);
-        return false;
+        throw std::exception("EVP_DecryptFinal_ex - FAILED");
     }
 
     out_plaintext.resize(plaintext_length + additional_length);
     EVP_CIPHER_CTX_free(ctx);
-    return true;
+    return out_plaintext;
 }
 
 /// <summary>
@@ -101,7 +85,7 @@ bool Decrypt(
 /// <param name="out_key">[out] Generated key.</param>
 /// <param name="out_initialization_vector">[out] Generated initialization vector.</param>
 /// <returns>True on success.</returns>
-bool GetKeys(
+void GetKeys(
     const std::vector<uint8_t> &salt,
     const std::vector<uint8_t> &source_bytes,
     std::vector<uint8_t> &out_key,
@@ -115,7 +99,7 @@ bool GetKeys(
     out_key.resize(cipher->key_len);
     out_initialization_vector.resize(cipher->iv_len);
 
-    auto result = EVP_BytesToKey(
+    auto derived_key_length = EVP_BytesToKey(
         cipher,
         md,
         &salt[0],
@@ -125,7 +109,11 @@ bool GetKeys(
         &out_key[0],
         &out_initialization_vector[0]
     );
-    return result > 0;
+
+    if (derived_key_length == 0)
+    {
+        throw std::exception("EVP_BytesToKey - Failed to generate key");
+    }
 }
 
 /// <summary>
@@ -165,26 +153,23 @@ std::string GetMachineGuid()
     if (result != ERROR_SUCCESS)
     {
         RegCloseKey(key_handle);
-        std::cerr << "RegOpenKeyEx - FAILED" << std::endl;
-        return "";
+        throw std::exception("RegOpenKeyEx - FAILED");
     }
 
     DWORD buff_size = 0;
     result = RegQueryValueExA(key_handle, kMachineGuidName.c_str(), nullptr, nullptr, nullptr, &buff_size);
     if (result != ERROR_SUCCESS)
     {
         RegCloseKey(key_handle);
-        std::cerr << "RegQueryValueEx - FAILED" << std::endl;
-        return "";
+        throw std::exception("RegQueryValueEx - FAILED");
     }
 
     auto machine_guid = std::vector<uint8_t>(buff_size);
     result = RegQueryValueExA(key_handle, kMachineGuidName.c_str(), nullptr, nullptr, &machine_guid[0], &buff_size);
     if (result != ERROR_SUCCESS)
     {
         RegCloseKey(key_handle);
-        std::cerr << "RegQueryValueEx - FAILED" << std::endl;
-        return "";
+        throw std::exception("RegQueryValueEx - FAILED");
     }
 
     RegCloseKey(key_handle);
@@ -215,56 +200,50 @@ std::string GetPathToUserPreferencesBag()
     return local_app_data_path + kDefaultUserPreferencesPath;
 }
 
-int main(int argc, char* argv[])
-{
-    // The salt is hardcoded
-    static const std::vector<uint8_t> kSalt {
-        0x6E, 0x3F, 0x03, 0x29, 0x49, 0x63, 0x7D, 0x2E
-    };
 
-    auto machine_guid = GetMachineGuid();
-    if (machine_guid.empty())
-    {
-        std::cerr << "Failed to get MachineGuid" << std::endl;
-        return 0;
-    }
+/// <summary>
+/// Decrypts the specified encrypted user preferences file
+/// </summary>
+/// <param name="file_path">Path to the encrypted UserPreferences.bag</param>
+/// <param name="machine_guid">Machine GUID used to encrypt the UserPreferences.bag</param>
+/// <param name="salt_string">Salt used to encrypt UserPreferences.bag</param>
+/// <returns>Decrypted user preferences</returns>
+std::string DecryptUserPreferences(const std::string& file_path, const std::string& machine_guid, const std::string& salt_string)
+{
+    std::vector<uint8_t> salt_bytes;
+    boost::algorithm::unhex(salt_string.begin(), salt_string.end(), std::back_inserter(salt_bytes));
 
     auto machine_guid_bytes = std::vector<uint8_t>(machine_guid.begin(), machine_guid.end() - 1);
     auto mangled_data = MangleData(machine_guid_bytes);
 
     std::vector<uint8_t> key;
     std::vector<uint8_t> initialization_vector;
-    if (!GetKeys(kSalt, mangled_data, key, initialization_vector))
-    {
-        std::cerr << "Failed to generate keys" << std::endl;
-        return EXIT_FAILURE;
-    }
+    GetKeys(salt_bytes, mangled_data, key, initialization_vector);
 
-    std::string path_to_decrypt;
-    if (argc == 2)
-    {
-        path_to_decrypt = std::string(argv[1]);
-    }
-    else
-    {
-        path_to_decrypt = GetPathToUserPreferencesBag();
-    }
+    auto cipher_text = ReadAllBytes(file_path);
+    auto plaintext = Decrypt(cipher_text, key, initialization_vector);
+
+    return std::string(plaintext.begin(), plaintext.end());
+}
 
-    auto cipher_text = ReadAllBytes(path_to_decrypt);
-    if (cipher_text.empty())
+int main(int argc, char* argv[])
+{
+    static const auto kSalt = std::string("6E3F032949637D2E");
+
+    try
     {
-        std::cerr << "ReadAllBytes - FAILED" << std::endl;
-        return EXIT_FAILURE;
-    }
+        auto user_preferences_path = GetPathToUserPreferencesBag();
+        auto machine_guid = GetMachineGuid();
+        auto salt = kSalt;
 
-    auto plaintext = std::vector<uint8_t>(cipher_text.size());
-    if (!Decrypt(cipher_text, key, initialization_vector, plaintext))
+        auto decrypted_preferences = DecryptUserPreferences(user_preferences_path, machine_guid, salt);
+        std::cout << decrypted_preferences << std::endl;
+    }
+    catch (const std::exception& ex)
     {
-        std::cerr << "Decrypt - FAILED" << std::endl;
+        std::cerr << "Failed to decrypt user preferences: " << ex.what() << std::endl;
         return EXIT_FAILURE;
     }
-
-    std::cout << &plaintext[0] << std::endl;
-
+   
     return EXIT_SUCCESS;
 }