Merge github.com:grpc/grpc into news

src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.cc

@@ -50,7 +50,10 @@ absl::Status ValidateRootCertificates(absl::string_view root_certificates) {
   absl::StatusOr<std::vector<X509*>> parsed_roots =
       ParsePemCertificateChain(root_certificates);
   if (!parsed_roots.ok()) {
-    return parsed_roots.status();
+    return absl::Status(
+        parsed_roots.status().code(),
+        absl::StrCat("Failed to parse root certificates as PEM: ",
+                     parsed_roots.status().message()));
   }
   for (X509* x509 : *parsed_roots) {
     X509_free(x509);
@@ -65,7 +68,10 @@ absl::Status ValidatePemKeyCertPair(absl::string_view cert_chain,
   absl::StatusOr<std::vector<X509*>> parsed_certs =
       ParsePemCertificateChain(cert_chain);
   if (!parsed_certs.ok()) {
-    return parsed_certs.status();
+    return absl::Status(
+        parsed_certs.status().code(),
+        absl::StrCat("Failed to parse certificate chain as PEM: ",
+                     parsed_certs.status().message()));
   }
   for (X509* x509 : *parsed_certs) {
     X509_free(x509);
@@ -74,7 +80,9 @@ absl::Status ValidatePemKeyCertPair(absl::string_view cert_chain,
   absl::StatusOr<EVP_PKEY*> parsed_private_key =
       ParsePemPrivateKey(private_key);
   if (!parsed_private_key.ok()) {
-    return parsed_private_key.status();
+    return absl::Status(parsed_private_key.status().code(),
+                        absl::StrCat("Failed to parse private key as PEM: ",
+                                     parsed_private_key.status().message()));
   }
   EVP_PKEY_free(*parsed_private_key);
   return absl::OkStatus();

test/core/address_utils/BUILD

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 load("//bazel:grpc_build_system.bzl", "grpc_cc_test", "grpc_package")
-load("//test/core/test_util:grpc_fuzzer.bzl", "grpc_fuzzer")
+load("//test/core/test_util:grpc_fuzzer.bzl", "grpc_fuzz_test")
 
 licenses(["notice"])
 
@@ -51,14 +51,15 @@ grpc_cc_test(
     ],
 )
 
-grpc_fuzzer(
+grpc_fuzz_test(
     name = "sockaddr_utils_fuzzer_test",
     srcs = ["sockaddr_utils_fuzzer_test.cc"],
-    corpus = "sockaddr_uri_corpus",
-    external_deps = ["absl/log:check"],
+    external_deps = [
+        "absl/log:check",
+        "fuzztest",
+        "fuzztest_main",
+    ],
     tags = ["no_windows"],
-    uses_event_engine = False,
-    uses_polling = False,
     deps = [
         "//:grpc",
         "//test/core/test_util:grpc_test_util",

test/core/address_utils/sockaddr_utils_fuzzer_test.cc

@@ -18,28 +18,30 @@
 #include <string.h>
 
 #include <string>
+#include <vector>
 
 #include "absl/log/check.h"
 #include "absl/status/statusor.h"
+#include "fuzztest/fuzztest.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/util/uri.h"
 
-bool squelch = true;
+using fuzztest::Arbitrary;
+using fuzztest::VectorOf;
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  if (size > GRPC_MAX_SOCKADDR_SIZE) return 0;
+void CheckUriIsParseable(std::vector<uint8_t> buffer) {
   grpc_resolved_address address;
   memset(&address, 0, sizeof(address));
-  memcpy(address.addr, data, size);
-  address.len = size;
-
+  address.len = buffer.size();
   absl::StatusOr<std::string> uri = grpc_sockaddr_to_uri(&address);
-  if (!uri.ok()) return 0;
+  if (!uri.ok()) return;
   absl::StatusOr<grpc_core::URI> parsed_uri =
       grpc_core::URI::Parse(uri.value());
-
   CHECK_OK(parsed_uri);
-  return 0;
 }
+FUZZ_TEST(MyTestSuite, CheckUriIsParseable)
+    .WithDomains(VectorOf(Arbitrary<uint8_t>())
+                     .WithMaxSize(GRPC_MAX_SOCKADDR_SIZE)
+                     .WithMinSize(1));

test/core/compression/BUILD

@@ -17,7 +17,7 @@ load(
     "grpc_cc_test",
     "grpc_package",
 )
-load("//test/core/test_util:grpc_fuzzer.bzl", "grpc_fuzzer")
+load("//test/core/test_util:grpc_fuzzer.bzl", "grpc_fuzz_test")
 
 grpc_package(name = "test/core/compression")
 
@@ -40,26 +40,26 @@ grpc_cc_test(
     ],
 )
 
-grpc_fuzzer(
+grpc_fuzz_test(
     name = "message_compress_fuzzer",
     srcs = ["message_compress_fuzzer.cc"],
-    corpus = "message_compress_corpus",
-    tags = ["no_windows"],
-    uses_event_engine = False,
-    uses_polling = False,
+    external_deps = [
+        "fuzztest",
+        "fuzztest_main",
+    ],
     deps = [
         "//:grpc",
         "//test/core/test_util:grpc_test_util",
     ],
 )
 
-grpc_fuzzer(
+grpc_fuzz_test(
     name = "message_decompress_fuzzer",
     srcs = ["message_decompress_fuzzer.cc"],
-    corpus = "message_decompress_corpus",
-    tags = ["no_windows"],
-    uses_event_engine = False,
-    uses_polling = False,
+    external_deps = [
+        "fuzztest",
+        "fuzztest_main",
+    ],
     deps = [
         "//:grpc",
         "//test/core/test_util:grpc_test_util",

test/core/compression/message_compress_fuzzer.cc

@@ -21,34 +21,37 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <stdint.h>
-#include <string.h>
 
-#include "src/core/lib/compression/message_compress.h"
-
-bool squelch = true;
+#include <cstdint>
+#include <vector>
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  if (size < 1) return 0;
+#include "fuzztest/fuzztest.h"
+#include "src/core/lib/compression/message_compress.h"
 
-  // Instead of rolling something complicated to convert a uint8_t to the enum,
-  // just bail out if it isn't trivially convertible.
-  if (data[0] >= GRPC_COMPRESS_ALGORITHMS_COUNT) return 0;
-  const auto compression_algorithm =
-      static_cast<grpc_compression_algorithm>(data[0]);
+using fuzztest::Arbitrary;
+using fuzztest::ElementOf;
+using fuzztest::VectorOf;
 
+void CheckCompresses(grpc_compression_algorithm compression_algorithm,
+                     std::vector<uint8_t> buffer) {
   grpc_init();
   grpc_slice_buffer input_buffer;
   grpc_slice_buffer_init(&input_buffer);
-  grpc_slice_buffer_add(&input_buffer,
-                        grpc_slice_from_copied_buffer(
-                            reinterpret_cast<const char*>(data + 1), size - 1));
+  grpc_slice_buffer_add(
+      &input_buffer,
+      grpc_slice_from_copied_buffer(
+          reinterpret_cast<const char*>(buffer.data()), buffer.size()));
   grpc_slice_buffer output_buffer;
   grpc_slice_buffer_init(&output_buffer);
 
   grpc_msg_compress(compression_algorithm, &input_buffer, &output_buffer);
+  // TODO(ctiller): decompress and check it's an identity transform.
 
   grpc_slice_buffer_destroy(&input_buffer);
   grpc_slice_buffer_destroy(&output_buffer);
   grpc_shutdown();
-  return 0;
 }
+FUZZ_TEST(MyTestSuite, CheckCompresses)
+    .WithDomains(ElementOf({GRPC_COMPRESS_NONE, GRPC_COMPRESS_DEFLATE,
+                            GRPC_COMPRESS_GZIP}),
+                 VectorOf(Arbitrary<uint8_t>()).WithMinSize(1));

test/core/compression/message_decompress_fuzzer.cc

@@ -21,27 +21,26 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <stdint.h>
-#include <string.h>
 
-#include "src/core/lib/compression/message_compress.h"
-
-bool squelch = true;
+#include <cstdint>
+#include <vector>
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  if (size < 1) return 0;
+#include "fuzztest/fuzztest.h"
+#include "src/core/lib/compression/message_compress.h"
 
-  // Instead of rolling something complicated to convert a uint8_t to the enum,
-  // just bail out if it isn't trivially convertible.
-  if (data[0] >= GRPC_COMPRESS_ALGORITHMS_COUNT) return 0;
-  const auto compression_algorithm =
-      static_cast<grpc_compression_algorithm>(data[0]);
+using fuzztest::Arbitrary;
+using fuzztest::ElementOf;
+using fuzztest::VectorOf;
 
+void CheckDecompresses(grpc_compression_algorithm compression_algorithm,
+                       std::vector<uint8_t> buffer) {
   grpc_init();
   grpc_slice_buffer input_buffer;
   grpc_slice_buffer_init(&input_buffer);
-  grpc_slice_buffer_add(&input_buffer,
-                        grpc_slice_from_copied_buffer(
-                            reinterpret_cast<const char*>(data + 1), size - 1));
+  grpc_slice_buffer_add(
+      &input_buffer,
+      grpc_slice_from_copied_buffer(
+          reinterpret_cast<const char*>(buffer.data()), buffer.size()));
   grpc_slice_buffer output_buffer;
   grpc_slice_buffer_init(&output_buffer);
 
@@ -50,5 +49,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_slice_buffer_destroy(&input_buffer);
   grpc_slice_buffer_destroy(&output_buffer);
   grpc_shutdown();
-  return 0;
 }
+FUZZ_TEST(MyTestSuite, CheckDecompresses)
+    .WithDomains(ElementOf({GRPC_COMPRESS_NONE, GRPC_COMPRESS_DEFLATE,
+                            GRPC_COMPRESS_GZIP}),
+                 VectorOf(Arbitrary<uint8_t>()).WithMinSize(1));

test/core/security/BUILD

@@ -13,17 +13,20 @@
 # limitations under the License.
 
 load("//bazel:grpc_build_system.bzl", "grpc_cc_binary", "grpc_cc_library", "grpc_cc_test", "grpc_package")
-load("//test/core/test_util:grpc_fuzzer.bzl", "grpc_fuzzer")
+load("//test/core/test_util:grpc_fuzzer.bzl", "grpc_fuzz_test")
 
 licenses(["notice"])
 
 grpc_package(name = "test/core/security")
 
-grpc_fuzzer(
+grpc_fuzz_test(
     name = "alts_credentials_fuzzer",
     srcs = ["alts_credentials_fuzzer.cc"],
-    corpus = "corpus/alts_credentials_corpus",
-    external_deps = ["absl/log:check"],
+    external_deps = [
+        "absl/log:check",
+        "fuzztest",
+        "fuzztest_main",
+    ],
     tags = ["no_windows"],
     deps = [
         "//:gpr",
@@ -33,16 +36,19 @@ grpc_fuzzer(
     ],
 )
 
-grpc_fuzzer(
+grpc_fuzz_test(
     name = "ssl_server_fuzzer",
     srcs = ["ssl_server_fuzzer.cc"],
-    corpus = "corpus/ssl_server_corpus",
     data = [
         "//src/core/tsi/test_creds:ca.pem",
         "//src/core/tsi/test_creds:server1.key",
         "//src/core/tsi/test_creds:server1.pem",
     ],
-    external_deps = ["absl/log:check"],
+    external_deps = [
+        "absl/log:check",
+        "fuzztest",
+        "fuzztest_main",
+    ],
     tags = ["no_windows"],
     deps = [
         "//:event_engine_base_hdrs",