grpc 1.25.0 → 1.26.0.pre1

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -30,9 +30,11 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
 
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/surface/channel.h"
 #include "src/core/tsi/alts/frame_protector/alts_frame_protector.h"
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 #include "src/core/tsi/alts/handshaker/alts_shared_resource.h"
@@ -42,7 +44,6 @@
 /* Main struct for ALTS TSI handshaker. */
 struct alts_tsi_handshaker {
   tsi_handshaker base;
-  alts_handshaker_client* client;
   grpc_slice target_name;
   bool is_client;
   bool has_sent_start_message;
@@ -52,6 +53,16 @@ struct alts_tsi_handshaker {
   grpc_alts_credentials_options* options;
   alts_handshaker_client_vtable* client_vtable_for_testing;
   grpc_channel* channel;
+  bool use_dedicated_cq;
+  // mu synchronizes all fields below. Note these are the
+  // only fields that can be concurrently accessed (due to
+  // potential concurrency of tsi_handshaker_shutdown and
+  // tsi_handshaker_next).
+  gpr_mu mu;
+  alts_handshaker_client* client;
+  // shutdown effectively follows base.handshake_shutdown,
+  // but is synchronized by the mutex of this object.
+  bool shutdown;
 };
 
 /* Main struct for ALTS TSI handshaker result. */
@@ -63,6 +74,7 @@ typedef struct alts_tsi_handshaker_result {
   size_t unused_bytes_size;
   grpc_slice rpc_versions;
   bool is_client;
+  grpc_slice serialized_context;
 } alts_tsi_handshaker_result;
 
 static tsi_result handshaker_result_extract_peer(
@@ -74,7 +86,7 @@ static tsi_result handshaker_result_extract_peer(
   alts_tsi_handshaker_result* result =
       reinterpret_cast<alts_tsi_handshaker_result*>(
           const_cast<tsi_handshaker_result*>(self));
-  GPR_ASSERT(kTsiAltsNumOfPeerProperties == 3);
+  GPR_ASSERT(kTsiAltsNumOfPeerProperties == 4);
   tsi_result ok = tsi_construct_peer(kTsiAltsNumOfPeerProperties, peer);
   int index = 0;
   if (ok != TSI_OK) {
@@ -104,7 +116,17 @@ static tsi_result handshaker_result_extract_peer(
   ok = tsi_construct_string_peer_property(
       TSI_ALTS_RPC_VERSIONS,
       reinterpret_cast<char*>(GRPC_SLICE_START_PTR(result->rpc_versions)),
-      GRPC_SLICE_LENGTH(result->rpc_versions), &peer->properties[2]);
+      GRPC_SLICE_LENGTH(result->rpc_versions), &peer->properties[index]);
+  if (ok != TSI_OK) {
+    tsi_peer_destruct(peer);
+    gpr_log(GPR_ERROR, "Failed to set tsi peer property");
+  }
+  index++;
+  GPR_ASSERT(&peer->properties[index] != nullptr);
+  ok = tsi_construct_string_peer_property(
+      TSI_ALTS_CONTEXT,
+      reinterpret_cast<char*>(GRPC_SLICE_START_PTR(result->serialized_context)),
+      GRPC_SLICE_LENGTH(result->serialized_context), &peer->properties[index]);
   if (ok != TSI_OK) {
     tsi_peer_destruct(peer);
     gpr_log(GPR_ERROR, "Failed to set tsi peer property");
@@ -183,6 +205,7 @@ static void handshaker_result_destroy(tsi_handshaker_result* self) {
   gpr_free(result->key_data);
   gpr_free(result->unused_bytes);
   grpc_slice_unref_internal(result->rpc_versions);
+  grpc_slice_unref_internal(result->serialized_context);
   gpr_free(result);
 }
 
@@ -207,9 +230,10 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Invalid identity");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview service_account = grpc_gcp_Identity_service_account(identity);
-  if (service_account.size == 0) {
-    gpr_log(GPR_ERROR, "Invalid service account");
+  upb_strview peer_service_account =
+      grpc_gcp_Identity_service_account(identity);
+  if (peer_service_account.size == 0) {
+    gpr_log(GPR_ERROR, "Invalid peer service account");
     return TSI_FAILED_PRECONDITION;
   }
   upb_strview key_data = grpc_gcp_HandshakerResult_key_data(hresult);
@@ -223,21 +247,65 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Peer does not set RPC protocol versions.");
     return TSI_FAILED_PRECONDITION;
   }
+  upb_strview application_protocol =
+      grpc_gcp_HandshakerResult_application_protocol(hresult);
+  if (application_protocol.size == 0) {
+    gpr_log(GPR_ERROR, "Invalid application protocol");
+    return TSI_FAILED_PRECONDITION;
+  }
+  upb_strview record_protocol =
+      grpc_gcp_HandshakerResult_record_protocol(hresult);
+  if (record_protocol.size == 0) {
+    gpr_log(GPR_ERROR, "Invalid record protocol");
+    return TSI_FAILED_PRECONDITION;
+  }
+  const grpc_gcp_Identity* local_identity =
+      grpc_gcp_HandshakerResult_local_identity(hresult);
+  if (local_identity == nullptr) {
+    gpr_log(GPR_ERROR, "Invalid local identity");
+    return TSI_FAILED_PRECONDITION;
+  }
+  upb_strview local_service_account =
+      grpc_gcp_Identity_service_account(local_identity);
+  // We don't check if local service account is empty here
+  // because local identity could be empty in certain situations.
   alts_tsi_handshaker_result* result =
       static_cast<alts_tsi_handshaker_result*>(gpr_zalloc(sizeof(*result)));
   result->key_data =
       static_cast<char*>(gpr_zalloc(kAltsAes128GcmRekeyKeyLength));
   memcpy(result->key_data, key_data.data, kAltsAes128GcmRekeyKeyLength);
   result->peer_identity =
-      static_cast<char*>(gpr_zalloc(service_account.size + 1));
-  memcpy(result->peer_identity, service_account.data, service_account.size);
-  upb::Arena arena;
+      static_cast<char*>(gpr_zalloc(peer_service_account.size + 1));
+  memcpy(result->peer_identity, peer_service_account.data,
+         peer_service_account.size);
+  upb::Arena rpc_versions_arena;
   bool serialized = grpc_gcp_rpc_protocol_versions_encode(
-      peer_rpc_version, arena.ptr(), &result->rpc_versions);
+      peer_rpc_version, rpc_versions_arena.ptr(), &result->rpc_versions);
   if (!serialized) {
     gpr_log(GPR_ERROR, "Failed to serialize peer's RPC protocol versions.");
     return TSI_FAILED_PRECONDITION;
   }
+  upb::Arena context_arena;
+  grpc_gcp_AltsContext* context = grpc_gcp_AltsContext_new(context_arena.ptr());
+  grpc_gcp_AltsContext_set_application_protocol(context, application_protocol);
+  grpc_gcp_AltsContext_set_record_protocol(context, record_protocol);
+  // ALTS currently only supports the security level of 2,
+  // which is "grpc_gcp_INTEGRITY_AND_PRIVACY".
+  grpc_gcp_AltsContext_set_security_level(context, 2);
+  grpc_gcp_AltsContext_set_peer_service_account(context, peer_service_account);
+  grpc_gcp_AltsContext_set_local_service_account(context,
+                                                 local_service_account);
+  grpc_gcp_AltsContext_set_peer_rpc_versions(
+      context, const_cast<grpc_gcp_RpcProtocolVersions*>(peer_rpc_version));
+  size_t serialized_ctx_length;
+  char* serialized_ctx = grpc_gcp_AltsContext_serialize(
+      context, context_arena.ptr(), &serialized_ctx_length);
+  if (serialized_ctx == nullptr) {
+    gpr_log(GPR_ERROR, "Failed to serialize peer's ALTS context.");
+    return TSI_FAILED_PRECONDITION;
+  }
+  result->serialized_context =
+      grpc_slice_from_copied_buffer(serialized_ctx, serialized_ctx_length);
   result->is_client = is_client;
   result->base.vtable = &result_vtable;
   *self = &result->base;
@@ -272,22 +340,11 @@ static void on_handshaker_service_resp_recv_dedicated(void* arg,
                  nullptr, &resource->storage);
 }
 
-static tsi_result handshaker_next(
-    tsi_handshaker* self, const unsigned char* received_bytes,
-    size_t received_bytes_size, const unsigned char** /*bytes_to_send*/,
-    size_t* /*bytes_to_send_size*/, tsi_handshaker_result** /*result*/,
-    tsi_handshaker_on_next_done_cb cb, void* user_data) {
-  if (self == nullptr || cb == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to handshaker_next()");
-    return TSI_INVALID_ARGUMENT;
-  }
-  if (self->handshake_shutdown) {
-    gpr_log(GPR_ERROR, "TSI handshake shutdown");
-    return TSI_HANDSHAKE_SHUTDOWN;
-  }
-  alts_tsi_handshaker* handshaker =
-      reinterpret_cast<alts_tsi_handshaker*>(self);
-  tsi_result ok = TSI_OK;
+/* Returns TSI_OK if and only if no error is encountered. */
+static tsi_result alts_tsi_handshaker_continue_handshaker_next(
+    alts_tsi_handshaker* handshaker, const unsigned char* received_bytes,
+    size_t received_bytes_size, tsi_handshaker_on_next_done_cb cb,
+    void* user_data) {
   if (!handshaker->has_created_handshaker_client) {
     if (handshaker->channel == nullptr) {
       grpc_alts_shared_resource_dedicated_start(
@@ -303,15 +360,24 @@ static tsi_result handshaker_next(
         handshaker->channel == nullptr
             ? grpc_alts_get_shared_resource_dedicated()->channel
             : handshaker->channel;
-    handshaker->client = alts_grpc_handshaker_client_create(
+    alts_handshaker_client* client = alts_grpc_handshaker_client_create(
         handshaker, channel, handshaker->handshaker_service_url,
         handshaker->interested_parties, handshaker->options,
         handshaker->target_name, grpc_cb, cb, user_data,
         handshaker->client_vtable_for_testing, handshaker->is_client);
-    if (handshaker->client == nullptr) {
+    if (client == nullptr) {
       gpr_log(GPR_ERROR, "Failed to create ALTS handshaker client");
       return TSI_FAILED_PRECONDITION;
     }
+    {
+      grpc_core::MutexLock lock(&handshaker->mu);
+      GPR_ASSERT(handshaker->client == nullptr);
+      handshaker->client = client;
+      if (handshaker->shutdown) {
+        gpr_log(GPR_ERROR, "TSI handshake shutdown");
+        return TSI_HANDSHAKE_SHUTDOWN;
+      }
+    }
     handshaker->has_created_handshaker_client = true;
   }
   if (handshaker->channel == nullptr &&
@@ -324,18 +390,100 @@ static tsi_result handshaker_next(
                          : grpc_slice_from_copied_buffer(
                                reinterpret_cast<const char*>(received_bytes),
                                received_bytes_size);
+  tsi_result ok = TSI_OK;
   if (!handshaker->has_sent_start_message) {
+    handshaker->has_sent_start_message = true;
     ok = handshaker->is_client
              ? alts_handshaker_client_start_client(handshaker->client)
              : alts_handshaker_client_start_server(handshaker->client, &slice);
-    handshaker->has_sent_start_message = true;
+    // It's unsafe for the current thread to access any state in handshaker
+    // at this point, since alts_handshaker_client_start_client/server
+    // have potentially just started an op batch on the handshake call.
+    // The completion callback for that batch is unsynchronized and so
+    // can invoke the TSI next API callback from any thread, at which point
+    // there is nothing taking ownership of this handshaker to prevent it
+    // from being destroyed.
   } else {
     ok = alts_handshaker_client_next(handshaker->client, &slice);
   }
   grpc_slice_unref_internal(slice);
-  if (ok != TSI_OK) {
-    gpr_log(GPR_ERROR, "Failed to schedule ALTS handshaker requests");
-    return ok;
+  return ok;
+}
+
+struct alts_tsi_handshaker_continue_handshaker_next_args {
+  alts_tsi_handshaker* handshaker;
+  std::unique_ptr<unsigned char> received_bytes;
+  size_t received_bytes_size;
+  tsi_handshaker_on_next_done_cb cb;
+  void* user_data;
+  grpc_closure closure;
+};
+
+static void alts_tsi_handshaker_create_channel(void* arg,
+                                               grpc_error* unused_error) {
+  alts_tsi_handshaker_continue_handshaker_next_args* next_args =
+      static_cast<alts_tsi_handshaker_continue_handshaker_next_args*>(arg);
+  alts_tsi_handshaker* handshaker = next_args->handshaker;
+  GPR_ASSERT(handshaker->channel == nullptr);
+  handshaker->channel = grpc_insecure_channel_create(
+      next_args->handshaker->handshaker_service_url, nullptr, nullptr);
+  tsi_result continue_next_result =
+      alts_tsi_handshaker_continue_handshaker_next(
+          handshaker, next_args->received_bytes.get(),
+          next_args->received_bytes_size, next_args->cb, next_args->user_data);
+  if (continue_next_result != TSI_OK) {
+    next_args->cb(continue_next_result, next_args->user_data, nullptr, 0,
+                  nullptr);
+  }
+  delete next_args;
+}
+
+static tsi_result handshaker_next(
+    tsi_handshaker* self, const unsigned char* received_bytes,
+    size_t received_bytes_size, const unsigned char** /*bytes_to_send*/,
+    size_t* /*bytes_to_send_size*/, tsi_handshaker_result** /*result*/,
+    tsi_handshaker_on_next_done_cb cb, void* user_data) {
+  if (self == nullptr || cb == nullptr) {
+    gpr_log(GPR_ERROR, "Invalid arguments to handshaker_next()");
+    return TSI_INVALID_ARGUMENT;
+  }
+  alts_tsi_handshaker* handshaker =
+      reinterpret_cast<alts_tsi_handshaker*>(self);
+  {
+    grpc_core::MutexLock lock(&handshaker->mu);
+    if (handshaker->shutdown) {
+      gpr_log(GPR_ERROR, "TSI handshake shutdown");
+      return TSI_HANDSHAKE_SHUTDOWN;
+    }
+  }
+  if (handshaker->channel == nullptr && !handshaker->use_dedicated_cq) {
+    alts_tsi_handshaker_continue_handshaker_next_args* args =
+        new alts_tsi_handshaker_continue_handshaker_next_args();
+    args->handshaker = handshaker;
+    args->received_bytes = nullptr;
+    args->received_bytes_size = received_bytes_size;
+    if (received_bytes_size > 0) {
+      args->received_bytes = std::unique_ptr<unsigned char>(
+          static_cast<unsigned char*>(gpr_zalloc(received_bytes_size)));
+      memcpy(args->received_bytes.get(), received_bytes, received_bytes_size);
+    }
+    args->cb = cb;
+    args->user_data = user_data;
+    GRPC_CLOSURE_INIT(&args->closure, alts_tsi_handshaker_create_channel, args,
+                      grpc_schedule_on_exec_ctx);
+    // We continue this handshaker_next call at the bottom of the ExecCtx just
+    // so that we can invoke grpc_channel_create at the bottom of the call
+    // stack. Doing so avoids potential lock cycles between g_init_mu and other
+    // mutexes within core that might be held on the current call stack
+    // (note that g_init_mu gets acquired during channel creation).
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &args->closure, GRPC_ERROR_NONE);
+  } else {
+    tsi_result ok = alts_tsi_handshaker_continue_handshaker_next(
+        handshaker, received_bytes, received_bytes_size, cb, user_data);
+    if (ok != TSI_OK) {
+      gpr_log(GPR_ERROR, "Failed to schedule ALTS handshaker requests");
+      return ok;
+    }
   }
   return TSI_ASYNC;
 }
@@ -358,12 +506,16 @@ static tsi_result handshaker_next_dedicated(
 
 static void handshaker_shutdown(tsi_handshaker* self) {
   GPR_ASSERT(self != nullptr);
-  if (self->handshake_shutdown) {
-    return;
-  }
   alts_tsi_handshaker* handshaker =
       reinterpret_cast<alts_tsi_handshaker*>(self);
-  alts_handshaker_client_shutdown(handshaker->client);
+  grpc_core::MutexLock lock(&handshaker->mu);
+  if (handshaker->shutdown) {
+    return;
+  }
+  if (handshaker->client != nullptr) {
+    alts_handshaker_client_shutdown(handshaker->client);
+  }
+  handshaker->shutdown = true;
 }
 
 static void handshaker_destroy(tsi_handshaker* self) {
@@ -376,9 +528,10 @@ static void handshaker_destroy(tsi_handshaker* self) {
   grpc_slice_unref_internal(handshaker->target_name);
   grpc_alts_credentials_options_destroy(handshaker->options);
   if (handshaker->channel != nullptr) {
-    grpc_channel_destroy(handshaker->channel);
+    grpc_channel_destroy_internal(handshaker->channel);
   }
   gpr_free(handshaker->handshaker_service_url);
+  gpr_mu_destroy(&handshaker->mu);
   gpr_free(handshaker);
 }
 
@@ -400,7 +553,8 @@ static const tsi_handshaker_vtable handshaker_vtable_dedicated = {
 
 bool alts_tsi_handshaker_has_shutdown(alts_tsi_handshaker* handshaker) {
   GPR_ASSERT(handshaker != nullptr);
-  return handshaker->base.handshake_shutdown;
+  grpc_core::MutexLock lock(&handshaker->mu);
+  return handshaker->shutdown;
 }
 
 tsi_result alts_tsi_handshaker_create(
@@ -414,7 +568,8 @@ tsi_result alts_tsi_handshaker_create(
   }
   alts_tsi_handshaker* handshaker =
       static_cast<alts_tsi_handshaker*>(gpr_zalloc(sizeof(*handshaker)));
-  bool use_dedicated_cq = interested_parties == nullptr;
+  gpr_mu_init(&handshaker->mu);
+  handshaker->use_dedicated_cq = interested_parties == nullptr;
   handshaker->client = nullptr;
   handshaker->is_client = is_client;
   handshaker->has_sent_start_message = false;
@@ -425,13 +580,9 @@ tsi_result alts_tsi_handshaker_create(
   handshaker->has_created_handshaker_client = false;
   handshaker->handshaker_service_url = gpr_strdup(handshaker_service_url);
   handshaker->options = grpc_alts_credentials_options_copy(options);
-  handshaker->base.vtable =
-      use_dedicated_cq ? &handshaker_vtable_dedicated : &handshaker_vtable;
-  handshaker->channel =
-      use_dedicated_cq
-          ? nullptr
-          : grpc_insecure_channel_create(handshaker->handshaker_service_url,
-                                         nullptr, nullptr);
+  handshaker->base.vtable = handshaker->use_dedicated_cq
+                                ? &handshaker_vtable_dedicated
+                                : &handshaker_vtable;
   *self = &handshaker->base;
   return TSI_OK;
 }

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.h

@@ -28,13 +28,15 @@
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 #include "src/core/tsi/transport_security.h"
 #include "src/core/tsi/transport_security_interface.h"
+#include "src/proto/grpc/gcp/altscontext.upb.h"
 #include "src/proto/grpc/gcp/handshaker.upb.h"
 
-#define TSI_ALTS_SERVICE_ACCOUNT_PEER_PROPERTY "service_accont"
+#define TSI_ALTS_SERVICE_ACCOUNT_PEER_PROPERTY "service_account"
 #define TSI_ALTS_CERTIFICATE_TYPE "ALTS"
 #define TSI_ALTS_RPC_VERSIONS "rpc_versions"
+#define TSI_ALTS_CONTEXT "alts_context"
 
-const size_t kTsiAltsNumOfPeerProperties = 3;
+const size_t kTsiAltsNumOfPeerProperties = 4;
 
 typedef struct alts_tsi_handshaker alts_tsi_handshaker;
 

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker_private.h

@@ -77,6 +77,11 @@ void alts_handshaker_client_set_cb_for_testing(
 grpc_closure* alts_handshaker_client_get_closure_for_testing(
     alts_handshaker_client* client);
 
+void alts_handshaker_client_on_status_received_for_testing(
+    alts_handshaker_client* client, grpc_status_code status, grpc_error* error);
+
+void alts_handshaker_client_ref_for_testing(alts_handshaker_client* c);
+
 }  // namespace internal
 }  // namespace grpc_core
 

data/src/core/tsi/ssl/session_cache/ssl_session.h

@@ -57,7 +57,7 @@ class SslCachedSession {
   SslCachedSession& operator=(const SslCachedSession&) = delete;
 
   /// Create single cached instance of \a session.
-  static grpc_core::UniquePtr<SslCachedSession> Create(SslSessionPtr session);
+  static std::unique_ptr<SslCachedSession> Create(SslSessionPtr session);
 
   virtual ~SslCachedSession() = default;
 

data/src/core/tsi/ssl/session_cache/ssl_session_boringssl.cc

@@ -47,7 +47,7 @@ class BoringSslCachedSession : public SslCachedSession {
 
 }  // namespace
 
-grpc_core::UniquePtr<SslCachedSession> SslCachedSession::Create(
+std::unique_ptr<SslCachedSession> SslCachedSession::Create(
     SslSessionPtr session) {
   return grpc_core::MakeUnique<BoringSslCachedSession>(std::move(session));
 }

data/src/core/tsi/ssl/session_cache/ssl_session_cache.cc

@@ -76,7 +76,7 @@ class SslSessionLRUCache::Node {
   friend class SslSessionLRUCache;
 
   grpc_slice key_;
-  grpc_core::UniquePtr<SslCachedSession> session_;
+  std::unique_ptr<SslCachedSession> session_;
 
   Node* next_ = nullptr;
   Node* prev_ = nullptr;
@@ -92,7 +92,7 @@ SslSessionLRUCache::~SslSessionLRUCache() {
   Node* node = use_order_list_head_;
   while (node) {
     Node* next = node->next_;
-    grpc_core::Delete(node);
+    delete node;
     node = next;
   }
   grpc_avl_unref(entry_by_key_, nullptr);
@@ -127,7 +127,7 @@ void SslSessionLRUCache::Put(const char* key, SslSessionPtr session) {
     return;
   }
   grpc_slice key_slice = grpc_slice_from_copied_string(key);
-  node = grpc_core::New<Node>(key_slice, std::move(session));
+  node = new Node(key_slice, std::move(session));
   PushFront(node);
   entry_by_key_ = grpc_avl_add(entry_by_key_, node->AvlKey(), node, nullptr);
   AssertInvariants();
@@ -137,7 +137,7 @@ void SslSessionLRUCache::Put(const char* key, SslSessionPtr session) {
     Remove(node);
     // Order matters, key is destroyed after deleting node.
     entry_by_key_ = grpc_avl_remove(entry_by_key_, node->AvlKey(), nullptr);
-    grpc_core::Delete(node);
+    delete node;
     AssertInvariants();
   }
 }