OpenDNSSEC-enforcer  2.1.7
test_hsm_key.c
Go to the documentation of this file.
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)
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)
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 
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 
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 
260 static void test_hsm_key_set(void) {
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));
285  CU_ASSERT(!hsm_key_set_backup(object, HSM_KEY_BACKUP_BACKUP_DONE));
287 }
288 
289 static void test_hsm_key_get(void) {
290  int ret;
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);
311 }
312 
313 static void test_hsm_key_create(void) {
314  CU_ASSERT_FATAL(!hsm_key_create(object));
315 }
316 
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 
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 
507 static void test_hsm_key_verify(void) {
508  int ret;
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);
529 }
530 
531 static void test_hsm_key_read_by_locator(void) {
532  CU_ASSERT_FATAL(!hsm_key_get_by_locator(object, "locator 1"));
533 }
534 
535 static void test_hsm_key_verify_locator(void) {
536  int ret;
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);
557 }
558 
559 static void test_hsm_key_change(void) {
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));
578 }
579 
580 static void test_hsm_key_update(void) {
581  CU_ASSERT_FATAL(!hsm_key_update(object));
582 }
583 
584 static void test_hsm_key_verify2(void) {
585  int ret;
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);
606 }
607 
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 
614 static void test_hsm_key_read_by_locator2(void) {
615  CU_ASSERT_FATAL(!hsm_key_get_by_locator(object, "locator 2"));
616 }
617 
618 static void test_hsm_key_verify_locator2(void) {
619  int ret;
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);
640 }
641 
642 static void test_hsm_key_delete(void) {
643 }
644 
645 static void test_hsm_key_list2(void) {
646  CU_ASSERT_PTR_NULL(hsm_key_list_next(object_list));
647 }
648 
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 
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 
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 }
hsm_key_set_state
int hsm_key_set_state(hsm_key_t *hsm_key, hsm_key_state_t state)
Definition: hsm_key.c:625
hsm_key_algorithm_clause
db_clause_t * hsm_key_algorithm_clause(db_clause_list_t *clause_list, unsigned int algorithm)
Definition: hsm_key.c:798
HSM_KEY_STATE_DELETE
@ HSM_KEY_STATE_DELETE
Definition: hsm_key.h:45
db_value_reset
void db_value_reset(db_value_t *value)
Definition: db_value.c:60
hsm_key_set_bits
int hsm_key_set_bits(hsm_key_t *hsm_key, unsigned int bits)
Definition: hsm_key.c:638
hsm_key_list_free
void hsm_key_list_free(hsm_key_list_t *hsm_key_list)
Definition: hsm_key.c:1496
hsm_key_policy_id
const db_value_t * hsm_key_policy_id(const hsm_key_t *hsm_key)
Definition: hsm_key.c:512
HSM_KEY_BACKUP_BACKUP_DONE
@ HSM_KEY_BACKUP_BACKUP_DONE
Definition: hsm_key.h:69
db_value
Definition: db_value.h:48
hsm_key_set_inception
int hsm_key_set_inception(hsm_key_t *hsm_key, unsigned int inception)
Definition: hsm_key.c:671
hsm_key_bits
unsigned int hsm_key_bits(const hsm_key_t *hsm_key)
Definition: hsm_key.c:536
hsm_key_list_next
const hsm_key_t * hsm_key_list_next(hsm_key_list_t *hsm_key_list)
Definition: hsm_key.c:1924
hsm_key_role_clause
db_clause_t * hsm_key_role_clause(db_clause_list_t *clause_list, hsm_key_role_t role)
Definition: hsm_key.c:819
hsm_key_new
hsm_key_t * hsm_key_new(const db_connection_t *connection)
Definition: hsm_key.c:244
hsm_key_role
hsm_key_role
Definition: hsm_key.h:49
hsm_key_set_backup
int hsm_key_set_backup(hsm_key_t *hsm_key, hsm_key_backup_t backup)
Definition: hsm_key.c:716
hsm_key_state
hsm_key_state
Definition: hsm_key.h:40
db_connection_set_configuration_list
int db_connection_set_configuration_list(db_connection_t *connection, const db_configuration_list_t *configuration_list)
Definition: db_connection.c:54
db_configuration
Definition: db_configuration.h:41
hsm_key_backup_clause
db_clause_t * hsm_key_backup_clause(db_clause_list_t *clause_list, hsm_key_backup_t backup)
Definition: hsm_key.c:906
hsm_key_repository
const char * hsm_key_repository(const hsm_key_t *hsm_key)
Definition: hsm_key.c:568
hsm_key_backup
hsm_key_backup
Definition: hsm_key.h:64
hsm_key_set_locator
int hsm_key_set_locator(hsm_key_t *hsm_key, const char *locator_text)
Definition: hsm_key.c:603
db_configuration_list_new
db_configuration_list_t * db_configuration_list_new(void)
Definition: db_configuration.c:127
hsm_key_get_by_locator
int hsm_key_get_by_locator(hsm_key_t *hsm_key, const char *locator)
Definition: hsm_key.c:1155
db_value_from_int32
int db_value_from_int32(db_value_t *value, db_type_int32_t from_int32)
Definition: db_value.c:479
db_configuration_free
void db_configuration_free(db_configuration_t *configuration)
Definition: db_configuration.c:48
hsm_key_list_get_by_clauses
int hsm_key_list_get_by_clauses(hsm_key_list_t *hsm_key_list, const db_clause_list_t *clause_list)
Definition: hsm_key.c:1684
db_configuration_new
db_configuration_t * db_configuration_new(void)
Definition: db_configuration.c:41
hsm_key_set_key_type
int hsm_key_set_key_type(hsm_key_t *hsm_key, hsm_key_key_type_t key_type)
Definition: hsm_key.c:681
HSM_KEY_BACKUP_NO_BACKUP
@ HSM_KEY_BACKUP_NO_BACKUP
Definition: hsm_key.h:66
db_connection_setup
int db_connection_setup(db_connection_t *connection)
Definition: db_connection.c:66
db_clause_list
Definition: db_clause.h:226
hsm_key_set_repository
int hsm_key_set_repository(hsm_key_t *hsm_key, const char *repository_text)
Definition: hsm_key.c:694
HSM_KEY_BACKUP_BACKUP_REQUESTED
@ HSM_KEY_BACKUP_BACKUP_REQUESTED
Definition: hsm_key.h:68
db_connection_connect
int db_connection_connect(const db_connection_t *connection)
Definition: db_connection.c:88
hsm_key_set_policy_id
int hsm_key_set_policy_id(hsm_key_t *hsm_key, const db_value_t *policy_id)
Definition: hsm_key.c:584
HSM_KEY_ROLE_CSK
@ HSM_KEY_ROLE_CSK
Definition: hsm_key.h:53
hsm_key_create
int hsm_key_create(hsm_key_t *hsm_key)
Definition: hsm_key.c:927
hsm_key_policy_id_clause
db_clause_t * hsm_key_policy_id_clause(db_clause_list_t *clause_list, const db_value_t *policy_id)
Definition: hsm_key.c:729
db_clause_list_free
void db_clause_list_free(db_clause_list_t *clause_list)
Definition: db_clause.c:209
hsm_key_set_algorithm
int hsm_key_set_algorithm(hsm_key_t *hsm_key, unsigned int algorithm)
Definition: hsm_key.c:648
hsm_key
Definition: hsm_key.h:79
HSM_KEY_ROLE_KSK
@ HSM_KEY_ROLE_KSK
Definition: hsm_key.h:51
db_configuration_set_value
int db_configuration_set_value(db_configuration_t *configuration, const char *value)
Definition: db_configuration.c:89
HSM_KEY_BACKUP_BACKUP_REQUIRED
@ HSM_KEY_BACKUP_BACKUP_REQUIRED
Definition: hsm_key.h:67
db_connection_free
void db_connection_free(db_connection_t *connection)
Definition: db_connection.c:45
hsm_key_update
int hsm_key_update(hsm_key_t *hsm_key)
Definition: hsm_key.c:1225
HSM_KEY_STATE_PRIVATE
@ HSM_KEY_STATE_PRIVATE
Definition: hsm_key.h:43
HSM_KEY_ROLE_ZSK
@ HSM_KEY_ROLE_ZSK
Definition: hsm_key.h:52
HSM_KEY_STATE_SHARED
@ HSM_KEY_STATE_SHARED
Definition: hsm_key.h:44
hsm_key_bits_clause
db_clause_t * hsm_key_bits_clause(db_clause_list_t *clause_list, unsigned int bits)
Definition: hsm_key.c:777
hsm_key_inception
unsigned int hsm_key_inception(const hsm_key_t *hsm_key)
Definition: hsm_key.c:560
HSM_KEY_STATE_UNUSED
@ HSM_KEY_STATE_UNUSED
Definition: hsm_key.h:42
hsm_key_count
int hsm_key_count(hsm_key_t *hsm_key, db_clause_list_t *clause_list, size_t *count)
Definition: hsm_key.c:1435
db_clause_list_new
db_clause_list_t * db_clause_list_new(void)
Definition: db_clause.c:202
DB_VALUE_EMPTY
#define DB_VALUE_EMPTY
Definition: db_value.h:60
db_value_cmp
int db_value_cmp(const db_value_t *value_a, const db_value_t *value_b, int *result)
Definition: db_value.c:102
db_configuration_list_add
int db_configuration_list_add(db_configuration_list_t *configuration_list, db_configuration_t *configuration)
Definition: db_configuration.c:150
hsm_key_state_clause
db_clause_t * hsm_key_state_clause(db_clause_list_t *clause_list, hsm_key_state_t state)
Definition: hsm_key.c:756
hsm_key_locator
const char * hsm_key_locator(const hsm_key_t *hsm_key)
Definition: hsm_key.c:520
db_configuration_list
Definition: db_configuration.h:93
HSM_KEY_KEY_TYPE_RSA
@ HSM_KEY_KEY_TYPE_RSA
Definition: hsm_key.h:61
hsm_key_repository_clause
db_clause_t * hsm_key_repository_clause(db_clause_list_t *clause_list, const char *repository_text)
Definition: hsm_key.c:882
db_value_from_uint64
int db_value_from_uint64(db_value_t *value, db_type_uint64_t from_uint64)
Definition: db_value.c:518
db_configuration_set_name
int db_configuration_set_name(db_configuration_t *configuration, const char *name)
Definition: db_configuration.c:68
hsm_key_set_role
int hsm_key_set_role(hsm_key_t *hsm_key, hsm_key_role_t role)
Definition: hsm_key.c:658
db_connection_new
db_connection_t * db_connection_new(void)
Definition: db_connection.c:38
db_connection
Definition: db_connection.h:46
hsm_key_free
void hsm_key_free(hsm_key_t *hsm_key)
Definition: hsm_key.c:286
db_configuration_list_free
void db_configuration_list_free(db_configuration_list_t *configuration_list)
Definition: db_configuration.c:134
hsm_key_list
Definition: hsm_key.h:436
hsm_key_algorithm
unsigned int hsm_key_algorithm(const hsm_key_t *hsm_key)
Definition: hsm_key.c:544
policy_id
const db_value_t * policy_id(const policy_t *policy)
Definition: policy.c:805
hsm_key_list_new
hsm_key_list_t * hsm_key_list_new(const db_connection_t *connection)
Definition: hsm_key.c:1453
test_hsm_key_add_suite
int test_hsm_key_add_suite(void)
Definition: test_hsm_key.c:685
hsm_key_list_new_get_by_clauses
hsm_key_list_t * hsm_key_list_new_get_by_clauses(const db_connection_t *connection, const db_clause_list_t *clause_list)
Definition: hsm_key.c:1726