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