git://git.novaco.in / novacoin.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw
Code style fix (no "tab" symbol).
[novacoin.git] / src / key.cpp
diff --git a/src/key.cpp b/src/key.cpp
index b1db7cb..49868b8 100644 (file)
--- a/src/key.cpp
+++ b/src/key.cpp
@@ -725,6 +725,14 @@ std::string CMalleablePubKey::ToString() const
     return EncodeBase58Check(vch);
 }
 
+bool CMalleablePubKey::setvch(const std::vector<unsigned char> &vchPubKeyPair)
+{
+    CDataStream ssKey(vchPubKeyPair, SER_NETWORK, PROTOCOL_VERSION);
+    ssKey >> *this;
+
+    return IsValid();
+}
+
 std::vector<unsigned char> CMalleablePubKey::Raw() const
 {
     CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
@@ -804,7 +812,7 @@ bool CMalleableKey::SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSe
     CKey keyL(pvchSecretL);
     CKey keyH(pvchSecretH);
 
-    if (!keyL.IsValid() || !keyL.IsValid())
+    if (!keyL.IsValid() || !keyH.IsValid())
         return false;
 
     vchSecretL = pvchSecretL;
@@ -815,14 +823,8 @@ bool CMalleableKey::SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSe
 
 CMalleablePubKey CMalleableKey::GetMalleablePubKey() const
 {
-    CKey L, H;
-    L.SetSecret(vchSecretL, true);
-    H.SetSecret(vchSecretH, true);
-
-    std::vector<unsigned char> vchPubKeyL = L.GetPubKey().Raw();
-    std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
-
-    return CMalleablePubKey(vchPubKeyL, vchPubKeyH);
+    CKey L(vchSecretL), H(vchSecretH);
+    return CMalleablePubKey(L.GetPubKey().Raw(), H.GetPubKey().Raw());
 }
 
 // Check ownership
@@ -833,35 +835,40 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa
     }
 
     if (!R.IsValid()) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : R is invalid");
+        printf("CMalleableKey::CheckKeyVariant() : R is invalid");
+        return false;
     }
 
     if (!vchPubKeyVariant.IsValid()) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+        printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+        return false;
     }
 
     CPoint point_R;
     if (!point_R.setPubKey(R)) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+        printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+        return false;
     }
 
-    CKey H;
-    H.SetSecret(vchSecretH, true);
+    CKey H(vchSecretH);
     std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
 
     CPoint point_H;
     if (!point_H.setPubKey(vchPubKeyH)) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+        printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+        return false;
     }
 
     CPoint point_P;
     if (!point_P.setPubKey(vchPubKeyVariant)) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+        printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+        return false;
     }
 
     // Infinity points are senseless
     if (point_P.IsInfinity()) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : P is infinity");
+        printf("CMalleableKey::CheckKeyVariant() : P is infinity");
+        return false;
     }
 
     CBigNum bnl;
@@ -871,7 +878,8 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa
 
     std::vector<unsigned char> vchRl;
     if (!point_R.getBytes(vchRl)) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+        printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+        return false;
     }
 
     // Calculate Hash(R*l)
@@ -884,7 +892,8 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa
 
     // Infinity points are senseless
     if (point_Ps.IsInfinity()) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+        printf("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+        return false;
     }
 
     // Check ownership
@@ -903,35 +912,40 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa
     }
 
     if (!R.IsValid()) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : R is invalid");
+        printf("CMalleableKey::CheckKeyVariant() : R is invalid");
+        return false;
     }
 
     if (!vchPubKeyVariant.IsValid()) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+        printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+        return false;
     }
 
     CPoint point_R;
     if (!point_R.setPubKey(R)) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+        printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+        return false;
     }
 
-    CKey H;
-    H.SetSecret(vchSecretH, true);
+    CKey H(vchSecretH);
     std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
 
     CPoint point_H;
     if (!point_H.setPubKey(vchPubKeyH)) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+        printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+        return false;
     }
 
     CPoint point_P;
     if (!point_P.setPubKey(vchPubKeyVariant)) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+        printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+        return false;
     }
 
     // Infinity points are senseless
     if (point_P.IsInfinity()) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : P is infinity");
+        printf("CMalleableKey::CheckKeyVariant() : P is infinity");
+        return false;
     }
 
     CBigNum bnl;
@@ -941,7 +955,8 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa
 
     std::vector<unsigned char> vchRl;
     if (!point_R.getBytes(vchRl)) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+        printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+        return false;
     }
 
     // Calculate Hash(R*l)
@@ -954,7 +969,8 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa
 
     // Infinity points are senseless
     if (point_Ps.IsInfinity()) {
-        throw key_error("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+        printf("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+        return false;
     }
 
     // Check ownership
@@ -970,7 +986,7 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa
     CBigNum bnp = bnHash + bnh;
 
     std::vector<unsigned char> vchp = bnp.getBytes();
-    privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end()), true);
+    privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end()));
 
     return true;
 }
@@ -1019,13 +1035,11 @@ CMalleableKeyView::CMalleableKeyView(const CMalleableKey &b)
         throw key_error("CMalleableKeyView::CMalleableKeyView() : L size must be 32 bytes");
 
     if (b.vchSecretH.size() != 32)
-        throw key_error("CMalleableKeyView::CMalleableKeyView() : L size must be 32 bytes");
+        throw key_error("CMalleableKeyView::CMalleableKeyView() : H size must be 32 bytes");
 
     vchSecretL = b.vchSecretL;
 
-    CKey H;
-    H.SetSecret(b.vchSecretH, true);
-
+    CKey H(b.vchSecretH);
     vchPubKeyH = H.GetPubKey().Raw();
 }
 
@@ -1039,8 +1053,7 @@ CMalleableKeyView& CMalleableKeyView::operator=(const CMalleableKey &b)
 {
     vchSecretL = b.vchSecretL;
 
-    CKey H;
-    H.SetSecret(b.vchSecretH, true);
+    CKey H(b.vchSecretH);
     vchPubKeyH = H.GetPubKey().Raw();
 
     return (*this);
@@ -1052,40 +1065,49 @@ CMalleableKeyView::~CMalleableKeyView()
 
 CMalleablePubKey CMalleableKeyView::GetMalleablePubKey() const
 {
-    CKey keyL;
-    keyL.SetSecret(vchSecretL, true);
+    CKey keyL(vchSecretL);
     return CMalleablePubKey(keyL.GetPubKey(), vchPubKeyH);
 }
 
 // Check ownership
 bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const
 {
+    if (!IsValid()) {
+        throw key_error("CMalleableKeyView::CheckKeyVariant() : Attempting to run on invalid view object.");
+    }
+
     if (!R.IsValid()) {
-        throw key_error("CMalleableKeyView::CheckKeyVariant() : R is invalid");
+        printf("CMalleableKeyView::CheckKeyVariant() : R is invalid");
+        return false;
     }
 
     if (!vchPubKeyVariant.IsValid()) {
-        throw key_error("CMalleableKeyView::CheckKeyVariant() : public key variant is invalid");
+        printf("CMalleableKeyView::CheckKeyVariant() : public key variant is invalid");
+        return false;
     }
 
     CPoint point_R;
     if (!point_R.setPubKey(R)) {
-        throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value");
+        printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value");
+        return false;
     }
 
     CPoint point_H;
     if (!point_H.setPubKey(vchPubKeyH)) {
-        throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value");
+        printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value");
+        return false;
     }
 
     CPoint point_P;
     if (!point_P.setPubKey(vchPubKeyVariant)) {
-        throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value");
+        printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value");
+        return false;
     }
 
     // Infinity points are senseless
     if (point_P.IsInfinity()) {
-        throw key_error("CMalleableKeyView::CheckKeyVariant() : P is infinity");
+        printf("CMalleableKeyView::CheckKeyVariant() : P is infinity");
+        return false;
     }
 
     CBigNum bnl;
@@ -1095,7 +1117,8 @@ bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubK
 
     std::vector<unsigned char> vchRl;
     if (!point_R.getBytes(vchRl)) {
-        throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to convert Rl value");
+        printf("CMalleableKeyView::CheckKeyVariant() : Unable to convert Rl value");
+        return false;
     }
 
     // Calculate Hash(R*l)
@@ -1108,7 +1131,8 @@ bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubK
 
     // Infinity points are senseless
     if (point_Ps.IsInfinity()) {
-        throw key_error("CMalleableKeyView::CheckKeyVariant() : Ps is infinity");
+        printf("CMalleableKeyView::CheckKeyVariant() : Ps is infinity");
+        return false;
     }
 
     // Check ownership
Novacoin client