| /* |
| * |
| * Copyright 2015 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 "src/core/tsi/transport_security.h" |
| |
| #include <grpc/support/alloc.h> |
| #include <grpc/support/string_util.h> |
| |
| #include <stdlib.h> |
| #include <string.h> |
| |
| /* --- Tracing. --- */ |
| |
| grpc_tracer_flag tsi_tracing_enabled = GRPC_TRACER_INITIALIZER(false, "tsi"); |
| |
| /* --- tsi_result common implementation. --- */ |
| |
| const char *tsi_result_to_string(tsi_result result) { |
| switch (result) { |
| case TSI_OK: |
| return "TSI_OK"; |
| case TSI_UNKNOWN_ERROR: |
| return "TSI_UNKNOWN_ERROR"; |
| case TSI_INVALID_ARGUMENT: |
| return "TSI_INVALID_ARGUMENT"; |
| case TSI_PERMISSION_DENIED: |
| return "TSI_PERMISSION_DENIED"; |
| case TSI_INCOMPLETE_DATA: |
| return "TSI_INCOMPLETE_DATA"; |
| case TSI_FAILED_PRECONDITION: |
| return "TSI_FAILED_PRECONDITION"; |
| case TSI_UNIMPLEMENTED: |
| return "TSI_UNIMPLEMENTED"; |
| case TSI_INTERNAL_ERROR: |
| return "TSI_INTERNAL_ERROR"; |
| case TSI_DATA_CORRUPTED: |
| return "TSI_DATA_CORRUPTED"; |
| case TSI_NOT_FOUND: |
| return "TSI_NOT_FOUND"; |
| case TSI_PROTOCOL_FAILURE: |
| return "TSI_PROTOCOL_FAILURE"; |
| case TSI_HANDSHAKE_IN_PROGRESS: |
| return "TSI_HANDSHAKE_IN_PROGRESS"; |
| case TSI_OUT_OF_RESOURCES: |
| return "TSI_OUT_OF_RESOURCES"; |
| case TSI_ASYNC: |
| return "TSI_ASYNC"; |
| default: |
| return "UNKNOWN"; |
| } |
| } |
| |
| /* --- tsi_frame_protector common implementation. --- |
| |
| Calls specific implementation after state/input validation. */ |
| |
| tsi_result tsi_frame_protector_protect(tsi_frame_protector *self, |
| const unsigned char *unprotected_bytes, |
| size_t *unprotected_bytes_size, |
| unsigned char *protected_output_frames, |
| size_t *protected_output_frames_size) { |
| if (self == NULL || self->vtable == NULL || unprotected_bytes == NULL || |
| unprotected_bytes_size == NULL || protected_output_frames == NULL || |
| protected_output_frames_size == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (self->vtable->protect == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->protect(self, unprotected_bytes, unprotected_bytes_size, |
| protected_output_frames, |
| protected_output_frames_size); |
| } |
| |
| tsi_result tsi_frame_protector_protect_flush( |
| tsi_frame_protector *self, unsigned char *protected_output_frames, |
| size_t *protected_output_frames_size, size_t *still_pending_size) { |
| if (self == NULL || self->vtable == NULL || protected_output_frames == NULL || |
| protected_output_frames_size == NULL || still_pending_size == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (self->vtable->protect_flush == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->protect_flush(self, protected_output_frames, |
| protected_output_frames_size, |
| still_pending_size); |
| } |
| |
| tsi_result tsi_frame_protector_unprotect( |
| tsi_frame_protector *self, const unsigned char *protected_frames_bytes, |
| size_t *protected_frames_bytes_size, unsigned char *unprotected_bytes, |
| size_t *unprotected_bytes_size) { |
| if (self == NULL || self->vtable == NULL || protected_frames_bytes == NULL || |
| protected_frames_bytes_size == NULL || unprotected_bytes == NULL || |
| unprotected_bytes_size == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (self->vtable->unprotect == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->unprotect(self, protected_frames_bytes, |
| protected_frames_bytes_size, unprotected_bytes, |
| unprotected_bytes_size); |
| } |
| |
| void tsi_frame_protector_destroy(tsi_frame_protector *self) { |
| if (self == NULL) return; |
| self->vtable->destroy(self); |
| } |
| |
| /* --- tsi_handshaker common implementation. --- |
| |
| Calls specific implementation after state/input validation. */ |
| |
| tsi_result tsi_handshaker_get_bytes_to_send_to_peer(tsi_handshaker *self, |
| unsigned char *bytes, |
| size_t *bytes_size) { |
| if (self == NULL || self->vtable == NULL || bytes == NULL || |
| bytes_size == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
| if (self->vtable->get_bytes_to_send_to_peer == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->get_bytes_to_send_to_peer(self, bytes, bytes_size); |
| } |
| |
| tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker *self, |
| const unsigned char *bytes, |
| size_t *bytes_size) { |
| if (self == NULL || self->vtable == NULL || bytes == NULL || |
| bytes_size == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
| if (self->vtable->process_bytes_from_peer == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->process_bytes_from_peer(self, bytes, bytes_size); |
| } |
| |
| tsi_result tsi_handshaker_get_result(tsi_handshaker *self) { |
| if (self == NULL || self->vtable == NULL) return TSI_INVALID_ARGUMENT; |
| if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
| if (self->vtable->get_result == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->get_result(self); |
| } |
| |
| tsi_result tsi_handshaker_extract_peer(tsi_handshaker *self, tsi_peer *peer) { |
| if (self == NULL || self->vtable == NULL || peer == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| memset(peer, 0, sizeof(tsi_peer)); |
| if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
| if (tsi_handshaker_get_result(self) != TSI_OK) { |
| return TSI_FAILED_PRECONDITION; |
| } |
| if (self->vtable->extract_peer == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->extract_peer(self, peer); |
| } |
| |
| tsi_result tsi_handshaker_create_frame_protector( |
| tsi_handshaker *self, size_t *max_protected_frame_size, |
| tsi_frame_protector **protector) { |
| tsi_result result; |
| if (self == NULL || self->vtable == NULL || protector == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
| if (tsi_handshaker_get_result(self) != TSI_OK) return TSI_FAILED_PRECONDITION; |
| if (self->vtable->create_frame_protector == NULL) return TSI_UNIMPLEMENTED; |
| result = self->vtable->create_frame_protector(self, max_protected_frame_size, |
| protector); |
| if (result == TSI_OK) { |
| self->frame_protector_created = true; |
| } |
| return result; |
| } |
| |
| tsi_result tsi_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 **handshaker_result, |
| tsi_handshaker_on_next_done_cb cb, void *user_data) { |
| if (self == NULL || self->vtable == NULL) return TSI_INVALID_ARGUMENT; |
| if (self->handshaker_result_created) return TSI_FAILED_PRECONDITION; |
| if (self->vtable->next == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->next(self, received_bytes, received_bytes_size, |
| bytes_to_send, bytes_to_send_size, |
| handshaker_result, cb, user_data); |
| } |
| |
| void tsi_handshaker_destroy(tsi_handshaker *self) { |
| if (self == NULL) return; |
| self->vtable->destroy(self); |
| } |
| |
| /* --- tsi_handshaker_result implementation. --- */ |
| |
| tsi_result tsi_handshaker_result_extract_peer(const tsi_handshaker_result *self, |
| tsi_peer *peer) { |
| if (self == NULL || self->vtable == NULL || peer == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| memset(peer, 0, sizeof(tsi_peer)); |
| if (self->vtable->extract_peer == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->extract_peer(self, peer); |
| } |
| |
| tsi_result tsi_handshaker_result_create_frame_protector( |
| const tsi_handshaker_result *self, size_t *max_protected_frame_size, |
| tsi_frame_protector **protector) { |
| if (self == NULL || self->vtable == NULL || protector == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (self->vtable->create_frame_protector == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->create_frame_protector(self, max_protected_frame_size, |
| protector); |
| } |
| |
| tsi_result tsi_handshaker_result_get_unused_bytes( |
| const tsi_handshaker_result *self, const unsigned char **bytes, |
| size_t *bytes_size) { |
| if (self == NULL || self->vtable == NULL || bytes == NULL || |
| bytes_size == NULL) { |
| return TSI_INVALID_ARGUMENT; |
| } |
| if (self->vtable->get_unused_bytes == NULL) return TSI_UNIMPLEMENTED; |
| return self->vtable->get_unused_bytes(self, bytes, bytes_size); |
| } |
| |
| void tsi_handshaker_result_destroy(tsi_handshaker_result *self) { |
| if (self == NULL) return; |
| self->vtable->destroy(self); |
| } |
| |
| /* --- tsi_peer implementation. --- */ |
| |
| tsi_peer_property tsi_init_peer_property(void) { |
| tsi_peer_property property; |
| memset(&property, 0, sizeof(tsi_peer_property)); |
| return property; |
| } |
| |
| static void tsi_peer_destroy_list_property(tsi_peer_property *children, |
| size_t child_count) { |
| size_t i; |
| for (i = 0; i < child_count; i++) { |
| tsi_peer_property_destruct(&children[i]); |
| } |
| gpr_free(children); |
| } |
| |
| void tsi_peer_property_destruct(tsi_peer_property *property) { |
| if (property->name != NULL) { |
| gpr_free(property->name); |
| } |
| if (property->value.data != NULL) { |
| gpr_free(property->value.data); |
| } |
| *property = tsi_init_peer_property(); /* Reset everything to 0. */ |
| } |
| |
| void tsi_peer_destruct(tsi_peer *self) { |
| if (self == NULL) return; |
| if (self->properties != NULL) { |
| tsi_peer_destroy_list_property(self->properties, self->property_count); |
| self->properties = NULL; |
| } |
| self->property_count = 0; |
| } |
| |
| tsi_result tsi_construct_allocated_string_peer_property( |
| const char *name, size_t value_length, tsi_peer_property *property) { |
| *property = tsi_init_peer_property(); |
| if (name != NULL) property->name = gpr_strdup(name); |
| if (value_length > 0) { |
| property->value.data = (char *)gpr_zalloc(value_length); |
| property->value.length = value_length; |
| } |
| return TSI_OK; |
| } |
| |
| tsi_result tsi_construct_string_peer_property_from_cstring( |
| const char *name, const char *value, tsi_peer_property *property) { |
| return tsi_construct_string_peer_property(name, value, strlen(value), |
| property); |
| } |
| |
| tsi_result tsi_construct_string_peer_property(const char *name, |
| const char *value, |
| size_t value_length, |
| tsi_peer_property *property) { |
| tsi_result result = tsi_construct_allocated_string_peer_property( |
| name, value_length, property); |
| if (result != TSI_OK) return result; |
| if (value_length > 0) { |
| memcpy(property->value.data, value, value_length); |
| } |
| return TSI_OK; |
| } |
| |
| tsi_result tsi_construct_peer(size_t property_count, tsi_peer *peer) { |
| memset(peer, 0, sizeof(tsi_peer)); |
| if (property_count > 0) { |
| peer->properties = (tsi_peer_property *)gpr_zalloc( |
| property_count * sizeof(tsi_peer_property)); |
| peer->property_count = property_count; |
| } |
| return TSI_OK; |
| } |