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