grpc 1.46.3 → 1.53.1

data/src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
-
-#ifndef GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_IOVEC_RECORD_PROTOCOL_H
-#define GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_IOVEC_RECORD_PROTOCOL_H
+//
+//
+// Copyright 2018 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_IOVEC_RECORD_PROTOCOL_H
+#define GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_IOVEC_RECORD_PROTOCOL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -35,165 +35,164 @@ constexpr size_t kZeroCopyFrameHeaderSize =
 constexpr size_t kAltsRecordProtocolRekeyFrameLimit = 8;
 constexpr size_t kAltsRecordProtocolFrameLimit = 5;
 
-/* An implementation of alts record protocol. The API is thread-compatible. */
+// An implementation of alts record protocol. The API is thread-compatible.
 
 typedef struct iovec iovec_t;
 
 typedef struct alts_iovec_record_protocol alts_iovec_record_protocol;
 
-/**
- * This method gets the length of record protocol frame header.
- */
+///
+/// This method gets the length of record protocol frame header.
+///
 size_t alts_iovec_record_protocol_get_header_length();
 
-/**
- * This method gets the length of record protocol frame tag.
- *
- * - rp: an alts_iovec_record_protocol instance.
- *
- * On success, the method returns the length of record protocol frame tag.
- * Otherwise, it returns zero.
- */
+///
+/// This method gets the length of record protocol frame tag.
+///
+///- rp: an alts_iovec_record_protocol instance.
+///
+/// On success, the method returns the length of record protocol frame tag.
+/// Otherwise, it returns zero.
+///
 size_t alts_iovec_record_protocol_get_tag_length(
     const alts_iovec_record_protocol* rp);
 
-/**
- * This method returns maximum allowed unprotected data size, given maximum
- * protected frame size.
- *
- * - rp: an alts_iovec_record_protocol instance.
- * - max_protected_frame_size: maximum protected frame size.
- *
- * On success, the method returns the maximum allowed unprotected data size.
- * Otherwise, it returns zero.
- */
+///
+/// This method returns maximum allowed unprotected data size, given maximum
+/// protected frame size.
+///
+///- rp: an alts_iovec_record_protocol instance.
+///- max_protected_frame_size: maximum protected frame size.
+///
+/// On success, the method returns the maximum allowed unprotected data size.
+/// Otherwise, it returns zero.
+///
 size_t alts_iovec_record_protocol_max_unprotected_data_size(
     const alts_iovec_record_protocol* rp, size_t max_protected_frame_size);
 
-/**
- * This method performs integrity-only protect operation on a
- * alts_iovec_record_protocol instance, i.e., compute frame header and tag. The
- * caller needs to allocate the memory for header and tag prior to calling this
- * method.
- *
- * - rp: an alts_iovec_record_protocol instance.
- * - unprotected_vec: an iovec array containing unprotected data.
- * - unprotected_vec_length: the array length of unprotected_vec.
- * - header: an iovec containing the output frame header.
- * - tag: an iovec containing the output frame tag.
- * - error_details: a buffer containing an error message if the method does not
- *   function correctly. It is OK to pass nullptr into error_details.
- *
- * On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
- * error status code along with its details specified in error_details (if
- * error_details is not nullptr).
- */
+///
+/// This method performs integrity-only protect operation on a
+/// alts_iovec_record_protocol instance, i.e., compute frame header and tag. The
+/// caller needs to allocate the memory for header and tag prior to calling this
+/// method.
+///
+///- rp: an alts_iovec_record_protocol instance.
+///- unprotected_vec: an iovec array containing unprotected data.
+///- unprotected_vec_length: the array length of unprotected_vec.
+///- header: an iovec containing the output frame header.
+///- tag: an iovec containing the output frame tag.
+///- error_details: a buffer containing an error message if the method does not
+///  function correctly. It is OK to pass nullptr into error_details.
+///
+/// On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
+/// error status code along with its details specified in error_details (if
+/// error_details is not nullptr).
+///
 grpc_status_code alts_iovec_record_protocol_integrity_only_protect(
     alts_iovec_record_protocol* rp, const iovec_t* unprotected_vec,
     size_t unprotected_vec_length, iovec_t header, iovec_t tag,
     char** error_details);
 
-/**
- * This method performs integrity-only unprotect operation on a
- * alts_iovec_record_protocol instance, i.e., verify frame header and tag.
- *
- * - rp: an alts_iovec_record_protocol instance.
- * - protected_vec: an iovec array containing protected data.
- * - protected_vec_length: the array length of protected_vec.
- * - header: an iovec containing the frame header.
- * - tag: an iovec containing the frame tag.
- * - error_details: a buffer containing an error message if the method does not
- *   function correctly. It is OK to pass nullptr into error_details.
- *
- * On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
- * error status code along with its details specified in error_details (if
- * error_details is not nullptr).
- */
+///
+/// This method performs integrity-only unprotect operation on a
+/// alts_iovec_record_protocol instance, i.e., verify frame header and tag.
+///
+///- rp: an alts_iovec_record_protocol instance.
+///- protected_vec: an iovec array containing protected data.
+///- protected_vec_length: the array length of protected_vec.
+///- header: an iovec containing the frame header.
+///- tag: an iovec containing the frame tag.
+///- error_details: a buffer containing an error message if the method does not
+///  function correctly. It is OK to pass nullptr into error_details.
+///
+/// On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
+/// error status code along with its details specified in error_details (if
+/// error_details is not nullptr).
+///
 grpc_status_code alts_iovec_record_protocol_integrity_only_unprotect(
     alts_iovec_record_protocol* rp, const iovec_t* protected_vec,
     size_t protected_vec_length, iovec_t header, iovec_t tag,
     char** error_details);
 
-/**
- * This method performs privacy-integrity protect operation on a
- * alts_iovec_record_protocol instance, i.e., compute a protected frame. The
- * caller needs to allocate the memory for the protected frame prior to calling
- * this method.
- *
- * - rp: an alts_iovec_record_protocol instance.
- * - unprotected_vec: an iovec array containing unprotected data.
- * - unprotected_vec_length: the array length of unprotected_vec.
- * - protected_frame: an iovec containing the output protected frame.
- * - error_details: a buffer containing an error message if the method does not
- *   function correctly. It is OK to pass nullptr into error_details.
- *
- * On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
- * error status code along with its details specified in error_details (if
- * error_details is not nullptr).
- */
+///
+/// This method performs privacy-integrity protect operation on a
+/// alts_iovec_record_protocol instance, i.e., compute a protected frame. The
+/// caller needs to allocate the memory for the protected frame prior to calling
+/// this method.
+///
+///- rp: an alts_iovec_record_protocol instance.
+///- unprotected_vec: an iovec array containing unprotected data.
+///- unprotected_vec_length: the array length of unprotected_vec.
+///- protected_frame: an iovec containing the output protected frame.
+///- error_details: a buffer containing an error message if the method does not
+///  function correctly. It is OK to pass nullptr into error_details.
+///
+/// On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
+/// error status code along with its details specified in error_details (if
+/// error_details is not nullptr).
+///
 grpc_status_code alts_iovec_record_protocol_privacy_integrity_protect(
     alts_iovec_record_protocol* rp, const iovec_t* unprotected_vec,
     size_t unprotected_vec_length, iovec_t protected_frame,
     char** error_details);
 
-/**
- * This method performs privacy-integrity unprotect operation on a
- * alts_iovec_record_protocol instance given a full protected frame, i.e.,
- * compute the unprotected data. The caller needs to allocated the memory for
- * the unprotected data prior to calling this method.
- *
- * - rp: an alts_iovec_record_protocol instance.
- * - header: an iovec containing the frame header.
- * - protected_vec: an iovec array containing protected data including the tag.
- * - protected_vec_length: the array length of protected_vec.
- * - unprotected_data: an iovec containing the output unprotected data.
- * - error_details: a buffer containing an error message if the method does not
- *   function correctly. It is OK to pass nullptr into error_details.
- *
- * On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
- * error status code along with its details specified in error_details (if
- * error_details is not nullptr).
- */
+///
+/// This method performs privacy-integrity unprotect operation on a
+/// alts_iovec_record_protocol instance given a full protected frame, i.e.,
+/// compute the unprotected data. The caller needs to allocated the memory for
+/// the unprotected data prior to calling this method.
+///
+///- rp: an alts_iovec_record_protocol instance.
+///- header: an iovec containing the frame header.
+///- protected_vec: an iovec array containing protected data including the tag.
+///- protected_vec_length: the array length of protected_vec.
+///- unprotected_data: an iovec containing the output unprotected data.
+///- error_details: a buffer containing an error message if the method does not
+///  function correctly. It is OK to pass nullptr into error_details.
+///
+/// On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
+/// error status code along with its details specified in error_details (if
+/// error_details is not nullptr).
+///
 grpc_status_code alts_iovec_record_protocol_privacy_integrity_unprotect(
     alts_iovec_record_protocol* rp, iovec_t header,
     const iovec_t* protected_vec, size_t protected_vec_length,
     iovec_t unprotected_data, char** error_details);
 
-/**
- * This method creates an alts_iovec_record_protocol instance, given a
- * gsec_aead_crypter instance, a flag indicating if the created instance will be
- * used at the client or server side, and a flag indicating if the created
- * instance will be used for integrity-only mode or privacy-integrity mode. The
- * ownership of gsec_aead_crypter instance is transferred to this new object.
- *
- * - crypter: a gsec_aead_crypter instance used to perform AEAD decryption.
- * - overflow_size: overflow size of counter in bytes.
- * - is_client: a flag indicating if the alts_iovec_record_protocol instance
- *   will be used at the client or server side.
- * - is_integrity_only: a flag indicating if the alts_iovec_record_protocol
- *   instance will be used for integrity-only or privacy-integrity mode.
- * - is_protect: a flag indicating if the alts_grpc_record_protocol instance
- *   will be used for protect or unprotect.
- * - rp: an alts_iovec_record_protocol instance to be returned from
- *   the method.
- * - error_details: a buffer containing an error message if the method does not
- *   function correctly. It is OK to pass nullptr into error_details.
- *
- * On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
- * error status code along with its details specified in error_details (if
- * error_details is not nullptr).
- */
+///
+/// This method creates an alts_iovec_record_protocol instance, given a
+/// gsec_aead_crypter instance, a flag indicating if the created instance will
+/// be used at the client or server side, and a flag indicating if the created
+/// instance will be used for integrity-only mode or privacy-integrity mode. The
+/// ownership of gsec_aead_crypter instance is transferred to this new object.
+///
+///- crypter: a gsec_aead_crypter instance used to perform AEAD decryption.
+///- overflow_size: overflow size of counter in bytes.
+///- is_client: a flag indicating if the alts_iovec_record_protocol instance
+///  will be used at the client or server side.
+///- is_integrity_only: a flag indicating if the alts_iovec_record_protocol
+///  instance will be used for integrity-only or privacy-integrity mode.
+///- is_protect: a flag indicating if the alts_grpc_record_protocol instance
+///  will be used for protect or unprotect.
+///- rp: an alts_iovec_record_protocol instance to be returned from
+///  the method.
+///- error_details: a buffer containing an error message if the method does not
+///  function correctly. It is OK to pass nullptr into error_details.
+///
+/// On success, the method returns GRPC_STATUS_OK. Otherwise, it returns an
+/// error status code along with its details specified in error_details (if
+/// error_details is not nullptr).
+///
 grpc_status_code alts_iovec_record_protocol_create(
     gsec_aead_crypter* crypter, size_t overflow_size, bool is_client,
     bool is_integrity_only, bool is_protect, alts_iovec_record_protocol** rp,
     char** error_details);
 
-/**
- * This method destroys an alts_iovec_record_protocol instance by de-allocating
- * all of its occupied memory. A gsec_aead_crypter instance passed in at
- * gsec_alts_crypter instance creation time will be destroyed in this method.
- */
+///
+/// This method destroys an alts_iovec_record_protocol instance by de-allocating
+/// all of its occupied memory. A gsec_aead_crypter instance passed in at
+/// gsec_alts_crypter instance creation time will be destroyed in this method.
+///
 void alts_iovec_record_protocol_destroy(alts_iovec_record_protocol* rp);
 
-#endif /* GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_IOVEC_RECORD_PROTOCOL_H \
-        */
+#endif  // GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_IOVEC_RECORD_PROTOCOL_H

data/src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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>
 
@@ -26,6 +26,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/alts/crypt/gsec.h"
@@ -39,13 +40,13 @@ constexpr size_t kMinFrameLength = 1024;
 constexpr size_t kDefaultFrameLength = 16 * 1024;
 constexpr size_t kMaxFrameLength = 16 * 1024 * 1024;
 
-/**
- * Main struct for alts_zero_copy_grpc_protector.
- * We choose to have two alts_grpc_record_protocol objects and two sets of slice
- * buffers: one for protect and the other for unprotect, so that protect and
- * unprotect can be executed in parallel. Implementations of this object must be
- * thread compatible.
- */
+///
+/// Main struct for alts_zero_copy_grpc_protector.
+/// We choose to have two alts_grpc_record_protocol objects and two sets of
+/// slice buffers: one for protect and the other for unprotect, so that protect
+/// and unprotect can be executed in parallel. Implementations of this object
+/// must be thread compatible.
+///
 typedef struct alts_zero_copy_grpc_protector {
   tsi_zero_copy_grpc_protector base;
   alts_grpc_record_protocol* record_protocol;
@@ -58,12 +59,12 @@ typedef struct alts_zero_copy_grpc_protector {
   uint32_t parsed_frame_size;
 } alts_zero_copy_grpc_protector;
 
-/**
- * Given a slice buffer, parses the first 4 bytes little-endian unsigned frame
- * size and returns the total frame size including the frame field. Caller
- * needs to make sure the input slice buffer has at least 4 bytes. Returns true
- * on success and false on failure.
- */
+///
+/// Given a slice buffer, parses the first 4 bytes little-endian unsigned frame
+/// size and returns the total frame size including the frame field. Caller
+/// needs to make sure the input slice buffer has at least 4 bytes. Returns true
+/// on success and false on failure.
+///
 static bool read_frame_size(const grpc_slice_buffer* sb,
                             uint32_t* total_frame_size) {
   if (sb == nullptr || sb->length < kZeroCopyFrameLengthFieldSize) {
@@ -71,7 +72,7 @@ static bool read_frame_size(const grpc_slice_buffer* sb,
   }
   uint8_t frame_size_buffer[kZeroCopyFrameLengthFieldSize];
   uint8_t* buf = frame_size_buffer;
-  /* Copies the first 4 bytes to a temporary buffer.  */
+  // Copies the first 4 bytes to a temporary buffer.
   size_t remaining = kZeroCopyFrameLengthFieldSize;
   for (size_t i = 0; i < sb->count; i++) {
     size_t slice_length = GRPC_SLICE_LENGTH(sb->slices[i]);
@@ -86,7 +87,7 @@ static bool read_frame_size(const grpc_slice_buffer* sb,
     }
   }
   GPR_ASSERT(remaining == 0);
-  /* Gets little-endian frame size.  */
+  // Gets little-endian frame size.
   uint32_t frame_size = (static_cast<uint32_t>(frame_size_buffer[3]) << 24) |
                         (static_cast<uint32_t>(frame_size_buffer[2]) << 16) |
                         (static_cast<uint32_t>(frame_size_buffer[1]) << 8) |
@@ -95,19 +96,19 @@ static bool read_frame_size(const grpc_slice_buffer* sb,
     gpr_log(GPR_ERROR, "Frame size is larger than maximum frame size");
     return false;
   }
-  /* Returns frame size including frame length field.  */
+  // Returns frame size including frame length field.
   *total_frame_size =
       static_cast<uint32_t>(frame_size + kZeroCopyFrameLengthFieldSize);
   return true;
 }
 
-/**
- * Creates an alts_grpc_record_protocol object, given key, key size, and flags
- * to indicate whether the record_protocol object uses the rekeying AEAD,
- * whether the object is for client or server, whether the object is for
- * integrity-only or privacy-integrity mode, and whether the object is used
- * for protect or unprotect.
- */
+///
+/// Creates an alts_grpc_record_protocol object, given key, key size, and flags
+/// to indicate whether the record_protocol object uses the rekeying AEAD,
+/// whether the object is for client or server, whether the object is for
+/// integrity-only or privacy-integrity mode, and whether the object is used
+/// for protect or unprotect.
+///
 static tsi_result create_alts_grpc_record_protocol(
     const uint8_t* key, size_t key_size, bool is_rekey, bool is_client,
     bool is_integrity_only, bool is_protect, bool enable_extra_copy,
@@ -128,8 +129,8 @@ static tsi_result create_alts_grpc_record_protocol(
   }
   size_t overflow_limit = is_rekey ? kAltsRecordProtocolRekeyFrameLimit
                                    : kAltsRecordProtocolFrameLimit;
-  /* Creates alts_grpc_record_protocol with AEAD crypter ownership transferred.
-   */
+  // Creates alts_grpc_record_protocol with AEAD crypter ownership transferred.
+  //
   tsi_result result = is_integrity_only
                           ? alts_grpc_integrity_only_record_protocol_create(
                                 crypter, overflow_limit, is_client, is_protect,
@@ -144,7 +145,7 @@ static tsi_result create_alts_grpc_record_protocol(
   return TSI_OK;
 }
 
-/* --- tsi_zero_copy_grpc_protector methods implementation. --- */
+// --- tsi_zero_copy_grpc_protector methods implementation. ---
 
 static tsi_result alts_zero_copy_grpc_protector_protect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* unprotected_slices,
@@ -156,7 +157,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
   }
   alts_zero_copy_grpc_protector* protector =
       reinterpret_cast<alts_zero_copy_grpc_protector*>(self);
-  /* Calls alts_grpc_record_protocol protect repeatly.  */
+  // Calls alts_grpc_record_protocol protect repeatly.
   while (unprotected_slices->length > protector->max_unprotected_data_size) {
     grpc_slice_buffer_move_first(unprotected_slices,
                                  protector->max_unprotected_data_size,
@@ -174,7 +175,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
 
 static tsi_result alts_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices) {
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
     gpr_log(GPR_ERROR,
@@ -184,18 +185,18 @@ static tsi_result alts_zero_copy_grpc_protector_unprotect(
   alts_zero_copy_grpc_protector* protector =
       reinterpret_cast<alts_zero_copy_grpc_protector*>(self);
   grpc_slice_buffer_move_into(protected_slices, &protector->protected_sb);
-  /* Keep unprotecting each frame if possible.  */
+  // Keep unprotecting each frame if possible.
   while (protector->protected_sb.length >= kZeroCopyFrameLengthFieldSize) {
     if (protector->parsed_frame_size == 0) {
-      /* We have not parsed frame size yet. Parses frame size.  */
+      // We have not parsed frame size yet. Parses frame size.
       if (!read_frame_size(&protector->protected_sb,
                            &protector->parsed_frame_size)) {
-        grpc_slice_buffer_reset_and_unref_internal(&protector->protected_sb);
+        grpc_slice_buffer_reset_and_unref(&protector->protected_sb);
         return TSI_DATA_CORRUPTED;
       }
     }
     if (protector->protected_sb.length < protector->parsed_frame_size) break;
-    /* At this point, protected_sb contains at least one frame of data.  */
+    // At this point, protected_sb contains at least one frame of data.
     tsi_result status;
     if (protector->protected_sb.length == protector->parsed_frame_size) {
       status = alts_grpc_record_protocol_unprotect(protector->unrecord_protocol,
@@ -211,10 +212,18 @@ static tsi_result alts_zero_copy_grpc_protector_unprotect(
     }
     protector->parsed_frame_size = 0;
     if (status != TSI_OK) {
-      grpc_slice_buffer_reset_and_unref_internal(&protector->protected_sb);
+      grpc_slice_buffer_reset_and_unref(&protector->protected_sb);
       return status;
     }
   }
+  if (min_progress_size != nullptr) {
+    if (protector->parsed_frame_size > kZeroCopyFrameLengthFieldSize) {
+      *min_progress_size =
+          protector->parsed_frame_size - protector->protected_sb.length;
+    } else {
+      *min_progress_size = 1;
+    }
+  }
   return TSI_OK;
 }
 
@@ -227,9 +236,9 @@ static void alts_zero_copy_grpc_protector_destroy(
       reinterpret_cast<alts_zero_copy_grpc_protector*>(self);
   alts_grpc_record_protocol_destroy(protector->record_protocol);
   alts_grpc_record_protocol_destroy(protector->unrecord_protocol);
-  grpc_slice_buffer_destroy_internal(&protector->unprotected_staging_sb);
-  grpc_slice_buffer_destroy_internal(&protector->protected_sb);
-  grpc_slice_buffer_destroy_internal(&protector->protected_staging_sb);
+  grpc_slice_buffer_destroy(&protector->unprotected_staging_sb);
+  grpc_slice_buffer_destroy(&protector->protected_sb);
+  grpc_slice_buffer_destroy(&protector->protected_staging_sb);
   gpr_free(protector);
 }
 
@@ -261,11 +270,11 @@ tsi_result alts_zero_copy_grpc_protector_create(
         "Invalid nullptr arguments to alts_zero_copy_grpc_protector create.");
     return TSI_INVALID_ARGUMENT;
   }
-  /* Creates alts_zero_copy_protector.  */
+  // Creates alts_zero_copy_protector.
   alts_zero_copy_grpc_protector* impl =
       static_cast<alts_zero_copy_grpc_protector*>(
           gpr_zalloc(sizeof(alts_zero_copy_grpc_protector)));
-  /* Creates alts_grpc_record_protocol objects.  */
+  // Creates alts_grpc_record_protocol objects.
   tsi_result status = create_alts_grpc_record_protocol(
       key, key_size, is_rekey, is_client, is_integrity_only,
       /*is_protect=*/true, enable_extra_copy, &impl->record_protocol);
@@ -274,7 +283,7 @@ tsi_result alts_zero_copy_grpc_protector_create(
         key, key_size, is_rekey, is_client, is_integrity_only,
         /*is_protect=*/false, enable_extra_copy, &impl->unrecord_protocol);
     if (status == TSI_OK) {
-      /* Sets maximum frame size.  */
+      // Sets maximum frame size.
       size_t max_protected_frame_size_to_set = kDefaultFrameLength;
       if (max_protected_frame_size != nullptr) {
         *max_protected_frame_size =
@@ -288,7 +297,7 @@ tsi_result alts_zero_copy_grpc_protector_create(
           alts_grpc_record_protocol_max_unprotected_data_size(
               impl->record_protocol, max_protected_frame_size_to_set);
       GPR_ASSERT(impl->max_unprotected_data_size > 0);
-      /* Allocates internal slice buffers.  */
+      // Allocates internal slice buffers.
       grpc_slice_buffer_init(&impl->unprotected_staging_sb);
       grpc_slice_buffer_init(&impl->protected_sb);
       grpc_slice_buffer_init(&impl->protected_staging_sb);
@@ -299,7 +308,7 @@ tsi_result alts_zero_copy_grpc_protector_create(
     }
   }
 
-  /* Cleanup if create failed.  */
+  // Cleanup if create failed.
   alts_grpc_record_protocol_destroy(impl->record_protocol);
   alts_grpc_record_protocol_destroy(impl->unrecord_protocol);
   gpr_free(impl);