git / moonbite-core / src/test/key_tests.cpp · raw

// Copyright (c) 2012-2020 The Bitcoin Core developers// Distributed under the MIT software license, see the accompanying// file COPYING or http://www.opensource.org/licenses/mit-license.php.#include <key.h>#include <key_io.h>#include <streams.h>#include <test/util/setup_common.h>#include <uint256.h>#include <util/strencodings.h>#include <util/string.h>#include <util/system.h>#include <string>#include <vector>#include <boost/test/unit_test.hpp>static const std::string strSecret1 = "6uGFQ4DSW7zh1viHZi6iiVT17CncvoaV4MHvGvJKPDaLCdymj87";static const std::string strSecret2 = "6vVo7sPkeLTwVdAntrv4Gbnsyr75H8ChD3P5iyHziwaqe8mCYR5";static const std::string strSecret1C = "T3gJYmBuZXsdd65E7NQF88ZmUP2MaUanqnZg9GFS94W7kND4Ebjq";static const std::string strSecret2C = "T986ZKRRdnuuXLeDZuKBRrZW1ujotAncU9WTrFU1n7vMgRW75ZtF";static const std::string addr1 = "MXA14nNca6jHw4GZXYYWZUUkExDchQHLDW";static const std::string addr2 = "MMz8JeyerdFMtJHDQ8MGpkFPWV77nQnSPe";static const std::string addr1C = "MVhU6EnHTQM8YsGEXW6zXrEeKkJPeFxtsp";static const std::string addr2C = "MKKtFiskWDhKsx8rZPYeWcb29bLK3egqZm";static const std::string strAddressBad = "Lbi6bpMhSwp2CXkivEeUK9wzyQEFzHDfSr";BOOST_FIXTURE_TEST_SUITE(key_tests, BasicTestingSetup)BOOST_AUTO_TEST_CASE(key_test1){    CKey key1  = DecodeSecret(strSecret1);    BOOST_CHECK(key1.IsValid() && !key1.IsCompressed());    CKey key2  = DecodeSecret(strSecret2);    BOOST_CHECK(key2.IsValid() && !key2.IsCompressed());    CKey key1C = DecodeSecret(strSecret1C);    BOOST_CHECK(key1C.IsValid() && key1C.IsCompressed());    CKey key2C = DecodeSecret(strSecret2C);    BOOST_CHECK(key2C.IsValid() && key2C.IsCompressed());    CKey bad_key = DecodeSecret(strAddressBad);    BOOST_CHECK(!bad_key.IsValid());    CPubKey pubkey1  = key1. GetPubKey();    CPubKey pubkey2  = key2. GetPubKey();    CPubKey pubkey1C = key1C.GetPubKey();    CPubKey pubkey2C = key2C.GetPubKey();    BOOST_CHECK(key1.VerifyPubKey(pubkey1));    BOOST_CHECK(!key1.VerifyPubKey(pubkey1C));    BOOST_CHECK(!key1.VerifyPubKey(pubkey2));    BOOST_CHECK(!key1.VerifyPubKey(pubkey2C));    BOOST_CHECK(!key1C.VerifyPubKey(pubkey1));    BOOST_CHECK(key1C.VerifyPubKey(pubkey1C));    BOOST_CHECK(!key1C.VerifyPubKey(pubkey2));    BOOST_CHECK(!key1C.VerifyPubKey(pubkey2C));    BOOST_CHECK(!key2.VerifyPubKey(pubkey1));    BOOST_CHECK(!key2.VerifyPubKey(pubkey1C));    BOOST_CHECK(key2.VerifyPubKey(pubkey2));    BOOST_CHECK(!key2.VerifyPubKey(pubkey2C));    BOOST_CHECK(!key2C.VerifyPubKey(pubkey1));    BOOST_CHECK(!key2C.VerifyPubKey(pubkey1C));    BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));    BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));    BOOST_CHECK(DecodeDestination(addr1)  == CTxDestination(PKHash(pubkey1)));    BOOST_CHECK(DecodeDestination(addr2)  == CTxDestination(PKHash(pubkey2)));    BOOST_CHECK(DecodeDestination(addr1C) == CTxDestination(PKHash(pubkey1C)));    BOOST_CHECK(DecodeDestination(addr2C) == CTxDestination(PKHash(pubkey2C)));    for (int n=0; n<16; n++)    {        std::string strMsg = strprintf("Very secret message %i: 11", n);        uint256 hashMsg = Hash(strMsg);        // normal signatures        std::vector<unsigned char> sign1, sign2, sign1C, sign2C;        BOOST_CHECK(key1.Sign (hashMsg, sign1));        BOOST_CHECK(key2.Sign (hashMsg, sign2));        BOOST_CHECK(key1C.Sign(hashMsg, sign1C));        BOOST_CHECK(key2C.Sign(hashMsg, sign2C));        BOOST_CHECK( pubkey1.Verify(hashMsg, sign1));        BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2));        BOOST_CHECK( pubkey1.Verify(hashMsg, sign1C));        BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2C));        BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1));        BOOST_CHECK( pubkey2.Verify(hashMsg, sign2));        BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1C));        BOOST_CHECK( pubkey2.Verify(hashMsg, sign2C));        BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1));        BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2));        BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1C));        BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2C));        BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1));        BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2));        BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1C));        BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2C));        // compact signatures (with key recovery)        std::vector<unsigned char> csign1, csign2, csign1C, csign2C;        BOOST_CHECK(key1.SignCompact (hashMsg, csign1));        BOOST_CHECK(key2.SignCompact (hashMsg, csign2));        BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));        BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));        CPubKey rkey1, rkey2, rkey1C, rkey2C;        BOOST_CHECK(rkey1.RecoverCompact (hashMsg, csign1));        BOOST_CHECK(rkey2.RecoverCompact (hashMsg, csign2));        BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));        BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));        BOOST_CHECK(rkey1  == pubkey1);        BOOST_CHECK(rkey2  == pubkey2);        BOOST_CHECK(rkey1C == pubkey1C);        BOOST_CHECK(rkey2C == pubkey2C);    }    // test deterministic signing    std::vector<unsigned char> detsig, detsigc;    std::string strMsg = "Very deterministic message";    uint256 hashMsg = Hash(strMsg);    BOOST_CHECK(key1.Sign(hashMsg, detsig));    BOOST_CHECK(key1C.Sign(hashMsg, detsigc));    BOOST_CHECK(detsig == detsigc);    BOOST_CHECK(detsig == ParseHex("304402205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d022014ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));    BOOST_CHECK(key2.Sign(hashMsg, detsig));    BOOST_CHECK(key2C.Sign(hashMsg, detsigc));    BOOST_CHECK(detsig == detsigc);    BOOST_CHECK(detsig == ParseHex("3044022052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd5022061d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));    BOOST_CHECK(key1.SignCompact(hashMsg, detsig));    BOOST_CHECK(key1C.SignCompact(hashMsg, detsigc));    BOOST_CHECK(detsig == ParseHex("1c5dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));    BOOST_CHECK(detsigc == ParseHex("205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));    BOOST_CHECK(key2.SignCompact(hashMsg, detsig));    BOOST_CHECK(key2C.SignCompact(hashMsg, detsigc));    BOOST_CHECK(detsig == ParseHex("1c52d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));    BOOST_CHECK(detsigc == ParseHex("2052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));}BOOST_AUTO_TEST_CASE(key_signature_tests){    // When entropy is specified, we should see at least one high R signature within 20 signatures    CKey key = DecodeSecret(strSecret1);    std::string msg = "A message to be signed";    uint256 msg_hash = Hash(msg);    std::vector<unsigned char> sig;    bool found = false;    for (int i = 1; i <=20; ++i) {        sig.clear();        BOOST_CHECK(key.Sign(msg_hash, sig, false, i));        found = sig[3] == 0x21 && sig[4] == 0x00;        if (found) {            break;        }    }    BOOST_CHECK(found);    // When entropy is not specified, we should always see low R signatures that are less than 70 bytes in 256 tries    // We should see at least one signature that is less than 70 bytes.    found = true;    bool found_small = false;    for (int i = 0; i < 256; ++i) {        sig.clear();        std::string msg = "A message to be signed" + ToString(i);        msg_hash = Hash(msg);        BOOST_CHECK(key.Sign(msg_hash, sig));        found = sig[3] == 0x20;        BOOST_CHECK(sig.size() <= 70);        found_small |= sig.size() < 70;    }    BOOST_CHECK(found);    BOOST_CHECK(found_small);}BOOST_AUTO_TEST_CASE(key_key_negation){    // create a dummy hash for signature comparison    unsigned char rnd[8];    std::string str = "Bitcoin key verification\n";    GetRandBytes(rnd, sizeof(rnd));    uint256 hash;    CHash256().Write(MakeUCharSpan(str)).Write(rnd).Finalize(hash);    // import the static test key    CKey key = DecodeSecret(strSecret1C);    // create a signature    std::vector<unsigned char> vch_sig;    std::vector<unsigned char> vch_sig_cmp;    key.Sign(hash, vch_sig);    // negate the key twice    BOOST_CHECK(key.GetPubKey().data()[0] == 0x03);    key.Negate();    // after the first negation, the signature must be different    key.Sign(hash, vch_sig_cmp);    BOOST_CHECK(vch_sig_cmp != vch_sig);    BOOST_CHECK(key.GetPubKey().data()[0] == 0x02);    key.Negate();    // after the second negation, we should have the original key and thus the    // same signature    key.Sign(hash, vch_sig_cmp);    BOOST_CHECK(vch_sig_cmp == vch_sig);    BOOST_CHECK(key.GetPubKey().data()[0] == 0x03);}static CPubKey UnserializePubkey(const std::vector<uint8_t>& data){    CDataStream stream{SER_NETWORK, INIT_PROTO_VERSION};    stream << data;    CPubKey pubkey;    stream >> pubkey;    return pubkey;}static unsigned int GetLen(unsigned char chHeader){    if (chHeader == 2 || chHeader == 3)        return CPubKey::COMPRESSED_SIZE;    if (chHeader == 4 || chHeader == 6 || chHeader == 7)        return CPubKey::SIZE;    return 0;}static void CmpSerializationPubkey(const CPubKey& pubkey){    CDataStream stream{SER_NETWORK, INIT_PROTO_VERSION};    stream << pubkey;    CPubKey pubkey2;    stream >> pubkey2;    BOOST_CHECK(pubkey == pubkey2);}BOOST_AUTO_TEST_CASE(pubkey_unserialize){    for (uint8_t i = 2; i <= 7; ++i) {        CPubKey key = UnserializePubkey({0x02});        BOOST_CHECK(!key.IsValid());        CmpSerializationPubkey(key);        key = UnserializePubkey(std::vector<uint8_t>(GetLen(i), i));        CmpSerializationPubkey(key);        if (i == 5) {            BOOST_CHECK(!key.IsValid());        } else {            BOOST_CHECK(key.IsValid());        }    }}BOOST_AUTO_TEST_CASE(bip340_test_vectors){    static const std::vector<std::pair<std::array<std::string, 3>, bool>> VECTORS = {        {{"F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9", "0000000000000000000000000000000000000000000000000000000000000000", "E907831F80848D1069A5371B402410364BDF1C5F8307B0084C55F1CE2DCA821525F66A4A85EA8B71E482A74F382D2CE5EBEEE8FDB2172F477DF4900D310536C0"}, true},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6896BD60EEAE296DB48A229FF71DFE071BDE413E6D43F917DC8DCF8C78DE33418906D11AC976ABCCB20B091292BFF4EA897EFCB639EA871CFA95F6DE339E4B0A"}, true},        {{"DD308AFEC5777E13121FA72B9CC1B7CC0139715309B086C960E18FD969774EB8", "7E2D58D8B3BCDF1ABADEC7829054F90DDA9805AAB56C77333024B9D0A508B75C", "5831AAEED7B44BB74E5EAB94BA9D4294C49BCF2A60728D8B4C200F50DD313C1BAB745879A5AD954A72C45A91C3A51D3C7ADEA98D82F8481E0E1E03674A6F3FB7"}, true},        {{"25D1DFF95105F5253C4022F628A996AD3A0D95FBF21D468A1B33F8C160D8F517", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "7EB0509757E246F19449885651611CB965ECC1A187DD51B64FDA1EDC9637D5EC97582B9CB13DB3933705B32BA982AF5AF25FD78881EBB32771FC5922EFC66EA3"}, true},        {{"D69C3509BB99E412E68B0FE8544E72837DFA30746D8BE2AA65975F29D22DC7B9", "4DF3C3F68FCC83B27E9D42C90431A72499F17875C81A599B566C9889B9696703", "00000000000000000000003B78CE563F89A0ED9414F5AA28AD0D96D6795F9C6376AFB1548AF603B3EB45C9F8207DEE1060CB71C04E80F593060B07D28308D7F4"}, true},        {{"EEFDEA4CDB677750A420FEE807EACF21EB9898AE79B9768766E4FAA04A2D4A34", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E17776969E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B"}, false},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A14602975563CC27944640AC607CD107AE10923D9EF7A73C643E166BE5EBEAFA34B1AC553E2"}, false},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "1FA62E331EDBC21C394792D2AB1100A7B432B013DF3F6FF4F99FCB33E0E1515F28890B3EDB6E7189B630448B515CE4F8622A954CFE545735AAEA5134FCCDB2BD"}, false},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E177769961764B3AA9B2FFCB6EF947B6887A226E8D7C93E00C5ED0C1834FF0D0C2E6DA6"}, false},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "0000000000000000000000000000000000000000000000000000000000000000123DDA8328AF9C23A94C1FEECFD123BA4FB73476F0D594DCB65C6425BD186051"}, false},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "00000000000000000000000000000000000000000000000000000000000000017615FBAF5AE28864013C099742DEADB4DBA87F11AC6754F93780D5A1837CF197"}, false},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "4A298DACAE57395A15D0795DDBFD1DCB564DA82B0F269BC70A74F8220429BA1D69E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B"}, false},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F69E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B"}, false},        {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E177769FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"}, false},        {{"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC30", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E17776969E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B"}, false}    };    for (const auto& test : VECTORS) {        auto pubkey = ParseHex(test.first[0]);        auto msg = ParseHex(test.first[1]);        auto sig = ParseHex(test.first[2]);        BOOST_CHECK_EQUAL(XOnlyPubKey(pubkey).VerifySchnorr(uint256(msg), sig), test.second);    }}BOOST_AUTO_TEST_SUITE_END()