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/alloc.h>
20 #include <grpc/support/log.h>
21
22 #include "src/core/lib/iomgr/exec_ctx.h"
23 #include "src/core/lib/slice/slice_internal.h"
24 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.h"
25 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_privacy_integrity_record_protocol.h"
26 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol.h"
27 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
28 #include "test/core/tsi/alts/crypt/gsec_test_util.h"
29
30 constexpr size_t kMaxSliceLength = 256;
31 constexpr size_t kMaxSlices = 10;
32 constexpr size_t kSealRepeatTimes = 5;
33 constexpr size_t kTagLength = 16;
34
35 /* Test fixtures for each test cases. */
36 struct alts_grpc_record_protocol_test_fixture {
37 alts_grpc_record_protocol* client_protect;
38 alts_grpc_record_protocol* client_unprotect;
39 alts_grpc_record_protocol* server_protect;
40 alts_grpc_record_protocol* server_unprotect;
41 };
42
43 /* Test input variables for protect/unprotect operations. */
44 struct alts_grpc_record_protocol_test_var {
45 size_t header_length;
46 size_t tag_length;
47 grpc_slice_buffer original_sb;
48 grpc_slice_buffer duplicate_sb;
49 grpc_slice_buffer protected_sb;
50 grpc_slice_buffer unprotected_sb;
51 };
52
53 /* --- Test utility functions. --- */
54
create_random_slice_buffer(grpc_slice_buffer * sb)55 static void create_random_slice_buffer(grpc_slice_buffer* sb) {
56 GPR_ASSERT(sb != nullptr);
57 size_t slice_count = gsec_test_bias_random_uint32(kMaxSlices) + 1;
58 for (size_t i = 0; i < slice_count; i++) {
59 size_t slice_length = gsec_test_bias_random_uint32(kMaxSliceLength) + 1;
60 grpc_slice slice = GRPC_SLICE_MALLOC(slice_length);
61 gsec_test_random_bytes(GRPC_SLICE_START_PTR(slice), slice_length);
62 grpc_slice_buffer_add(sb, slice);
63 }
64 }
65
pointer_to_nth_byte(grpc_slice_buffer * sb,size_t index)66 static uint8_t* pointer_to_nth_byte(grpc_slice_buffer* sb, size_t index) {
67 GPR_ASSERT(sb != nullptr);
68 GPR_ASSERT(index < sb->length);
69 for (size_t i = 0; i < sb->count; i++) {
70 if (index < GRPC_SLICE_LENGTH(sb->slices[i])) {
71 return GRPC_SLICE_START_PTR(sb->slices[i]) + index;
72 } else {
73 index -= GRPC_SLICE_LENGTH(sb->slices[i]);
74 }
75 }
76 return nullptr;
77 }
78
79 /* Checks if two slice buffer contents are the same. It is not super efficient,
80 * but OK for testing. */
are_slice_buffers_equal(grpc_slice_buffer * first,grpc_slice_buffer * second)81 static bool are_slice_buffers_equal(grpc_slice_buffer* first,
82 grpc_slice_buffer* second) {
83 GPR_ASSERT(first != nullptr);
84 GPR_ASSERT(second != nullptr);
85 if (first->length != second->length) {
86 return false;
87 }
88 for (size_t i = 0; i < first->length; i++) {
89 uint8_t* first_ptr = pointer_to_nth_byte(first, i);
90 uint8_t* second_ptr = pointer_to_nth_byte(second, i);
91 GPR_ASSERT(first_ptr != nullptr);
92 GPR_ASSERT(second_ptr != nullptr);
93 if ((*first_ptr) != (*second_ptr)) {
94 return false;
95 }
96 }
97 return true;
98 }
99
alter_random_byte(grpc_slice_buffer * sb)100 static void alter_random_byte(grpc_slice_buffer* sb) {
101 GPR_ASSERT(sb != nullptr);
102 if (sb->length == 0) {
103 return;
104 }
105 uint32_t offset =
106 gsec_test_bias_random_uint32(static_cast<uint32_t>(sb->length));
107 uint8_t* ptr = pointer_to_nth_byte(sb, offset);
108 (*ptr)++;
109 }
110
111 static alts_grpc_record_protocol_test_fixture*
test_fixture_integrity_only_create(bool rekey,bool extra_copy)112 test_fixture_integrity_only_create(bool rekey, bool extra_copy) {
113 alts_grpc_record_protocol_test_fixture* fixture =
114 static_cast<alts_grpc_record_protocol_test_fixture*>(
115 gpr_zalloc(sizeof(alts_grpc_record_protocol_test_fixture)));
116 size_t key_length = rekey ? kAes128GcmRekeyKeyLength : kAes128GcmKeyLength;
117 uint8_t* key;
118 gsec_test_random_array(&key, key_length);
119 gsec_aead_crypter* crypter = nullptr;
120
121 /* Create client record protocol for protect. */
122 GPR_ASSERT(gsec_aes_gcm_aead_crypter_create(
123 key, key_length, kAesGcmNonceLength, kAesGcmTagLength, rekey,
124 &crypter, nullptr) == GRPC_STATUS_OK);
125 GPR_ASSERT(alts_grpc_integrity_only_record_protocol_create(
126 crypter, 8, /*is_client=*/true, /*is_protect=*/true,
127 extra_copy, &fixture->client_protect) == TSI_OK);
128 /* Create client record protocol for unprotect. */
129 GPR_ASSERT(gsec_aes_gcm_aead_crypter_create(
130 key, key_length, kAesGcmNonceLength, kAesGcmTagLength, rekey,
131 &crypter, nullptr) == GRPC_STATUS_OK);
132 GPR_ASSERT(alts_grpc_integrity_only_record_protocol_create(
133 crypter, 8, /*is_client=*/true, /*is_protect=*/false,
134 extra_copy, &fixture->client_unprotect) == TSI_OK);
135 /* Create server record protocol for protect. */
136 GPR_ASSERT(gsec_aes_gcm_aead_crypter_create(
137 key, key_length, kAesGcmNonceLength, kAesGcmTagLength, rekey,
138 &crypter, nullptr) == GRPC_STATUS_OK);
139 GPR_ASSERT(alts_grpc_integrity_only_record_protocol_create(
140 crypter, 8, /*is_client=*/false, /*is_protect=*/true,
141 extra_copy, &fixture->server_protect) == TSI_OK);
142 /* Create server record protocol for unprotect. */
143 GPR_ASSERT(gsec_aes_gcm_aead_crypter_create(
144 key, key_length, kAesGcmNonceLength, kAesGcmTagLength, rekey,
145 &crypter, nullptr) == GRPC_STATUS_OK);
146 GPR_ASSERT(alts_grpc_integrity_only_record_protocol_create(
147 crypter, 8, /*is_client=*/false, /*is_protect=*/false,
148 extra_copy, &fixture->server_unprotect) == TSI_OK);
149
150 gpr_free(key);
151 return fixture;
152 }
153
154 static alts_grpc_record_protocol_test_fixture*
test_fixture_integrity_only_no_rekey_no_extra_copy_create()155 test_fixture_integrity_only_no_rekey_no_extra_copy_create() {
156 return test_fixture_integrity_only_create(false, false);
157 }
158
159 static alts_grpc_record_protocol_test_fixture*
test_fixture_integrity_only_rekey_create()160 test_fixture_integrity_only_rekey_create() {
161 return test_fixture_integrity_only_create(true, false);
162 }
163
164 static alts_grpc_record_protocol_test_fixture*
test_fixture_integrity_only_extra_copy_create()165 test_fixture_integrity_only_extra_copy_create() {
166 return test_fixture_integrity_only_create(false, true);
167 }
168
169 static alts_grpc_record_protocol_test_fixture*
test_fixture_privacy_integrity_create(bool rekey)170 test_fixture_privacy_integrity_create(bool rekey) {
171 alts_grpc_record_protocol_test_fixture* fixture =
172 static_cast<alts_grpc_record_protocol_test_fixture*>(
173 gpr_zalloc(sizeof(alts_grpc_record_protocol_test_fixture)));
174 size_t key_length = rekey ? kAes128GcmRekeyKeyLength : kAes128GcmKeyLength;
175 uint8_t* key;
176 gsec_test_random_array(&key, key_length);
177 gsec_aead_crypter* crypter = nullptr;
178
179 /* Create client record protocol for protect. */
180 GPR_ASSERT(gsec_aes_gcm_aead_crypter_create(
181 key, key_length, kAesGcmNonceLength, kAesGcmTagLength, rekey,
182 &crypter, nullptr) == GRPC_STATUS_OK);
183 GPR_ASSERT(alts_grpc_privacy_integrity_record_protocol_create(
184 crypter, 8, /*is_client=*/true, /*is_protect=*/true,
185 &fixture->client_protect) == TSI_OK);
186 /* Create client record protocol for unprotect. */
187 GPR_ASSERT(gsec_aes_gcm_aead_crypter_create(
188 key, key_length, kAesGcmNonceLength, kAesGcmTagLength, rekey,
189 &crypter, nullptr) == GRPC_STATUS_OK);
190 GPR_ASSERT(alts_grpc_privacy_integrity_record_protocol_create(
191 crypter, 8, /*is_client=*/true, /*is_protect=*/false,
192 &fixture->client_unprotect) == TSI_OK);
193 /* Create server record protocol for protect. */
194 GPR_ASSERT(gsec_aes_gcm_aead_crypter_create(
195 key, key_length, kAesGcmNonceLength, kAesGcmTagLength, rekey,
196 &crypter, nullptr) == GRPC_STATUS_OK);
197 GPR_ASSERT(alts_grpc_privacy_integrity_record_protocol_create(
198 crypter, 8, /*is_client=*/false, /*is_protect=*/true,
199 &fixture->server_protect) == TSI_OK);
200 /* Create server record protocol for unprotect. */
201 GPR_ASSERT(gsec_aes_gcm_aead_crypter_create(
202 key, key_length, kAesGcmNonceLength, kAesGcmTagLength, rekey,
203 &crypter, nullptr) == GRPC_STATUS_OK);
204 GPR_ASSERT(alts_grpc_privacy_integrity_record_protocol_create(
205 crypter, 8, /*is_client=*/false, /*is_protect=*/false,
206 &fixture->server_unprotect) == TSI_OK);
207
208 gpr_free(key);
209 return fixture;
210 }
211
212 static alts_grpc_record_protocol_test_fixture*
test_fixture_privacy_integrity_no_rekey_create()213 test_fixture_privacy_integrity_no_rekey_create() {
214 return test_fixture_privacy_integrity_create(false);
215 }
216
217 static alts_grpc_record_protocol_test_fixture*
test_fixture_privacy_integrity_rekey_create()218 test_fixture_privacy_integrity_rekey_create() {
219 return test_fixture_privacy_integrity_create(true);
220 }
221
alts_grpc_record_protocol_test_fixture_destroy(alts_grpc_record_protocol_test_fixture * fixture)222 static void alts_grpc_record_protocol_test_fixture_destroy(
223 alts_grpc_record_protocol_test_fixture* fixture) {
224 if (fixture == nullptr) {
225 return;
226 }
227 grpc_core::ExecCtx exec_ctx;
228 alts_grpc_record_protocol_destroy(fixture->client_protect);
229 alts_grpc_record_protocol_destroy(fixture->client_unprotect);
230 alts_grpc_record_protocol_destroy(fixture->server_protect);
231 alts_grpc_record_protocol_destroy(fixture->server_unprotect);
232 grpc_core::ExecCtx::Get()->Flush();
233 gpr_free(fixture);
234 }
235
236 static alts_grpc_record_protocol_test_var*
alts_grpc_record_protocol_test_var_create()237 alts_grpc_record_protocol_test_var_create() {
238 alts_grpc_record_protocol_test_var* var =
239 static_cast<alts_grpc_record_protocol_test_var*>(
240 gpr_zalloc(sizeof(alts_grpc_record_protocol_test_var)));
241 var->header_length = alts_iovec_record_protocol_get_header_length();
242 var->tag_length = kTagLength;
243 /* Initialized slice buffers. */
244 grpc_slice_buffer_init(&var->original_sb);
245 grpc_slice_buffer_init(&var->duplicate_sb);
246 grpc_slice_buffer_init(&var->protected_sb);
247 grpc_slice_buffer_init(&var->unprotected_sb);
248 /* Randomly sets content of original_sb, and copies into duplicate_sb. */
249 create_random_slice_buffer(&var->original_sb);
250 for (size_t i = 0; i < var->original_sb.count; i++) {
251 grpc_slice_buffer_add(&var->duplicate_sb,
252 grpc_slice_ref(var->original_sb.slices[i]));
253 }
254 return var;
255 }
256
alts_grpc_record_protocol_test_var_destroy(alts_grpc_record_protocol_test_var * var)257 static void alts_grpc_record_protocol_test_var_destroy(
258 alts_grpc_record_protocol_test_var* var) {
259 if (var == nullptr) {
260 return;
261 }
262 grpc_slice_buffer_destroy_internal(&var->original_sb);
263 grpc_slice_buffer_destroy_internal(&var->duplicate_sb);
264 grpc_slice_buffer_destroy_internal(&var->protected_sb);
265 grpc_slice_buffer_destroy_internal(&var->unprotected_sb);
266 gpr_free(var);
267 }
268
269 /* --- alts grpc record protocol tests. --- */
270
random_seal_unseal(alts_grpc_record_protocol * sender,alts_grpc_record_protocol * receiver)271 static void random_seal_unseal(alts_grpc_record_protocol* sender,
272 alts_grpc_record_protocol* receiver) {
273 grpc_core::ExecCtx exec_ctx;
274 for (size_t i = 0; i < kSealRepeatTimes; i++) {
275 alts_grpc_record_protocol_test_var* var =
276 alts_grpc_record_protocol_test_var_create();
277 /* Seals and then unseals. */
278 size_t data_length = var->original_sb.length;
279 tsi_result status = alts_grpc_record_protocol_protect(
280 sender, &var->original_sb, &var->protected_sb);
281 GPR_ASSERT(status == TSI_OK);
282 GPR_ASSERT(var->protected_sb.length ==
283 data_length + var->header_length + var->tag_length);
284 status = alts_grpc_record_protocol_unprotect(receiver, &var->protected_sb,
285 &var->unprotected_sb);
286 GPR_ASSERT(status == TSI_OK);
287 GPR_ASSERT(
288 are_slice_buffers_equal(&var->unprotected_sb, &var->duplicate_sb));
289 alts_grpc_record_protocol_test_var_destroy(var);
290 }
291 grpc_core::ExecCtx::Get()->Flush();
292 }
293
empty_seal_unseal(alts_grpc_record_protocol * sender,alts_grpc_record_protocol * receiver)294 static void empty_seal_unseal(alts_grpc_record_protocol* sender,
295 alts_grpc_record_protocol* receiver) {
296 grpc_core::ExecCtx exec_ctx;
297 for (size_t i = 0; i < kSealRepeatTimes; i++) {
298 alts_grpc_record_protocol_test_var* var =
299 alts_grpc_record_protocol_test_var_create();
300 /* Seals and then unseals empty payload. */
301 grpc_slice_buffer_reset_and_unref_internal(&var->original_sb);
302 grpc_slice_buffer_reset_and_unref_internal(&var->duplicate_sb);
303 tsi_result status = alts_grpc_record_protocol_protect(
304 sender, &var->original_sb, &var->protected_sb);
305 GPR_ASSERT(status == TSI_OK);
306 GPR_ASSERT(var->protected_sb.length ==
307 var->header_length + var->tag_length);
308 status = alts_grpc_record_protocol_unprotect(receiver, &var->protected_sb,
309 &var->unprotected_sb);
310 GPR_ASSERT(status == TSI_OK);
311 GPR_ASSERT(
312 are_slice_buffers_equal(&var->unprotected_sb, &var->duplicate_sb));
313 alts_grpc_record_protocol_test_var_destroy(var);
314 }
315 grpc_core::ExecCtx::Get()->Flush();
316 }
317
unsync_seal_unseal(alts_grpc_record_protocol * sender,alts_grpc_record_protocol * receiver)318 static void unsync_seal_unseal(alts_grpc_record_protocol* sender,
319 alts_grpc_record_protocol* receiver) {
320 grpc_core::ExecCtx exec_ctx;
321 tsi_result status;
322 alts_grpc_record_protocol_test_var* var =
323 alts_grpc_record_protocol_test_var_create();
324 /* Seals once. */
325 status = alts_grpc_record_protocol_protect(sender, &var->original_sb,
326 &var->protected_sb);
327 GPR_ASSERT(status == TSI_OK);
328 grpc_slice_buffer_reset_and_unref_internal(&var->protected_sb);
329 /* Seals again. */
330 status = alts_grpc_record_protocol_protect(sender, &var->duplicate_sb,
331 &var->protected_sb);
332 GPR_ASSERT(status == TSI_OK);
333 /* Unseals the second frame. */
334 status = alts_grpc_record_protocol_unprotect(receiver, &var->protected_sb,
335 &var->unprotected_sb);
336 GPR_ASSERT(status == TSI_INTERNAL_ERROR);
337 alts_grpc_record_protocol_test_var_destroy(var);
338 grpc_core::ExecCtx::Get()->Flush();
339 }
340
corrupted_data(alts_grpc_record_protocol * sender,alts_grpc_record_protocol * receiver)341 static void corrupted_data(alts_grpc_record_protocol* sender,
342 alts_grpc_record_protocol* receiver) {
343 grpc_core::ExecCtx exec_ctx;
344 tsi_result status;
345 alts_grpc_record_protocol_test_var* var =
346 alts_grpc_record_protocol_test_var_create();
347 /* Seals once. */
348 status = alts_grpc_record_protocol_protect(sender, &var->original_sb,
349 &var->protected_sb);
350 GPR_ASSERT(status == TSI_OK);
351 /* Corrupts one byte in protected_sb and tries to unprotect. */
352 alter_random_byte(&var->protected_sb);
353 status = alts_grpc_record_protocol_unprotect(receiver, &var->protected_sb,
354 &var->unprotected_sb);
355 GPR_ASSERT(status == TSI_INTERNAL_ERROR);
356 alts_grpc_record_protocol_test_var_destroy(var);
357 grpc_core::ExecCtx::Get()->Flush();
358 }
359
input_check(alts_grpc_record_protocol * rp)360 static void input_check(alts_grpc_record_protocol* rp) {
361 grpc_core::ExecCtx exec_ctx;
362 tsi_result status;
363 alts_grpc_record_protocol_test_var* var =
364 alts_grpc_record_protocol_test_var_create();
365 /* Protects with nullptr input. */
366 status = alts_grpc_record_protocol_protect(rp, nullptr, &var->protected_sb);
367 GPR_ASSERT(status == TSI_INVALID_ARGUMENT);
368 status = alts_grpc_record_protocol_protect(rp, &var->original_sb, nullptr);
369 GPR_ASSERT(status == TSI_INVALID_ARGUMENT);
370 /* Unprotects with nullptr input. */
371 status = alts_grpc_record_protocol_protect(rp, &var->original_sb,
372 &var->protected_sb);
373 GPR_ASSERT(status == TSI_OK);
374 status =
375 alts_grpc_record_protocol_unprotect(rp, nullptr, &var->unprotected_sb);
376 GPR_ASSERT(status == TSI_INVALID_ARGUMENT);
377 status = alts_grpc_record_protocol_unprotect(rp, &var->protected_sb, nullptr);
378 GPR_ASSERT(status == TSI_INVALID_ARGUMENT);
379 /* Unprotects on a temporary slice buffer which length is smaller than header
380 * length plus tag length. */
381 grpc_slice_buffer temp_sb;
382 grpc_slice_buffer_init(&temp_sb);
383 grpc_slice_buffer_move_first(
384 &var->protected_sb, var->header_length + var->tag_length - 1, &temp_sb);
385 status =
386 alts_grpc_record_protocol_unprotect(rp, &temp_sb, &var->unprotected_sb);
387 GPR_ASSERT(status == TSI_INVALID_ARGUMENT);
388 grpc_slice_buffer_destroy_internal(&temp_sb);
389 alts_grpc_record_protocol_test_var_destroy(var);
390 grpc_core::ExecCtx::Get()->Flush();
391 }
392
393 /* --- Test cases. --- */
394
alts_grpc_record_protocol_random_seal_unseal_tests(alts_grpc_record_protocol_test_fixture * fixture)395 static void alts_grpc_record_protocol_random_seal_unseal_tests(
396 alts_grpc_record_protocol_test_fixture* fixture) {
397 random_seal_unseal(fixture->client_protect, fixture->server_unprotect);
398 random_seal_unseal(fixture->server_protect, fixture->client_unprotect);
399 }
400
alts_grpc_record_protocol_empty_seal_unseal_tests(alts_grpc_record_protocol_test_fixture * fixture)401 static void alts_grpc_record_protocol_empty_seal_unseal_tests(
402 alts_grpc_record_protocol_test_fixture* fixture) {
403 empty_seal_unseal(fixture->client_protect, fixture->server_unprotect);
404 empty_seal_unseal(fixture->server_protect, fixture->client_unprotect);
405 }
406
alts_grpc_record_protocol_unsync_seal_unseal_tests(alts_grpc_record_protocol_test_fixture * fixture)407 static void alts_grpc_record_protocol_unsync_seal_unseal_tests(
408 alts_grpc_record_protocol_test_fixture* fixture) {
409 unsync_seal_unseal(fixture->client_protect, fixture->server_unprotect);
410 unsync_seal_unseal(fixture->server_protect, fixture->client_unprotect);
411 }
412
alts_grpc_record_protocol_corrupted_data_tests(alts_grpc_record_protocol_test_fixture * fixture)413 static void alts_grpc_record_protocol_corrupted_data_tests(
414 alts_grpc_record_protocol_test_fixture* fixture) {
415 corrupted_data(fixture->client_protect, fixture->server_unprotect);
416 corrupted_data(fixture->server_protect, fixture->client_unprotect);
417 }
418
alts_grpc_record_protocol_input_check_tests(alts_grpc_record_protocol_test_fixture * fixture)419 static void alts_grpc_record_protocol_input_check_tests(
420 alts_grpc_record_protocol_test_fixture* fixture) {
421 input_check(fixture->client_protect);
422 }
423
alts_grpc_record_protocol_tests(alts_grpc_record_protocol_test_fixture * (* fixture_create)())424 static void alts_grpc_record_protocol_tests(
425 alts_grpc_record_protocol_test_fixture* (*fixture_create)()) {
426 auto* fixture_1 = fixture_create();
427 alts_grpc_record_protocol_random_seal_unseal_tests(fixture_1);
428 alts_grpc_record_protocol_test_fixture_destroy(fixture_1);
429
430 auto* fixture_2 = fixture_create();
431 alts_grpc_record_protocol_empty_seal_unseal_tests(fixture_2);
432 alts_grpc_record_protocol_test_fixture_destroy(fixture_2);
433
434 auto* fixture_3 = fixture_create();
435 alts_grpc_record_protocol_unsync_seal_unseal_tests(fixture_3);
436 alts_grpc_record_protocol_test_fixture_destroy(fixture_3);
437
438 auto* fixture_4 = fixture_create();
439 alts_grpc_record_protocol_corrupted_data_tests(fixture_4);
440 alts_grpc_record_protocol_test_fixture_destroy(fixture_4);
441
442 auto* fixture_5 = fixture_create();
443 alts_grpc_record_protocol_input_check_tests(fixture_5);
444 alts_grpc_record_protocol_test_fixture_destroy(fixture_5);
445 }
446
main(int argc,char ** argv)447 int main(int argc, char** argv) {
448 alts_grpc_record_protocol_tests(
449 &test_fixture_integrity_only_no_rekey_no_extra_copy_create);
450 alts_grpc_record_protocol_tests(&test_fixture_integrity_only_rekey_create);
451 alts_grpc_record_protocol_tests(
452 &test_fixture_integrity_only_extra_copy_create);
453 alts_grpc_record_protocol_tests(
454 &test_fixture_privacy_integrity_no_rekey_create);
455 alts_grpc_record_protocol_tests(&test_fixture_privacy_integrity_rekey_create);
456
457 return 0;
458 }
459