Branch data Line data Source code
1 : : /*
2 : : SSSD
3 : :
4 : : Authors:
5 : : Stephen Gallagher <sgallagh@redhat.com>
6 : :
7 : : Copyright (C) 2011 Red Hat
8 : :
9 : : This program is free software; you can redistribute it and/or modify
10 : : it under the terms of the GNU General Public License as published by
11 : : the Free Software Foundation; either version 3 of the License, or
12 : : (at your option) any later version.
13 : :
14 : : This program is distributed in the hope that it will be useful,
15 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : : GNU General Public License for more details.
18 : :
19 : : You should have received a copy of the GNU General Public License
20 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
21 : : */
22 : : #include <stdlib.h>
23 : : #include <check.h>
24 : : #include <unistd.h>
25 : : #include <sys/types.h>
26 : : #include <sys/stat.h>
27 : : #include <talloc.h>
28 : :
29 : : #include "tests/common.h"
30 : : #include "providers/ipa/ipa_hbac.h"
31 : :
32 : : #define HBAC_TEST_USER "testuser"
33 : : #define HBAC_TEST_INVALID_USER "nosuchuser"
34 : :
35 : : #define HBAC_TEST_GROUP1 "testgroup1"
36 : : #define HBAC_TEST_GROUP2 "testgroup2"
37 : : #define HBAC_TEST_INVALID_GROUP "nosuchgroup"
38 : :
39 : : #define HBAC_TEST_SERVICE "testservice"
40 : : #define HBAC_TEST_INVALID_SERVICE "nosuchservice"
41 : :
42 : : #define HBAC_TEST_SERVICEGROUP1 "login_services"
43 : : #define HBAC_TEST_SERVICEGROUP2 "all_services"
44 : : #define HBAC_TEST_INVALID_SERVICEGROUP "nosuchservicegroup"
45 : :
46 : : #define HBAC_TEST_SRCHOST "client.example.com"
47 : : #define HBAC_TEST_INVALID_SRCHOST "nosuchsrchost"
48 : :
49 : : #define HBAC_TEST_SRCHOSTGROUP1 "site_hosts"
50 : : #define HBAC_TEST_SRCHOSTGROUP2 "corp_hosts"
51 : : #define HBAC_TEST_INVALID_SRCHOSTGROUP "nosuchsrchostgroup"
52 : :
53 : :
54 : : /* These don't make sense for a user/group/service but they do the job and
55 : : * every one is from a different codepage */
56 : : /* Latin Extended A - "Czech" */
57 : : const uint8_t user_utf8_lowcase[] = { 0xC4, 0x8D, 'e', 'c', 'h', 0x0 };
58 : : const uint8_t user_utf8_upcase[] = { 0xC4, 0x8C, 'e', 'c', 'h', 0x0 };
59 : : const uint8_t user_utf8_lowcase_neg[] = { 0xC4, 0x8E, 'e', 'c', 'h', 0x0 };
60 : : /* Latin 1 Supplement - "Munchen" */
61 : : const uint8_t service_utf8_lowcase[] = { 'm', 0xC3, 0xBC, 'n', 'c', 'h', 'e', 'n', 0x0 };
62 : : const uint8_t service_utf8_upcase[] = { 'M', 0xC3, 0x9C, 'N', 'C', 'H', 'E', 'N', 0x0 };
63 : : /* Greek - "AlphaBetaGamma" */
64 : : const uint8_t srchost_utf8_lowcase[] = { 0xCE, 0xB1, 0xCE, 0xB2, 0xCE, 0xB3, 0x0 };
65 : : const uint8_t srchost_utf8_upcase[] = { 0xCE, 0x91, 0xCE, 0x92, 0xCE, 0x93, 0x0 };
66 : : /* Turkish "capital I" and "dotless i" */
67 : : const uint8_t user_lowcase_tr[] = { 0xC4, 0xB1, 0x0 };
68 : : const uint8_t user_upcase_tr[] = { 0x49, 0x0 };
69 : :
70 : 8 : static void get_allow_all_rule(TALLOC_CTX *mem_ctx,
71 : : struct hbac_rule **allow_rule)
72 : : {
73 : : struct hbac_rule *rule;
74 : : /* Create a rule that ALLOWs all services, users and
75 : : * remote hosts.
76 : : */
77 : 8 : rule = talloc_zero(mem_ctx, struct hbac_rule);
78 : 8 : fail_if (rule == NULL);
79 : :
80 : 8 : rule->enabled = true;
81 : :
82 : 8 : rule->services = talloc_zero(rule, struct hbac_rule_element);
83 : 8 : fail_if (rule->services == NULL);
84 : 8 : rule->services->category = HBAC_CATEGORY_ALL;
85 : 8 : rule->services->names = NULL;
86 : 8 : rule->services->groups = NULL;
87 : :
88 : 8 : rule->users = talloc_zero(rule, struct hbac_rule_element);
89 : 8 : fail_if (rule->users == NULL);
90 : 8 : rule->users->category = HBAC_CATEGORY_ALL;
91 : 8 : rule->users->names = NULL;
92 : 8 : rule->users->groups = NULL;
93 : :
94 : 8 : rule->targethosts = talloc_zero(rule, struct hbac_rule_element);
95 : 8 : fail_if (rule->targethosts == NULL);
96 : 8 : rule->targethosts->category = HBAC_CATEGORY_ALL;
97 : 8 : rule->targethosts->names = NULL;
98 : 8 : rule->targethosts->groups = NULL;
99 : :
100 : 8 : rule->srchosts = talloc_zero(rule, struct hbac_rule_element);
101 : 8 : fail_if (rule->srchosts == NULL);
102 : 8 : rule->srchosts->category = HBAC_CATEGORY_ALL;
103 : 8 : rule->srchosts->names = NULL;
104 : 8 : rule->srchosts->groups = NULL;
105 : :
106 : 8 : *allow_rule = rule;
107 : 8 : }
108 : :
109 : 8 : static void get_test_user(TALLOC_CTX *mem_ctx,
110 : : struct hbac_request_element **user)
111 : : {
112 : : struct hbac_request_element *new_user;
113 : :
114 : 8 : new_user = talloc_zero(mem_ctx, struct hbac_request_element);
115 : 8 : fail_if (new_user == NULL);
116 : :
117 : 8 : new_user->name = talloc_strdup(new_user, HBAC_TEST_USER);
118 : 8 : fail_if(new_user->name == NULL);
119 : :
120 : 8 : new_user->groups = talloc_array(new_user, const char *, 3);
121 : 8 : fail_if(new_user->groups == NULL);
122 : :
123 : 8 : new_user->groups[0] = talloc_strdup(new_user->groups, HBAC_TEST_GROUP1);
124 : 8 : fail_if(new_user->groups[0] == NULL);
125 : :
126 : 8 : new_user->groups[1] = talloc_strdup(new_user->groups, HBAC_TEST_GROUP2);
127 : 8 : fail_if(new_user->groups[1] == NULL);
128 : :
129 : 8 : new_user->groups[2] = NULL;
130 : :
131 : 8 : *user = new_user;
132 : 8 : }
133 : :
134 : 8 : static void get_test_service(TALLOC_CTX *mem_ctx,
135 : : struct hbac_request_element **service)
136 : : {
137 : : struct hbac_request_element *new_service;
138 : :
139 : 8 : new_service = talloc_zero(mem_ctx, struct hbac_request_element);
140 : 8 : fail_if (new_service == NULL);
141 : :
142 : 8 : new_service->name = talloc_strdup(new_service, HBAC_TEST_SERVICE);
143 : 8 : fail_if(new_service->name == NULL);
144 : :
145 : 8 : new_service->groups = talloc_array(new_service, const char *, 3);
146 : 8 : fail_if(new_service->groups == NULL);
147 : :
148 : 8 : new_service->groups[0] = talloc_strdup(new_service->groups, HBAC_TEST_SERVICEGROUP1);
149 : 8 : fail_if(new_service->groups[0] == NULL);
150 : :
151 : 8 : new_service->groups[1] = talloc_strdup(new_service->groups, HBAC_TEST_SERVICEGROUP2);
152 : 8 : fail_if(new_service->groups[1] == NULL);
153 : :
154 : 8 : new_service->groups[2] = NULL;
155 : :
156 : 8 : *service = new_service;
157 : 8 : }
158 : :
159 : 8 : static void get_test_srchost(TALLOC_CTX *mem_ctx,
160 : : struct hbac_request_element **srchost)
161 : : {
162 : : struct hbac_request_element *new_srchost;
163 : :
164 : 8 : new_srchost = talloc_zero(mem_ctx, struct hbac_request_element);
165 : 8 : fail_if (new_srchost == NULL);
166 : :
167 : 8 : new_srchost->name = talloc_strdup(new_srchost, "client.example.com");
168 : 8 : fail_if(new_srchost->name == NULL);
169 : :
170 : 8 : new_srchost->groups = talloc_array(new_srchost, const char *, 3);
171 : 8 : fail_if(new_srchost->groups == NULL);
172 : :
173 : 8 : new_srchost->groups[0] = talloc_strdup(new_srchost->groups, "site_hosts");
174 : 8 : fail_if(new_srchost->groups[0] == NULL);
175 : :
176 : 8 : new_srchost->groups[1] = talloc_strdup(new_srchost->groups, "corp_hosts");
177 : 8 : fail_if(new_srchost->groups[1] == NULL);
178 : :
179 : 8 : new_srchost->groups[2] = NULL;
180 : :
181 : 8 : *srchost = new_srchost;
182 : 8 : }
183 : :
184 : 1 : START_TEST(ipa_hbac_test_allow_all)
185 : : {
186 : : enum hbac_eval_result result;
187 : : TALLOC_CTX *test_ctx;
188 : : struct hbac_rule **rules;
189 : : struct hbac_eval_req *eval_req;
190 : : struct hbac_info *info;
191 : : bool is_valid;
192 : : uint32_t missing_attrs;
193 : :
194 : 1 : test_ctx = talloc_new(global_talloc_context);
195 : :
196 : : /* Create a request */
197 : 1 : eval_req = talloc_zero(test_ctx, struct hbac_eval_req);
198 : 1 : fail_if (eval_req == NULL);
199 : :
200 : 1 : get_test_user(eval_req, &eval_req->user);
201 : 1 : get_test_service(eval_req, &eval_req->service);
202 : 1 : get_test_srchost(eval_req, &eval_req->srchost);
203 : :
204 : : /* Create the rules to evaluate against */
205 : 1 : rules = talloc_array(test_ctx, struct hbac_rule *, 2);
206 : 1 : fail_if (rules == NULL);
207 : :
208 : 1 : get_allow_all_rule(rules, &rules[0]);
209 : 1 : rules[0]->name = talloc_strdup(rules[0], "Allow All");
210 : 1 : fail_if(rules[0]->name == NULL);
211 : 1 : rules[1] = NULL;
212 : :
213 : : /* Validate this rule */
214 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
215 : 1 : fail_unless(is_valid);
216 : 1 : fail_unless(missing_attrs == 0);
217 : :
218 : : /* Evaluate the rules */
219 : 1 : result = hbac_evaluate(rules, eval_req, &info);
220 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_ALLOW,
221 : : "Expected [%s], got [%s]; "
222 : : "Error: [%s]",
223 : : hbac_result_string(HBAC_EVAL_ALLOW),
224 : : hbac_result_string(result),
225 : : info ? hbac_error_string(info->code):"Unknown");
226 : :
227 : 1 : talloc_free(test_ctx);
228 : : }
229 : 1 : END_TEST
230 : :
231 : 1 : START_TEST(ipa_hbac_test_allow_user)
232 : : {
233 : : enum hbac_eval_result result;
234 : : TALLOC_CTX *test_ctx;
235 : : struct hbac_rule **rules;
236 : : struct hbac_eval_req *eval_req;
237 : : struct hbac_info *info;
238 : : bool is_valid;
239 : : uint32_t missing_attrs;
240 : :
241 : 1 : test_ctx = talloc_new(global_talloc_context);
242 : :
243 : : /* Create a request */
244 : 1 : eval_req = talloc_zero(test_ctx, struct hbac_eval_req);
245 : 1 : fail_if (eval_req == NULL);
246 : :
247 : 1 : get_test_user(eval_req, &eval_req->user);
248 : 1 : get_test_service(eval_req, &eval_req->service);
249 : 1 : get_test_srchost(eval_req, &eval_req->srchost);
250 : :
251 : : /* Create the rules to evaluate against */
252 : 1 : rules = talloc_array(test_ctx, struct hbac_rule *, 2);
253 : 1 : fail_if (rules == NULL);
254 : :
255 : 1 : get_allow_all_rule(rules, &rules[0]);
256 : :
257 : : /* Modify the rule to allow only a specific user */
258 : 1 : rules[0]->name = talloc_strdup(rules[0], "Allow user");
259 : 1 : fail_if(rules[0]->name == NULL);
260 : 1 : rules[0]->users->category = HBAC_CATEGORY_NULL;
261 : :
262 : 1 : rules[0]->users->names = talloc_array(rules[0], const char *, 2);
263 : 1 : fail_if(rules[0]->users->names == NULL);
264 : :
265 : 1 : rules[0]->users->names[0] = HBAC_TEST_USER;
266 : 1 : rules[0]->users->names[1] = NULL;
267 : :
268 : 1 : rules[1] = NULL;
269 : :
270 : : /* Validate this rule */
271 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
272 : 1 : fail_unless(is_valid);
273 : 1 : fail_unless(missing_attrs == 0);
274 : :
275 : : /* Evaluate the rules */
276 : 1 : result = hbac_evaluate(rules, eval_req, &info);
277 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_ALLOW,
278 : : "Expected [%s], got [%s]; "
279 : : "Error: [%s]",
280 : : hbac_result_string(HBAC_EVAL_ALLOW),
281 : : hbac_result_string(result),
282 : : info ? hbac_error_string(info->code):"Unknown");
283 : :
284 : : /* Negative test */
285 : 1 : rules[0]->users->names[0] = HBAC_TEST_INVALID_USER;
286 : :
287 : : /* Validate this rule */
288 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
289 : 1 : fail_unless(is_valid);
290 : 1 : fail_unless(missing_attrs == 0);
291 : :
292 : : /* Evaluate the rules */
293 : 1 : result = hbac_evaluate(rules, eval_req, &info);
294 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_DENY,
295 : : "Expected [%s], got [%s]; "
296 : : "Error: [%s]",
297 : : hbac_result_string(HBAC_EVAL_DENY),
298 : : hbac_result_string(result),
299 : : info ? hbac_error_string(info->code):"Unknown");
300 : :
301 : 1 : talloc_free(test_ctx);
302 : : }
303 : 1 : END_TEST
304 : :
305 : 1 : START_TEST(ipa_hbac_test_allow_utf8)
306 : : {
307 : : enum hbac_eval_result result;
308 : : TALLOC_CTX *test_ctx;
309 : : struct hbac_rule **rules;
310 : : struct hbac_eval_req *eval_req;
311 : : struct hbac_info *info;
312 : : bool is_valid;
313 : : uint32_t missing_attrs;
314 : :
315 : 1 : test_ctx = talloc_new(global_talloc_context);
316 : :
317 : : /* Create a request */
318 : 1 : eval_req = talloc_zero(test_ctx, struct hbac_eval_req);
319 : 1 : fail_if (eval_req == NULL);
320 : :
321 : 1 : get_test_user(eval_req, &eval_req->user);
322 : 1 : get_test_service(eval_req, &eval_req->service);
323 : 1 : get_test_srchost(eval_req, &eval_req->srchost);
324 : :
325 : : /* Override the with UTF8 values */
326 : 1 : eval_req->user->name = (const char *) &user_utf8_lowcase;
327 : 1 : eval_req->srchost->name = (const char *) &srchost_utf8_lowcase;
328 : 1 : eval_req->service->name = (const char *) &service_utf8_lowcase;
329 : :
330 : : /* Create the rules to evaluate against */
331 : 1 : rules = talloc_array(test_ctx, struct hbac_rule *, 2);
332 : 1 : fail_if (rules == NULL);
333 : :
334 : 1 : get_allow_all_rule(rules, &rules[0]);
335 : :
336 : 1 : rules[0]->name = talloc_strdup(rules[0], "Allow user");
337 : 1 : fail_if(rules[0]->name == NULL);
338 : 1 : rules[0]->users->category = HBAC_CATEGORY_NULL;
339 : :
340 : : /* Modify the rule to allow only a specific user */
341 : 1 : rules[0]->users->names = talloc_array(rules[0], const char *, 2);
342 : 1 : fail_if(rules[0]->users->names == NULL);
343 : :
344 : 1 : rules[0]->users->names[0] = (const char *) &user_utf8_upcase;
345 : 1 : rules[0]->users->names[1] = NULL;
346 : :
347 : : /* Modify the rule to allow only a specific service */
348 : 1 : rules[0]->services->category = HBAC_CATEGORY_NULL;
349 : :
350 : 1 : rules[0]->services->names = talloc_array(rules[0], const char *, 2);
351 : 1 : fail_if(rules[0]->services->names == NULL);
352 : :
353 : 1 : rules[0]->services->names[0] = (const char *) &service_utf8_upcase;
354 : 1 : rules[0]->services->names[1] = NULL;
355 : :
356 : : /* Modify the rule to allow only a specific service */
357 : 1 : rules[0]->srchosts->category = HBAC_CATEGORY_NULL;
358 : :
359 : 1 : rules[0]->srchosts->names = talloc_array(rules[0], const char *, 2);
360 : 1 : fail_if(rules[0]->services->names == NULL);
361 : :
362 : 1 : rules[0]->srchosts->names[0] = (const char *) &srchost_utf8_upcase;
363 : 1 : rules[0]->services->names[1] = NULL;
364 : :
365 : 1 : rules[1] = NULL;
366 : :
367 : : /* Validate this rule */
368 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
369 : 1 : fail_unless(is_valid);
370 : 1 : fail_unless(missing_attrs == 0);
371 : :
372 : : /* Evaluate the rules */
373 : 1 : result = hbac_evaluate(rules, eval_req, &info);
374 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_ALLOW,
375 : : "Expected [%s], got [%s]; "
376 : : "Error: [%s]",
377 : : hbac_result_string(HBAC_EVAL_ALLOW),
378 : : hbac_result_string(result),
379 : : info ? hbac_error_string(info->code):"Unknown");
380 : :
381 : : /* Negative test - a different letter */
382 : 1 : rules[0]->users->names[0] = (const char *) &user_utf8_lowcase_neg;
383 : :
384 : : /* Evaluate the rules */
385 : 1 : result = hbac_evaluate(rules, eval_req, &info);
386 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_DENY,
387 : : "Expected [%s], got [%s]; "
388 : : "Error: [%s]",
389 : : hbac_result_string(HBAC_EVAL_DENY),
390 : : hbac_result_string(result),
391 : : info ? hbac_error_string(info->code):"Unknown");
392 : :
393 : : /* Negative test - Turkish dotless i. We cannot know that capital I
394 : : * casefolds into dotless i unless we know the language is Turkish */
395 : 1 : eval_req->user->name = (const char *) &user_lowcase_tr;
396 : 1 : rules[0]->users->names[0] = (const char *) &user_upcase_tr;
397 : :
398 : : /* Validate this rule */
399 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
400 : 1 : fail_unless(is_valid);
401 : 1 : fail_unless(missing_attrs == 0);
402 : :
403 : : /* Evaluate the rules */
404 : 1 : result = hbac_evaluate(rules, eval_req, &info);
405 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_DENY,
406 : : "Expected [%s], got [%s]; "
407 : : "Error: [%s]",
408 : : hbac_result_string(HBAC_EVAL_DENY),
409 : : hbac_result_string(result),
410 : : info ? hbac_error_string(info->code):"Unknown");
411 : :
412 : 1 : talloc_free(test_ctx);
413 : : }
414 : 1 : END_TEST
415 : :
416 : 1 : START_TEST(ipa_hbac_test_allow_group)
417 : : {
418 : : enum hbac_eval_result result;
419 : : TALLOC_CTX *test_ctx;
420 : : struct hbac_rule **rules;
421 : : struct hbac_eval_req *eval_req;
422 : : struct hbac_info *info;
423 : : bool is_valid;
424 : : uint32_t missing_attrs;
425 : :
426 : 1 : test_ctx = talloc_new(global_talloc_context);
427 : :
428 : : /* Create a request */
429 : 1 : eval_req = talloc_zero(test_ctx, struct hbac_eval_req);
430 : 1 : fail_if (eval_req == NULL);
431 : :
432 : 1 : get_test_user(eval_req, &eval_req->user);
433 : 1 : get_test_service(eval_req, &eval_req->service);
434 : 1 : get_test_srchost(eval_req, &eval_req->srchost);
435 : :
436 : : /* Create the rules to evaluate against */
437 : 1 : rules = talloc_array(test_ctx, struct hbac_rule *, 2);
438 : 1 : fail_if (rules == NULL);
439 : :
440 : 1 : get_allow_all_rule(rules, &rules[0]);
441 : :
442 : : /* Modify the rule to allow only a group of users */
443 : 1 : rules[0]->name = talloc_strdup(rules[0], "Allow group");
444 : 1 : fail_if(rules[0]->name == NULL);
445 : 1 : rules[0]->users->category = HBAC_CATEGORY_NULL;
446 : :
447 : 1 : rules[0]->users->names = NULL;
448 : 1 : rules[0]->users->groups = talloc_array(rules[0], const char *, 2);
449 : 1 : fail_if(rules[0]->users->groups == NULL);
450 : :
451 : 1 : rules[0]->users->groups[0] = HBAC_TEST_GROUP1;
452 : 1 : rules[0]->users->groups[1] = NULL;
453 : :
454 : 1 : rules[1] = NULL;
455 : :
456 : : /* Validate this rule */
457 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
458 : 1 : fail_unless(is_valid);
459 : 1 : fail_unless(missing_attrs == 0);
460 : :
461 : : /* Evaluate the rules */
462 : 1 : result = hbac_evaluate(rules, eval_req, &info);
463 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_ALLOW,
464 : : "Expected [%s], got [%s]; "
465 : : "Error: [%s]",
466 : : hbac_result_string(HBAC_EVAL_ALLOW),
467 : : hbac_result_string(result),
468 : : info ? hbac_error_string(info->code):"Unknown");
469 : :
470 : : /* Negative test */
471 : 1 : rules[0]->users->groups[0] = HBAC_TEST_INVALID_GROUP;
472 : :
473 : : /* Validate this rule */
474 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
475 : 1 : fail_unless(is_valid);
476 : 1 : fail_unless(missing_attrs == 0);
477 : :
478 : : /* Evaluate the rules */
479 : 1 : result = hbac_evaluate(rules, eval_req, &info);
480 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_DENY,
481 : : "Expected [%s], got [%s]; "
482 : : "Error: [%s]",
483 : : hbac_result_string(HBAC_EVAL_DENY),
484 : : hbac_result_string(result),
485 : : info ? hbac_error_string(info->code):"Unknown");
486 : :
487 : 1 : talloc_free(test_ctx);
488 : : }
489 : 1 : END_TEST
490 : :
491 : 1 : START_TEST(ipa_hbac_test_allow_svc)
492 : : {
493 : : enum hbac_eval_result result;
494 : : TALLOC_CTX *test_ctx;
495 : : struct hbac_rule **rules;
496 : : struct hbac_eval_req *eval_req;
497 : : struct hbac_info *info;
498 : : bool is_valid;
499 : : uint32_t missing_attrs;
500 : :
501 : 1 : test_ctx = talloc_new(global_talloc_context);
502 : :
503 : : /* Create a request */
504 : 1 : eval_req = talloc_zero(test_ctx, struct hbac_eval_req);
505 : 1 : fail_if (eval_req == NULL);
506 : :
507 : 1 : get_test_user(eval_req, &eval_req->user);
508 : 1 : get_test_service(eval_req, &eval_req->service);
509 : 1 : get_test_srchost(eval_req, &eval_req->srchost);
510 : :
511 : : /* Create the rules to evaluate against */
512 : 1 : rules = talloc_array(test_ctx, struct hbac_rule *, 2);
513 : 1 : fail_if (rules == NULL);
514 : :
515 : 1 : get_allow_all_rule(rules, &rules[0]);
516 : :
517 : : /* Modify the rule to allow only a specific service */
518 : 1 : rules[0]->name = talloc_strdup(rules[0], "Allow service");
519 : 1 : fail_if(rules[0]->name == NULL);
520 : 1 : rules[0]->services->category = HBAC_CATEGORY_NULL;
521 : :
522 : 1 : rules[0]->services->names = talloc_array(rules[0], const char *, 2);
523 : 1 : fail_if(rules[0]->services->names == NULL);
524 : :
525 : 1 : rules[0]->services->names[0] = HBAC_TEST_SERVICE;
526 : 1 : rules[0]->services->names[1] = NULL;
527 : :
528 : 1 : rules[1] = NULL;
529 : :
530 : : /* Validate this rule */
531 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
532 : 1 : fail_unless(is_valid);
533 : 1 : fail_unless(missing_attrs == 0);
534 : :
535 : : /* Evaluate the rules */
536 : 1 : result = hbac_evaluate(rules, eval_req, &info);
537 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_ALLOW,
538 : : "Expected [%s], got [%s]; "
539 : : "Error: [%s]",
540 : : hbac_result_string(HBAC_EVAL_ALLOW),
541 : : hbac_result_string(result),
542 : : info ? hbac_error_string(info->code):"Unknown");
543 : :
544 : : /* Negative test */
545 : 1 : rules[0]->services->names[0] = HBAC_TEST_INVALID_SERVICE;
546 : :
547 : : /* Validate this rule */
548 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
549 : 1 : fail_unless(is_valid);
550 : 1 : fail_unless(missing_attrs == 0);
551 : :
552 : : /* Evaluate the rules */
553 : 1 : result = hbac_evaluate(rules, eval_req, &info);
554 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_DENY,
555 : : "Expected [%s], got [%s]; "
556 : : "Error: [%s]",
557 : : hbac_result_string(HBAC_EVAL_DENY),
558 : : hbac_result_string(result),
559 : : info ? hbac_error_string(info->code):"Unknown");
560 : :
561 : 1 : talloc_free(test_ctx);
562 : : }
563 : 1 : END_TEST
564 : :
565 : 1 : START_TEST(ipa_hbac_test_allow_svcgroup)
566 : : {
567 : : enum hbac_eval_result result;
568 : : TALLOC_CTX *test_ctx;
569 : : struct hbac_rule **rules;
570 : : struct hbac_eval_req *eval_req;
571 : : struct hbac_info *info;
572 : : bool is_valid;
573 : : uint32_t missing_attrs;
574 : :
575 : 1 : test_ctx = talloc_new(global_talloc_context);
576 : :
577 : : /* Create a request */
578 : 1 : eval_req = talloc_zero(test_ctx, struct hbac_eval_req);
579 : 1 : fail_if (eval_req == NULL);
580 : :
581 : 1 : get_test_user(eval_req, &eval_req->user);
582 : 1 : get_test_service(eval_req, &eval_req->service);
583 : 1 : get_test_srchost(eval_req, &eval_req->srchost);
584 : :
585 : : /* Create the rules to evaluate against */
586 : 1 : rules = talloc_array(test_ctx, struct hbac_rule *, 2);
587 : 1 : fail_if (rules == NULL);
588 : :
589 : 1 : get_allow_all_rule(rules, &rules[0]);
590 : :
591 : : /* Modify the rule to allow only a group of users */
592 : 1 : rules[0]->name = talloc_strdup(rules[0], "Allow servicegroup");
593 : 1 : fail_if(rules[0]->name == NULL);
594 : 1 : rules[0]->services->category = HBAC_CATEGORY_NULL;
595 : :
596 : 1 : rules[0]->services->names = NULL;
597 : 1 : rules[0]->services->groups = talloc_array(rules[0], const char *, 2);
598 : 1 : fail_if(rules[0]->services->groups == NULL);
599 : :
600 : 1 : rules[0]->services->groups[0] = HBAC_TEST_SERVICEGROUP1;
601 : 1 : rules[0]->services->groups[1] = NULL;
602 : :
603 : 1 : rules[1] = NULL;
604 : :
605 : : /* Validate this rule */
606 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
607 : 1 : fail_unless(is_valid);
608 : 1 : fail_unless(missing_attrs == 0);
609 : :
610 : : /* Evaluate the rules */
611 : 1 : result = hbac_evaluate(rules, eval_req, &info);
612 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_ALLOW,
613 : : "Expected [%s], got [%s]; "
614 : : "Error: [%s]",
615 : : hbac_result_string(HBAC_EVAL_ALLOW),
616 : : hbac_result_string(result),
617 : : info ? hbac_error_string(info->code):"Unknown");
618 : :
619 : : /* Negative test */
620 : 1 : rules[0]->services->groups[0] = HBAC_TEST_INVALID_SERVICEGROUP;
621 : :
622 : : /* Validate this rule */
623 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
624 : 1 : fail_unless(is_valid);
625 : 1 : fail_unless(missing_attrs == 0);
626 : :
627 : : /* Evaluate the rules */
628 : 1 : result = hbac_evaluate(rules, eval_req, &info);
629 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_DENY,
630 : : "Expected [%s], got [%s]; "
631 : : "Error: [%s]",
632 : : hbac_result_string(HBAC_EVAL_DENY),
633 : : hbac_result_string(result),
634 : : info ? hbac_error_string(info->code):"Unknown");
635 : :
636 : 1 : talloc_free(test_ctx);
637 : : }
638 : 1 : END_TEST
639 : :
640 : 1 : START_TEST(ipa_hbac_test_allow_srchost)
641 : : {
642 : : enum hbac_eval_result result;
643 : : TALLOC_CTX *test_ctx;
644 : : struct hbac_rule **rules;
645 : : struct hbac_eval_req *eval_req;
646 : : struct hbac_info *info;
647 : : bool is_valid;
648 : : uint32_t missing_attrs;
649 : :
650 : 1 : test_ctx = talloc_new(global_talloc_context);
651 : :
652 : : /* Create a request */
653 : 1 : eval_req = talloc_zero(test_ctx, struct hbac_eval_req);
654 : 1 : fail_if (eval_req == NULL);
655 : :
656 : 1 : get_test_user(eval_req, &eval_req->user);
657 : 1 : get_test_service(eval_req, &eval_req->service);
658 : 1 : get_test_srchost(eval_req, &eval_req->srchost);
659 : :
660 : : /* Create the rules to evaluate against */
661 : 1 : rules = talloc_array(test_ctx, struct hbac_rule *, 2);
662 : 1 : fail_if (rules == NULL);
663 : :
664 : 1 : get_allow_all_rule(rules, &rules[0]);
665 : :
666 : : /* Modify the rule to allow only a specific service */
667 : 1 : rules[0]->name = talloc_strdup(rules[0], "Allow srchost");
668 : 1 : fail_if(rules[0]->name == NULL);
669 : 1 : rules[0]->srchosts->category = HBAC_CATEGORY_NULL;
670 : :
671 : 1 : rules[0]->srchosts->names = talloc_array(rules[0], const char *, 2);
672 : 1 : fail_if(rules[0]->srchosts->names == NULL);
673 : :
674 : 1 : rules[0]->srchosts->names[0] = HBAC_TEST_SRCHOST;
675 : 1 : rules[0]->srchosts->names[1] = NULL;
676 : :
677 : 1 : rules[1] = NULL;
678 : :
679 : : /* Validate this rule */
680 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
681 : 1 : fail_unless(is_valid);
682 : 1 : fail_unless(missing_attrs == 0);
683 : :
684 : : /* Evaluate the rules */
685 : 1 : result = hbac_evaluate(rules, eval_req, &info);
686 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_ALLOW,
687 : : "Expected [%s], got [%s]; "
688 : : "Error: [%s]",
689 : : hbac_result_string(HBAC_EVAL_ALLOW),
690 : : hbac_result_string(result),
691 : : info ? hbac_error_string(info->code):"Unknown");
692 : :
693 : : /* Negative test */
694 : 1 : rules[0]->srchosts->names[0] = HBAC_TEST_INVALID_SRCHOST;
695 : :
696 : : /* Validate this rule */
697 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
698 : 1 : fail_unless(is_valid);
699 : 1 : fail_unless(missing_attrs == 0);
700 : :
701 : : /* Evaluate the rules */
702 : 1 : result = hbac_evaluate(rules, eval_req, &info);
703 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_DENY,
704 : : "Expected [%s], got [%s]; "
705 : : "Error: [%s](%s)",
706 : : hbac_result_string(HBAC_EVAL_DENY),
707 : : hbac_result_string(result),
708 : : info ? hbac_error_string(info->code):"Unknown");
709 : :
710 : 1 : talloc_free(test_ctx);
711 : : }
712 : 1 : END_TEST
713 : :
714 : 1 : START_TEST(ipa_hbac_test_allow_srchostgroup)
715 : : {
716 : : enum hbac_eval_result result;
717 : : TALLOC_CTX *test_ctx;
718 : : struct hbac_rule **rules;
719 : : struct hbac_eval_req *eval_req;
720 : : struct hbac_info *info;
721 : : bool is_valid;
722 : : uint32_t missing_attrs;
723 : :
724 : 1 : test_ctx = talloc_new(global_talloc_context);
725 : :
726 : : /* Create a request */
727 : 1 : eval_req = talloc_zero(test_ctx, struct hbac_eval_req);
728 : 1 : fail_if (eval_req == NULL);
729 : :
730 : 1 : get_test_user(eval_req, &eval_req->user);
731 : 1 : get_test_service(eval_req, &eval_req->service);
732 : 1 : get_test_srchost(eval_req, &eval_req->srchost);
733 : :
734 : : /* Create the rules to evaluate against */
735 : 1 : rules = talloc_array(test_ctx, struct hbac_rule *, 2);
736 : 1 : fail_if (rules == NULL);
737 : :
738 : 1 : get_allow_all_rule(rules, &rules[0]);
739 : :
740 : : /* Modify the rule to allow only a group of users */
741 : 1 : rules[0]->name = talloc_strdup(rules[0], "Allow srchostgroup");
742 : 1 : fail_if(rules[0]->name == NULL);
743 : 1 : rules[0]->srchosts->category = HBAC_CATEGORY_NULL;
744 : :
745 : 1 : rules[0]->srchosts->names = NULL;
746 : 1 : rules[0]->srchosts->groups = talloc_array(rules[0], const char *, 2);
747 : 1 : fail_if(rules[0]->srchosts->groups == NULL);
748 : :
749 : 1 : rules[0]->srchosts->groups[0] = HBAC_TEST_SRCHOSTGROUP1;
750 : 1 : rules[0]->srchosts->groups[1] = NULL;
751 : :
752 : 1 : rules[1] = NULL;
753 : :
754 : : /* Validate this rule */
755 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
756 : 1 : fail_unless(is_valid);
757 : 1 : fail_unless(missing_attrs == 0);
758 : :
759 : : /* Evaluate the rules */
760 : 1 : result = hbac_evaluate(rules, eval_req, &info);
761 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_ALLOW,
762 : : "Expected [%s], got [%s]; "
763 : : "Error: [%s]",
764 : : hbac_result_string(HBAC_EVAL_ALLOW),
765 : : hbac_result_string(result),
766 : : info ? hbac_error_string(info->code):"Unknown");
767 : :
768 : : /* Negative test */
769 : 1 : rules[0]->srchosts->groups[0] = HBAC_TEST_INVALID_SRCHOSTGROUP;
770 : :
771 : : /* Validate this rule */
772 : 1 : is_valid = hbac_rule_is_complete(rules[0], &missing_attrs);
773 : 1 : fail_unless(is_valid);
774 : 1 : fail_unless(missing_attrs == 0);
775 : :
776 : : /* Evaluate the rules */
777 : 1 : result = hbac_evaluate(rules, eval_req, &info);
778 [ + - ]: 1 : fail_unless(result == HBAC_EVAL_DENY,
779 : : "Expected [%s], got [%s]; "
780 : : "Error: [%s]",
781 : : hbac_result_string(HBAC_EVAL_DENY),
782 : : hbac_result_string(result),
783 : : info ? hbac_error_string(info->code):"Unknown");
784 : :
785 : 1 : talloc_free(test_ctx);
786 : : }
787 : 1 : END_TEST
788 : :
789 : 1 : START_TEST(ipa_hbac_test_incomplete)
790 : : {
791 : : TALLOC_CTX *test_ctx;
792 : : struct hbac_rule *rule;
793 : : bool is_valid;
794 : : uint32_t missing_attrs;
795 : :
796 : 1 : test_ctx = talloc_new(global_talloc_context);
797 : :
798 : 1 : rule = talloc_zero(test_ctx, struct hbac_rule);
799 : :
800 : : /* Validate this rule */
801 : 1 : is_valid = hbac_rule_is_complete(rule, &missing_attrs);
802 : 1 : fail_if(is_valid);
803 : 1 : fail_unless(missing_attrs | HBAC_RULE_ELEMENT_USERS);
804 : 1 : fail_unless(missing_attrs | HBAC_RULE_ELEMENT_SERVICES);
805 : 1 : fail_unless(missing_attrs | HBAC_RULE_ELEMENT_TARGETHOSTS);
806 : 1 : fail_unless(missing_attrs | HBAC_RULE_ELEMENT_SOURCEHOSTS);
807 : :
808 : 1 : talloc_free(test_ctx);
809 : : }
810 : 1 : END_TEST
811 : :
812 : 10 : Suite *hbac_test_suite (void)
813 : : {
814 : 10 : Suite *s = suite_create ("HBAC");
815 : :
816 : 10 : TCase *tc_hbac = tcase_create("HBAC_rules");
817 : 10 : tcase_add_checked_fixture(tc_hbac,
818 : : leak_check_setup,
819 : : leak_check_teardown);
820 : :
821 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_allow_all);
822 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_allow_user);
823 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_allow_group);
824 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_allow_svc);
825 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_allow_svcgroup);
826 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_allow_srchost);
827 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_allow_srchostgroup);
828 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_allow_utf8);
829 : 10 : tcase_add_test(tc_hbac, ipa_hbac_test_incomplete);
830 : :
831 : 10 : suite_add_tcase(s, tc_hbac);
832 : 10 : return s;
833 : : }
834 : :
835 : 10 : int main(int argc, const char *argv[])
836 : : {
837 : : int number_failed;
838 : :
839 : 10 : tests_set_cwd();
840 : :
841 : 10 : Suite *s = hbac_test_suite();
842 : 10 : SRunner *sr = srunner_create(s);
843 : :
844 : : /* If CK_VERBOSITY is set, use that, otherwise it defaults to CK_NORMAL */
845 : 10 : srunner_run_all(sr, CK_ENV);
846 : 1 : number_failed = srunner_ntests_failed (sr);
847 : 1 : srunner_free (sr);
848 : :
849 : 1 : return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
850 : : }
|
