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 <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include <grpc/support/alloc.h>
24 #include <grpc/support/log.h>
25
26 #include "src/core/tsi/alts/frame_protector/alts_crypter.h"
27 #include "test/core/tsi/alts/crypt/gsec_test_util.h"
28
alts_crypter_test_random_seal_unseal(alts_crypter * server_seal,alts_crypter * server_unseal,alts_crypter * client_seal,alts_crypter * client_unseal)29 static void alts_crypter_test_random_seal_unseal(alts_crypter* server_seal,
30 alts_crypter* server_unseal,
31 alts_crypter* client_seal,
32 alts_crypter* client_unseal) {
33 size_t data_size = gsec_test_bias_random_uint32(1024) + 1;
34 size_t num_overhead_bytes = alts_crypter_num_overhead_bytes(server_seal);
35 size_t protected_data_size = data_size + num_overhead_bytes;
36 uint8_t* data_buffer = static_cast<uint8_t*>(gpr_malloc(protected_data_size));
37 gsec_test_random_bytes(data_buffer, data_size);
38 uint8_t* duplicate_buffer = nullptr;
39 gsec_test_copy(data_buffer, &duplicate_buffer, data_size);
40
41 /* Client seal and server unseal */
42 size_t size = data_size;
43 grpc_status_code status = alts_crypter_process_in_place(
44 client_seal, data_buffer, protected_data_size, size, &size, nullptr);
45 GPR_ASSERT(status == GRPC_STATUS_OK);
46 GPR_ASSERT(size == protected_data_size);
47 status = alts_crypter_process_in_place(
48 server_unseal, data_buffer, protected_data_size, size, &size, nullptr);
49 GPR_ASSERT(status == GRPC_STATUS_OK);
50 GPR_ASSERT(memcmp(data_buffer, duplicate_buffer, data_size) == 0);
51 GPR_ASSERT(size == data_size);
52 /* Server seal and client unseal */
53 status = alts_crypter_process_in_place(
54 server_seal, data_buffer, protected_data_size, size, &size, nullptr);
55 GPR_ASSERT(status == GRPC_STATUS_OK);
56 GPR_ASSERT(size == protected_data_size);
57 status = alts_crypter_process_in_place(
58 client_unseal, data_buffer, protected_data_size, size, &size, nullptr);
59 GPR_ASSERT(status == GRPC_STATUS_OK);
60 GPR_ASSERT(memcmp(data_buffer, duplicate_buffer, data_size) == 0);
61 GPR_ASSERT(size == data_size);
62 gpr_free(data_buffer);
63 gpr_free(duplicate_buffer);
64 }
65
alts_crypter_test_multiple_random_seal_unseal(alts_crypter * server_seal,alts_crypter * server_unseal,alts_crypter * client_seal,alts_crypter * client_unseal)66 static void alts_crypter_test_multiple_random_seal_unseal(
67 alts_crypter* server_seal, alts_crypter* server_unseal,
68 alts_crypter* client_seal, alts_crypter* client_unseal) {
69 size_t data_size = gsec_test_bias_random_uint32(1024) + 1;
70 size_t num_overhead_bytes = alts_crypter_num_overhead_bytes(server_seal);
71 size_t protected_data_size = data_size + num_overhead_bytes;
72
73 uint8_t* data_buffer1 =
74 static_cast<uint8_t*>(gpr_malloc(protected_data_size));
75 uint8_t* data_buffer2 =
76 static_cast<uint8_t*>(gpr_malloc(protected_data_size));
77 uint8_t* duplicate_buffer1 = nullptr;
78 uint8_t* duplicate_buffer2 = nullptr;
79 gsec_test_random_bytes(data_buffer1, data_size);
80 gsec_test_random_bytes(data_buffer2, data_size);
81 gsec_test_copy(data_buffer1, &duplicate_buffer1, data_size);
82 gsec_test_copy(data_buffer2, &duplicate_buffer2, data_size);
83
84 /* Client seal and server unseal */
85 size_t size1 = data_size, size2 = data_size;
86 grpc_status_code status = alts_crypter_process_in_place(
87 client_seal, data_buffer1, protected_data_size, size1, &size1, nullptr);
88 GPR_ASSERT(status == GRPC_STATUS_OK);
89 GPR_ASSERT(size1 == protected_data_size);
90 status = alts_crypter_process_in_place(
91 client_seal, data_buffer2, protected_data_size, size2, &size2, nullptr);
92 GPR_ASSERT(status == GRPC_STATUS_OK);
93 GPR_ASSERT(size2 == protected_data_size);
94 status = alts_crypter_process_in_place(
95 server_unseal, data_buffer1, protected_data_size, size1, &size1, nullptr);
96 GPR_ASSERT(status == GRPC_STATUS_OK);
97 GPR_ASSERT(memcmp(data_buffer1, duplicate_buffer1, data_size) == 0);
98 GPR_ASSERT(size1 == data_size);
99 status = alts_crypter_process_in_place(
100 server_unseal, data_buffer2, protected_data_size, size2, &size2, nullptr);
101 GPR_ASSERT(status == GRPC_STATUS_OK);
102 GPR_ASSERT(memcmp(data_buffer2, duplicate_buffer2, data_size) == 0);
103 GPR_ASSERT(size2 == data_size);
104
105 /* Server seal and client unseal */
106 status = alts_crypter_process_in_place(
107 server_seal, data_buffer1, protected_data_size, size1, &size1, nullptr);
108 GPR_ASSERT(status == GRPC_STATUS_OK);
109 GPR_ASSERT(size1 == protected_data_size);
110 status = alts_crypter_process_in_place(
111 server_seal, data_buffer2, protected_data_size, size2, &size2, nullptr);
112 GPR_ASSERT(status == GRPC_STATUS_OK);
113 GPR_ASSERT(size2 == protected_data_size);
114 status = alts_crypter_process_in_place(
115 client_unseal, data_buffer1, protected_data_size, size1, &size1, nullptr);
116 GPR_ASSERT(status == GRPC_STATUS_OK);
117 GPR_ASSERT(memcmp(data_buffer1, duplicate_buffer1, data_size) == 0);
118 GPR_ASSERT(size1 == data_size);
119 status = alts_crypter_process_in_place(
120 client_unseal, data_buffer2, protected_data_size, size2, &size2, nullptr);
121 GPR_ASSERT(status == GRPC_STATUS_OK);
122 GPR_ASSERT(memcmp(data_buffer2, duplicate_buffer2, data_size) == 0);
123 GPR_ASSERT(size2 == data_size);
124
125 gpr_free(data_buffer1);
126 gpr_free(data_buffer2);
127 gpr_free(duplicate_buffer1);
128 gpr_free(duplicate_buffer2);
129 }
130
alts_crypter_test_corrupted_unseal(alts_crypter * server_seal,alts_crypter * server_unseal,alts_crypter * client_seal,alts_crypter *)131 static void alts_crypter_test_corrupted_unseal(
132 alts_crypter* server_seal, alts_crypter* server_unseal,
133 alts_crypter* client_seal, alts_crypter* /*client_unseal*/) {
134 size_t data_size = gsec_test_bias_random_uint32(1024) + 1;
135 size_t num_overhead_bytes = alts_crypter_num_overhead_bytes(server_seal);
136 size_t protected_data_size = data_size + num_overhead_bytes;
137 auto* data_buffer = static_cast<uint8_t*>(gpr_malloc(protected_data_size));
138 auto* zero_buffer = static_cast<uint8_t*>(gpr_zalloc(data_size));
139
140 /* Corrupt a random byte in protected data. */
141 size_t size = data_size;
142 gsec_test_random_bytes(data_buffer, data_size);
143 grpc_status_code status = alts_crypter_process_in_place(
144 client_seal, data_buffer, protected_data_size, size, &size, nullptr);
145 GPR_ASSERT(status == GRPC_STATUS_OK);
146 GPR_ASSERT(size == protected_data_size);
147 uint8_t* corrupted_data_buffer;
148 char* error_message = nullptr;
149 gsec_test_copy_and_alter_random_byte(data_buffer, &corrupted_data_buffer,
150 protected_data_size);
151 status = alts_crypter_process_in_place(server_unseal, corrupted_data_buffer,
152 protected_data_size, size, &size,
153 &error_message);
154 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
155 status, GRPC_STATUS_FAILED_PRECONDITION, error_message,
156 "Checking tag failed"));
157 GPR_ASSERT(memcmp(corrupted_data_buffer, zero_buffer, data_size) == 0);
158 gpr_free(corrupted_data_buffer);
159 gpr_free(error_message);
160
161 /* Corrupt the beginning of protected data. */
162 size = data_size;
163 gsec_test_random_bytes(data_buffer, data_size);
164 status = alts_crypter_process_in_place(
165 client_seal, data_buffer, protected_data_size, size, &size, nullptr);
166 GPR_ASSERT(status == GRPC_STATUS_OK);
167 GPR_ASSERT(size == protected_data_size);
168 gsec_test_copy(data_buffer, &corrupted_data_buffer, protected_data_size);
169 (*corrupted_data_buffer)++;
170 status = alts_crypter_process_in_place(server_unseal, corrupted_data_buffer,
171 protected_data_size, size, &size,
172 &error_message);
173 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
174 status, GRPC_STATUS_FAILED_PRECONDITION, error_message,
175 "Checking tag failed"));
176 GPR_ASSERT(memcmp(corrupted_data_buffer, zero_buffer, data_size) == 0);
177 gpr_free(corrupted_data_buffer);
178 gpr_free(error_message);
179
180 /* Corrupt the end of protected data. */
181 size = data_size;
182 gsec_test_random_bytes(data_buffer, data_size);
183 status = alts_crypter_process_in_place(
184 client_seal, data_buffer, protected_data_size, size, &size, nullptr);
185 GPR_ASSERT(status == GRPC_STATUS_OK);
186 GPR_ASSERT(size == protected_data_size);
187 gsec_test_copy(data_buffer, &corrupted_data_buffer, protected_data_size);
188 (*(corrupted_data_buffer + protected_data_size - 1))++;
189 status = alts_crypter_process_in_place(server_unseal, corrupted_data_buffer,
190 protected_data_size, size, &size,
191 &error_message);
192 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
193 status, GRPC_STATUS_FAILED_PRECONDITION, error_message,
194 "Checking tag failed"));
195 GPR_ASSERT(memcmp(corrupted_data_buffer, zero_buffer, data_size) == 0);
196 gpr_free(corrupted_data_buffer);
197 gpr_free(error_message);
198
199 gpr_free(data_buffer);
200 gpr_free(zero_buffer);
201 }
202
alts_crypter_test_unsync_seal_unseal(alts_crypter * server_seal,alts_crypter * server_unseal,alts_crypter * client_seal,alts_crypter * client_unseal)203 static void alts_crypter_test_unsync_seal_unseal(alts_crypter* server_seal,
204 alts_crypter* server_unseal,
205 alts_crypter* client_seal,
206 alts_crypter* client_unseal) {
207 size_t data_size = gsec_test_bias_random_uint32(1024) + 1;
208 size_t num_overhead_bytes = alts_crypter_num_overhead_bytes(server_seal);
209 size_t protected_data_size = data_size + num_overhead_bytes;
210 auto* data_buffer = static_cast<uint8_t*>(gpr_malloc(protected_data_size));
211 auto* zero_buffer = static_cast<uint8_t*>(gpr_zalloc(data_size));
212
213 /* Perform two seals at client, one unseal at server. */
214 size_t size = data_size;
215 gsec_test_random_bytes(data_buffer, data_size);
216 grpc_status_code status = alts_crypter_process_in_place(
217 client_seal, data_buffer, protected_data_size, size, &size, nullptr);
218 GPR_ASSERT(status == GRPC_STATUS_OK);
219 GPR_ASSERT(size == protected_data_size);
220
221 size = data_size;
222 gsec_test_random_bytes(data_buffer, data_size);
223 status = alts_crypter_process_in_place(
224 client_seal, data_buffer, protected_data_size, size, &size, nullptr);
225 GPR_ASSERT(status == GRPC_STATUS_OK);
226 GPR_ASSERT(size == protected_data_size);
227
228 char* error_message = nullptr;
229 status = alts_crypter_process_in_place(server_unseal, data_buffer,
230 protected_data_size, size, &size,
231 &error_message);
232 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
233 status, GRPC_STATUS_FAILED_PRECONDITION, error_message,
234 "Checking tag failed"));
235 GPR_ASSERT(memcmp(data_buffer, zero_buffer, data_size) == 0);
236 gpr_free(error_message);
237
238 /* Perform two seals at server, one unseal at client. */
239 size = data_size;
240 gsec_test_random_bytes(data_buffer, data_size);
241 status = alts_crypter_process_in_place(
242 server_seal, data_buffer, protected_data_size, size, &size, nullptr);
243 GPR_ASSERT(status == GRPC_STATUS_OK);
244 GPR_ASSERT(size == protected_data_size);
245
246 size = data_size;
247 gsec_test_random_bytes(data_buffer, data_size);
248 status = alts_crypter_process_in_place(
249 server_seal, data_buffer, protected_data_size, size, &size, nullptr);
250 GPR_ASSERT(status == GRPC_STATUS_OK);
251 GPR_ASSERT(size == protected_data_size);
252
253 status = alts_crypter_process_in_place(client_unseal, data_buffer,
254 protected_data_size, size, &size,
255 &error_message);
256 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
257 status, GRPC_STATUS_FAILED_PRECONDITION, error_message,
258 "Checking tag failed"));
259 GPR_ASSERT(memcmp(data_buffer, zero_buffer, data_size) == 0);
260 gpr_free(error_message);
261 gpr_free(data_buffer);
262 gpr_free(zero_buffer);
263 }
264
alts_crypter_test_input_sanity_check(alts_crypter * crypter_seal,alts_crypter * crypter_unseal)265 static void alts_crypter_test_input_sanity_check(alts_crypter* crypter_seal,
266 alts_crypter* crypter_unseal) {
267 size_t data_size = gsec_test_bias_random_uint32(1024) + 1;
268 size_t num_overhead_bytes = alts_crypter_num_overhead_bytes(crypter_seal);
269 size_t protected_data_size = data_size + num_overhead_bytes;
270 auto* data_buffer = static_cast<uint8_t*>(gpr_malloc(protected_data_size));
271 gsec_test_random_bytes(data_buffer, data_size);
272 char* error_message = nullptr;
273 size_t size = data_size;
274
275 /* Crypter is nullptr. */
276 grpc_status_code status = alts_crypter_process_in_place(
277 nullptr, data_buffer, protected_data_size, size, &size, &error_message);
278 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
279 status, GRPC_STATUS_INVALID_ARGUMENT, error_message,
280 "crypter or crypter->vtable has not been initialized properly."));
281 gpr_free(error_message);
282
283 /* Seal data is nullptr. */
284 size = data_size;
285 status = alts_crypter_process_in_place(
286 crypter_seal, nullptr, protected_data_size, size, &size, &error_message);
287 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
288 status, GRPC_STATUS_INVALID_ARGUMENT, error_message, "data is nullptr."));
289 gpr_free(error_message);
290
291 /* Seal data size is 0. */
292 size = 0;
293 status = alts_crypter_process_in_place(crypter_seal, data_buffer,
294 protected_data_size, size, &size,
295 &error_message);
296 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
297 status, GRPC_STATUS_INVALID_ARGUMENT, error_message,
298 "data_size is zero."));
299 gpr_free(error_message);
300
301 /* Seal data buffer has a size smaller than the required. */
302 size = data_size;
303 status = alts_crypter_process_in_place(crypter_seal, data_buffer,
304 protected_data_size - 1, size, &size,
305 &error_message);
306 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
307 status, GRPC_STATUS_INVALID_ARGUMENT, error_message,
308 "data_allocated_size is smaller than sum of data_size and "
309 "num_overhead_bytes."));
310 gpr_free(error_message);
311
312 /* Unseal data is nullptr. */
313 size = data_size;
314 status = alts_crypter_process_in_place(crypter_unseal, nullptr,
315 protected_data_size, size, &size,
316 &error_message);
317 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
318 status, GRPC_STATUS_INVALID_ARGUMENT, error_message, "data is nullptr."));
319 gpr_free(error_message);
320
321 /* Unseal data size is 0. */
322 size = 0;
323 status = alts_crypter_process_in_place(crypter_unseal, data_buffer,
324 protected_data_size, size, &size,
325 &error_message);
326 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
327 status, GRPC_STATUS_INVALID_ARGUMENT, error_message,
328 "data_size is smaller than num_overhead_bytes."));
329 gpr_free(error_message);
330
331 /* Unseal data size is smaller than number of overhead bytes. */
332 size = num_overhead_bytes - 1;
333 status = alts_crypter_process_in_place(crypter_unseal, data_buffer,
334 protected_data_size, size, &size,
335 &error_message);
336 GPR_ASSERT(gsec_test_expect_compare_code_and_substr(
337 status, GRPC_STATUS_INVALID_ARGUMENT, error_message,
338 "data_size is smaller than num_overhead_bytes."));
339 gpr_free(error_message);
340 gpr_free(data_buffer);
341 }
342
create_random_alts_seal_crypter(alts_crypter ** server_seal,alts_crypter ** server_unseal,alts_crypter ** client_seal,alts_crypter ** client_unseal,gsec_aead_crypter ** server_crypter_seal,gsec_aead_crypter ** server_crypter_unseal,gsec_aead_crypter ** client_crypter_seal,gsec_aead_crypter ** client_crypter_unseal,bool rekey)343 static void create_random_alts_seal_crypter(
344 alts_crypter** server_seal, alts_crypter** server_unseal,
345 alts_crypter** client_seal, alts_crypter** client_unseal,
346 gsec_aead_crypter** server_crypter_seal,
347 gsec_aead_crypter** server_crypter_unseal,
348 gsec_aead_crypter** client_crypter_seal,
349 gsec_aead_crypter** client_crypter_unseal, bool rekey) {
350 size_t key_length = rekey ? kAes128GcmRekeyKeyLength : kAes128GcmKeyLength;
351 uint8_t* key;
352 gsec_test_random_array(&key, key_length);
353 gsec_aes_gcm_aead_crypter_create(key, key_length, kAesGcmNonceLength,
354 kAesGcmTagLength, rekey, server_crypter_seal,
355 nullptr);
356 gsec_aes_gcm_aead_crypter_create(key, key_length, kAesGcmNonceLength,
357 kAesGcmTagLength, rekey,
358 server_crypter_unseal, nullptr);
359 gsec_aes_gcm_aead_crypter_create(key, key_length, kAesGcmNonceLength,
360 kAesGcmTagLength, rekey, client_crypter_seal,
361 nullptr);
362 gsec_aes_gcm_aead_crypter_create(key, key_length, kAesGcmNonceLength,
363 kAesGcmTagLength, rekey,
364 client_crypter_unseal, nullptr);
365
366 size_t overflow_size = rekey ? 8 : 5;
367 alts_seal_crypter_create(*client_crypter_seal, /*is_client=*/true,
368 overflow_size, client_seal, nullptr);
369 alts_unseal_crypter_create(*client_crypter_unseal, /*is_client=*/true,
370 overflow_size, client_unseal, nullptr);
371 alts_seal_crypter_create(*server_crypter_seal, /*is_client=*/false,
372 overflow_size, server_seal, nullptr);
373 alts_unseal_crypter_create(*server_crypter_unseal, /*is_client=*/false,
374 overflow_size, server_unseal, nullptr);
375 gpr_free(key);
376 }
377
destroy_random_alts_seal_crypter(alts_crypter * server_seal,alts_crypter * server_unseal,alts_crypter * client_seal,alts_crypter * client_unseal)378 static void destroy_random_alts_seal_crypter(alts_crypter* server_seal,
379 alts_crypter* server_unseal,
380 alts_crypter* client_seal,
381 alts_crypter* client_unseal) {
382 alts_crypter_destroy(server_seal);
383 alts_crypter_destroy(server_unseal);
384 alts_crypter_destroy(client_seal);
385 alts_crypter_destroy(client_unseal);
386 }
387
alts_crypter_do_generic_tests()388 static void alts_crypter_do_generic_tests() {
389 alts_crypter *server_seal = nullptr, *server_unseal = nullptr,
390 *client_seal = nullptr, *client_unseal = nullptr;
391 gsec_aead_crypter *server_crypter_seal = nullptr,
392 *server_crypter_unseal = nullptr,
393 *client_crypter_seal = nullptr,
394 *client_crypter_unseal = nullptr;
395 /* Random seal and unseal tests */
396 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
397 &client_unseal, &server_crypter_seal,
398 &server_crypter_unseal, &client_crypter_seal,
399 &client_crypter_unseal, /*rekey=*/false);
400 alts_crypter_test_random_seal_unseal(server_seal, server_unseal, client_seal,
401 client_unseal);
402 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
403 client_unseal);
404
405 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
406 &client_unseal, &server_crypter_seal,
407 &server_crypter_unseal, &client_crypter_seal,
408 &client_crypter_unseal, /*rekey=*/true);
409 alts_crypter_test_random_seal_unseal(server_seal, server_unseal, client_seal,
410 client_unseal);
411 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
412 client_unseal);
413
414 /* Multiple random seal and unseal tests */
415 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
416 &client_unseal, &server_crypter_seal,
417 &server_crypter_unseal, &client_crypter_seal,
418 &client_crypter_unseal, /*rekey=*/false);
419 alts_crypter_test_multiple_random_seal_unseal(server_seal, server_unseal,
420 client_seal, client_unseal);
421 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
422 client_unseal);
423
424 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
425 &client_unseal, &server_crypter_seal,
426 &server_crypter_unseal, &client_crypter_seal,
427 &client_crypter_unseal, /*rekey=*/true);
428 alts_crypter_test_multiple_random_seal_unseal(server_seal, server_unseal,
429 client_seal, client_unseal);
430 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
431 client_unseal);
432
433 /* Corrupted unseal tests */
434 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
435 &client_unseal, &server_crypter_seal,
436 &server_crypter_unseal, &client_crypter_seal,
437 &client_crypter_unseal, /*rekey=*/false);
438 alts_crypter_test_corrupted_unseal(server_seal, server_unseal, client_seal,
439 client_unseal);
440 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
441 client_unseal);
442
443 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
444 &client_unseal, &server_crypter_seal,
445 &server_crypter_unseal, &client_crypter_seal,
446 &client_crypter_unseal, /*rekey=*/true);
447 alts_crypter_test_corrupted_unseal(server_seal, server_unseal, client_seal,
448 client_unseal);
449 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
450 client_unseal);
451
452 /* Unsync seal and unseal tests */
453 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
454 &client_unseal, &server_crypter_seal,
455 &server_crypter_unseal, &client_crypter_seal,
456 &client_crypter_unseal, /*rekey=*/false);
457 alts_crypter_test_unsync_seal_unseal(server_seal, server_unseal, client_seal,
458 client_unseal);
459 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
460 client_unseal);
461
462 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
463 &client_unseal, &server_crypter_seal,
464 &server_crypter_unseal, &client_crypter_seal,
465 &client_crypter_unseal, /*rekey=*/true);
466 alts_crypter_test_unsync_seal_unseal(server_seal, server_unseal, client_seal,
467 client_unseal);
468 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
469 client_unseal);
470
471 /* Input sanity check tests */
472 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
473 &client_unseal, &server_crypter_seal,
474 &server_crypter_unseal, &client_crypter_seal,
475 &client_crypter_unseal, /*rekey=*/false);
476 alts_crypter_test_input_sanity_check(server_seal, server_unseal);
477 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
478 client_unseal);
479
480 create_random_alts_seal_crypter(&server_seal, &server_unseal, &client_seal,
481 &client_unseal, &server_crypter_seal,
482 &server_crypter_unseal, &client_crypter_seal,
483 &client_crypter_unseal, /*rekey=*/true);
484 alts_crypter_test_input_sanity_check(server_seal, server_unseal);
485 destroy_random_alts_seal_crypter(server_seal, server_unseal, client_seal,
486 client_unseal);
487 }
488
main(int,char **)489 int main(int /*argc*/, char** /*argv*/) {
490 alts_crypter_do_generic_tests();
491 return 0;
492 }
493