grpc 1.62.0.pre1 → 1.63.0

data/src/core/lib/security/security_connector/load_system_roots_fallback.cc

@@ -19,7 +19,7 @@
 #include <grpc/support/port_platform.h>
 
 #if !defined(GPR_LINUX) && !defined(GPR_ANDROID) && !defined(GPR_FREEBSD) && \
-    !defined(GPR_APPLE)
+    !defined(GPR_APPLE) && !defined(GPR_WINDOWS)
 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
@@ -32,4 +32,5 @@ grpc_slice LoadSystemRootCerts() { return grpc_empty_slice(); }
 
 }  // namespace grpc_core
 
-#endif  // !(GPR_LINUX || GPR_ANDROID || GPR_FREEBSD || GPR_APPLE)
+#endif  // !(GPR_LINUX || GPR_ANDROID || GPR_FREEBSD || GPR_APPLE ||
+        // GPR_WINDOWS)

data/src/core/lib/security/security_connector/load_system_roots_windows.cc

@@ -0,0 +1,87 @@
+//
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#if defined(GPR_WINDOWS)
+
+#pragma comment(lib, "crypt32")
+
+#include <esent.h>
+#include <wincrypt.h>
+
+#include <vector>
+
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/security/security_connector/load_system_roots.h"
+#include "src/core/lib/slice/slice_internal.h"
+
+namespace grpc_core {
+namespace {
+
+std::string Utf8Encode(const std::wstring& wstr) {
+  if (wstr.empty()) return "";
+
+  int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(),
+                                        NULL, 0, NULL, NULL);
+  std::string str_to(size_needed, 0);
+  WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &str_to[0],
+                      size_needed, NULL, NULL);
+  return str_to;
+}
+
+}  // namespace
+
+grpc_slice LoadSystemRootCerts() {
+  std::string bundle_string;
+
+  // Open root certificate store.
+  HANDLE root_cert_store = CertOpenSystemStoreW(NULL, L"ROOT");
+  if (!root_cert_store) {
+    return grpc_empty_slice();
+  }
+
+  // Load all root certificates from certificate store.
+  PCCERT_CONTEXT cert = NULL;
+  while ((cert = CertEnumCertificatesInStore(root_cert_store, cert)) != NULL) {
+    // Append each certificate in PEM format.
+    DWORD size = 0;
+    CryptBinaryToStringW(cert->pbCertEncoded, cert->cbCertEncoded,
+                         CRYPT_STRING_BASE64HEADER, NULL, &size);
+    std::vector<WCHAR> pem(size);
+    CryptBinaryToStringW(cert->pbCertEncoded, cert->cbCertEncoded,
+                         CRYPT_STRING_BASE64HEADER, pem.data(), &size);
+    bundle_string += Utf8Encode(pem.data());
+  }
+
+  CertCloseStore(root_cert_store, 0);
+  if (bundle_string.size() == 0) {
+    return grpc_empty_slice();
+  }
+
+  return grpc_slice_from_cpp_string(std::move(bundle_string));
+}
+
+}  // namespace grpc_core
+
+#endif  // GPR_WINDOWS

data/src/core/lib/security/transport/auth_filters.h

@@ -62,31 +62,6 @@ class ClientAuthFilter final : public ChannelFilter {
   grpc_call_credentials::GetRequestMetadataArgs args_;
 };
 
-class LegacyServerAuthFilter final : public ChannelFilter {
- public:
-  static const grpc_channel_filter kFilter;
-
-  static absl::StatusOr<LegacyServerAuthFilter> Create(const ChannelArgs& args,
-                                                       ChannelFilter::Args);
-
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
-
- private:
-  LegacyServerAuthFilter(
-      RefCountedPtr<grpc_server_credentials> server_credentials,
-      RefCountedPtr<grpc_auth_context> auth_context);
-
-  class RunApplicationCode;
-
-  ArenaPromise<absl::StatusOr<CallArgs>> GetCallCredsMetadata(
-      CallArgs call_args);
-
-  RefCountedPtr<grpc_server_credentials> server_credentials_;
-  RefCountedPtr<grpc_auth_context> auth_context_;
-};
-
 class ServerAuthFilter final : public ImplementChannelFilter<ServerAuthFilter> {
  private:
   ServerAuthFilter(RefCountedPtr<grpc_server_credentials> server_credentials,

data/src/core/lib/security/transport/security_handshaker.cc

@@ -27,6 +27,7 @@
 #include <algorithm>
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "absl/base/attributes.h"
 #include "absl/status/status.h"
@@ -585,25 +586,25 @@ void SecurityHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
 
 class FailHandshaker : public Handshaker {
  public:
+  explicit FailHandshaker(absl::Status status) : status_(std::move(status)) {}
   const char* name() const override { return "security_fail"; }
   void Shutdown(grpc_error_handle /*why*/) override {}
   void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
                    grpc_closure* on_handshake_done,
                    HandshakerArgs* args) override {
-    grpc_error_handle error =
-        GRPC_ERROR_CREATE("Failed to create security handshaker");
-    grpc_endpoint_shutdown(args->endpoint, error);
+    grpc_endpoint_shutdown(args->endpoint, status_);
     grpc_endpoint_destroy(args->endpoint);
     args->endpoint = nullptr;
     args->args = ChannelArgs();
     grpc_slice_buffer_destroy(args->read_buffer);
     gpr_free(args->read_buffer);
     args->read_buffer = nullptr;
-    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, error);
+    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, status_);
   }
 
  private:
   ~FailHandshaker() override = default;
+  absl::Status status_;
 };
 
 //
@@ -652,14 +653,22 @@ class ServerSecurityHandshakerFactory : public HandshakerFactory {
 //
 
 RefCountedPtr<Handshaker> SecurityHandshakerCreate(
-    tsi_handshaker* handshaker, grpc_security_connector* connector,
-    const ChannelArgs& args) {
+    absl::StatusOr<tsi_handshaker*> handshaker,
+    grpc_security_connector* connector, const ChannelArgs& args) {
   // If no TSI handshaker was created, return a handshaker that always fails.
   // Otherwise, return a real security handshaker.
-  if (handshaker == nullptr) {
-    return MakeRefCounted<FailHandshaker>();
+  if (!handshaker.ok()) {
+    return MakeRefCounted<FailHandshaker>(
+        absl::Status(handshaker.status().code(),
+                     absl::StrCat("Failed to create security handshaker: ",
+                                  handshaker.status().message())));
+  } else if (*handshaker == nullptr) {
+    // TODO(gtcooke94) Once all TSI impls are updated to pass StatusOr<> instead
+    // of null, we should change this to use absl::InternalError().
+    return MakeRefCounted<FailHandshaker>(
+        absl::UnknownError("Failed to create security handshaker."));
   } else {
-    return MakeRefCounted<SecurityHandshaker>(handshaker, connector, args);
+    return MakeRefCounted<SecurityHandshaker>(*handshaker, connector, args);
   }
 }
 

data/src/core/lib/security/transport/security_handshaker.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/statusor.h"
+
 #include <grpc/grpc.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -34,8 +36,8 @@ namespace grpc_core {
 
 /// Creates a security handshaker using \a handshaker.
 RefCountedPtr<Handshaker> SecurityHandshakerCreate(
-    tsi_handshaker* handshaker, grpc_security_connector* connector,
-    const ChannelArgs& args);
+    absl::StatusOr<tsi_handshaker*> handshaker,
+    grpc_security_connector* connector, const ChannelArgs& args);
 
 /// Registers security handshaker factories.
 void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder*);

data/src/core/lib/slice/slice.cc

@@ -289,8 +289,10 @@ grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) {
   return subset;
 }
 
-grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
-                                           grpc_slice_ref_whom ref_whom) {
+template <bool allow_inline>
+grpc_slice grpc_slice_split_tail_maybe_ref_impl(grpc_slice* source,
+                                                size_t split,
+                                                grpc_slice_ref_whom ref_whom) {
   grpc_slice tail;
 
   if (source->refcount == nullptr) {
@@ -311,7 +313,7 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
   } else {
     size_t tail_length = source->data.refcounted.length - split;
     GPR_ASSERT(source->data.refcounted.length >= split);
-    if (tail_length < sizeof(tail.data.inlined.bytes) &&
+    if (allow_inline && tail_length < sizeof(tail.data.inlined.bytes) &&
         ref_whom != GRPC_SLICE_REF_TAIL) {
       // Copy out the bytes - it'll be cheaper than refcounting
       tail.refcount = nullptr;
@@ -346,11 +348,27 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
   return tail;
 }
 
+grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
+                                           grpc_slice_ref_whom ref_whom) {
+  return grpc_slice_split_tail_maybe_ref_impl<true>(source, split, ref_whom);
+}
+
+grpc_slice grpc_slice_split_tail_maybe_ref_no_inline(
+    grpc_slice* source, size_t split, grpc_slice_ref_whom ref_whom) {
+  return grpc_slice_split_tail_maybe_ref_impl<false>(source, split, ref_whom);
+}
+
 grpc_slice grpc_slice_split_tail(grpc_slice* source, size_t split) {
   return grpc_slice_split_tail_maybe_ref(source, split, GRPC_SLICE_REF_BOTH);
 }
 
-grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
+grpc_slice grpc_slice_split_tail_no_inline(grpc_slice* source, size_t split) {
+  return grpc_slice_split_tail_maybe_ref_no_inline(source, split,
+                                                   GRPC_SLICE_REF_BOTH);
+}
+
+template <bool allow_inline>
+grpc_slice grpc_slice_split_head_impl(grpc_slice* source, size_t split) {
   grpc_slice head;
 
   if (source->refcount == nullptr) {
@@ -363,7 +381,7 @@ grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
         static_cast<uint8_t>(source->data.inlined.length - split);
     memmove(source->data.inlined.bytes, source->data.inlined.bytes + split,
             source->data.inlined.length);
-  } else if (split < sizeof(head.data.inlined.bytes)) {
+  } else if (allow_inline && split < sizeof(head.data.inlined.bytes)) {
     GPR_ASSERT(source->data.refcounted.length >= split);
 
     head.refcount = nullptr;
@@ -390,6 +408,14 @@ grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
   return head;
 }
 
+grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
+  return grpc_slice_split_head_impl<true>(source, split);
+}
+
+grpc_slice grpc_slice_split_head_no_inline(grpc_slice* source, size_t split) {
+  return grpc_slice_split_head_impl<false>(source, split);
+}
+
 int grpc_slice_eq(grpc_slice a, grpc_slice b) {
   if (GRPC_SLICE_LENGTH(a) != GRPC_SLICE_LENGTH(b)) return false;
   if (GRPC_SLICE_LENGTH(a) == 0) return true;

data/src/core/lib/slice/slice_buffer.cc

@@ -324,9 +324,13 @@ void grpc_slice_buffer_move_into(grpc_slice_buffer* src,
   src->length = 0;
 }
 
-template <bool incref>
+template <bool incref, bool allow_inline>
 static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer* src, size_t n,
                                               grpc_slice_buffer* dst) {
+  if (n == 0) {
+    return;
+  }
+
   GPR_ASSERT(src->length >= n);
   if (src->length == n) {
     grpc_slice_buffer_move_into(src, dst);
@@ -346,14 +350,28 @@ static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer* src, size_t n,
       grpc_slice_buffer_add(dst, slice);
       break;
     } else if (incref) {  // n < slice_len
-      grpc_slice_buffer_undo_take_first(
-          src, grpc_slice_split_tail_maybe_ref(&slice, n, GRPC_SLICE_REF_BOTH));
+      if (allow_inline) {
+        grpc_slice_buffer_undo_take_first(
+            src,
+            grpc_slice_split_tail_maybe_ref(&slice, n, GRPC_SLICE_REF_BOTH));
+      } else {
+        grpc_slice_buffer_undo_take_first(
+            src, grpc_slice_split_tail_maybe_ref_no_inline(
+                     &slice, n, GRPC_SLICE_REF_BOTH));
+      }
       GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == n);
       grpc_slice_buffer_add(dst, slice);
       break;
     } else {  // n < slice_len
-      grpc_slice_buffer_undo_take_first(
-          src, grpc_slice_split_tail_maybe_ref(&slice, n, GRPC_SLICE_REF_TAIL));
+      if (allow_inline) {
+        grpc_slice_buffer_undo_take_first(
+            src,
+            grpc_slice_split_tail_maybe_ref(&slice, n, GRPC_SLICE_REF_TAIL));
+      } else {
+        grpc_slice_buffer_undo_take_first(
+            src, grpc_slice_split_tail_maybe_ref_no_inline(
+                     &slice, n, GRPC_SLICE_REF_TAIL));
+      }
       GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == n);
       grpc_slice_buffer_add_indexed(dst, slice);
       break;
@@ -364,14 +382,19 @@ static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer* src, size_t n,
   GPR_ASSERT(src->count > 0);
 }
 
+void grpc_slice_buffer_move_first_no_inline(grpc_slice_buffer* src, size_t n,
+                                            grpc_slice_buffer* dst) {
+  slice_buffer_move_first_maybe_ref<true, false>(src, n, dst);
+}
+
 void grpc_slice_buffer_move_first(grpc_slice_buffer* src, size_t n,
                                   grpc_slice_buffer* dst) {
-  slice_buffer_move_first_maybe_ref<true>(src, n, dst);
+  slice_buffer_move_first_maybe_ref<true, true>(src, n, dst);
 }
 
 void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src, size_t n,
                                          grpc_slice_buffer* dst) {
-  slice_buffer_move_first_maybe_ref<false>(src, n, dst);
+  slice_buffer_move_first_maybe_ref<false, true>(src, n, dst);
 }
 
 void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n,
@@ -417,9 +440,9 @@ void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
     n -= slice_len;
   }
 }
-
-void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
-                                grpc_slice_buffer* garbage) {
+template <bool allow_inline>
+void grpc_slice_buffer_trim_end_impl(grpc_slice_buffer* sb, size_t n,
+                                     grpc_slice_buffer* garbage) {
   GPR_ASSERT(n <= sb->length);
   sb->length -= n;
   for (;;) {
@@ -427,7 +450,12 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
     grpc_slice slice = sb->slices[idx];
     size_t slice_len = GRPC_SLICE_LENGTH(slice);
     if (slice_len > n) {
-      sb->slices[idx] = grpc_slice_split_head(&slice, slice_len - n);
+      if (allow_inline) {
+        sb->slices[idx] = grpc_slice_split_head(&slice, slice_len - n);
+      } else {
+        sb->slices[idx] =
+            grpc_slice_split_head_no_inline(&slice, slice_len - n);
+      }
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
@@ -454,6 +482,16 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
   }
 }
 
+void grpc_slice_buffer_trim_end_no_inline(grpc_slice_buffer* sb, size_t n,
+                                          grpc_slice_buffer* garbage) {
+  return grpc_slice_buffer_trim_end_impl<false>(sb, n, garbage);
+}
+
+void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
+                                grpc_slice_buffer* garbage) {
+  return grpc_slice_buffer_trim_end_impl<true>(sb, n, garbage);
+}
+
 grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb) {
   grpc_slice slice;
   GPR_ASSERT(sb->count > 0);

data/src/core/lib/slice/slice_buffer.h

@@ -32,6 +32,12 @@
 void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
                                               void* dst);
 
+void grpc_slice_buffer_move_first_no_inline(grpc_slice_buffer* src, size_t n,
+                                            grpc_slice_buffer* dst);
+
+void grpc_slice_buffer_trim_end_no_inline(grpc_slice_buffer* sb, size_t n,
+                                          grpc_slice_buffer* garbage);
+
 namespace grpc_core {
 
 /// A slice buffer holds the memory for a collection of slices.
@@ -96,7 +102,14 @@ class SliceBuffer {
     grpc_slice_buffer_trim_end(&slice_buffer_, n, nullptr);
   }
 
-  /// Move the first n bytes of the SliceBuffer into a memory pointed to by dst.
+  /// Removes/deletes the last n bytes in the SliceBuffer while avoiding the
+  /// the creation of inline slices.
+  void RemoveLastNBytesNoInline(size_t n) {
+    grpc_slice_buffer_trim_end_no_inline(&slice_buffer_, n, nullptr);
+  }
+
+  /// Move the first n bytes of the SliceBuffer into a memory pointed to by
+  /// dst.
   void MoveFirstNBytesIntoBuffer(size_t n, void* dst) {
     grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
   }

data/src/core/lib/slice/slice_internal.h

@@ -67,6 +67,13 @@ grpc_slice grpc_slice_from_cpp_string(std::string str);
 // 0. All other slices will return the size of the allocated chars.
 size_t grpc_slice_memory_usage(grpc_slice s);
 
+grpc_slice grpc_slice_split_tail_maybe_ref_no_inline(
+    grpc_slice* source, size_t split, grpc_slice_ref_whom ref_whom);
+
+grpc_slice grpc_slice_split_tail_no_inline(grpc_slice* source, size_t split);
+
+grpc_slice grpc_slice_split_head_no_inline(grpc_slice* source, size_t split);
+
 namespace grpc_core {
 
 // Converts grpc_slice to absl::string_view.