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 <stdio.h>
20 #include <string.h>
21
22 #include <grpc/byte_buffer.h>
23 #include <grpc/grpc_security.h>
24 #include <grpc/support/alloc.h>
25 #include <grpc/support/log.h>
26 #include <grpc/support/time.h>
27
28 #include "src/core/lib/gpr/string.h"
29 #include "src/core/lib/security/credentials/credentials.h"
30 #include "test/core/end2end/cq_verifier.h"
31 #include "test/core/end2end/end2end_tests.h"
32
33 static const char iam_token[] = "token";
34 static const char iam_selector[] = "selector";
35 static const char overridden_iam_token[] = "overridden_token";
36 static const char overridden_iam_selector[] = "overridden_selector";
37 static const char fake_md_key[] = "fake_key";
38 static const char fake_md_value[] = "fake_value";
39 static const char overridden_fake_md_key[] = "overridden_fake_key";
40 static const char overridden_fake_md_value[] = "overridden_fake_value";
41
42 typedef enum { NONE, OVERRIDE, DESTROY, FAIL } override_mode;
43
tag(intptr_t t)44 static void* tag(intptr_t t) { return reinterpret_cast<void*>(t); }
45
begin_test(grpc_end2end_test_config config,const char * test_name,bool use_secure_call_creds,int fail_server_auth_check)46 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
47 const char* test_name,
48 bool use_secure_call_creds,
49 int fail_server_auth_check) {
50 grpc_end2end_test_fixture f;
51 gpr_log(GPR_INFO, "Running test: %s%s/%s", test_name,
52 use_secure_call_creds ? "_with_secure_call_creds"
53 : "_with_insecure_call_creds",
54 config.name);
55 f = config.create_fixture(nullptr, nullptr);
56 config.init_client(&f, nullptr);
57 if (fail_server_auth_check) {
58 grpc_arg fail_auth_arg = {
59 GRPC_ARG_STRING,
60 const_cast<char*>(FAIL_AUTH_CHECK_SERVER_ARG_NAME),
61 {nullptr}};
62 grpc_channel_args args;
63 args.num_args = 1;
64 args.args = &fail_auth_arg;
65 config.init_server(&f, &args);
66 } else {
67 config.init_server(&f, nullptr);
68 }
69 return f;
70 }
71
n_seconds_from_now(int n)72 static gpr_timespec n_seconds_from_now(int n) {
73 return grpc_timeout_seconds_to_deadline(n);
74 }
75
five_seconds_from_now(void)76 static gpr_timespec five_seconds_from_now(void) {
77 return n_seconds_from_now(5);
78 }
79
drain_cq(grpc_completion_queue * cq)80 static void drain_cq(grpc_completion_queue* cq) {
81 grpc_event ev;
82 do {
83 ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
84 } while (ev.type != GRPC_QUEUE_SHUTDOWN);
85 }
86
shutdown_server(grpc_end2end_test_fixture * f)87 static void shutdown_server(grpc_end2end_test_fixture* f) {
88 if (!f->server) return;
89 grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
90 GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
91 grpc_timeout_seconds_to_deadline(5),
92 nullptr)
93 .type == GRPC_OP_COMPLETE);
94 grpc_server_destroy(f->server);
95 f->server = nullptr;
96 }
97
shutdown_client(grpc_end2end_test_fixture * f)98 static void shutdown_client(grpc_end2end_test_fixture* f) {
99 if (!f->client) return;
100 grpc_channel_destroy(f->client);
101 f->client = nullptr;
102 }
103
end_test(grpc_end2end_test_fixture * f)104 static void end_test(grpc_end2end_test_fixture* f) {
105 shutdown_server(f);
106 shutdown_client(f);
107
108 grpc_completion_queue_shutdown(f->cq);
109 drain_cq(f->cq);
110 grpc_completion_queue_destroy(f->cq);
111 grpc_completion_queue_destroy(f->shutdown_cq);
112 }
113
print_auth_context(int is_client,const grpc_auth_context * ctx)114 static void print_auth_context(int is_client, const grpc_auth_context* ctx) {
115 const grpc_auth_property* p;
116 grpc_auth_property_iterator it;
117 gpr_log(GPR_INFO, "%s peer:", is_client ? "client" : "server");
118 gpr_log(GPR_INFO, "\tauthenticated: %s",
119 grpc_auth_context_peer_is_authenticated(ctx) ? "YES" : "NO");
120 it = grpc_auth_context_peer_identity(ctx);
121 while ((p = grpc_auth_property_iterator_next(&it)) != nullptr) {
122 gpr_log(GPR_INFO, "\t\t%s: %s", p->name, p->value);
123 }
124 gpr_log(GPR_INFO, "\tall properties:");
125 it = grpc_auth_context_property_iterator(ctx);
126 while ((p = grpc_auth_property_iterator_next(&it)) != nullptr) {
127 gpr_log(GPR_INFO, "\t\t%s: %s", p->name, p->value);
128 }
129 }
130
request_response_with_payload_and_call_creds(const char * test_name,grpc_end2end_test_config config,override_mode mode,bool use_secure_call_creds)131 static void request_response_with_payload_and_call_creds(
132 const char* test_name, grpc_end2end_test_config config, override_mode mode,
133 bool use_secure_call_creds) {
134 grpc_call* c = nullptr;
135 grpc_call* s = nullptr;
136 grpc_slice request_payload_slice =
137 grpc_slice_from_copied_string("hello world");
138 grpc_slice response_payload_slice =
139 grpc_slice_from_copied_string("hello you");
140 grpc_byte_buffer* request_payload =
141 grpc_raw_byte_buffer_create(&request_payload_slice, 1);
142 grpc_byte_buffer* response_payload =
143 grpc_raw_byte_buffer_create(&response_payload_slice, 1);
144 grpc_end2end_test_fixture f;
145 cq_verifier* cqv;
146 grpc_op ops[6];
147 grpc_op* op;
148 grpc_metadata_array initial_metadata_recv;
149 grpc_metadata_array trailing_metadata_recv;
150 grpc_metadata_array request_metadata_recv;
151 grpc_byte_buffer* request_payload_recv = nullptr;
152 grpc_byte_buffer* response_payload_recv = nullptr;
153 grpc_call_details call_details;
154 grpc_status_code status;
155 grpc_call_error error;
156 grpc_slice details;
157 int was_cancelled = 2;
158 grpc_call_credentials* creds = nullptr;
159 grpc_auth_context* s_auth_context = nullptr;
160 grpc_auth_context* c_auth_context = nullptr;
161
162 f = begin_test(config, test_name, use_secure_call_creds, 0);
163 cqv = cq_verifier_create(f.cq);
164
165 gpr_timespec deadline = five_seconds_from_now();
166 c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
167 grpc_slice_from_static_string("/foo"), nullptr,
168 deadline, nullptr);
169 GPR_ASSERT(c);
170 if (use_secure_call_creds) {
171 creds =
172 grpc_google_iam_credentials_create(iam_token, iam_selector, nullptr);
173 } else {
174 creds =
175 grpc_md_only_test_credentials_create(fake_md_key, fake_md_value, false);
176 }
177 GPR_ASSERT(creds != nullptr);
178 GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK);
179 switch (mode) {
180 case NONE:
181 break;
182 case OVERRIDE:
183 grpc_call_credentials_release(creds);
184 if (use_secure_call_creds) {
185 creds = grpc_google_iam_credentials_create(
186 overridden_iam_token, overridden_iam_selector, nullptr);
187 } else {
188 creds = grpc_md_only_test_credentials_create(
189 overridden_fake_md_key, overridden_fake_md_value, false);
190 }
191 GPR_ASSERT(creds != nullptr);
192 GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK);
193 break;
194 case DESTROY:
195 GPR_ASSERT(grpc_call_set_credentials(c, nullptr) == GRPC_CALL_OK);
196 break;
197 case FAIL:
198 // Do nothing
199 break;
200 }
201 grpc_call_credentials_release(creds);
202
203 grpc_metadata_array_init(&initial_metadata_recv);
204 grpc_metadata_array_init(&trailing_metadata_recv);
205 grpc_metadata_array_init(&request_metadata_recv);
206 grpc_call_details_init(&call_details);
207
208 memset(ops, 0, sizeof(ops));
209 op = ops;
210 op->op = GRPC_OP_SEND_INITIAL_METADATA;
211 op->data.send_initial_metadata.count = 0;
212 op->flags = 0;
213 op->reserved = nullptr;
214 op++;
215 op->op = GRPC_OP_SEND_MESSAGE;
216 op->data.send_message.send_message = request_payload;
217 op->flags = 0;
218 op->reserved = nullptr;
219 op++;
220 op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
221 op->flags = 0;
222 op->reserved = nullptr;
223 op++;
224 op->op = GRPC_OP_RECV_INITIAL_METADATA;
225 op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
226 op->flags = 0;
227 op->reserved = nullptr;
228 op++;
229 op->op = GRPC_OP_RECV_MESSAGE;
230 op->data.recv_message.recv_message = &response_payload_recv;
231 op->flags = 0;
232 op->reserved = nullptr;
233 op++;
234 op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
235 op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
236 op->data.recv_status_on_client.status = &status;
237 op->data.recv_status_on_client.status_details = &details;
238 op->flags = 0;
239 op->reserved = nullptr;
240 op++;
241 error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(1),
242 nullptr);
243 GPR_ASSERT(GRPC_CALL_OK == error);
244
245 if (mode == FAIL) {
246 // Expect the call to fail since the channel credentials did not satisfy the
247 // minimum security level requirements.
248 CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
249 cq_verify(cqv);
250 GPR_ASSERT(status == GRPC_STATUS_UNAUTHENTICATED);
251 } else {
252 error =
253 grpc_server_request_call(f.server, &s, &call_details,
254 &request_metadata_recv, f.cq, f.cq, tag(101));
255 GPR_ASSERT(GRPC_CALL_OK == error);
256 CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
257 cq_verify(cqv);
258 s_auth_context = grpc_call_auth_context(s);
259 GPR_ASSERT(s_auth_context != nullptr);
260 print_auth_context(0, s_auth_context);
261 grpc_auth_context_release(s_auth_context);
262
263 c_auth_context = grpc_call_auth_context(c);
264 GPR_ASSERT(c_auth_context != nullptr);
265 print_auth_context(1, c_auth_context);
266 grpc_auth_context_release(c_auth_context);
267
268 /* Cannot set creds on the server call object. */
269 GPR_ASSERT(grpc_call_set_credentials(s, nullptr) != GRPC_CALL_OK);
270
271 memset(ops, 0, sizeof(ops));
272 op = ops;
273 op->op = GRPC_OP_SEND_INITIAL_METADATA;
274 op->data.send_initial_metadata.count = 0;
275 op->flags = 0;
276 op->reserved = nullptr;
277 op++;
278 op->op = GRPC_OP_RECV_MESSAGE;
279 op->data.recv_message.recv_message = &request_payload_recv;
280 op->flags = 0;
281 op->reserved = nullptr;
282 op++;
283 error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops),
284 tag(102), nullptr);
285 GPR_ASSERT(GRPC_CALL_OK == error);
286
287 CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
288 cq_verify(cqv);
289
290 memset(ops, 0, sizeof(ops));
291 op = ops;
292 op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
293 op->data.recv_close_on_server.cancelled = &was_cancelled;
294 op->flags = 0;
295 op->reserved = nullptr;
296 op++;
297 op->op = GRPC_OP_SEND_MESSAGE;
298 op->data.send_message.send_message = response_payload;
299 op->flags = 0;
300 op->reserved = nullptr;
301 op++;
302 op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
303 op->data.send_status_from_server.trailing_metadata_count = 0;
304 op->data.send_status_from_server.status = GRPC_STATUS_OK;
305 grpc_slice status_details = grpc_slice_from_static_string("xyz");
306 op->data.send_status_from_server.status_details = &status_details;
307 op->flags = 0;
308 op->reserved = nullptr;
309 op++;
310 error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops),
311 tag(103), nullptr);
312 GPR_ASSERT(GRPC_CALL_OK == error);
313
314 CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
315 CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
316 cq_verify(cqv);
317
318 GPR_ASSERT(status == GRPC_STATUS_OK);
319 GPR_ASSERT(0 == grpc_slice_str_cmp(details, "xyz"));
320 GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo"));
321 GPR_ASSERT(was_cancelled == 0);
322 GPR_ASSERT(byte_buffer_eq_string(request_payload_recv, "hello world"));
323 GPR_ASSERT(byte_buffer_eq_string(response_payload_recv, "hello you"));
324
325 switch (mode) {
326 case NONE:
327 if (use_secure_call_creds) {
328 GPR_ASSERT(contains_metadata(
329 &request_metadata_recv, GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY,
330 iam_token));
331 GPR_ASSERT(contains_metadata(&request_metadata_recv,
332 GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY,
333 iam_selector));
334 } else {
335 GPR_ASSERT(contains_metadata(&request_metadata_recv, fake_md_key,
336 fake_md_value));
337 }
338 break;
339 case OVERRIDE:
340 if (use_secure_call_creds) {
341 GPR_ASSERT(contains_metadata(
342 &request_metadata_recv, GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY,
343 overridden_iam_token));
344 GPR_ASSERT(contains_metadata(&request_metadata_recv,
345 GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY,
346 overridden_iam_selector));
347 } else {
348 GPR_ASSERT(contains_metadata(&request_metadata_recv,
349 overridden_fake_md_key,
350 overridden_fake_md_value));
351 }
352 break;
353 case DESTROY:
354 GPR_ASSERT(!contains_metadata(&request_metadata_recv,
355 GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY,
356 iam_token));
357 GPR_ASSERT(!contains_metadata(&request_metadata_recv,
358 GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY,
359 iam_selector));
360 GPR_ASSERT(!contains_metadata(&request_metadata_recv,
361 GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY,
362 overridden_iam_token));
363 GPR_ASSERT(!contains_metadata(&request_metadata_recv,
364 GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY,
365 overridden_iam_selector));
366 GPR_ASSERT(!contains_metadata(&request_metadata_recv, fake_md_key,
367 fake_md_value));
368 GPR_ASSERT(!contains_metadata(&request_metadata_recv,
369 overridden_fake_md_key,
370 overridden_fake_md_value));
371 break;
372 case FAIL:
373 GPR_ASSERT(0);
374 }
375 grpc_call_unref(s);
376 }
377
378 grpc_slice_unref(details);
379 grpc_metadata_array_destroy(&initial_metadata_recv);
380 grpc_metadata_array_destroy(&trailing_metadata_recv);
381 grpc_metadata_array_destroy(&request_metadata_recv);
382 grpc_call_details_destroy(&call_details);
383
384 grpc_call_unref(c);
385
386 cq_verifier_destroy(cqv);
387
388 grpc_byte_buffer_destroy(request_payload);
389 grpc_byte_buffer_destroy(response_payload);
390 grpc_byte_buffer_destroy(request_payload_recv);
391 grpc_byte_buffer_destroy(response_payload_recv);
392
393 end_test(&f);
394 config.tear_down_data(&f);
395 }
396
test_request_response_with_payload_and_call_creds(grpc_end2end_test_config config,bool use_secure_call_creds)397 static void test_request_response_with_payload_and_call_creds(
398 grpc_end2end_test_config config, bool use_secure_call_creds) {
399 request_response_with_payload_and_call_creds(
400 "test_request_response_with_payload_and_call_creds", config, NONE,
401 use_secure_call_creds);
402 }
403
test_request_response_with_payload_and_overridden_call_creds(grpc_end2end_test_config config,bool use_secure_call_creds)404 static void test_request_response_with_payload_and_overridden_call_creds(
405 grpc_end2end_test_config config, bool use_secure_call_creds) {
406 request_response_with_payload_and_call_creds(
407 "test_request_response_with_payload_and_overridden_call_creds", config,
408 OVERRIDE, use_secure_call_creds);
409 }
410
test_request_response_with_payload_and_deleted_call_creds(grpc_end2end_test_config config,bool use_secure_call_creds)411 static void test_request_response_with_payload_and_deleted_call_creds(
412 grpc_end2end_test_config config, bool use_secure_call_creds) {
413 request_response_with_payload_and_call_creds(
414 "test_request_response_with_payload_and_deleted_call_creds", config,
415 DESTROY, use_secure_call_creds);
416 }
417
test_request_response_with_payload_fail_to_send_call_creds(grpc_end2end_test_config config,bool use_secure_call_creds)418 static void test_request_response_with_payload_fail_to_send_call_creds(
419 grpc_end2end_test_config config, bool use_secure_call_creds) {
420 request_response_with_payload_and_call_creds(
421 "test_request_response_with_payload_fail_to_send_call_creds", config,
422 FAIL, use_secure_call_creds);
423 }
424
test_request_with_server_rejecting_client_creds(grpc_end2end_test_config config)425 static void test_request_with_server_rejecting_client_creds(
426 grpc_end2end_test_config config) {
427 grpc_op ops[6];
428 grpc_op* op;
429 grpc_call* c;
430 grpc_end2end_test_fixture f;
431 gpr_timespec deadline = five_seconds_from_now();
432 cq_verifier* cqv;
433 grpc_metadata_array initial_metadata_recv;
434 grpc_metadata_array trailing_metadata_recv;
435 grpc_metadata_array request_metadata_recv;
436 grpc_call_details call_details;
437 grpc_status_code status;
438 grpc_call_error error;
439 grpc_slice details;
440 grpc_byte_buffer* response_payload_recv = nullptr;
441 grpc_slice request_payload_slice =
442 grpc_slice_from_copied_string("hello world");
443 grpc_byte_buffer* request_payload =
444 grpc_raw_byte_buffer_create(&request_payload_slice, 1);
445 grpc_call_credentials* creds;
446
447 f = begin_test(config, "test_request_with_server_rejecting_client_creds",
448 false, 1);
449 cqv = cq_verifier_create(f.cq);
450
451 c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
452 grpc_slice_from_static_string("/foo"), nullptr,
453 deadline, nullptr);
454 GPR_ASSERT(c);
455
456 creds =
457 grpc_md_only_test_credentials_create(fake_md_key, fake_md_value, false);
458 GPR_ASSERT(creds != nullptr);
459 GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK);
460 grpc_call_credentials_release(creds);
461
462 grpc_metadata_array_init(&initial_metadata_recv);
463 grpc_metadata_array_init(&trailing_metadata_recv);
464 grpc_metadata_array_init(&request_metadata_recv);
465 grpc_call_details_init(&call_details);
466
467 memset(ops, 0, sizeof(ops));
468 op = ops;
469 op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
470 op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
471 op->data.recv_status_on_client.status = &status;
472 op->data.recv_status_on_client.status_details = &details;
473 op->flags = 0;
474 op->reserved = nullptr;
475 op++;
476 op->op = GRPC_OP_SEND_INITIAL_METADATA;
477 op->data.send_initial_metadata.count = 0;
478 op->flags = 0;
479 op->reserved = nullptr;
480 op++;
481 op->op = GRPC_OP_SEND_MESSAGE;
482 op->data.send_message.send_message = request_payload;
483 op->flags = 0;
484 op->reserved = nullptr;
485 op++;
486 op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
487 op->flags = 0;
488 op->reserved = nullptr;
489 op++;
490 op->op = GRPC_OP_RECV_INITIAL_METADATA;
491 op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
492 op->flags = 0;
493 op->reserved = nullptr;
494 op++;
495 op->op = GRPC_OP_RECV_MESSAGE;
496 op->data.recv_message.recv_message = &response_payload_recv;
497 op->flags = 0;
498 op->reserved = nullptr;
499 op++;
500 error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(1),
501 nullptr);
502 GPR_ASSERT(error == GRPC_CALL_OK);
503
504 CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
505 cq_verify(cqv);
506
507 GPR_ASSERT(status == GRPC_STATUS_UNAUTHENTICATED);
508
509 grpc_metadata_array_destroy(&initial_metadata_recv);
510 grpc_metadata_array_destroy(&trailing_metadata_recv);
511 grpc_metadata_array_destroy(&request_metadata_recv);
512 grpc_call_details_destroy(&call_details);
513
514 grpc_byte_buffer_destroy(request_payload);
515 grpc_byte_buffer_destroy(response_payload_recv);
516 grpc_slice_unref(details);
517
518 grpc_call_unref(c);
519
520 cq_verifier_destroy(cqv);
521 end_test(&f);
522 config.tear_down_data(&f);
523 }
524
call_creds(grpc_end2end_test_config config)525 void call_creds(grpc_end2end_test_config config) {
526 // Test fixtures that support call credentials with a minimum security level
527 // of GRPC_PRIVACY_AND_INTEGRITY
528 if (config.feature_mask & FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS) {
529 test_request_response_with_payload_and_call_creds(config, true);
530 test_request_response_with_payload_and_overridden_call_creds(config, true);
531 test_request_response_with_payload_and_deleted_call_creds(config, true);
532 }
533 // Test that fixtures that support call credentials with a minimum security
534 // level of GRPC_SECURITY_NONE cannot send call credentials that require
535 // higher security level
536 if (config.feature_mask &
537 FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS_LEVEL_INSECURE) {
538 test_request_response_with_payload_fail_to_send_call_creds(config, true);
539 }
540 // Fixtures that support sending call credentials should be able to send call
541 // credentials of security level GRPC_SECURITY_NONE.
542 if (config.feature_mask & FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS ||
543 config.feature_mask &
544 FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS_LEVEL_INSECURE) {
545 test_request_response_with_payload_and_call_creds(config, false);
546 test_request_response_with_payload_and_overridden_call_creds(config, false);
547 test_request_response_with_payload_and_deleted_call_creds(config, false);
548 test_request_with_server_rejecting_client_creds(config);
549 }
550 }
551
call_creds_pre_init(void)552 void call_creds_pre_init(void) {}
553