base_encode_decode.cpp raw

   1  // Copyright (c) 2019-present 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 <test/fuzz/fuzz.h>
   6  
   7  #include <base58.h>
   8  #include <psbt.h>
   9  #include <span.h>
  10  #include <test/fuzz/FuzzedDataProvider.h>
  11  #include <util/strencodings.h>
  12  #include <util/string.h>
  13  
  14  #include <cassert>
  15  #include <string>
  16  #include <vector>
  17  #include <ranges>
  18  
  19  using util::TrimStringView;
  20  
  21  FUZZ_TARGET(base58_encode_decode)
  22  {
  23      FuzzedDataProvider provider{buffer.data(), buffer.size()};
  24      const auto random_string{provider.ConsumeRandomLengthString(100)};
  25  
  26      const auto encoded{EncodeBase58(MakeUCharSpan(random_string))};
  27      const auto decode_input{provider.ConsumeBool() ? random_string : encoded};
  28      const int max_ret_len{provider.ConsumeIntegralInRange<int>(-1, decode_input.size() + 1)};
  29      if (std::vector<unsigned char> decoded; DecodeBase58(decode_input, decoded, max_ret_len)) {
  30          const auto encoded_string{EncodeBase58(decoded)};
  31          assert(encoded_string == TrimStringView(decode_input));
  32          if (decoded.size() > 0) {
  33              assert(max_ret_len > 0);
  34              assert(decoded.size() <= static_cast<size_t>(max_ret_len));
  35              assert(!DecodeBase58(encoded_string, decoded, provider.ConsumeIntegralInRange<int>(0, decoded.size() - 1)));
  36          }
  37      }
  38  }
  39  
  40  FUZZ_TARGET(base58check_encode_decode)
  41  {
  42      FuzzedDataProvider provider{buffer.data(), buffer.size()};
  43      const auto random_string{provider.ConsumeRandomLengthString(100)};
  44  
  45      const auto encoded{EncodeBase58Check(MakeUCharSpan(random_string))};
  46      const auto decode_input{provider.ConsumeBool() ? random_string : encoded};
  47      const int max_ret_len{provider.ConsumeIntegralInRange<int>(-1, decode_input.size() + 1)};
  48      if (std::vector<unsigned char> decoded; DecodeBase58Check(decode_input, decoded, max_ret_len)) {
  49          const auto encoded_string{EncodeBase58Check(decoded)};
  50          assert(encoded_string == TrimStringView(decode_input));
  51          if (decoded.size() > 0) {
  52              assert(max_ret_len > 0);
  53              assert(decoded.size() <= static_cast<size_t>(max_ret_len));
  54              assert(!DecodeBase58Check(encoded_string, decoded, provider.ConsumeIntegralInRange<int>(0, decoded.size() - 1)));
  55          }
  56      }
  57  }
  58  
  59  FUZZ_TARGET(base32_encode_decode)
  60  {
  61      const std::string random_string{buffer.begin(), buffer.end()};
  62  
  63      // Decode/Encode roundtrip
  64      if (auto result{DecodeBase32(random_string)}) {
  65          const auto encoded_string{EncodeBase32(*result)};
  66          assert(encoded_string == ToLower(TrimStringView(random_string)));
  67      }
  68      // Encode/Decode roundtrip
  69      const auto encoded{EncodeBase32(buffer)};
  70      const auto decoded{DecodeBase32(encoded)};
  71      assert(decoded && std::ranges::equal(*decoded, buffer));
  72  }
  73  
  74  FUZZ_TARGET(base64_encode_decode)
  75  {
  76      const std::string random_string{buffer.begin(), buffer.end()};
  77  
  78      // Decode/Encode roundtrip
  79      if (auto result{DecodeBase64(random_string)}) {
  80          const auto encoded_string{EncodeBase64(*result)};
  81          assert(encoded_string == TrimStringView(random_string));
  82      }
  83      // Encode/Decode roundtrip
  84      const auto encoded{EncodeBase64(buffer)};
  85      const auto decoded{DecodeBase64(encoded)};
  86      assert(decoded && std::ranges::equal(*decoded, buffer));
  87  }
  88  
  89  FUZZ_TARGET(psbt_base64_decode)
  90  {
  91      const std::string random_string{buffer.begin(), buffer.end()};
  92  
  93      util::Result<PartiallySignedTransaction> psbt = DecodeBase64PSBT(random_string);
  94  }
  95