1 // Copyright (c) 2019-2020 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 <amount.h>
6 #include <arith_uint256.h>
7 #include <compressor.h>
8 #include <consensus/merkle.h>
9 #include <core_io.h>
10 #include <crypto/common.h>
11 #include <crypto/siphash.h>
12 #include <key_io.h>
13 #include <memusage.h>
14 #include <netbase.h>
15 #include <policy/settings.h>
16 #include <pow.h>
17 #include <protocol.h>
18 #include <pubkey.h>
19 #include <rpc/util.h>
20 #include <script/signingprovider.h>
21 #include <script/standard.h>
22 #include <serialize.h>
23 #include <streams.h>
24 #include <test/fuzz/FuzzedDataProvider.h>
25 #include <test/fuzz/fuzz.h>
26 #include <test/fuzz/util.h>
27 #include <uint256.h>
28 #include <util/check.h>
29 #include <util/moneystr.h>
30 #include <util/strencodings.h>
31 #include <util/string.h>
32 #include <util/system.h>
33 #include <util/time.h>
34 #include <version.h>
35
36 #include <cassert>
37 #include <chrono>
38 #include <ctime>
39 #include <limits>
40 #include <set>
41 #include <vector>
42
initialize()43 void initialize()
44 {
45 SelectParams(CBaseChainParams::REGTEST);
46 }
47
test_one_input(const std::vector<uint8_t> & buffer)48 void test_one_input(const std::vector<uint8_t>& buffer)
49 {
50 if (buffer.size() < sizeof(uint256) + sizeof(uint160)) {
51 return;
52 }
53 FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
54 const uint256 u256(fuzzed_data_provider.ConsumeBytes<unsigned char>(sizeof(uint256)));
55 const uint160 u160(fuzzed_data_provider.ConsumeBytes<unsigned char>(sizeof(uint160)));
56 const uint64_t u64 = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
57 const int64_t i64 = fuzzed_data_provider.ConsumeIntegral<int64_t>();
58 const uint32_t u32 = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
59 const int32_t i32 = fuzzed_data_provider.ConsumeIntegral<int32_t>();
60 const uint16_t u16 = fuzzed_data_provider.ConsumeIntegral<uint16_t>();
61 const int16_t i16 = fuzzed_data_provider.ConsumeIntegral<int16_t>();
62 const uint8_t u8 = fuzzed_data_provider.ConsumeIntegral<uint8_t>();
63 const int8_t i8 = fuzzed_data_provider.ConsumeIntegral<int8_t>();
64 // We cannot assume a specific value of std::is_signed<char>::value:
65 // ConsumeIntegral<char>() instead of casting from {u,}int8_t.
66 const char ch = fuzzed_data_provider.ConsumeIntegral<char>();
67 const bool b = fuzzed_data_provider.ConsumeBool();
68
69 const Consensus::Params& consensus_params = Params().GetConsensus();
70 (void)CheckProofOfWork(u256, u32, consensus_params);
71 if (u64 <= MAX_MONEY) {
72 const uint64_t compressed_money_amount = CompressAmount(u64);
73 assert(u64 == DecompressAmount(compressed_money_amount));
74 static const uint64_t compressed_money_amount_max = CompressAmount(MAX_MONEY - 1);
75 assert(compressed_money_amount <= compressed_money_amount_max);
76 } else {
77 (void)CompressAmount(u64);
78 }
79 static const uint256 u256_min(uint256S("0000000000000000000000000000000000000000000000000000000000000000"));
80 static const uint256 u256_max(uint256S("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
81 const std::vector<uint256> v256{u256, u256_min, u256_max};
82 (void)ComputeMerkleRoot(v256);
83 (void)CountBits(u64);
84 (void)DecompressAmount(u64);
85 (void)FormatISO8601Date(i64);
86 (void)FormatISO8601DateTime(i64);
87 // FormatMoney(i) not defined when i == std::numeric_limits<int64_t>::min()
88 if (i64 != std::numeric_limits<int64_t>::min()) {
89 int64_t parsed_money;
90 if (ParseMoney(FormatMoney(i64), parsed_money)) {
91 assert(parsed_money == i64);
92 }
93 }
94 (void)GetSizeOfCompactSize(u64);
95 (void)GetSpecialScriptSize(u32);
96 if (!MultiplicationOverflow(i64, static_cast<int64_t>(::nBytesPerSigOp)) && !AdditionOverflow(i64 * ::nBytesPerSigOp, static_cast<int64_t>(4))) {
97 (void)GetVirtualTransactionSize(i64, i64);
98 }
99 if (!MultiplicationOverflow(i64, static_cast<int64_t>(u32)) && !AdditionOverflow(i64, static_cast<int64_t>(4)) && !AdditionOverflow(i64 * u32, static_cast<int64_t>(4))) {
100 (void)GetVirtualTransactionSize(i64, i64, u32);
101 }
102 (void)HexDigit(ch);
103 (void)MoneyRange(i64);
104 (void)ToString(i64);
105 (void)IsDigit(ch);
106 (void)IsSpace(ch);
107 (void)IsSwitchChar(ch);
108 (void)memusage::DynamicUsage(ch);
109 (void)memusage::DynamicUsage(i16);
110 (void)memusage::DynamicUsage(i32);
111 (void)memusage::DynamicUsage(i64);
112 (void)memusage::DynamicUsage(i8);
113 (void)memusage::DynamicUsage(u16);
114 (void)memusage::DynamicUsage(u32);
115 (void)memusage::DynamicUsage(u64);
116 (void)memusage::DynamicUsage(u8);
117 const unsigned char uch = static_cast<unsigned char>(u8);
118 (void)memusage::DynamicUsage(uch);
119 {
120 const std::set<int64_t> i64s{i64, static_cast<int64_t>(u64)};
121 const size_t dynamic_usage = memusage::DynamicUsage(i64s);
122 const size_t incremental_dynamic_usage = memusage::IncrementalDynamicUsage(i64s);
123 assert(dynamic_usage == incremental_dynamic_usage * i64s.size());
124 }
125 (void)MillisToTimeval(i64);
126 const double d = ser_uint64_to_double(u64);
127 assert(ser_double_to_uint64(d) == u64);
128 const float f = ser_uint32_to_float(u32);
129 assert(ser_float_to_uint32(f) == u32);
130 (void)SighashToStr(uch);
131 (void)SipHashUint256(u64, u64, u256);
132 (void)SipHashUint256Extra(u64, u64, u256, u32);
133 (void)ToLower(ch);
134 (void)ToUpper(ch);
135 // ValueFromAmount(i) not defined when i == std::numeric_limits<int64_t>::min()
136 if (i64 != std::numeric_limits<int64_t>::min()) {
137 int64_t parsed_money;
138 if (ParseMoney(ValueFromAmount(i64).getValStr(), parsed_money)) {
139 assert(parsed_money == i64);
140 }
141 }
142 if (i32 >= 0 && i32 <= 16) {
143 assert(i32 == CScript::DecodeOP_N(CScript::EncodeOP_N(i32)));
144 }
145
146 const std::chrono::seconds seconds{i64};
147 assert(count_seconds(seconds) == i64);
148
149 const CScriptNum script_num{i64};
150 (void)script_num.getint();
151 (void)script_num.getvch();
152
153 const arith_uint256 au256 = UintToArith256(u256);
154 assert(ArithToUint256(au256) == u256);
155 assert(uint256S(au256.GetHex()) == u256);
156 (void)au256.bits();
157 (void)au256.GetCompact(/* fNegative= */ false);
158 (void)au256.GetCompact(/* fNegative= */ true);
159 (void)au256.getdouble();
160 (void)au256.GetHex();
161 (void)au256.GetLow64();
162 (void)au256.size();
163 (void)au256.ToString();
164
165 const CKeyID key_id{u160};
166 const CScriptID script_id{u160};
167 // CTxDestination = CNoDestination ∪ PKHash ∪ ScriptHash ∪ WitnessV0ScriptHash ∪ WitnessV0KeyHash ∪ WitnessUnknown
168 const PKHash pk_hash{u160};
169 const ScriptHash script_hash{u160};
170 const WitnessV0KeyHash witness_v0_key_hash{u160};
171 const WitnessV0ScriptHash witness_v0_script_hash{u256};
172 const std::vector<CTxDestination> destinations{pk_hash, script_hash, witness_v0_key_hash, witness_v0_script_hash};
173 const SigningProvider store;
174 for (const CTxDestination& destination : destinations) {
175 (void)DescribeAddress(destination);
176 (void)EncodeDestination(destination);
177 (void)GetKeyForDestination(store, destination);
178 (void)GetScriptForDestination(destination);
179 (void)IsValidDestination(destination);
180 }
181
182 {
183 CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION);
184
185 uint256 deserialized_u256;
186 stream << u256;
187 stream >> deserialized_u256;
188 assert(u256 == deserialized_u256 && stream.empty());
189
190 uint160 deserialized_u160;
191 stream << u160;
192 stream >> deserialized_u160;
193 assert(u160 == deserialized_u160 && stream.empty());
194
195 uint64_t deserialized_u64;
196 stream << u64;
197 stream >> deserialized_u64;
198 assert(u64 == deserialized_u64 && stream.empty());
199
200 int64_t deserialized_i64;
201 stream << i64;
202 stream >> deserialized_i64;
203 assert(i64 == deserialized_i64 && stream.empty());
204
205 uint32_t deserialized_u32;
206 stream << u32;
207 stream >> deserialized_u32;
208 assert(u32 == deserialized_u32 && stream.empty());
209
210 int32_t deserialized_i32;
211 stream << i32;
212 stream >> deserialized_i32;
213 assert(i32 == deserialized_i32 && stream.empty());
214
215 uint16_t deserialized_u16;
216 stream << u16;
217 stream >> deserialized_u16;
218 assert(u16 == deserialized_u16 && stream.empty());
219
220 int16_t deserialized_i16;
221 stream << i16;
222 stream >> deserialized_i16;
223 assert(i16 == deserialized_i16 && stream.empty());
224
225 uint8_t deserialized_u8;
226 stream << u8;
227 stream >> deserialized_u8;
228 assert(u8 == deserialized_u8 && stream.empty());
229
230 int8_t deserialized_i8;
231 stream << i8;
232 stream >> deserialized_i8;
233 assert(i8 == deserialized_i8 && stream.empty());
234
235 char deserialized_ch;
236 stream << ch;
237 stream >> deserialized_ch;
238 assert(ch == deserialized_ch && stream.empty());
239
240 bool deserialized_b;
241 stream << b;
242 stream >> deserialized_b;
243 assert(b == deserialized_b && stream.empty());
244 }
245
246 {
247 const ServiceFlags service_flags = (ServiceFlags)u64;
248 (void)HasAllDesirableServiceFlags(service_flags);
249 (void)MayHaveUsefulAddressDB(service_flags);
250 }
251
252 {
253 CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION);
254
255 ser_writedata64(stream, u64);
256 const uint64_t deserialized_u64 = ser_readdata64(stream);
257 assert(u64 == deserialized_u64 && stream.empty());
258
259 ser_writedata32(stream, u32);
260 const uint32_t deserialized_u32 = ser_readdata32(stream);
261 assert(u32 == deserialized_u32 && stream.empty());
262
263 ser_writedata32be(stream, u32);
264 const uint32_t deserialized_u32be = ser_readdata32be(stream);
265 assert(u32 == deserialized_u32be && stream.empty());
266
267 ser_writedata16(stream, u16);
268 const uint16_t deserialized_u16 = ser_readdata16(stream);
269 assert(u16 == deserialized_u16 && stream.empty());
270
271 ser_writedata16be(stream, u16);
272 const uint16_t deserialized_u16be = ser_readdata16be(stream);
273 assert(u16 == deserialized_u16be && stream.empty());
274
275 ser_writedata8(stream, u8);
276 const uint8_t deserialized_u8 = ser_readdata8(stream);
277 assert(u8 == deserialized_u8 && stream.empty());
278 }
279
280 {
281 CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION);
282
283 WriteCompactSize(stream, u64);
284 try {
285 const uint64_t deserialized_u64 = ReadCompactSize(stream);
286 assert(u64 == deserialized_u64 && stream.empty());
287 } catch (const std::ios_base::failure&) {
288 }
289 }
290
291 try {
292 CHECK_NONFATAL(b);
293 } catch (const NonFatalCheckError&) {
294 }
295 }
296