Line data Source code
1 : /*
2 : SSSD
3 :
4 : authtok - Utilities tests
5 :
6 : Authors:
7 : Pallavi Jha <pallavikumarijha@gmail.com>
8 :
9 : Copyright (C) 2013 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 <string.h>
26 : #include <popt.h>
27 :
28 : #include "tests/cmocka/common_mock.h"
29 :
30 : #include "util/authtok.h"
31 :
32 :
33 : struct test_state {
34 : struct sss_auth_token *authtoken;
35 : };
36 :
37 11 : static int setup(void **state)
38 : {
39 11 : struct test_state *ts = NULL;
40 :
41 11 : assert_true(leak_check_setup());
42 :
43 11 : ts = talloc(global_talloc_context, struct test_state);
44 11 : assert_non_null(ts);
45 :
46 11 : ts->authtoken = sss_authtok_new(ts);
47 11 : assert_non_null(ts->authtoken);
48 :
49 11 : check_leaks_push(ts);
50 11 : *state = (void *)ts;
51 11 : return 0;
52 : }
53 :
54 11 : static int teardown(void **state)
55 : {
56 11 : struct test_state *ts = talloc_get_type_abort(*state, struct test_state);
57 :
58 11 : assert_non_null(ts);
59 :
60 11 : assert_true(check_leaks_pop(ts));
61 11 : talloc_free(ts);
62 11 : assert_true(leak_check_teardown());
63 11 : return 0;
64 : }
65 :
66 1 : static void test_sss_authtok_new(void **state)
67 : {
68 1 : struct test_state *ts = talloc_get_type_abort(*state, struct test_state);
69 : struct sss_auth_token *authtoken;
70 :
71 1 : authtoken = sss_authtok_new(ts);
72 1 : assert_non_null(authtoken);
73 :
74 1 : talloc_free(authtoken);
75 1 : }
76 :
77 : /* @test_authtok_type_x : tests following functions for different value of type
78 : * sss_authtok_set
79 : * sss_authtok_get_type
80 : * sss_authtok_get_size
81 : * sss_authtok_get_data
82 : * sss_authtok_get_password
83 : * sss_authtok_get_ccfile
84 : *
85 : * @test_authtok_type_password : type => SSS_AUTHTOK_TYPE_PASSWORD
86 : * @test_authtok_type_ccfile : type => SSS_AUTHTOK_TYPE_CCFILE
87 : * @test_authtok_type_empty : type => SSS_AUTHTOK_TYPE_EMPTY
88 : */
89 :
90 : /* Test when type has value SSS_AUTHTOK_TYPE_PASSWORD */
91 1 : static void test_sss_authtok_password(void **state)
92 : {
93 : size_t len;
94 : errno_t ret;
95 : char *data;
96 : size_t ret_len;
97 : const char *pwd;
98 : struct test_state *ts;
99 : enum sss_authtok_type type;
100 :
101 1 : ts = talloc_get_type_abort(*state, struct test_state);
102 1 : data = talloc_strdup(ts, "password");
103 1 : assert_non_null(data);
104 :
105 1 : len = strlen(data) + 1;
106 1 : type = SSS_AUTHTOK_TYPE_PASSWORD;
107 1 : ret = sss_authtok_set(ts->authtoken, type, (const uint8_t *)data, len);
108 :
109 1 : assert_int_equal(ret, EOK);
110 1 : assert_int_equal(type, sss_authtok_get_type(ts->authtoken));
111 1 : assert_int_equal(len, sss_authtok_get_size(ts->authtoken));
112 1 : assert_string_equal(data, sss_authtok_get_data(ts->authtoken));
113 :
114 1 : ret = sss_authtok_get_password(ts->authtoken, &pwd, &ret_len);
115 :
116 1 : assert_int_equal(ret, EOK);
117 1 : assert_string_equal(data, pwd);
118 1 : assert_int_equal(len - 1, ret_len);
119 :
120 1 : ret = sss_authtok_set_password(ts->authtoken, data, len);
121 1 : assert_int_equal(ret, EOK);
122 :
123 1 : ret = sss_authtok_get_password(ts->authtoken, &pwd, &ret_len);
124 1 : assert_int_equal(ret, EOK);
125 1 : assert_string_equal(data, pwd);
126 1 : assert_int_equal(len - 1, ret_len);
127 :
128 1 : talloc_free(data);
129 1 : sss_authtok_set_empty(ts->authtoken);
130 1 : }
131 :
132 : /* Test when type has value SSS_AUTHTOK_TYPE_CCFILE */
133 1 : static void test_sss_authtok_ccfile(void **state)
134 : {
135 : size_t len;
136 : errno_t ret;
137 : char *data;
138 : size_t ret_len;
139 : const char *pwd;
140 : struct test_state *ts;
141 : enum sss_authtok_type type;
142 :
143 1 : ts = talloc_get_type_abort(*state, struct test_state);
144 1 : data = talloc_strdup(ts, "path/to/cc_file");
145 1 : assert_non_null(data);
146 :
147 1 : len = strlen(data) + 1;
148 1 : type = SSS_AUTHTOK_TYPE_CCFILE;
149 1 : ret = sss_authtok_set(ts->authtoken, type, (const uint8_t *)data, len);
150 :
151 1 : assert_int_equal(ret, EOK);
152 1 : assert_int_equal(type, sss_authtok_get_type(ts->authtoken));
153 1 : assert_int_equal(len, sss_authtok_get_size(ts->authtoken));
154 1 : assert_string_equal(data, sss_authtok_get_data(ts->authtoken));
155 :
156 1 : ret = sss_authtok_get_ccfile(ts->authtoken, &pwd, &ret_len);
157 :
158 1 : assert_int_equal(ret, EOK);
159 1 : assert_string_equal(data, pwd);
160 1 : assert_int_equal(len - 1, ret_len);
161 :
162 1 : ret = sss_authtok_set_ccfile(ts->authtoken, data, len);
163 :
164 1 : assert_int_equal(ret, EOK);
165 :
166 1 : ret = sss_authtok_get_ccfile(ts->authtoken, &pwd, &ret_len);
167 :
168 1 : assert_int_equal(ret, EOK);
169 1 : assert_string_equal(data, pwd);
170 1 : assert_int_equal(len - 1, ret_len);
171 :
172 :
173 1 : ret = sss_authtok_set(ts->authtoken, type, (const uint8_t *) data, 0);
174 :
175 1 : assert_int_equal(ret, EOK);
176 1 : assert_int_equal(type, sss_authtok_get_type(ts->authtoken));
177 1 : assert_int_equal(len, sss_authtok_get_size(ts->authtoken));
178 1 : assert_string_equal(data, sss_authtok_get_data(ts->authtoken));
179 :
180 1 : ret = sss_authtok_get_ccfile(ts->authtoken, &pwd, &ret_len);
181 :
182 1 : assert_int_equal(ret, EOK);
183 1 : assert_string_equal(data, pwd);
184 1 : assert_int_equal(len - 1, ret_len);
185 :
186 1 : talloc_free(data);
187 1 : sss_authtok_set_empty(ts->authtoken);
188 1 : }
189 :
190 : /* Test when type has value SSS_AUTHTOK_TYPE_EMPTY */
191 1 : static void test_sss_authtok_empty(void **state)
192 : {
193 : errno_t ret;
194 : size_t ret_len;
195 : const char *pwd;
196 : struct test_state *ts;
197 : enum sss_authtok_type type;
198 :
199 1 : type = SSS_AUTHTOK_TYPE_EMPTY;
200 1 : ts = talloc_get_type_abort(*state, struct test_state);
201 1 : ret = sss_authtok_set(ts->authtoken, type, NULL, 0);
202 :
203 1 : assert_int_equal(ret, EOK);
204 1 : assert_int_equal(type, sss_authtok_get_type(ts->authtoken));
205 1 : assert_int_equal(0, sss_authtok_get_size(ts->authtoken));
206 1 : assert_null(sss_authtok_get_data(ts->authtoken));
207 :
208 1 : ret = sss_authtok_get_password(ts->authtoken, &pwd, &ret_len);
209 :
210 1 : assert_int_equal(ret, ENOENT);
211 :
212 1 : ret = sss_authtok_get_ccfile(ts->authtoken, &pwd, &ret_len);
213 :
214 1 : assert_int_equal(ret, ENOENT);
215 :
216 1 : sss_authtok_set_empty(ts->authtoken);
217 :
218 1 : assert_int_equal(type, sss_authtok_get_type(ts->authtoken));
219 1 : assert_int_equal(0, sss_authtok_get_size(ts->authtoken));
220 1 : assert_null(sss_authtok_get_data(ts->authtoken));
221 :
222 1 : ret = sss_authtok_set(ts->authtoken, type, (const uint8_t*)"", 0);
223 1 : assert_int_equal(ret, EOK);
224 :
225 1 : assert_int_equal(type, sss_authtok_get_type(ts->authtoken));
226 1 : assert_int_equal(EOK, sss_authtok_get_size(ts->authtoken));
227 1 : assert_null(sss_authtok_get_data(ts->authtoken));
228 :
229 1 : ret = sss_authtok_get_password(ts->authtoken, &pwd, &ret_len);
230 :
231 1 : assert_int_equal(ret, ENOENT);
232 :
233 1 : ret = sss_authtok_get_ccfile(ts->authtoken, &pwd, &ret_len);
234 :
235 1 : assert_int_equal(ret, ENOENT);
236 1 : }
237 :
238 1 : static void test_sss_authtok_wipe_password(void **state)
239 : {
240 : size_t len;
241 : errno_t ret;
242 : char *data;
243 : size_t ret_len;
244 : const char *pwd;
245 : struct test_state *ts;
246 : enum sss_authtok_type type;
247 :
248 1 : ts = talloc_get_type_abort(*state, struct test_state);
249 1 : data = talloc_strdup(ts, "password");
250 1 : assert_non_null(data);
251 :
252 1 : len = strlen(data) + 1;
253 1 : type = SSS_AUTHTOK_TYPE_PASSWORD;
254 1 : ret = sss_authtok_set(ts->authtoken, type, (const uint8_t *)data, len);
255 :
256 1 : assert_int_equal(ret, EOK);
257 :
258 1 : sss_authtok_wipe_password(ts->authtoken);
259 :
260 1 : ret = sss_authtok_get_password(ts->authtoken, &pwd, &ret_len);
261 :
262 1 : assert_int_equal(ret, EOK);
263 1 : assert_string_equal(pwd, "");
264 1 : assert_int_equal(len - 1, ret_len);
265 :
266 1 : sss_authtok_set_empty(ts->authtoken);
267 1 : talloc_free(data);
268 1 : }
269 :
270 1 : static void test_sss_authtok_copy(void **state)
271 : {
272 : size_t len;
273 : errno_t ret;
274 : char *data;
275 : struct test_state *ts;
276 : enum sss_authtok_type type;
277 : struct sss_auth_token *dest_authtoken;
278 :
279 1 : ts= talloc_get_type_abort(*state, struct test_state);
280 :
281 1 : dest_authtoken = sss_authtok_new(ts);
282 1 : assert_non_null(dest_authtoken);
283 :
284 1 : data = talloc_strdup(ts, "password");
285 1 : assert_non_null(data);
286 :
287 1 : len = strlen(data) + 1;
288 1 : type = SSS_AUTHTOK_TYPE_EMPTY;
289 1 : ret = sss_authtok_set(ts->authtoken, type, (const uint8_t *)data, len);
290 :
291 1 : assert_int_equal(ret, EOK);
292 1 : assert_int_equal(EOK, sss_authtok_copy(ts->authtoken, dest_authtoken));
293 1 : assert_int_equal(type, sss_authtok_get_type(dest_authtoken));
294 :
295 1 : sss_authtok_set_empty(dest_authtoken);
296 1 : type = SSS_AUTHTOK_TYPE_PASSWORD;
297 1 : ret = sss_authtok_set(ts->authtoken, type, (const uint8_t *)data, len);
298 :
299 1 : assert_int_equal(ret, EOK);
300 :
301 1 : ret = sss_authtok_copy(ts->authtoken, dest_authtoken);
302 :
303 1 : assert_int_equal(ret, EOK);
304 1 : assert_int_equal(type, sss_authtok_get_type(dest_authtoken));
305 1 : assert_string_equal(data, sss_authtok_get_data(dest_authtoken));
306 1 : assert_int_equal(len, sss_authtok_get_size(dest_authtoken));
307 :
308 1 : sss_authtok_set_empty(dest_authtoken);
309 1 : talloc_free(dest_authtoken);
310 1 : sss_authtok_set_empty(ts->authtoken);
311 1 : talloc_free(data);
312 1 : }
313 :
314 1 : void test_sss_authtok_2fa(void **state)
315 : {
316 : int ret;
317 : const char *fa1;
318 : size_t fa1_size;
319 : const char *fa2;
320 : size_t fa2_size;
321 : struct test_state *ts;
322 :
323 1 : ts = talloc_get_type_abort(*state, struct test_state);
324 :
325 1 : ret = sss_authtok_set_2fa(NULL, "a", 0, "b", 0);
326 1 : assert_int_equal(ret, EINVAL);
327 :
328 : /* Test missing first factor */
329 1 : ret = sss_authtok_set_2fa(ts->authtoken, NULL, 1, "b", 1);
330 1 : assert_int_equal(ret, EINVAL);
331 : /* Test missing second factor */
332 1 : ret = sss_authtok_set_2fa(ts->authtoken, "a", 1, NULL, 1);
333 1 : assert_int_equal(ret, EINVAL);
334 : /* Test wrong first factor length */
335 1 : ret = sss_authtok_set_2fa(ts->authtoken, "ab", 1, "b", 1);
336 1 : assert_int_equal(ret, EINVAL);
337 : /* Test wrong second factor length */
338 1 : ret = sss_authtok_set_2fa(ts->authtoken, "a", 1, "bc", 1);
339 1 : assert_int_equal(ret, EINVAL);
340 :
341 1 : ret = sss_authtok_set_2fa(ts->authtoken, "a", 1, "bc", 2);
342 1 : assert_int_equal(ret, EOK);
343 1 : assert_int_equal(sss_authtok_get_size(ts->authtoken),
344 : 2 * sizeof(uint32_t) + 5);
345 1 : assert_int_equal(sss_authtok_get_type(ts->authtoken), SSS_AUTHTOK_TYPE_2FA);
346 : #if __BYTE_ORDER == __LITTLE_ENDIAN
347 1 : assert_memory_equal(sss_authtok_get_data(ts->authtoken),
348 : "\2\0\0\0\3\0\0\0a\0bc\0",
349 : 2 * sizeof(uint32_t) + 5);
350 : #else
351 : assert_memory_equal(sss_authtok_get_data(ts->authtoken),
352 : "\0\0\0\2\0\0\0\3a\0bc\0",
353 : 2 * sizeof(uint32_t) + 5);
354 : #endif
355 :
356 1 : ret = sss_authtok_get_2fa(ts->authtoken, &fa1, &fa1_size, &fa2, &fa2_size);
357 1 : assert_int_equal(ret, EOK);
358 1 : assert_int_equal(fa1_size, 1);
359 1 : assert_string_equal(fa1, "a");
360 1 : assert_int_equal(fa2_size, 2);
361 1 : assert_string_equal(fa2, "bc");
362 :
363 1 : sss_authtok_set_empty(ts->authtoken);
364 :
365 : /* check return code of empty token */
366 1 : ret = sss_authtok_get_2fa(ts->authtoken, &fa1, &fa1_size, &fa2, &fa2_size);
367 1 : assert_int_equal(ret, ENOENT);
368 :
369 : /* check return code for other token type */
370 1 : ret = sss_authtok_set_password(ts->authtoken, "abc", 0);
371 1 : assert_int_equal(ret, EOK);
372 :
373 1 : ret = sss_authtok_get_2fa(ts->authtoken, &fa1, &fa1_size, &fa2, &fa2_size);
374 1 : assert_int_equal(ret, EACCES);
375 :
376 1 : sss_authtok_set_empty(ts->authtoken);
377 :
378 : /* check return code for garbage */
379 1 : ret = sss_authtok_set(ts->authtoken, SSS_AUTHTOK_TYPE_2FA,
380 : (const uint8_t *) "1111222233334444", 16);
381 1 : assert_int_equal(ret, EINVAL);
382 :
383 1 : sss_authtok_set_empty(ts->authtoken);
384 1 : }
385 :
386 1 : void test_sss_authtok_2fa_blobs(void **state)
387 : {
388 : int ret;
389 : struct test_state *ts;
390 : size_t needed_size;
391 : uint8_t *buf;
392 : char *fa1;
393 : size_t fa1_len;
394 : char *fa2;
395 : size_t fa2_len;
396 :
397 1 : ts = talloc_get_type_abort(*state, struct test_state);
398 :
399 1 : ret = sss_auth_pack_2fa_blob(NULL, 0, "defg", 0, NULL, 0, &needed_size);
400 1 : assert_int_equal(ret, EINVAL);
401 :
402 1 : ret = sss_auth_pack_2fa_blob("abc", 0, NULL, 0, NULL, 0, &needed_size);
403 1 : assert_int_equal(ret, EINVAL);
404 :
405 1 : ret = sss_auth_pack_2fa_blob("", 0, "defg", 0, NULL, 0, &needed_size);
406 1 : assert_int_equal(ret, EINVAL);
407 :
408 1 : ret = sss_auth_pack_2fa_blob("abc", 0, "", 0, NULL, 0, &needed_size);
409 1 : assert_int_equal(ret, EINVAL);
410 :
411 1 : ret = sss_auth_pack_2fa_blob("abc", 0, "defg", 0, NULL, 0, &needed_size);
412 1 : assert_int_equal(ret, EAGAIN);
413 :
414 1 : buf = talloc_size(ts, needed_size);
415 1 : assert_non_null(buf);
416 :
417 1 : ret = sss_auth_pack_2fa_blob("abc", 0, "defg", 0, buf, needed_size,
418 : &needed_size);
419 1 : assert_int_equal(ret, EOK);
420 :
421 : #if __BYTE_ORDER == __LITTLE_ENDIAN
422 1 : assert_memory_equal(buf, "\4\0\0\0\5\0\0\0abc\0defg\0", needed_size);
423 : #else
424 : assert_memory_equal(buf, "\0\0\0\4\0\0\0\5abc\0defg\0", needed_size);
425 : #endif
426 :
427 1 : ret = sss_auth_unpack_2fa_blob(ts, buf, needed_size, &fa1, &fa1_len, &fa2,
428 : &fa2_len);
429 1 : assert_int_equal(ret, EOK);
430 1 : assert_int_equal(fa1_len, 3);
431 1 : assert_string_equal(fa1, "abc");
432 1 : assert_int_equal(fa2_len, 4);
433 1 : assert_string_equal(fa2, "defg");
434 :
435 1 : talloc_free(buf);
436 1 : talloc_free(fa1);
437 1 : talloc_free(fa2);
438 1 : }
439 :
440 : #define MISSING_NULL_CHECK do { \
441 : assert_int_equal(ret, EOK); \
442 : assert_int_equal(fa1_len, 3); \
443 : assert_string_equal(fa1, "abc"); \
444 : assert_int_equal(fa2_len, 4); \
445 : assert_string_equal(fa2, "defg"); \
446 : \
447 : talloc_free(fa1); \
448 : talloc_free(fa2); \
449 : } while (0)
450 :
451 1 : void test_sss_authtok_2fa_blobs_missing_null(void **state)
452 : {
453 : int ret;
454 : struct test_state *ts;
455 : char *fa1;
456 : size_t fa1_len;
457 : char *fa2;
458 : size_t fa2_len;
459 : #if __BYTE_ORDER == __LITTLE_ENDIAN
460 1 : uint8_t b0[] = {0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 'a', 'b', 'c', 0x00, 'd', 'e', 'f', 'g', 0x00};
461 1 : uint8_t b1[] = {0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 0x00};
462 1 : uint8_t b2[] = {0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 'a', 'b', 'c', 0x00, 'd', 'e', 'f', 'g'};
463 1 : uint8_t b3[] = {0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 'a', 'b', 'c', 'd', 'e', 'f', 'g'};
464 : #else
465 : uint8_t b0[] = {0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 'a', 'b', 'c', 0x00, 'd', 'e', 'f', 'g', 0x00};
466 : uint8_t b1[] = {0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 0x00};
467 : uint8_t b2[] = {0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 'a', 'b', 'c', 0x00, 'd', 'e', 'f', 'g'};
468 : uint8_t b3[] = {0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 'a', 'b', 'c', 'd', 'e', 'f', 'g'};
469 : #endif
470 :
471 :
472 1 : ts = talloc_get_type_abort(*state, struct test_state);
473 :
474 1 : ret = sss_auth_unpack_2fa_blob(ts, b0, sizeof(b0), &fa1, &fa1_len, &fa2,
475 : &fa2_len);
476 1 : MISSING_NULL_CHECK;
477 :
478 1 : ret = sss_auth_unpack_2fa_blob(ts, b1, sizeof(b1), &fa1, &fa1_len, &fa2,
479 : &fa2_len);
480 1 : MISSING_NULL_CHECK;
481 :
482 1 : ret = sss_auth_unpack_2fa_blob(ts, b2, sizeof(b2), &fa1, &fa1_len, &fa2,
483 : &fa2_len);
484 1 : MISSING_NULL_CHECK;
485 :
486 1 : ret = sss_auth_unpack_2fa_blob(ts, b3, sizeof(b3), &fa1, &fa1_len, &fa2,
487 : &fa2_len);
488 1 : MISSING_NULL_CHECK;
489 1 : }
490 :
491 1 : void test_sss_authtok_sc_keypad(void **state)
492 : {
493 : struct test_state *ts;
494 :
495 1 : ts = talloc_get_type_abort(*state, struct test_state);
496 :
497 1 : sss_authtok_set_sc_keypad(NULL);
498 :
499 1 : sss_authtok_set_sc_keypad(ts->authtoken);
500 1 : assert_int_equal(sss_authtok_get_type(ts->authtoken),
501 : SSS_AUTHTOK_TYPE_SC_KEYPAD);
502 1 : assert_int_equal(sss_authtok_get_size(ts->authtoken), 0);
503 1 : assert_null(sss_authtok_get_data(ts->authtoken));
504 1 : }
505 :
506 1 : void test_sss_authtok_sc_pin(void **state)
507 : {
508 : struct test_state *ts;
509 : int ret;
510 : size_t size;
511 : const char *pin;
512 : size_t len;
513 :
514 1 : ts = talloc_get_type_abort(*state, struct test_state);
515 :
516 1 : ret = sss_authtok_set_sc_pin(NULL, NULL, 0);
517 1 : assert_int_equal(ret, EFAULT);
518 :
519 1 : ret = sss_authtok_set_sc_pin(ts->authtoken, NULL, 0);
520 1 : assert_int_equal(ret, EINVAL);
521 :
522 1 : ret = sss_authtok_set_sc_pin(ts->authtoken, "12345678", 0);
523 1 : assert_int_equal(ret, EOK);
524 1 : assert_int_equal(sss_authtok_get_type(ts->authtoken),
525 : SSS_AUTHTOK_TYPE_SC_PIN);
526 1 : size = sss_authtok_get_size(ts->authtoken);
527 1 : assert_int_equal(size, 9);
528 1 : assert_memory_equal(sss_authtok_get_data(ts->authtoken), "12345678\0",
529 : size);
530 :
531 1 : ret = sss_authtok_set_sc_pin(ts->authtoken, "12345678", 5);
532 1 : assert_int_equal(ret, EOK);
533 1 : assert_int_equal(sss_authtok_get_type(ts->authtoken),
534 : SSS_AUTHTOK_TYPE_SC_PIN);
535 1 : size = sss_authtok_get_size(ts->authtoken);
536 1 : assert_int_equal(size, 6);
537 1 : assert_memory_equal(sss_authtok_get_data(ts->authtoken), "12345\0",
538 : size);
539 :
540 1 : ret = sss_authtok_get_sc_pin(ts->authtoken, &pin, &len);
541 1 : assert_int_equal(ret, EOK);
542 1 : assert_int_equal(len, 5);
543 1 : assert_string_equal(pin, "12345");
544 :
545 1 : sss_authtok_set_empty(ts->authtoken);
546 :
547 1 : ret = sss_authtok_get_sc_pin(ts->authtoken, &pin, &len);
548 1 : assert_int_equal(ret, ENOENT);
549 :
550 1 : ret = sss_authtok_set_password(ts->authtoken, "12345", 0);
551 1 : assert_int_equal(ret, EOK);
552 :
553 1 : ret = sss_authtok_get_sc_pin(ts->authtoken, &pin, &len);
554 1 : assert_int_equal(ret, EACCES);
555 :
556 1 : sss_authtok_set_empty(ts->authtoken);
557 :
558 1 : ret = sss_authtok_get_sc_pin(NULL, &pin, &len);
559 1 : assert_int_equal(ret, EFAULT);
560 1 : }
561 :
562 1 : int main(int argc, const char *argv[])
563 : {
564 : poptContext pc;
565 : int opt;
566 6 : struct poptOption long_options[] = {
567 : POPT_AUTOHELP
568 5 : SSSD_DEBUG_OPTS
569 : POPT_TABLEEND
570 : };
571 :
572 1 : const struct CMUnitTest tests[] = {
573 : cmocka_unit_test_setup_teardown(test_sss_authtok_new,
574 : setup, teardown),
575 : cmocka_unit_test_setup_teardown(test_sss_authtok_password,
576 : setup, teardown),
577 : cmocka_unit_test_setup_teardown(test_sss_authtok_ccfile,
578 : setup, teardown),
579 : cmocka_unit_test_setup_teardown(test_sss_authtok_empty,
580 : setup, teardown),
581 : cmocka_unit_test_setup_teardown(test_sss_authtok_wipe_password,
582 : setup, teardown),
583 : cmocka_unit_test_setup_teardown(test_sss_authtok_copy,
584 : setup, teardown),
585 : cmocka_unit_test_setup_teardown(test_sss_authtok_2fa,
586 : setup, teardown),
587 : cmocka_unit_test_setup_teardown(test_sss_authtok_2fa_blobs,
588 : setup, teardown),
589 : cmocka_unit_test_setup_teardown(test_sss_authtok_2fa_blobs_missing_null,
590 : setup, teardown),
591 : cmocka_unit_test_setup_teardown(test_sss_authtok_sc_keypad,
592 : setup, teardown),
593 : cmocka_unit_test_setup_teardown(test_sss_authtok_sc_pin,
594 : setup, teardown),
595 : };
596 :
597 : /* Set debug level to invalid value so we can deside if -d 0 was used. */
598 1 : debug_level = SSSDBG_INVALID;
599 :
600 1 : pc = poptGetContext(argv[0], argc, argv, long_options, 0);
601 1 : while((opt = poptGetNextOpt(pc)) != -1) {
602 : switch(opt) {
603 : default:
604 0 : fprintf(stderr, "\nInvalid option %s: %s\n\n",
605 : poptBadOption(pc, 0), poptStrerror(opt));
606 0 : poptPrintUsage(pc, stderr, 0);
607 0 : return 1;
608 : }
609 : }
610 1 : poptFreeContext(pc);
611 :
612 1 : DEBUG_CLI_INIT(debug_level);
613 :
614 1 : return cmocka_run_group_tests(tests, NULL, NULL);
615 : }
|
