Migrate the project from modules to headers

C++20 Module support varies by compilers, and is quite unstable across multiple compilers as of now (Feb. 2025)

Author: dr8co

CMakeLists.txt

@@ -1,5 +1,5 @@
 # Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
-# Copyright (C) 2024  Ian Duncan <dr8co@duck.com>
+# Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -14,7 +14,6 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see https://www.gnu.org/licenses.
 
-# CMake 3.28+ is required for C++20 modules
 cmake_minimum_required(VERSION 3.28)
 
 project(privacyShield
@@ -50,44 +49,33 @@ cmake_dependent_option(ENABLE_SANITIZERS
 # Valgrind support
 option(VALGRIND_BUILD "Build with Valgrind support" OFF)
 
+# Add the executable target
+add_executable(privacyShield)
+
 # Additional checks for the Debug build
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-    add_compile_options(
+    target_compile_options(privacyShield PRIVATE
             -Wall
             -Wextra
             -Werror
             -Wpedantic
     )
 endif ()
 
-# Add the executable target
-add_executable(privacyShield)
-
-# Add sources for the target
+# project source files
 target_sources(privacyShield PRIVATE
+        src/duplicateFinder/duplicateFinder.cpp
         src/encryption/encryptDecrypt.cpp
         src/encryption/encryptFiles.cpp
         src/encryption/encryptStrings.cpp
+        src/fileShredder/fileShredder.cpp
         src/passwordManager/passwordManager.cpp
         src/passwordManager/passwords.cpp
+        src/privacyTracks/privacyTracks.cpp
+        src/utils/utils.cpp
         src/main.cpp
 )
 
-# C++20 Modules
-target_sources(privacyShield PRIVATE
-        FILE_SET CXX_MODULES FILES
-        src/duplicateFinder/duplicateFinder.cppm
-        src/encryption/cryptoCipher.cppm
-        src/encryption/encryption.cppm
-        src/fileShredder/fileShredder.cppm
-        src/passwordManager/FuzzyMatcher.cppm
-        src/passwordManager/passwordManager.cppm
-        src/privacyTracks/privacyTracks.cppm
-        src/utils/utils.cppm
-        src/secureAllocator.cppm
-        src/mimallocSTL.cppm
-)
-
 # Sanitizers for debugging and testing
 # Requires llvm-symbolizer and sanitizer libraries (asan, ubsan, msan, tsan)
 if (ENABLE_SANITIZERS)
@@ -111,6 +99,7 @@ if (ENABLE_SANITIZERS)
 
     # Track mimalloc allocations for AddressSanitizer
     set(MI_TRACK_ASAN ON)
+    set(MI_DEBUG_UBSAN ON)
 
     # Link the enabled sanitizers.
     target_link_libraries(privacyShield PRIVATE asan ubsan)
@@ -161,6 +150,7 @@ if (NOT TARGET mimalloc-static OR NOT TARGET mimalloc)
     )
 endif ()
 
+set(MI_SECURE ON)
 set(MI_BUILD_TESTS OFF) # Do not build tests
 
 FetchContent_MakeAvailable(mimalloc)

CMakeModules/FindGcrypt.cmake

@@ -1,5 +1,5 @@
 # Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
-# Copyright (C) 2024  Ian Duncan <dr8co@duck.com>
+# Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

CMakeModules/FindReadline.cmake

@@ -1,5 +1,5 @@
 # Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
-# Copyright (C) 2024  Ian Duncan <dr8co@duck.com>
+# Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

CMakeModules/Packing.cmake

@@ -1,5 +1,5 @@
 # Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
-# Copyright (C) 2024  Ian Duncan <dr8co@duck.com>
+# Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

src/duplicateFinder/duplicateFinder.cppm src/duplicateFinder/duplicateFinder.cppsrc/duplicateFinder/duplicateFinder.cppm renamed to src/duplicateFinder/duplicateFinder.cpp

@@ -1,5 +1,5 @@
 // Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
-// Copyright (C) 2024  Ian Duncan <dr8co@duck.com>
+// Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -14,23 +14,16 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see https://www.gnu.org/licenses.
 
-module;
-
-#include <print>
 #include <fstream>
 #include <system_error>
 #include <thread>
-#include <vector>
-#include <unordered_map>
-#include <filesystem>
 #include <blake3.h>
 #include <cstring>
-#include <format>
 #include <ranges>
 
-export module duplicateFinder;
-import utils;
-import mimallocSTL;
+#include "duplicateFinder.hpp"
+#include "../utils/utils.hpp"
+#include "../mimallocSTL.hpp"
 
 namespace fs = std::filesystem;
 
@@ -222,7 +215,7 @@ std::size_t findDuplicates(const fs::path &directoryPath) {
 }
 
 /// \brief A simple duplicate file detective.
-export void duplicateFinder() {
+void duplicateFinder() {
     while (true) {
         std::print("\n-------------------");
         printColoredOutput('m', " Duplicate Finder ");

src/duplicateFinder/duplicateFinder.hpp

@@ -0,0 +1,19 @@
+// Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
+// Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see https://www.gnu.org/licenses.
+
+#pragma once
+
+void duplicateFinder();

src/encryption/cryptoCipher.cppm src/encryption/cryptoCipher.hppsrc/encryption/cryptoCipher.cppm renamed to src/encryption/cryptoCipher.hpp

@@ -1,5 +1,5 @@
 // Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
-// Copyright (C) 2024  Ian Duncan <dr8co@duck.com>
+// Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -13,14 +13,12 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see https://www.gnu.org/licenses.
-module;
+#pragma once
 
 #include <openssl/evp.h>
 
-export module cryptoCipher;
-
 /// \brief A class wrapper for OpenSSL cipher implementations and contexts.
-export class CryptoCipher final {
+class CryptoCipher final {
 public:
     // Default constructor
     constexpr CryptoCipher() noexcept = default;

src/encryption/encryptDecrypt.cpp

@@ -1,5 +1,5 @@
 // Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
-// Copyright (C) 2024  Ian Duncan <dr8co@duck.com>
+// Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -14,28 +14,22 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see https://www.gnu.org/licenses.
 
-module;
 
 #include <algorithm>
 #include <system_error>
 #include <utility>
-#include <format>
 #include <cmath>
-#include <unordered_map>
-#include <filesystem>
 #include <gcrypt.h>
 #include <sodium.h>
-#include <print>
 
-import utils;
-import secureAllocator;
-import mimallocSTL;
-import passwordManager;
-
-module encryption;
+#include "encryption.hpp"
+#include "../passwordManager/passwordManager.hpp"
+#include "../utils/utils.hpp"
 
 namespace fs = std::filesystem;
 
+// clang-format off
+
 /// \brief Available encryption/decryption ciphers.
 enum class Algorithms : std::uint_fast8_t {
     AES      = 1 << 0,
@@ -60,17 +54,18 @@ constexpr struct {
     const gcry_cipher_algos Twofish = GCRY_CIPHER_TWOFISH;
 } AlgoSelection;
 
+// clang-format on
+
 
 /// \brief Formats a file size into a human-readable string.
 /// \param size The file size as an unsigned integer.
 /// \return A string representing the formatted file size.
-miSTL::string formatFileSize(const std::uintmax_t &size) {
+miSTL::string formatFileSize(const std::uintmax_t& size) {
     int i{};
     auto mantissa = static_cast<double>(size);
-    for (; mantissa >= 1024.; mantissa /= 1024., ++i) {
-    }
+    for (; mantissa >= 1024.; mantissa /= 1024., ++i) {}
     mantissa = std::ceil(mantissa * 10.) / 10.;
-    miSTL::string result { std::to_string(mantissa) + "BKMGTPE"[i]};
+    miSTL::string result{std::to_string(mantissa) + "BKMGTPE"[i]};
     return i == 0 ? result : result + "B (" + std::to_string(size).c_str() + ')';
 }
 
@@ -80,7 +75,7 @@ miSTL::string formatFileSize(const std::uintmax_t &size) {
 /// \throws std::invalid_argument if \p mode is invalid.
 /// \throws std::runtime_error if the input file does not exist, is a directory,
 /// is not a regular file, or is not readable.
-void checkInputFile(const fs::path &inFile, const OperationMode &mode) {
+void checkInputFile(const fs::path& inFile, const OperationMode& mode) {
     if (mode != OperationMode::Encryption && mode != OperationMode::Decryption)
         throw std::invalid_argument("Invalid mode of operation.");
 
@@ -109,7 +104,7 @@ void checkInputFile(const fs::path &inFile, const OperationMode &mode) {
 /// \brief Creates non-existing parent directories for a file.
 /// \param filePath The file path for which the directory path needs to be created.
 /// \return True if the directory path is created successfully or already exists, false otherwise.
-bool createPath(const fs::path &filePath) noexcept {
+bool createPath(const fs::path& filePath) noexcept {
     if (filePath.string().empty()) return false; // Can't create empty paths
 
     std::error_code ec;
@@ -136,7 +131,7 @@ bool createPath(const fs::path &filePath) noexcept {
 /// \param mode the mode of operation: encryption or decryption.
 /// \throws std::invalid_argument if \p mode is invalid.
 /// \throws std::runtime_error if the output file is not writable, readable, or there is not enough space to save it.
-inline void checkOutputFile(const fs::path &inFile, fs::path &outFile, const OperationMode &mode) {
+inline void checkOutputFile(const fs::path& inFile, fs::path& outFile, const OperationMode& mode) {
     if (mode != OperationMode::Encryption && mode != OperationMode::Decryption)
         throw std::invalid_argument("Invalid mode of operation.");
 
@@ -212,8 +207,8 @@ inline void copyLastWrite(const std::string_view srcFile, const std::string_view
 /// \param password the password to use for encryption/decryption.
 /// \param algo the algorithm to use for encryption/decryption.
 /// \param mode the mode of operation: encryption or decryption.
-void fileEncryptionDecryption(const miSTL::string &inputFileName, const miSTL::string &outputFileName,
-                              const privacy::string &password, const Algorithms &algo, const OperationMode &mode) {
+void fileEncryptionDecryption(const miSTL::string& inputFileName, const miSTL::string& outputFileName,
+                              const privacy::string& password, const Algorithms& algo, const OperationMode& mode) {
     // The mode must be valid: must be either encryption or decryption
     if (mode != OperationMode::Encryption && mode != OperationMode::Decryption) [[unlikely]] {
         printColoredErrorln('r', "Invalid mode of operation.");
@@ -222,15 +217,15 @@ void fileEncryptionDecryption(const miSTL::string &inputFileName, const miSTL::s
 
     try {
         /// Encrypts/decrypts a file based on the passed mode and algorithm.
-        auto encryptDecrypt = [&](const miSTL::string &algorithm) -> void {
+        auto encryptDecrypt = [&](const miSTL::string& algorithm) -> void {
             if (mode == OperationMode::Encryption) // Encryption
                 encryptFile(inputFileName, outputFileName, password, algorithm);
             else // Decryption
                 decryptFile(inputFileName, outputFileName, password, algorithm);
         };
 
         /// Encrypts/decrypts a file using a cipher with more rounds.
-        auto encryptDecryptMoreRounds = [&](const gcry_cipher_algos &algorithm) -> void {
+        auto encryptDecryptMoreRounds = [&](const gcry_cipher_algos& algorithm) -> void {
             if (mode == OperationMode::Encryption) // Encryption
                 encryptFileWithMoreRounds(inputFileName, outputFileName, password, algorithm);
             else // Decryption
@@ -264,11 +259,11 @@ void fileEncryptionDecryption(const miSTL::string &inputFileName, const miSTL::s
         // Preserve file permissions
         if (!copyFilePermissions(inputFileName, outputFileName))
             [[unlikely]]
-                    printColoredOutputln('m', "Check the permissions of the {}crypted file.", pre);
+                printColoredOutputln('m', "Check the permissions of the {}crypted file.", pre);
 
         // Try to preserve the time of last modification
         copyLastWrite(inputFileName, outputFileName);
-    } catch (const std::exception &ex) {
+    } catch (const std::exception& ex) {
         printColoredErrorln('r', "Error: {}", ex.what());
     }
 }
@@ -371,10 +366,11 @@ void encryptDecrypt() {
                 printColoredOutput('c', "{}", algoDescription.find(cipher)->second);
                 printColoredOutputln('g', "...");
 
-                fileEncryptionDecryption(canonical(inputPath).string().c_str(), weakly_canonical(outputPath).string().c_str(),
+                fileEncryptionDecryption(canonical(inputPath).string().c_str(),
+                                         weakly_canonical(outputPath).string().c_str(),
                                          password, cipher, static_cast<OperationMode>(choice));
                 std::println("");
-            } catch (const std::exception &ex) {
+            } catch (const std::exception& ex) {
                 printColoredError('y', "Error: ");
                 printColoredErrorln('r', "{}", ex.what());
             }

src/encryption/encryptFiles.cpp

@@ -1,5 +1,5 @@
 // Privacy Shield: A Suite of Tools Designed to Facilitate Privacy Management.
-// Copyright (C) 2024  Ian Duncan <dr8co@duck.com>
+// Copyright (C) 2025 Ian Duncan <dr8co@duck.com>
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -14,30 +14,27 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see https://www.gnu.org/licenses.
 
-module;
-
 #include <iostream>
 #include <fstream>
 #include <memory>
 #include <openssl/kdf.h>
 #include <openssl/core_names.h>
 #include <openssl/rand.h>
 #include <sodium.h>
-#include <format>
 #include <mutex>
-#include <vector>
+#include "encryption.hpp"
+#include "cryptoCipher.hpp"
 #include <gcrypt.h>
 
-import cryptoCipher;
-import secureAllocator;
-import mimallocSTL;
-
-module encryption;
 
 constexpr int MAX_KEY_SIZE = EVP_MAX_KEY_LENGTH;    ///< Maximum length of a key
 constexpr std::streamsize CHUNK_SIZE = 4096;        ///< Read/Write files in chunks of 4 kB
 constexpr unsigned int PBKDF2_ITERATIONS = 100'000; ///< Iterations for PBKDF2 key derivation
 
+// OpenSSL's library context and property query string
+static OSSL_LIB_CTX* libContext = nullptr;
+constexpr static char* propertyQuery = nullptr;
+
 
 /// \brief Generates random bytes using a CSPRNG.
 /// \param saltSize number of bytes of salt to generate.