Branch data Line data Source code
1 : : /*
2 : : SSSD
3 : :
4 : : Kerberos 5 Backend Module -- Utilities tests
5 : :
6 : : Authors:
7 : : Sumit Bose <sbose@redhat.com>
8 : :
9 : : Copyright (C) 2009 Red Hat
10 : :
11 : : This program is free software; you can redistribute it and/or modify
12 : : it under the terms of the GNU General Public License as published by
13 : : the Free Software Foundation; either version 3 of the License, or
14 : : (at your option) any later version.
15 : :
16 : : This program is distributed in the hope that it will be useful,
17 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : GNU General Public License for more details.
20 : :
21 : : You should have received a copy of the GNU General Public License
22 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
23 : : */
24 : :
25 : : #include <stdlib.h>
26 : : #include <popt.h>
27 : : #include <check.h>
28 : :
29 : : #include "providers/krb5/krb5_utils.h"
30 : : #include "providers/krb5/krb5_auth.h"
31 : : #include "tests/common.h"
32 : :
33 : : #define TESTS_PATH "tests_krb5_utils"
34 : :
35 : : #define BASE "/abc/def"
36 : : #define FILENAME "ghi"
37 : :
38 : : #define USERNAME "testuser"
39 : : #define UID "12345"
40 : : #define PRINCIPAL_NAME "testuser@EXAMPLE.COM"
41 : : #define REALM "REALM.ORG"
42 : : #define HOME_DIRECTORY "/home/testuser"
43 : : #define CCACHE_DIR "/var/tmp"
44 : : #define PID "4321"
45 : :
46 : : extern struct dp_option default_krb5_opts[];
47 : :
48 : : TALLOC_CTX *tmp_ctx = NULL;
49 : : struct krb5child_req *kr;
50 : :
51 : : #define RMDIR(__dir__) do { \
52 : : ret = rmdir(__dir__); \
53 : : fail_unless(ret == EOK, "rmdir [%s] failed, [%d][%s].", __dir__, \
54 : : errno, strerror(errno)); \
55 : : } while(0)
56 : :
57 : 2 : void setup_create_dir(void)
58 : : {
59 : 2 : fail_unless(tmp_ctx == NULL, "Talloc context already initialized.");
60 : 2 : tmp_ctx = talloc_new(NULL);
61 : 2 : fail_unless(tmp_ctx != NULL, "Cannot create talloc context.");
62 : 2 : }
63 : :
64 : 2 : void teardown_create_dir(void)
65 : : {
66 : : int ret;
67 : 2 : fail_unless(tmp_ctx != NULL, "Talloc context already freed.");
68 : 2 : ret = talloc_free(tmp_ctx);
69 : 2 : tmp_ctx = NULL;
70 : 2 : fail_unless(ret == 0, "Connot free talloc context.");
71 : 2 : }
72 : :
73 : 0 : static void check_dir(const char *dirname, uid_t uid, gid_t gid, mode_t mode)
74 : : {
75 : : struct stat stat_buf;
76 : : int ret;
77 : :
78 : 0 : ret = stat(dirname, &stat_buf);
79 : 0 : fail_unless(ret == EOK, "stat failed [%d][%s].", errno, strerror(errno));
80 : :
81 : 0 : fail_unless(S_ISDIR(stat_buf.st_mode), "[%s] is not a directory.", dirname);
82 : 0 : fail_unless(stat_buf.st_uid == uid, "uid does not match, "
83 : : "expected [%d], got [%d].",
84 : : uid, stat_buf.st_uid);
85 : 0 : fail_unless(stat_buf.st_gid == gid, "gid does not match, "
86 : : "expected [%d], got [%d].",
87 : : gid, stat_buf.st_gid);
88 : 0 : fail_unless((stat_buf.st_mode & ~S_IFMT) == mode,
89 : : "mode of [%s] does not match, "
90 : : "expected [%o], got [%o].", dirname,
91 : : mode, (stat_buf.st_mode & ~S_IFMT));
92 : 0 : }
93 : :
94 : 0 : START_TEST(test_pub_ccache_dir)
95 : : {
96 : : int ret;
97 : : char *cwd;
98 : : char *testpath;
99 : : char *dirname;
100 : : char *subdirname;
101 : : char *filename;
102 : :
103 : 0 : fail_unless(getuid() == 0, "This test must be run as root.");
104 : :
105 : 0 : cwd = getcwd(NULL, 0);
106 : 0 : fail_unless(cwd != NULL, "getcwd failed.");
107 : :
108 : 0 : testpath = talloc_asprintf(tmp_ctx, "%s/%s", cwd, TESTS_PATH);
109 : 0 : free(cwd);
110 : 0 : fail_unless(testpath != NULL, "talloc_asprintf failed.");
111 : 0 : dirname = talloc_asprintf(tmp_ctx, "%s/pub_ccdir", testpath);
112 : 0 : fail_unless(dirname != NULL, "talloc_asprintf failed.");
113 : 0 : subdirname = talloc_asprintf(tmp_ctx, "%s/subdir", dirname);
114 : 0 : fail_unless(subdirname != NULL, "talloc_asprintf failed.");
115 : 0 : filename = talloc_asprintf(tmp_ctx, "%s/ccfile", subdirname);
116 : 0 : fail_unless(filename != NULL, "talloc_asprintf failed.");
117 : :
118 : 0 : ret = chmod(testpath, 0754);
119 : 0 : fail_unless(ret == EOK, "chmod failed.");
120 : 0 : ret = cc_file_create(filename, NULL, 12345, 12345, false);
121 : 0 : fail_unless(ret == EINVAL, "cc_file_create does not return EINVAL "
122 : : "while x-bit is missing.");
123 : :
124 : 0 : ret = chmod(testpath, 0755);
125 : 0 : fail_unless(ret == EOK, "chmod failed.");
126 : 0 : ret = cc_file_create(filename, NULL, 12345, 12345, false);
127 : 0 : fail_unless(ret == EOK, "cc_file_create failed.");
128 : :
129 : 0 : check_dir(subdirname, 0, 0, 01777);
130 : 0 : RMDIR(subdirname);
131 : 0 : check_dir(dirname, 0, 0, 0755);
132 : 0 : RMDIR(dirname);
133 : : }
134 : 0 : END_TEST
135 : :
136 : 0 : START_TEST(test_pub_ccache_dir_in_user_dir)
137 : : {
138 : : int ret;
139 : : char *cwd;
140 : : char *dirname;
141 : : char *subdirname;
142 : : char *filename;
143 : :
144 : 0 : fail_unless(getuid() == 0, "This test must be run as root.");
145 : :
146 : 0 : cwd = getcwd(NULL, 0);
147 : 0 : fail_unless(cwd != NULL, "getcwd failed.");
148 : :
149 : 0 : dirname = talloc_asprintf(tmp_ctx, "%s/%s/pub_ccdir", cwd, TESTS_PATH);
150 : 0 : free(cwd);
151 : 0 : fail_unless(dirname != NULL, "talloc_asprintf failed.");
152 : 0 : ret = mkdir(dirname, 0700);
153 : 0 : fail_unless(ret == EOK, "mkdir failed.\n");
154 : 0 : ret = chown(dirname, 12345, 12345);
155 : 0 : fail_unless(ret == EOK, "chown failed.\n");
156 : 0 : subdirname = talloc_asprintf(tmp_ctx, "%s/subdir", dirname);
157 : 0 : fail_unless(subdirname != NULL, "talloc_asprintf failed.");
158 : 0 : filename = talloc_asprintf(tmp_ctx, "%s/ccfile", subdirname);
159 : 0 : fail_unless(filename != NULL, "talloc_asprintf failed.");
160 : :
161 : 0 : ret = cc_file_create(filename, NULL, 12345, 12345, false);
162 : 0 : fail_unless(ret == EINVAL, "Creating public ccache dir in user dir "
163 : : "does not failed with EINVAL.");
164 : :
165 : 0 : RMDIR(dirname);
166 : : }
167 : 0 : END_TEST
168 : :
169 : 0 : START_TEST(test_priv_ccache_dir)
170 : : {
171 : : int ret;
172 : : char *cwd;
173 : : char *testpath;
174 : : char *dirname;
175 : : char *subdir;
176 : : char *filename;
177 : 0 : uid_t uid = 12345;
178 : 0 : gid_t gid = 12345;
179 : :
180 : 0 : fail_unless(getuid() == 0, "This test must be run as root.");
181 : :
182 : 0 : cwd = getcwd(NULL, 0);
183 : 0 : fail_unless(cwd != NULL, "getcwd failed.");
184 : :
185 : 0 : testpath = talloc_asprintf(tmp_ctx, "%s/%s", cwd, TESTS_PATH);
186 : 0 : free(cwd);
187 : 0 : fail_unless(testpath != NULL, "talloc_asprintf failed.");
188 : 0 : dirname = talloc_asprintf(tmp_ctx, "%s/base", testpath);
189 : 0 : subdir = talloc_asprintf(tmp_ctx, "%s/priv_ccdir", dirname);
190 : 0 : fail_unless(subdir != NULL, "talloc_asprintf failed.");
191 : 0 : filename = talloc_asprintf(tmp_ctx, "%s/ccfile", subdir);
192 : 0 : fail_unless(filename != NULL, "talloc_asprintf failed.");
193 : :
194 : 0 : ret = chmod(testpath, 0754);
195 : 0 : fail_unless(ret == EOK, "chmod failed.");
196 : 0 : ret = cc_file_create(filename, NULL, uid, gid, true);
197 : 0 : fail_unless(ret == EINVAL, "cc_file_create does not return EINVAL "
198 : : "while x-bit is missing.");
199 : :
200 : 0 : ret = chmod(testpath, 0755);
201 : 0 : fail_unless(ret == EOK, "chmod failed.");
202 : 0 : ret = cc_file_create(filename, NULL, uid, gid, true);
203 : 0 : fail_unless(ret == EOK, "cc_file_create failed.");
204 : :
205 : 0 : check_dir(subdir, uid, gid, 0700);
206 : 0 : RMDIR(subdir);
207 : 0 : check_dir(dirname, 0, 0, 0755);
208 : 0 : RMDIR(dirname);
209 : : }
210 : 0 : END_TEST
211 : :
212 : 0 : START_TEST(test_private_ccache_dir_in_user_dir)
213 : : {
214 : : int ret;
215 : : char *cwd;
216 : : char *user_dir;
217 : : char *dn1;
218 : : char *dn2;
219 : : char *dn3;
220 : : char *filename;
221 : 0 : uid_t uid = getuid();
222 : 0 : gid_t gid = getgid();
223 : :
224 [ # # ]: 0 : if (uid == 0) {
225 : 0 : uid = 12345;
226 : 0 : gid = 12345;
227 : : }
228 : :
229 : 0 : cwd = getcwd(NULL, 0);
230 : 0 : fail_unless(cwd != NULL, "getcwd failed.");
231 : :
232 : 0 : user_dir = talloc_asprintf(tmp_ctx, "%s/%s/user", cwd, TESTS_PATH);
233 : 0 : free(cwd);
234 : 0 : fail_unless(user_dir != NULL, "talloc_asprintf failed.");
235 : 0 : ret = mkdir(user_dir, 0700);
236 : 0 : fail_unless(ret == EOK, "mkdir failed.");
237 : 0 : ret = chown(user_dir, uid, gid);
238 : 0 : fail_unless(ret == EOK, "chown failed.");
239 : :
240 : 0 : dn1 = talloc_asprintf(tmp_ctx, "%s/a", user_dir);
241 : 0 : fail_unless(dn1 != NULL, "talloc_asprintf failed.");
242 : 0 : dn2 = talloc_asprintf(tmp_ctx, "%s/b", dn1);
243 : 0 : fail_unless(dn2 != NULL, "talloc_asprintf failed.");
244 : 0 : dn3 = talloc_asprintf(tmp_ctx, "%s/c", dn2);
245 : 0 : fail_unless(dn3 != NULL, "talloc_asprintf failed.");
246 : 0 : filename = talloc_asprintf(tmp_ctx, "%s/ccfile", dn3);
247 : 0 : fail_unless(filename != NULL, "talloc_asprintf failed.");
248 : :
249 : 0 : ret = chmod(user_dir, 0600);
250 : 0 : fail_unless(ret == EOK, "chmod failed.");
251 : 0 : ret = cc_file_create(filename, NULL, uid, gid, true);
252 : 0 : fail_unless(ret == EINVAL, "cc_file_create does not return EINVAL "
253 : : "while x-bit is missing.");
254 : :
255 : 0 : ret = chmod(user_dir, 0700);
256 : 0 : fail_unless(ret == EOK, "chmod failed.");
257 : 0 : ret = cc_file_create(filename, NULL, uid, gid, true);
258 : 0 : fail_unless(ret == EOK, "cc_file_create failed.");
259 : :
260 : 0 : check_dir(dn3, uid, gid, 0700);
261 : 0 : RMDIR(dn3);
262 : 0 : check_dir(dn2, uid, gid, 0700);
263 : 0 : RMDIR(dn2);
264 : 0 : check_dir(dn1, uid, gid, 0700);
265 : 0 : RMDIR(dn1);
266 : 0 : RMDIR(user_dir);
267 : : }
268 : 0 : END_TEST
269 : :
270 : 0 : START_TEST(test_private_ccache_dir_in_wrong_user_dir)
271 : : {
272 : : int ret;
273 : : char *cwd;
274 : : char *dirname;
275 : : char *subdirname;
276 : : char *filename;
277 : :
278 : 0 : fail_unless(getuid() == 0, "This test must be run as root.");
279 : :
280 : 0 : cwd = getcwd(NULL, 0);
281 : 0 : fail_unless(cwd != NULL, "getcwd failed.");
282 : :
283 : 0 : dirname = talloc_asprintf(tmp_ctx, "%s/%s/priv_ccdir", cwd, TESTS_PATH);
284 : 0 : free(cwd);
285 : 0 : fail_unless(dirname != NULL, "talloc_asprintf failed.");
286 : 0 : ret = mkdir(dirname, 0700);
287 : 0 : fail_unless(ret == EOK, "mkdir failed.\n");
288 : 0 : ret = chown(dirname, 12346, 12346);
289 : 0 : fail_unless(ret == EOK, "chown failed.\n");
290 : 0 : subdirname = talloc_asprintf(tmp_ctx, "%s/subdir", dirname);
291 : 0 : fail_unless(subdirname != NULL, "talloc_asprintf failed.");
292 : 0 : filename = talloc_asprintf(tmp_ctx, "%s/ccfile", subdirname);
293 : 0 : fail_unless(filename != NULL, "talloc_asprintf failed.");
294 : :
295 : 0 : ret = cc_file_create(filename, NULL, 12345, 12345, true);
296 : 0 : fail_unless(ret == EINVAL, "Creating private ccache dir in wrong user "
297 : : "dir does not failed with EINVAL.");
298 : :
299 : 0 : RMDIR(dirname);
300 : : }
301 : 0 : END_TEST
302 : :
303 : 1 : START_TEST(test_illegal_patterns)
304 : : {
305 : : int ret;
306 : : char *cwd;
307 : : char *dirname;
308 : : char *filename;
309 : 1 : uid_t uid = getuid();
310 : 1 : gid_t gid = getgid();
311 : : pcre *illegal_re;
312 : : const char *errstr;
313 : : int errval;
314 : : int errpos;
315 : :
316 : 1 : illegal_re = pcre_compile2(ILLEGAL_PATH_PATTERN, 0,
317 : : &errval, &errstr, &errpos, NULL);
318 : 1 : fail_unless(illegal_re != NULL, "Invalid Regular Expression pattern at "
319 : : " position %d. (Error: %d [%s])\n",
320 : : errpos, errval, errstr);
321 : :
322 : 1 : cwd = getcwd(NULL, 0);
323 : 1 : fail_unless(cwd != NULL, "getcwd failed.");
324 : :
325 : 1 : dirname = talloc_asprintf(tmp_ctx, "%s/%s/priv_ccdir", cwd, TESTS_PATH);
326 : 1 : free(cwd);
327 : 1 : fail_unless(dirname != NULL, "talloc_asprintf failed.");
328 : :
329 : :
330 : 1 : filename = talloc_asprintf(tmp_ctx, "abc/./ccfile");
331 : 1 : fail_unless(filename != NULL, "talloc_asprintf failed.");
332 : 1 : ret = create_ccache_dir(filename, illegal_re, uid, gid, true);
333 : 1 : fail_unless(ret == EINVAL, "create_ccache_dir allowed relative path [%s].",
334 : : filename);
335 : :
336 : 1 : filename = talloc_asprintf(tmp_ctx, "%s/abc/./ccfile", dirname);
337 : 1 : fail_unless(filename != NULL, "talloc_asprintf failed.");
338 : 1 : ret = create_ccache_dir(filename, illegal_re, uid, gid, true);
339 : 1 : fail_unless(ret == EINVAL, "create_ccache_dir allowed "
340 : : "illegal pattern '/./' in filename [%s].",
341 : : filename);
342 : :
343 : 1 : filename = talloc_asprintf(tmp_ctx, "%s/abc/../ccfile", dirname);
344 : 1 : fail_unless(filename != NULL, "talloc_asprintf failed.");
345 : 1 : ret = create_ccache_dir(filename, illegal_re, uid, gid, true);
346 : 1 : fail_unless(ret == EINVAL, "create_ccache_dir allowed "
347 : : "illegal pattern '/../' in filename [%s].",
348 : : filename);
349 : :
350 : 1 : filename = talloc_asprintf(tmp_ctx, "%s/abc//ccfile", dirname);
351 : 1 : fail_unless(filename != NULL, "talloc_asprintf failed.");
352 : 1 : ret = create_ccache_dir(filename, illegal_re, uid, gid, true);
353 : 1 : fail_unless(ret == EINVAL, "create_ccache_dir allowed "
354 : : "illegal pattern '//' in filename [%s].",
355 : : filename);
356 : :
357 : : }
358 : 1 : END_TEST
359 : :
360 : : #ifdef HAVE_KRB5_DIRCACHE
361 : 1 : START_TEST(test_cc_dir_create)
362 : : {
363 : : char *residual;
364 : : char *dirname;
365 : : char *cwd;
366 : 1 : uid_t uid = getuid();
367 : 1 : gid_t gid = getgid();
368 : : pcre *illegal_re;
369 : : errno_t ret;
370 : : const char *errstr;
371 : : int errval;
372 : : int errpos;
373 : :
374 : 1 : illegal_re = pcre_compile2(ILLEGAL_PATH_PATTERN, 0,
375 : : &errval, &errstr, &errpos, NULL);
376 : 1 : fail_unless(illegal_re != NULL, "Invalid Regular Expression pattern at "
377 : : " position %d. (Error: %d [%s])\n",
378 : : errpos, errval, errstr);
379 : :
380 : 1 : cwd = getcwd(NULL, 0);
381 : 1 : fail_unless(cwd != NULL, "getcwd failed.");
382 : :
383 : 1 : dirname = talloc_asprintf(tmp_ctx, "%s/%s/user_dir",
384 : : cwd, TESTS_PATH);
385 : 1 : fail_unless(dirname != NULL, "talloc_asprintf failed.");
386 : 1 : residual = talloc_asprintf(tmp_ctx, "DIR:%s/%s", dirname, "ccdir");
387 : 1 : fail_unless(residual != NULL, "talloc_asprintf failed.");
388 : :
389 : 1 : ret = cc_dir_create(residual, illegal_re, uid, gid, true);
390 : 1 : fail_unless(ret == EOK, "cc_dir_create failed\n");
391 : 1 : ret = rmdir(dirname);
392 [ - + ]: 1 : if (ret < 0) ret = errno;
393 : 1 : fail_unless(ret == 0, "Cannot remove %s: %s\n", dirname, strerror(ret));
394 : 1 : talloc_free(residual);
395 : :
396 : 1 : dirname = talloc_asprintf(tmp_ctx, "%s/%s/user_dir2",
397 : : cwd, TESTS_PATH);
398 : 1 : fail_unless(dirname != NULL, "talloc_asprintf failed.");
399 : 1 : residual = talloc_asprintf(tmp_ctx, "DIR:%s/%s", dirname, "ccdir/");
400 : 1 : fail_unless(residual != NULL, "talloc_asprintf failed.");
401 : :
402 : 1 : ret = cc_dir_create(residual, illegal_re, uid, gid, true);
403 : 1 : fail_unless(ret == EOK, "cc_dir_create failed\n");
404 : 1 : ret = rmdir(dirname);
405 [ - + ]: 1 : if (ret < 0) ret = errno;
406 : 1 : fail_unless(ret == 0, "Cannot remove %s: %s\n", dirname, strerror(ret));
407 : 1 : talloc_free(residual);
408 : 1 : free(cwd);
409 : : }
410 : 1 : END_TEST
411 : : #endif /* HAVE_KRB5_DIRCACHE */
412 : :
413 : :
414 : 13 : void setup_talloc_context(void)
415 : : {
416 : : int ret;
417 : : int i;
418 : :
419 : : struct pam_data *pd;
420 : : struct krb5_ctx *krb5_ctx;
421 : 13 : fail_unless(tmp_ctx == NULL, "Talloc context already initialized.");
422 : 13 : tmp_ctx = talloc_new(NULL);
423 : 13 : fail_unless(tmp_ctx != NULL, "Cannot create talloc context.");
424 : :
425 : 13 : kr = talloc_zero(tmp_ctx, struct krb5child_req);
426 : 13 : fail_unless(kr != NULL, "Cannot create krb5child_req structure.");
427 : :
428 : 13 : pd = talloc_zero(tmp_ctx, struct pam_data);
429 : 13 : fail_unless(pd != NULL, "Cannot create pam_data structure.");
430 : :
431 : 13 : krb5_ctx = talloc_zero(tmp_ctx, struct krb5_ctx);
432 : 13 : fail_unless(pd != NULL, "Cannot create krb5_ctx structure.");
433 : :
434 : 13 : pd->user = discard_const(USERNAME);
435 : 26 : kr->uid = atoi(UID);
436 : 13 : kr->upn = discard_const(PRINCIPAL_NAME);
437 : 13 : pd->cli_pid = atoi(PID);
438 : :
439 : 13 : krb5_ctx->opts = talloc_zero_array(tmp_ctx, struct dp_option, KRB5_OPTS);
440 : 13 : fail_unless(krb5_ctx->opts != NULL, "Cannot created options.");
441 [ + + ]: 234 : for (i = 0; i < KRB5_OPTS; i++) {
442 : 221 : krb5_ctx->opts[i].opt_name = default_krb5_opts[i].opt_name;
443 : 221 : krb5_ctx->opts[i].type = default_krb5_opts[i].type;
444 : 221 : krb5_ctx->opts[i].def_val = default_krb5_opts[i].def_val;
445 : : }
446 : 13 : ret = dp_opt_set_string(krb5_ctx->opts, KRB5_REALM, REALM);
447 : 13 : fail_unless(ret == EOK, "Failed to set Realm");
448 : 13 : ret = dp_opt_set_string(krb5_ctx->opts, KRB5_CCACHEDIR, CCACHE_DIR);
449 : 13 : fail_unless(ret == EOK, "Failed to set Ccache dir");
450 : :
451 : 13 : kr->homedir = HOME_DIRECTORY;
452 : :
453 : 13 : kr->pd = pd;
454 : 13 : kr->krb5_ctx = krb5_ctx;
455 : :
456 : 13 : }
457 : :
458 : 13 : void free_talloc_context(void)
459 : : {
460 : : int ret;
461 : 13 : fail_unless(tmp_ctx != NULL, "Talloc context already freed.");
462 : 13 : ret = talloc_free(tmp_ctx);
463 : 13 : tmp_ctx = NULL;
464 : 13 : fail_unless(ret == 0, "Connot free talloc context.");
465 : 13 : }
466 : :
467 : 16 : static void do_test(const char *file_template, const char *dir_template,
468 : : const char *expected, const bool expected_private_path)
469 : : {
470 : : char *result;
471 : : int ret;
472 : 16 : bool private_path = false;
473 : :
474 : 16 : ret = dp_opt_set_string(kr->krb5_ctx->opts, KRB5_CCACHEDIR, dir_template);
475 : 16 : fail_unless(ret == EOK, "Failed to set Ccache dir");
476 : :
477 : 16 : result = expand_ccname_template(tmp_ctx, kr, file_template, true,
478 : : true, &private_path);
479 : :
480 : 16 : fail_unless(result != NULL, "Cannot expand template [%s].", file_template);
481 : 16 : fail_unless(strcmp(result, expected) == 0,
482 : : "Expansion failed, result [%s], expected [%s].",
483 : : result, expected);
484 [ + + ][ + + ]: 16 : fail_unless(private_path == expected_private_path,
485 : : "Unexprected private path, get [%s], expected [%s].",
486 : : private_path ? "true" : "false",
487 : : expected_private_path ? "true" : "false");
488 : 16 : }
489 : :
490 : 1 : START_TEST(test_multiple_substitutions)
491 : : {
492 : 1 : do_test(BASE"_%u_%U_%u", CCACHE_DIR, BASE"_"USERNAME"_"UID"_"USERNAME, false);
493 : 1 : do_test("%d/"FILENAME, BASE"_%u_%U_%u",
494 : : BASE"_"USERNAME"_"UID"_"USERNAME"/"FILENAME, true);
495 : : }
496 : 1 : END_TEST
497 : :
498 : 1 : START_TEST(test_username)
499 : : {
500 : 1 : do_test(BASE"_%u", CCACHE_DIR, BASE"_"USERNAME, false);
501 : 1 : do_test("%d/"FILENAME, BASE"_%u", BASE"_"USERNAME"/"FILENAME, true);
502 : : }
503 : 1 : END_TEST
504 : :
505 : 1 : START_TEST(test_case_sensitive)
506 : : {
507 : : char *result;
508 : : int ret;
509 : 1 : bool private_path = false;
510 : 1 : const char *file_template = BASE"_%u";
511 : 1 : const char *expected_cs = BASE"_TestUser";
512 : 1 : const char *expected_ci = BASE"_testuser";
513 : :
514 : 1 : kr->pd->user = discard_const("TestUser");
515 : 1 : ret = dp_opt_set_string(kr->krb5_ctx->opts, KRB5_CCACHEDIR, CCACHE_DIR);
516 : 1 : fail_unless(ret == EOK, "Failed to set Ccache dir");
517 : :
518 : 1 : result = expand_ccname_template(tmp_ctx, kr, file_template, true,
519 : : true, &private_path);
520 : :
521 : 1 : fail_unless(result != NULL, "Cannot expand template [%s].", file_template);
522 : 1 : fail_unless(strcmp(result, expected_cs) == 0,
523 : : "Expansion failed, result [%s], expected [%s].",
524 : : result, expected_cs);
525 : :
526 : 1 : result = expand_ccname_template(tmp_ctx, kr, file_template, true,
527 : : false, &private_path);
528 : :
529 : 1 : fail_unless(result != NULL, "Cannot expand template [%s].", file_template);
530 : 1 : fail_unless(strcmp(result, expected_ci) == 0,
531 : : "Expansion failed, result [%s], expected [%s].",
532 : : result, expected_ci);
533 : : }
534 : 1 : END_TEST
535 : :
536 : 1 : START_TEST(test_uid)
537 : : {
538 : 1 : do_test(BASE"_%U", CCACHE_DIR, BASE"_"UID, false);
539 : 1 : do_test("%d/"FILENAME, BASE"_%U", BASE"_"UID"/"FILENAME, true);
540 : : }
541 : 1 : END_TEST
542 : :
543 : 1 : START_TEST(test_upn)
544 : : {
545 : 1 : do_test(BASE"_%p", CCACHE_DIR, BASE"_"PRINCIPAL_NAME, false);
546 : 1 : do_test("%d/"FILENAME, BASE"_%p", BASE"_"PRINCIPAL_NAME"/"FILENAME, true);
547 : : }
548 : 1 : END_TEST
549 : :
550 : 1 : START_TEST(test_realm)
551 : : {
552 : 1 : do_test(BASE"_%r", CCACHE_DIR, BASE"_"REALM, false);
553 : 1 : do_test("%d/"FILENAME, BASE"_%r", BASE"_"REALM"/"FILENAME, false);
554 : : }
555 : 1 : END_TEST
556 : :
557 : 1 : START_TEST(test_home)
558 : : {
559 : 1 : do_test(BASE"_%h", CCACHE_DIR, BASE"_"HOME_DIRECTORY, false);
560 : 1 : do_test("%d/"FILENAME, BASE"_%h", BASE"_"HOME_DIRECTORY"/"FILENAME, true);
561 : : }
562 : 1 : END_TEST
563 : :
564 : 1 : START_TEST(test_ccache_dir)
565 : : {
566 : : char *result;
567 : : int ret;
568 : 1 : bool private_path = false;
569 : :
570 : 1 : do_test(BASE"_%d", CCACHE_DIR, BASE"_"CCACHE_DIR, false);
571 : :
572 : 1 : ret = dp_opt_set_string(kr->krb5_ctx->opts, KRB5_CCACHEDIR, BASE"_%d");
573 : 1 : fail_unless(ret == EOK, "Failed to set Ccache dir");
574 : :
575 : 1 : result = expand_ccname_template(tmp_ctx, kr, "%d/"FILENAME, true,
576 : : true, &private_path);
577 : :
578 : 1 : fail_unless(result == NULL, "Using %%d in ccache dir should fail.");
579 [ + - ]: 1 : fail_unless(private_path == false,
580 : : "Unexprected private path, get [%s], expected [%s].",
581 : : private_path ? "true" : "false", "false");
582 : : }
583 : 1 : END_TEST
584 : :
585 : 1 : START_TEST(test_pid)
586 : : {
587 : : char *result;
588 : : int ret;
589 : 1 : bool private_path = false;
590 : :
591 : 1 : do_test(BASE"_%P", CCACHE_DIR, BASE"_"PID, false);
592 : :
593 : 1 : ret = dp_opt_set_string(kr->krb5_ctx->opts, KRB5_CCACHEDIR, BASE"_%P");
594 : 1 : fail_unless(ret == EOK, "Failed to set Ccache dir");
595 : :
596 : 1 : result = expand_ccname_template(tmp_ctx, kr, "%d/"FILENAME, true,
597 : : true, &private_path);
598 : :
599 : 1 : fail_unless(result == NULL, "Using %%P in ccache dir should fail.");
600 [ + - ]: 1 : fail_unless(private_path == false,
601 : : "Unexprected private path, get [%s], expected [%s].",
602 : : private_path ? "true" : "false", "false");
603 : : }
604 : 1 : END_TEST
605 : :
606 : 1 : START_TEST(test_percent)
607 : : {
608 : 1 : do_test(BASE"_%%", CCACHE_DIR, BASE"_%", false);
609 : 1 : do_test("%d/"FILENAME, BASE"_%%", BASE"_%/"FILENAME, false);
610 : : }
611 : 1 : END_TEST
612 : :
613 : 1 : START_TEST(test_unknow_template)
614 : : {
615 : 1 : const char *test_template = BASE"_%X";
616 : : char *result;
617 : : int ret;
618 : 1 : bool private_path = false;
619 : :
620 : 1 : result = expand_ccname_template(tmp_ctx, kr, test_template, true,
621 : : true, &private_path);
622 : :
623 : 1 : fail_unless(result == NULL, "Unknown template [%s] should fail.",
624 : : test_template);
625 : :
626 : 1 : ret = dp_opt_set_string(kr->krb5_ctx->opts, KRB5_CCACHEDIR, BASE"_%X");
627 : 1 : fail_unless(ret == EOK, "Failed to set Ccache dir");
628 : 1 : test_template = "%d/"FILENAME;
629 : 1 : result = expand_ccname_template(tmp_ctx, kr, test_template, true,
630 : : true, &private_path);
631 : :
632 : 1 : fail_unless(result == NULL, "Unknown template [%s] should fail.",
633 : : test_template);
634 [ + - ]: 1 : fail_unless(private_path == false,
635 : : "Unexprected private path, get [%s], expected [%s].",
636 : : private_path ? "true" : "false", "false");
637 : : }
638 : 1 : END_TEST
639 : :
640 : 1 : START_TEST(test_NULL)
641 : : {
642 : 1 : char *test_template = NULL;
643 : : char *result;
644 : 1 : bool private_path = false;
645 : :
646 : 1 : result = expand_ccname_template(tmp_ctx, kr, test_template, true,
647 : : true, &private_path);
648 : :
649 : 1 : fail_unless(result == NULL, "Expected NULL as a result for an empty input.",
650 : : test_template);
651 [ + - ]: 1 : fail_unless(private_path == false,
652 : : "Unexprected private path, get [%s], expected [%s].",
653 : : private_path ? "true" : "false", "false");
654 : : }
655 : 1 : END_TEST
656 : :
657 : 1 : START_TEST(test_no_substitution)
658 : : {
659 : 1 : const char *test_template = BASE;
660 : : char *result;
661 : 1 : bool private_path = false;
662 : :
663 : 1 : result = expand_ccname_template(tmp_ctx, kr, test_template, true,
664 : : true, &private_path);
665 : :
666 : 1 : fail_unless(result != NULL, "Cannot expand template [%s].", test_template);
667 : 1 : fail_unless(strcmp(result, test_template) == 0,
668 : : "Expansion failed, result [%s], expected [%s].",
669 : : result, test_template);
670 [ + - ]: 1 : fail_unless(private_path == false,
671 : : "Unexprected private path, get [%s], expected [%s].",
672 : : private_path ? "true" : "false", "false");
673 : : }
674 : 1 : END_TEST
675 : :
676 : 1 : START_TEST(test_compare_principal_realm)
677 : : {
678 : : int ret;
679 : : bool different_realm;
680 : :
681 : 1 : ret = compare_principal_realm(NULL, "a", &different_realm);
682 : 1 : fail_unless(ret == EINVAL, "NULL upn does not cause EINVAL.");
683 : :
684 : 1 : ret = compare_principal_realm("a", NULL, &different_realm);
685 : 1 : fail_unless(ret == EINVAL, "NULL realm does not cause EINVAL.");
686 : :
687 : 1 : ret = compare_principal_realm("a", "b", NULL);
688 : 1 : fail_unless(ret == EINVAL, "NULL different_realmbool " \
689 : : "does not cause EINVAL.");
690 : :
691 : 1 : ret = compare_principal_realm("", "a", &different_realm);
692 : 1 : fail_unless(ret == EINVAL, "Empty upn does not cause EINVAL.");
693 : :
694 : 1 : ret = compare_principal_realm("a", "", &different_realm);
695 : 1 : fail_unless(ret == EINVAL, "Empty realm does not cause EINVAL.");
696 : :
697 : 1 : ret = compare_principal_realm("ABC", "ABC", &different_realm);
698 : 1 : fail_unless(ret == EINVAL, "Short UPN does not cause EINVAL.");
699 : :
700 : 1 : ret = compare_principal_realm("userABC", "ABC", &different_realm);
701 : 1 : fail_unless(ret == EINVAL, "Missing '@' does not cause EINVAL.");
702 : :
703 : 1 : fail_unless(different_realm == false, "Same realm but " \
704 : : "different_realm is not false.");
705 : 1 : ret = compare_principal_realm("user@ABC", "ABC", &different_realm);
706 : 1 : fail_unless(ret == EOK, "Failure with same realm");
707 : 1 : fail_unless(different_realm == false, "Same realm but " \
708 : : "different_realm is not false.");
709 : :
710 : 1 : ret = compare_principal_realm("user@ABC", "DEF", &different_realm);
711 : 1 : fail_unless(ret == EOK, "Failure with different realm");
712 : 1 : fail_unless(different_realm == true, "Different realm but " \
713 : : "different_realm is not true.");
714 : :
715 : 1 : ret = compare_principal_realm("user@ABC", "REALMNAMELONGERTHANUPN",
716 : : &different_realm);
717 : 1 : fail_unless(ret == EOK, "Failure with long realm name.");
718 : 1 : fail_unless(different_realm == true, "Realm name longer than UPN but "
719 : : "different_realm is not true.");
720 : : }
721 : 1 : END_TEST
722 : :
723 : 17 : Suite *krb5_utils_suite (void)
724 : : {
725 : 17 : Suite *s = suite_create ("krb5_utils");
726 : :
727 : 17 : TCase *tc_ccname_template = tcase_create ("ccname_template");
728 : 17 : tcase_add_checked_fixture (tc_ccname_template, setup_talloc_context,
729 : : free_talloc_context);
730 : 17 : tcase_add_test (tc_ccname_template, test_no_substitution);
731 : 17 : tcase_add_test (tc_ccname_template, test_NULL);
732 : 17 : tcase_add_test (tc_ccname_template, test_unknow_template);
733 : 17 : tcase_add_test (tc_ccname_template, test_username);
734 : 17 : tcase_add_test (tc_ccname_template, test_case_sensitive);
735 : 17 : tcase_add_test (tc_ccname_template, test_uid);
736 : 17 : tcase_add_test (tc_ccname_template, test_upn);
737 : 17 : tcase_add_test (tc_ccname_template, test_realm);
738 : 17 : tcase_add_test (tc_ccname_template, test_home);
739 : 17 : tcase_add_test (tc_ccname_template, test_ccache_dir);
740 : 17 : tcase_add_test (tc_ccname_template, test_pid);
741 : 17 : tcase_add_test (tc_ccname_template, test_percent);
742 : 17 : tcase_add_test (tc_ccname_template, test_multiple_substitutions);
743 : 17 : suite_add_tcase (s, tc_ccname_template);
744 : :
745 : 17 : TCase *tc_create_dir = tcase_create("create_dir");
746 : 17 : tcase_add_checked_fixture (tc_create_dir, setup_create_dir,
747 : : teardown_create_dir);
748 : 17 : tcase_add_test (tc_create_dir, test_illegal_patterns);
749 : : #ifdef HAVE_KRB5_DIRCACHE
750 : 17 : tcase_add_test (tc_create_dir, test_cc_dir_create);
751 : : #endif /* HAVE_KRB5_DIRCACHE */
752 [ - + ]: 17 : if (getuid() == 0) {
753 : 0 : tcase_add_test (tc_create_dir, test_priv_ccache_dir);
754 : 0 : tcase_add_test (tc_create_dir, test_private_ccache_dir_in_user_dir);
755 : 0 : tcase_add_test (tc_create_dir, test_pub_ccache_dir);
756 : 0 : tcase_add_test (tc_create_dir, test_pub_ccache_dir_in_user_dir);
757 : 0 : tcase_add_test (tc_create_dir, test_private_ccache_dir_in_wrong_user_dir);
758 : : } else {
759 : 17 : printf("Run as root to enable more tests.\n");
760 : : }
761 : 17 : suite_add_tcase (s, tc_create_dir);
762 : :
763 : 17 : TCase *tc_krb5_helpers = tcase_create("Helper functions");
764 : 17 : tcase_add_test(tc_krb5_helpers, test_compare_principal_realm);
765 : 17 : suite_add_tcase(s, tc_krb5_helpers);
766 : :
767 : 17 : return s;
768 : : }
769 : :
770 : 17 : int main(int argc, const char *argv[])
771 : : {
772 : : int ret;
773 : : int opt;
774 : : poptContext pc;
775 : : int number_failed;
776 : :
777 : 17 : tests_set_cwd();
778 : :
779 : 85 : struct poptOption long_options[] = {
780 : : POPT_AUTOHELP
781 : 68 : SSSD_MAIN_OPTS
782 : : POPT_TABLEEND
783 : : };
784 : :
785 : : /* Set debug level to invalid value so we can deside if -d 0 was used. */
786 : 17 : debug_level = SSSDBG_INVALID;
787 : :
788 : 17 : pc = poptGetContext(argv[0], argc, argv, long_options, 0);
789 [ - + ]: 17 : while((opt = poptGetNextOpt(pc)) != -1) {
790 : : switch(opt) {
791 : : default:
792 : 0 : fprintf(stderr, "\nInvalid option %s: %s\n\n",
793 : : poptBadOption(pc, 0), poptStrerror(opt));
794 : 0 : poptPrintUsage(pc, stderr, 0);
795 : : return 1;
796 : : }
797 : : }
798 : 17 : poptFreeContext(pc);
799 : :
800 [ - + ]: 17 : DEBUG_INIT(debug_level);
801 : :
802 : 17 : ret = mkdir(TESTS_PATH, 0775);
803 [ - + ]: 17 : if (ret != EOK) {
804 : 0 : fprintf(stderr, "Could not create empty directory [%s]. ", TESTS_PATH);
805 [ # # ]: 0 : if (errno == EEXIST) {
806 : 0 : fprintf(stderr, "Please remove [%s].\n", TESTS_PATH);
807 : : } else {
808 : 0 : fprintf(stderr, "[%d][%s].\n", errno, strerror(errno));
809 : : }
810 : :
811 : : return 1;
812 : : }
813 : :
814 : 17 : Suite *s = krb5_utils_suite ();
815 : 17 : SRunner *sr = srunner_create (s);
816 : : /* If CK_VERBOSITY is set, use that, otherwise it defaults to CK_NORMAL */
817 : 17 : srunner_run_all(sr, CK_ENV);
818 : 1 : number_failed = srunner_ntests_failed (sr);
819 : 1 : srunner_free (sr);
820 [ + - ]: 1 : if (number_failed == 0) {
821 : 1 : ret = rmdir(TESTS_PATH);
822 [ - + ]: 1 : if (ret != EOK) {
823 : 1 : fprintf(stderr, "Cannot remove [%s]: [%d][%s].\n", TESTS_PATH,
824 : 0 : errno, strerror(errno));
825 : : return EXIT_FAILURE;
826 : : }
827 : :
828 : : return EXIT_SUCCESS;
829 : : }
830 : :
831 : : return EXIT_FAILURE;
832 : : }
833 : :
|
