diff options
Diffstat (limited to 'src/core/function')
| -rw-r--r-- | src/core/function/DataObjectOperator.cpp | 154 | ||||
| -rw-r--r-- | src/core/function/DataObjectOperator.h | 82 | ||||
| -rw-r--r-- | src/core/function/GlobalSettingStation.cpp | 141 | ||||
| -rw-r--r-- | src/core/function/GlobalSettingStation.h | 232 | ||||
| -rw-r--r-- | src/core/function/KeyPackageOperator.cpp | 10 | ||||
| -rw-r--r-- | src/core/function/KeyPackageOperator.h | 35 | ||||
| -rw-r--r-- | src/core/function/PassphraseGenerator.cpp | 29 | ||||
| -rw-r--r-- | src/core/function/PassphraseGenerator.h | 73 |
8 files changed, 722 insertions, 34 deletions
diff --git a/src/core/function/DataObjectOperator.cpp b/src/core/function/DataObjectOperator.cpp new file mode 100644 index 00000000..f1395152 --- /dev/null +++ b/src/core/function/DataObjectOperator.cpp @@ -0,0 +1,154 @@ +/** + * Copyright (C) 2021 Saturneric + * + * This file is part of GpgFrontend. + * + * GpgFrontend 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. + * + * GpgFrontend 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 GpgFrontend. If not, see <https://www.gnu.org/licenses/>. + * + * The initial version of the source code is inherited from + * the gpg4usb project, which is under GPL-3.0-or-later. + * + * All the source code of GpgFrontend was modified and released by + * Saturneric<[email protected]> starting on May 12, 2021. + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include "DataObjectOperator.h" + +#include <qt-aes/qaesencryption.h> + +#include "core/function/FileOperator.h" +#include "core/function/PassphraseGenerator.h" + +void GpgFrontend::DataObjectOperator::init_app_secure_key() { + FileOperator::WriteFileStd(app_secure_key_path_, + PassphraseGenerator::GetInstance().Generate(256)); + std::filesystem::permissions( + app_secure_key_path_, + std::filesystem::perms::owner_read | std::filesystem::perms::owner_write); +} + +GpgFrontend::DataObjectOperator::DataObjectOperator(int channel) + : SingletonFunctionObject<DataObjectOperator>(channel) { + if (!is_directory(app_secure_path_)) create_directory(app_secure_path_); + + if (!exists(app_secure_key_path_)) { + init_app_secure_key(); + } + + std::string key; + if (!FileOperator::ReadFileStd(app_secure_key_path_.string(), key)) { + LOG(ERROR) << _("Failed to read app secure key file") + << app_secure_key_path_; + } + hash_key_ = QCryptographicHash::hash(QByteArray::fromStdString(key), + QCryptographicHash::Sha256); + + if (!exists(app_data_objs_path_)) create_directory(app_data_objs_path_); +} + +std::string GpgFrontend::DataObjectOperator::SaveDataObj( + const std::string& _key, const nlohmann::json& value) { + std::string _hash_obj_key = {}; + if (_key.empty()) { + _hash_obj_key = + QCryptographicHash::hash( + hash_key_ + QByteArray::fromStdString( + PassphraseGenerator::GetInstance().Generate(32) + + to_iso_extended_string( + boost::posix_time::second_clock::local_time())), + QCryptographicHash::Sha256) + .toHex() + .toStdString(); + } else { + _hash_obj_key = + QCryptographicHash::hash(hash_key_ + QByteArray::fromStdString(_key), + QCryptographicHash::Sha256) + .toHex() + .toStdString(); + } + + const auto obj_path = app_data_objs_path_ / _hash_obj_key; + + QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB, + QAESEncryption::Padding::ISO); + auto encoded = + encryption.encode(QByteArray::fromStdString(to_string(value)), hash_key_); + + GpgFrontend::write_buffer_to_file(obj_path.string(), encoded.toStdString()); + + return _key.empty() ? _hash_obj_key : std::string(); +} + +std::optional<nlohmann::json> GpgFrontend::DataObjectOperator::GetDataObject( + const std::string& _key) { + try { + auto _hash_obj_key = + QCryptographicHash::hash(hash_key_ + QByteArray::fromStdString(_key), + QCryptographicHash::Sha256) + .toHex() + .toStdString(); + + const auto obj_path = app_data_objs_path_ / _hash_obj_key; + + if (!std::filesystem::exists(obj_path)) { + return {}; + } + + std::string buffer; + if (!FileOperator::ReadFileStd(obj_path.string(), buffer)) { + return {}; + } + + auto encoded = QByteArray::fromStdString(buffer); + + QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB, + QAESEncryption::Padding::ISO); + + auto decoded = + encryption.removePadding(encryption.decode(encoded, hash_key_)); + + return nlohmann::json::parse(decoded.toStdString()); + } catch (...) { + return {}; + } +} + +std::optional<nlohmann::json> +GpgFrontend::DataObjectOperator::GetDataObjectByRef(const std::string& _ref) { + if (_ref.size() != 64) return {}; + + try { + const auto& _hash_obj_key = _ref; + const auto obj_path = app_data_objs_path_ / _hash_obj_key; + + if (!std::filesystem::exists(obj_path)) return {}; + + std::string buffer; + if (!FileOperator::ReadFileStd(obj_path.string(), buffer)) return {}; + auto encoded = QByteArray::fromStdString(buffer); + + QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB, + QAESEncryption::Padding::ISO); + + auto decoded = + encryption.removePadding(encryption.decode(encoded, hash_key_)); + + return nlohmann::json::parse(decoded.toStdString()); + } catch (...) { + return {}; + } +} diff --git a/src/core/function/DataObjectOperator.h b/src/core/function/DataObjectOperator.h new file mode 100644 index 00000000..0ce4e313 --- /dev/null +++ b/src/core/function/DataObjectOperator.h @@ -0,0 +1,82 @@ +/** + * Copyright (C) 2021 Saturneric + * + * This file is part of GpgFrontend. + * + * GpgFrontend 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. + * + * GpgFrontend 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 GpgFrontend. If not, see <https://www.gnu.org/licenses/>. + * + * The initial version of the source code is inherited from + * the gpg4usb project, which is under GPL-3.0-or-later. + * + * All the source code of GpgFrontend was modified and released by + * Saturneric<[email protected]> starting on May 12, 2021. + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef GPGFRONTEND_DATAOBJECTOPERATOR_H +#define GPGFRONTEND_DATAOBJECTOPERATOR_H + +#include <json/single_include/nlohmann/json.hpp> + +#include "core/GpgFrontendCore.h" +#include "core/GpgFunctionObject.h" +#include "core/function/GlobalSettingStation.h" + +namespace GpgFrontend { + +class DataObjectOperator : public SingletonFunctionObject<DataObjectOperator> { + public: + /** + * @brief DataObjectOperator constructor + * + * @param channel channel + */ + explicit DataObjectOperator( + int channel = SingletonFunctionObject::GetDefaultChannel()); + + std::string SaveDataObj(const std::string &_key, const nlohmann::json &value); + + std::optional<nlohmann::json> GetDataObject(const std::string &_key); + + std::optional<nlohmann::json> GetDataObjectByRef(const std::string &_ref); + + private: + /** + * @brief init the secure key of application data object + * + */ + void init_app_secure_key(); + + GlobalSettingStation &global_setting_station_ = + GlobalSettingStation::GetInstance(); ///< GlobalSettingStation + std::filesystem::path app_secure_path_ = + global_setting_station_.GetAppConfigPath() / + "secure"; ///< Where sensitive information is stored + std::filesystem::path app_secure_key_path_ = + app_secure_path_ / "app.key"; ///< Where the key of data object is stored + std::filesystem::path app_data_objs_path_ = + global_setting_station_.GetAppDataPath() / "data_objs"; ///< Where data + ///< object is + ///< stored + + std::random_device rd_; ///< Random device + std::mt19937 mt_ = std::mt19937(rd_()); ///< Mersenne twister + QByteArray hash_key_; ///< Hash key +}; + +} // namespace GpgFrontend + +#endif // GPGFRONTEND_DATAOBJECTOPERATOR_H diff --git a/src/core/function/GlobalSettingStation.cpp b/src/core/function/GlobalSettingStation.cpp new file mode 100644 index 00000000..7b3e868e --- /dev/null +++ b/src/core/function/GlobalSettingStation.cpp @@ -0,0 +1,141 @@ +/** + * Copyright (C) 2021 Saturneric + * + * This file is part of GpgFrontend. + * + * GpgFrontend 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. + * + * GpgFrontend 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 GpgFrontend. If not, see <https://www.gnu.org/licenses/>. + * + * The initial version of the source code is inherited from + * the gpg4usb project, which is under GPL-3.0-or-later. + * + * All the source code of GpgFrontend was modified and released by + * Saturneric<[email protected]> starting on May 12, 2021. + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include "GlobalSettingStation.h" + +#include <openssl/bio.h> +#include <openssl/pem.h> + +#include <vmime/security/cert/openssl/X509Certificate_OpenSSL.hpp> +#include <vmime/vmime.hpp> + +#include "core/function/FileOperator.h" + +void GpgFrontend::GlobalSettingStation::SyncSettings() noexcept { + using namespace libconfig; + try { + ui_cfg_.writeFile(ui_config_path_.string().c_str()); + LOG(INFO) << _("Updated ui configuration successfully written to") + << ui_config_path_; + + } catch (const FileIOException &fioex) { + LOG(ERROR) << _("I/O error while writing ui configuration file") + << ui_config_path_; + } +} + +GpgFrontend::GlobalSettingStation::GlobalSettingStation(int channel) noexcept + : SingletonFunctionObject<GlobalSettingStation>(channel) { + using namespace std::filesystem; + using namespace libconfig; + + el::Loggers::addFlag(el::LoggingFlag::AutoSpacing); + + LOG(INFO) << _("App Path") << app_path_; + LOG(INFO) << _("App Configure Path") << app_configure_path_; + LOG(INFO) << _("App Data Path") << app_data_path_; + LOG(INFO) << _("App Log Path") << app_log_path_; + LOG(INFO) << _("App Locale Path") << app_locale_path_; + + if (!is_directory(app_configure_path_)) create_directory(app_configure_path_); + + if (!is_directory(app_data_path_)) create_directory(app_data_path_); + + if (!is_directory(app_log_path_)) create_directory(app_log_path_); + + if (!is_directory(ui_config_dir_path_)) create_directory(ui_config_dir_path_); + + if (!exists(ui_config_path_)) { + try { + this->ui_cfg_.writeFile(ui_config_path_.string().c_str()); + LOG(INFO) << _("UserInterface configuration successfully written to") + << ui_config_path_; + + } catch (const FileIOException &fioex) { + LOG(ERROR) + << _("I/O error while writing UserInterface configuration file") + << ui_config_path_; + } + } else { + try { + this->ui_cfg_.readFile(ui_config_path_.string().c_str()); + LOG(INFO) << _("UserInterface configuration successfully read from") + << ui_config_path_; + } catch (const FileIOException &fioex) { + LOG(ERROR) << _("I/O error while reading UserInterface configure file"); + } catch (const ParseException &pex) { + LOG(ERROR) << _("Parse error at ") << pex.getFile() << ":" + << pex.getLine() << " - " << pex.getError(); + } + } +} + +void GpgFrontend::GlobalSettingStation::AddRootCert( + const std::filesystem::path &path) { + std::string out_buffer; + if (!FileOperator::ReadFileStd(path.string(), out_buffer)) { + LOG(ERROR) << _("Failed to read root certificate file") << path; + return; + } + + auto mem_bio = std::shared_ptr<BIO>( + BIO_new_mem_buf(out_buffer.data(), static_cast<int>(out_buffer.size())), + [](BIO *_p) { BIO_free(_p); }); + + auto x509 = std::shared_ptr<X509>( + PEM_read_bio_X509(mem_bio.get(), nullptr, nullptr, nullptr), + [](X509 *_p) { X509_free(_p); }); + + if (!x509) return; + + root_certs_.push_back(x509); +} + +vmime::shared_ptr<vmime::security::cert::defaultCertificateVerifier> +GpgFrontend::GlobalSettingStation::GetCertVerifier() const { + auto p_cv = + vmime::make_shared<vmime::security::cert::defaultCertificateVerifier>(); + + std::vector<vmime::shared_ptr<vmime::security::cert::X509Certificate>> + _root_certs; + for (const auto &cert : root_certs_) { + _root_certs.push_back( + std::make_shared<vmime::security::cert::X509Certificate_OpenSSL>( + cert.get())); + } + return p_cv; +} + +const std::vector<std::shared_ptr<X509>> + &GpgFrontend::GlobalSettingStation::GetRootCerts() { + return root_certs_; +} + +void GpgFrontend::GlobalSettingStation::init_app_secure_key() {} + +GpgFrontend::GlobalSettingStation::~GlobalSettingStation() noexcept = default; diff --git a/src/core/function/GlobalSettingStation.h b/src/core/function/GlobalSettingStation.h new file mode 100644 index 00000000..d6521c8a --- /dev/null +++ b/src/core/function/GlobalSettingStation.h @@ -0,0 +1,232 @@ +/** + * Copyright (C) 2021 Saturneric + * + * This file is part of GpgFrontend. + * + * GpgFrontend 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. + * + * GpgFrontend 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 GpgFrontend. If not, see <https://www.gnu.org/licenses/>. + * + * The initial version of the source code is inherited from + * the gpg4usb project, which is under GPL-3.0-or-later. + * + * All the source code of GpgFrontend was modified and released by + * Saturneric<[email protected]> starting on May 12, 2021. + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef GPGFRONTEND_GLOBALSETTINGSTATION_H +#define GPGFRONTEND_GLOBALSETTINGSTATION_H + +#include <openssl/x509.h> + +#include <boost/filesystem/operations.hpp> +#include <boost/filesystem/path.hpp> + +#include "GpgFrontendBuildInstallInfo.h" +#include "core/GpgFrontendCore.h" +#include "core/GpgFunctionObject.h" + +namespace vmime::security::cert { +class defaultCertificateVerifier; +class X509Certificate; +} // namespace vmime::security::cert + +namespace GpgFrontend { + +/** + * @brief + * + */ +class GlobalSettingStation + : public SingletonFunctionObject<GlobalSettingStation> { + public: + /** + * @brief Construct a new Global Setting Station object + * + */ + explicit GlobalSettingStation( + int channel = SingletonFunctionObject::GetDefaultChannel()) noexcept; + + /** + * @brief Destroy the Global Setting Station object + * + */ + ~GlobalSettingStation() noexcept override; + + /** + * @brief + * + * @return libconfig::Setting& + */ + libconfig::Setting &GetUISettings() noexcept { return ui_cfg_.getRoot(); } + + /** + * @brief Get the App Dir object + * + * @return std::filesystem::path + */ + [[nodiscard]] std::filesystem::path GetAppDir() const { return app_path_; } + + [[nodiscard]] std::filesystem::path GetAppDataPath() const { + return app_data_path_; + } + + /** + * @brief Get the Log Dir object + * + * @return std::filesystem::path + */ + [[nodiscard]] std::filesystem::path GetLogDir() const { + return app_log_path_; + } + + /** + * @brief Get the Standalone Database Dir object + * + * @return std::filesystem::path + */ + [[nodiscard]] std::filesystem::path GetStandaloneDatabaseDir() const { + auto db_path = app_configure_path_ / "db"; + if (!std::filesystem::exists(db_path)) { + std::filesystem::create_directory(db_path); + } + return db_path; + } + + [[nodiscard]] std::filesystem::path GetAppConfigPath() const { + return app_configure_path_; + } + + /** + * @brief Get the Standalone Gpg Bin Dir object + * + * @return std::filesystem::path + */ + [[nodiscard]] std::filesystem::path GetStandaloneGpgBinDir() const { + return app_resource_path_ / "gpg1.4" / "gpg"; + } + + /** + * @brief Get the Locale Dir object + * + * @return std::filesystem::path + */ + [[nodiscard]] std::filesystem::path GetLocaleDir() const { + return app_locale_path_; + } + + /** + * @brief Get the Resource Dir object + * + * @return std::filesystem::path + */ + [[nodiscard]] std::filesystem::path GetResourceDir() const { + return app_resource_path_; + } + + /** + * @brief Get the Certs Dir object + * + * @return std::filesystem::path + */ + [[nodiscard]] std::filesystem::path GetCertsDir() const { + return app_resource_path_ / "certs"; + } + + /** + * @brief Get the Cert Verifier object + * + * @return std::shared_ptr< + * vmime::security::cert::defaultCertificateVerifier> + */ + [[nodiscard]] std::shared_ptr< + vmime::security::cert::defaultCertificateVerifier> + GetCertVerifier() const; + + /** + * @brief + * + * @param path + */ + void AddRootCert(const std::filesystem::path &path); + + /** + * @brief Get the Root Certs object + * + * @return const std::vector<std::shared_ptr<X509>>& + */ + const std::vector<std::shared_ptr<X509>> &GetRootCerts(); + + /** + * @brief + * + */ + void ResetRootCerts() { root_certs_.clear(); } + + /** + * @brief sync the settings to the file + * + */ + void SyncSettings() noexcept; + + private: + std::filesystem::path app_path_ = + qApp->applicationDirPath().toStdString(); ///< Program Location + std::filesystem::path app_data_path_ = + QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + .toStdString(); ///< Program Data Location + std::filesystem::path app_log_path_ = + app_data_path_ / "logs"; ///< Program Data Location + std::filesystem::path app_data_objs_path_ = + app_data_path_ / "objs"; ///< Object storage path + +#ifdef LINUX_INSTALL_BUILD + std::filesystem::path app_resource_path_ = + std::filesystem::path(APP_LOCALSTATE_PATH) / + "gpgfrontend"; ///< Program Data Location +#else + std::filesystem::path app_resource_path_ = + RESOURCE_DIR_BOOST_PATH(app_path_); ///< Program Data Location +#endif + +#ifdef LINUX_INSTALL_BUILD + std::filesystem::path app_locale_path_ = + std::string(APP_LOCALE_PATH); ///< Program Data Location +#else + std::filesystem::path app_locale_path_ = + app_resource_path_ / "locales"; ///< Program Data Location +#endif + + std::filesystem::path app_configure_path_ = + QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation) + .toStdString(); ///< Program Configure Location + std::filesystem::path ui_config_dir_path_ = + app_configure_path_ / + "UserInterface"; ///< Configure File Directory Location + std::filesystem::path ui_config_path_ = + ui_config_dir_path_ / "ui.cfg"; ///< UI Configure File Location + + libconfig::Config ui_cfg_; ///< + std::vector<std::shared_ptr<X509>> root_certs_; ///< + + /** + * @brief + * + */ + void init_app_secure_key(); +}; +} // namespace GpgFrontend + +#endif // GPGFRONTEND_GLOBALSETTINGSTATION_H diff --git a/src/core/function/KeyPackageOperator.cpp b/src/core/function/KeyPackageOperator.cpp index 89210987..7ff65b50 100644 --- a/src/core/function/KeyPackageOperator.cpp +++ b/src/core/function/KeyPackageOperator.cpp @@ -28,17 +28,17 @@ #include "KeyPackageOperator.h" -#include "qt-aes/qaesencryption.h" - #include "FileOperator.h" +#include "function/PassphraseGenerator.h" #include "function/gpg/GpgKeyGetter.h" #include "function/gpg/GpgKeyImportExporter.h" +#include "qt-aes/qaesencryption.h" namespace GpgFrontend { bool KeyPackageOperator::GeneratePassphrase( const std::filesystem::path& phrase_path, std::string& phrase) { - phrase = generate_passphrase(256); + phrase = PassphraseGenerator::GetInstance().Generate(256); return FileOperator::WriteFileStd(phrase_path, phrase); } @@ -65,8 +65,8 @@ bool KeyPackageOperator::GenerateKeyPackage( bool KeyPackageOperator::ImportKeyPackage( const std::filesystem::path& key_package_path, - const std::filesystem::path& phrase_path, GpgFrontend::GpgImportInformation &import_info) { - + const std::filesystem::path& phrase_path, + GpgFrontend::GpgImportInformation& import_info) { std::string encrypted_data; FileOperator::ReadFileStd(key_package_path, encrypted_data); diff --git a/src/core/function/KeyPackageOperator.h b/src/core/function/KeyPackageOperator.h index ee81e86e..cd344688 100644 --- a/src/core/function/KeyPackageOperator.h +++ b/src/core/function/KeyPackageOperator.h @@ -39,7 +39,7 @@ namespace GpgFrontend { * */ class KeyPackageOperator { -public: + public: /** * @brief generate passphrase for key package and save it to file * @@ -87,44 +87,21 @@ public: const std::filesystem::path &phrase_path, GpgFrontend::GpgImportInformation &import_info); -private: - /** - * @brief genearte passphrase - * - * @param len length of the passphrase - * @return std::string passphrase - */ - static std::string generate_passphrase(const int len) { - std::random_device rd_; ///< Random device - auto mt_ = std::mt19937(rd_()); ///< Mersenne twister - - std::uniform_int_distribution<int> dist(999, 99999); - static const char alphanum[] = "0123456789" - "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - "abcdefghijklmnopqrstuvwxyz"; - std::string tmp_str; - tmp_str.reserve(len); - - for (int i = 0; i < len; ++i) { - tmp_str += alphanum[dist(mt_) % (sizeof(alphanum) - 1)]; - } - return tmp_str; - } - + private: /** * @brief generate key package name * * @return std::string key package name */ static std::string generate_key_package_name() { - std::random_device rd_; ///< Random device - auto mt_ = std::mt19937(rd_()); ///< Mersenne twister + std::random_device rd_; ///< Random device + auto mt_ = std::mt19937(rd_()); ///< Mersenne twister std::uniform_int_distribution<int> dist(999, 99999); auto file_string = boost::format("KeyPackage_%1%") % dist(mt_); return file_string.str(); } }; -} // namespace GpgFrontend +} // namespace GpgFrontend -#endif // GPGFRONTEND_KEYPACKAGEOPERATOR_H +#endif // GPGFRONTEND_KEYPACKAGEOPERATOR_H diff --git a/src/core/function/PassphraseGenerator.cpp b/src/core/function/PassphraseGenerator.cpp new file mode 100644 index 00000000..0267edda --- /dev/null +++ b/src/core/function/PassphraseGenerator.cpp @@ -0,0 +1,29 @@ +/** +* Copyright (C) 2021 Saturneric +* +* This file is part of GpgFrontend. +* +* GpgFrontend 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. +* +* GpgFrontend 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 GpgFrontend. If not, see <https://www.gnu.org/licenses/>. +* +* The initial version of the source code is inherited from +* the gpg4usb project, which is under GPL-3.0-or-later. +* +* All the source code of GpgFrontend was modified and released by +* Saturneric<[email protected]> starting on May 12, 2021. +* +* SPDX-License-Identifier: GPL-3.0-or-later +* + */ + +#include "PassphraseGenerator.h" diff --git a/src/core/function/PassphraseGenerator.h b/src/core/function/PassphraseGenerator.h new file mode 100644 index 00000000..5e55b2dd --- /dev/null +++ b/src/core/function/PassphraseGenerator.h @@ -0,0 +1,73 @@ +/** + * Copyright (C) 2021 Saturneric + * + * This file is part of GpgFrontend. + * + * GpgFrontend 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. + * + * GpgFrontend 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 GpgFrontend. If not, see <https://www.gnu.org/licenses/>. + * + * The initial version of the source code is inherited from + * the gpg4usb project, which is under GPL-3.0-or-later. + * + * All the source code of GpgFrontend was modified and released by + * Saturneric<[email protected]> starting on May 12, 2021. + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef GPGFRONTEND_PASSPHRASEGENERATOR_H +#define GPGFRONTEND_PASSPHRASEGENERATOR_H + +#include "core/GpgFrontendCore.h" +#include "core/GpgFunctionObject.h" + +namespace GpgFrontend { + +/** + * @brief The PassphraseGenerator class + * + * This class is used to generate a passphrase. + */ +class PassphraseGenerator + : public SingletonFunctionObject<PassphraseGenerator> { + public: + + /** + * @brief PassphraseGenerator constructor + * + * @param channel The channel to use + */ + explicit PassphraseGenerator( + int channel = SingletonFunctionObject::GetDefaultChannel()) + : SingletonFunctionObject<PassphraseGenerator>(channel) {} + + /** + * @brief generate passphrase + * + * @param len length of the passphrase + * @return std::string passphrase + */ + std::string Generate(int len) { + std::uniform_int_distribution<int> dist(999, 99999); + auto file_string = boost::format("KeyPackage_%1%") % dist(mt_); + return file_string.str(); + } + + std::random_device rd_; ///< Random device + std::mt19937 mt_ = std::mt19937(rd_()); ///< Mersenne twister +}; + +} // namespace GpgFrontend + +#endif // GPGFRONTEND_PASSPHRASEGENERATOR_H |