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