[fuzz] add fuzz tests for hpack encoding and decoding

test/common/http/http2/BUILD

@@ -4,6 +4,7 @@ load(
     "envoy_cc_test",
     "envoy_cc_test_library",
     "envoy_package",
+    "envoy_proto_library",
 )
 
 licenses(["notice"])  # Apache 2
@@ -177,3 +178,22 @@ envoy_cc_fuzz_test(
         "//test/common/http/http2:codec_impl_test_util",
     ],
 )
+
+envoy_proto_library(
+    name = "hpack_fuzz_proto",
+    srcs = ["hpack_fuzz.proto"],
+    deps = ["//test/fuzz:common_proto"],
+)
+
+envoy_cc_fuzz_test(
+    name = "hpack_fuzz_test",
+    srcs = ["hpack_fuzz_test.cc"],
+    corpus = "hpack_corpus",
+    external_deps = [
+        "nghttp2",
+    ],
+    deps = [
+        ":hpack_fuzz_proto_cc_proto",
+        "//test/test_common:utility_lib",
+    ],
+)

test/common/http/http2/hpack_fuzz.proto

@@ -0,0 +1,14 @@
+syntax = "proto3";
+
+package test.common.http.http2;
+
+import "test/fuzz/common.proto";
+
+import "validate/validate.proto";
+
+// Structured input for hpack_fuzz_test.
+
+message HpackTestCase {
+  test.fuzz.Headers headers = 1 [(validate.rules).message.required = true];
+  bool end_headers = 2;
+}

test/common/http/http2/hpack_fuzz_test.cc

@@ -0,0 +1,155 @@
+// Fuzzer for HPACK encoding and decoding.
+// TODO(asraa): Speed up by using raw byte input and separators rather than protobuf input.
+
+#include <algorithm>
+
+#include "test/common/http/http2/hpack_fuzz.pb.validate.h"
+#include "test/fuzz/fuzz_runner.h"
+#include "test/test_common/utility.h"
+
+#include "absl/container/fixed_array.h"
+#include "nghttp2/nghttp2.h"
+
+namespace Envoy {
+namespace Http {
+namespace Http2 {
+namespace {
+
+// Dynamic Header Table Size
+constexpr int kHeaderTableSize = 4096;
+
+std::vector<nghttp2_nv> createNameValueArray(const test::fuzz::Headers& input) {
+  const size_t nvlen = input.headers().size();
+  std::vector<nghttp2_nv> nva(nvlen);
+  int i = 0;
+  for (const auto& header : input.headers()) {
+    // TODO(asraa): Consider adding flags in fuzzed input.
+    const uint8_t flags = 0;
+    nva[i++] = {const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(header.key().data())),
+                const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(header.value().data())),
+                header.key().size(), header.value().size(), flags};
+  }
+
+  return nva;
+}
+
+Buffer::OwnedImpl encodeHeaders(nghttp2_hd_deflater* deflater,
+                                const std::vector<nghttp2_nv>& input_nv) {
+  // Estimate the upper bound
+  const size_t buflen = nghttp2_hd_deflate_bound(deflater, input_nv.data(), input_nv.size());
+
+  Buffer::RawSlice iovec;
+  Buffer::OwnedImpl payload;
+  payload.reserve(buflen, &iovec, 1);
+  ASSERT(iovec.len_ >= buflen);
+
+  // Encode using nghttp2
+  uint8_t* buf = reinterpret_cast<uint8_t*>(iovec.mem_);
+  ASSERT(input_nv.data() != nullptr);
+  const ssize_t result =
+      nghttp2_hd_deflate_hd(deflater, buf, buflen, input_nv.data(), input_nv.size());
+  ASSERT(result >= 0, absl::StrCat("Failed to decode with result ", result));
+
+  iovec.len_ = result;
+  payload.commit(&iovec, 1);
+
+  return payload;
+}
+
+std::vector<nghttp2_nv> decodeHeaders(nghttp2_hd_inflater* inflater,
+                                      const Buffer::OwnedImpl& payload, bool end_headers) {
+  // Decode using nghttp2
+  Buffer::RawSliceVector slices = payload.getRawSlices();
+  const int num_slices = slices.size();
+  ASSERT(num_slices == 1, absl::StrCat("number of slices ", num_slices));
+
+  std::vector<nghttp2_nv> decoded_headers;
+  int inflate_flags = 0;
+  nghttp2_nv decoded_nv;
+  while (slices[0].len_ > 0) {
+    ssize_t result = nghttp2_hd_inflate_hd2(inflater, &decoded_nv, &inflate_flags,
+                                            reinterpret_cast<uint8_t*>(slices[0].mem_),
+                                            slices[0].len_, end_headers);
+    // Decoding should not fail and data should not be left in slice.
+    ASSERT(result >= 0);
+
+    slices[0].mem_ = reinterpret_cast<uint8_t*>(slices[0].mem_) + result;
+    slices[0].len_ -= result;
+
+    if (inflate_flags & NGHTTP2_HD_INFLATE_EMIT) {
+      // One header key value pair has been successfully decoded.
+      decoded_headers.push_back(decoded_nv);
+    }
+  }
+
+  if (end_headers) {
+    nghttp2_hd_inflate_end_headers(inflater);
+  }
+
+  return decoded_headers;
+}
+
+struct NvComparator {
+  inline bool operator()(const nghttp2_nv& a, const nghttp2_nv& b) {
+    absl::string_view a_str(reinterpret_cast<char*>(a.name), a.namelen);
+    absl::string_view b_str(reinterpret_cast<char*>(b.name), b.namelen);
+    return a_str.compare(b_str);
+  }
+};
+
+DEFINE_PROTO_FUZZER(const test::common::http::http2::HpackTestCase& input) {
+  // Validate headers.
+  try {
+    TestUtility::validate(input);
+  } catch (const EnvoyException& e) {
+    ENVOY_LOG_MISC(trace, "EnvoyException: {}", e.what());
+    return;
+  }
+
+  // Create name value pairs from headers.
+  std::vector<nghttp2_nv> input_nv = createNameValueArray(input.headers());
+  // Skip encoding empty headers. nghttp2 will throw a nullptr error on runtime if it receives a
+  // nullptr input.
+  if (!input_nv.data()) {
+    return;
+  }
+
+  // Create Deflater and Inflater
+  nghttp2_hd_deflater* deflater = nullptr;
+  int rc = nghttp2_hd_deflate_new(&deflater, kHeaderTableSize);
+  ASSERT(rc == 0);
+  nghttp2_hd_inflater* inflater = nullptr;
+  rc = nghttp2_hd_inflate_new(&inflater);
+  ASSERT(rc == 0);
+
+  // Encode headers with nghttp2.
+  const Buffer::OwnedImpl payload = encodeHeaders(deflater, input_nv);
+  ASSERT(!payload.getRawSlices().empty());
+
+  // Decode headers with nghttp2
+  std::vector<nghttp2_nv> output_nv = decodeHeaders(inflater, payload, input.end_headers());
+
+  // Verify that decoded == encoded.
+  ASSERT(input_nv.size() == output_nv.size());
+  std::sort(input_nv.begin(), input_nv.end(), NvComparator());
+  std::sort(output_nv.begin(), output_nv.end(), NvComparator());
+  for (size_t i = 0; i < input_nv.size(); i++) {
+    absl::string_view in_name = {reinterpret_cast<char*>(input_nv[i].name), input_nv[i].namelen};
+    absl::string_view out_name = {reinterpret_cast<char*>(output_nv[i].name), output_nv[i].namelen};
+    absl::string_view in_val = {reinterpret_cast<char*>(input_nv[i].value), input_nv[i].valuelen};
+    absl::string_view out_val = {reinterpret_cast<char*>(output_nv[i].value),
+                                 output_nv[i].valuelen};
+    ASSERT(in_name == out_name);
+    ASSERT(in_val == out_val);
+  }
+
+  // Delete inflater
+  nghttp2_hd_inflate_del(inflater);
+  // Delete deflater.
+  nghttp2_hd_deflate_del(deflater);
+}
+
+} // namespace
+} // namespace Http2
+} // namespace Http
+} // namespace Envoy