1 /*
2 *
3 * Copyright 2015 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/fake_transport_security.h"
22
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include <grpc/support/alloc.h>
27 #include <grpc/support/log.h>
28
29 #include "src/core/lib/gpr/useful.h"
30 #include "src/core/lib/slice/slice_internal.h"
31 #include "src/core/tsi/transport_security_grpc.h"
32
33 /* --- Constants. ---*/
34 #define TSI_FAKE_FRAME_HEADER_SIZE 4
35 #define TSI_FAKE_FRAME_INITIAL_ALLOCATED_SIZE 64
36 #define TSI_FAKE_DEFAULT_FRAME_SIZE 16384
37 #define TSI_FAKE_HANDSHAKER_OUTGOING_BUFFER_INITIAL_SIZE 256
38
39 /* --- Structure definitions. ---*/
40
41 /* a frame is encoded like this:
42 | size | data |
43 where the size field value is the size of the size field plus the size of
44 the data encoded in little endian on 4 bytes. */
45 struct tsi_fake_frame {
46 unsigned char* data;
47 size_t size;
48 size_t allocated_size;
49 size_t offset;
50 int needs_draining;
51 };
52 typedef enum {
53 TSI_FAKE_CLIENT_INIT = 0,
54 TSI_FAKE_SERVER_INIT = 1,
55 TSI_FAKE_CLIENT_FINISHED = 2,
56 TSI_FAKE_SERVER_FINISHED = 3,
57 TSI_FAKE_HANDSHAKE_MESSAGE_MAX = 4
58 } tsi_fake_handshake_message;
59
60 struct tsi_fake_handshaker {
61 tsi_handshaker base;
62 int is_client;
63 tsi_fake_handshake_message next_message_to_send;
64 int needs_incoming_message;
65 tsi_fake_frame incoming_frame;
66 tsi_fake_frame outgoing_frame;
67 unsigned char* outgoing_bytes_buffer;
68 size_t outgoing_bytes_buffer_size;
69 tsi_result result;
70 };
71 struct tsi_fake_frame_protector {
72 tsi_frame_protector base;
73 tsi_fake_frame protect_frame;
74 tsi_fake_frame unprotect_frame;
75 size_t max_frame_size;
76 };
77 struct tsi_fake_zero_copy_grpc_protector {
78 tsi_zero_copy_grpc_protector base;
79 grpc_slice_buffer header_sb;
80 grpc_slice_buffer protected_sb;
81 size_t max_frame_size;
82 size_t parsed_frame_size;
83 };
84 /* --- Utils. ---*/
85
86 static const char* tsi_fake_handshake_message_strings[] = {
87 "CLIENT_INIT", "SERVER_INIT", "CLIENT_FINISHED", "SERVER_FINISHED"};
88
tsi_fake_handshake_message_to_string(int msg)89 static const char* tsi_fake_handshake_message_to_string(int msg) {
90 if (msg < 0 || msg >= TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
91 gpr_log(GPR_ERROR, "Invalid message %d", msg);
92 return "UNKNOWN";
93 }
94 return tsi_fake_handshake_message_strings[msg];
95 }
96
tsi_fake_handshake_message_from_string(const char * msg_string,tsi_fake_handshake_message * msg)97 static tsi_result tsi_fake_handshake_message_from_string(
98 const char* msg_string, tsi_fake_handshake_message* msg) {
99 for (int i = 0; i < TSI_FAKE_HANDSHAKE_MESSAGE_MAX; i++) {
100 if (strncmp(msg_string, tsi_fake_handshake_message_strings[i],
101 strlen(tsi_fake_handshake_message_strings[i])) == 0) {
102 *msg = static_cast<tsi_fake_handshake_message>(i);
103 return TSI_OK;
104 }
105 }
106 gpr_log(GPR_ERROR, "Invalid handshake message.");
107 return TSI_DATA_CORRUPTED;
108 }
109
load32_little_endian(const unsigned char * buf)110 static uint32_t load32_little_endian(const unsigned char* buf) {
111 return (static_cast<uint32_t>(buf[0]) | static_cast<uint32_t>(buf[1] << 8) |
112 static_cast<uint32_t>(buf[2] << 16) |
113 static_cast<uint32_t>(buf[3] << 24));
114 }
115
store32_little_endian(uint32_t value,unsigned char * buf)116 static void store32_little_endian(uint32_t value, unsigned char* buf) {
117 buf[3] = static_cast<unsigned char>((value >> 24) & 0xFF);
118 buf[2] = static_cast<unsigned char>((value >> 16) & 0xFF);
119 buf[1] = static_cast<unsigned char>((value >> 8) & 0xFF);
120 buf[0] = static_cast<unsigned char>((value)&0xFF);
121 }
122
read_frame_size(const grpc_slice_buffer * sb)123 static uint32_t read_frame_size(const grpc_slice_buffer* sb) {
124 GPR_ASSERT(sb != nullptr && sb->length >= TSI_FAKE_FRAME_HEADER_SIZE);
125 uint8_t frame_size_buffer[TSI_FAKE_FRAME_HEADER_SIZE];
126 uint8_t* buf = frame_size_buffer;
127 /* Copies the first 4 bytes to a temporary buffer. */
128 size_t remaining = TSI_FAKE_FRAME_HEADER_SIZE;
129 for (size_t i = 0; i < sb->count; i++) {
130 size_t slice_length = GRPC_SLICE_LENGTH(sb->slices[i]);
131 if (remaining <= slice_length) {
132 memcpy(buf, GRPC_SLICE_START_PTR(sb->slices[i]), remaining);
133 remaining = 0;
134 break;
135 } else {
136 memcpy(buf, GRPC_SLICE_START_PTR(sb->slices[i]), slice_length);
137 buf += slice_length;
138 remaining -= slice_length;
139 }
140 }
141 GPR_ASSERT(remaining == 0);
142 return load32_little_endian(frame_size_buffer);
143 }
144
tsi_fake_frame_reset(tsi_fake_frame * frame,int needs_draining)145 static void tsi_fake_frame_reset(tsi_fake_frame* frame, int needs_draining) {
146 frame->offset = 0;
147 frame->needs_draining = needs_draining;
148 if (!needs_draining) frame->size = 0;
149 }
150
151 /* Checks if the frame's allocated size is at least frame->size, and reallocs
152 * more memory if necessary. */
tsi_fake_frame_ensure_size(tsi_fake_frame * frame)153 static void tsi_fake_frame_ensure_size(tsi_fake_frame* frame) {
154 if (frame->data == nullptr) {
155 frame->allocated_size = frame->size;
156 frame->data =
157 static_cast<unsigned char*>(gpr_malloc(frame->allocated_size));
158 } else if (frame->size > frame->allocated_size) {
159 unsigned char* new_data =
160 static_cast<unsigned char*>(gpr_realloc(frame->data, frame->size));
161 frame->data = new_data;
162 frame->allocated_size = frame->size;
163 }
164 }
165
166 /* Decodes the serialized fake frame contained in incoming_bytes, and fills
167 * frame with the contents of the decoded frame.
168 * This method should not be called if frame->needs_framing is not 0. */
tsi_fake_frame_decode(const unsigned char * incoming_bytes,size_t * incoming_bytes_size,tsi_fake_frame * frame)169 static tsi_result tsi_fake_frame_decode(const unsigned char* incoming_bytes,
170 size_t* incoming_bytes_size,
171 tsi_fake_frame* frame) {
172 size_t available_size = *incoming_bytes_size;
173 size_t to_read_size = 0;
174 const unsigned char* bytes_cursor = incoming_bytes;
175
176 if (frame->needs_draining) return TSI_INTERNAL_ERROR;
177 if (frame->data == nullptr) {
178 frame->allocated_size = TSI_FAKE_FRAME_INITIAL_ALLOCATED_SIZE;
179 frame->data =
180 static_cast<unsigned char*>(gpr_malloc(frame->allocated_size));
181 }
182
183 if (frame->offset < TSI_FAKE_FRAME_HEADER_SIZE) {
184 to_read_size = TSI_FAKE_FRAME_HEADER_SIZE - frame->offset;
185 if (to_read_size > available_size) {
186 /* Just fill what we can and exit. */
187 memcpy(frame->data + frame->offset, bytes_cursor, available_size);
188 bytes_cursor += available_size;
189 frame->offset += available_size;
190 *incoming_bytes_size = static_cast<size_t>(bytes_cursor - incoming_bytes);
191 return TSI_INCOMPLETE_DATA;
192 }
193 memcpy(frame->data + frame->offset, bytes_cursor, to_read_size);
194 bytes_cursor += to_read_size;
195 frame->offset += to_read_size;
196 available_size -= to_read_size;
197 frame->size = load32_little_endian(frame->data);
198 tsi_fake_frame_ensure_size(frame);
199 }
200
201 to_read_size = frame->size - frame->offset;
202 if (to_read_size > available_size) {
203 memcpy(frame->data + frame->offset, bytes_cursor, available_size);
204 frame->offset += available_size;
205 bytes_cursor += available_size;
206 *incoming_bytes_size = static_cast<size_t>(bytes_cursor - incoming_bytes);
207 return TSI_INCOMPLETE_DATA;
208 }
209 memcpy(frame->data + frame->offset, bytes_cursor, to_read_size);
210 bytes_cursor += to_read_size;
211 *incoming_bytes_size = static_cast<size_t>(bytes_cursor - incoming_bytes);
212 tsi_fake_frame_reset(frame, 1 /* needs_draining */);
213 return TSI_OK;
214 }
215
216 /* Encodes a fake frame into its wire format and places the result in
217 * outgoing_bytes. outgoing_bytes_size indicates the size of the encoded frame.
218 * This method should not be called if frame->needs_framing is 0. */
tsi_fake_frame_encode(unsigned char * outgoing_bytes,size_t * outgoing_bytes_size,tsi_fake_frame * frame)219 static tsi_result tsi_fake_frame_encode(unsigned char* outgoing_bytes,
220 size_t* outgoing_bytes_size,
221 tsi_fake_frame* frame) {
222 size_t to_write_size = frame->size - frame->offset;
223 if (!frame->needs_draining) return TSI_INTERNAL_ERROR;
224 if (*outgoing_bytes_size < to_write_size) {
225 memcpy(outgoing_bytes, frame->data + frame->offset, *outgoing_bytes_size);
226 frame->offset += *outgoing_bytes_size;
227 return TSI_INCOMPLETE_DATA;
228 }
229 memcpy(outgoing_bytes, frame->data + frame->offset, to_write_size);
230 *outgoing_bytes_size = to_write_size;
231 tsi_fake_frame_reset(frame, 0 /* needs_draining */);
232 return TSI_OK;
233 }
234
235 /* Sets the payload of a fake frame to contain the given data blob, where
236 * data_size indicates the size of data. */
tsi_fake_frame_set_data(unsigned char * data,size_t data_size,tsi_fake_frame * frame)237 static tsi_result tsi_fake_frame_set_data(unsigned char* data, size_t data_size,
238 tsi_fake_frame* frame) {
239 frame->offset = 0;
240 frame->size = data_size + TSI_FAKE_FRAME_HEADER_SIZE;
241 tsi_fake_frame_ensure_size(frame);
242 store32_little_endian(static_cast<uint32_t>(frame->size), frame->data);
243 memcpy(frame->data + TSI_FAKE_FRAME_HEADER_SIZE, data, data_size);
244 tsi_fake_frame_reset(frame, 1 /* needs draining */);
245 return TSI_OK;
246 }
247
248 /* Destroys the contents of a fake frame. */
tsi_fake_frame_destruct(tsi_fake_frame * frame)249 static void tsi_fake_frame_destruct(tsi_fake_frame* frame) {
250 if (frame->data != nullptr) gpr_free(frame->data);
251 }
252
253 /* --- tsi_frame_protector methods implementation. ---*/
254
fake_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)255 static tsi_result fake_protector_protect(tsi_frame_protector* self,
256 const unsigned char* unprotected_bytes,
257 size_t* unprotected_bytes_size,
258 unsigned char* protected_output_frames,
259 size_t* protected_output_frames_size) {
260 tsi_result result = TSI_OK;
261 tsi_fake_frame_protector* impl =
262 reinterpret_cast<tsi_fake_frame_protector*>(self);
263 unsigned char frame_header[TSI_FAKE_FRAME_HEADER_SIZE];
264 tsi_fake_frame* frame = &impl->protect_frame;
265 size_t saved_output_size = *protected_output_frames_size;
266 size_t drained_size = 0;
267 size_t* num_bytes_written = protected_output_frames_size;
268 *num_bytes_written = 0;
269
270 /* Try to drain first. */
271 if (frame->needs_draining) {
272 drained_size = saved_output_size - *num_bytes_written;
273 result =
274 tsi_fake_frame_encode(protected_output_frames, &drained_size, frame);
275 *num_bytes_written += drained_size;
276 protected_output_frames += drained_size;
277 if (result != TSI_OK) {
278 if (result == TSI_INCOMPLETE_DATA) {
279 *unprotected_bytes_size = 0;
280 result = TSI_OK;
281 }
282 return result;
283 }
284 }
285
286 /* Now process the unprotected_bytes. */
287 if (frame->needs_draining) return TSI_INTERNAL_ERROR;
288 if (frame->size == 0) {
289 /* New frame, create a header. */
290 size_t written_in_frame_size = 0;
291 store32_little_endian(static_cast<uint32_t>(impl->max_frame_size),
292 frame_header);
293 written_in_frame_size = TSI_FAKE_FRAME_HEADER_SIZE;
294 result = tsi_fake_frame_decode(frame_header, &written_in_frame_size, frame);
295 if (result != TSI_INCOMPLETE_DATA) {
296 gpr_log(GPR_ERROR, "tsi_fake_frame_decode returned %s",
297 tsi_result_to_string(result));
298 return result;
299 }
300 }
301 result =
302 tsi_fake_frame_decode(unprotected_bytes, unprotected_bytes_size, frame);
303 if (result != TSI_OK) {
304 if (result == TSI_INCOMPLETE_DATA) result = TSI_OK;
305 return result;
306 }
307
308 /* Try to drain again. */
309 if (!frame->needs_draining) return TSI_INTERNAL_ERROR;
310 if (frame->offset != 0) return TSI_INTERNAL_ERROR;
311 drained_size = saved_output_size - *num_bytes_written;
312 result = tsi_fake_frame_encode(protected_output_frames, &drained_size, frame);
313 *num_bytes_written += drained_size;
314 if (result == TSI_INCOMPLETE_DATA) result = TSI_OK;
315 return result;
316 }
317
fake_protector_protect_flush(tsi_frame_protector * self,unsigned char * protected_output_frames,size_t * protected_output_frames_size,size_t * still_pending_size)318 static tsi_result fake_protector_protect_flush(
319 tsi_frame_protector* self, unsigned char* protected_output_frames,
320 size_t* protected_output_frames_size, size_t* still_pending_size) {
321 tsi_result result = TSI_OK;
322 tsi_fake_frame_protector* impl =
323 reinterpret_cast<tsi_fake_frame_protector*>(self);
324 tsi_fake_frame* frame = &impl->protect_frame;
325 if (!frame->needs_draining) {
326 /* Create a short frame. */
327 frame->size = frame->offset;
328 frame->offset = 0;
329 frame->needs_draining = 1;
330 store32_little_endian(static_cast<uint32_t>(frame->size),
331 frame->data); /* Overwrite header. */
332 }
333 result = tsi_fake_frame_encode(protected_output_frames,
334 protected_output_frames_size, frame);
335 if (result == TSI_INCOMPLETE_DATA) result = TSI_OK;
336 *still_pending_size = frame->size - frame->offset;
337 return result;
338 }
339
fake_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)340 static tsi_result fake_protector_unprotect(
341 tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
342 size_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
343 size_t* unprotected_bytes_size) {
344 tsi_result result = TSI_OK;
345 tsi_fake_frame_protector* impl =
346 reinterpret_cast<tsi_fake_frame_protector*>(self);
347 tsi_fake_frame* frame = &impl->unprotect_frame;
348 size_t saved_output_size = *unprotected_bytes_size;
349 size_t drained_size = 0;
350 size_t* num_bytes_written = unprotected_bytes_size;
351 *num_bytes_written = 0;
352
353 /* Try to drain first. */
354 if (frame->needs_draining) {
355 /* Go past the header if needed. */
356 if (frame->offset == 0) frame->offset = TSI_FAKE_FRAME_HEADER_SIZE;
357 drained_size = saved_output_size - *num_bytes_written;
358 result = tsi_fake_frame_encode(unprotected_bytes, &drained_size, frame);
359 unprotected_bytes += drained_size;
360 *num_bytes_written += drained_size;
361 if (result != TSI_OK) {
362 if (result == TSI_INCOMPLETE_DATA) {
363 *protected_frames_bytes_size = 0;
364 result = TSI_OK;
365 }
366 return result;
367 }
368 }
369
370 /* Now process the protected_bytes. */
371 if (frame->needs_draining) return TSI_INTERNAL_ERROR;
372 result = tsi_fake_frame_decode(protected_frames_bytes,
373 protected_frames_bytes_size, frame);
374 if (result != TSI_OK) {
375 if (result == TSI_INCOMPLETE_DATA) result = TSI_OK;
376 return result;
377 }
378
379 /* Try to drain again. */
380 if (!frame->needs_draining) return TSI_INTERNAL_ERROR;
381 if (frame->offset != 0) return TSI_INTERNAL_ERROR;
382 frame->offset = TSI_FAKE_FRAME_HEADER_SIZE; /* Go past the header. */
383 drained_size = saved_output_size - *num_bytes_written;
384 result = tsi_fake_frame_encode(unprotected_bytes, &drained_size, frame);
385 *num_bytes_written += drained_size;
386 if (result == TSI_INCOMPLETE_DATA) result = TSI_OK;
387 return result;
388 }
389
fake_protector_destroy(tsi_frame_protector * self)390 static void fake_protector_destroy(tsi_frame_protector* self) {
391 tsi_fake_frame_protector* impl =
392 reinterpret_cast<tsi_fake_frame_protector*>(self);
393 tsi_fake_frame_destruct(&impl->protect_frame);
394 tsi_fake_frame_destruct(&impl->unprotect_frame);
395 gpr_free(self);
396 }
397
398 static const tsi_frame_protector_vtable frame_protector_vtable = {
399 fake_protector_protect,
400 fake_protector_protect_flush,
401 fake_protector_unprotect,
402 fake_protector_destroy,
403 };
404
405 /* --- tsi_zero_copy_grpc_protector methods implementation. ---*/
406
fake_zero_copy_grpc_protector_protect(tsi_zero_copy_grpc_protector * self,grpc_slice_buffer * unprotected_slices,grpc_slice_buffer * protected_slices)407 static tsi_result fake_zero_copy_grpc_protector_protect(
408 tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* unprotected_slices,
409 grpc_slice_buffer* protected_slices) {
410 if (self == nullptr || unprotected_slices == nullptr ||
411 protected_slices == nullptr) {
412 return TSI_INVALID_ARGUMENT;
413 }
414 tsi_fake_zero_copy_grpc_protector* impl =
415 reinterpret_cast<tsi_fake_zero_copy_grpc_protector*>(self);
416 /* Protects each frame. */
417 while (unprotected_slices->length > 0) {
418 size_t frame_length =
419 GPR_MIN(impl->max_frame_size,
420 unprotected_slices->length + TSI_FAKE_FRAME_HEADER_SIZE);
421 grpc_slice slice = GRPC_SLICE_MALLOC(TSI_FAKE_FRAME_HEADER_SIZE);
422 store32_little_endian(static_cast<uint32_t>(frame_length),
423 GRPC_SLICE_START_PTR(slice));
424 grpc_slice_buffer_add(protected_slices, slice);
425 size_t data_length = frame_length - TSI_FAKE_FRAME_HEADER_SIZE;
426 grpc_slice_buffer_move_first(unprotected_slices, data_length,
427 protected_slices);
428 }
429 return TSI_OK;
430 }
431
fake_zero_copy_grpc_protector_unprotect(tsi_zero_copy_grpc_protector * self,grpc_slice_buffer * protected_slices,grpc_slice_buffer * unprotected_slices)432 static tsi_result fake_zero_copy_grpc_protector_unprotect(
433 tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
434 grpc_slice_buffer* unprotected_slices) {
435 if (self == nullptr || unprotected_slices == nullptr ||
436 protected_slices == nullptr) {
437 return TSI_INVALID_ARGUMENT;
438 }
439 tsi_fake_zero_copy_grpc_protector* impl =
440 reinterpret_cast<tsi_fake_zero_copy_grpc_protector*>(self);
441 grpc_slice_buffer_move_into(protected_slices, &impl->protected_sb);
442 /* Unprotect each frame, if we get a full frame. */
443 while (impl->protected_sb.length >= TSI_FAKE_FRAME_HEADER_SIZE) {
444 if (impl->parsed_frame_size == 0) {
445 impl->parsed_frame_size = read_frame_size(&impl->protected_sb);
446 if (impl->parsed_frame_size <= 4) {
447 gpr_log(GPR_ERROR, "Invalid frame size.");
448 return TSI_DATA_CORRUPTED;
449 }
450 }
451 /* If we do not have a full frame, return with OK status. */
452 if (impl->protected_sb.length < impl->parsed_frame_size) break;
453 /* Strips header bytes. */
454 grpc_slice_buffer_move_first(&impl->protected_sb,
455 TSI_FAKE_FRAME_HEADER_SIZE, &impl->header_sb);
456 /* Moves data to unprotected slices. */
457 grpc_slice_buffer_move_first(
458 &impl->protected_sb,
459 impl->parsed_frame_size - TSI_FAKE_FRAME_HEADER_SIZE,
460 unprotected_slices);
461 impl->parsed_frame_size = 0;
462 grpc_slice_buffer_reset_and_unref_internal(&impl->header_sb);
463 }
464 return TSI_OK;
465 }
466
fake_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector * self)467 static void fake_zero_copy_grpc_protector_destroy(
468 tsi_zero_copy_grpc_protector* self) {
469 if (self == nullptr) return;
470 tsi_fake_zero_copy_grpc_protector* impl =
471 reinterpret_cast<tsi_fake_zero_copy_grpc_protector*>(self);
472 grpc_slice_buffer_destroy_internal(&impl->header_sb);
473 grpc_slice_buffer_destroy_internal(&impl->protected_sb);
474 gpr_free(impl);
475 }
476
477 static const tsi_zero_copy_grpc_protector_vtable
478 zero_copy_grpc_protector_vtable = {
479 fake_zero_copy_grpc_protector_protect,
480 fake_zero_copy_grpc_protector_unprotect,
481 fake_zero_copy_grpc_protector_destroy,
482 nullptr /* fake_zero_copy_grpc_protector_max_frame_size */
483 };
484
485 /* --- tsi_handshaker_result methods implementation. ---*/
486
487 struct fake_handshaker_result {
488 tsi_handshaker_result base;
489 unsigned char* unused_bytes;
490 size_t unused_bytes_size;
491 };
fake_handshaker_result_extract_peer(const tsi_handshaker_result *,tsi_peer * peer)492 static tsi_result fake_handshaker_result_extract_peer(
493 const tsi_handshaker_result* /*self*/, tsi_peer* peer) {
494 /* Construct a tsi_peer with 1 property: certificate type, security_level. */
495 tsi_result result = tsi_construct_peer(2, peer);
496 if (result != TSI_OK) return result;
497 result = tsi_construct_string_peer_property_from_cstring(
498 TSI_CERTIFICATE_TYPE_PEER_PROPERTY, TSI_FAKE_CERTIFICATE_TYPE,
499 &peer->properties[0]);
500 if (result != TSI_OK) tsi_peer_destruct(peer);
501 result = tsi_construct_string_peer_property_from_cstring(
502 TSI_SECURITY_LEVEL_PEER_PROPERTY,
503 tsi_security_level_to_string(TSI_SECURITY_NONE), &peer->properties[1]);
504 if (result != TSI_OK) tsi_peer_destruct(peer);
505 return result;
506 }
507
fake_handshaker_result_create_zero_copy_grpc_protector(const tsi_handshaker_result *,size_t * max_output_protected_frame_size,tsi_zero_copy_grpc_protector ** protector)508 static tsi_result fake_handshaker_result_create_zero_copy_grpc_protector(
509 const tsi_handshaker_result* /*self*/,
510 size_t* max_output_protected_frame_size,
511 tsi_zero_copy_grpc_protector** protector) {
512 *protector =
513 tsi_create_fake_zero_copy_grpc_protector(max_output_protected_frame_size);
514 return TSI_OK;
515 }
516
fake_handshaker_result_create_frame_protector(const tsi_handshaker_result *,size_t * max_output_protected_frame_size,tsi_frame_protector ** protector)517 static tsi_result fake_handshaker_result_create_frame_protector(
518 const tsi_handshaker_result* /*self*/,
519 size_t* max_output_protected_frame_size, tsi_frame_protector** protector) {
520 *protector = tsi_create_fake_frame_protector(max_output_protected_frame_size);
521 return TSI_OK;
522 }
523
fake_handshaker_result_get_unused_bytes(const tsi_handshaker_result * self,const unsigned char ** bytes,size_t * bytes_size)524 static tsi_result fake_handshaker_result_get_unused_bytes(
525 const tsi_handshaker_result* self, const unsigned char** bytes,
526 size_t* bytes_size) {
527 fake_handshaker_result* result = reinterpret_cast<fake_handshaker_result*>(
528 const_cast<tsi_handshaker_result*>(self));
529 *bytes_size = result->unused_bytes_size;
530 *bytes = result->unused_bytes;
531 return TSI_OK;
532 }
533
fake_handshaker_result_destroy(tsi_handshaker_result * self)534 static void fake_handshaker_result_destroy(tsi_handshaker_result* self) {
535 fake_handshaker_result* result =
536 reinterpret_cast<fake_handshaker_result*>(self);
537 gpr_free(result->unused_bytes);
538 gpr_free(self);
539 }
540
541 static const tsi_handshaker_result_vtable handshaker_result_vtable = {
542 fake_handshaker_result_extract_peer,
543 fake_handshaker_result_create_zero_copy_grpc_protector,
544 fake_handshaker_result_create_frame_protector,
545 fake_handshaker_result_get_unused_bytes,
546 fake_handshaker_result_destroy,
547 };
548
fake_handshaker_result_create(const unsigned char * unused_bytes,size_t unused_bytes_size,tsi_handshaker_result ** handshaker_result)549 static tsi_result fake_handshaker_result_create(
550 const unsigned char* unused_bytes, size_t unused_bytes_size,
551 tsi_handshaker_result** handshaker_result) {
552 if ((unused_bytes_size > 0 && unused_bytes == nullptr) ||
553 handshaker_result == nullptr) {
554 return TSI_INVALID_ARGUMENT;
555 }
556 fake_handshaker_result* result =
557 static_cast<fake_handshaker_result*>(gpr_zalloc(sizeof(*result)));
558 result->base.vtable = &handshaker_result_vtable;
559 if (unused_bytes_size > 0) {
560 result->unused_bytes =
561 static_cast<unsigned char*>(gpr_malloc(unused_bytes_size));
562 memcpy(result->unused_bytes, unused_bytes, unused_bytes_size);
563 }
564 result->unused_bytes_size = unused_bytes_size;
565 *handshaker_result = &result->base;
566 return TSI_OK;
567 }
568
569 /* --- tsi_handshaker methods implementation. ---*/
570
fake_handshaker_get_bytes_to_send_to_peer(tsi_handshaker * self,unsigned char * bytes,size_t * bytes_size)571 static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
572 tsi_handshaker* self, unsigned char* bytes, size_t* bytes_size) {
573 tsi_fake_handshaker* impl = reinterpret_cast<tsi_fake_handshaker*>(self);
574 tsi_result result = TSI_OK;
575 if (impl->needs_incoming_message || impl->result == TSI_OK) {
576 *bytes_size = 0;
577 return TSI_OK;
578 }
579 if (!impl->outgoing_frame.needs_draining) {
580 tsi_fake_handshake_message next_message_to_send =
581 // NOLINTNEXTLINE(bugprone-misplaced-widening-cast)
582 static_cast<tsi_fake_handshake_message>(impl->next_message_to_send + 2);
583 const char* msg_string =
584 tsi_fake_handshake_message_to_string(impl->next_message_to_send);
585 result = tsi_fake_frame_set_data(
586 reinterpret_cast<unsigned char*>(const_cast<char*>(msg_string)),
587 strlen(msg_string), &impl->outgoing_frame);
588 if (result != TSI_OK) return result;
589 if (next_message_to_send > TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
590 next_message_to_send = TSI_FAKE_HANDSHAKE_MESSAGE_MAX;
591 }
592 if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
593 gpr_log(GPR_INFO, "%s prepared %s.",
594 impl->is_client ? "Client" : "Server",
595 tsi_fake_handshake_message_to_string(impl->next_message_to_send));
596 }
597 impl->next_message_to_send = next_message_to_send;
598 }
599 result = tsi_fake_frame_encode(bytes, bytes_size, &impl->outgoing_frame);
600 if (result != TSI_OK) return result;
601 if (!impl->is_client &&
602 impl->next_message_to_send == TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
603 /* We're done. */
604 if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
605 gpr_log(GPR_INFO, "Server is done.");
606 }
607 impl->result = TSI_OK;
608 } else {
609 impl->needs_incoming_message = 1;
610 }
611 return TSI_OK;
612 }
613
fake_handshaker_process_bytes_from_peer(tsi_handshaker * self,const unsigned char * bytes,size_t * bytes_size)614 static tsi_result fake_handshaker_process_bytes_from_peer(
615 tsi_handshaker* self, const unsigned char* bytes, size_t* bytes_size) {
616 tsi_result result = TSI_OK;
617 tsi_fake_handshaker* impl = reinterpret_cast<tsi_fake_handshaker*>(self);
618 tsi_fake_handshake_message expected_msg =
619 static_cast<tsi_fake_handshake_message>(impl->next_message_to_send - 1);
620 tsi_fake_handshake_message received_msg;
621
622 if (!impl->needs_incoming_message || impl->result == TSI_OK) {
623 *bytes_size = 0;
624 return TSI_OK;
625 }
626 result = tsi_fake_frame_decode(bytes, bytes_size, &impl->incoming_frame);
627 if (result != TSI_OK) return result;
628
629 /* We now have a complete frame. */
630 result = tsi_fake_handshake_message_from_string(
631 reinterpret_cast<const char*>(impl->incoming_frame.data) +
632 TSI_FAKE_FRAME_HEADER_SIZE,
633 &received_msg);
634 if (result != TSI_OK) {
635 impl->result = result;
636 return result;
637 }
638 if (received_msg != expected_msg) {
639 gpr_log(GPR_ERROR, "Invalid received message (%s instead of %s)",
640 tsi_fake_handshake_message_to_string(received_msg),
641 tsi_fake_handshake_message_to_string(expected_msg));
642 }
643 if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
644 gpr_log(GPR_INFO, "%s received %s.", impl->is_client ? "Client" : "Server",
645 tsi_fake_handshake_message_to_string(received_msg));
646 }
647 tsi_fake_frame_reset(&impl->incoming_frame, 0 /* needs_draining */);
648 impl->needs_incoming_message = 0;
649 if (impl->next_message_to_send == TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
650 /* We're done. */
651 if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
652 gpr_log(GPR_INFO, "%s is done.", impl->is_client ? "Client" : "Server");
653 }
654 impl->result = TSI_OK;
655 }
656 return TSI_OK;
657 }
658
fake_handshaker_get_result(tsi_handshaker * self)659 static tsi_result fake_handshaker_get_result(tsi_handshaker* self) {
660 tsi_fake_handshaker* impl = reinterpret_cast<tsi_fake_handshaker*>(self);
661 return impl->result;
662 }
663
fake_handshaker_destroy(tsi_handshaker * self)664 static void fake_handshaker_destroy(tsi_handshaker* self) {
665 tsi_fake_handshaker* impl = reinterpret_cast<tsi_fake_handshaker*>(self);
666 tsi_fake_frame_destruct(&impl->incoming_frame);
667 tsi_fake_frame_destruct(&impl->outgoing_frame);
668 gpr_free(impl->outgoing_bytes_buffer);
669 gpr_free(self);
670 }
671
fake_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,void *)672 static tsi_result fake_handshaker_next(
673 tsi_handshaker* self, const unsigned char* received_bytes,
674 size_t received_bytes_size, const unsigned char** bytes_to_send,
675 size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
676 tsi_handshaker_on_next_done_cb /*cb*/, void* /*user_data*/) {
677 /* Sanity check the arguments. */
678 if ((received_bytes_size > 0 && received_bytes == nullptr) ||
679 bytes_to_send == nullptr || bytes_to_send_size == nullptr ||
680 handshaker_result == nullptr) {
681 return TSI_INVALID_ARGUMENT;
682 }
683 tsi_fake_handshaker* handshaker =
684 reinterpret_cast<tsi_fake_handshaker*>(self);
685 tsi_result result = TSI_OK;
686
687 /* Decode and process a handshake frame from the peer. */
688 size_t consumed_bytes_size = received_bytes_size;
689 if (received_bytes_size > 0) {
690 result = fake_handshaker_process_bytes_from_peer(self, received_bytes,
691 &consumed_bytes_size);
692 if (result != TSI_OK) return result;
693 }
694
695 /* Create a handshake message to send to the peer and encode it as a fake
696 * frame. */
697 size_t offset = 0;
698 do {
699 size_t sent_bytes_size = handshaker->outgoing_bytes_buffer_size - offset;
700 result = fake_handshaker_get_bytes_to_send_to_peer(
701 self, handshaker->outgoing_bytes_buffer + offset, &sent_bytes_size);
702 offset += sent_bytes_size;
703 if (result == TSI_INCOMPLETE_DATA) {
704 handshaker->outgoing_bytes_buffer_size *= 2;
705 handshaker->outgoing_bytes_buffer = static_cast<unsigned char*>(
706 gpr_realloc(handshaker->outgoing_bytes_buffer,
707 handshaker->outgoing_bytes_buffer_size));
708 }
709 } while (result == TSI_INCOMPLETE_DATA);
710 if (result != TSI_OK) return result;
711 *bytes_to_send = handshaker->outgoing_bytes_buffer;
712 *bytes_to_send_size = offset;
713
714 /* Check if the handshake was completed. */
715 if (fake_handshaker_get_result(self) == TSI_HANDSHAKE_IN_PROGRESS) {
716 *handshaker_result = nullptr;
717 } else {
718 /* Calculate the unused bytes. */
719 const unsigned char* unused_bytes = nullptr;
720 size_t unused_bytes_size = received_bytes_size - consumed_bytes_size;
721 if (unused_bytes_size > 0) {
722 unused_bytes = received_bytes + consumed_bytes_size;
723 }
724
725 /* Create a handshaker_result containing the unused bytes. */
726 result = fake_handshaker_result_create(unused_bytes, unused_bytes_size,
727 handshaker_result);
728 if (result == TSI_OK) {
729 /* Indicate that the handshake has completed and that a handshaker_result
730 * has been created. */
731 self->handshaker_result_created = true;
732 }
733 }
734 return result;
735 }
736
737 static const tsi_handshaker_vtable handshaker_vtable = {
738 nullptr, /* get_bytes_to_send_to_peer -- deprecated */
739 nullptr, /* process_bytes_from_peer -- deprecated */
740 nullptr, /* get_result -- deprecated */
741 nullptr, /* extract_peer -- deprecated */
742 nullptr, /* create_frame_protector -- deprecated */
743 fake_handshaker_destroy,
744 fake_handshaker_next,
745 nullptr, /* shutdown */
746 };
747
tsi_create_fake_handshaker(int is_client)748 tsi_handshaker* tsi_create_fake_handshaker(int is_client) {
749 tsi_fake_handshaker* impl =
750 static_cast<tsi_fake_handshaker*>(gpr_zalloc(sizeof(*impl)));
751 impl->base.vtable = &handshaker_vtable;
752 impl->is_client = is_client;
753 impl->result = TSI_HANDSHAKE_IN_PROGRESS;
754 impl->outgoing_bytes_buffer_size =
755 TSI_FAKE_HANDSHAKER_OUTGOING_BUFFER_INITIAL_SIZE;
756 impl->outgoing_bytes_buffer =
757 static_cast<unsigned char*>(gpr_malloc(impl->outgoing_bytes_buffer_size));
758 if (is_client) {
759 impl->needs_incoming_message = 0;
760 impl->next_message_to_send = TSI_FAKE_CLIENT_INIT;
761 } else {
762 impl->needs_incoming_message = 1;
763 impl->next_message_to_send = TSI_FAKE_SERVER_INIT;
764 }
765 return &impl->base;
766 }
767
tsi_create_fake_frame_protector(size_t * max_protected_frame_size)768 tsi_frame_protector* tsi_create_fake_frame_protector(
769 size_t* max_protected_frame_size) {
770 tsi_fake_frame_protector* impl =
771 static_cast<tsi_fake_frame_protector*>(gpr_zalloc(sizeof(*impl)));
772 impl->max_frame_size = (max_protected_frame_size == nullptr)
773 ? TSI_FAKE_DEFAULT_FRAME_SIZE
774 : *max_protected_frame_size;
775 impl->base.vtable = &frame_protector_vtable;
776 return &impl->base;
777 }
778
tsi_create_fake_zero_copy_grpc_protector(size_t * max_protected_frame_size)779 tsi_zero_copy_grpc_protector* tsi_create_fake_zero_copy_grpc_protector(
780 size_t* max_protected_frame_size) {
781 tsi_fake_zero_copy_grpc_protector* impl =
782 static_cast<tsi_fake_zero_copy_grpc_protector*>(
783 gpr_zalloc(sizeof(*impl)));
784 grpc_slice_buffer_init(&impl->header_sb);
785 grpc_slice_buffer_init(&impl->protected_sb);
786 impl->max_frame_size = (max_protected_frame_size == nullptr)
787 ? TSI_FAKE_DEFAULT_FRAME_SIZE
788 : *max_protected_frame_size;
789 impl->parsed_frame_size = 0;
790 impl->base.vtable = &zero_copy_grpc_protector_vtable;
791 return &impl->base;
792 }
793