GpgGenKeyInfo.h

 
#ifndef GPGFRONTEND_GPGGENKEYINFO_H
#define GPGFRONTEND_GPGGENKEYINFO_H
 
#include <boost/date_time.hpp>
#include <boost/date_time/gregorian/greg_duration_types.hpp>
#include <boost/format.hpp>
#include <string>
#include <vector>
 
#include "GpgFrontend.h"
 
namespace GpgFrontend {
 
class GPGFRONTEND_CORE_EXPORT GenKeyInfo {
  bool standalone_ = false;  
  bool subkey_ = false;      
  std::string name_;         
  std::string email_;        
  std::string comment_;      
 
  std::string algo_;  
  int key_size_ = 2048;
  boost::posix_time::ptime expired_ =
      boost::posix_time::second_clock::local_time() +
      boost::gregorian::years(2);  
  bool non_expired_ = false;       
 
  bool no_passphrase_ = false;        
  bool allow_no_pass_phrase_ = true;  
 
  int suggest_max_key_size_ = 4096;        
  int suggest_size_addition_step_ = 1024;  
  int suggest_min_key_size_ = 1024;        
 
  std::string passphrase_;  
 
  using KeyGenAlgo = std::pair<std::string, std::string>;
 
 public:
  static const std::vector<KeyGenAlgo> &GetSupportedKeyAlgo();
 
  static const std::vector<KeyGenAlgo> &GetSupportedSubkeyAlgo();
 
  static const std::vector<KeyGenAlgo> &GetSupportedKeyAlgoStandalone();
 
  static const std::vector<KeyGenAlgo> &GetSupportedSubkeyAlgoStandalone();
 
  [[nodiscard]] bool IsSubKey() const { return subkey_; }
 
  void SetIsSubKey(bool m_sub_key) { GenKeyInfo::subkey_ = m_sub_key; }
 
  [[nodiscard]] std::string GetUserid() const {
    auto uid_format = boost::format("%1%(%2%)<%3%>") % this->name_ %
                      this->comment_ % this->email_;
    return uid_format.str();
  }
 
  void SetName(const std::string &m_name) { this->name_ = m_name; }
 
  void SetEmail(const std::string &m_email) { this->email_ = m_email; }
 
  void SetComment(const std::string &m_comment) { this->comment_ = m_comment; }
 
  [[nodiscard]] std::string GetName() const { return name_; }
 
  [[nodiscard]] std::string GetEmail() const { return email_; }
 
  [[nodiscard]] std::string GetComment() const { return comment_; }
 
  [[nodiscard]] const std::string &GetAlgo() const { return algo_; }
 
  void SetAlgo(const GpgFrontend::GenKeyInfo::KeyGenAlgo &m_algo);
 
  [[nodiscard]] std::string GetKeySizeStr() const;
 
  [[nodiscard]] int GetKeyLength() const { return key_size_; }
 
  void SetKeyLength(int m_key_size);
 
  [[nodiscard]] const boost::posix_time::ptime &GetExpireTime() const {
    return expired_;
  }
 
  void SetExpireTime(const boost::posix_time::ptime &m_expired);
 
  [[nodiscard]] bool IsNonExpired() const { return non_expired_; }
 
  void SetNonExpired(bool m_non_expired);
 
  [[nodiscard]] bool IsNoPassPhrase() const { return this->no_passphrase_; }
 
  void SetNonPassPhrase(bool m_non_pass_phrase) {
    GenKeyInfo::no_passphrase_ = m_non_pass_phrase;
  }
 
  [[nodiscard]] bool IsAllowSigning() const { return allow_signing_; }
 
  [[nodiscard]] bool IsAllowNoPassPhrase() const {
    return allow_no_pass_phrase_;
  }
 
  void SetAllowSigning(bool m_allow_signing) {
    if (allow_change_signing_) GenKeyInfo::allow_signing_ = m_allow_signing;
  }
 
  [[nodiscard]] bool IsAllowEncryption() const { return allow_encryption_; }
 
  void SetAllowEncryption(bool m_allow_encryption);
 
  [[nodiscard]] bool IsAllowCertification() const {
    return allow_certification_;
  }
 
  void SetAllowCertification(bool m_allow_certification);
 
  [[nodiscard]] bool IsAllowAuthentication() const {
    return allow_authentication_;
  }
 
  void SetAllowAuthentication(bool m_allow_authentication) {
    if (allow_change_authentication_)
      GenKeyInfo::allow_authentication_ = m_allow_authentication;
  }
 
  [[nodiscard]] const std::string &GetPassPhrase() const { return passphrase_; }
 
  void SetPassPhrase(const std::string &m_pass_phrase) {
    GenKeyInfo::passphrase_ = m_pass_phrase;
  }
 
  [[nodiscard]] bool IsAllowChangeSigning() const {
    return allow_change_signing_;
  }
 
  [[nodiscard]] bool IsAllowChangeEncryption() const {
    return allow_change_encryption_;
  }
 
  [[nodiscard]] bool IsAllowChangeCertification() const {
    return allow_change_certification_;
  }
 
  [[nodiscard]] bool IsAllowChangeAuthentication() const {
    return allow_change_authentication_;
  }
 
  [[nodiscard]] int GetSuggestMaxKeySize() const {
    return suggest_max_key_size_;
  }
 
  [[nodiscard]] int GetSuggestMinKeySize() const {
    return suggest_min_key_size_;
  }
 
  [[nodiscard]] int GetSizeChangeStep() const {
    return suggest_size_addition_step_;
  }
 
 private:
  bool allow_encryption_ = true;             
  bool allow_change_encryption_ = true;      
  bool allow_certification_ = true;          
  bool allow_change_certification_ = true;   
  bool allow_authentication_ = true;         
  bool allow_change_authentication_ = true;  
  bool allow_signing_ = true;                
  bool allow_change_signing_ = true;         
 
  void reset_options();
 
 public:
  explicit GenKeyInfo(bool m_is_sub_key = false, bool m_standalone = false);
};
 
}  // namespace GpgFrontend
 
#endif  // GPGFRONTEND_GPGGENKEYINFO_H