#include <OTMasterkey.hpp>

Inheritance diagram for opentxs::OTMasterkey:

Collaboration diagram for opentxs::OTMasterkey:

Public Member Functions
virtual bool	VerifyInternally ()

bool	VerifyAgainstSource () const

bool	VerifySource_HTTP (const OTString strSource) const

bool	VerifySource_HTTPS (const OTString strSource) const

bool	VerifySource_Bitcoin (const OTString strSource) const

bool	VerifySource_Namecoin (const OTString strSource) const

bool	VerifySource_Freenet (const OTString strSource) const

bool	VerifySource_TOR (const OTString strSource) const

bool	VerifySource_I2P (const OTString strSource) const

bool	VerifySource_CA (const OTString strSource) const

bool	VerifySource_Pubkey (const OTString strSource) const

	OTMasterkey ()

	OTMasterkey (OTCredential &theOwner)

virtual	~OTMasterkey ()

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)

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 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 179 of file OTMasterkey.hpp.

Constructor & Destructor Documentation

opentxs::OTMasterkey::OTMasterkey ( )

Definition at line 529 of file OTMasterkey.cpp.

     : ot_super()
 {
     m_strContractType = "MASTER KEY CREDENTIAL";
 }

opentxs::OTMasterkey::OTMasterkey ( OTCredential & theOwner )

Definition at line 535 of file OTMasterkey.cpp.

     : ot_super(theOwner)
 {
     m_strContractType = "MASTER KEY CREDENTIAL";
 }

opentxs::OTMasterkey::~OTMasterkey ( )

virtual

Definition at line 541 of file OTMasterkey.cpp.

542 {

543 }

Member Function Documentation

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

virtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 163 of file OTMasterkey.cpp.

 {
     int32_t nReturnVal = ot_super::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 (0 != nReturnVal) return nReturnVal;
     // else it was 0 (continue...)
 
     const OTString strNodeName(xml->getNodeName());
 
     if (strNodeName.Compare("masterCredential")) {
         m_strNymID = xml->getAttributeValue("nymID");
 
         m_strMasterCredID.Release();
 
         otWarn << "Loading masterCredential...\n";
 
         nReturnVal = 1;
     }
 
     return nReturnVal;
 }

void opentxs::OTMasterkey::UpdateContents ( )

virtual

Reimplemented from opentxs::OTSubcredential.

Definition at line 194 of file OTMasterkey.cpp.

 {
     m_xmlUnsigned.Release();
 
     m_xmlUnsigned.Concatenate(
         "<masterCredential nymID=\"%s\" >\n\n", // a hash of the nymIDSource
         GetNymID().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());
     }
 
     // PUBLIC INFO
     //
     //  if (OTSubcredential::credPublicInfo == m_StoreAs)   // PUBLIC INFO
     // (Always save this in every state.)
     {
         UpdatePublicContentsToString(m_xmlUnsigned);
     }
 
     // PRIVATE INFO
     //
     // If we're saving the private credential info...
     //
     if (OTSubcredential::credPrivateInfo == m_StoreAs) // PRIVATE INFO
     {
         UpdatePublicCredentialToString(m_xmlUnsigned);
 
         UpdatePrivateContentsToString(m_xmlUnsigned);
     }
     // -------------------------------------------------
     m_xmlUnsigned.Concatenate("</masterCredential>\n");
 
     m_StoreAs = OTSubcredential::credPrivateInfo; // <=== SET IT BACK TO DEFAULT
                                                   // BEHAVIOR. Any other state
                                                   // processes ONCE, and then
                                                   // goes back to this again.
 }

bool opentxs::OTMasterkey::VerifyAgainstSource ( ) const

Definition at line 297 of file OTMasterkey.cpp.

 {
     // RULE: *Any* source except for a public key, will begin with a
     // protocol specifier. Such as:
     //
     // http:        (a normal URL)
     // https:       (a normal URL on https)
     // bitcoin:     (a bitcoin address)
     // namecoin:    (a namecoin address)
     // i2p:         (an i2p address)
     // tor:         (a tor address)
     // freenet:     (a freenet address)
     // cert:        (Subject and Issuer DN from the cert)
     //
     // If NO protocol specifier is found, the source is assumed
     // to be a public key.
     // Public key is the default because that's the original behavior
     // of OT anyway: the public key was hashed to form the NymID. We will
     // continue to support this as a default, but now we are additionally
     // also allowing other sources such as Namecoin, Freenet, etc. As int64_t
     // as a Nym's source hashes to its correct ID, and as long as its master
     // credentials can be verified from that same source, then all master
     // credentials can be verified (as well as subcredentials) from any source
     // the user prefers.
     //
 
     bool bVerified = false;
 
     const std::string str_raw_source(m_strSourceForNymID.Get());
     std::string str_source;
 
     // It's a URL.
     if (str_raw_source.compare(0, 5, "http:") == 0) {
         str_source.insert(str_source.begin(), str_raw_source.begin() + 5,
                           str_raw_source.end());
         bVerified = VerifySource_HTTP(str_source.c_str());
     }
     else if (str_raw_source.compare(0, 6, "https:") == 0) {
         str_source.insert(str_source.begin(), str_raw_source.begin() + 6,
                           str_raw_source.end());
         bVerified = VerifySource_HTTPS(str_source.c_str());
     }
     // It's a Bitcoin address.
     else if (str_raw_source.compare(0, 8, "bitcoin:") == 0) {
         str_source.insert(str_source.begin(), str_raw_source.begin() + 8,
                           str_raw_source.end());
         bVerified = VerifySource_Bitcoin(str_source.c_str());
     }
     // It's a Namecoin address.
     else if (str_raw_source.compare(0, 9, "namecoin:") == 0) {
         str_source.insert(str_source.begin(), str_raw_source.begin() + 9,
                           str_raw_source.end());
         bVerified = VerifySource_Namecoin(str_source.c_str());
     }
     // It's a Freenet URL.
     else if (str_raw_source.compare(0, 8, "freenet:") == 0) {
         str_source.insert(str_source.begin(), str_raw_source.begin() + 8,
                           str_raw_source.end());
         bVerified = VerifySource_Freenet(str_source.c_str());
     }
     // It's a Tor URL.
     else if (str_raw_source.compare(0, 4, "tor:") == 0) {
         str_source.insert(str_source.begin(), str_raw_source.begin() + 4,
                           str_raw_source.end());
         bVerified = VerifySource_TOR(str_source.c_str());
     }
     // It's an I2P URL.
     else if (str_raw_source.compare(0, 4, "i2p:") == 0) {
         str_source.insert(str_source.begin(), str_raw_source.begin() + 4,
                           str_raw_source.end());
         bVerified = VerifySource_I2P(str_source.c_str());
     }
     // It's the Issuer/Subject DN info from a cert issued by a traditional
     // certificate authority.
     else if (str_raw_source.compare(0, 5, "cert:") == 0) {
         str_source.insert(str_source.begin(), str_raw_source.begin() + 5,
                           str_raw_source.end());
         bVerified = VerifySource_CA(str_source.c_str());
     }
     else // It's presumably a public key.
     {
         str_source = str_raw_source;
         bVerified = VerifySource_Pubkey(str_source.c_str());
     }
 
     return bVerified;
 }

bool opentxs::OTMasterkey::VerifyInternally ( )

virtual

Reimplemented from opentxs::OTKeyCredential.

Definition at line 245 of file OTMasterkey.cpp.

 {
     // Verify that m_strNymID is the same as the hash of m_strSourceForNymID.
     //
     // We can't use super here, since OTSubcredential::VerifyInternally will
     // verify
     // m_strMasterCredID against the actual Master, which is not relevant to us
     // in
     // OTMasterkey. But this means if we need anything else that
     // OTKeyCredential::VerifyInternally
     // was doing, we will have to duplicate that here as well...
     //  if (!ot_super::VerifyInternally())
     //      return false;
     if (!VerifyNymID()) return false;
 
     OT_ASSERT(nullptr != m_pOwner);
     // Verify that *this == m_pOwner->GetMasterkey() (the master credential.)
     //
     if (this != &(m_pOwner->GetMasterkey())) {
         otOut << __FUNCTION__ << ": Failure: Expected *this object to be the "
                                  "same as m_pOwner->GetMasterkey(), "
                                  "but it wasn't.\n";
         return false;
     }
 
     // Remember this note above: ...if we need anything else that
     // OTKeyCredential::VerifyInternally
     // was doing, we will have to duplicate that here as well...
     // Since we aren't calling OTKeyCredential::VerifyInternally (the super) and
     // since that function
     // verifies that the credential is self-signed, we must do the same
     // verification here:
     //
     // Any OTKeyCredential (both master and subkeys, but no other credentials)
     // must ** sign itself.**
     //
     if (!VerifySignedBySelf()) {
         otOut << __FUNCTION__ << ": Failed verifying master credential: it's "
                                  "not signed by itself (its own signing "
                                  "key.)\n";
         return false;
     }
 
     return true;
 }

bool opentxs::OTMasterkey::VerifySource_Bitcoin ( const OTString strSource ) const

Definition at line 427 of file OTMasterkey.cpp.

 {
     /*
      The source is a Bitcoin address
      The last transfer from that address should have memo data with the hash of
      the master credential.
      I compare that to my own ID and they should match.
      Alternately, to support multiple master credentials, have the last transfer
      go to multiple addresses,
      and each should have a memo with the master cred ID for each credential,
      one of which should match my own.
      If so, then I verify.
      */
 
     otErr << __FUNCTION__ << ": Failure: this function has not yet been "
                              "written, so this Bitcoin source cannot be "
                              "verified.\n";
     //    return false;
 
     // Todo security
     otErr << "\nNOTE: Returning TRUE for TESTING PURPOSES, as if Bitcoin had "
              "verified."
              "\n\n\n ----------------------- \n\n";
 
     return true;
 }

bool opentxs::OTMasterkey::VerifySource_CA ( const OTString strSource ) const

Definition at line 499 of file OTMasterkey.cpp.

 {
 
     /*
      The Source is the DN info on the Cert.
      Therefore look at the Cert being used in this Masterkey.
      Does it have the same DN info? Does it verify through its CA ?
      Then it verifies.
      */
 
     otErr << __FUNCTION__ << ": Failure: this function has not yet been "
                              "written, so this CA source cannot be verified.\n";
     return false;
 }

bool opentxs::OTMasterkey::VerifySource_Freenet ( const OTString strSource ) const

Definition at line 475 of file OTMasterkey.cpp.

 {
     otErr << __FUNCTION__ << ": Failure: this function has not yet been "
                              "written, so this Freenet source cannot be "
                              "verified.\n";
     return false;
 }

bool opentxs::OTMasterkey::VerifySource_HTTP ( const OTString strSource ) const

Definition at line 385 of file OTMasterkey.cpp.

 {
     /*
      The source is a URL, http://blah.com/folder
      If I download files from there, will I find my own masterkey inside?
      If so, then I verify.
      */
 
     otErr << __FUNCTION__ << ": Failure: this function has not yet been "
                              "written, so this HTTP source cannot be "
                              "verified.\n";
     //    return false;
 
     // Todo security
     otErr << "\nNOTE: Returning TRUE for TESTING PURPOSES, as if HTTP source "
              "had verified."
              "\n\n\n ----------------------- \n\n";
 
     return true;
 }

bool opentxs::OTMasterkey::VerifySource_HTTPS ( const OTString strSource ) const

Definition at line 406 of file OTMasterkey.cpp.

 {
     /*
      The source is a URL, https://blah.com/folder
      If I download files from there, will I find my own masterkey inside?
      If so, then I verify.
      */
 
     otErr << __FUNCTION__ << ": Failure: this function has not yet been "
                              "written, so this HTTPS source cannot be "
                              "verified.\n";
     //    return false;
 
     // Todo security
     otErr << "\nNOTE: Returning TRUE for TESTING PURPOSES, as if HTTPS source "
              "had verified."
              "\n\n\n ----------------------- \n\n";
 
     return true;
 }

bool opentxs::OTMasterkey::VerifySource_I2P ( const OTString strSource ) const

Definition at line 491 of file OTMasterkey.cpp.

 {
     otErr << __FUNCTION__ << ": Failure: this function has not yet been "
                              "written, so this I2P source cannot be "
                              "verified.\n";
     return false;
 }

bool opentxs::OTMasterkey::VerifySource_Namecoin ( const OTString strSource ) const

Definition at line 454 of file OTMasterkey.cpp.

 {
     /*
      The source is a URL, http://blah.bit/folder
      If I download files from there, will I find my own masterkey inside?
      If so, then I verify.
      */
 
     otErr << __FUNCTION__ << ": Failure: this function has not yet been "
                              "written, so this Namecoin source cannot be "
                              "verified.\n";
     //    return false;
 
     // Todo security
     otErr << "\nNOTE: Returning TRUE for TESTING PURPOSES, as if Namecoin had "
              "verified."
              "\n\n\n ----------------------- \n\n";
 
     return true;
 }

bool opentxs::OTMasterkey::VerifySource_Pubkey ( const OTString strSource ) const

Definition at line 514 of file OTMasterkey.cpp.

 {
     // Verify signed by self.
     //
     // Note: Whenever VerifyAgainstSource is called, VerifyInternally is also
     // called.
     // And VerifyInternally, for all OTKeyCredentials, verifies already that the
     // credential has been signed by its own private signing key.
     // Since the credential is already verified as having signed itself, there's
     // no
     // reason to verify that redundantly here, so we just return true.
     //
     return true;
 }

bool opentxs::OTMasterkey::VerifySource_TOR ( const OTString strSource ) const

Definition at line 483 of file OTMasterkey.cpp.

 {
     otErr << __FUNCTION__ << ": Failure: this function has not yet been "
                              "written, so this Tor source cannot be "
                              "verified.\n";
     return false;
 }

Friends And Related Function Documentation

friend class OTCredential

friend

Definition at line 183 of file OTMasterkey.hpp.

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

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

Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation