key_tests.cpp

// Copyright (c) 2012-2021 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 = "7qh6LYnLN2w2ntz2wwUhRUEgkQ2j8XB16FGw77ZRDZmC29bn7cD";
static const std::string strSecret2 = "7rve4MxeWFQHGbSYH6J2yaaZd3MBUqoDEwN6ZAZ6ZHmhTT4r3hW";
static const std::string strSecret1C = "XBuxZHH6TqXUuaSjbVTFR1DQSYecxCB9QA1Koyx5tTc3ddhqEnhm";
static const std::string strSecret2C = "XHMkZqWcY6Zkoq1j42NBijD8z5N5FtNy2Wx7WyAfXX2HZgxry8cr";
static const std::string addr1 = "Xywgfc872nn5CKtpATCoAjZCc4v96pJczy";
static const std::string addr2 = "XpmouUj9KKJ99ZuU331ZS1KqsboeFnLGgK";
static const std::string addr1C = "XxV9h4Xmv6Pup8tVAQmH97K6grzvDwMG9F";
static const std::string addr2C = "Xn7ZrYdExuk79Dm7CJCw7sfUWi2qWJSbRy";

static const std::string strAddressBad = "Xta1praZQjyELweyMByXyiREw1ZRsjXzVP";


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 or equal to 70 bytes in 256 tries
 // The low R signatures should always have the value of their "length of R" byte less than or equal to 32
 // We should see at least one signature that is less than 70 bytes.
 bool found_small = false;
 bool found_big = false;
 bool bad_sign = false;
 for (int i = 0; i < 256; ++i) {
 sig.clear();
 std::string msg = "A message to be signed" + ToString(i);
 msg_hash = Hash(msg);
 if (!key.Sign(msg_hash, sig)) {
 bad_sign = true;
 break;
 }
 // sig.size() > 70 implies sig[3] > 32, because S is always low.
 // But check both conditions anyway, just in case this implication is broken for some reason
 if (sig[3] > 32 || sig.size() > 70) {
 found_big = true;
 break;
 }
 found_small |= sig.size() < 70;
 }
 BOOST_CHECK(!bad_sign);
 BOOST_CHECK(!found_big);
 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);
 uint256 hash{Hash(str, rnd)};

 // 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(key_ellswift)
{
 for (const auto& secret : {strSecret1, strSecret2, strSecret1C, strSecret2C}) {
 CKey key = DecodeSecret(secret);
 BOOST_CHECK(key.IsValid());

 uint256 ent32 = InsecureRand256();
 auto ellswift = key.EllSwiftCreate(AsBytes(Span{ent32}));

 CPubKey decoded_pubkey = ellswift.Decode();
 if (!key.IsCompressed()) {
 // The decoding constructor returns a compressed pubkey. If the
 // original was uncompressed, we must decompress the decoded one
 // to compare.
 decoded_pubkey.Decompress();
 }
 BOOST_CHECK(key.GetPubKey() == decoded_pubkey);
 }
}

BOOST_AUTO_TEST_SUITE_END()