#include <OTKeyCredential.hpp>

Inheritance diagram for opentxs::OTKeyCredential:

Collaboration diagram for opentxs::OTKeyCredential:

Public Member Functions
bool	GenerateKeys (int32_t nBits=1024)

bool	ReEncryptKeys (const OTPassword &theExportPassword, bool bImporting)

virtual bool	VerifyInternally ()

bool	VerifySignedBySelf ()

virtual void	SetMetadata ()

	OTKeyCredential ()

	OTKeyCredential (OTCredential &theOwner)

bool	Sign (OTContract &theContract, const OTPasswordData *pPWData=nullptr)

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

virtual	~OTKeyCredential ()

virtual void	Release ()

void	Release_Subkey ()

Public Member Functions inherited from opentxs::OTSubcredential
const OTString::Map &	GetPublicMap () const

const OTString::Map &	GetPrivateMap () const

const OTString &	GetMasterCredID () const

const OTString &	GetNymID () const

const OTString &	GetNymIDSource () const

const OTString &	GetContents () const

EXPORT const OTString &	GetPubCredential () const

const OTString &	GetPriCredential () const

const OTString &	GetMasterSigned () const

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

virtual bool	VerifyContract ()

bool	VerifyNymID () const

virtual bool	VerifySignedByMaster ()

void	SetOwner (OTCredential &theOwner)

	OTSubcredential ()

	OTSubcredential (OTCredential &theOwner)

virtual	~OTSubcredential ()

void	Release_Subcredential ()

virtual void	UpdateContents ()

virtual int32_t	ProcessXMLNode (irr::io::IrrXMLReader *&xml)

virtual bool	SaveContractWallet (std::ofstream &) const

Public Member Functions inherited from opentxs::OTContract
const char *	GetHashType () const

void	SetIdentifier (const OTIdentifier &theID)

EXPORT	OTContract ()

EXPORT	OTContract (const OTString &name, const OTString &foldername, const OTString &filename, const OTString &strID)

EXPORT	OTContract (const OTString &strID)

EXPORT	OTContract (const OTIdentifier &theID)

void	Initialize ()

virtual EXPORT	~OTContract ()

EXPORT void	Release_Contract ()

EXPORT void	ReleaseSignatures ()

virtual EXPORT bool	CreateContract (const OTString &strContract, const OTPseudonym &theSigner)

EXPORT bool	InsertNym (const OTString &strKeyName, const OTString &strKeyValue)

EXPORT void	GetName (OTString &strName) const

EXPORT void	SetName (const OTString &strName)

virtual EXPORT void	GetIdentifier (OTIdentifier &theIdentifier) const

virtual EXPORT void	GetIdentifier (OTString &theIdentifier) const

EXPORT void	GetFilename (OTString &strFilename) const

EXPORT void	GetFoldername (OTString &strFoldername) const

virtual EXPORT bool	LoadContract ()

EXPORT bool	LoadContract (const char szFoldername, const char szFilename)

EXPORT bool	LoadContractFromString (const OTString &theStr)

bool	LoadContractRawFile ()

EXPORT bool	ParseRawFile ()

EXPORT bool	SaveToContractFolder ()

EXPORT bool	SaveContractRaw (OTString &strOutput) const

EXPORT bool	RewriteContract (OTString &strOutput) const

EXPORT bool	SaveContract ()

EXPORT bool	SaveContract (const char szFoldername, const char szFilename)

virtual EXPORT void	CreateContents ()

EXPORT void	CreateInnerContents ()

virtual EXPORT bool	SaveContents (std::ofstream &ofs) const

virtual EXPORT bool	SaveContractWallet (OTString &strContents) const

virtual EXPORT bool	DisplayStatistics (OTString &strContents) const

virtual EXPORT bool	SaveContents (OTString &strContents) const

virtual EXPORT bool	SignContract (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTAsymmetricKey &theKey, OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const char szFoldername, const char szFilename, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

virtual EXPORT bool	VerifyContractID () const

virtual EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

virtual EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifyWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTAsymmetricKey &theKey, const OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const char szFoldername, const char szFilename, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT const OTAsymmetricKey *	GetContractPublicKey () const

EXPORT const OTPseudonym *	GetContractPublicNym () const

Public Attributes
OTKeypair	m_SigningKey

OTKeypair	m_AuthentKey

OTKeypair	m_EncryptKey

Protected Member Functions
virtual bool	SetPublicContents (const OTString::Map &mapPublic)

virtual bool	SetPrivateContents (const OTString::Map &mapPrivate, const OTPassword *pImportPassword=nullptr)

Protected Member Functions inherited from opentxs::OTSubcredential
void	UpdateMasterPublicToString (OTString &strAppendTo)

void	UpdatePublicContentsToString (OTString &strAppendTo)

void	UpdatePublicCredentialToString (OTString &strAppendTo)

void	UpdatePrivateContentsToString (OTString &strAppendTo)

void	SetMasterSigned (const OTString &strMasterSigned)

void	SetContents (const OTString &strContents)

void	SetNymIDandSource (const OTString &strNymID, const OTString &strSourceForNymID)

void	SetMasterCredID (const OTString &strMasterCredID)

void	StoreAsMasterSigned ()

void	StoreAsPublic ()

Protected Member Functions inherited from opentxs::OTContract
bool	LoadContractXML ()

Friends
class	OTCredential

Additional Inherited Members
Static Public Member Functions inherited from opentxs::OTContract
static EXPORT bool	DearmorAndTrim (const OTString &strInput, OTString &strOutput, OTString &strFirstLine)

static bool	AddBookendsAroundContent (OTString &strOutput, const OTString &strContents, const OTString &strContractType, const OTString &strHashType, const listOfSignatures &listSignatures)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTASCIIArmor &ascOutput)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTString &strOutput)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTASCIIArmor &ascOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTString &strOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	SkipToElement (irr::io::IrrXMLReader *&xml)

static bool	SkipToTextField (irr::io::IrrXMLReader *&xml)

static bool	SkipAfterLoadingField (irr::io::IrrXMLReader *&xml)

static EXPORT bool	SignFlatText (OTString &strFlatText, const OTString &strContractType, const OTPseudonym &theSigner, OTString &strOutput)

Protected Types inherited from opentxs::OTSubcredential
enum	CredStoreAs { credPrivateInfo, credPublicInfo = 1, credMasterSigned = 2 }

Protected Attributes inherited from opentxs::OTSubcredential
CredStoreAs	m_StoreAs

OTCredential *	m_pOwner

OTString	m_strMasterCredID

OTString	m_strNymID

OTString	m_strSourceForNymID

OTString::Map	m_mapPublicInfo

OTString::Map	m_mapPrivateInfo

OTString	m_strMasterSigned

OTString	m_strContents

Protected Attributes inherited from opentxs::OTContract
OTString	m_strName

OTString	m_strFoldername

OTString	m_strFilename

OTIdentifier	m_ID

OTStringXML	m_xmlUnsigned

OTString	m_strRawFile

OTString	m_strSigHashType

OTString	m_strContractType

mapOfNyms	m_mapNyms

listOfSignatures	m_listSignatures

OTString	m_strVersion

OTString	m_strEntityShortName

OTString	m_strEntityLongName

OTString	m_strEntityEmail

OTString::Map	m_mapConditions

Detailed Description

OTKeyCredential A form of OTSubcredential that contains 3 key pairs: signing, authentication, and encryption. We won't use OTKeyCredential directly but only as a common base class for OTSubkey and OTMasterkey.

Definition at line 249 of file OTKeyCredential.hpp.

Constructor & Destructor Documentation

opentxs::OTKeyCredential::OTKeyCredential ( )

Definition at line 284 of file OTKeyCredential.cpp.

     : ot_super()
 {
 }

opentxs::OTKeyCredential::OTKeyCredential ( OTCredential & theOwner )

Definition at line 288 of file OTKeyCredential.cpp.

     : ot_super(theOwner)
 {
 }

opentxs::OTKeyCredential::~OTKeyCredential ( )

virtual

Definition at line 293 of file OTKeyCredential.cpp.

 {
     Release_Subkey();
 }

Member Function Documentation

bool opentxs::OTKeyCredential::GenerateKeys ( int32_t nBits = 1024 )

Definition at line 313 of file OTKeyCredential.cpp.

 {
     const bool bSign = m_SigningKey.MakeNewKeypair(nBits);
     const bool bAuth = m_AuthentKey.MakeNewKeypair(nBits);
     const bool bEncr = m_EncryptKey.MakeNewKeypair(nBits);
 
     OT_ASSERT(bSign && bAuth && bEncr);
 
     m_SigningKey.SaveAndReloadBothKeysFromTempFile(); // Keys won't be right
                                                       // until this happens.
     m_AuthentKey.SaveAndReloadBothKeysFromTempFile(); // (Necessary evil until
                                                       // better fix.)
     m_EncryptKey.SaveAndReloadBothKeysFromTempFile();
 
     // Since the keys were all generated successfully, we need to copy their
     // certificate data into the m_mapPublicInfo and m_mapPrivateInfo (string
     // maps.)
     //
     OTString strPublicKey, strPrivateCert;
     OTString::Map mapPublic, mapPrivate;
 
     const OTString strReason("Generating keys for new credential...");
 
     const bool b1 = m_SigningKey.GetPublicKey(
         strPublicKey, false); // bEscaped=true by default.
     const bool b2 =
         m_SigningKey.SaveCertAndPrivateKeyToString(strPrivateCert, &strReason);
 
     if (b1)
         mapPublic.insert(
             std::pair<std::string, std::string>("S", strPublicKey.Get()));
     if (b2)
         mapPrivate.insert(
             std::pair<std::string, std::string>("S", strPrivateCert.Get()));
 
     strPublicKey.Release();
     strPrivateCert.Release();
     const bool b3 = m_AuthentKey.GetPublicKey(
         strPublicKey, false); // bEscaped=true by default.
     const bool b4 =
         m_AuthentKey.SaveCertAndPrivateKeyToString(strPrivateCert, &strReason);
 
     if (b3)
         mapPublic.insert(
             std::pair<std::string, std::string>("A", strPublicKey.Get()));
     if (b4)
         mapPrivate.insert(
             std::pair<std::string, std::string>("A", strPrivateCert.Get()));
 
     strPublicKey.Release();
     strPrivateCert.Release();
     const bool b5 = m_EncryptKey.GetPublicKey(
         strPublicKey, false); // bEscaped=true by default.
     const bool b6 =
         m_EncryptKey.SaveCertAndPrivateKeyToString(strPrivateCert, &strReason);
 
     if (b5)
         mapPublic.insert(
             std::pair<std::string, std::string>("E", strPublicKey.Get()));
     if (b6)
         mapPrivate.insert(
             std::pair<std::string, std::string>("E", strPrivateCert.Get()));
 
     if (3 != mapPublic.size()) {
         otErr << "In " << __FILE__ << ", line " << __LINE__
               << ": Failed getting public keys in "
                  "OTKeyCredential::GenerateKeys.\n";
         return false;
     }
     else
         ot_super::SetPublicContents(mapPublic);
 
     if (3 != mapPrivate.size()) {
         otErr << "In " << __FILE__ << ", line " << __LINE__
               << ": Failed getting private keys in "
                  "OTKeyCredential::GenerateKeys.\n";
         return false;
     }
     else
         ot_super::SetPrivateContents(mapPrivate);
 
     return true;
 }

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

Definition at line 190 of file OTKeyCredential.cpp.

 {
     // Key type was not specified, because we only want keys that match the
     // metadata on theSignature.
     // And if theSignature has no metadata, then we want to return 0 keys.
     if (('0' == cKeyType) && !theSignature.getMetaData().HasMetadata())
         return 0;
 
     // By this point, we know that EITHER exact metadata matches must occur, and
     // the signature DOES have metadata, ('0')
     // OR the search is only for 'A', 'E', or 'S' candidates, based on cKeyType,
     // and that the signature's metadata
     // can additionally narrow the search down, if it's present, which in this
     // case it's not guaranteed to be.
     int32_t nCount = 0;
     switch (cKeyType) {
     // Specific search only for signatures with metadata.
     // FYI, theSignature.getMetaData().HasMetadata() is true, in this case.
     case '0': {
         // That's why I can just assume theSignature has a key type here:
         switch (theSignature.getMetaData().GetKeyType()) {
         case 'A':
             nCount =
                 m_AuthentKey.GetPublicKeyBySignature(listOutput, theSignature);
             break; // bInclusive=false by default
         case 'E':
             nCount =
                 m_EncryptKey.GetPublicKeyBySignature(listOutput, theSignature);
             break; // bInclusive=false by default
         case 'S':
             nCount =
                 m_SigningKey.GetPublicKeyBySignature(listOutput, theSignature);
             break; // bInclusive=false by default
         default:
             otErr << __FUNCTION__
                   << ": Unexpected keytype value in signature metadata: "
                   << theSignature.getMetaData().GetKeyType() << " (failure)\n";
             return 0;
         }
         break;
     }
     // Generalized search which specifies key type and returns keys
     // even for signatures with no metadata. (When metadata is present,
     // it's still used to eliminate keys.)
     case 'A':
         nCount = m_AuthentKey.GetPublicKeyBySignature(listOutput, theSignature,
                                                       true);
         break; // bInclusive=true
     case 'E':
         nCount = m_EncryptKey.GetPublicKeyBySignature(listOutput, theSignature,
                                                       true);
         break; // bInclusive=true
     case 'S':
         nCount = m_SigningKey.GetPublicKeyBySignature(listOutput, theSignature,
                                                       true);
         break; // bInclusive=true
     default:
         otErr << __FUNCTION__
               << ": Unexpected value for cKeyType (should be 0, A, E, or S): "
               << cKeyType << "\n";
         return 0;
     }
     return nCount;
 }

bool opentxs::OTKeyCredential::ReEncryptKeys	(	const OTPassword &	theExportPassword,
		bool	bImporting
	)

Definition at line 673 of file OTKeyCredential.cpp.

 {
     OTString strSign, strAuth, strEncr;
 
     const bool bSign =
         m_SigningKey.ReEncrypt(theExportPassword, bImporting, strSign);
     bool bAuth = false;
     bool bEncr = false;
 
     if (bSign) {
         bAuth = m_AuthentKey.ReEncrypt(theExportPassword, bImporting, strAuth);
 
         if (bAuth)
             bEncr =
                 m_EncryptKey.ReEncrypt(theExportPassword, bImporting, strEncr);
     }
 
     const bool bSuccessReEncrypting = (bSign && bAuth && bEncr);
     bool bSuccess = false;
 
     // If success, we now have the updated versions of the private certs.
     //
     if (bSuccessReEncrypting) {
         OTString::Map mapPrivate;
 
         for (auto& it : m_mapPrivateInfo) {
             std::string str_key_type = it.first; // A, E, S.
             std::string str_key_contents = it.second;
 
             if ("A" == str_key_type) {
                 mapPrivate.insert(
                     std::pair<std::string, std::string>("A", strAuth.Get()));
             }
             else if ("E" == str_key_type)
                 mapPrivate.insert(
                     std::pair<std::string, std::string>("E", strEncr.Get()));
             else if ("S" == str_key_type)
                 mapPrivate.insert(
                     std::pair<std::string, std::string>("S", strSign.Get()));
 
             else // Should never happen, but if there are other keys here, we'll
                  // preserve 'em.
             {
                 mapPrivate.insert(std::pair<std::string, std::string>(
                     str_key_type, str_key_contents));
                 OT_FAIL; // really this should never happen.
             }
         }
 
         if (3 != mapPrivate.size())
             otErr << __FUNCTION__ << ": Unexpected, mapPrivate does not have "
                                      "exactly a size of 3. \n";
 
         else {
             // Logic: If I'm IMPORTING, bImporting is true, and that means the
             // Nym WAS
             // encrypted to its own external passphrase (whenever it was
             // exported) and
             // in order to IMPORT it, I re-encrypted all the keys from the
             // exported passphrase,
             // to the wallet master key (this was done above in ReEncrypt.)
             // So now that I am loading up the private contents again based on
             // those
             // re-encrypted keys, I will want to use the normal wallet master
             // key to load
             // them. (So I pass nullptr.)
             //
             // But if I'm EXPORTING, bImporting is false, and that means the Nym
             // WAS
             // encrypted to the wallet's master passphrase, until just above
             // when I ReEncrypted
             // it to its own external passphrase. So now that I am attempting to
             // reload the
             // keys based on this new external passphrase, I need to pass it in
             // so it can be
             // used for that loading. (So I pass &theExportPassword.)
             //
             bSuccess = SetPrivateContents(
                 mapPrivate, bImporting ? nullptr : &theExportPassword);
         }
     }
 
     return bSuccess; // Note: Caller must re-sign credential after doing this,
                      // to keep these changes.
 }

void opentxs::OTKeyCredential::Release ( )

virtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 299 of file OTKeyCredential.cpp.

 {
     Release_Subkey(); // My own cleanup is done here.
 
     // Next give the base class a chance to do the same...
     ot_super::Release(); // since I've overridden the base class, I call it
                          // now...
 }

void opentxs::OTKeyCredential::Release_Subkey ( )

Definition at line 308 of file OTKeyCredential.cpp.

 {
     // Release any dynamically allocated members here. (Normally.)
 }

void opentxs::OTKeyCredential::SetMetadata ( )

virtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 760 of file OTKeyCredential.cpp.

 {
     char cMetaKeyType;     // Can be A, E, or S (authentication, encryption, or
                            // signing. Also, E would be unusual.)
     char cMetaNymID = '0'; // Can be any letter from base62 alphabet. Represents
                            // first letter of a Nym's ID.
     char cMetaMasterCredID = '0'; // Can be any letter from base62 alphabet.
                                   // Represents first letter of a Master
                                   // Credential ID (for that Nym.)
     char cMetaSubCredID = '0';    // Can be any letter from base62 alphabet.
     // Represents first letter of a SubCredential ID
     // (signed by that Master.)
 
     OTString strSubcredID;
     GetIdentifier(strSubcredID);
 
     const bool bNymID = GetNymID().At(0, cMetaNymID);
     const bool bCredID = m_pOwner->GetMasterCredID().At(0, cMetaMasterCredID);
     const bool bSubID =
         strSubcredID.At(0, cMetaSubCredID); // In the case of the master
                                             // credential, this will repeat the
                                             // previous one.
 
     if (!bNymID || !bCredID || !bSubID) {
         otWarn << __FUNCTION__ << ": No metadata available:\n "
                << "bNymID"
                << " is " << (bNymID ? "True" : "False") << ", "
                << "bCredID"
                << " is " << (bNymID ? "True" : "False") << ", "
                << "bSubID"
                << " is " << (bNymID ? "True" : "False") << "";
     }
 
     OTSignatureMetadata theMetadata;
 
     cMetaKeyType = 'A';
     theMetadata.SetMetadata(cMetaKeyType, cMetaNymID, cMetaMasterCredID,
                             cMetaSubCredID);
     m_AuthentKey.SetMetadata(theMetadata);
 
     cMetaKeyType = 'E';
     theMetadata.SetMetadata(cMetaKeyType, cMetaNymID, cMetaMasterCredID,
                             cMetaSubCredID);
     m_EncryptKey.SetMetadata(theMetadata);
 
     cMetaKeyType = 'S';
     theMetadata.SetMetadata(cMetaKeyType, cMetaNymID, cMetaMasterCredID,
                             cMetaSubCredID);
     m_SigningKey.SetMetadata(theMetadata);
 }

bool opentxs::OTKeyCredential::SetPrivateContents	(	const OTString::Map &	mapPrivate,
		const OTPassword *	pImportPassword = `nullptr`
	)

protectedvirtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 488 of file OTKeyCredential.cpp.

 {
 
     if (mapPrivate.size() != 3) {
         otErr << __FILE__ << " line " << __LINE__
               << ": Failure: Expected 3 in mapPrivate(), but the actual value "
                  "was: " << mapPrivate.size() << "\n";
         return false;
     }
 
     auto itAuth = mapPrivate.find("A"); // Authentication key
     if (mapPrivate.end() == itAuth) {
         otErr << __FILE__ << " line " << __LINE__
               << ": Failure: Unable to find private authentication key.\n";
         return false;
     }
 
     auto itEncr = mapPrivate.find("E"); // Encryption key
     if (mapPrivate.end() == itEncr) {
         otErr << __FILE__ << " line " << __LINE__
               << ": Failure: Unable to find private encryption key.\n";
         return false;
     }
 
     auto itSign = mapPrivate.find("S"); // Signing key
     if (mapPrivate.end() == itSign) {
         otErr << __FILE__ << " line " << __LINE__
               << ": Failure: Unable to find private signing key.\n";
         return false;
     }
 
     if (ot_super::SetPrivateContents(mapPrivate, pImportPassword)) {
         const OTString strReason("Loading private key from credential.");
         OTString::Map mapPublic;
 
         OTString strPrivate;
         strPrivate.Set(itAuth->second.c_str()); // strPrivate now contains the
                                                 // private Cert string.
 
         if (false ==
             m_AuthentKey.LoadPrivateKeyFromCertString(
                 strPrivate, false /*bEscaped true by default*/, &strReason,
                 pImportPassword)) {
             otErr << __FILE__ << " line " << __LINE__
                   << ": Failure: Unable to set private authentication key "
                      "based on string.\n";
             //          otErr << __FILE__ << " line " << __LINE__ <<
             //            ": Failure: Unable to set private authentication key
             // based on string:\n" << strPrivate << "\n";
             return false;
         }
         else // Success loading the private key. Let's grab the public key
                // here.
         {
             OTString strPublic;
 
             if ((false ==
                  m_AuthentKey.LoadPublicKeyFromCertString(
                      strPrivate, false /* bEscaped true by default */,
                      &strReason, pImportPassword)) ||
                 (false ==
                  m_AuthentKey.GetPublicKey(
                      strPublic, false /* bEscaped true by default */))) {
                 otErr << __FILE__ << " line " << __LINE__
                       << ": Failure: Unable to set public authentication key "
                          "based on private string.\n";
                 //              otErr << __FILE__ << " line " << __LINE__ <<
                 //                ": Failure: Unable to set public
                 // authentication key based on private string:\n" << strPrivate
                 // << "\n";
                 return false;
             }
             mapPublic.insert(
                 std::pair<std::string, std::string>("A", strPublic.Get()));
         }
 
         strPrivate.Release();
         strPrivate.Set(itEncr->second.c_str());
 
         if (false ==
             m_EncryptKey.LoadPrivateKeyFromCertString(
                 strPrivate, false /*bEscaped true by default*/, &strReason,
                 pImportPassword)) {
             otErr << __FILE__ << " line " << __LINE__
                   << ": Failure: Unable to set private encryption key based on "
                      "string.\n";
             //          otErr << __FILE__ << " line " << __LINE__ <<
             //            ": Failure: Unable to set private encryption key based
             // on string:\n" << strPrivate << "\n";
             return false;
         }
         else // Success loading the private key. Let's grab the public key
                // here.
         {
             OTString strPublic;
 
             if ((false ==
                  m_EncryptKey.LoadPublicKeyFromCertString(
                      strPrivate, false /* bEscaped true by default */,
                      &strReason, pImportPassword)) ||
                 (false ==
                  m_EncryptKey.GetPublicKey(
                      strPublic, false /* bEscaped true by default */))) {
                 otErr << __FILE__ << " line " << __LINE__
                       << ": Failure: Unable to set public encryption key based "
                          "on private string.\n";
                 //              otErr << __FILE__ << " line " << __LINE__ <<
                 //                ": Failure: Unable to set public encryption
                 // key based on private string:\n" << strPrivate << "\n";
                 return false;
             }
             mapPublic.insert(
                 std::pair<std::string, std::string>("E", strPublic.Get()));
         }
 
         strPrivate.Release();
         strPrivate.Set(itSign->second.c_str());
 
         if (false ==
             m_SigningKey.LoadPrivateKeyFromCertString(
                 strPrivate, false /*bEscaped true by default*/, &strReason,
                 pImportPassword)) {
             otErr << __FILE__ << " line " << __LINE__
                   << ": Failure: Unable to set private signing key based on "
                      "string.\n";
             //          otErr << __FILE__ << " line " << __LINE__ <<
             //            ": Failure: Unable to set private signing key based on
             // string:\n" << strPrivate << "\n";
             return false;
         }
         else // Success loading the private key. Let's grab the public key
                // here.
         {
             OTString strPublic;
 
             if ((false ==
                  m_SigningKey.LoadPublicKeyFromCertString(
                      strPrivate, false /* bEscaped true by default */,
                      &strReason, pImportPassword)) ||
                 (false ==
                  m_SigningKey.GetPublicKey(
                      strPublic, false /* bEscaped true by default */))) {
                 otErr << __FILE__ << " line " << __LINE__
                       << ": Failure: Unable to set public signing key based on "
                          "private string.\n";
                 //              otErr << __FILE__ << " line " << __LINE__ <<
                 //                ": Failure: Unable to set public signing key
                 // based on private string:\n" << strPrivate << "\n";
                 return false;
             }
             mapPublic.insert(
                 std::pair<std::string, std::string>("S", strPublic.Get()));
         }
 
         if (!ot_super::SetPublicContents(mapPublic)) {
             otErr << __FILE__ << " line " << __LINE__
                   << ": Failure: While trying to call: "
                      "ot_super::SetPublicContents(mapPublic)\n"; // Should never
                                                                  // happen (it
                                                                  // always just
                                                                  // returns
                                                                  // true.)
             return false;
         }
 
         return true; // SUCCESS! This means the input, mapPrivate, actually
                      // contained an "A" key, an "E"
         // key, and an "S" key (and nothing else) and that all three of those
         // private keys actually loaded
         // from string form into their respective key object members. We also
         // set the public keys in here, FYI.
     }
 
     return false;
 }

bool opentxs::OTKeyCredential::SetPublicContents ( const OTString::Map & mapPublic )

protectedvirtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 399 of file OTKeyCredential.cpp.

 {
     // NOTE: We might use this on the server side, we'll see, but so far on the
     // client
     // side, we won't need to use this function, since SetPrivateContents
     // already does
     // the dirty work of extracting the public keys and setting them.
     //
 
     if (mapPublic.size() != 3) {
         otErr << __FILE__ << " line " << __LINE__
               << ": Failure: Expected 3 in mapPublic.size(), but the actual "
                  "value was: " << mapPublic.size() << "\n";
         return false;
     }
 
     auto itAuth = mapPublic.find("A"); // Authentication key
     if (mapPublic.end() == itAuth) {
         otErr << __FILE__ << " line " << __LINE__
               << ": Failure: Unable to find public authentication key.\n";
         return false;
     }
 
     auto itEncr = mapPublic.find("E"); // Encryption key
     if (mapPublic.end() == itEncr) {
         otErr << __FILE__ << " line " << __LINE__
               << ": Failure: Unable to find public encryption key.\n";
         return false;
     }
 
     auto itSign = mapPublic.find("S"); // Signing key
     if (mapPublic.end() == itSign) {
         otErr << __FILE__ << " line " << __LINE__
               << ": Failure: Unable to find public signing key.\n";
         return false;
     }
 
     if (ot_super::SetPublicContents(mapPublic)) {
 
         OTString strKey;
         strKey.Set(itAuth->second.c_str());
         if (!m_AuthentKey.SetPublicKey(strKey)) {
             otErr << __FILE__ << " line " << __LINE__
                   << ": Failure: Unable to set public authentication key based "
                      "on string:\n" << strKey << "\n";
             return false;
         }
 
         strKey.Release();
         strKey.Set(itEncr->second.c_str());
         if (!m_EncryptKey.SetPublicKey(strKey)) {
             otErr << __FILE__ << " line " << __LINE__
                   << ": Failure: Unable to set public encryption key based on "
                      "string:\n" << strKey << "\n";
             return false;
         }
 
         strKey.Release();
         strKey.Set(itSign->second.c_str());
         if (!m_SigningKey.SetPublicKey(strKey)) {
             otErr << __FILE__ << " line " << __LINE__
                   << ": Failure: Unable to set public signing key based on "
                      "string:\n" << strKey << "\n";
             return false;
         }
 
         return true; // SUCCESS! This means the input, mapPublic, actually
                      // contained an "A" key, an "E"
         // key, and an "S" key (and nothing else) and that all three of those
         // public keys actually loaded
         // from string form into their respective key object members.
     }
 
     return false;
 }

bool opentxs::OTKeyCredential::Sign	(	OTContract &	theContract,
		const OTPasswordData *	pPWData = `nullptr`
	)

Definition at line 667 of file OTKeyCredential.cpp.

 {
     return m_SigningKey.SignContract(theContract, pPWData);
 }

bool opentxs::OTKeyCredential::VerifyInternally ( )

virtual

Reimplemented from opentxs::OTSubcredential.

Reimplemented in opentxs::OTMasterkey.

Definition at line 265 of file OTKeyCredential.cpp.

 {
     // Verify that m_strNymID is the same as the hash of m_strSourceForNymID.
     if (!ot_super::VerifyInternally()) return false;
 
     // Any OTKeyCredential (both master and subkeys, but no other credentials)
     // must ** sign itself.**
     //
     if (!VerifySignedBySelf()) {
         otOut << __FUNCTION__ << ": Failed verifying key credential: it's not "
                                  "signed by itself (its own signing key.)\n";
         return false;
     }
 
     return true;
 }

bool opentxs::OTKeyCredential::VerifySignedBySelf ( )

Definition at line 159 of file OTKeyCredential.cpp.

 {
     return VerifyWithKey(m_SigningKey.GetPublicKey());
 }

Friends And Related Function Documentation

friend class OTCredential

friend

Definition at line 253 of file OTKeyCredential.hpp.

Member Data Documentation

OTKeypair opentxs::OTKeyCredential::m_AuthentKey

Definition at line 266 of file OTKeyCredential.hpp.

OTKeypair opentxs::OTKeyCredential::m_EncryptKey

Definition at line 268 of file OTKeyCredential.hpp.

OTKeypair opentxs::OTKeyCredential::m_SigningKey

Definition at line 264 of file OTKeyCredential.hpp.

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

/usr/local/src/opentxs/include/opentxs/core/crypto/OTKeyCredential.hpp
/usr/local/src/opentxs/src/core/crypto/OTKeyCredential.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation