36 #include "scheduler/schedule.h" 37 #include "scheduler/task.h" 59 static pthread_once_t __hsm_key_factory_once = PTHREAD_ONCE_INIT;
60 static pthread_mutex_t* __hsm_key_factory_lock = NULL;
62 static void hsm_key_factory_init(
void) {
63 pthread_mutexattr_t attr;
65 if (!__hsm_key_factory_lock) {
66 if (!(__hsm_key_factory_lock = calloc(1,
sizeof(pthread_mutex_t)))
67 || pthread_mutexattr_init(&attr)
68 || pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)
69 || pthread_mutex_init(__hsm_key_factory_lock, &attr))
72 ods_log_error(
"[hsm_key_factory_init] mutex error");
73 if (__hsm_key_factory_lock) {
74 pthread_mutex_destroy(__hsm_key_factory_lock);
75 free(__hsm_key_factory_lock);
76 __hsm_key_factory_lock = NULL;
84 if (__hsm_key_factory_lock) {
85 (void)pthread_mutex_destroy(__hsm_key_factory_lock);
86 free(__hsm_key_factory_lock);
87 __hsm_key_factory_lock = NULL;
100 ssize_t generate_keys;
101 libhsm_key_t *key = NULL;
104 hsm_repository_t* hsm;
114 if (!__hsm_key_factory_lock) {
115 pthread_once(&__hsm_key_factory_once, hsm_key_factory_init);
116 if (!__hsm_key_factory_lock) {
117 ods_log_error(
"[hsm_key_factory_generate] mutex init error");
121 if (pthread_mutex_lock(__hsm_key_factory_lock)) {
122 ods_log_error(
"[hsm_key_factory_generate] mutex lock error");
144 ods_log_error(
"[hsm_key_factory_generate] unable to count unused keys, database or memory allocation error");
147 pthread_mutex_unlock(__hsm_key_factory_lock);
161 ods_log_error(
"[hsm_key_factory_generate] unable to count zones for policy, database or memory allocation error");
164 pthread_mutex_unlock(__hsm_key_factory_lock);
175 pthread_mutex_unlock(__hsm_key_factory_lock);
187 if (num_zones == 0 || (ssize_t)num_keys >= generate_keys) {
188 pthread_mutex_unlock(__hsm_key_factory_lock);
192 if (policy != NULL) {
193 ods_log_info(
"%lu zone(s) found on policy \"%s\"", num_zones,
policy_name(policy));
195 ods_log_info(
"%lu zone(s) found on policy <unknown>", num_zones);
197 ods_log_info(
"[hsm_key_factory_generate] %lu keys needed for %lu " 198 "zones covering %lld seconds, generating %lu keys for policy %s",
199 generate_keys, num_zones, (
long long)duration,
200 (
unsigned long)(generate_keys-num_keys),
202 generate_keys -= num_keys;
208 if (!(hsm_ctx = hsm_create_context())) {
209 pthread_mutex_unlock(__hsm_key_factory_lock);
213 if ((hsm_err = hsm_get_error(hsm_ctx))) {
214 ods_log_error(
"[hsm_key_factory_generate] unable to check for repository %s, HSM error: %s",
policy_key_repository(policy_key), hsm_err);
218 ods_log_error(
"[hsm_key_factory_generate] unable to find repository %s in HSM",
policy_key_repository(policy_key));
220 hsm_destroy_context(hsm_ctx);
221 pthread_mutex_unlock(__hsm_key_factory_lock);
228 while (generate_keys--) {
240 ods_log_error(
"[hsm_key_factory_generate] unable to find repository %s needed for key generation",
policy_key_repository(policy_key));
241 hsm_destroy_context(hsm_ctx);
242 pthread_mutex_unlock(__hsm_key_factory_lock);
251 case LDNS_RSASHA1_NSEC3:
259 case LDNS_ECDSAP256SHA256:
262 case LDNS_ECDSAP384SHA384:
273 if (!(key_id = hsm_get_key_id(hsm_ctx, key))) {
274 if ((hsm_err = hsm_get_error(hsm_ctx))) {
275 ods_log_error(
"[hsm_key_factory_generate] unable to get the ID of the key generated, HSM error: %s", hsm_err);
279 ods_log_error(
"[hsm_key_factory_generate] unable to get the ID of the key generated");
281 libhsm_key_free(key);
282 hsm_destroy_context(hsm_ctx);
283 pthread_mutex_unlock(__hsm_key_factory_lock);
303 ods_log_error(
"[hsm_key_factory_generate] hsm key creation failed, database or memory error");
307 hsm_destroy_context(hsm_ctx);
308 pthread_mutex_unlock(__hsm_key_factory_lock);
312 ods_log_debug(
"[hsm_key_factory_generate] generated key %s successfully", key_id);
316 libhsm_key_free(key);
319 if ((hsm_err = hsm_get_error(hsm_ctx))) {
320 ods_log_error(
"[hsm_key_factory_generate] key generation failed, HSM error: %s", hsm_err);
324 ods_log_error(
"[hsm_key_factory_generate] key generation failed");
326 hsm_destroy_context(hsm_ctx);
327 pthread_mutex_unlock(__hsm_key_factory_lock);
331 hsm_destroy_context(hsm_ctx);
332 pthread_mutex_unlock(__hsm_key_factory_lock);
341 if (!engine || !policy || !connection) {
345 if (!__hsm_key_factory_lock) {
346 pthread_once(&__hsm_key_factory_once, hsm_key_factory_init);
347 if (!__hsm_key_factory_lock) {
348 ods_log_error(
"[hsm_key_factory_generate_policy] mutex init error");
352 if (pthread_mutex_lock(__hsm_key_factory_lock)) {
353 ods_log_error(
"[hsm_key_factory_generate_policy] mutex lock error");
357 ods_log_debug(
"[hsm_key_factory_generate_policy] policy %s",
policy_name(policy));
364 pthread_mutex_unlock(__hsm_key_factory_lock);
372 pthread_mutex_unlock(__hsm_key_factory_lock);
383 if (!engine || !connection) {
387 if (!__hsm_key_factory_lock) {
388 pthread_once(&__hsm_key_factory_once, hsm_key_factory_init);
389 if (!__hsm_key_factory_lock) {
390 ods_log_error(
"[hsm_key_factory_generate_all] mutex init error");
394 if (pthread_mutex_lock(__hsm_key_factory_lock)) {
395 ods_log_error(
"[hsm_key_factory_generate_all] mutex lock error");
399 ods_log_debug(
"[hsm_key_factory_generate_all] generating keys");
406 pthread_mutex_unlock(__hsm_key_factory_lock);
421 pthread_mutex_unlock(__hsm_key_factory_lock);
426 hsm_key_factory_generate_cb(task_type* task,
char const *owner,
void* userdata,
void* context)
435 return schedule_SUCCESS;
446 ods_log_debug(
"[hsm_key_factory_generate_cb] generate for policy key [duration: %lu]", (
unsigned long)task2->
duration);
448 ods_log_debug(
"[hsm_key_factory_generate_cb] generate for policy key done");
454 return schedule_SUCCESS;
458 hsm_key_factory_generate_policy_cb(task_type* task,
char const *owner,
void *userdata,
467 return schedule_SUCCESS;
471 ods_log_debug(
"[hsm_key_factory_generate_policy_cb] generate for policy [duration: %lu]", (
unsigned long) task2->
duration);
473 ods_log_debug(
"[hsm_key_factory_generate_policy_cb] generate for policy done");
476 return schedule_SUCCESS;
480 hsm_key_factory_generate_all_cb(task_type* task,
char const *owner,
void *userdata,
489 return schedule_SUCCESS;
493 ods_log_debug(
"[hsm_key_factory_generate_all_cb] generate for all policies [duration: %lu]", (
unsigned long)task2->
duration);
495 ods_log_debug(
"[hsm_key_factory_generate_all_cb] generate for all policies done");
498 return schedule_SUCCESS;
533 task = task_create(strdup(
"hsm_key_factory_schedule_generation"),
534 TASK_CLASS_ENFORCER, TASK_TYPE_HSMKEYGEN,
535 hsm_key_factory_generate_cb, task2,
538 if (schedule_task(engine->
taskq, task, 1, 0) != ODS_STATUS_OK) {
571 task = task_create(strdup(
"hsm_key_factory_schedule_generation_policy"),
572 TASK_CLASS_ENFORCER, TASK_TYPE_HSMKEYGEN,
573 hsm_key_factory_generate_policy_cb, task2,
576 if (schedule_task(engine->
taskq, task, 1, 0) != ODS_STATUS_OK) {
603 task = task_create(strdup(
"hsm_key_factory_schedule_generation"),
604 TASK_CLASS_ENFORCER, TASK_TYPE_HSMKEYGEN,
605 hsm_key_factory_generate_all_cb, task2,
608 if (schedule_task(engine->
taskq, task, 1, 0) != ODS_STATUS_OK) {
639 ods_log_debug(
"[hsm_key_factory_get_key] get %s key", (hsm_key_state ==
HSM_KEY_STATE_PRIVATE ?
"private" :
"shared"));
655 ods_log_error(
"[hsm_key_factory_get_key] unable to list keys, database or memory allocation error");
666 ods_log_warning(
"[hsm_key_factory_get_key] no keys available");
668 hsm_key_factory_schedule_generate(engine, policy_key, 0, 1);
680 ods_log_debug(
"[hsm_key_factory_get_key] unable to update fetched key");
688 ods_log_debug(
"[hsm_key_factory_get_key] key allocated");
690 hsm_key_factory_schedule_generate(engine, policy_key, 0, 0);
713 ods_log_debug(
"[hsm_key_factory_release_key_id] unable to check usage of hsm_key, database or memory allocation error");
723 ods_log_debug(
"[hsm_key_factory_release_key_id] unable to release hsm_key, in use");
729 ods_log_debug(
"[hsm_key_factory_release_key_id] unable to fetch hsm_key");
735 ods_log_debug(
"[hsm_key_factory_release_key_id] hsm_key already DELETE (?)");
743 ods_log_debug(
"[hsm_key_factory_release_key_id] unable to change hsm_key state to DELETE");
747 ods_log_debug(
"[hsm_key_factory_release_key_id] key %s marked DELETE",
hsm_key_locator(hsm_key));
770 ods_log_debug(
"[hsm_key_factory_release_key] unable to check usage of hsm_key, database or memory allocation error");
779 ods_log_debug(
"[hsm_key_factory_release_key] unable to release hsm_key, in use");
784 ods_log_debug(
"[hsm_key_factory_release_key] hsm_key already DELETE (?)");
791 ods_log_debug(
"[hsm_key_factory_release_key] unable to change hsm_key state to DELETE");
794 ods_log_debug(
"[hsm_key_factory_release_key] key %s marked DELETE",
hsm_key_locator(hsm_key));
const policy_key_t * policy_key_list_next(policy_key_list_t *policy_key_list)
void zone_db_free(zone_db_t *zone)
int hsm_key_set_locator(hsm_key_t *hsm_key, const char *locator_text)
int hsm_key_set_role(hsm_key_t *hsm_key, hsm_key_role_t role)
void policy_list_free(policy_list_t *policy_list)
hsm_key_t * hsm_key_factory_get_key(engine_type *engine, const db_connection_t *connection, const policy_key_t *policy_key, hsm_key_state_t hsm_key_state)
int reschedule_enforce_task
db_clause_list_t * db_clause_list_new(void)
int hsm_key_set_key_type(hsm_key_t *hsm_key, hsm_key_key_type_t key_type)
const char * policy_name(const policy_t *policy)
policy_key_t * policy_key
int hsm_key_get_by_id(hsm_key_t *hsm_key, const db_value_t *id)
int zone_db_count(zone_db_t *zone, db_clause_list_t *clause_list, size_t *count)
int hsm_key_set_policy_id(hsm_key_t *hsm_key, const db_value_t *policy_id)
time_t automatic_keygen_duration
int hsm_key_set_bits(hsm_key_t *hsm_key, unsigned int bits)
int hsm_key_set_repository(hsm_key_t *hsm_key, const char *repository_text)
int hsm_key_set_inception(hsm_key_t *hsm_key, unsigned int inception)
int hsm_key_set_algorithm(hsm_key_t *hsm_key, unsigned int algorithm)
void enforce_task_flush_all(engine_type *engine, db_connection_t *dbconn)
int hsm_key_set_backup(hsm_key_t *hsm_key, hsm_key_backup_t backup)
db_clause_t * key_data_hsm_key_id_clause(db_clause_list_t *clause_list, const db_value_t *hsm_key_id)
void db_clause_list_free(db_clause_list_t *clause_list)
db_clause_t * hsm_key_is_revoked_clause(db_clause_list_t *clause_list, unsigned int is_revoked)
int hsm_key_factory_release_key(hsm_key_t *hsm_key, const db_connection_t *connection)
int hsm_key_update(hsm_key_t *hsm_key)
int hsm_key_factory_generate_policy(engine_type *engine, const db_connection_t *connection, const policy_t *policy, time_t duration)
enum hsm_key_state hsm_key_state_t
void hsm_key_factory_deinit(void)
int hsm_key_factory_generate(engine_type *engine, const db_connection_t *connection, const policy_t *policy, const policy_key_t *policy_key, time_t duration)
engineconfig_type * config
const char * policy_key_repository(const policy_key_t *policy_key)
void policy_free(policy_t *policy)
int hsm_key_count(hsm_key_t *hsm_key, db_clause_list_t *clause_list, size_t *count)
hsm_repository_t * repositories
unsigned int policy_key_lifetime(const policy_key_t *policy_key)
key_data_t * key_data_new(const db_connection_t *connection)
db_clause_t * zone_db_policy_id_clause(db_clause_list_t *clause_list, const db_value_t *policy_id)
policy_t * policy_new(const db_connection_t *connection)
void enforce_task_flush_policy(engine_type *engine, db_connection_t *dbconn, policy_t const *policy)
const char * hsm_key_locator(const hsm_key_t *hsm_key)
int hsm_key_factory_schedule_generate_all(engine_type *engine, time_t duration)
policy_list_t * policy_list_new_get(const db_connection_t *connection)
db_clause_t * hsm_key_policy_id_clause(db_clause_list_t *clause_list, const db_value_t *policy_id)
policy_t * policy_new_copy(const policy_t *policy)
db_clause_t * hsm_key_repository_clause(db_clause_list_t *clause_list, const char *repository_text)
int hsm_key_create(hsm_key_t *hsm_key)
const char * policy_key_role_text(const policy_key_t *policy_key)
hsm_key_t * hsm_key_list_get_next(hsm_key_list_t *hsm_key_list)
const policy_t * policy_list_next(policy_list_t *policy_list)
void key_data_free(key_data_t *key_data)
int hsm_key_factory_schedule_generate_policy(engine_type *engine, const policy_t *policy_orig, time_t duration)
void hsm_key_free(hsm_key_t *hsm_key)
hsm_key_list_t * hsm_key_list_new_get_by_clauses(const db_connection_t *connection, const db_clause_list_t *clause_list)
int hsm_key_factory_generate_all(engine_type *engine, const db_connection_t *connection, time_t duration)
unsigned int policy_key_algorithm(const policy_key_t *policy_key)
int hsm_key_set_state(hsm_key_t *hsm_key, hsm_key_state_t state)
db_clause_t * hsm_key_algorithm_clause(db_clause_list_t *clause_list, unsigned int algorithm)
db_clause_t * hsm_key_bits_clause(db_clause_list_t *clause_list, unsigned int bits)
policy_key_t * policy_key_new_copy(const policy_key_t *policy_key)
void hsm_key_list_free(hsm_key_list_t *hsm_key_list)
unsigned int policy_key_bits(const policy_key_t *policy_key)
void policy_key_list_free(policy_key_list_t *policy_key_list)
const db_value_t * hsm_key_id(const hsm_key_t *hsm_key)
int key_data_count(key_data_t *key_data, db_clause_list_t *clause_list, size_t *count)
const db_value_t * policy_id(const policy_t *policy)
const db_value_t * policy_key_policy_id(const policy_key_t *policy_key)
int policy_get_by_id(policy_t *policy, const db_value_t *id)
int hsm_key_factory_release_key_id(const db_value_t *hsm_key_id, const db_connection_t *connection)
void policy_key_free(policy_key_t *policy_key)
db_clause_t * hsm_key_key_type_clause(db_clause_list_t *clause_list, hsm_key_key_type_t key_type)
zone_db_t * zone_db_new(const db_connection_t *connection)
policy_key_list_t * policy_key_list_new_get_by_policy_id(const db_connection_t *connection, const db_value_t *policy_id)
db_clause_t * hsm_key_role_clause(db_clause_list_t *clause_list, hsm_key_role_t role)
enum hsm_key_role hsm_key_role_t
hsm_key_t * hsm_key_new(const db_connection_t *connection)
db_clause_t * hsm_key_state_clause(db_clause_list_t *clause_list, hsm_key_state_t state)