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