_Z16htole32_internalj: 39| 15.9M|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 15.9M| else return host_32bits; 42| 15.9M|} _Z16le32toh_internalj: 49| 1.27M|{ 50| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits); 51| 1.27M| else return little_endian_32bits; 52| 1.27M|} _ZN15ChaCha20Aligned6SetKeyE4SpanIKSt4byteE: 26| 1.26k|{ 27| 1.26k| assert(key.size() == KEYLEN); 28| 1.26k| input[0] = ReadLE32(key.data() + 0); 29| 1.26k| input[1] = ReadLE32(key.data() + 4); 30| 1.26k| input[2] = ReadLE32(key.data() + 8); 31| 1.26k| input[3] = ReadLE32(key.data() + 12); 32| 1.26k| input[4] = ReadLE32(key.data() + 16); 33| 1.26k| input[5] = ReadLE32(key.data() + 20); 34| 1.26k| input[6] = ReadLE32(key.data() + 24); 35| 1.26k| input[7] = ReadLE32(key.data() + 28); 36| 1.26k| input[8] = 0; 37| 1.26k| input[9] = 0; 38| 1.26k| input[10] = 0; 39| 1.26k| input[11] = 0; 40| 1.26k|} _ZN15ChaCha20AlignedD2Ev: 43| 518|{ 44| 518| memory_cleanse(input, sizeof(input)); 45| 518|} _ZN15ChaCha20AlignedC2E4SpanIKSt4byteE: 48| 518|{ 49| 518| SetKey(key); 50| 518|} _ZN15ChaCha20Aligned4SeekENSt3__14pairIjmEEj: 53| 36.8k|{ 54| 36.8k| input[8] = block_counter; 55| 36.8k| input[9] = nonce.first; 56| 36.8k| input[10] = nonce.second; 57| 36.8k| input[11] = nonce.second >> 32; 58| 36.8k|} _ZN8ChaCha209KeystreamE4SpanISt4byteE: 283| 18.3k|{ 284| 18.3k| if (out.empty()) return; ------------------ | Branch (284:9): [True: 470, False: 17.8k] ------------------ 285| 17.8k| if (m_bufleft) { ------------------ | Branch (285:9): [True: 16.7k, False: 1.10k] ------------------ 286| 16.7k| unsigned reuse = std::min(m_bufleft, out.size()); 287| 16.7k| std::copy(m_buffer.end() - m_bufleft, m_buffer.end() - m_bufleft + reuse, out.begin()); 288| 16.7k| m_bufleft -= reuse; 289| 16.7k| out = out.subspan(reuse); 290| 16.7k| } 291| 17.8k| if (out.size() >= m_aligned.BLOCKLEN) { ------------------ | Branch (291:9): [True: 16.2k, False: 1.55k] ------------------ 292| 16.2k| size_t blocks = out.size() / m_aligned.BLOCKLEN; 293| 16.2k| m_aligned.Keystream(out.first(blocks * m_aligned.BLOCKLEN)); 294| 16.2k| out = out.subspan(blocks * m_aligned.BLOCKLEN); 295| 16.2k| } 296| 17.8k| if (!out.empty()) { ------------------ | Branch (296:9): [True: 16.4k, False: 1.35k] ------------------ 297| 16.4k| m_aligned.Keystream(m_buffer); 298| 16.4k| std::copy(m_buffer.begin(), m_buffer.begin() + out.size(), out.begin()); 299| 16.4k| m_bufleft = m_aligned.BLOCKLEN - out.size(); 300| 16.4k| } 301| 17.8k|} _ZN8ChaCha205CryptE4SpanIKSt4byteES0_IS1_E: 304| 5.31k|{ 305| 5.31k| assert(input.size() == output.size()); 306| | 307| 5.31k| if (!input.size()) return; ------------------ | Branch (307:9): [True: 1.41k, False: 3.89k] ------------------ 308| 3.89k| if (m_bufleft) { ------------------ | Branch (308:9): [True: 2.29k, False: 1.60k] ------------------ 309| 2.29k| unsigned reuse = std::min(m_bufleft, input.size()); 310| 39.3k| for (unsigned i = 0; i < reuse; i++) { ------------------ | Branch (310:30): [True: 37.0k, False: 2.29k] ------------------ 311| 37.0k| output[i] = input[i] ^ m_buffer[m_aligned.BLOCKLEN - m_bufleft + i]; 312| 37.0k| } 313| 2.29k| m_bufleft -= reuse; 314| 2.29k| output = output.subspan(reuse); 315| 2.29k| input = input.subspan(reuse); 316| 2.29k| } 317| 3.89k| if (input.size() >= m_aligned.BLOCKLEN) { ------------------ | Branch (317:9): [True: 2.41k, False: 1.48k] ------------------ 318| 2.41k| size_t blocks = input.size() / m_aligned.BLOCKLEN; 319| 2.41k| m_aligned.Crypt(input.first(blocks * m_aligned.BLOCKLEN), output.first(blocks * m_aligned.BLOCKLEN)); 320| 2.41k| output = output.subspan(blocks * m_aligned.BLOCKLEN); 321| 2.41k| input = input.subspan(blocks * m_aligned.BLOCKLEN); 322| 2.41k| } 323| 3.89k| if (!input.empty()) { ------------------ | Branch (323:9): [True: 2.42k, False: 1.47k] ------------------ 324| 2.42k| m_aligned.Keystream(m_buffer); 325| 50.0k| for (unsigned i = 0; i < input.size(); i++) { ------------------ | Branch (325:30): [True: 47.6k, False: 2.42k] ------------------ 326| 47.6k| output[i] = input[i] ^ m_buffer[i]; 327| 47.6k| } 328| 2.42k| m_bufleft = m_aligned.BLOCKLEN - input.size(); 329| 2.42k| } 330| 3.89k|} _ZN8ChaCha20D2Ev: 333| 518|{ 334| 518| memory_cleanse(m_buffer.data(), m_buffer.size()); 335| 518|} _ZN8ChaCha206SetKeyE4SpanIKSt4byteE: 338| 743|{ 339| 743| m_aligned.SetKey(key); 340| 743| m_bufleft = 0; 341| 743| memory_cleanse(m_buffer.data(), m_buffer.size()); 342| 743|} _ZN15ChaCha20Aligned9KeystreamE4SpanISt4byteE: 61| 35.1k|{ 62| 35.1k| std::byte* c = output.data(); 63| 35.1k| size_t blocks = output.size() / BLOCKLEN; 64| 35.1k| assert(blocks * BLOCKLEN == output.size()); 65| | 66| 35.1k| uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15; 67| 35.1k| uint32_t j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15; 68| | 69| 35.1k| if (!blocks) return; ------------------ | Branch (69:9): [True: 0, False: 35.1k] ------------------ 70| | 71| 35.1k| j4 = input[0]; 72| 35.1k| j5 = input[1]; 73| 35.1k| j6 = input[2]; 74| 35.1k| j7 = input[3]; 75| 35.1k| j8 = input[4]; 76| 35.1k| j9 = input[5]; 77| 35.1k| j10 = input[6]; 78| 35.1k| j11 = input[7]; 79| 35.1k| j12 = input[8]; 80| 35.1k| j13 = input[9]; 81| 35.1k| j14 = input[10]; 82| 35.1k| j15 = input[11]; 83| | 84| 915k| for (;;) { 85| 915k| x0 = 0x61707865; 86| 915k| x1 = 0x3320646e; 87| 915k| x2 = 0x79622d32; 88| 915k| x3 = 0x6b206574; 89| 915k| x4 = j4; 90| 915k| x5 = j5; 91| 915k| x6 = j6; 92| 915k| x7 = j7; 93| 915k| x8 = j8; 94| 915k| x9 = j9; 95| 915k| x10 = j10; 96| 915k| x11 = j11; 97| 915k| x12 = j12; 98| 915k| x13 = j13; 99| 915k| x14 = j14; 100| 915k| x15 = j15; 101| | 102| | // The 20 inner ChaCha20 rounds are unrolled here for performance. 103| 915k| REPEAT10( ------------------ | | 23| 915k|#define REPEAT10(a) do { {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; } while(0) | | ------------------ | | | Branch (23:84): [Folded - Ignored] | | ------------------ ------------------ 104| 915k| QUARTERROUND( x0, x4, x8,x12); 105| 915k| QUARTERROUND( x1, x5, x9,x13); 106| 915k| QUARTERROUND( x2, x6,x10,x14); 107| 915k| QUARTERROUND( x3, x7,x11,x15); 108| 915k| QUARTERROUND( x0, x5,x10,x15); 109| 915k| QUARTERROUND( x1, x6,x11,x12); 110| 915k| QUARTERROUND( x2, x7, x8,x13); 111| 915k| QUARTERROUND( x3, x4, x9,x14); 112| 915k| ); 113| | 114| 915k| x0 += 0x61707865; 115| 915k| x1 += 0x3320646e; 116| 915k| x2 += 0x79622d32; 117| 915k| x3 += 0x6b206574; 118| 915k| x4 += j4; 119| 915k| x5 += j5; 120| 915k| x6 += j6; 121| 915k| x7 += j7; 122| 915k| x8 += j8; 123| 915k| x9 += j9; 124| 915k| x10 += j10; 125| 915k| x11 += j11; 126| 915k| x12 += j12; 127| 915k| x13 += j13; 128| 915k| x14 += j14; 129| 915k| x15 += j15; 130| | 131| 915k| ++j12; 132| 915k| if (!j12) ++j13; ------------------ | Branch (132:13): [True: 202, False: 915k] ------------------ 133| | 134| 915k| WriteLE32(c + 0, x0); 135| 915k| WriteLE32(c + 4, x1); 136| 915k| WriteLE32(c + 8, x2); 137| 915k| WriteLE32(c + 12, x3); 138| 915k| WriteLE32(c + 16, x4); 139| 915k| WriteLE32(c + 20, x5); 140| 915k| WriteLE32(c + 24, x6); 141| 915k| WriteLE32(c + 28, x7); 142| 915k| WriteLE32(c + 32, x8); 143| 915k| WriteLE32(c + 36, x9); 144| 915k| WriteLE32(c + 40, x10); 145| 915k| WriteLE32(c + 44, x11); 146| 915k| WriteLE32(c + 48, x12); 147| 915k| WriteLE32(c + 52, x13); 148| 915k| WriteLE32(c + 56, x14); 149| 915k| WriteLE32(c + 60, x15); 150| | 151| 915k| if (blocks == 1) { ------------------ | Branch (151:13): [True: 35.1k, False: 880k] ------------------ 152| 35.1k| input[8] = j12; 153| 35.1k| input[9] = j13; 154| 35.1k| return; 155| 35.1k| } 156| 880k| blocks -= 1; 157| 880k| c += BLOCKLEN; 158| 880k| } 159| 35.1k|} _ZN15ChaCha20Aligned5CryptE4SpanIKSt4byteES0_IS1_E: 162| 2.41k|{ 163| 2.41k| assert(in_bytes.size() == out_bytes.size()); 164| 2.41k| const std::byte* m = in_bytes.data(); 165| 2.41k| std::byte* c = out_bytes.data(); 166| 2.41k| size_t blocks = out_bytes.size() / BLOCKLEN; 167| 2.41k| assert(blocks * BLOCKLEN == out_bytes.size()); 168| | 169| 2.41k| uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15; 170| 2.41k| uint32_t j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15; 171| | 172| 2.41k| if (!blocks) return; ------------------ | Branch (172:9): [True: 0, False: 2.41k] ------------------ 173| | 174| 2.41k| j4 = input[0]; 175| 2.41k| j5 = input[1]; 176| 2.41k| j6 = input[2]; 177| 2.41k| j7 = input[3]; 178| 2.41k| j8 = input[4]; 179| 2.41k| j9 = input[5]; 180| 2.41k| j10 = input[6]; 181| 2.41k| j11 = input[7]; 182| 2.41k| j12 = input[8]; 183| 2.41k| j13 = input[9]; 184| 2.41k| j14 = input[10]; 185| 2.41k| j15 = input[11]; 186| | 187| 78.9k| for (;;) { 188| 78.9k| x0 = 0x61707865; 189| 78.9k| x1 = 0x3320646e; 190| 78.9k| x2 = 0x79622d32; 191| 78.9k| x3 = 0x6b206574; 192| 78.9k| x4 = j4; 193| 78.9k| x5 = j5; 194| 78.9k| x6 = j6; 195| 78.9k| x7 = j7; 196| 78.9k| x8 = j8; 197| 78.9k| x9 = j9; 198| 78.9k| x10 = j10; 199| 78.9k| x11 = j11; 200| 78.9k| x12 = j12; 201| 78.9k| x13 = j13; 202| 78.9k| x14 = j14; 203| 78.9k| x15 = j15; 204| | 205| | // The 20 inner ChaCha20 rounds are unrolled here for performance. 206| 78.9k| REPEAT10( ------------------ | | 23| 78.9k|#define REPEAT10(a) do { {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; } while(0) | | ------------------ | | | Branch (23:84): [Folded - Ignored] | | ------------------ ------------------ 207| 78.9k| QUARTERROUND( x0, x4, x8,x12); 208| 78.9k| QUARTERROUND( x1, x5, x9,x13); 209| 78.9k| QUARTERROUND( x2, x6,x10,x14); 210| 78.9k| QUARTERROUND( x3, x7,x11,x15); 211| 78.9k| QUARTERROUND( x0, x5,x10,x15); 212| 78.9k| QUARTERROUND( x1, x6,x11,x12); 213| 78.9k| QUARTERROUND( x2, x7, x8,x13); 214| 78.9k| QUARTERROUND( x3, x4, x9,x14); 215| 78.9k| ); 216| | 217| 78.9k| x0 += 0x61707865; 218| 78.9k| x1 += 0x3320646e; 219| 78.9k| x2 += 0x79622d32; 220| 78.9k| x3 += 0x6b206574; 221| 78.9k| x4 += j4; 222| 78.9k| x5 += j5; 223| 78.9k| x6 += j6; 224| 78.9k| x7 += j7; 225| 78.9k| x8 += j8; 226| 78.9k| x9 += j9; 227| 78.9k| x10 += j10; 228| 78.9k| x11 += j11; 229| 78.9k| x12 += j12; 230| 78.9k| x13 += j13; 231| 78.9k| x14 += j14; 232| 78.9k| x15 += j15; 233| | 234| 78.9k| x0 ^= ReadLE32(m + 0); 235| 78.9k| x1 ^= ReadLE32(m + 4); 236| 78.9k| x2 ^= ReadLE32(m + 8); 237| 78.9k| x3 ^= ReadLE32(m + 12); 238| 78.9k| x4 ^= ReadLE32(m + 16); 239| 78.9k| x5 ^= ReadLE32(m + 20); 240| 78.9k| x6 ^= ReadLE32(m + 24); 241| 78.9k| x7 ^= ReadLE32(m + 28); 242| 78.9k| x8 ^= ReadLE32(m + 32); 243| 78.9k| x9 ^= ReadLE32(m + 36); 244| 78.9k| x10 ^= ReadLE32(m + 40); 245| 78.9k| x11 ^= ReadLE32(m + 44); 246| 78.9k| x12 ^= ReadLE32(m + 48); 247| 78.9k| x13 ^= ReadLE32(m + 52); 248| 78.9k| x14 ^= ReadLE32(m + 56); 249| 78.9k| x15 ^= ReadLE32(m + 60); 250| | 251| 78.9k| ++j12; 252| 78.9k| if (!j12) ++j13; ------------------ | Branch (252:13): [True: 274, False: 78.7k] ------------------ 253| | 254| 78.9k| WriteLE32(c + 0, x0); 255| 78.9k| WriteLE32(c + 4, x1); 256| 78.9k| WriteLE32(c + 8, x2); 257| 78.9k| WriteLE32(c + 12, x3); 258| 78.9k| WriteLE32(c + 16, x4); 259| 78.9k| WriteLE32(c + 20, x5); 260| 78.9k| WriteLE32(c + 24, x6); 261| 78.9k| WriteLE32(c + 28, x7); 262| 78.9k| WriteLE32(c + 32, x8); 263| 78.9k| WriteLE32(c + 36, x9); 264| 78.9k| WriteLE32(c + 40, x10); 265| 78.9k| WriteLE32(c + 44, x11); 266| 78.9k| WriteLE32(c + 48, x12); 267| 78.9k| WriteLE32(c + 52, x13); 268| 78.9k| WriteLE32(c + 56, x14); 269| 78.9k| WriteLE32(c + 60, x15); 270| | 271| 78.9k| if (blocks == 1) { ------------------ | Branch (271:13): [True: 2.41k, False: 76.5k] ------------------ 272| 2.41k| input[8] = j12; 273| 2.41k| input[9] = j13; 274| 2.41k| return; 275| 2.41k| } 276| 76.5k| blocks -= 1; 277| 76.5k| c += BLOCKLEN; 278| 76.5k| m += BLOCKLEN; 279| 76.5k| } 280| 2.41k|} _ZN8ChaCha20C2E4SpanIKSt4byteE: 92| 518| ChaCha20(Span key) noexcept : m_aligned(key) {} _ZN8ChaCha204SeekENSt3__14pairIjmEEj: 105| 36.8k| { 106| 36.8k| m_aligned.Seek(nonce, block_counter); 107| 36.8k| m_bufleft = 0; 108| 36.8k| } _Z9WriteLE32ITk8ByteTypeSt4byteEvPT_j: 51| 15.9M|{ 52| 15.9M| uint32_t v = htole32_internal(x); 53| 15.9M| memcpy(ptr, &v, 4); 54| 15.9M|} _Z8ReadLE32ITk8ByteTypeSt4byteEjPKT_: 28| 1.27M|{ 29| 1.27M| uint32_t x; 30| 1.27M| memcpy(&x, ptr, 4); 31| 1.27M| return le32toh_internal(x); 32| 1.27M|} _ZNK4SpanIKSt4byteE5firstEm: 206| 2.41k| { 207| 2.41k| ASSERT_IF_DEBUG(size() >= count); 208| 2.41k| return Span(m_data, count); 209| 2.41k| } _ZNK4SpanISt4byteE5firstEm: 206| 18.6k| { 207| 18.6k| ASSERT_IF_DEBUG(size() >= count); 208| 18.6k| return Span(m_data, count); 209| 18.6k| } _ZNK4SpanIKSt4byteE4sizeEv: 187| 79.2k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIKSt4byteE4dataEv: 174| 12.5k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIhE4dataEv: 174| 18.3k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanISt4byteE4sizeEv: 187| 202k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanISt4byteEixEm: 191| 84.7k| { 192| 84.7k| ASSERT_IF_DEBUG(size() > pos); 193| 84.7k| return m_data[pos]; 194| 84.7k| } _ZNK4SpanIKSt4byteEixEm: 191| 84.7k| { 192| 84.7k| ASSERT_IF_DEBUG(size() > pos); 193| 84.7k| return m_data[pos]; 194| 84.7k| } _ZNK4SpanISt4byteE4dataEv: 174| 37.5k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanISt4byteE7subspanEm: 196| 37.7k| { 197| 37.7k| ASSERT_IF_DEBUG(size() >= offset); 198| 37.7k| return Span(m_data + offset, m_size - offset); 199| 37.7k| } _ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m: 119| 7.12k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZNK4SpanIhE10size_bytesEv: 188| 18.3k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m: 119| 74.7k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E: 264| 18.3k|{ 265| 18.3k| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 18.3k|} _ZN4SpanIKSt4byteEC2INSt3__16vectorIS0_NS4_9allocatorIS0_EEEEEERT_NS4_9enable_ifIXaaaantsr7is_SpanIS9_EE5valuesr3std14is_convertibleIPA_NS4_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S1_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE: 165| 743| : m_data(other.data()), m_size(other.size()){} _ZN4SpanISt4byteEC2INSt3__16vectorIS0_NS3_9allocatorIS0_EEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE: 165| 5.31k| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIhEC2INSt3__16vectorIhNS2_9allocatorIhEEEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS7_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE: 165| 18.3k| : 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| 5.83k| : m_data(other.data()), m_size(other.size()){} _Z20MakeWritableByteSpanIRNSt3__16vectorIhNS0_9allocatorIhEEEEE4SpanISt4byteEOT_: 275| 18.3k|{ 276| 18.3k| return AsWritableBytes(Span{std::forward(v)}); 277| 18.3k|} _ZNK4SpanISt4byteE5beginEv: 175| 33.2k| constexpr C* begin() const noexcept { return m_data; } _ZNK4SpanIKSt4byteE7subspanEm: 196| 4.70k| { 197| 4.70k| ASSERT_IF_DEBUG(size() >= offset); 198| 4.70k| return Span(m_data + offset, m_size - offset); 199| 4.70k| } _ZNK4SpanISt4byteE5emptyEv: 189| 36.1k| constexpr bool empty() const noexcept { return size() == 0; } _ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm64EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE: 165| 18.9k| : m_data(other.data()), m_size(other.size()){} _ZNK4SpanIKSt4byteE5emptyEv: 189| 3.89k| constexpr bool empty() const noexcept { return size() == 0; } _Z14memory_cleansePvm: 15| 1.77k|{ 16| |#if defined(WIN32) 17| | /* SecureZeroMemory is guaranteed not to be optimized out. */ 18| | SecureZeroMemory(ptr, len); 19| |#else 20| 1.77k| std::memset(ptr, 0, len); 21| | 22| | /* Memory barrier that scares the compiler away from optimizing out the memset. 23| | * 24| | * Quoting Adam Langley in commit ad1907fe73334d6c696c8539646c21b11178f20f 25| | * in BoringSSL (ISC License): 26| | * As best as we can tell, this is sufficient to break any optimisations that 27| | * might try to eliminate "superfluous" memsets. 28| | * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it 29| | * is pretty efficient because the compiler can still implement the memset() efficiently, 30| | * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by 31| | * Yang et al. (USENIX Security 2017) for more background. 32| | */ 33| 1.77k| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 34| 1.77k|#endif 35| 1.77k|} _ZN18FuzzedDataProviderC2EPKhm: 37| 518| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider15ConsumeIntegralImEET_v: 195| 36.8k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 36.8k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 36.8k| std::numeric_limits::max()); 198| 36.8k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 121k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 121k| static_assert(std::is_integral::value, "An integral type is required."); 207| 121k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 121k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 121k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 121k| uint64_t range = static_cast(max) - static_cast(min); 214| 121k| uint64_t result = 0; 215| 121k| size_t offset = 0; 216| | 217| 524k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 487k, False: 36.8k] | Branch (217:43): [True: 402k, False: 84.5k] ------------------ 218| 524k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 402k, False: 288] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 402k| --remaining_bytes_; 226| 402k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 402k| offset += CHAR_BIT; 228| 402k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 121k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 84.8k, False: 36.8k] ------------------ 232| 84.8k| result = result % (range + 1); 233| | 234| 121k| return static_cast(static_cast(min) + result); 235| 121k|} _ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v: 195| 73.6k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 73.6k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 73.6k| std::numeric_limits::max()); 198| 73.6k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_: 205| 73.6k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 73.6k| static_assert(std::is_integral::value, "An integral type is required."); 207| 73.6k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 73.6k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 73.6k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 73.6k| uint64_t range = static_cast(max) - static_cast(min); 214| 73.6k| uint64_t result = 0; 215| 73.6k| size_t offset = 0; 216| | 217| 368k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 294k, False: 73.6k] | Branch (217:43): [True: 294k, False: 0] ------------------ 218| 368k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 294k, False: 73] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 294k| --remaining_bytes_; 226| 294k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 294k| offset += CHAR_BIT; 228| 294k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 73.6k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 73.6k, False: 0] ------------------ 232| 73.6k| result = result % (range + 1); 233| | 234| 73.6k| return static_cast(static_cast(min) + result); 235| 73.6k|} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 61.7k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 61.7k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 61.7k| std::numeric_limits::max()); 198| 61.7k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 61.7k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 61.7k| static_assert(std::is_integral::value, "An integral type is required."); 207| 61.7k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 61.7k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 61.7k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 61.7k| uint64_t range = static_cast(max) - static_cast(min); 214| 61.7k| uint64_t result = 0; 215| 61.7k| size_t offset = 0; 216| | 217| 122k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 61.7k, False: 61.2k] | Branch (217:43): [True: 61.7k, False: 0] ------------------ 218| 122k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 61.2k, False: 454] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 61.2k| --remaining_bytes_; 226| 61.2k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 61.2k| offset += CHAR_BIT; 228| 61.2k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 61.7k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 61.7k, False: 0] ------------------ 232| 61.7k| result = result % (range + 1); 233| | 234| 61.7k| return static_cast(static_cast(min) + result); 235| 61.7k|} _ZN18FuzzedDataProvider11ConsumeBoolEv: 289| 61.7k|inline bool FuzzedDataProvider::ConsumeBool() { 290| 61.7k| return 1 & ConsumeIntegral(); 291| 61.7k|} _ZN18FuzzedDataProvider14CopyAndAdvanceEPvm: 339| 4.98k| size_t num_bytes) { 340| 4.98k| std::memcpy(destination, data_ptr_, num_bytes); 341| 4.98k| Advance(num_bytes); 342| 4.98k|} _ZN18FuzzedDataProvider7AdvanceEm: 344| 4.98k|inline void FuzzedDataProvider::Advance(size_t num_bytes) { 345| 4.98k| if (num_bytes > remaining_bytes_) ------------------ | Branch (345:7): [True: 0, False: 4.98k] ------------------ 346| 0| abort(); 347| | 348| 4.98k| data_ptr_ += num_bytes; 349| 4.98k| remaining_bytes_ -= num_bytes; 350| 4.98k|} _ZN18FuzzedDataProvider12ConsumeBytesISt4byteEENSt3__16vectorIT_NS2_9allocatorIS4_EEEEm: 109| 6.57k|std::vector FuzzedDataProvider::ConsumeBytes(size_t num_bytes) { 110| 6.57k| num_bytes = std::min(num_bytes, remaining_bytes_); 111| 6.57k| return ConsumeBytes(num_bytes, num_bytes); 112| 6.57k|} _ZN18FuzzedDataProvider12ConsumeBytesISt4byteEENSt3__16vectorIT_NS2_9allocatorIS4_EEEEmm: 353| 6.57k|std::vector FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) { 354| 6.57k| 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| 6.57k| std::vector result(size); 363| 6.57k| if (size == 0) { ------------------ | Branch (363:7): [True: 1.59k, False: 4.98k] ------------------ 364| 1.59k| if (num_bytes != 0) ------------------ | Branch (364:9): [True: 0, False: 1.59k] ------------------ 365| 0| abort(); 366| 1.59k| return result; 367| 1.59k| } 368| | 369| 4.98k| 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| 4.98k| result.shrink_to_fit(); 375| 4.98k| return result; 376| 6.57k|} _Z27crypto_chacha20_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 17| 518|{ 18| 518| FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()}; 19| | 20| 518| const auto key = ConsumeFixedLengthByteVector(fuzzed_data_provider, ChaCha20::KEYLEN); 21| 518| ChaCha20 chacha20{key}; 22| | 23| 61.2k| LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) { ------------------ | | 23| 61.7k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 61.2k, False: 515] | | | Branch (23:49): [True: 61.2k, False: 3] | | ------------------ ------------------ 24| 61.2k| CallOneOf( 25| 61.2k| fuzzed_data_provider, 26| 61.2k| [&] { 27| 61.2k| auto key = ConsumeFixedLengthByteVector(fuzzed_data_provider, ChaCha20::KEYLEN); 28| 61.2k| chacha20.SetKey(key); 29| 61.2k| }, 30| 61.2k| [&] { 31| 61.2k| ChaCha20::Nonce96 nonce{ 32| 61.2k| fuzzed_data_provider.ConsumeIntegral(), 33| 61.2k| fuzzed_data_provider.ConsumeIntegral()}; 34| 61.2k| chacha20.Seek(nonce, fuzzed_data_provider.ConsumeIntegral()); 35| 61.2k| }, 36| 61.2k| [&] { 37| 61.2k| std::vector output(fuzzed_data_provider.ConsumeIntegralInRange(0, 4096)); 38| 61.2k| chacha20.Keystream(MakeWritableByteSpan(output)); 39| 61.2k| }, 40| 61.2k| [&] { 41| 61.2k| std::vector output(fuzzed_data_provider.ConsumeIntegralInRange(0, 4096)); 42| 61.2k| const auto input = ConsumeFixedLengthByteVector(fuzzed_data_provider, output.size()); 43| 61.2k| chacha20.Crypt(input, output); 44| 61.2k| }); 45| 61.2k| } 46| 518|} crypto_chacha20.cpp:_ZZ27crypto_chacha20_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv: 26| 743| [&] { 27| 743| auto key = ConsumeFixedLengthByteVector(fuzzed_data_provider, ChaCha20::KEYLEN); 28| 743| chacha20.SetKey(key); 29| 743| }, crypto_chacha20.cpp:_ZZ27crypto_chacha20_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv: 30| 36.8k| [&] { 31| 36.8k| ChaCha20::Nonce96 nonce{ 32| 36.8k| fuzzed_data_provider.ConsumeIntegral(), 33| 36.8k| fuzzed_data_provider.ConsumeIntegral()}; 34| 36.8k| chacha20.Seek(nonce, fuzzed_data_provider.ConsumeIntegral()); 35| 36.8k| }, crypto_chacha20.cpp:_ZZ27crypto_chacha20_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv: 36| 18.3k| [&] { 37| 18.3k| std::vector output(fuzzed_data_provider.ConsumeIntegralInRange(0, 4096)); 38| 18.3k| chacha20.Keystream(MakeWritableByteSpan(output)); 39| 18.3k| }, crypto_chacha20.cpp:_ZZ27crypto_chacha20_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv: 40| 5.31k| [&] { 41| 5.31k| std::vector output(fuzzed_data_provider.ConsumeIntegralInRange(0, 4096)); 42| 5.31k| const auto input = ConsumeFixedLengthByteVector(fuzzed_data_provider, output.size()); 43| 5.31k| chacha20.Crypt(input, output); 44| 5.31k| }); LLVMFuzzerTestOneInput: 222| 518|{ 223| 518| test_one_input({data, size}); 224| 518| return 0; 225| 518|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 83| 518|{ 84| 518| CheckGlobals check{}; 85| 518| (*Assert(g_test_one_input))(buffer); ------------------ | | 85| 518|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 86| 518|} _Z28ConsumeFixedLengthByteVectorISt4byteENSt3__16vectorIT_NS1_9allocatorIS3_EEEER18FuzzedDataProviderm: 257| 6.57k|{ 258| 6.57k| static_assert(sizeof(B) == 1); 259| 6.57k| auto random_bytes = fuzzed_data_provider.ConsumeBytes(length); 260| 6.57k| random_bytes.resize(length); 261| 6.57k| return random_bytes; 262| 6.57k|} crypto_chacha20.cpp:_Z9CallOneOfIJZ27crypto_chacha20_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_0Z27crypto_chacha20_fuzz_targetS3_E3$_1Z27crypto_chacha20_fuzz_targetS3_E3$_2Z27crypto_chacha20_fuzz_targetS3_E3$_3EEmR18FuzzedDataProviderDpT_: 36| 61.2k|{ 37| 61.2k| constexpr size_t call_size{sizeof...(callables)}; 38| 61.2k| static_assert(call_size >= 1); 39| 61.2k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 40| | 41| 61.2k| size_t i{0}; 42| 244k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (42:7): [True: 743, False: 60.4k] | Branch (42:7): [True: 36.8k, False: 24.3k] | Branch (42:7): [True: 18.3k, False: 42.9k] | Branch (42:7): [True: 5.31k, False: 55.8k] ------------------ 43| 61.2k| return call_size; 44| 61.2k|} _ZN12CheckGlobalsC2Ev: 56| 518|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 57| 518|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 518| { 18| 518| g_used_g_prng = false; 19| 518| g_seeded_g_prng_zero = false; 20| 518| g_used_system_time = false; 21| 518| SetMockTime(0s); 22| 518| } _ZN16CheckGlobalsImplD2Ev: 24| 518| { 25| 518| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (25:13): [True: 0, False: 518] | 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| 518| if (g_used_system_time) { ------------------ | Branch (41:13): [True: 0, False: 518] ------------------ 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| 518| } _Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_: 52| 518|{ 53| 518| 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| 518| ) { 58| 518| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 518] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 518| } 62| 518| return std::forward(val); 63| 518|} _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_: 52| 518|{ 53| 518| 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| 518| ) { 58| 518| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 518] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 518| } 62| 518| return std::forward(val); 63| 518|} _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 42| 518|{ 43| 518| Assert(mock_time_in >= 0s); ------------------ | | 85| 518|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 44| 518| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 45| 518|}