From d8f9470fe23fce7b45fd93c6065b2895a0ae9bc7 Mon Sep 17 00:00:00 2001
From: Gregory Sanders <gsanders87@gmail.com>
Date: Mon, 29 Oct 2018 15:21:55 -0400
Subject: [PATCH] Add more blocksigning infrastructure

---
 src/Makefile.am          |  1 +
 src/chain.h              |  5 ++++
 src/chainparams.cpp      |  4 +--
 src/pow.cpp              | 51 ++++++++++++++++++++++++++++++++++
 src/pow.h                |  8 ++++++
 src/primitives/block.cpp | 10 +++++--
 src/script/generic.hpp   | 59 ++++++++++++++++++++++++++++++++++++++++
 7 files changed, 134 insertions(+), 4 deletions(-)
 create mode 100644 src/script/generic.hpp

diff --git a/src/Makefile.am b/src/Makefile.am
index c5eddc6cf0..81700addf3 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -159,6 +159,7 @@ BITCOIN_CORE_H = \
   rpc/util.h \
   scheduler.h \
   script/descriptor.h \
+  script/generic.hpp \
   script/ismine.h \
   script/sigcache.h \
   script/sign.h \
diff --git a/src/chain.h b/src/chain.h
index 01011d54f1..7323d04a09 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -212,6 +212,7 @@ public:
     uint32_t nTime;
     uint32_t nBits;
     uint32_t nNonce;
+    CProof proof;
 
     //! (memory only) Sequential id assigned to distinguish order in which blocks are received.
     int32_t nSequenceId;
@@ -240,6 +241,7 @@ public:
         nTime          = 0;
         nBits          = 0;
         nNonce         = 0;
+        proof.SetNull();
     }
 
     CBlockIndex()
@@ -256,6 +258,7 @@ public:
         nTime          = block.nTime;
         nBits          = block.nBits;
         nNonce         = block.nNonce;
+        proof          = block.proof;
     }
 
     CDiskBlockPos GetBlockPos() const {
@@ -405,6 +408,7 @@ public:
         READWRITE(nTime);
         READWRITE(nBits);
         READWRITE(nNonce);
+        READWRITE(proof);
     }
 
     uint256 GetBlockHash() const
@@ -416,6 +420,7 @@ public:
         block.nTime           = nTime;
         block.nBits           = nBits;
         block.nNonce          = nNonce;
+        block.proof           = proof;
         return block.GetHash();
     }
 
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index da1752828d..480a02f24b 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -437,8 +437,8 @@ class CCustomParams : public CRegTestParams {
         consensus.mandatory_coinbase_destination = CScript(man_bytes.begin(), man_bytes.end()); // Blank script allows any coinbase destination
 
         // Block signing encumberance script
-        std::vector<unsigned char> sign_bytes = ParseHex(gArgs.GetArg("-con_parent_chain_signblockscript", ""));
-        consensus.parent_chain_signblockscript = CScript(sign_bytes.begin(), sign_bytes.end());
+        std::vector<unsigned char> sign_bytes = ParseHex(gArgs.GetArg("-signblockscript", ""));
+        consensus.signblockscript = CScript(sign_bytes.begin(), sign_bytes.end());
 
         // Custom chains connect coinbase outputs to db by default
         consensus.connect_genesis_outputs = gArgs.GetArg("-con_connect_coinbase", true);
diff --git a/src/pow.cpp b/src/pow.cpp
index 1414d37564..ac97e12345 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -9,6 +9,19 @@
 #include <chain.h>
 #include <primitives/block.h>
 #include <uint256.h>
+#include <script/interpreter.h>
+#include <script/sign.h>
+#include <script/generic.hpp>
+
+bool CheckChallenge(const CBlockHeader& block, const CBlockIndex& indexLast, const Consensus::Params& params)
+{
+    return block.proof.challenge == indexLast.proof.challenge;
+}
+
+void ResetChallenge(CBlockHeader& block, const CBlockIndex& indexLast, const Consensus::Params& params)
+{
+    block.proof.challenge = indexLast.proof.challenge;
+}
 
 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
 {
@@ -89,3 +102,41 @@ bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&
 
     return true;
 }
+
+static bool CheckProofGeneric(const CBlockHeader& block, const Consensus::Params& params, const CScript& challenge)
+{
+    if (block.GetHash() == params.hashGenesisBlock)
+       return true;
+
+    // Some important anti-DoS flags.
+    // Note: Blockhashes do not commit to the proof.
+    // Therefore we may have a signature be mealleated
+    // to stay valid, but cause the block to fail
+    // validation, in this case, block weight.
+    // In that case, the block will be marked as permanently
+    // invalid and not processed.
+    // NOTE: These have only been deemed sufficient for OP_CMS
+    // ANY OTHER SCRIPT TYPE MAY REQUIRE DIFFERENT FLAGS/CONSIDERATIONS
+    // TODO: Better design to not have to worry about script specifics
+    // i.e. exempt block header solution from weight limit
+    unsigned int proof_flags = SCRIPT_VERIFY_P2SH // Just allows P2SH evaluation
+        | SCRIPT_VERIFY_STRICTENC // Minimally-sized DER sigs
+        | SCRIPT_VERIFY_NULLDUMMY // No extra data stuffed into OP_CMS witness
+        | SCRIPT_VERIFY_CLEANSTACK // No extra pushes leftover in witness
+        | SCRIPT_VERIFY_MINIMALDATA // Pushes are minimally-sized
+        | SCRIPT_VERIFY_SIGPUSHONLY // Witness is push-only
+        | SCRIPT_VERIFY_LOW_S // Stop easiest signature fiddling
+        | SCRIPT_VERIFY_WITNESS // Required for cleanstack eval in VerifyScript
+        | SCRIPT_NO_SIGHASH_BYTE; // non-Check(Multi)Sig signatures will not have sighash byte
+    return GenericVerifyScript(block.proof.solution, challenge, proof_flags, block);
+}
+
+bool CheckProof(const CBlockHeader& block, const Consensus::Params& params)
+{
+    return CheckProofGeneric(block, params, params.signblockscript);
+}
+
+void ResetProof(CBlockHeader& block)
+{
+    block.proof.solution.clear();
+}
diff --git a/src/pow.h b/src/pow.h
index 1d802cd01e..d5ac0435b3 100644
--- a/src/pow.h
+++ b/src/pow.h
@@ -13,6 +13,8 @@
 class CBlockHeader;
 class CBlockIndex;
 class uint256;
+class CProof;
+class CScript;
 
 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params&);
 unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params&);
@@ -20,4 +22,10 @@ unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nF
 /** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
 bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&);
 
+// Elements signed chain functionality
+bool CheckProof(const CBlockHeader& block, const Consensus::Params&);
+void ResetProof(CBlockHeader& block);
+bool CheckChallenge(const CBlockHeader& block, const CBlockIndex& indexLast, const Consensus::Params&);
+void ResetChallenge(CBlockHeader& block, const CBlockIndex& indexLast, const Consensus::Params&);
+
 #endif // BITCOIN_POW_H
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index fb95a66bde..ee41cc88d6 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -10,6 +10,12 @@
 #include <utilstrencodings.h>
 #include <crypto/common.h>
 
+std::string CProof::ToString() const
+{
+    return strprintf("CProof(challenge=%s, solution=%s)",
+                     HexStr(challenge), HexStr(solution));
+}
+
 uint256 CBlockHeader::GetHash() const
 {
     return SerializeHash(*this);
@@ -18,12 +24,12 @@ uint256 CBlockHeader::GetHash() const
 std::string CBlock::ToString() const
 {
     std::stringstream s;
-    s << strprintf("CBlock(hash=%s, ver=0x%08x, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%u)\n",
+    s << strprintf("CBlock(hash=%s, ver=0x%08x, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, proof=%u, vtx=%u)\n",
         GetHash().ToString(),
         nVersion,
         hashPrevBlock.ToString(),
         hashMerkleRoot.ToString(),
-        nTime, nBits, nNonce,
+        nTime, nBits, nNonce, proof.ToString(),
         vtx.size());
     for (const auto& tx : vtx) {
         s << "  " << tx->ToString() << "\n";
diff --git a/src/script/generic.hpp b/src/script/generic.hpp
new file mode 100644
index 0000000000..e4e66fc7c9
--- /dev/null
+++ b/src/script/generic.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2014 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef H_BITCOIN_SCRIPT_GENERIC
+#define H_BITCOIN_SCRIPT_GENERIC
+
+#include <hash.h>
+#include <script/interpreter.h>
+#include <script/sign.h>
+#include <keystore.h>
+
+class SimpleSignatureChecker : public BaseSignatureChecker
+{
+public:
+    uint256 hash;
+
+    SimpleSignatureChecker(const uint256& hashIn) : hash(hashIn) {};
+    bool CheckSig(const std::vector<unsigned char>& vchSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const
+    {
+        CPubKey pubkey(vchPubKey);
+        if (!pubkey.IsValid())
+            return false;
+        if (vchSig.empty())
+            return false;
+        return pubkey.Verify(hash, vchSig);
+    }
+};
+
+class SimpleSignatureCreator : public BaseSignatureCreator
+{
+    SimpleSignatureChecker checker;
+
+public:
+    SimpleSignatureCreator(const uint256& hashIn) : checker(hashIn) {};
+    const BaseSignatureChecker& Checker() const { return checker; }
+    bool CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const
+    {
+        CKey key;
+        if (!provider.GetKey(keyid, key))
+            return false;
+        return key.Sign(checker.hash, vchSig);
+    }
+};
+
+template<typename T>
+bool GenericVerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, unsigned int flags, const T& data)
+{
+    return VerifyScript(scriptSig, scriptPubKey, NULL, flags, SimpleSignatureChecker(SerializeHash(data)));
+}
+
+template<typename T>
+bool GenericSignScript(const CKeyStore& keystore, const T& data, const CScript& fromPubKey, SignatureData& scriptSig)
+{
+    return ProduceSignature(keystore, SimpleSignatureCreator(SerializeHash(data)), fromPubKey, scriptSig);
+}
+
+#endif // H_BITCOIN_SCRIPT_GENERIC