Added encryption module, and data output layer

GCryptCLI/src/DataOutputLayer.cpp

@@ -0,0 +1,135 @@
+#include "DataOutputLayer.h"
+#include "DataFormatter.h"
+#include "CommandlineInterface.h"
+#include <ostream>
+#include <fstream>
+#include <iostream>
+
+using namespace IO;
+
+void DataOutputLayer::Init() {
+
+  // Set our ostream
+  switch (Configuration::outputTo) {
+
+    // Are we writing to stdout?
+    case Configuration::OUTPUT_TO::STDOUT:
+
+      // Redirect our ostream to stdout
+      out = &std::cout;
+      break;
+
+    // Are we writing to a file?
+    case Configuration::OUTPUT_TO::FILE:
+
+      // Open the file
+      ofs.open(
+        Configuration::inputFilename,
+        std::ios::out | std::ios::binary
+      );
+
+      // A little bit of error handling
+      if (!ofs.good()) {
+        throw std::runtime_error("Unable to open outfilestream!");
+      }
+
+      // Redirect our ostream to this outfilestream
+      out = &ofs;
+      break;
+  }
+
+  // Determine which iobase format to write in
+  // If we are decrypting, input is not formatted
+  if (Configuration::activeModule == Configuration::MODULE::DECRYPTION) {
+    outFormat = Configuration::IOBASE_FORMAT::BASE_BYTES;
+  }
+  // If we are doing anything else, output is the requested format
+  else {
+    outFormat = Configuration::iobaseFormat;
+  }
+
+  initialized = true;
+  reachedEof = false;
+
+  return;
+
+}
+
+void DataOutputLayer::Destruct() {
+  if (Configuration::outputTo == Configuration::OUTPUT_TO::FILE) {
+    ofs.close();
+  }
+
+  return;
+}
+
+void DataOutputLayer::Enqueue(const Block& block) {
+  blocks.emplace(block);
+  return;
+}
+
+void DataOutputLayer::WriteBlock() {
+  // Some error checking
+  if (!initialized) {
+    throw std::runtime_error("Attempted to write on uninitialized DataOutputLayer!");
+  }
+
+  // Check if we have any block to write
+  // and if we should (output-puffering)
+  // Basically: only output if we have anything to output, and
+  //   if --puffer-output is given, only output once we have reachedEof.
+  if (
+      (blocks.size() > 0) &&
+      (
+        (!CommandlineInterface::Get().HasParam("--puffer-output")) ||
+        (reachedEof)
+      )
+  ) {
+
+    // Fetch the block to write
+    const Block block = blocks.front();
+    blocks.pop();
+
+    // Recode it to our output format
+    const std::string formattedBlock =
+      DataFormatter::FormatBlock(
+        block,
+        outFormat
+      );
+
+    // Dump it
+    *out << formattedBlock;
+
+    // If this is not the last block, and the used iobase set
+    // requires it, append a seperator
+    if (
+        (!IsFinished()) &&
+        (
+         (outFormat == Configuration::IOBASE_FORMAT::BASE_UWU) ||
+         (outFormat == Configuration::IOBASE_FORMAT::BASE_UGH)
+        )
+    ) {
+      *out << " ";
+    }
+
+  }
+
+  return;
+}
+
+void DataOutputLayer::ReachedEOF() {
+  reachedEof = true;
+  return;
+}
+
+bool DataOutputLayer::IsFinished() {
+  return (reachedEof) && (blocks.size() == 0);
+}
+
+std::ostream* DataOutputLayer::out;
+std::ofstream DataOutputLayer::ofs;
+bool DataOutputLayer::reachedEof = false;
+bool DataOutputLayer::initialized = false;
+Configuration::IOBASE_FORMAT DataOutputLayer::outFormat;
+std::queue<Block> DataOutputLayer::blocks;
+

GCryptCLI/src/ModuleEncryption.cpp

@@ -0,0 +1,57 @@
+#include "ModuleEncryption.h"
+#include "DataIngestionLayer.h"
+#include "DataOutputLayer.h"
+#include "KeyManager.h"
+#include <iostream>
+#include <GCrypt/GCipher.h>
+
+using namespace Module;
+using namespace Leonetienne::GCrypt;
+
+void Encryption::Run() {
+
+  // Initialize the data ingestion layer
+  IO::DataIngestionLayer::Init();
+
+  // Initialize the data output layer
+  IO::DataOutputLayer::Init();
+
+  // Initialize a cipher
+  GCipher cipher(
+    KeyManager::GetKey(),
+    GCipher::DIRECTION::ENCIPHER
+  );
+
+  while (!IO::DataOutputLayer::IsFinished()) {
+    // Read in new blocks, if not reached eof
+    if (!IO::DataIngestionLayer::ReachedEOF()) {
+      IO::DataIngestionLayer::ReadBlock();
+    }
+
+    // Process a block, if one is ready
+    if (IO::DataIngestionLayer::IsBlockReady()) {
+      const Block cleartext = IO::DataIngestionLayer::GetNextBlock();
+      const Block ciphertext = cipher.Digest(cleartext);
+
+      // Enqueue the block for output
+      IO::DataOutputLayer::Enqueue(ciphertext);
+
+      // Tell the data output layer that it just received the
+      // last block, if it did
+      if (IO::DataIngestionLayer::IsFinished()) {
+        IO::DataOutputLayer::ReachedEOF();
+      }
+    }
+
+    // Attempt to write a block
+    IO::DataOutputLayer::WriteBlock();
+  }
+
+  // Destruct the data ingestion layer
+  IO::DataIngestionLayer::Destruct();
+
+  // Destruct the data output layer
+  IO::DataOutputLayer::Destruct();
+
+  return;
+}

GCryptCLI/src/main.cpp

@@ -2,8 +2,7 @@
 #include "Configuration.h"
 #include "KeyManager.h"
 #include "ModuleGenerateKey.h"
-
-#include "DataIngestionLayer.h"
+#include "ModuleEncryption.h"
 
 int main(int argc, char* const* argv) {
 
@@ -16,12 +15,12 @@ int main(int argc, char* const* argv) {
   // Prepare the key
   KeyManager::PrepareKey();
 
-  IO::DataIngestionLayer::Init();
-
   // Launch our module
   switch (Configuration::activeModule) {
     case Configuration::MODULE::GENERATE_KEY:
       Module::GenerateKey::Run();
+    case Configuration::MODULE::ENCRYPTION:
+      Module::Encryption::Run();
   }
 
   return 0;