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