#include <OTSubkey.hpp>

Inheritance diagram for opentxs::OTSubkey:

Collaboration diagram for opentxs::OTSubkey:

Public Member Functions
	OTSubkey ()

	OTSubkey (OTCredential &other)

virtual	~OTSubkey ()

virtual bool	VerifySignedByMaster ()

virtual void	UpdateContents ()

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

Public Member Functions inherited from opentxs::OTKeyCredential
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

void	SetOwner (OTCredential &theOwner)

	OTSubcredential ()

	OTSubcredential (OTCredential &theOwner)

virtual	~OTSubcredential ()

void	Release_Subcredential ()

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

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)

Public Attributes inherited from opentxs::OTKeyCredential
OTKeypair	m_SigningKey

OTKeypair	m_AuthentKey

OTKeypair	m_EncryptKey

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

Protected Member Functions inherited from opentxs::OTKeyCredential
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 ()

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

Definition at line 177 of file OTSubkey.hpp.

Constructor & Destructor Documentation

opentxs::OTSubkey::OTSubkey ( )

Definition at line 161 of file OTSubkey.cpp.

     : OTKeyCredential()
 {
     m_strContractType = "KEY CREDENTIAL";
 }

opentxs::OTSubkey::OTSubkey ( OTCredential & other )

Definition at line 167 of file OTSubkey.cpp.

     : OTKeyCredential(other)
 {
     m_strContractType = "KEY CREDENTIAL";
 }

opentxs::OTSubkey::~OTSubkey ( )

virtual

Definition at line 173 of file OTSubkey.cpp.

174 {

175 }

Member Function Documentation

int32_t opentxs::OTSubkey::ProcessXMLNode ( irr::io::IrrXMLReader *& xml )

virtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 177 of file OTSubkey.cpp.

 {
     int32_t retval = OTKeyCredential::ProcessXMLNode(xml);
 
     // Here we call the parent class first.
     // If the node is found there, or there is some error,
     // then we just return either way.  But if it comes back
     // as '0', then nothing happened, and we'll continue executing.
     //
     // -- Note you can choose not to call the parent if
     // you don't want to use any of those xml tags.
     // As I do in the case of OTAccount.
     if (retval != 0) return retval;
 
     OTString nodeName(xml->getNodeName());
     if (nodeName.Compare("keyCredential")) {
         m_strNymID = xml->getAttributeValue("nymID");
         m_strMasterCredID = xml->getAttributeValue("masterCredentialID");
 
         OTLog::Output(1, "Loading keyCredential...\n");
         retval = 1;
     }
     else if (nodeName.Compare("masterSigned")) {
         if (!OTContract::LoadEncodedTextField(xml, m_strMasterSigned)) {
             OTLog::vError("Error in %s line %d: failed loading expected "
                           "master-signed version while loading "
                           "keyCredential.\n",
                           __FILE__, __LINE__);
             return -1;
         }
         retval = 1;
     }
     return retval;
 }

void opentxs::OTSubkey::UpdateContents ( )

virtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 212 of file OTSubkey.cpp.

 {
     m_xmlUnsigned.Release();
 
     m_xmlUnsigned.Concatenate(
         "<keyCredential nymID=\"%s\"\n"     // a hash of the nymIDSource
         " masterCredentialID=\"%s\" >\n\n", // Hash of the master credential
                                             // that signed this subcredential.
         GetNymID().Get(),
         GetMasterCredID().Get());
 
     if (GetNymIDSource().Exists()) {
         OTASCIIArmor ascSource;
         ascSource.SetString(GetNymIDSource()); // A nym should always
                                                // verify through its own
                                                // source. (Whatever that
                                                // may be.)
         m_xmlUnsigned.Concatenate("<nymIDSource>\n%s</nymIDSource>\n\n",
                                   ascSource.Get());
     }
     // MASTER-SIGNED INFO
     if (OTSubcredential::credMasterSigned == m_StoreAs ||
         OTSubcredential::credPrivateInfo == m_StoreAs) {
         UpdateMasterPublicToString(m_xmlUnsigned);
         UpdatePublicContentsToString(m_xmlUnsigned);
     }
     // PUBLIC INFO (signed by subkey, contains master signed info.)
     if (OTSubcredential::credPublicInfo == m_StoreAs ||
         OTSubcredential::credPrivateInfo == m_StoreAs) {
         // GetMasterSigned() returns the contract
         // containing the master-signed contents
         // from the above block.
         OTASCIIArmor ascMasterSigned(GetMasterSigned());
         m_xmlUnsigned.Concatenate(
             "<masterSigned>\n%s</masterSigned>\n\n", // Contains all the public
                                                      // info, signed by the
                                                      // master key.
             ascMasterSigned.Get()); // Packaged up here inside a final,
                                     // subkey-signed credential.
     }
     // PRIVATE INFO
     //
     // If we're saving the private credential info...
     if (OTSubcredential::credPrivateInfo == m_StoreAs) {
         UpdatePublicCredentialToString(m_xmlUnsigned);
         UpdatePrivateContentsToString(m_xmlUnsigned);
     }
 
     // <=== SET IT BACK TO DEFAULT BEHAVIOR. Any other state
     // processes ONCE, and then goes back to this again.
     m_xmlUnsigned.Concatenate("</keyCredential>\n");
     m_StoreAs = OTSubcredential::credPrivateInfo;
 }

bool opentxs::OTSubkey::VerifySignedByMaster ( )

virtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 266 of file OTSubkey.cpp.

 {
     // See if m_strMasterSigned was signed by my master credential.
     OTSubkey masterKey(*m_pOwner);
 
     if (m_strMasterSigned.Exists() &&
         masterKey.LoadContractFromString(m_strMasterSigned)) {
         // Here we need to MAKE SURE that the "master signed" version contains
         // the same CONTENTS as the actual version.
         if (!GetNymID().Compare(masterKey.GetNymID())) {
             OTLog::vOutput(0, "%s: Failure, NymID of this key credential "
                               "doesn't match NymID of master-signed version of "
                               "this key credential.\n",
                            __FUNCTION__);
             return false;
         }
 
         if (!GetNymIDSource().Compare(masterKey.GetNymIDSource())) {
             OTLog::vOutput(0, "%s: Failure, NymIDSource of this key credential "
                               "doesn't match NymIDSource of master-signed "
                               "version of this key credential.\n",
                            __FUNCTION__);
             return false;
         }
 
         if (!GetMasterCredID().Compare(masterKey.GetMasterCredID())) {
             OTLog::vOutput(0, "%s: Failure, MasterCredID of this key "
                               "credential doesn't match MasterCredID of "
                               "master-signed version of this key credential.\n",
                            __FUNCTION__);
             return false;
         }
 
         if (GetPublicMap().size() > 0 &&
             GetPublicMap() != masterKey.GetPublicMap()) {
             OTLog::vOutput(0, "%s: Failure, public info of this key credential "
                               "doesn't match public info of master-signed "
                               "version of this key credential.\n",
                            __FUNCTION__);
             return false;
         }
 
         // Master-signed version of subkey does not contain the private keys,
         // since normally the master is signing
         // the public version of the sub credential (to validate it) and you
         // don't want the public seeing your private keys.
         // So we would never expect these to match, since the master signed
         // version should have no private keys in it.
         //
         //        if (GetPrivateMap() != masterKey.GetPrivateMap())
         //        {
         //            OTLog::vOutput(0, "%s: Failure, private info of this key
         // credential doesn't match private info of master-signed version of
         // this key credential.\n", __FUNCTION__);
         //            return false;
         //        }
 
         bool verifiedWithKey = masterKey.VerifyWithKey(
             m_pOwner->GetMasterkey().m_SigningKey.GetPublicKey());
 
         // ON SERVER SIDE, THE ACTUAL SUBKEY doesn't have any public key, only
         // the master-signed version of it.
         // (The master-signed version being basically the only contents of the
         // public version.)
         // So we need to be able to, after verifying, load up those contents so
         // they are available on the
         // subkey itself, and not just on some master-signed version of itself
         // hidden inside itself.
         // Otherwise I would have to load up the master-signed version anytime
         // the server-side wanted to
         // mess with any of the keys.
         // Thus: copy the public info from master signed, to* this, if the above
         // call was successful
         if (verifiedWithKey && GetPublicMap().size() == 0) {
             // For master credential.
             return SetPublicContents(masterKey.GetPublicMap());
         }
         return verifiedWithKey;
     }
     return false;
 }

Friends And Related Function Documentation

friend class OTCredential

friend

Definition at line 179 of file OTSubkey.hpp.

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

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

Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation