Branch data     Line data    Source code

       1                 :             : // Copyright (c) 2019-2021 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 <bech32.h>
       6                 :             : #include <test/fuzz/fuzz.h>
       7                 :             : #include <test/fuzz/FuzzedDataProvider.h>
       8                 :             : #include <test/util/str.h>
       9                 :             : #include <util/strencodings.h>
      10                 :             : 
      11                 :             : #include <cassert>
      12                 :             : #include <cstdint>
      13                 :             : #include <string>
      14                 :             : #include <vector>
      15                 :             : 
      16         [ +  - ]:         432 : FUZZ_TARGET(bech32_random_decode)
      17                 :             : {
      18                 :           0 :     auto limit = bech32::CharLimit::BECH32;
      19                 :           0 :     FuzzedDataProvider fdp(buffer.data(), buffer.size());
      20                 :           0 :     auto random_string = fdp.ConsumeRandomLengthString(limit + 1);
      21         [ #  # ]:           0 :     auto decoded = bech32::Decode(random_string, limit);
      22                 :             : 
      23         [ #  # ]:           0 :     if (decoded.hrp.empty()) {
      24         [ #  # ]:           0 :         assert(decoded.encoding == bech32::Encoding::INVALID);
      25         [ #  # ]:           0 :         assert(decoded.data.empty());
      26                 :             :     } else {
      27         [ #  # ]:           0 :         assert(decoded.encoding != bech32::Encoding::INVALID);
      28         [ #  # ]:           0 :         auto reencoded = bech32::Encode(decoded.encoding, decoded.hrp, decoded.data);
      29   [ #  #  #  # ]:           0 :         assert(CaseInsensitiveEqual(random_string, reencoded));
      30                 :           0 :     }
      31                 :           0 : }
      32                 :             : 
      33                 :             : // https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki and https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
      34                 :           0 : std::string GenerateRandomHRP(FuzzedDataProvider& fdp)
      35                 :             : {
      36                 :           0 :     std::string hrp;
      37                 :           0 :     size_t length = fdp.ConsumeIntegralInRange<size_t>(1, 83);
      38         [ #  # ]:           0 :     for (size_t i = 0; i < length; ++i) {
      39                 :             :         // Generate lowercase ASCII characters in ([33-126] - ['A'-'Z']) range
      40                 :           0 :         char c = fdp.ConsumeBool()
      41         [ #  # ]:           0 :                  ? fdp.ConsumeIntegralInRange<char>(33, 'A' - 1)
      42                 :           0 :                  : fdp.ConsumeIntegralInRange<char>('Z' + 1, 126);
      43         [ #  # ]:           0 :         hrp += c;
      44                 :             :     }
      45                 :           0 :     return hrp;
      46                 :           0 : }
      47                 :             : 
      48         [ +  - ]:         432 : FUZZ_TARGET(bech32_roundtrip)
      49                 :             : {
      50                 :           0 :     FuzzedDataProvider fdp(buffer.data(), buffer.size());
      51                 :           0 :     auto hrp = GenerateRandomHRP(fdp);
      52                 :             : 
      53         [ #  # ]:           0 :     auto input_chars = fdp.ConsumeBytes<unsigned char>(fdp.ConsumeIntegralInRange<size_t>(0, 82));
      54                 :           0 :     std::vector<uint8_t> converted_input;
      55         [ #  # ]:           0 :     ConvertBits<8, 5, true>([&](auto c) { converted_input.push_back(c); }, input_chars.begin(), input_chars.end());
      56                 :             : 
      57         [ #  # ]:           0 :     auto size = converted_input.size() + hrp.length() + std::string({bech32::SEPARATOR}).size() + bech32::CHECKSUM_SIZE;
      58         [ #  # ]:           0 :     if (size <= bech32::CharLimit::BECH32) {
      59         [ #  # ]:           0 :         for (auto encoding: {bech32::Encoding::BECH32, bech32::Encoding::BECH32M}) {
      60         [ #  # ]:           0 :             auto encoded = bech32::Encode(encoding, hrp, converted_input);
      61         [ #  # ]:           0 :             assert(!encoded.empty());
      62                 :             : 
      63         [ #  # ]:           0 :             const auto decoded = bech32::Decode(encoded);
      64         [ #  # ]:           0 :             assert(decoded.encoding == encoding);
      65         [ #  # ]:           0 :             assert(decoded.hrp == hrp);
      66         [ #  # ]:           0 :             assert(decoded.data == converted_input);
      67                 :           0 :         }
      68                 :             :     }
      69                 :           0 : }