aboutsummaryrefslogtreecommitdiffstats
path: root/src/core/GpgGenKeyInfo.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/GpgGenKeyInfo.cpp')
-rw-r--r--src/core/GpgGenKeyInfo.cpp225
1 files changed, 225 insertions, 0 deletions
diff --git a/src/core/GpgGenKeyInfo.cpp b/src/core/GpgGenKeyInfo.cpp
new file mode 100644
index 00000000..6ca83c96
--- /dev/null
+++ b/src/core/GpgGenKeyInfo.cpp
@@ -0,0 +1,225 @@
+/**
+ * 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 "core/GpgGenKeyInfo.h"
+
+#include <boost/date_time/gregorian/greg_date.hpp>
+#include <boost/date_time/gregorian/greg_duration.hpp>
+#include <boost/date_time/gregorian/gregorian_types.hpp>
+#include <string>
+#include <vector>
+
+void GpgFrontend::GenKeyInfo::SetAlgo(const std::string &m_algo) {
+ LOG(INFO) << "set algo" << m_algo;
+ // Check algo if supported
+ std::string algo_args = std::string(m_algo);
+ boost::algorithm::to_upper(algo_args);
+ if (standalone_) {
+ if (!subkey_) {
+ auto support_algo = GetSupportedKeyAlgoStandalone();
+ auto it = std::find(support_algo.begin(), support_algo.end(), algo_args);
+ // Algo Not Supported
+ if (it == support_algo.end()) return;
+ } else {
+ auto support_algo = GetSupportedSubkeyAlgoStandalone();
+ auto it = std::find(support_algo.begin(), support_algo.end(), algo_args);
+ // Algo Not Supported
+ if (it == support_algo.end()) return;
+ }
+ } else {
+ if (!subkey_) {
+ auto support_algo = GetSupportedKeyAlgo();
+ auto it = std::find(support_algo.begin(), support_algo.end(), algo_args);
+ // Algo Not Supported
+ if (it == support_algo.end()) return;
+ } else {
+ auto support_algo = GetSupportedSubkeyAlgo();
+ auto it = std::find(support_algo.begin(), support_algo.end(), algo_args);
+ // Algo Not Supported
+ if (it == support_algo.end()) return;
+ }
+ }
+
+ // reset all options
+ reset_options();
+
+ if (!this->subkey_) {
+ this->SetAllowCertification(true);
+ } else {
+ this->SetAllowCertification(false);
+ }
+
+ this->allow_change_certification_ = false;
+
+ if (!standalone_) boost::algorithm::to_lower(algo_args);
+
+ if (algo_args == "rsa") {
+ /**
+ * RSA is the world’s premier asymmetric cryptographic algorithm,
+ * and is built on the difficulty of factoring extremely large composites.
+ * GnuPG supports RSA with key sizes of between 1024 and 4096 bits.
+ */
+ suggest_min_key_size_ = 1024;
+ suggest_max_key_size_ = 4096;
+ suggest_size_addition_step_ = 1024;
+ SetKeyLength(2048);
+
+ } else if (algo_args == "dsa") {
+ /**
+ * Algorithm (DSA) as a government standard for digital signatures.
+ * Originally, it supported key lengths between 512 and 1024 bits.
+ * Recently, NIST has declared 512-bit keys obsolete:
+ * now, DSA is available in 1024, 2048 and 3072-bit lengths.
+ */
+ SetAllowEncryption(false);
+ allow_change_encryption_ = false;
+
+ suggest_min_key_size_ = 1024;
+ suggest_max_key_size_ = 3072;
+ suggest_size_addition_step_ = 1024;
+ SetKeyLength(2048);
+
+ } else if (algo_args == "ed25519") {
+ /**
+ * GnuPG supports the Elgamal asymmetric encryption algorithm in key lengths
+ * ranging from 1024 to 4096 bits.
+ */
+ SetAllowEncryption(false);
+ allow_change_encryption_ = false;
+
+ suggest_min_key_size_ = -1;
+ suggest_max_key_size_ = -1;
+ suggest_size_addition_step_ = -1;
+ SetKeyLength(-1);
+ } else if (algo_args == "elg") {
+ /**
+ * GnuPG supports the Elgamal asymmetric encryption algorithm in key lengths
+ * ranging from 1024 to 4096 bits.
+ */
+ SetAllowAuthentication(false);
+ allow_change_authentication_ = false;
+
+ SetAllowSigning(false);
+ allow_change_signing_ = false;
+
+ suggest_min_key_size_ = 1024;
+ suggest_max_key_size_ = 4096;
+ suggest_size_addition_step_ = 1024;
+ SetKeyLength(2048);
+ }
+ this->algo_ = algo_args;
+}
+
+void GpgFrontend::GenKeyInfo::reset_options() {
+ allow_change_encryption_ = true;
+ SetAllowEncryption(true);
+
+ allow_change_certification_ = true;
+ SetAllowCertification(true);
+
+ allow_change_signing_ = true;
+ SetAllowSigning(true);
+
+ allow_change_authentication_ = true;
+ SetAllowAuthentication(true);
+
+ passphrase_.clear();
+}
+
+std::string GpgFrontend::GenKeyInfo::GetKeySizeStr() const {
+ if (key_size_ > 0) {
+ return std::to_string(key_size_);
+ } else {
+ return {};
+ }
+}
+
+void GpgFrontend::GenKeyInfo::SetKeyLength(int m_key_size) {
+ if (m_key_size < suggest_min_key_size_ ||
+ m_key_size > suggest_max_key_size_) {
+ return;
+ }
+ GenKeyInfo::key_size_ = m_key_size;
+}
+
+void GpgFrontend::GenKeyInfo::SetExpireTime(
+ const boost::posix_time::ptime &m_expired) {
+ using namespace boost::gregorian;
+ if (!IsNonExpired()) {
+ GenKeyInfo::expired_ = m_expired;
+ }
+}
+
+void GpgFrontend::GenKeyInfo::SetNonExpired(bool m_non_expired) {
+ using namespace boost::posix_time;
+ if (!m_non_expired) this->expired_ = from_time_t(0);
+ GenKeyInfo::non_expired_ = m_non_expired;
+}
+
+void GpgFrontend::GenKeyInfo::SetAllowEncryption(bool m_allow_encryption) {
+ if (allow_change_encryption_)
+ GenKeyInfo::allow_encryption_ = m_allow_encryption;
+}
+
+void GpgFrontend::GenKeyInfo::SetAllowCertification(
+ bool m_allow_certification) {
+ if (allow_change_certification_)
+ GenKeyInfo::allow_certification_ = m_allow_certification;
+}
+
+GpgFrontend::GenKeyInfo::GenKeyInfo(bool m_is_sub_key, bool m_standalone)
+ : standalone_(m_standalone), subkey_(m_is_sub_key) {
+ SetAlgo("rsa");
+}
+
+const std::vector<std::string> &GpgFrontend::GenKeyInfo::GetSupportedKeyAlgo() {
+ static const std::vector<std::string> support_key_algo = {"RSA", "DSA",
+ "ED25519"};
+ return support_key_algo;
+}
+
+const std::vector<std::string>
+ &GpgFrontend::GenKeyInfo::GetSupportedSubkeyAlgo() {
+ static const std::vector<std::string> support_subkey_algo = {"RSA", "DSA",
+ "ED25519"};
+ return support_subkey_algo;
+}
+
+const std::vector<std::string>
+ &GpgFrontend::GenKeyInfo::GetSupportedKeyAlgoStandalone() {
+ static const std::vector<std::string> support_subkey_algo_standalone = {
+ "RSA", "DSA"};
+ return support_subkey_algo_standalone;
+}
+
+const std::vector<std::string>
+ &GpgFrontend::GenKeyInfo::GetSupportedSubkeyAlgoStandalone() {
+ static const std::vector<std::string> support_subkey_algo_standalone = {
+ "RSA", "DSA", "ELG-E"};
+ return support_subkey_algo_standalone;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-28 08:10:49 +0000