1 /*
2 * Copyright (c) 2014 Jerry Lundström <lundstrom.jerry@gmail.com>
3 * Copyright (c) 2014 .SE (The Internet Infrastructure Foundation).
4 * Copyright (c) 2014 OpenDNSSEC AB (svb)
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
22 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
24 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30 #include "CUnit/Basic.h"
31
32 #include "../db_configuration.h"
33 #include "../db_connection.h"
34 #include "../hsm_key.h"
35
36 #include <string.h>
37
38 static db_configuration_list_t* configuration_list = NULL;
39 static db_configuration_t* configuration = NULL;
40 static db_connection_t* connection = NULL;
41
42 static hsm_key_t* object = NULL;
43 static hsm_key_list_t* object_list = NULL;
44 static db_value_t id = DB_VALUE_EMPTY;
45 static db_clause_list_t* clause_list = NULL;
46
47 static int db_sqlite = 0;
48 static int db_mysql = 0;
49
50 #if defined(ENFORCER_DATABASE_SQLITE3)
test_hsm_key_init_suite_sqlite(void)51 int test_hsm_key_init_suite_sqlite(void) {
52 if (configuration_list) {
53 return 1;
54 }
55 if (configuration) {
56 return 1;
57 }
58 if (connection) {
59 return 1;
60 }
61
62 /*
63 * Setup the configuration for the connection
64 */
65 if (!(configuration_list = db_configuration_list_new())) {
66 return 1;
67 }
68 if (!(configuration = db_configuration_new())
69 || db_configuration_set_name(configuration, "backend")
70 || db_configuration_set_value(configuration, "sqlite")
71 || db_configuration_list_add(configuration_list, configuration))
72 {
73 db_configuration_free(configuration);
74 configuration = NULL;
75 db_configuration_list_free(configuration_list);
76 configuration_list = NULL;
77 return 1;
78 }
79 configuration = NULL;
80 if (!(configuration = db_configuration_new())
81 || db_configuration_set_name(configuration, "file")
82 || db_configuration_set_value(configuration, "test.db")
83 || db_configuration_list_add(configuration_list, configuration))
84 {
85 db_configuration_free(configuration);
86 configuration = NULL;
87 db_configuration_list_free(configuration_list);
88 configuration_list = NULL;
89 return 1;
90 }
91 configuration = NULL;
92
93 /*
94 * Connect to the database
95 */
96 if (!(connection = db_connection_new())
97 || db_connection_set_configuration_list(connection, configuration_list))
98 {
99 db_connection_free(connection);
100 connection = NULL;
101 db_configuration_list_free(configuration_list);
102 configuration_list = NULL;
103 return 1;
104 }
105 configuration_list = NULL;
106
107 if (db_connection_setup(connection)
108 || db_connection_connect(connection))
109 {
110 db_connection_free(connection);
111 connection = NULL;
112 return 1;
113 }
114
115 db_sqlite = 1;
116 db_mysql = 0;
117
118 return 0;
119 }
120 #endif
121
122 #if defined(ENFORCER_DATABASE_MYSQL)
test_hsm_key_init_suite_mysql(void)123 int test_hsm_key_init_suite_mysql(void) {
124 if (configuration_list) {
125 return 1;
126 }
127 if (configuration) {
128 return 1;
129 }
130 if (connection) {
131 return 1;
132 }
133
134 /*
135 * Setup the configuration for the connection
136 */
137 if (!(configuration_list = db_configuration_list_new())) {
138 return 1;
139 }
140 if (!(configuration = db_configuration_new())
141 || db_configuration_set_name(configuration, "backend")
142 || db_configuration_set_value(configuration, "mysql")
143 || db_configuration_list_add(configuration_list, configuration))
144 {
145 db_configuration_free(configuration);
146 configuration = NULL;
147 db_configuration_list_free(configuration_list);
148 configuration_list = NULL;
149 return 1;
150 }
151 configuration = NULL;
152 if (!(configuration = db_configuration_new())
153 || db_configuration_set_name(configuration, "host")
154 || db_configuration_set_value(configuration, ENFORCER_DB_HOST)
155 || db_configuration_list_add(configuration_list, configuration))
156 {
157 db_configuration_free(configuration);
158 configuration = NULL;
159 db_configuration_list_free(configuration_list);
160 configuration_list = NULL;
161 return 1;
162 }
163 configuration = NULL;
164 if (!(configuration = db_configuration_new())
165 || db_configuration_set_name(configuration, "port")
166 || db_configuration_set_value(configuration, ENFORCER_DB_PORT_TEXT)
167 || db_configuration_list_add(configuration_list, configuration))
168 {
169 db_configuration_free(configuration);
170 configuration = NULL;
171 db_configuration_list_free(configuration_list);
172 configuration_list = NULL;
173 return 1;
174 }
175 configuration = NULL;
176 if (!(configuration = db_configuration_new())
177 || db_configuration_set_name(configuration, "user")
178 || db_configuration_set_value(configuration, ENFORCER_DB_USERNAME)
179 || db_configuration_list_add(configuration_list, configuration))
180 {
181 db_configuration_free(configuration);
182 configuration = NULL;
183 db_configuration_list_free(configuration_list);
184 configuration_list = NULL;
185 return 1;
186 }
187 configuration = NULL;
188 if (!(configuration = db_configuration_new())
189 || db_configuration_set_name(configuration, "pass")
190 || db_configuration_set_value(configuration, ENFORCER_DB_PASSWORD)
191 || db_configuration_list_add(configuration_list, configuration))
192 {
193 db_configuration_free(configuration);
194 configuration = NULL;
195 db_configuration_list_free(configuration_list);
196 configuration_list = NULL;
197 return 1;
198 }
199 configuration = NULL;
200 if (!(configuration = db_configuration_new())
201 || db_configuration_set_name(configuration, "db")
202 || db_configuration_set_value(configuration, ENFORCER_DB_DATABASE)
203 || db_configuration_list_add(configuration_list, configuration))
204 {
205 db_configuration_free(configuration);
206 configuration = NULL;
207 db_configuration_list_free(configuration_list);
208 configuration_list = NULL;
209 return 1;
210 }
211 configuration = NULL;
212
213 /*
214 * Connect to the database
215 */
216 if (!(connection = db_connection_new())
217 || db_connection_set_configuration_list(connection, configuration_list))
218 {
219 db_connection_free(connection);
220 connection = NULL;
221 db_configuration_list_free(configuration_list);
222 configuration_list = NULL;
223 return 1;
224 }
225 configuration_list = NULL;
226
227 if (db_connection_setup(connection)
228 || db_connection_connect(connection))
229 {
230 db_connection_free(connection);
231 connection = NULL;
232 return 1;
233 }
234
235 db_sqlite = 0;
236 db_mysql = 1;
237
238 return 0;
239 }
240 #endif
241
test_hsm_key_clean_suite(void)242 static int test_hsm_key_clean_suite(void) {
243 db_connection_free(connection);
244 connection = NULL;
245 db_configuration_free(configuration);
246 configuration = NULL;
247 db_configuration_list_free(configuration_list);
248 configuration_list = NULL;
249 db_value_reset(&id);
250 db_clause_list_free(clause_list);
251 clause_list = NULL;
252 return 0;
253 }
254
test_hsm_key_new(void)255 static void test_hsm_key_new(void) {
256 CU_ASSERT_PTR_NOT_NULL_FATAL((object = hsm_key_new(connection)));
257 CU_ASSERT_PTR_NOT_NULL_FATAL((object_list = hsm_key_list_new(connection)));
258 }
259
test_hsm_key_set(void)260 static void test_hsm_key_set(void) {
261 db_value_t policy_id = DB_VALUE_EMPTY;
262 if (db_sqlite) {
263 CU_ASSERT(!db_value_from_int32(&policy_id, 1));
264 }
265 if (db_mysql) {
266 CU_ASSERT(!db_value_from_uint64(&policy_id, 1));
267 }
268 CU_ASSERT(!hsm_key_set_policy_id(object, &policy_id));
269 CU_ASSERT(!hsm_key_set_locator(object, "locator 1"));
270 CU_ASSERT(!hsm_key_set_state(object, HSM_KEY_STATE_UNUSED));
271 CU_ASSERT(!hsm_key_set_state(object, HSM_KEY_STATE_PRIVATE));
272 CU_ASSERT(!hsm_key_set_state(object, HSM_KEY_STATE_SHARED));
273 CU_ASSERT(!hsm_key_set_state(object, HSM_KEY_STATE_DELETE));
274 CU_ASSERT(!hsm_key_set_bits(object, 1));
275 CU_ASSERT(!hsm_key_set_algorithm(object, 1));
276 CU_ASSERT(!hsm_key_set_role(object, HSM_KEY_ROLE_KSK));
277 CU_ASSERT(!hsm_key_set_role(object, HSM_KEY_ROLE_ZSK));
278 CU_ASSERT(!hsm_key_set_role(object, HSM_KEY_ROLE_CSK));
279 CU_ASSERT(!hsm_key_set_inception(object, 1));
280 CU_ASSERT(!hsm_key_set_key_type(object, HSM_KEY_KEY_TYPE_RSA));
281 CU_ASSERT(!hsm_key_set_repository(object, "repository 1"));
282 CU_ASSERT(!hsm_key_set_backup(object, HSM_KEY_BACKUP_NO_BACKUP));
283 CU_ASSERT(!hsm_key_set_backup(object, HSM_KEY_BACKUP_BACKUP_REQUIRED));
284 CU_ASSERT(!hsm_key_set_backup(object, HSM_KEY_BACKUP_BACKUP_REQUESTED));
285 CU_ASSERT(!hsm_key_set_backup(object, HSM_KEY_BACKUP_BACKUP_DONE));
286 db_value_reset(&policy_id);
287 }
288
test_hsm_key_get(void)289 static void test_hsm_key_get(void) {
290 int ret;
291 db_value_t policy_id = DB_VALUE_EMPTY;
292 if (db_sqlite) {
293 CU_ASSERT(!db_value_from_int32(&policy_id, 1));
294 }
295 if (db_mysql) {
296 CU_ASSERT(!db_value_from_uint64(&policy_id, 1));
297 }
298 CU_ASSERT(!db_value_cmp(hsm_key_policy_id(object), &policy_id, &ret));
299 CU_ASSERT(!ret);
300 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_locator(object));
301 CU_ASSERT(!strcmp(hsm_key_locator(object), "locator 1"));
302 CU_ASSERT(hsm_key_state(object) == HSM_KEY_STATE_DELETE);
303 CU_ASSERT(hsm_key_bits(object) == 1);
304 CU_ASSERT(hsm_key_algorithm(object) == 1);
305 CU_ASSERT(hsm_key_role(object) == HSM_KEY_ROLE_CSK);
306 CU_ASSERT(hsm_key_inception(object) == 1);
307 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_repository(object));
308 CU_ASSERT(!strcmp(hsm_key_repository(object), "repository 1"));
309 CU_ASSERT(hsm_key_backup(object) == HSM_KEY_BACKUP_BACKUP_DONE);
310 db_value_reset(&policy_id);
311 }
312
test_hsm_key_create(void)313 static void test_hsm_key_create(void) {
314 CU_ASSERT_FATAL(!hsm_key_create(object));
315 }
316
test_hsm_key_clauses(void)317 static void test_hsm_key_clauses(void) {
318 hsm_key_list_t* new_list;
319
320 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
321 CU_ASSERT_PTR_NOT_NULL(hsm_key_policy_id_clause(clause_list, hsm_key_policy_id(object)));
322 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
323 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
324 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
325 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
326 hsm_key_list_free(new_list);
327 db_clause_list_free(clause_list);
328 clause_list = NULL;
329
330 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
331 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
332 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
333 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
334 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
335 hsm_key_list_free(new_list);
336 db_clause_list_free(clause_list);
337 clause_list = NULL;
338
339 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
340 CU_ASSERT_PTR_NOT_NULL(hsm_key_state_clause(clause_list, hsm_key_state(object)));
341 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
342 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
343 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
344 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
345 hsm_key_list_free(new_list);
346 db_clause_list_free(clause_list);
347 clause_list = NULL;
348
349 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
350 CU_ASSERT_PTR_NOT_NULL(hsm_key_bits_clause(clause_list, hsm_key_bits(object)));
351 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
352 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
353 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
354 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
355 hsm_key_list_free(new_list);
356 db_clause_list_free(clause_list);
357 clause_list = NULL;
358
359 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
360 CU_ASSERT_PTR_NOT_NULL(hsm_key_algorithm_clause(clause_list, hsm_key_algorithm(object)));
361 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
362 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
363 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
364 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
365 hsm_key_list_free(new_list);
366 db_clause_list_free(clause_list);
367 clause_list = NULL;
368
369 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
370 CU_ASSERT_PTR_NOT_NULL(hsm_key_role_clause(clause_list, hsm_key_role(object)));
371 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
372 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
373 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
374 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
375 hsm_key_list_free(new_list);
376 db_clause_list_free(clause_list);
377 clause_list = NULL;
378
379 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
380 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
381 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
382 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
383 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
384 hsm_key_list_free(new_list);
385 db_clause_list_free(clause_list);
386 clause_list = NULL;
387
388 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
389 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
390 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
391 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
392 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
393 hsm_key_list_free(new_list);
394 db_clause_list_free(clause_list);
395 clause_list = NULL;
396
397 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
398 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
399 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
400 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
401 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
402 hsm_key_list_free(new_list);
403 db_clause_list_free(clause_list);
404 clause_list = NULL;
405
406 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
407 CU_ASSERT_PTR_NOT_NULL(hsm_key_repository_clause(clause_list, hsm_key_repository(object)));
408 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
409 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
410 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
411 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
412 hsm_key_list_free(new_list);
413 db_clause_list_free(clause_list);
414 clause_list = NULL;
415
416 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
417 CU_ASSERT_PTR_NOT_NULL(hsm_key_backup_clause(clause_list, hsm_key_backup(object)));
418 CU_ASSERT(!hsm_key_list_get_by_clauses(object_list, clause_list));
419 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(object_list));
420 CU_ASSERT_PTR_NOT_NULL((new_list = hsm_key_list_new_get_by_clauses(connection, clause_list)));
421 CU_ASSERT_PTR_NOT_NULL(hsm_key_list_next(new_list));
422 hsm_key_list_free(new_list);
423 db_clause_list_free(clause_list);
424 clause_list = NULL;
425 }
426
test_hsm_key_count(void)427 static void test_hsm_key_count(void) {
428 size_t count;
429
430 CU_ASSERT(!hsm_key_count(object, NULL, &count));
431 CU_ASSERT(count == 1);
432
433 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
434 CU_ASSERT_PTR_NOT_NULL(hsm_key_policy_id_clause(clause_list, hsm_key_policy_id(object)));
435 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
436 CU_ASSERT(count == 1);
437 db_clause_list_free(clause_list);
438 clause_list = NULL;
439
440 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
441 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
442 CU_ASSERT(count == 1);
443 db_clause_list_free(clause_list);
444 clause_list = NULL;
445
446 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
447 CU_ASSERT_PTR_NOT_NULL(hsm_key_state_clause(clause_list, hsm_key_state(object)));
448 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
449 CU_ASSERT(count == 1);
450 db_clause_list_free(clause_list);
451 clause_list = NULL;
452
453 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
454 CU_ASSERT_PTR_NOT_NULL(hsm_key_bits_clause(clause_list, hsm_key_bits(object)));
455 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
456 CU_ASSERT(count == 1);
457 db_clause_list_free(clause_list);
458 clause_list = NULL;
459
460 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
461 CU_ASSERT_PTR_NOT_NULL(hsm_key_algorithm_clause(clause_list, hsm_key_algorithm(object)));
462 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
463 CU_ASSERT(count == 1);
464 db_clause_list_free(clause_list);
465 clause_list = NULL;
466
467 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
468 CU_ASSERT_PTR_NOT_NULL(hsm_key_role_clause(clause_list, hsm_key_role(object)));
469 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
470 CU_ASSERT(count == 1);
471 db_clause_list_free(clause_list);
472 clause_list = NULL;
473
474 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
475 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
476 CU_ASSERT(count == 1);
477 db_clause_list_free(clause_list);
478 clause_list = NULL;
479
480 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
481 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
482 CU_ASSERT(count == 1);
483 db_clause_list_free(clause_list);
484 clause_list = NULL;
485
486 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
487 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
488 CU_ASSERT(count == 1);
489 db_clause_list_free(clause_list);
490 clause_list = NULL;
491
492 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
493 CU_ASSERT_PTR_NOT_NULL(hsm_key_repository_clause(clause_list, hsm_key_repository(object)));
494 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
495 CU_ASSERT(count == 1);
496 db_clause_list_free(clause_list);
497 clause_list = NULL;
498
499 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
500 CU_ASSERT_PTR_NOT_NULL(hsm_key_backup_clause(clause_list, hsm_key_backup(object)));
501 CU_ASSERT(!hsm_key_count(object, clause_list, &count));
502 CU_ASSERT(count == 1);
503 db_clause_list_free(clause_list);
504 clause_list = NULL;
505 }
506
test_hsm_key_verify(void)507 static void test_hsm_key_verify(void) {
508 int ret;
509 db_value_t policy_id = DB_VALUE_EMPTY;
510 if (db_sqlite) {
511 CU_ASSERT(!db_value_from_int32(&policy_id, 1));
512 }
513 if (db_mysql) {
514 CU_ASSERT(!db_value_from_uint64(&policy_id, 1));
515 }
516 CU_ASSERT(!db_value_cmp(hsm_key_policy_id(object), &policy_id, &ret));
517 CU_ASSERT(!ret);
518 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_locator(object));
519 CU_ASSERT(!strcmp(hsm_key_locator(object), "locator 1"));
520 CU_ASSERT(hsm_key_state(object) == HSM_KEY_STATE_DELETE);
521 CU_ASSERT(hsm_key_bits(object) == 1);
522 CU_ASSERT(hsm_key_algorithm(object) == 1);
523 CU_ASSERT(hsm_key_role(object) == HSM_KEY_ROLE_CSK);
524 CU_ASSERT(hsm_key_inception(object) == 1);
525 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_repository(object));
526 CU_ASSERT(!strcmp(hsm_key_repository(object), "repository 1"));
527 CU_ASSERT(hsm_key_backup(object) == HSM_KEY_BACKUP_BACKUP_DONE);
528 db_value_reset(&policy_id);
529 }
530
test_hsm_key_read_by_locator(void)531 static void test_hsm_key_read_by_locator(void) {
532 CU_ASSERT_FATAL(!hsm_key_get_by_locator(object, "locator 1"));
533 }
534
test_hsm_key_verify_locator(void)535 static void test_hsm_key_verify_locator(void) {
536 int ret;
537 db_value_t policy_id = DB_VALUE_EMPTY;
538 if (db_sqlite) {
539 CU_ASSERT(!db_value_from_int32(&policy_id, 1));
540 }
541 if (db_mysql) {
542 CU_ASSERT(!db_value_from_uint64(&policy_id, 1));
543 }
544 CU_ASSERT(!db_value_cmp(hsm_key_policy_id(object), &policy_id, &ret));
545 CU_ASSERT(!ret);
546 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_locator(object));
547 CU_ASSERT(!strcmp(hsm_key_locator(object), "locator 1"));
548 CU_ASSERT(hsm_key_state(object) == HSM_KEY_STATE_DELETE);
549 CU_ASSERT(hsm_key_bits(object) == 1);
550 CU_ASSERT(hsm_key_algorithm(object) == 1);
551 CU_ASSERT(hsm_key_role(object) == HSM_KEY_ROLE_CSK);
552 CU_ASSERT(hsm_key_inception(object) == 1);
553 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_repository(object));
554 CU_ASSERT(!strcmp(hsm_key_repository(object), "repository 1"));
555 CU_ASSERT(hsm_key_backup(object) == HSM_KEY_BACKUP_BACKUP_DONE);
556 db_value_reset(&policy_id);
557 }
558
test_hsm_key_change(void)559 static void test_hsm_key_change(void) {
560 db_value_t policy_id = DB_VALUE_EMPTY;
561 if (db_sqlite) {
562 CU_ASSERT(!db_value_from_int32(&policy_id, 1));
563 }
564 if (db_mysql) {
565 CU_ASSERT(!db_value_from_uint64(&policy_id, 1));
566 }
567 CU_ASSERT(!hsm_key_set_policy_id(object, &policy_id));
568 CU_ASSERT(!hsm_key_set_locator(object, "locator 2"));
569 CU_ASSERT(!hsm_key_set_state(object, HSM_KEY_STATE_UNUSED));
570 CU_ASSERT(!hsm_key_set_bits(object, 2));
571 CU_ASSERT(!hsm_key_set_algorithm(object, 2));
572 CU_ASSERT(!hsm_key_set_role(object, HSM_KEY_ROLE_KSK));
573 CU_ASSERT(!hsm_key_set_inception(object, 2));
574 CU_ASSERT(!hsm_key_set_key_type(object, HSM_KEY_KEY_TYPE_RSA));
575 CU_ASSERT(!hsm_key_set_repository(object, "repository 2"));
576 CU_ASSERT(!hsm_key_set_backup(object, HSM_KEY_BACKUP_NO_BACKUP));
577 db_value_reset(&policy_id);
578 }
579
test_hsm_key_update(void)580 static void test_hsm_key_update(void) {
581 CU_ASSERT_FATAL(!hsm_key_update(object));
582 }
583
test_hsm_key_verify2(void)584 static void test_hsm_key_verify2(void) {
585 int ret;
586 db_value_t policy_id = DB_VALUE_EMPTY;
587 if (db_sqlite) {
588 CU_ASSERT(!db_value_from_int32(&policy_id, 1));
589 }
590 if (db_mysql) {
591 CU_ASSERT(!db_value_from_uint64(&policy_id, 1));
592 }
593 CU_ASSERT(!db_value_cmp(hsm_key_policy_id(object), &policy_id, &ret));
594 CU_ASSERT(!ret);
595 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_locator(object));
596 CU_ASSERT(!strcmp(hsm_key_locator(object), "locator 2"));
597 CU_ASSERT(hsm_key_state(object) == HSM_KEY_STATE_UNUSED);
598 CU_ASSERT(hsm_key_bits(object) == 2);
599 CU_ASSERT(hsm_key_algorithm(object) == 2);
600 CU_ASSERT(hsm_key_role(object) == HSM_KEY_ROLE_KSK);
601 CU_ASSERT(hsm_key_inception(object) == 2);
602 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_repository(object));
603 CU_ASSERT(!strcmp(hsm_key_repository(object), "repository 2"));
604 CU_ASSERT(hsm_key_backup(object) == HSM_KEY_BACKUP_NO_BACKUP);
605 db_value_reset(&policy_id);
606 }
607
test_hsm_key_cmp(void)608 static void test_hsm_key_cmp(void) {
609 hsm_key_t* local_object;
610
611 CU_ASSERT_PTR_NOT_NULL_FATAL((local_object = hsm_key_new(connection)));
612 }
613
test_hsm_key_read_by_locator2(void)614 static void test_hsm_key_read_by_locator2(void) {
615 CU_ASSERT_FATAL(!hsm_key_get_by_locator(object, "locator 2"));
616 }
617
test_hsm_key_verify_locator2(void)618 static void test_hsm_key_verify_locator2(void) {
619 int ret;
620 db_value_t policy_id = DB_VALUE_EMPTY;
621 if (db_sqlite) {
622 CU_ASSERT(!db_value_from_int32(&policy_id, 1));
623 }
624 if (db_mysql) {
625 CU_ASSERT(!db_value_from_uint64(&policy_id, 1));
626 }
627 CU_ASSERT(!db_value_cmp(hsm_key_policy_id(object), &policy_id, &ret));
628 CU_ASSERT(!ret);
629 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_locator(object));
630 CU_ASSERT(!strcmp(hsm_key_locator(object), "locator 2"));
631 CU_ASSERT(hsm_key_state(object) == HSM_KEY_STATE_UNUSED);
632 CU_ASSERT(hsm_key_bits(object) == 2);
633 CU_ASSERT(hsm_key_algorithm(object) == 2);
634 CU_ASSERT(hsm_key_role(object) == HSM_KEY_ROLE_KSK);
635 CU_ASSERT(hsm_key_inception(object) == 2);
636 CU_ASSERT_PTR_NOT_NULL_FATAL(hsm_key_repository(object));
637 CU_ASSERT(!strcmp(hsm_key_repository(object), "repository 2"));
638 CU_ASSERT(hsm_key_backup(object) == HSM_KEY_BACKUP_NO_BACKUP);
639 db_value_reset(&policy_id);
640 }
641
test_hsm_key_delete(void)642 static void test_hsm_key_delete(void) {
643 }
644
test_hsm_key_list2(void)645 static void test_hsm_key_list2(void) {
646 CU_ASSERT_PTR_NULL(hsm_key_list_next(object_list));
647 }
648
test_hsm_key_end(void)649 static void test_hsm_key_end(void) {
650 if (object) {
651 hsm_key_free(object);
652 CU_PASS("hsm_key_free");
653 }
654 if (object_list) {
655 hsm_key_list_free(object_list);
656 CU_PASS("hsm_key_list_free");
657 }
658 }
659
test_hsm_key_add_tests(CU_pSuite pSuite)660 static int test_hsm_key_add_tests(CU_pSuite pSuite) {
661 if (!CU_add_test(pSuite, "new object", test_hsm_key_new)
662 || !CU_add_test(pSuite, "set fields", test_hsm_key_set)
663 || !CU_add_test(pSuite, "get fields", test_hsm_key_get)
664 || !CU_add_test(pSuite, "create object", test_hsm_key_create)
665 || !CU_add_test(pSuite, "object clauses", test_hsm_key_clauses)
666 || !CU_add_test(pSuite, "object count", test_hsm_key_count)
667 || !CU_add_test(pSuite, "verify fields", test_hsm_key_verify)
668 || !CU_add_test(pSuite, "read object by locator", test_hsm_key_read_by_locator)
669 || !CU_add_test(pSuite, "verify fields (locator)", test_hsm_key_verify_locator)
670 || !CU_add_test(pSuite, "change object", test_hsm_key_change)
671 || !CU_add_test(pSuite, "update object", test_hsm_key_update)
672 || !CU_add_test(pSuite, "verify fields after update", test_hsm_key_verify2)
673 || !CU_add_test(pSuite, "compare objects", test_hsm_key_cmp)
674 || !CU_add_test(pSuite, "reread object by locator", test_hsm_key_read_by_locator2)
675 || !CU_add_test(pSuite, "verify fields after update (locator)", test_hsm_key_verify_locator2)
676 || !CU_add_test(pSuite, "delete object", test_hsm_key_delete)
677 || !CU_add_test(pSuite, "list objects to verify delete", test_hsm_key_list2)
678 || !CU_add_test(pSuite, "end test", test_hsm_key_end))
679 {
680 return CU_get_error();
681 }
682 return 0;
683 }
684
test_hsm_key_add_suite(void)685 int test_hsm_key_add_suite(void) {
686 CU_pSuite pSuite = NULL;
687 int ret;
688
689 #if defined(ENFORCER_DATABASE_SQLITE3)
690 pSuite = CU_add_suite("Test of hsm key (SQLite)", test_hsm_key_init_suite_sqlite, test_hsm_key_clean_suite);
691 if (!pSuite) {
692 return CU_get_error();
693 }
694 ret = test_hsm_key_add_tests(pSuite);
695 if (ret) {
696 return ret;
697 }
698 #endif
699 #if defined(ENFORCER_DATABASE_MYSQL)
700 pSuite = CU_add_suite("Test of hsm key (MySQL)", test_hsm_key_init_suite_mysql, test_hsm_key_clean_suite);
701 if (!pSuite) {
702 return CU_get_error();
703 }
704 ret = test_hsm_key_add_tests(pSuite);
705 if (ret) {
706 return ret;
707 }
708 #endif
709 return 0;
710 }
711