opentxs::OTKeypair Class Reference

#include <OTKeypair.hpp>

Public Member Functions
EXPORT bool	MakeNewKeypair (int32_t nBits=1024)
EXPORT bool	ReEncrypt (const OTPassword &theExportPassword, bool bImporting, OTString &strOutput)
EXPORT bool	HasPublicKey ()
EXPORT bool	HasPrivateKey ()
EXPORT const OTAsymmetricKey &	GetPublicKey () const
EXPORT const OTAsymmetricKey &	GetPrivateKey () const
EXPORT bool	CalculateID (OTIdentifier &theOutput) const
EXPORT bool	SaveCertToString (OTString &strOutput, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr) const
EXPORT bool	SavePrivateKeyToString (OTString &strOutput, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr) const
EXPORT bool	SaveCertAndPrivateKeyToString (OTString &strOutput, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT bool	LoadPrivateKey (const OTString &strFoldername, const OTString &strFilename, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT bool	LoadPublicKey (const OTString &strFoldername, const OTString &strFilename)
EXPORT bool	LoadPrivateKeyFromCertString (const OTString &strCert, bool bEscaped=true, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT bool	LoadPublicKeyFromCertString (const OTString &strCert, bool bEscaped=true, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT bool	LoadPublicKeyFromCertFile (const OTString &strFoldername, const OTString &strFilename, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT bool	LoadCertAndPrivateKeyFromString (const OTString &strInput, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT bool	LoadBothKeysFromCertFile (const OTString &strFoldername, const OTString &strFilename, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT bool	SaveAndReloadBothKeysFromTempFile (OTString *pstrOutputCert=nullptr, const OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
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)
EXPORT bool	GetPrivateKey (OTString &strKey, bool bEscaped=true) const
EXPORT bool	GetPrivateKey (OTASCIIArmor &strKey) const
EXPORT bool	SetPrivateKey (const OTString &strKey, bool bEscaped=false)
EXPORT bool	SetPrivateKey (const OTASCIIArmor &strKey)
EXPORT bool	SignContract (OTContract &theContract, const OTPasswordData *pPWData=nullptr)
EXPORT void	SetMetadata (const OTSignatureMetadata &theMetadata)
EXPORT int32_t	GetPublicKeyBySignature (listOfAsymmetricKeys &listOutput, const OTSignature &theSignature, bool bInclusive=false) const
EXPORT	OTKeypair ()
EXPORT	~OTKeypair ()

Friends
class	OTLowLevelKeyData

Detailed Description

Definition at line 192 of file OTKeypair.hpp.

Constructor & Destructor Documentation

opentxs::OTKeypair::OTKeypair

(

)

Definition at line 184 of file OTKeypair.cpp.

    : m_pkeyPublic(OTAsymmetricKey::KeyFactory())
    , m_pkeyPrivate(OTAsymmetricKey::KeyFactory())
{
}

opentxs::OTKeypair::~OTKeypair

(

)

Definition at line 190 of file OTKeypair.cpp.

{

    if (nullptr != m_pkeyPublic) delete m_pkeyPublic; // todo: else error
    m_pkeyPublic = nullptr;

    if (nullptr != m_pkeyPrivate) delete m_pkeyPrivate; // todo: else error
    m_pkeyPrivate = nullptr;
}

Member Function Documentation

bool opentxs::OTKeypair::CalculateID

(

OTIdentifier &

theOutput

)

const

Definition at line 643 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return m_pkeyPublic->CalculateID(theOutput); // Only works for public keys.
}

const OTAsymmetricKey & opentxs::OTKeypair::GetPrivateKey

(

)

const

Definition at line 236 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    return (*m_pkeyPrivate);
}

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

Definition at line 568 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    return m_pkeyPrivate->GetPrivateKey(strKey, bEscaped);
}

bool opentxs::OTKeypair::GetPrivateKey

(

OTASCIIArmor &

strKey

)

const

Definition at line 575 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    return m_pkeyPrivate->GetPrivateKey(strKey);
}

const OTAsymmetricKey & opentxs::OTKeypair::GetPublicKey

(

)

const

Definition at line 229 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return (*m_pkeyPublic);
}

bool opentxs::OTKeypair::GetPublicKey

(

OTASCIIArmor &

strKey

)

const

Definition at line 509 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return m_pkeyPublic->GetPublicKey(strKey);
}

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

Definition at line 516 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return m_pkeyPublic->GetPublicKey(strKey, bEscaped);
}

int32_t opentxs::OTKeypair::GetPublicKeyBySignature	(	listOfAsymmetricKeys &	listOutput,
		const OTSignature &	theSignature,
		bool	bInclusive = false
	)		const

Definition at line 650 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);
    OT_ASSERT(nullptr != m_pkeyPublic->m_pMetadata);

    // We know that EITHER exact metadata matches must occur, and the signature
    // MUST have metadata, (bInclusive=false)
    // OR if bInclusive=true, we know that metadata is still used to eliminate
    // keys where possible, but that otherwise,
    // if the signature has no metadata, then the key is still returned, "just
    // in case."
    //
    if ((false == bInclusive) &&
        (false == theSignature.getMetaData().HasMetadata()))
        return 0;

    // Below this point, metadata is used if it's available.
    // It's assumed to be "okay" if it's not available, since any non-inclusive
    // calls would have already returned by now, if that were the case.
    // (But if it IS available, then it must match, or the key won't be
    // returned.)
    //
    // If the signature has no metadata, or if m_pkeyPublic has no metadata, or
    // if they BOTH have metadata, and their metadata is a MATCH...
    if (!theSignature.getMetaData().HasMetadata() ||
        !m_pkeyPublic->m_pMetadata->HasMetadata() ||
        (m_pkeyPublic->m_pMetadata->HasMetadata() &&
         theSignature.getMetaData().HasMetadata() &&
         (theSignature.getMetaData() == *(m_pkeyPublic->m_pMetadata)))) {
        // ...Then add m_pkeyPublic as a possible match, to listOutput.
        //
        listOutput.push_back(m_pkeyPublic);
        return 1;
    }
    return 0;
}

bool opentxs::OTKeypair::HasPrivateKey

(

)

Definition at line 221 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    return m_pkeyPrivate->IsPrivate(); // This means it actually has a private
                                       // key in it, or tried to.
}

bool opentxs::OTKeypair::HasPublicKey

(

)

Definition at line 213 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return m_pkeyPublic->IsPublic(); // This means it actually has a public key
                                     // in it, or tried to.
}

bool opentxs::OTKeypair::LoadBothKeysFromCertFile	(	const OTString &	strFoldername,
		const OTString &	strFilename,
		const OTString *	pstrReason = nullptr,
		const OTPassword *	pImportPassword = nullptr
	)

Definition at line 456 of file OTKeypair.cpp.

{
    const char* szFunc = "OTKeypair::LoadBothKeysFromCertFile";

    OT_ASSERT(nullptr != m_pkeyPublic);
    OT_ASSERT(nullptr != m_pkeyPrivate);

    bool bPublic = m_pkeyPublic->LoadPublicKeyFromCertFile(
        strFoldername.Get(), strFilename.Get(), pstrReason, pImportPassword);
    bool bPrivate = m_pkeyPrivate->LoadPrivateKey(
        strFoldername.Get(), strFilename.Get(), pstrReason, pImportPassword);
    if (!bPublic) {
        otErr << szFunc << ": Although the ascii-armored file (" << strFilename
              << ") was read, LoadPublicKeyFromCert "
                 "returned false.\n";
        return false;
    }
    else {
        otInfo << szFunc << ": Successfully loaded public key from Certfile: "
               << strFilename << "\n";
    }

    if (!bPrivate) {
        otErr << szFunc << ": Although the ascii-armored file (" << strFilename
              << ") was read, LoadPrivateKey returned false.\n";
        return false;
    }
    else {
        otInfo << szFunc << ": Successfully loaded private key from certfile: "
               << strFilename << "\n";
    }

    return true;
}

bool opentxs::OTKeypair::LoadCertAndPrivateKeyFromString	(	const OTString &	strInput,
		const OTString *	pstrReason = nullptr,
		const OTPassword *	pImportPassword = nullptr
	)

Definition at line 294 of file OTKeypair.cpp.

{
    OT_ASSERT(strInput.Exists());

    // "escaped" means pre-pended with "- " as in:   - -----BEGIN CER....
    //
    const bool bPublic = LoadPublicKeyFromCertString(
        strInput, false, // bool bEscaped=true by default
        pstrReason, pImportPassword);
    const bool bPrivate = LoadPrivateKeyFromCertString(
        strInput, false, // bool bEscaped=true by default,
        pstrReason, pImportPassword);
    if (!bPublic) {
        otErr << __FUNCTION__
              << ": Although the input string apparently exists, "
                 "LoadPublicKeyFromCertString returned false.\n";
        return false;
    }
    else {
        otInfo << __FUNCTION__
               << ": Successfully loaded public key from string.\n";
    }

    if (!bPrivate) {
        otErr << __FUNCTION__
              << ": Although the input string apparently exists, "
                 "LoadPrivateKeyFromCertString returned false.\n";
        return false;
    }
    else {
        otInfo << __FUNCTION__
               << ": Successfully loaded private key from string.\n";
    }

    return true;
}

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

Definition at line 373 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    return m_pkeyPrivate->LoadPrivateKey(strFoldername, strFilename, pstrReason,
                                         pImportPassword);
}

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

Definition at line 396 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    return m_pkeyPrivate->LoadPrivateKeyFromCertString(
        strCert, bEscaped, pstrReason, pImportPassword);
}

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

Definition at line 384 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return m_pkeyPublic->LoadPublicKey(strFoldername, strFilename);
}

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

Definition at line 419 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return m_pkeyPublic->LoadPublicKeyFromCertFile(strFoldername, strFilename,
                                                   pstrReason, pImportPassword);
}

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

Definition at line 409 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return m_pkeyPublic->LoadPublicKeyFromCertString(
        strCert, bEscaped, pstrReason, pImportPassword);
}

bool opentxs::OTKeypair::MakeNewKeypair

(

int32_t

nBits = 1024

)

Definition at line 430 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);
    OT_ASSERT(nullptr != m_pkeyPublic);

    OTLowLevelKeyData lowLevelData;

    if (!lowLevelData.MakeNewKeypair(nBits)) {
        otErr << "OTKeypair::MakeNewKeypair"
              << ": Failed in a call to OTLowLevelKeyData::MakeNewKeypair("
              << nBits << ").\n";
        return false;
    }

    return lowLevelData.SetOntoKeypair(*this);

    // If true is returned:
    // Success! At this point, theKeypair's public and private keys have been
    // set.
    // Keep in mind though, they still won't be "quite right" until saved and
    // loaded
    // again, at least according to existing logic. That saving/reloading is
    // currently
    // performed in OTPseudonym::GenerateNym().
}

bool opentxs::OTKeypair::ReEncrypt	(	const OTPassword &	theExportPassword,
		bool	bImporting,
		OTString &	strOutput
	)

Definition at line 692 of file OTKeypair.cpp.

{

    OT_ASSERT(nullptr != m_pkeyPublic);
    OT_ASSERT(nullptr != m_pkeyPrivate);

    OT_ASSERT(HasPublicKey());
    OT_ASSERT(HasPrivateKey());

    // If we were importing, we were in the exported format but now we're in the
    // internal format.
    // Therefore we want to use the wallet's internal cached master passphrase
    // to save. Therefore
    // strReason will be used for the import case.
    //
    // But if we were exporting, then we were in the internal format and just
    // re-encrypted to the
    // export format. So we'd want to pass the export passphrase when saving.
    //
    const OTString strReasonAbove(
        bImporting ? "Enter the new export passphrase. (Above "
                     "ReEncryptPrivateKey in OTKeypair::ReEncrypt)"
                   : "Enter your wallet's master passphrase. (Above "
                     "ReEncryptPrivateKey in OTKeypair::ReEncrypt)");

    const OTString strReasonBelow(
        bImporting ? "Enter your wallet's master passphrase. (Below "
                     "ReEncryptPrivateKey in OTKeypair::ReEncrypt)"
                   : "Enter the new export passphrase. (Below "
                     "ReEncryptPrivateKey in OTKeypair::ReEncrypt)");

    // At this point the public key was loaded from a public key, not a cert,
    // but the private key was loaded from the cert. Therefore we'll save the
    // public cert from the private key, and then use that to reload the public
    // key after ReEncrypting. (Otherwise the public key would be there, but it
    // would be missing the x509, which is only available in the cert, not the
    // pubkey alone -- and without the x509 being there, the "SaveAndReload"
    // call
    // below would fail.
    // Why don't I just stick the Cert itself into the public data, instead of
    // sticking the public key in there? Because not all key credentials will
    // use
    // certs. Some will use pubkeys from certs, and some will use pubkeys not
    // from
    // certs. But I might still just stick it in there, and code things to be
    // able to
    // load either indiscriminately. After all, that's what I'm doing already in
    // the
    // asset and server contracts. But even in those cases, there will be times
    // when
    // only a pubkey is available, not a cert, so I'll probably still find
    // myself having
    // to do this. Hmm...

    const bool bReEncrypted = m_pkeyPrivate->ReEncryptPrivateKey(
        theExportPassword, bImporting); // <==== IMPORT or EXPORT occurs here.
    bool bGotCert = false;

    if (bReEncrypted) {

        // Keys won't be right until this happens. Todo: eliminate this need.
        bGotCert = SaveAndReloadBothKeysFromTempFile(
            &strOutput, &strReasonBelow,
            bImporting ? nullptr : &theExportPassword);
    }

    const bool bSuccess = (bReEncrypted && bGotCert);

    if (!bSuccess) {
        strOutput.Release();
        otErr << __FUNCTION__ << ": Failure, either when re-encrypting, or "
                                 "when subsequently retrieving "
                                 "the public/private keys. bImporting == "
              << (bImporting ? "true" : "false") << "\n";
    }

    return bSuccess;
}

bool opentxs::OTKeypair::SaveAndReloadBothKeysFromTempFile	(	OTString *	pstrOutputCert = nullptr,
		const OTString *	pstrReason = nullptr,
		const OTPassword *	pImportPassword = nullptr
	)

Definition at line 333 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);
    OT_ASSERT(nullptr != m_pkeyPublic);

    OTString strOutput;
    const bool bSuccess =
        SaveCertAndPrivateKeyToString(strOutput, pstrReason, pImportPassword);

    if (bSuccess) {
        // todo security. Revisit this part during security audit.
        //
        const OTString strFilename("temp.nym"); // todo stop hardcoding. Plus
                                                // this maybe should select a
                                                // random number too.

        if (!OTDB::StorePlainString(strOutput.Get(), OTFolders::Cert().Get(),
                                    strFilename.Get())) // temp.nym
        {
            otErr << __FUNCTION__
                  << ": Failure storing new cert in temp file: " << strFilename
                  << "\n";
            return false;
        }

        if (!LoadBothKeysFromCertFile(OTFolders::Cert().Get(), strFilename,
                                      pstrReason, pImportPassword))
            return false; // LoadBothKeysFromCertFile already has error logs, no
                          // need to log twice at this point.

        if (nullptr != pstrOutputCert)
            pstrOutputCert->Set(strOutput); // Success!
    }

    return bSuccess;
}

bool opentxs::OTKeypair::SaveCertAndPrivateKeyToString	(	OTString &	strOutput,
		const OTString *	pstrReason = nullptr,
		const OTPassword *	pImportPassword = nullptr
	)

Definition at line 277 of file OTKeypair.cpp.

{
    OTString strCert, strPrivateKey;

    const bool bSaved1 = SaveCertToString(strCert, pstrReason, pImportPassword);
    const bool bSaved2 =
        SavePrivateKeyToString(strPrivateKey, pstrReason, pImportPassword);

    if (bSaved1 && bSaved2)
        strOutput.Format(const_cast<char*>("%s%s"), strPrivateKey.Get(),
                         strCert.Get());

    return (bSaved1 && bSaved2);
}

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

Definition at line 243 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    OTString strCert,
        strReason(nullptr == pstrReason ? "OTKeypair::SaveCertToString"
                                        : pstrReason->Get());

    const bool bSaved =
        m_pkeyPublic->SaveCertToString(strCert, &strReason, pImportPassword);

    if (bSaved) strOutput = strCert;

    return bSaved;
}

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

Definition at line 261 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    OTString strPrivateKey;

    const bool bSaved = m_pkeyPrivate->SavePrivateKeyToString(
        strPrivateKey, pstrReason, pImportPassword);

    if (bSaved) strOutput = strPrivateKey;

    return bSaved;
}

void opentxs::OTKeypair::SetMetadata

(

const OTSignatureMetadata &

theMetadata

)

Definition at line 200 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);
    OT_ASSERT(nullptr != m_pkeyPrivate);
    OT_ASSERT(nullptr != m_pkeyPublic->m_pMetadata);
    OT_ASSERT(nullptr != m_pkeyPrivate->m_pMetadata);

    // Set it for both keys.
    //
    *(m_pkeyPublic->m_pMetadata) = theMetadata;
    *(m_pkeyPrivate->m_pMetadata) = theMetadata;
}

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

Definition at line 588 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    const char* szOverride = "PGP PRIVATE KEY";

    if (strKey.Contains(szOverride)) {
        OTASCIIArmor theArmor;

        if (theArmor.LoadFromString(const_cast<OTString&>(strKey), bEscaped,
                                    szOverride)) // szOverride == "PGP PRIVATE
                                                 // KEY"
        {
            // This function expects that the bookends are already removed.
            // The ascii-armor loading code removes them and handles the escapes
            // also.
            //            return
            // m_pkeyPrivate->LoadPrivateKeyFromPGPKey(theArmor);
            //
            otOut << "OTKeypair::SetPrivateKey 1: Failure: PGP private keys "
                     "are NOT YET SUPPORTED.\n\n";
            //            otOut << "OTKeypair::SetPrivateKey 1: Failure: PGP
            // private keys are NOT YET SUPPORTED:\n\n%s\n\n",
            //                           strKey.Get());
            return false;
        }
        else {
            otOut << "OTKeypair::SetPrivateKey 2: Failure: PGP private keys "
                     "are NOT YET SUPPORTED.\n\n";
            //            otOut << "OTKeypair::SetPrivateKey 2: Failure: PGP
            // private keys are NOT YET SUPPORTED:\n\n%s\n\n",
            //                           strKey.Get());
            return false;
        }
    }
    else // the below function SetPrivateKey (in the return call) expects the
        // bookends to still be there, and it will handle removing them. (Unlike
        // PGP code above.)
        //
        return m_pkeyPrivate->SetPrivateKey(strKey, bEscaped);
}

bool opentxs::OTKeypair::SetPrivateKey

(

const OTASCIIArmor &

strKey

)

Definition at line 630 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    return m_pkeyPrivate->SetPrivateKey(strKey);
}

bool opentxs::OTKeypair::SetPublicKey

(

const OTASCIIArmor &

strKey

)

Definition at line 526 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    return m_pkeyPublic->SetPublicKey(strKey);
}

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

Definition at line 538 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPublic);

    if (strKey.Contains("PGP PUBLIC KEY")) {
        OTASCIIArmor theArmor;

        if (theArmor.LoadFromString(const_cast<OTString&>(strKey), bEscaped)) {
            // This function expects that the bookends are already removed.
            // The ascii-armor loading code removes them and handles the escapes
            // also.
            return m_pkeyPublic->LoadPublicKeyFromPGPKey(theArmor);
        }
        else {
            otInfo << "OTKeypair::SetPublicKey: Failed extracting PGP public "
                      "key from ascii-armored text.\n";
            return false;
        }
    }
    else // the below function SetPublicKey (in the return call) expects the
        // bookends to still be there, and it will handle removing them. (Unlike
        // PGP code above.)
        return m_pkeyPublic->SetPublicKey(strKey, bEscaped);
}

bool opentxs::OTKeypair::SignContract	(	OTContract &	theContract,
		const OTPasswordData *	pPWData = nullptr
	)

Definition at line 494 of file OTKeypair.cpp.

{
    OT_ASSERT(nullptr != m_pkeyPrivate);

    return theContract.SignWithKey(*m_pkeyPrivate, pPWData);
}

Friends And Related Function Documentation

friend class OTLowLevelKeyData

friend

Definition at line 194 of file OTKeypair.hpp.

---

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

• /usr/local/src/opentxs/include/opentxs/core/crypto/OTKeypair.hpp
• /usr/local/src/opentxs/src/core/crypto/OTKeypair.cpp