_Z16htole32_internalj: 39| 1.24k|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 1.24k| else return host_32bits; 42| 1.24k|} _Z16le32toh_internalj: 49| 6.76M|{ 50| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits); 51| 6.76M| else return little_endian_32bits; 52| 6.76M|} _Z9WriteLE32ITk8ByteTypehEvPT_j: 51| 1.24k|{ 52| 1.24k| uint32_t v = htole32_internal(x); 53| 1.24k| memcpy(ptr, &v, 4); 54| 1.24k|} _Z8ReadLE32ITk8ByteTypehEjPKT_: 28| 6.76M|{ 29| 6.76M| uint32_t x; 30| 6.76M| memcpy(&x, ptr, 4); 31| 6.76M| return le32toh_internal(x); 32| 6.76M|} _ZN14poly1305_donna13poly1305_initEPNS_16poly1305_contextEPKh: 15| 310|void poly1305_init(poly1305_context *st, const unsigned char key[32]) noexcept { 16| | /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */ 17| 310| st->r[0] = (ReadLE32(&key[ 0]) ) & 0x3ffffff; 18| 310| st->r[1] = (ReadLE32(&key[ 3]) >> 2) & 0x3ffff03; 19| 310| st->r[2] = (ReadLE32(&key[ 6]) >> 4) & 0x3ffc0ff; 20| 310| st->r[3] = (ReadLE32(&key[ 9]) >> 6) & 0x3f03fff; 21| 310| st->r[4] = (ReadLE32(&key[12]) >> 8) & 0x00fffff; 22| | 23| | /* h = 0 */ 24| 310| st->h[0] = 0; 25| 310| st->h[1] = 0; 26| 310| st->h[2] = 0; 27| 310| st->h[3] = 0; 28| 310| st->h[4] = 0; 29| | 30| | /* save pad for later */ 31| 310| st->pad[0] = ReadLE32(&key[16]); 32| 310| st->pad[1] = ReadLE32(&key[20]); 33| 310| st->pad[2] = ReadLE32(&key[24]); 34| 310| st->pad[3] = ReadLE32(&key[28]); 35| | 36| 310| st->leftover = 0; 37| 310| st->final = 0; 38| 310|} _ZN14poly1305_donna15poly1305_finishEPNS_16poly1305_contextEPh: 100| 310|void poly1305_finish(poly1305_context *st, unsigned char mac[16]) noexcept { 101| 310| uint32_t h0,h1,h2,h3,h4,c; 102| 310| uint32_t g0,g1,g2,g3,g4; 103| 310| uint64_t f; 104| 310| uint32_t mask; 105| | 106| | /* process the remaining block */ 107| 310| if (st->leftover) { ------------------ | Branch (107:9): [True: 189, False: 121] ------------------ 108| 189| size_t i = st->leftover; 109| 189| st->buffer[i++] = 1; 110| 1.36k| for (; i < POLY1305_BLOCK_SIZE; i++) { ------------------ | | 14| 1.36k|#define POLY1305_BLOCK_SIZE 16 ------------------ | Branch (110:16): [True: 1.17k, False: 189] ------------------ 111| 1.17k| st->buffer[i] = 0; 112| 1.17k| } 113| 189| st->final = 1; 114| 189| poly1305_blocks(st, st->buffer, POLY1305_BLOCK_SIZE); ------------------ | | 14| 189|#define POLY1305_BLOCK_SIZE 16 ------------------ 115| 189| } 116| | 117| | /* fully carry h */ 118| 310| h0 = st->h[0]; 119| 310| h1 = st->h[1]; 120| 310| h2 = st->h[2]; 121| 310| h3 = st->h[3]; 122| 310| h4 = st->h[4]; 123| | 124| 310| c = h1 >> 26; h1 = h1 & 0x3ffffff; 125| 310| h2 += c; c = h2 >> 26; h2 = h2 & 0x3ffffff; 126| 310| h3 += c; c = h3 >> 26; h3 = h3 & 0x3ffffff; 127| 310| h4 += c; c = h4 >> 26; h4 = h4 & 0x3ffffff; 128| 310| h0 += c * 5; c = h0 >> 26; h0 = h0 & 0x3ffffff; 129| 310| h1 += c; 130| | 131| | /* compute h + -p */ 132| 310| g0 = h0 + 5; c = g0 >> 26; g0 &= 0x3ffffff; 133| 310| g1 = h1 + c; c = g1 >> 26; g1 &= 0x3ffffff; 134| 310| g2 = h2 + c; c = g2 >> 26; g2 &= 0x3ffffff; 135| 310| g3 = h3 + c; c = g3 >> 26; g3 &= 0x3ffffff; 136| 310| g4 = h4 + c - (1UL << 26); 137| | 138| | /* select h if h < p, or h + -p if h >= p */ 139| 310| mask = (g4 >> ((sizeof(uint32_t) * 8) - 1)) - 1; 140| 310| g0 &= mask; 141| 310| g1 &= mask; 142| 310| g2 &= mask; 143| 310| g3 &= mask; 144| 310| g4 &= mask; 145| 310| mask = ~mask; 146| 310| h0 = (h0 & mask) | g0; 147| 310| h1 = (h1 & mask) | g1; 148| 310| h2 = (h2 & mask) | g2; 149| 310| h3 = (h3 & mask) | g3; 150| 310| h4 = (h4 & mask) | g4; 151| | 152| | /* h = h % (2^128) */ 153| 310| h0 = ((h0 ) | (h1 << 26)) & 0xffffffff; 154| 310| h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff; 155| 310| h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff; 156| 310| h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff; 157| | 158| | /* mac = (h + pad) % (2^128) */ 159| 310| f = (uint64_t)h0 + st->pad[0] ; h0 = (uint32_t)f; 160| 310| f = (uint64_t)h1 + st->pad[1] + (f >> 32); h1 = (uint32_t)f; 161| 310| f = (uint64_t)h2 + st->pad[2] + (f >> 32); h2 = (uint32_t)f; 162| 310| f = (uint64_t)h3 + st->pad[3] + (f >> 32); h3 = (uint32_t)f; 163| | 164| 310| WriteLE32(mac + 0, h0); 165| 310| WriteLE32(mac + 4, h1); 166| 310| WriteLE32(mac + 8, h2); 167| 310| WriteLE32(mac + 12, h3); 168| | 169| | /* zero out the state */ 170| 310| st->h[0] = 0; 171| 310| st->h[1] = 0; 172| 310| st->h[2] = 0; 173| 310| st->h[3] = 0; 174| 310| st->h[4] = 0; 175| 310| st->r[0] = 0; 176| 310| st->r[1] = 0; 177| 310| st->r[2] = 0; 178| 310| st->r[3] = 0; 179| 310| st->r[4] = 0; 180| 310| st->pad[0] = 0; 181| 310| st->pad[1] = 0; 182| 310| st->pad[2] = 0; 183| 310| st->pad[3] = 0; 184| 310|} _ZN14poly1305_donna15poly1305_updateEPNS_16poly1305_contextEPKhm: 186| 310|void poly1305_update(poly1305_context *st, const unsigned char *m, size_t bytes) noexcept { 187| 310| size_t i; 188| | 189| | /* handle leftover */ 190| 310| if (st->leftover) { ------------------ | Branch (190:9): [True: 0, False: 310] ------------------ 191| 0| size_t want = (POLY1305_BLOCK_SIZE - st->leftover); ------------------ | | 14| 0|#define POLY1305_BLOCK_SIZE 16 ------------------ 192| 0| if (want > bytes) { ------------------ | Branch (192:13): [True: 0, False: 0] ------------------ 193| 0| want = bytes; 194| 0| } 195| 0| for (i = 0; i < want; i++) { ------------------ | Branch (195:21): [True: 0, False: 0] ------------------ 196| 0| st->buffer[st->leftover + i] = m[i]; 197| 0| } 198| 0| bytes -= want; 199| 0| m += want; 200| 0| st->leftover += want; 201| 0| if (st->leftover < POLY1305_BLOCK_SIZE) return; ------------------ | | 14| 0|#define POLY1305_BLOCK_SIZE 16 ------------------ | Branch (201:13): [True: 0, False: 0] ------------------ 202| 0| poly1305_blocks(st, st->buffer, POLY1305_BLOCK_SIZE); ------------------ | | 14| 0|#define POLY1305_BLOCK_SIZE 16 ------------------ 203| 0| st->leftover = 0; 204| 0| } 205| | 206| | /* process full blocks */ 207| 310| if (bytes >= POLY1305_BLOCK_SIZE) { ------------------ | | 14| 310|#define POLY1305_BLOCK_SIZE 16 ------------------ | Branch (207:9): [True: 197, False: 113] ------------------ 208| 197| size_t want = (bytes & ~(POLY1305_BLOCK_SIZE - 1)); ------------------ | | 14| 197|#define POLY1305_BLOCK_SIZE 16 ------------------ 209| 197| poly1305_blocks(st, m, want); 210| 197| m += want; 211| 197| bytes -= want; 212| 197| } 213| | 214| | /* store leftover */ 215| 310| if (bytes) { ------------------ | Branch (215:9): [True: 189, False: 121] ------------------ 216| 1.84k| for (i = 0; i < bytes; i++) { ------------------ | Branch (216:21): [True: 1.66k, False: 189] ------------------ 217| 1.66k| st->buffer[st->leftover + i] = m[i]; 218| 1.66k| } 219| 189| st->leftover += bytes; 220| 189| } 221| 310|} poly1305.cpp:_ZN14poly1305_donnaL15poly1305_blocksEPNS_16poly1305_contextEPKhm: 40| 386|static void poly1305_blocks(poly1305_context *st, const unsigned char *m, size_t bytes) noexcept { 41| 386| const uint32_t hibit = (st->final) ? 0 : (1UL << 24); /* 1 << 128 */ ------------------ | Branch (41:28): [True: 189, False: 197] ------------------ 42| 386| uint32_t r0,r1,r2,r3,r4; 43| 386| uint32_t s1,s2,s3,s4; 44| 386| uint32_t h0,h1,h2,h3,h4; 45| 386| uint64_t d0,d1,d2,d3,d4; 46| 386| uint32_t c; 47| | 48| 386| r0 = st->r[0]; 49| 386| r1 = st->r[1]; 50| 386| r2 = st->r[2]; 51| 386| r3 = st->r[3]; 52| 386| r4 = st->r[4]; 53| | 54| 386| s1 = r1 * 5; 55| 386| s2 = r2 * 5; 56| 386| s3 = r3 * 5; 57| 386| s4 = r4 * 5; 58| | 59| 386| h0 = st->h[0]; 60| 386| h1 = st->h[1]; 61| 386| h2 = st->h[2]; 62| 386| h3 = st->h[3]; 63| 386| h4 = st->h[4]; 64| | 65| 1.35M| while (bytes >= POLY1305_BLOCK_SIZE) { ------------------ | | 14| 1.35M|#define POLY1305_BLOCK_SIZE 16 ------------------ | Branch (65:12): [True: 1.35M, False: 386] ------------------ 66| | /* h += m[i] */ 67| 1.35M| h0 += (ReadLE32(m+ 0) ) & 0x3ffffff; 68| 1.35M| h1 += (ReadLE32(m+ 3) >> 2) & 0x3ffffff; 69| 1.35M| h2 += (ReadLE32(m+ 6) >> 4) & 0x3ffffff; 70| 1.35M| h3 += (ReadLE32(m+ 9) >> 6) & 0x3ffffff; 71| 1.35M| h4 += (ReadLE32(m+12) >> 8) | hibit; 72| | 73| | /* h *= r */ 74| 1.35M| d0 = ((uint64_t)h0 * r0) + ((uint64_t)h1 * s4) + ((uint64_t)h2 * s3) + ((uint64_t)h3 * s2) + ((uint64_t)h4 * s1); 75| 1.35M| d1 = ((uint64_t)h0 * r1) + ((uint64_t)h1 * r0) + ((uint64_t)h2 * s4) + ((uint64_t)h3 * s3) + ((uint64_t)h4 * s2); 76| 1.35M| d2 = ((uint64_t)h0 * r2) + ((uint64_t)h1 * r1) + ((uint64_t)h2 * r0) + ((uint64_t)h3 * s4) + ((uint64_t)h4 * s3); 77| 1.35M| d3 = ((uint64_t)h0 * r3) + ((uint64_t)h1 * r2) + ((uint64_t)h2 * r1) + ((uint64_t)h3 * r0) + ((uint64_t)h4 * s4); 78| 1.35M| d4 = ((uint64_t)h0 * r4) + ((uint64_t)h1 * r3) + ((uint64_t)h2 * r2) + ((uint64_t)h3 * r1) + ((uint64_t)h4 * r0); 79| | 80| | /* (partial) h %= p */ 81| 1.35M| c = (uint32_t)(d0 >> 26); h0 = (uint32_t)d0 & 0x3ffffff; 82| 1.35M| d1 += c; c = (uint32_t)(d1 >> 26); h1 = (uint32_t)d1 & 0x3ffffff; 83| 1.35M| d2 += c; c = (uint32_t)(d2 >> 26); h2 = (uint32_t)d2 & 0x3ffffff; 84| 1.35M| d3 += c; c = (uint32_t)(d3 >> 26); h3 = (uint32_t)d3 & 0x3ffffff; 85| 1.35M| d4 += c; c = (uint32_t)(d4 >> 26); h4 = (uint32_t)d4 & 0x3ffffff; 86| 1.35M| h0 += c * 5; c = (h0 >> 26); h0 = h0 & 0x3ffffff; 87| 1.35M| h1 += c; 88| | 89| 1.35M| m += POLY1305_BLOCK_SIZE; ------------------ | | 14| 1.35M|#define POLY1305_BLOCK_SIZE 16 ------------------ 90| 1.35M| bytes -= POLY1305_BLOCK_SIZE; ------------------ | | 14| 1.35M|#define POLY1305_BLOCK_SIZE 16 ------------------ 91| 1.35M| } 92| | 93| 386| st->h[0] = h0; 94| 386| st->h[1] = h1; 95| 386| st->h[2] = h2; 96| 386| st->h[3] = h3; 97| 386| st->h[4] = h4; 98| 386|} _ZN8Poly1305C2E4SpanIKSt4byteE: 50| 310| { 51| 310| assert(key.size() == KEYLEN); 52| 310| poly1305_donna::poly1305_init(&m_ctx, UCharCast(key.data())); 53| 310| } _ZN8Poly13056UpdateE4SpanIKSt4byteE: 57| 310| { 58| 310| poly1305_donna::poly1305_update(&m_ctx, UCharCast(msg.data()), msg.size()); 59| 310| return *this; 60| 310| } _ZN8Poly13058FinalizeE4SpanISt4byteE: 64| 310| { 65| 310| assert(out.size() == TAGLEN); 66| 310| poly1305_donna::poly1305_finish(&m_ctx, UCharCast(out.data())); 67| 310| } _Z9UCharCastPSt4byte: 283| 310|inline unsigned char* UCharCast(std::byte* c) { return reinterpret_cast(c); } _Z9UCharCastPKSt4byte: 287| 620|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast(c); } _ZNK4SpanIKSt4byteE4sizeEv: 187| 620| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIKSt4byteE4dataEv: 174| 620| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanISt4byteE4sizeEv: 187| 310| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanISt4byteE4dataEv: 174| 310| constexpr C* data() const noexcept { return m_data; } _ZN4SpanISt4byteEC2INSt3__16vectorIS0_NS3_9allocatorIS0_EEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE: 165| 310| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIKSt4byteEC2INSt3__16vectorIS0_NS4_9allocatorIS0_EEEEEERKT_NS4_9enable_ifIXaaaantsr7is_SpanIS9_EE5valuesr3std14is_convertibleIPA_NS4_14remove_pointerIDTcldtclsr3stdE7declvalISB_EE4dataEEE4typeEPA_S1_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISB_EE4sizeEEmEE5valueEDnE4typeE: 172| 620| : m_data(other.data()), m_size(other.size()){} _ZN18FuzzedDataProviderC2EPKhm: 37| 310| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm: 153| 310|FuzzedDataProvider::ConsumeRandomLengthString(size_t max_length) { 154| | // Reads bytes from the start of |data_ptr_|. Maps "\\" to "\", and maps "\" 155| | // followed by anything else to the end of the string. As a result of this 156| | // logic, a fuzzer can insert characters into the string, and the string 157| | // will be lengthened to include those new characters, resulting in a more 158| | // stable fuzzer than picking the length of a string independently from 159| | // picking its contents. 160| 310| std::string result; 161| | 162| | // Reserve the anticipated capacity to prevent several reallocations. 163| 310| result.reserve(std::min(max_length, remaining_bytes_)); 164| 21.6M| for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) { ------------------ | Branch (164:22): [True: 21.6M, False: 183] | Branch (164:40): [True: 21.6M, False: 33] ------------------ 165| 21.6M| char next = ConvertUnsignedToSigned(data_ptr_[0]); 166| 21.6M| Advance(1); 167| 21.6M| if (next == '\\' && remaining_bytes_ != 0) { ------------------ | Branch (167:9): [True: 962, False: 21.6M] | Branch (167:25): [True: 959, False: 3] ------------------ 168| 959| next = ConvertUnsignedToSigned(data_ptr_[0]); 169| 959| Advance(1); 170| 959| if (next != '\\') ------------------ | Branch (170:11): [True: 94, False: 865] ------------------ 171| 94| break; 172| 959| } 173| 21.6M| result += next; 174| 21.6M| } 175| | 176| 310| result.shrink_to_fit(); 177| 310| return result; 178| 310|} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv: 181| 310|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() { 182| 310| return ConsumeRandomLengthString(remaining_bytes_); 183| 310|} _ZN18FuzzedDataProvider14CopyAndAdvanceEPvm: 339| 310| size_t num_bytes) { 340| 310| std::memcpy(destination, data_ptr_, num_bytes); 341| 310| Advance(num_bytes); 342| 310|} _ZN18FuzzedDataProvider7AdvanceEm: 344| 21.6M|inline void FuzzedDataProvider::Advance(size_t num_bytes) { 345| 21.6M| if (num_bytes > remaining_bytes_) ------------------ | Branch (345:7): [True: 0, False: 21.6M] ------------------ 346| 0| abort(); 347| | 348| 21.6M| data_ptr_ += num_bytes; 349| 21.6M| remaining_bytes_ -= num_bytes; 350| 21.6M|} _ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_: 379| 21.6M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) { 380| 21.6M| static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types."); 381| 21.6M| static_assert(!std::numeric_limits::is_signed, 382| 21.6M| "Source type must be unsigned."); 383| | 384| | // TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream. 385| 21.6M| if (std::numeric_limits::is_modulo) ------------------ | Branch (385:7): [Folded - Ignored] ------------------ 386| 0| return static_cast(value); 387| | 388| | // Avoid using implementation-defined unsigned to signed conversions. 389| | // To learn more, see https://stackoverflow.com/questions/13150449. 390| 21.6M| if (value <= std::numeric_limits::max()) { ------------------ | Branch (390:7): [True: 21.0M, False: 533k] ------------------ 391| 21.0M| return static_cast(value); 392| 21.0M| } else { 393| 533k| constexpr auto TS_min = std::numeric_limits::min(); 394| 533k| return TS_min + static_cast(value - TS_min); 395| 533k| } 396| 21.6M|} _ZN18FuzzedDataProvider12ConsumeBytesISt4byteEENSt3__16vectorIT_NS2_9allocatorIS4_EEEEm: 109| 310|std::vector FuzzedDataProvider::ConsumeBytes(size_t num_bytes) { 110| 310| num_bytes = std::min(num_bytes, remaining_bytes_); 111| 310| return ConsumeBytes(num_bytes, num_bytes); 112| 310|} _ZN18FuzzedDataProvider12ConsumeBytesISt4byteEENSt3__16vectorIT_NS2_9allocatorIS4_EEEEmm: 353| 310|std::vector FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) { 354| 310| static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type."); 355| | 356| | // The point of using the size-based constructor below is to increase the 357| | // odds of having a vector object with capacity being equal to the length. 358| | // That part is always implementation specific, but at least both libc++ and 359| | // libstdc++ allocate the requested number of bytes in that constructor, 360| | // which seems to be a natural choice for other implementations as well. 361| | // To increase the odds even more, we also call |shrink_to_fit| below. 362| 310| std::vector result(size); 363| 310| if (size == 0) { ------------------ | Branch (363:7): [True: 0, False: 310] ------------------ 364| 0| if (num_bytes != 0) ------------------ | Branch (364:9): [True: 0, False: 0] ------------------ 365| 0| abort(); 366| 0| return result; 367| 0| } 368| | 369| 310| CopyAndAdvance(result.data(), num_bytes); 370| | 371| | // Even though |shrink_to_fit| is also implementation specific, we expect it 372| | // to provide an additional assurance in case vector's constructor allocated 373| | // a buffer which is larger than the actual amount of data we put inside it. 374| 310| result.shrink_to_fit(); 375| 310| return result; 376| 310|} _Z27crypto_poly1305_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 14| 310|{ 15| 310| FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()}; 16| | 17| 310| const auto key = ConsumeFixedLengthByteVector(fuzzed_data_provider, Poly1305::KEYLEN); 18| 310| const auto in = ConsumeRandomLengthByteVector(fuzzed_data_provider); 19| | 20| 310| std::vector tag_out(Poly1305::TAGLEN); 21| 310| Poly1305{key}.Update(in).Finalize(tag_out); 22| 310|} LLVMFuzzerTestOneInput: 222| 310|{ 223| 310| test_one_input({data, size}); 224| 310| return 0; 225| 310|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 83| 310|{ 84| 310| CheckGlobals check{}; 85| 310| (*Assert(g_test_one_input))(buffer); ------------------ | | 85| 310|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 86| 310|} _Z29ConsumeRandomLengthByteVectorISt4byteENSt3__16vectorIT_NS1_9allocatorIS3_EEEER18FuzzedDataProviderRKNS1_8optionalImEE: 58| 310|{ 59| 310| static_assert(sizeof(B) == 1); 60| 310| const std::string s = max_length ? ------------------ | Branch (60:27): [True: 0, False: 310] ------------------ 61| 0| fuzzed_data_provider.ConsumeRandomLengthString(*max_length) : 62| 310| fuzzed_data_provider.ConsumeRandomLengthString(); 63| 310| std::vector ret(s.size()); 64| 310| std::copy(s.begin(), s.end(), reinterpret_cast(ret.data())); 65| 310| return ret; 66| 310|} _Z28ConsumeFixedLengthByteVectorISt4byteENSt3__16vectorIT_NS1_9allocatorIS3_EEEER18FuzzedDataProviderm: 257| 310|{ 258| 310| static_assert(sizeof(B) == 1); 259| 310| auto random_bytes = fuzzed_data_provider.ConsumeBytes(length); 260| 310| random_bytes.resize(length); 261| 310| return random_bytes; 262| 310|} _ZN12CheckGlobalsC2Ev: 56| 310|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 57| 310|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 310| { 18| 310| g_used_g_prng = false; 19| 310| g_seeded_g_prng_zero = false; 20| 310| g_used_system_time = false; 21| 310| SetMockTime(0s); 22| 310| } _ZN16CheckGlobalsImplD2Ev: 24| 310| { 25| 310| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (25:13): [True: 0, False: 310] | Branch (25:30): [True: 0, False: 0] ------------------ 26| 0| std::cerr << "\n\n" 27| 0| "The current fuzz target used the global random state.\n\n" 28| | 29| 0| "This is acceptable, but requires the fuzz target to call \n" 30| 0| "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n" 31| 0| "of the FUZZ_TARGET function.\n\n" 32| | 33| 0| "An alternative solution would be to avoid any use of globals.\n\n" 34| | 35| 0| "Without a solution, fuzz instability and non-determinism can lead \n" 36| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 37| 0| << std::endl; 38| 0| std::abort(); // Abort, because AFL may try to recover from a std::exit 39| 0| } 40| | 41| 310| if (g_used_system_time) { ------------------ | Branch (41:13): [True: 0, False: 310] ------------------ 42| 0| std::cerr << "\n\n" 43| 0| "The current fuzz target accessed system time.\n\n" 44| | 45| 0| "This is acceptable, but requires the fuzz target to call \n" 46| 0| "SetMockTime() at the beginning of processing the fuzz input.\n\n" 47| | 48| 0| "Without setting mock time, time-dependent behavior can lead \n" 49| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 50| 0| << std::endl; 51| 0| std::abort(); 52| 0| } 53| 310| } _Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_: 52| 310|{ 53| 310| if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING ------------------ | Branch (53:9): [Folded - Ignored] | Branch (53:22): [Folded - Ignored] | Branch (53:54): [Folded - Ignored] ------------------ 54| |#ifdef ABORT_ON_FAILED_ASSUME 55| | || true 56| |#endif 57| 310| ) { 58| 310| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 310] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 310| } 62| 310| return std::forward(val); 63| 310|} _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_: 52| 310|{ 53| 310| if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING ------------------ | Branch (53:9): [Folded - Ignored] | Branch (53:22): [Folded - Ignored] | Branch (53:54): [Folded - Ignored] ------------------ 54| |#ifdef ABORT_ON_FAILED_ASSUME 55| | || true 56| |#endif 57| 310| ) { 58| 310| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 310] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 310| } 62| 310| return std::forward(val); 63| 310|} _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 42| 310|{ 43| 310| Assert(mock_time_in >= 0s); ------------------ | | 85| 310|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 44| 310| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 45| 310|}