integer.cpp
1 // Copyright (c) 2019-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 #include <arith_uint256.h> 6 #include <common/args.h> 7 #include <common/system.h> 8 #include <compressor.h> 9 #include <consensus/amount.h> 10 #include <consensus/merkle.h> 11 #include <core_io.h> 12 #include <crypto/common.h> 13 #include <crypto/siphash.h> 14 #include <key_io.h> 15 #include <memusage.h> 16 #include <netbase.h> 17 #include <policy/policy.h> 18 #include <policy/settings.h> 19 #include <pow.h> 20 #include <protocol.h> 21 #include <pubkey.h> 22 #include <script/script.h> 23 #include <serialize.h> 24 #include <streams.h> 25 #include <test/fuzz/FuzzedDataProvider.h> 26 #include <test/fuzz/fuzz.h> 27 #include <test/fuzz/util.h> 28 #include <uint256.h> 29 #include <univalue.h> 30 #include <util/chaintype.h> 31 #include <util/check.h> 32 #include <util/moneystr.h> 33 #include <util/overflow.h> 34 #include <util/strencodings.h> 35 #include <util/string.h> 36 37 #include <cassert> 38 #include <chrono> 39 #include <limits> 40 #include <set> 41 #include <vector> 42 43 void initialize_integer() 44 { 45 SelectParams(ChainType::REGTEST); 46 } 47 48 FUZZ_TARGET(integer, .init = initialize_integer) 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)DecompressAmount(u64); 84 { 85 if (std::optional<CAmount> parsed = ParseMoney(FormatMoney(i64))) { 86 assert(parsed.value() == i64); 87 } 88 } 89 (void)GetSizeOfCompactSize(u64); 90 (void)GetSpecialScriptSize(u32); 91 if (!MultiplicationOverflow(i64, static_cast<int64_t>(u32)) && !AdditionOverflow(i64, static_cast<int64_t>(4)) && !AdditionOverflow(i64 * u32, static_cast<int64_t>(4))) { 92 (void)GetVirtualTransactionSize(i64, i64, u32); 93 } 94 (void)HexDigit(ch); 95 (void)MoneyRange(i64); 96 (void)ToString(i64); 97 (void)IsDigit(ch); 98 (void)IsSpace(ch); 99 (void)IsSwitchChar(ch); 100 (void)memusage::DynamicUsage(ch); 101 (void)memusage::DynamicUsage(i16); 102 (void)memusage::DynamicUsage(i32); 103 (void)memusage::DynamicUsage(i64); 104 (void)memusage::DynamicUsage(i8); 105 (void)memusage::DynamicUsage(u16); 106 (void)memusage::DynamicUsage(u32); 107 (void)memusage::DynamicUsage(u64); 108 (void)memusage::DynamicUsage(u8); 109 const unsigned char uch = static_cast<unsigned char>(u8); 110 (void)memusage::DynamicUsage(uch); 111 { 112 const std::set<int64_t> i64s{i64, static_cast<int64_t>(u64)}; 113 const size_t dynamic_usage = memusage::DynamicUsage(i64s); 114 const size_t incremental_dynamic_usage = memusage::IncrementalDynamicUsage(i64s); 115 assert(dynamic_usage == incremental_dynamic_usage * i64s.size()); 116 } 117 (void)MillisToTimeval(i64); 118 (void)SighashToStr(uch); 119 (void)SipHashUint256(u64, u64, u256); 120 (void)SipHashUint256Extra(u64, u64, u256, u32); 121 (void)ToLower(ch); 122 (void)ToUpper(ch); 123 { 124 if (std::optional<CAmount> parsed = ParseMoney(ValueFromAmount(i64).getValStr())) { 125 assert(parsed.value() == i64); 126 } 127 } 128 if (i32 >= 0 && i32 <= 16) { 129 assert(i32 == CScript::DecodeOP_N(CScript::EncodeOP_N(i32))); 130 } 131 132 const std::chrono::seconds seconds{i64}; 133 assert(count_seconds(seconds) == i64); 134 135 const CScriptNum script_num{i64}; 136 (void)script_num.getint(); 137 (void)script_num.getvch(); 138 139 const arith_uint256 au256 = UintToArith256(u256); 140 assert(ArithToUint256(au256) == u256); 141 assert(uint256S(au256.GetHex()) == u256); 142 (void)au256.bits(); 143 (void)au256.GetCompact(/* fNegative= */ false); 144 (void)au256.GetCompact(/* fNegative= */ true); 145 (void)au256.getdouble(); 146 (void)au256.GetHex(); 147 (void)au256.GetLow64(); 148 (void)au256.size(); 149 (void)au256.ToString(); 150 151 const CKeyID key_id{u160}; 152 const CScriptID script_id{u160}; 153 154 { 155 DataStream stream{}; 156 157 uint256 deserialized_u256; 158 stream << u256; 159 stream >> deserialized_u256; 160 assert(u256 == deserialized_u256 && stream.empty()); 161 162 uint160 deserialized_u160; 163 stream << u160; 164 stream >> deserialized_u160; 165 assert(u160 == deserialized_u160 && stream.empty()); 166 167 uint64_t deserialized_u64; 168 stream << u64; 169 stream >> deserialized_u64; 170 assert(u64 == deserialized_u64 && stream.empty()); 171 172 int64_t deserialized_i64; 173 stream << i64; 174 stream >> deserialized_i64; 175 assert(i64 == deserialized_i64 && stream.empty()); 176 177 uint32_t deserialized_u32; 178 stream << u32; 179 stream >> deserialized_u32; 180 assert(u32 == deserialized_u32 && stream.empty()); 181 182 int32_t deserialized_i32; 183 stream << i32; 184 stream >> deserialized_i32; 185 assert(i32 == deserialized_i32 && stream.empty()); 186 187 uint16_t deserialized_u16; 188 stream << u16; 189 stream >> deserialized_u16; 190 assert(u16 == deserialized_u16 && stream.empty()); 191 192 int16_t deserialized_i16; 193 stream << i16; 194 stream >> deserialized_i16; 195 assert(i16 == deserialized_i16 && stream.empty()); 196 197 uint8_t deserialized_u8; 198 stream << u8; 199 stream >> deserialized_u8; 200 assert(u8 == deserialized_u8 && stream.empty()); 201 202 int8_t deserialized_i8; 203 stream << i8; 204 stream >> deserialized_i8; 205 assert(i8 == deserialized_i8 && stream.empty()); 206 207 bool deserialized_b; 208 stream << b; 209 stream >> deserialized_b; 210 assert(b == deserialized_b && stream.empty()); 211 } 212 213 { 214 const ServiceFlags service_flags = (ServiceFlags)u64; 215 (void)MayHaveUsefulAddressDB(service_flags); 216 } 217 218 { 219 DataStream stream{}; 220 221 ser_writedata64(stream, u64); 222 const uint64_t deserialized_u64 = ser_readdata64(stream); 223 assert(u64 == deserialized_u64 && stream.empty()); 224 225 ser_writedata32(stream, u32); 226 const uint32_t deserialized_u32 = ser_readdata32(stream); 227 assert(u32 == deserialized_u32 && stream.empty()); 228 229 ser_writedata32be(stream, u32); 230 const uint32_t deserialized_u32be = ser_readdata32be(stream); 231 assert(u32 == deserialized_u32be && stream.empty()); 232 233 ser_writedata16(stream, u16); 234 const uint16_t deserialized_u16 = ser_readdata16(stream); 235 assert(u16 == deserialized_u16 && stream.empty()); 236 237 ser_writedata16be(stream, u16); 238 const uint16_t deserialized_u16be = ser_readdata16be(stream); 239 assert(u16 == deserialized_u16be && stream.empty()); 240 241 ser_writedata8(stream, u8); 242 const uint8_t deserialized_u8 = ser_readdata8(stream); 243 assert(u8 == deserialized_u8 && stream.empty()); 244 } 245 246 { 247 DataStream stream{}; 248 249 WriteCompactSize(stream, u64); 250 try { 251 const uint64_t deserialized_u64 = ReadCompactSize(stream); 252 assert(u64 == deserialized_u64 && stream.empty()); 253 } catch (const std::ios_base::failure&) { 254 } 255 } 256 257 try { 258 CHECK_NONFATAL(b); 259 } catch (const NonFatalCheckError&) { 260 } 261 }