|
|
|
|
@ -31,7 +31,7 @@ |
|
|
|
|
* |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
#include "src/core/security/secure_transport_setup.h" |
|
|
|
|
#include "src/core/security/handshake.h" |
|
|
|
|
|
|
|
|
|
#include <string.h> |
|
|
|
|
|
|
|
|
|
@ -52,133 +52,134 @@ typedef struct { |
|
|
|
|
gpr_slice_buffer left_overs; |
|
|
|
|
gpr_slice_buffer incoming; |
|
|
|
|
gpr_slice_buffer outgoing; |
|
|
|
|
grpc_secure_transport_setup_done_cb cb; |
|
|
|
|
grpc_security_handshake_done_cb cb; |
|
|
|
|
void *user_data; |
|
|
|
|
grpc_iomgr_closure on_handshake_data_sent_to_peer; |
|
|
|
|
grpc_iomgr_closure on_handshake_data_received_from_peer; |
|
|
|
|
} grpc_secure_transport_setup; |
|
|
|
|
} grpc_security_handshake; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void on_handshake_data_received_from_peer(void *setup, int success); |
|
|
|
|
|
|
|
|
|
static void on_handshake_data_sent_to_peer(void *setup, int success); |
|
|
|
|
|
|
|
|
|
static void secure_transport_setup_done(grpc_secure_transport_setup *s, |
|
|
|
|
int is_success) { |
|
|
|
|
static void security_handshake_done(grpc_security_handshake *h, |
|
|
|
|
int is_success) { |
|
|
|
|
if (is_success) { |
|
|
|
|
s->cb(s->user_data, GRPC_SECURITY_OK, s->wrapped_endpoint, |
|
|
|
|
s->secure_endpoint); |
|
|
|
|
h->cb(h->user_data, GRPC_SECURITY_OK, h->wrapped_endpoint, |
|
|
|
|
h->secure_endpoint); |
|
|
|
|
} else { |
|
|
|
|
if (s->secure_endpoint != NULL) { |
|
|
|
|
grpc_endpoint_shutdown(s->secure_endpoint); |
|
|
|
|
grpc_endpoint_destroy(s->secure_endpoint); |
|
|
|
|
if (h->secure_endpoint != NULL) { |
|
|
|
|
grpc_endpoint_shutdown(h->secure_endpoint); |
|
|
|
|
grpc_endpoint_destroy(h->secure_endpoint); |
|
|
|
|
} else { |
|
|
|
|
grpc_endpoint_destroy(s->wrapped_endpoint); |
|
|
|
|
grpc_endpoint_destroy(h->wrapped_endpoint); |
|
|
|
|
} |
|
|
|
|
s->cb(s->user_data, GRPC_SECURITY_ERROR, s->wrapped_endpoint, NULL); |
|
|
|
|
h->cb(h->user_data, GRPC_SECURITY_ERROR, h->wrapped_endpoint, NULL); |
|
|
|
|
} |
|
|
|
|
if (s->handshaker != NULL) tsi_handshaker_destroy(s->handshaker); |
|
|
|
|
if (s->handshake_buffer != NULL) gpr_free(s->handshake_buffer); |
|
|
|
|
gpr_slice_buffer_destroy(&s->left_overs); |
|
|
|
|
gpr_slice_buffer_destroy(&s->outgoing); |
|
|
|
|
gpr_slice_buffer_destroy(&s->incoming); |
|
|
|
|
GRPC_SECURITY_CONNECTOR_UNREF(s->connector, "secure_transport_setup"); |
|
|
|
|
gpr_free(s); |
|
|
|
|
if (h->handshaker != NULL) tsi_handshaker_destroy(h->handshaker); |
|
|
|
|
if (h->handshake_buffer != NULL) gpr_free(h->handshake_buffer); |
|
|
|
|
gpr_slice_buffer_destroy(&h->left_overs); |
|
|
|
|
gpr_slice_buffer_destroy(&h->outgoing); |
|
|
|
|
gpr_slice_buffer_destroy(&h->incoming); |
|
|
|
|
GRPC_SECURITY_CONNECTOR_UNREF(h->connector, "handshake"); |
|
|
|
|
gpr_free(h); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void on_peer_checked(void *user_data, grpc_security_status status) { |
|
|
|
|
grpc_secure_transport_setup *s = user_data; |
|
|
|
|
grpc_security_handshake *h = user_data; |
|
|
|
|
tsi_frame_protector *protector; |
|
|
|
|
tsi_result result; |
|
|
|
|
if (status != GRPC_SECURITY_OK) { |
|
|
|
|
gpr_log(GPR_ERROR, "Error checking peer."); |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
security_handshake_done(h, 0); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
result = |
|
|
|
|
tsi_handshaker_create_frame_protector(s->handshaker, NULL, &protector); |
|
|
|
|
tsi_handshaker_create_frame_protector(h->handshaker, NULL, &protector); |
|
|
|
|
if (result != TSI_OK) { |
|
|
|
|
gpr_log(GPR_ERROR, "Frame protector creation failed with error %s.", |
|
|
|
|
tsi_result_to_string(result)); |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
security_handshake_done(h, 0); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
s->secure_endpoint = |
|
|
|
|
grpc_secure_endpoint_create(protector, s->wrapped_endpoint, |
|
|
|
|
s->left_overs.slices, s->left_overs.count); |
|
|
|
|
s->left_overs.count = 0; |
|
|
|
|
s->left_overs.length = 0; |
|
|
|
|
secure_transport_setup_done(s, 1); |
|
|
|
|
h->secure_endpoint = |
|
|
|
|
grpc_secure_endpoint_create(protector, h->wrapped_endpoint, |
|
|
|
|
h->left_overs.slices, h->left_overs.count); |
|
|
|
|
h->left_overs.count = 0; |
|
|
|
|
h->left_overs.length = 0; |
|
|
|
|
security_handshake_done(h, 1); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void check_peer(grpc_secure_transport_setup *s) { |
|
|
|
|
static void check_peer(grpc_security_handshake *h) { |
|
|
|
|
grpc_security_status peer_status; |
|
|
|
|
tsi_peer peer; |
|
|
|
|
tsi_result result = tsi_handshaker_extract_peer(s->handshaker, &peer); |
|
|
|
|
tsi_result result = tsi_handshaker_extract_peer(h->handshaker, &peer); |
|
|
|
|
|
|
|
|
|
if (result != TSI_OK) { |
|
|
|
|
gpr_log(GPR_ERROR, "Peer extraction failed with error %s", |
|
|
|
|
tsi_result_to_string(result)); |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
security_handshake_done(h, 0); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
peer_status = grpc_security_connector_check_peer(s->connector, peer, |
|
|
|
|
on_peer_checked, s); |
|
|
|
|
peer_status = grpc_security_connector_check_peer(h->connector, peer, |
|
|
|
|
on_peer_checked, h); |
|
|
|
|
if (peer_status == GRPC_SECURITY_ERROR) { |
|
|
|
|
gpr_log(GPR_ERROR, "Peer check failed."); |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
security_handshake_done(h, 0); |
|
|
|
|
return; |
|
|
|
|
} else if (peer_status == GRPC_SECURITY_OK) { |
|
|
|
|
on_peer_checked(s, peer_status); |
|
|
|
|
on_peer_checked(h, peer_status); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void send_handshake_bytes_to_peer(grpc_secure_transport_setup *s) { |
|
|
|
|
static void send_handshake_bytes_to_peer(grpc_security_handshake *h) { |
|
|
|
|
size_t offset = 0; |
|
|
|
|
tsi_result result = TSI_OK; |
|
|
|
|
gpr_slice to_send; |
|
|
|
|
|
|
|
|
|
do { |
|
|
|
|
size_t to_send_size = s->handshake_buffer_size - offset; |
|
|
|
|
size_t to_send_size = h->handshake_buffer_size - offset; |
|
|
|
|
result = tsi_handshaker_get_bytes_to_send_to_peer( |
|
|
|
|
s->handshaker, s->handshake_buffer + offset, &to_send_size); |
|
|
|
|
h->handshaker, h->handshake_buffer + offset, &to_send_size); |
|
|
|
|
offset += to_send_size; |
|
|
|
|
if (result == TSI_INCOMPLETE_DATA) { |
|
|
|
|
s->handshake_buffer_size *= 2; |
|
|
|
|
s->handshake_buffer = |
|
|
|
|
gpr_realloc(s->handshake_buffer, s->handshake_buffer_size); |
|
|
|
|
h->handshake_buffer_size *= 2; |
|
|
|
|
h->handshake_buffer = |
|
|
|
|
gpr_realloc(h->handshake_buffer, h->handshake_buffer_size); |
|
|
|
|
} |
|
|
|
|
} while (result == TSI_INCOMPLETE_DATA); |
|
|
|
|
|
|
|
|
|
if (result != TSI_OK) { |
|
|
|
|
gpr_log(GPR_ERROR, "Handshake failed with error %s", |
|
|
|
|
tsi_result_to_string(result)); |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
security_handshake_done(h, 0); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
to_send = |
|
|
|
|
gpr_slice_from_copied_buffer((const char *)s->handshake_buffer, offset); |
|
|
|
|
gpr_slice_buffer_reset_and_unref(&s->outgoing); |
|
|
|
|
gpr_slice_buffer_add(&s->outgoing, to_send); |
|
|
|
|
gpr_slice_from_copied_buffer((const char *)h->handshake_buffer, offset); |
|
|
|
|
gpr_slice_buffer_reset_and_unref(&h->outgoing); |
|
|
|
|
gpr_slice_buffer_add(&h->outgoing, to_send); |
|
|
|
|
/* TODO(klempner,jboeuf): This should probably use the client setup
|
|
|
|
|
deadline */ |
|
|
|
|
switch (grpc_endpoint_write(s->wrapped_endpoint, &s->outgoing, |
|
|
|
|
&s->on_handshake_data_sent_to_peer)) { |
|
|
|
|
switch (grpc_endpoint_write(h->wrapped_endpoint, &h->outgoing, |
|
|
|
|
&h->on_handshake_data_sent_to_peer)) { |
|
|
|
|
case GRPC_ENDPOINT_ERROR: |
|
|
|
|
gpr_log(GPR_ERROR, "Could not send handshake data to peer."); |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
security_handshake_done(h, 0); |
|
|
|
|
break; |
|
|
|
|
case GRPC_ENDPOINT_DONE: |
|
|
|
|
on_handshake_data_sent_to_peer(s, 1); |
|
|
|
|
on_handshake_data_sent_to_peer(h, 1); |
|
|
|
|
break; |
|
|
|
|
case GRPC_ENDPOINT_PENDING: |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void on_handshake_data_received_from_peer(void *setup, int success) { |
|
|
|
|
grpc_secure_transport_setup *s = setup; |
|
|
|
|
static void on_handshake_data_received_from_peer(void *handshake, int success) { |
|
|
|
|
grpc_security_handshake *h = handshake; |
|
|
|
|
size_t consumed_slice_size = 0; |
|
|
|
|
tsi_result result = TSI_OK; |
|
|
|
|
size_t i; |
|
|
|
|
@ -187,35 +188,35 @@ static void on_handshake_data_received_from_peer(void *setup, int success) { |
|
|
|
|
|
|
|
|
|
if (!success) { |
|
|
|
|
gpr_log(GPR_ERROR, "Read failed."); |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
security_handshake_done(h, 0); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
for (i = 0; i < s->incoming.count; i++) { |
|
|
|
|
consumed_slice_size = GPR_SLICE_LENGTH(s->incoming.slices[i]); |
|
|
|
|
for (i = 0; i < h->incoming.count; i++) { |
|
|
|
|
consumed_slice_size = GPR_SLICE_LENGTH(h->incoming.slices[i]); |
|
|
|
|
result = tsi_handshaker_process_bytes_from_peer( |
|
|
|
|
s->handshaker, GPR_SLICE_START_PTR(s->incoming.slices[i]), |
|
|
|
|
h->handshaker, GPR_SLICE_START_PTR(h->incoming.slices[i]), |
|
|
|
|
&consumed_slice_size); |
|
|
|
|
if (!tsi_handshaker_is_in_progress(s->handshaker)) break; |
|
|
|
|
if (!tsi_handshaker_is_in_progress(h->handshaker)) break; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (tsi_handshaker_is_in_progress(s->handshaker)) { |
|
|
|
|
if (tsi_handshaker_is_in_progress(h->handshaker)) { |
|
|
|
|
/* We may need more data. */ |
|
|
|
|
if (result == TSI_INCOMPLETE_DATA) { |
|
|
|
|
switch (grpc_endpoint_read(s->wrapped_endpoint, &s->incoming, |
|
|
|
|
&s->on_handshake_data_received_from_peer)) { |
|
|
|
|
switch (grpc_endpoint_read(h->wrapped_endpoint, &h->incoming, |
|
|
|
|
&h->on_handshake_data_received_from_peer)) { |
|
|
|
|
case GRPC_ENDPOINT_DONE: |
|
|
|
|
on_handshake_data_received_from_peer(s, 1); |
|
|
|
|
on_handshake_data_received_from_peer(h, 1); |
|
|
|
|
break; |
|
|
|
|
case GRPC_ENDPOINT_ERROR: |
|
|
|
|
on_handshake_data_received_from_peer(s, 0); |
|
|
|
|
on_handshake_data_received_from_peer(h, 0); |
|
|
|
|
break; |
|
|
|
|
case GRPC_ENDPOINT_PENDING: |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
return; |
|
|
|
|
} else { |
|
|
|
|
send_handshake_bytes_to_peer(s); |
|
|
|
|
send_handshake_bytes_to_peer(h); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
@ -223,90 +224,85 @@ static void on_handshake_data_received_from_peer(void *setup, int success) { |
|
|
|
|
if (result != TSI_OK) { |
|
|
|
|
gpr_log(GPR_ERROR, "Handshake failed with error %s", |
|
|
|
|
tsi_result_to_string(result)); |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
security_handshake_done(h, 0); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* Handshake is done and successful this point. */ |
|
|
|
|
has_left_overs_in_current_slice = |
|
|
|
|
(consumed_slice_size < GPR_SLICE_LENGTH(s->incoming.slices[i])); |
|
|
|
|
(consumed_slice_size < GPR_SLICE_LENGTH(h->incoming.slices[i])); |
|
|
|
|
num_left_overs = |
|
|
|
|
(has_left_overs_in_current_slice ? 1 : 0) + s->incoming.count - i - 1; |
|
|
|
|
(has_left_overs_in_current_slice ? 1 : 0) + h->incoming.count - i - 1; |
|
|
|
|
if (num_left_overs == 0) { |
|
|
|
|
check_peer(s); |
|
|
|
|
check_peer(h); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* Put the leftovers in our buffer (ownership transfered). */ |
|
|
|
|
if (has_left_overs_in_current_slice) { |
|
|
|
|
gpr_slice_buffer_add( |
|
|
|
|
&s->left_overs, |
|
|
|
|
gpr_slice_split_tail(&s->incoming.slices[i], consumed_slice_size)); |
|
|
|
|
&h->left_overs, |
|
|
|
|
gpr_slice_split_tail(&h->incoming.slices[i], consumed_slice_size)); |
|
|
|
|
gpr_slice_unref( |
|
|
|
|
s->incoming.slices[i]); /* split_tail above increments refcount. */ |
|
|
|
|
h->incoming.slices[i]); /* split_tail above increments refcount. */ |
|
|
|
|
} |
|
|
|
|
gpr_slice_buffer_addn( |
|
|
|
|
&s->left_overs, &s->incoming.slices[i + 1], |
|
|
|
|
&h->left_overs, &h->incoming.slices[i + 1], |
|
|
|
|
num_left_overs - (size_t)has_left_overs_in_current_slice); |
|
|
|
|
check_peer(s); |
|
|
|
|
check_peer(h); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* If setup is NULL, the setup is done. */ |
|
|
|
|
static void on_handshake_data_sent_to_peer(void *setup, int success) { |
|
|
|
|
grpc_secure_transport_setup *s = setup; |
|
|
|
|
/* If handshake is NULL, the handshake is done. */ |
|
|
|
|
static void on_handshake_data_sent_to_peer(void *handshake, int success) { |
|
|
|
|
grpc_security_handshake *h = handshake; |
|
|
|
|
|
|
|
|
|
/* Make sure that write is OK. */ |
|
|
|
|
if (!success) { |
|
|
|
|
gpr_log(GPR_ERROR, "Write failed."); |
|
|
|
|
if (setup != NULL) secure_transport_setup_done(s, 0); |
|
|
|
|
if (handshake != NULL) security_handshake_done(h, 0); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* We may be done. */ |
|
|
|
|
if (tsi_handshaker_is_in_progress(s->handshaker)) { |
|
|
|
|
if (tsi_handshaker_is_in_progress(h->handshaker)) { |
|
|
|
|
/* TODO(klempner,jboeuf): This should probably use the client setup
|
|
|
|
|
deadline */ |
|
|
|
|
switch (grpc_endpoint_read(s->wrapped_endpoint, &s->incoming, |
|
|
|
|
&s->on_handshake_data_received_from_peer)) { |
|
|
|
|
switch (grpc_endpoint_read(h->wrapped_endpoint, &h->incoming, |
|
|
|
|
&h->on_handshake_data_received_from_peer)) { |
|
|
|
|
case GRPC_ENDPOINT_ERROR: |
|
|
|
|
on_handshake_data_received_from_peer(s, 0); |
|
|
|
|
on_handshake_data_received_from_peer(h, 0); |
|
|
|
|
break; |
|
|
|
|
case GRPC_ENDPOINT_PENDING: |
|
|
|
|
break; |
|
|
|
|
case GRPC_ENDPOINT_DONE: |
|
|
|
|
on_handshake_data_received_from_peer(s, 1); |
|
|
|
|
on_handshake_data_received_from_peer(h, 1); |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
} else { |
|
|
|
|
check_peer(s); |
|
|
|
|
check_peer(h); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void grpc_setup_secure_transport(grpc_security_connector *connector, |
|
|
|
|
grpc_endpoint *nonsecure_endpoint, |
|
|
|
|
grpc_secure_transport_setup_done_cb cb, |
|
|
|
|
void *user_data) { |
|
|
|
|
grpc_security_status result = GRPC_SECURITY_OK; |
|
|
|
|
grpc_secure_transport_setup *s = |
|
|
|
|
gpr_malloc(sizeof(grpc_secure_transport_setup)); |
|
|
|
|
memset(s, 0, sizeof(grpc_secure_transport_setup)); |
|
|
|
|
result = grpc_security_connector_create_handshaker(connector, &s->handshaker); |
|
|
|
|
if (result != GRPC_SECURITY_OK) { |
|
|
|
|
secure_transport_setup_done(s, 0); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
s->connector = |
|
|
|
|
GRPC_SECURITY_CONNECTOR_REF(connector, "secure_transport_setup"); |
|
|
|
|
s->handshake_buffer_size = GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE; |
|
|
|
|
s->handshake_buffer = gpr_malloc(s->handshake_buffer_size); |
|
|
|
|
s->wrapped_endpoint = nonsecure_endpoint; |
|
|
|
|
s->user_data = user_data; |
|
|
|
|
s->cb = cb; |
|
|
|
|
grpc_iomgr_closure_init(&s->on_handshake_data_sent_to_peer, |
|
|
|
|
on_handshake_data_sent_to_peer, s); |
|
|
|
|
grpc_iomgr_closure_init(&s->on_handshake_data_received_from_peer, |
|
|
|
|
on_handshake_data_received_from_peer, s); |
|
|
|
|
gpr_slice_buffer_init(&s->left_overs); |
|
|
|
|
gpr_slice_buffer_init(&s->outgoing); |
|
|
|
|
gpr_slice_buffer_init(&s->incoming); |
|
|
|
|
send_handshake_bytes_to_peer(s); |
|
|
|
|
void grpc_do_security_handshake(tsi_handshaker *handshaker, |
|
|
|
|
grpc_security_connector *connector, |
|
|
|
|
grpc_endpoint *nonsecure_endpoint, |
|
|
|
|
grpc_security_handshake_done_cb cb, |
|
|
|
|
void *user_data) { |
|
|
|
|
grpc_security_handshake *h = gpr_malloc(sizeof(grpc_security_handshake)); |
|
|
|
|
memset(h, 0, sizeof(grpc_security_handshake)); |
|
|
|
|
h->handshaker = handshaker; |
|
|
|
|
h->connector = GRPC_SECURITY_CONNECTOR_REF(connector, "handshake"); |
|
|
|
|
h->handshake_buffer_size = GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE; |
|
|
|
|
h->handshake_buffer = gpr_malloc(h->handshake_buffer_size); |
|
|
|
|
h->wrapped_endpoint = nonsecure_endpoint; |
|
|
|
|
h->user_data = user_data; |
|
|
|
|
h->cb = cb; |
|
|
|
|
grpc_iomgr_closure_init(&h->on_handshake_data_sent_to_peer, |
|
|
|
|
on_handshake_data_sent_to_peer, h); |
|
|
|
|
grpc_iomgr_closure_init(&h->on_handshake_data_received_from_peer, |
|
|
|
|
on_handshake_data_received_from_peer, h); |
|
|
|
|
gpr_slice_buffer_init(&h->left_overs); |
|
|
|
|
gpr_slice_buffer_init(&h->outgoing); |
|
|
|
|
gpr_slice_buffer_init(&h->incoming); |
|
|
|
|
send_handshake_bytes_to_peer(h); |
|
|
|
|
} |
murgatroid99
10 years ago