opentxs::OTLowLevelKeyData Class Reference

#include <OTLowLevelKeyData.hpp>

Collaboration diagram for opentxs::OTLowLevelKeyData:

Classes
class	OTLowLevelKeyDataOpenSSLdp

Public Member Functions
bool	MakeNewKeypair (int32_t nBits=1024)
void	Cleanup ()
bool	SetOntoKeypair (OTKeypair &theKeypair)
	OTLowLevelKeyData ()
	~OTLowLevelKeyData ()

Public Attributes
bool	m_bCleanup
OTLowLevelKeyDataOpenSSLdp *	dp

Detailed Description

OTLowLevelKeyData Used for passing x509's and EVP_PKEYs around, so a replacement crypto engine will not require changes to any function parameters throughout the rest of OT.

Definition at line 186 of file OTLowLevelKeyData.hpp.

Constructor & Destructor Documentation

opentxs::OTLowLevelKeyData::OTLowLevelKeyData

(

)

Definition at line 171 of file OTLowLevelKeyData.cpp.

    : m_bCleanup(true)
{
    dp = new OTLowLevelKeyDataOpenSSLdp();
    dp->m_pX509 = nullptr;
    dp->m_pKey = nullptr;
}

opentxs::OTLowLevelKeyData::~OTLowLevelKeyData

(

)

Definition at line 163 of file OTLowLevelKeyData.cpp.

{
    if (m_bCleanup) Cleanup();
    if (nullptr != dp) delete (dp);
}

Member Function Documentation

void opentxs::OTLowLevelKeyData::Cleanup

(

)

Definition at line 183 of file OTLowLevelKeyData.cpp.

{
    if (nullptr != dp->m_pKey) EVP_PKEY_free(dp->m_pKey);
    dp->m_pKey = nullptr;
    if (nullptr != dp->m_pX509) X509_free(dp->m_pX509);
    dp->m_pX509 = nullptr;
}

bool opentxs::OTLowLevelKeyData::MakeNewKeypair

(

int32_t

nBits = 1024

)

Definition at line 191 of file OTLowLevelKeyData.cpp.

{

    //    OpenSSL_BIO        bio_err    =    nullptr;
    X509* x509 = nullptr;
    EVP_PKEY* pNewKey = nullptr;

    //    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); // memory leak detection.
    // Leaving this for now.
    //    bio_err    =    BIO_new_fp(stderr, BIO_NOCLOSE);

    // actually generate the things. // TODO THESE PARAMETERS...(mkcert)
    mkcert(&x509, &pNewKey, nBits, 0, 3650); // 3650=10 years. Todo hardcoded.
    // Note: 512 bit key CRASHES
    // 1024 is apparently a minimum requirement, if not an only requirement.
    // Will need to go over just what sorts of keys are involved here... todo.

    if (nullptr == x509) {
        otErr << __FUNCTION__
              << ": Failed attempting to generate new x509 cert.\n";

        if (nullptr != pNewKey) EVP_PKEY_free(pNewKey);
        pNewKey = nullptr;

        return false;
    }

    if (nullptr == pNewKey) {
        otErr << __FUNCTION__
              << ": Failed attempting to generate new private key.\n";

        if (nullptr != x509) X509_free(x509);
        x509 = nullptr;

        return false;
    }

    // Below this point, x509 and pNewKey will need to be cleaned up properly.

    if (m_bCleanup) Cleanup();

    m_bCleanup = true;
    dp->m_pKey = pNewKey;
    dp->m_pX509 = x509;

    // --------COMMENT THIS OUT FOR PRODUCTION --------  TODO security
    //                  (Debug only.)
    //    RSA_print_fp(stdout, pNewKey->pkey.rsa, 0); // human readable
    //    X509_print_fp(stdout, x509); // human readable

    // --------COMMENT THIS OUT FOR PRODUCTION --------  TODO security
    //                  (Debug only.)
    // write the private key, then the x509, to stdout.

    //    OTPasswordData thePWData2("OTPseudonym::GenerateNym is calling
    // PEM_write_PrivateKey...");
    //
    //    PEM_write_PrivateKey(stdout, pNewKey, EVP_des_ede3_cbc(), nullptr, 0,
    // OTAsymmetricKey::GetPasswordCallback(), &thePWData2);
    //    PEM_write_X509(stdout, x509);

    return true;
}

bool opentxs::OTLowLevelKeyData::SetOntoKeypair

(

OTKeypair &

theKeypair

)

Definition at line 255 of file OTLowLevelKeyData.cpp.

{
    OT_ASSERT(nullptr != dp->m_pKey);
    OT_ASSERT(nullptr != dp->m_pX509);

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

    // Since we are in OpenSSL-specific code, we have to make sure these are
    // OpenSSL-specific keys.
    //
    OTAsymmetricKey_OpenSSL* pPublicKey =
        dynamic_cast<OTAsymmetricKey_OpenSSL*>(theKeypair.m_pkeyPublic);
    OTAsymmetricKey_OpenSSL* pPrivateKey =
        dynamic_cast<OTAsymmetricKey_OpenSSL*>(theKeypair.m_pkeyPrivate);

    if (nullptr == pPublicKey) {
        otErr << __FUNCTION__ << ": dynamic_cast to OTAsymmetricKey_OpenSSL "
                                 "failed. (theKeypair.m_pkeyPublic)\n";
        return false;
    }
    if (nullptr == pPrivateKey) {
        otErr << __FUNCTION__ << ": dynamic_cast to OTAsymmetricKey_OpenSSL "
                                 "failed. (theKeypair.m_pkeyPrivate)\n";
        return false;
    }

    // Now we can call OpenSSL-specific methods on these keys...
    //
    pPublicKey->SetAsPublic();
    //  EVP_PKEY * pEVP_PubKey = X509_get_pubkey(m_pX509);
    //  OT_ASSERT(nullptr != pEVP_PubKey);
    //  pPublicKey-> SetKeyAsCopyOf(*pEVP_PubKey); // bool bIsPrivateKey=false
    // by default.
    pPublicKey->dp->SetKeyAsCopyOf(
        *dp->m_pKey); // bool bIsPrivateKey=false by default.
                      //  EVP_PKEY_free(pEVP_PubKey);
                      //  pEVP_PubKey = nullptr;

    pPublicKey->dp->SetX509(dp->m_pX509); // m_pX509 is now owned by pPublicKey.
                                          // (No need to free it in our own
                                          // destructor anymore.)
    dp->m_pX509 =
        nullptr; // pPublicKey took ownership, so we don't want to ALSO
                 // clean it up, since pPublicKey already will do so.

    pPrivateKey->SetAsPrivate();
    pPrivateKey->dp->SetKeyAsCopyOf(
        *dp->m_pKey, true); // bool bIsPrivateKey=true; (Default is false)
    // Since pPrivateKey only takes a COPY of m_pKey, we are still responsible
    // to clean up m_pKey in our own destructor.
    // (Assuming m_bCleanup is set to true, which is the default.) That's why
    // I'm NOT setting it to nullptr, as I did above
    // with m_pX509.

    EVP_PKEY_free(dp->m_pKey);
    dp->m_pKey = nullptr;

    // 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().
    //
    return true;
}

Member Data Documentation

OTLowLevelKeyDataOpenSSLdp* opentxs::OTLowLevelKeyData::dp

Definition at line 203 of file OTLowLevelKeyData.hpp.

bool opentxs::OTLowLevelKeyData::m_bCleanup

Definition at line 193 of file OTLowLevelKeyData.hpp.

---

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

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