X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fkey.h;h=ca78c724e8a273c1dddc5e6e2ea051a1ca65cc87;hb=e5e4c598dc43bb5e01b3a30aaeb2dfc9376bd7b4;hp=c98f52ed043c8a64a127e31e861468bd64123e2d;hpb=84a4a7763f386934da90e2bd1e355b70023fa9ca;p=novacoin.git

diff --git a/src/key.h b/src/key.h
index c98f52e..ca78c72 100644
--- a/src/key.h
+++ b/src/key.h
@@ -11,7 +11,9 @@
 #include "allocators.h"
 #include "serialize.h"
 #include "uint256.h"
-#include "util.h"
+#include "hash.h"
+#include "bignum.h"
+#include "ies.h"
 
 #include <openssl/ec.h> // for EC_KEY definition
 
@@ -96,6 +98,9 @@ public:
     std::vector<unsigned char> Raw() const {
         return vchPubKey;
     }
+
+    // Encrypt data
+    void EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted);
 };
 
 
@@ -157,6 +162,157 @@ public:
     bool VerifyCompact(uint256 hash, const std::vector<unsigned char>& 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<unsigned char>& vchSig);
+
+    // Encrypt data
+    void EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted);
+
+    // Decrypt data
+    void DecryptData(const std::vector<unsigned char>& encrypted, std::vector<unsigned char>& data);
+};
+
+class CPoint
+{
+private:
+    EC_POINT *point;
+    EC_GROUP* group;
+    BN_CTX* ctx;
+
+public:
+    CPoint();
+    bool operator!=(const CPoint &a);
+    ~CPoint();
+
+    // Initialize from octets stream
+    bool setBytes(const std::vector<unsigned char> &vchBytes);
+
+    // Serialize to octets stream
+    bool getBytes(std::vector<unsigned char> &vchBytes);
+
+    // ECC multiplication by specified multiplier
+    bool ECMUL(const CBigNum &bnMultiplier);
+
+    // Calculate G*m + q
+    bool ECMULGEN(const CBigNum &bnMultiplier, const CPoint &qPoint);
+
+    bool IsInfinity() { return EC_POINT_is_at_infinity(group, point); }
+};
+
+class CMalleablePubKey
+{
+private:
+    unsigned char nVersion;
+    CPubKey pubKeyL;
+    CPubKey pubKeyH;
+    friend class CMalleableKey;
+
+    static const unsigned char CURRENT_VERSION = 1;
+
+public:
+    CMalleablePubKey() { nVersion = CMalleablePubKey::CURRENT_VERSION; }
+    CMalleablePubKey(const std::string& strMalleablePubKey) { SetString(strMalleablePubKey); }
+    CMalleablePubKey(const CPubKey &pubKeyInL, const CPubKey &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { nVersion = CMalleablePubKey::CURRENT_VERSION; }
+    CMalleablePubKey(const std::vector<unsigned char> &pubKeyInL, const std::vector<unsigned char> &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { nVersion = CMalleablePubKey::CURRENT_VERSION; }
+
+    IMPLEMENT_SERIALIZE(
+        READWRITE(this->nVersion);
+        nVersion = this->nVersion;
+        READWRITE(pubKeyL);
+        READWRITE(pubKeyH);
+    )
+
+    bool IsValid() const {
+        return pubKeyL.IsValid() && pubKeyH.IsValid();
+    }
+
+    bool operator==(const CMalleablePubKey &b);
+    bool operator!=(const CMalleablePubKey &b) { return !(*this == b); }
+
+    std::string ToString();
+    bool SetString(const std::string& strMalleablePubKey);
+    uint256 GetID() const;
+
+    CPubKey& GetL() { return pubKeyL; }
+    CPubKey& GetH() { return pubKeyH; }
+    void GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant);
+};
+
+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);
+    CMalleableKey(const CSecret &L, const CSecret &H);
+    CMalleableKey& operator=(const CMalleableKey &b);
+    ~CMalleableKey();
+
+    IMPLEMENT_SERIALIZE(
+        READWRITE(this->nVersion);
+        nVersion = this->nVersion;
+        READWRITE(vchSecretL);
+        READWRITE(vchSecretH);
+    )
+
+    std::string ToString();
+    bool SetString(const std::string& strMalleablePubKey);
+
+    void Reset();
+    void MakeNewKeys();
+    bool IsNull() const;
+    bool SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH);
+    void GetSecrets(CSecret &pvchSecretL, CSecret &pvchSecretH) const;
+
+    CMalleablePubKey GetMalleablePubKey() const;
+    bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant);
+    bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant);
+};
+
+class CMalleableKeyView
+{
+private:
+    unsigned char nVersion;
+    CSecret vchSecretL;
+    std::vector<unsigned char> vchPubKeyH;
+
+    static const unsigned char CURRENT_VERSION = 1;
+
+public:
+    CMalleableKeyView() { nVersion = 0; };
+    CMalleableKeyView(const CMalleableKey &b);
+    CMalleableKeyView(const CSecret &L, const CPubKey &pvchPubKeyH);
+
+    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;
+    std::string ToString();
+    bool SetString(const std::string& strMalleablePubKey);
+
+    CMalleablePubKey GetMalleablePubKey() const;
+    bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant);
 };
 
 #endif