Restructuring to introduce basic testing and seperating frontend from backend logic

Author: nooperation

UserPreferencesExplorer/Encryption.cpp

@@ -0,0 +1,216 @@
+#include <openssl/evp.h>
+#include <boost/algorithm/hex.hpp>
+
+#include "UserPreferences.h"
+#include "Utils.h"
+
+#pragma comment(lib, "libeay32")
+
+namespace Encryption
+{
+    namespace
+    {
+        /// <summary>
+        /// Decrypts ciphertext using the given key and initialization vector.
+        /// </summary>
+        /// <param name="ciphertext">Encrypted bytes to decrypt.</param>
+        /// <param name="key">Key used for decryption.</param>
+        /// <param name="initialization_vector">Initialization vector used for decryption.</param>
+        /// <returns>Decrypted contents of ciphertext.</returns>
+        std::vector<uint8_t> Decrypt(
+            const std::vector<uint8_t> &ciphertext,
+            const std::vector<uint8_t> &key,
+            const std::vector<uint8_t> &initialization_vector)
+        {
+            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);
+
+            if (!EVP_DecryptInit_ex(ctx, cipher, nullptr, &key[0], &initialization_vector[0]))
+            {
+                EVP_CIPHER_CTX_free(ctx);
+                throw std::exception("EVP_DecryptInit_ex - FAILED");
+            }
+
+            if (!EVP_DecryptUpdate(ctx, &out_plaintext[0], &plaintext_length, &ciphertext[0], static_cast<int>(ciphertext.size())))
+            {
+                EVP_CIPHER_CTX_free(ctx);
+                throw std::exception("EVP_DecryptUpdate - FAILED");
+            }
+
+            auto additional_length = 0;
+            if (!EVP_DecryptFinal_ex(ctx, &out_plaintext[plaintext_length], &additional_length))
+            {
+                EVP_CIPHER_CTX_free(ctx);
+                throw std::exception("EVP_DecryptFinal_ex - FAILED");
+            }
+
+            out_plaintext.resize(plaintext_length + additional_length);
+            EVP_CIPHER_CTX_free(ctx);
+            return out_plaintext;
+        }
+
+        /// <summary>
+        /// Encrypts plaintext into using the given key and initialization vector.
+        /// </summary>
+        /// <param name="plaintext">Plaintext to encrypt.</param>
+        /// <param name="key">Key used for encryption.</param>
+        /// <param name="initialization_vector">Initialization vector used for encryption.</param>
+        /// <returns>Encrypted plaintext.</returns>
+        std::vector<uint8_t> Encrypt(
+            const std::vector<uint8_t> &plaintext,
+            const std::vector<uint8_t> &key,
+            const std::vector<uint8_t> &initialization_vector)
+        {
+            auto plaintext_length = 0;
+            auto cipher = EVP_aes_256_cbc();
+            auto ctx = EVP_CIPHER_CTX_new();
+
+            auto num_blocks = plaintext.size() / cipher->block_size;
+            if (plaintext.size() % cipher->block_size != 0) {
+                ++num_blocks;
+            }
+            auto out_plaintext = std::vector<uint8_t>(cipher->block_size * num_blocks);
+            memset(&out_plaintext[0], 0, out_plaintext.size());
+
+            EVP_CIPHER_CTX_init(ctx);
+
+            if (!EVP_EncryptInit_ex(ctx, cipher, nullptr, &key[0], &initialization_vector[0]))
+            {
+                EVP_CIPHER_CTX_free(ctx);
+                throw std::exception("EVP_EncryptInit_ex - FAILED");
+            }
+
+            if (!EVP_EncryptUpdate(ctx, &out_plaintext[0], &plaintext_length, &plaintext[0], static_cast<int>(plaintext.size())))
+            {
+                EVP_CIPHER_CTX_free(ctx);
+                throw std::exception("EVP_EncryptUpdate - FAILED");
+            }
+
+            auto additional_length = 0;
+            if (!EVP_EncryptFinal_ex(ctx, &out_plaintext[plaintext_length], &additional_length))
+            {
+                EVP_CIPHER_CTX_free(ctx);
+                throw std::exception("EVP_EncryptFinal_ex - FAILED");
+            }
+
+            out_plaintext.resize(plaintext_length + additional_length);
+            EVP_CIPHER_CTX_free(ctx);
+            return out_plaintext;
+        }
+
+        /// <summary>
+        /// Generates a key and initialization_vector out of the specified salt and source bytes.
+        /// </summary>
+        /// <param name="salt">Salt bytes used to generate the key and initialization vector.</param>
+        /// <param name="source_bytes">Source bytes used to generate the key and initialization vector.</param>
+        /// <param name="out_key">[out] Generated key.</param>
+        /// <param name="out_initialization_vector">[out] Generated initialization vector.</param>
+        /// <returns>True on success.</returns>
+        void GetKeys(
+            const std::vector<uint8_t> &salt,
+            const std::vector<uint8_t> &source_bytes,
+            std::vector<uint8_t> &out_key,
+            std::vector<uint8_t> &out_initialization_vector)
+        {
+            static const int kIterationCount = 5;
+
+            auto cipher = EVP_aes_256_cbc();
+            auto md = EVP_sha1();
+
+            out_key.resize(cipher->key_len);
+            out_initialization_vector.resize(cipher->iv_len);
+
+            auto derived_key_length = EVP_BytesToKey(
+                cipher,
+                md,
+                &salt[0],
+                &source_bytes[0],
+                static_cast<int>(source_bytes.size()),
+                kIterationCount,
+                &out_key[0],
+                &out_initialization_vector[0]
+            );
+
+            if (derived_key_length == 0)
+            {
+                throw std::exception("EVP_BytesToKey - Failed to generate key");
+            }
+        }
+
+        /// <summary>
+        /// Mangles data for use as source bytes when generating a key and initialization vector.
+        /// </summary>
+        /// <param name="data_to_mangle">Bytes to mangle.</param>
+        /// <returns>Collection of mangled bytes.</returns>
+        std::vector<uint8_t> MangleData(const std::vector<uint8_t> &data_to_mangle)
+        {
+            auto mangled_data = std::vector<uint8_t>(data_to_mangle);
+            const auto kMangledDataSize = mangled_data.size();
+
+            for (size_t index = 0; index < kMangledDataSize; ++index)
+            {
+                auto mangled_character = ((index + 2) * mangled_data[index]) % 128;
+                if (mangled_character != 0)
+                {
+                    mangled_data[index] = static_cast<uint8_t>(mangled_character);
+                }
+            }
+
+            return mangled_data;
+        }
+
+        /// <summary>
+        /// Encrypts or decrypts data
+        /// </summary>
+        /// <param name="data">Data to encrypt or decrypt</param>
+        /// <param name="machine_guid">Machine GUID used to encrypt data</param>
+        /// <param name="salt_string">Salt used to encrypt data</param>
+        /// <param name="is_encrypting">Determines if data should be encrypted or decrypted</param>
+        /// <returns>Encrypted or decrypted data</returns>
+        std::vector<uint8_t> EncryptOrDecryptData(
+            const std::vector<uint8_t>& data,
+            const std::string& machine_guid,
+            const std::string& salt_string,
+            bool is_encrypting)
+        {
+            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());
+            auto mangled_data = MangleData(machine_guid_bytes);
+
+            std::vector<uint8_t> key;
+            std::vector<uint8_t> initialization_vector;
+            GetKeys(salt_bytes, mangled_data, key, initialization_vector);
+
+            if (is_encrypting)
+            {
+                return Encrypt(data, key, initialization_vector);
+            }
+            else
+            {
+                return Decrypt(data, key, initialization_vector);
+            }
+        }
+    }
+
+    std::vector<uint8_t> DecryptData(
+        const std::vector<uint8_t>& encrypted_data,
+        const std::string& machine_guid,
+        const std::string& salt_string)
+    {
+        return EncryptOrDecryptData(encrypted_data, machine_guid, salt_string, false);
+    }
+
+    std::vector<uint8_t> EncryptData(
+        const std::vector<uint8_t>& plaintext_data,
+        const std::string& machine_guid,
+        const std::string& salt_string)
+    {
+        return EncryptOrDecryptData(plaintext_data, machine_guid, salt_string, true);
+    }
+}

UserPreferencesExplorer/Main.cpp

@@ -0,0 +1,54 @@
+#include <string>
+#include <iostream>
+#include <boost/program_options.hpp>
+
+#include "UserPreferences.h"
+#include "Utils.h"
+
+int main(int argc, char* argv[])
+{
+    namespace po = boost::program_options;
+    static const auto kSalt = std::string("6E3F032949637D2E");
+
+    try
+    {
+        auto arg_salt = po::value<std::string>()->default_value(kSalt, "");
+        auto arg_guid = po::value<std::string>()->default_value(Utils::GetMachineGuid(), "");
+        auto arg_path = po::value<std::string>()->default_value(Utils::GetPathToUserPreferencesBag(), "");
+
+        auto commandline_descriptions = po::options_description("Arguments");
+        commandline_descriptions.add_options()
+            ("help", "Help")
+            ("salt", arg_salt, "Salt used for key generation.")
+            ("guid", arg_guid, "GUID used for key generation.")
+            ("path", arg_path, "Path to the UserPreferences.bag to decrypt.");
+
+        auto parsed_options = po::parse_command_line(argc, argv, commandline_descriptions);
+        po::variables_map vm;
+        po::store(parsed_options, vm);
+        po::notify(vm);
+
+        if (vm.count("help"))
+        {
+            std::cout << commandline_descriptions << std::endl;
+            return EXIT_SUCCESS;
+        }
+
+        auto path = vm["path"].as<std::string>();
+        auto guid = vm["guid"].as<std::string>();
+        auto salt = vm["salt"].as<std::string>();
+
+        auto ciphertext = Utils::ReadAllBytes(vm["path"].as<std::string>());
+        auto plaintext = Encryption::DecryptData(ciphertext, guid, salt);
+        auto plaintext_string = std::string(plaintext.begin(), plaintext.end());
+
+        std::cout << plaintext_string << std::endl;
+    }
+    catch (const std::exception& ex)
+    {
+        std::cerr << "Failed to decrypt user preferences: " << ex.what() << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}

UserPreferencesExplorer/UserPreferences.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+namespace Encryption
+{
+    /// <summary>
+    /// Decrypts encrypted data
+    /// </summary>
+    /// <param name="encrypted_data">Encrypted data</param>
+    /// <param name="machine_guid">Machine GUID used to encrypt data</param>
+    /// <param name="salt_string">Salt used to encrypt data</param>
+    /// <returns>Decrypted data</returns>
+    std::vector<uint8_t> DecryptData(
+        const std::vector<uint8_t>& encrypted_data,
+        const std::string& machine_guid,
+        const std::string& salt_string);
+
+    /// <summary>
+    /// Encrypts data
+    /// </summary>
+    /// <param name="encrypted_data">Data to encrypt</param>
+    /// <param name="machine_guid">Machine GUID used to encrypt data</param>
+    /// <param name="salt_string">Salt used to encrypt data</param>
+    /// <returns>Decrypted data</returns>
+    std::vector<uint8_t> EncryptData(const std::vector<uint8_t>& plaintext_data,
+        const std::string& machine_guid,
+        const std::string& salt_string);
+};