#include <OTAsymmetricKey_OpenSSLPrivdp.hpp>

Collaboration diagram for opentxs::OTAsymmetricKey_OpenSSL::OTAsymmetricKey_OpenSSLPrivdp:

Public Member Functions
	OTAsymmetricKey_OpenSSLPrivdp ()

Static Public Member Functions
static bool	ArmorPrivateKey (EVP_PKEY &theKey, OTASCIIArmor &ascKey, Timer &theTimer, const OTPasswordData pPWData=nullptr, const OTPassword pImportPassword=nullptr)

static bool	ArmorPublicKey (EVP_PKEY &theKey, OTASCIIArmor &ascKey)

static EVP_PKEY *	CopyPublicKey (EVP_PKEY &theKey, const OTPasswordData pPWData=nullptr, const OTPassword pImportPassword=nullptr)

static EVP_PKEY *	CopyPrivateKey (EVP_PKEY &theKey, const OTPasswordData pPWData=nullptr, const OTPassword pImportPassword=nullptr)

Public Attributes
OTAsymmetricKey_OpenSSL *	backlink

Friends
class	OTAsymmetricKey

class	OTLowLevelKeyData

class	OTCrypto_OpenSSL

class	OTAsymmetricKey_OpenSSL

Detailed Description

Definition at line 152 of file OTAsymmetricKey_OpenSSLPrivdp.hpp.

Constructor & Destructor Documentation

opentxs::OTAsymmetricKey_OpenSSL::OTAsymmetricKey_OpenSSLPrivdp::OTAsymmetricKey_OpenSSLPrivdp ( )

inlineexplicit

Definition at line 165 of file OTAsymmetricKey_OpenSSLPrivdp.hpp.

         : backlink(0)
     {
     }

Member Function Documentation

bool opentxs::OTAsymmetricKey_OpenSSL::OTAsymmetricKey_OpenSSLPrivdp::ArmorPrivateKey	(	EVP_PKEY &	theKey,
		OTASCIIArmor &	ascKey,
		Timer &	theTimer,
		const OTPasswordData *	pPWData = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

static

Definition at line 727 of file OTAsymmetricKeyOpenSSLPrivdp.cpp.

 {
     bool bReturnVal = false;
 
     ascKey.Release();
 
     // Create a new memory buffer on the OpenSSL side
     OpenSSL_BIO bmem = BIO_new(BIO_s_mem());
     OT_ASSERT(nullptr != bmem);
 
     // write a private key to that buffer, from theKey
     //
     OTPasswordData thePWData("OTAsymmetricKey_OpenSSL::ArmorPrivateKey is "
                              "calling PEM_write_bio_PrivateKey...");
 
     if (nullptr == pPWData) pPWData = &thePWData;
 
     int32_t nWriteBio = 0;
 
     if (nullptr == pImportPassword)
         nWriteBio = PEM_write_bio_PrivateKey(
             bmem, &theKey,
             EVP_des_ede3_cbc(), // todo should this algorithm be hardcoded?
             nullptr, 0, OTAsymmetricKey::GetPasswordCallback(),
             const_cast<OTPasswordData*>(pPWData));
     else
         nWriteBio = PEM_write_bio_PrivateKey(
             bmem, &theKey,
             EVP_des_ede3_cbc(), // todo should this algorithm be hardcoded?
             nullptr, 0, 0, const_cast<void*>(reinterpret_cast<const void*>(
                                pImportPassword->getPassword())));
 
     if (0 == nWriteBio) {
         otErr << __FUNCTION__
               << ": Failed writing EVP_PKEY to memory buffer.\n";
     }
     else {
         // 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!
         //
 
         theTimer.start(); // Note: this isn't the ultimate timer solution. See
                           // notes in ReleaseKeyLowLevel.
 
         otLog5 << __FUNCTION__
                << ": Success writing EVP_PKEY to memory buffer.\n";
 
         OTPayload theData;
         char* pChar = nullptr;
 
         // After the below call, pChar will point to the memory buffer where the
         // private key supposedly is,
         // and lSize will contain the size of that memory.
         //
         int64_t lSize = BIO_get_mem_data(bmem, &pChar);
         uint32_t nSize = static_cast<uint32_t>(lSize);
 
         if (nSize > 0) {
             // Set the buffer size in our own memory.
             theData.SetPayloadSize(nSize);
 
             //            void * pv =
             OTPassword::safe_memcpy(
                 (static_cast<char*>(const_cast<void*>(
                     theData.GetPayloadPointer()))), // destination
                 theData.GetSize(), // size of destination buffer.
                 pChar,             // source
                 nSize);            // length of source.
             // bool bZeroSource=false); // if true, sets the source buffer to
             // zero after copying is done.
 
             // This base64 encodes the private key data, which
             // is already encrypted to its passphase as well.
             //
             ascKey.SetData(theData);
 
             otLog5 << __FUNCTION__
                    << ": Success copying private key into memory.\n";
             bReturnVal = true;
         }
         else {
             otErr << __FUNCTION__
                   << ": Failed copying private key into memory.\n";
         }
     }
 
     return bReturnVal;
 }

bool opentxs::OTAsymmetricKey_OpenSSL::OTAsymmetricKey_OpenSSLPrivdp::ArmorPublicKey	(	EVP_PKEY &	theKey,
		OTASCIIArmor &	ascKey
	)

static

Definition at line 512 of file OTAsymmetricKeyOpenSSLPrivdp.cpp.

 {
     bool bReturnVal = false;
 
     const char* szFunc = "OTAsymmetricKey_OpenSSL::ArmorPublicKey";
 
     ascKey.Release();
 
     // Create a new memory buffer on the OpenSSL side
     OpenSSL_BIO bmem = BIO_new(BIO_s_mem());
     OT_ASSERT_MSG(
         nullptr != bmem,
         "OTAsymmetricKey_OpenSSL::ArmorPublicKey: ASSERT: nullptr != bmem");
 
     // write a public key to that buffer, from theKey (parameter.)
     //
     int32_t nWriteBio = PEM_write_bio_PUBKEY(bmem, &theKey);
 
     if (0 == nWriteBio) {
         otErr << szFunc
               << ": Error: Failed writing EVP_PKEY to memory buffer.\n";
     }
     else {
         otLog5 << szFunc << ": Success writing EVP_PKEY to memory buffer.\n";
 
         OTPayload theData;
         char* pChar = nullptr;
 
         // After the below call, pChar will point to the memory buffer where the
         // public key
         // supposedly is, and lSize will contain the size of that memory.
         //
         int64_t lSize = BIO_get_mem_data(bmem, &pChar);
         uint32_t nSize = static_cast<uint32_t>(
             lSize); // todo security, etc. Fix this assumed type conversion.
 
         if (nSize > 0) {
             // Set the buffer size in our own memory.
             theData.SetPayloadSize(nSize);
 
             //            void * pv =
             OTPassword::safe_memcpy(
                 (static_cast<char*>(const_cast<void*>(
                     theData.GetPayloadPointer()))), // destination
                 theData.GetSize(), // size of destination buffer.
                 pChar,             // source
                 nSize);            // length of source.
             // bool bZeroSource=false); // if true, sets the source buffer to
             // zero after copying is done.
 
             // This base64 encodes the public key data
             //
             ascKey.SetData(theData);
 
             otLog5 << szFunc << ": Success copying public key into memory.\n";
             bReturnVal = true;
         }
         else {
             otErr << szFunc << ": Failed copying public key into memory.\n";
         }
     }
 
     return bReturnVal;
 }

EVP_PKEY * opentxs::OTAsymmetricKey_OpenSSL::OTAsymmetricKey_OpenSSLPrivdp::CopyPrivateKey	(	EVP_PKEY &	theKey,
		const OTPasswordData *	pPWData = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

static

Definition at line 390 of file OTAsymmetricKeyOpenSSLPrivdp.cpp.

 {
     const EVP_CIPHER* pCipher =
         EVP_des_ede3_cbc(); // todo should this algorithm be hardcoded?
 
     // Create a new memory buffer on the OpenSSL side
     OpenSSL_BIO bmem = BIO_new(BIO_s_mem());
     OT_ASSERT(nullptr != bmem);
 
     EVP_PKEY* pReturnKey = nullptr;
 
     // write a private key to that buffer, from theKey
     //
     OTPasswordData thePWDataWrite("OTAsymmetricKey_OpenSSL::CopyPrivateKey is "
                                   "calling PEM_write_bio_PrivateKey...");
 
     // todo optimization: might just remove the password callback here, and just
     // write the private key in the clear,
     // and then load it up again, saving the encrypt/decrypt step that otherwise
     // occurs, and then as long as we OpenSSL_cleanse
     // the BIO, then it SHOULD stil be safe, right?
     //
     int32_t nWriteBio = false;
 
     if (nullptr == pImportPassword)
         nWriteBio = PEM_write_bio_PrivateKey(
             bmem, &theKey, pCipher, nullptr, 0,
             OTAsymmetricKey::GetPasswordCallback(),
             nullptr == pPWData ? &thePWDataWrite
                                : const_cast<OTPasswordData*>(pPWData));
     else
         nWriteBio = PEM_write_bio_PrivateKey(
             bmem, &theKey, pCipher, nullptr, 0, 0,
             const_cast<void*>(
                 reinterpret_cast<const void*>(pImportPassword->getPassword())));
 
     if (0 == nWriteBio) {
         otErr << __FUNCTION__
               << ": Failed writing EVP_PKEY to memory buffer.\n";
     }
     else {
         otLog5 << __FUNCTION__
                << ": Success writing EVP_PKEY to memory buffer.\n";
 
         char* pChar = nullptr;
 
         // After the below call, pChar will point to the memory buffer where the
         // private key supposedly is,
         // and lSize will contain the size of that memory.
         //
         const int64_t lSize = BIO_get_mem_data(bmem, &pChar);
         const uint32_t nSize = static_cast<uint32_t>(lSize);
 
         if (nSize > 0) {
             OTPayload theData;
 
             // Set the buffer size in our own memory.
             theData.SetPayloadSize(nSize);
 
             void* pv = OTPassword::safe_memcpy(
                 (static_cast<char*>(const_cast<void*>(
                     theData.GetPayloadPointer()))), // destination
                 theData.GetSize(), // size of destination buffer.
                 pChar,             // source
                 nSize);            // length of source.
             // bool bZeroSource=false); // if true, sets the source buffer to
             // zero after copying is done.
 
             if (nullptr != pv) {
 
                 // Next, copy theData's contents into a new BIO_mem_buf,
                 // so OpenSSL can load the key out of it.
                 //
                 OpenSSL_BIO keyBio =
                     BIO_new_mem_buf(static_cast<char*>(const_cast<void*>(
                                         theData.GetPayloadPointer())),
                                     theData.GetSize());
                 OT_ASSERT_MSG(nullptr != keyBio,
                               "OTAsymmetricKey_OpenSSL::"
                               "CopyPrivateKey: Assert: nullptr != "
                               "keyBio \n");
 
                 // Next we load up the key from the BIO string into an
                 // instantiated key object.
                 //
                 OTPasswordData thePWData("OTAsymmetricKey_OpenSSL::"
                                          "CopyPrivateKey is calling "
                                          "PEM_read_bio_PUBKEY...");
 
                 if (nullptr == pImportPassword)
                     pReturnKey = PEM_read_bio_PrivateKey(
                         keyBio, nullptr, OTAsymmetricKey::GetPasswordCallback(),
                         nullptr == pPWData
                             ? &thePWData
                             : const_cast<OTPasswordData*>(pPWData));
                 else
                     pReturnKey = PEM_read_bio_PrivateKey(
                         keyBio, nullptr, 0,
                         const_cast<void*>(reinterpret_cast<const void*>(
                             pImportPassword->getPassword())));
 
             }
             else
                 otErr << __FUNCTION__ << ": Error: Failed copying memory from "
                                          "BIO into OTPayload.\n";
 
         }
         else {
             otErr << __FUNCTION__
                   << ": Failed copying private key into memory.\n";
         }
     }
 
     return pReturnKey;
 }

EVP_PKEY * opentxs::OTAsymmetricKey_OpenSSL::OTAsymmetricKey_OpenSSLPrivdp::CopyPublicKey	(	EVP_PKEY &	theKey,
		const OTPasswordData *	pPWData = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

static

Definition at line 273 of file OTAsymmetricKeyOpenSSLPrivdp.cpp.

 {
     // Create a new memory buffer on the OpenSSL side
     OpenSSL_BIO bmem = BIO_new(BIO_s_mem());
     OT_ASSERT_MSG(
         nullptr != bmem,
         "OTAsymmetricKey_OpenSSL::CopyPublicKey: ASSERT: nullptr != bmem");
 
     EVP_PKEY* pReturnKey = nullptr;
 
     // write a public key to that buffer, from theKey (parameter.)
     //
     int32_t nWriteBio = PEM_write_bio_PUBKEY(bmem, &theKey);
 
     if (0 == nWriteBio) {
         otErr << __FUNCTION__
               << ": Error: Failed writing EVP_PKEY to memory buffer.\n";
     }
     else {
         otLog5 << __FUNCTION__
                << ": Success writing EVP_PKEY to memory buffer.\n";
 
         char* pChar = nullptr;
 
         // After the below call, pChar will point to the memory buffer where the
         // public key
         // supposedly is, and lSize will contain the size of that memory.
         //
         const int64_t lSize = BIO_get_mem_data(bmem, &pChar);
         const uint32_t nSize = static_cast<uint32_t>(lSize);
 
         if (nSize > 0) {
             OTPayload theData;
 
             // Set the buffer size in our own memory.
             theData.SetPayloadSize(nSize);
 
             void* pv = OTPassword::safe_memcpy(
                 (static_cast<char*>(const_cast<void*>(
                     theData.GetPayloadPointer()))), // destination
                 theData.GetSize(), // size of destination buffer.
                 pChar,             // source
                 nSize);            // length of source.
 
             if (nullptr != pv) {
                 // Next, copy theData's contents into a new BIO_mem_buf,
                 // so OpenSSL can load the key out of it.
                 //
                 OpenSSL_BIO keyBio =
                     BIO_new_mem_buf(static_cast<char*>(const_cast<void*>(
                                         theData.GetPayloadPointer())),
                                     theData.GetSize());
                 OT_ASSERT_MSG(nullptr != keyBio,
                               "OTAsymmetricKey_OpenSSL::"
                               "CopyPublicKey: Assert: nullptr != "
                               "keyBio \n");
 
                 // Next we load up the key from the BIO string into an
                 // instantiated key object.
                 //
                 OTPasswordData thePWData(
                     nullptr == pImportPassword
                         ? "Enter your wallet master passphrase. "
                           "(OTAsymmetricKey_OpenSSL::CopyPublicKey is calling "
                           "PEM_read_bio_PUBKEY...)"
                         : "Enter the passphrase for your exported Nym.");
 
                 if (nullptr == pImportPassword)
                     pReturnKey = PEM_read_bio_PUBKEY(
                         keyBio, nullptr, OTAsymmetricKey::GetPasswordCallback(),
                         nullptr == pPWData
                             ? &thePWData
                             : const_cast<OTPasswordData*>(pPWData));
                 else
                     pReturnKey = PEM_read_bio_PUBKEY(
                         keyBio, nullptr, 0,
                         const_cast<OTPassword*>(pImportPassword));
 
                 // We don't need the BIO anymore.
                 // Free the BIO and related buffers, filters, etc. (auto with
                 // scope).
                 //
             }
             else {
                 otErr << __FUNCTION__ << ": Error: Failed copying memory from "
                                          "BIO into OTPayload.\n";
             }
         }
         else {
             otErr << __FUNCTION__
                   << ": Failed copying private key into memory.\n";
         }
     }
 
     return pReturnKey;
 }