test: add key IO tests

src/Makefile.test.include

@@ -8,9 +8,9 @@ TEST_SRCDIR = test
 TEST_BINARY=test/test_gridcoin$(EXEEXT)
 
 JSON_TEST_FILES = \
-	test/data/base58_keys_valid.json \
 	test/data/base58_encode_decode.json \
-	test/data/base58_keys_invalid.json \
+	test/data/key_io_invalid.json \
+	test/data/key_io_valid.json \
 	test/data/script_valid.json \
 	test/data/script_invalid.json \
 	test/data/tx_invalid.json \
@@ -59,6 +59,7 @@ GRIDCOIN_TESTS =\
 	test/gridcoin/sidestake_tests.cpp \
 	test/gridcoin/superblock_tests.cpp \
 	test/key_tests.cpp \
+	test/key_io_tests.cpp \
 	test/merkle_tests.cpp \
 	test/mruset_tests.cpp \
 	test/multisig_tests.cpp \

src/test/key_io_tests.cpp

@@ -0,0 +1,149 @@
+// Copyright (c) 2011-2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://opensource.org/licenses/mit-license.php.
+
+#include <test/data/key_io_invalid.json.h>
+#include <test/data/key_io_valid.json.h>
+
+#include <key.h>
+#include <key_io.h>
+#include <script.h>
+#include <util/strencodings.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <univalue.h>
+
+UniValue read_json(const std::string& jsondata);
+
+BOOST_AUTO_TEST_SUITE(key_io_tests)
+
+// Goal: check that parsed keys match test payload
+BOOST_AUTO_TEST_CASE(key_io_valid_parse)
+{
+    UniValue tests = read_json(std::string(json_tests::key_io_valid, json_tests::key_io_valid + sizeof(json_tests::key_io_valid)));
+    CKey privkey;
+    CTxDestination destination;
+    SelectParams(CBaseChainParams::MAIN);
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        const UniValue& test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 3) { // Allow for extra stuff (useful for comments)
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        std::string exp_base58string = test[0].get_str();
+        const std::vector<unsigned char> exp_payload{ParseHex(test[1].get_str())};
+        const UniValue &metadata = test[2].get_obj();
+        bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
+        SelectParams(find_value(metadata, "chain").get_str());
+        bool try_case_flip = find_value(metadata, "tryCaseFlip").isNull() ? false : find_value(metadata, "tryCaseFlip").get_bool();
+        if (isPrivkey) {
+            bool isCompressed = find_value(metadata, "isCompressed").get_bool();
+            // Must be valid private key
+            privkey = DecodeSecret(exp_base58string);
+            BOOST_CHECK_MESSAGE(privkey.IsValid(), "!IsValid:" + strTest);
+            BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed, "compressed mismatch:" + strTest);
+            BOOST_CHECK_MESSAGE(Span{privkey} == MakeByteSpan(exp_payload), "key mismatch:" + strTest);
+
+            // Private key must be invalid public key
+            destination = DecodeDestination(exp_base58string);
+            BOOST_CHECK_MESSAGE(!IsValidDestination(destination), "IsValid privkey as pubkey:" + strTest);
+        } else {
+            // Must be valid public key
+            destination = DecodeDestination(exp_base58string);
+            CScript script;
+            script.SetDestination(destination);
+            BOOST_CHECK_MESSAGE(IsValidDestination(destination), "!IsValid:" + strTest);
+            BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
+
+            // Try flipped case version
+            for (char& c : exp_base58string) {
+                if (c >= 'a' && c <= 'z') {
+                    c = (c - 'a') + 'A';
+                } else if (c >= 'A' && c <= 'Z') {
+                    c = (c - 'A') + 'a';
+                }
+            }
+            destination = DecodeDestination(exp_base58string);
+            BOOST_CHECK_MESSAGE(IsValidDestination(destination) == try_case_flip, "!IsValid case flipped:" + strTest);
+            if (IsValidDestination(destination)) {
+                script.SetDestination(destination);
+                BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
+            }
+
+            // Public key must be invalid private key
+            privkey = DecodeSecret(exp_base58string);
+            BOOST_CHECK_MESSAGE(!privkey.IsValid(), "IsValid pubkey as privkey:" + strTest);
+        }
+    }
+}
+
+// Goal: check that generated keys match test vectors
+BOOST_AUTO_TEST_CASE(key_io_valid_gen)
+{
+    UniValue tests = read_json(std::string(json_tests::key_io_valid, json_tests::key_io_valid + sizeof(json_tests::key_io_valid)));
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        const UniValue& test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 3) // Allow for extra stuff (useful for comments)
+        {
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        std::string exp_base58string = test[0].get_str();
+        std::vector<unsigned char> exp_payload = ParseHex(test[1].get_str());
+        const UniValue &metadata = test[2].get_obj();
+        bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
+        SelectParams(find_value(metadata, "chain").get_str());
+        if (isPrivkey) {
+            bool isCompressed = find_value(metadata, "isCompressed").get_bool();
+            CKey key;
+            key.Set(exp_payload.begin(), exp_payload.end(), isCompressed);
+            assert(key.IsValid());
+            BOOST_CHECK_MESSAGE(EncodeSecret(key) == exp_base58string, "result mismatch: " + strTest);
+        } else {
+            CTxDestination dest;
+            CScript exp_script(exp_payload.begin(), exp_payload.end());
+            BOOST_CHECK(ExtractDestination(exp_script, dest));
+            std::string address = EncodeDestination(dest);
+
+            BOOST_CHECK_EQUAL(address, exp_base58string);
+        }
+    }
+
+    SelectParams(CBaseChainParams::MAIN);
+}
+
+
+// Goal: check that base58 parsing code is robust against a variety of corrupted data
+BOOST_AUTO_TEST_CASE(key_io_invalid)
+{
+    UniValue tests = read_json(std::string(json_tests::key_io_invalid, json_tests::key_io_invalid + sizeof(json_tests::key_io_invalid))); // Negative testcases
+    CKey privkey;
+    CTxDestination destination;
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        const UniValue& test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 1) // Allow for extra stuff (useful for comments)
+        {
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        std::string exp_base58string = test[0].get_str();
+
+        // must be invalid as public and as private key
+        for (const auto& chain : { CBaseChainParams::MAIN, CBaseChainParams::TESTNET }) {
+            SelectParams(chain);
+            destination = DecodeDestination(exp_base58string);
+            BOOST_CHECK_MESSAGE(!IsValidDestination(destination), "IsValid pubkey in mainnet:" + strTest);
+            privkey = DecodeSecret(exp_base58string);
+            BOOST_CHECK_MESSAGE(!privkey.IsValid(), "IsValid privkey in mainnet:" + strTest);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()