opentxs::OTNym_or_SymmetricKey Class Reference

#include <OTNymOrSymmetricKey.hpp>

Public Member Functions
EXPORT OTPseudonym *	GetNym () const
EXPORT OTSymmetricKey *	GetKey () const
EXPORT OTPassword *	GetPassword () const
EXPORT bool	IsNym () const
EXPORT bool	IsKey () const
EXPORT bool	HasPassword () const
EXPORT void	GetIdentifier (OTIdentifier &theIdentifier) const
EXPORT void	GetIdentifier (OTString &strIdentifier) const
EXPORT bool	CompareID (const OTNym_or_SymmetricKey &rhs) const
EXPORT bool	Seal_or_Encrypt (OTEnvelope &outputEnvelope, const OTString &strInput, const OTString *pstrDisplay=nullptr)
EXPORT bool	Open_or_Decrypt (const OTEnvelope &inputEnvelope, OTString &strOutput, const OTString *pstrDisplay=nullptr)
EXPORT	~OTNym_or_SymmetricKey ()
EXPORT	OTNym_or_SymmetricKey (const OTNym_or_SymmetricKey &rhs)
EXPORT	OTNym_or_SymmetricKey (const OTPseudonym &theNym, const OTString *pstrDisplay=nullptr)
EXPORT	OTNym_or_SymmetricKey (const OTSymmetricKey &theKey, const OTString *pstrDisplay=nullptr)
EXPORT	OTNym_or_SymmetricKey (const OTSymmetricKey &theKey, const OTPassword &thePassword, const OTString *pstrDisplay=nullptr)
EXPORT void	swap (OTNym_or_SymmetricKey &other)
EXPORT OTNym_or_SymmetricKey &	operator= (OTNym_or_SymmetricKey other)
EXPORT void	Release ()
EXPORT void	Release_Nym_or_SymmetricKey ()

Detailed Description

Definition at line 150 of file OTNymOrSymmetricKey.hpp.

Constructor & Destructor Documentation

opentxs::OTNym_or_SymmetricKey::~OTNym_or_SymmetricKey

(

)

Definition at line 166 of file OTNymOrSymmetricKey.cpp.

{
    // We don't own these objects.
    // Rather, we own a pointer to ONE of them, since we are a wrapper
    // for this one or that.
    //
    m_pNym = nullptr;

    m_pKey = nullptr;

    if (m_bCleanupPassword && (nullptr != m_pPassword)) delete m_pPassword;
    m_pPassword = nullptr; // optional

    m_pstrDisplay = nullptr;

    // Since this is merely a wrapper class, we don't even Release() these
    // things.
    // However, we DO have a release function, since the programmatic USER of
    // this class
    // MAY wish to Release() whatever it is wrapping. That's his choice. But we
    // don't call
    // it here in the destructor, because we aren't the owner.
    //
    //  Release_Nym_or_SymmetricKey();
}

opentxs::OTNym_or_SymmetricKey::OTNym_or_SymmetricKey

(

const OTNym_or_SymmetricKey &

rhs

)

Definition at line 192 of file OTNymOrSymmetricKey.cpp.

    : m_pNym(nullptr),
      m_pKey(nullptr),
      m_pPassword(nullptr),
      m_bCleanupPassword(false),
      m_pstrDisplay(rhs.m_pstrDisplay)
{
    // This class doesn't do any cleanup, it's just a temporary wrapper.
    // So we won't have anything get deleted twice, because this class won't
    // even delete it once.
    //
    m_pNym = rhs.m_pNym;

    m_pKey = rhs.m_pKey;
    m_pPassword = rhs.m_pPassword; // optional

    // m_bCleanupPassword  = rhs.m_bCleanupPassword; // optional
    //
    // This is commented out because this object keeps a POINTER to the
    // password,
    // which is usually owned by the caller. (So we normally wouldn't delete
    // it.)
    // But sometimes, we have to CREATE the password, in which case we store it
    // until
    // we destruct, and then destroy it in our destructor. (Having it available
    // in the
    // meantime to use, without having to load again.)
    // m_bCleanupPassword thus normally tells us whether the password was passed
    // in
    // by its owner for reference purposes only, or whether we created it
    // internally and
    // thus need to clean it up ourselves.
    // THEREFORE, here in the COPY CONSTRUCTOR, we need to keep a pointer to the
    // password
    // from the rhs object, in case we need that password, but we cannot DESTROY
    // that password,
    // if rhs is also destroying it! Therefore we copy the password, but we
    // leave m_bCleanupPassword
    // as false (its default) since THIS INSTANCE definitely does not own
    // m_pPassword.
    //
}

opentxs::OTNym_or_SymmetricKey::OTNym_or_SymmetricKey	(	const OTPseudonym &	theNym,
		const OTString *	pstrDisplay = nullptr
	)

Definition at line 236 of file OTNymOrSymmetricKey.cpp.

    : m_pNym(const_cast<OTPseudonym*>(&theNym)),
      m_pKey(nullptr),
      m_pPassword(nullptr),
      m_bCleanupPassword(false),
      m_pstrDisplay(pstrDisplay)
{
}

opentxs::OTNym_or_SymmetricKey::OTNym_or_SymmetricKey	(	const OTSymmetricKey &	theKey,
		const OTString *	pstrDisplay = nullptr
	)

Definition at line 247 of file OTNymOrSymmetricKey.cpp.

    : m_pNym(nullptr),
      m_pKey(const_cast<OTSymmetricKey*>(&theKey)),
      m_pPassword(nullptr),
      m_bCleanupPassword(false),
      m_pstrDisplay(pstrDisplay)
{
}

opentxs::OTNym_or_SymmetricKey::OTNym_or_SymmetricKey	(	const OTSymmetricKey &	theKey,
		const OTPassword &	thePassword,
		const OTString *	pstrDisplay = nullptr
	)

Definition at line 258 of file OTNymOrSymmetricKey.cpp.

    : m_pNym(nullptr)
    , m_pKey(const_cast<OTSymmetricKey*>(&theKey))
    , m_pPassword(const_cast<OTPassword*>(&thePassword))
    , m_bCleanupPassword(false)
    , m_pstrDisplay(pstrDisplay)
{
}

Member Function Documentation

bool opentxs::OTNym_or_SymmetricKey::CompareID

(

const OTNym_or_SymmetricKey &

rhs

)

const

Definition at line 327 of file OTNymOrSymmetricKey.cpp.

{
    OTIdentifier idTHIS, idRHS;

    GetIdentifier(idTHIS);
    rhs.GetIdentifier(idRHS);

    return (idTHIS == idRHS);
}

void opentxs::OTNym_or_SymmetricKey::GetIdentifier

(

OTIdentifier &

theIdentifier

)

const

Definition at line 337 of file OTNymOrSymmetricKey.cpp.

{
    if (IsNym()) {
        m_pNym->GetIdentifier(theIdentifier);
    }
    else if (IsKey()) {
        m_pKey->GetIdentifier(theIdentifier);
    }
    else {
        OT_FAIL; // should never happen
    }
}

void opentxs::OTNym_or_SymmetricKey::GetIdentifier

(

OTString &

strIdentifier

)

const

Definition at line 350 of file OTNymOrSymmetricKey.cpp.

{
    if (IsNym()) {
        m_pNym->GetIdentifier(strIdentifier);
    }
    else if (IsKey()) {
        m_pKey->GetIdentifier(strIdentifier);
    }
    else {
        OT_FAIL; // should never happen
    }
}

EXPORT OTSymmetricKey* opentxs::OTNym_or_SymmetricKey::GetKey ( ) const

inline

Definition at line 175 of file OTNymOrSymmetricKey.hpp.

    {
        return m_pKey;
    }

EXPORT OTPseudonym* opentxs::OTNym_or_SymmetricKey::GetNym ( ) const

inline

Definition at line 171 of file OTNymOrSymmetricKey.hpp.

    {
        return m_pNym;
    }

EXPORT OTPassword* opentxs::OTNym_or_SymmetricKey::GetPassword ( ) const

inline

Definition at line 179 of file OTNymOrSymmetricKey.hpp.

    {
        return m_pPassword;
    } // for symmetric key (optional)

EXPORT bool opentxs::OTNym_or_SymmetricKey::HasPassword ( ) const

inline

Definition at line 192 of file OTNymOrSymmetricKey.hpp.

    {
        return (nullptr != m_pPassword);
    } // for symmetric key (optional)

EXPORT bool opentxs::OTNym_or_SymmetricKey::IsKey ( ) const

inline

Definition at line 188 of file OTNymOrSymmetricKey.hpp.

    {
        return (nullptr != m_pKey);
    }

EXPORT bool opentxs::OTNym_or_SymmetricKey::IsNym ( ) const

inline

Definition at line 184 of file OTNymOrSymmetricKey.hpp.

    {
        return (nullptr != m_pNym);
    }

bool opentxs::OTNym_or_SymmetricKey::Open_or_Decrypt	(	const OTEnvelope &	inputEnvelope,
		OTString &	strOutput,
		const OTString *	pstrDisplay = nullptr
	)

Definition at line 369 of file OTNymOrSymmetricKey.cpp.

{
    const char* szFunc = "OTNym_or_SymmetricKey::Open_or_Decrypt";

    bool bSuccess = false;
    bool bHadToInstantiatePassword = false;

    // Decrypt/Open inputEnvelope into strOutput
    //
    if (IsNym()) // *this is a Nym.
    {
        bSuccess = (const_cast<OTEnvelope&>(inputEnvelope))
                       .Open(*(GetNym()), strOutput);
    }
    else if (IsKey()) // *this is a symmetric key, possibly with a
                        // password already as well.
    {
        OTPassword* pPassword = nullptr;

        if (HasPassword()) // Password is already available. Let's use it.
            pPassword = GetPassword();
        else // NO PASSWORD already? let's collect it from the user...
        {
            const OTString strDisplay(
                (nullptr == pstrDisplay) ? szFunc : pstrDisplay->Get());
            // NOTE: m_pstrDisplay overrides this below.

            // returns a text OTPassword, or nullptr.
            //
            pPassword = OTSymmetricKey::GetPassphraseFromUser(
                (nullptr == m_pstrDisplay)
                    ? &strDisplay
                    : m_pstrDisplay); // bool bAskTwice=false

            if (nullptr ==
                pPassword) // Unable to retrieve passphrase from user.
            {
                otOut << szFunc
                      << ": Failed trying to retrieve passphrase for key. "
                         "Returning false.\n";
                return false;
            }
            else // OTNym_or_SymmetricKey stores this, if it creates it.
                   // (And cleans it up on destruction, IF it created it.)
                   //
                bHadToInstantiatePassword = true;
        }

        bSuccess = (const_cast<OTEnvelope&>(inputEnvelope))
                       .Decrypt(strOutput, *(GetKey()), *pPassword);

        // We only set this, presuming we have to at all, if it was a success.
        if (bHadToInstantiatePassword) {
            if (bSuccess) {
                m_bCleanupPassword = true;
                m_pPassword = pPassword; // Not bothering to cleanup whatever
                                         // was here before, since we only end
                                         // up here if m_pPassword was set to
                // nullptr (according to above logic...)
            }
            else // We instantiated the password, but the decrypt failed.
                   // (Need to cleanup the password then.)
            {
                delete pPassword;
                pPassword = nullptr;
            }
        }
    }
    // else ? should never happen.

    return bSuccess;
}

OTNym_or_SymmetricKey & opentxs::OTNym_or_SymmetricKey::operator=

(

OTNym_or_SymmetricKey

other

)

Definition at line 281 of file OTNymOrSymmetricKey.cpp.

{
    // swap this with other
    swap(other);

    // by convention, always return *this
    return *this;
}

void opentxs::OTNym_or_SymmetricKey::Release

(

)

Definition at line 292 of file OTNymOrSymmetricKey.cpp.

{
    OT_ASSERT((m_pNym != nullptr) ||
              (m_pKey != nullptr)); // m_pPassword is optional

    Release_Nym_or_SymmetricKey();

    // no need to call ot_super::Release here, since this class has no
    // superclass.
}

void opentxs::OTNym_or_SymmetricKey::Release_Nym_or_SymmetricKey

(

)

Definition at line 306 of file OTNymOrSymmetricKey.cpp.

{
    if (nullptr != m_pNym) {
        //      m_pNym->Release(); // no such call on OTPseudonym. (Otherwise it
        // wouldn't be commented out.)
    }

    if (nullptr != m_pKey) m_pKey->Release();

    if (nullptr != m_pPassword) {
        m_pPassword->zeroMemory();

        if (m_bCleanupPassword) // Only in cases where *this is the actual owner
                                // of m_pPassword.
        {
            delete m_pPassword;
            m_pPassword = nullptr;
        }
    }
}

bool opentxs::OTNym_or_SymmetricKey::Seal_or_Encrypt	(	OTEnvelope &	outputEnvelope,
		const OTString &	strInput,
		const OTString *	pstrDisplay = nullptr
	)

Definition at line 444 of file OTNymOrSymmetricKey.cpp.

{
    const char* szFunc = "OTNym_or_SymmetricKey::Seal_or_Encrypt";

    bool bSuccess = false;
    bool bHadToInstantiatePassword = false;

    // Encrypt/Seal strInput into outputEnvelope
    //
    if (IsNym()) {
        bSuccess = outputEnvelope.Seal(*(GetNym()), strInput);
    }
    else if (IsKey()) {
        OTPassword* pPassword = nullptr;

        if (HasPassword()) // Password is already available. Let's use it.
            pPassword = GetPassword();
        else // no password? let's collect it from the user...
        {
            const OTString strDisplay(
                (nullptr == pstrDisplay) ? szFunc : pstrDisplay->Get());
            // NOTE: m_pstrDisplay overrides this below.

            // returns a text OTPassword, or nullptr.
            //
            pPassword = OTSymmetricKey::GetPassphraseFromUser(
                (nullptr == m_pstrDisplay)
                    ? &strDisplay
                    : m_pstrDisplay); // bool bAskTwice=false

            if (nullptr ==
                pPassword) // Unable to retrieve passphrase from user.
            {
                otOut << szFunc
                      << ": Failed trying to retrieve passphrase for key. "
                         "Returning false.\n";
                return false;
            }
            else // OTNym_or_SymmetricKey stores this, if it creates it.
                   // (And cleans it up on destruction, IF it created it.)
                   //
                bHadToInstantiatePassword = true;
        }

        bSuccess = outputEnvelope.Encrypt(strInput, *(GetKey()), *pPassword);

        // We only set this, presuming we have to at all, if it was a success.
        if (bHadToInstantiatePassword) {
            if (bSuccess) {
                m_bCleanupPassword = true;
                m_pPassword = pPassword; // Not bothering to cleanup whatever
                                         // was here before, since we only end
                                         // up here if m_pPassword was set to
                // nullptr (according to above logic...)
            }
            else // We instantiated the password, but the encrypt failed.
                   // (Need to cleanup the password then.)
            {
                delete pPassword;
                pPassword = nullptr;
            }
        }
    }
    // else ? should never happen.

    return bSuccess;
}

void opentxs::OTNym_or_SymmetricKey::swap

(

OTNym_or_SymmetricKey &

other

)

Definition at line 270 of file OTNymOrSymmetricKey.cpp.

{
    if (&other != this) {
        std::swap(m_pNym, other.m_pNym);
        std::swap(m_pKey, other.m_pKey);
        std::swap(m_pPassword, other.m_pPassword);
        std::swap(m_bCleanupPassword, other.m_bCleanupPassword);
        std::swap(m_pstrDisplay, other.m_pstrDisplay);
    }
}

---

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

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