OpenDNSSEC-libhsm 2.1.13
hsmutil.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2009 .SE (The Internet Infrastructure Foundation).
3 * Copyright (c) 2009 NLNet Labs.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
19 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
21 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
23 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
25 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include "config.h"
29
30#include <stdio.h>
31#include <string.h>
32#include <stdlib.h>
33#include <syslog.h>
34#include <unistd.h>
35
36#include "libhsm.h"
37#include "hsmtest.h"
38
39#include <libhsmdns.h>
40
41extern hsm_repository_t* parse_conf_repositories(const char* cfgfile);
42
43extern char *optarg;
44char *progname = NULL;
45unsigned int verbose = 0;
46hsm_ctx_t *ctx = NULL;
47
48
49static void
50version ()
51{
52 fprintf(stderr, "%s (%s) version %s\n",
53 progname, PACKAGE_NAME, PACKAGE_VERSION);
54}
55
56static void
57usage ()
58{
59 fprintf(stderr,
60 "usage: %s [-c config] [-vVfh] [command [options]]\n",
61 progname);
62
63 fprintf(stderr," -h Print this usage information.\n");
64 fprintf(stderr," -v Increase verbosity.\n");
65 fprintf(stderr," -V Print version and exit.\n");
66 fprintf(stderr," -f Force, Assume yes on all questions.\n");
67 fprintf(stderr," -c <cfg> Use alternative conf.xml.\n");
68
69 fprintf(stderr,"commands\n");
70
71 fprintf(stderr," login\n");
72 fprintf(stderr," logout\n");
73 fprintf(stderr," list [repository]\n");
74 fprintf(stderr," generate <repository> rsa|dsa|gost|ecdsa [keysize]\n");
75 fprintf(stderr," remove <id>\n");
76 fprintf(stderr," purge <repository>\n");
77 fprintf(stderr," dnskey <id> <name> <type> <algo>\n");
78 fprintf(stderr," test <repository>\n");
79 fprintf(stderr," info\n");
80#if 0
81 fprintf(stderr," debug\n");
82#endif
83}
84
85static int
86cmd_login ()
87{
88 printf("The tokens are now logged in.\n");
89
90 return 0;
91}
92
93static int
94cmd_logout ()
95{
96 if (hsm_logout_pin() != HSM_OK) {
97 printf("Failed to erase the credentials.\n");
98 hsm_print_error(NULL);
99 return 1;
100 }
101
102 printf("The credentials has been erased.\n");
103
104 return 0;
105}
106
107#pragma GCC diagnostic push
108#pragma GCC diagnostic ignored "-Wformat-nonliteral"
109static int
110cmd_list (int argc, char *argv[])
111{
112 size_t i;
113 char *repository = NULL;
114
115 size_t key_count = 0;
116 size_t key_count_valid = 0;
117 libhsm_key_t **keys;
118
119 const char *key_info_format = "%-20s %-32s %-10s\n";
120
122
123 if (argc) {
124 repository = argv[0];
125 argc--;
126 argv++;
127
128 /* Check for repository before starting using it */
129 if (hsm_token_attached(ctx, repository) == 0) {
131 return 1;
132 }
133
134 fprintf(stdout, "\nListing keys in repository: %s\n", repository);
135 keys = hsm_list_keys_repository(ctx, &key_count, repository);
136 } else {
137 fprintf(stdout, "\nListing keys in all repositories.\n");
138 keys = hsm_list_keys(ctx, &key_count);
139 }
140
141 fprintf(stdout, "%u %s found.\n\n", (unsigned int) key_count,
142 (key_count > 1 || key_count == 0 ? "keys" : "key"));
143
144 if (!keys) {
145 return -1;
146 }
147
148 /* print fancy header */
149 fprintf(stdout, key_info_format, "Repository", "ID", "Type");
150 fprintf(stdout, key_info_format, "----------", "--", "----");
151
152 for (i = 0; i < key_count; i++) {
153 libhsm_key_info_t *key_info;
154 libhsm_key_t *key = NULL;
155 char key_type[HSM_MAX_ALGONAME + 8];
156 char const * key_id = NULL;
157
158 key = keys[i];
159 if (key == NULL) {
160 /* Skip NULL key for now */
161 continue;
162 }
163
164 key_count_valid++;
165
166 key_info = hsm_get_key_info(ctx, key);
167
168 if (key_info) {
169 snprintf(key_type, sizeof(key_type), "%s/%lu",
170 key_info->algorithm_name, key_info->keysize);
171 key_id = key_info->id;
172 } else {
173 snprintf(key_type, sizeof(key_type), "UNKNOWN");
174 key_id = "UNKNOWN";
175 }
176
177 printf(key_info_format, key->modulename, key_id, key_type);
178
179 libhsm_key_info_free(key_info);
180 }
181 libhsm_key_list_free(keys, key_count);
182
183 if (key_count != key_count_valid) {
184 size_t invalid_keys;
185 invalid_keys = key_count - key_count_valid;
186 printf("\n");
187 fprintf(stderr, "Warning: %u %s not usable by OpenDNSSEC was found.\n",
188 (unsigned int) invalid_keys, invalid_keys > 1 ? "keys" : "key");
189 }
190
191 return 0;
192}
193#pragma GCC diagnostic pop
194
195static int
196cmd_generate (int argc, char *argv[])
197{
198 const char *repository = NULL;
199 const char *algorithm = NULL;
200 unsigned int keysize = 1024;
201
202 libhsm_key_t *key = NULL;
203
204 if (argc < 2 || argc > 3) {
205 usage();
206 return -1;
207 }
208
209 repository = argv[0];
210
211 /* Check for repository before starting using it */
212 if (hsm_token_attached(ctx, repository) == 0) {
214 return 1;
215 }
216
217 algorithm = argv[1];
218 if (argc == 3) {
219 keysize = atoi(argv[2]);
220 }
221
222 if (!strcasecmp(algorithm, "rsa")) {
223 printf("Generating %d bit RSA key in repository: %s\n",
224 keysize, repository);
225
226 key = hsm_generate_rsa_key(ctx, repository, keysize);
227 } else if (!strcasecmp(algorithm, "dsa")) {
228 printf("Generating %d bit DSA key in repository: %s\n",
229 keysize, repository);
230
231 key = hsm_generate_dsa_key(ctx, repository, keysize);
232 } else if (!strcasecmp(algorithm, "gost")) {
233 printf("Generating 512 bit GOST key in repository: %s\n",
234 repository);
235
236 key = hsm_generate_gost_key(ctx, repository);
237 } else if (!strcasecmp(algorithm, "ecdsa")) {
238 if (keysize == 256) {
239 printf("Generating a P-256 ECDSA key in repository: %s\n",
240 repository);
241
242 key = hsm_generate_ecdsa_key(ctx, repository, "P-256");
243 } else if (keysize == 384) {
244 printf("Generating a P-384 ECDSA key in repository: %s\n",
245 repository);
246
247 key = hsm_generate_ecdsa_key(ctx, repository, "P-384");
248 } else {
249 printf("Invalid ECDSA key size: %d\n", keysize);
250 printf("Expecting 256 or 384.\n");
251 return -1;
252 }
253 } else {
254 printf("Unknown algorithm: %s\n", algorithm);
255 return -1;
256 }
257
258 if (key) {
259 libhsm_key_info_t *key_info;
260
261 key_info = hsm_get_key_info(ctx, key);
262 printf("Key generation successful: %s\n",
263 key_info ? key_info->id : "NULL");
264 libhsm_key_info_free(key_info);
265 if (verbose) hsm_print_key(ctx, key);
266 libhsm_key_free(key);
267 } else {
268 printf("Key generation failed.\n");
269 return -1;
270 }
271
272 return 0;
273}
274
275static int
276cmd_remove (int argc, char *argv[])
277{
278 char *id;
279 int result;
280
281 libhsm_key_t *key = NULL;
282
283 if (argc != 1) {
284 usage();
285 return -1;
286 }
287
288 id = argv[0];
289
290 key = hsm_find_key_by_id(ctx, id);
291
292 if (!key) {
293 printf("Key not found: %s\n", id);
294 return -1;
295 }
296
297 result = hsm_remove_key(ctx, key);
298
299 if (!result) {
300 printf("Key remove successful.\n");
301 } else {
302 printf("Key remove failed.\n");
303 }
304
305 libhsm_key_free(key);
306
307 return result;
308}
309
310static int
311cmd_purge (int argc, char *argv[], int force)
312{
313 int result;
314 int final_result = 0;
315 char *fresult;
316
317 size_t i;
318 char *repository = NULL;
319 char confirm[16];
320
321 size_t key_count = 0;
322 libhsm_key_t **keys;
323
324 if (argc != 1) {
325 usage();
326 return -1;
327 }
328
329 repository = argv[0];
330 argc--;
331 argv++;
332
333 /* Check for repository before starting using it */
334 if (hsm_token_attached(ctx, repository) == 0) {
336 return 1;
337 }
338
339 printf("Purging all keys from repository: %s\n", repository);
340 keys = hsm_list_keys_repository(ctx, &key_count, repository);
341
342 printf("%u %s found.\n\n", (unsigned int) key_count,
343 (key_count > 1 || key_count == 0 ? "keys" : "key"));
344
345 if (!keys) {
346 return -1;
347 }
348
349 if (key_count == 0) {
350 libhsm_key_list_free(keys, key_count);
351 return -1;
352 }
353
354 if (!force) {
355 printf("Are you sure you want to remove ALL keys from repository %s ? (YES/NO) ", repository);
356 fresult = fgets(confirm, sizeof(confirm) - 1, stdin);
357 if (fresult == NULL || strncasecmp(confirm, "yes", 3) != 0) {
358 printf("\npurge cancelled.\n");
359 libhsm_key_list_free(keys, key_count);
360 return -1;
361 }
362 }
363 printf("\nStarting purge...\n");
364
365 for (i = 0; i < key_count; i++) {
366 libhsm_key_info_t *key_info;
367 libhsm_key_t *key = keys[i];
368
369 key_info = hsm_get_key_info(ctx, key);
370 result = hsm_remove_key(ctx, key);
371
372 if (!result) {
373 printf("Key remove successful: %s\n",
374 key_info ? key_info->id : "NULL");
375 } else {
376 printf("Key remove failed: %s\n",
377 key_info ? key_info->id : "NULL");
378 final_result++;
379 }
380
381 libhsm_key_info_free(key_info);
382 }
383 libhsm_key_list_free(keys, key_count);
384
385 printf("Purge done.\n");
386
387 return final_result;
388}
389
390static int
391cmd_dnskey (int argc, char *argv[])
392{
393 char *id;
394 char *name;
395 int type;
396 int algo;
397
398 libhsm_key_t *key = NULL;
399 ldns_rr *dnskey_rr;
400 hsm_sign_params_t *sign_params;
401
402 if (argc != 4) {
403 usage();
404 return -1;
405 }
406
407 id = strdup(argv[0]);
408 name = strdup(argv[1]);
409 type = atoi(argv[2]);
410 algo = atoi(argv[3]);
411
412 key = hsm_find_key_by_id(ctx, id);
413
414 if (!key) {
415 printf("Key not found: %s\n", id);
416 free(name);
417 free(id);
418 return -1;
419 }
420
421 if (type != LDNS_KEY_ZONE_KEY && type != LDNS_KEY_ZONE_KEY + LDNS_KEY_SEP_KEY) {
422 printf("Invalid key type: %i\n", type);
423 printf("Please use: %i or %i\n", LDNS_KEY_ZONE_KEY, LDNS_KEY_ZONE_KEY + LDNS_KEY_SEP_KEY);
424 free(name);
425 free(id);
426 free(key);
427 return -1;
428 }
429
430 libhsm_key_info_t *key_info = hsm_get_key_info(ctx, key);
431 switch (algo) {
432 case LDNS_SIGN_RSAMD5:
433 case LDNS_SIGN_RSASHA1:
434 case LDNS_SIGN_RSASHA1_NSEC3:
435 case LDNS_SIGN_RSASHA256:
436 case LDNS_SIGN_RSASHA512:
437 if (strcmp(key_info->algorithm_name, "RSA") != 0) {
438 printf("Not an RSA key, the key is of algorithm %s.\n", key_info->algorithm_name);
439 libhsm_key_info_free(key_info);
440 free(key);
441 free(name);
442 free(id);
443 return -1;
444 }
445 break;
446 case LDNS_SIGN_DSA:
447 case LDNS_SIGN_DSA_NSEC3:
448 if (strcmp(key_info->algorithm_name, "DSA") != 0) {
449 printf("Not a DSA key, the key is of algorithm %s.\n", key_info->algorithm_name);
450 libhsm_key_info_free(key_info);
451 free(key);
452 free(name);
453 free(id);
454 return -1;
455 }
456 break;
457 case LDNS_SIGN_ECC_GOST:
458 if (strcmp(key_info->algorithm_name, "GOST") != 0) {
459 printf("Not a GOST key, the key is of algorithm %s.\n", key_info->algorithm_name);
460 libhsm_key_info_free(key_info);
461 free(key);
462 free(name);
463 free(id);
464 return -1;
465 }
466 break;
467 case LDNS_SIGN_ECDSAP256SHA256:
468 if (strcmp(key_info->algorithm_name, "ECDSA") != 0) {
469 printf("Not an ECDSA key, the key is of algorithm %s.\n", key_info->algorithm_name);
470 libhsm_key_info_free(key_info);
471 free(key);
472 free(name);
473 free(id);
474 return -1;
475 }
476 if (key_info->keysize != 256) {
477 printf("The key is a ECDSA/%lu, expecting ECDSA/256 for this algorithm.\n", key_info->keysize);
478 libhsm_key_info_free(key_info);
479 free(key);
480 free(name);
481 free(id);
482 return -1;
483 }
484 break;
485 case LDNS_SIGN_ECDSAP384SHA384:
486 if (strcmp(key_info->algorithm_name, "ECDSA") != 0) {
487 printf("Not an ECDSA key, the key is of algorithm %s.\n", key_info->algorithm_name);
488 libhsm_key_info_free(key_info);
489 free(key);
490 free(name);
491 free(id);
492 return -1;
493 }
494 if (key_info->keysize != 384) {
495 printf("The key is a ECDSA/%lu, expecting ECDSA/384 for this algorithm.\n", key_info->keysize);
496 libhsm_key_info_free(key_info);
497 free(key);
498 free(name);
499 free(id);
500 return -1;
501 }
502 break;
503#if (LDNS_REVISION >= ((1<<16)|(7<<8)|(0)))
504 case LDNS_SIGN_ED25519:
505 if (strcmp(key_info->algorithm_name, "EDDSA") != 0) {
506 printf("Not an EDDSA key, the key is of algorithm %s.\n", key_info->algorithm_name);
507 libhsm_key_info_free(key_info);
508 free(key);
509 free(name);
510 free(id);
511 return -1;
512 }
513 if (key_info->keysize != 255) {
514 printf("The key is EDDSA/%lu, expecting EDDSA/255 for this algorithm.\n", key_info->keysize);
515 libhsm_key_info_free(key_info);
516 free(key);
517 free(name);
518 free(id);
519 return -1;
520 }
521 break;
522 case LDNS_SIGN_ED448:
523 if (strcmp(key_info->algorithm_name, "EDDSA") != 0) {
524 printf("Not an EDDSA key, the key is of algorithm %s.\n", key_info->algorithm_name);
525 libhsm_key_info_free(key_info);
526 free(key);
527 free(name);
528 free(id);
529 return -1;
530 }
531 if (key_info->keysize != 448) {
532 printf("The key is EDDSA/%lu, expecting EDDSA/448 for this algorithm.\n", key_info->keysize);
533 libhsm_key_info_free(key_info);
534 free(key);
535 free(name);
536 free(id);
537 return -1;
538 }
539 break;
540#endif
541 default:
542 printf("Invalid algorithm: %i\n", algo);
543 libhsm_key_info_free(key_info);
544 free(key);
545 free(name);
546 free(id);
547 return -1;
548 }
549 libhsm_key_info_free(key_info);
550
551 sign_params = hsm_sign_params_new();
552 sign_params->algorithm = algo;
553 sign_params->flags = type;
554 sign_params->owner = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, name);
555 dnskey_rr = hsm_get_dnskey(ctx, key, sign_params);
556 sign_params->keytag = ldns_calc_keytag(dnskey_rr);
557
558 ldns_rr_print(stdout, dnskey_rr);
559
560 hsm_sign_params_free(sign_params);
561 ldns_rr_free(dnskey_rr);
562 libhsm_key_free(key);
563 free(name);
564 free(id);
565
566 return 0;
567}
568
569static int
570cmd_test (int argc, char *argv[], hsm_ctx_t* ctx)
571{
572 char *repository = NULL;
573
574 if (argc) {
575 repository = strdup(argv[0]);
576 argc--;
577 argv++;
578
579 printf("Testing repository: %s\n\n", repository);
580 int rv = hsm_test(repository, ctx);
581 if (repository) free(repository);
582 return rv;
583 } else {
584 usage();
585 }
586
587 return 0;
588}
589
590static int
591cmd_info (hsm_ctx_t* ctx)
592{
594
595 return 0;
596}
597
598static int
599cmd_debug (hsm_ctx_t* ctx)
600{
602
603 return 0;
604}
605
606int
607main (int argc, char *argv[])
608{
609 int result;
610
611 char *config = NULL;
612
613 int ch;
614 int force = 0;
615 progname = argv[0];
616
617 while ((ch = getopt(argc, argv, "c:vVhf")) != -1) {
618 switch (ch) {
619 case 'c':
620 config = strdup(optarg);
621 break;
622 case 'f':
623 force = 1;
624 break;
625 case 'v':
626 verbose++;
627 break;
628 case 'V':
629 version();
630 exit(0);
631 break;
632 case 'h':
633 usage();
634 exit(0);
635 break;
636 default:
637 usage();
638 exit(1);
639 }
640 }
641 argc -= optind;
642 argv += optind;
643
644 if (!argc) {
645 usage();
646 exit(1);
647 }
648
649
650 if (!strcasecmp(argv[0], "logout")) {
651 if (config) free(config);
652 exit(cmd_logout());
653 }
654
655 result = hsm_open2(parse_conf_repositories(config?config:HSM_DEFAULT_CONFIG), hsm_prompt_pin);
656 if (result != HSM_OK) {
657 char* error = hsm_get_error(NULL);
658 if (error != NULL) {
659 fprintf(stderr,"%s\n", error);
660 free(error);
661 }
662 exit(-1);
663 }
665
666 openlog("hsmutil", LOG_PID, LOG_USER);
667
668 if (!strcasecmp(argv[0], "login")) {
669 argc --;
670 argv ++;
671 result = cmd_login();
672 } else if (!strcasecmp(argv[0], "list")) {
673 argc --;
674 argv ++;
675 result = cmd_list(argc, argv);
676 } else if (!strcasecmp(argv[0], "generate")) {
677 argc --;
678 argv ++;
679 result = cmd_generate(argc, argv);
680 } else if (!strcasecmp(argv[0], "remove")) {
681 argc --;
682 argv ++;
683 result = cmd_remove(argc, argv);
684 } else if (!strcasecmp(argv[0], "purge")) {
685 argc --;
686 argv ++;
687 result = cmd_purge(argc, argv, force);
688 } else if (!strcasecmp(argv[0], "dnskey")) {
689 argc --;
690 argv ++;
691 result = cmd_dnskey(argc, argv);
692 } else if (!strcasecmp(argv[0], "test")) {
693 argc --;
694 argv ++;
695 result = cmd_test(argc, argv, ctx);
696 } else if (!strcasecmp(argv[0], "info")) {
697 argc --;
698 argv ++;
699 result = cmd_info(ctx);
700 } else if (!strcasecmp(argv[0], "debug")) {
701 argc --;
702 argv ++;
703 result = cmd_debug(ctx);
704 } else {
705 usage();
706 result = -1;
707 }
708
710 hsm_close();
711 if (config) free(config);
712
713 closelog();
714
715 exit(result);
716}
ldns_algorithm algorithm
Definition hsmspeed.c:43
int hsm_test(const char *repository, hsm_ctx_t *ctx)
Definition hsmtest.c:107
int main(int argc, char *argv[])
Definition hsmutil.c:607
unsigned int verbose
Definition hsmutil.c:45
hsm_repository_t * parse_conf_repositories(const char *cfgfile)
Definition confparser.c:51
char * progname
Definition hsmutil.c:44
char * optarg
hsm_ctx_t * ctx
Definition hsmutil.c:46
void libhsm_key_list_free(libhsm_key_t **key_list, size_t count)
Definition libhsm.c:3053
char * hsm_get_error(hsm_ctx_t *gctx)
Definition libhsm.c:3414
void hsm_print_error(hsm_ctx_t *gctx)
Definition libhsm.c:3493
libhsm_key_t * hsm_find_key_by_id(hsm_ctx_t *ctx, const char *id)
Definition libhsm.c:2521
int hsm_token_attached(hsm_ctx_t *ctx, const char *repository)
Definition libhsm.c:3397
libhsm_key_t * hsm_generate_rsa_key(hsm_ctx_t *ctx, const char *repository, unsigned long keysize)
Definition libhsm.c:2550
libhsm_key_t * hsm_generate_gost_key(hsm_ctx_t *ctx, const char *repository)
Definition libhsm.c:2752
void hsm_print_key(hsm_ctx_t *ctx, libhsm_key_t *key)
Definition libhsm.c:3467
hsm_sign_params_t * hsm_sign_params_new()
Definition libhsm.c:2448
void hsm_print_ctx(hsm_ctx_t *ctx)
Definition libhsm.c:3456
void libhsm_key_info_free(libhsm_key_info_t *key_info)
Definition libhsm.c:3140
libhsm_key_t ** hsm_list_keys_repository(hsm_ctx_t *ctx, size_t *count, const char *repository)
Definition libhsm.c:2504
int hsm_open2(hsm_repository_t *rlist, char *(pin_callback)(unsigned int, const char *, unsigned int))
Definition libhsm.c:2297
ldns_rr * hsm_get_dnskey(hsm_ctx_t *ctx, const libhsm_key_t *key, const hsm_sign_params_t *sign_params)
Definition libhsm.c:3267
libhsm_key_t * hsm_generate_dsa_key(hsm_ctx_t *ctx, const char *repository, unsigned long keysize)
Definition libhsm.c:2638
libhsm_key_t * hsm_generate_ecdsa_key(hsm_ctx_t *ctx, const char *repository, const char *curve)
Definition libhsm.c:2832
void hsm_close()
Definition libhsm.c:2364
int hsm_remove_key(hsm_ctx_t *ctx, libhsm_key_t *key)
Definition libhsm.c:3024
void hsm_print_tokeninfo(hsm_ctx_t *ctx)
Definition libhsm.c:3508
libhsm_key_info_t * hsm_get_key_info(hsm_ctx_t *ctx, const libhsm_key_t *key)
Definition libhsm.c:3089
void hsm_destroy_context(hsm_ctx_t *ctx)
Definition libhsm.c:2439
libhsm_key_t ** hsm_list_keys(hsm_ctx_t *ctx, size_t *count)
Definition libhsm.c:2478
void libhsm_key_free(libhsm_key_t *key)
Definition libhsm.c:2471
void hsm_sign_params_free(hsm_sign_params_t *params)
Definition libhsm.c:2462
hsm_ctx_t * hsm_create_context()
Definition libhsm.c:2374
char * hsm_prompt_pin(unsigned int id, const char *repository, unsigned int mode)
Definition pin.c:228
#define HSM_MAX_ALGONAME
Definition libhsm.h:47
#define HSM_OK
Definition libhsm.h:65
int hsm_logout_pin(void)
Definition pin.c:413
ldns_algorithm algorithm
Definition libhsmdns.h:36
ldns_rdf * owner
Definition libhsmdns.h:46
uint16_t keytag
Definition libhsmdns.h:44
char * algorithm_name
Definition libhsm.h:112
unsigned long keysize
Definition libhsm.h:113
char * modulename
Definition libhsm.h:103