Bitcoin Core  28.1.0
P2P Digital Currency
key_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2012-2022 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 <common/system.h>
8 #include <key_io.h>
9 #include <span.h>
10 #include <streams.h>
11 #include <secp256k1_extrakeys.h>
12 #include <test/util/random.h>
13 #include <test/util/setup_common.h>
14 #include <uint256.h>
15 #include <util/strencodings.h>
16 #include <util/string.h>
17 
18 #include <string>
19 #include <vector>
20 
21 #include <boost/test/unit_test.hpp>
22 
23 using util::ToString;
24 
25 static const std::string strSecret1 = "5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj";
26 static const std::string strSecret2 = "5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3";
27 static const std::string strSecret1C = "Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw";
28 static const std::string strSecret2C = "L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g";
29 static const std::string addr1 = "1QFqqMUD55ZV3PJEJZtaKCsQmjLT6JkjvJ";
30 static const std::string addr2 = "1F5y5E5FMc5YzdJtB9hLaUe43GDxEKXENJ";
31 static const std::string addr1C = "1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs";
32 static const std::string addr2C = "1CRj2HyM1CXWzHAXLQtiGLyggNT9WQqsDs";
33 
34 static const std::string strAddressBad = "1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF";
35 
36 
37 BOOST_FIXTURE_TEST_SUITE(key_tests, BasicTestingSetup)
38 
39 BOOST_AUTO_TEST_CASE(key_test1)
40 {
41  CKey key1 = DecodeSecret(strSecret1);
42  BOOST_CHECK(key1.IsValid() && !key1.IsCompressed());
43  CKey key2 = DecodeSecret(strSecret2);
44  BOOST_CHECK(key2.IsValid() && !key2.IsCompressed());
45  CKey key1C = DecodeSecret(strSecret1C);
46  BOOST_CHECK(key1C.IsValid() && key1C.IsCompressed());
47  CKey key2C = DecodeSecret(strSecret2C);
48  BOOST_CHECK(key2C.IsValid() && key2C.IsCompressed());
49  CKey bad_key = DecodeSecret(strAddressBad);
50  BOOST_CHECK(!bad_key.IsValid());
51 
52  CPubKey pubkey1 = key1. GetPubKey();
53  CPubKey pubkey2 = key2. GetPubKey();
54  CPubKey pubkey1C = key1C.GetPubKey();
55  CPubKey pubkey2C = key2C.GetPubKey();
56 
57  BOOST_CHECK(key1.VerifyPubKey(pubkey1));
58  BOOST_CHECK(!key1.VerifyPubKey(pubkey1C));
59  BOOST_CHECK(!key1.VerifyPubKey(pubkey2));
60  BOOST_CHECK(!key1.VerifyPubKey(pubkey2C));
61 
62  BOOST_CHECK(!key1C.VerifyPubKey(pubkey1));
63  BOOST_CHECK(key1C.VerifyPubKey(pubkey1C));
64  BOOST_CHECK(!key1C.VerifyPubKey(pubkey2));
65  BOOST_CHECK(!key1C.VerifyPubKey(pubkey2C));
66 
67  BOOST_CHECK(!key2.VerifyPubKey(pubkey1));
68  BOOST_CHECK(!key2.VerifyPubKey(pubkey1C));
69  BOOST_CHECK(key2.VerifyPubKey(pubkey2));
70  BOOST_CHECK(!key2.VerifyPubKey(pubkey2C));
71 
72  BOOST_CHECK(!key2C.VerifyPubKey(pubkey1));
73  BOOST_CHECK(!key2C.VerifyPubKey(pubkey1C));
74  BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));
75  BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));
76 
77  BOOST_CHECK(DecodeDestination(addr1) == CTxDestination(PKHash(pubkey1)));
78  BOOST_CHECK(DecodeDestination(addr2) == CTxDestination(PKHash(pubkey2)));
79  BOOST_CHECK(DecodeDestination(addr1C) == CTxDestination(PKHash(pubkey1C)));
80  BOOST_CHECK(DecodeDestination(addr2C) == CTxDestination(PKHash(pubkey2C)));
81 
82  for (int n=0; n<16; n++)
83  {
84  std::string strMsg = strprintf("Very secret message %i: 11", n);
85  uint256 hashMsg = Hash(strMsg);
86 
87  // normal signatures
88 
89  std::vector<unsigned char> sign1, sign2, sign1C, sign2C;
90 
91  BOOST_CHECK(key1.Sign (hashMsg, sign1));
92  BOOST_CHECK(key2.Sign (hashMsg, sign2));
93  BOOST_CHECK(key1C.Sign(hashMsg, sign1C));
94  BOOST_CHECK(key2C.Sign(hashMsg, sign2C));
95 
96  BOOST_CHECK( pubkey1.Verify(hashMsg, sign1));
97  BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2));
98  BOOST_CHECK( pubkey1.Verify(hashMsg, sign1C));
99  BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2C));
100 
101  BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1));
102  BOOST_CHECK( pubkey2.Verify(hashMsg, sign2));
103  BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1C));
104  BOOST_CHECK( pubkey2.Verify(hashMsg, sign2C));
105 
106  BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1));
107  BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2));
108  BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1C));
109  BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2C));
110 
111  BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1));
112  BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2));
113  BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1C));
114  BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2C));
115 
116  // compact signatures (with key recovery)
117 
118  std::vector<unsigned char> csign1, csign2, csign1C, csign2C;
119 
120  BOOST_CHECK(key1.SignCompact (hashMsg, csign1));
121  BOOST_CHECK(key2.SignCompact (hashMsg, csign2));
122  BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));
123  BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));
124 
125  CPubKey rkey1, rkey2, rkey1C, rkey2C;
126 
127  BOOST_CHECK(rkey1.RecoverCompact (hashMsg, csign1));
128  BOOST_CHECK(rkey2.RecoverCompact (hashMsg, csign2));
129  BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));
130  BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));
131 
132  BOOST_CHECK(rkey1 == pubkey1);
133  BOOST_CHECK(rkey2 == pubkey2);
134  BOOST_CHECK(rkey1C == pubkey1C);
135  BOOST_CHECK(rkey2C == pubkey2C);
136  }
137 
138  // test deterministic signing
139 
140  std::vector<unsigned char> detsig, detsigc;
141  std::string strMsg = "Very deterministic message";
142  uint256 hashMsg = Hash(strMsg);
143  BOOST_CHECK(key1.Sign(hashMsg, detsig));
144  BOOST_CHECK(key1C.Sign(hashMsg, detsigc));
145  BOOST_CHECK(detsig == detsigc);
146  BOOST_CHECK(detsig == ParseHex("304402205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d022014ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
147  BOOST_CHECK(key2.Sign(hashMsg, detsig));
148  BOOST_CHECK(key2C.Sign(hashMsg, detsigc));
149  BOOST_CHECK(detsig == detsigc);
150  BOOST_CHECK(detsig == ParseHex("3044022052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd5022061d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
151  BOOST_CHECK(key1.SignCompact(hashMsg, detsig));
152  BOOST_CHECK(key1C.SignCompact(hashMsg, detsigc));
153  BOOST_CHECK(detsig == ParseHex("1c5dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
154  BOOST_CHECK(detsigc == ParseHex("205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
155  BOOST_CHECK(key2.SignCompact(hashMsg, detsig));
156  BOOST_CHECK(key2C.SignCompact(hashMsg, detsigc));
157  BOOST_CHECK(detsig == ParseHex("1c52d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
158  BOOST_CHECK(detsigc == ParseHex("2052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
159 }
160 
161 BOOST_AUTO_TEST_CASE(key_signature_tests)
162 {
163  // When entropy is specified, we should see at least one high R signature within 20 signatures
164  CKey key = DecodeSecret(strSecret1);
165  std::string msg = "A message to be signed";
166  uint256 msg_hash = Hash(msg);
167  std::vector<unsigned char> sig;
168  bool found = false;
169 
170  for (int i = 1; i <=20; ++i) {
171  sig.clear();
172  BOOST_CHECK(key.Sign(msg_hash, sig, false, i));
173  found = sig[3] == 0x21 && sig[4] == 0x00;
174  if (found) {
175  break;
176  }
177  }
178  BOOST_CHECK(found);
179 
180  // When entropy is not specified, we should always see low R signatures that are less than or equal to 70 bytes in 256 tries
181  // The low R signatures should always have the value of their "length of R" byte less than or equal to 32
182  // We should see at least one signature that is less than 70 bytes.
183  bool found_small = false;
184  bool found_big = false;
185  bool bad_sign = false;
186  for (int i = 0; i < 256; ++i) {
187  sig.clear();
188  std::string msg = "A message to be signed" + ToString(i);
189  msg_hash = Hash(msg);
190  if (!key.Sign(msg_hash, sig)) {
191  bad_sign = true;
192  break;
193  }
194  // sig.size() > 70 implies sig[3] > 32, because S is always low.
195  // But check both conditions anyway, just in case this implication is broken for some reason
196  if (sig[3] > 32 || sig.size() > 70) {
197  found_big = true;
198  break;
199  }
200  found_small |= sig.size() < 70;
201  }
202  BOOST_CHECK(!bad_sign);
203  BOOST_CHECK(!found_big);
204  BOOST_CHECK(found_small);
205 }
206 
207 static CPubKey UnserializePubkey(const std::vector<uint8_t>& data)
208 {
209  DataStream stream{};
210  stream << data;
211  CPubKey pubkey;
212  stream >> pubkey;
213  return pubkey;
214 }
215 
216 static unsigned int GetLen(unsigned char chHeader)
217 {
218  if (chHeader == 2 || chHeader == 3)
219  return CPubKey::COMPRESSED_SIZE;
220  if (chHeader == 4 || chHeader == 6 || chHeader == 7)
221  return CPubKey::SIZE;
222  return 0;
223 }
224 
225 static void CmpSerializationPubkey(const CPubKey& pubkey)
226 {
227  DataStream stream{};
228  stream << pubkey;
229  CPubKey pubkey2;
230  stream >> pubkey2;
231  BOOST_CHECK(pubkey == pubkey2);
232 }
233 
234 BOOST_AUTO_TEST_CASE(pubkey_unserialize)
235 {
236  for (uint8_t i = 2; i <= 7; ++i) {
237  CPubKey key = UnserializePubkey({0x02});
238  BOOST_CHECK(!key.IsValid());
239  CmpSerializationPubkey(key);
240  key = UnserializePubkey(std::vector<uint8_t>(GetLen(i), i));
241  CmpSerializationPubkey(key);
242  if (i == 5) {
243  BOOST_CHECK(!key.IsValid());
244  } else {
245  BOOST_CHECK(key.IsValid());
246  }
247  }
248 }
249 
250 BOOST_AUTO_TEST_CASE(bip340_test_vectors)
251 {
252  static const std::vector<std::pair<std::array<std::string, 3>, bool>> VECTORS = {
253  {{"F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9", "0000000000000000000000000000000000000000000000000000000000000000", "E907831F80848D1069A5371B402410364BDF1C5F8307B0084C55F1CE2DCA821525F66A4A85EA8B71E482A74F382D2CE5EBEEE8FDB2172F477DF4900D310536C0"}, true},
254  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6896BD60EEAE296DB48A229FF71DFE071BDE413E6D43F917DC8DCF8C78DE33418906D11AC976ABCCB20B091292BFF4EA897EFCB639EA871CFA95F6DE339E4B0A"}, true},
255  {{"DD308AFEC5777E13121FA72B9CC1B7CC0139715309B086C960E18FD969774EB8", "7E2D58D8B3BCDF1ABADEC7829054F90DDA9805AAB56C77333024B9D0A508B75C", "5831AAEED7B44BB74E5EAB94BA9D4294C49BCF2A60728D8B4C200F50DD313C1BAB745879A5AD954A72C45A91C3A51D3C7ADEA98D82F8481E0E1E03674A6F3FB7"}, true},
256  {{"25D1DFF95105F5253C4022F628A996AD3A0D95FBF21D468A1B33F8C160D8F517", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "7EB0509757E246F19449885651611CB965ECC1A187DD51B64FDA1EDC9637D5EC97582B9CB13DB3933705B32BA982AF5AF25FD78881EBB32771FC5922EFC66EA3"}, true},
257  {{"D69C3509BB99E412E68B0FE8544E72837DFA30746D8BE2AA65975F29D22DC7B9", "4DF3C3F68FCC83B27E9D42C90431A72499F17875C81A599B566C9889B9696703", "00000000000000000000003B78CE563F89A0ED9414F5AA28AD0D96D6795F9C6376AFB1548AF603B3EB45C9F8207DEE1060CB71C04E80F593060B07D28308D7F4"}, true},
258  {{"EEFDEA4CDB677750A420FEE807EACF21EB9898AE79B9768766E4FAA04A2D4A34", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E17776969E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B"}, false},
259  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A14602975563CC27944640AC607CD107AE10923D9EF7A73C643E166BE5EBEAFA34B1AC553E2"}, false},
260  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "1FA62E331EDBC21C394792D2AB1100A7B432B013DF3F6FF4F99FCB33E0E1515F28890B3EDB6E7189B630448B515CE4F8622A954CFE545735AAEA5134FCCDB2BD"}, false},
261  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E177769961764B3AA9B2FFCB6EF947B6887A226E8D7C93E00C5ED0C1834FF0D0C2E6DA6"}, false},
262  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "0000000000000000000000000000000000000000000000000000000000000000123DDA8328AF9C23A94C1FEECFD123BA4FB73476F0D594DCB65C6425BD186051"}, false},
263  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "00000000000000000000000000000000000000000000000000000000000000017615FBAF5AE28864013C099742DEADB4DBA87F11AC6754F93780D5A1837CF197"}, false},
264  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "4A298DACAE57395A15D0795DDBFD1DCB564DA82B0F269BC70A74F8220429BA1D69E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B"}, false},
265  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F69E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B"}, false},
266  {{"DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E177769FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"}, false},
267  {{"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC30", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E17776969E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B"}, false}
268  };
269 
270  for (const auto& test : VECTORS) {
271  auto pubkey = ParseHex(test.first[0]);
272  auto msg = ParseHex(test.first[1]);
273  auto sig = ParseHex(test.first[2]);
274  BOOST_CHECK_EQUAL(XOnlyPubKey(pubkey).VerifySchnorr(uint256(msg), sig), test.second);
275  }
276 
277  static const std::vector<std::array<std::string, 5>> SIGN_VECTORS = {
278  {{"0000000000000000000000000000000000000000000000000000000000000003", "F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9", "0000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000000", "E907831F80848D1069A5371B402410364BDF1C5F8307B0084C55F1CE2DCA821525F66A4A85EA8B71E482A74F382D2CE5EBEEE8FDB2172F477DF4900D310536C0"}},
279  {{"B7E151628AED2A6ABF7158809CF4F3C762E7160F38B4DA56A784D9045190CFEF", "DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "0000000000000000000000000000000000000000000000000000000000000001", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "6896BD60EEAE296DB48A229FF71DFE071BDE413E6D43F917DC8DCF8C78DE33418906D11AC976ABCCB20B091292BFF4EA897EFCB639EA871CFA95F6DE339E4B0A"}},
280  {{"C90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B14E5C9", "DD308AFEC5777E13121FA72B9CC1B7CC0139715309B086C960E18FD969774EB8", "C87AA53824B4D7AE2EB035A2B5BBBCCC080E76CDC6D1692C4B0B62D798E6D906", "7E2D58D8B3BCDF1ABADEC7829054F90DDA9805AAB56C77333024B9D0A508B75C", "5831AAEED7B44BB74E5EAB94BA9D4294C49BCF2A60728D8B4C200F50DD313C1BAB745879A5AD954A72C45A91C3A51D3C7ADEA98D82F8481E0E1E03674A6F3FB7"}},
281  {{"0B432B2677937381AEF05BB02A66ECD012773062CF3FA2549E44F58ED2401710", "25D1DFF95105F5253C4022F628A996AD3A0D95FBF21D468A1B33F8C160D8F517", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "7EB0509757E246F19449885651611CB965ECC1A187DD51B64FDA1EDC9637D5EC97582B9CB13DB3933705B32BA982AF5AF25FD78881EBB32771FC5922EFC66EA3"}},
282  };
283 
284  for (const auto& [sec_hex, pub_hex, aux_hex, msg_hex, sig_hex] : SIGN_VECTORS) {
285  auto sec = ParseHex(sec_hex);
286  auto pub = ParseHex(pub_hex);
287  uint256 aux256(ParseHex(aux_hex));
288  uint256 msg256(ParseHex(msg_hex));
289  auto sig = ParseHex(sig_hex);
290  unsigned char sig64[64];
291 
292  // Run the untweaked test vectors above, comparing with exact expected signature.
293  CKey key;
294  key.Set(sec.begin(), sec.end(), true);
295  XOnlyPubKey pubkey(key.GetPubKey());
296  BOOST_CHECK(std::equal(pubkey.begin(), pubkey.end(), pub.begin(), pub.end()));
297  bool ok = key.SignSchnorr(msg256, sig64, nullptr, aux256);
298  BOOST_CHECK(ok);
299  BOOST_CHECK(std::vector<unsigned char>(sig64, sig64 + 64) == sig);
300  // Verify those signatures for good measure.
301  BOOST_CHECK(pubkey.VerifySchnorr(msg256, sig64));
302 
303  // Repeat the same check, but use the KeyPair directly without any merkle tweak
304  KeyPair keypair = key.ComputeKeyPair(/*merkle_root=*/nullptr);
305  bool kp_ok = keypair.SignSchnorr(msg256, sig64, aux256);
306  BOOST_CHECK(kp_ok);
307  BOOST_CHECK(pubkey.VerifySchnorr(msg256, sig64));
308  BOOST_CHECK(std::vector<unsigned char>(sig64, sig64 + 64) == sig);
309 
310  // Do 10 iterations where we sign with a random Merkle root to tweak,
311  // and compare against the resulting tweaked keys, with random aux.
312  // In iteration i=0 we tweak with empty Merkle tree.
313  for (int i = 0; i < 10; ++i) {
314  uint256 merkle_root;
315  if (i) merkle_root = InsecureRand256();
316  auto tweaked = pubkey.CreateTapTweak(i ? &merkle_root : nullptr);
317  BOOST_CHECK(tweaked);
318  XOnlyPubKey tweaked_key = tweaked->first;
319  aux256 = InsecureRand256();
320  bool ok = key.SignSchnorr(msg256, sig64, &merkle_root, aux256);
321  BOOST_CHECK(ok);
322  BOOST_CHECK(tweaked_key.VerifySchnorr(msg256, sig64));
323 
324  // Repeat the same check, but use the KeyPair class directly
325  KeyPair keypair = key.ComputeKeyPair(&merkle_root);
326  bool kp_ok = keypair.SignSchnorr(msg256, sig64, aux256);
327  BOOST_CHECK(kp_ok);
328  BOOST_CHECK(tweaked_key.VerifySchnorr(msg256, sig64));
329  }
330  }
331 }
332 
333 BOOST_AUTO_TEST_CASE(key_ellswift)
334 {
335  for (const auto& secret : {strSecret1, strSecret2, strSecret1C, strSecret2C}) {
336  CKey key = DecodeSecret(secret);
337  BOOST_CHECK(key.IsValid());
338 
339  uint256 ent32 = InsecureRand256();
340  auto ellswift = key.EllSwiftCreate(AsBytes(Span{ent32}));
341 
342  CPubKey decoded_pubkey = ellswift.Decode();
343  if (!key.IsCompressed()) {
344  // The decoding constructor returns a compressed pubkey. If the
345  // original was uncompressed, we must decompress the decoded one
346  // to compare.
347  decoded_pubkey.Decompress();
348  }
349  BOOST_CHECK(key.GetPubKey() == decoded_pubkey);
350  }
351 }
352 
353 BOOST_AUTO_TEST_CASE(bip341_test_h)
354 {
355  std::vector<unsigned char> G_uncompressed = ParseHex("0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8");
356  HashWriter hw;
357  hw.write(MakeByteSpan(G_uncompressed));
358  XOnlyPubKey H{hw.GetSHA256()};
359  BOOST_CHECK(XOnlyPubKey::NUMS_H == H);
360 }
361 
362 BOOST_AUTO_TEST_CASE(key_schnorr_tweak_smoke_test)
363 {
364  // Sanity check to ensure we get the same tweak using CPubKey vs secp256k1 functions
365  secp256k1_context* secp256k1_context_sign = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
366 
367  CKey key;
368  key.MakeNewKey(true);
369  uint256 merkle_root = InsecureRand256();
370 
371  // secp256k1 functions
372  secp256k1_keypair keypair;
373  BOOST_CHECK(secp256k1_keypair_create(secp256k1_context_sign, &keypair, UCharCast(key.begin())));
374  secp256k1_xonly_pubkey xonly_pubkey;
375  BOOST_CHECK(secp256k1_keypair_xonly_pub(secp256k1_context_sign, &xonly_pubkey, nullptr, &keypair));
376  unsigned char xonly_bytes[32];
377  BOOST_CHECK(secp256k1_xonly_pubkey_serialize(secp256k1_context_sign, xonly_bytes, &xonly_pubkey));
378  uint256 tweak_old = XOnlyPubKey(xonly_bytes).ComputeTapTweakHash(&merkle_root);
379 
380  // CPubKey
381  CPubKey pubkey = key.GetPubKey();
382  uint256 tweak_new = XOnlyPubKey(pubkey).ComputeTapTweakHash(&merkle_root);
383 
384  BOOST_CHECK_EQUAL(tweak_old, tweak_new);
385 
386  secp256k1_context_destroy(secp256k1_context_sign);
387 }
388 
389 BOOST_AUTO_TEST_SUITE_END()
strSecret2C
static const std::string strSecret2C
Definition: key_tests.cpp:28
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(key_test1)
Definition: key_tests.cpp:39
CPubKey::SIZE
static constexpr unsigned int SIZE
secp256k1:
Definition: pubkey.h:39
KeyPair::SignSchnorr
bool SignSchnorr(const uint256 &hash, Span< unsigned char > sig, const uint256 &aux) const
Definition: key.cpp:426
ParseHex
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition: strencodings.h:66
tests_wycheproof_generate.msg
def msg
Definition: tests_wycheproof_generate.py:56
UnserializePubkey
static CPubKey UnserializePubkey(const std::vector< uint8_t > &data)
Definition: key_tests.cpp:207
strSecret1
static const std::string strSecret1
Definition: key_tests.cpp:25
CKey::EllSwiftCreate
EllSwiftPubKey EllSwiftCreate(Span< const std::byte > entropy) const
Create an ellswift-encoded public key for this key, with specified entropy.
Definition: key.cpp:311
addr1C
static const std::string addr1C
Definition: key_tests.cpp:31
secp256k1_keypair_create
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_keypair_create(const secp256k1_context *ctx, secp256k1_keypair *keypair, const unsigned char *seckey) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3)
Compute the keypair for a secret key.
Definition: main_impl.h:196
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1161
CKey::VerifyPubKey
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
Definition: key.cpp:236
CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:182
XOnlyPubKey::ComputeTapTweakHash
uint256 ComputeTapTweakHash(const uint256 *merkle_root) const
Compute the Taproot tweak as specified in BIP341, with *this as internal key:
Definition: pubkey.cpp:242
SECP256K1_CONTEXT_NONE
#define SECP256K1_CONTEXT_NONE
Context flags to pass to secp256k1_context_create, secp256k1_context_preallocated_size, and secp256k1_context_preallocated_create.
Definition: secp256k1.h:205
secp256k1_context_destroy
SECP256K1_API void secp256k1_context_destroy(secp256k1_context *ctx) SECP256K1_ARG_NONNULL(1)
Destroy a secp256k1 context object (created in dynamically allocated memory).
Definition: secp256k1.c:187
secp256k1_context_struct
Definition: secp256k1.c:61
CKey::SignSchnorr
bool SignSchnorr(const uint256 &hash, Span< unsigned char > sig, const uint256 *merkle_root, const uint256 &aux) const
Create a BIP-340 Schnorr signature, for the xonly-pubkey corresponding to *this, optionally tweaked b...
Definition: key.cpp:272
XOnlyPubKey::VerifySchnorr
bool VerifySchnorr(const uint256 &msg, Span< const unsigned char > sigbytes) const
Verify a Schnorr signature against this public key.
Definition: pubkey.cpp:232
strAddressBad
static const std::string strAddressBad
Definition: key_tests.cpp:34
BasicTestingSetup
Basic testing setup.
Definition: setup_common.h:64
KeyPair
KeyPair.
Definition: key.h:267
CKey::SignCompact
bool SignCompact(const uint256 &hash, std::vector< unsigned char > &vchSig) const
Create a compact signature (65 bytes), which allows reconstructing the used public key...
Definition: key.cpp:249
secp256k1_extrakeys.h
CKey::Sign
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, bool grind=true, uint32_t test_case=0) const
Create a DER-serialized signature.
Definition: key.cpp:208
key_io.h
CPubKey::COMPRESSED_SIZE
static constexpr unsigned int COMPRESSED_SIZE
Definition: pubkey.h:40
HashWriter::GetSHA256
uint256 GetSHA256()
Compute the SHA256 hash of all data written to this object.
Definition: hash.h:126
addr2
static const std::string addr2
Definition: key_tests.cpp:30
CKey::ComputeKeyPair
KeyPair ComputeKeyPair(const uint256 *merkle_root) const
Compute a KeyPair.
Definition: key.cpp:347
strSecret1C
static const std::string strSecret1C
Definition: key_tests.cpp:27
secp256k1_xonly_pubkey
Opaque data structure that holds a parsed and valid "x-only" public key.
Definition: secp256k1_extrakeys.h:22
addr1
static const std::string addr1
Definition: key_tests.cpp:29
HashWriter::write
void write(Span< const std::byte > src)
Definition: hash.h:106
DataStream
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:146
HashWriter
A writer stream (for serialization) that computes a 256-bit hash.
Definition: hash.h:100
CPubKey::IsValid
bool IsValid() const
Definition: pubkey.h:189
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
setup_common.h
CPubKey
An encapsulated public key.
Definition: pubkey.h:33
CKey::MakeNewKey
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:161
CKey::IsCompressed
bool IsCompressed() const
Check whether the public key corresponding to this private key is (to be) compressed.
Definition: key.h:126
InsecureRand256
static uint256 InsecureRand256()
Definition: random.h:35
secp256k1_keypair_xonly_pub
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_keypair_xonly_pub(const secp256k1_context *ctx, secp256k1_xonly_pubkey *pubkey, int *pk_parity, const secp256k1_keypair *keypair) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(4)
Get the x-only public key from a keypair.
Definition: main_impl.h:234
CKey::Set
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
Definition: key.h:103
secp256k1_keypair
Opaque data structure that holds a keypair consisting of a secret and a public key.
Definition: secp256k1_extrakeys.h:33
secp256k1_context_sign
static secp256k1_context * secp256k1_context_sign
Definition: key.cpp:19
uint256
256-bit opaque blob.
Definition: uint256.h:178
strSecret2
static const std::string strSecret2
Definition: key_tests.cpp:26
CPubKey::Verify
bool Verify(const uint256 &hash, const std::vector< unsigned char > &vchSig) const
Verify a DER signature (~72 bytes).
Definition: pubkey.cpp:279
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
GetPubKey
static bool GetPubKey(const SigningProvider &provider, const SignatureData &sigdata, const CKeyID &address, CPubKey &pubkey)
Definition: sign.cpp:109
CTxDestination
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
Definition: addresstype.h:140
CKey::begin
const std::byte * begin() const
Definition: key.h:119
secp256k1_xonly_pubkey_serialize
SECP256K1_API int secp256k1_xonly_pubkey_serialize(const secp256k1_context *ctx, unsigned char *output32, const secp256k1_xonly_pubkey *pubkey) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3)
Serialize an xonly_pubkey object into a 32-byte sequence.
Definition: main_impl.h:44
MakeByteSpan
Span< const std::byte > MakeByteSpan(V &&v) noexcept
Definition: span.h:277
AsBytes
Span< const std::byte > AsBytes(Span< T > s) noexcept
Definition: span.h:266
GetLen
static unsigned int GetLen(unsigned char chHeader)
Definition: key_tests.cpp:216
UCharCast
unsigned char * UCharCast(char *c)
Definition: span.h:288
CmpSerializationPubkey
static void CmpSerializationPubkey(const CPubKey &pubkey)
Definition: key_tests.cpp:225
CKey
An encapsulated private key.
Definition: key.h:34
Span
A Span is an object that can refer to a contiguous sequence of objects.
Definition: solver.h:20
Hash
uint256 Hash(const T &in1)
Compute the 256-bit hash of an object.
Definition: hash.h:75
DecodeSecret
CKey DecodeSecret(const std::string &str)
Definition: key_io.cpp:213
XOnlyPubKey::NUMS_H
static const XOnlyPubKey NUMS_H
Nothing Up My Sleeve point H Used as an internal key for provably disabling the key path spend see BI...
Definition: pubkey.h:239
DecodeDestination
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
Definition: key_io.cpp:299
secp256k1_context_create
SECP256K1_API secp256k1_context * secp256k1_context_create(unsigned int flags) SECP256K1_WARN_UNUSED_RESULT
Create a secp256k1 context object (in dynamically allocated memory).
Definition: secp256k1.c:141
addr2C
static const std::string addr2C
Definition: key_tests.cpp:32
util::ToString
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:156
CPubKey::Decompress
bool Decompress()
Turn this public key into an uncompressed public key.
Definition: pubkey.cpp:323
CKey::IsValid
bool IsValid() const
Check whether this private key is valid.
Definition: key.h:123
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
Generated on Tue Jan 7 2025 12:00:00 for Bitcoin Core by   doxygen 1.8.14