Line data Source code
1 : // Copyright (c) 2012-2013 The Bitcoin Core developers
2 : // Distributed under the MIT software license, see the accompanying
3 : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 :
5 : #include "key.h"
6 :
7 : #include "base58.h"
8 : #include "script/script.h"
9 : #include "uint256.h"
10 : #include "util.h"
11 : #include "utilstrencodings.h"
12 : #include "test/test_bitcoin.h"
13 :
14 : #include <string>
15 : #include <vector>
16 :
17 : #include <boost/test/unit_test.hpp>
18 :
19 : using namespace std;
20 :
21 2 : static const string strSecret1 ("5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj");
22 2 : static const string strSecret2 ("5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3");
23 2 : static const string strSecret1C ("Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw");
24 2 : static const string strSecret2C ("L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g");
25 1 : static const CBitcoinAddress addr1 ("1QFqqMUD55ZV3PJEJZtaKCsQmjLT6JkjvJ");
26 1 : static const CBitcoinAddress addr2 ("1F5y5E5FMc5YzdJtB9hLaUe43GDxEKXENJ");
27 1 : static const CBitcoinAddress addr1C("1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs");
28 1 : static const CBitcoinAddress addr2C("1CRj2HyM1CXWzHAXLQtiGLyggNT9WQqsDs");
29 :
30 :
31 2 : static const string strAddressBad("1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF");
32 :
33 :
34 : #ifdef KEY_TESTS_DUMPINFO
35 : void dumpKeyInfo(uint256 privkey)
36 : {
37 : CKey key;
38 : key.resize(32);
39 : memcpy(&secret[0], &privkey, 32);
40 : vector<unsigned char> sec;
41 : sec.resize(32);
42 : memcpy(&sec[0], &secret[0], 32);
43 : printf(" * secret (hex): %s\n", HexStr(sec).c_str());
44 :
45 : for (int nCompressed=0; nCompressed<2; nCompressed++)
46 : {
47 : bool fCompressed = nCompressed == 1;
48 : printf(" * %s:\n", fCompressed ? "compressed" : "uncompressed");
49 : CBitcoinSecret bsecret;
50 : bsecret.SetSecret(secret, fCompressed);
51 : printf(" * secret (base58): %s\n", bsecret.ToString().c_str());
52 : CKey key;
53 : key.SetSecret(secret, fCompressed);
54 : vector<unsigned char> vchPubKey = key.GetPubKey();
55 : printf(" * pubkey (hex): %s\n", HexStr(vchPubKey).c_str());
56 : printf(" * address (base58): %s\n", CBitcoinAddress(vchPubKey).ToString().c_str());
57 : }
58 : }
59 : #endif
60 :
61 :
62 1 : BOOST_FIXTURE_TEST_SUITE(key_tests, BasicTestingSetup)
63 :
64 6 : BOOST_AUTO_TEST_CASE(key_test1)
65 : {
66 : CBitcoinSecret bsecret1, bsecret2, bsecret1C, bsecret2C, baddress1;
67 8 : BOOST_CHECK( bsecret1.SetString (strSecret1));
68 8 : BOOST_CHECK( bsecret2.SetString (strSecret2));
69 7 : BOOST_CHECK( bsecret1C.SetString(strSecret1C));
70 8 : BOOST_CHECK( bsecret2C.SetString(strSecret2C));
71 8 : BOOST_CHECK(!baddress1.SetString(strAddressBad));
72 :
73 1 : CKey key1 = bsecret1.GetKey();
74 8 : BOOST_CHECK(key1.IsCompressed() == false);
75 1 : CKey key2 = bsecret2.GetKey();
76 8 : BOOST_CHECK(key2.IsCompressed() == false);
77 1 : CKey key1C = bsecret1C.GetKey();
78 8 : BOOST_CHECK(key1C.IsCompressed() == true);
79 1 : CKey key2C = bsecret2C.GetKey();
80 8 : BOOST_CHECK(key2C.IsCompressed() == true);
81 :
82 1 : CPubKey pubkey1 = key1. GetPubKey();
83 1 : CPubKey pubkey2 = key2. GetPubKey();
84 1 : CPubKey pubkey1C = key1C.GetPubKey();
85 1 : CPubKey pubkey2C = key2C.GetPubKey();
86 :
87 8 : BOOST_CHECK(key1.VerifyPubKey(pubkey1));
88 8 : BOOST_CHECK(!key1.VerifyPubKey(pubkey1C));
89 8 : BOOST_CHECK(!key1.VerifyPubKey(pubkey2));
90 8 : BOOST_CHECK(!key1.VerifyPubKey(pubkey2C));
91 :
92 8 : BOOST_CHECK(!key1C.VerifyPubKey(pubkey1));
93 8 : BOOST_CHECK(key1C.VerifyPubKey(pubkey1C));
94 8 : BOOST_CHECK(!key1C.VerifyPubKey(pubkey2));
95 8 : BOOST_CHECK(!key1C.VerifyPubKey(pubkey2C));
96 :
97 8 : BOOST_CHECK(!key2.VerifyPubKey(pubkey1));
98 8 : BOOST_CHECK(!key2.VerifyPubKey(pubkey1C));
99 8 : BOOST_CHECK(key2.VerifyPubKey(pubkey2));
100 8 : BOOST_CHECK(!key2.VerifyPubKey(pubkey2C));
101 :
102 8 : BOOST_CHECK(!key2C.VerifyPubKey(pubkey1));
103 8 : BOOST_CHECK(!key2C.VerifyPubKey(pubkey1C));
104 8 : BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));
105 8 : BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));
106 :
107 11 : BOOST_CHECK(addr1.Get() == CTxDestination(pubkey1.GetID()));
108 11 : BOOST_CHECK(addr2.Get() == CTxDestination(pubkey2.GetID()));
109 11 : BOOST_CHECK(addr1C.Get() == CTxDestination(pubkey1C.GetID()));
110 11 : BOOST_CHECK(addr2C.Get() == CTxDestination(pubkey2C.GetID()));
111 :
112 17 : for (int n=0; n<16; n++)
113 : {
114 16 : string strMsg = strprintf("Very secret message %i: 11", n);
115 32 : uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
116 :
117 : // normal signatures
118 :
119 : vector<unsigned char> sign1, sign2, sign1C, sign2C;
120 :
121 128 : BOOST_CHECK(key1.Sign (hashMsg, sign1));
122 128 : BOOST_CHECK(key2.Sign (hashMsg, sign2));
123 128 : BOOST_CHECK(key1C.Sign(hashMsg, sign1C));
124 128 : BOOST_CHECK(key2C.Sign(hashMsg, sign2C));
125 :
126 128 : BOOST_CHECK( pubkey1.Verify(hashMsg, sign1));
127 128 : BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2));
128 128 : BOOST_CHECK( pubkey1.Verify(hashMsg, sign1C));
129 128 : BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2C));
130 :
131 128 : BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1));
132 128 : BOOST_CHECK( pubkey2.Verify(hashMsg, sign2));
133 128 : BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1C));
134 128 : BOOST_CHECK( pubkey2.Verify(hashMsg, sign2C));
135 :
136 128 : BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1));
137 128 : BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2));
138 128 : BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1C));
139 128 : BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2C));
140 :
141 128 : BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1));
142 128 : BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2));
143 128 : BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1C));
144 128 : BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2C));
145 :
146 : // compact signatures (with key recovery)
147 :
148 : vector<unsigned char> csign1, csign2, csign1C, csign2C;
149 :
150 128 : BOOST_CHECK(key1.SignCompact (hashMsg, csign1));
151 128 : BOOST_CHECK(key2.SignCompact (hashMsg, csign2));
152 128 : BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));
153 128 : BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));
154 :
155 : CPubKey rkey1, rkey2, rkey1C, rkey2C;
156 :
157 128 : BOOST_CHECK(rkey1.RecoverCompact (hashMsg, csign1));
158 128 : BOOST_CHECK(rkey2.RecoverCompact (hashMsg, csign2));
159 128 : BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));
160 128 : BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));
161 :
162 112 : BOOST_CHECK(rkey1 == pubkey1);
163 128 : BOOST_CHECK(rkey2 == pubkey2);
164 128 : BOOST_CHECK(rkey1C == pubkey1C);
165 128 : BOOST_CHECK(rkey2C == pubkey2C);
166 : }
167 :
168 : // test deterministic signing
169 :
170 : std::vector<unsigned char> detsig, detsigc;
171 2 : string strMsg = "Very deterministic message";
172 2 : uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
173 8 : BOOST_CHECK(key1.Sign(hashMsg, detsig));
174 8 : BOOST_CHECK(key1C.Sign(hashMsg, detsigc));
175 8 : BOOST_CHECK(detsig == detsigc);
176 9 : BOOST_CHECK(detsig == ParseHex("304402205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d022014ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
177 8 : BOOST_CHECK(key2.Sign(hashMsg, detsig));
178 8 : BOOST_CHECK(key2C.Sign(hashMsg, detsigc));
179 8 : BOOST_CHECK(detsig == detsigc);
180 9 : BOOST_CHECK(detsig == ParseHex("3044022052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd5022061d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
181 8 : BOOST_CHECK(key1.SignCompact(hashMsg, detsig));
182 8 : BOOST_CHECK(key1C.SignCompact(hashMsg, detsigc));
183 9 : BOOST_CHECK(detsig == ParseHex("1c5dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
184 9 : BOOST_CHECK(detsigc == ParseHex("205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
185 8 : BOOST_CHECK(key2.SignCompact(hashMsg, detsig));
186 8 : BOOST_CHECK(key2C.SignCompact(hashMsg, detsigc));
187 9 : BOOST_CHECK(detsig == ParseHex("1c52d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
188 9 : BOOST_CHECK(detsigc == ParseHex("2052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
189 1 : }
190 :
191 3 : BOOST_AUTO_TEST_SUITE_END()
|
