legacy-libs/grpc-cloned/deps/grpc/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.cc

   1 /*
   2  *
   3  * Copyright 2018 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <grpc/support/port_platform.h>
  20
  21 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.h"
  22
  23 #include <grpc/support/alloc.h>
  24 #include <grpc/support/log.h>
  25
  26 #include <string.h>
  27
  28 #include "src/core/lib/slice/slice_internal.h"
  29 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.h"
  30 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
  31
  32 /* Main struct for alts_grpc_integrity_only_record_protocol.  */
  33 typedef struct alts_grpc_integrity_only_record_protocol {
  34   alts_grpc_record_protocol base;
  35   bool enable_extra_copy;
  36   grpc_slice_buffer data_sb;
  37   unsigned char* tag_buf;
  38 } alts_grpc_integrity_only_record_protocol;
  39
  40 /* --- alts_grpc_record_protocol methods implementation. --- */
  41
  42 static tsi_result alts_grpc_integrity_only_extra_copy_protect(
  43     alts_grpc_record_protocol* rp, grpc_slice_buffer* unprotected_slices,
  44     grpc_slice_buffer* protected_slices) {
  45   /* Allocates memory for protected frame and copies data.  */
  46   size_t data_length = unprotected_slices->length;
  47   size_t protected_frame_size =
  48       unprotected_slices->length + rp->header_length + rp->tag_length;
  49   grpc_slice protected_slice = GRPC_SLICE_MALLOC(protected_frame_size);
  50   uint8_t* data = GRPC_SLICE_START_PTR(protected_slice) + rp->header_length;
  51   for (size_t i = 0; i < unprotected_slices->count; i++) {
  52     memcpy(data, GRPC_SLICE_START_PTR(unprotected_slices->slices[i]),
  53            GRPC_SLICE_LENGTH(unprotected_slices->slices[i]));
  54     data += GRPC_SLICE_LENGTH(unprotected_slices->slices[i]);
  55   }
  56   /* Calls alts_iovec_record_protocol protect.  */
  57   char* error_details = nullptr;
  58   iovec_t header_iovec = {GRPC_SLICE_START_PTR(protected_slice),
  59                           rp->header_length};
  60   iovec_t tag_iovec = {
  61       GRPC_SLICE_START_PTR(protected_slice) + rp->header_length + data_length,
  62       rp->tag_length};
  63   rp->iovec_buf[0].iov_base =
  64       GRPC_SLICE_START_PTR(protected_slice) + rp->header_length;
  65   rp->iovec_buf[0].iov_len = data_length;
  66   grpc_status_code status = alts_iovec_record_protocol_integrity_only_protect(
  67       rp->iovec_rp, rp->iovec_buf, 1, header_iovec, tag_iovec, &error_details);
  68   if (status != GRPC_STATUS_OK) {
  69     gpr_log(GPR_ERROR, "Failed to protect, %s", error_details);
  70     gpr_free(error_details);
  71     return TSI_INTERNAL_ERROR;
  72   }
  73   grpc_slice_buffer_add(protected_slices, protected_slice);
  74   grpc_slice_buffer_reset_and_unref_internal(unprotected_slices);
  75   return TSI_OK;
  76 }
  77
  78 static tsi_result alts_grpc_integrity_only_protect(
  79     alts_grpc_record_protocol* rp, grpc_slice_buffer* unprotected_slices,
  80     grpc_slice_buffer* protected_slices) {
  81   /* Input sanity check.  */
  82   if (rp == nullptr || unprotected_slices == nullptr ||
  83       protected_slices == nullptr) {
  84     gpr_log(GPR_ERROR,
  85             "Invalid nullptr arguments to alts_grpc_record_protocol protect.");
  86     return TSI_INVALID_ARGUMENT;
  87   }
  88   alts_grpc_integrity_only_record_protocol* integrity_only_record_protocol =
  89       reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp);
  90   if (integrity_only_record_protocol->enable_extra_copy) {
  91     return alts_grpc_integrity_only_extra_copy_protect(rp, unprotected_slices,
  92                                                        protected_slices);
  93   }
  94   /* Allocates memory for header and tag slices.  */
  95   grpc_slice header_slice = GRPC_SLICE_MALLOC(rp->header_length);
  96   grpc_slice tag_slice = GRPC_SLICE_MALLOC(rp->tag_length);
  97   /* Calls alts_iovec_record_protocol protect.  */
  98   char* error_details = nullptr;
  99   iovec_t header_iovec = {GRPC_SLICE_START_PTR(header_slice),
 100                           GRPC_SLICE_LENGTH(header_slice)};
 101   iovec_t tag_iovec = {GRPC_SLICE_START_PTR(tag_slice),
 102                        GRPC_SLICE_LENGTH(tag_slice)};
 103   alts_grpc_record_protocol_convert_slice_buffer_to_iovec(rp,
 104                                                           unprotected_slices);
 105   grpc_status_code status = alts_iovec_record_protocol_integrity_only_protect(
 106       rp->iovec_rp, rp->iovec_buf, unprotected_slices->count, header_iovec,
 107       tag_iovec, &error_details);
 108   if (status != GRPC_STATUS_OK) {
 109     gpr_log(GPR_ERROR, "Failed to protect, %s", error_details);
 110     gpr_free(error_details);
 111     return TSI_INTERNAL_ERROR;
 112   }
 113   /* Appends result to protected_slices.  */
 114   grpc_slice_buffer_add(protected_slices, header_slice);
 115   grpc_slice_buffer_move_into(unprotected_slices, protected_slices);
 116   grpc_slice_buffer_add(protected_slices, tag_slice);
 117   return TSI_OK;
 118 }
 119
 120 static tsi_result alts_grpc_integrity_only_unprotect(
 121     alts_grpc_record_protocol* rp, grpc_slice_buffer* protected_slices,
 122     grpc_slice_buffer* unprotected_slices) {
 123   /* Input sanity check.  */
 124   if (rp == nullptr || protected_slices == nullptr ||
 125       unprotected_slices == nullptr) {
 126     gpr_log(
 127         GPR_ERROR,
 128         "Invalid nullptr arguments to alts_grpc_record_protocol unprotect.");
 129     return TSI_INVALID_ARGUMENT;
 130   }
 131   if (protected_slices->length < rp->header_length + rp->tag_length) {
 132     gpr_log(GPR_ERROR, "Protected slices do not have sufficient data.");
 133     return TSI_INVALID_ARGUMENT;
 134   }
 135   /* In this method, rp points to alts_grpc_record_protocol struct
 136    * and integrity_only_record_protocol points to
 137    * alts_grpc_integrity_only_record_protocol struct.  */
 138   alts_grpc_integrity_only_record_protocol* integrity_only_record_protocol =
 139       reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp);
 140   /* Strips frame header from protected slices.  */
 141   grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
 142   grpc_slice_buffer_move_first(protected_slices, rp->header_length,
 143                                &rp->header_sb);
 144   GPR_ASSERT(rp->header_sb.length == rp->header_length);
 145   iovec_t header_iovec = alts_grpc_record_protocol_get_header_iovec(rp);
 146   /* Moves protected slices data to data_sb and leaves the remaining tag.  */
 147   grpc_slice_buffer_reset_and_unref_internal(
 148       &integrity_only_record_protocol->data_sb);
 149   grpc_slice_buffer_move_first(protected_slices,
 150                                protected_slices->length - rp->tag_length,
 151                                &integrity_only_record_protocol->data_sb);
 152   GPR_ASSERT(protected_slices->length == rp->tag_length);
 153   iovec_t tag_iovec = {nullptr, rp->tag_length};
 154   if (protected_slices->count == 1) {
 155     tag_iovec.iov_base = GRPC_SLICE_START_PTR(protected_slices->slices[0]);
 156   } else {
 157     /* Frame tag is in multiple slices, copies the tag bytes from slice
 158      * buffer to a single flat buffer.  */
 159     alts_grpc_record_protocol_copy_slice_buffer(
 160         protected_slices, integrity_only_record_protocol->tag_buf);
 161     tag_iovec.iov_base = integrity_only_record_protocol->tag_buf;
 162   }
 163   /* Calls alts_iovec_record_protocol unprotect.  */
 164   char* error_details = nullptr;
 165   alts_grpc_record_protocol_convert_slice_buffer_to_iovec(
 166       rp, &integrity_only_record_protocol->data_sb);
 167   grpc_status_code status = alts_iovec_record_protocol_integrity_only_unprotect(
 168       rp->iovec_rp, rp->iovec_buf,
 169       integrity_only_record_protocol->data_sb.count, header_iovec, tag_iovec,
 170       &error_details);
 171   if (status != GRPC_STATUS_OK) {
 172     gpr_log(GPR_ERROR, "Failed to unprotect, %s", error_details);
 173     gpr_free(error_details);
 174     return TSI_INTERNAL_ERROR;
 175   }
 176   grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
 177   grpc_slice_buffer_reset_and_unref_internal(protected_slices);
 178   grpc_slice_buffer_move_into(&integrity_only_record_protocol->data_sb,
 179                               unprotected_slices);
 180   return TSI_OK;
 181 }
 182
 183 static void alts_grpc_integrity_only_destruct(alts_grpc_record_protocol* rp) {
 184   if (rp == nullptr) {
 185     return;
 186   }
 187   alts_grpc_integrity_only_record_protocol* integrity_only_rp =
 188       reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp);
 189   grpc_slice_buffer_destroy_internal(&integrity_only_rp->data_sb);
 190   gpr_free(integrity_only_rp->tag_buf);
 191 }
 192
 193 static const alts_grpc_record_protocol_vtable
 194     alts_grpc_integrity_only_record_protocol_vtable = {
 195         alts_grpc_integrity_only_protect, alts_grpc_integrity_only_unprotect,
 196         alts_grpc_integrity_only_destruct};
 197
 198 tsi_result alts_grpc_integrity_only_record_protocol_create(
 199     gsec_aead_crypter* crypter, size_t overflow_size, bool is_client,
 200     bool is_protect, bool enable_extra_copy, alts_grpc_record_protocol** rp) {
 201   if (crypter == nullptr || rp == nullptr) {
 202     gpr_log(GPR_ERROR,
 203             "Invalid nullptr arguments to alts_grpc_record_protocol create.");
 204     return TSI_INVALID_ARGUMENT;
 205   }
 206   alts_grpc_integrity_only_record_protocol* impl =
 207       static_cast<alts_grpc_integrity_only_record_protocol*>(
 208           gpr_zalloc(sizeof(alts_grpc_integrity_only_record_protocol)));
 209   /* Calls alts_grpc_record_protocol init.  */
 210   tsi_result result = alts_grpc_record_protocol_init(
 211       &impl->base, crypter, overflow_size, is_client,
 212       /*is_integrity_only=*/true, is_protect);
 213   if (result != TSI_OK) {
 214     gpr_free(impl);
 215     return result;
 216   }
 217   impl->enable_extra_copy = enable_extra_copy;
 218   /* Initializes slice buffer for data_sb.  */
 219   grpc_slice_buffer_init(&impl->data_sb);
 220   /* Allocates tag buffer.  */
 221   impl->tag_buf =
 222       static_cast<unsigned char*>(gpr_malloc(impl->base.tag_length));
 223   impl->base.vtable = &alts_grpc_integrity_only_record_protocol_vtable;
 224   *rp = &impl->base;
 225   return TSI_OK;
 226 }