#include <OTAsymmetricKey.hpp>

Inheritance diagram for opentxs::OTAsymmetricKey:

Collaboration diagram for opentxs::OTAsymmetricKey:

Public Member Functions
virtual OTAsymmetricKey *	ClonePubKey () const

virtual EXPORT	~OTAsymmetricKey ()

virtual void	Release ()

void	Release_AsymmetricKey ()

void	ReleaseKey ()

bool	IsEmpty () const

bool	IsPublic () const

bool	IsPrivate () const

void	SetAsPublic ()

void	SetAsPrivate ()

virtual bool	CalculateID (OTIdentifier &theOutput) const

bool	LoadPrivateKey (const OTString &strFoldername, const OTString &strFilename, const OTString pstrReason=nullptr, const OTPassword pImportPassword=nullptr)

bool	LoadPublicKey (const OTString &strFoldername, const OTString &strFilename)

virtual bool	LoadPublicKeyFromPGPKey (const OTASCIIArmor &strKey)=0

virtual bool	LoadPrivateKeyFromCertString (const OTString &strCert, bool bEscaped=true, const OTString pstrReason=nullptr, const OTPassword pImportPassword=nullptr)=0

virtual bool	LoadPublicKeyFromCertString (const OTString &strCert, bool bEscaped=true, const OTString pstrReason=nullptr, const OTPassword pImportPassword=nullptr)=0

bool	LoadPublicKeyFromCertFile (const OTString &strFoldername, const OTString &strFilename, const OTString pstrReason=nullptr, const OTPassword pImportPassword=nullptr)

virtual bool	SaveCertToString (OTString &strOutput, const OTString pstrReason=nullptr, const OTPassword pImportPassword=nullptr) const =0

virtual bool	SavePrivateKeyToString (OTString &strOutput, const OTString pstrReason=nullptr, const OTPassword pImportPassword=nullptr) const =0

virtual bool	ReEncryptPrivateKey (const OTPassword &theExportPassword, bool bImporting) const =0

EXPORT bool	GetPublicKey (OTASCIIArmor &strKey) const

EXPORT bool	GetPublicKey (OTString &strKey, bool bEscaped=true) const

EXPORT bool	SetPublicKey (const OTASCIIArmor &strKey)

EXPORT bool	SetPublicKey (const OTString &strKey, bool bEscaped=false)

bool	GetPrivateKey (OTString &strKey, bool bEscaped=true) const

bool	GetPrivateKey (OTASCIIArmor &strKey) const

bool	SetPrivateKey (const OTString &strKey, bool bEscaped=false)

bool	SetPrivateKey (const OTASCIIArmor &strKey)

Static Public Member Functions
static EXPORT OTAsymmetricKey *	KeyFactory ()

static void	SetPasswordCallback (OT_OPENSSL_CALLBACK *pCallback)

static EXPORT OT_OPENSSL_CALLBACK *	GetPasswordCallback ()

static bool	IsPasswordCallbackSet ()

static bool	SetPasswordCaller (OTCaller &theCaller)

static OTCaller *	GetPasswordCaller ()

Public Attributes
OTSignatureMetadata *	m_pMetadata

Protected Member Functions
void	ReleaseKeyLowLevel ()

virtual void	ReleaseKeyLowLevel_Hook () const =0

EXPORT	OTAsymmetricKey ()

Protected Attributes
OTASCIIArmor *	m_p_ascKey

bool	m_bIsPublicKey

bool	m_bIsPrivateKey

Timer	m_timer

Static Protected Attributes
static OT_OPENSSL_CALLBACK *	s_pwCallback = nullptr

static OTCaller *	s_pCaller = nullptr

Detailed Description

Definition at line 203 of file OTAsymmetricKey.hpp.

Constructor & Destructor Documentation

opentxs::OTAsymmetricKey::OTAsymmetricKey ( )

protected

Definition at line 994 of file OTAsymmetricKey.cpp.

     : m_p_ascKey(nullptr)
     , m_bIsPublicKey(false)
     , m_bIsPrivateKey(false)
     , m_pMetadata(new OTSignatureMetadata)
 {
     //    if (nullptr == m_p_ascKey)
     //    {
     //        m_p_ascKey = new OTASCIIArmor;
     //        OT_ASSERT(nullptr != m_p_ascKey);
     //    }
 }

opentxs::OTAsymmetricKey::~OTAsymmetricKey ( )

virtual

Definition at line 1007 of file OTAsymmetricKey.cpp.

 {
     //    Release_AsymmetricKey(); // ******
 
     m_timer.clear(); // Since ReleaseKeyLowLevel is no longer called here (via
                      // Release_AsymmetricKey) then
     // m_timer.clear() was no longer getting called, so I added it here to
     // rectify that. See below NOTE for
     // more details.
     //
     // NOTE: It's very unusual that the above is commented out, since my normal
     // convention is to
     // call this function both in the destructor, as well as in the Release()
     // method for any given
     // class.
     // Here's why it's commented out, in this case. Because all it does is call
     // ReleaseKeyLowLevel,
     // which calls ReleaseKeyLowLevel_Hook, which is pure virtual and is what
     // allows the
     // OTAsymmetricKey_OpenSSL class to clean up its OpenSSL-specific private
     // members.
     // We CANNOT call a pure virtual method from a destructor (which is where we
     // currently are)
     // and so we cannot call Release_AsymmetricKey without removing that pure
     // virtual call. The
     // problem is, ReleaseKeyLowLevel USES that pure virtual call all over this
     // file (i.e. in many
     // other places BESIDES the destructor) and so we cannot just remove the
     // pure virtual call it
     // uses which is, in fact, the entire purpose it's being called in the first
     // place. So what I
     // did was, I changed OTAsymmetricKey_OpenSSL to directly clean up its
     // OpenSSL-specific key data,
     // and it just ALSO has the hook override doing the same thing. This way
     // Release_AsymmetricKey
     // can continue to be used by ReleaseKeyLowLevel all over this file, as it
     // was designed, using
     // the hook and the override, yet also this destructor will continue to work
     // perfectly... because
     // Release_AsymmetricKey() is commented out above, we won't have any runtime
     // errors from trying to
     // run a pure virtual method from a destructor. And because
     // OTAsymmetricKey_OpenSSL now cleans itself
     // up in its own destructor automatically, we have no need whatsoever to
     // call a virtual function here
     // to clean it up. So it's commented out.
     // Makes sense? Of course we didn't have any virtuality before
     // OTAsymmetricKey_OpenSSL was added,
     // since OTAsymmetricKey previously had no subclasses at all. But that has
     // changed recently, so that
     // it is now an abstract interface, so that someday a GPG implementation, or
     // NaCl implementation can
     // someday be added.
 
     // Release the ascii-armored version of the key (safe to store in this
     // form.)
     //
     if (nullptr != m_p_ascKey) delete m_p_ascKey;
     m_p_ascKey = nullptr;
 
     if (nullptr != m_pMetadata) delete m_pMetadata;
     m_pMetadata = nullptr;
 }

Member Function Documentation

bool opentxs::OTAsymmetricKey::CalculateID ( OTIdentifier & theOutput ) const

virtual

Definition at line 763 of file OTAsymmetricKey.cpp.

 {
     const char* szFunc = "OTAsymmetricKey::CalculateID";
 
     theOutput.Release();
 
     if (!IsPublic()) {
         otErr << szFunc << ": Error: !IsPublic() (This function should only be "
                            "called on a public key.)\n";
         return false;
     }
 
     OTString strPublicKey;
     bool bGotPublicKey = GetPublicKey(strPublicKey);
 
     if (!bGotPublicKey) {
         otErr << szFunc << ": Error getting public key.\n";
         return false;
     }
 
     bool bSuccessCalculateDigest = theOutput.CalculateDigest(strPublicKey);
 
     if (!bSuccessCalculateDigest) {
         theOutput.Release();
         otErr << szFunc << ": Error calculating digest of public key.\n";
         return false;
     }
 
     return true;
 }

OTAsymmetricKey * opentxs::OTAsymmetricKey::ClonePubKey ( ) const

virtual

Definition at line 173 of file OTAsymmetricKey.cpp.

 {
     OTAsymmetricKey* pKey = OTAsymmetricKey::KeyFactory();
     OT_ASSERT(nullptr != pKey);
     OT_ASSERT(nullptr != m_pMetadata);
     OT_ASSERT(nullptr != pKey->m_pMetadata);
 
     OTASCIIArmor ascTransfer;
     GetPublicKey(ascTransfer); // Get this's public key in ASCII-armored format
     pKey->SetPublicKey(
         ascTransfer); // Decodes that public key from ASCII armor into pKey
 
     *(pKey->m_pMetadata) = *(m_pMetadata); // Metadata will be attached to
                                            // signatures, if set.
 
     return pKey;
 }

OT_OPENSSL_CALLBACK * opentxs::OTAsymmetricKey::GetPasswordCallback ( )

static

Definition at line 224 of file OTAsymmetricKey.cpp.

 {
     // cppcheck-suppress variableScope
     const char* szFunc = "OTAsymmetricKey::GetPasswordCallback";
 
 #if defined(OT_TEST_PASSWORD)
     otInfo << szFunc << ": WARNING, OT_TEST_PASSWORD *is* defined. The "
                         "internal 'C'-based password callback was just "
                         "requested by OT (to pass to OpenSSL). So, returning "
                         "the default_pass_cb password callback, which will "
                         "automatically return "
                         "the 'test' password to OpenSSL, if/when it calls that "
                         "callback function.\n";
     return &default_pass_cb;
 #else
     if (IsPasswordCallbackSet()) {
         otLog5 << szFunc
                << ": FYI, the internal 'C'-based password callback is now "
                   "being returning to OT, "
                   "which is passing it to OpenSSL "
                   "during a crypto operation. (If OpenSSL invokes it, then we "
                   "should see other logs after this from when it triggers "
                   "whatever password-collection dialog is provided at startup "
                   "by the (probably Java) OTAPI client.)\n";
         return s_pwCallback;
     }
     else {
         //        otInfo << "OTAsymmetricKey::GetPasswordCallback: FYI, the
         // internal 'C'-based password callback was requested by OT (to pass to
         // OpenSSL), "
         //                      "but the callback hasn't been set yet.
         // (Returning nullptr CALLBACK to OpenSSL!! Thus causing it to instead
         // ask
         // for the passphrase on the CONSOLE, "
         //                      "since no Java password dialog was apparently
         // available.)\n");
 
         //        return static_cast<OT_OPENSSL_CALLBACK *>(nullptr);
 
         // We have our own "console" password-gathering function, which allows
         // us to use our master key.
         // Since the souped-up cb uses it, I'm just returning that here as a
         // default, for now.
         OTAsymmetricKey::SetPasswordCallback(&souped_up_pass_cb);
         return s_pwCallback;
     }
 #endif
 }

OTCaller * opentxs::OTAsymmetricKey::GetPasswordCaller ( )

static

Definition at line 321 of file OTAsymmetricKey.cpp.

 {
     const char* szFunc = "OTAsymmetricKey::GetPasswordCaller";
 
     otLog4 << szFunc << ": FYI, this was just called by souped_up_pass_cb "
                         "(which must have just been called by OpenSSL.) "
                         "Returning s_pCaller == "
            << ((nullptr == s_pCaller) ? "nullptr" : "VALID POINTER")
            << " (Hopefully NOT nullptr, so the "
               "custom password dialog can be triggered.)\n";
 
     return s_pCaller;
 }

bool opentxs::OTAsymmetricKey::GetPrivateKey	(	OTString &	strKey,
		bool	bEscaped = `true`
	)		const

Definition at line 908 of file OTAsymmetricKey.cpp.

 {
     OTASCIIArmor theArmor;
 
     if (GetPrivateKey(theArmor)) {
         if (bEscaped) {
             strKey.Concatenate("- -----BEGIN ENCRYPTED PRIVATE KEY-----\n"
                                "%s"
                                "- -----END ENCRYPTED PRIVATE KEY-----\n",
                                theArmor.Get());
         }
         else {
             strKey.Concatenate("-----BEGIN ENCRYPTED PRIVATE KEY-----\n"
                                "%s"
                                "-----END ENCRYPTED PRIVATE KEY-----\n",
                                theArmor.Get());
         }
         return true;
     }
     else
         otErr << "OTAsymmetricKey::GetPrivateKey: Error: "
                  "GetPrivateKey(armored) returned false. (Returning false.)\n";
 
     return false;
 }

bool opentxs::OTAsymmetricKey::GetPrivateKey ( OTASCIIArmor & strKey ) const

Definition at line 935 of file OTAsymmetricKey.cpp.

 {
     OT_ASSERT(IsPrivate());
 
     ascKey.Release();
 
     if (nullptr == m_p_ascKey) return false;
 
     ascKey.Set(*m_p_ascKey);
 
     return true;
 }

bool opentxs::OTAsymmetricKey::GetPublicKey ( OTASCIIArmor & strKey ) const

Definition at line 840 of file OTAsymmetricKey.cpp.

 {
     OT_ASSERT_MSG(IsPublic(),
                   "OTAsymmetricKey::GetPublicKey: ASSERT: IsPublic()\n");
 
     ascKey.Release();
 
     if (nullptr == m_p_ascKey) return false;
 
     ascKey.Set(*m_p_ascKey);
 
     return true;
 }

bool opentxs::OTAsymmetricKey::GetPublicKey	(	OTString &	strKey,
		bool	bEscaped = `true`
	)		const

Definition at line 800 of file OTAsymmetricKey.cpp.

 {
     OTASCIIArmor theArmor;
 
     // TODO: optimization: When optimizing for CPU cycles, and willing to
     // sacrifice a little RAM, we
     // can save this value the first time it's computed, and then as long as the
     // armored version (without
     // bookends) doesn't change, we can save the computed version and pass it
     // back here, instead of re-generating
     // it here each time this is called. This implies a need for the armored
     // version to be able to be flagged
     // as "dirty" when it is changed.
 
     if (GetPublicKey(theArmor)) {
         if (bEscaped) {
             strKey.Concatenate(
                 "- -----BEGIN PUBLIC KEY-----\n" // ESCAPED VERSION
                 "%s"
                 "- -----END PUBLIC KEY-----\n",
                 theArmor.Get());
         }
         else {
             strKey.Concatenate(
                 "-----BEGIN PUBLIC KEY-----\n" // UN-ESCAPED VERSION
                 "%s"
                 "-----END PUBLIC KEY-----\n",
                 theArmor.Get());
         }
         return true;
     }
     else
         otErr << "OTAsymmetricKey::GetPublicKey: Error: GetPublicKey(armored) "
                  "returned false. (Returning false.)\n";
 
     return false;
 }

bool opentxs::OTAsymmetricKey::IsEmpty ( ) const

inline

Definition at line 279 of file OTAsymmetricKey.hpp.

     {
         return (nullptr == m_p_ascKey);
     } // m_p_ascKey is the most basic value. m_pKey is derived from it, for

static bool opentxs::OTAsymmetricKey::IsPasswordCallbackSet ( )

inlinestatic

Definition at line 217 of file OTAsymmetricKey.hpp.

     {
         return (nullptr == s_pwCallback) ? false : true;
     }

bool opentxs::OTAsymmetricKey::IsPrivate ( ) const

inline

Definition at line 288 of file OTAsymmetricKey.hpp.

     {
         return m_bIsPrivateKey;
     }

bool opentxs::OTAsymmetricKey::IsPublic ( ) const

inline

Definition at line 284 of file OTAsymmetricKey.hpp.

     {
         return m_bIsPublicKey;
     }

OTAsymmetricKey * opentxs::OTAsymmetricKey::KeyFactory ( )

static

Definition at line 154 of file OTAsymmetricKey.cpp.

 {
     OTAsymmetricKey* pKey = nullptr;
 #if defined(OT_CRYPTO_USING_OPENSSL)
     pKey = new OTAsymmetricKey_OpenSSL;
 #elif defined(OT_CRYPTO_USING_GPG)
     //  pKey = new OTAsymmetricKey_GPG;
     otErr << __FUNCTION__ << ": Open-Transactions doesn't support GPG (yet), "
                              "so it's impossible to instantiate a key.\n";
 #else
     otErr << __FUNCTION__
           << ": Open-Transactions isn't built with any crypto engine, "
              "so it's impossible to instantiate a key.\n";
 #endif
     return pKey;
 }

bool opentxs::OTAsymmetricKey::LoadPrivateKey	(	const OTString &	strFoldername,
		const OTString &	strFilename,
		const OTString *	pstrReason = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

Definition at line 1174 of file OTAsymmetricKey.cpp.

 {
     Release();
 
     m_bIsPublicKey = false;
     m_bIsPrivateKey = true;
 
     const char* szFoldername = strFoldername.Get();
     const char* szFilename = strFilename.Get();
 
     OT_ASSERT(strFoldername.Exists());
     OT_ASSERT(strFilename.Exists());
 
     if (!OTDB::Exists(szFoldername, szFilename)) {
         otOut << "OTAsymmetricKey::LoadPrivateKey: Unable to find private key "
                  "file: " << szFoldername << OTLog::PathSeparator()
               << szFilename << "\n";
         return false;
     }
 
     // The private key is stored in an encrypted form, which is how it stays
     // until the
     // password callback is passed into some OpenSSL call that attempts to use
     // it.
     //
     std::string strFileContents(OTDB::QueryPlainString(
         szFoldername, szFilename)); // <=== LOADING "AS-IS" FROM DATA STORE.
 
     if (strFileContents.length() < 2) {
         otErr << "OTAsymmetricKey::LoadPrivateKey: Error reading file: "
               << szFoldername << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     const OTString strCert(strFileContents),
         strReason(nullptr == pstrReason ? "OTAsymmetricKey::LoadPrivateKey"
                                         : *pstrReason);
 
     return LoadPrivateKeyFromCertString(strCert, false, &strReason,
                                         pImportPassword); // bEscaped=false;
     // "escaped" means pre-pended with "- " as in:   - -----BEGIN CER....
 }

virtual bool opentxs::OTAsymmetricKey::LoadPrivateKeyFromCertString	(	const OTString &	strCert,
		bool	bEscaped = `true`,
		const OTString *	pstrReason = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

pure virtual

Implemented in opentxs::OTAsymmetricKey_OpenSSL.

bool opentxs::OTAsymmetricKey::LoadPublicKey	(	const OTString &	strFoldername,
		const OTString &	strFilename
	)

Definition at line 1224 of file OTAsymmetricKey.cpp.

 {
     // Already done in SetPublicKey()
     //    m_bIsPublicKey    = true;
     //    m_bIsPrivateKey    = false;
 
     Release();
 
     // This doesn't use assert on the arguments, but theArmor.LoadFromFile DOES.
 
     OTASCIIArmor theArmor;
 
     if (theArmor.LoadFromFile(strFoldername, strFilename)) {
         if (SetPublicKey(theArmor)) {
             otLog4 << "Success setting public key from OTASCIIArmor in "
                       "OTAsymmetricKey::LoadPublicKey.\n";
             return true;
         }
         else {
             otErr << "Unable to convert from OTASCIIArmor to public key in "
                      "OTAsymmetricKey::LoadPublicKey: " << strFilename << "\n";
             return false;
         }
     }
     else {
         otErr
             << "Unable to read pubkey file in OTAsymmetricKey::LoadPublicKey: "
             << strFilename << "\n";
         return false;
     }
 }

bool opentxs::OTAsymmetricKey::LoadPublicKeyFromCertFile	(	const OTString &	strFoldername,
		const OTString &	strFilename,
		const OTString *	pstrReason = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

Definition at line 1258 of file OTAsymmetricKey.cpp.

 {
     Release();
 
     m_bIsPublicKey = true;
     m_bIsPrivateKey = false;
 
     const char* szFoldername = strFoldername.Get();
     const char* szFilename = strFilename.Get();
 
     OT_ASSERT(strFoldername.Exists());
     OT_ASSERT(strFilename.Exists());
 
     if (!OTDB::Exists(szFoldername, szFilename)) {
         otErr << __FUNCTION__ << ": File does not exist: " << szFoldername
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     //
     std::string strFileContents(OTDB::QueryPlainString(
         szFoldername, szFilename)); // <=== LOADING FROM DATA STORE.
 
     if (strFileContents.length() < 2) {
         otErr << __FUNCTION__ << ": Error reading file: " << szFoldername
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     const OTString strCert(strFileContents);
 
     return LoadPublicKeyFromCertString(
         strCert, false, pstrReason,
         pImportPassword); // bEscaped=false; "escaped" means pre-pended with "-
                           // " as in:   - -----BEGIN CER....
 }

virtual bool opentxs::OTAsymmetricKey::LoadPublicKeyFromCertString	(	const OTString &	strCert,
		bool	bEscaped = `true`,
		const OTString *	pstrReason = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

pure virtual

Implemented in opentxs::OTAsymmetricKey_OpenSSL.

virtual bool opentxs::OTAsymmetricKey::LoadPublicKeyFromPGPKey ( const OTASCIIArmor & strKey )

pure virtual

Implemented in opentxs::OTAsymmetricKey_OpenSSL.

virtual bool opentxs::OTAsymmetricKey::ReEncryptPrivateKey	(	const OTPassword &	theExportPassword,
		bool	bImporting
	)		const

pure virtual

Implemented in opentxs::OTAsymmetricKey_OpenSSL.

void opentxs::OTAsymmetricKey::Release ( )

virtual

Reimplemented in opentxs::OTAsymmetricKey_OpenSSL.

Definition at line 1164 of file OTAsymmetricKey.cpp.

 {
     Release_AsymmetricKey(); // My own cleanup is done here.
 
     // Next give the base class a chance to do the same...
     //    ot_super::Release(); // THERE IS NO base class in this case. But
     // normally this would be here for most classes.
 }

void opentxs::OTAsymmetricKey::Release_AsymmetricKey ( )

Definition at line 1071 of file OTAsymmetricKey.cpp.

 {
 
     // Release the ascii-armored version of the key (safe to store in this
     // form.)
     //
     // Moving this to the destructor. Shouldn't be going nullptr here IMO.
     //    if (nullptr != m_p_ascKey)
     //        delete m_p_ascKey;
     //    m_p_ascKey = nullptr;
 
     // Release the instantiated OpenSSL key (unsafe to store in this form.)
     //
     ReleaseKeyLowLevel();
 
     //    m_bIsPrivateKey = false;  // Every time this Releases, I don't want to
     // lose what kind of key it was. (Once we know, we know.)
 }

void opentxs::OTAsymmetricKey::ReleaseKey ( )

Definition at line 1101 of file OTAsymmetricKey.cpp.

 {
     // Todo: someday put a timer inside this class, so it doesn't REALLY release
     // the
     // key until the Timer has expired.
     // NOTE: marking this as "todo" because I won't necessarily want it done
     // this way. This
     // solution would keep the actual private key loaded in OpenSSL, meaning I'd
     // have to take
     // over the OpenSSL memory management to make it into a safe solution
     // (though I probably
     // have to do that anyway.)
     // A better solution might be to have a random session key used for
     // protecting a hashed
     // version of the passphrase, and then ALWAYS destroying the key as fast as
     // possible,
     // instead using the hashed passphrase within the bounds of a timer, with
     // the hashed passphrase
     // being decrypted JUST before use and then destroyed, just as the private
     // key is destroyed.
     // I might also wish such a thing was stored not just in OT protected
     // memory, but in a standard
     // *API* for protected memory, such as ssh-agent or the Mac Keychain.
     // However, that can easily
     // be just an option to be added later, meaning I can go ahead and code my
     // hashed password solution
     // in the meantime. But will that be coded here at the OTAsymmetricKey
     // level? Or at the Nym level,
     // or at the static Nym level, or the app level? Hmm...
     //
     // Security:
     // UPDATE: Since the above solution is coming at some point anyway, I'm
     // going ahead and adding a
     // Timer version that works at this level (OTAsymmetricKey.)  The reason is
     // because it will be quick
     // and easy, and will give me the functionality I need for now, until I code
     // all the stuff above.
     // Just keep in mind: This is good enough for now, but it WILL result in the
     // private key staying
     // loaded in memory until the timer runs out, meaning if an attacker has
     // access to the RAM on the
     // local machine, if I haven't replaced the OpenSSL memory management, then
     // that is a security issue.
     //
     // TODO (remove theTimer entirely. OTCachedKey replaces already.)
     // I set this timer because the above required a password. But now that
     // master key is working,
     // the above would flow through even WITHOUT the user typing his passphrase
     // (since master key still
     // not timed out.) Resulting in THIS timer being reset!  Todo: I already
     // shortened this timer to 30
     // seconds, but need to phase it down to 0 and then remove it entirely!
     // Master key takes over now!
     //
 
     //  if (m_timer.getElapsedTimeInSec() > OT_KEY_TIMER)
     ReleaseKeyLowLevel();
 
     // Programmatic user (developer) may call ReleaseKey, but then we don't
     // actually release it until it's
     // been at least X minutes.
 }

void opentxs::OTAsymmetricKey::ReleaseKeyLowLevel ( )

protected

Definition at line 1090 of file OTAsymmetricKey.cpp.

 {
     ReleaseKeyLowLevel_Hook();
 
     m_timer.clear();
 
     //    m_bIsPrivateKey = false;  // Every time this Releases, I don't want to
     // lose what kind of key it was. (Once we know, we know.)
 }

virtual void opentxs::OTAsymmetricKey::ReleaseKeyLowLevel_Hook ( ) const

protectedpure virtual

Implemented in opentxs::OTAsymmetricKey_OpenSSL.

virtual bool opentxs::OTAsymmetricKey::SaveCertToString	(	OTString &	strOutput,
		const OTString *	pstrReason = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)		const

pure virtual

Implemented in opentxs::OTAsymmetricKey_OpenSSL.

virtual bool opentxs::OTAsymmetricKey::SavePrivateKeyToString	(	OTString &	strOutput,
		const OTString *	pstrReason = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)		const

pure virtual

Implemented in opentxs::OTAsymmetricKey_OpenSSL.

void opentxs::OTAsymmetricKey::SetAsPrivate ( )

inline

Definition at line 297 of file OTAsymmetricKey.hpp.

     {
         m_bIsPublicKey = false;
         m_bIsPrivateKey = true;
     } // (Only if you really know what you are doing.)

void opentxs::OTAsymmetricKey::SetAsPublic ( )

inline

Definition at line 292 of file OTAsymmetricKey.hpp.

     {
         m_bIsPublicKey = true;
         m_bIsPrivateKey = false;
     } // Don't use this, normally it's not necessary.

void opentxs::OTAsymmetricKey::SetPasswordCallback ( OT_OPENSSL_CALLBACK * pCallback )

static

Definition at line 201 of file OTAsymmetricKey.cpp.

 {
     const char* szFunc = "OTAsymmetricKey::SetPasswordCallback";
 
     if (nullptr != s_pwCallback)
         otOut << szFunc << ": WARNING: re-setting the password callback (one "
                            "was already there)...\n";
     else
         otWarn << szFunc << ": FYI, setting the password callback to a "
                             "non-nullptr pointer (which is what we want.)\n";
 
     if (nullptr == pCallback)
         otErr << szFunc
               << ": WARNING, setting the password callback to nullptr! "
                  "(OpenSSL will thus "
                  "be forced to ask for the passphase on the console, "
                  "until this is called "
                  "again and set properly.)\n";
 
     s_pwCallback = pCallback; // no need to delete function pointer that came
                               // before this function pointer.
 }

bool opentxs::OTAsymmetricKey::SetPasswordCaller ( OTCaller & theCaller )

static

Definition at line 280 of file OTAsymmetricKey.cpp.

 {
     const char* szFunc = "OTAsymmetricKey::SetPasswordCaller";
 
     otLog3 << szFunc
            << ": Attempting to set the password caller... "
               "(the Java code has passed us its custom password dialog object "
               "for later use if/when the "
               "OT 'C'-based password callback is triggered by openssl.)\n";
 
     if (!theCaller.isCallbackSet()) {
         otErr << szFunc << ": ERROR: OTCaller::setCallback() "
                            "MUST be called first, with an OTCallback-extended "
                            "object passed to it,\n"
                            "BEFORE calling this function with that OTCaller. "
                            "(Returning false.)\n";
         return false;
     }
 
     if (nullptr != s_pCaller) {
         otErr << szFunc
               << ": WARNING: Setting the password caller again, even though "
                  "it was apparently ALREADY set... (Meaning Java has probably "
                  "erroneously called this twice, "
                  "possibly passing the same OTCaller both times.)\n";
         //        delete s_pCaller; // Let Java delete it.
     }
 
     s_pCaller = &theCaller;
 
     OTAsymmetricKey::SetPasswordCallback(&souped_up_pass_cb);
 
     otWarn << szFunc
            << ": FYI, Successfully set the password caller object from "
               "Java, and set the souped_up_pass_cb in C for OpenSSL (which "
               "triggers "
               "that Java object when the time is right.) Returning true.\n";
 
     return true;
 }

bool opentxs::OTAsymmetricKey::SetPrivateKey	(	const OTString &	strKey,
		bool	bEscaped = `false`
	)

Definition at line 953 of file OTAsymmetricKey.cpp.

 {
     m_bIsPublicKey = false;
     m_bIsPrivateKey = true;
 
     // This reads the string into the Armor and removes the bookends. (-----
     // BEGIN ...)
     //
     OTASCIIArmor theArmor;
     const char* szPrivateKeyStarts = "-----BEGIN ENCRYPTED PRIVATE KEY-----";
     if (theArmor.LoadFromString(const_cast<OTString&>(strKey), bEscaped,
                                 szPrivateKeyStarts)) // This last param causes
                                                      // OTASCIIArmor to only
                                                      // "start loading" when it
                                                      // reaches the private key.
     {
         return SetPrivateKey(theArmor);
     }
 
     return false;
 }

bool opentxs::OTAsymmetricKey::SetPrivateKey ( const OTASCIIArmor & strKey )

Definition at line 977 of file OTAsymmetricKey.cpp.

 {
     ReleaseKeyLowLevel();
 
     m_bIsPublicKey = false;
     m_bIsPrivateKey = true; // PRIVATE KEY
 
     if (nullptr == m_p_ascKey) {
         m_p_ascKey = new OTASCIIArmor;
         OT_ASSERT(nullptr != m_p_ascKey);
     }
 
     m_p_ascKey->Set(ascKey);
 
     return true;
 }

bool opentxs::OTAsymmetricKey::SetPublicKey ( const OTASCIIArmor & strKey )

Definition at line 884 of file OTAsymmetricKey.cpp.

 {
     ReleaseKeyLowLevel(); // In case the key is already loaded, we release it
                           // here. (Since it's being replaced, it's now the
                           // wrong key anyway.)
 
     m_bIsPublicKey = true;
     m_bIsPrivateKey = false;
 
     if (nullptr == m_p_ascKey) {
         m_p_ascKey = new OTASCIIArmor;
         OT_ASSERT(nullptr != m_p_ascKey);
     }
 
     m_p_ascKey->Set(ascKey);
 
     return true;
 }

bool opentxs::OTAsymmetricKey::SetPublicKey	(	const OTString &	strKey,
		bool	bEscaped = `false`
	)

Definition at line 861 of file OTAsymmetricKey.cpp.

 {
     m_bIsPublicKey = true;
     m_bIsPrivateKey = false;
 
     // This reads the string into the Armor and removes the bookends. (-----
     // BEGIN ...)
     OTASCIIArmor theArmor;
 
     if (theArmor.LoadFromString(const_cast<OTString&>(strKey), bEscaped)) {
         return SetPublicKey(theArmor);
     }
     else
         otErr << "OTAsymmetricKey::SetPublicKey: Error: failed loading "
                  "ascii-armored contents from bookended string:\n\n" << strKey
               << "\n\n";
 
     return false;
 }

Member Data Documentation

bool opentxs::OTAsymmetricKey::m_bIsPrivateKey

protected

Definition at line 233 of file OTAsymmetricKey.hpp.

bool opentxs::OTAsymmetricKey::m_bIsPublicKey

protected

Definition at line 232 of file OTAsymmetricKey.hpp.

OTASCIIArmor* opentxs::OTAsymmetricKey::m_p_ascKey

protected

Definition at line 229 of file OTAsymmetricKey.hpp.

OTSignatureMetadata* opentxs::OTAsymmetricKey::m_pMetadata

Definition at line 237 of file OTAsymmetricKey.hpp.

Timer opentxs::OTAsymmetricKey::m_timer

protected

Definition at line 234 of file OTAsymmetricKey.hpp.

OTCaller * opentxs::OTAsymmetricKey::s_pCaller = nullptr

staticprotected

Definition at line 226 of file OTAsymmetricKey.hpp.

OT_OPENSSL_CALLBACK * opentxs::OTAsymmetricKey::s_pwCallback = nullptr

staticprotected

Definition at line 225 of file OTAsymmetricKey.hpp.

The documentation for this class was generated from the following files:

/usr/local/src/opentxs/include/opentxs/core/crypto/OTAsymmetricKey.hpp
/usr/local/src/opentxs/src/core/crypto/OTAsymmetricKey.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation