57 static pthread_once_t __hsm_key_factory_once = PTHREAD_ONCE_INIT;
58 static pthread_mutex_t* __hsm_key_factory_lock = NULL;
60 static void hsm_key_factory_init(
void) {
61 pthread_mutexattr_t attr;
63 if (!__hsm_key_factory_lock) {
64 if (!(__hsm_key_factory_lock = calloc(1,
sizeof(pthread_mutex_t)))
65 || pthread_mutexattr_init(&attr)
66 || pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)
67 || pthread_mutex_init(__hsm_key_factory_lock, &attr))
70 if (__hsm_key_factory_lock) {
71 pthread_mutex_destroy(__hsm_key_factory_lock);
72 free(__hsm_key_factory_lock);
73 __hsm_key_factory_lock = NULL;
81 if (__hsm_key_factory_lock) {
82 (void)pthread_mutex_destroy(__hsm_key_factory_lock);
83 free(__hsm_key_factory_lock);
84 __hsm_key_factory_lock = NULL;
94 ssize_t generate_keys;
95 libhsm_key_t *key = NULL;
98 hsm_repository_t* hsm;
108 if (!__hsm_key_factory_lock) {
109 pthread_once(&__hsm_key_factory_once, hsm_key_factory_init);
110 if (!__hsm_key_factory_lock) {
111 ods_log_error(
"[hsm_key_factory_generate] mutex init error");
115 if (pthread_mutex_lock(__hsm_key_factory_lock)) {
116 ods_log_error(
"[hsm_key_factory_generate] mutex lock error");
138 ods_log_error(
"[hsm_key_factory_generate] unable to count unused keys, database or memory allocation error");
141 pthread_mutex_unlock(__hsm_key_factory_lock);
155 ods_log_error(
"[hsm_key_factory_generate] unable to count zones for policy, database or memory allocation error");
158 pthread_mutex_unlock(__hsm_key_factory_lock);
169 pthread_mutex_unlock(__hsm_key_factory_lock);
181 if (num_zones == 0 || (ssize_t)num_keys >= generate_keys) {
182 pthread_mutex_unlock(__hsm_key_factory_lock);
186 if (policy != NULL) {
189 ods_log_info(
"%lu zone(s) found on policy <unknown>", num_zones);
191 ods_log_info(
"[hsm_key_factory_generate] %lu keys needed for %lu " 192 "zones covering %lld seconds, generating %lu keys for policy %s",
193 generate_keys, num_zones, (
long long)duration,
194 (
unsigned long)(generate_keys-num_keys),
196 generate_keys -= num_keys;
202 if (!(hsm_ctx = hsm_create_context())) {
203 pthread_mutex_unlock(__hsm_key_factory_lock);
207 if ((hsm_err = hsm_get_error(hsm_ctx))) {
214 hsm_destroy_context(hsm_ctx);
215 pthread_mutex_unlock(__hsm_key_factory_lock);
222 while (generate_keys--) {
235 hsm_destroy_context(hsm_ctx);
236 pthread_mutex_unlock(__hsm_key_factory_lock);
244 if (!(key_id = hsm_get_key_id(hsm_ctx, key))) {
245 if ((hsm_err = hsm_get_error(hsm_ctx))) {
246 ods_log_error(
"[hsm_key_factory_generate] unable to get the ID of the key generated, HSM error: %s", hsm_err);
250 ods_log_error(
"[hsm_key_factory_generate] unable to get the ID of the key generated");
253 hsm_destroy_context(hsm_ctx);
254 pthread_mutex_unlock(__hsm_key_factory_lock);
274 ods_log_error(
"[hsm_key_factory_generate] hsm key creation failed, database or memory error");
278 hsm_destroy_context(hsm_ctx);
279 pthread_mutex_unlock(__hsm_key_factory_lock);
283 ods_log_debug(
"[hsm_key_factory_generate] generated key %s successfully", key_id);
290 if ((hsm_err = hsm_get_error(hsm_ctx))) {
291 ods_log_error(
"[hsm_key_factory_generate] key generation failed, HSM error: %s", hsm_err);
295 ods_log_error(
"[hsm_key_factory_generate] key generation failed");
297 hsm_destroy_context(hsm_ctx);
298 pthread_mutex_unlock(__hsm_key_factory_lock);
302 hsm_destroy_context(hsm_ctx);
303 pthread_mutex_unlock(__hsm_key_factory_lock);
320 if (!__hsm_key_factory_lock) {
321 pthread_once(&__hsm_key_factory_once, hsm_key_factory_init);
322 if (!__hsm_key_factory_lock) {
323 ods_log_error(
"[hsm_key_factory_generate_policy] mutex init error");
327 if (pthread_mutex_lock(__hsm_key_factory_lock)) {
328 ods_log_error(
"[hsm_key_factory_generate_policy] mutex lock error");
339 pthread_mutex_unlock(__hsm_key_factory_lock);
347 pthread_mutex_unlock(__hsm_key_factory_lock);
363 if (!__hsm_key_factory_lock) {
364 pthread_once(&__hsm_key_factory_once, hsm_key_factory_init);
365 if (!__hsm_key_factory_lock) {
366 ods_log_error(
"[hsm_key_factory_generate_all] mutex init error");
370 if (pthread_mutex_lock(__hsm_key_factory_lock)) {
371 ods_log_error(
"[hsm_key_factory_generate_all] mutex lock error");
375 ods_log_debug(
"[hsm_key_factory_generate_all] generating keys");
382 pthread_mutex_unlock(__hsm_key_factory_lock);
396 pthread_mutex_unlock(__hsm_key_factory_lock);
424 ods_log_debug(
"[hsm_key_factory_generate_task] generate for policy key [duration: %lu]", (
unsigned long)task2->
duration);
426 ods_log_debug(
"[hsm_key_factory_generate_task] generate for policy key done");
457 ods_log_debug(
"[hsm_key_factory_generate_policy_task] generate for policy [duration: %lu]", (
unsigned long) task2->
duration);
459 ods_log_debug(
"[hsm_key_factory_generate_policy_task] generate for policy done");
482 ods_log_debug(
"[hsm_key_factory_generate_all_task] generate for all policies [duration: %lu]", (
unsigned long)task2->
duration);
484 ods_log_debug(
"[hsm_key_factory_generate_all_task] generate for all policies done");
528 what_id =
task_register(
"hsmkeygen",
"hsm_key_factory_schedule_generation",
529 hsm_key_factory_generate_task);
531 || !(task =
task_create(what_id, time_now(),
"policy_key",
532 "hsmkeygen", task2, hsm_key_factory_clean_context))
565 what_id =
task_register(
"hsmkeygen",
"hsm_key_factory_schedule_generation_policy",
566 hsm_key_factory_generate_policy_task);
568 || !(task =
task_create(what_id, time_now(),
"policy",
569 "hsmkeygen", task2, hsm_key_factory_clean_context))
595 what_id =
task_register(
"hsmkeygen",
"hsm_key_factory_schedule_generation",
596 hsm_key_factory_generate_all_task);
598 || !(task =
task_create(what_id, time_now(),
"all policies",
599 "hsmkeygen", task2, hsm_key_factory_clean_context))
602 if (!task) free(task2);
645 ods_log_error(
"[hsm_key_factory_get_key] unable to list keys, database or memory allocation error");
657 hsm_key_factory_schedule_generate(engine, policy_key, 0, 1);
669 ods_log_debug(
"[hsm_key_factory_get_key] unable to update fetched key");
678 hsm_key_factory_schedule_generate(engine, policy_key, 0, 0);
701 ods_log_debug(
"[hsm_key_factory_release_key_id] unable to check usage of hsm_key, database or memory allocation error");
711 ods_log_debug(
"[hsm_key_factory_release_key_id] unable to release hsm_key, in use");
717 ods_log_debug(
"[hsm_key_factory_release_key_id] unable to fetch hsm_key");
723 ods_log_debug(
"[hsm_key_factory_release_key_id] hsm_key already DELETE (?)");
731 ods_log_debug(
"[hsm_key_factory_release_key_id] unable to change hsm_key state to DELETE");
758 ods_log_debug(
"[hsm_key_factory_release_key] unable to check usage of hsm_key, database or memory allocation error");
767 ods_log_debug(
"[hsm_key_factory_release_key] unable to release hsm_key, in use");
772 ods_log_debug(
"[hsm_key_factory_release_key] hsm_key already DELETE (?)");
779 ods_log_debug(
"[hsm_key_factory_release_key] unable to change hsm_key state to DELETE");
const policy_key_t * policy_key_list_next(policy_key_list_t *policy_key_list)
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)
void ods_log_debug(const char *format,...)
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)
void hsm_key_factory_generate_policy(engine_type *engine, const db_connection_t *connection, const policy_t *policy, time_t duration)
int hsm_key_set_policy_id(hsm_key_t *hsm_key, const db_value_t *policy_id)
time_t automatic_keygen_duration
void ods_log_info(const char *format,...)
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)
ods_status schedule_task(schedule_type *schedule, task_type *task)
void ods_log_error(const char *format,...)
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)
enum task_id_enum task_id
void zone_free(zone_t *zone)
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)
enum hsm_key_state hsm_key_state_t
void hsm_key_factory_deinit(void)
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)
int zone_count(zone_t *zone, db_clause_list_t *clause_list, size_t *count)
hsm_repository_t * repositories
zone_t * zone_new(const db_connection_t *connection)
unsigned int policy_key_lifetime(const policy_key_t *policy_key)
key_data_t * key_data_new(const db_connection_t *connection)
void task_cleanup(task_type *task)
policy_t * policy_new(const db_connection_t *connection)
void 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)
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)
task_id task_register(const char *short_name, const char *long_name, how_type how)
void hsm_key_factory_generate_all(engine_type *engine, const db_connection_t *connection, time_t duration)
hsm_key_list_t * hsm_key_list_new_get_by_clauses(const db_connection_t *connection, const db_clause_list_t *clause_list)
task_type * task_create(task_id what_id, time_t when, const char *who, const char *what, void *context, how_type clean_context)
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)
db_clause_t * zone_policy_id_clause(db_clause_list_t *clause_list, const db_value_t *policy_id)
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)
void ods_log_warning(const char *format,...)
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)
int flush_enforce_task(engine_type *engine, bool enforce_all)
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)
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)