Skip to content

Commit 75f8396

Browse files
achow101achow101
committed
Merge bitcoin/bitcoin#30746: test: cover base[32|58|64] with symmetric roundtrip fuzz (and padding) tests
f919d91 fuzz: Add fuzzing for max_ret_len in DecodeBase58/DecodeBase58Check (Lőrinc) 635bc58 test: Fuzz Base32/Base58/Base64 roundtrip conversions (Lőrinc) 5dd3a0d test: Extend base58_encode_decode.json with edge cases (Lőrinc) ae40cf1 test: Add padding tests for Base32/Base64 (Lőrinc) Pull request description: Added fuzzed roundtrips for `base[32|58|64]` encoding to make sure encoding/decoding are symmetric. Note that if we omit the padding in `EncodeBase32` we won't be able to decode it with `DecodeBase32`. Added dedicated padding tests to cover failure behavior Also moved over the Base58 json test edge cases from bitcoin/bitcoin#30035 ACKs for top commit: hodlinator: re-ACK f919d91 achow101: ACK f919d91 Tree-SHA512: 6a6c63d0a659b70d42aad7a8f37ce6e372756e2c88c84e7be5c1ff1f2a7c58860ed7113acbe1a9658a7d19deb91f0abe2ec527ed660335845cd1e0a9380b4295
2 parents c4b46b4 + f919d91 commit 75f8396

File tree

5 files changed

+114
-50
lines changed

5 files changed

+114
-50
lines changed

‎src/test/base32_tests.cpp‎

Lines changed: 21 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -29,11 +29,28 @@ BOOST_AUTO_TEST_CASE(base32_testvectors)
2929
BOOST_CHECK_MESSAGE(std::ranges::equal(*dec, vstrIn[i]), vstrOut[i]);
3030
}
3131

32+
BOOST_CHECK(!DecodeBase32("AWSX3VPPinvalid")); // invalid size
33+
BOOST_CHECK( DecodeBase32("AWSX3VPP")); // valid
34+
3235
// Decoding strings with embedded NUL characters should fail
33-
BOOST_CHECK(!DecodeBase32("invalid\0"s)); // correct size, invalid due to \0
34-
BOOST_CHECK(DecodeBase32("AWSX3VPP"s)); // valid
35-
BOOST_CHECK(!DecodeBase32("AWSX3VPP\0invalid"s)); // correct size, invalid due to \0
36-
BOOST_CHECK(!DecodeBase32("AWSX3VPPinvalid"s)); // invalid size
36+
BOOST_CHECK(!DecodeBase32("invalid\0"sv)); // correct size, invalid due to \0
37+
BOOST_CHECK(!DecodeBase32("AWSX3VPP\0invalid"sv)); // correct size, invalid due to \0
38+
}
39+
40+
BOOST_AUTO_TEST_CASE(base32_padding)
41+
{
42+
// Is valid without padding
43+
BOOST_CHECK_EQUAL(EncodeBase32("fooba"), "mzxw6ytb");
44+
45+
// Valid size
46+
BOOST_CHECK(!DecodeBase32("========"));
47+
BOOST_CHECK(!DecodeBase32("a======="));
48+
BOOST_CHECK( DecodeBase32("aa======"));
49+
BOOST_CHECK(!DecodeBase32("aaa====="));
50+
BOOST_CHECK( DecodeBase32("aaaa===="));
51+
BOOST_CHECK( DecodeBase32("aaaaa==="));
52+
BOOST_CHECK(!DecodeBase32("aaaaaa=="));
53+
BOOST_CHECK( DecodeBase32("aaaaaaa="));
3754
}
3855

3956
BOOST_AUTO_TEST_SUITE_END()

‎src/test/base58_tests.cpp‎

Lines changed: 2 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
6565
BOOST_CHECK(!DecodeBase58("invalid\0"s, result, 100));
6666
BOOST_CHECK(!DecodeBase58("\0invalid"s, result, 100));
6767

68-
BOOST_CHECK(DecodeBase58("good"s, result, 100));
68+
BOOST_CHECK( DecodeBase58("good"s, result, 100));
6969
BOOST_CHECK(!DecodeBase58("bad0IOl"s, result, 100));
7070
BOOST_CHECK(!DecodeBase58("goodbad0IOl"s, result, 100));
7171
BOOST_CHECK(!DecodeBase58("good\0bad0IOl"s, result, 100));
@@ -76,26 +76,10 @@ BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
7676
constexpr auto expected{"971a55"_hex_u8};
7777
BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
7878

79-
BOOST_CHECK(DecodeBase58Check("3vQB7B6MrGQZaxCuFg4oh"s, result, 100));
79+
BOOST_CHECK( DecodeBase58Check("3vQB7B6MrGQZaxCuFg4oh"s, result, 100));
8080
BOOST_CHECK(!DecodeBase58Check("3vQB7B6MrGQZaxCuFg4oi"s, result, 100));
8181
BOOST_CHECK(!DecodeBase58Check("3vQB7B6MrGQZaxCuFg4oh0IOl"s, result, 100));
8282
BOOST_CHECK(!DecodeBase58Check("3vQB7B6MrGQZaxCuFg4oh\0" "0IOl"s, result, 100));
8383
}
8484

85-
BOOST_AUTO_TEST_CASE(base58_random_encode_decode)
86-
{
87-
for (int n = 0; n < 1000; ++n) {
88-
unsigned int len = 1 + m_rng.randbits(8);
89-
unsigned int zeroes = m_rng.randbool() ? m_rng.randrange(len + 1) : 0;
90-
auto data = Cat(std::vector<unsigned char>(zeroes, '\000'), m_rng.randbytes(len - zeroes));
91-
auto encoded = EncodeBase58Check(data);
92-
std::vector<unsigned char> decoded;
93-
auto ok_too_small = DecodeBase58Check(encoded, decoded, m_rng.randrange(len));
94-
BOOST_CHECK(!ok_too_small);
95-
auto ok = DecodeBase58Check(encoded, decoded, len + m_rng.randrange(257 - len));
96-
BOOST_CHECK(ok);
97-
BOOST_CHECK(data == decoded);
98-
}
99-
}
100-
10185
BOOST_AUTO_TEST_SUITE_END()

‎src/test/base64_tests.cpp‎

Lines changed: 17 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -36,11 +36,24 @@ BOOST_AUTO_TEST_CASE(base64_testvectors)
3636
BOOST_CHECK_EQUAL(EncodeBase64(in_s), out_exp);
3737
}
3838

39+
BOOST_CHECK(DecodeBase64("nQB/pZw=")); // valid
40+
3941
// Decoding strings with embedded NUL characters should fail
40-
BOOST_CHECK(!DecodeBase64("invalid\0"s));
41-
BOOST_CHECK(DecodeBase64("nQB/pZw="s));
42-
BOOST_CHECK(!DecodeBase64("nQB/pZw=\0invalid"s));
43-
BOOST_CHECK(!DecodeBase64("nQB/pZw=invalid\0"s));
42+
BOOST_CHECK(!DecodeBase64("invalid\0"sv)); // correct size, invalid due to \0
43+
BOOST_CHECK(!DecodeBase64("nQB/pZw=\0invalid"sv));
44+
BOOST_CHECK(!DecodeBase64("nQB/pZw=invalid\0"sv)); // invalid, padding only allowed at the end
45+
}
46+
47+
BOOST_AUTO_TEST_CASE(base64_padding)
48+
{
49+
// Is valid without padding
50+
BOOST_CHECK_EQUAL(EncodeBase64("foobar"), "Zm9vYmFy");
51+
52+
// Valid size
53+
BOOST_CHECK(!DecodeBase64("===="));
54+
BOOST_CHECK(!DecodeBase64("a==="));
55+
BOOST_CHECK( DecodeBase64("YQ=="));
56+
BOOST_CHECK( DecodeBase64("YWE="));
4457
}
4558

4659
BOOST_AUTO_TEST_SUITE_END()

‎src/test/data/base58_encode_decode.json‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,13 @@
1111
["ecac89cad93923c02321", "EJDM8drfXA6uyA"],
1212
["10c8511e", "Rt5zm"],
1313
["00000000000000000000", "1111111111"],
14+
["00000000000000000000000000000000000000000000000000000000000000000000000000000000", "1111111111111111111111111111111111111111"],
15+
["00000000000000000000000000000000000000000000000000000000000000000000000000000001", "1111111111111111111111111111111111111112"],
16+
["0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ec39d04c37e71e5d591881f6", "111111111111111111111111111111111111111111111111111111111111111111111111111111111111115TYzLYH1udmLdzCLM"],
1417
["000111d38e5fc9071ffcd20b4a763cc9ae4f252bb4e48fd66a835e252ada93ff480d6dd43dc62a641155a5", "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"],
15-
["000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", "1cWB5HCBdLjAuqGGReWE3R3CguuwSjw6RHn39s2yuDRTS5NsBgNiFpWgAnEx6VQi8csexkgYw3mdYrMHr8x9i7aEwP8kZ7vccXWqKDvGv3u1GxFKPuAkn8JCPPGDMf3vMMnbzm6Nh9zh1gcNsMvH3ZNLmP5fSG6DGbbi2tuwMWPthr4boWwCxf7ewSgNQeacyozhKDDQQ1qL5fQFUW52QKUZDZ5fw3KXNQJMcNTcaB723LchjeKun7MuGW5qyCBZYzA1KjofN1gYBV3NqyhQJ3Ns746GNuf9N2pQPmHz4xpnSrrfCvy6TVVz5d4PdrjeshsWQwpZsZGzvbdAdN8MKV5QsBDY"]
18+
["000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", "1cWB5HCBdLjAuqGGReWE3R3CguuwSjw6RHn39s2yuDRTS5NsBgNiFpWgAnEx6VQi8csexkgYw3mdYrMHr8x9i7aEwP8kZ7vccXWqKDvGv3u1GxFKPuAkn8JCPPGDMf3vMMnbzm6Nh9zh1gcNsMvH3ZNLmP5fSG6DGbbi2tuwMWPthr4boWwCxf7ewSgNQeacyozhKDDQQ1qL5fQFUW52QKUZDZ5fw3KXNQJMcNTcaB723LchjeKun7MuGW5qyCBZYzA1KjofN1gYBV3NqyhQJ3Ns746GNuf9N2pQPmHz4xpnSrrfCvy6TVVz5d4PdrjeshsWQwpZsZGzvbdAdN8MKV5QsBDY"],
19+
["271F359E", "zzzzy"],
20+
["271F359F", "zzzzz"],
21+
["271F35A0", "211111"],
22+
["271F35A1", "211112"]
1623
]

‎src/test/fuzz/base_encode_decode.cpp‎

Lines changed: 66 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -6,49 +6,92 @@
66

77
#include <base58.h>
88
#include <psbt.h>
9+
#include <test/fuzz/FuzzedDataProvider.h>
910
#include <util/strencodings.h>
1011
#include <util/string.h>
1112

1213
#include <cassert>
13-
#include <cstdint>
1414
#include <string>
1515
#include <vector>
16+
#include <ranges>
1617

17-
using util::TrimString;
1818
using util::TrimStringView;
1919

20-
FUZZ_TARGET(base_encode_decode)
20+
FUZZ_TARGET(base58_encode_decode)
2121
{
22-
const std::string random_encoded_string(buffer.begin(), buffer.end());
22+
FuzzedDataProvider provider(buffer.data(), buffer.size());
23+
const std::string random_string{provider.ConsumeRandomLengthString(1000)};
24+
const int max_ret_len{provider.ConsumeIntegralInRange<int>(-1, 1000)};
2325

26+
// Decode/Encode roundtrip
2427
std::vector<unsigned char> decoded;
25-
if (DecodeBase58(random_encoded_string, decoded, 100)) {
26-
const std::string encoded_string = EncodeBase58(decoded);
27-
assert(encoded_string == TrimStringView(encoded_string));
28-
assert(ToLower(encoded_string) == ToLower(TrimString(random_encoded_string)));
28+
if (DecodeBase58(random_string, decoded, max_ret_len)) {
29+
const auto encoded_string{EncodeBase58(decoded)};
30+
assert(encoded_string == TrimStringView(random_string));
31+
assert(encoded_string.empty() || !DecodeBase58(encoded_string, decoded, provider.ConsumeIntegralInRange<int>(0, decoded.size() - 1)));
2932
}
33+
// Encode/Decode roundtrip
34+
const auto encoded{EncodeBase58(buffer)};
35+
std::vector<unsigned char> roundtrip_decoded;
36+
assert(DecodeBase58(encoded, roundtrip_decoded, buffer.size())
37+
&& std::ranges::equal(roundtrip_decoded, buffer));
38+
}
39+
40+
FUZZ_TARGET(base58check_encode_decode)
41+
{
42+
FuzzedDataProvider provider(buffer.data(), buffer.size());
43+
const std::string random_string{provider.ConsumeRandomLengthString(1000)};
44+
const int max_ret_len{provider.ConsumeIntegralInRange<int>(-1, 1000)};
3045

31-
if (DecodeBase58Check(random_encoded_string, decoded, 100)) {
32-
const std::string encoded_string = EncodeBase58Check(decoded);
33-
assert(encoded_string == TrimString(encoded_string));
34-
assert(ToLower(encoded_string) == ToLower(TrimString(random_encoded_string)));
46+
// Decode/Encode roundtrip
47+
std::vector<unsigned char> decoded;
48+
if (DecodeBase58Check(random_string, decoded, max_ret_len)) {
49+
const auto encoded_string{EncodeBase58Check(decoded)};
50+
assert(encoded_string == TrimStringView(random_string));
51+
assert(encoded_string.empty() || !DecodeBase58Check(encoded_string, decoded, provider.ConsumeIntegralInRange<int>(0, decoded.size() - 1)));
3552
}
53+
// Encode/Decode roundtrip
54+
const auto encoded{EncodeBase58Check(buffer)};
55+
std::vector<unsigned char> roundtrip_decoded;
56+
assert(DecodeBase58Check(encoded, roundtrip_decoded, buffer.size())
57+
&& std::ranges::equal(roundtrip_decoded, buffer));
58+
}
59+
60+
FUZZ_TARGET(base32_encode_decode)
61+
{
62+
const std::string random_string{buffer.begin(), buffer.end()};
3663

37-
auto result = DecodeBase32(random_encoded_string);
38-
if (result) {
39-
const std::string encoded_string = EncodeBase32(*result);
40-
assert(encoded_string == TrimStringView(encoded_string));
41-
assert(ToLower(encoded_string) == ToLower(TrimString(random_encoded_string)));
64+
// Decode/Encode roundtrip
65+
if (auto result{DecodeBase32(random_string)}) {
66+
const auto encoded_string{EncodeBase32(*result)};
67+
assert(encoded_string == ToLower(TrimStringView(random_string)));
4268
}
69+
// Encode/Decode roundtrip
70+
const auto encoded{EncodeBase32(buffer)};
71+
const auto decoded{DecodeBase32(encoded)};
72+
assert(decoded && std::ranges::equal(*decoded, buffer));
73+
}
74+
75+
FUZZ_TARGET(base64_encode_decode)
76+
{
77+
const std::string random_string{buffer.begin(), buffer.end()};
4378

44-
result = DecodeBase64(random_encoded_string);
45-
if (result) {
46-
const std::string encoded_string = EncodeBase64(*result);
47-
assert(encoded_string == TrimString(encoded_string));
48-
assert(ToLower(encoded_string) == ToLower(TrimString(random_encoded_string)));
79+
// Decode/Encode roundtrip
80+
if (auto result{DecodeBase64(random_string)}) {
81+
const auto encoded_string{EncodeBase64(*result)};
82+
assert(encoded_string == TrimStringView(random_string));
4983
}
84+
// Encode/Decode roundtrip
85+
const auto encoded{EncodeBase64(buffer)};
86+
const auto decoded{DecodeBase64(encoded)};
87+
assert(decoded && std::ranges::equal(*decoded, buffer));
88+
}
89+
90+
FUZZ_TARGET(psbt_base64_decode)
91+
{
92+
const std::string random_string{buffer.begin(), buffer.end()};
5093

5194
PartiallySignedTransaction psbt;
5295
std::string error;
53-
(void)DecodeBase64PSBT(psbt, random_encoded_string, error);
96+
assert(DecodeBase64PSBT(psbt, random_string, error) == error.empty());
5497
}

0 commit comments

Comments
 (0)