X-Git-Url: https://git.novaco.in/?p=novacoin.git;a=blobdiff_plain;f=src%2Fkey.h;h=cb5a7122c27aaba0ed30d44366c5bfeacc2ddc38;hp=67c414e516f3ac3724c4aeecb801e90ae5f74daf;hb=3e59ebf3286bcd620e6ff79fa84eb9aa50a6c59e;hpb=7f910f05a59a13fc96b8a4cafa4e6fdd5de725e4 diff --git a/src/key.h b/src/key.h index 67c414e..cb5a712 100644 --- a/src/key.h +++ b/src/key.h @@ -62,63 +62,167 @@ public: CScriptID(const uint160 &in) : uint160(in) { } }; -/** An encapsulated public key. */ -class CPubKey { +/** An encapsulated OpenSSL Elliptic Curve key (public) */ +class CPubKey +{ private: - std::vector vchPubKey; - friend class CKey; + + /** + * Just store the serialized data. + * Its length can very cheaply be computed from the first byte. + */ + unsigned char vbytes[65]; + + //! Compute the length of a pubkey with a given first byte. + unsigned int static GetLen(unsigned char chHeader) + { + if (chHeader == 2 || chHeader == 3) + return 33; + if (chHeader == 4 || chHeader == 6 || chHeader == 7) + return 65; + return 0; + } + + // Set this key data to be invalid + void Invalidate() + { + vbytes[0] = 0xFF; + } public: - CPubKey() { } - CPubKey(const std::vector &vchPubKeyIn) : vchPubKey(vchPubKeyIn) { } - friend bool operator==(const CPubKey &a, const CPubKey &b) { return a.vchPubKey == b.vchPubKey; } - friend bool operator!=(const CPubKey &a, const CPubKey &b) { return a.vchPubKey != b.vchPubKey; } - friend bool operator<(const CPubKey &a, const CPubKey &b) { return a.vchPubKey < b.vchPubKey; } + // Construct an invalid public key. + CPubKey() + { + Invalidate(); + } - IMPLEMENT_SERIALIZE( - READWRITE(vchPubKey); - ) + // Initialize a public key using begin/end iterators to byte data. + template + void Set(const T pbegin, const T pend) + { + int len = pend == pbegin ? 0 : GetLen(pbegin[0]); + if (len && len == (pend - pbegin)) + memcpy(vbytes, (unsigned char*)&pbegin[0], len); + else + Invalidate(); + } - CKeyID GetID() const { - return CKeyID(Hash160(vchPubKey)); + void Set(const std::vector& vch) + { + Set(vch.begin(), vch.end()); } - uint256 GetHash() const { - return Hash(vchPubKey.begin(), vchPubKey.end()); + template + CPubKey(const T pbegin, const T pend) + { + Set(pbegin, pend); } - bool IsValid() const { - return vchPubKey.size() == 33 || vchPubKey.size() == 65; + CPubKey(const std::vector& vch) + { + Set(vch.begin(), vch.end()); + } + + // Read-only vector-like interface to the data. + unsigned int size() const { return GetLen(vbytes[0]); } + const unsigned char* begin() const { return vbytes; } + const unsigned char* end() const { return vbytes + size(); } + const unsigned char& operator[](unsigned int pos) const { return vbytes[pos]; } + + friend bool operator==(const CPubKey& a, const CPubKey& b) { return a.vbytes[0] == b.vbytes[0] && memcmp(a.vbytes, b.vbytes, a.size()) == 0; } + friend bool operator!=(const CPubKey& a, const CPubKey& b) { return !(a == b); } + friend bool operator<(const CPubKey& a, const CPubKey& b) { return a.vbytes[0] < b.vbytes[0] || (a.vbytes[0] == b.vbytes[0] && memcmp(a.vbytes, b.vbytes, a.size()) < 0); } + + //! Implement serialization, as if this was a byte vector. + unsigned int GetSerializeSize(int nType, int nVersion) const + { + return size() + 1; + } + template + void Serialize(Stream& s, int nType, int nVersion) const + { + unsigned int len = size(); + ::WriteCompactSize(s, len); + s.write((char*)vbytes, len); + } + template + void Unserialize(Stream& s, int nType, int nVersion) + { + unsigned int len = ::ReadCompactSize(s); + if (len <= 65) { + s.read((char*)vbytes, len); + } else { + // invalid pubkey, skip available data + char dummy; + while (len--) + s.read(&dummy, 1); + Invalidate(); + } + } + + CKeyID GetID() const + { + return CKeyID(Hash160(vbytes, vbytes + size())); } - bool IsCompressed() const { - return vchPubKey.size() == 33; + uint256 GetHash() const + { + return Hash(vbytes, vbytes + size()); } - std::vector Raw() const { - return vchPubKey; + /* + * Check syntactic correctness. + * + * Note that this is consensus critical as CheckSig() calls it! + */ + bool IsValid() const + { + return size() > 0; } + //! fully validate whether this is a valid public key (more expensive than IsValid()) + bool IsFullyValid() const + { + const unsigned char* pbegin = &vbytes[0]; + EC_KEY *pkey = EC_KEY_new_by_curve_name(NID_secp256k1); + if (o2i_ECPublicKey(&pkey, &pbegin, size())) + { + EC_KEY_free(pkey); + return true; + } + return false; + } + + //! Check whether this is a compressed public key. + bool IsCompressed() const + { + return size() == 33; + } + + bool Verify(const uint256& hash, const std::vector& vchSig) const; + bool VerifyCompact(uint256 hash, const std::vector& vchSig); + + bool SetCompactSignature(uint256 hash, const std::vector& vchSig); + + // Reserialize to DER + static bool ReserealizeSignature(std::vector& vchSig); + // Encrypt data void EncryptData(const std::vector& data, std::vector& encrypted); }; - // secure_allocator is defined in allocators.h // CPrivKey is a serialized private key, with all parameters included (279 bytes) typedef std::vector > CPrivKey; // CSecret is a serialization of just the secret parameter (32 bytes) typedef std::vector > CSecret; -/** An encapsulated OpenSSL Elliptic Curve key (public and/or private) */ +/** An encapsulated OpenSSL Elliptic Curve key (private) */ class CKey { protected: EC_KEY* pkey; bool fSet; - bool fCompressedPubKey; - - void SetCompressedPubKey(); public: @@ -126,6 +230,7 @@ public: CKey(); CKey(const CKey& b); + CKey(const CSecret& b, bool fCompressed=true); CKey& operator=(const CKey& b); @@ -134,13 +239,15 @@ public: bool IsNull() const; bool IsCompressed() const; - void MakeNewKey(bool fCompressed); + void SetCompressedPubKey(bool fCompressed=true); + void MakeNewKey(bool fCompressed=true); bool SetPrivKey(const CPrivKey& vchPrivKey); - bool SetSecret(const CSecret& vchSecret, bool fCompressed = false); + bool SetSecret(const CSecret& vchSecret, bool fCompressed = true); CSecret GetSecret(bool &fCompressed) const; + CSecret GetSecret() const; CPrivKey GetPrivKey() const; - bool SetPubKey(const CPubKey& vchPubKey); CPubKey GetPubKey() const; + bool WritePEM(BIO *streamObj, const SecureString &strPassKey) const; bool Sign(uint256 hash, std::vector& vchSig); @@ -150,28 +257,11 @@ public: // 0x1D = second key with even y, 0x1E = second key with odd y bool SignCompact(uint256 hash, std::vector& vchSig); - // reconstruct public key from a compact signature - // This is only slightly more CPU intensive than just verifying it. - // If this function succeeds, the recovered public key is guaranteed to be valid - // (the signature is a valid signature of the given data for that key) - bool SetCompactSignature(uint256 hash, const std::vector& vchSig); - - bool Verify(uint256 hash, const std::vector& vchSig); - - // Verify a compact signature - bool VerifyCompact(uint256 hash, const std::vector& vchSig); - bool IsValid(); // Check whether an element of a signature (r or s) is valid. static bool CheckSignatureElement(const unsigned char *vch, int len, bool half); - // Reserialize to DER - static bool ReserealizeSignature(std::vector& vchSig); - - // Encrypt data - void EncryptData(const std::vector& data, std::vector& encrypted); - // Decrypt data void DecryptData(const std::vector& encrypted, std::vector& data); }; @@ -203,13 +293,12 @@ public: // Calculate G*m + q bool ECMULGEN(const CBigNum &bnMultiplier, const CPoint &qPoint); - bool IsInfinity() { return EC_POINT_is_at_infinity(group, point); } + bool IsInfinity() { return EC_POINT_is_at_infinity(group, point) != 0; } }; class CMalleablePubKey { private: - unsigned char nVersion; CPubKey pubKeyL; CPubKey pubKeyH; friend class CMalleableKey; @@ -217,19 +306,17 @@ private: static const unsigned char CURRENT_VERSION = 1; public: - CMalleablePubKey() { nVersion = CMalleablePubKey::CURRENT_VERSION; } + CMalleablePubKey() { } CMalleablePubKey(const CMalleablePubKey& mpk) { - nVersion = mpk.nVersion; pubKeyL = mpk.pubKeyL; pubKeyH = mpk.pubKeyH; } + CMalleablePubKey(const std::vector &vchPubKeyPair) { setvch(vchPubKeyPair); } CMalleablePubKey(const std::string& strMalleablePubKey) { SetString(strMalleablePubKey); } - CMalleablePubKey(const CPubKey &pubKeyInL, const CPubKey &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { nVersion = CMalleablePubKey::CURRENT_VERSION; } + CMalleablePubKey(const CPubKey &pubKeyInL, const CPubKey &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { } IMPLEMENT_SERIALIZE( - READWRITE(this->nVersion); - nVersion = this->nVersion; READWRITE(pubKeyL); READWRITE(pubKeyH); ) @@ -241,7 +328,6 @@ public: bool operator==(const CMalleablePubKey &b); bool operator!=(const CMalleablePubKey &b) { return !(*this == b); } CMalleablePubKey& operator=(const CMalleablePubKey& mpk) { - nVersion = mpk.nVersion; pubKeyL = mpk.pubKeyL; pubKeyH = mpk.pubKeyH; return *this; @@ -254,6 +340,7 @@ public: return pubKeyL.GetID(); } + bool setvch(const std::vector &vchPubKeyPair); std::vector Raw() const; CPubKey& GetL() { return pubKeyL; } @@ -264,14 +351,11 @@ public: class CMalleableKey { private: - unsigned char nVersion; CSecret vchSecretL; CSecret vchSecretH; friend class CMalleableKeyView; - static const unsigned char CURRENT_VERSION = 1; - public: CMalleableKey(); CMalleableKey(const CMalleableKey &b); @@ -279,8 +363,6 @@ public: ~CMalleableKey(); IMPLEMENT_SERIALIZE( - READWRITE(this->nVersion); - nVersion = this->nVersion; READWRITE(vchSecretL); READWRITE(vchSecretH); ) @@ -289,7 +371,6 @@ public: bool SetString(const std::string& strMalleablePubKey); std::vector Raw() const; CMalleableKey& operator=(const CMalleableKey& mk) { - nVersion = mk.nVersion; vchSecretL = mk.vchSecretL; vchSecretH = mk.vchSecretH; return *this; @@ -315,34 +396,28 @@ public: class CMalleableKeyView { private: - unsigned char nVersion; CSecret vchSecretL; CPubKey vchPubKeyH; - static const unsigned char CURRENT_VERSION = 1; - public: - CMalleableKeyView() { nVersion = 0; }; + CMalleableKeyView() { }; CMalleableKeyView(const CMalleableKey &b); + CMalleableKeyView(const std::string &strMalleableKey); CMalleableKeyView(const CMalleableKeyView &b); CMalleableKeyView& operator=(const CMalleableKey &b); ~CMalleableKeyView(); IMPLEMENT_SERIALIZE( - READWRITE(this->nVersion); - nVersion = this->nVersion; READWRITE(vchSecretL); READWRITE(vchPubKeyH); ) - bool IsNull() const; - bool IsValid() const { return !IsNull() && GetMalleablePubKey().IsValid(); } + bool IsValid() const; std::string ToString() const; bool SetString(const std::string& strMalleablePubKey); std::vector Raw() const; CMalleableKeyView& operator=(const CMalleableKeyView& mkv) { - nVersion = mkv.nVersion; vchSecretL = mkv.vchSecretL; vchPubKeyH = mkv.vchPubKeyH; return *this;