Electroneum
Loading...
Searching...
No Matches
base58.cpp
Go to the documentation of this file.
1// Copyrights(c) 2017-2021, The Electroneum Project
2// Copyrights(c) 2014-2019, The Monero Project
3//
4// All rights reserved.
5//
6// Redistribution and use in source and binary forms, with or without modification, are
7// permitted provided that the following conditions are met:
8//
9// 1. Redistributions of source code must retain the above copyright notice, this list of
10// conditions and the following disclaimer.
11//
12// 2. Redistributions in binary form must reproduce the above copyright notice, this list
13// of conditions and the following disclaimer in the documentation and/or other
14// materials provided with the distribution.
15//
16// 3. Neither the name of the copyright holder nor the names of its contributors may be
17// used to endorse or promote products derived from this software without specific
18// prior written permission.
19//
20// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
21// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
23// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
27// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29//
30// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
31
32#include "gtest/gtest.h"
33
34#include <cstdint>
35
36#include "common/base58.cpp"
37#include "cryptonote_basic/cryptonote_basic_impl.h"
38#include "serialization/binary_utils.h"
39
40using namespace tools;
41
42#define MAKE_STR(arr) std::string(arr, sizeof(arr) - 1)
43
44namespace
45{
46 void do_test_uint_8be_to_64(uint64_t expected, const uint8_t* data, size_t size)
47 {
48 uint64_t val = base58::uint_8be_to_64(data, size);
49 ASSERT_EQ(val, expected);
50 }
51
52 void do_test_uint_64_to_8be(uint64_t num, const std::string& expected_str)
53 {
54 std::string data(expected_str.size(), '\x0');
55 base58::uint_64_to_8be(num, data.size(), reinterpret_cast<uint8_t*>(&data[0]));
56 ASSERT_EQ(data, expected_str);
57 }
58
59 void do_test_encode_block(const std::string& block, const std::string& expected)
60 {
61 ASSERT_TRUE(1 <= block.size() && block.size() <= base58::full_block_size);
62 std::string enc(base58::encoded_block_sizes[block.size()], base58::alphabet[0]);
63 base58::encode_block(block.data(), block.size(), &enc[0]);
64 ASSERT_EQ(enc, expected);
65
66 std::string dec(block.size(), '\0');
67 ASSERT_TRUE(base58::decode_block(enc.data(), enc.size(), &dec[0]));
68 ASSERT_EQ(block, dec);
69 }
70
71 void do_test_decode_block_pos(const std::string& enc, const std::string& expected)
72 {
73 std::string data(base58::decoded_block_sizes::instance(enc.size()), '\0');
74 ASSERT_TRUE(base58::decode_block(enc.data(), enc.size(), &data[0]));
75 ASSERT_EQ(data, expected);
76 }
77
78 void do_test_decode_block_neg(const std::string& enc)
79 {
80 std::string data(base58::full_block_size, '\0');
81 ASSERT_FALSE(base58::decode_block(enc.data(), enc.size(), &data[0]));
82 }
83
84 void do_test_encode(const std::string& data, const std::string& expected)
85 {
86 std::string enc = base58::encode(data);
87 ASSERT_EQ(enc, expected);
88
89 std::string dec;
90 ASSERT_TRUE(base58::decode(enc, dec));
91 ASSERT_EQ(dec, data);
92 }
93
94 void do_test_decode_pos(const std::string& enc, const std::string& expected)
95 {
96 std::string dec;
97 ASSERT_TRUE(base58::decode(enc, dec));
98 ASSERT_EQ(dec, expected);
99 }
100
101 void do_test_decode_neg(const std::string& enc)
102 {
103 std::string dec;
104 ASSERT_FALSE(base58::decode(enc, dec));
105 }
106
107 void do_test_encode_decode_addr(uint64_t tag, const std::string& data, const std::string& expected)
108 {
109 std::string addr = base58::encode_addr(tag, data);
110 ASSERT_EQ(addr, expected);
111
112 uint64_t dec_tag;
113 std::string dec_data;
114 ASSERT_TRUE(base58::decode_addr(addr, dec_tag, dec_data));
115 ASSERT_EQ(tag, dec_tag);
116 ASSERT_EQ(data, dec_data);
117 }
118}
119
120#define TEST_uint_8be_to_64(expected, str) \
121 TEST(base58_uint_8be_to_64, handles_bytes_##expected) \
122 { \
123 std::string data = str; \
124 do_test_uint_8be_to_64(expected, reinterpret_cast<const uint8_t*>(data.data()), data.size()); \
125 }
126
127TEST_uint_8be_to_64(0x0000000000000001, "\x1");
128TEST_uint_8be_to_64(0x0000000000000102, "\x1\x2");
129TEST_uint_8be_to_64(0x0000000000010203, "\x1\x2\x3");
130TEST_uint_8be_to_64(0x0000000001020304, "\x1\x2\x3\x4");
131TEST_uint_8be_to_64(0x0000000102030405, "\x1\x2\x3\x4\x5");
132TEST_uint_8be_to_64(0x0000010203040506, "\x1\x2\x3\x4\x5\x6");
133TEST_uint_8be_to_64(0x0001020304050607, "\x1\x2\x3\x4\x5\x6\x7");
134TEST_uint_8be_to_64(0x0102030405060708, "\x1\x2\x3\x4\x5\x6\x7\x8");
135
136
137#define TEST_uint_64_to_8be(num, expected_str) \
138 TEST(base58_uint_64_to_8be, handles_bytes_##num) \
139 { \
140 do_test_uint_64_to_8be(num, expected_str); \
141 }
142
143TEST_uint_64_to_8be(0x0000000000000001, "\x1");
144TEST_uint_64_to_8be(0x0000000000000102, "\x1\x2");
145TEST_uint_64_to_8be(0x0000000000010203, "\x1\x2\x3");
146TEST_uint_64_to_8be(0x0000000001020304, "\x1\x2\x3\x4");
147TEST_uint_64_to_8be(0x0000000102030405, "\x1\x2\x3\x4\x5");
148TEST_uint_64_to_8be(0x0000010203040506, "\x1\x2\x3\x4\x5\x6");
149TEST_uint_64_to_8be(0x0001020304050607, "\x1\x2\x3\x4\x5\x6\x7");
150TEST_uint_64_to_8be(0x0102030405060708, "\x1\x2\x3\x4\x5\x6\x7\x8");
151
152TEST(reverse_alphabet, is_correct)
153{
154 ASSERT_EQ(-1, base58::reverse_alphabet::instance(0));
155 ASSERT_EQ(-1, base58::reverse_alphabet::instance(std::numeric_limits<char>::min()));
156 ASSERT_EQ(-1, base58::reverse_alphabet::instance(std::numeric_limits<char>::max()));
157 ASSERT_EQ(-1, base58::reverse_alphabet::instance('1' - 1));
158 ASSERT_EQ(-1, base58::reverse_alphabet::instance('z' + 1));
159 ASSERT_EQ(-1, base58::reverse_alphabet::instance('0'));
160 ASSERT_EQ(-1, base58::reverse_alphabet::instance('I'));
161 ASSERT_EQ(-1, base58::reverse_alphabet::instance('O'));
162 ASSERT_EQ(-1, base58::reverse_alphabet::instance('l'));
163 ASSERT_EQ(0, base58::reverse_alphabet::instance('1'));
164 ASSERT_EQ(8, base58::reverse_alphabet::instance('9'));
165 ASSERT_EQ(base58::alphabet_size - 1, base58::reverse_alphabet::instance('z'));
166}
167
168
169#define TEST_encode_block(block, expected) \
170 TEST(base58_encode_block, handles_##expected) \
171 { \
172 do_test_encode_block(MAKE_STR(block), #expected); \
173 }
174
175TEST_encode_block("\x00", 11);
176TEST_encode_block("\x39", 1z);
177TEST_encode_block("\xFF", 5Q);
178
179TEST_encode_block("\x00\x00", 111);
180TEST_encode_block("\x00\x39", 11z);
181TEST_encode_block("\x01\x00", 15R);
182TEST_encode_block("\xFF\xFF", LUv);
183
184TEST_encode_block("\x00\x00\x00", 11111);
185TEST_encode_block("\x00\x00\x39", 1111z);
186TEST_encode_block("\x01\x00\x00", 11LUw);
187TEST_encode_block("\xFF\xFF\xFF", 2UzHL);
188
189TEST_encode_block("\x00\x00\x00\x39", 11111z);
190TEST_encode_block("\xFF\xFF\xFF\xFF", 7YXq9G);
191TEST_encode_block("\x00\x00\x00\x00\x39", 111111z);
192TEST_encode_block("\xFF\xFF\xFF\xFF\xFF", VtB5VXc);
193TEST_encode_block("\x00\x00\x00\x00\x00\x39", 11111111z);
194TEST_encode_block("\xFF\xFF\xFF\xFF\xFF\xFF", 3CUsUpv9t);
195TEST_encode_block("\x00\x00\x00\x00\x00\x00\x39", 111111111z);
196TEST_encode_block("\xFF\xFF\xFF\xFF\xFF\xFF\xFF", Ahg1opVcGW);
197TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x39", 1111111111z);
198TEST_encode_block("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", jpXCZedGfVQ);
199
200TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x00", 11111111111);
201TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x01", 11111111112);
202TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x08", 11111111119);
203TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x09", 1111111111A);
204TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x3A", 11111111121);
205TEST_encode_block("\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 1Ahg1opVcGW);
206TEST_encode_block("\x06\x15\x60\x13\x76\x28\x79\xF7", 22222222222);
207TEST_encode_block("\x05\xE0\x22\xBA\x37\x4B\x2A\x00", 1z111111111);
208
209
210#define TEST_decode_block_pos(enc, expected) \
211 TEST(base58_decode_block, handles_pos_##enc) \
212 { \
213 do_test_decode_block_pos(#enc, MAKE_STR(expected)); \
214 }
215
216#define TEST_decode_block_neg(enc) \
217 TEST(base58_decode_block, handles_neg_##enc) \
218 { \
219 do_test_decode_block_neg(#enc); \
220 }
221
222// 1-byte block
223TEST_decode_block_neg(1);
224TEST_decode_block_neg(z);
225// 2-bytes block
226TEST_decode_block_pos(11, "\x00");
227TEST_decode_block_pos(5Q, "\xFF");
228TEST_decode_block_neg(5R);
229TEST_decode_block_neg(zz);
230// 3-bytes block
231TEST_decode_block_pos(111, "\x00\x00");
232TEST_decode_block_pos(LUv, "\xFF\xFF");
233TEST_decode_block_neg(LUw);
234TEST_decode_block_neg(zzz);
235// 4-bytes block
236TEST_decode_block_neg(1111);
237TEST_decode_block_neg(zzzz);
238// 5-bytes block
239TEST_decode_block_pos(11111, "\x00\x00\x00");
240TEST_decode_block_pos(2UzHL, "\xFF\xFF\xFF");
241TEST_decode_block_neg(2UzHM);
242TEST_decode_block_neg(zzzzz);
243// 6-bytes block
244TEST_decode_block_pos(111111, "\x00\x00\x00\x00");
245TEST_decode_block_pos(7YXq9G, "\xFF\xFF\xFF\xFF");
246TEST_decode_block_neg(7YXq9H);
247TEST_decode_block_neg(zzzzzz);
248// 7-bytes block
249TEST_decode_block_pos(1111111, "\x00\x00\x00\x00\x00");
250TEST_decode_block_pos(VtB5VXc, "\xFF\xFF\xFF\xFF\xFF");
251TEST_decode_block_neg(VtB5VXd);
252TEST_decode_block_neg(zzzzzzz);
253// 8-bytes block
254TEST_decode_block_neg(11111111);
255TEST_decode_block_neg(zzzzzzzz);
256// 9-bytes block
257TEST_decode_block_pos(111111111, "\x00\x00\x00\x00\x00\x00");
258TEST_decode_block_pos(3CUsUpv9t, "\xFF\xFF\xFF\xFF\xFF\xFF");
259TEST_decode_block_neg(3CUsUpv9u);
260TEST_decode_block_neg(zzzzzzzzz);
261// 10-bytes block
262TEST_decode_block_pos(1111111111, "\x00\x00\x00\x00\x00\x00\x00");
263TEST_decode_block_pos(Ahg1opVcGW, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
264TEST_decode_block_neg(Ahg1opVcGX);
265TEST_decode_block_neg(zzzzzzzzzz);
266// 11-bytes block
267TEST_decode_block_pos(11111111111, "\x00\x00\x00\x00\x00\x00\x00\x00");
268TEST_decode_block_pos(jpXCZedGfVQ, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
269TEST_decode_block_neg(jpXCZedGfVR);
270TEST_decode_block_neg(zzzzzzzzzzz);
271// Invalid symbols
272TEST_decode_block_neg(01111111111);
273TEST_decode_block_neg(11111111110);
274TEST_decode_block_neg(11111011111);
275TEST_decode_block_neg(I1111111111);
276TEST_decode_block_neg(O1111111111);
277TEST_decode_block_neg(l1111111111);
278TEST_decode_block_neg(_1111111111);
279
280
281#define TEST_encode(expected, data) \
282 TEST(base58_encode, handles_##expected) \
283 { \
284 do_test_encode(MAKE_STR(data), #expected); \
285 }
286
287TEST_encode(11, "\x00");
288TEST_encode(111, "\x00\x00");
289TEST_encode(11111, "\x00\x00\x00");
290TEST_encode(111111, "\x00\x00\x00\x00");
291TEST_encode(1111111, "\x00\x00\x00\x00\x00");
292TEST_encode(111111111, "\x00\x00\x00\x00\x00\x00");
293TEST_encode(1111111111, "\x00\x00\x00\x00\x00\x00\x00");
294TEST_encode(11111111111, "\x00\x00\x00\x00\x00\x00\x00\x00");
295TEST_encode(1111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00");
296TEST_encode(11111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
297TEST_encode(1111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
298TEST_encode(11111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
299TEST_encode(111111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
300TEST_encode(11111111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
301TEST_encode(111111111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
302TEST_encode(1111111111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
303TEST_encode(22222222222VtB5VXc, "\x06\x15\x60\x13\x76\x28\x79\xF7\xFF\xFF\xFF\xFF\xFF");
304
305
306#define TEST_decode_pos(enc, expected) \
307 TEST(base58_decode_pos, handles_pos_##enc) \
308 { \
309 do_test_decode_pos(#enc, MAKE_STR(expected)); \
310 }
311
312#define TEST_decode_neg(enc) \
313 TEST(base58_decode_neg, handles_neg_##enc) \
314 { \
315 do_test_decode_neg(#enc); \
316 }
317
318TEST_decode_pos(, "");
319TEST_decode_pos(5Q, "\xFF");
320TEST_decode_pos(LUv, "\xFF\xFF");
321TEST_decode_pos(2UzHL, "\xFF\xFF\xFF");
322TEST_decode_pos(7YXq9G, "\xFF\xFF\xFF\xFF");
323TEST_decode_pos(VtB5VXc, "\xFF\xFF\xFF\xFF\xFF");
324TEST_decode_pos(3CUsUpv9t, "\xFF\xFF\xFF\xFF\xFF\xFF");
325TEST_decode_pos(Ahg1opVcGW, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
326TEST_decode_pos(jpXCZedGfVQ, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
327TEST_decode_pos(jpXCZedGfVQ5Q, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
328TEST_decode_pos(jpXCZedGfVQLUv, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
329TEST_decode_pos(jpXCZedGfVQ2UzHL, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
330TEST_decode_pos(jpXCZedGfVQ7YXq9G, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
331TEST_decode_pos(jpXCZedGfVQVtB5VXc, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
332TEST_decode_pos(jpXCZedGfVQ3CUsUpv9t, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
333TEST_decode_pos(jpXCZedGfVQAhg1opVcGW, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
334TEST_decode_pos(jpXCZedGfVQjpXCZedGfVQ, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
335// Invalid length
336TEST_decode_neg(1);
337TEST_decode_neg(z);
338TEST_decode_neg(1111);
339TEST_decode_neg(zzzz);
340TEST_decode_neg(11111111);
341TEST_decode_neg(zzzzzzzz);
342TEST_decode_neg(123456789AB1);
343TEST_decode_neg(123456789ABz);
344TEST_decode_neg(123456789AB1111);
345TEST_decode_neg(123456789ABzzzz);
346TEST_decode_neg(123456789AB11111111);
347TEST_decode_neg(123456789ABzzzzzzzz);
348// Overflow
349TEST_decode_neg(5R);
350TEST_decode_neg(zz);
351TEST_decode_neg(LUw);
352TEST_decode_neg(zzz);
353TEST_decode_neg(2UzHM);
354TEST_decode_neg(zzzzz);
355TEST_decode_neg(7YXq9H);
356TEST_decode_neg(zzzzzz);
357TEST_decode_neg(VtB5VXd);
358TEST_decode_neg(zzzzzzz);
359TEST_decode_neg(3CUsUpv9u);
360TEST_decode_neg(zzzzzzzzz);
361TEST_decode_neg(Ahg1opVcGX);
362TEST_decode_neg(zzzzzzzzzz);
363TEST_decode_neg(jpXCZedGfVR);
364TEST_decode_neg(zzzzzzzzzzz);
365TEST_decode_neg(123456789AB5R);
366TEST_decode_neg(123456789ABzz);
367TEST_decode_neg(123456789ABLUw);
368TEST_decode_neg(123456789ABzzz);
369TEST_decode_neg(123456789AB2UzHM);
370TEST_decode_neg(123456789ABzzzzz);
371TEST_decode_neg(123456789AB7YXq9H);
372TEST_decode_neg(123456789ABzzzzzz);
373TEST_decode_neg(123456789ABVtB5VXd);
374TEST_decode_neg(123456789ABzzzzzzz);
375TEST_decode_neg(123456789AB3CUsUpv9u);
376TEST_decode_neg(123456789ABzzzzzzzzz);
377TEST_decode_neg(123456789ABAhg1opVcGX);
378TEST_decode_neg(123456789ABzzzzzzzzzz);
379TEST_decode_neg(123456789ABjpXCZedGfVR);
380TEST_decode_neg(123456789ABzzzzzzzzzzz);
381TEST_decode_neg(zzzzzzzzzzz11);
382// Invalid symbols
383TEST_decode_neg(10);
384TEST_decode_neg(11I);
385TEST_decode_neg(11O11);
386TEST_decode_neg(11l111);
387TEST_decode_neg(11_11111111);
388TEST_decode_neg(1101111111111);
389TEST_decode_neg(11I11111111111111);
390TEST_decode_neg(11O1111111111111111111);
391TEST_decode_neg(1111111111110);
392TEST_decode_neg(111111111111l1111);
393TEST_decode_neg(111111111111_111111111);
394
395
396#define TEST_encode_decode_addr(addr, tag, data) \
397 TEST(base58_encode_decode_addr, handles_##addr) \
398 { \
399 do_test_encode_decode_addr(UINT64_C(tag), MAKE_STR(data), #addr); \
400 }
401
402TEST_encode_decode_addr(21D35quxec71111111111111111111111111111111111111111111111111111111111111111111111111111116Q5tCH, 6,
403 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
404 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
405TEST_encode_decode_addr(2Aui6ejTFscjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQVqegMoV, 6,
406 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
407 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
408TEST_encode_decode_addr(1119XrkPuSmLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKVphZRvn, 0,
409 "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
410 "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF");
411TEST_encode_decode_addr(111111111111111111111111111111111111111111111111111111111111111111111111111111111111111115TXfiA, 0,
412 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
413 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
414TEST_encode_decode_addr(PuT7GAdgbA83qvSEivPLYo11111111111111111111111111111111111111111111111111111111111111111111111111111169tWrH, 0x1122334455667788,
415 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
416 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
417TEST_encode_decode_addr(PuT7GAdgbA841d7FXjswpJjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQVq4LL1v, 0x1122334455667788,
418 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
419 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
420TEST_encode_decode_addr(PuT7GAdgbA819VwdWVDP, 0x1122334455667788, "\x11");
421TEST_encode_decode_addr(PuT7GAdgbA81efAfdCjPg, 0x1122334455667788, "\x22\x22");
422TEST_encode_decode_addr(PuT7GAdgbA83sryEt3YC8Q, 0x1122334455667788, "\x33\x33\x33");
423TEST_encode_decode_addr(PuT7GAdgbA83tWUuc54PFP3b, 0x1122334455667788, "\x44\x44\x44\x44");
424TEST_encode_decode_addr(PuT7GAdgbA83u9zaKrtRKZ1J6, 0x1122334455667788, "\x55\x55\x55\x55\x55");
425TEST_encode_decode_addr(PuT7GAdgbA83uoWF3eanGG1aRoG, 0x1122334455667788, "\x66\x66\x66\x66\x66\x66");
426TEST_encode_decode_addr(PuT7GAdgbA83vT1umSHMYJ4oNVdu, 0x1122334455667788, "\x77\x77\x77\x77\x77\x77\x77");
427TEST_encode_decode_addr(PuT7GAdgbA83w6XaVDyvpoGQBEWbB, 0x1122334455667788, "\x88\x88\x88\x88\x88\x88\x88\x88");
428TEST_encode_decode_addr(PuT7GAdgbA83wk3FD1gW7J2KVGofA1r, 0x1122334455667788, "\x99\x99\x99\x99\x99\x99\x99\x99\x99");
429TEST_encode_decode_addr(15p2yAV, 0, "");
430TEST_encode_decode_addr(FNQ3D6A, 0x7F, "");
431TEST_encode_decode_addr(26k9QWweu, 0x80, "");
432TEST_encode_decode_addr(3BzAD7n3y, 0xFF, "");
433TEST_encode_decode_addr(11efCaY6UjG7JrxuB, 0, "\x11\x22\x33\x44\x55\x66\x77");
434TEST_encode_decode_addr(21rhHRT48LN4PriP9, 6, "\x11\x22\x33\x44\x55\x66\x77");
435
436
437#define TEST_decode_addr_neg(addr, test_name) \
438 TEST(base58_decode_addr_neg, test_name) \
439 { \
440 uint64_t tag; \
441 std::string data; \
442 ASSERT_FALSE(base58::decode_addr(MAKE_STR(addr), tag, data)); \
443 }
444
445TEST_decode_addr_neg("zuT7GAdgbA819VwdWVDP", decode_fails_due_overflow);
446TEST_decode_addr_neg("0uT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_0);
447TEST_decode_addr_neg("IuT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_I);
448TEST_decode_addr_neg("OuT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_O);
449TEST_decode_addr_neg("luT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_l);
450TEST_decode_addr_neg("\0uT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_00);
451TEST_decode_addr_neg("PuT7GAdgbA819VwdWVD", decode_fails_due_invalid_lenght);
452TEST_decode_addr_neg("11efCaY6UjG7JrxuC", handles_invalid_checksum);
453TEST_decode_addr_neg("jerj2e4mESo", handles_non_correct_tag); // "jerj2e4mESo" == "\xFF\x00\xFF\xFF\x5A\xD9\xF1\x1C"
454TEST_decode_addr_neg("1", decode_fails_due_invalid_block_len_0);
455TEST_decode_addr_neg("1111", decode_fails_due_invalid_block_len_1);
456TEST_decode_addr_neg("11", decode_fails_due_address_too_short_0);
457TEST_decode_addr_neg("111", decode_fails_due_address_too_short_1);
458TEST_decode_addr_neg("11111", decode_fails_due_address_too_short_2);
459TEST_decode_addr_neg("111111", decode_fails_due_address_too_short_3);
460TEST_decode_addr_neg("999999", decode_fails_due_address_too_short_4);
461TEST_decode_addr_neg("ZZZZZZ", decode_fails_due_address_too_short_5);
462
463namespace
464{
465 std::string test_serialized_keys = MAKE_STR(
466 "\xf7\x24\xbc\x5c\x6c\xfb\xb9\xd9\x76\x02\xc3\x00\x42\x3a\x2f\x28"
467 "\x64\x18\x74\x51\x3a\x03\x57\x78\xa0\xc1\x77\x8d\x83\x32\x01\xe9"
468 "\x22\x09\x39\x68\x9e\xdf\x1a\xbd\x5b\xc1\xd0\x31\xf7\x3e\xcd\x6c"
469 "\x99\x3a\xdd\x66\xd6\x80\x88\x70\x45\x6a\xfe\xb8\xe7\xee\xb6\x8d");
470 // DON'T ever use this as a destination for funds, as the keys are right above this comment...
471 std::string test_keys_addr_str = "etnkQ3cy4RZj74KgQDGKRKAjTfWJywnvM1ZRGv9yX9o89N8qGedHKLheKPmtkLpTmpBWGDT3ZuLUmNVvz3LmU5LrA3gGg1nv6P";
472}
473
474TEST(get_account_address_as_str, works_correctly)
475{
476 cryptonote::account_public_address addr;
477 ASSERT_TRUE(serialization::parse_binary(test_serialized_keys, addr));
478 std::string addr_str = cryptonote::get_account_address_as_str(cryptonote::MAINNET, false, addr);
479 ASSERT_EQ(addr_str, test_keys_addr_str);
480}
481
482TEST(get_account_address_from_str, handles_valid_address)
483{
484 cryptonote::address_parse_info info;
485 ASSERT_TRUE(cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, test_keys_addr_str));
486
487 std::string blob;
488 ASSERT_TRUE(serialization::dump_binary(info.address, blob));
489 ASSERT_EQ(blob, test_serialized_keys);
490}
491
492TEST(get_account_address_from_str, fails_on_invalid_address_format)
493{
494 cryptonote::address_parse_info info;
495 std::string addr_str = test_keys_addr_str;
496 addr_str[0] = '0';
497
498 ASSERT_FALSE(cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, addr_str));
499}
500
501TEST(get_account_address_from_str, fails_on_invalid_address_prefix)
502{
503 std::string addr_str = base58::encode_addr(0, test_serialized_keys);
504
505 cryptonote::address_parse_info info;
506 ASSERT_FALSE(cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, addr_str));
507}
508
509TEST(get_account_address_from_str, fails_on_invalid_address_content)
510{
511 std::string addr_str = base58::encode_addr(config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, test_serialized_keys.substr(1));
512
513 cryptonote::address_parse_info info;
514 ASSERT_FALSE(cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, addr_str));
515}
516
517TEST(get_account_address_from_str, fails_on_invalid_address_spend_key)
518{
519 std::string serialized_keys_copy = test_serialized_keys;
520 serialized_keys_copy[0] = '\0';
521 std::string addr_str = base58::encode_addr(config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, serialized_keys_copy);
522
523 cryptonote::address_parse_info info;
524 ASSERT_FALSE(cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, addr_str));
525}
526
527TEST(get_account_address_from_str, fails_on_invalid_address_view_key)
528{
529 std::string serialized_keys_copy = test_serialized_keys;
530 serialized_keys_copy.back() = '\x01';
531 std::string addr_str = base58::encode_addr(config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, serialized_keys_copy);
532
533 cryptonote::address_parse_info info;
534 ASSERT_FALSE(cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, addr_str));
535}
536
537TEST(get_account_address_from_str, parses_old_address_format)
538{
539 cryptonote::address_parse_info info;
540 ASSERT_TRUE(cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, "002391bbbb24dea6fd95232e97594a27769d0153d053d2102b789c498f57a2b00b69cd6f2f5c529c1660f2f4a2b50178d6640c20ce71fe26373041af97c5b10236fc"));
541}
binary_utils.h
cryptonote_basic_impl.h
ASSERT_EQ
#define ASSERT_EQ(val1, val2)
Definition gtest.h:1956
ASSERT_FALSE
#define ASSERT_FALSE(condition)
Definition gtest.h:1868
TEST
#define TEST(test_case_name, test_name)
Definition gtest.h:2187
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition gtest.h:1865
A
Matcher< T > A()
Definition gmock-matchers.h:3732
config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX
uint64_t const CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX
Definition cryptonote_config.h:201
cryptonote::get_account_address_from_str
bool get_account_address_from_str(address_parse_info &info, network_type nettype, std::string const &str)
Definition cryptonote_basic_impl.cpp:243
cryptonote::get_account_address_as_str
std::string get_account_address_as_str(network_type nettype, bool subaddress, account_public_address const &adr)
Definition cryptonote_basic_impl.cpp:207
serialization::parse_binary
bool parse_binary(const std::string &blob, T &v)
Definition binary_utils.h:41
serialization::dump_binary
bool dump_binary(T &v, std::string &blob)
Definition binary_utils.h:51
tools::base58::decode
bool decode(const std::string &enc, std::string &data)
Definition base58.cpp:196
tools::base58::encode_addr
std::string encode_addr(uint64_t tag, const std::string &data)
Definition base58.cpp:228
tools::base58::encode
std::string encode(const std::string &data)
Definition base58.cpp:173
tools::base58::decode_addr
bool decode_addr(const std::string &addr, uint64_t &tag, std::string &data)
Definition base58.cpp:238
tools
Various Tools.
Definition tools.cpp:31
info
CXA_THROW_INFO_T * info
Definition stack_trace.cpp:91
uint8_t
unsigned char uint8_t
Definition stdint.h:124
uint64_t
unsigned __int64 uint64_t
Definition stdint.h:136
cryptonote::account_public_address
Definition cryptonote_basic.h:75
cryptonote::address_parse_info
Definition cryptonote_basic_impl.h:80
TEST_decode_neg
#define TEST_decode_neg(enc)
Definition base58.cpp:312
TEST_decode_addr_neg
#define TEST_decode_addr_neg(addr, test_name)
Definition base58.cpp:437
TEST_decode_block_neg
#define TEST_decode_block_neg(enc)
Definition base58.cpp:216
TEST_decode_pos
#define TEST_decode_pos(enc, expected)
Definition base58.cpp:306
TEST_uint_8be_to_64
#define TEST_uint_8be_to_64(expected, str)
Definition base58.cpp:120
TEST_encode
#define TEST_encode(expected, data)
Definition base58.cpp:281
MAKE_STR
#define MAKE_STR(arr)
Definition base58.cpp:42
TEST_uint_64_to_8be
#define TEST_uint_64_to_8be(num, expected_str)
Definition base58.cpp:137
TEST_encode_decode_addr
#define TEST_encode_decode_addr(addr, tag, data)
Definition base58.cpp:396
TEST_encode_block
#define TEST_encode_block(block, expected)
Definition base58.cpp:169
TEST_decode_block_pos
#define TEST_decode_block_pos(enc, expected)
Definition base58.cpp:210