Branch data Line data Source code
1 : : // Copyright (c) 2009-2022 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 : : #ifndef BITCOIN_TEST_FUZZ_UTIL_H
6 : : #define BITCOIN_TEST_FUZZ_UTIL_H
7 : :
8 : : #include <addresstype.h>
9 : : #include <arith_uint256.h>
10 : : #include <coins.h>
11 : : #include <compat/compat.h>
12 : : #include <consensus/amount.h>
13 : : #include <consensus/consensus.h>
14 : : #include <key.h>
15 : : #include <merkleblock.h>
16 : : #include <primitives/transaction.h>
17 : : #include <script/script.h>
18 : : #include <serialize.h>
19 : : #include <streams.h>
20 : : #include <test/fuzz/FuzzedDataProvider.h>
21 : : #include <test/fuzz/fuzz.h>
22 : : #include <uint256.h>
23 : : #include <version.h>
24 : :
25 : : #include <algorithm>
26 : : #include <array>
27 : : #include <cstdint>
28 : : #include <cstdio>
29 : : #include <optional>
30 : : #include <string>
31 : : #include <vector>
32 : :
33 : : class PeerManager;
34 : :
35 : : template <typename... Callables>
36 : 21085173 : size_t CallOneOf(FuzzedDataProvider& fuzzed_data_provider, Callables... callables)
37 : : {
38 : 21085173 : constexpr size_t call_size{sizeof...(callables)};
39 : : static_assert(call_size >= 1);
40 : 21085173 : const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
41 : :
42 : 21085173 : size_t i{0};
43 [ + + + + : 21085173 : ((i++ == call_index ? callables() : void()), ...);
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + ]
44 : 21053759 : return call_size;
45 : : }
46 : :
47 : : template <typename Collection>
48 : 4994897 : auto& PickValue(FuzzedDataProvider& fuzzed_data_provider, Collection& col)
49 : : {
50 : 4994897 : auto sz{col.size()};
51 [ + - + - : 4994897 : assert(sz >= 1);
+ - ]
52 : 4994897 : auto it = col.begin();
53 : 4994897 : std::advance(it, fuzzed_data_provider.ConsumeIntegralInRange<decltype(sz)>(0, sz - 1));
54 : 4994897 : return *it;
55 : : }
56 : :
57 : : template<typename B = uint8_t>
58 : 2834548 : [[nodiscard]] inline std::vector<B> ConsumeRandomLengthByteVector(FuzzedDataProvider& fuzzed_data_provider, const std::optional<size_t>& max_length = std::nullopt) noexcept
59 : : {
60 : : static_assert(sizeof(B) == 1);
61 [ + + ]: 5669096 : const std::string s = max_length ?
62 [ + - + - ]: 135619 : fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
63 [ + - ]: 2698929 : fuzzed_data_provider.ConsumeRandomLengthString();
64 [ + - ]: 2834548 : std::vector<B> ret(s.size());
65 [ + - ]: 2834548 : std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
66 : 2834548 : return ret;
67 [ + - ]: 2834548 : }
68 : :
69 : 2031 : [[nodiscard]] inline std::vector<bool> ConsumeRandomLengthBitVector(FuzzedDataProvider& fuzzed_data_provider, const std::optional<size_t>& max_length = std::nullopt) noexcept
70 : : {
71 [ + - ]: 2031 : return BytesToBits(ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length));
72 : : }
73 : :
74 : 755 : [[nodiscard]] inline DataStream ConsumeDataStream(FuzzedDataProvider& fuzzed_data_provider, const std::optional<size_t>& max_length = std::nullopt) noexcept
75 : : {
76 [ + - + - ]: 755 : return DataStream{ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length)};
77 : : }
78 : :
79 : 51366 : [[nodiscard]] inline std::vector<std::string> ConsumeRandomLengthStringVector(FuzzedDataProvider& fuzzed_data_provider, const size_t max_vector_size = 16, const size_t max_string_length = 16) noexcept
80 : : {
81 [ + - ]: 51366 : const size_t n_elements = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, max_vector_size);
82 : 51366 : std::vector<std::string> r;
83 [ + + ]: 282095 : for (size_t i = 0; i < n_elements; ++i) {
84 [ + - + - ]: 230729 : r.push_back(fuzzed_data_provider.ConsumeRandomLengthString(max_string_length));
85 : 230729 : }
86 : 51366 : return r;
87 [ + - ]: 51366 : }
88 : :
89 : : template <typename T>
90 : 1309 : [[nodiscard]] inline std::vector<T> ConsumeRandomLengthIntegralVector(FuzzedDataProvider& fuzzed_data_provider, const size_t max_vector_size = 16) noexcept
91 : : {
92 [ + - ]: 1309 : const size_t n_elements = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, max_vector_size);
93 : 1309 : std::vector<T> r;
94 [ + + ]: 7136 : for (size_t i = 0; i < n_elements; ++i) {
95 [ + - + - ]: 5827 : r.push_back(fuzzed_data_provider.ConsumeIntegral<T>());
96 : 5827 : }
97 : 1309 : return r;
98 [ + - ]: 1309 : }
99 : :
100 : : template <typename P>
101 : : [[nodiscard]] P ConsumeDeserializationParams(FuzzedDataProvider& fuzzed_data_provider) noexcept;
102 : :
103 : : template <typename T, typename P>
104 : 305 : [[nodiscard]] std::optional<T> ConsumeDeserializable(FuzzedDataProvider& fuzzed_data_provider, const P& params, const std::optional<size_t>& max_length = std::nullopt) noexcept
105 : : {
106 : 305 : const std::vector<uint8_t> buffer{ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length)};
107 [ + - + - : 305 : DataStream ds{buffer};
+ - + - +
- + - + -
+ - ]
108 [ + - + - : 305 : T obj;
+ - + - ]
109 : : try {
110 [ + - + + : 305 : ds >> WithParams(params, obj);
+ - + + +
- + + + -
+ + ]
111 [ + - + - : 305 : } catch (const std::ios_base::failure&) {
+ - + - ]
112 : 175 : return std::nullopt;
113 [ + - + - : 175 : }
+ - + - ]
114 [ + - + - : 130 : return obj;
+ - + - ]
115 : 480 : }
116 : :
117 : : template <typename T>
118 : 1021785 : [[nodiscard]] inline std::optional<T> ConsumeDeserializable(FuzzedDataProvider& fuzzed_data_provider, const std::optional<size_t>& max_length = std::nullopt) noexcept
119 : : {
120 : 1021785 : const std::vector<uint8_t> buffer = ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length);
121 [ + - + - : 1021785 : CDataStream ds{buffer, SER_NETWORK, INIT_PROTO_VERSION};
+ - + - +
- + - + -
+ - # # #
# # # #
# ]
122 [ + - + - : 1021785 : T obj;
+ - + - #
# ]
123 : : try {
124 [ + + + + : 1021785 : ds >> obj;
+ + + + #
# # # ]
125 [ + - + - : 1021785 : } catch (const std::ios_base::failure&) {
+ - + - #
# # # ]
126 : 515652 : return std::nullopt;
127 [ + - + - : 515652 : }
+ - + - #
# # # ]
128 [ + - + - : 506133 : return obj;
+ - + - #
# # # ]
129 : 1537437 : }
130 : :
131 : : template <typename WeakEnumType, size_t size>
132 : 924076 : [[nodiscard]] WeakEnumType ConsumeWeakEnum(FuzzedDataProvider& fuzzed_data_provider, const WeakEnumType (&all_types)[size]) noexcept
133 : : {
134 [ + - + + ]: 1848152 : return fuzzed_data_provider.ConsumeBool() ?
135 [ + - ]: 905048 : fuzzed_data_provider.PickValueInArray<WeakEnumType>(all_types) :
136 [ + - ]: 19028 : WeakEnumType(fuzzed_data_provider.ConsumeIntegral<typename std::underlying_type<WeakEnumType>::type>());
137 : : }
138 : :
139 : 310603 : [[nodiscard]] inline opcodetype ConsumeOpcodeType(FuzzedDataProvider& fuzzed_data_provider) noexcept
140 : : {
141 [ + - ]: 310603 : return static_cast<opcodetype>(fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(0, MAX_OPCODE));
142 : : }
143 : :
144 : : [[nodiscard]] CAmount ConsumeMoney(FuzzedDataProvider& fuzzed_data_provider, const std::optional<CAmount>& max = std::nullopt) noexcept;
145 : :
146 : : [[nodiscard]] int64_t ConsumeTime(FuzzedDataProvider& fuzzed_data_provider, const std::optional<int64_t>& min = std::nullopt, const std::optional<int64_t>& max = std::nullopt) noexcept;
147 : :
148 : : [[nodiscard]] CMutableTransaction ConsumeTransaction(FuzzedDataProvider& fuzzed_data_provider, const std::optional<std::vector<uint256>>& prevout_txids, const int max_num_in = 10, const int max_num_out = 10) noexcept;
149 : :
150 : : [[nodiscard]] CScriptWitness ConsumeScriptWitness(FuzzedDataProvider& fuzzed_data_provider, const size_t max_stack_elem_size = 32) noexcept;
151 : :
152 : : [[nodiscard]] CScript ConsumeScript(FuzzedDataProvider& fuzzed_data_provider, const bool maybe_p2wsh = false) noexcept;
153 : :
154 : : [[nodiscard]] uint32_t ConsumeSequence(FuzzedDataProvider& fuzzed_data_provider) noexcept;
155 : :
156 : 356642 : [[nodiscard]] inline CScriptNum ConsumeScriptNum(FuzzedDataProvider& fuzzed_data_provider) noexcept
157 : : {
158 [ + - + - ]: 356642 : return CScriptNum{fuzzed_data_provider.ConsumeIntegral<int64_t>()};
159 : : }
160 : :
161 : 872 : [[nodiscard]] inline uint160 ConsumeUInt160(FuzzedDataProvider& fuzzed_data_provider) noexcept
162 : : {
163 [ + - ]: 872 : const std::vector<uint8_t> v160 = fuzzed_data_provider.ConsumeBytes<uint8_t>(160 / 8);
164 [ + + ]: 872 : if (v160.size() != 160 / 8) {
165 [ + - ]: 36 : return {};
166 : : }
167 [ + - + - ]: 836 : return uint160{v160};
168 : 872 : }
169 : :
170 : 105166 : [[nodiscard]] inline uint256 ConsumeUInt256(FuzzedDataProvider& fuzzed_data_provider) noexcept
171 : : {
172 [ + - ]: 105166 : const std::vector<uint8_t> v256 = fuzzed_data_provider.ConsumeBytes<uint8_t>(256 / 8);
173 [ + + ]: 105166 : if (v256.size() != 256 / 8) {
174 [ + - ]: 1073 : return {};
175 : : }
176 [ + - + - ]: 104093 : return uint256{v256};
177 : 105166 : }
178 : :
179 : 38660 : [[nodiscard]] inline arith_uint256 ConsumeArithUInt256(FuzzedDataProvider& fuzzed_data_provider) noexcept
180 : : {
181 [ + - ]: 38660 : return UintToArith256(ConsumeUInt256(fuzzed_data_provider));
182 : : }
183 : :
184 : : [[nodiscard]] CTxDestination ConsumeTxDestination(FuzzedDataProvider& fuzzed_data_provider) noexcept;
185 : :
186 : : [[nodiscard]] CKey ConsumePrivateKey(FuzzedDataProvider& fuzzed_data_provider, std::optional<bool> compressed = std::nullopt) noexcept;
187 : :
188 : : template <typename T>
189 : 625 : [[nodiscard]] bool MultiplicationOverflow(const T i, const T j) noexcept
190 : : {
191 : : static_assert(std::is_integral<T>::value, "Integral required.");
192 : : if (std::numeric_limits<T>::is_signed) {
193 [ + + + + : 381 : if (i > 0) {
+ + + + +
+ ]
194 [ + + + + : 66 : if (j > 0) {
+ + + + +
+ ]
195 : 32 : return i > (std::numeric_limits<T>::max() / j);
196 : : } else {
197 : 34 : return j < (std::numeric_limits<T>::min() / i);
198 : : }
199 : : } else {
200 [ + + + + : 315 : if (j > 0) {
+ + + + +
+ ]
201 : 64 : return i < (std::numeric_limits<T>::min() / j);
202 : : } else {
203 [ + + + + : 251 : return i != 0 && (j < (std::numeric_limits<T>::max() / i));
+ + + + +
+ ]
204 : : }
205 : : }
206 : : } else {
207 [ + + + + : 244 : return j != 0 && i > std::numeric_limits<T>::max() / j;
+ + + + ]
208 : : }
209 : 381 : }
210 : :
211 : : [[nodiscard]] bool ContainsSpentInput(const CTransaction& tx, const CCoinsViewCache& inputs) noexcept;
212 : :
213 : : /**
214 : : * Sets errno to a value selected from the given std::array `errnos`.
215 : : */
216 : : template <typename T, size_t size>
217 : 24702 : void SetFuzzedErrNo(FuzzedDataProvider& fuzzed_data_provider, const std::array<T, size>& errnos)
218 : : {
219 : 24702 : errno = fuzzed_data_provider.PickValueInArray(errnos);
220 : 24702 : }
221 : :
222 : : /*
223 : : * Sets a fuzzed errno in the range [0, 133 (EHWPOISON)]. Can be used from functions emulating
224 : : * standard library functions that set errno, or in other contexts where the value of errno
225 : : * might be relevant for the execution path that will be taken.
226 : : */
227 : 24853 : inline void SetFuzzedErrNo(FuzzedDataProvider& fuzzed_data_provider) noexcept
228 : : {
229 [ + - ]: 24853 : errno = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 133);
230 : 24853 : }
231 : :
232 : : /**
233 : : * Returns a byte vector of specified size regardless of the number of remaining bytes available
234 : : * from the fuzzer. Pads with zero value bytes if needed to achieve the specified size.
235 : : */
236 : : template<typename B = uint8_t>
237 : 8091 : [[nodiscard]] inline std::vector<B> ConsumeFixedLengthByteVector(FuzzedDataProvider& fuzzed_data_provider, const size_t length) noexcept
238 : : {
239 : : static_assert(sizeof(B) == 1);
240 [ + - ]: 8091 : auto random_bytes = fuzzed_data_provider.ConsumeBytes<B>(length);
241 [ + - ]: 8091 : random_bytes.resize(length);
242 : 8091 : return random_bytes;
243 [ + - ]: 8091 : }
244 : :
245 : : class FuzzedFileProvider
246 : : {
247 : : FuzzedDataProvider& m_fuzzed_data_provider;
248 : 2072 : int64_t m_offset = 0;
249 : :
250 : : public:
251 : 2072 : FuzzedFileProvider(FuzzedDataProvider& fuzzed_data_provider) : m_fuzzed_data_provider{fuzzed_data_provider}
252 : : {
253 : 2072 : }
254 : :
255 : : FILE* open();
256 : :
257 : : static ssize_t read(void* cookie, char* buf, size_t size);
258 : :
259 : : static ssize_t write(void* cookie, const char* buf, size_t size);
260 : :
261 : : static int seek(void* cookie, int64_t* offset, int whence);
262 : :
263 : : static int close(void* cookie);
264 : : };
265 : :
266 : 1135 : [[nodiscard]] inline FuzzedFileProvider ConsumeFile(FuzzedDataProvider& fuzzed_data_provider) noexcept
267 : : {
268 [ + - ]: 1135 : return {fuzzed_data_provider};
269 : : }
270 : :
271 : : class FuzzedAutoFileProvider
272 : : {
273 : : FuzzedFileProvider m_fuzzed_file_provider;
274 : :
275 : : public:
276 : 937 : FuzzedAutoFileProvider(FuzzedDataProvider& fuzzed_data_provider) : m_fuzzed_file_provider{fuzzed_data_provider}
277 : : {
278 : 937 : }
279 : :
280 : 937 : AutoFile open()
281 : : {
282 [ + - ]: 937 : return AutoFile{m_fuzzed_file_provider.open()};
283 : 0 : }
284 : : };
285 : :
286 : 937 : [[nodiscard]] inline FuzzedAutoFileProvider ConsumeAutoFile(FuzzedDataProvider& fuzzed_data_provider) noexcept
287 : : {
288 [ + - ]: 937 : return {fuzzed_data_provider};
289 : : }
290 : :
291 : : #define WRITE_TO_STREAM_CASE(type, consume) \
292 : : [&] { \
293 : : type o = consume; \
294 : : stream << o; \
295 : : }
296 : : template <typename Stream>
297 : 4436 : void WriteToStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept
298 : : {
299 [ + - + + ]: 14753 : while (fuzzed_data_provider.ConsumeBool()) {
300 : : try {
301 [ + + ]: 13037 : CallOneOf(
302 : 13037 : fuzzed_data_provider,
303 : 13387 : WRITE_TO_STREAM_CASE(bool, fuzzed_data_provider.ConsumeBool()),
304 : 14132 : WRITE_TO_STREAM_CASE(int8_t, fuzzed_data_provider.ConsumeIntegral<int8_t>()),
305 : 13576 : WRITE_TO_STREAM_CASE(uint8_t, fuzzed_data_provider.ConsumeIntegral<uint8_t>()),
306 : 16520 : WRITE_TO_STREAM_CASE(int16_t, fuzzed_data_provider.ConsumeIntegral<int16_t>()),
307 : 14255 : WRITE_TO_STREAM_CASE(uint16_t, fuzzed_data_provider.ConsumeIntegral<uint16_t>()),
308 : 13959 : WRITE_TO_STREAM_CASE(int32_t, fuzzed_data_provider.ConsumeIntegral<int32_t>()),
309 : 13282 : WRITE_TO_STREAM_CASE(uint32_t, fuzzed_data_provider.ConsumeIntegral<uint32_t>()),
310 : 15368 : WRITE_TO_STREAM_CASE(int64_t, fuzzed_data_provider.ConsumeIntegral<int64_t>()),
311 : 13425 : WRITE_TO_STREAM_CASE(uint64_t, fuzzed_data_provider.ConsumeIntegral<uint64_t>()),
312 [ + + ]: 14276 : WRITE_TO_STREAM_CASE(std::string, fuzzed_data_provider.ConsumeRandomLengthString(32)),
313 [ + + ]: 14264 : WRITE_TO_STREAM_CASE(std::vector<uint8_t>, ConsumeRandomLengthIntegralVector<uint8_t>(fuzzed_data_provider)));
314 [ + - ]: 13037 : } catch (const std::ios_base::failure&) {
315 : : break;
316 [ + - ]: 2720 : }
317 : : }
318 : 7156 : }
319 : :
320 : : #define READ_FROM_STREAM_CASE(type) \
321 : : [&] { \
322 : : type o; \
323 : : stream >> o; \
324 : : }
325 : : template <typename Stream>
326 : 29369 : void ReadFromStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept
327 : : {
328 [ + - + + ]: 58862 : while (fuzzed_data_provider.ConsumeBool()) {
329 : : try {
330 [ + + ]: 57074 : CallOneOf(
331 : 57074 : fuzzed_data_provider,
332 : 58955 : READ_FROM_STREAM_CASE(bool),
333 : 57792 : READ_FROM_STREAM_CASE(int8_t),
334 : 61704 : READ_FROM_STREAM_CASE(uint8_t),
335 : 58028 : READ_FROM_STREAM_CASE(int16_t),
336 : 57846 : READ_FROM_STREAM_CASE(uint16_t),
337 : 62024 : READ_FROM_STREAM_CASE(int32_t),
338 : 59621 : READ_FROM_STREAM_CASE(uint32_t),
339 : 84245 : READ_FROM_STREAM_CASE(int64_t),
340 : 58315 : READ_FROM_STREAM_CASE(uint64_t),
341 [ + + ]: 61451 : READ_FROM_STREAM_CASE(std::string),
342 [ + + ]: 64907 : READ_FROM_STREAM_CASE(std::vector<uint8_t>));
343 [ + - ]: 57074 : } catch (const std::ios_base::failure&) {
344 : : break;
345 [ + - ]: 27581 : }
346 : : }
347 : 56950 : }
348 : :
349 : : #endif // BITCOIN_TEST_FUZZ_UTIL_H
|
