| /* |
| * |
| * 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> |
| |
| #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.h" |
| |
| #include <grpc/support/alloc.h> |
| #include <grpc/support/log.h> |
| |
| #include <string.h> |
| |
| #include "src/core/lib/slice/slice_internal.h" |
| #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.h" |
| #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h" |
| |
| /* Main struct for alts_grpc_integrity_only_record_protocol. */ |
| typedef struct alts_grpc_integrity_only_record_protocol { |
| alts_grpc_record_protocol base; |
| bool enable_extra_copy; |
| grpc_slice_buffer data_sb; |
| unsigned char* tag_buf; |
| } alts_grpc_integrity_only_record_protocol; |
| |
| /* --- alts_grpc_record_protocol methods implementation. --- */ |
| |
| static tsi_result alts_grpc_integrity_only_extra_copy_protect( |
| alts_grpc_record_protocol* rp, grpc_slice_buffer* unprotected_slices, |
| grpc_slice_buffer* protected_slices) { |
| /* Allocates memory for protected frame and copies data. */ |
| size_t data_length = unprotected_slices->length; |
| size_t protected_frame_size = |
| unprotected_slices->length + rp->header_length + rp->tag_length; |
| grpc_slice protected_slice = GRPC_SLICE_MALLOC(protected_frame_size); |
| uint8_t* data = GRPC_SLICE_START_PTR(protected_slice) + rp->header_length; |
| for (size_t i = 0; i < unprotected_slices->count; i++) { |
| memcpy(data, GRPC_SLICE_START_PTR(unprotected_slices->slices[i]), |
| GRPC_SLICE_LENGTH(unprotected_slices->slices[i])); |
| data += GRPC_SLICE_LENGTH(unprotected_slices->slices[i]); |
| } |
| /* Calls alts_iovec_record_protocol protect. */ |
| char* error_details = nullptr; |
| iovec_t header_iovec = {GRPC_SLICE_START_PTR(protected_slice), |
| rp->header_length}; |
| iovec_t tag_iovec = { |
| GRPC_SLICE_START_PTR(protected_slice) + rp->header_length + data_length, |
| rp->tag_length}; |
| rp->iovec_buf[0].iov_base = |
| GRPC_SLICE_START_PTR(protected_slice) + rp->header_length; |
| rp->iovec_buf[0].iov_len = data_length; |
| grpc_status_code status = alts_iovec_record_protocol_integrity_only_protect( |
| rp->iovec_rp, rp->iovec_buf, 1, header_iovec, tag_iovec, &error_details); |
| if (status != GRPC_STATUS_OK) { |
| gpr_log(GPR_ERROR, "Failed to protect, %s", error_details); |
| gpr_free(error_details); |
| return TSI_INTERNAL_ERROR; |
| } |
| grpc_slice_buffer_add(protected_slices, protected_slice); |
| grpc_slice_buffer_reset_and_unref_internal(unprotected_slices); |
| return TSI_OK; |
| } |
| |
| static tsi_result alts_grpc_integrity_only_protect( |
| alts_grpc_record_protocol* rp, grpc_slice_buffer* unprotected_slices, |
| grpc_slice_buffer* protected_slices) { |
| /* Input sanity check. */ |
| if (rp == nullptr || unprotected_slices == nullptr || |
| protected_slices == nullptr) { |
| gpr_log(GPR_ERROR, |
| "Invalid nullptr arguments to alts_grpc_record_protocol protect."); |
| return TSI_INVALID_ARGUMENT; |
| } |
| alts_grpc_integrity_only_record_protocol* integrity_only_record_protocol = |
| reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp); |
| if (integrity_only_record_protocol->enable_extra_copy) { |
| return alts_grpc_integrity_only_extra_copy_protect(rp, unprotected_slices, |
| protected_slices); |
| } |
| /* Allocates memory for header and tag slices. */ |
| grpc_slice header_slice = GRPC_SLICE_MALLOC(rp->header_length); |
| grpc_slice tag_slice = GRPC_SLICE_MALLOC(rp->tag_length); |
| /* Calls alts_iovec_record_protocol protect. */ |
| char* error_details = nullptr; |
| iovec_t header_iovec = {GRPC_SLICE_START_PTR(header_slice), |
| GRPC_SLICE_LENGTH(header_slice)}; |
| iovec_t tag_iovec = {GRPC_SLICE_START_PTR(tag_slice), |
| GRPC_SLICE_LENGTH(tag_slice)}; |
| alts_grpc_record_protocol_convert_slice_buffer_to_iovec(rp, |
| unprotected_slices); |
| grpc_status_code status = alts_iovec_record_protocol_integrity_only_protect( |
| rp->iovec_rp, rp->iovec_buf, unprotected_slices->count, header_iovec, |
| tag_iovec, &error_details); |
| if (status != GRPC_STATUS_OK) { |
| gpr_log(GPR_ERROR, "Failed to protect, %s", error_details); |
| gpr_free(error_details); |
| return TSI_INTERNAL_ERROR; |
| } |
| /* Appends result to protected_slices. */ |
| grpc_slice_buffer_add(protected_slices, header_slice); |
| grpc_slice_buffer_move_into(unprotected_slices, protected_slices); |
| grpc_slice_buffer_add(protected_slices, tag_slice); |
| return TSI_OK; |
| } |
| |
| static tsi_result alts_grpc_integrity_only_unprotect( |
| alts_grpc_record_protocol* rp, grpc_slice_buffer* protected_slices, |
| grpc_slice_buffer* unprotected_slices) { |
| /* Input sanity check. */ |
| if (rp == nullptr || protected_slices == nullptr || |
| unprotected_slices == nullptr) { |
| gpr_log( |
| GPR_ERROR, |
| "Invalid nullptr arguments to alts_grpc_record_protocol unprotect."); |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (protected_slices->length < rp->header_length + rp->tag_length) { |
| gpr_log(GPR_ERROR, "Protected slices do not have sufficient data."); |
| return TSI_INVALID_ARGUMENT; |
| } |
| /* In this method, rp points to alts_grpc_record_protocol struct |
| * and integrity_only_record_protocol points to |
| * alts_grpc_integrity_only_record_protocol struct. */ |
| alts_grpc_integrity_only_record_protocol* integrity_only_record_protocol = |
| reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp); |
| /* Strips frame header from protected slices. */ |
| grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb); |
| grpc_slice_buffer_move_first(protected_slices, rp->header_length, |
| &rp->header_sb); |
| GPR_ASSERT(rp->header_sb.length == rp->header_length); |
| iovec_t header_iovec = alts_grpc_record_protocol_get_header_iovec(rp); |
| /* Moves protected slices data to data_sb and leaves the remaining tag. */ |
| grpc_slice_buffer_reset_and_unref_internal( |
| &integrity_only_record_protocol->data_sb); |
| grpc_slice_buffer_move_first(protected_slices, |
| protected_slices->length - rp->tag_length, |
| &integrity_only_record_protocol->data_sb); |
| GPR_ASSERT(protected_slices->length == rp->tag_length); |
| iovec_t tag_iovec = {nullptr, rp->tag_length}; |
| if (protected_slices->count == 1) { |
| tag_iovec.iov_base = GRPC_SLICE_START_PTR(protected_slices->slices[0]); |
| } else { |
| /* Frame tag is in multiple slices, copies the tag bytes from slice |
| * buffer to a single flat buffer. */ |
| alts_grpc_record_protocol_copy_slice_buffer( |
| protected_slices, integrity_only_record_protocol->tag_buf); |
| tag_iovec.iov_base = integrity_only_record_protocol->tag_buf; |
| } |
| /* Calls alts_iovec_record_protocol unprotect. */ |
| char* error_details = nullptr; |
| alts_grpc_record_protocol_convert_slice_buffer_to_iovec( |
| rp, &integrity_only_record_protocol->data_sb); |
| grpc_status_code status = alts_iovec_record_protocol_integrity_only_unprotect( |
| rp->iovec_rp, rp->iovec_buf, |
| integrity_only_record_protocol->data_sb.count, header_iovec, tag_iovec, |
| &error_details); |
| if (status != GRPC_STATUS_OK) { |
| gpr_log(GPR_ERROR, "Failed to unprotect, %s", error_details); |
| gpr_free(error_details); |
| return TSI_INTERNAL_ERROR; |
| } |
| grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb); |
| grpc_slice_buffer_reset_and_unref_internal(protected_slices); |
| grpc_slice_buffer_move_into(&integrity_only_record_protocol->data_sb, |
| unprotected_slices); |
| return TSI_OK; |
| } |
| |
| static void alts_grpc_integrity_only_destruct(alts_grpc_record_protocol* rp) { |
| if (rp == nullptr) { |
| return; |
| } |
| alts_grpc_integrity_only_record_protocol* integrity_only_rp = |
| reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp); |
| grpc_slice_buffer_destroy_internal(&integrity_only_rp->data_sb); |
| gpr_free(integrity_only_rp->tag_buf); |
| } |
| |
| static const alts_grpc_record_protocol_vtable |
| alts_grpc_integrity_only_record_protocol_vtable = { |
| alts_grpc_integrity_only_protect, alts_grpc_integrity_only_unprotect, |
| alts_grpc_integrity_only_destruct}; |
| |
| tsi_result alts_grpc_integrity_only_record_protocol_create( |
| gsec_aead_crypter* crypter, size_t overflow_size, bool is_client, |
| bool is_protect, bool enable_extra_copy, alts_grpc_record_protocol** rp) { |
| if (crypter == nullptr || rp == nullptr) { |
| gpr_log(GPR_ERROR, |
| "Invalid nullptr arguments to alts_grpc_record_protocol create."); |
| return TSI_INVALID_ARGUMENT; |
| } |
| alts_grpc_integrity_only_record_protocol* impl = |
| static_cast<alts_grpc_integrity_only_record_protocol*>( |
| gpr_zalloc(sizeof(alts_grpc_integrity_only_record_protocol))); |
| /* Calls alts_grpc_record_protocol init. */ |
| tsi_result result = alts_grpc_record_protocol_init( |
| &impl->base, crypter, overflow_size, is_client, |
| /*is_integrity_only=*/true, is_protect); |
| if (result != TSI_OK) { |
| gpr_free(impl); |
| return result; |
| } |
| impl->enable_extra_copy = enable_extra_copy; |
| /* Initializes slice buffer for data_sb. */ |
| grpc_slice_buffer_init(&impl->data_sb); |
| /* Allocates tag buffer. */ |
| impl->tag_buf = |
| static_cast<unsigned char*>(gpr_malloc(impl->base.tag_length)); |
| impl->base.vtable = &alts_grpc_integrity_only_record_protocol_vtable; |
| *rp = &impl->base; |
| return TSI_OK; |
| } |