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 : :
24 : : #include <algorithm>
25 : : #include <array>
26 : : #include <cstdint>
27 : : #include <cstdio>
28 : : #include <optional>
29 : : #include <string>
30 : : #include <vector>
31 : :
32 : : class PeerManager;
33 : :
34 : : template <typename... Callables>
35 : 19792306 : size_t CallOneOf(FuzzedDataProvider& fuzzed_data_provider, Callables... callables)
36 : : {
37 : 19792306 : constexpr size_t call_size{sizeof...(callables)};
38 : : static_assert(call_size >= 1);
39 : 19792306 : const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
40 : :
41 : : size_t i{0};
42 [ + + + + : 20339530 : ((i++ == call_index ? callables() : void()), ...);
+ + + + +
+ + + + +
+ + + + ]
[ + + + +
+ + + + +
+ + + +
+ ][ + + +
+ + + + +
+ + ][ + +
+ + + + +
+ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ][ +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + ]
[ + + + +
+ + # # #
# # # #
# ][ + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + ]
[ + + + +
+ + + + +
+ + + + +
+ + + + +
+ # # #
# ][ + + +
+ + + + +
+ + + + #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ + + + +
+ + + + +
+ + + + +
+ + ][ + +
+ + # # #
# # # # #
# # # # #
# # # ][ +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + # #
# # # # #
# # # ][ +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + ][ +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ ]
43 : 19785466 : return call_size;
44 : : }
45 : :
46 : : template <typename Collection>
47 [ - + ]: 2694846 : auto& PickValue(FuzzedDataProvider& fuzzed_data_provider, Collection& col)
48 : : {
49 : 2694846 : auto sz{col.size()};
50 [ - + ]: 2678501 : assert(sz >= 1);
51 : 2694846 : auto it = col.begin();
52 : 2694846 : std::advance(it, fuzzed_data_provider.ConsumeIntegralInRange<decltype(sz)>(0, sz - 1));
53 : 2694846 : return *it;
54 : : }
55 : :
56 : : template<typename B = uint8_t>
57 [ + + ]: 2022700 : [[nodiscard]] inline std::vector<B> ConsumeRandomLengthByteVector(FuzzedDataProvider& fuzzed_data_provider, const std::optional<size_t>& max_length = std::nullopt) noexcept
58 : : {
59 : : static_assert(sizeof(B) == 1);
60 [ + + ]: 2022700 : const std::string s = max_length ?
61 : 265191 : fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
62 : : fuzzed_data_provider.ConsumeRandomLengthString();
63 : 2022700 : std::vector<B> ret(s.size());
64 : 2022700 : std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
65 : 2022700 : return ret;
66 : 2022700 : }
67 : :
68 : 7255 : [[nodiscard]] inline std::vector<bool> ConsumeRandomLengthBitVector(FuzzedDataProvider& fuzzed_data_provider, const std::optional<size_t>& max_length = std::nullopt) noexcept
69 : : {
70 : 7255 : return BytesToBits(ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length));
71 : : }
72 : :
73 : 4925 : [[nodiscard]] inline DataStream ConsumeDataStream(FuzzedDataProvider& fuzzed_data_provider, const std::optional<size_t>& max_length = std::nullopt) noexcept
74 : : {
75 : 4925 : return DataStream{ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length)};
76 : : }
77 : :
78 : 227438 : [[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
79 : : {
80 : 227438 : const size_t n_elements = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, max_vector_size);
81 : 227438 : std::vector<std::string> r;
82 : 227438 : r.reserve(n_elements);
83 [ + + ]: 1472632 : for (size_t i = 0; i < n_elements; ++i) {
84 : 1245194 : r.push_back(fuzzed_data_provider.ConsumeRandomLengthString(max_string_length));
85 : : }
86 : 227438 : return r;
87 : : }
88 : :
89 : : template <typename T>
90 : 1352 : [[nodiscard]] inline std::vector<T> ConsumeRandomLengthIntegralVector(FuzzedDataProvider& fuzzed_data_provider, const size_t max_vector_size = 16) noexcept
91 : : {
92 : 1352 : const size_t n_elements = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, max_vector_size);
93 : 1352 : std::vector<T> r;
94 : 1352 : r.reserve(n_elements);
95 [ + + ]: 7251 : for (size_t i = 0; i < n_elements; ++i) {
96 : 5899 : r.push_back(fuzzed_data_provider.ConsumeIntegral<T>());
97 : : }
98 : 1352 : return r;
99 : : }
100 : :
101 : : template <typename P>
102 : : [[nodiscard]] P ConsumeDeserializationParams(FuzzedDataProvider& fuzzed_data_provider) noexcept;
103 : :
104 : : template <typename T, typename P>
105 : 228454 : [[nodiscard]] std::optional<T> ConsumeDeserializable(FuzzedDataProvider& fuzzed_data_provider, const P& params, const std::optional<size_t>& max_length = std::nullopt) noexcept
106 : : {
107 : 228454 : const std::vector<uint8_t> buffer{ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length)};
108 : 228454 : DataStream ds{buffer};
109 [ + + ]: 228454 : T obj;
110 : : try {
111 [ + + ]: 451974 : ds >> params(obj);
112 [ - + ]: 4934 : } catch (const std::ios_base::failure&) {
113 : 4934 : return std::nullopt;
114 : : }
115 : 223520 : return obj;
116 : 228454 : }
117 : :
118 : : template <typename T>
119 : 710160 : [[nodiscard]] inline std::optional<T> ConsumeDeserializable(FuzzedDataProvider& fuzzed_data_provider, const std::optional<size_t>& max_length = std::nullopt) noexcept
120 : : {
121 : 710160 : const std::vector<uint8_t> buffer = ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length);
122 [ + + ]: 710160 : DataStream ds{buffer};
123 [ + + ]: 710160 : T obj;
124 : : try {
125 : 522879 : ds >> obj;
126 [ - + ]: 187281 : } catch (const std::ios_base::failure&) {
127 : 187281 : return std::nullopt;
128 : : }
129 : 522879 : return obj;
130 : 710160 : }
131 : :
132 : : template <typename WeakEnumType, size_t size>
133 : 2557254 : [[nodiscard]] WeakEnumType ConsumeWeakEnum(FuzzedDataProvider& fuzzed_data_provider, const WeakEnumType (&all_types)[size]) noexcept
134 : : {
135 [ + + ]: 2557254 : return fuzzed_data_provider.ConsumeBool() ?
136 : 2498357 : fuzzed_data_provider.PickValueInArray<WeakEnumType>(all_types) :
137 : 58897 : WeakEnumType(fuzzed_data_provider.ConsumeIntegral<typename std::underlying_type<WeakEnumType>::type>());
138 : : }
139 : :
140 : 307729 : [[nodiscard]] inline opcodetype ConsumeOpcodeType(FuzzedDataProvider& fuzzed_data_provider) noexcept
141 : : {
142 : 308702 : return static_cast<opcodetype>(fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(0, MAX_OPCODE));
143 : : }
144 : :
145 : : [[nodiscard]] CAmount ConsumeMoney(FuzzedDataProvider& fuzzed_data_provider, const std::optional<CAmount>& max = std::nullopt) noexcept;
146 : :
147 : : [[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;
148 : :
149 : : [[nodiscard]] CMutableTransaction ConsumeTransaction(FuzzedDataProvider& fuzzed_data_provider, const std::optional<std::vector<Txid>>& prevout_txids, const int max_num_in = 10, const int max_num_out = 10) noexcept;
150 : :
151 : : [[nodiscard]] CScriptWitness ConsumeScriptWitness(FuzzedDataProvider& fuzzed_data_provider, const size_t max_stack_elem_size = 32) noexcept;
152 : :
153 : : [[nodiscard]] CScript ConsumeScript(FuzzedDataProvider& fuzzed_data_provider, const bool maybe_p2wsh = false) noexcept;
154 : :
155 : : [[nodiscard]] uint32_t ConsumeSequence(FuzzedDataProvider& fuzzed_data_provider) noexcept;
156 : :
157 : 304657 : [[nodiscard]] inline CScriptNum ConsumeScriptNum(FuzzedDataProvider& fuzzed_data_provider) noexcept
158 : : {
159 [ + + + + : 304657 : return CScriptNum{fuzzed_data_provider.ConsumeIntegral<int64_t>()};
- + ]
160 : : }
161 : :
162 : 12984 : [[nodiscard]] inline uint160 ConsumeUInt160(FuzzedDataProvider& fuzzed_data_provider) noexcept
163 : : {
164 : 12984 : const std::vector<uint8_t> v160 = fuzzed_data_provider.ConsumeBytes<uint8_t>(160 / 8);
165 [ + + ]: 12984 : if (v160.size() != 160 / 8) {
166 : 1875 : return {};
167 : : }
168 : 22218 : return uint160{v160};
169 : 12984 : }
170 : :
171 : 122633 : [[nodiscard]] inline uint256 ConsumeUInt256(FuzzedDataProvider& fuzzed_data_provider) noexcept
172 : : {
173 : 122633 : const std::vector<uint8_t> v256 = fuzzed_data_provider.ConsumeBytes<uint8_t>(256 / 8);
174 [ + + ]: 122633 : if (v256.size() != 256 / 8) {
175 : 4411 : return {};
176 : : }
177 : 118222 : return uint256{v256};
178 : 122633 : }
179 : :
180 : 49044 : [[nodiscard]] inline arith_uint256 ConsumeArithUInt256(FuzzedDataProvider& fuzzed_data_provider) noexcept
181 : : {
182 : 49044 : return UintToArith256(ConsumeUInt256(fuzzed_data_provider));
183 : : }
184 : :
185 : 3612 : [[nodiscard]] inline arith_uint256 ConsumeArithUInt256InRange(FuzzedDataProvider& fuzzed_data_provider, const arith_uint256& min, const arith_uint256& max) noexcept
186 : : {
187 [ - + ]: 3612 : assert(min <= max);
188 : 3612 : const arith_uint256 range = max - min;
189 : 3612 : const arith_uint256 value = ConsumeArithUInt256(fuzzed_data_provider);
190 : 3612 : arith_uint256 result = value;
191 : : // Avoid division by 0, in case range + 1 results in overflow.
192 [ + - ]: 7224 : if (range != ~arith_uint256(0)) {
193 : 7224 : const arith_uint256 quotient = value / (range + 1);
194 [ + - ]: 10836 : result = value - (quotient * (range + 1));
195 : : }
196 : 3612 : result += min;
197 [ + - - + ]: 3612 : assert(result >= min && result <= max);
198 : 3612 : return result;
199 : : }
200 : :
201 : : [[nodiscard]] std::map<COutPoint, Coin> ConsumeCoins(FuzzedDataProvider& fuzzed_data_provider) noexcept;
202 : :
203 : : [[nodiscard]] CTxDestination ConsumeTxDestination(FuzzedDataProvider& fuzzed_data_provider) noexcept;
204 : :
205 : : [[nodiscard]] CKey ConsumePrivateKey(FuzzedDataProvider& fuzzed_data_provider, std::optional<bool> compressed = std::nullopt) noexcept;
206 : :
207 : : template <typename T>
208 : 1106 : [[nodiscard]] bool MultiplicationOverflow(const T i, const T j) noexcept
209 : : {
210 : : static_assert(std::is_integral<T>::value, "Integral required.");
211 : : if (std::numeric_limits<T>::is_signed) {
212 [ + + ]: 698 : if (i > 0) {
213 [ + + ]: 159 : if (j > 0) {
214 : 89 : return i > (std::numeric_limits<T>::max() / j);
215 : : } else {
216 : 70 : return j < (std::numeric_limits<T>::min() / i);
217 : : }
218 : : } else {
219 [ + + ]: 539 : if (j > 0) {
220 : 103 : return i < (std::numeric_limits<T>::min() / j);
221 : : } else {
222 [ + + + + ]: 436 : return i != 0 && (j < (std::numeric_limits<T>::max() / i));
223 : : }
224 : : }
225 : : } else {
226 [ + + + + ]: 408 : return j != 0 && i > std::numeric_limits<T>::max() / j;
227 : : }
228 : : }
229 : :
230 : : [[nodiscard]] bool ContainsSpentInput(const CTransaction& tx, const CCoinsViewCache& inputs) noexcept;
231 : :
232 : : /**
233 : : * Sets errno to a value selected from the given std::array `errnos`.
234 : : */
235 : : template <typename T, size_t size>
236 : 10571 : void SetFuzzedErrNo(FuzzedDataProvider& fuzzed_data_provider, const std::array<T, size>& errnos)
237 : : {
238 : 10571 : errno = fuzzed_data_provider.PickValueInArray(errnos);
239 : 10571 : }
240 : :
241 : : /*
242 : : * Sets a fuzzed errno in the range [0, 133 (EHWPOISON)]. Can be used from functions emulating
243 : : * standard library functions that set errno, or in other contexts where the value of errno
244 : : * might be relevant for the execution path that will be taken.
245 : : */
246 : 36310 : inline void SetFuzzedErrNo(FuzzedDataProvider& fuzzed_data_provider) noexcept
247 : : {
248 : 36310 : errno = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 133);
249 : 36310 : }
250 : :
251 : : /**
252 : : * Returns a byte vector of specified size regardless of the number of remaining bytes available
253 : : * from the fuzzer. Pads with zero value bytes if needed to achieve the specified size.
254 : : */
255 : : template<typename B = uint8_t>
256 : 131425 : [[nodiscard]] inline std::vector<B> ConsumeFixedLengthByteVector(FuzzedDataProvider& fuzzed_data_provider, const size_t length) noexcept
257 : : {
258 : : static_assert(sizeof(B) == 1);
259 : 131425 : auto random_bytes = fuzzed_data_provider.ConsumeBytes<B>(length);
260 : 131425 : random_bytes.resize(length);
261 : 131425 : return random_bytes;
262 : : }
263 : :
264 : : class FuzzedFileProvider
265 : : {
266 : : FuzzedDataProvider& m_fuzzed_data_provider;
267 : : int64_t m_offset = 0;
268 : :
269 : : public:
270 [ + - ]: 4007 : FuzzedFileProvider(FuzzedDataProvider& fuzzed_data_provider) : m_fuzzed_data_provider{fuzzed_data_provider}
271 : : {
272 : : }
273 : :
274 : : FILE* open();
275 : :
276 : : static ssize_t read(void* cookie, char* buf, size_t size);
277 : :
278 : : static ssize_t write(void* cookie, const char* buf, size_t size);
279 : :
280 : : static int seek(void* cookie, int64_t* offset, int whence);
281 : :
282 : : static int close(void* cookie);
283 : : };
284 : :
285 : : #define WRITE_TO_STREAM_CASE(type, consume) \
286 : : [&] { \
287 : : type o = consume; \
288 : : stream << o; \
289 : : }
290 : : template <typename Stream>
291 : 1900 : void WriteToStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept
292 : : {
293 [ + + ]: 85134 : while (fuzzed_data_provider.ConsumeBool()) {
294 : : try {
295 [ + + ]: 84315 : CallOneOf(
296 : : fuzzed_data_provider,
297 : 3033 : WRITE_TO_STREAM_CASE(bool, fuzzed_data_provider.ConsumeBool()),
298 : 36952 : WRITE_TO_STREAM_CASE(int8_t, fuzzed_data_provider.ConsumeIntegral<int8_t>()),
299 : 1948 : WRITE_TO_STREAM_CASE(uint8_t, fuzzed_data_provider.ConsumeIntegral<uint8_t>()),
300 : 2629 : WRITE_TO_STREAM_CASE(int16_t, fuzzed_data_provider.ConsumeIntegral<int16_t>()),
301 : 710 : WRITE_TO_STREAM_CASE(uint16_t, fuzzed_data_provider.ConsumeIntegral<uint16_t>()),
302 : 2902 : WRITE_TO_STREAM_CASE(int32_t, fuzzed_data_provider.ConsumeIntegral<int32_t>()),
303 : 447 : WRITE_TO_STREAM_CASE(uint32_t, fuzzed_data_provider.ConsumeIntegral<uint32_t>()),
304 : 1290 : WRITE_TO_STREAM_CASE(int64_t, fuzzed_data_provider.ConsumeIntegral<int64_t>()),
305 : 2095 : WRITE_TO_STREAM_CASE(uint64_t, fuzzed_data_provider.ConsumeIntegral<uint64_t>()),
306 [ + + ]: 61997 : WRITE_TO_STREAM_CASE(std::string, fuzzed_data_provider.ConsumeRandomLengthString(32)),
307 [ + + ]: 1968 : WRITE_TO_STREAM_CASE(std::vector<uint8_t>, ConsumeRandomLengthIntegralVector<uint8_t>(fuzzed_data_provider)));
308 [ - + ]: 1081 : } catch (const std::ios_base::failure&) {
309 : : break;
310 : : }
311 : : }
312 : 1900 : }
313 : :
314 : : #define READ_FROM_STREAM_CASE(type) \
315 : : [&] { \
316 : : type o; \
317 : : stream >> o; \
318 : : }
319 : : template <typename Stream>
320 : 6504 : void ReadFromStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept
321 : : {
322 [ + + ]: 85634 : while (fuzzed_data_provider.ConsumeBool()) {
323 : : try {
324 [ + + ]: 84541 : CallOneOf(
325 : : fuzzed_data_provider,
326 : 918 : READ_FROM_STREAM_CASE(bool),
327 : 4796 : READ_FROM_STREAM_CASE(int8_t),
328 : 33342 : READ_FROM_STREAM_CASE(uint8_t),
329 : 2893 : READ_FROM_STREAM_CASE(int16_t),
330 : 5356 : READ_FROM_STREAM_CASE(uint16_t),
331 : 6293 : READ_FROM_STREAM_CASE(int32_t),
332 : 2384 : READ_FROM_STREAM_CASE(uint32_t),
333 : 6638 : READ_FROM_STREAM_CASE(int64_t),
334 : 1262 : READ_FROM_STREAM_CASE(uint64_t),
335 [ + + ]: 24647 : READ_FROM_STREAM_CASE(std::string),
336 [ + + ]: 12906 : READ_FROM_STREAM_CASE(std::vector<uint8_t>));
337 [ - + ]: 5411 : } catch (const std::ios_base::failure&) {
338 : : break;
339 : : }
340 : : }
341 : 6504 : }
342 : :
343 : : #endif // BITCOIN_TEST_FUZZ_UTIL_H
|
