rippled
KeyGeneration_test.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2015 Ripple Labs Inc.
5 
6  Permission to use, copy, modify, and/or distribute this software for any
7  purpose with or without fee is hereby granted, provided that the above
8  copyright notice and this permission notice appear in all copies.
9 
10  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 //==============================================================================
19 
20 #include <ripple/basics/StringUtilities.h>
21 #include <test/jtx/TestSuite.h>
22 #include <ripple/json/json_value.h>
23 #include <ripple/json/json_writer.h>
24 #include <ripple/protocol/ErrorCodes.h>
25 #include <ripple/protocol/jss.h>
26 #include <ripple/rpc/handlers/WalletPropose.h>
27 #include <ripple/rpc/impl/RPCHelpers.h>
28 
29 namespace ripple {
30 
31 namespace RPC {
32 
33 struct key_strings
34 {
35  char const* account_id;
36  char const* master_key;
37  char const* master_seed;
38  char const* master_seed_hex;
39  char const* public_key;
40  char const* public_key_hex;
41  char const* secret_key_hex;
42  char const* passphrase;
43  char const* passphrase_warning;
44 };
45 
46 namespace common {
47 static char const* passphrase = "REINDEER FLOTILLA";
48 static char const* master_key = "SCAT BERN ISLE FOR ROIL BUS SOAK AQUA FREE FOR DRAM BRIG";
49 static char const* master_seed = "snMwVWs2hZzfDUF3p2tHZ3EgmyhFs";
50 static char const* master_seed_hex = "BE6A670A19B209E112146D0A7ED2AAD7";
51 }
52 
53 static key_strings const secp256k1_strings =
54 {
55  "r4Vtj2jrfmTVZGfSP3gH9hQPMqFPQFin8f",
56  common::master_key,
57  common::master_seed,
58  common::master_seed_hex,
59  "aBQxK2YFNqzmAaXNczYcjqDjfiKkLsJUizsr1UBf44RCF8FHdrmX",
60  "038AAE247B2344B1837FBED8F57389C8C11774510A3F7D784F2A09F0CB6843236C",
61  "1949ECD889EA71324BC7A30C8E81F4E93CB73EE19D59E9082111E78CC3DDABC2",
62  common::passphrase,
63  "This wallet was generated using a user-supplied "
64  "passphrase that has low entropy and is vulnerable "
65  "to brute-force attacks.",
66 };
67 
68 static key_strings const ed25519_strings =
69 {
70  "r4qV6xTXerqaZav3MJfSY79ynmc1BSBev1",
71  common::master_key,
72  common::master_seed,
73  common::master_seed_hex,
74  "aKEQmgLMyZPMruJFejUuedp169LgW6DbJt1rej1DJ5hWUMH4pHJ7",
75  "ED54C3F5BEDA8BD588B203D23A27398FAD9D20F88A974007D6994659CD7273FE1D",
76  "77AAED2698D56D6676323629160F4EEF21CFD9EE3D0745CC78FA291461F98278",
77  common::passphrase,
78  "This wallet was generated using a user-supplied "
79  "passphrase that has low entropy and is vulnerable "
80  "to brute-force attacks.",
81 };
82 
83 static key_strings const strong_brain_strings =
84 {
85  "rBcvXmNb7KPkNdMkpckdWPpbvkWgcV3nir",
86  "TED AVON CAVE HOUR BRAG JEFF RIFT NEAL TOLD FAT SEW SAN",
87  "shKdhWka8hS7Es3bpctCZXBiAwfUN",
88  "74BA8389B44F98CF41E795CD91F9C93F",
89  "aBRL2sqVuzrsM6zikPB4v8UBHGn1aKkrsxhYEffhcQxB2LKyywE5",
90  "03BD334FB9E06C58D69603E9922686528B18A754BC2F2E1ADA095FFE67DE952C64",
91  "84262FB16AA25BE407174C7EDAB531220C30FA4D8A28AA9D564673FB3D34502C",
92  "A4yKIRGdzrw0YQ$2%TFKYG9HP*&ok^!sy7E@RwICs",
93  "This wallet was generated using a user-supplied "
94  "passphrase. It may be vulnerable to brute-force "
95  "attacks.",
96 };
97 
98 class WalletPropose_test : public ripple::TestSuite
99 {
100 public:
101  void testRandomWallet(boost::optional<std::string> const& keyType)
102  {
103  Json::Value params;
104  if (keyType)
105  params[jss::key_type] = *keyType;
106  Json::Value result = walletPropose (params);
107 
108  BEAST_EXPECT(! contains_error (result));
109  BEAST_EXPECT(result.isMember (jss::account_id));
110  BEAST_EXPECT(result.isMember (jss::master_seed));
111  BEAST_EXPECT(result.isMember (jss::master_seed_hex));
112  BEAST_EXPECT(result.isMember (jss::public_key));
113  BEAST_EXPECT(result.isMember (jss::public_key_hex));
114  BEAST_EXPECT(result.isMember (jss::key_type));
115 
116  expectEquals (result[jss::key_type],
117  params.isMember (jss::key_type) ? params[jss::key_type]
118  : "secp256k1");
119  BEAST_EXPECT(!result.isMember(jss::warning));
120 
121  std::string seed = result[jss::master_seed].asString();
122 
123  result = walletPropose (params);
124 
125  // We asked for two random seeds, so they shouldn't match.
126  BEAST_EXPECT(result[jss::master_seed].asString() != seed);
127  }
128 
129  Json::Value testSecretWallet (Json::Value const& params, key_strings const& s)
130  {
131  Json::Value result = walletPropose (params);
132 
133  BEAST_EXPECT(! contains_error (result));
134  expectEquals (result[jss::account_id], s.account_id);
135  expectEquals (result[jss::master_seed], s.master_seed);
136  expectEquals (result[jss::master_seed_hex], s.master_seed_hex);
137  expectEquals (result[jss::public_key], s.public_key);
138  expectEquals (result[jss::public_key_hex], s.public_key_hex);
139  expectEquals (result[jss::key_type],
140  params.isMember (jss::key_type) ? params[jss::key_type]
141  : "secp256k1");
142  return result;
143  }
144 
145  void testSeed (boost::optional<std::string> const& keyType,
146  key_strings const& strings)
147  {
148  testcase ("seed");
149 
150  Json::Value params;
151  if (keyType)
152  params[jss::key_type] = *keyType;
153  params[jss::seed] = strings.master_seed;
154 
155  auto const wallet = testSecretWallet (params, strings);
156  BEAST_EXPECT(!wallet.isMember(jss::warning));
157  }
158 
159  void testSeedHex (boost::optional<std::string> const& keyType,
160  key_strings const& strings)
161  {
162  testcase ("seed_hex");
163 
164  Json::Value params;
165  if (keyType)
166  params[jss::key_type] = *keyType;
167  params[jss::seed_hex] = strings.master_seed_hex;
168 
169  auto const wallet = testSecretWallet (params, strings);
170  BEAST_EXPECT(!wallet.isMember(jss::warning));
171  }
172 
173  void testLegacyPassphrase (char const* value,
174  boost::optional<std::string> const& keyType,
175  key_strings const& strings)
176  {
177  Json::Value params;
178  if (keyType)
179  params[jss::key_type] = *keyType;
180  params[jss::passphrase] = value;
181 
182  auto const wallet = testSecretWallet (params, strings);
183  if (value == strings.passphrase)
184  BEAST_EXPECT(wallet[jss::warning] == strings.passphrase_warning);
185  else
186  BEAST_EXPECT(!wallet.isMember(jss::warning));
187  }
188 
189  void testLegacyPassphrase(boost::optional<std::string> const& keyType,
190  key_strings const& strings)
191  {
192  testcase ("passphrase");
193 
194  testLegacyPassphrase (strings.passphrase, keyType, strings);
195  testLegacyPassphrase (strings.master_key, keyType, strings);
196  testLegacyPassphrase (strings.master_seed, keyType, strings);
197  testLegacyPassphrase (strings.master_seed_hex, keyType, strings);
198  }
199 
200  void testKeyType (boost::optional<std::string> const& keyType,
201  key_strings const& strings)
202  {
203  testcase (keyType ? *keyType : "no key_type");
204 
205  testRandomWallet (keyType);
206  testSeed (keyType, strings);
207  testSeedHex (keyType, strings);
208  testLegacyPassphrase (keyType, strings);
209 
210  Json::Value params;
211  if (keyType)
212  params[jss::key_type] = *keyType;
213  params[jss::seed] = strings.master_seed;
214  params[jss::seed_hex] = strings.master_seed_hex;
215 
216  // Secret fields are mutually exclusive.
217  BEAST_EXPECT(contains_error (walletPropose (params)));
218  }
219 
220  void testBadInput ()
221  {
222  testcase ("Bad inputs");
223 
224  // Passing non-strings where strings are required
225  {
226  Json::Value params;
227  params[jss::key_type] = "secp256k1";
228  params[jss::passphrase] = 20160506;
229  auto result = walletPropose (params);
230  BEAST_EXPECT(contains_error (result));
231  BEAST_EXPECT(result[jss::error_message] ==
232  "Invalid field 'passphrase', not string.");
233  }
234 
235  {
236  Json::Value params;
237  params[jss::key_type] = "secp256k1";
238  params[jss::seed] = Json::objectValue;
239  auto result = walletPropose (params);
240  BEAST_EXPECT(contains_error (result));
241  BEAST_EXPECT(result[jss::error_message] ==
242  "Invalid field 'seed', not string.");
243  }
244 
245  {
246  Json::Value params;
247  params[jss::key_type] = "ed25519";
248  params[jss::seed_hex] = Json::arrayValue;
249  auto result = walletPropose (params);
250  BEAST_EXPECT(contains_error (result));
251  BEAST_EXPECT(result[jss::error_message] ==
252  "Invalid field 'seed_hex', not string.");
253  }
254 
255  // Specifying multiple items at once
256  {
257  Json::Value params;
258  params[jss::key_type] = "secp256k1";
259  params[jss::passphrase] = common::master_key;
260  params[jss::seed_hex] = common::master_seed_hex;
261  params[jss::seed] = common::master_seed;
262  auto result = walletPropose (params);
263  BEAST_EXPECT(contains_error (result));
264  BEAST_EXPECT(result[jss::error_message] ==
265  "Exactly one of the following must be specified: passphrase, seed or seed_hex");
266  }
267 
268  // Specifying bad key types:
269  {
270  Json::Value params;
271  params[jss::key_type] = "prime256v1";
272  params[jss::passphrase] = common::master_key;
273  auto result = walletPropose (params);
274  BEAST_EXPECT(contains_error (result));
275  BEAST_EXPECT(result[jss::error_message] ==
276  "Invalid parameters.");
277  }
278 
279  {
280  Json::Value params;
281  params[jss::key_type] = Json::objectValue;
282  params[jss::seed_hex] = common::master_seed_hex;
283  auto result = walletPropose (params);
284  BEAST_EXPECT(contains_error (result));
285  BEAST_EXPECT(result[jss::error_message] ==
286  "Invalid field 'key_type', not string.");
287  }
288 
289  {
290  Json::Value params;
291  params[jss::key_type] = Json::arrayValue;
292  params[jss::seed] = common::master_seed;
293  auto result = walletPropose (params);
294  BEAST_EXPECT(contains_error (result));
295  BEAST_EXPECT(result[jss::error_message] ==
296  "Invalid field 'key_type', not string.");
297  }
298  }
299 
300  void testKeypairForSignature (
301  boost::optional<std::string> keyType,
302  key_strings const& strings)
303  {
304  testcase ("keypairForSignature - " +
305  (keyType ? *keyType : "no key_type"));
306 
307  auto const publicKey = parseBase58<PublicKey>(
308  TokenType::AccountPublic, strings.public_key);
309  BEAST_EXPECT(publicKey);
310 
311  if (!keyType)
312  {
313  {
314  Json::Value params;
315  Json::Value error;
316  params[jss::secret] = strings.master_seed;
317 
318  auto ret = keypairForSignature (params, error);
319  BEAST_EXPECT(! contains_error (error));
320  BEAST_EXPECT(ret.first.size() != 0);
321  BEAST_EXPECT(ret.first == publicKey);
322  }
323 
324  {
325  Json::Value params;
326  Json::Value error;
327  params[jss::secret] = strings.master_seed_hex;
328 
329  auto ret = keypairForSignature (params, error);
330  BEAST_EXPECT(! contains_error (error));
331  BEAST_EXPECT(ret.first.size() != 0);
332  BEAST_EXPECT(ret.first == publicKey);
333  }
334 
335  {
336  Json::Value params;
337  Json::Value error;
338  params[jss::secret] = strings.master_key;
339 
340  auto ret = keypairForSignature (params, error);
341  BEAST_EXPECT(! contains_error (error));
342  BEAST_EXPECT(ret.first.size() != 0);
343  BEAST_EXPECT(ret.first == publicKey);
344  }
345 
346  keyType.emplace ("secp256k1");
347  }
348 
349  {
350  Json::Value params;
351  Json::Value error;
352 
353  params[jss::key_type] = *keyType;
354  params[jss::seed] = strings.master_seed;
355 
356  auto ret = keypairForSignature (params, error);
357  BEAST_EXPECT(! contains_error (error));
358  BEAST_EXPECT(ret.first.size() != 0);
359  BEAST_EXPECT(ret.first == publicKey);
360  }
361 
362  {
363  Json::Value params;
364  Json::Value error;
365 
366  params[jss::key_type] = *keyType;
367  params[jss::seed_hex] = strings.master_seed_hex;
368 
369  auto ret = keypairForSignature (params, error);
370  BEAST_EXPECT(! contains_error (error));
371  BEAST_EXPECT(ret.first.size() != 0);
372  BEAST_EXPECT(ret.first == publicKey);
373  }
374 
375  {
376  Json::Value params;
377  Json::Value error;
378 
379  params[jss::key_type] = *keyType;
380  params[jss::passphrase] = strings.master_key;
381 
382  auto ret = keypairForSignature (params, error);
383  BEAST_EXPECT(! contains_error (error));
384  BEAST_EXPECT(ret.first.size() != 0);
385  BEAST_EXPECT(ret.first == publicKey);
386  }
387  }
388 
389  void testKeypairForSignatureErrors()
390  {
391  // Specify invalid "secret"
392  {
393  Json::Value params;
394  Json::Value error;
395  params[jss::secret] = 314159265;
396  auto ret = keypairForSignature (params, error);
397  BEAST_EXPECT(contains_error (error));
398  BEAST_EXPECT(error[jss::error_message] ==
399  "Invalid field 'secret', not string.");
400  BEAST_EXPECT(ret.first.size() == 0);
401  }
402 
403  {
404  Json::Value params;
405  Json::Value error;
406  params[jss::secret] = Json::arrayValue;
407  params[jss::secret].append ("array:0");
408 
409  auto ret = keypairForSignature (params, error);
410  BEAST_EXPECT(contains_error (error));
411  BEAST_EXPECT(error[jss::error_message] ==
412  "Invalid field 'secret', not string.");
413  BEAST_EXPECT(ret.first.size() == 0);
414  }
415 
416  {
417  Json::Value params;
418  Json::Value error;
419  params[jss::secret] = Json::objectValue;
420  params[jss::secret]["string"] = "string";
421  params[jss::secret]["number"] = 702;
422 
423  auto ret = keypairForSignature (params, error);
424  BEAST_EXPECT(contains_error (error));
425  BEAST_EXPECT(ret.first.size() == 0);
426  BEAST_EXPECT(error[jss::error_message] ==
427  "Invalid field 'secret', not string.");
428  }
429 
430  // Specify "secret" and "key_type"
431  {
432  Json::Value params;
433  Json::Value error;
434  params[jss::key_type] = "ed25519";
435  params[jss::secret] = common::master_seed;
436 
437  auto ret = keypairForSignature (params, error);
438  BEAST_EXPECT(contains_error (error));
439  BEAST_EXPECT(error[jss::error_message] ==
440  "The secret field is not allowed if key_type is used.");
441  BEAST_EXPECT(ret.first.size() == 0);
442  }
443 
444  // Specify unknown or bad "key_type"
445  {
446  Json::Value params;
447  Json::Value error;
448  params[jss::key_type] = "prime256v1";
449  params[jss::passphrase] = common::master_key;
450 
451  auto ret = keypairForSignature (params, error);
452  BEAST_EXPECT(contains_error (error));
453  BEAST_EXPECT(error[jss::error_message] ==
454  "Invalid field 'key_type'.");
455  BEAST_EXPECT(ret.first.size() == 0);
456  }
457 
458  {
459  Json::Value params;
460  Json::Value error;
461  params[jss::key_type] = Json::objectValue;
462  params[jss::seed_hex] = common::master_seed_hex;
463 
464  auto ret = keypairForSignature (params, error);
465  BEAST_EXPECT(contains_error (error));
466  BEAST_EXPECT(error[jss::error_message] ==
467  "Invalid field 'key_type', not string.");
468  BEAST_EXPECT(ret.first.size() == 0);
469  }
470 
471  {
472  Json::Value params;
473  Json::Value error;
474  params[jss::key_type] = Json::arrayValue;
475  params[jss::seed] = common::master_seed;
476 
477  auto ret = keypairForSignature (params, error);
478  BEAST_EXPECT(contains_error (error));
479  BEAST_EXPECT(error[jss::error_message] ==
480  "Invalid field 'key_type', not string.");
481  BEAST_EXPECT(ret.first.size() == 0);
482  }
483 
484  // Specify non-string passphrase
485  { // not a passphrase: number
486  Json::Value params;
487  Json::Value error;
488  params[jss::key_type] = "secp256k1";
489  params[jss::passphrase] = 1234567890;
490 
491  auto ret = keypairForSignature (params, error);
492  BEAST_EXPECT(contains_error (error));
493  BEAST_EXPECT(error[jss::error_message] ==
494  "Invalid field 'passphrase', not string.");
495  BEAST_EXPECT(ret.first.size() == 0);
496  }
497 
498  { // not a passphrase: object
499  Json::Value params;
500  Json::Value error;
501  params[jss::key_type] = "secp256k1";
502  params[jss::passphrase] = Json::objectValue;
503 
504  auto ret = keypairForSignature (params, error);
505  BEAST_EXPECT(contains_error (error));
506  BEAST_EXPECT(error[jss::error_message] ==
507  "Invalid field 'passphrase', not string.");
508  BEAST_EXPECT(ret.first.size() == 0);
509  }
510 
511  { // not a passphrase: array
512  Json::Value params;
513  Json::Value error;
514  params[jss::key_type] = "secp256k1";
515  params[jss::passphrase] = Json::arrayValue;
516 
517  auto ret = keypairForSignature (params, error);
518  BEAST_EXPECT(contains_error (error));
519  BEAST_EXPECT(error[jss::error_message] ==
520  "Invalid field 'passphrase', not string.");
521  BEAST_EXPECT(ret.first.size() == 0);
522  }
523 
524  { // not a passphrase: empty string
525  Json::Value params;
526  Json::Value error;
527  params[jss::key_type] = "secp256k1";
528  params[jss::passphrase] = "";
529 
530  auto ret = keypairForSignature (params, error);
531  BEAST_EXPECT(contains_error (error));
532  BEAST_EXPECT(error[jss::error_message] ==
533  "Disallowed seed.");
534  BEAST_EXPECT(ret.first.size() == 0);
535  }
536 
537 
538  // Specify non-string or invalid seed
539  { // not a seed: number
540  Json::Value params;
541  Json::Value error;
542  params[jss::key_type] = "secp256k1";
543  params[jss::seed] = 443556;
544 
545  auto ret = keypairForSignature (params, error);
546  BEAST_EXPECT(contains_error (error));
547  BEAST_EXPECT(error[jss::error_message] ==
548  "Invalid field 'seed', not string.");
549  BEAST_EXPECT(ret.first.size() == 0);
550  }
551 
552  { // not a string: object
553  Json::Value params;
554  Json::Value error;
555  params[jss::key_type] = "secp256k1";
556  params[jss::seed] = Json::objectValue;
557 
558  auto ret = keypairForSignature (params, error);
559  BEAST_EXPECT(contains_error (error));
560  BEAST_EXPECT(error[jss::error_message] ==
561  "Invalid field 'seed', not string.");
562  BEAST_EXPECT(ret.first.size() == 0);
563  }
564 
565  { // not a string: array
566  Json::Value params;
567  Json::Value error;
568  params[jss::key_type] = "secp256k1";
569  params[jss::seed] = Json::arrayValue;
570 
571  auto ret = keypairForSignature (params, error);
572  BEAST_EXPECT(contains_error (error));
573  BEAST_EXPECT(error[jss::error_message] ==
574  "Invalid field 'seed', not string.");
575  BEAST_EXPECT(ret.first.size() == 0);
576  }
577 
578  { // not a seed: empty
579  Json::Value params;
580  Json::Value error;
581  params[jss::key_type] = "secp256k1";
582  params[jss::seed] = "";
583 
584  auto ret = keypairForSignature (params, error);
585  BEAST_EXPECT(contains_error (error));
586  BEAST_EXPECT(error[jss::error_message] ==
587  "Disallowed seed.");
588  BEAST_EXPECT(ret.first.size() == 0);
589  }
590 
591  { // not a seed: invalid characters
592  Json::Value params;
593  Json::Value error;
594  params[jss::key_type] = "secp256k1";
595  params[jss::seed] = "s M V s h z D F p t Z E m h s";
596 
597  auto ret = keypairForSignature (params, error);
598  BEAST_EXPECT(contains_error (error));
599  BEAST_EXPECT(error[jss::error_message] ==
600  "Disallowed seed.");
601  BEAST_EXPECT(ret.first.size() == 0);
602  }
603 
604  { // not a seed: random string
605  Json::Value params;
606  Json::Value error;
607  params[jss::key_type] = "secp256k1";
608  params[jss::seed] = "pnnjkbnobnml43679nbvjdsklnbjs";
609 
610  auto ret = keypairForSignature (params, error);
611  BEAST_EXPECT(contains_error (error));
612  BEAST_EXPECT(error[jss::error_message] ==
613  "Disallowed seed.");
614  BEAST_EXPECT(ret.first.size() == 0);
615  }
616 
617  // Specify non-string or invalid seed_hex
618  { // not a string: number
619  Json::Value params;
620  Json::Value error;
621  params[jss::key_type] = "secp256k1";
622  params[jss::seed_hex] = 443556;
623 
624  auto ret = keypairForSignature (params, error);
625  BEAST_EXPECT(contains_error (error));
626  BEAST_EXPECT(error[jss::error_message] ==
627  "Invalid field 'seed_hex', not string.");
628  BEAST_EXPECT(ret.first.size() == 0);
629  }
630 
631  { // not a string: object
632  Json::Value params;
633  Json::Value error;
634  params[jss::key_type] = "secp256k1";
635  params[jss::seed_hex] = Json::objectValue;
636 
637  auto ret = keypairForSignature (params, error);
638  BEAST_EXPECT(contains_error (error));
639  BEAST_EXPECT(error[jss::error_message] ==
640  "Invalid field 'seed_hex', not string.");
641  BEAST_EXPECT(ret.first.size() == 0);
642  }
643 
644  { // not a string: array
645  Json::Value params;
646  Json::Value error;
647  params[jss::key_type] = "secp256k1";
648  params[jss::seed_hex] = Json::arrayValue;
649 
650  auto ret = keypairForSignature (params, error);
651  BEAST_EXPECT(contains_error (error));
652  BEAST_EXPECT(error[jss::error_message] ==
653  "Invalid field 'seed_hex', not string.");
654  BEAST_EXPECT(ret.first.size() == 0);
655  }
656 
657  { // empty
658  Json::Value params;
659  Json::Value error;
660  params[jss::key_type] = "secp256k1";
661  params[jss::seed_hex] = "";
662 
663  auto ret = keypairForSignature (params, error);
664  BEAST_EXPECT(contains_error (error));
665  BEAST_EXPECT(error[jss::error_message] ==
666  "Disallowed seed.");
667  BEAST_EXPECT(ret.first.size() == 0);
668  }
669 
670  { // short
671  Json::Value params;
672  Json::Value error;
673  params[jss::key_type] = "secp256k1";
674  params[jss::seed_hex] = "A670A19B";
675 
676  auto ret = keypairForSignature (params, error);
677  BEAST_EXPECT(contains_error (error));
678  BEAST_EXPECT(error[jss::error_message] ==
679  "Disallowed seed.");
680  BEAST_EXPECT(ret.first.size() == 0);
681  }
682 
683  { // not hex
684  Json::Value params;
685  Json::Value error;
686  params[jss::key_type] = "secp256k1";
687  params[jss::seed_hex] = common::passphrase;
688 
689  auto ret = keypairForSignature (params, error);
690  BEAST_EXPECT(contains_error (error));
691  BEAST_EXPECT(error[jss::error_message] ==
692  "Disallowed seed.");
693  BEAST_EXPECT(ret.first.size() == 0);
694  }
695 
696  { // overlong
697  Json::Value params;
698  Json::Value error;
699  params[jss::key_type] = "secp256k1";
700  params[jss::seed_hex] = "BE6A670A19B209E112146D0A7ED2AAD72567D0FC913";
701 
702  auto ret = keypairForSignature (params, error);
703  BEAST_EXPECT(contains_error (error));
704  BEAST_EXPECT(error[jss::error_message] ==
705  "Disallowed seed.");
706  BEAST_EXPECT(ret.first.size() == 0);
707  }
708  }
709 
710  void testRippleLibEd25519()
711  {
712  testcase ("ripple-lib encoded Ed25519 keys");
713 
714  auto test = [this](char const* seed, char const* addr)
715  {
716  {
717  Json::Value params;
718  Json::Value error;
719 
720  params[jss::passphrase] = seed;
721 
722  auto ret = keypairForSignature(params, error);
723 
724  BEAST_EXPECT(!contains_error(error));
725  BEAST_EXPECT(ret.first.size() != 0);
726  BEAST_EXPECT(toBase58(calcAccountID(ret.first)) == addr);
727  }
728 
729  {
730  Json::Value params;
731  Json::Value error;
732 
733  params[jss::key_type] = "secp256k1";
734  params[jss::passphrase] = seed;
735 
736  auto ret = keypairForSignature(params, error);
737 
738  BEAST_EXPECT(contains_error(error));
739  BEAST_EXPECT(error[jss::error_message] ==
740  "Specified seed is for an Ed25519 wallet.");
741  }
742 
743  {
744  Json::Value params;
745  Json::Value error;
746 
747  params[jss::key_type] = "ed25519";
748  params[jss::seed] = seed;
749 
750  auto ret = keypairForSignature(params, error);
751 
752  BEAST_EXPECT(!contains_error(error));
753  BEAST_EXPECT(ret.first.size() != 0);
754  BEAST_EXPECT(toBase58(calcAccountID(ret.first)) == addr);
755  }
756 
757  {
758  Json::Value params;
759  Json::Value error;
760 
761  params[jss::key_type] = "secp256k1";
762  params[jss::seed] = seed;
763 
764  auto ret = keypairForSignature(params, error);
765 
766  BEAST_EXPECT(contains_error(error));
767  BEAST_EXPECT(error[jss::error_message] ==
768  "Specified seed is for an Ed25519 wallet.");
769  }
770  };
771 
772  test("sEdVWZmeUDgQdMEFKTK9kYVX71FKB7o", "r34XnDB2zS11NZ1wKJzpU1mjWExGVugTaQ");
773  test("sEd7zJoVnqg1FxB9EuaHC1AB5UPfHWz", "rDw51qRrBEeMw7Na1Nh79LN7HYZDo7nZFE");
774  test("sEdSxVntbihdLyabbfttMCqsaaucVR9", "rwiyBDfAYegXZyaQcN2L1vAbKRYn2wNFMq");
775  test("sEdSVwJjEXTYCztqDK4JD9WByH3otDX", "rQJ4hZzNGkLQhLtKPCmu1ywEw1ai2vgUJN");
776  test("sEdV3jXjKuUoQTSr1Rb4yw8Kyn9r46U", "rERRw2Pxbau4tevE61V5vZUwD7Rus5Y6vW");
777  test("sEdVeUZjuYT47Uy51FQCnzivsuWyiwB", "rszewT5gRjUgWNEmnfMjvVYzJCkhvWY32i");
778  test("sEd7MHTewdw4tFYeS7rk7XT4qHiA9jH", "rBB2rvnf4ztwjgNhinFXQJ91nAZjkFgR3p");
779  test("sEd7A5jFBSdWbNeKGriQvLr1thBScJh", "rLAXz8Nz7aDivz7PwThsLFqaKrizepNCdA");
780  test("sEdVPU9M2uyzVNT4Yb5Dn4tUtYjbFAw", "rHbHRFPCxD5fnn98TBzsQHJ7SsRq7eHkRj");
781  test("sEdVfF2zhAmS8gfMYzJ4yWBMeR4BZKc", "r9PsneKHcAE7kUfiTixomM5Mnwi28tCc7h");
782  test("sEdTjRtcsQkwthDXUSLi9DHNyJcR8GW", "rM4soF4XS3wZrmLurvE6ZmudG16Lk5Dur5");
783  test("sEdVNKeu1Lhpfh7Nf6tRDbxnmMyZ4Dv", "r4ZwJxq6FDtWjapDtCGhjG6mtNm1nWdJcD");
784  test("sEd7bK4gf5BHJ1WbaEWx8pKMA9MLHpC", "rD6tnn51m4o1uXeEK9CFrZ3HR7DcFhiYnp");
785  test("sEd7jCh3ppnQMsLdGcZ6TZayZaHhBLg", "rTcBkiRQ1EfFQ4FCCwqXNHpn1yUTAACkj");
786  test("sEdTFJezurQwSJAbkLygj2gQXBut2wh", "rnXaMacNbRwcJddbbPbqdcpSUQcfzFmrR8");
787  test("sEdSWajfQAAWFuDvVZF3AiGucReByLt", "rBJtow6V3GTdsWMamrxetRDwWs6wwTxcKa");
788  }
789 
790  void run() override
791  {
792  testKeyType (boost::none, secp256k1_strings);
793  testKeyType (std::string("secp256k1"), secp256k1_strings);
794  testKeyType (std::string("ed25519"), ed25519_strings);
795  testKeyType (std::string("secp256k1"), strong_brain_strings);
796  testBadInput ();
797 
798  testKeypairForSignature (boost::none, secp256k1_strings);
799  testKeypairForSignature (std::string("secp256k1"), secp256k1_strings);
800  testKeypairForSignature (std::string("ed25519"), ed25519_strings);
801  testKeypairForSignature (std::string("secp256k1"), strong_brain_strings);
802 
803  testRippleLibEd25519();
804 
805  testKeypairForSignatureErrors ();
806  }
807 };
808 
809 BEAST_DEFINE_TESTSUITE(WalletPropose,ripple_basics,ripple);
810 
811 } // RPC
812 } // ripple
ripple::RPC::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(AccountLinesRPC, app, ripple)
ripple::RPC::strong_brain_strings
static const key_strings strong_brain_strings
Definition: KeyGeneration_test.cpp:83
std::string
STL class.
ripple::RPC::key_strings::public_key
char const * public_key
Definition: KeyGeneration_test.cpp:39
ripple::RPC::key_strings::master_seed
char const * master_seed
Definition: KeyGeneration_test.cpp:37
Json::arrayValue
@ arrayValue
array value (ordered list)
Definition: json_value.h:44
ripple::RPC::WalletPropose_test::testBadInput
void testBadInput()
Definition: KeyGeneration_test.cpp:220
ripple::TestSuite::expectEquals
bool expectEquals(S actual, T expected, std::string const &message="")
Definition: TestSuite.h:32
ripple::RPC::WalletPropose_test::testSeed
void testSeed(boost::optional< std::string > const &keyType, key_strings const &strings)
Definition: KeyGeneration_test.cpp:145
ripple::RPC::key_strings::account_id
char const * account_id
Definition: KeyGeneration_test.cpp:35
ripple::RPC::WalletPropose_test::run
void run() override
Definition: KeyGeneration_test.cpp:790
ripple::RPC::key_strings::public_key_hex
char const * public_key_hex
Definition: KeyGeneration_test.cpp:40
ripple::RPC::common::master_seed
static char const * master_seed
Definition: KeyGeneration_test.cpp:49
ripple::RPC::WalletPropose_test::testKeyType
void testKeyType(boost::optional< std::string > const &keyType, key_strings const &strings)
Definition: KeyGeneration_test.cpp:200
ripple::toBase58
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition: AccountID.cpp:29
ripple::RPC::key_strings
Definition: KeyGeneration_test.cpp:33
ripple::RPC::WalletPropose_test::testLegacyPassphrase
void testLegacyPassphrase(char const *value, boost::optional< std::string > const &keyType, key_strings const &strings)
Definition: KeyGeneration_test.cpp:173
ripple::RPC::WalletPropose_test::testKeypairForSignatureErrors
void testKeypairForSignatureErrors()
Definition: KeyGeneration_test.cpp:389
ripple::RPC::secp256k1_strings
static const key_strings secp256k1_strings
Definition: KeyGeneration_test.cpp:53
ripple::RPC::WalletPropose_test::testKeypairForSignature
void testKeypairForSignature(boost::optional< std::string > keyType, key_strings const &strings)
Definition: KeyGeneration_test.cpp:300
Json::Value::append
Value & append(const Value &value)
Append value to array at the end.
Definition: json_value.cpp:907
ripple::RPC::key_strings::master_seed_hex
char const * master_seed_hex
Definition: KeyGeneration_test.cpp:38
ripple::RPC::WalletPropose_test::testLegacyPassphrase
void testLegacyPassphrase(boost::optional< std::string > const &keyType, key_strings const &strings)
Definition: KeyGeneration_test.cpp:189
Json::objectValue
@ objectValue
object value (collection of name/value pairs).
Definition: json_value.h:45
ripple::RPC::contains_error
bool contains_error(Json::Value const &json)
Returns true if the json contains an rpc error specification.
Definition: ErrorCodes.cpp:196
ripple::RPC::WalletPropose_test
Definition: KeyGeneration_test.cpp:98
ripple::calcAccountID
AccountID calcAccountID(PublicKey const &pk)
Definition: AccountID.cpp:136
ripple::RPC::common::master_seed_hex
static char const * master_seed_hex
Definition: KeyGeneration_test.cpp:50
Json::Value::isMember
bool isMember(const char *key) const
Return true if the object has a member named key.
Definition: json_value.cpp:961
ripple::TestSuite
Definition: TestSuite.h:28
ripple::RPC::WalletPropose_test::testRippleLibEd25519
void testRippleLibEd25519()
Definition: KeyGeneration_test.cpp:710
ripple::RPC::WalletPropose_test::testSeedHex
void testSeedHex(boost::optional< std::string > const &keyType, key_strings const &strings)
Definition: KeyGeneration_test.cpp:159
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::RPC::keypairForSignature
std::pair< PublicKey, SecretKey > keypairForSignature(Json::Value const &params, Json::Value &error)
Definition: RPCHelpers.cpp:659
ripple::TokenType::AccountPublic
@ AccountPublic
ripple::RPC::WalletPropose_test::testSecretWallet
Json::Value testSecretWallet(Json::Value const &params, key_strings const &s)
Definition: KeyGeneration_test.cpp:129
ripple::RPC::common::passphrase
static char const * passphrase
Definition: KeyGeneration_test.cpp:47
ripple::RPC::ed25519_strings
static const key_strings ed25519_strings
Definition: KeyGeneration_test.cpp:68
ripple::RPC::key_strings::passphrase
char const * passphrase
Definition: KeyGeneration_test.cpp:42
ripple::RPC::common::master_key
static char const * master_key
Definition: KeyGeneration_test.cpp:48
ripple::walletPropose
Json::Value walletPropose(Json::Value const &params)
Definition: WalletPropose.cpp:72
ripple::RPC::WalletPropose_test::testRandomWallet
void testRandomWallet(boost::optional< std::string > const &keyType)
Definition: KeyGeneration_test.cpp:101
ripple::RPC::key_strings::secret_key_hex
char const * secret_key_hex
Definition: KeyGeneration_test.cpp:41
Json::Value
Represents a JSON value.
Definition: json_value.h:141
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition: json_value.cpp:482
ripple::RPC::key_strings::master_key
char const * master_key
Definition: KeyGeneration_test.cpp:36
ripple::RPC::key_strings::passphrase_warning
char const * passphrase_warning
Definition: KeyGeneration_test.cpp:43
Generated by   doxygen 1.8.17