grpc 1.51.0 → 1.52.0.pre2

data/src/core/tsi/alts/frame_protector/alts_frame_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>
 
@@ -29,6 +29,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/tsi/alts/crypt/gsec.h"
 #include "src/core/tsi/alts/frame_protector/alts_crypter.h"
 #include "src/core/tsi/alts/frame_protector/frame_handler.h"
@@ -42,7 +43,7 @@ constexpr size_t kMaxFrameLength = 1024 * 1024;
 constexpr size_t kAltsRecordProtocolRekeyFrameLimit = 8;
 constexpr size_t kAltsRecordProtocolFrameLimit = 5;
 
-/* Main struct for alts_frame_protector. */
+// Main struct for alts_frame_protector.
 struct alts_frame_protector {
   tsi_frame_protector base;
   alts_crypter* seal_crypter;
@@ -90,20 +91,20 @@ static tsi_result alts_protect_flush(tsi_frame_protector* self,
     return TSI_INVALID_ARGUMENT;
   }
   alts_frame_protector* impl = reinterpret_cast<alts_frame_protector*>(self);
-  /**
-   * If there's nothing to flush (i.e., in_place_protect_buffer is empty),
-   * we're done.
-   */
+  ///
+  /// If there's nothing to flush (i.e., in_place_protect_buffer is empty),
+  /// we're done.
+  ///
   if (impl->in_place_protect_bytes_buffered == 0) {
     *protected_output_frames_size = 0;
     *still_pending_size = 0;
     return TSI_OK;
   }
-  /**
-   * If a new frame can start being processed, we encrypt the payload and reset
-   * the frame writer to point to in_place_protect_buffer that holds the newly
-   * sealed frame.
-   */
+  ///
+  /// If a new frame can start being processed, we encrypt the payload and reset
+  /// the frame writer to point to in_place_protect_buffer that holds the newly
+  /// sealed frame.
+  ///
   if (alts_is_frame_writer_done(impl->writer)) {
     tsi_result result = seal(impl);
     if (result != TSI_OK) {
@@ -115,12 +116,12 @@ static tsi_result alts_protect_flush(tsi_frame_protector* self,
       return TSI_INTERNAL_ERROR;
     }
   }
-  /**
-   * Write the sealed frame as much as possible to protected_output_frames. It's
-   * possible a frame will not be written out completely by a single flush
-   * (i.e., still_pending_size != 0), in which case the flush should be called
-   * iteratively until a complete frame has been written out.
-   */
+  ///
+  /// Write the sealed frame as much as possible to protected_output_frames.
+  /// It's possible a frame will not be written out completely by a single flush
+  ///(i.e., still_pending_size != 0), in which case the flush should be called
+  /// iteratively until a complete frame has been written out.
+  ///
   size_t written_frame_bytes = *protected_output_frames_size;
   if (!alts_write_frame_bytes(impl->writer, protected_output_frames,
                               &written_frame_bytes)) {
@@ -129,10 +130,10 @@ static tsi_result alts_protect_flush(tsi_frame_protector* self,
   }
   *protected_output_frames_size = written_frame_bytes;
   *still_pending_size = alts_get_num_writer_bytes_remaining(impl->writer);
-  /**
-   * If the current frame has been finished processing (i.e., sealed and written
-   * out completely), we empty in_place_protect_buffer.
-   */
+  ///
+  /// If the current frame has been finished processing (i.e., sealed and
+  /// written out completely), we empty in_place_protect_buffer.
+  ///
   if (alts_is_frame_writer_done(impl->writer)) {
     impl->in_place_protect_bytes_buffered = 0;
   }
@@ -152,10 +153,10 @@ static tsi_result alts_protect(tsi_frame_protector* self,
   }
   alts_frame_protector* impl = reinterpret_cast<alts_frame_protector*>(self);
 
-  /**
-   * If more payload can be buffered, we buffer it as much as possible to
-   * in_place_protect_buffer.
-   */
+  ///
+  /// If more payload can be buffered, we buffer it as much as possible to
+  /// in_place_protect_buffer.
+  ///
   if (impl->in_place_protect_bytes_buffered + impl->overhead_length <
       max_encrypted_payload_bytes(impl)) {
     size_t bytes_to_buffer = std::min(
@@ -172,12 +173,12 @@ static tsi_result alts_protect(tsi_frame_protector* self,
   } else {
     *unprotected_bytes_size = 0;
   }
-  /**
-   * If a full frame has been buffered, we output it. If the first condition
-   * holds, then there exists an unencrypted full frame. If the second
-   * condition holds, then there exists a full frame that has already been
-   * encrypted.
-   */
+  ///
+  /// If a full frame has been buffered, we output it. If the first condition
+  /// holds, then there exists an unencrypted full frame. If the second
+  /// condition holds, then there exists a full frame that has already been
+  /// encrypted.
+  ///
   if (max_encrypted_payload_bytes(impl) ==
           impl->in_place_protect_bytes_buffered + impl->overhead_length ||
       max_encrypted_payload_bytes(impl) ==
@@ -213,10 +214,10 @@ static void ensure_buffer_size(alts_frame_protector* impl) {
   }
   size_t buffer_space_remaining = impl->max_unprotected_frame_size -
                                   alts_get_output_bytes_read(impl->reader);
-  /**
-   * Check if we need to resize in_place_unprotect_buffer in order to hold
-   * remaining bytes of a full frame.
-   */
+  ///
+  /// Check if we need to resize in_place_unprotect_buffer in order to hold
+  /// remaining bytes of a full frame.
+  ///
   if (buffer_space_remaining < alts_get_reader_bytes_remaining(impl->reader)) {
     size_t buffer_len = alts_get_output_bytes_read(impl->reader) +
                         alts_get_reader_bytes_remaining(impl->reader);
@@ -243,11 +244,11 @@ static tsi_result alts_unprotect(tsi_frame_protector* self,
     return TSI_INVALID_ARGUMENT;
   }
   alts_frame_protector* impl = reinterpret_cast<alts_frame_protector*>(self);
-  /**
-   * If a new frame can start being processed, we reset the frame reader to
-   * point to in_place_unprotect_buffer that will be used to hold deframed
-   * result.
-   */
+  ///
+  /// If a new frame can start being processed, we reset the frame reader to
+  /// point to in_place_unprotect_buffer that will be used to hold deframed
+  /// result.
+  ///
   if (alts_is_frame_reader_done(impl->reader) &&
       ((alts_get_output_buffer(impl->reader) == nullptr) ||
        (alts_get_output_bytes_read(impl->reader) ==
@@ -259,12 +260,12 @@ static tsi_result alts_unprotect(tsi_frame_protector* self,
     }
     impl->in_place_unprotect_bytes_processed = 0;
   }
-  /**
-   * If a full frame has not yet been read, we read more bytes from
-   * protected_frames_bytes until a full frame has been read. We also need to
-   * make sure in_place_unprotect_buffer is large enough to hold a complete
-   * frame.
-   */
+  ///
+  /// If a full frame has not yet been read, we read more bytes from
+  /// protected_frames_bytes until a full frame has been read. We also need to
+  /// make sure in_place_unprotect_buffer is large enough to hold a complete
+  /// frame.
+  ///
   if (!alts_is_frame_reader_done(impl->reader)) {
     ensure_buffer_size(impl);
     *protected_frames_bytes_size =
@@ -281,10 +282,10 @@ static tsi_result alts_unprotect(tsi_frame_protector* self,
   } else {
     *protected_frames_bytes_size = 0;
   }
-  /**
-   * If a full frame has been read, we unseal it, and write out the
-   * deframed result to unprotected_bytes.
-   */
+  ///
+  /// If a full frame has been read, we unseal it, and write out the
+  /// deframed result to unprotected_bytes.
+  ///
   if (alts_is_frame_reader_done(impl->reader)) {
     if (impl->in_place_unprotect_bytes_processed == 0) {
       tsi_result result = unseal(impl);
@@ -378,11 +379,11 @@ tsi_result alts_create_frame_protector(const uint8_t* key, size_t key_size,
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }
-  /**
-   * Set maximum frame size to be used by a frame protector. If it is nullptr, a
-   * default frame size will be used. Otherwise, the provided frame size will be
-   * adjusted (if not falling into a valid frame range) and used.
-   */
+  ///
+  /// Set maximum frame size to be used by a frame protector. If it is nullptr,
+  /// a default frame size will be used. Otherwise, the provided frame size will
+  /// be adjusted (if not falling into a valid frame range) and used.
+  ///
   size_t max_protected_frame_size_to_set = kDefaultFrameLength;
   if (max_protected_frame_size != nullptr) {
     *max_protected_frame_size =

data/src/core/tsi/alts/frame_protector/alts_frame_protector.h

@@ -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.
+//
+//
 
 #ifndef GRPC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_FRAME_PROTECTOR_H
 #define GRPC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_FRAME_PROTECTOR_H
@@ -27,29 +27,29 @@
 
 typedef struct alts_frame_protector alts_frame_protector;
 
-/**
- * TODO: Add a parameter to the interface to support the use of
- * different record protocols within a frame protector.
- *
- * This method creates a frame protector.
- *
- * - key: a symmetric key used to seal/unseal frames.
- * - key_size: the size of symmetric key.
- * - is_client: a flag indicating if the frame protector will be used at client
- *   (is_client = true) or server (is_client = false) side.
- * - is_rekey: a flag indicating if the frame protector will use an AEAD with
- *   rekeying.
- * - max_protected_frame_size: an in/out parameter indicating max frame size
- *   to be used by the frame protector. If it is nullptr, the default frame
- *   size will be used. Otherwise, the provided frame size will be adjusted (if
- *   not falling into a valid frame range) and used.
- * - self: a pointer to the frame protector returned from the method.
- *
- * This method returns TSI_OK on success and TSI_INTERNAL_ERROR otherwise.
- */
+///
+/// TODO: Add a parameter to the interface to support the use of
+/// different record protocols within a frame protector.
+///
+/// This method creates a frame protector.
+///
+///- key: a symmetric key used to seal/unseal frames.
+///- key_size: the size of symmetric key.
+///- is_client: a flag indicating if the frame protector will be used at client
+///  (is_client = true) or server (is_client = false) side.
+///- is_rekey: a flag indicating if the frame protector will use an AEAD with
+///  rekeying.
+///- max_protected_frame_size: an in/out parameter indicating max frame size
+///  to be used by the frame protector. If it is nullptr, the default frame
+///  size will be used. Otherwise, the provided frame size will be adjusted (if
+///  not falling into a valid frame range) and used.
+///- self: a pointer to the frame protector returned from the method.
+///
+/// This method returns TSI_OK on success and TSI_INTERNAL_ERROR otherwise.
+///
 tsi_result alts_create_frame_protector(const uint8_t* key, size_t key_size,
                                        bool is_client, bool is_rekey,
                                        size_t* max_protected_frame_size,
                                        tsi_frame_protector** self);
 
-#endif /* GRPC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_FRAME_PROTECTOR_H */
+#endif  // GRPC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_FRAME_PROTECTOR_H

data/src/core/tsi/alts/frame_protector/alts_record_protocol_crypter_common.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>
 
@@ -99,7 +99,7 @@ alts_record_protocol_crypter* alts_crypter_create_common(
     if (status != GRPC_STATUS_OK) {
       return nullptr;
     }
-    /* Create a counter. */
+    // Create a counter.
     status = alts_counter_create(is_client, counter_size, overflow_size,
                                  &rp_crypter->ctr, error_details);
     if (status != GRPC_STATUS_OK) {

data/src/core/tsi/alts/frame_protector/alts_record_protocol_crypter_common.h

@@ -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.
+//
+//
 
 #ifndef GRPC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_RECORD_PROTOCOL_CRYPTER_COMMON_H
 #define GRPC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_RECORD_PROTOCOL_CRYPTER_COMMON_H
@@ -26,89 +26,88 @@
 #include "src/core/tsi/alts/frame_protector/alts_counter.h"
 #include "src/core/tsi/alts/frame_protector/alts_crypter.h"
 
-/**
- * This file contains common implementation that will be used in both seal and
- * unseal operations.
- */
+///
+/// This file contains common implementation that will be used in both seal and
+/// unseal operations.
+///
 
-/**
- * Main struct for alts_record_protocol_crypter that will be used in both
- * seal and unseal operations.
- */
+///
+/// Main struct for alts_record_protocol_crypter that will be used in both
+/// seal and unseal operations.
+///
 typedef struct alts_record_protocol_crypter {
   alts_crypter base;
   gsec_aead_crypter* crypter;
   alts_counter* ctr;
 } alts_record_protocol_crypter;
 
-/**
- * This method performs input sanity checks on a subset of inputs to
- * alts_crypter_process_in_place() for both seal and unseal operations.
- *
- * - rp_crypter: an alts_record_protocol_crypter instance.
- * - data: it represents raw data that needs to be sealed in a seal operation or
- *   protected data that needs to be unsealed in an unseal operation.
- * - output_size: size of data written to the data buffer after a seal or
- *   unseal operation.
- * - error_details: a buffer containing an error message if any of checked
- *   inputs is nullptr. It is legal to pass nullptr into error_details and
- *   otherwise, the parameter should be freed with gpr_free.
- *
- * 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 input sanity checks on a subset of inputs to
+/// alts_crypter_process_in_place() for both seal and unseal operations.
+///
+///- rp_crypter: an alts_record_protocol_crypter instance.
+///- data: it represents raw data that needs to be sealed in a seal operation or
+///  protected data that needs to be unsealed in an unseal operation.
+///- output_size: size of data written to the data buffer after a seal or
+///  unseal operation.
+///- error_details: a buffer containing an error message if any of checked
+///  inputs is nullptr. It is legal to pass nullptr into error_details and
+///  otherwise, the parameter should be freed with gpr_free.
+///
+/// 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 input_sanity_check(
     const alts_record_protocol_crypter* rp_crypter, const unsigned char* data,
     size_t* output_size, char** error_details);
 
-/**
- * This method increments the counter within an alts_record_protocol_crypter
- * instance.
- *
- * - rp_crypter: an alts_record_protocol_crypter instance.
- * - error_details: a buffer containing an error message if the method does not
- *   function correctly or the counter is wrapped. It is legal to pass nullptr
- *   into error_details and otherwise, the parameter should be freed with
- *   gpr_free.
- *
- * 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 increments the counter within an alts_record_protocol_crypter
+/// instance.
+///
+///- rp_crypter: an alts_record_protocol_crypter instance.
+///- error_details: a buffer containing an error message if the method does not
+///  function correctly or the counter is wrapped. It is legal to pass nullptr
+///  into error_details and otherwise, the parameter should be freed with
+///  gpr_free.
+///
+/// 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 increment_counter(alts_record_protocol_crypter* rp_crypter,
                                    char** error_details);
 
-/**
- * This method creates an alts_crypter instance, and populates the fields
- * that are common to both seal and unseal operations.
- *
- * - crypter: a gsec_aead_crypter instance used to perform AEAD decryption. The
- *   function does not take ownership of crypter.
- * - is_client: a flag indicating if the alts_crypter instance will be
- *   used at the client (is_client = true) or server (is_client =
- *   false) side.
- * - overflow_size: overflow size of counter in bytes.
- * - error_details: a buffer containing an error message if the method does
- *   not function correctly. It is legal to pass nullptr into error_details, and
- *   otherwise, the parameter should be freed with gpr_free.
- *
- * On success of creation, the method returns alts_record_protocol_crypter
- * instance. Otherwise, it returns nullptr with its details specified in
- * error_details (if error_details is not nullptr).
- *
- */
+///
+/// This method creates an alts_crypter instance, and populates the fields
+/// that are common to both seal and unseal operations.
+///
+///- crypter: a gsec_aead_crypter instance used to perform AEAD decryption. The
+///  function does not take ownership of crypter.
+///- is_client: a flag indicating if the alts_crypter instance will be
+///  used at the client (is_client = true) or server (is_client =
+///  false) side.
+///- overflow_size: overflow size of counter in bytes.
+///- error_details: a buffer containing an error message if the method does
+///  not function correctly. It is legal to pass nullptr into error_details, and
+///  otherwise, the parameter should be freed with gpr_free.
+///
+/// On success of creation, the method returns alts_record_protocol_crypter
+/// instance. Otherwise, it returns nullptr with its details specified in
+/// error_details (if error_details is not nullptr).
+///
+///
 alts_record_protocol_crypter* alts_crypter_create_common(
     gsec_aead_crypter* crypter, bool is_client, size_t overflow_size,
     char** error_details);
 
-/**
- * For the following two methods, please refer to the corresponding API in
- * alts_crypter.h for detailed specifications.
- */
+///
+/// For the following two methods, please refer to the corresponding API in
+/// alts_crypter.h for detailed specifications.
+///
 size_t alts_record_protocol_crypter_num_overhead_bytes(const alts_crypter* c);
 
 void alts_record_protocol_crypter_destruct(alts_crypter* c);
 
-#endif /* GRPC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_RECORD_PROTOCOL_CRYPTER_COMMON_H \
-        */
+#endif  // GRPC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_RECORD_PROTOCOL_CRYPTER_COMMON_H

data/src/core/tsi/alts/frame_protector/alts_seal_privacy_integrity_crypter.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>
 
@@ -31,16 +31,16 @@ static void maybe_copy_error_msg(const char* src, char** dst) {
   }
 }
 
-/* Perform input santity check for a seal operation. */
+// Perform input santity check for a seal operation.
 static grpc_status_code seal_check(alts_crypter* c, const unsigned char* data,
                                    size_t data_allocated_size, size_t data_size,
                                    size_t* output_size, char** error_details) {
-  /* Do common input sanity check. */
+  // Do common input sanity check.
   grpc_status_code status = input_sanity_check(
       reinterpret_cast<const alts_record_protocol_crypter*>(c), data,
       output_size, error_details);
   if (status != GRPC_STATUS_OK) return status;
-  /* Do seal-specific check. */
+  // Do seal-specific check.
   size_t num_overhead_bytes =
       alts_crypter_num_overhead_bytes(reinterpret_cast<const alts_crypter*>(c));
   if (data_size == 0) {
@@ -66,7 +66,7 @@ static grpc_status_code alts_seal_crypter_process_in_place(
   if (status != GRPC_STATUS_OK) {
     return status;
   }
-  /* Do AEAD encryption. */
+  // Do AEAD encryption.
   alts_record_protocol_crypter* rp_crypter =
       reinterpret_cast<alts_record_protocol_crypter*>(c);
   status = gsec_aead_crypter_encrypt(
@@ -77,7 +77,7 @@ static grpc_status_code alts_seal_crypter_process_in_place(
   if (status != GRPC_STATUS_OK) {
     return status;
   }
-  /* Increment the crypter counter. */
+  // Increment the crypter counter.
   return increment_counter(rp_crypter, error_details);
 }