Open-Transactions  0.93.0-ge03d287
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
OTSubcredential.hpp
Go to the documentation of this file.
1 /************************************************************
2  *
3  * OTSubcredential.hpp
4  *
5  */
6 
7 /************************************************************
8  -----BEGIN PGP SIGNED MESSAGE-----
9  Hash: SHA1
10 
11  * OPEN TRANSACTIONS
12  *
13  * Financial Cryptography and Digital Cash
14  * Library, Protocol, API, Server, CLI, GUI
15  *
16  * -- Anonymous Numbered Accounts.
17  * -- Untraceable Digital Cash.
18  * -- Triple-Signed Receipts.
19  * -- Cheques, Vouchers, Transfers, Inboxes.
20  * -- Basket Currencies, Markets, Payment Plans.
21  * -- Signed, XML, Ricardian-style Contracts.
22  * -- Scripted smart contracts.
23  *
24  * Copyright (C) 2010-2013 by "Fellow Traveler" (A pseudonym)
25  *
26  * EMAIL:
28  *
29  * BITCOIN: 1NtTPVVjDsUfDWybS4BwvHpG2pdS9RnYyQ
30  *
31  * KEY FINGERPRINT (PGP Key in license file):
32  * 9DD5 90EB 9292 4B48 0484 7910 0308 00ED F951 BB8E
33  *
34  * OFFICIAL PROJECT WIKI(s):
35  * https://github.com/FellowTraveler/Moneychanger
36  * https://github.com/FellowTraveler/Open-Transactions/wiki
37  *
38  * WEBSITE:
39  * http://www.OpenTransactions.org/
40  *
41  * Components and licensing:
42  * -- Moneychanger..A Java client GUI.....LICENSE:.....GPLv3
43  * -- otlib.........A class library.......LICENSE:...LAGPLv3
44  * -- otapi.........A client API..........LICENSE:...LAGPLv3
45  * -- opentxs/ot....Command-line client...LICENSE:...LAGPLv3
46  * -- otserver......Server Application....LICENSE:....AGPLv3
47  * Github.com/FellowTraveler/Open-Transactions/wiki/Components
48  *
49  * All of the above OT components were designed and written by
50  * Fellow Traveler, with the exception of Moneychanger, which
51  * was contracted out to Vicky C ([email protected]).
52  * The open-source community has since actively contributed.
53  *
54  * -----------------------------------------------------
55  *
56  * LICENSE:
57  * This program is free software: you can redistribute it
58  * and/or modify it under the terms of the GNU Affero
59  * General Public License as published by the Free Software
60  * Foundation, either version 3 of the License, or (at your
61  * option) any later version.
62  *
63  * ADDITIONAL PERMISSION under the GNU Affero GPL version 3
64  * section 7: (This paragraph applies only to the LAGPLv3
65  * components listed above.) If you modify this Program, or
66  * any covered work, by linking or combining it with other
67  * code, such other code is not for that reason alone subject
68  * to any of the requirements of the GNU Affero GPL version 3.
69  * (==> This means if you are only using the OT API, then you
70  * don't have to open-source your code--only your changes to
71  * Open-Transactions itself must be open source. Similar to
72  * LGPLv3, except it applies to software-as-a-service, not
73  * just to distributing binaries.)
74  *
75  * Extra WAIVER for OpenSSL, Lucre, and all other libraries
76  * used by Open Transactions: This program is released under
77  * the AGPL with the additional exemption that compiling,
78  * linking, and/or using OpenSSL is allowed. The same is true
79  * for any other open source libraries included in this
80  * project: complete waiver from the AGPL is hereby granted to
81  * compile, link, and/or use them with Open-Transactions,
82  * according to their own terms, as long as the rest of the
83  * Open-Transactions terms remain respected, with regard to
84  * the Open-Transactions code itself.
85  *
86  * Lucre License:
87  * This code is also "dual-license", meaning that Ben Lau-
88  * rie's license must also be included and respected, since
89  * the code for Lucre is also included with Open Transactions.
90  * See Open-Transactions/src/otlib/lucre/LUCRE_LICENSE.txt
91  * The Laurie requirements are light, but if there is any
92  * problem with his license, simply remove the Lucre code.
93  * Although there are no other blind token algorithms in Open
94  * Transactions (yet. credlib is coming), the other functions
95  * will continue to operate.
96  * See Lucre on Github: https://github.com/benlaurie/lucre
97  * -----------------------------------------------------
98  * You should have received a copy of the GNU Affero General
99  * Public License along with this program. If not, see:
100  * http://www.gnu.org/licenses/
101  *
102  * If you would like to use this software outside of the free
103  * software license, please contact FellowTraveler.
104  * (Unfortunately many will run anonymously and untraceably,
105  * so who could really stop them?)
106  *
107  * DISCLAIMER:
108  * This program is distributed in the hope that it will be
109  * useful, but WITHOUT ANY WARRANTY; without even the implied
110  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
111  * PURPOSE. See the GNU Affero General Public License for
112  * more details.
113 
114  -----BEGIN PGP SIGNATURE-----
115  Version: GnuPG v1.4.9 (Darwin)
116 
117  iQIcBAEBAgAGBQJRSsfJAAoJEAMIAO35UbuOQT8P/RJbka8etf7wbxdHQNAY+2cC
118  vDf8J3X8VI+pwMqv6wgTVy17venMZJa4I4ikXD/MRyWV1XbTG0mBXk/7AZk7Rexk
119  KTvL/U1kWiez6+8XXLye+k2JNM6v7eej8xMrqEcO0ZArh/DsLoIn1y8p8qjBI7+m
120  aE7lhstDiD0z8mwRRLKFLN2IH5rAFaZZUvj5ERJaoYUKdn4c+RcQVei2YOl4T0FU
121  LWND3YLoH8naqJXkaOKEN4UfJINCwxhe5Ke9wyfLWLUO7NamRkWD2T7CJ0xocnD1
122  sjAzlVGNgaFDRflfIF4QhBx1Ddl6wwhJfw+d08bjqblSq8aXDkmFA7HeunSFKkdn
123  oIEOEgyj+veuOMRJC5pnBJ9vV+7qRdDKQWaCKotynt4sWJDGQ9kWGWm74SsNaduN
124  TPMyr9kNmGsfR69Q2Zq/FLcLX/j8ESxU+HYUB4vaARw2xEOu2xwDDv6jt0j3Vqsg
125  x7rWv4S/Eh18FDNDkVRChiNoOIilLYLL6c38uMf1pnItBuxP3uhgY6COm59kVaRh
126  nyGTYCDYD2TK+fI9o89F1297uDCwEJ62U0Q7iTDp5QuXCoxkPfv8/kX6lS6T3y9G
127  M9mqIoLbIQ1EDntFv7/t6fUTS2+46uCrdZWbQ5RjYXdrzjij02nDmJAm2BngnZvd
128  kamH0Y/n11lCvo1oQxM+
129  =uSzz
130  -----END PGP SIGNATURE-----
131  **************************************************************/
132 
133 #ifndef OPENTXS_CORE_CRYPTO_OTSUBCREDENTIAL_HPP
134 #define OPENTXS_CORE_CRYPTO_OTSUBCREDENTIAL_HPP
135 
136 #include "../OTContract.hpp"
137 
138 // A nym contains a list of master credentials, via OTCredential.
139 // The whole purpose of a Nym is to be an identity, which can have
140 // master credentials.
141 //
142 // Each credential is like a master key for the Nym's identity,
143 // which can issue its own subkeys.
144 //
145 // Each subkey has 3 key pairs: encryption, signing, and authentication.
146 // Not all subcredentials are a subkey. For example, you might have a
147 // subcredential that uses Google Authenticator, and thus doesn't contain
148 // any keys, because it uses alternate methods for its own authentication.
149 //
150 // Each OTCredential contains a "master" subkey, and a list of subcredentials
151 // (some of them subkeys) signed by that master.
152 //
153 // The same class (subcredential/subkey) is used because there are master
154 // credentials and subcredentials, so we're using inheritance for
155 // "subcredential"
156 // and "subkey" to encapsulate the credentials, so we don't have to repeat code
157 // across both.
158 // We're using a "has-a" model here, since the OTCredential "has a" master
159 // subkey, and also "has a" list of subcredentials, some of which are subkeys.
160 //
161 // Each subcredential must be signed by the subkey that is the master key.
162 // Each subkey has 3 key pairs: encryption, signing, and authentication.
163 //
164 // Each key pair has 2 OTAsymmetricKeys (public and private.)
165 //
166 // I'm thinking that the Nym should also have a key pair (for whatever is
167 // its current key pair, copied from its credentials.)
168 //
169 // the master should never be able to do any actions except for sign subkeys.
170 // the subkeys, meanwhile should only be able to do actions, and not issue
171 // any new keys.
172 
173 namespace opentxs
174 {
175 
176 class OTContract;
177 class OTCredential;
178 class OTIdentifier;
179 class OTPassword;
180 class OTString;
181 
182 // This is stored as an OTContract, and it must be signed by the
183 // master key. (which is also an OTSubcredential.)
184 //
186 {
187 private: // Private prevents erroneous use by other classes.
188  typedef OTContract ot_super;
189  friend class OTCredential;
190 
191 protected:
192  enum CredStoreAs {
194  0, // For saving the private keys, too. Default behavior.
195  credPublicInfo = 1, // For saving a version with public keys only.
196  credMasterSigned = 2 // For saving a version with the master signature
197  // included, so the subkey can then countersign on
198  // top of that. (To prove that the subkey
199  // authorizes the master key's signature.) Only
200  // used by subkeys.
201  };
202  CredStoreAs m_StoreAs; // Not serialized.
203 protected:
204  OTCredential* m_pOwner; // a pointer for convenience only. Do not cleanup.
205  OTString m_strMasterCredID; // All subcredentials within the same
206  // OTCredential share the same
207  // m_strMasterCredID. It's a hash of the signed
208  // master credential.
209  OTString m_strNymID; // All subcredentials within the same OTCredential
210  // (including m_MasterKey) must have
211  OTString m_strSourceForNymID; // the same NymID and source.
212  OTString::Map m_mapPublicInfo; // A map of strings containing the
213  // credential's public info. This was
214  // originally 1 string but subclasses ended
215  // up needing a map of them. Who'da thought.
216  OTString::Map m_mapPrivateInfo; // A map of strings containing the
217  // credential's private info. This was
218  // originally 1 string but subclasses ended
219  // up needing a map of them. Who'da thought.
220  OTString m_strMasterSigned; // A public version of the credential with the
221  // master credential's signature on it. (The
222  // final public version will contain the
223  // subkey's own signature on top of that.)
224  OTString m_strContents; // The actual final public credential as sent to the
225  // server. Does not include private keys, even on
226  // client side.
227  void UpdateMasterPublicToString(OTString& strAppendTo); // Used in
228  // UpdateContents.
229  void UpdatePublicContentsToString(OTString& strAppendTo); // Used in
230  // UpdateContents.
232  OTString& strAppendTo); // Used in UpdateContents.
234  OTString& strAppendTo); // Used in UpdateContents.
235  inline void SetMasterSigned(const OTString& strMasterSigned)
236  {
237  m_strMasterSigned = strMasterSigned;
238  }
239  inline void SetContents(const OTString& strContents)
240  {
241  m_strContents = strContents;
242  }
243  void SetNymIDandSource(const OTString& strNymID,
244  const OTString& strSourceForNymID);
245  void SetMasterCredID(const OTString& strMasterCredID); // Used in all
246  // subclasses except
247  // OTMasterkey. (It
248  // can't contain its
249  // own ID, since it
250  // is signed, and the
251  // ID is its hash
252  // AFTER it's signed.
253  // So it could never
254  // contain its own
255  // ID.)
256  inline void StoreAsMasterSigned()
257  {
259  } // Upon signing, the credential reverts to credPrivateInfo again.
260  inline void StoreAsPublic()
261  {
263  } // Upon signing, the credential reverts to credPrivateInfo again.
264  virtual bool SetPublicContents(const OTString::Map& mapPublic);
265  virtual bool SetPrivateContents(
266  const OTString::Map& mapPrivate,
267  const OTPassword* pImportPassword = nullptr); // if not nullptr, it
268  // means to
269  // use
270  // this password by default.
271 public:
273  {
274  return m_mapPublicInfo;
275  }
277  {
278  return m_mapPrivateInfo;
279  }
280  const OTString& GetMasterCredID() const
281  {
282  return m_strMasterCredID;
283  } // MasterCredentialID (usually applicable.) OTMasterkey doesn't use this.
284  const OTString& GetNymID() const
285  {
286  return m_strNymID;
287  } // NymID for this credential.
288  const OTString& GetNymIDSource() const
289  {
290  return m_strSourceForNymID;
291  } // Source for NymID for this credential. (Hash it to get ID.)
292  const OTString& GetContents() const
293  {
294  return m_strContents;
295  } // The actual, final, signed public credential. Public keys only.
296 
297  EXPORT const OTString& GetPubCredential() const; // More intelligent version
298  // of GetContents. Higher
299  // level.
300  const OTString& GetPriCredential() const; // I needed this for exporting a
301  // Nym (with credentials) from the
302  // wallet.
303 
304  const OTString& GetMasterSigned() const
305  {
306  return m_strMasterSigned;
307  } // For subkeys, the master credential signs first, then the subkey signs a
308  // version which contains the "master signed" version. (This proves the
309  // subkey really authorizes all this.) That "master signed" version is
310  // stored here in m_strMasterSigned. But the final actual public
311  // credential (which must be hashed to get the credential ID) is the
312  // contents, not the master signed. The contents is the public version,
313  // signed by the subkey, which contains the master-signed version inside
314  // of it as a data member (this variable in fact, m_strMasterSigned.) You
315  // might ask: then what's in m_strRawContents? Answer: the version that
316  // includes the private keys. Well at least, on the client side. On the
317  // server side, the raw contents will contain only the public version
318  // because that's all the client will send it. Que sera sera.
319  virtual bool VerifyInternally(); // Call VerifyNymID. Also verify
320  // m_strMasterCredID against the hash of
321  // m_pOwner->m_MasterKey (the master
322  // credential.) Verify that
323  // m_pOwner->m_MasterKey and *this have the
324  // same NymID. Then verify the signature of
325  // m_pOwner->m_MasterKey on
326  // m_strMasterSigned.
327  // We also inherit OTContract::VerifyContractID() which hashes the contents
328  // and compares to the ID as already set.
329  // Unlike OTContract, a credential's ID is formed by hashing GetContents(),
330  // not by hashing m_xmlRawContents,
331  // (that is, the public info only, not the version containing the private
332  // keys.) So we override CalculateContractID
333  // to account for that.
334  //
335  EXPORT virtual void CalculateContractID(OTIdentifier& newID) const;
336 
337  // We also inherit OTContract::VerifyContract() which tries to find the
338  // "contract" key. Of course, there is no
339  // "contract" key in this case, so we should override it and provide our own
340  // version. What should it do? Well, it
341  // should call VerifyContractID, VerifyInternally, VerifyMaster, and
342  // VerifyAgainstSource. (If that last step later
343  // on adds too much slowdown, then we'll modify that function to check a
344  // signed file left for us by the IDENTITY
345  // VERIFICATION SREVER which we can stick in a separate process.)
346  // HOWEVER!! This may add vast unnecessary delay. For example, if we
347  // "VerifyContract" on EACH subcredential, which
348  // we SHOULD do, then that means EACH subcredential is going to verify its
349  // Master (when they share the same master...)
350  // and EACH subcredential is going to also re-verify its source (when they
351  // all share the same source!)
352  // Solution?
353  // Clearly the master itself only needs to be verified once, including its
354  // source, when the Nym is first loaded.
355  // (Verifying it twice would be redundant.) After that, each subcredential
356  // should be verified internally and against
357  // its master -- again, when first loaded. No need to verify it again after
358  // that, since it wouldn't have even loaded.
359  // After that, any signature for that Nym should be verifiable using one of
360  // that Nym's subcredentials.
361  //
362  virtual bool VerifyContract();
363  bool VerifyNymID() const; // Verifies that m_strNymID is the same as the
364  // hash of
365  // m_strSourceForNymID.
366  virtual bool VerifySignedByMaster();
367  void SetOwner(OTCredential& theOwner);
368  virtual void SetMetadata()
369  {
370  } // Only key-based subclasses will use this.
371  OTSubcredential();
372  OTSubcredential(OTCredential& theOwner);
373  virtual ~OTSubcredential();
374  virtual void Release();
375  void Release_Subcredential();
376  virtual void UpdateContents();
377  virtual int32_t ProcessXMLNode(irr::io::IrrXMLReader*& xml);
378  virtual bool SaveContractWallet(std::ofstream&) const;
379 };
380 
381 } // namespace opentxs
382 
383 #endif // OPENTXS_CORE_CRYPTO_OTSUBCREDENTIAL_HPP
std::map< std::string, std::string > Map
Definition: OTString.hpp:162
void UpdatePublicCredentialToString(OTString &strAppendTo)
const OTString & GetContents() const
void SetOwner(OTCredential &theOwner)
const OTString & GetMasterCredID() const
void SetMasterCredID(const OTString &strMasterCredID)
const OTString::Map & GetPrivateMap() const
virtual bool VerifySignedByMaster()
void UpdatePublicContentsToString(OTString &strAppendTo)
virtual bool SetPrivateContents(const OTString::Map &mapPrivate, const OTPassword *pImportPassword=nullptr)
void UpdateMasterPublicToString(OTString &strAppendTo)
virtual EXPORT void CalculateContractID(OTIdentifier &newID) const
const OTString & GetPriCredential() const
void SetMasterSigned(const OTString &strMasterSigned)
void SetNymIDandSource(const OTString &strNymID, const OTString &strSourceForNymID)
virtual bool SaveContractWallet(std::ofstream &) const
const OTString & GetNymID() const
void SetContents(const OTString &strContents)
const OTString & GetNymIDSource() const
const OTString::Map & GetPublicMap() const
void UpdatePrivateContentsToString(OTString &strAppendTo)
EXPORT const OTString & GetPubCredential() const
virtual bool SetPublicContents(const OTString::Map &mapPublic)
const OTString & GetMasterSigned() const
virtual int32_t ProcessXMLNode(irr::io::IrrXMLReader *&xml)