Inside Bitcoin

1// Copyright (c) 2012-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <dbwrapper.h>
6#include <test/util/common.h>
7#include <test/util/random.h>
8#include <test/util/setup_common.h>
9#include <uint256.h>
10#include <util/byte_units.h>
11#include <util/string.h>
12
13#include <fstream>
14#include <memory>
15#include <ranges>
16
17#include <boost/test/unit_test.hpp>
18
19using util::ToString;
20
21BOOST_FIXTURE_TEST_SUITE(dbwrapper_tests, BasicTestingSetup)
22
23BOOST_AUTO_TEST_CASE(dbwrapper)
24{
25    // Perform tests both obfuscated and non-obfuscated.
26    for (const bool obfuscate : {false, true}) {
27        constexpr size_t CACHE_SIZE{1_MiB};
28        const fs::path path{m_args.GetDataDirBase() / "dbwrapper"};
29
30        Obfuscation obfuscation;
31        std::vector<std::pair<uint8_t, uint256>> key_values{};
32
33        // Write values
34        {
35            CDBWrapper dbw{{.path = path, .cache_bytes = CACHE_SIZE, .wipe_data = true, .obfuscate = obfuscate}};
36            BOOST_CHECK_EQUAL(obfuscate, !dbw.IsEmpty());
37
38            // Ensure that we're doing real obfuscation when obfuscate=true
39            obfuscation = dbwrapper_private::GetObfuscation(dbw);
40            BOOST_CHECK_EQUAL(obfuscate, dbwrapper_private::GetObfuscation(dbw));
41
42            for (uint8_t k{0}; k < 10; ++k) {
43                uint8_t key{k};
44                uint256 value{m_rng.rand256()};
45                dbw.Write(key, value);
46                key_values.emplace_back(key, value);
47            }
48        }
49
50        // Verify that the obfuscation key is never obfuscated
51        {
52            CDBWrapper dbw{{.path = path, .cache_bytes = CACHE_SIZE, .obfuscate = false}};
53            BOOST_CHECK_EQUAL(obfuscation, dbwrapper_private::GetObfuscation(dbw));
54        }
55
56        // Read back the values
57        {
58            CDBWrapper dbw{{.path = path, .cache_bytes = CACHE_SIZE, .obfuscate = obfuscate}};
59
60            // Ensure obfuscation is read back correctly
61            BOOST_CHECK_EQUAL(obfuscation, dbwrapper_private::GetObfuscation(dbw));
62            BOOST_CHECK_EQUAL(obfuscate, dbwrapper_private::GetObfuscation(dbw));
63
64            // Verify all written values
65            for (const auto& [key, expected_value] : key_values) {
66                uint256 read_value{};
67                BOOST_CHECK(dbw.Read(key, read_value));
68                BOOST_CHECK_EQUAL(read_value, expected_value);
69            }
70        }
71    }
72}
73
74BOOST_AUTO_TEST_CASE(dbwrapper_basic_data)
75{
76    // Perform tests both obfuscated and non-obfuscated.
77    for (bool obfuscate : {false, true}) {
78        fs::path ph = m_args.GetDataDirBase() / (obfuscate ? "dbwrapper_1_obfuscate_true" : "dbwrapper_1_obfuscate_false");
79        CDBWrapper dbw({.path = ph, .cache_bytes = 1_MiB, .memory_only = false, .wipe_data = true, .obfuscate = obfuscate});
80
81        uint256 res;
82        uint32_t res_uint_32;
83        bool res_bool;
84
85        // Ensure that we're doing real obfuscation when obfuscate=true
86        BOOST_CHECK_EQUAL(obfuscate, dbwrapper_private::GetObfuscation(dbw));
87
88        //Simulate block raw data - "b + block hash"
89        std::string key_block = "b" + m_rng.rand256().ToString();
90
91        uint256 in_block = m_rng.rand256();
92        dbw.Write(key_block, in_block);
93        BOOST_CHECK(dbw.Read(key_block, res));
94        BOOST_CHECK_EQUAL(res.ToString(), in_block.ToString());
95
96        //Simulate file raw data - "f + file_number"
97        std::string key_file = strprintf("f%04x", m_rng.rand32());
98
99        uint256 in_file_info = m_rng.rand256();
100        dbw.Write(key_file, in_file_info);
101        BOOST_CHECK(dbw.Read(key_file, res));
102        BOOST_CHECK_EQUAL(res.ToString(), in_file_info.ToString());
103
104        //Simulate transaction raw data - "t + transaction hash"
105        std::string key_transaction = "t" + m_rng.rand256().ToString();
106
107        uint256 in_transaction = m_rng.rand256();
108        dbw.Write(key_transaction, in_transaction);
109        BOOST_CHECK(dbw.Read(key_transaction, res));
110        BOOST_CHECK_EQUAL(res.ToString(), in_transaction.ToString());
111
112        //Simulate UTXO raw data - "c + transaction hash"
113        std::string key_utxo = "c" + m_rng.rand256().ToString();
114
115        uint256 in_utxo = m_rng.rand256();
116        dbw.Write(key_utxo, in_utxo);
117        BOOST_CHECK(dbw.Read(key_utxo, res));
118        BOOST_CHECK_EQUAL(res.ToString(), in_utxo.ToString());
119
120        //Simulate last block file number - "l"
121        uint8_t key_last_blockfile_number{'l'};
122        uint32_t lastblockfilenumber = m_rng.rand32();
123        dbw.Write(key_last_blockfile_number, lastblockfilenumber);
124        BOOST_CHECK(dbw.Read(key_last_blockfile_number, res_uint_32));
125        BOOST_CHECK_EQUAL(lastblockfilenumber, res_uint_32);
126
127        //Simulate Is Reindexing - "R"
128        uint8_t key_IsReindexing{'R'};
129        bool isInReindexing = m_rng.randbool();
130        dbw.Write(key_IsReindexing, isInReindexing);
131        BOOST_CHECK(dbw.Read(key_IsReindexing, res_bool));
132        BOOST_CHECK_EQUAL(isInReindexing, res_bool);
133
134        //Simulate last block hash up to which UXTO covers - 'B'
135        uint8_t key_lastblockhash_uxto{'B'};
136        uint256 lastblock_hash = m_rng.rand256();
137        dbw.Write(key_lastblockhash_uxto, lastblock_hash);
138        BOOST_CHECK(dbw.Read(key_lastblockhash_uxto, res));
139        BOOST_CHECK_EQUAL(lastblock_hash, res);
140
141        //Simulate file raw data - "F + filename_number + filename"
142        std::string file_option_tag = "F";
143        uint8_t filename_length = m_rng.randbits(8);
144        std::string filename = "randomfilename";
145        std::string key_file_option = strprintf("%s%01x%s", file_option_tag, filename_length, filename);
146
147        bool in_file_bool = m_rng.randbool();
148        dbw.Write(key_file_option, in_file_bool);
149        BOOST_CHECK(dbw.Read(key_file_option, res_bool));
150        BOOST_CHECK_EQUAL(res_bool, in_file_bool);
151    }
152}
153
154// Test batch operations
155BOOST_AUTO_TEST_CASE(dbwrapper_batch)
156{
157    // Perform tests both obfuscated and non-obfuscated.
158    for (const bool obfuscate : {false, true}) {
159        fs::path ph = m_args.GetDataDirBase() / (obfuscate ? "dbwrapper_batch_obfuscate_true" : "dbwrapper_batch_obfuscate_false");
160        CDBWrapper dbw({.path = ph, .cache_bytes = 1_MiB, .memory_only = true, .wipe_data = false, .obfuscate = obfuscate});
161
162        uint8_t key{'i'};
163        uint256 in = m_rng.rand256();
164        uint8_t key2{'j'};
165        uint256 in2 = m_rng.rand256();
166        uint8_t key3{'k'};
167        uint256 in3 = m_rng.rand256();
168
169        uint256 res;
170        CDBBatch batch(dbw);
171
172        batch.Write(key, in);
173        batch.Write(key2, in2);
174        batch.Write(key3, in3);
175
176        // Remove key3 before it's even been written
177        batch.Erase(key3);
178
179        dbw.WriteBatch(batch);
180
181        BOOST_CHECK(dbw.Read(key, res));
182        BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
183        BOOST_CHECK(dbw.Read(key2, res));
184        BOOST_CHECK_EQUAL(res.ToString(), in2.ToString());
185
186        // key3 should've never been written
187        BOOST_CHECK(dbw.Read(key3, res) == false);
188
189        batch.Clear();
190        batch.Write(key3, in3);
191        dbw.WriteBatch(batch);
192
193        BOOST_CHECK(dbw.Read(key3, res));
194        BOOST_CHECK_EQUAL(res.ToString(), in3.ToString());
195    }
196}
197
198// Verify that Read() returns false (without throwing) when the stored value
199// fails to be deserialized
200BOOST_AUTO_TEST_CASE(dbwrapper_read_returns_false_on_deserialization_error)
201{
202    for (const bool obfuscate : {false, true}) {
203        const fs::path path{m_args.GetDataDirBase() / (obfuscate ? "dbwrapper_deser_obf" : "dbwrapper_deser_noobf")};
204        CDBWrapper dbw({.path = path, .cache_bytes = 1 << 20, .wipe_data = true, .obfuscate = obfuscate});
205
206        constexpr uint8_t key{'X'};
207
208        // Write a single byte. uint256 requires 32 bytes, so reading this key
209        // as uint256 must trigger a deserialization error inside Read()
210        dbw.Write(key, uint8_t{0xFF});
211        BOOST_CHECK(dbw.Exists(key));
212
213        // Read() must catch the deserialization exception and return false,
214        // the same as if the key were absent
215        uint256 result;
216        BOOST_CHECK(!dbw.Read(key, result));
217    }
218}
219
220// Verify Read() throws dbwrapper_error due to an internal db error
221BOOST_AUTO_TEST_CASE(dbwrapper_read_throws_on_db_error)
222{
223    const fs::path path{m_args.GetDataDirBase() / "dbwrapper_db_error"};
224    constexpr uint8_t key{'Y'};
225
226    const auto make_db = [] (const fs::path& path, const bool force_compact) {
227        return CDBWrapper({.path = path, .cache_bytes = 1 << 20, .obfuscate = false,
228                        .options = {.force_compact = force_compact}});
229    };
230
231    // Write a value and close the database
232    make_db(path, /*force_compact=*/false).Write(key, m_rng.rand256());
233
234    // Force compaction to ensure the data is written into the .ldb files
235    // rather than left in the WAL.
236    (void)make_db(path, /*force_compact=*/true);
237
238    // Corrupt every table so any subsequent Read() fails
239    for (const auto& entry : fs::directory_iterator(path)) {
240        if (entry.path().extension() == ".ldb") {
241            std::ofstream{entry.path(), std::ios::binary | std::ios::trunc}
242            .write("\xff", 1);
243        }
244    }
245
246    // Read() should detect the issue now and throw
247    const auto db{make_db(path, /*force_compact=*/false)};
248    uint256 result;
249    BOOST_CHECK_EXCEPTION(db.Read(key, result), dbwrapper_error, HasReason("Fatal LevelDB error"));
250