opentxs::OTCredential Class Reference

#include <OTCredential.hpp>

Public Member Functions
EXPORT const OTPassword *	GetImportPassword () const
EXPORT void	SetImportPassword (const OTPassword *pImportPassword)
EXPORT bool	Load_Master (const OTString &strNymID, const OTString &strMasterCredID, const OTPasswordData *pPWData=nullptr)
EXPORT bool	Load_MasterFromString (const OTString &strInput, const OTString &strNymID, const OTString &strMasterCredID, const OTPasswordData *pPWData=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT bool	AddNewSubkey (int32_t nBits=1024, const OTString::Map *pmapPrivate=nullptr, const OTPasswordData *pPWData=nullptr, OTSubkey **ppSubkey=nullptr)
EXPORT bool	AddNewSubcredential (const OTString::Map &mapPrivate, const OTString::Map &mapPublic, const OTPasswordData *pPWData=nullptr, OTSubcredential **ppSubcred=nullptr)
EXPORT bool	ReEncryptPrivateCredentials (const OTPassword &theExportPassword, bool bImporting)
EXPORT bool	LoadSubkey (const OTString &strSubID)
EXPORT bool	LoadSubcredential (const OTString &strSubID)
EXPORT bool	LoadSubkeyFromString (const OTString &strInput, const OTString &strSubID, const OTPassword *pImportPassword=nullptr)
EXPORT bool	LoadSubcredentialFromString (const OTString &strInput, const OTString &strSubID, const OTPassword *pImportPassword=nullptr)
EXPORT size_t	GetSubcredentialCount () const
EXPORT const OTSubcredential *	GetSubcredential (const OTString &strSubID, const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTSubcredential *	GetSubcredentialByIndex (int32_t nIndex) const
EXPORT const std::string	GetSubcredentialIDByIndex (size_t nIndex) const
EXPORT const OTString &	GetPubCredential () const
EXPORT const OTString &	GetPriCredential () const
EXPORT const OTString &	GetMasterCredID () const
EXPORT const OTString &	GetNymID () const
EXPORT const OTString &	GetSourceForNymID () const
EXPORT void	SerializeIDs (OTString &strOutput, const OTString::List &listRevokedIDs, OTString::Map *pmapPubInfo=nullptr, OTString::Map *pmapPriInfo=nullptr, bool bShowRevoked=false, bool bValid=true) const
EXPORT bool	VerifyInternally () const
EXPORT bool	VerifyAgainstSource () const
EXPORT const OTMasterkey &	GetMasterkey () const
EXPORT int32_t	GetPublicKeysBySignature (listOfAsymmetricKeys &listOutput, const OTSignature &theSignature, char cKeyType= '0') const
EXPORT const OTAsymmetricKey &	GetPublicAuthKey (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTAsymmetricKey &	GetPublicEncrKey (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTAsymmetricKey &	GetPublicSignKey (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTAsymmetricKey &	GetPrivateSignKey (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTAsymmetricKey &	GetPrivateEncrKey (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTAsymmetricKey &	GetPrivateAuthKey (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTKeypair &	GetAuthKeypair (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTKeypair &	GetEncrKeypair (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT const OTKeypair &	GetSignKeypair (const OTString::List *plistRevokedIDs=nullptr) const
EXPORT void	ClearSubcredentials ()
EXPORT	~OTCredential ()

Static Public Member Functions
static OTCredential *	CreateMaster (const OTString &strSourceForNymID, int32_t nBits=1024, const OTString::Map *pmapPrivate=nullptr, const OTString::Map *pmapPublic=nullptr, const OTPasswordData *pPWData=nullptr)
static OTCredential *	LoadMaster (const OTString &strNymID, const OTString &strMasterCredID, const OTPasswordData *pPWData=nullptr)
static OTCredential *	LoadMasterFromString (const OTString &strInput, const OTString &strNymID, const OTString &strMasterCredID, OTPasswordData *pPWData=nullptr, const OTPassword *pImportPassword=nullptr)

Detailed Description

Definition at line 217 of file OTCredential.hpp.

Constructor & Destructor Documentation

opentxs::OTCredential::~OTCredential

(

)

Definition at line 1523 of file OTCredential.cpp.

{
    ClearSubcredentials();
}

Member Function Documentation

bool opentxs::OTCredential::AddNewSubcredential	(	const OTString::Map &	mapPrivate,
		const OTString::Map &	mapPublic,
		const OTPasswordData *	pPWData = nullptr,
		OTSubcredential **	ppSubcred = nullptr
	)

Definition at line 1110 of file OTCredential.cpp.

{
    OTSubcredential* pSub = new OTSubcredential(*this);
    OT_ASSERT(nullptr != pSub);

    pSub->SetNymIDandSource(m_strNymID, m_strSourceForNymID); // Set NymID and
                                                              // source string
                                                              // that hashes to
                                                              // it.
    pSub->SetMasterCredID(GetMasterCredID()); // Set master credential ID
                                              // (onto this new
                                              // subcredential...)

    if (!pSub->SetPublicContents(mapPublic)) {
        otErr << "In " << __FILE__ << ", line " << __LINE__
              << ": Failed while calling pSub->SetPublicContents.\n";
        delete pSub;
        pSub = nullptr;
        return false;
    }
    else if (!pSub->SetPrivateContents(mapPrivate)) {
        otErr << "In " << __FILE__ << ", line " << __LINE__
              << ": Failed while trying to pSub->SetPrivateContents.\n";
        delete pSub;
        pSub = nullptr;
        return false;
    }
    else // By this point we've set up the subcredential with its NymID, the
           // source string for that NymID,
    { // my master credential ID, and the public and private contents for the
        // subcredential. Let's sign
        // it...
        OTPasswordData thePWData(
            "Signing new subcredential... OTCredential::AddNewSubcredential");
        OTIdentifier theSubCredID;

        // SignNewSubcredential uses m_Masterkey's actual signing key to sign
        // "pSub the contract."
        //
        if (false ==
            SignNewSubcredential(*pSub, theSubCredID,
                                 nullptr == pPWData ? &thePWData : pPWData)) {
            otErr << "In " << __FILE__ << ", line " << __LINE__
                  << ": Failed trying to call SignNewSubcredential\n";
            delete pSub;
            pSub = nullptr;
            return false;
        }

        const OTString strSubCredID(theSubCredID);

        // ADD IT TO THE MAP
        // Only after pSub is signed and saved can we then calculate its ID and
        // use that ID
        // as the key in m_mapSubcredentials (with pSub being the value.)
        //
        m_mapSubcredentials.insert(
            std::pair<std::string, OTSubcredential*>(strSubCredID.Get(), pSub));
        if (nullptr != ppSubcred) // output
            *ppSubcred = pSub;
        return true;
    }
}

bool opentxs::OTCredential::AddNewSubkey	(	int32_t	nBits = 1024,
		const OTString::Map *	pmapPrivate = nullptr,
		const OTPasswordData *	pPWData = nullptr,
		OTSubkey **	ppSubkey = nullptr
	)

Definition at line 1026 of file OTCredential.cpp.

{
    OTSubkey* pSub = new OTSubkey(*this);
    OT_ASSERT(nullptr != pSub);

    pSub->SetNymIDandSource(GetNymID(),
                            GetSourceForNymID()); // Set NymID and source
                                                  // string that hashes to
                                                  // it.
    pSub->SetMasterCredID(GetMasterCredID());     // Set master credential ID
                                                  // (onto this new
                                                  // subcredential...)

    // If a map of private certs was not passed in, we're expected to
    // generate the keys ourselves.
    //
    bool bContentsReady = false;

    if (nullptr !=
        pmapPrivate) // Pre-generated keys were passed in for us to use,
        bContentsReady = pSub->SetPrivateContents(
            *pmapPrivate); // so let's set them onto the sub key.
    else
        // No keys were provided, so let's generate them ourselves...
        bContentsReady = pSub->GenerateKeys(nBits);

    if (!bContentsReady) {
        otErr << "In " << __FILE__ << ", line " << __LINE__
              << ": Failed trying to SetPrivateContents or GenerateKeys\n";
        delete pSub;
        pSub = nullptr;
        return false;
    }
    else // By this point we've set up the subkey with its NymID, the source
           // string for that NymID,
    {      // my master credential ID, and the public and private certs for the
           // subkey. Now let's
           // sign it...
        OTPasswordData thePWData(
            "Signing new subkey... OTCredential::AddNewSubkey");
        OTIdentifier theSubCredID;

        // SignNewSubcredential uses m_Masterkey's actual signing key to sign
        // "pSub the contract."
        //
        if (false ==
            SignNewSubcredential(*pSub, theSubCredID,
                                 nullptr == pPWData ? &thePWData : pPWData)) {
            otErr << "In " << __FILE__ << ", line " << __LINE__
                  << ": Failed trying to call SignNewSubcredential\n";
            delete pSub;
            pSub = nullptr;
            return false;
        }

        const OTString strSubCredID(
            theSubCredID); // SignNewSubcredential also generates the ID.

        pSub->SetMetadata();

        // ADD IT TO THE MAP
        // Only after pSub is signed and saved can we then calculate its ID and
        // use that ID
        // as the key in m_mapSubcredentials (with pSub being the value.)
        //
        m_mapSubcredentials.insert(
            std::pair<std::string, OTSubcredential*>(strSubCredID.Get(), pSub));

        if (nullptr != ppSubkey) // output
        {
            *ppSubkey = pSub;
        }

        return true;
    }
}

void opentxs::OTCredential::ClearSubcredentials

(

)

Definition at line 1528 of file OTCredential.cpp.

{

    while (!m_mapSubcredentials.empty()) {
        OTSubcredential* pSub = m_mapSubcredentials.begin()->second;
        OT_ASSERT(nullptr != pSub);

        delete pSub;
        pSub = nullptr;

        m_mapSubcredentials.erase(m_mapSubcredentials.begin());
    } // while
}

OTCredential * opentxs::OTCredential::CreateMaster ( const OTString &  strSourceForNymID, int32_t  nBits = 1024, const OTString::Map *  pmapPrivate = nullptr, const OTString::Map *  pmapPublic = nullptr, const OTPasswordData *  pPWData = nullptr  )

static

Definition at line 1183 of file OTCredential.cpp.

{
    OTCredential* pCredential = new OTCredential;
    OT_ASSERT(nullptr != pCredential);

    pCredential->SetSourceForNymID(
        strSourceForNymID); // This also recalculates and sets  ** m_strNymID **

    // OTKeyCredential::SetPrivateContents will already set the public keys,
    // which is why this argument is optional. But not all credentials are keys,
    // so we must still retain the ability to explicitly set the public info.
    // Even so, in the case of keys, private is below, so it will overwrite
    // this.

    if ((nullptr != pmapPublic) &&
        (nullptr != pmapPrivate)) // You cannot pass public
                                  // info in here unless
                                  // you also pass private
                                  // info.
    {
        if (!pCredential->SetPublicContents(*pmapPublic)) {
            otErr << "In " << __FILE__ << ", line " << __LINE__
                  << ": Failed trying to call pCredential->SetPublicContents\n";
            delete pCredential;
            pCredential = nullptr;
            return nullptr;
        }
    }

    // Private info must be passed in to create a credential. This saves a copy
    // of the map, and for keys also loads the map all up into the OTKeypair
    // objects (in the case of OTKeyCredentials anyway -- not all credentials
    // are keys.)
    //
    bool bContentsReady = false;

    if (nullptr !=
        pmapPrivate) // Pre-generated keys were passed in for us to use.
        bContentsReady = pCredential->SetPrivateContents(
            *pmapPrivate); // So let's set them onto the master key.
    else
        // No keys were provided, so let's generate them ourselves...
        bContentsReady = pCredential->GenerateMasterkey(nBits);

    if (!bContentsReady) {
        otErr << "In " << __FILE__ << ", line " << __LINE__
              << ": Failed trying to SetPrivateContents or GenerateMasterkey\n";
        delete pCredential;
        pCredential = nullptr;
        return nullptr;
    }
    else {
        OTPasswordData thePWData(
            "Signing new master credential... OTCredential::CreateMaster");

        // Using m_Masterkey's actual signing key to sign "m_Masterkey the
        // contract."
        //
        if (false ==
            pCredential->SignNewMaster(nullptr == pPWData ? &thePWData
                                                          : pPWData)) {
            otErr << "In " << __FILE__ << ", line " << __LINE__
                  << ": Failed trying to call pCredential->SignNewMaster\n";
            delete pCredential;
            pCredential = nullptr;
            return nullptr;
        }
    }

    // By this point, we have instantiated a new OTCredential, set the source
    // string, hashed that
    // source string to get the NymID for this credential, and set the public
    // and private info for
    // this credential (each a map of strings.) Since pCredential->m_Masterkey
    // is derived from
    // OTKeyCredential, it also loaded up the 3 keypairs (authentication,
    // encryption, and signing.)
    // Then we signed that master key with itself, with its signing key. (It's
    // also an OTContract,
    // so it can be signed.) This also calculated the new master credential ID,
    // and called
    // pCredential->SetMasterCredID. That is, the OTCredential's "master
    // credential ID" is formed
    // as a hash of the signed contract that is its OTMasterkey.
    // BUT!!! We don't want to use a hash of the private key information, since
    // others cannot verify
    // the hash without seeing our private key. We want OTMasterkey to create an
    // 'official' signed
    // public version of itself, minus private keys, which is what can be sent
    // to servers and to
    // other users, and which can be hashed to form the master credential ID
    // (and verified later.)
    // ...Which is exactly what it does. Inside pCredential->SignNewMaster, a
    // public version is created
    // and signed, and set onto that masterkey as m_strContents. It's then
    // re-signed as the private
    // version, which contains m_strContents in encoded form, along with the
    // private keys.
    //
    return pCredential;
}

const OTKeypair & opentxs::OTCredential::GetAuthKeypair

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1369 of file OTCredential.cpp.

{
    for (const auto& it : m_mapSubcredentials) {
        const std::string str_cred_id = it.first;
        const OTSubcredential* pSub = it.second;
        OT_ASSERT(nullptr != pSub);

        const OTSubkey* pKey = dynamic_cast<const OTSubkey*>(pSub);
        if (nullptr == pKey) continue;

        // See if pKey, with ID str_cred_id, is on plistRevokedIDs...
        //
        if (nullptr != plistRevokedIDs) {
            auto iter = std::find(plistRevokedIDs->begin(),
                                  plistRevokedIDs->end(), str_cred_id);
            if (iter != plistRevokedIDs->end()) // It was on the revoked list.
                continue;                       // Skip this revoked key.
        }
        // At this point we know it's a key credential, and we know it's not on
        // the revoked list. Therefore, let's return the key! (Any other future
        // smart criteria might go here before taking this final step...)
        //
        return pKey->m_AuthentKey;
    }

    // Didn't find any subcredentials we can use? For now, we'll return the
    // master key instead.
    // This is purely for backwards compatibility reasons and eventually should
    // be removed. That is,
    // masters should only be able to verify subkeys, and only subkeys should be
    // able to do actions.
    // Capiche?
    //
    return m_Masterkey.m_AuthentKey;
}

const OTKeypair & opentxs::OTCredential::GetEncrKeypair

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1406 of file OTCredential.cpp.

{
    for (const auto& it : m_mapSubcredentials) {
        const std::string str_cred_id = it.first;
        const OTSubcredential* pSub = it.second;
        OT_ASSERT(nullptr != pSub);

        const OTSubkey* pKey = dynamic_cast<const OTSubkey*>(pSub);
        if (nullptr == pKey) continue;

        // See if pKey, with ID str_cred_id, is on plistRevokedIDs...
        //
        if (nullptr != plistRevokedIDs) {
            auto iter = std::find(plistRevokedIDs->begin(),
                                  plistRevokedIDs->end(), str_cred_id);
            if (iter != plistRevokedIDs->end()) // It was on the revoked list.
                continue;                       // Skip this revoked key.
        }
        // At this point we know it's a key credential, and we know it's not on
        // the revoked list. Therefore, let's return the key! (Any other future
        // smart criteria might go here before taking this final step...)
        //
        return pKey->m_EncryptKey;
    }

    // Didn't find any subcredentials we can use? For now, we'll return the
    // master key instead.
    // This is purely for backwards compatibility reasons and eventually should
    // be removed. That is,
    // masters should only be able to verify subkeys, and only subkeys should be
    // able to do actions.
    // Capiche?
    //
    return m_Masterkey.m_EncryptKey;
}

EXPORT const OTPassword* opentxs::OTCredential::GetImportPassword ( ) const

inline

Definition at line 273 of file OTCredential.hpp.

    {
        return m_pImportPassword;
    }

const OTString & opentxs::OTCredential::GetMasterCredID

(

)

const

Definition at line 343 of file OTCredential.cpp.

{
    return m_strMasterCredID;
}

EXPORT const OTMasterkey& opentxs::OTCredential::GetMasterkey ( ) const

inline

Definition at line 371 of file OTCredential.hpp.

    {
        return m_Masterkey;
    }

const OTString & opentxs::OTCredential::GetNymID

(

)

const

Definition at line 278 of file OTCredential.cpp.

{
    return m_strNymID;
}

const OTString & opentxs::OTCredential::GetPriCredential

(

)

const

Definition at line 316 of file OTCredential.cpp.

{
    return m_Masterkey.GetPriCredential();
}

const OTAsymmetricKey & opentxs::OTCredential::GetPrivateAuthKey

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1505 of file OTCredential.cpp.

{
    return GetAuthKeypair(plistRevokedIDs).GetPrivateKey();
}

const OTAsymmetricKey & opentxs::OTCredential::GetPrivateEncrKey

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1511 of file OTCredential.cpp.

{
    return GetEncrKeypair(plistRevokedIDs).GetPrivateKey();
}

const OTAsymmetricKey & opentxs::OTCredential::GetPrivateSignKey

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1517 of file OTCredential.cpp.

{
    return GetSignKeypair(plistRevokedIDs).GetPrivateKey();
}

const OTString & opentxs::OTCredential::GetPubCredential

(

)

const

Definition at line 311 of file OTCredential.cpp.

{
    return m_Masterkey.GetPubCredential();
}

const OTAsymmetricKey & opentxs::OTCredential::GetPublicAuthKey

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1487 of file OTCredential.cpp.

{
    return GetAuthKeypair(plistRevokedIDs).GetPublicKey();
}

const OTAsymmetricKey & opentxs::OTCredential::GetPublicEncrKey

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1493 of file OTCredential.cpp.

{
    return GetEncrKeypair(plistRevokedIDs).GetPublicKey();
}

int32_t opentxs::OTCredential::GetPublicKeysBySignature	(	listOfAsymmetricKeys &	listOutput,
		const OTSignature &	theSignature,
		char	cKeyType = '0'
	)		const

Definition at line 172 of file OTCredential.cpp.

{
    int32_t nCount = 0;
    for (const auto& it : m_mapSubcredentials) {
        const OTSubcredential* pSub = it.second;
        OT_ASSERT(nullptr != pSub);

        const OTSubkey* pKey = dynamic_cast<const OTSubkey*>(pSub);
        if (nullptr == pKey)
            continue; // Skip all non-key credentials. We're looking for keys.

        const int32_t nTempCount =
            pKey->GetPublicKeysBySignature(listOutput, theSignature, cKeyType);
        nCount += nTempCount;
    }
    return nCount;
}

const OTAsymmetricKey & opentxs::OTCredential::GetPublicSignKey

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1499 of file OTCredential.cpp.

{
    return GetSignKeypair(plistRevokedIDs).GetPublicKey();
}

const OTKeypair & opentxs::OTCredential::GetSignKeypair

(

const OTString::List *

plistRevokedIDs = nullptr

)

const

Definition at line 1443 of file OTCredential.cpp.

{
    for (const auto& it : m_mapSubcredentials) {
        const std::string str_cred_id = it.first;
        const OTSubcredential* pSub = it.second;
        OT_ASSERT(nullptr != pSub);

        const OTSubkey* pKey = dynamic_cast<const OTSubkey*>(pSub);
        if (nullptr == pKey) continue;

        // See if pKey, with ID str_cred_id, is on plistRevokedIDs...
        //
        if (nullptr != plistRevokedIDs) {
            auto iter = std::find(plistRevokedIDs->begin(),
                                  plistRevokedIDs->end(), str_cred_id);
            if (iter != plistRevokedIDs->end()) // It was on the revoked list.
                continue;                       // Skip this revoked key.
        }
        // At this point we know it's a key credential, and we know it's not on
        // the revoked list. Therefore, let's return the key! (Any other future
        // smart criteria might go here before taking this final step...)
        //
        return pKey->m_SigningKey;
    }

    // Didn't find any subcredentials we can use? For now, we'll return the
    // master key instead.
    // This is purely for backwards compatibility reasons and eventually should
    // be removed. That is,
    // masters should only be able to verify subkeys, and only subkeys should be
    // able to do actions.
    // Capiche?
    //
    return m_Masterkey.m_SigningKey;
}

const OTString & opentxs::OTCredential::GetSourceForNymID

(

)

const

Definition at line 283 of file OTCredential.cpp.

{
    return m_strSourceForNymID;
}

const OTSubcredential * opentxs::OTCredential::GetSubcredential	(	const OTString &	strSubID,
		const OTString::List *	plistRevokedIDs = nullptr
	)		const

Definition at line 1300 of file OTCredential.cpp.

{
    for (const auto& it : m_mapSubcredentials) {
        const std::string str_cred_id = it.first;
        const OTSubcredential* pSub = it.second;
        OT_ASSERT(nullptr != pSub);

        // See if pSub, with ID str_cred_id, is on plistRevokedIDs...
        //
        if (nullptr != plistRevokedIDs) {
            auto iter = std::find(plistRevokedIDs->begin(),
                                  plistRevokedIDs->end(), str_cred_id);
            if (iter != plistRevokedIDs->end()) // It was on the revoked list.
                continue;                       // Skip this revoked credential.
        }
        // At this point we know it's not on the revoked list, if one was passed
        // in.

        if (strSubID.Compare(str_cred_id.c_str())) return pSub;
    }
    return nullptr;
}

const OTSubcredential * opentxs::OTCredential::GetSubcredentialByIndex

(

int32_t

nIndex

)

const

Definition at line 1324 of file OTCredential.cpp.

{
    if ((nIndex < 0) ||
        (nIndex >= static_cast<int64_t>(m_mapSubcredentials.size()))) {
        otErr << __FUNCTION__ << ": Index out of bounds: " << nIndex << "\n";
    }
    else {
        int32_t nLoopIndex = -1;

        for (const auto& it : m_mapSubcredentials) {
            const OTSubcredential* pSub = it.second;
            OT_ASSERT(nullptr != pSub);

            ++nLoopIndex; // 0 on first iteration.

            if (nIndex == nLoopIndex) return pSub;
        }
    }

    return nullptr;
}

size_t opentxs::OTCredential::GetSubcredentialCount

(

)

const

Definition at line 1295 of file OTCredential.cpp.

{
    return m_mapSubcredentials.size();
}

const std::string opentxs::OTCredential::GetSubcredentialIDByIndex

(

size_t

nIndex

)

const

Definition at line 1347 of file OTCredential.cpp.

{
    if (nIndex >= m_mapSubcredentials.size()) {
        otErr << __FUNCTION__ << ": Index out of bounds: " << nIndex << "\n";
    }
    else {
        int32_t nLoopIndex = -1;

        for (const auto& it : m_mapSubcredentials) {
            const std::string str_cred_id = it.first;
            const OTSubcredential* pSub = it.second;
            OT_ASSERT(nullptr != pSub);

            ++nLoopIndex; // 0 on first iteration.

            if (static_cast<int64_t>(nIndex) == nLoopIndex) return str_cred_id;
        }
    }

    return nullptr;
}

bool opentxs::OTCredential::Load_Master	(	const OTString &	strNymID,
		const OTString &	strMasterCredID,
		const OTPasswordData *	pPWData = nullptr
	)

Definition at line 806 of file OTCredential.cpp.

{

    std::string str_Folder =
        OTFolders::Credential().Get(); // Try private credential first. If that
                                       // fails, then public.

    if (false ==
        OTDB::Exists(str_Folder, strNymID.Get(), strMasterCredID.Get())) {
        str_Folder = OTFolders::Pubcred().Get();

        if (false ==
            OTDB::Exists(str_Folder, strNymID.Get(), strMasterCredID.Get())) {
            otErr << __FUNCTION__ << ": Failure: Master Credential "
                  << strMasterCredID << " doesn't exist for Nym " << strNymID
                  << "\n";
            return false;
        }
    }

    OTString strFileContents(OTDB::QueryPlainString(str_Folder, strNymID.Get(),
                                                    strMasterCredID.Get()));
    if (!strFileContents.Exists()) {
        otErr << __FUNCTION__ << ": Failed trying to load master credential "
                                 "from local storage.\n";
        return false;
    }

    if (false ==
        strFileContents.DecodeIfArmored()) // bEscapedIsAllowed=true by default.
    {
        otErr << __FUNCTION__ << ": File contents apparently were encoded and "
                                 "then failed decoding. Contents: \n"
              << strFileContents << "\n";
        return false;
    }

    return Load_MasterFromString(strFileContents, strNymID, strMasterCredID,
                                 pPWData);
}

bool opentxs::OTCredential::Load_MasterFromString	(	const OTString &	strInput,
		const OTString &	strNymID,
		const OTString &	strMasterCredID,
		const OTPasswordData *	pPWData = nullptr,
		const OTPassword *	pImportPassword = nullptr
	)

Definition at line 758 of file OTCredential.cpp.

{
    m_strNymID = strNymID;
    m_strMasterCredID = strMasterCredID;

    m_Masterkey.SetIdentifier(strMasterCredID);

    // m_Masterkey and the subkeys all have a pointer to "owner" (who is *this)
    // and so I can set pImportPassword onto a member variable, perform the
    // load,
    // and then set that member nullptr again. During the call to
    // LoadContractFromString,
    // m_Masterkey can reference m_pOwner->GetImportPassword() and if it's not
    // nullptr,
    // use it instead of using the wallet's cached master key. After all, if
    // it's not
    // nullptr here, that's why it was passed in.
    //

    SetImportPassword(pImportPassword); // might be nullptr.

    const bool bLoaded = m_Masterkey.LoadContractFromString(strInput);
    if (!bLoaded) {
        otErr << __FUNCTION__
              << ": Failed trying to load master credential from string.\n";
        return false;
    }

    SetImportPassword(nullptr); // It was only set during the
                                // m_Masterkey.LoadContractFromString (which
                                // references it.)

    m_strNymID = m_Masterkey.GetNymID();
    m_strSourceForNymID = m_Masterkey.GetNymIDSource();

    ClearSubcredentials(); // The master is loaded first, and then any
                           // subcredentials. So this is probably already
                           // empty. Just looking ahead.

    m_Masterkey.SetMetadata();

    return true;
}

OTCredential * opentxs::OTCredential::LoadMaster ( const OTString &  strNymID, const OTString &  strMasterCredID, const OTPasswordData *  pPWData = nullptr  )

static

Definition at line 349 of file OTCredential.cpp.

{
    OTCredential* pCredential = new OTCredential;
    std::unique_ptr<OTCredential> theCredentialAngel(pCredential);
    OT_ASSERT(nullptr != pCredential);

    OTPasswordData thePWData("Loading master credential. (static 1.)");
    const bool bLoaded = pCredential->Load_Master(
        strNymID, strMasterCredID, (nullptr == pPWData) ? &thePWData : pPWData);
    if (!bLoaded) {
        otErr << __FUNCTION__ << ": Failed trying to load master credential "
                                 "from local storage. 1\n";
        return nullptr;
    }

    return theCredentialAngel.release();
}

OTCredential * opentxs::OTCredential::LoadMasterFromString ( const OTString &  strInput, const OTString &  strNymID, const OTString &  strMasterCredID, OTPasswordData *  pPWData = nullptr, const OTPassword *  pImportPassword = nullptr  )

static

Definition at line 371 of file OTCredential.cpp.

{
    OTCredential* pCredential = new OTCredential;
    std::unique_ptr<OTCredential> theCredentialAngel(pCredential);
    OT_ASSERT(nullptr != pCredential);

    OTPasswordData thePWData(nullptr == pImportPassword
                                 ? "Enter wallet master passphrase."
                                 : "Enter passphrase for exported Nym.");
    const bool bLoaded = pCredential->Load_MasterFromString(
        strInput, strNymID, strMasterCredID,
        (nullptr == pPWData) ? &thePWData : pPWData, pImportPassword);
    if (!bLoaded) {
        otErr << __FUNCTION__
              << ": Failed trying to load master credential from string. 2\n";
        return nullptr;
    }

    return theCredentialAngel.release();
}

bool opentxs::OTCredential::LoadSubcredential

(

const OTString &

strSubID

)

Definition at line 985 of file OTCredential.cpp.

{

    std::string str_Folder =
        OTFolders::Credential().Get(); // Try private credential first. If that
                                       // fails, then public.

    if (!OTDB::Exists(str_Folder, GetNymID().Get(), strSubID.Get())) {
        str_Folder = OTFolders::Pubcred().Get();

        if (false ==
            OTDB::Exists(str_Folder, GetNymID().Get(), strSubID.Get())) {
            otErr << __FUNCTION__ << ": Failure: Credential " << strSubID
                  << " doesn't exist for Nym " << GetNymID() << "\n";
            return false;
        }
    }

    OTString strFileContents(
        OTDB::QueryPlainString(str_Folder, GetNymID().Get(), strSubID.Get()));
    if (!strFileContents.Exists()) {
        otErr << __FUNCTION__
              << ": Failed trying to load subCredential from local storage.\n";
        return false;
    }

    if (false ==
        strFileContents.DecodeIfArmored()) // bEscapedIsAllowed=true by default.
    {
        otErr << __FUNCTION__ << ": File contents apparently were encoded and "
                                 "then failed decoding. Contents: \n"
              << strFileContents << "\n";
        return false;
    }

    return LoadSubcredentialFromString(strFileContents, strSubID);
}

bool opentxs::OTCredential::LoadSubcredentialFromString	(	const OTString &	strInput,
		const OTString &	strSubID,
		const OTPassword *	pImportPassword = nullptr
	)

Definition at line 937 of file OTCredential.cpp.

{
    // Make sure it's not already there.
    //
    auto it = m_mapSubcredentials.find(strSubID.Get());
    if (it != m_mapSubcredentials.end()) // It was already there. (Reload it.)
    {
        otErr << __FUNCTION__ << ": Warning: Deleting and re-loading "
                                 "subCredential that was already loaded.\n";
        OTSubcredential* pSub = it->second;
        OT_ASSERT(nullptr != pSub);
        delete pSub;
        m_mapSubcredentials.erase(it);
    }

    OTSubcredential* pSub = new OTSubcredential(*this);
    std::unique_ptr<OTSubcredential> theSubAngel(pSub);
    OT_ASSERT(nullptr != pSub);

    pSub->SetIdentifier(strSubID);
    pSub->SetNymIDandSource(GetNymID(),
                            GetSourceForNymID()); // Set NymID and source
                                                  // string that hashes to
                                                  // it.
    pSub->SetMasterCredID(GetMasterCredID());     // Set master credential ID
                                                  // (onto this new
                                                  // subcredential...)

    SetImportPassword(pImportPassword); // might be nullptr.

    if (!pSub->LoadContractFromString(strInput)) {
        otErr << __FUNCTION__
              << ": Failed trying to load subCredential from string.\n";
        return false;
    }

    SetImportPassword(nullptr); // This is only set int64_t enough for
                                // LoadContractFromString to use it. (Then
                                // back to nullptr.)

    m_mapSubcredentials.insert(std::pair<std::string, OTSubcredential*>(
        strSubID.Get(), theSubAngel.release()));

    return true;
}

bool opentxs::OTCredential::LoadSubkey

(

const OTString &

strSubID

)

Definition at line 898 of file OTCredential.cpp.

{

    std::string str_Folder =
        OTFolders::Credential().Get(); // Try private credential first. If that
                                       // fails, then public.

    if (!OTDB::Exists(str_Folder, GetNymID().Get(), strSubID.Get())) {
        str_Folder = OTFolders::Pubcred().Get();

        if (false ==
            OTDB::Exists(str_Folder, GetNymID().Get(), strSubID.Get())) {
            otErr << __FUNCTION__ << ": Failure: Key Credential " << strSubID
                  << " doesn't exist for Nym " << GetNymID() << "\n";
            return false;
        }
    }

    OTString strFileContents(
        OTDB::QueryPlainString(str_Folder, GetNymID().Get(), strSubID.Get()));

    if (!strFileContents.Exists()) {
        otErr << __FUNCTION__
              << ": Failed trying to load keyCredential from local storage.\n";
        return false;
    }

    if (false ==
        strFileContents.DecodeIfArmored()) // bEscapedIsAllowed=true by default.
    {
        otErr << __FUNCTION__ << ": File contents apparently were encoded and "
                                 "then failed decoding. Contents: \n"
              << strFileContents << "\n";
        return false;
    }

    return LoadSubkeyFromString(strFileContents, strSubID);
}

bool opentxs::OTCredential::LoadSubkeyFromString	(	const OTString &	strInput,
		const OTString &	strSubID,
		const OTPassword *	pImportPassword = nullptr
	)

Definition at line 849 of file OTCredential.cpp.

{
    // Make sure it's not already there.
    //
    auto it = m_mapSubcredentials.find(strSubID.Get());
    if (it != m_mapSubcredentials.end()) // It was already there. (Reload it.)
    {
        otErr << __FUNCTION__ << ": Warning: Deleting and re-loading "
                                 "keyCredential that was already loaded.\n";
        OTSubcredential* pSub = it->second;
        OT_ASSERT(nullptr != pSub);
        delete pSub;
        m_mapSubcredentials.erase(it);
    }

    OTSubkey* pSub = new OTSubkey(*this);
    std::unique_ptr<OTSubkey> theSubAngel(pSub);
    OT_ASSERT(nullptr != pSub);

    pSub->SetIdentifier(strSubID);
    pSub->SetNymIDandSource(GetNymID(),
                            GetSourceForNymID()); // Set NymID and source
                                                  // string that hashes to
                                                  // it.
    pSub->SetMasterCredID(GetMasterCredID());     // Set master credential ID
                                                  // (onto this new
                                                  // subcredential...)

    SetImportPassword(pImportPassword); // might be nullptr.

    if (!pSub->LoadContractFromString(strInput)) {
        otErr << __FUNCTION__
              << ": Failed trying to load keyCredential from string.\n";
        return false;
    }

    SetImportPassword(nullptr); // Only set int64_t enough for
                                // LoadContractFromString above to use it.

    pSub->SetMetadata();

    m_mapSubcredentials.insert(std::pair<std::string, OTSubcredential*>(
        strSubID.Get(), theSubAngel.release()));

    return true;
}

bool opentxs::OTCredential::ReEncryptPrivateCredentials	(	const OTPassword &	theExportPassword,
		bool	bImporting
	)

Definition at line 489 of file OTCredential.cpp.

{
    if (m_Masterkey.GetPrivateMap().size() > 0) {
        OTPasswordData thePWData(
            bImporting ? "2 Enter passphrase for the Nym being imported."
                       : "2 Enter new passphrase for exported Nym.");

        // Re-encrypt the private keys in the masterkey. (THEN sign.)
        //
        const bool bReEncryptMaster =
            m_Masterkey.ReEncryptKeys(theExportPassword, bImporting);
        bool bSignedMaster = false;

        if (bReEncryptMaster) {
            m_Masterkey.ReleaseSignatures(); // This time we'll sign it in
                                             // private mode.
            bSignedMaster = m_Masterkey.Sign(m_Masterkey, &thePWData);
        }
        else {
            otErr << "In " << __FILE__ << ", line " << __LINE__
                  << ": Failed trying to re-encrypt the private masterkey.\n";
            return false;
        }

        if (bSignedMaster) {
            m_Masterkey.SaveContract();
            m_Masterkey.SetMetadata(); // todo: can probably remove this, since
                                       // it was set based on public info when
                                       // the key was first created.

            for (auto& it : m_mapSubcredentials) {
                OTSubcredential* pSub = it.second;
                OT_ASSERT(nullptr != pSub);

                OTSubkey* pKey = dynamic_cast<OTSubkey*>(pSub);
                if (nullptr == pKey) continue;

                const bool bReEncryptSubkey =
                    pKey->ReEncryptKeys(theExportPassword, bImporting);
                bool bSignedSubkey = false;

                if (bReEncryptSubkey) {
                    pKey->ReleaseSignatures();
                    bSignedSubkey = pKey->Sign(*pKey, &thePWData);
                }
                else {
                    otErr << "In " << __FILE__ << ", line " << __LINE__
                          << ": Failed trying to re-encrypt the private "
                             "subkey.\n";
                    return false;
                }

                if (bSignedSubkey) {
                    pKey->SaveContract();
                    pKey->SetMetadata(); // todo: can probably remove this,
                                         // since it was set based on public
                                         // info when the key was first created.
                }
                else {
                    otErr << "In " << __FILE__ << ", line " << __LINE__
                          << ": Failed trying to re-sign the private subkey.\n";
                    return false;
                }
            }

            return true; // <=== Success.
        }
        else
            otErr << "In " << __FILE__ << ", line " << __LINE__
                  << ": Failed trying to re-sign the master private "
                     "credential.\n";
    }
    else
        otErr << "In " << __FILE__ << ", line " << __LINE__
              << ": Failed: There is no private info on this master "
                 "credential.\n";

    return false;
}

void opentxs::OTCredential::SerializeIDs	(	OTString &	strOutput,
		const OTString::List &	listRevokedIDs,
		OTString::Map *	pmapPubInfo = nullptr,
		OTString::Map *	pmapPriInfo = nullptr,
		bool	bShowRevoked = false,
		bool	bValid = true
	)		const

Definition at line 1553 of file OTCredential.cpp.

{
    if (bValid || bShowRevoked) {
        strOutput.Concatenate("<masterCredential\n"
                              " ID=\"%s\"\n"
                              " valid=\"%s\""
                              "/>\n\n",
                              GetMasterCredID().Get(),
                              bValid ? "true" : "false");

        if (nullptr != pmapPubInfo) // optional out-param.
            pmapPubInfo->insert(std::pair<std::string, std::string>(
                GetMasterCredID().Get(), GetPubCredential().Get()));

        if (nullptr != pmapPriInfo) // optional out-param.
            pmapPriInfo->insert(std::pair<std::string, std::string>(
                GetMasterCredID().Get(), GetPriCredential().Get()));
    }

    for (const auto& it : m_mapSubcredentials) {
        const std::string str_cred_id = it.first;
        const OTSubcredential* pSub = it.second;
        OT_ASSERT(nullptr != pSub);

        // See if the current subcredential is on the Nym's list of "revoked"
        // subcredential IDs.
        // If so, we'll skip serializing it here.
        //
        auto iter = std::find(listRevokedIDs.begin(), listRevokedIDs.end(),
                              str_cred_id);

        // Was it on the 'revoked' list?
        // If not, then the subcredential isn't revoked, so it's still valid.
        //
        const bool bSubcredValid =
            bValid ? (iter == listRevokedIDs.end()) : false;

        if (bSubcredValid || bShowRevoked) {
            const OTSubkey* pSubkey = dynamic_cast<const OTSubkey*>(pSub);

            if (nullptr != pSubkey)
                strOutput.Concatenate("<keyCredential\n"
                                      " ID=\"%s\"\n"
                                      " masterID=\"%s\"\n"
                                      " valid=\"%s\""
                                      "/>\n\n",
                                      str_cred_id.c_str(),
                                      pSubkey->GetMasterCredID().Get(),
                                      bSubcredValid ? "true" : "false");
            else
                strOutput.Concatenate("<subCredential\n"
                                      " ID=\"%s\"\n"
                                      " masterID=\"%s\"\n"
                                      " valid=\"%s\""
                                      "/>\n\n",
                                      str_cred_id.c_str(),
                                      pSub->GetMasterCredID().Get(),
                                      bSubcredValid ? "true" : "false");

            if (nullptr != pmapPubInfo) // optional out-param.
                pmapPubInfo->insert(std::pair<std::string, std::string>(
                    str_cred_id.c_str(), pSub->GetPubCredential().Get()));

            if (nullptr != pmapPriInfo) // optional out-param.
                pmapPriInfo->insert(std::pair<std::string, std::string>(
                    str_cred_id.c_str(), pSub->GetPriCredential().Get()));

        } // if (bSubcredValid)
    }
}

EXPORT void opentxs::OTCredential::SetImportPassword ( const OTPassword *  pImportPassword )

inline

Definition at line 277 of file OTCredential.hpp.

    {
        m_pImportPassword = pImportPassword;
    }

bool opentxs::OTCredential::VerifyAgainstSource

(

)

const

Definition at line 242 of file OTCredential.cpp.

{
    // * Any OTMasterkey must (at some point, and/or regularly) verify against
    // its own source.
    //
    if (!m_Masterkey.VerifyAgainstSource()) {
        otWarn
            << __FUNCTION__
            << ": Failed verifying master credential against its own source.\n";
        return false;
    }
    // NOTE: This spot will have a significant delay, TODO OPTIMIZE. Performing
    // a Freenet lookup, or DNS, etc,
    // will introduce delay inside the call VerifyAgainstSource. Therefore in
    // the int64_t term, we must have a
    // separate server process which will verify identities for some specified
    // period of time (specified in
    // their credentials I suppose...) That way, when we call
    // VerifyAgainstSource, we are verifying against
    // some server-signed authorization, based on a lookup that some separate
    // process did within the past
    // X allowed time, such that the lookup is still considered valid (without
    // having to lookup every single
    // time, which is untenable.)

    return true;
}

bool opentxs::OTCredential::VerifyInternally

(

)

const

Definition at line 193 of file OTCredential.cpp.

{

    OTIdentifier theActualMasterCredID;
    theActualMasterCredID.CalculateDigest(m_Masterkey.GetPubCredential());
    const OTString strActualMasterCredID(theActualMasterCredID);

    if (!m_strNymID.Compare(m_Masterkey.GetNymID())) {
        otOut << __FUNCTION__
              << ": NymID did not match its "
                 "counterpart in m_Masterkey (failed to verify): " << GetNymID()
              << "\n";
        return false;
    }

    if (!m_strMasterCredID.Compare(strActualMasterCredID)) {
        otOut << __FUNCTION__
              << ": Master Credential ID did not match its "
                 "counterpart in m_Masterkey:\nExpected Master Credential ID: "
              << GetMasterCredID()
              << "\n "
                 "Hash of m_Masterkey contents: " << strActualMasterCredID
              << "\nContents:\n" << m_Masterkey.GetPubCredential() << "\n";
        return false;
    }

    if (!const_cast<OTMasterkey&>(m_Masterkey).VerifyContract()) {
        otOut << __FUNCTION__
              << ": Master Credential failed to verify: " << GetMasterCredID()
              << "\nNymID: " << GetNymID() << "\n";
        return false;
    }

    for (const auto& it : m_mapSubcredentials) {
        std::string str_sub_id = it.first;
        OTSubcredential* pSub = it.second;
        OT_ASSERT(nullptr != pSub);

        if (!pSub->VerifyContract()) {
            otOut << __FUNCTION__
                  << ": Subcredential failed to verify: " << str_sub_id
                  << "\nNymID: " << GetNymID() << "\n";
            return false;
        }
    }

    return true;
}

---

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

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