From 8b9221e2e0a0f70179c4c55d8cac7398de3eb487 Mon Sep 17 00:00:00 2001 From: Leonetienne Date: Thu, 26 May 2022 21:32:04 +0200 Subject: [PATCH] Add Configuration class to intelligently decide default settings --- GCryptCLI/CMakeLists.txt | 5 + GCryptCLI/include/Configuration.h | 52 +++ GCryptCLI/include/DataIngestionLayer.h | 0 GCryptCLI/src/CommandlineInterface.cpp | 94 ++++-- GCryptCLI/src/Configuration.cpp | 156 +++++++++ GCryptCLI/src/DataIngestionLayer.cpp | 0 GCryptCLI/src/main.cpp | 434 +------------------------ 7 files changed, 288 insertions(+), 453 deletions(-) create mode 100644 GCryptCLI/include/Configuration.h create mode 100644 GCryptCLI/include/DataIngestionLayer.h create mode 100644 GCryptCLI/src/Configuration.cpp create mode 100644 GCryptCLI/src/DataIngestionLayer.cpp diff --git a/GCryptCLI/CMakeLists.txt b/GCryptCLI/CMakeLists.txt index 9541a68..1e39b42 100644 --- a/GCryptCLI/CMakeLists.txt +++ b/GCryptCLI/CMakeLists.txt @@ -42,3 +42,8 @@ target_include_directories(${PROJECT_NAME} PRIVATE ${gcrypt_include} ) +target_compile_options(${PROJECT_NAME} PRIVATE + -Werror + -fdiagnostics-color=always +) + diff --git a/GCryptCLI/include/Configuration.h b/GCryptCLI/include/Configuration.h new file mode 100644 index 0000000..979cae6 --- /dev/null +++ b/GCryptCLI/include/Configuration.h @@ -0,0 +1,52 @@ +#ifndef GCRYPTCLI_CONFIGURATION_H +#define GCRYPTCLI_CONFIGURATION_H + +#include + +class Configuration { + public: + static enum class INPUT_FROM { + STDIN, + FILE, + PARAMETER + } inputFrom; + + static enum class OUTPUT_TO { + STDOUT, + FILE + } outputTo; + + static enum class IOBASE_FORMAT { + BASE_BYTES, + BASE_2, + BASE_8, + BASE_10, + BASE_16, + BASE_64, + BASE_UWU, + BASE_UGH + } iobaseFormat; + + static std::string inputFilename; + static std::string outputFilename; + + static enum class MODULE { + ENCRYPT, + DECRYPT, + HASH, + GENERATE_KEYFILE + } activeModule; + + //! Will analyze the supplied cli parameters, + //! and decide what the configuration will be. + static void Parse(); + + private: + static void DecideInputFrom(); + static void DecideOutputTo(); + static void DecideIOBaseFormat(); + static void DecideModule(); +}; + +#endif + diff --git a/GCryptCLI/include/DataIngestionLayer.h b/GCryptCLI/include/DataIngestionLayer.h new file mode 100644 index 0000000..e69de29 diff --git a/GCryptCLI/src/CommandlineInterface.cpp b/GCryptCLI/src/CommandlineInterface.cpp index b0bf54a..0a17b39 100644 --- a/GCryptCLI/src/CommandlineInterface.cpp +++ b/GCryptCLI/src/CommandlineInterface.cpp @@ -2,14 +2,13 @@ #include #include #include -#include +#include #include "Version.h" using namespace Hazelnp; -using namespace Leonetienne; +using namespace Leonetienne::GCrypt; -void CommandlineInterface::Init(int argc, const char* const* argv) -{ +void CommandlineInterface::Init(int argc, const char* const* argv) { /* General information */ std::stringstream ss; ss << "CLI for the GCrypt cipher/obfuscator" << std::endl @@ -23,20 +22,20 @@ void CommandlineInterface::Init(int argc, const char* const* argv) nupp.SetCrashOnFail("true"); /* Builtin documentation */ - nupp.RegisterDescription("--encrypt", "Use the encryption routine."); + nupp.RegisterDescription("--encrypt", "Use the encryption module."); nupp.RegisterConstraint("--encrypt", ParamConstraint(true, DATA_TYPE::VOID, {}, false, {"--decrypt", "--hash" })); nupp.RegisterAbbreviation("-e", "--encrypt"); - nupp.RegisterDescription("--decrypt", "Use decryption routine."); + nupp.RegisterDescription("--decrypt", "Use decryption module."); nupp.RegisterConstraint("--decrypt", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--encrypt", "--hash", "--generate-keyfile" })); nupp.RegisterAbbreviation("-d", "--decrypt"); - nupp.RegisterDescription("--hash", "Use the GHash hash function to calculate a hashsum."); + nupp.RegisterDescription("--hash", "Use the GHash hash module to calculate a hashsum."); nupp.RegisterConstraint("--hash", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--encrypt", "--decrypt", "--generate-keyfile" })); nupp.RegisterAbbreviation("-h", "--hash"); - nupp.RegisterDescription("--generate-keyfile", "Will generate a random keyfile, and exit."); - nupp.RegisterConstraint("--generate-keyfile", ParamConstraint(true, DATA_TYPE::STRING, { "--encrypt", "--decrypt", "--hash" }, false, {})); + nupp.RegisterDescription("--generate-keyfile", "Use the Keyfile module. Will generate a random keyfile, and exit."); + nupp.RegisterConstraint("--generate-keyfile", ParamConstraint(true, DATA_TYPE::STRING, {}, false, { "--encrypt", "--decrypt", "--hash" })); nupp.RegisterDescription("--intext", "Encrypt this string."); nupp.RegisterConstraint("--intext", ParamConstraint(true, DATA_TYPE::STRING, {}, false, { "--infile" })); @@ -55,7 +54,7 @@ void CommandlineInterface::Init(int argc, const char* const* argv) nupp.RegisterConstraint("--key", ParamConstraint(true, DATA_TYPE::STRING, {}, false, { "--keyfile", "--keyask", "--hash" })); nupp.RegisterAbbreviation("-k", "--key"); - ss << "Read in the first {KEYSIZE}(=" << GCrypt::BLOCK_SIZE << ") bits of this file and use that as an encryption key. WARNING: Arguments may be logged by the system!"; + ss << "Read in the first {KEYSIZE}(=" << Block::BLOCK_SIZE_BITS << ") bits of this file and use that as an encryption key. WARNING: Arguments may be logged by the system!"; nupp.RegisterDescription("--keyfile", ss.str()); ss.str(""); nupp.RegisterConstraint("--keyfile", ParamConstraint(true, DATA_TYPE::STRING, {}, false, { "--key", "--keyask", "--hash" })); @@ -73,25 +72,25 @@ void CommandlineInterface::Init(int argc, const char* const* argv) nupp.RegisterConstraint("--iobase-bytes", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-2", "--iobase-8", "--iobase-10", "--iobase-16", "--iobase-64", "--iobase-uwu", "--iobase-ugh" })); nupp.RegisterDescription("--iobase-2", "Interpret and format ciphertexts in base2"); - nupp.RegisterConstraint("--iobase-2", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-8", "--iobase-10", "--iobase-16",, "--iobase-64", "--iobase-uwu", "--iobase-ugh" })); + nupp.RegisterConstraint("--iobase-2", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-8", "--iobase-10", "--iobase-16", "--iobase-64", "--iobase-uwu", "--iobase-ugh" })); nupp.RegisterDescription("--iobase-8", "Interpret and format ciphertexts in base8"); - nupp.RegisterConstraint("--iobase-8", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-10", "--iobase-16",, "--iobase-64", "--iobase-uwu", "--iobase-ugh" })); + nupp.RegisterConstraint("--iobase-8", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-10", "--iobase-16", "--iobase-64", "--iobase-uwu", "--iobase-ugh" })); nupp.RegisterDescription("--iobase-10", "Interpret and format ciphertexts in base10"); - nupp.RegisterConstraint("--iobase-10", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-16",, "--iobase-64", "--iobase-uwu", "--iobase-ugh" })); + nupp.RegisterConstraint("--iobase-10", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-16", "--iobase-64", "--iobase-uwu", "--iobase-ugh" })); nupp.RegisterDescription("--iobase-16", "Interpret and format ciphertexts in base16 (hex)"); nupp.RegisterConstraint("--iobase-16", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-64", "--iobase-uwu", "--iobase-ugh" })); nupp.RegisterDescription("--iobase-64", "Interpret and format ciphertexts in base64"); - nupp.RegisterConstraint("--iobase-64", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-10", "--iobase-16",, "--iobase-uwu", "--iobase-ugh" })); + nupp.RegisterConstraint("--iobase-64", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-10", "--iobase-16", "--iobase-uwu", "--iobase-ugh" })); nupp.RegisterDescription("--iobase-uwu", "Interpret and format ciphertexts in base uwu"); - nupp.RegisterConstraint("--iobase-uwu", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-10", "--iobase-16",, "--iobase-64", "--iobase-ugh" })); + nupp.RegisterConstraint("--iobase-uwu", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-10", "--iobase-16", "--iobase-64", "--iobase-ugh" })); nupp.RegisterDescription("--iobase-ugh", "Interpret and format ciphertexts in base ugh"); - nupp.RegisterConstraint("--iobase-ugh", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-10", "--iobase-16",, "--iobase-64", "--iobase-uwu" })); + nupp.RegisterConstraint("--iobase-ugh", ParamConstraint(true, DATA_TYPE::VOID, {}, false, { "--iobase-bytes", "--iobase-2", "--iobase-8", "--iobase-10", "--iobase-16", "--iobase-64", "--iobase-uwu" })); nupp.RegisterDescription("--lib-version", "Will supply the version of GCryptLib used."); nupp.RegisterConstraint("--lib-version", ParamConstraint(true, DATA_TYPE::VOID, {}, false, {})); @@ -115,13 +114,23 @@ void CommandlineInterface::Init(int argc, const char* const* argv) return; } -Hazelnp::CmdArgsInterface& CommandlineInterface::Get() -{ +Hazelnp::CmdArgsInterface& CommandlineInterface::Get() { return nupp; } -void CommandlineInterface::SpecialCompatibilityChecking() -{ +void CommandlineInterface::SpecialCompatibilityChecking() { + + // Active module + // Do we have EITHER --encrypt or --decrypt or --hash? + if ( + (!nupp.HasParam("--generate-keyfile")) && + (!nupp.HasParam("--hash")) && + (!nupp.HasParam("--encrypt")) && + (!nupp.HasParam("--decrypt")) + ) { + CrashWithMsg("No module supplied! Please supply either --encrypt, --decrypt, --hash, or --generate-keyfile!"); + } + // Encryption key // Do we have EITHER --hash (no key required), --generate-keyfile (no key required), --key, --keyask or --keyfile given? if ( @@ -130,23 +139,43 @@ void CommandlineInterface::SpecialCompatibilityChecking() (!nupp.HasParam("--key")) && (!nupp.HasParam("--keyfile")) && (!nupp.HasParam("--keyask")) - ) + ) { CrashWithMsg("No encryption key supplied! Please supply either --key, --keyfile, or --keyask!"); + } - // Digestion mode - // Do we have EITHER --encrypt or --decrypt or --hash? + // Check that, if supplied, filename strings are not empty. if ( - (!nupp.HasParam("--hash")) && - (!nupp.HasParam("--encrypt")) && - (!nupp.HasParam("--decrypt")) - ) - CrashWithMsg("No digestion mode supplied! Please supply either --encrypt, --decrypt, or --hash!"); + (nupp.HasParam("--ofile")) && + (nupp["--ofile"].GetString().length() == 0) + ) { + CrashWithMsg("Length of --ofile is zero! That can't be a valid path!"); + } + + if ( + (nupp.HasParam("--ifile")) && + (nupp["--ifile"].GetString().length() == 0) + ) { + CrashWithMsg("Length of --ifile is zero! That can't be a valid path!"); + } + + if ( + (nupp.HasParam("--keyfile")) && + (nupp["--keyfile"].GetString().length() == 0) + ) { + CrashWithMsg("Length of --keyfile is zero! That can't be a valid path!"); + } + + if ( + (nupp.HasParam("--generate-keyfile")) && + (nupp["--generate-keyfile"].GetString().length() == 0) + ) { + CrashWithMsg("Length of --generate-keyfile is zero! That can't be a valid path!"); + } return; } -void CommandlineInterface::CrashWithMsg(const std::string& msg) -{ +void CommandlineInterface::CrashWithMsg(const std::string& msg) { std::cerr << nupp.GetBriefDescription() << std::endl @@ -156,11 +185,10 @@ void CommandlineInterface::CrashWithMsg(const std::string& msg) exit(-1); } -void CommandlineInterface::CatchVersionQueries() -{ +void CommandlineInterface::CatchVersionQueries() { if ( (nupp.HasParam("--version")) || - (nupp.HasParam("--cli-version") + (nupp.HasParam("--cli-version")) ) { std::cout << GCRYPTCLI_VERSION << std::endl; exit(0); diff --git a/GCryptCLI/src/Configuration.cpp b/GCryptCLI/src/Configuration.cpp new file mode 100644 index 0000000..43c2438 --- /dev/null +++ b/GCryptCLI/src/Configuration.cpp @@ -0,0 +1,156 @@ +#include "Configuration.h" +#include "CommandlineInterface.h" + +void Configuration::Parse() { + DecideModule(); + DecideInputFrom(); + DecideOutputTo(); + DecideIOBaseFormat(); + + return; +} + +void Configuration::DecideInputFrom() { + + if (CommandlineInterface::Get().HasParam("--intext")) { + inputFrom = INPUT_FROM::PARAMETER; + } + else if (CommandlineInterface::Get().HasParam("--infile")) { + inputFrom = INPUT_FROM::FILE; + inputFilename = CommandlineInterface::Get()["--infile"].GetString(); + } + else { + inputFrom = INPUT_FROM::STDIN; + } + + return; +} + +void Configuration::DecideOutputTo() { + + // If module is "generate keyfile", we'll always write to a file. + if (activeModule == MODULE::GENERATE_KEYFILE) { + outputTo = OUTPUT_TO::FILE; + outputFilename = CommandlineInterface::Get()["--generate-keyfile"].GetString(); + } + + // Else, check if we have an --ofile defined. + if (CommandlineInterface::Get().HasParam("--ofile")) { + outputTo = OUTPUT_TO::FILE; + outputFilename = CommandlineInterface::Get()["--ofile"].GetString(); + } + else { + outputTo = OUTPUT_TO::STDOUT; + } + + return; +} + +void Configuration::DecideModule() { + if (CommandlineInterface::Get().HasParam("--encrypt")) { + activeModule = MODULE::ENCRYPT; + } + else if (CommandlineInterface::Get().HasParam("--decrypt")) { + activeModule == MODULE::DECRYPT; + } + else if (CommandlineInterface::Get().HasParam("--hash")) { + activeModule == MODULE::HASH; + } + else if (CommandlineInterface::Get().HasParam("--generate-keyfile")) { + activeModule == MODULE::GENERATE_KEYFILE; + } + + return; +} + +void Configuration::DecideIOBaseFormat() { + + // Do we have any iobase specified? + if (CommandlineInterface::Get().HasParam("--iobase-bytes")) { + iobaseFormat = IOBASE_FORMAT::BASE_BYTES; + return; + } + else if (CommandlineInterface::Get().HasParam("--iobase-2")) { + iobaseFormat = IOBASE_FORMAT::BASE_2; + return; + } + else if (CommandlineInterface::Get().HasParam("--iobase-8")) { + iobaseFormat = IOBASE_FORMAT::BASE_8; + return; + } + else if (CommandlineInterface::Get().HasParam("--iobase-10")) { + iobaseFormat = IOBASE_FORMAT::BASE_10; + return; + } + else if (CommandlineInterface::Get().HasParam("--iobase-16")) { + iobaseFormat = IOBASE_FORMAT::BASE_16; + return; + } + else if (CommandlineInterface::Get().HasParam("--iobase-64")) { + iobaseFormat = IOBASE_FORMAT::BASE_64; + return; + } + else if (CommandlineInterface::Get().HasParam("--iobase-uwu")) { + iobaseFormat = IOBASE_FORMAT::BASE_UWU; + return; + } + else if (CommandlineInterface::Get().HasParam("--iobase-ugh")) { + iobaseFormat = IOBASE_FORMAT::BASE_UGH; + return; + } + + // So we have no iobase explicitly specified.. Let's default.. + + // If we are encrypting or hashing, + if ( + (activeModule == MODULE::ENCRYPT) || + (activeModule == MODULE::HASH) + ) { + // and input comes from a parameter, + // and output goes to stdout, let's assume base-16. + if ( + (inputFrom == INPUT_FROM::PARAMETER) && + (outputTo == OUTPUT_TO::STDOUT) + ) { + iobaseFormat = IOBASE_FORMAT::BASE_16; + return; + } + + // Any other case whilst encrypting, we'll assume base-bytes. + else { + iobaseFormat = IOBASE_FORMAT::BASE_BYTES; + return; + } + + } + + // Else, if we are decrypting, + else if (activeModule == MODULE::DECRYPT) { + // and input comes from a parameter, we'll assume base-16. + if (inputFrom == INPUT_FROM::PARAMETER) { + iobaseFormat = IOBASE_FORMAT::BASE_16; + return; + } + // Any other case whilst decrypting, we'll assume base-bytes. + else { + iobaseFormat = IOBASE_FORMAT::BASE_BYTES; + return; + } + } + + // Else, if we are generating a keyfile, iobase format is bytes. + else if (activeModule == MODULE::GENERATE_KEYFILE) { + iobaseFormat = IOBASE_FORMAT::BASE_BYTES; + return; + } + + return; +} + +std::string Configuration::inputFilename; +std::string Configuration::outputFilename; +Configuration::MODULE Configuration::activeModule; +Configuration::IOBASE_FORMAT Configuration::iobaseFormat; +Configuration::INPUT_FROM Configuration::inputFrom; +Configuration::OUTPUT_TO Configuration::outputTo; + diff --git a/GCryptCLI/src/DataIngestionLayer.cpp b/GCryptCLI/src/DataIngestionLayer.cpp new file mode 100644 index 0000000..e69de29 diff --git a/GCryptCLI/src/main.cpp b/GCryptCLI/src/main.cpp index 497f8c5..5f16f6f 100644 --- a/GCryptCLI/src/main.cpp +++ b/GCryptCLI/src/main.cpp @@ -1,420 +1,14 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "CommandlineInterface.h" - -#include "Bases.h" -#include -#include - -// Required for hidden password input -#if defined _WIN32 || defined _WIN64 -#include -#elif defined __GNUG__ -#include -#include -#endif - -using namespace ::Leonetienne::GCrypt; -using namespace ::Leonetienne::StringTools; -using namespace ::Leonetienne::GeneralUtility; - -enum class OPERATION_MODE { - ENCRYPT, - DECRYPT, - HASH -}; - -namespace { - inline std::string Bin2CustomBase(const std::string& bin, const std::vector& customSet, const std::string& seperator = "") - { - std::stringstream ss; - - // Translate to custom set - const std::vector vec_base_custom = - Leonetienne::GeneralUtility::BaseConversion::BaseX_2_Y>(bin, "01", customSet); - - // Convert to string - for (std::size_t i = 0; i < vec_base_custom.size(); i++) - { - ss << vec_base_custom[i]; - - if (i != vec_base_custom.size() - 1) - ss << seperator; - } - - return ss.str(); - } - - inline std::string CustomBase2Bin(const std::string& in, const std::vector& customSet, const std::string& seperator = "") - { - // Split input into symbols - const std::vector in_symbols = StringTools::Split(in, seperator); - - // Translate to binary - std::string binary = - Leonetienne::GeneralUtility::BaseConversion::BaseX_2_Y, std::string>(in_symbols, customSet, std::string("01")); - - // Apply padding to be a multiple of BLOCK_SIZE - // Count how many bits we need - std::size_t required_size = 0; - while (required_size < binary.length()) - required_size += BLOCK_SIZE; - - // Create a string of that many zeroes - std::string padding = ""; - for (std::size_t i = binary.length(); i < required_size; i++) - padding += "0"; - - // Prepend it to our bitstring - binary = padding + binary; - - return binary; - } -} - -//! Will prompt a user password from stdin, hiding the input -std::string PasswordPrompt() -{ - // Disable stdin-echo - #if defined _WIN32 || defined _WIN64 - HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE); - DWORD mode = 0; - GetConsoleMode(hStdin, &mode); - SetConsoleMode(hStdin, mode & (~ENABLE_ECHO_INPUT)); - - #elif defined __GNUG__ - termios oldt; - tcgetattr(STDIN_FILENO, &oldt); - termios newt = oldt; - newt.c_lflag &= ~ECHO; - tcsetattr(STDIN_FILENO, TCSANOW, &newt); - - #endif - - // Prompt stdin - std::string key; - std::cin >> key; - - // Restore previous config - #if defined _WIN32 || defined _WIN64 - SetConsoleMode(hStdin, mode); - - #elif defined __GNUG__ - tcsetattr(STDIN_FILENO, TCSANOW, &oldt); - - #endif - - // Return input - return key; -} - -Block GetEncryptionKey() -{ - // Easy-case: key supplied as param - if (CommandlineInterface::Get().HasParam("--key")) - return PasswordToKey(CommandlineInterface::Get()["--key"].GetString()); - - // Case: Ask for key - else if (CommandlineInterface::Get().HasParam("--keyask")) - return PasswordToKey(PasswordPrompt()); - - // Case: Read key from file - else if (CommandlineInterface::Get().HasParam("--keyfile")) - { - const std::string keyfilepath = CommandlineInterface::Get()["--keyfile"].GetString(); - - // Read this many chars - const std::size_t maxChars = BLOCK_SIZE / 8; - - // Open ifilestream for keyfile - std::ifstream ifs(keyfilepath, std::ios::in | std::ios::binary); - - // Is the file open now? Or were there any issues... - if (!ifs.good()) - { - std::cerr << "Unable to open ifilestream for keyfile \"" << keyfilepath << "\"! Aborting..." << std::endl; - exit(-1); - } - - // Read these chars to buffer - char* ckeyfileContent = new char[maxChars]; - memset(ckeyfileContent, 0, maxChars * sizeof(char)); - ifs.read(ckeyfileContent, maxChars); - ifs.close(); - - // Convert the buffer to a bit block of key size - std::stringstream ss; - for (std::size_t i = 0; i < maxChars; i++) - ss << std::bitset<8>(ckeyfileContent[i]); - - Block key(ss.str()); - - // And delete the buffer - delete[] ckeyfileContent; - ckeyfileContent = nullptr; - - // Return it - return key; - } - - // Unreachable - throw std::runtime_error("This code should not have been reached. Most likely, the cli argument parser failed making sure at least one key method was supplied."); -} - -const Flexblock GetInputText(const OPERATION_MODE operationMode) -{ - // Easy-case: input text supplied as param - if (CommandlineInterface::Get().HasParam("--intext")) { - switch (operationMode) { - // Encryption, or hashing mode: We want to return the text as-is, as bits - case OPERATION_MODE::ENCRYPT: - case OPERATION_MODE::HASH: - return StringToBits(CommandlineInterface::Get()["--intext"].GetString()); - - // Decryption mode: We need to first convert our input to a bitstring - case OPERATION_MODE::DECRYPT: - const std::string userInput = CommandlineInterface::Get()["--intext"].GetString(); - - // Are we using iobase 2? - if (CommandlineInterface::Get().HasParam("--iobase-2")) - // Yes: convert to binary from base 2 - return CustomBase2Bin(userInput, BASE_2); - - // Are we using iobase 8? - else if (CommandlineInterface::Get().HasParam("--iobase-8")) - // Yes: convert to binary from base 8 - return CustomBase2Bin(userInput, BASE_8); - - // Are we using iobase 10? - else if (CommandlineInterface::Get().HasParam("--iobase-10")) - // Yes: convert to binary from base 10 - return CustomBase2Bin(userInput, BASE_10); - - // Are we using iobase 64? - else if (CommandlineInterface::Get().HasParam("--iobase-64")) - // Yes: convert to binary from base 64 - return CustomBase2Bin(userInput, BASE_64); - - // Are we using iobase uwu? - else if (CommandlineInterface::Get().HasParam("--iobase-uwu")) - // Yes: convert to binary from base uwu - return CustomBase2Bin(userInput, BASE_UWU, " "); - - // Are we using iobase emoji? - else if (CommandlineInterface::Get().HasParam("--iobase-ugh")) - // Yes: convert to binary from base ugh - return CustomBase2Bin(userInput, BASE_UGH, " "); - - // Else, no special output format specified, use hex - else - return HexstringToBits(userInput); - } - } - - - // Case: Read from file - else if (CommandlineInterface::Get().HasParam("--infile")) - return ReadFileToBits(CommandlineInterface::Get()["--infile"].GetString()); - - // Unreachable - throw std::runtime_error("This code should not have been reached. Most likely, the cli argument parser failed making sure at least one input method was supplied."); -} - -const std::string GetOutfileName(const OPERATION_MODE operationMode) -{ - // Do we have an output file name specified? - // Use it. - if (CommandlineInterface::Get().HasParam("--ofile")) - return CommandlineInterface::Get()["--ofile"].GetString(); - - // Else: append a custom postfix to the inputs filename - else - return CommandlineInterface::Get()["--infile"].GetString() + - (operationMode == OPERATION_MODE::ENCRYPT ? ".crypt" : ".plain"); -} - -int main(int argc, char** argv) -{ - // Init cmdargs - CommandlineInterface::Init(argc, argv); - - // Get operation modes - OPERATION_MODE opMode; - if (CommandlineInterface::Get().HasParam("--encrypt")) - opMode = OPERATION_MODE::ENCRYPT; - else if (CommandlineInterface::Get().HasParam("--hash")) - opMode = OPERATION_MODE::HASH; - else if (CommandlineInterface::Get().HasParam("--decrypt")) - opMode = OPERATION_MODE::DECRYPT; - else - // Unreachable - throw std::runtime_error("This code should not have been reached. Most likely, the cli argument parser failed making sure at least one mode of operation (-e, -d, -h) was supplied."); - - const bool isFileMode = CommandlineInterface::Get().HasParam("--infile"); - const bool printDigestionProgress = CommandlineInterface::Get().HasParam("--progress"); - - - // Digest - Flexblock output; - - switch (opMode) { - case OPERATION_MODE::ENCRYPT: { - // Gather input and key - const Block encryptionKey = GetEncryptionKey(); - const Flexblock input = GetInputText(opMode); - - // Create cipher - Cipher cipher(encryptionKey); - - // Run it - output = cipher.Encipher(input, printDigestionProgress); - break; - } - - case OPERATION_MODE::DECRYPT: { - // Gather input and key - const Block encryptionKey = GetEncryptionKey(); - const Flexblock input = GetInputText(opMode); - - // Create cipher - Cipher cipher(encryptionKey); - - // Run it - output = cipher.Decipher(input, printDigestionProgress); - break; - } - - case OPERATION_MODE::HASH: { - // Gather input - Flexblock input = GetInputText(opMode); - - // Also add an extra left-padded block with the length of the input, - // to make sure, H(n) != H(n + 0x0) - input += PadStringToLength(Block(input.size()).to_string(), BLOCK_SIZE, '0'); - - // Derive an encryption key - // This is quiet sensitive, because it absolutely MUST be impossible - // to acquire K without already knowing M. - // This alone is making this cipher a one-way function. - // Just reducing the output is not a solution, because: If len(input) <= BLOCK_SIZE: H(m) = E(m)_k ^ k, with k being 0 <= k <= BLOCK_SIZE. That's not good. - // - // So here's what we're doing: - // - We're going to take the first BLOCK_SIZE bits of the input (it's length is at least that because of the size embedding) - // - We're creating a sudo-random initialization vector, seeded with this block. - // - That's our encryption key. - // This way, the encryption key can only be obtained by already knowing the first BLOCK_SIZE bits of the cleartext. - // By not taking in ALL the bits for deriving a key, we're saving a LOT on performance, as otherwise we would basically be encrypting the input THREE times. - // Why create an initialization vector at all? To make sure, even an input of only zeroes would provide a strong key - const Block encryptionKey = InitializationVector( - Block(input.substr(0, BLOCK_SIZE)) - ); - - // Create cipher - Cipher cipher(encryptionKey); - - // Run it - output = cipher.Encipher(input, printDigestionProgress); - - if (printDigestionProgress) { - std::cout << "Done encrypting... Applying reduction function on ciphertext..." << std::endl; - std::cout << "This will take about just as long..." << std::endl; - } - - // Reduce output to a single block - output = ReductionFunction_Flexblock2Block(output).to_string(); - - break; - } - } - - - // Now output the darn thing. - // Outputting to a file (only if not hashing) - if ((isFileMode) && (opMode != OPERATION_MODE::HASH)) - { - // File mode is a bit different. - - // Dump to stdout? - if (CommandlineInterface::Get().HasParam("--ostdout")) - { - const std::string outstr = BitsToBytes(output); - - // We have to print char-by-char to prevent a nullbyte terminating output. - for (std::size_t i = 0; i < outstr.size(); i++) - std::cout << outstr[i]; - } - // Else: Dump to file - else - { - const std::string outfileName = GetOutfileName(opMode); - WriteBitsToFile(outfileName, output); - } - } - // Else: we are just dealing with a string, or want to print a hashsum - else - { - switch (opMode) { - case OPERATION_MODE::ENCRYPT: - case OPERATION_MODE::HASH: { - - // We are encrypting or hashing: - // Output to stdout as a formatted bytestring - std::string formattedCiphertext; - - // Are we using iobase 2? - if (CommandlineInterface::Get().HasParam("--iobase-2")) - // Yes: convert hex to base 2 - formattedCiphertext = Bin2CustomBase(output, BASE_2); - - // Are we using iobase 8? - else if (CommandlineInterface::Get().HasParam("--iobase-8")) - // Yes: convert binary to base 8 - formattedCiphertext = Bin2CustomBase(output, BASE_8); - - // Are we using iobase 10? - else if (CommandlineInterface::Get().HasParam("--iobase-10")) - // Yes: convert binary to base 10 - formattedCiphertext = Bin2CustomBase(output, BASE_10); - - // Are we using iobase 64? - else if (CommandlineInterface::Get().HasParam("--iobase-64")) - // Yes: convert binary to base 64 - formattedCiphertext = Bin2CustomBase(output, BASE_64); - - // Are we using iobase uwu? - else if (CommandlineInterface::Get().HasParam("--iobase-uwu")) - // Yes: convert binary to base 64 - formattedCiphertext = Bin2CustomBase(output, BASE_UWU, " "); - - // Are we using iobase ugh? - else if (CommandlineInterface::Get().HasParam("--iobase-ugh")) - // Yes: convert binary to base 64 - formattedCiphertext = Bin2CustomBase(output, BASE_UGH, " "); - - // Else, no special output format specified, use hex - else - formattedCiphertext = BitsToHexstring(output); - - std::cout << formattedCiphertext << std::endl; - break; - } - - case OPERATION_MODE::DECRYPT: - // We are just decrypting: - // Just print it string-formatted - std::cout << BitsToString(output) << std::endl; - break; - } - } - - return 0; -} - +#include "CommandlineInterface.h" +#include "Configuration.h" + +int main(int argc, char* const* argv) { + + // Init cli args + CommandlineInterface::Init(argc, argv); + + // Parse configuration + Configuration::Parse(); + + return 0; +} +