rippled
Loading...
Searching...
No Matches
Seed_test.cpp
1#include <xrpl/basics/random.h>
2#include <xrpl/beast/unit_test.h>
3#include <xrpl/beast/utility/rngfill.h>
4#include <xrpl/protocol/PublicKey.h>
5#include <xrpl/protocol/SecretKey.h>
6#include <xrpl/protocol/Seed.h>
7
8#include <algorithm>
9
10namespace xrpl {
11
12class Seed_test : public beast::unit_test::suite
13{
14 static bool
15 equal(Seed const& lhs, Seed const& rhs)
16 {
17 return std::equal(lhs.data(), lhs.data() + lhs.size(), rhs.data(), rhs.data() + rhs.size());
18 }
19
20public:
21 void
22 testConstruction()
23 {
24 testcase("construction");
25
26 {
27 std::uint8_t src[16];
28
29 for (std::uint8_t i = 0; i < 64; i++)
30 {
31 beast::rngfill(src, sizeof(src), default_prng());
32 Seed const seed({src, sizeof(src)});
33 BEAST_EXPECT(memcmp(seed.data(), src, sizeof(src)) == 0);
34 }
35 }
36
37 for (int i = 0; i < 64; i++)
38 {
39 uint128 src;
40 beast::rngfill(src.data(), src.size(), default_prng());
41 Seed const seed(src);
42 BEAST_EXPECT(memcmp(seed.data(), src.data(), src.size()) == 0);
43 }
44 }
45
46 std::string
47 testPassphrase(std::string passphrase)
48 {
49 auto const seed1 = generateSeed(passphrase);
50 auto const seed2 = parseBase58<Seed>(toBase58(seed1));
51
52 BEAST_EXPECT(static_cast<bool>(seed2));
53 BEAST_EXPECT(equal(seed1, *seed2)); // NOLINT(bugprone-unchecked-optional-access)
54 return toBase58(seed1);
55 }
56
57 void
58 testPassphrase()
59 {
60 testcase("generation from passphrase");
61 BEAST_EXPECT(testPassphrase("masterpassphrase") == "snoPBrXtMeMyMHUVTgbuqAfg1SUTb");
62 BEAST_EXPECT(testPassphrase("Non-Random Passphrase") == "snMKnVku798EnBwUfxeSD8953sLYA");
63 BEAST_EXPECT(
64 testPassphrase("cookies excitement hand public") == "sspUXGrmjQhq6mgc24jiRuevZiwKT");
65 }
66
67 void
68 testBase58()
69 {
70 testcase("base58 operations");
71
72 // Success:
73 BEAST_EXPECT(parseBase58<Seed>("snoPBrXtMeMyMHUVTgbuqAfg1SUTb"));
74 BEAST_EXPECT(parseBase58<Seed>("snMKnVku798EnBwUfxeSD8953sLYA"));
75 BEAST_EXPECT(parseBase58<Seed>("sspUXGrmjQhq6mgc24jiRuevZiwKT"));
76
77 // Failure:
78 BEAST_EXPECT(!parseBase58<Seed>(""));
79 BEAST_EXPECT(!parseBase58<Seed>("sspUXGrmjQhq6mgc24jiRuevZiwK"));
80 BEAST_EXPECT(!parseBase58<Seed>("sspUXGrmjQhq6mgc24jiRuevZiwKTT"));
81 BEAST_EXPECT(!parseBase58<Seed>("sspOXGrmjQhq6mgc24jiRuevZiwKT"));
82 BEAST_EXPECT(!parseBase58<Seed>("ssp/XGrmjQhq6mgc24jiRuevZiwKT"));
83 }
84
85 void
86 testRandom()
87 {
88 testcase("random generation");
89
90 for (int i = 0; i < 32; i++)
91 {
92 auto const seed1 = randomSeed();
93 auto const seed2 = parseBase58<Seed>(toBase58(seed1));
94
95 BEAST_EXPECT(static_cast<bool>(seed2));
96 BEAST_EXPECT(equal(seed1, *seed2)); // NOLINT(bugprone-unchecked-optional-access)
97 }
98 }
99
100 void
101 testKeypairGenerationAndSigning()
102 {
103 std::string const message1 = "http://www.ripple.com";
104 std::string const message2 = "https://www.ripple.com";
105
106 {
107 testcase("Node keypair generation & signing (secp256k1)");
108
109 auto const secretKey =
110 generateSecretKey(KeyType::secp256k1, generateSeed("masterpassphrase"));
111 auto const publicKey = derivePublicKey(KeyType::secp256k1, secretKey);
112
113 BEAST_EXPECT(
114 toBase58(TokenType::NodePublic, publicKey) ==
115 "n94a1u4jAz288pZLtw6yFWVbi89YamiC6JBXPVUj5zmExe5fTVg9");
116 BEAST_EXPECT(
117 toBase58(TokenType::NodePrivate, secretKey) ==
118 "pnen77YEeUd4fFKG7iycBWcwKpTaeFRkW2WFostaATy1DSupwXe");
119 BEAST_EXPECT(
120 to_string(calcNodeID(publicKey)) == "7E59C17D50F5959C7B158FEC95C8F815BF653DC8");
121
122 auto sig = sign(publicKey, secretKey, makeSlice(message1));
123 BEAST_EXPECT(!sig.empty());
124 BEAST_EXPECT(verify(publicKey, makeSlice(message1), sig));
125
126 // Correct public key but wrong message
127 BEAST_EXPECT(!verify(publicKey, makeSlice(message2), sig));
128
129 // Verify with incorrect public key
130 {
131 auto const otherPublicKey = derivePublicKey(
132 KeyType::secp256k1,
133 generateSecretKey(KeyType::secp256k1, generateSeed("otherpassphrase")));
134
135 BEAST_EXPECT(!verify(otherPublicKey, makeSlice(message1), sig));
136 }
137
138 // Correct public key but wrong signature
139 {
140 // Slightly change the signature:
141 if (auto ptr = sig.data())
142 ptr[sig.size() / 2]++;
143
144 BEAST_EXPECT(!verify(publicKey, makeSlice(message1), sig));
145 }
146 }
147
148 {
149 testcase("Node keypair generation & signing (ed25519)");
150
151 auto const secretKey =
152 generateSecretKey(KeyType::ed25519, generateSeed("masterpassphrase"));
153 auto const publicKey = derivePublicKey(KeyType::ed25519, secretKey);
154
155 BEAST_EXPECT(
156 toBase58(TokenType::NodePublic, publicKey) ==
157 "nHUeeJCSY2dM71oxM8Cgjouf5ekTuev2mwDpc374aLMxzDLXNmjf");
158 BEAST_EXPECT(
159 toBase58(TokenType::NodePrivate, secretKey) ==
160 "paKv46LztLqK3GaKz1rG2nQGN6M4JLyRtxFBYFTw4wAVHtGys36");
161 BEAST_EXPECT(
162 to_string(calcNodeID(publicKey)) == "AA066C988C712815CC37AF71472B7CBBBD4E2A0A");
163
164 auto sig = sign(publicKey, secretKey, makeSlice(message1));
165 BEAST_EXPECT(!sig.empty());
166 BEAST_EXPECT(verify(publicKey, makeSlice(message1), sig));
167
168 // Correct public key but wrong message
169 BEAST_EXPECT(!verify(publicKey, makeSlice(message2), sig));
170
171 // Verify with incorrect public key
172 {
173 auto const otherPublicKey = derivePublicKey(
174 KeyType::ed25519,
175 generateSecretKey(KeyType::ed25519, generateSeed("otherpassphrase")));
176
177 BEAST_EXPECT(!verify(otherPublicKey, makeSlice(message1), sig));
178 }
179
180 // Correct public key but wrong signature
181 {
182 // Slightly change the signature:
183 if (auto ptr = sig.data())
184 ptr[sig.size() / 2]++;
185
186 BEAST_EXPECT(!verify(publicKey, makeSlice(message1), sig));
187 }
188 }
189
190 {
191 testcase("Account keypair generation & signing (secp256k1)");
192
193 auto const [pk, sk] =
194 generateKeyPair(KeyType::secp256k1, generateSeed("masterpassphrase"));
195
196 BEAST_EXPECT(toBase58(calcAccountID(pk)) == "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh");
197 BEAST_EXPECT(
198 toBase58(TokenType::AccountPublic, pk) ==
199 "aBQG8RQAzjs1eTKFEAQXr2gS4utcDiEC9wmi7pfUPTi27VCahwgw");
200 BEAST_EXPECT(
201 toBase58(TokenType::AccountSecret, sk) ==
202 "p9JfM6HHi64m6mvB6v5k7G2b1cXzGmYiCNJf6GHPKvFTWdeRVjh");
203
204 auto sig = sign(pk, sk, makeSlice(message1));
205 BEAST_EXPECT(!sig.empty());
206 BEAST_EXPECT(verify(pk, makeSlice(message1), sig));
207
208 // Correct public key but wrong message
209 BEAST_EXPECT(!verify(pk, makeSlice(message2), sig));
210
211 // Verify with incorrect public key
212 {
213 auto const otherKeyPair =
214 generateKeyPair(KeyType::secp256k1, generateSeed("otherpassphrase"));
215
216 BEAST_EXPECT(!verify(otherKeyPair.first, makeSlice(message1), sig));
217 }
218
219 // Correct public key but wrong signature
220 {
221 // Slightly change the signature:
222 if (auto ptr = sig.data())
223 ptr[sig.size() / 2]++;
224
225 BEAST_EXPECT(!verify(pk, makeSlice(message1), sig));
226 }
227 }
228
229 {
230 testcase("Account keypair generation & signing (ed25519)");
231
232 auto const [pk, sk] =
233 generateKeyPair(KeyType::ed25519, generateSeed("masterpassphrase"));
234
235 BEAST_EXPECT(to_string(calcAccountID(pk)) == "rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf");
236 BEAST_EXPECT(
237 toBase58(TokenType::AccountPublic, pk) ==
238 "aKGheSBjmCsKJVuLNKRAKpZXT6wpk2FCuEZAXJupXgdAxX5THCqR");
239 BEAST_EXPECT(
240 toBase58(TokenType::AccountSecret, sk) ==
241 "pwDQjwEhbUBmPuEjFpEG75bFhv2obkCB7NxQsfFxM7xGHBMVPu9");
242
243 auto sig = sign(pk, sk, makeSlice(message1));
244 BEAST_EXPECT(!sig.empty());
245 BEAST_EXPECT(verify(pk, makeSlice(message1), sig));
246
247 // Correct public key but wrong message
248 BEAST_EXPECT(!verify(pk, makeSlice(message2), sig));
249
250 // Verify with incorrect public key
251 {
252 auto const otherKeyPair =
253 generateKeyPair(KeyType::ed25519, generateSeed("otherpassphrase"));
254
255 BEAST_EXPECT(!verify(otherKeyPair.first, makeSlice(message1), sig));
256 }
257
258 // Correct public key but wrong signature
259 {
260 // Slightly change the signature:
261 if (auto ptr = sig.data())
262 ptr[sig.size() / 2]++;
263
264 BEAST_EXPECT(!verify(pk, makeSlice(message1), sig));
265 }
266 }
267 }
268
269 void
270 testSeedParsing()
271 {
272 testcase("Parsing");
273
274 // account IDs and node and account public and private
275 // keys should not be parsable as seeds.
276
277 auto const node1 = randomKeyPair(KeyType::secp256k1);
278
279 BEAST_EXPECT(!parseGenericSeed(toBase58(TokenType::NodePublic, node1.first)));
280 BEAST_EXPECT(!parseGenericSeed(toBase58(TokenType::NodePrivate, node1.second)));
281
282 auto const node2 = randomKeyPair(KeyType::ed25519);
283
284 BEAST_EXPECT(!parseGenericSeed(toBase58(TokenType::NodePublic, node2.first)));
285 BEAST_EXPECT(!parseGenericSeed(toBase58(TokenType::NodePrivate, node2.second)));
286
287 auto const account1 = generateKeyPair(KeyType::secp256k1, randomSeed());
288
289 BEAST_EXPECT(!parseGenericSeed(toBase58(calcAccountID(account1.first))));
290 BEAST_EXPECT(!parseGenericSeed(toBase58(TokenType::AccountPublic, account1.first)));
291 BEAST_EXPECT(!parseGenericSeed(toBase58(TokenType::AccountSecret, account1.second)));
292
293 auto const account2 = generateKeyPair(KeyType::ed25519, randomSeed());
294
295 BEAST_EXPECT(!parseGenericSeed(toBase58(calcAccountID(account2.first))));
296 BEAST_EXPECT(!parseGenericSeed(toBase58(TokenType::AccountPublic, account2.first)));
297 BEAST_EXPECT(!parseGenericSeed(toBase58(TokenType::AccountSecret, account2.second)));
298 }
299
300 void
301 run() override
302 {
303 testConstruction();
304 testPassphrase();
305 testBase58();
306 testRandom();
307 testKeypairGenerationAndSigning();
308 testSeedParsing();
309 }
310};
311
312BEAST_DEFINE_TESTSUITE(Seed, protocol, xrpl);
313
314} // namespace xrpl
beast::unit_test::suite
A testsuite class.
Definition suite.h:51
beast::unit_test::suite::testcase
testcase_t testcase
Memberspace for declaring test cases.
Definition suite.h:150
xrpl::Seed_test
Definition Seed_test.cpp:13
xrpl::Seed_test::testSeedParsing
void testSeedParsing()
Definition Seed_test.cpp:270
xrpl::Seed_test::testKeypairGenerationAndSigning
void testKeypairGenerationAndSigning()
Definition Seed_test.cpp:101
xrpl::Seed_test::testRandom
void testRandom()
Definition Seed_test.cpp:86
xrpl::Seed_test::testPassphrase
std::string testPassphrase(std::string passphrase)
Definition Seed_test.cpp:47
xrpl::Seed_test::equal
static bool equal(Seed const &lhs, Seed const &rhs)
Definition Seed_test.cpp:15
xrpl::Seed_test::run
void run() override
Runs the suite.
Definition Seed_test.cpp:301
xrpl::Seed_test::testBase58
void testBase58()
Definition Seed_test.cpp:68
xrpl::Seed_test::testPassphrase
void testPassphrase()
Definition Seed_test.cpp:58
xrpl::Seed_test::testConstruction
void testConstruction()
Definition Seed_test.cpp:22
xrpl::Seed
Seeds are used to generate deterministic secret keys.
Definition Seed.h:14
xrpl::Seed::size
std::size_t size() const
Definition Seed.h:45
xrpl::Seed::data
std::uint8_t const * data() const
Definition Seed.h:39
xrpl::base_uint
Integers of any length that is a multiple of 32-bits.
Definition base_uint.h:66
xrpl::base_uint::data
pointer data()
Definition base_uint.h:101
xrpl::base_uint::size
static constexpr std::size_t size()
Definition base_uint.h:499
std::equal
T equal(T... args)
beast::rngfill
void rngfill(void *const buffer, std::size_t const bytes, Generator &g)
Definition rngfill.h:14
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
xrpl::randomKeyPair
std::pair< PublicKey, SecretKey > randomKeyPair(KeyType type)
Create a key pair using secure random numbers.
Definition SecretKey.cpp:350
xrpl::derivePublicKey
PublicKey derivePublicKey(KeyType type, SecretKey const &sk)
Derive the public key from a secret key.
Definition SecretKey.cpp:301
xrpl::randomSeed
Seed randomSeed()
Create a seed using secure random numbers.
Definition Seed.cpp:47
xrpl::to_string
std::string to_string(base_uint< Bits, Tag > const &a)
Definition base_uint.h:602
xrpl::verify
bool verify(PublicKey const &publicKey, Slice const &m, Slice const &sig) noexcept
Verify a signature on a message.
Definition PublicKey.cpp:267
xrpl::toBase58
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition AccountID.cpp:92
xrpl::generateSecretKey
SecretKey generateSecretKey(KeyType type, Seed const &seed)
Generate a new secret key deterministically.
Definition SecretKey.cpp:279
xrpl::generateSeed
Seed generateSeed(std::string const &passPhrase)
Generate a seed deterministically.
Definition Seed.cpp:57
xrpl::generateKeyPair
std::pair< PublicKey, SecretKey > generateKeyPair(KeyType type, Seed const &seed)
Generate a key pair deterministically.
Definition SecretKey.cpp:333
xrpl::default_prng
beast::xor_shift_engine & default_prng()
Return the default random engine.
Definition include/xrpl/basics/random.h:47
xrpl::calcNodeID
NodeID calcNodeID(PublicKey const &)
Calculate the 160-bit node ID from a node public key.
Definition PublicKey.cpp:291
xrpl::calcAccountID
AccountID calcAccountID(PublicKey const &pk)
Definition AccountID.cpp:146
xrpl::sign
Buffer sign(PublicKey const &pk, SecretKey const &sk, Slice const &message)
Generate a signature for a message.
Definition SecretKey.cpp:228
xrpl::makeSlice
std::enable_if_t< std::is_same< T, char >::value||std::is_same< T, unsigned char >::value, Slice > makeSlice(std::array< T, N > const &a)
Definition Slice.h:215
xrpl::parseGenericSeed
std::optional< Seed > parseGenericSeed(std::string const &str, bool rfc1751=true)
Attempt to parse a string as a seed.
Definition Seed.cpp:78
Generated by doxygen 1.9.8