Fuzzing all of add, sub, mul, div

ckormanyos · Sep 26, 2024 · e65ba64 · e65ba64
1 parent 87d02c7
commit e65ba64
Show file tree

Hide file tree

Showing 5 changed files with 273 additions and 1 deletion.
diff --git a/.github/workflows/wide_integer_fuzzing.yml b/.github/workflows/wide_integer_fuzzing.yml
@@ -22,7 +22,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        tcase: [ add, div ]
+        tcase: [ add, sub, mul, div ]
     steps:
       - uses: actions/checkout@v4
         with:

diff --git a/test/fuzzing/test_fuzzing_mul.cpp b/test/fuzzing/test_fuzzing_mul.cpp
@@ -0,0 +1,127 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright Christopher Kormanyos 2024.
+//  Distributed under the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt
+//  or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// cd /mnt/c/Users/ckorm/Documents/Ks/PC_Software/NumericalPrograms/ExtendedNumberTypes/wide_integer
+// clang++ -g -O2 -fsanitize=fuzzer,address,undefined -I. -I/mnt/c/boost/boost_1_85_0 test/fuzzing/test_fuzzing_mul.cpp -o test_fuzzing_mul
+// ./test_fuzzing_mul -max_total_time=180
+
+#include <math/wide_integer/uintwide_t.h>
+
+#include <boost/multiprecision/cpp_int.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace fuzzing
+{
+  using boost_uint_backend_type =
+    boost::multiprecision::cpp_int_backend<static_cast<unsigned>(UINT32_C(256)),
+                                           static_cast<unsigned>(UINT32_C(256)),
+                                           boost::multiprecision::unsigned_magnitude>;
+
+  using boost_uint_type = boost::multiprecision::number<boost_uint_backend_type,
+                                                        boost::multiprecision::et_off>;
+
+  using local_uint_type = ::math::wide_integer::uint256_t;
+
+  auto eval_mul(const std::uint8_t* data, std::size_t size) -> bool;
+}
+
+auto fuzzing::eval_mul(const std::uint8_t* data, std::size_t size) -> bool
+{
+  const std::size_t
+    max_size
+    {
+      static_cast<std::size_t>
+      (
+        std::numeric_limits<fuzzing::local_uint_type>::digits / 8
+      )
+    };
+
+  bool result_is_ok { true };
+
+  if((size > std::size_t { UINT8_C(1) }) && (size <= std::size_t { max_size * 2U }))
+  {
+    local_uint_type a_local { };
+    local_uint_type b_local { };
+
+    boost_uint_type a_boost { };
+    boost_uint_type b_boost { };
+
+    // Import data into their respective uintwide_t a and b values.
+    import_bits
+    (
+      a_local,
+      data,
+      data + std::size_t { size / 2U },
+      8U
+    );
+
+    import_bits
+    (
+      b_local,
+      data + std::size_t { size / 2U },
+      data + size,
+      8U
+    );
+
+    // Import data into their respective boost-based a and b values.
+    import_bits
+    (
+      a_boost,
+      data,
+      data + std::size_t { size / 2U },
+      8U
+    );
+
+    import_bits
+    (
+      b_boost,
+      data + std::size_t { size / 2U },
+      data + size,
+      8U
+    );
+
+    local_uint_type result_local { a_local * b_local };
+    boost_uint_type result_boost { a_boost * b_boost };
+
+    std::vector<std::uint8_t> result_data_local(max_size, UINT8_C(0));
+    std::vector<std::uint8_t> result_data_boost(result_data_local.size(), UINT8_C(0));
+
+    export_bits(result_local, result_data_local.data(), 8U);
+    export_bits(result_boost, result_data_boost.data(), 8U);
+
+    // Verify that both uintwide_t as well as boost obtain the same result.
+    const bool result_mul_is_ok =
+      std::equal
+      (
+        result_data_local.cbegin(),
+        result_data_local.cend(),
+        result_data_boost.cbegin(),
+        result_data_boost.cend()
+      );
+
+    result_is_ok = (result_mul_is_ok && result_is_ok);
+  }
+
+  // Assert the correct result.
+  assert(result_is_ok);
+
+  return result_is_ok;
+}
+
+// The fuzzing entry point.
+extern "C"
+int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+  const bool result_one_mul_is_ok { fuzzing::eval_mul(data, size) };
+
+  return (result_one_mul_is_ok ? 0 : -1);
+}
diff --git a/test/fuzzing/test_fuzzing_sub.cpp b/test/fuzzing/test_fuzzing_sub.cpp
@@ -0,0 +1,127 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright Christopher Kormanyos 2024.
+//  Distributed under the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt
+//  or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// cd /mnt/c/Users/ckorm/Documents/Ks/PC_Software/NumericalPrograms/ExtendedNumberTypes/wide_integer
+// clang++ -g -O2 -fsanitize=fuzzer,address,undefined -I. -I/mnt/c/boost/boost_1_85_0 test/fuzzing/test_fuzzing_sub.cpp -o test_fuzzing_sub
+// ./test_fuzzing_sub -max_total_time=180
+
+#include <math/wide_integer/uintwide_t.h>
+
+#include <boost/multiprecision/cpp_int.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace fuzzing
+{
+  using boost_uint_backend_type =
+    boost::multiprecision::cpp_int_backend<static_cast<unsigned>(UINT32_C(256)),
+                                           static_cast<unsigned>(UINT32_C(256)),
+                                           boost::multiprecision::unsigned_magnitude>;
+
+  using boost_uint_type = boost::multiprecision::number<boost_uint_backend_type,
+                                                        boost::multiprecision::et_off>;
+
+  using local_uint_type = ::math::wide_integer::uint256_t;
+
+  auto eval_sub(const std::uint8_t* data, std::size_t size) -> bool;
+}
+
+auto fuzzing::eval_sub(const std::uint8_t* data, std::size_t size) -> bool
+{
+  const std::size_t
+    max_size
+    {
+      static_cast<std::size_t>
+      (
+        std::numeric_limits<fuzzing::local_uint_type>::digits / 8
+      )
+    };
+
+  bool result_is_ok { true };
+
+  if((size > std::size_t { UINT8_C(1) }) && (size <= std::size_t { max_size * 2U }))
+  {
+    local_uint_type a_local { };
+    local_uint_type b_local { };
+
+    boost_uint_type a_boost { };
+    boost_uint_type b_boost { };
+
+    // Import data into their respective uintwide_t a and b values.
+    import_bits
+    (
+      a_local,
+      data,
+      data + std::size_t { size / 2U },
+      8U
+    );
+
+    import_bits
+    (
+      b_local,
+      data + std::size_t { size / 2U },
+      data + size,
+      8U
+    );
+
+    // Import data into their respective boost-based a and b values.
+    import_bits
+    (
+      a_boost,
+      data,
+      data + std::size_t { size / 2U },
+      8U
+    );
+
+    import_bits
+    (
+      b_boost,
+      data + std::size_t { size / 2U },
+      data + size,
+      8U
+    );
+
+    local_uint_type result_local { a_local - b_local };
+    boost_uint_type result_boost { a_boost - b_boost };
+
+    std::vector<std::uint8_t> result_data_local(max_size, UINT8_C(0));
+    std::vector<std::uint8_t> result_data_boost(result_data_local.size(), UINT8_C(0));
+
+    export_bits(result_local, result_data_local.data(), 8U);
+    export_bits(result_boost, result_data_boost.data(), 8U);
+
+    // Verify that both uintwide_t as well as boost obtain the same result.
+    const bool result_sub_is_ok =
+      std::equal
+      (
+        result_data_local.cbegin(),
+        result_data_local.cend(),
+        result_data_boost.cbegin(),
+        result_data_boost.cend()
+      );
+
+    result_is_ok = (result_sub_is_ok && result_is_ok);
+  }
+
+  // Assert the correct result.
+  assert(result_is_ok);
+
+  return result_is_ok;
+}
+
+// The fuzzing entry point.
+extern "C"
+int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+  const bool result_one_sub_is_ok { fuzzing::eval_sub(data, size) };
+
+  return (result_one_sub_is_ok ? 0 : -1);
+}
diff --git a/wide_integer_vs2022.vcxproj b/wide_integer_vs2022.vcxproj
@@ -244,6 +244,18 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="test\fuzzing\test_fuzzing_mul.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="test\fuzzing\test_fuzzing_sub.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="test\test.cpp" />
     <ClCompile Include="test\test_uintwide_t_boost_backend.cpp" />
     <ClCompile Include="test\test_uintwide_t_boost_backend_via_test_arithmetic.cpp">

diff --git a/wide_integer_vs2022.vcxproj.filters b/wide_integer_vs2022.vcxproj.filters
@@ -231,6 +231,12 @@
     <ClCompile Include="test\fuzzing\test_fuzzing_div.cpp">
       <Filter>Source Files\test\fuzzing</Filter>
     </ClCompile>
+    <ClCompile Include="test\fuzzing\test_fuzzing_sub.cpp">
+      <Filter>Source Files\test\fuzzing</Filter>
+    </ClCompile>
+    <ClCompile Include="test\fuzzing\test_fuzzing_mul.cpp">
+      <Filter>Source Files\test\fuzzing</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include=".github\workflows\wide_integer.yml">