Line data    Source code

       1             : // Copyright (c) 2012-2013 The Bitcoin Core developers
       2             : // Copyright (c) 2017-2021 The PIVX Core developers
       3             : // Distributed under the MIT/X11 software license, see the accompanying
       4             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5             : 
       6             : #include "key.h"
       7             : 
       8             : #include "base58.h"
       9             : #include "key_io.h"
      10             : #include "uint256.h"
      11             : #include "util/system.h"
      12             : #include "utilstrencodings.h"
      13             : #include "test_pivx.h"
      14             : 
      15             : #include <string>
      16             : #include <vector>
      17             : 
      18             : #include <boost/test/unit_test.hpp>
      19             : 
      20             : 
      21             : static const std::string strSecret1  = "87vK7Vayi3QLsuiva5yWSuVwSMhMcRM9dBsaD6JXMD1P5vnjRFn";
      22             : static const std::string strSecret2  = "87FGYGFDg5SYfdD4XL593hr7do6f52czPecVsYSAXi8N4RGeS9i";
      23             : static const std::string strSecret1C = "YRYJwfAyJ9c2jhi3T2xQyLijGvM7yLTw4izDaNQLxBzgUYrQiPmJ";
      24             : static const std::string strSecret2C = "YNZyazHkwUbkmUpEYsBGWwHnHQTy2n9rJy1gS5k54YXVx3pE8n6N";
      25             : static const std::string addr1 = "DBFi8XAE1rcdCQfkv9w22n8Y9RxgaJnrDD";
      26             : static const std::string addr2 = "DPvKfv1FVp69yZMDzeuugvfZ9pzYiMv1bs";
      27             : static const std::string addr1C = "DNPrHK9ezAAUVExFDpZ7EE1xWpPskgp1gP";
      28             : static const std::string addr2C = "DNBVSAoc2whPFjZVAZ1pQbXPJk1LRrDC8Q";
      29             : 
      30             : 
      31             : static const std::string strAddressBad ="Xta1praZQjyELweyMByXyiREw1ZRsjXzVP";
      32             : 
      33             : 
      34             : BOOST_FIXTURE_TEST_SUITE(key_tests, TestingSetup)
      35             : 
      36           2 : BOOST_AUTO_TEST_CASE(key_test1)
      37             : {
      38           1 :     CKey key1  = KeyIO::DecodeSecret(strSecret1);
      39           1 :     BOOST_CHECK(key1.IsValid() && !key1.IsCompressed());
      40           2 :     CKey key2  = KeyIO::DecodeSecret(strSecret2);
      41           2 :     BOOST_CHECK(key2.IsValid() && !key2.IsCompressed());
      42           2 :     CKey key1C = KeyIO::DecodeSecret(strSecret1C);
      43           2 :     BOOST_CHECK(key1C.IsValid() && key1C.IsCompressed());
      44           2 :     CKey key2C = KeyIO::DecodeSecret(strSecret2C);
      45           2 :     BOOST_CHECK(key2C.IsValid() && key2C.IsCompressed());
      46           2 :     CKey bad_key = KeyIO::DecodeSecret(strAddressBad);
      47           2 :     BOOST_CHECK(!bad_key.IsValid());
      48             : 
      49           1 :     CPubKey pubkey1  = key1. GetPubKey();
      50           1 :     CPubKey pubkey2  = key2. GetPubKey();
      51           1 :     CPubKey pubkey1C = key1C.GetPubKey();
      52           1 :     CPubKey pubkey2C = key2C.GetPubKey();
      53             : 
      54           2 :     BOOST_CHECK(key1.VerifyPubKey(pubkey1));
      55           2 :     BOOST_CHECK(!key1.VerifyPubKey(pubkey1C));
      56           2 :     BOOST_CHECK(!key1.VerifyPubKey(pubkey2));
      57           2 :     BOOST_CHECK(!key1.VerifyPubKey(pubkey2C));
      58             : 
      59           2 :     BOOST_CHECK(!key1C.VerifyPubKey(pubkey1));
      60           2 :     BOOST_CHECK(key1C.VerifyPubKey(pubkey1C));
      61           2 :     BOOST_CHECK(!key1C.VerifyPubKey(pubkey2));
      62           2 :     BOOST_CHECK(!key1C.VerifyPubKey(pubkey2C));
      63             : 
      64           2 :     BOOST_CHECK(!key2.VerifyPubKey(pubkey1));
      65           2 :     BOOST_CHECK(!key2.VerifyPubKey(pubkey1C));
      66           2 :     BOOST_CHECK(key2.VerifyPubKey(pubkey2));
      67           2 :     BOOST_CHECK(!key2.VerifyPubKey(pubkey2C));
      68             : 
      69           2 :     BOOST_CHECK(!key2C.VerifyPubKey(pubkey1));
      70           2 :     BOOST_CHECK(!key2C.VerifyPubKey(pubkey1C));
      71           2 :     BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));
      72           2 :     BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));
      73             : 
      74           2 :     BOOST_CHECK(DecodeDestination(addr1)  == CTxDestination(pubkey1.GetID()));
      75           2 :     BOOST_CHECK(DecodeDestination(addr2)  == CTxDestination(pubkey2.GetID()));
      76           2 :     BOOST_CHECK(DecodeDestination(addr1C) == CTxDestination(pubkey1C.GetID()));
      77           2 :     BOOST_CHECK(DecodeDestination(addr2C) == CTxDestination(pubkey2C.GetID()));
      78             : 
      79          17 :     for (int n=0; n<16; n++)
      80             :     {
      81          32 :         std::string strMsg = strprintf("Very secret message %i: 11", n);
      82          16 :         uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
      83             : 
      84             :         // normal signatures
      85             : 
      86          80 :         std::vector<unsigned char> sign1, sign2, sign1C, sign2C;
      87             : 
      88          32 :         BOOST_CHECK(key1.Sign (hashMsg, sign1));
      89          32 :         BOOST_CHECK(key2.Sign (hashMsg, sign2));
      90          32 :         BOOST_CHECK(key1C.Sign(hashMsg, sign1C));
      91          32 :         BOOST_CHECK(key2C.Sign(hashMsg, sign2C));
      92             : 
      93          32 :         BOOST_CHECK( pubkey1.Verify(hashMsg, sign1));
      94          32 :         BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2));
      95          32 :         BOOST_CHECK( pubkey1.Verify(hashMsg, sign1C));
      96          32 :         BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2C));
      97             : 
      98          32 :         BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1));
      99          32 :         BOOST_CHECK( pubkey2.Verify(hashMsg, sign2));
     100          32 :         BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1C));
     101          32 :         BOOST_CHECK( pubkey2.Verify(hashMsg, sign2C));
     102             : 
     103          32 :         BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1));
     104          32 :         BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2));
     105          32 :         BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1C));
     106          32 :         BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2C));
     107             : 
     108          32 :         BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1));
     109          32 :         BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2));
     110          32 :         BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1C));
     111          32 :         BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2C));
     112             : 
     113             :         // compact signatures (with key recovery)
     114             : 
     115          80 :         std::vector<unsigned char> csign1, csign2, csign1C, csign2C;
     116             : 
     117          32 :         BOOST_CHECK(key1.SignCompact (hashMsg, csign1));
     118          32 :         BOOST_CHECK(key2.SignCompact (hashMsg, csign2));
     119          32 :         BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));
     120          32 :         BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));
     121             : 
     122          16 :         CPubKey rkey1, rkey2, rkey1C, rkey2C;
     123             : 
     124          32 :         BOOST_CHECK(rkey1.RecoverCompact (hashMsg, csign1));
     125          32 :         BOOST_CHECK(rkey2.RecoverCompact (hashMsg, csign2));
     126          32 :         BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));
     127          32 :         BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));
     128             : 
     129          32 :         BOOST_CHECK(rkey1  == pubkey1);
     130          32 :         BOOST_CHECK(rkey2  == pubkey2);
     131          32 :         BOOST_CHECK(rkey1C == pubkey1C);
     132          32 :         BOOST_CHECK(rkey2C == pubkey2C);
     133             :     }
     134             : 
     135             :     // test deterministic signing
     136             : 
     137           3 :     std::vector<unsigned char> detsig, detsigc;
     138           2 :     std::string strMsg = "Very deterministic message";
     139           1 :     uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
     140           2 :     BOOST_CHECK(key1.Sign(hashMsg, detsig));
     141           2 :     BOOST_CHECK(key1C.Sign(hashMsg, detsigc));
     142           2 :     BOOST_CHECK(detsig == detsigc);
     143           3 :     BOOST_CHECK(detsig == ParseHex("30450221009071d4fead181ea197d6a23106c48ee5de25e023b38afaf71c170e3088e5238a02200dcbc7f1aad626a5ee812e08ef047114642538e423a94b4bd6a272731cf500d0"));
     144           2 :     BOOST_CHECK(key2.Sign(hashMsg, detsig));
     145           2 :     BOOST_CHECK(key2C.Sign(hashMsg, detsigc));
     146           2 :     BOOST_CHECK(detsig == detsigc);
     147           3 :     BOOST_CHECK(detsig == ParseHex("304402204f304f1b05599f88bc517819f6d43c69503baea5f253c55ea2d791394f7ce0de02204f23c0d4c1f4d7a89bf130fed755201d22581911a8a44cf594014794231d325a"));
     148           2 :     BOOST_CHECK(key1.SignCompact(hashMsg, detsig));
     149           2 :     BOOST_CHECK(key1C.SignCompact(hashMsg, detsigc));
     150           3 :     BOOST_CHECK(detsig == ParseHex("1b9071d4fead181ea197d6a23106c48ee5de25e023b38afaf71c170e3088e5238a0dcbc7f1aad626a5ee812e08ef047114642538e423a94b4bd6a272731cf500d0"));
     151           3 :     BOOST_CHECK(detsigc == ParseHex("1f9071d4fead181ea197d6a23106c48ee5de25e023b38afaf71c170e3088e5238a0dcbc7f1aad626a5ee812e08ef047114642538e423a94b4bd6a272731cf500d0"));
     152           2 :     BOOST_CHECK(key2.SignCompact(hashMsg, detsig));
     153           2 :     BOOST_CHECK(key2C.SignCompact(hashMsg, detsigc));
     154           3 :     BOOST_CHECK(detsig == ParseHex("1b4f304f1b05599f88bc517819f6d43c69503baea5f253c55ea2d791394f7ce0de4f23c0d4c1f4d7a89bf130fed755201d22581911a8a44cf594014794231d325a"));
     155           3 :     BOOST_CHECK(detsigc == ParseHex("1f4f304f1b05599f88bc517819f6d43c69503baea5f253c55ea2d791394f7ce0de4f23c0d4c1f4d7a89bf130fed755201d22581911a8a44cf594014794231d325a"));
     156           1 : }
     157             : 
     158             : BOOST_AUTO_TEST_SUITE_END()