diff --git a/.gitignore b/.gitignore index 18b037df..efb78d60 100644 --- a/.gitignore +++ b/.gitignore @@ -70,6 +70,7 @@ examples/x25519keygen examples/x448keygen examples/falcon512keygen examples/mldsa87keygen +examples/mlkem768keygen examples/slhdsa256skeygen examples/storecert @@ -98,6 +99,7 @@ tests/ed448-keygen tests/ed25519-keygen-prov tests/ed448-keygen-prov tests/mldsa87-keygen-prov +tests/mlkem768-keygen-prov tests/check-all-prov tests/*.log diff --git a/NEWS b/NEWS index 2435f4d2..799ac857 100644 --- a/NEWS +++ b/NEWS @@ -1,6 +1,9 @@ NEWS for Libp11 -- History of user visible changes New in 0.4.20; unreleased +* Updated the bundled PKCS#11 header to version 3.2. (Małgorzata Olszówka) +* Added PKCS#11 provider support for ML-KEM key generation, + encapsulation and decapsulation (Małgorzata Olszówka) New in 0.4.19; 2026-07-21; Michał Trojnara * Define LIBP11_VERSION_NUMBER (Michał Trojnara) diff --git a/examples/Makefile.am b/examples/Makefile.am index f20d0fa9..683e2c6a 100644 --- a/examples/Makefile.am +++ b/examples/Makefile.am @@ -7,7 +7,8 @@ EXTRA_DIST = README noinst_PROGRAMS = auth decrypt getrandom listkeys listkeys_ext \ ed25519keygen ed448keygen eckeygen rsakeygen \ x25519keygen x448keygen \ - mldsa87keygen slhdsa256skeygen falcon512keygen \ + mldsa87keygen mlkem768keygen \ + slhdsa256skeygen falcon512keygen \ storecert LDADD = ../src/libp11.la $(OPENSSL_LIBS) diff --git a/examples/mlkem768keygen.c b/examples/mlkem768keygen.c new file mode 100644 index 00000000..3de7501c --- /dev/null +++ b/examples/mlkem768keygen.c @@ -0,0 +1,193 @@ +/* + * Copyright © 2026 Mobi - Com Polska Sp. z o.o. + * Author: Małgorzata Olszówka + * All rights reserved. + * + * Module-Lattice-based KEM ML-KEM-768 key pair generation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include + +#if !defined(OPENSSL_NO_ML_KEM) && (OPENSSL_VERSION_NUMBER >= 0x30500000L) + +#define EVP_PKEY_ML_KEM_768 NID_ML_KEM_768 + +#define CHECK_ERR(cond, txt, code) \ + do { \ + if (cond) { \ + fprintf(stderr, "%s\n", (txt)); \ + rc=(code); \ + goto end; \ + } \ + } while (0) + +static void error_queue(const char *name) +{ + if (ERR_peek_last_error()) { + fprintf(stderr, "%s generated errors:\n", name); + ERR_print_errors_fp(stderr); + } +} + +static int hex_to_bytes(const char *hex, unsigned char *out, size_t out_len) +{ + size_t i; + + for (i = 0; i < out_len; i++) { + if (sscanf(hex + (i * 2), "%2hhx", &out[i]) != 1) { + return -1; + } + } + return 0; +} + +static void list_keys(const char *title, const PKCS11_KEY *keys, + const unsigned int nkeys) { + unsigned int i; + + printf("\n%s:\n", title); + for (i = 0; i < nkeys; i++) { + printf(" #%d id=", i); + for (size_t j = 0; j < keys[i].id_len; j++) { + printf("%02x", keys[i].id[j]); + } + printf(";object=%s\n", keys[i].label); + } +} + +int main(int argc, char *argv[]) +{ + PKCS11_CTX *ctx = NULL; + PKCS11_SLOT *slots = NULL, *slot; + PKCS11_KEY *keys; + unsigned int nslots, nkeys; + unsigned char *key_id = NULL; + size_t len, key_id_len; + const char *key_id_str; + int rc = 0; + PKCS11_params params = {.sensitive = 1, .extractable = 0}; + PKCS11_EDDSA_KGEN mlkem = {.nid = NID_ML_KEM_768}; + PKCS11_KGEN_ATTRS eckg = {0}; + + if (argc < 6) { + fprintf(stderr, "usage: %s [module] [TOKEN] [KEY-LABEL] [KEY-ID] [PIN]\n", argv[0]); + return 1; + } + key_id_str = argv[4]; + len = strlen(key_id_str); + CHECK_ERR(len % 2 != 0, "Invalid key ID format: odd length", 1); + + /* key_id_str is a null-terminated string, but key_id is not */ + key_id_len = len / 2; + key_id = OPENSSL_malloc(key_id_len); + CHECK_ERR(!key_id, "Memory allocation failed for key ID", 2); + + rc = hex_to_bytes(key_id_str, key_id, key_id_len); + CHECK_ERR(rc != 0, "Invalid hex digit in key ID", 3); + + ctx = PKCS11_CTX_new(); + error_queue("PKCS11_CTX_new"); + + /* load PKCS#11 module */ + rc = PKCS11_CTX_load(ctx, argv[1]); + error_queue("PKCS11_CTX_load"); + CHECK_ERR(rc < 0, "loading PKCS#11 module failed", 4); + + /* get information on all slots */ + rc = PKCS11_enumerate_slots(ctx, &slots, &nslots); + error_queue("PKCS11_enumerate_slots"); + CHECK_ERR(rc < 0, "no slots available", 5); + + slot = PKCS11_find_token(ctx, slots, nslots); + error_queue("PKCS11_find_token"); + while (slot) { + if (slot->token && slot->token->initialized && slot->token->label + && strcmp(argv[2], slot->token->label) == 0) + break; + slot = PKCS11_find_next_token(ctx, slots, nslots, slot); + }; + CHECK_ERR(!slot || !slot->token, "no token available", 6); + + printf("Found token:\n"); + printf("Slot manufacturer......: %s\n", slot->manufacturer); + printf("Slot description.......: %s\n", slot->description); + printf("Slot token label.......: %s\n", slot->token->label); + printf("Slot token serialnr....: %s\n", slot->token->serialnr); + + rc = PKCS11_login(slot, 0, argv[5]); + error_queue("PKCS11_login"); + CHECK_ERR(rc < 0, "PKCS11_login failed", 7); + + eckg.type = EVP_PKEY_ML_KEM_768; + eckg.kgen.eddsa = &mlkem; + eckg.token_label = argv[2]; + eckg.key_label = argv[3]; + /* key_id is a raw binary buffer of length key_id_len */ + eckg.key_id = (const unsigned char *)key_id; + eckg.id_len = key_id_len; + eckg.key_params = ¶ms; + + rc = PKCS11_keygen(slot->token, &eckg); + error_queue("PKCS11_keygen"); + CHECK_ERR(rc < 0, "Failed to generate a key pair on the token", 8); + + printf("\nML-KEM-768 keys generated\n"); + + /* get private keys */ + rc = PKCS11_enumerate_keys(slot->token, &keys, &nkeys); + error_queue("PKCS11_enumerate_keys"); + CHECK_ERR(rc < 0, "PKCS11_enumerate_keys failed", 9); + CHECK_ERR(nkeys == 0, "No private keys found", 10); + list_keys("Private keys", keys, nkeys); + +end: + if (slots) + PKCS11_release_all_slots(ctx, slots, nslots); + if (ctx) { + PKCS11_CTX_unload(ctx); + PKCS11_CTX_free(ctx); + } + OPENSSL_free(key_id); + + if (rc) + printf("Failed (error code %d).\n", rc); + else + printf("Success.\n"); + return rc; +} + +#else /* !OPENSSL_NO_ML_KEM && OpenSSL 3.5 */ + +#include + +int main(void) +{ + fprintf(stderr, "Skipped: requires OpenSSL 3.5 built with ML-KEM support\n"); + return 77; +} + +#endif /* !OPENSSL_NO_ML_KEM && OpenSSL 3.5 */ + +/* vim: set noexpandtab: */ diff --git a/src/libp11-int.h b/src/libp11-int.h index dde47f1f..8a18121c 100644 --- a/src/libp11-int.h +++ b/src/libp11-int.h @@ -52,6 +52,12 @@ extern int NID_FALCON_512; extern int NID_FALCON_1024; #endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */ +#if !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L +#define EVP_PKEY_ML_KEM_512 NID_ML_KEM_512 +#define EVP_PKEY_ML_KEM_768 NID_ML_KEM_768 +#define EVP_PKEY_ML_KEM_1024 NID_ML_KEM_1024 +#endif /* !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ + /* forward type declarations */ typedef struct pkcs11_keys PKCS11_keys; typedef struct pkcs11_object_ops PKCS11_OBJECT_ops; @@ -65,6 +71,7 @@ typedef struct pkcs11_template_st PKCS11_TEMPLATE; struct pkcs11_ctx_private { int flags; CK_FUNCTION_LIST_PTR method; + CK_FUNCTION_LIST_3_2_PTR method_3_2; void *handle; char *init_args; CK_VERSION cryptoki_version; @@ -143,6 +150,11 @@ extern PKCS11_OBJECT_ops pkcs11_mldsa44_ops; extern PKCS11_OBJECT_ops pkcs11_mldsa65_ops; extern PKCS11_OBJECT_ops pkcs11_mldsa87_ops; #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM +extern PKCS11_OBJECT_ops pkcs11_mlkem512_ops; +extern PKCS11_OBJECT_ops pkcs11_mlkem768_ops; +extern PKCS11_OBJECT_ops pkcs11_mlkem1024_ops; +#endif /* OPENSSL_NO_ML_KEM */ #ifndef OPENSSL_NO_SLH_DSA extern PKCS11_OBJECT_ops pkcs11_slhdsa_sha2_128s_ops; extern PKCS11_OBJECT_ops pkcs11_slhdsa_sha2_128f_ops; @@ -177,6 +189,10 @@ extern PKCS11_OBJECT_ops pkcs11_falcon1024_ops; } while (0) #define CRYPTOKI_call(ctx, func_and_args) \ ctx->method->func_and_args + +#define CRYPTOKI_call_3_2(ctx, func_and_args) \ + (ctx)->method_3_2->func_and_args + extern int ERR_load_CKR_strings(void); /* Memory allocation */ @@ -203,7 +219,8 @@ extern int check_slot_fork(PKCS11_SLOT_private *slot); extern int check_object_fork(PKCS11_OBJECT_private *key); /* Other internal functions */ -extern void *C_LoadModule(const char *name, CK_FUNCTION_LIST_PTR_PTR); +extern void *C_LoadModule(const char *name, CK_FUNCTION_LIST_PTR_PTR, + CK_FUNCTION_LIST_3_2_PTR_PTR); extern CK_RV C_UnloadModule(void *module); extern void pkcs11_destroy_keys(PKCS11_SLOT_private *, unsigned int); extern void pkcs11_destroy_certs(PKCS11_SLOT_private *); @@ -411,6 +428,12 @@ extern int pkcs11_mldsa_keygen(PKCS11_SLOT_private *tpriv, size_t id_len, const PKCS11_params *params); #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM +extern int pkcs11_mlkem_keygen(PKCS11_SLOT_private *tpriv, + int nid, const char *label, const unsigned char *id, + size_t id_len, const PKCS11_params *params); +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA extern int pkcs11_slhdsa_keygen(PKCS11_SLOT_private *tpriv, int nid, const char *label, const unsigned char *id, @@ -510,6 +533,18 @@ extern int pkcs11_evp_pkey_xdh_derive(PKCS11_OBJECT_private *key, unsigned char *secret, size_t *secretlen); #endif /* !defined(OPENSSL_NO_ECX) && OPENSSL_VERSION_NUMBER >= 0x30000000L */ +#if OPENSSL_VERSION_NUMBER >= 0x30000000L +extern int pkcs11_evp_pkey_rsa_decapsulate(PKCS11_OBJECT_private *key, + unsigned char *out, size_t *outlen, + const unsigned char *in, size_t inlen); +#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */ + +#if !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L +extern int pkcs11_evp_pkey_ml_kem_decapsulate(PKCS11_OBJECT_private *key, + unsigned char *out, size_t *outlen, + const unsigned char *in, size_t inlen); +#endif /* !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ + /* This function has never been implemented */ extern int pkcs11_verify(int type, const unsigned char *m, unsigned int m_len, diff --git a/src/libp11.exports b/src/libp11.exports index d2ab387c..a0834ed2 100644 --- a/src/libp11.exports +++ b/src/libp11.exports @@ -42,6 +42,7 @@ PKCS11_evp_pkey_sign PKCS11_evp_pkey_verify PKCS11_evp_pkey_decrypt PKCS11_evp_pkey_derive +PKCS11_evp_pkey_decapsulate PKCS11_private_encrypt PKCS11_private_decrypt PKCS11_verify diff --git a/src/libp11.h b/src/libp11.h index 0f4b3cab..08fd9ad4 100644 --- a/src/libp11.h +++ b/src/libp11.h @@ -581,6 +581,11 @@ extern int PKCS11_evp_pkey_derive(EVP_PKEY *pk, int type, const unsigned char *peer_pub, size_t peer_pub_len, int cofactor_mode, unsigned char *secret, size_t *secretlen); +/* Perform a private-key decapsulate operation using a PKCS#11-backed EVP_PKEY */ +extern int PKCS11_evp_pkey_decapsulate(EVP_PKEY *pk, int type, + unsigned char *out, size_t *outlen, + const unsigned char *in, size_t inlen); + #endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */ /* Encrypts data using the private key */ diff --git a/src/libpkcs11.c b/src/libpkcs11.c index bef4e1b9..27e434b2 100644 --- a/src/libpkcs11.c +++ b/src/libpkcs11.c @@ -42,28 +42,39 @@ struct sc_pkcs11_module { typedef struct sc_pkcs11_module sc_pkcs11_module_t; /* - * Load a module - this will load the shared object, call - * C_Initialize, and get the list of function pointers + * Load a module - this will load the shared object and get + * the legacy and, if available, PKCS#11 3.2 function lists. */ void * -C_LoadModule(const char *mspec, CK_FUNCTION_LIST_PTR_PTR funcs) +C_LoadModule(const char *mspec, CK_FUNCTION_LIST_PTR_PTR funcs, + CK_FUNCTION_LIST_3_2_PTR_PTR funcs_3_2) { sc_pkcs11_module_t *mod; /* POSIX requires that the result of dlsym() is safely convertible * to a function pointer, even though ISO C doesn't guarantee this. */ union { - CK_RV (*func)(CK_FUNCTION_LIST_PTR_PTR); + CK_C_GetFunctionList func; void *data; } c_get_function_list; - int rv; + union { + CK_C_GetInterface func; + void *data; + } c_get_interface; + CK_INTERFACE_PTR interface = NULL; + CK_VERSION version = {3, 2}; + CK_RV rv; - if (!mspec) + if (!mspec || !funcs) return NULL; - mod = OPENSSL_malloc(sizeof(sc_pkcs11_module_t)); + *funcs = NULL; + if (funcs_3_2) + *funcs_3_2 = NULL; + + mod = OPENSSL_zalloc(sizeof(sc_pkcs11_module_t)); if (!mod) return NULL; - memset(mod, 0, sizeof(sc_pkcs11_module_t)); + mod->_magic = MAGIC; /* The caller intentionally selects the PKCS#11 module to load. */ @@ -80,6 +91,8 @@ C_LoadModule(const char *mspec, CK_FUNCTION_LIST_PTR_PTR funcs) goto failed; } + /* C_GetFunctionList provides the legacy PKCS#11 2.40-compatible + * function list used by existing libp11 code. */ #ifdef WIN32 c_get_function_list.func = (CK_C_GetFunctionList) GetProcAddress(mod->handle, "C_GetFunctionList"); @@ -93,9 +106,33 @@ C_LoadModule(const char *mspec, CK_FUNCTION_LIST_PTR_PTR funcs) #endif goto failed; } + rv = c_get_function_list.func(funcs); - if (rv == CKR_OK) - return mod; + if (rv != CKR_OK) + goto failed; + + /* + * C_GetInterface is optional. Use it to obtain the PKCS#11 3.2 + * function list containing C_EncapsulateKey and C_DecapsulateKey. + */ +#ifdef WIN32 + c_get_interface.func = (CK_C_GetInterface) + GetProcAddress(mod->handle, "C_GetInterface"); +#else + c_get_interface.data = dlsym(mod->handle, "C_GetInterface"); +#endif + + if (c_get_interface.func && funcs_3_2) { + rv = c_get_interface.func((CK_UTF8CHAR_PTR)"PKCS 11", + &version, &interface, 0); + + if (rv == CKR_OK && interface && interface->pFunctionList) { + *funcs_3_2 = (CK_FUNCTION_LIST_3_2_PTR) + interface->pFunctionList; + } + } + + return mod; failed: C_UnloadModule((void *) mod); diff --git a/src/p11_front.c b/src/p11_front.c index af35a6aa..7cffe80e 100644 --- a/src/p11_front.c +++ b/src/p11_front.c @@ -451,6 +451,14 @@ int PKCS11_keygen(PKCS11_TOKEN *token, PKCS11_KGEN_ATTRS *kg) kg->key_label, kg->key_id, kg->id_len, kg->key_params); #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM + case EVP_PKEY_ML_KEM_512: + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: + return pkcs11_mlkem_keygen(slot, kg->kgen.nid->nid, + kg->key_label, kg->key_id, kg->id_len, kg->key_params); +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA case EVP_PKEY_SLH_DSA_SHA2_128S: case EVP_PKEY_SLH_DSA_SHA2_128F: @@ -606,6 +614,47 @@ int PKCS11_generate_key(PKCS11_TOKEN *token, int algorithm, break; #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM + case EVP_PKEY_ML_KEM_512: + nid_kgen.nid = NID_ML_KEM_512; + kgen_attrs = (PKCS11_KGEN_ATTRS){ + .type = EVP_PKEY_ML_KEM_512, + .kgen.nid = &nid_kgen, + .token_label = (const char *)token->label, + .key_label = label, + .key_id = (const unsigned char *)id, + .id_len = id_len, + .key_params = &key_params + }; + break; + + case EVP_PKEY_ML_KEM_768: + nid_kgen.nid = NID_ML_KEM_768; + kgen_attrs = (PKCS11_KGEN_ATTRS){ + .type = EVP_PKEY_ML_KEM_768, + .kgen.nid = &nid_kgen, + .token_label = (const char *)token->label, + .key_label = label, + .key_id = (const unsigned char *)id, + .id_len = id_len, + .key_params = &key_params + }; + break; + + case EVP_PKEY_ML_KEM_1024: + nid_kgen.nid = NID_ML_KEM_1024; + kgen_attrs = (PKCS11_KGEN_ATTRS){ + .type = EVP_PKEY_ML_KEM_1024, + .kgen.nid = &nid_kgen, + .token_label = (const char *)token->label, + .key_label = label, + .key_id = (const unsigned char *)id, + .id_len = id_len, + .key_params = &key_params + }; + break; +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA case EVP_PKEY_SLH_DSA_SHA2_128S: nid_kgen.nid = NID_SLH_DSA_SHA2_128s; @@ -976,6 +1025,31 @@ int PKCS11_evp_pkey_derive(EVP_PKEY *pk, int type, } #endif /* !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_ECX) */ +int PKCS11_evp_pkey_decapsulate(EVP_PKEY *pk, int type, + unsigned char *out, size_t *outlen, + const unsigned char *in, size_t inlen) +{ + PKCS11_OBJECT_private *key = pkcs11_get_ex_data_object(pk); + + if (check_object_fork(key) < 0) + return -1; + + switch (type) { + case EVP_PKEY_RSA: + return pkcs11_evp_pkey_rsa_decapsulate(key, out, outlen, + in, inlen); +#if !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L + case EVP_PKEY_ML_KEM_512: + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: + return pkcs11_evp_pkey_ml_kem_decapsulate(key, out, outlen, + in, inlen); +#endif /* !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ + default: + return -2; /* type not supported */ + } +} + #endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */ int PKCS11_private_encrypt(int flen, const unsigned char *from, unsigned char *to, diff --git a/src/p11_key.c b/src/p11_key.c index 89d5f9a0..371a4843 100644 --- a/src/p11_key.c +++ b/src/p11_key.c @@ -143,12 +143,16 @@ static void pkcs11_luna_privkey_attr(PKCS11_TEMPLATE *, const char *, const unsigned char *, size_t, const PKCS11_params *); static PKCS11_OBJECT_ops *pkcs11_mldsa_ops_from_param(CK_ULONG param_set); #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM +static PKCS11_OBJECT_ops *pkcs11_mlkem_ops_from_param(CK_ULONG param_set); +#endif /* OPENSSL_NO_ML_KEM */ #ifndef OPENSSL_NO_SLH_DSA static PKCS11_OBJECT_ops *pkcs11_slhdsa_ops_from_param(CK_ULONG param_set); #endif /* OPENSSL_NO_SLH_DSA */ #endif /* OPENSSL_VERSION_NUMBER >= 0x30500000L */ #if OPENSSL_VERSION_NUMBER >= 0x30000000L +static EVP_PKEY *pkcs11_dup_raw_public_key(EVP_PKEY *pkey); static PKCS11_OBJECT_ops *pkcs11_falcon_ops_from_param(CK_ULONG param_set); #endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */ @@ -299,6 +303,34 @@ PKCS11_OBJECT_private *pkcs11_object_from_handle(PKCS11_SLOT_private *slot, break; } #endif /* OPENSSL_NO_ML_DSA */ + +#ifndef OPENSSL_NO_ML_KEM + case CKK_ML_KEM: { + CK_ULONG param_set; + + if (pkcs11_getattr_alloc(ctx, session, object, + CKA_PARAMETER_SET, &data, &size)) { + pkcs11_log(ctx, LOG_DEBUG, + "Missing CKA_PARAMETER_SET attribute\n"); + return NULL; + } + if (size != sizeof(CK_ULONG)) { + pkcs11_log(ctx, LOG_DEBUG, "Invalid CKA_PARAMETER_SET size for ML-KEM\n"); + OPENSSL_free(data); + return NULL; + } + memcpy(¶m_set, data, sizeof(param_set)); + OPENSSL_free(data); + + ops = pkcs11_mlkem_ops_from_param(param_set); + if (ops == NULL) { + pkcs11_log(ctx, LOG_DEBUG, "Unsupported ML-KEM parameter set\n"); + return NULL; + } + break; + } +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA case CKK_SLH_DSA: { CK_ULONG param_set; @@ -560,6 +592,7 @@ int pkcs11_rsa_keygen(PKCS11_SLOT_private *slot, unsigned int bits, /* The following attributes are necessary for RSA encryption and DSA */ /* pubkey attributes */ pkcs11_common_pubkey_attr(&pubtmpl, label, id, id_len); + pkcs11_addattr_bool(&pubtmpl, CKA_VERIFY, TRUE); pkcs11_addattr_bool(&pubtmpl, CKA_ENCRYPT, TRUE); pkcs11_addattr_var(&pubtmpl, CKA_MODULUS_BITS, num_bits); pkcs11_addattr(&pubtmpl, CKA_PUBLIC_EXPONENT, @@ -567,6 +600,7 @@ int pkcs11_rsa_keygen(PKCS11_SLOT_private *slot, unsigned int bits, /* privkey attributes */ pkcs11_common_privkey_attr(&privtmpl, label, id, id_len, params); + pkcs11_addattr_bool(&privtmpl, CKA_SIGN, TRUE); pkcs11_addattr_bool(&privtmpl, CKA_DECRYPT, TRUE); /* call the pkcs11 module to create the key pair */ @@ -654,9 +688,12 @@ int pkcs11_ec_keygen(PKCS11_SLOT_private *slot, const char *curve, /* pubkey attributes */ pkcs11_common_pubkey_attr(&pubtmpl, label, id, id_len); pkcs11_addattr(&pubtmpl, CKA_EC_PARAMS, ec_params, ec_params_len); + pkcs11_addattr_bool(&pubtmpl, CKA_VERIFY, TRUE); + pkcs11_addattr_bool(&pubtmpl, CKA_DERIVE, TRUE); /* privkey attributes */ pkcs11_common_privkey_attr(&privtmpl, label, id, id_len, params); + pkcs11_addattr_bool(&privtmpl, CKA_SIGN, TRUE); pkcs11_addattr_bool(&privtmpl, CKA_DERIVE, TRUE); /* call the pkcs11 module to create the key pair */ @@ -810,7 +847,7 @@ int pkcs11_mldsa_keygen(PKCS11_SLOT_private *slot, CK_MECHANISM mechanism = { CKM_ML_DSA_KEY_PAIR_GEN, NULL_PTR, 0 }; - CK_SIGN_PARAMETER_SET_TYPE signParamSet = 0; + CK_ULONG signParamSet = 0; CK_OBJECT_HANDLE pub_key_obj, priv_key_obj; CK_RV rv; @@ -861,10 +898,10 @@ int pkcs11_mldsa_keygen(PKCS11_SLOT_private *slot, pkcs11_luna_pubkey_attr(&pubtmpl, label, id, id_len); pkcs11_addattr(&pubtmpl, CKA_PARAMETER_SET, &signParamSet, sizeof(signParamSet)); + pkcs11_addattr_bool(&pubtmpl, CKA_VERIFY, TRUE); pkcs11_luna_privkey_attr(&privtmpl, label, id, id_len, params); - pkcs11_addattr(&privtmpl, CKA_PARAMETER_SET, - &signParamSet, sizeof(signParamSet)); + pkcs11_addattr_bool(&privtmpl, CKA_SIGN, TRUE); pub_key_obj = CK_INVALID_HANDLE; priv_key_obj = CK_INVALID_HANDLE; @@ -885,6 +922,98 @@ int pkcs11_mldsa_keygen(PKCS11_SLOT_private *slot, return 0; } #endif /* OPENSSL_NO_ML_DSA */ + +#ifndef OPENSSL_NO_ML_KEM +/** + * Generate ML-KEM (ML-KEM-512 / ML-KEM-768 / ML-KEM-1024) + * key pair directly on token. + */ +int pkcs11_mlkem_keygen(PKCS11_SLOT_private *slot, int nid, + const char *label, const unsigned char *id, size_t id_len, + const PKCS11_params *params) +{ + PKCS11_CTX_private *ctx = slot->ctx; + CK_SESSION_HANDLE session; + PKCS11_TEMPLATE pubtmpl = {0}, privtmpl = {0}; + CK_MECHANISM mechanism = { + CKM_ML_KEM_KEY_PAIR_GEN, NULL_PTR, 0 + }; + CK_ML_KEM_PARAMETER_SET_TYPE kemParamSet = 0; + CK_OBJECT_HANDLE pub_key_obj, priv_key_obj; + CK_RV rv; + + if (pkcs11_init_keygen(slot, &session)) + return -1; + + switch (nid) { + case NID_ML_KEM_512: + kemParamSet = CKP_ML_KEM_512; + break; + case NID_ML_KEM_768: + kemParamSet = CKP_ML_KEM_768; + break; + case NID_ML_KEM_1024: + kemParamSet = CKP_ML_KEM_1024; + break; + default: + pkcs11_put_session(slot, session); + return -1; /* unsupported */ + } + + /* public key attributes */ + pkcs11_common_pubkey_attr(&pubtmpl, label, id, id_len); + pkcs11_addattr(&pubtmpl, CKA_PARAMETER_SET, + &kemParamSet, sizeof(kemParamSet)); + pkcs11_addattr_bool(&pubtmpl, CKA_ENCAPSULATE, TRUE); + + /* private key attributes */ + pkcs11_common_privkey_attr(&privtmpl, label, id, id_len, params); + pkcs11_addattr_bool(&privtmpl, CKA_DECAPSULATE, TRUE); + + /* generate the key pair */ + rv = CRYPTOKI_call(ctx, C_GenerateKeyPair( + session, (CK_MECHANISM_PTR)&mechanism, + pubtmpl.attrs, pubtmpl.nattr, + privtmpl.attrs, privtmpl.nattr, + &pub_key_obj, &priv_key_obj)); + + if (rv != CKR_OK) { + /* Thales Luna HSM firmware does not support the wrapping + * or unwrapping of CK_ML_KEM private key objects. + * Retry with these attributes explicitly disabled. */ + pkcs11_zap_attrs(&privtmpl); + pkcs11_zap_attrs(&pubtmpl); + memset(&privtmpl, 0, sizeof(privtmpl)); + memset(&pubtmpl, 0, sizeof(pubtmpl)); + + pkcs11_luna_pubkey_attr(&pubtmpl, label, id, id_len); + pkcs11_addattr(&pubtmpl, CKA_PARAMETER_SET, + &kemParamSet, sizeof(kemParamSet)); + pkcs11_addattr_bool(&pubtmpl, CKA_ENCAPSULATE, TRUE); + + pkcs11_luna_privkey_attr(&privtmpl, label, id, id_len, params); + pkcs11_addattr_bool(&privtmpl, CKA_DECAPSULATE, TRUE); + + pub_key_obj = CK_INVALID_HANDLE; + priv_key_obj = CK_INVALID_HANDLE; + + rv = CRYPTOKI_call(ctx, C_GenerateKeyPair( + session, (CK_MECHANISM_PTR)&mechanism, + pubtmpl.attrs, pubtmpl.nattr, + privtmpl.attrs, privtmpl.nattr, + &pub_key_obj, &priv_key_obj)); + } + + /* cleanup */ + pkcs11_put_session(slot, session); + pkcs11_zap_attrs(&privtmpl); + pkcs11_zap_attrs(&pubtmpl); + + CRYPTOKI_checkerr(CKR_F_PKCS11_GENERATE_KEY, rv); + return 0; +} +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA /** * Generate SLH-DSA key pair directly on token @@ -899,7 +1028,7 @@ int pkcs11_slhdsa_keygen(PKCS11_SLOT_private *slot, CK_MECHANISM mechanism = { CKM_SLH_DSA_KEY_PAIR_GEN, NULL_PTR, 0 }; - CK_SIGN_PARAMETER_SET_TYPE signParamSet = 0; + CK_ULONG signParamSet = 0; CK_OBJECT_HANDLE pub_key_obj, priv_key_obj; CK_RV rv; @@ -956,8 +1085,6 @@ int pkcs11_slhdsa_keygen(PKCS11_SLOT_private *slot, /* private key attributes */ pkcs11_common_privkey_attr(&privtmpl, label, id, id_len, params); - pkcs11_addattr(&privtmpl, CKA_PARAMETER_SET, - &signParamSet, sizeof(signParamSet)); pkcs11_addattr_bool(&privtmpl, CKA_SIGN, TRUE); /* generate key pair */ @@ -994,7 +1121,7 @@ int pkcs11_falcon_keygen(PKCS11_SLOT_private *slot, CK_MECHANISM mechanism = { CKM_PQC_FALCON, NULL_PTR, 0 }; - CK_SIGN_PARAMETER_SET_TYPE signParamSet = 0; + CK_ULONG signParamSet = 0; CK_OBJECT_HANDLE pub_key_obj, priv_key_obj; CK_RV rv; @@ -1229,7 +1356,7 @@ EVP_PKEY *pkcs11_get_key(PKCS11_OBJECT_private *key0, CK_OBJECT_CLASS object_cla #endif #if OPENSSL_VERSION_NUMBER >= 0x30000000L } else { - ret = EVP_PKEY_dup(key->evp_key); + ret = pkcs11_dup_raw_public_key(key->evp_key); #endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */ } @@ -1551,7 +1678,6 @@ static void pkcs11_common_pubkey_attr(PKCS11_TEMPLATE *pubtmpl, if (label) pkcs11_addattr_s(pubtmpl, CKA_LABEL, label); pkcs11_addattr_bool(pubtmpl, CKA_TOKEN, TRUE); - pkcs11_addattr_bool(pubtmpl, CKA_VERIFY, TRUE); pkcs11_addattr_bool(pubtmpl, CKA_WRAP, TRUE); } @@ -1567,13 +1693,11 @@ static void pkcs11_common_privkey_attr(PKCS11_TEMPLATE *privtmpl, pkcs11_addattr_bool(privtmpl, CKA_TOKEN, TRUE); pkcs11_addattr_bool(privtmpl, CKA_SENSITIVE, params->sensitive); pkcs11_addattr_bool(privtmpl, CKA_EXTRACTABLE, params->extractable); - pkcs11_addattr_bool(privtmpl, CKA_SIGN, TRUE); pkcs11_addattr_bool(privtmpl, CKA_UNWRAP, TRUE); } #if OPENSSL_VERSION_NUMBER >= 0x30500000L -#ifndef OPENSSL_NO_ML_DSA - +#if !defined(OPENSSL_NO_ML_DSA) || !defined(OPENSSL_NO_ML_KEM) static void pkcs11_luna_pubkey_attr(PKCS11_TEMPLATE *pubtmpl, const char *label, const unsigned char *id, size_t id_len) { @@ -1582,7 +1706,6 @@ static void pkcs11_luna_pubkey_attr(PKCS11_TEMPLATE *pubtmpl, if (label) pkcs11_addattr_s(pubtmpl, CKA_LABEL, label); pkcs11_addattr_bool(pubtmpl, CKA_TOKEN, TRUE); - pkcs11_addattr_bool(pubtmpl, CKA_VERIFY, TRUE); } static void pkcs11_luna_privkey_attr(PKCS11_TEMPLATE *privtmpl, @@ -1597,9 +1720,10 @@ static void pkcs11_luna_privkey_attr(PKCS11_TEMPLATE *privtmpl, pkcs11_addattr_bool(privtmpl, CKA_TOKEN, TRUE); pkcs11_addattr_bool(privtmpl, CKA_SENSITIVE, params->sensitive); pkcs11_addattr_bool(privtmpl, CKA_EXTRACTABLE, params->extractable); - pkcs11_addattr_bool(privtmpl, CKA_SIGN, TRUE); } +#endif /* !defined(OPENSSL_NO_ML_DSA) || !defined(OPENSSL_NO_ML_KEM) */ +#ifndef OPENSSL_NO_ML_DSA static PKCS11_OBJECT_ops *pkcs11_mldsa_ops_from_param(CK_ULONG param_set) { switch (param_set) { @@ -1615,6 +1739,22 @@ static PKCS11_OBJECT_ops *pkcs11_mldsa_ops_from_param(CK_ULONG param_set) } #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM +static PKCS11_OBJECT_ops *pkcs11_mlkem_ops_from_param(CK_ULONG param_set) +{ + switch (param_set) { + case CKP_ML_KEM_512: + return &pkcs11_mlkem512_ops; + case CKP_ML_KEM_768: + return &pkcs11_mlkem768_ops; + case CKP_ML_KEM_1024: + return &pkcs11_mlkem1024_ops; + default: + return NULL; + } +} +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA static PKCS11_OBJECT_ops *pkcs11_slhdsa_ops_from_param(CK_ULONG param_set) { @@ -1651,6 +1791,52 @@ static PKCS11_OBJECT_ops *pkcs11_slhdsa_ops_from_param(CK_ULONG param_set) #endif /* OPENSSL_VERSION_NUMBER >= 0x30500000L */ #if OPENSSL_VERSION_NUMBER >= 0x30000000L +/* + * Recreate a raw public key, since EVP_PKEY_dup() does not support raw keys. + */ +static EVP_PKEY *pkcs11_dup_raw_public_key(EVP_PKEY *pkey) +{ + const char *name; + unsigned char *pub = NULL; + size_t publen = 0; + EVP_PKEY *ret = NULL; +#if OPENSSL_VERSION_NUMBER < 0x40000000L + PKCS11_OBJECT_private *obj; +#endif /* OPENSSL_VERSION_NUMBER < 0x40000000L */ + + if (pkey == NULL) + return NULL; + + name = EVP_PKEY_get0_type_name(pkey); + if (name == NULL) + return NULL; + + if (!EVP_PKEY_get_raw_public_key(pkey, NULL, &publen) || + publen == 0) + return NULL; + + pub = OPENSSL_malloc(publen); + if (pub == NULL) + return NULL; + + if (!EVP_PKEY_get_raw_public_key(pkey, pub, &publen)) + goto end; + + ret = EVP_PKEY_new_raw_public_key_ex(NULL, name, NULL, pub, publen); + if (ret == NULL) + goto end; + +#if OPENSSL_VERSION_NUMBER < 0x40000000L + /* Preserve the ex_data association used by legacy EVP_PKEY_METHOD wrappers. */ + obj = pkcs11_get_ex_data_pkey(pkey); + if (obj != NULL) + pkcs11_set_ex_data_pkey(ret, obj); +#endif /* OPENSSL_VERSION_NUMBER < 0x40000000L */ +end: + OPENSSL_free(pub); + return ret; +} + static PKCS11_OBJECT_ops *pkcs11_falcon_ops_from_param(CK_ULONG param_set) { switch (param_set) { diff --git a/src/p11_load.c b/src/p11_load.c index 825d8fc0..c5b92ea9 100644 --- a/src/p11_load.c +++ b/src/p11_load.c @@ -177,7 +177,7 @@ int pkcs11_CTX_load(PKCS11_CTX *ctx, const char *name) CK_INFO ck_info; int rv; - cpriv->handle = C_LoadModule(name, &cpriv->method); + cpriv->handle = C_LoadModule(name, &cpriv->method, &cpriv->method_3_2); if (!cpriv->handle) { P11err(P11_F_PKCS11_CTX_LOAD, P11_R_LOAD_MODULE_ERROR); return -1; diff --git a/src/p11_mldsa.c b/src/p11_mldsa.c index ae4803e6..9a04e390 100644 --- a/src/p11_mldsa.c +++ b/src/p11_mldsa.c @@ -3,7 +3,8 @@ * Author: Małgorzata Olszówka * All rights reserved. * - * This file implements the handling of ML-DSA keys stored on a PKCS11 token. + * This file implements the handling of ML-DSA and ML-KEM keys + * stored on a PKCS#11 token. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -30,18 +31,28 @@ #include "libp11-int.h" #include -#if !defined(OPENSSL_NO_ML_DSA) && OPENSSL_VERSION_NUMBER >= 0x30500000L +#if OPENSSL_VERSION_NUMBER >= 0x30500000L +#ifndef OPENSSL_NO_ML_DSA #define ML_DSA_44_PUB_LEN 1312 #define ML_DSA_65_PUB_LEN 1952 #define ML_DSA_87_PUB_LEN 2592 +#endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM +#define ML_KEM_512_PUB_LEN 800 +#define ML_KEM_768_PUB_LEN 1184 +#define ML_KEM_1024_PUB_LEN 1568 +#endif /* OPENSSL_NO_ML_KEM */ + +#if !defined(OPENSSL_NO_ML_DSA) || !defined(OPENSSL_NO_ML_KEM) /* - * Extract raw ML-DSA public key bytes from a CKO_PUBLIC_KEY object using CKA_VALUE. + * Extract raw ML-DSA or ML-KEM public key bytes from a + * CKO_PUBLIC_KEY object using CKA_VALUE. * Returns 1 on success, 0 on failure. */ static int extract_pub_from_public_key_obj(PKCS11_CTX_private *ctx, - CK_SESSION_HANDLE session, CK_OBJECT_HANDLE obj, + CK_SESSION_HANDLE session, CK_OBJECT_HANDLE obj, const char *algname, size_t expected_len, unsigned char **raw, size_t *rawlen) { unsigned char *value = NULL; @@ -56,14 +67,15 @@ static int extract_pub_from_public_key_obj(PKCS11_CTX_private *ctx, if (pkcs11_getattr_alloc(ctx, session, obj, CKA_VALUE, &value, &value_len)) { pkcs11_log(ctx, LOG_DEBUG, - "Missing CKA_VALUE attribute on ML-DSA public key\n"); + "Missing CKA_VALUE attribute on %s public key\n", algname); return 0; } if (value_len != expected_len) { pkcs11_log(ctx, LOG_DEBUG, - "Unexpected ML-DSA public key size: got %lu, expected %lu\n", - (unsigned long)value_len, (unsigned long)expected_len); + "Unexpected %s public key size: got %lu, expected %lu\n", + algname, (unsigned long)value_len, + (unsigned long)expected_len); OPENSSL_free(value); return 0; } @@ -74,7 +86,8 @@ static int extract_pub_from_public_key_obj(PKCS11_CTX_private *ctx, } /* - * Extract raw ML-DSA public key bytes from a CKO_CERTIFICATE object. + * Extract raw ML-DSA or ML-KEM public key bytes from a + * CKO_CERTIFICATE object. * The certificate is read from CKA_VALUE (DER-encoded X.509) and * the public key is obtained via X.509 parsing. * Returns 1 on success, 0 on failure. @@ -189,7 +202,7 @@ static PKCS11_OBJECT_private *pkcs11_choose_public_source(PKCS11_OBJECT_private } /* - * Retrieve raw ML-DSA public key bytes. + * Retrieve raw ML-DSA or ML-KEM public key bytes. * * Preference order: * 1. CKO_PUBLIC_KEY -> CKA_VALUE @@ -228,7 +241,7 @@ static int pkcs11_get_raw_public_key(PKCS11_OBJECT_private *key, switch (obj->object_class) { case CKO_PUBLIC_KEY: ok = extract_pub_from_public_key_obj(ctx, session, obj->object, - expected_len, raw, rawlen); + algname, expected_len, raw, rawlen); break; case CKO_CERTIFICATE: ok = extract_pub_from_cert_obj(ctx, session, obj->object, @@ -253,7 +266,7 @@ static int pkcs11_get_raw_public_key(PKCS11_OBJECT_private *key, return ok ? 0 : -1; } -static EVP_PKEY *pkcs11_get_evp_key_mldsa(PKCS11_OBJECT_private *key, +static EVP_PKEY *pkcs11_get_evp_key_ml(PKCS11_OBJECT_private *key, size_t publen, const char *algname) { EVP_PKEY *pkey = NULL; @@ -264,28 +277,31 @@ static EVP_PKEY *pkcs11_get_evp_key_mldsa(PKCS11_OBJECT_private *key, if (pkcs11_get_raw_public_key(key, publen, algname, &raw, &rawlen) < 0) return NULL; - /* Build a EVP_PKEY from the raw public key, used only as software public key */ + /* Build an EVP_PKEY used only as a software public key */ pkey = EVP_PKEY_new_raw_public_key_ex(NULL, algname, NULL, raw, rawlen); OPENSSL_free(raw); + return pkey; } +#endif /* !defined(OPENSSL_NO_ML_DSA) || !defined(OPENSSL_NO_ML_KEM) */ + +#ifndef OPENSSL_NO_ML_DSA static EVP_PKEY *pkcs11_get_evp_key_mldsa44(PKCS11_OBJECT_private *key) { - return pkcs11_get_evp_key_mldsa(key, ML_DSA_44_PUB_LEN, "ML-DSA-44"); + return pkcs11_get_evp_key_ml(key, ML_DSA_44_PUB_LEN, "ML-DSA-44"); } static EVP_PKEY *pkcs11_get_evp_key_mldsa65(PKCS11_OBJECT_private *key) { - return pkcs11_get_evp_key_mldsa(key, ML_DSA_65_PUB_LEN, "ML-DSA-65"); + return pkcs11_get_evp_key_ml(key, ML_DSA_65_PUB_LEN, "ML-DSA-65"); } static EVP_PKEY *pkcs11_get_evp_key_mldsa87(PKCS11_OBJECT_private *key) { - return pkcs11_get_evp_key_mldsa(key, ML_DSA_87_PUB_LEN, "ML-DSA-87"); + return pkcs11_get_evp_key_ml(key, ML_DSA_87_PUB_LEN, "ML-DSA-87"); } - PKCS11_OBJECT_ops pkcs11_mldsa44_ops = { EVP_PKEY_ML_DSA_44, pkcs11_get_evp_key_mldsa44, @@ -300,15 +316,49 @@ PKCS11_OBJECT_ops pkcs11_mldsa87_ops = { EVP_PKEY_ML_DSA_87, pkcs11_get_evp_key_mldsa87, }; +#else /* OPENSSL_NO_ML_DSA */ +#warning "ML-DSA support not built with libp11" +#endif /* OPENSSL_NO_ML_DSA */ + +#ifndef OPENSSL_NO_ML_KEM +static EVP_PKEY *pkcs11_get_evp_key_mlkem512(PKCS11_OBJECT_private *key) +{ + return pkcs11_get_evp_key_ml(key, ML_KEM_512_PUB_LEN, "ML-KEM-512"); +} + +static EVP_PKEY *pkcs11_get_evp_key_mlkem768(PKCS11_OBJECT_private *key) +{ + return pkcs11_get_evp_key_ml(key, ML_KEM_768_PUB_LEN, "ML-KEM-768"); +} + +static EVP_PKEY *pkcs11_get_evp_key_mlkem1024(PKCS11_OBJECT_private *key) +{ + return pkcs11_get_evp_key_ml(key, ML_KEM_1024_PUB_LEN, "ML-KEM-1024"); +} + +PKCS11_OBJECT_ops pkcs11_mlkem512_ops = { + EVP_PKEY_ML_KEM_512, + pkcs11_get_evp_key_mlkem512, +}; + +PKCS11_OBJECT_ops pkcs11_mlkem768_ops = { + EVP_PKEY_ML_KEM_768, + pkcs11_get_evp_key_mlkem768, +}; + +PKCS11_OBJECT_ops pkcs11_mlkem1024_ops = { + EVP_PKEY_ML_KEM_1024, + pkcs11_get_evp_key_mlkem1024, +}; +#else /* OPENSSL_NO_ML_KEM */ +#warning "ML-KEM support not built with libp11" +#endif /* OPENSSL_NO_ML_KEM */ + +#else /* OPENSSL_VERSION_NUMBER >= 0x30500000L */ -#else /* !defined(OPENSSL_NO_ML_DSA) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ -/* - * ML-DSA support is not available: - * - either OpenSSL was built without ML-DSA support, or - * - OpenSSL version is older than 3.5. - */ #warning "ML-DSA support not built with libp11" +#warning "ML-KEM support not built with libp11" -#endif /* !defined(OPENSSL_NO_ML_DSA) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ +#endif /* OPENSSL_VERSION_NUMBER >= 0x30500000L */ /* vim: set noexpandtab: */ diff --git a/src/p11_pkey.c b/src/p11_pkey.c index 1c9b29ee..58d4180f 100644 --- a/src/p11_pkey.c +++ b/src/p11_pkey.c @@ -342,6 +342,8 @@ const char *pkcs11_mechanism_name(CK_MECHANISM *mechanism) return "CKM_ECDH1_DERIVE"; case CKM_ECDH1_COFACTOR_DERIVE: return "CKM_ECDH1_COFACTOR_DERIVE"; + case CKM_ML_KEM: + return "CKM_ML_KEM"; default: return "UNKNOWN_MECHANISM"; } @@ -661,6 +663,133 @@ static CK_RV pkcs11_derive_with_mechanism(PKCS11_OBJECT_private *key, return rv; } +#if OPENSSL_VERSION_NUMBER >= 0x30000000L +/* + * Execute a PKCS#11 decapsulation operation using the specified mechanism. + * + * The resulting secret key is created as an extractable session object, + * read through CKA_VALUE and destroyed before the session is released. + * + * Returns CKR_OK on success or a PKCS#11/vendor-defined error code on failure. + */ +static CK_RV pkcs11_decapsulate_with_mechanism( + PKCS11_OBJECT_private *key, CK_MECHANISM *mechanism, + unsigned char *out, size_t *outlen, + const unsigned char *in, size_t inlen) +{ + CK_RV rv = CKR_GENERAL_ERROR; + PKCS11_SLOT_private *slot; + PKCS11_CTX_private *ctx; + CK_SESSION_HANDLE session; + CK_OBJECT_HANDLE newkey = CK_INVALID_HANDLE; + CK_OBJECT_CLASS newkey_class = CKO_SECRET_KEY; + CK_KEY_TYPE newkey_type = CKK_GENERIC_SECRET; + CK_BBOOL ck_false = CK_FALSE; + CK_BBOOL ck_true = CK_TRUE; + CK_ULONG newkey_len = 0; + CK_ULONG ck_inlen; + unsigned char *value = NULL; + size_t len, value_len_alloc = 0; + CK_ATTRIBUTE newkey_template[] = { + {CKA_TOKEN, &ck_false, sizeof(ck_false)}, /* session only object */ + {CKA_CLASS, &newkey_class, sizeof(newkey_class)}, + {CKA_KEY_TYPE, &newkey_type, sizeof(newkey_type)}, + {CKA_VALUE_LEN, &newkey_len, sizeof(newkey_len)}, + {CKA_SENSITIVE, &ck_false, sizeof(ck_false)}, + {CKA_EXTRACTABLE, &ck_true, sizeof(ck_true)}, + }; + + if (key == NULL || mechanism == NULL || out == NULL || + outlen == NULL || *outlen == 0 || in == NULL) + return CKR_ARGUMENTS_BAD; + + if (*outlen > (size_t)(CK_ULONG)-1 || + inlen > (size_t)(CK_ULONG)-1) + return CKR_ARGUMENTS_BAD; + + slot = key->slot; + if (slot == NULL) + return CKR_GENERAL_ERROR; + + ctx = slot->ctx; + if (ctx == NULL) + return CKR_GENERAL_ERROR; + +#ifdef DEBUG + pkcs11_log(ctx, LOG_DEBUG, + "%s:%d pkcs11_decapsulate_with_mechanism() " + "%s out=%p *outlen=%lu in=%p inlen=%lu\n", + __FILE__, __LINE__, + pkcs11_mechanism_name(mechanism), + out, (unsigned long)*outlen, + in, (unsigned long)inlen); +#endif + + len = *outlen; + newkey_len = (CK_ULONG)len; + ck_inlen = (CK_ULONG)inlen; + + if (pkcs11_get_session(slot, 0, &session)) + return CKR_GENERAL_ERROR; + + if (key->always_authenticate == CK_TRUE) { + rv = pkcs11_authenticate(key, session); + if (rv != CKR_OK) + goto end; + } + + if (ctx->method_3_2 == NULL || + ctx->method_3_2->C_DecapsulateKey == NULL) { + pkcs11_log(ctx, LOG_DEBUG, + "PKCS#11 3.2 C_DecapsulateKey is not available\n"); + rv = CKR_FUNCTION_NOT_SUPPORTED; + goto end; + } + + rv = CRYPTOKI_call_3_2(ctx, + C_DecapsulateKey(session, mechanism, key->object, + newkey_template, + sizeof(newkey_template) / sizeof(*newkey_template), + (CK_BYTE_PTR)in, ck_inlen, &newkey)); + if (rv != CKR_OK) { + pkcs11_log(ctx, LOG_DEBUG, + "%s:%d C_DecapsulateKey rv=0x%08lX (%lu)\n", + __FILE__, __LINE__, + (unsigned long)rv, (unsigned long)rv); + goto end; + } + + if (newkey == CK_INVALID_HANDLE) { + rv = CKR_GENERAL_ERROR; + goto end; + } + + if (pkcs11_getattr_alloc(ctx, session, newkey, CKA_VALUE, + &value, &value_len_alloc)) { + rv = CKR_GENERAL_ERROR; + goto end; + } + + if (value_len_alloc > len) { + *outlen = value_len_alloc; + rv = CKR_BUFFER_TOO_SMALL; + goto end; + } + + memcpy(out, value, value_len_alloc); + *outlen = value_len_alloc; + rv = CKR_OK; + +end: + if (newkey != CK_INVALID_HANDLE) + CRYPTOKI_call(ctx, C_DestroyObject(session, newkey)); + + OPENSSL_clear_free(value, value_len_alloc); + pkcs11_put_session(slot, session); + return rv; +} +#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */ + /* DER-encode data as an ASN.1 OCTET STRING. */ static unsigned char *der_encode_octet_string(const unsigned char *data, size_t data_len, size_t *der_len) @@ -1264,6 +1393,51 @@ extern int pkcs11_evp_pkey_xdh_derive(PKCS11_OBJECT_private *key, } #endif /* !defined(OPENSSL_NO_ECX) && OPENSSL_VERSION_NUMBER >= 0x30000000L */ +#if OPENSSL_VERSION_NUMBER >= 0x30000000L +extern int pkcs11_evp_pkey_rsa_decapsulate(PKCS11_OBJECT_private *key, + unsigned char *out, size_t *outlen, + const unsigned char *in, size_t inlen) +{ + CK_MECHANISM mechanism; + + if (key == NULL || outlen == NULL || in == NULL) + return -1; + + memset(&mechanism, 0, sizeof(mechanism)); + mechanism.mechanism = CKM_RSA_X_509; + + if (pkcs11_decapsulate_with_mechanism(key, &mechanism, + out, outlen, in, inlen) != CKR_OK) + return -1; + + return 1; +} +#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */ + +#if !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L +/* + * Decapsulate an ML-KEM ciphertext using a private key on the token. + */ +extern int pkcs11_evp_pkey_ml_kem_decapsulate(PKCS11_OBJECT_private *key, + unsigned char *out, size_t *outlen, + const unsigned char *in, size_t inlen) +{ + CK_MECHANISM mechanism; + + if (key == NULL || outlen == NULL || in == NULL) + return -1; + + memset(&mechanism, 0, sizeof(mechanism)); + mechanism.mechanism = CKM_ML_KEM; + + if (pkcs11_decapsulate_with_mechanism(key, &mechanism, + out, outlen, in, inlen) != CKR_OK) + return -1; + + return 1; +} +#endif /* !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ + #if OPENSSL_VERSION_NUMBER < 0x40000000L #ifndef OPENSSL_NO_EC diff --git a/src/pkcs11.h b/src/pkcs11.h index 93960433..78e775c8 100644 --- a/src/pkcs11.h +++ b/src/pkcs11.h @@ -1,6 +1,7 @@ /* pkcs11.h Copyright 2006, 2007 g10 Code GmbH Copyright 2006 Andreas Jellinghaus + Copyright 2017, 2021-2025 Red Hat, Inc. This file is free software; as a special exception the author gives unlimited permission to copy and/or distribute it, with or without @@ -11,12 +12,12 @@ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ -/* Please submit changes back to the Scute project at - http://www.scute.org/ (or send them to marcus@g10code.com), so that +/* Please submit any changes back to the p11-kit project at + https://github.com/p11-glue/p11-kit/, so that they can be picked up by other projects from there as well. */ /* This file is a modified implementation of the PKCS #11 standard by - RSA Security Inc. It is mostly a drop-in replacement, with the + OASIS group. It is mostly a drop-in replacement, with the following change: This header file does not require any macro definitions by the user @@ -59,13 +60,13 @@ extern "C" { /* The version of cryptoki we implement. The revision is changed with - each modification of this file. If you do not use the "official" - version of this file, please consider deleting the revision macro - (you may use a macro with a different name to keep track of your - versions). */ -#define CRYPTOKI_VERSION_MAJOR 2 -#define CRYPTOKI_VERSION_MINOR 20 -#define CRYPTOKI_VERSION_REVISION 6 + each modification of this file. */ +#define CRYPTOKI_VERSION_MAJOR 3 +#define CRYPTOKI_VERSION_MINOR 2 +#define CRYPTOKI_VERSION_REVISION 0 +#define CRYPTOKI_LEGACY_VERSION_MAJOR 2 +#define CRYPTOKI_LEGACY_VERSION_MINOR 40 +#define P11_KIT_CRYPTOKI_VERSION_REVISION 0 /* Compatibility interface is default, unless CRYPTOKI_GNU is @@ -95,13 +96,18 @@ extern "C" { #endif + #ifdef CRYPTOKI_COMPAT -/* If we are in compatibility mode, switch all exposed names to the - * PKCS #11 variant. There are corresponding #undefs below. */ + /* If we are in compatibility mode, switch all exposed names to the + PKCS #11 variant. There are corresponding #undefs below. */ #define ck_flags_t CK_FLAGS #define ck_version _CK_VERSION +#define templ pTemplate +#define attribute_count ulAttributeCount +#define key_ptr phKey + #define ck_info _CK_INFO #define cryptoki_version cryptokiVersion #define manufacturer_id manufacturerID @@ -142,31 +148,64 @@ extern "C" { #define ck_object_class_t CK_OBJECT_CLASS #define ck_hw_feature_type_t CK_HW_FEATURE_TYPE #define ck_key_type_t CK_KEY_TYPE +#define ck_certificate_category_t CK_CERTIFICATE_CATEGORY #define ck_certificate_type_t CK_CERTIFICATE_TYPE #define ck_attribute_type_t CK_ATTRIBUTE_TYPE +#define ck_ec_kdf_type_t CK_EC_KDF_TYPE +#define ck_extract_params_t CK_EXTRACT_PARAMS +#define ck_java_midp_security_domain_t CK_JAVA_MIDP_SECURITY_DOMAIN +#define ck_mac_general_params_t CK_MAC_GENERAL_PARAMS +#define ck_otp_param_type_t CK_OTP_PARAM_TYPE +#define ck_pkcs5_pbkd2_pseudo_random_function_type_t CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE +#define ck_pkcs5_pbkdf2_salt_source_type_t CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE +#define ck_prf_data_type_t CK_PRF_DATA_TYPE +#define ck_profile_id_t CK_PROFILE_ID +#define ck_rc2_params_t CK_RC2_PARAMS +#define ck_sp800_108_dkm_length_method_t CK_SP800_108_DKM_LENGTH_METHOD +#define ck_x2ratchet_kdf_type_t CK_X2RATCHET_KDF_TYPE +#define ck_x3dh_kdf_type_t CK_X3DH_KDF_TYPE +#define ck_x9_42_dh_kdf_type_t CK_X9_42_DH_KDF_TYPE +#define ck_xeddsa_hash_type_t CK_XEDDSA_HASH_TYPE +#define ck_sp800_108_prf_type_t CK_SP800_108_PRF_TYPE +#define ck_hss_levels_t CK_HSS_LEVELS +#define ck_lms_type_t CK_LMS_TYPE +#define ck_lmots_type_t CK_LMOTS_TYPE #define ck_attribute _CK_ATTRIBUTE #define value pValue #define value_len ulValueLen +#define count ulCount + #define ck_date _CK_DATE #define ck_mechanism_type_t CK_MECHANISM_TYPE -#define ck_rsa_pkcs_mgf_type_t CK_RSA_PKCS_MGF_TYPE - #define ck_mechanism _CK_MECHANISM #define parameter pParameter #define parameter_len ulParameterLen +#define params pParams + #define ck_mechanism_info _CK_MECHANISM_INFO #define min_key_size ulMinKeySize #define max_key_size ulMaxKeySize +#define ck_param_type CK_PARAM_TYPE +#define ck_otp_param CK_OTP_PARAM +#define ck_otp_params CK_OTP_PARAMS +#define ck_otp_signature_info CK_OTP_SIGNATURE_INFO + #define ck_rv_t CK_RV #define ck_notify_t CK_NOTIFY +#define ck_interface CK_INTERFACE +#define interface_name_ptr pInterfaceName +#define function_list_ptr pFunctionList + #define ck_function_list _CK_FUNCTION_LIST +#define ck_function_list_3_0 _CK_FUNCTION_LIST_3_0 +#define ck_function_list_3_2 _CK_FUNCTION_LIST_3_2 #define ck_createmutex_t CK_CREATEMUTEX #define ck_destroymutex_t CK_DESTROYMUTEX @@ -180,10 +219,1450 @@ extern "C" { #define unlock_mutex UnlockMutex #define reserved pReserved -#endif /* CRYPTOKI_COMPAT */ +#define ck_rsa_pkcs_mgf_type_t CK_RSA_PKCS_MGF_TYPE +#define ck_rsa_pkcs_oaep_source_type_t CK_RSA_PKCS_OAEP_SOURCE_TYPE +#define hash_alg hashAlg +#define s_len sLen +#define source_data pSourceData +#define source_data_len ulSourceDataLen + +#define ck_generator_function_t CK_GENERATOR_FUNCTION +#define counter_bits ulCounterBits +#define iv_ptr pIv +#define iv_len ulIvLen +#define iv_bits ulIvBits +#define iv_fixed_bits ulIvFixedBits +#define iv_generator ivGenerator +#define aad_ptr pAAD +#define aad_len ulAADLen +#define tag_bits ulTagBits +#define tag_ptr pTag +#define block_counter pBlockCounter +#define block_counter_bits blockCounterBits +#define nonce_ptr pNonce +#define nonce_bits ulNonceBits +#define nonce_fixed_bits ulNonceFixedBits +#define nonce_len ulNonceLen +#define nonce_generator nonceGenerator +#define shared_data_len ulSharedDataLen +#define shared_data pSharedData +#define public_data_len ulPublicDataLen +#define public_data pPublicData +#define public_data_len2 ulPublicDataLen2 +#define public_data2 pPublicData2 +#define private_data_len ulPrivateDataLen +#define private_data hPrivateData +#define string_data pData +#define string_data_len ulLen +#define data_params pData +#define data_len ulDataLen +#define mac_ptr pMac +#define mac_len ulMACLen +#define certificate_handle certificateHandle +#define signing_mechanism_ptr pSigningMechanism +#define digest_mechanism_ptr pDigestMechanism +#define content_type pContentType +#define requested_attributes pRequestedAttributes +#define requested_attributes_len ulRequestedAttributesLen +#define required_attributes pRequiredAttributes +#define required_attributes_len ulRequiredAttributesLen +#define seed_ptr pSeed +#define seed_len ulSeedLen +#define index ulIndex +#define aes_key_bits ulAESKeyBits +#define public_key publicKey +#define flag phFlag +#define context_data_length ulContextDataLength +#define context_data_len ulContextDataLen +#define context_data pContextData +#define wrap_oid pWrapOID +#define wrap_oid_len ulWrapOIDLen +#define ukm_ptr pUKM +#define ukm_len ulUKMLen +#define key hKey +#define extract bExtract +#define expand bExpand +#define prf_hash_mechanism prfHashMechanism +#define salt_type ulSaltType +#define salt_ptr pSalt +#define salt_len ulSaltLen +#define salt_key hSaltKey +#define info pInfo +#define info_len ulInfoLen +#define is_sender isSender +#define random_len ulRandomLen +#define random_a RandomA +#define random_b RandomB +#define bc bBC +#define x_ptr pX +#define x_len ulXLen +#define mechanism_ptr pMechanism +#define init_vector pInitVector +#define password_ptr pPassword +#define password_len ulPasswordLen +#define iteration ulIteration +#define salt_source saltSource +#define salt_source_data pSaltSourceData +#define salt_source_data_len ulSaltSourceDataLen +#define prf_data pPrfData +#define prf_data_len ulPrfDataLen +#define effective_bits ulEffectiveBits +#define mac_length ulMacLength +#define word_size ulWordsize +#define rounds ulRounds +#define oaep_params pOAEPParams +#define p_and_g_len ulPAndGLen +#define q_len ulQLen +#define random_a_ptr pRandomA +#define prime_p pPrimeP +#define base_g pBaseG +#define subprime_q pSubprimeQ +#define old_wrapped_x_len ulOldWrappedXLen +#define old_wrapped_x pOldWrappedX +#define old_password_len ulOldPasswordLen +#define old_password pOldPassword +#define old_public_data_len ulOldPublicDataLen +#define old_public_data pOldPublicData +#define old_random_len ulOldRandomLen +#define old_random_a pOldRandomA +#define new_password_len ulNewPasswordLen +#define new_password pNewPassword +#define new_public_data_len ulNewPublicDataLen +#define new_public_data pNewPublicData +#define new_random_len ulNewRandomLen +#define new_random_a pNewRandomA +#define little_endian bLittleEndian +#define width_in_bits ulWidthInBits +#define dkm_length_method dkmLengthMethod +#define prf_type prfType +#define number_of_data_params ulNumberOfDataParams +#define data_params_ptr pDataParams +#define additional_derived_keys_len ulAdditionalDerivedKeys +#define additional_derived_keys pAdditionalDerivedKeys +#define encrypted_header bEncryptedHeader +#define curve eCurve +#define aead_mechanism aeadMechanism +#define kdf_mechanism kdfMechanism +#define peer_identity pPeer_identity +#define peer_prekey pPeer_prekey +#define prekey_signature pPrekey_signature +#define onetime_key pOnetime_key +#define own_identity pOwn_identity +#define own_ephemeral pOwn_ephemeral +#define identity_id pIdentity_id +#define prekey_id pPrekey_id +#define onetime_id pOnetime_id +#define initiator_identity pInitiator_identity +#define initiator_ephemeral pInitiator_ephemeral +#define other_info_len ulOtherInfoLen +#define other_info pOtherInfo +#define prf_mechanism prfMechanism +#define data_as_key bDataAsKey +#define rekey bRekey +#define ni_ptr pNi +#define ni_len ulNiLen +#define nr_ptr pNr +#define nr_len ulNrLen +#define new_key hNewKey +#define has_key_gxy bHasKeygxy +#define key_gxy hKeygxy +#define extra_data pExtraData +#define extra_data_len ulExtraDataLen +#define has_prev_key bHasPrevKey +#define prev_key hPrevKey +#define cky_i_ptr pCKYi +#define cky_i_len ulCKYiLen +#define cky_r_ptr pCKYr +#define cky_r_len ulCKYrLen +#define key_number keyNumber +#define has_seed_key bHasSeedKey +#define seed_key hSeedKey +#define seed_data pSeedData +#define seed_data_len ulSeedDataLen +#define client_mac_secret hClientMacSecret +#define server_mac_secret hServerMacSecret +#define client_key hClientKey +#define server_key hServerKey +#define iv_client pIVClient +#define iv_server pIVServer +#define client_random_ptr pClientRandom +#define client_random_len ulClientRandomLen +#define server_random_ptr pServerRandom +#define server_random_len ulServerRandomLen +#define mac_size_in_bits ulMacSizeInBits +#define key_size_in_bits ulKeySizeInBits +#define iv_size_in_bits ulIVSizeInBits +#define is_export bIsExport +#define random_info RandomInfo +#define returned_key_material pReturnedKeyMaterial +#define version_ptr pVersion +#define label_length ulLabelLength +#define label_len ulLabelLen +#define label_ptr pLabel +#define server_or_client ulServerOrClient +#define output_ptr pOutput +#define output_len_ptr pulOutputLen +#define mac_secret hMacSecret +#define i_v_ptr pIV +#define digest_mechanism DigestMechanism +#define sequence_number ulSequenceNumber + +#define ck_hedge_type_t CK_HEDGE_TYPE +#define ck_ml_dsa_parameter_set_type_t CK_ML_DSA_PARAMETER_SET_TYPE +#define ck_ml_kem_parameter_set_type_t CK_ML_KEM_PARAMETER_SET_TYPE +#define ck_session_validation_flags_type_t CK_SESSION_VALIDATION_FLAGS_TYPE +#define ck_slh_dsa_parameter_set_type_t CK_SLH_DSA_PARAMETER_SET_TYPE +#define ck_trust_t CK_TRUST +#define ck_validation_authority_type_t CK_VALIDATION_AUTHORITY_TYPE +#define ck_validation_type_t CK_VALIDATION_TYPE +#define ck_xmssmt_parameter_set_type_t CK_XMSSMT_PARAMETER_SET_TYPE +#define ck_xmss_parameter_set_type_t CK_XMSS_PARAMETER_SET_TYPE + +#define version_num ulVersion +#define object_handle hObject +#define additional_object_handle hAdditionalObject +#define hedge_variant hedgeVariant +#define context_ptr pContext +#define context_len ulContextLen +#define session_hash_ptr pSessionHash +#define session_hash_len ulSessionHashLen +#endif /* CRYPTOKI_COMPAT */ + + + +/* CK_ATTRIBUTE_TYPE */ +#define CKA_CLASS (0UL) +#define CKA_TOKEN (1UL) +#define CKA_PRIVATE (2UL) +#define CKA_LABEL (3UL) +#define CKA_UNIQUE_ID (4UL) +#define CKA_APPLICATION (0x10UL) +#define CKA_VALUE (0x11UL) +#define CKA_OBJECT_ID (0x12UL) +#define CKA_CERTIFICATE_TYPE (0x80UL) +#define CKA_ISSUER (0x81UL) +#define CKA_SERIAL_NUMBER (0x82UL) +#define CKA_AC_ISSUER (0x83UL) +#define CKA_OWNER (0x84UL) +#define CKA_ATTR_TYPES (0x85UL) +#define CKA_TRUSTED (0x86UL) +#define CKA_CERTIFICATE_CATEGORY (0x87UL) +#define CKA_JAVA_MIDP_SECURITY_DOMAIN (0x88UL) +#define CKA_URL (0x89UL) +#define CKA_HASH_OF_SUBJECT_PUBLIC_KEY (0x8aUL) +#define CKA_HASH_OF_ISSUER_PUBLIC_KEY (0x8bUL) +#define CKA_NAME_HASH_ALGORITHM (0x8cUL) +#define CKA_CHECK_VALUE (0x90UL) +#define CKA_KEY_TYPE (0x100UL) +#define CKA_SUBJECT (0x101UL) +#define CKA_ID (0x102UL) +#define CKA_SENSITIVE (0x103UL) +#define CKA_ENCRYPT (0x104UL) +#define CKA_DECRYPT (0x105UL) +#define CKA_WRAP (0x106UL) +#define CKA_UNWRAP (0x107UL) +#define CKA_SIGN (0x108UL) +#define CKA_SIGN_RECOVER (0x109UL) +#define CKA_VERIFY (0x10aUL) +#define CKA_VERIFY_RECOVER (0x10bUL) +#define CKA_DERIVE (0x10cUL) +#define CKA_START_DATE (0x110UL) +#define CKA_END_DATE (0x111UL) +#define CKA_MODULUS (0x120UL) +#define CKA_MODULUS_BITS (0x121UL) +#define CKA_PUBLIC_EXPONENT (0x122UL) +#define CKA_PRIVATE_EXPONENT (0x123UL) +#define CKA_PRIME_1 (0x124UL) +#define CKA_PRIME_2 (0x125UL) +#define CKA_EXPONENT_1 (0x126UL) +#define CKA_EXPONENT_2 (0x127UL) +#define CKA_COEFFICIENT (0x128UL) +#define CKA_PUBLIC_KEY_INFO (0x129UL) +#define CKA_PRIME (0x130UL) +#define CKA_SUBPRIME (0x131UL) +#define CKA_BASE (0x132UL) +#define CKA_PRIME_BITS (0x133UL) +#define CKA_SUBPRIME_BITS (0x134UL) +#define CKA_SUB_PRIME_BITS (0x134UL) +#define CKA_VALUE_BITS (0x160UL) +#define CKA_VALUE_LEN (0x161UL) +#define CKA_EXTRACTABLE (0x162UL) +#define CKA_LOCAL (0x163UL) +#define CKA_NEVER_EXTRACTABLE (0x164UL) +#define CKA_ALWAYS_SENSITIVE (0x165UL) +#define CKA_KEY_GEN_MECHANISM (0x166UL) +#define CKA_MODIFIABLE (0x170UL) +#define CKA_COPYABLE (0x171UL) +#define CKA_DESTROYABLE (0x172UL) +#define CKA_ECDSA_PARAMS (0x180UL) +#define CKA_EC_PARAMS (0x180UL) +#define CKA_EC_POINT (0x181UL) +#define CKA_SECONDARY_AUTH (0x200UL) +#define CKA_AUTH_PIN_FLAGS (0x201UL) +#define CKA_ALWAYS_AUTHENTICATE (0x202UL) +#define CKA_WRAP_WITH_TRUSTED (0x210UL) +#define CKA_OTP_FORMAT (0x220UL) +#define CKA_OTP_LENGTH (0x221UL) +#define CKA_OTP_TIME_INTERVAL (0x222UL) +#define CKA_OTP_USER_FRIENDLY_MODE (0x223UL) +#define CKA_OTP_CHALLENGE_REQUIREMENT (0x224UL) +#define CKA_OTP_TIME_REQUIREMENT (0x225UL) +#define CKA_OTP_COUNTER_REQUIREMENT (0x226UL) +#define CKA_OTP_PIN_REQUIREMENT (0x227UL) +#define CKA_OTP_USER_IDENTIFIER (0x22aUL) +#define CKA_OTP_SERVICE_IDENTIFIER (0x22bUL) +#define CKA_OTP_SERVICE_LOGO (0x22cUL) +#define CKA_OTP_SERVICE_LOGO_TYPE (0x22dUL) +#define CKA_OTP_COUNTER (0x22eUL) +#define CKA_OTP_TIME (0x22fUL) +#define CKA_GOSTR3410_PARAMS (0x250UL) +#define CKA_GOSTR3411_PARAMS (0x251UL) +#define CKA_GOST28147_PARAMS (0x252UL) +#define CKA_HW_FEATURE_TYPE (0x300UL) +#define CKA_RESET_ON_INIT (0x301UL) +#define CKA_HAS_RESET (0x302UL) +#define CKA_PIXEL_X (0x400UL) +#define CKA_PIXEL_Y (0x401UL) +#define CKA_RESOLUTION (0x402UL) +#define CKA_CHAR_ROWS (0x403UL) +#define CKA_CHAR_COLUMNS (0x404UL) +#define CKA_COLOR (0x405UL) +#define CKA_BITS_PER_PIXEL (0x406UL) +#define CKA_CHAR_SETS (0x480UL) +#define CKA_ENCODING_METHODS (0x481UL) +#define CKA_MIME_TYPES (0x482UL) +#define CKA_MECHANISM_TYPE (0x500UL) +#define CKA_REQUIRED_CMS_ATTRIBUTES (0x501UL) +#define CKA_DEFAULT_CMS_ATTRIBUTES (0x502UL) +#define CKA_SUPPORTED_CMS_ATTRIBUTES (0x503UL) +#define CKA_WRAP_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x211UL) +#define CKA_UNWRAP_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x212UL) +#define CKA_DERIVE_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x213UL) +#define CKA_ALLOWED_MECHANISMS (CKF_ARRAY_ATTRIBUTE | 0x600UL) +#define CKA_PROFILE_ID (0x601UL) +#define CKA_X2RATCHET_BAG (0x602UL) +#define CKA_X2RATCHET_BAGSIZE (0x603UL) +#define CKA_X2RATCHET_BOBS1STMSG (0x604UL) +#define CKA_X2RATCHET_CKR (0x605UL) +#define CKA_X2RATCHET_CKS (0x606UL) +#define CKA_X2RATCHET_DHP (0x607UL) +#define CKA_X2RATCHET_DHR (0x608UL) +#define CKA_X2RATCHET_DHS (0x609UL) +#define CKA_X2RATCHET_HKR (0x60aUL) +#define CKA_X2RATCHET_HKS (0x60bUL) +#define CKA_X2RATCHET_ISALICE (0x60cUL) +#define CKA_X2RATCHET_NHKR (0x60dUL) +#define CKA_X2RATCHET_NHKS (0x60eUL) +#define CKA_X2RATCHET_NR (0x60fUL) +#define CKA_X2RATCHET_NS (0x610UL) +#define CKA_X2RATCHET_PNS (0x611UL) +#define CKA_X2RATCHET_RK (0x612UL) +#define CKA_HSS_LEVELS (0x617UL) +#define CKA_HSS_LMS_TYPE (0x618UL) +#define CKA_HSS_LMOTS_TYPE (0x619UL) +#define CKA_HSS_LMS_TYPES (0x61AUL) +#define CKA_HSS_LMOTS_TYPES (0x61BUL) +#define CKA_HSS_KEYS_REMAINING (0x61CUL) +#define CKA_PARAMETER_SET (0x61DUL) +#define CKA_OBJECT_VALIDATION_FLAGS (0x61EUL) +#define CKA_VALIDATION_TYPE (0x61FUL) +#define CKA_VALIDATION_VERSION (0x620UL) +#define CKA_VALIDATION_LEVEL (0x621UL) +#define CKA_VALIDATION_MODULE_ID (0x622UL) +#define CKA_VALIDATION_FLAG (0x623UL) +#define CKA_VALIDATION_AUTHORITY_TYPE (0x624UL) +#define CKA_VALIDATION_COUNTRY (0x625UL) +#define CKA_VALIDATION_CERTIFICATE_IDENTIFIER (0x626UL) +#define CKA_VALIDATION_CERTIFICATE_URI (0x627UL) +#define CKA_VALIDATION_VENDOR_URI (0x628UL) +#define CKA_VALIDATION_PROFILE (0x629UL) +#define CKA_ENCAPSULATE_TEMPLATE (0x62AUL) +#define CKA_DECAPSULATE_TEMPLATE (0x62BUL) +#define CKA_TRUST_SERVER_AUTH (0x62CUL) +#define CKA_TRUST_CLIENT_AUTH (0x62DUL) +#define CKA_TRUST_CODE_SIGNING (0x62EUL) +#define CKA_TRUST_EMAIL_PROTECTION (0x62FUL) +#define CKA_TRUST_IPSEC_IKE (0x630UL) +#define CKA_TRUST_TIME_STAMPING (0x631UL) +#define CKA_TRUST_OCSP_SIGNING (0x632UL) +#define CKA_ENCAPSULATE (0x633UL) +#define CKA_DECAPSULATE (0x634UL) +#define CKA_HASH_OF_CERTIFICATE (0x635UL) +#define CKA_PUBLIC_CRC64_VALUE (0x636UL) +#define CKA_SEED (0x637UL) +#define CKA_VENDOR_DEFINED ((unsigned long) (1UL << 31)) + +/* CK_CERTIFICATE_CATEGORY */ +#define CK_CERTIFICATE_CATEGORY_UNSPECIFIED (0UL) +#define CK_CERTIFICATE_CATEGORY_TOKEN_USER (1UL) +#define CK_CERTIFICATE_CATEGORY_AUTHORITY (2UL) +#define CK_CERTIFICATE_CATEGORY_OTHER_ENTITY (3UL) + +/* CK_CERTIFICATE_TYPE */ +#define CKC_X_509 (0UL) +#define CKC_X_509_ATTR_CERT (1UL) +#define CKC_WTLS (2UL) +#define CKC_VENDOR_DEFINED ((unsigned long) (1UL << 31)) +#define CKC_OPENPGP (CKC_VENDOR_DEFINED|0x504750UL) + +/* KDFs */ +#define CKD_NULL (0x01UL) +#define CKD_SHA1_KDF (0x02UL) +#define CKD_SHA1_KDF_ASN1 (0x03UL) +#define CKD_SHA1_KDF_CONCATENATE (0x04UL) +#define CKD_SHA224_KDF (0x05UL) +#define CKD_SHA256_KDF (0x06UL) +#define CKD_SHA384_KDF (0x07UL) +#define CKD_SHA512_KDF (0x08UL) +#define CKD_CPDIVERSIFY_KDF (0x09UL) +#define CKD_SHA3_224_KDF (0x0aUL) +#define CKD_SHA3_256_KDF (0x0bUL) +#define CKD_SHA3_384_KDF (0x0cUL) +#define CKD_SHA3_512_KDF (0x0dUL) +#define CKD_SHA1_KDF_SP800 (0x0eUL) +#define CKD_SHA224_KDF_SP800 (0x0fUL) +#define CKD_SHA256_KDF_SP800 (0x10UL) +#define CKD_SHA384_KDF_SP800 (0x11UL) +#define CKD_SHA512_KDF_SP800 (0x12UL) +#define CKD_SHA3_224_KDF_SP800 (0x13UL) +#define CKD_SHA3_256_KDF_SP800 (0x14UL) +#define CKD_SHA3_384_KDF_SP800 (0x15UL) +#define CKD_SHA3_512_KDF_SP800 (0x16UL) +#define CKD_BLAKE2B_160_KDF (0x17UL) +#define CKD_BLAKE2B_256_KDF (0x18UL) +#define CKD_BLAKE2B_384_KDF (0x19UL) +#define CKD_BLAKE2B_512_KDF (0x1aUL) + +/* CK_GENERATOR_FUNCTION */ +#define CKG_NO_GENERATE (0UL) +#define CKG_GENERATE (1UL) +#define CKG_GENERATE_COUNTER (2UL) +#define CKG_GENERATE_RANDOM (3UL) +#define CKG_GENERATE_COUNTER_XOR (4UL) + +/* CK_FLAGS */ +#define CKF_TOKEN_PRESENT (1UL << 0) +#define CKF_REMOVABLE_DEVICE (1UL << 1) +#define CKF_HW_SLOT (1UL << 2) +#define CKF_ARRAY_ATTRIBUTE (1UL << 30) + +#define CKF_LIBRARY_CANT_CREATE_OS_THREADS (1UL << 0) +#define CKF_OS_LOCKING_OK (1UL << 1) + +#define CKF_HKDF_SALT_NULL (1UL << 0) +#define CKF_HKDF_SALT_DATA (1UL << 1) +#define CKF_HKDF_SALT_KEY (1UL << 2) + +#define CKF_INTERFACE_FORK_SAFE (1UL) + +#define CKF_EC_F_P (1UL << 20) +#define CKF_EC_F_2M (1UL << 21) +#define CKF_EC_ECPARAMETERS (1UL << 22) +#define CKF_EC_OID (1UL << 23) +#define CKF_EC_NAMEDCURVE (1UL << 23) +#define CKF_EC_UNCOMPRESS (1UL << 24) +#define CKF_EC_COMPRESS (1UL << 25) +#define CKF_EC_CURVENAME (1UL << 26) +#define CKF_ENCAPSULATE (1UL << 28) +#define CKF_DECAPSULATE (1UL << 29) + +#define CKF_HW (1UL << 0) +#define CKF_MESSAGE_ENCRYPT (1UL << 1) +#define CKF_MESSAGE_DECRYPT (1UL << 2) +#define CKF_MESSAGE_SIGN (1UL << 3) +#define CKF_MESSAGE_VERIFY (1UL << 4) +#define CKF_MULTI_MESSAGE (1UL << 5) +#define CKF_FIND_OBJECTS (1UL << 6) +#define CKF_ENCRYPT (1UL << 8) +#define CKF_DECRYPT (1UL << 9) +#define CKF_DIGEST (1UL << 10) +#define CKF_SIGN (1UL << 11) +#define CKF_SIGN_RECOVER (1UL << 12) +#define CKF_VERIFY (1UL << 13) +#define CKF_VERIFY_RECOVER (1UL << 14) +#define CKF_GENERATE (1UL << 15) +#define CKF_GENERATE_KEY_PAIR (1UL << 16) +#define CKF_WRAP (1UL << 17) +#define CKF_UNWRAP (1UL << 18) +#define CKF_DERIVE (1UL << 19) +#define CKF_EXTENSION ((unsigned long) (1UL << 31)) +/* Flags for message-based functions */ +#define CKF_END_OF_MESSAGE (0x1UL) +/* OTP mechanism flags */ +#define CKF_NEXT_OTP (0x01UL) +#define CKF_EXCLUDE_TIME (0x02UL) +#define CKF_EXCLUDE_COUNTER (0x04UL) +#define CKF_EXCLUDE_CHALLENGE (0x08UL) +#define CKF_EXCLUDE_PIN (0x10UL) +#define CKF_USER_FRIENDLY_OTP (0x20UL) + +/* Flags for C_WaitForSlotEvent. */ +#define CKF_DONT_BLOCK (1UL) + +#define CKF_RW_SESSION (1UL << 1) +#define CKF_SERIAL_SESSION (1UL << 2) +#define CKF_ASYNC_SESSION (1UL << 3) + +#define CKF_RNG (1UL << 0) +#define CKF_WRITE_PROTECTED (1UL << 1) +#define CKF_LOGIN_REQUIRED (1UL << 2) +#define CKF_USER_PIN_INITIALIZED (1UL << 3) +#define CKF_RESTORE_KEY_NOT_NEEDED (1UL << 5) +#define CKF_CLOCK_ON_TOKEN (1UL << 6) +#define CKF_PROTECTED_AUTHENTICATION_PATH (1UL << 8) +#define CKF_DUAL_CRYPTO_OPERATIONS (1UL << 9) +#define CKF_TOKEN_INITIALIZED (1UL << 10) +#define CKF_SECONDARY_AUTHENTICATION (1UL << 11) +#define CKF_USER_PIN_COUNT_LOW (1UL << 16) +#define CKF_USER_PIN_FINAL_TRY (1UL << 17) +#define CKF_USER_PIN_LOCKED (1UL << 18) +#define CKF_USER_PIN_TO_BE_CHANGED (1UL << 19) +#define CKF_SO_PIN_COUNT_LOW (1UL << 20) +#define CKF_SO_PIN_FINAL_TRY (1UL << 21) +#define CKF_SO_PIN_LOCKED (1UL << 22) +#define CKF_SO_PIN_TO_BE_CHANGED (1UL << 23) +#define CKF_ERROR_STATE (1UL << 24) +#define CKF_SEED_RANDOM_REQUIRED (1UL << 25) +#define CKF_ASYNC_SESSION_SUPPORTED (1UL << 26) + +/* CK_HW_FEATURE_TYPE */ +#define CKH_MONOTONIC_COUNTER (1UL) +#define CKH_CLOCK (2UL) +#define CKH_USER_INTERFACE (3UL) +#define CKH_VENDOR_DEFINED ((unsigned long) (1UL << 31)) + +/* CK_HEDGE_TYPE */ +#define CKH_HEDGE_PREFERRED (0UL) +#define CKH_HEDGE_REQUIRED (1UL) +#define CKH_DETERMINISTIC_REQUIRED (2UL) + +/* CK_JAVA_MIDP_SECURITY_DOMAIN */ +#define CK_SECURITY_DOMAIN_UNSPECIFIED (0UL) +#define CK_SECURITY_DOMAIN_MANUFACTURER (1UL) +#define CK_SECURITY_DOMAIN_OPERATOR (2UL) +#define CK_SECURITY_DOMAIN_THIRD_PARTY (3UL) + +/* CK_KEY_TYPE */ +#define CKK_RSA (0UL) +#define CKK_DSA (1UL) +#define CKK_DH (2UL) +#define CKK_ECDSA (3UL) +#define CKK_EC (3UL) +#define CKK_X9_42_DH (4UL) +#define CKK_KEA (5UL) +#define CKK_GENERIC_SECRET (0x10UL) +#define CKK_RC2 (0x11UL) +#define CKK_RC4 (0x12UL) +#define CKK_DES (0x13UL) +#define CKK_DES2 (0x14UL) +#define CKK_DES3 (0x15UL) +#define CKK_CAST (0x16UL) +#define CKK_CAST3 (0x17UL) +#define CKK_CAST128 (0x18UL) +#define CKK_RC5 (0x19UL) +#define CKK_IDEA (0x1aUL) +#define CKK_SKIPJACK (0x1bUL) +#define CKK_BATON (0x1cUL) +#define CKK_JUNIPER (0x1dUL) +#define CKK_CDMF (0x1eUL) +#define CKK_AES (0x1fUL) +#define CKK_BLOWFISH (0x20UL) +#define CKK_TWOFISH (0x21UL) +#define CKK_SECURID (0x22UL) +#define CKK_HOTP (0x23UL) +#define CKK_ACTI (0x24UL) +#define CKK_CAMELLIA (0x25UL) +#define CKK_ARIA (0x26UL) +#define CKK_MD5_HMAC (0x27UL) +#define CKK_SHA_1_HMAC (0x28UL) +#define CKK_RIPEMD128_HMAC (0x29UL) +#define CKK_RIPEMD160_HMAC (0x2aUL) +#define CKK_SHA256_HMAC (0x2bUL) +#define CKK_SHA384_HMAC (0x2cUL) +#define CKK_SHA512_HMAC (0x2dUL) +#define CKK_SHA224_HMAC (0x2eUL) +#define CKK_SEED (0x2fUL) +#define CKK_GOSTR3410 (0x30UL) +#define CKK_GOSTR3411 (0x31UL) +#define CKK_GOST28147 (0x32UL) +#define CKK_CHACHA20 (0x33UL) +#define CKK_POLY1305 (0x34UL) +#define CKK_AES_XTS (0x35UL) +#define CKK_SHA3_224_HMAC (0x36UL) +#define CKK_SHA3_256_HMAC (0x37UL) +#define CKK_SHA3_384_HMAC (0x38UL) +#define CKK_SHA3_512_HMAC (0x39UL) +#define CKK_BLAKE2B_160_HMAC (0x3aUL) +#define CKK_BLAKE2B_256_HMAC (0x3bUL) +#define CKK_BLAKE2B_384_HMAC (0x3cUL) +#define CKK_BLAKE2B_512_HMAC (0x3dUL) +#define CKK_SALSA20 (0x3eUL) +#define CKK_X2RATCHET (0x3fUL) +#define CKK_EC_EDWARDS (0x40UL) +#define CKK_EC_MONTGOMERY (0x41UL) +#define CKK_HKDF (0x42UL) +#define CKK_SHA512_224_HMAC (0x43UL) +#define CKK_SHA512_256_HMAC (0x44UL) +#define CKK_SHA512_T_HMAC (0x45UL) +#define CKK_HSS (0x46UL) +#define CKK_XMSS (0x47UL) +#define CKK_XMSSMT (0x48UL) +#define CKK_ML_KEM (0x49UL) +#define CKK_ML_DSA (0x4AUL) +#define CKK_SLH_DSA (0x4BUL) +/* + * Thales Luna customer-defined Falcon identifiers. + * Falcon does not currently have standard PKCS#11 CKK_ values. + * Luna defines the key type and mechanisms in its customer-defined range. + */ +#define CKK_FALCON (0xC0000006UL) +#define CKK_VENDOR_DEFINED ((unsigned long) (1UL << 31)) + +/* CK_MECHANISM_TYPE */ +#define CKM_RSA_PKCS_KEY_PAIR_GEN (0UL) +#define CKM_RSA_PKCS (1UL) +#define CKM_RSA_9796 (2UL) +#define CKM_RSA_X_509 (3UL) +#define CKM_MD2_RSA_PKCS (4UL) +#define CKM_MD5_RSA_PKCS (5UL) +#define CKM_SHA1_RSA_PKCS (6UL) +#define CKM_RIPEMD128_RSA_PKCS (7UL) +#define CKM_RIPEMD160_RSA_PKCS (8UL) +#define CKM_RSA_PKCS_OAEP (9UL) +#define CKM_RSA_X9_31_KEY_PAIR_GEN (0xaUL) +#define CKM_RSA_X9_31 (0xbUL) +#define CKM_SHA1_RSA_X9_31 (0xcUL) +#define CKM_RSA_PKCS_PSS (0xdUL) +#define CKM_SHA1_RSA_PKCS_PSS (0xeUL) +#define CKM_ML_KEM_KEY_PAIR_GEN (0xfUL) +#define CKM_DSA_KEY_PAIR_GEN (0x10UL) +#define CKM_DSA (0x11UL) +#define CKM_DSA_SHA1 (0x12UL) +#define CKM_DSA_SHA224 (0x13UL) +#define CKM_DSA_SHA256 (0x14UL) +#define CKM_DSA_SHA384 (0x15UL) +#define CKM_DSA_SHA512 (0x16UL) +#define CKM_ML_KEM (0x17UL) +#define CKM_DSA_SHA3_224 (0x18UL) +#define CKM_DSA_SHA3_256 (0x19UL) +#define CKM_DSA_SHA3_384 (0x1AUL) +#define CKM_DSA_SHA3_512 (0x1BUL) +#define CKM_ML_DSA_KEY_PAIR_GEN (0x1CUL) +#define CKM_ML_DSA (0x1DUL) +#define CKM_HASH_ML_DSA (0x1FUL) +#define CKM_DH_PKCS_KEY_PAIR_GEN (0x20UL) +#define CKM_DH_PKCS_DERIVE (0x21UL) +#define CKM_HASH_ML_DSA_SHA224 (0x23UL) +#define CKM_HASH_ML_DSA_SHA256 (0x24UL) +#define CKM_HASH_ML_DSA_SHA384 (0x25UL) +#define CKM_HASH_ML_DSA_SHA512 (0x26UL) +#define CKM_HASH_ML_DSA_SHA3_224 (0x27UL) +#define CKM_HASH_ML_DSA_SHA3_256 (0x28UL) +#define CKM_HASH_ML_DSA_SHA3_384 (0x29UL) +#define CKM_HASH_ML_DSA_SHA3_512 (0x2AUL) +#define CKM_HASH_ML_DSA_SHAKE128 (0x2BUL) +#define CKM_HASH_ML_DSA_SHAKE256 (0x2CUL) +#define CKM_SLH_DSA_KEY_PAIR_GEN (0x2DUL) +#define CKM_SLH_DSA (0x2EUL) +#define CKM_X9_42_DH_KEY_PAIR_GEN (0x30UL) +#define CKM_X9_42_DH_DERIVE (0x31UL) +#define CKM_X9_42_DH_HYBRID_DERIVE (0x32UL) +#define CKM_X9_42_MQV_DERIVE (0x33UL) +#define CKM_HASH_SLH_DSA (0x34UL) +#define CKM_HASH_SLH_DSA_SHA224 (0x36UL) +#define CKM_HASH_SLH_DSA_SHA256 (0x37UL) +#define CKM_HASH_SLH_DSA_SHA384 (0x38UL) +#define CKM_HASH_SLH_DSA_SHA512 (0x39UL) +#define CKM_HASH_SLH_DSA_SHA3_224 (0x3AUL) +#define CKM_HASH_SLH_DSA_SHA3_256 (0x3BUL) +#define CKM_HASH_SLH_DSA_SHA3_384 (0x3CUL) +#define CKM_HASH_SLH_DSA_SHA3_512 (0x3DUL) +#define CKM_HASH_SLH_DSA_SHAKE128 (0x3EUL) +#define CKM_HASH_SLH_DSA_SHAKE256 (0x3FUL) +#define CKM_SHA256_RSA_PKCS (0x40UL) +#define CKM_SHA384_RSA_PKCS (0x41UL) +#define CKM_SHA512_RSA_PKCS (0x42UL) +#define CKM_SHA256_RSA_PKCS_PSS (0x43UL) +#define CKM_SHA384_RSA_PKCS_PSS (0x44UL) +#define CKM_SHA512_RSA_PKCS_PSS (0x45UL) +#define CKM_SHA224_RSA_PKCS (0x46UL) +#define CKM_SHA224_RSA_PKCS_PSS (0x47UL) +#define CKM_SHA512_224 (0x48UL) +#define CKM_SHA512_224_HMAC (0x49UL) +#define CKM_SHA512_224_HMAC_GENERAL (0x4aUL) +#define CKM_SHA512_224_KEY_DERIVATION (0x4bUL) +#define CKM_SHA512_256 (0x4cUL) +#define CKM_SHA512_256_HMAC (0x4dUL) +#define CKM_SHA512_256_HMAC_GENERAL (0x4eUL) +#define CKM_SHA512_256_KEY_DERIVATION (0x4fUL) +#define CKM_SHA512_T (0x50UL) +#define CKM_SHA512_T_HMAC (0x51UL) +#define CKM_SHA512_T_HMAC_GENERAL (0x52UL) +#define CKM_SHA512_T_KEY_DERIVATION (0x53UL) +#define CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE (0x56UL) +#define CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH (0x57UL) +#define CKM_SHA3_256_RSA_PKCS (0x60UL) +#define CKM_SHA3_384_RSA_PKCS (0x61UL) +#define CKM_SHA3_512_RSA_PKCS (0x62UL) +#define CKM_SHA3_256_RSA_PKCS_PSS (0x63UL) +#define CKM_SHA3_384_RSA_PKCS_PSS (0x64UL) +#define CKM_SHA3_512_RSA_PKCS_PSS (0x65UL) +#define CKM_SHA3_224_RSA_PKCS (0x66UL) +#define CKM_SHA3_224_RSA_PKCS_PSS (0x67UL) +#define CKM_RC2_KEY_GEN (0x100UL) +#define CKM_RC2_ECB (0x101UL) +#define CKM_RC2_CBC (0x102UL) +#define CKM_RC2_MAC (0x103UL) +#define CKM_RC2_MAC_GENERAL (0x104UL) +#define CKM_RC2_CBC_PAD (0x105UL) +#define CKM_RC4_KEY_GEN (0x110UL) +#define CKM_RC4 (0x111UL) +#define CKM_DES_KEY_GEN (0x120UL) +#define CKM_DES_ECB (0x121UL) +#define CKM_DES_CBC (0x122UL) +#define CKM_DES_MAC (0x123UL) +#define CKM_DES_MAC_GENERAL (0x124UL) +#define CKM_DES_CBC_PAD (0x125UL) +#define CKM_DES2_KEY_GEN (0x130UL) +#define CKM_DES3_KEY_GEN (0x131UL) +#define CKM_DES3_ECB (0x132UL) +#define CKM_DES3_CBC (0x133UL) +#define CKM_DES3_MAC (0x134UL) +#define CKM_DES3_MAC_GENERAL (0x135UL) +#define CKM_DES3_CBC_PAD (0x136UL) +#define CKM_DES3_CMAC_GENERAL (0x137UL) +#define CKM_DES3_CMAC (0x138UL) +#define CKM_CDMF_KEY_GEN (0x140UL) +#define CKM_CDMF_ECB (0x141UL) +#define CKM_CDMF_CBC (0x142UL) +#define CKM_CDMF_MAC (0x143UL) +#define CKM_CDMF_MAC_GENERAL (0x144UL) +#define CKM_CDMF_CBC_PAD (0x145UL) +#define CKM_DES_OFB64 (0x150UL) +#define CKM_DES_OFB8 (0x151UL) +#define CKM_DES_CFB64 (0x152UL) +#define CKM_DES_CFB8 (0x153UL) +#define CKM_MD2 (0x200UL) +#define CKM_MD2_HMAC (0x201UL) +#define CKM_MD2_HMAC_GENERAL (0x202UL) +#define CKM_MD5 (0x210UL) +#define CKM_MD5_HMAC (0x211UL) +#define CKM_MD5_HMAC_GENERAL (0x212UL) +#define CKM_SHA_1 (0x220UL) +#define CKM_SHA_1_HMAC (0x221UL) +#define CKM_SHA_1_HMAC_GENERAL (0x222UL) +#define CKM_RIPEMD128 (0x230UL) +#define CKM_RIPEMD128_HMAC (0x231UL) +#define CKM_RIPEMD128_HMAC_GENERAL (0x232UL) +#define CKM_RIPEMD160 (0x240UL) +#define CKM_RIPEMD160_HMAC (0x241UL) +#define CKM_RIPEMD160_HMAC_GENERAL (0x242UL) +#define CKM_SHA256 (0x250UL) +#define CKM_SHA256_HMAC (0x251UL) +#define CKM_SHA256_HMAC_GENERAL (0x252UL) +#define CKM_SHA224 (0x255UL) +#define CKM_SHA224_HMAC (0x256UL) +#define CKM_SHA224_HMAC_GENERAL (0x257UL) +#define CKM_SHA384 (0x260UL) +#define CKM_SHA384_HMAC (0x261UL) +#define CKM_SHA384_HMAC_GENERAL (0x262UL) +#define CKM_SHA512 (0x270UL) +#define CKM_SHA512_HMAC (0x271UL) +#define CKM_SHA512_HMAC_GENERAL (0x272UL) +#define CKM_SECURID_KEY_GEN (0x280UL) +#define CKM_SECURID (0x282UL) +#define CKM_HOTP_KEY_GEN (0x290UL) +#define CKM_HOTP (0x291UL) +#define CKM_ACTI (0x2a0UL) +#define CKM_ACTI_KEY_GEN (0x2a1UL) +#define CKM_SHA3_256 (0x2b0UL) +#define CKM_SHA3_256_HMAC (0x2b1UL) +#define CKM_SHA3_256_HMAC_GENERAL (0x2b2UL) +#define CKM_SHA3_256_KEY_GEN (0x2b3UL) +#define CKM_SHA3_224 (0x2b5UL) +#define CKM_SHA3_224_HMAC (0x2b6UL) +#define CKM_SHA3_224_HMAC_GENERAL (0x2b7UL) +#define CKM_SHA3_224_KEY_GEN (0x2b8UL) +#define CKM_SHA3_384 (0x2c0UL) +#define CKM_SHA3_384_HMAC (0x2c1UL) +#define CKM_SHA3_384_HMAC_GENERAL (0x2c2UL) +#define CKM_SHA3_384_KEY_GEN (0x2c3UL) +#define CKM_SHA3_512 (0x2d0UL) +#define CKM_SHA3_512_HMAC (0x2d1UL) +#define CKM_SHA3_512_HMAC_GENERAL (0x2d2UL) +#define CKM_SHA3_512_KEY_GEN (0x2d3UL) +#define CKM_CAST_KEY_GEN (0x300UL) +#define CKM_CAST_ECB (0x301UL) +#define CKM_CAST_CBC (0x302UL) +#define CKM_CAST_MAC (0x303UL) +#define CKM_CAST_MAC_GENERAL (0x304UL) +#define CKM_CAST_CBC_PAD (0x305UL) +#define CKM_CAST3_KEY_GEN (0x310UL) +#define CKM_CAST3_ECB (0x311UL) +#define CKM_CAST3_CBC (0x312UL) +#define CKM_CAST3_MAC (0x313UL) +#define CKM_CAST3_MAC_GENERAL (0x314UL) +#define CKM_CAST3_CBC_PAD (0x315UL) +#define CKM_CAST5_KEY_GEN (0x320UL) +#define CKM_CAST128_KEY_GEN (0x320UL) +#define CKM_CAST5_ECB (0x321UL) +#define CKM_CAST128_ECB (0x321UL) +#define CKM_CAST5_CBC (0x322UL) +#define CKM_CAST128_CBC (0x322UL) +#define CKM_CAST5_MAC (0x323UL) +#define CKM_CAST128_MAC (0x323UL) +#define CKM_CAST5_MAC_GENERAL (0x324UL) +#define CKM_CAST128_MAC_GENERAL (0x324UL) +#define CKM_CAST5_CBC_PAD (0x325UL) +#define CKM_CAST128_CBC_PAD (0x325UL) +#define CKM_RC5_KEY_GEN (0x330UL) +#define CKM_RC5_ECB (0x331UL) +#define CKM_RC5_CBC (0x332UL) +#define CKM_RC5_MAC (0x333UL) +#define CKM_RC5_MAC_GENERAL (0x334UL) +#define CKM_RC5_CBC_PAD (0x335UL) +#define CKM_IDEA_KEY_GEN (0x340UL) +#define CKM_IDEA_ECB (0x341UL) +#define CKM_IDEA_CBC (0x342UL) +#define CKM_IDEA_MAC (0x343UL) +#define CKM_IDEA_MAC_GENERAL (0x344UL) +#define CKM_IDEA_CBC_PAD (0x345UL) +#define CKM_GENERIC_SECRET_KEY_GEN (0x350UL) +#define CKM_CONCATENATE_BASE_AND_KEY (0x360UL) +#define CKM_CONCATENATE_BASE_AND_DATA (0x362UL) +#define CKM_CONCATENATE_DATA_AND_BASE (0x363UL) +#define CKM_XOR_BASE_AND_DATA (0x364UL) +#define CKM_EXTRACT_KEY_FROM_KEY (0x365UL) +#define CKM_SSL3_PRE_MASTER_KEY_GEN (0x370UL) +#define CKM_SSL3_MASTER_KEY_DERIVE (0x371UL) +#define CKM_SSL3_KEY_AND_MAC_DERIVE (0x372UL) +#define CKM_SSL3_MASTER_KEY_DERIVE_DH (0x373UL) +#define CKM_TLS_PRE_MASTER_KEY_GEN (0x374UL) +#define CKM_TLS_MASTER_KEY_DERIVE (0x375UL) +#define CKM_TLS_KEY_AND_MAC_DERIVE (0x376UL) +#define CKM_TLS_MASTER_KEY_DERIVE_DH (0x377UL) +#define CKM_TLS_PRF (0x378UL) +#define CKM_SSL3_MD5_MAC (0x380UL) +#define CKM_SSL3_SHA1_MAC (0x381UL) +#define CKM_MD5_KEY_DERIVATION (0x390UL) +#define CKM_MD2_KEY_DERIVATION (0x391UL) +#define CKM_SHA1_KEY_DERIVATION (0x392UL) +#define CKM_SHA256_KEY_DERIVATION (0x393UL) +#define CKM_SHA384_KEY_DERIVATION (0x394UL) +#define CKM_SHA512_KEY_DERIVATION (0x395UL) +#define CKM_SHA224_KEY_DERIVATION (0x396UL) +#define CKM_SHA3_256_KEY_DERIVATION (0x397UL) +#define CKM_SHA3_256_KEY_DERIVE (0x397UL) +#define CKM_SHA3_224_KEY_DERIVATION (0x398UL) +#define CKM_SHA3_224_KEY_DERIVE (0x398UL) +#define CKM_SHA3_384_KEY_DERIVATION (0x399UL) +#define CKM_SHA3_384_KEY_DERIVE (0x399UL) +#define CKM_SHA3_512_KEY_DERIVATION (0x39aUL) +#define CKM_SHA3_512_KEY_DERIVE (0x39aUL) +#define CKM_SHAKE_128_KEY_DERIVATION (0x39bUL) +#define CKM_SHAKE_128_KEY_DERIVE (0x39bUL) +#define CKM_SHAKE_256_KEY_DERIVATION (0x39cUL) +#define CKM_SHAKE_256_KEY_DERIVE (0x39cUL) +#define CKM_PBE_MD2_DES_CBC (0x3a0UL) +#define CKM_PBE_MD5_DES_CBC (0x3a1UL) +#define CKM_PBE_MD5_CAST_CBC (0x3a2UL) +#define CKM_PBE_MD5_CAST3_CBC (0x3a3UL) +#define CKM_PBE_MD5_CAST5_CBC (0x3a4UL) +#define CKM_PBE_MD5_CAST128_CBC (0x3a4UL) +#define CKM_PBE_SHA1_CAST5_CBC (0x3a5UL) +#define CKM_PBE_SHA1_CAST128_CBC (0x3a5UL) +#define CKM_PBE_SHA1_RC4_128 (0x3a6UL) +#define CKM_PBE_SHA1_RC4_40 (0x3a7UL) +#define CKM_PBE_SHA1_DES3_EDE_CBC (0x3a8UL) +#define CKM_PBE_SHA1_DES2_EDE_CBC (0x3a9UL) +#define CKM_PBE_SHA1_RC2_128_CBC (0x3aaUL) +#define CKM_PBE_SHA1_RC2_40_CBC (0x3abUL) +#define CKM_PKCS5_PBKD2 (0x3b0UL) +#define CKM_PBA_SHA1_WITH_SHA1_HMAC (0x3c0UL) +#define CKM_WTLS_PRE_MASTER_KEY_GEN (0x3d0UL) +#define CKM_WTLS_MASTER_KEY_DERIVE (0x3d1UL) +#define CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC (0x3d2UL) +#define CKM_WTLS_PRF (0x3d3UL) +#define CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE (0x3d4UL) +#define CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE (0x3d5UL) +#define CKM_TLS10_MAC_SERVER (0x3d6UL) +#define CKM_TLS10_MAC_CLIENT (0x3d7UL) +#define CKM_TLS12_MAC (0x3d8UL) +#define CKM_TLS12_KDF (0x3d9UL) +#define CKM_TLS12_MASTER_KEY_DERIVE (0x3e0UL) +#define CKM_TLS12_KEY_AND_MAC_DERIVE (0x3e1UL) +#define CKM_TLS12_MASTER_KEY_DERIVE_DH (0x3e2UL) +#define CKM_TLS12_KEY_SAFE_DERIVE (0x3e3UL) +#define CKM_TLS_MAC (0x3e4UL) +#define CKM_TLS_KDF (0x3e5UL) +#define CKM_KEY_WRAP_LYNKS (0x400UL) +#define CKM_KEY_WRAP_SET_OAEP (0x401UL) +#define CKM_CMS_SIG (0x500UL) +#define CKM_KIP_DERIVE (0x510UL) +#define CKM_KIP_WRAP (0x511UL) +#define CKM_KIP_MAC (0x512UL) +#define CKM_CAMELLIA_KEY_GEN (0x550UL) +#define CKM_CAMELLIA_ECB (0x551UL) +#define CKM_CAMELLIA_CBC (0x552UL) +#define CKM_CAMELLIA_MAC (0x553UL) +#define CKM_CAMELLIA_MAC_GENERAL (0x554UL) +#define CKM_CAMELLIA_CBC_PAD (0x555UL) +#define CKM_CAMELLIA_ECB_ENCRYPT_DATA (0x556UL) +#define CKM_CAMELLIA_CBC_ENCRYPT_DATA (0x557UL) +#define CKM_CAMELLIA_CTR (0x558UL) +#define CKM_ARIA_KEY_GEN (0x560UL) +#define CKM_ARIA_ECB (0x561UL) +#define CKM_ARIA_CBC (0x562UL) +#define CKM_ARIA_MAC (0x563UL) +#define CKM_ARIA_MAC_GENERAL (0x564UL) +#define CKM_ARIA_CBC_PAD (0x565UL) +#define CKM_ARIA_ECB_ENCRYPT_DATA (0x566UL) +#define CKM_ARIA_CBC_ENCRYPT_DATA (0x567UL) +#define CKM_SEED_KEY_GEN (0x650UL) +#define CKM_SEED_ECB (0x651UL) +#define CKM_SEED_CBC (0x652UL) +#define CKM_SEED_MAC (0x653UL) +#define CKM_SEED_MAC_GENERAL (0x654UL) +#define CKM_SEED_CBC_PAD (0x655UL) +#define CKM_SEED_ECB_ENCRYPT_DATA (0x656UL) +#define CKM_SEED_CBC_ENCRYPT_DATA (0x657UL) +#define CKM_SKIPJACK_KEY_GEN (0x1000UL) +#define CKM_SKIPJACK_ECB64 (0x1001UL) +#define CKM_SKIPJACK_CBC64 (0x1002UL) +#define CKM_SKIPJACK_OFB64 (0x1003UL) +#define CKM_SKIPJACK_CFB64 (0x1004UL) +#define CKM_SKIPJACK_CFB32 (0x1005UL) +#define CKM_SKIPJACK_CFB16 (0x1006UL) +#define CKM_SKIPJACK_CFB8 (0x1007UL) +#define CKM_SKIPJACK_WRAP (0x1008UL) +#define CKM_SKIPJACK_PRIVATE_WRAP (0x1009UL) +#define CKM_SKIPJACK_RELAYX (0x100aUL) +#define CKM_KEA_KEY_PAIR_GEN (0x1010UL) +#define CKM_KEA_KEY_DERIVE (0x1011UL) +#define CKM_FORTEZZA_TIMESTAMP (0x1020UL) +#define CKM_BATON_KEY_GEN (0x1030UL) +#define CKM_BATON_ECB128 (0x1031UL) +#define CKM_BATON_ECB96 (0x1032UL) +#define CKM_BATON_CBC128 (0x1033UL) +#define CKM_BATON_COUNTER (0x1034UL) +#define CKM_BATON_SHUFFLE (0x1035UL) +#define CKM_BATON_WRAP (0x1036UL) +#define CKM_ECDSA_KEY_PAIR_GEN (0x1040UL) +#define CKM_EC_KEY_PAIR_GEN (0x1040UL) +#define CKM_ECDSA (0x1041UL) +#define CKM_ECDSA_SHA1 (0x1042UL) +#define CKM_ECDSA_SHA224 (0x1043UL) +#define CKM_ECDSA_SHA256 (0x1044UL) +#define CKM_ECDSA_SHA384 (0x1045UL) +#define CKM_ECDSA_SHA512 (0x1046UL) +#define CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS (0x140bUL) +#define CKM_ECDH1_DERIVE (0x1050UL) +#define CKM_ECDH1_COFACTOR_DERIVE (0x1051UL) +#define CKM_ECMQV_DERIVE (0x1052UL) +#define CKM_ECDH_AES_KEY_WRAP (0x1053UL) +#define CKM_RSA_AES_KEY_WRAP (0x1054UL) +#define CKM_JUNIPER_KEY_GEN (0x1060UL) +#define CKM_JUNIPER_ECB128 (0x1061UL) +#define CKM_JUNIPER_CBC128 (0x1062UL) +#define CKM_JUNIPER_COUNTER (0x1063UL) +#define CKM_JUNIPER_SHUFFLE (0x1064UL) +#define CKM_JUNIPER_WRAP (0x1065UL) +#define CKM_FASTHASH (0x1070UL) +#define CKM_AES_XTS (0x1071UL) +#define CKM_AES_XTS_KEY_GEN (0x1072UL) +#define CKM_AES_KEY_GEN (0x1080UL) +#define CKM_AES_ECB (0x1081UL) +#define CKM_AES_CBC (0x1082UL) +#define CKM_AES_MAC (0x1083UL) +#define CKM_AES_MAC_GENERAL (0x1084UL) +#define CKM_AES_CBC_PAD (0x1085UL) +#define CKM_AES_CTR (0x1086UL) +#define CKM_AES_GCM (0x1087UL) +#define CKM_AES_CCM (0x1088UL) +#define CKM_AES_CTS (0x1089UL) +#define CKM_AES_CMAC (0x108aUL) +#define CKM_AES_CMAC_GENERAL (0x108bUL) +#define CKM_AES_XCBC_MAC (0x108cUL) +#define CKM_AES_XCBC_MAC_96 (0x108dUL) +#define CKM_AES_GMAC (0x108eUL) +#define CKM_BLOWFISH_KEY_GEN (0x1090UL) +#define CKM_BLOWFISH_CBC (0x1091UL) +#define CKM_TWOFISH_KEY_GEN (0x1092UL) +#define CKM_TWOFISH_CBC (0x1093UL) +#define CKM_BLOWFISH_CBC_PAD (0x1094UL) +#define CKM_TWOFISH_CBC_PAD (0x1095UL) +#define CKM_DES_ECB_ENCRYPT_DATA (0x1100UL) +#define CKM_DES_CBC_ENCRYPT_DATA (0x1101UL) +#define CKM_DES3_ECB_ENCRYPT_DATA (0x1102UL) +#define CKM_DES3_CBC_ENCRYPT_DATA (0x1103UL) +#define CKM_AES_ECB_ENCRYPT_DATA (0x1104UL) +#define CKM_AES_CBC_ENCRYPT_DATA (0x1105UL) +#define CKM_GOSTR3410_KEY_PAIR_GEN (0x1200UL) +#define CKM_GOSTR3410 (0x1201UL) +#define CKM_GOSTR3410_WITH_GOSTR3411 (0x1202UL) +#define CKM_GOSTR3410_KEY_WRAP (0x1203UL) +#define CKM_GOSTR3410_DERIVE (0x1204UL) +#define CKM_GOSTR3411 (0x1210UL) +#define CKM_GOSTR3411_HMAC (0x1211UL) +#define CKM_GOST28147_KEY_GEN (0x1220UL) +#define CKM_GOST28147_ECB (0x1221UL) +#define CKM_GOST28147 (0x1222UL) +#define CKM_GOST28147_MAC (0x1223UL) +#define CKM_GOST28147_KEY_WRAP (0x1224UL) +#define CKM_CHACHA20_KEY_GEN (0x1225UL) +#define CKM_CHACHA20 (0x1226UL) +#define CKM_POLY1305_KEY_GEN (0x1227UL) +#define CKM_POLY1305 (0x1228UL) +#define CKM_DSA_PARAMETER_GEN (0x2000UL) +#define CKM_DH_PKCS_PARAMETER_GEN (0x2001UL) +#define CKM_X9_42_DH_PARAMETER_GEN (0x2002UL) +#define CKM_DSA_PROBABILISTIC_PARAMETER_GEN (0x2003UL) +#define CKM_DSA_PROBABLISTIC_PARAMETER_GEN (0x2003UL) +#define CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN (0x2004UL) +#define CKM_DSA_FIPS_G_GEN (0x2005UL) +#define CKM_AES_OFB (0x2104UL) +#define CKM_AES_CFB64 (0x2105UL) +#define CKM_AES_CFB8 (0x2106UL) +#define CKM_AES_CFB128 (0x2107UL) +#define CKM_AES_CFB1 (0x2108UL) +#define CKM_AES_KEY_WRAP (0x2109UL) +#define CKM_AES_KEY_WRAP_PAD (0x210aUL) +#define CKM_AES_KEY_WRAP_KWP (0x210BUL) +#define CKM_AES_KEY_WRAP_PKCS7 (0x210CUL) +#define CKM_RSA_PKCS_TPM_1_1 (0x4001UL) +#define CKM_RSA_PKCS_OAEP_TPM_1_1 (0x4002UL) +#define CKM_SHA_1_KEY_GEN (0x4003UL) +#define CKM_SHA224_KEY_GEN (0x4004UL) +#define CKM_SHA256_KEY_GEN (0x4005UL) +#define CKM_SHA384_KEY_GEN (0x4006UL) +#define CKM_SHA512_KEY_GEN (0x4007UL) +#define CKM_SHA512_224_KEY_GEN (0x4008UL) +#define CKM_SHA512_256_KEY_GEN (0x4009UL) +#define CKM_SHA512_T_KEY_GEN (0x400aUL) +#define CKM_NULL (0x400bUL) +#define CKM_BLAKE2B_160 (0x400cUL) +#define CKM_BLAKE2B_160_HMAC (0x400dUL) +#define CKM_BLAKE2B_160_HMAC_GENERAL (0x400eUL) +#define CKM_BLAKE2B_160_KEY_DERIVE (0x400fUL) +#define CKM_BLAKE2B_160_KEY_GEN (0x4010UL) +#define CKM_BLAKE2B_256 (0x4011UL) +#define CKM_BLAKE2B_256_HMAC (0x4012UL) +#define CKM_BLAKE2B_256_HMAC_GENERAL (0x4013UL) +#define CKM_BLAKE2B_256_KEY_DERIVE (0x4014UL) +#define CKM_BLAKE2B_256_KEY_GEN (0x4015UL) +#define CKM_BLAKE2B_384 (0x4016UL) +#define CKM_BLAKE2B_384_HMAC (0x4017UL) +#define CKM_BLAKE2B_384_HMAC_GENERAL (0x4018UL) +#define CKM_BLAKE2B_384_KEY_DERIVE (0x4019UL) +#define CKM_BLAKE2B_384_KEY_GEN (0x401aUL) +#define CKM_BLAKE2B_512 (0x401bUL) +#define CKM_BLAKE2B_512_HMAC (0x401cUL) +#define CKM_BLAKE2B_512_HMAC_GENERAL (0x401dUL) +#define CKM_BLAKE2B_512_KEY_DERIVE (0x401eUL) +#define CKM_BLAKE2B_512_KEY_GEN (0x401fUL) +#define CKM_SALSA20 (0x4020UL) +#define CKM_CHACHA20_POLY1305 (0x4021UL) +#define CKM_SALSA20_POLY1305 (0x4022UL) +#define CKM_X3DH_INITIALIZE (0x4023UL) +#define CKM_X3DH_RESPOND (0x4024UL) +#define CKM_X2RATCHET_INITIALIZE (0x4025UL) +#define CKM_X2RATCHET_RESPOND (0x4026UL) +#define CKM_X2RATCHET_ENCRYPT (0x4027UL) +#define CKM_X2RATCHET_DECRYPT (0x4028UL) +#define CKM_XEDDSA (0x4029UL) +#define CKM_HKDF_DERIVE (0x402aUL) +#define CKM_HKDF_DATA (0x402bUL) +#define CKM_HKDF_KEY_GEN (0x402cUL) +#define CKM_SALSA20_KEY_GEN (0x402dUL) +#define CKM_ECDSA_SHA3_224 (0x1047UL) +#define CKM_ECDSA_SHA3_256 (0x1048UL) +#define CKM_ECDSA_SHA3_384 (0x1049UL) +#define CKM_ECDSA_SHA3_512 (0x104aUL) +#define CKM_EC_EDWARDS_KEY_PAIR_GEN (0x1055UL) +#define CKM_EC_MONTGOMERY_KEY_PAIR_GEN (0x1056UL) +#define CKM_EDDSA (0x1057UL) +#define CKM_SP800_108_COUNTER_KDF (0x3acUL) +#define CKM_SP800_108_FEEDBACK_KDF (0x3adUL) +#define CKM_SP800_108_DOUBLE_PIPELINE_KDF (0x3AEUL) +#define CKM_IKE2_PRF_PLUS_DERIVE (0x402EUL) +#define CKM_IKE_PRF_DERIVE (0x402FUL) +#define CKM_IKE1_PRF_DERIVE (0x4030UL) +#define CKM_IKE1_EXTENDED_DERIVE (0x4031UL) +#define CKM_HSS_KEY_PAIR_GEN (0x4032UL) +#define CKM_HSS (0x4033UL) +#define CKM_XMSS_KEY_PAIR_GEN (0x4034UL) +#define CKM_XMSSMT_KEY_PAIR_GEN (0x4035UL) +#define CKM_XMSS (0x4036UL) +#define CKM_XMSSMT (0x4037UL) +#define CKM_ECDH_X_AES_KEY_WRAP (0x4038UL) +#define CKM_ECDH_COF_AES_KEY_WRAP (0x4039UL) +#define CKM_PUB_KEY_FROM_PRIV_KEY (0x403AUL) +/* + * Thales Luna customer-defined Falcon identifiers. + * Falcon does not currently have standard PKCS#11 CKM_ values. + * Luna defines the key type and mechanisms in its customer-defined range. + */ +#define CKM_FALCON_KEY_PAIR_GEN (0xC0000070UL) +#define CKM_FALCON (0xC0000071UL) +#define CKM_PQC_FALCON (CKM_VENDOR_DEFINED + 0x10025UL) +#define CKM_VENDOR_DEFINED ((unsigned long) (1UL << 31)) + +/* CK_NOTIFICATION */ +#define CKN_SURRENDER (0UL) +#define CKN_OTP_CHANGED (1UL) + +/* CK_OBJECT_CLASS */ +#define CKO_DATA (0UL) +#define CKO_CERTIFICATE (1UL) +#define CKO_PUBLIC_KEY (2UL) +#define CKO_PRIVATE_KEY (3UL) +#define CKO_SECRET_KEY (4UL) +#define CKO_HW_FEATURE (5UL) +#define CKO_DOMAIN_PARAMETERS (6UL) +#define CKO_MECHANISM (7UL) +#define CKO_OTP_KEY (8UL) +#define CKO_PROFILE (9UL) +#define CKO_VALIDATION (0xaUL) +#define CKO_TRUST (0xbUL) +#define CKO_VENDOR_DEFINED ((unsigned long) (1UL << 31)) + +/* CK_OTP_PARAM_TYPE */ +#define CK_OTP_VALUE (0UL) +#define CK_OTP_PIN (1UL) +#define CK_OTP_CHALLENGE (2UL) +#define CK_OTP_TIME (3UL) +#define CK_OTP_COUNTER (4UL) +#define CK_OTP_FLAGS (5UL) +#define CK_OTP_OUTPUT_LENGTH (6UL) +#define CK_OTP_OUTPUT_FORMAT (7UL) +#define CK_OTP_FORMAT (7UL) + +/* CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE */ +#define CKP_PKCS5_PBKD2_HMAC_SHA1 (1UL) +#define CKP_PKCS5_PBKD2_HMAC_GOSTR3411 (2UL) +#define CKP_PKCS5_PBKD2_HMAC_SHA224 (3UL) +#define CKP_PKCS5_PBKD2_HMAC_SHA256 (4UL) +#define CKP_PKCS5_PBKD2_HMAC_SHA384 (5UL) +#define CKP_PKCS5_PBKD2_HMAC_SHA512 (6UL) +#define CKP_PKCS5_PBKD2_HMAC_SHA512_224 (7UL) +#define CKP_PKCS5_PBKD2_HMAC_SHA512_256 (8UL) + +/* CK_ML_DSA_PARAMETER_SET_TYPE */ +#define CKP_ML_DSA_44 (1UL) +#define CKP_ML_DSA_65 (2UL) +#define CKP_ML_DSA_87 (3UL) + +/* CK_ML_KEM_PARAMETER_SET_TYPE */ +#define CKP_ML_KEM_512 (1UL) +#define CKP_ML_KEM_768 (2UL) +#define CKP_ML_KEM_1024 (3UL) + +/* CK_SLH_DSA_PARAMETER_SET_TYPE */ +#define CKP_SLH_DSA_SHA2_128S (1UL) +#define CKP_SLH_DSA_SHAKE_128S (2UL) +#define CKP_SLH_DSA_SHA2_128F (3UL) +#define CKP_SLH_DSA_SHAKE_128F (4UL) +#define CKP_SLH_DSA_SHA2_192S (5UL) +#define CKP_SLH_DSA_SHAKE_192S (6UL) +#define CKP_SLH_DSA_SHA2_192F (7UL) +#define CKP_SLH_DSA_SHAKE_192F (8UL) +#define CKP_SLH_DSA_SHA2_256S (9UL) +#define CKP_SLH_DSA_SHAKE_256S (0xaUL) +#define CKP_SLH_DSA_SHA2_256F (0xbUL) +#define CKP_SLH_DSA_SHAKE_256F (0xcUL) + +/* CKP (FALCON) */ +#define CKP_FALCON_512 (0x0001UL) +#define CKP_FALCON_1024 (0x0002UL) + +/* CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE */ +#define CKZ_SALT_SPECIFIED (0x1UL) + +/* CK_PRF_DATA_TYPE */ +#define CK_SP800_108_ITERATION_VARIABLE (1UL) +#define CK_SP800_108_OPTIONAL_COUNTER (2UL) +#define CK_SP800_108_COUNTER (2UL) +#define CK_SP800_108_DKM_LENGTH (3UL) +#define CK_SP800_108_BYTE_ARRAY (4UL) +#define CK_SP800_108_KEY_HANDLE (5UL) + +/* CK_PROFILE_ID */ +#define CKP_INVALID_ID (0UL) +#define CKP_BASELINE_PROVIDER (1UL) +#define CKP_EXTENDED_PROVIDER (2UL) +#define CKP_AUTHENTICATION_TOKEN (3UL) +#define CKP_PUBLIC_CERTIFICATES_TOKEN (4UL) +#define CKP_COMPLETE_PROVIDER (5UL) +#define CKP_HKDF_TLS_TOKEN (6UL) +#define CKP_VENDOR_DEFINED (1UL << 31) + +/* CK_RSA_PKCS_MGF_TYPE */ +#define CKG_MGF1_SHA1 (0x1UL) +#define CKG_MGF1_SHA224 (0x5UL) +#define CKG_MGF1_SHA256 (0x2UL) +#define CKG_MGF1_SHA384 (0x3UL) +#define CKG_MGF1_SHA512 (0x4UL) +#define CKG_MGF1_SHA3_224 (0x6UL) +#define CKG_MGF1_SHA3_256 (0x7UL) +#define CKG_MGF1_SHA3_384 (0x8UL) +#define CKG_MGF1_SHA3_512 (0x9UL) + +/* CK_RSA_PKCS_OAEP_SOURCE_TYPE */ +#define CKZ_DATA_SPECIFIED (0x1UL) + +/* CK_RV */ +#define CKR_OK (0UL) +#define CKR_CANCEL (1UL) +#define CKR_HOST_MEMORY (2UL) +#define CKR_SLOT_ID_INVALID (3UL) +#define CKR_GENERAL_ERROR (5UL) +#define CKR_FUNCTION_FAILED (6UL) +#define CKR_ARGUMENTS_BAD (7UL) +#define CKR_NO_EVENT (8UL) +#define CKR_NEED_TO_CREATE_THREADS (9UL) +#define CKR_CANT_LOCK (0xaUL) +#define CKR_ATTRIBUTE_READ_ONLY (0x10UL) +#define CKR_ATTRIBUTE_SENSITIVE (0x11UL) +#define CKR_ATTRIBUTE_TYPE_INVALID (0x12UL) +#define CKR_ATTRIBUTE_VALUE_INVALID (0x13UL) +#define CKR_ACTION_PROHIBITED (0x1bUL) +#define CKR_DATA_INVALID (0x20UL) +#define CKR_DATA_LEN_RANGE (0x21UL) +#define CKR_DEVICE_ERROR (0x30UL) +#define CKR_DEVICE_MEMORY (0x31UL) +#define CKR_DEVICE_REMOVED (0x32UL) +#define CKR_ENCRYPTED_DATA_INVALID (0x40UL) +#define CKR_ENCRYPTED_DATA_LEN_RANGE (0x41UL) +#define CKR_AEAD_DECRYPT_FAILED (0x42UL) +#define CKR_FUNCTION_CANCELED (0x50UL) +#define CKR_FUNCTION_NOT_PARALLEL (0x51UL) +#define CKR_FUNCTION_NOT_SUPPORTED (0x54UL) +#define CKR_KEY_HANDLE_INVALID (0x60UL) +#define CKR_KEY_SIZE_RANGE (0x62UL) +#define CKR_KEY_TYPE_INCONSISTENT (0x63UL) +#define CKR_KEY_NOT_NEEDED (0x64UL) +#define CKR_KEY_CHANGED (0x65UL) +#define CKR_KEY_NEEDED (0x66UL) +#define CKR_KEY_INDIGESTIBLE (0x67UL) +#define CKR_KEY_FUNCTION_NOT_PERMITTED (0x68UL) +#define CKR_KEY_NOT_WRAPPABLE (0x69UL) +#define CKR_KEY_UNEXTRACTABLE (0x6aUL) +#define CKR_MECHANISM_INVALID (0x70UL) +#define CKR_MECHANISM_PARAM_INVALID (0x71UL) +#define CKR_OBJECT_HANDLE_INVALID (0x82UL) +#define CKR_OPERATION_ACTIVE (0x90UL) +#define CKR_OPERATION_NOT_INITIALIZED (0x91UL) +#define CKR_PIN_INCORRECT (0xa0UL) +#define CKR_PIN_INVALID (0xa1UL) +#define CKR_PIN_LEN_RANGE (0xa2UL) +#define CKR_PIN_EXPIRED (0xa3UL) +#define CKR_PIN_LOCKED (0xa4UL) +#define CKR_SESSION_CLOSED (0xb0UL) +#define CKR_SESSION_COUNT (0xb1UL) +#define CKR_SESSION_HANDLE_INVALID (0xb3UL) +#define CKR_SESSION_PARALLEL_NOT_SUPPORTED (0xb4UL) +#define CKR_SESSION_READ_ONLY (0xb5UL) +#define CKR_SESSION_EXISTS (0xb6UL) +#define CKR_SESSION_READ_ONLY_EXISTS (0xb7UL) +#define CKR_SESSION_READ_WRITE_SO_EXISTS (0xb8UL) +#define CKR_SIGNATURE_INVALID (0xc0UL) +#define CKR_SIGNATURE_LEN_RANGE (0xc1UL) +#define CKR_TEMPLATE_INCOMPLETE (0xd0UL) +#define CKR_TEMPLATE_INCONSISTENT (0xd1UL) +#define CKR_TOKEN_NOT_PRESENT (0xe0UL) +#define CKR_TOKEN_NOT_RECOGNIZED (0xe1UL) +#define CKR_TOKEN_WRITE_PROTECTED (0xe2UL) +#define CKR_UNWRAPPING_KEY_HANDLE_INVALID (0xf0UL) +#define CKR_UNWRAPPING_KEY_SIZE_RANGE (0xf1UL) +#define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT (0xf2UL) +#define CKR_USER_ALREADY_LOGGED_IN (0x100UL) +#define CKR_USER_NOT_LOGGED_IN (0x101UL) +#define CKR_USER_PIN_NOT_INITIALIZED (0x102UL) +#define CKR_USER_TYPE_INVALID (0x103UL) +#define CKR_USER_ANOTHER_ALREADY_LOGGED_IN (0x104UL) +#define CKR_USER_TOO_MANY_TYPES (0x105UL) +#define CKR_WRAPPED_KEY_INVALID (0x110UL) +#define CKR_WRAPPED_KEY_LEN_RANGE (0x112UL) +#define CKR_WRAPPING_KEY_HANDLE_INVALID (0x113UL) +#define CKR_WRAPPING_KEY_SIZE_RANGE (0x114UL) +#define CKR_WRAPPING_KEY_TYPE_INCONSISTENT (0x115UL) +#define CKR_RANDOM_SEED_NOT_SUPPORTED (0x120UL) +#define CKR_RANDOM_NO_RNG (0x121UL) +#define CKR_DOMAIN_PARAMS_INVALID (0x130UL) +#define CKR_CURVE_NOT_SUPPORTED (0x140UL) +#define CKR_BUFFER_TOO_SMALL (0x150UL) +#define CKR_SAVED_STATE_INVALID (0x160UL) +#define CKR_INFORMATION_SENSITIVE (0x170UL) +#define CKR_STATE_UNSAVEABLE (0x180UL) +#define CKR_CRYPTOKI_NOT_INITIALIZED (0x190UL) +#define CKR_CRYPTOKI_ALREADY_INITIALIZED (0x191UL) +#define CKR_MUTEX_BAD (0x1a0UL) +#define CKR_MUTEX_NOT_LOCKED (0x1a1UL) +#define CKR_NEW_PIN_MODE (0x1b0UL) +#define CKR_NEXT_OTP (0x1b1UL) +#define CKR_EXCEEDED_MAX_ITERATIONS (0x1c0UL) +#define CKR_FIPS_SELF_TEST_FAILED (0x1c1UL) +#define CKR_LIBRARY_LOAD_FAILED (0x1c2UL) +#define CKR_PIN_TOO_WEAK (0x1c3UL) +#define CKR_PUBLIC_KEY_INVALID (0x1c4UL) +#define CKR_FUNCTION_REJECTED (0x200UL) +#define CKR_TOKEN_RESOURCE_EXCEEDED (0x201UL) +#define CKR_OPERATION_CANCEL_FAILED (0x202UL) +#define CKR_KEY_EXHAUSTED (0x203UL) +#define CKR_PENDING (0x204UL) +#define CKR_SESSION_ASYNC_NOT_SUPPORTED (0x205UL) +#define CKR_SEED_RANDOM_REQUIRED (0x206UL) +#define CKR_OPERATION_NOT_VALIDATED (0x207UL) +#define CKR_TOKEN_NOT_INITIALIZED (0x208UL) +#define CKR_PARAMETER_SET_NOT_SUPPORTED (0x209UL) +#define CKR_ECC_POINT_INVALID (CKR_VENDOR_DEFINED + 0x2F) +#define CKR_VENDOR_DEFINED ((unsigned long) (1UL << 31)) + +/* CK_SP800_108_DKM_LENGTH_METHOD */ +#define CK_SP800_108_DKM_LENGTH_SUM_OF_KEYS (1UL) +#define CK_SP800_108_DKM_LENGTH_SUM_OF_SEGMENTS (2UL) + +/* CK_STATE */ +#define CKS_RO_PUBLIC_SESSION (0UL) +#define CKS_RO_USER_FUNCTIONS (1UL) +#define CKS_RW_PUBLIC_SESSION (2UL) +#define CKS_RW_USER_FUNCTIONS (3UL) +#define CKS_RW_SO_FUNCTIONS (4UL) + +/* CK_SESSION_VALIDATION_FLAGS_TYPE */ +#define CKS_LAST_VALIDATION_OK (1UL) + +/* CK_TRUST */ +#define CKT_TRUST_UNKNOWN (0UL) +#define CKT_TRUSTED (1UL) +#define CKT_TRUST_ANCHOR (2UL) +#define CKT_NOT_TRUSTED (3UL) +#define CKT_TRUST_MUST_VERIFY_TRUST (4UL) + +/* CK_USER_TYPE */ +#define CKU_SO (0UL) +#define CKU_USER (1UL) +#define CKU_CONTEXT_SPECIFIC (2UL) + +/* CK_VALIDATION_AUTHORITY_TYPE */ +#define CKV_AUTHORITY_TYPE_UNSPECIFIED (0UL) +#define CKV_AUTHORITY_TYPE_NIST_CMVP (1UL) +#define CKV_AUTHORITY_TYPE_COMMON_CRITERIA (2UL) + +/* CK_VALIDATION_TYPE */ +#define CKV_TYPE_UNSPECIFIED (0UL) +#define CKV_TYPE_SOFTWARE (1UL) +#define CKV_TYPE_HARDWARE (2UL) +#define CKV_TYPE_FIRMWARE (3UL) +#define CKV_TYPE_HYBRID (4UL) + +/* Attribute and other constants related to OTP */ +#define CK_OTP_FORMAT_DECIMAL (0UL) +#define CK_OTP_FORMAT_HEXADECIMAL (1UL) +#define CK_OTP_FORMAT_ALPHANUMERIC (2UL) +#define CK_OTP_FORMAT_BINARY (3UL) +#define CK_OTP_PARAM_IGNORED (0UL) +#define CK_OTP_PARAM_OPTIONAL (1UL) +#define CK_OTP_PARAM_MANDATORY (2UL) + +#define CK_UNAVAILABLE_INFORMATION ((unsigned long)-1L) +#define CK_EFFECTIVELY_INFINITE (0UL) +#define CK_INVALID_HANDLE (0UL) + +typedef unsigned long ck_attribute_type_t; +typedef unsigned long ck_certificate_category_t; +typedef unsigned long ck_certificate_type_t; +typedef unsigned long ck_ec_kdf_type_t; +typedef unsigned long ck_extract_params_t; typedef unsigned long ck_flags_t; +typedef unsigned long ck_generator_function_t; +typedef unsigned long ck_hss_levels_t; +typedef unsigned long ck_hw_feature_type_t; +typedef unsigned long ck_java_midp_security_domain_t; +typedef unsigned long ck_key_type_t; +typedef unsigned long ck_lms_type_t; +typedef unsigned long ck_lmots_type_t; +typedef unsigned long ck_mac_general_params_t; +typedef unsigned long ck_mechanism_type_t; +typedef unsigned long ck_notification_t; +typedef unsigned long ck_object_class_t; +typedef unsigned long ck_object_handle_t; +typedef unsigned long ck_otp_param_type_t; +typedef unsigned long ck_pkcs5_pbkd2_pseudo_random_function_type_t; +typedef unsigned long ck_pkcs5_pbkdf2_salt_source_type_t; +typedef unsigned long ck_prf_data_type_t; +typedef unsigned long ck_profile_id_t; +typedef unsigned long ck_rc2_params_t; +typedef unsigned long ck_rsa_pkcs_mgf_type_t; +typedef unsigned long ck_rsa_pkcs_oaep_source_type_t; +typedef unsigned long ck_rv_t; +typedef unsigned long ck_session_handle_t; +typedef unsigned long ck_slot_id_t; +typedef unsigned long ck_sp800_108_dkm_length_method_t; +typedef unsigned long ck_state_t; +typedef unsigned long ck_user_type_t; +typedef unsigned long ck_x2ratchet_kdf_type_t; +typedef unsigned long ck_x3dh_kdf_type_t; +typedef unsigned long ck_x9_42_dh_kdf_type_t; +typedef unsigned long ck_xeddsa_hash_type_t; +typedef unsigned long ck_hedge_type_t; +typedef unsigned long ck_ml_dsa_parameter_set_type_t; +typedef unsigned long ck_ml_kem_parameter_set_type_t; +typedef unsigned long ck_session_validation_flags_type_t; +typedef unsigned long ck_slh_dsa_parameter_set_type_t; +typedef unsigned long ck_trust_t; +typedef unsigned long ck_validation_authority_type_t; +typedef unsigned long ck_validation_type_t; +typedef unsigned long ck_xmssmt_parameter_set_type_t; +typedef unsigned long ck_xmss_parameter_set_type_t; + +typedef ck_mechanism_type_t ck_sp800_108_prf_type_t; +typedef ck_otp_param_type_t ck_param_type; +typedef ck_profile_id_t ck_profile_id; +typedef ck_ec_kdf_type_t ck_ec_kdf_t; + +typedef ck_rv_t (*ck_createmutex_t) (void **mutex); +typedef ck_rv_t (*ck_destroymutex_t) (void *mutex); +typedef ck_rv_t (*ck_lockmutex_t) (void *mutex); +typedef ck_rv_t (*ck_unlockmutex_t) (void *mutex); +typedef ck_rv_t (*ck_notify_t) (ck_session_handle_t session, + ck_notification_t event, + void *application); + + + +struct ck_attribute +{ + ck_attribute_type_t type; + void *value; + unsigned long value_len; +}; + +struct ck_c_initialize_args +{ + ck_createmutex_t create_mutex; + ck_destroymutex_t destroy_mutex; + ck_lockmutex_t lock_mutex; + ck_unlockmutex_t unlock_mutex; + ck_flags_t flags; + void *reserved; +}; + +struct ck_date +{ + unsigned char year[4]; + unsigned char month[2]; + unsigned char day[2]; +}; + +struct ck_derived_key +{ + struct ck_attribute *templ; + unsigned long attribute_count; + ck_object_handle_t *key_ptr; +}; struct ck_version { @@ -191,7 +1670,6 @@ struct ck_version unsigned char minor; }; - struct ck_info { struct ck_version cryptoki_version; @@ -201,14 +1679,33 @@ struct ck_info struct ck_version library_version; }; +struct ck_interface { + char *interface_name_ptr; + void *function_list_ptr; + ck_flags_t flags; +}; -typedef unsigned long ck_notification_t; - -#define CKN_SURRENDER (0UL) - +struct ck_mechanism +{ + ck_mechanism_type_t mechanism; + void *parameter; + unsigned long parameter_len; +}; -typedef unsigned long ck_slot_id_t; +struct ck_mechanism_info +{ + unsigned long min_key_size; + unsigned long max_key_size; + ck_flags_t flags; +}; +struct ck_session_info +{ + ck_slot_id_t slot_id; + ck_state_t state; + ck_flags_t flags; + unsigned long device_error; +}; struct ck_slot_info { @@ -219,13 +1716,6 @@ struct ck_slot_info struct ck_version firmware_version; }; - -#define CKF_TOKEN_PRESENT (1UL << 0) -#define CKF_REMOVABLE_DEVICE (1UL << 1) -#define CKF_HW_SLOT (1UL << 2) -#define CKF_ARRAY_ATTRIBUTE (1UL << 30) - - struct ck_token_info { unsigned char label[32]; @@ -248,706 +1738,700 @@ struct ck_token_info unsigned char utc_time[16]; }; +struct ck_aes_cbc_encrypt_data_params { + unsigned char iv[16]; + unsigned char *data_params; + unsigned long length; +}; -#define CKF_RNG (1UL << 0) -#define CKF_WRITE_PROTECTED (1UL << 1) -#define CKF_LOGIN_REQUIRED (1UL << 2) -#define CKF_USER_PIN_INITIALIZED (1UL << 3) -#define CKF_RESTORE_KEY_NOT_NEEDED (1UL << 5) -#define CKF_CLOCK_ON_TOKEN (1UL << 6) -#define CKF_PROTECTED_AUTHENTICATION_PATH (1UL << 8) -#define CKF_DUAL_CRYPTO_OPERATIONS (1UL << 9) -#define CKF_TOKEN_INITIALIZED (1UL << 10) -#define CKF_SECONDARY_AUTHENTICATION (1UL << 11) -#define CKF_USER_PIN_COUNT_LOW (1UL << 16) -#define CKF_USER_PIN_FINAL_TRY (1UL << 17) -#define CKF_USER_PIN_LOCKED (1UL << 18) -#define CKF_USER_PIN_TO_BE_CHANGED (1UL << 19) -#define CKF_SO_PIN_COUNT_LOW (1UL << 20) -#define CKF_SO_PIN_FINAL_TRY (1UL << 21) -#define CKF_SO_PIN_LOCKED (1UL << 22) -#define CKF_SO_PIN_TO_BE_CHANGED (1UL << 23) - -#define CK_UNAVAILABLE_INFORMATION ((unsigned long) -1) -#define CK_EFFECTIVELY_INFINITE (0UL) +struct ck_aes_ccm_params { + unsigned long data_len; + unsigned char *nonce_ptr; + unsigned long nonce_len; + unsigned char *aad_ptr; + unsigned long aad_len; + unsigned long mac_len; +}; +struct ck_aes_ctr_params { + unsigned long counter_bits; + unsigned char cb[16]; +}; -typedef unsigned long ck_session_handle_t; +struct ck_aes_gcm_params { + unsigned char *iv_ptr; + unsigned long iv_len; + unsigned long iv_bits; + unsigned char *aad_ptr; + unsigned long aad_len; + unsigned long tag_bits; +}; -#define CK_INVALID_HANDLE (0UL) +struct ck_aria_cbc_encrypt_data_params { + unsigned char iv[16]; + unsigned char *data_params; + unsigned long length; +}; +struct ck_async_data { + unsigned long version_num; + unsigned char *value; + unsigned long value_len; + ck_object_handle_t object_handle; + ck_object_handle_t additional_object_handle; +}; -typedef unsigned long ck_user_type_t; +struct ck_camellia_cbc_encrypt_data_params { + unsigned char iv[16]; + unsigned char *data_params; + unsigned long length; +}; -#define CKU_SO (0UL) -#define CKU_USER (1UL) -#define CKU_CONTEXT_SPECIFIC (2UL) +struct ck_camellia_ctr_params { + unsigned long counter_bits; + unsigned char cb[16]; +}; +struct ck_ccm_message_params { + unsigned long data_len; + unsigned char *nonce_ptr; + unsigned long nonce_len; + unsigned long nonce_fixed_bits; + ck_generator_function_t nonce_generator; + unsigned char *mac_ptr; + unsigned long mac_len; +}; -typedef unsigned long ck_state_t; +struct ck_ccm_params { + unsigned long data_len; + unsigned char *nonce; + unsigned long nonce_len; + unsigned char *aad; + unsigned long aad_len; + unsigned long mac_len; +}; -#define CKS_RO_PUBLIC_SESSION (0UL) -#define CKS_RO_USER_FUNCTIONS (1UL) -#define CKS_RW_PUBLIC_SESSION (2UL) -#define CKS_RW_USER_FUNCTIONS (3UL) -#define CKS_RW_SO_FUNCTIONS (4UL) +struct ck_ccm_wrap_params { + unsigned long data_len; + unsigned char *nonce_ptr; + unsigned long nonce_len; + unsigned long nonce_fixed_bits; + ck_generator_function_t nonce_generator; + unsigned char *aad_ptr; + unsigned long aad_len; + unsigned long mac_len; +}; +struct ck_chacha20_params { + unsigned char *block_counter; + unsigned long block_counter_bits; + unsigned char *nonce_ptr; + unsigned long nonce_bits; +}; -struct ck_session_info -{ - ck_slot_id_t slot_id; - ck_state_t state; - ck_flags_t flags; - unsigned long device_error; +struct ck_cms_sig_params { + ck_object_handle_t certificate_handle; + struct ck_mechanism *signing_mechanism_ptr; + struct ck_mechanism *digest_mechanism_ptr; + unsigned char *content_type; + unsigned char *requested_attributes; + unsigned long requested_attributes_len; + unsigned char *required_attributes; + unsigned long required_attributes_len; }; -#define CKF_RW_SESSION (1UL << 1) -#define CKF_SERIAL_SESSION (1UL << 2) +struct ck_des_cbc_encrypt_data_params { + unsigned char iv[8]; + unsigned char *data_params; + unsigned long length; +}; +struct ck_dsa_parameter_gen_param { + ck_mechanism_type_t hash; + unsigned char *seed_ptr; + unsigned long seed_len; + unsigned long index; +}; -typedef unsigned long ck_object_handle_t; +struct ck_ecdh_aes_key_wrap_params { + unsigned long aes_key_bits; + ck_ec_kdf_type_t kdf; + unsigned long seed_len; + unsigned long index; +}; +struct ck_ecdh1_derive_params { + ck_ec_kdf_type_t kdf; + unsigned long shared_data_len; + unsigned char *shared_data; + unsigned long public_data_len; + unsigned char *public_data; +}; -typedef unsigned long ck_object_class_t; +struct ck_ecdh2_derive_params { + ck_ec_kdf_type_t kdf; + unsigned long shared_data_len; + unsigned char *shared_data; + unsigned long public_data_len; + unsigned char *public_data; + unsigned long private_data_len; + ck_object_handle_t private_data; + unsigned long public_data_len2; + unsigned char *public_data2; +}; -#define CKO_DATA (0UL) -#define CKO_CERTIFICATE (1UL) -#define CKO_PUBLIC_KEY (2UL) -#define CKO_PRIVATE_KEY (3UL) -#define CKO_SECRET_KEY (4UL) -#define CKO_HW_FEATURE (5UL) -#define CKO_DOMAIN_PARAMETERS (6UL) -#define CKO_MECHANISM (7UL) -#define CKO_VENDOR_DEFINED (1UL << 31) +struct ck_ecmqv_derive_params { + ck_ec_kdf_type_t kdf; + unsigned long shared_data_len; + unsigned char *shared_data; + unsigned long public_data_len; + unsigned char *public_data; + unsigned long private_data_len; + ck_object_handle_t private_data; + unsigned long public_data_len2; + unsigned char *public_data2; + ck_object_handle_t public_key; +}; +struct ck_eddsa_params { + unsigned char flag; + unsigned long context_data_len; + unsigned char *context_data; +}; -typedef unsigned long ck_hw_feature_type_t; +struct ck_gcm_message_params { + unsigned char *iv_ptr; + unsigned long iv_len; + unsigned long iv_fixed_bits; + ck_generator_function_t iv_generator; + unsigned char *tag_ptr; + unsigned long tag_bits; +}; -#define CKH_MONOTONIC_COUNTER (1UL) -#define CKH_CLOCK (2UL) -#define CKH_USER_INTERFACE (3UL) -#define CKH_VENDOR_DEFINED (1UL << 31) +struct ck_gcm_params { + unsigned char *iv_ptr; + unsigned long iv_len; + unsigned long iv_bits; + unsigned char *aad_ptr; + unsigned long aad_len; + unsigned long tag_bits; +}; +struct ck_gcm_wrap_params { + unsigned char *iv_ptr; + unsigned long iv_len; + unsigned long iv_fixed_bits; + ck_generator_function_t iv_generator; + unsigned char *aad_ptr; + unsigned long aad_len; + unsigned long tag_bits; +}; -typedef unsigned long ck_key_type_t; +struct ck_gostr3410_derive_params { + ck_ec_kdf_type_t kdf; + unsigned char *public_data; + unsigned long public_data_len; + unsigned char *ukm_ptr; + unsigned long ukm_len; +}; -#define CKK_RSA (0UL) -#define CKK_DSA (1UL) -#define CKK_DH (2UL) -#define CKK_ECDSA (3UL) -#define CKK_EC (3UL) -#define CKK_X9_42_DH (4UL) -#define CKK_KEA (5UL) -#define CKK_GENERIC_SECRET (0x10UL) -#define CKK_RC2 (0x11UL) -#define CKK_RC4 (0x12UL) -#define CKK_DES (0x13UL) -#define CKK_DES2 (0x14UL) -#define CKK_DES3 (0x15UL) -#define CKK_CAST (0x16UL) -#define CKK_CAST3 (0x17UL) -#define CKK_CAST128 (0x18UL) -#define CKK_RC5 (0x19UL) -#define CKK_IDEA (0x1aUL) -#define CKK_SKIPJACK (0x1bUL) -#define CKK_BATON (0x1cUL) -#define CKK_JUNIPER (0x1dUL) -#define CKK_CDMF (0x1eUL) -#define CKK_AES (0x1fUL) -#define CKK_BLOWFISH (0x20UL) -#define CKK_TWOFISH (0x21UL) -#define CKK_GOSTR3410 (0x30UL) -#define CKK_GOSTR3411 (0x31UL) -#define CKK_GOST28147 (0x32UL) -#define CKK_EC_EDWARDS (0x40UL) -#define CKK_EC_MONTGOMERY (0x41UL) -#define CKK_ML_DSA (0x4AUL) -#define CKK_SLH_DSA (0x4BUL) -/* - * Thales Luna customer-defined Falcon identifiers. - * Falcon does not currently have standard PKCS#11 CKK_ values. - * Luna defines the key type and mechanisms in its customer-defined range. - */ -#define CKK_FALCON (0xC0000006UL) -#define CKK_VENDOR_DEFINED (1UL << 31) +struct ck_gostr3410_key_wrap_params { + unsigned char *wrap_oid; + unsigned long wrap_oid_len; + unsigned char *ukm_ptr; + unsigned long ukm_len; + ck_object_handle_t key; +}; -/* - * A mask for new GOST algorithms. For details visit: - * https://tc26.ru/standarts/perevody/guidelines-the-pkcs-11-extensions-for-implementing-the-gost-r-34-10-2012-and-gost-r-34-11-2012-russian-standards-.html - */ -#define NSSCK_VENDOR_PKCS11_RU_TEAM (CKK_VENDOR_DEFINED | 0x54321000) -#define CK_VENDOR_PKCS11_RU_TEAM_TK26 NSSCK_VENDOR_PKCS11_RU_TEAM +struct ck_hash_sign_additional_context { + ck_hedge_type_t hedge_variant; + unsigned char *context_ptr; + unsigned long context_len; + ck_mechanism_type_t hash; +}; -#define CKK_GOSTR3410_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x003) +struct ck_hkdf_params { + unsigned char extract; + unsigned char expand; + ck_mechanism_type_t prf_hash_mechanism; + unsigned long salt_type; + unsigned char *salt_ptr; + unsigned long salt_len; + ck_object_handle_t salt_key; + unsigned char *info; + unsigned long info_len; +}; -typedef unsigned long ck_certificate_type_t; +struct ck_kea_derive_params { + unsigned char is_sender; + unsigned long random_len; + unsigned char *random_a; + unsigned char *random_b; + unsigned long public_data_len; + unsigned char *public_data; +}; -#define CKC_X_509 (0UL) -#define CKC_X_509_ATTR_CERT (1UL) -#define CKC_WTLS (2UL) -#define CKC_VENDOR_DEFINED (1UL << 31) +struct ck_key_derivation_string_data { + unsigned char *string_data; + unsigned long string_data_len; +}; +struct ck_key_wrap_set_oaep_params { + unsigned char bc; + unsigned char *x_ptr; + unsigned long x_len; +}; -typedef unsigned long ck_attribute_type_t; +struct ck_kip_params { + struct ck_mechanism *mechanism_ptr; + ck_object_handle_t key; + unsigned char *seed_ptr; + unsigned long seed_len; +}; -#define CKA_CLASS (0UL) -#define CKA_TOKEN (1UL) -#define CKA_PRIVATE (2UL) -#define CKA_LABEL (3UL) -#define CKA_APPLICATION (0x10UL) -#define CKA_VALUE (0x11UL) -#define CKA_OBJECT_ID (0x12UL) -#define CKA_CERTIFICATE_TYPE (0x80UL) -#define CKA_ISSUER (0x81UL) -#define CKA_SERIAL_NUMBER (0x82UL) -#define CKA_AC_ISSUER (0x83UL) -#define CKA_OWNER (0x84UL) -#define CKA_ATTR_TYPES (0x85UL) -#define CKA_TRUSTED (0x86UL) -#define CKA_CERTIFICATE_CATEGORY (0x87UL) -#define CKA_JAVA_MIDP_SECURITY_DOMAIN (0x88UL) -#define CKA_URL (0x89UL) -#define CKA_HASH_OF_SUBJECT_PUBLIC_KEY (0x8aUL) -#define CKA_HASH_OF_ISSUER_PUBLIC_KEY (0x8bUL) -#define CKA_NAME_HASH_ALGORITHM (0x8cUL) -#define CKA_CHECK_VALUE (0x90UL) -#define CKA_KEY_TYPE (0x100UL) -#define CKA_SUBJECT (0x101UL) -#define CKA_ID (0x102UL) -#define CKA_SENSITIVE (0x103UL) -#define CKA_ENCRYPT (0x104UL) -#define CKA_DECRYPT (0x105UL) -#define CKA_WRAP (0x106UL) -#define CKA_UNWRAP (0x107UL) -#define CKA_SIGN (0x108UL) -#define CKA_SIGN_RECOVER (0x109UL) -#define CKA_VERIFY (0x10aUL) -#define CKA_VERIFY_RECOVER (0x10bUL) -#define CKA_DERIVE (0x10cUL) -#define CKA_START_DATE (0x110UL) -#define CKA_END_DATE (0x111UL) -#define CKA_MODULUS (0x120UL) -#define CKA_MODULUS_BITS (0x121UL) -#define CKA_PUBLIC_EXPONENT (0x122UL) -#define CKA_PRIVATE_EXPONENT (0x123UL) -#define CKA_PRIME_1 (0x124UL) -#define CKA_PRIME_2 (0x125UL) -#define CKA_EXPONENT_1 (0x126UL) -#define CKA_EXPONENT_2 (0x127UL) -#define CKA_COEFFICIENT (0x128UL) -#define CKA_PRIME (0x130UL) -#define CKA_SUBPRIME (0x131UL) -#define CKA_BASE (0x132UL) -#define CKA_PRIME_BITS (0x133UL) -#define CKA_SUB_PRIME_BITS (0x134UL) -#define CKA_VALUE_BITS (0x160UL) -#define CKA_VALUE_LEN (0x161UL) -#define CKA_EXTRACTABLE (0x162UL) -#define CKA_LOCAL (0x163UL) -#define CKA_NEVER_EXTRACTABLE (0x164UL) -#define CKA_ALWAYS_SENSITIVE (0x165UL) -#define CKA_KEY_GEN_MECHANISM (0x166UL) -#define CKA_MODIFIABLE (0x170UL) -#define CKA_ECDSA_PARAMS (0x180UL) -#define CKA_EC_PARAMS (0x180UL) -#define CKA_EC_POINT (0x181UL) -#define CKA_SECONDARY_AUTH (0x200UL) -#define CKA_AUTH_PIN_FLAGS (0x201UL) -#define CKA_ALWAYS_AUTHENTICATE (0x202UL) -#define CKA_WRAP_WITH_TRUSTED (0x210UL) -#define CKA_GOSTR3410_PARAMS (0x250UL) -#define CKA_GOSTR3411_PARAMS (0x251UL) -#define CKA_GOST28147_PARAMS (0x252UL) -#define CKA_HW_FEATURE_TYPE (0x300UL) -#define CKA_RESET_ON_INIT (0x301UL) -#define CKA_HAS_RESET (0x302UL) -#define CKA_PIXEL_X (0x400UL) -#define CKA_PIXEL_Y (0x401UL) -#define CKA_RESOLUTION (0x402UL) -#define CKA_CHAR_ROWS (0x403UL) -#define CKA_CHAR_COLUMNS (0x404UL) -#define CKA_COLOR (0x405UL) -#define CKA_BITS_PER_PIXEL (0x406UL) -#define CKA_CHAR_SETS (0x480UL) -#define CKA_ENCODING_METHODS (0x481UL) -#define CKA_MIME_TYPES (0x482UL) -#define CKA_MECHANISM_TYPE (0x500UL) -#define CKA_REQUIRED_CMS_ATTRIBUTES (0x501UL) -#define CKA_DEFAULT_CMS_ATTRIBUTES (0x502UL) -#define CKA_SUPPORTED_CMS_ATTRIBUTES (0x503UL) -#define CKA_WRAP_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x211UL) -#define CKA_UNWRAP_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x212UL) -#define CKA_OTP_FORMAT (0x220UL) -#define CKA_OTP_LENGTH (0x221UL) -#define CKA_OTP_TIME_INTERVAL (0x222UL) -#define CKA_OTP_USER_FRIENDLY_MODE (0x223UL) -#define CKA_OTP_CHALLENGE_REQUIREMENT (0x224UL) -#define CKA_OTP_TIME_REQUIREMENT (0x225UL) -#define CKA_OTP_COUNTER_REQUIREMENT (0x226UL) -#define CKA_OTP_PIN_REQUIREMENT (0x227UL) -#define CKA_OTP_USER_IDENTIFIER (0x22AUL) -#define CKA_OTP_SERVICE_IDENTIFIER (0x22BUL) -#define CKA_OTP_SERVICE_LOGO (0x22CUL) -#define CKA_OTP_SERVICE_LOGO_TYPE (0x22DUL) -#define CKA_OTP_COUNTER (0x22EUL) -#define CKA_OTP_TIME (0x22FUL) -#define CKA_PARAMETER_SET (0x61DUL) -#define CKA_ALLOWED_MECHANISMS (CKF_ARRAY_ATTRIBUTE | 0x600UL) -#define CKA_VENDOR_DEFINED (1UL << 31) +typedef struct ck_otp_param { + ck_otp_param_type_t type; + void *value; + unsigned long value_len; +} ck_otp_param; +typedef struct ck_otp_params { + struct ck_otp_param *params; + unsigned long count; +} ck_otp_params; -struct ck_attribute +typedef struct ck_otp_signature_info { - ck_attribute_type_t type; + struct ck_otp_param *params; + unsigned long count; +} ck_otp_signature_info; + +struct ck_pbe_params { + unsigned char *init_vector; + unsigned char *password_ptr; + unsigned long password_len; + unsigned char *salt_ptr; + unsigned long salt_len; + unsigned long iteration; +}; + +struct ck_pkcs5_pbkd2_params { + ck_pkcs5_pbkdf2_salt_source_type_t salt_source; + void *salt_source_data; + unsigned long salt_source_data_len; + unsigned long iterations; + ck_pkcs5_pbkd2_pseudo_random_function_type_t prf; + void *prf_data; + unsigned long prf_data_len; + unsigned char *password_ptr; + unsigned long *password_len; +}; + +struct ck_pkcs5_pbkd2_params2 { + ck_pkcs5_pbkdf2_salt_source_type_t salt_source; + void *salt_source_data; + unsigned long salt_source_data_len; + unsigned long iterations; + ck_pkcs5_pbkd2_pseudo_random_function_type_t prf; + void *prf_data; + unsigned long prf_data_len; + unsigned char *password_ptr; + unsigned long password_len; +}; + +struct ck_prf_data_param { + ck_prf_data_type_t type; void *value; unsigned long value_len; }; +struct ck_rc2_cbc_params { + unsigned long effective_bits; + unsigned char iv[8]; +}; -struct ck_date -{ - unsigned char year[4]; - unsigned char month[2]; - unsigned char day[2]; +struct ck_rc2_mac_general_params { + unsigned long effective_bits; + unsigned long mac_length; }; +struct ck_rc5_cbc_params { + unsigned long word_size; + unsigned long rounds; + unsigned char *iv_ptr; + unsigned long iv_len; +}; -typedef unsigned long ck_mechanism_type_t; +struct ck_rc5_mac_general_params { + unsigned long word_size; + unsigned long rounds; + unsigned long mac_length; +}; -#define CKM_RSA_PKCS_KEY_PAIR_GEN (0UL) -#define CKM_RSA_PKCS (1UL) -#define CKM_RSA_9796 (2UL) -#define CKM_RSA_X_509 (3UL) -#define CKM_MD2_RSA_PKCS (4UL) -#define CKM_MD5_RSA_PKCS (5UL) -#define CKM_SHA1_RSA_PKCS (6UL) -#define CKM_RIPEMD128_RSA_PKCS (7UL) -#define CKM_RIPEMD160_RSA_PKCS (8UL) -#define CKM_RSA_PKCS_OAEP (9UL) -#define CKM_RSA_X9_31_KEY_PAIR_GEN (0xaUL) -#define CKM_RSA_X9_31 (0xbUL) -#define CKM_SHA1_RSA_X9_31 (0xcUL) -#define CKM_RSA_PKCS_PSS (0xdUL) -#define CKM_SHA1_RSA_PKCS_PSS (0xeUL) -#define CKM_DSA_KEY_PAIR_GEN (0x10UL) -#define CKM_DSA (0x11UL) -#define CKM_DSA_SHA1 (0x12UL) -#define CKM_DSA_SHA224 (0x13UL) -#define CKM_DSA_SHA256 (0x14UL) -#define CKM_DSA_SHA384 (0x15UL) -#define CKM_DSA_SHA512 (0x16UL) -#define CKM_ML_DSA_KEY_PAIR_GEN (0x1CUL) -#define CKM_ML_DSA (0x1DUL) -#define CKM_DH_PKCS_KEY_PAIR_GEN (0x20UL) -#define CKM_DH_PKCS_DERIVE (0x21UL) -/* PKCS#11 v3.2: SLH-DSA */ -#define CKM_SLH_DSA_KEY_PAIR_GEN (0x2DUL) -#define CKM_SLH_DSA (0x2EUL) -#define CKM_X9_42_DH_KEY_PAIR_GEN (0x30UL) -#define CKM_X9_42_DH_DERIVE (0x31UL) -#define CKM_X9_42_DH_HYBRID_DERIVE (0x32UL) -#define CKM_X9_42_MQV_DERIVE (0x33UL) -#define CKM_SHA256_RSA_PKCS (0x40UL) -#define CKM_SHA384_RSA_PKCS (0x41UL) -#define CKM_SHA512_RSA_PKCS (0x42UL) -#define CKM_SHA256_RSA_PKCS_PSS (0x43UL) -#define CKM_SHA384_RSA_PKCS_PSS (0x44UL) -#define CKM_SHA512_RSA_PKCS_PSS (0x45UL) -#define CKM_SHA224_RSA_PKCS (0x46UL) -#define CKM_SHA224_RSA_PKCS_PSS (0x47UL) -#define CKM_RC2_KEY_GEN (0x100UL) -#define CKM_RC2_ECB (0x101UL) -#define CKM_RC2_CBC (0x102UL) -#define CKM_RC2_MAC (0x103UL) -#define CKM_RC2_MAC_GENERAL (0x104UL) -#define CKM_RC2_CBC_PAD (0x105UL) -#define CKM_RC4_KEY_GEN (0x110UL) -#define CKM_RC4 (0x111UL) -#define CKM_DES_KEY_GEN (0x120UL) -#define CKM_DES_ECB (0x121UL) -#define CKM_DES_CBC (0x122UL) -#define CKM_DES_MAC (0x123UL) -#define CKM_DES_MAC_GENERAL (0x124UL) -#define CKM_DES_CBC_PAD (0x125UL) -#define CKM_DES2_KEY_GEN (0x130UL) -#define CKM_DES3_KEY_GEN (0x131UL) -#define CKM_DES3_ECB (0x132UL) -#define CKM_DES3_CBC (0x133UL) -#define CKM_DES3_MAC (0x134UL) -#define CKM_DES3_MAC_GENERAL (0x135UL) -#define CKM_DES3_CBC_PAD (0x136UL) -#define CKM_DES3_CMAC (0x138UL) -#define CKM_CDMF_KEY_GEN (0x140UL) -#define CKM_CDMF_ECB (0x141UL) -#define CKM_CDMF_CBC (0x142UL) -#define CKM_CDMF_MAC (0x143UL) -#define CKM_CDMF_MAC_GENERAL (0x144UL) -#define CKM_CDMF_CBC_PAD (0x145UL) -#define CKM_MD2 (0x200UL) -#define CKM_MD2_HMAC (0x201UL) -#define CKM_MD2_HMAC_GENERAL (0x202UL) -#define CKM_MD5 (0x210UL) -#define CKM_MD5_HMAC (0x211UL) -#define CKM_MD5_HMAC_GENERAL (0x212UL) -#define CKM_SHA_1 (0x220UL) -#define CKM_SHA_1_HMAC (0x221UL) -#define CKM_SHA_1_HMAC_GENERAL (0x222UL) -#define CKM_RIPEMD128 (0x230UL) -#define CKM_RIPEMD128_HMAC (0x231UL) -#define CKM_RIPEMD128_HMAC_GENERAL (0x232UL) -#define CKM_RIPEMD160 (0x240UL) -#define CKM_RIPEMD160_HMAC (0x241UL) -#define CKM_RIPEMD160_HMAC_GENERAL (0x242UL) -#define CKM_SHA256 (0x250UL) -#define CKM_SHA256_HMAC (0x251UL) -#define CKM_SHA256_HMAC_GENERAL (0x252UL) -#define CKM_SHA224 (0x255UL) -#define CKM_SHA224_HMAC (0x256UL) -#define CKM_SHA224_HMAC_GENERAL (0x257UL) -#define CKM_SHA384 (0x260UL) -#define CKM_SHA384_HMAC (0x261UL) -#define CKM_SHA384_HMAC_GENERAL (0x262UL) -#define CKM_SHA512 (0x270UL) -#define CKM_SHA512_HMAC (0x271UL) -#define CKM_SHA512_HMAC_GENERAL (0x272UL) -#define CKM_SHA3_256 (0x2B0UL) -#define CKM_SHA3_256_HMAC (0x2B1UL) -#define CKM_SHA3_256_HMAC_GENERAL (0x2B2UL) -#define CKM_SHA3_256_KEY_GEN (0x2B3UL) -#define CKM_SHA3_224 (0x2B5UL) -#define CKM_SHA3_224_HMAC (0x2B6UL) -#define CKM_SHA3_224_HMAC_GENERAL (0x2B7UL) -#define CKM_SHA3_224_KEY_GEN (0x2B8UL) -#define CKM_SHA3_384 (0x2C0UL) -#define CKM_SHA3_384_HMAC (0x2C1UL) -#define CKM_SHA3_384_HMAC_GENERAL (0x2C2UL) -#define CKM_SHA3_384_KEY_GEN (0x2C3UL) -#define CKM_SHA3_512 (0x2D0UL) -#define CKM_SHA3_512_HMAC (0x2D1UL) -#define CKM_SHA3_512_HMAC_GENERAL (0x2D2UL) -#define CKM_SHA3_512_KEY_GEN (0x2D3UL) -#define CKM_CAST_KEY_GEN (0x300UL) -#define CKM_CAST_ECB (0x301UL) -#define CKM_CAST_CBC (0x302UL) -#define CKM_CAST_MAC (0x303UL) -#define CKM_CAST_MAC_GENERAL (0x304UL) -#define CKM_CAST_CBC_PAD (0x305UL) -#define CKM_CAST3_KEY_GEN (0x310UL) -#define CKM_CAST3_ECB (0x311UL) -#define CKM_CAST3_CBC (0x312UL) -#define CKM_CAST3_MAC (0x313UL) -#define CKM_CAST3_MAC_GENERAL (0x314UL) -#define CKM_CAST3_CBC_PAD (0x315UL) -#define CKM_CAST5_KEY_GEN (0x320UL) -#define CKM_CAST128_KEY_GEN (0x320UL) -#define CKM_CAST5_ECB (0x321UL) -#define CKM_CAST128_ECB (0x321UL) -#define CKM_CAST5_CBC (0x322UL) -#define CKM_CAST128_CBC (0x322UL) -#define CKM_CAST5_MAC (0x323UL) -#define CKM_CAST128_MAC (0x323UL) -#define CKM_CAST5_MAC_GENERAL (0x324UL) -#define CKM_CAST128_MAC_GENERAL (0x324UL) -#define CKM_CAST5_CBC_PAD (0x325UL) -#define CKM_CAST128_CBC_PAD (0x325UL) -#define CKM_RC5_KEY_GEN (0x330UL) -#define CKM_RC5_ECB (0x331UL) -#define CKM_RC5_CBC (0x332UL) -#define CKM_RC5_MAC (0x333UL) -#define CKM_RC5_MAC_GENERAL (0x334UL) -#define CKM_RC5_CBC_PAD (0x335UL) -#define CKM_IDEA_KEY_GEN (0x340UL) -#define CKM_IDEA_ECB (0x341UL) -#define CKM_IDEA_CBC (0x342UL) -#define CKM_IDEA_MAC (0x343UL) -#define CKM_IDEA_MAC_GENERAL (0x344UL) -#define CKM_IDEA_CBC_PAD (0x345UL) -#define CKM_GENERIC_SECRET_KEY_GEN (0x350UL) -#define CKM_CONCATENATE_BASE_AND_KEY (0x360UL) -#define CKM_CONCATENATE_BASE_AND_DATA (0x362UL) -#define CKM_CONCATENATE_DATA_AND_BASE (0x363UL) -#define CKM_XOR_BASE_AND_DATA (0x364UL) -#define CKM_EXTRACT_KEY_FROM_KEY (0x365UL) -#define CKM_SSL3_PRE_MASTER_KEY_GEN (0x370UL) -#define CKM_SSL3_MASTER_KEY_DERIVE (0x371UL) -#define CKM_SSL3_KEY_AND_MAC_DERIVE (0x372UL) -#define CKM_SSL3_MASTER_KEY_DERIVE_DH (0x373UL) -#define CKM_TLS_PRE_MASTER_KEY_GEN (0x374UL) -#define CKM_TLS_MASTER_KEY_DERIVE (0x375UL) -#define CKM_TLS_KEY_AND_MAC_DERIVE (0x376UL) -#define CKM_TLS_MASTER_KEY_DERIVE_DH (0x377UL) -#define CKM_SSL3_MD5_MAC (0x380UL) -#define CKM_SSL3_SHA1_MAC (0x381UL) -#define CKM_MD5_KEY_DERIVATION (0x390UL) -#define CKM_MD2_KEY_DERIVATION (0x391UL) -#define CKM_SHA1_KEY_DERIVATION (0x392UL) -#define CKM_PBE_MD2_DES_CBC (0x3a0UL) -#define CKM_PBE_MD5_DES_CBC (0x3a1UL) -#define CKM_PBE_MD5_CAST_CBC (0x3a2UL) -#define CKM_PBE_MD5_CAST3_CBC (0x3a3UL) -#define CKM_PBE_MD5_CAST5_CBC (0x3a4UL) -#define CKM_PBE_MD5_CAST128_CBC (0x3a4UL) -#define CKM_PBE_SHA1_CAST5_CBC (0x3a5UL) -#define CKM_PBE_SHA1_CAST128_CBC (0x3a5UL) -#define CKM_PBE_SHA1_RC4_128 (0x3a6UL) -#define CKM_PBE_SHA1_RC4_40 (0x3a7UL) -#define CKM_PBE_SHA1_DES3_EDE_CBC (0x3a8UL) -#define CKM_PBE_SHA1_DES2_EDE_CBC (0x3a9UL) -#define CKM_PBE_SHA1_RC2_128_CBC (0x3aaUL) -#define CKM_PBE_SHA1_RC2_40_CBC (0x3abUL) -#define CKM_PKCS5_PBKD2 (0x3b0UL) -#define CKM_PBA_SHA1_WITH_SHA1_HMAC (0x3c0UL) -#define CKM_KEY_WRAP_LYNKS (0x400UL) -#define CKM_KEY_WRAP_SET_OAEP (0x401UL) -#define CKM_SKIPJACK_KEY_GEN (0x1000UL) -#define CKM_SKIPJACK_ECB64 (0x1001UL) -#define CKM_SKIPJACK_CBC64 (0x1002UL) -#define CKM_SKIPJACK_OFB64 (0x1003UL) -#define CKM_SKIPJACK_CFB64 (0x1004UL) -#define CKM_SKIPJACK_CFB32 (0x1005UL) -#define CKM_SKIPJACK_CFB16 (0x1006UL) -#define CKM_SKIPJACK_CFB8 (0x1007UL) -#define CKM_SKIPJACK_WRAP (0x1008UL) -#define CKM_SKIPJACK_PRIVATE_WRAP (0x1009UL) -#define CKM_SKIPJACK_RELAYX (0x100aUL) -#define CKM_KEA_KEY_PAIR_GEN (0x1010UL) -#define CKM_KEA_KEY_DERIVE (0x1011UL) -#define CKM_FORTEZZA_TIMESTAMP (0x1020UL) -#define CKM_BATON_KEY_GEN (0x1030UL) -#define CKM_BATON_ECB128 (0x1031UL) -#define CKM_BATON_ECB96 (0x1032UL) -#define CKM_BATON_CBC128 (0x1033UL) -#define CKM_BATON_COUNTER (0x1034UL) -#define CKM_BATON_SHUFFLE (0x1035UL) -#define CKM_BATON_WRAP (0x1036UL) -#define CKM_ECDSA_KEY_PAIR_GEN (0x1040UL) -#define CKM_EC_KEY_PAIR_GEN (0x1040UL) -#define CKM_ECDSA (0x1041UL) -#define CKM_ECDSA_SHA1 (0x1042UL) -#define CKM_ECDSA_SHA224 (0x1043UL) -#define CKM_ECDSA_SHA256 (0x1044UL) -#define CKM_ECDSA_SHA384 (0x1045UL) -#define CKM_ECDSA_SHA512 (0x1046UL) -#define CKM_ECDH1_DERIVE (0x1050UL) -#define CKM_ECDH1_COFACTOR_DERIVE (0x1051UL) -#define CKM_ECMQV_DERIVE (0x1052UL) -#define CKM_EC_EDWARDS_KEY_PAIR_GEN (0x1055UL) -#define CKM_EC_MONTGOMERY_KEY_PAIR_GEN (0x1056UL) -#define CKM_EDDSA (0x1057UL) -#define CKM_JUNIPER_KEY_GEN (0x1060UL) -#define CKM_JUNIPER_ECB128 (0x1061UL) -#define CKM_JUNIPER_CBC128 (0x1062UL) -#define CKM_JUNIPER_COUNTER (0x1063UL) -#define CKM_JUNIPER_SHUFFLE (0x1064UL) -#define CKM_JUNIPER_WRAP (0x1065UL) -#define CKM_FASTHASH (0x1070UL) -#define CKM_AES_KEY_GEN (0x1080UL) -#define CKM_AES_ECB (0x1081UL) -#define CKM_AES_CBC (0x1082UL) -#define CKM_AES_MAC (0x1083UL) -#define CKM_AES_MAC_GENERAL (0x1084UL) -#define CKM_AES_CBC_PAD (0x1085UL) -#define CKM_AES_CTR (0x1086UL) -#define CKM_AES_GCM (0x1087UL) -#define CKM_AES_CCM (0x1088UL) -#define CKM_AES_CTS (0x1089UL) -#define CKM_AES_CMAC (0x108AUL) -#define CKM_BLOWFISH_KEY_GEN (0x1090UL) -#define CKM_BLOWFISH_CBC (0x1091UL) -#define CKM_TWOFISH_KEY_GEN (0x1092UL) -#define CKM_TWOFISH_CBC (0x1093UL) -#define CKM_DES_ECB_ENCRYPT_DATA (0x1100UL) -#define CKM_DES_CBC_ENCRYPT_DATA (0x1101UL) -#define CKM_DES3_ECB_ENCRYPT_DATA (0x1102UL) -#define CKM_DES3_CBC_ENCRYPT_DATA (0x1103UL) -#define CKM_AES_ECB_ENCRYPT_DATA (0x1104UL) -#define CKM_AES_CBC_ENCRYPT_DATA (0x1105UL) -#define CKM_GOSTR3410_KEY_PAIR_GEN (0x1200UL) -#define CKM_GOSTR3410 (0x1201UL) -#define CKM_GOSTR3410_WITH_GOSTR3411 (0x1202UL) -#define CKM_GOSTR3410_KEY_WRAP (0x1203UL) -#define CKM_GOSTR3410_DERIVE (0x1204UL) -#define CKM_GOSTR3410_512_KEY_PAIR_GEN (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x005) -#define CKM_GOSTR3410_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x006) -#define CKM_GOSTR3410_12_DERIVE (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x007) -#define CKM_GOSTR3410_WITH_GOSTR3411_12_256 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x008) -#define CKM_GOSTR3410_WITH_GOSTR3411_12_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x009) -#define CKM_GOSTR3411 (0x1210UL) -#define CKM_GOSTR3411_HMAC (0x1211UL) -#define CKM_GOSTR3411_12_256 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x012) -#define CKM_GOSTR3411_12_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x013) -#define CKM_GOSTR3411_12_256_HMAC (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x014) -#define CKM_GOSTR3411_12_512_HMAC (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x015) -#define CKM_GOST28147_KEY_GEN (0x1220UL) -#define CKM_GOST28147_ECB (0x1221UL) -#define CKM_GOST28147 (0x1222UL) -#define CKM_GOST28147_MAC (0x1223UL) -#define CKM_GOST28147_KEY_WRAP (0x1224UL) - -#define CKM_DSA_PARAMETER_GEN (0x2000UL) -#define CKM_DH_PKCS_PARAMETER_GEN (0x2001UL) -#define CKM_X9_42_DH_PARAMETER_GEN (0x2002UL) -#define CKM_AES_KEY_WRAP (0x2109UL) -/* - * Thales Luna customer-defined Falcon identifiers. - * Falcon does not currently have standard PKCS#11 CKM_ values. - * Luna defines the key type and mechanisms in its customer-defined range. - */ -#define CKM_FALCON_KEY_PAIR_GEN (0xC0000070UL) -#define CKM_FALCON (0xC0000071UL) -#define CKM_PQC_FALCON (CKM_VENDOR_DEFINED + 0x10025UL) -#define CKM_VENDOR_DEFINED (1UL << 31) - -/* CKP (ML-DSA) */ -#define CKP_ML_DSA_44 (0x0001UL) -#define CKP_ML_DSA_65 (0x0002UL) -#define CKP_ML_DSA_87 (0x0003UL) - -/* CKP (SLH-DSA) */ -#define CKP_SLH_DSA_SHA2_128S (0x0001UL) -#define CKP_SLH_DSA_SHAKE_128S (0x0002UL) -#define CKP_SLH_DSA_SHA2_128F (0x0003UL) -#define CKP_SLH_DSA_SHAKE_128F (0x0004UL) -#define CKP_SLH_DSA_SHA2_192S (0x0005UL) -#define CKP_SLH_DSA_SHAKE_192S (0x0006UL) -#define CKP_SLH_DSA_SHA2_192F (0x0007UL) -#define CKP_SLH_DSA_SHAKE_192F (0x0008UL) -#define CKP_SLH_DSA_SHA2_256S (0x0009UL) -#define CKP_SLH_DSA_SHAKE_256S (0x000AUL) -#define CKP_SLH_DSA_SHA2_256F (0x000BUL) -#define CKP_SLH_DSA_SHAKE_256F (0x000CUL) +struct ck_rc5_params { + unsigned long word_size; + unsigned long rounds; +}; -/* CKP (FALCON) */ -#define CKP_FALCON_512 (0x0001UL) -#define CKP_FALCON_1024 (0x0002UL) +struct ck_rsa_pkcs_oaep_params { + ck_mechanism_type_t hash_alg; + ck_rsa_pkcs_mgf_type_t mgf; + ck_rsa_pkcs_oaep_source_type_t source; + void *source_data; + unsigned long source_data_len; +}; -struct ck_mechanism -{ - ck_mechanism_type_t mechanism; - void *parameter; - unsigned long parameter_len; +struct ck_rsa_aes_key_wrap_params { + unsigned long aes_key_bits; + struct ck_rsa_pkcs_oaep_params *oaep_params; }; +struct ck_rsa_pkcs_pss_params { + ck_mechanism_type_t hash_alg; + ck_rsa_pkcs_mgf_type_t mgf; + unsigned long s_len; +}; -struct ck_mechanism_info -{ - unsigned long min_key_size; - unsigned long max_key_size; - ck_flags_t flags; +struct ck_salsa20_chacha20_poly1305_msg_params { + unsigned char *nonce_ptr; + unsigned long nonce_bits; + unsigned char *tag_ptr; }; -#define CKF_HW (1UL << 0) -#define CKF_ENCRYPT (1UL << 8) -#define CKF_DECRYPT (1UL << 9) -#define CKF_DIGEST (1UL << 10) -#define CKF_SIGN (1UL << 11) -#define CKF_SIGN_RECOVER (1UL << 12) -#define CKF_VERIFY (1UL << 13) -#define CKF_VERIFY_RECOVER (1UL << 14) -#define CKF_GENERATE (1UL << 15) -#define CKF_GENERATE_KEY_PAIR (1UL << 16) -#define CKF_WRAP (1UL << 17) -#define CKF_UNWRAP (1UL << 18) -#define CKF_DERIVE (1UL << 19) -#define CKF_EXTENSION (1UL << 31) - -#define CKF_EC_F_P (1UL << 20) -#define CKF_EC_F_2M (1UL << 21) -#define CKF_EC_ECPARAMETERS (1UL << 22) -#define CKF_EC_NAMEDCURVE (1UL << 23) -#define CKF_EC_UNCOMPRESS (1UL << 24) -#define CKF_EC_COMPRESS (1UL << 25) +struct ck_salsa20_chacha20_poly1305_params { + unsigned char *nonce_ptr; + unsigned long nonce_bits; + unsigned char *aad_ptr; + unsigned long aad_len; +}; -/* Flags for C_WaitForSlotEvent. */ -#define CKF_DONT_BLOCK (1UL) - -/* Flags for Key derivation */ -#define CKD_NULL (0x1UL) -#define CKD_SHA1_KDF (0x2UL) -#define CKD_SHA224_KDF (0x5UL) -#define CKD_SHA256_KDF (0x6UL) -#define CKD_SHA384_KDF (0x7UL) -#define CKD_SHA512_KDF (0x8UL) - -typedef struct CK_ECDH1_DERIVE_PARAMS { - unsigned long kdf; - unsigned long ulSharedDataLen; - unsigned char *pSharedData; - unsigned long ulPublicDataLen; - unsigned char *pPublicData; -} CK_ECDH1_DERIVE_PARAMS; - -typedef struct CK_ECMQV_DERIVE_PARAMS { - unsigned long kdf; - unsigned long ulSharedDataLen; - unsigned char *pSharedData; - unsigned long ulPublicDataLen; - unsigned char *pPublicData; - unsigned long ulPrivateDataLen; - CK_OBJECT_HANDLE hPrivateData; - unsigned long ulPublicDataLen2; - unsigned char *pPublicData2; - CK_OBJECT_HANDLE publicKey; -} CK_ECMQV_DERIVE_PARAMS; +struct ck_salsa20_params { + unsigned char *block_counter; + unsigned char *nonce_ptr; + unsigned long nonce_bits; +}; -typedef unsigned long ck_rsa_pkcs_mgf_type_t; -typedef unsigned long CK_RSA_PKCS_OAEP_SOURCE_TYPE; - -typedef struct CK_RSA_PKCS_OAEP_PARAMS { - CK_MECHANISM_TYPE hashAlg; - CK_RSA_PKCS_MGF_TYPE mgf; - CK_RSA_PKCS_OAEP_SOURCE_TYPE source; - void *pSourceData; - unsigned long ulSourceDataLen; -} CK_RSA_PKCS_OAEP_PARAMS; - -typedef struct CK_RSA_PKCS_PSS_PARAMS { - ck_mechanism_type_t hashAlg; - CK_RSA_PKCS_MGF_TYPE mgf; - unsigned long sLen; -} CK_RSA_PKCS_PSS_PARAMS; - -/* EDDSA */ -typedef struct CK_EDDSA_PARAMS { - unsigned char phFlag; - unsigned long ulContextDataLen; - unsigned char *pContextData; -} CK_EDDSA_PARAMS; - -typedef CK_EDDSA_PARAMS *CK_EDDSA_PARAMS_PTR; - -#define CKG_MGF1_SHA1 (0x00000001UL) -#define CKG_MGF1_SHA224 (0x00000005UL) -#define CKG_MGF1_SHA256 (0x00000002UL) -#define CKG_MGF1_SHA384 (0x00000003UL) -#define CKG_MGF1_SHA512 (0x00000004UL) -#define CKG_MGF1_SHA3_224 (0x00000006UL) -#define CKG_MGF1_SHA3_256 (0x00000007UL) -#define CKG_MGF1_SHA3_384 (0x00000008UL) -#define CKG_MGF1_SHA3_512 (0x00000009UL) - -#define CKZ_DATA_SPECIFIED (0x00000001UL) - -typedef struct CK_GCM_PARAMS { - void *pIv; - unsigned long ulIvLen; - unsigned long ulIvBits; - void *pAAD; - unsigned long ulAADLen; - unsigned long ulTagBits; -} CK_GCM_PARAMS; +struct ck_seed_cbc_encrypt_data_params { + unsigned char iv[16]; + unsigned char *data_params; + unsigned long length; +}; -typedef unsigned long ck_rv_t; +struct ck_sign_additional_context { + ck_hedge_type_t hedge_variant; + unsigned char *context_ptr; + unsigned long context_len; +}; + +struct ck_skipjack_private_wrap_params { + unsigned long password_len; + unsigned char *password_ptr; + unsigned long public_data_len; + unsigned char *public_data; + unsigned long p_and_g_len; + unsigned long q_len; + unsigned long random_len; + unsigned char *random_a_ptr; + unsigned char *prime_p; + unsigned char *base_g; + unsigned char *subprime_q; +}; + +struct ck_skipjack_relayx_params { + unsigned long old_wrapped_x_len; + unsigned char *old_wrapped_x; + unsigned long old_password_len; + unsigned char *old_password; + unsigned long old_public_data_len; + unsigned char *old_public_data; + unsigned long old_random_len; + unsigned char *old_random_a; + unsigned long new_password_len; + unsigned char *new_password; + unsigned long new_public_data_len; + unsigned char *new_public_data; + unsigned long new_random_len; + unsigned char *new_random_a; +}; + +struct ck_sp800_108_counter_format { + unsigned char little_endian; + unsigned long width_in_bits; +}; + +struct ck_sp800_108_dkm_length_format { + ck_sp800_108_dkm_length_method_t dkm_length_method; + unsigned char little_endian; + unsigned long width_in_bits; +}; + +struct ck_sp800_108_feedback_kdf_params { + ck_sp800_108_prf_type_t prf_type; + unsigned long number_of_data_params; + struct ck_prf_data_param *data_params_ptr; + unsigned long iv_len; + unsigned char *iv_ptr; + unsigned long additional_derived_keys_len; + struct ck_derived_key *additional_derived_keys; +}; + +struct ck_tls12_extended_master_key_derive_params { + ck_mechanism_type_t prf_hash_mechanism; + unsigned char *session_hash_ptr; + unsigned long session_hash_len; + struct ck_version *version_ptr; +}; + +struct ck_sp800_108_kdf_params { + ck_sp800_108_prf_type_t prf_type; + unsigned long number_of_data_params; + struct ck_prf_data_param *data_params_ptr; + unsigned long additional_derived_keys_len; + struct ck_derived_key *additional_derived_keys; +}; + +struct ck_x2ratchet_initialize_params { + unsigned char *sk; + ck_object_handle_t peer_public_prekey; + ck_object_handle_t peer_public_identity; + ck_object_handle_t own_public_identity; + unsigned char encrypted_header; + unsigned long curve; + ck_mechanism_type_t aead_mechanism; + ck_x2ratchet_kdf_type_t kdf_mechanism; +}; + +struct ck_x2ratchet_respond_params { + unsigned char *sk; + ck_object_handle_t own_prekey; + ck_object_handle_t initiator_identity; + ck_object_handle_t own_public_identity; + unsigned char encrypted_header; + unsigned long curve; + ck_mechanism_type_t aead_mechanism; + ck_x2ratchet_kdf_type_t kdf_mechanism; +}; + +struct ck_x3dh_initiate_params { + ck_x3dh_kdf_type_t kdf; + ck_object_handle_t peer_identity; + ck_object_handle_t peer_prekey; + unsigned char *prekey_signature; + unsigned char *onetime_key; + ck_object_handle_t own_identity; + ck_object_handle_t own_ephemeral; +}; + +struct ck_x3dh_respond_params { + ck_x3dh_kdf_type_t kdf; + unsigned char *identity_id; + unsigned char *prekey_id; + unsigned char *onetime_id; + ck_object_handle_t initiator_identity; + unsigned char *initiator_ephemeral; +}; + +struct ck_x9_42_dh1_derive_params { + ck_x9_42_dh_kdf_type_t kdf; + unsigned long other_info_len; + unsigned char *other_info; + unsigned long public_data_len; + unsigned char *public_data; +}; + +struct ck_x9_42_dh2_derive_params { + ck_x9_42_dh_kdf_type_t kdf; + unsigned long other_info_len; + unsigned char *other_info; + unsigned long public_data_len; + unsigned char *public_data; + unsigned long private_data_len; + ck_object_handle_t private_data; + unsigned long public_data_len2; + unsigned char *public_data2; +}; + +struct ck_x9_42_mqv_derive_params { + ck_x9_42_dh_kdf_type_t kdf; + unsigned long other_info_len; + unsigned char *other_info; + unsigned long public_data_len; + unsigned char *public_data; + unsigned long private_data_len; + ck_object_handle_t private_data; + unsigned long public_data_len2; + unsigned char *public_data2; + ck_object_handle_t public_key; +}; + +struct ck_xeddsa_params { + ck_xeddsa_hash_type_t hash; +}; + +struct specified_params { + ck_hss_levels_t levels; + ck_lms_type_t lm_type[8]; + ck_lmots_type_t lm_ots_type[8]; +}; + +struct ck_ike_prf_derive_params { + ck_mechanism_type_t prf_mechanism; + unsigned char data_as_key; + unsigned char rekey; + unsigned char *ni_ptr; + unsigned long ni_len; + unsigned char *nr_ptr; + unsigned long nr_len; + ck_object_handle_t new_key; +}; + +struct ck_ike1_extended_derive_params { + ck_mechanism_type_t prf_mechanism; + unsigned char has_key_gxy; + ck_object_handle_t key_gxy; + unsigned char *extra_data; + unsigned long extra_data_len; +}; + +struct ck_ike1_prf_derive_params { + ck_mechanism_type_t prf_mechanism; + unsigned char has_prev_key; + ck_object_handle_t key_gxy; + ck_object_handle_t prev_key; + unsigned char *cky_i_ptr; + unsigned long cky_i_len; + unsigned char *cky_r_ptr; + unsigned long cky_r_len; + unsigned char key_number; +}; + +struct ck_ike2_prf_plus_derive_params { + ck_mechanism_type_t prf_mechanism; + unsigned char has_seed_key; + ck_object_handle_t seed_key; + unsigned char *seed_data; + unsigned long seed_data_len; +}; + +struct ck_ssl3_key_mat_out { + ck_object_handle_t client_mac_secret; + ck_object_handle_t server_mac_secret; + ck_object_handle_t client_key; + ck_object_handle_t server_key; + unsigned char *iv_client; + unsigned char *iv_server; +}; + +struct ck_ssl3_random_data { + unsigned char *client_random_ptr; + unsigned long client_random_len; + unsigned char *server_random_ptr; + unsigned long server_random_len; +}; + +struct ck_ssl3_key_mat_params { + unsigned long mac_size_in_bits; + unsigned long key_size_in_bits; + unsigned long iv_size_in_bits; + unsigned char is_export; + struct ck_ssl3_random_data random_info; + struct ck_ssl3_key_mat_out *returned_key_material; +}; + +struct ck_ssl3_master_key_derive_params { + struct ck_ssl3_random_data random_info; + struct ck_version *version_ptr; +}; + +struct ck_tls_kdf_params { + ck_mechanism_type_t prf_mechanism; + unsigned char *label_ptr; + unsigned long label_length; + struct ck_ssl3_random_data random_info; + unsigned char *context_data; + unsigned long context_data_length; +}; + +struct ck_tls_mac_params { + ck_mechanism_type_t prf_hash_mechanism; + unsigned long mac_length; + unsigned long server_or_client; +}; + +struct ck_tls_prf_params { + unsigned char *seed_ptr; + unsigned long seed_len; + unsigned char *label_ptr; + unsigned long label_len; + unsigned char *output_ptr; + unsigned long *output_len_ptr; +}; + +struct ck_tls12_key_mat_params { + unsigned long mac_size_in_bits; + unsigned long key_size_in_bits; + unsigned long iv_size_in_bits; + unsigned char is_export; + struct ck_ssl3_random_data random_info; + struct ck_ssl3_key_mat_out *returned_key_material; + ck_mechanism_type_t prf_hash_mechanism; +}; + +struct ck_tls12_master_key_derive_params { + struct ck_ssl3_random_data random_info; + struct ck_version *version_ptr; + ck_mechanism_type_t prf_hash_mechanism; +}; + +struct ck_wtls_key_mat_out { + ck_object_handle_t mac_secret; + ck_object_handle_t key; + unsigned char *i_v_ptr; +}; + +struct ck_wtls_random_data { + unsigned char *client_random_ptr; + unsigned long client_random_len; + unsigned char *server_random_ptr; + unsigned long server_random_len; +}; + +struct ck_wtls_key_mat_params { + ck_mechanism_type_t digest_mechanism; + unsigned long mac_size_in_bits; + unsigned long key_size_in_bits; + unsigned long iv_size_in_bits; + unsigned long sequence_number; + unsigned char is_export; + struct ck_wtls_random_data random_info; + struct ck_wtls_key_mat_out *returned_key_material; +}; + +struct ck_wtls_master_key_derive_params { + ck_mechanism_type_t digest_mechanism; + struct ck_wtls_random_data random_info; + unsigned char *version_ptr; +}; + +struct ck_wtls_prf_params { + ck_mechanism_type_t digest_mechanism; + unsigned char *seed_ptr; + unsigned long seed_len; + unsigned char *label_ptr; + unsigned long label_len; + unsigned char *output_ptr; + unsigned long *output_len_ptr; +}; -typedef ck_rv_t (*ck_notify_t) (ck_session_handle_t session, - ck_notification_t event, void *application); /* Forward reference. */ struct ck_function_list; +struct ck_function_list_3_0; +struct ck_function_list_3_2; -#define _CK_DECLARE_FUNCTION(name, args) \ -typedef ck_rv_t (*CK_ ## name) args; \ +#define _CK_DECLARE_FUNCTION(name, args) \ +typedef ck_rv_t (*CK_ ## name) args; \ ck_rv_t CK_SPEC name args _CK_DECLARE_FUNCTION (C_Initialize, (void *init_args)); @@ -1226,188 +2710,347 @@ _CK_DECLARE_FUNCTION (C_GenerateRandom, _CK_DECLARE_FUNCTION (C_GetFunctionStatus, (ck_session_handle_t session)); _CK_DECLARE_FUNCTION (C_CancelFunction, (ck_session_handle_t session)); +_CK_DECLARE_FUNCTION (C_GetInterfaceList, + (struct ck_interface *interfaces_list, + unsigned long *count)); +_CK_DECLARE_FUNCTION (C_GetInterface, + (unsigned char *interface_name, + struct ck_version *version, + struct ck_interface **interface_, + ck_flags_t flags)); -struct ck_function_list -{ - struct ck_version version; - CK_C_Initialize C_Initialize; - CK_C_Finalize C_Finalize; - CK_C_GetInfo C_GetInfo; - CK_C_GetFunctionList C_GetFunctionList; - CK_C_GetSlotList C_GetSlotList; - CK_C_GetSlotInfo C_GetSlotInfo; - CK_C_GetTokenInfo C_GetTokenInfo; - CK_C_GetMechanismList C_GetMechanismList; - CK_C_GetMechanismInfo C_GetMechanismInfo; - CK_C_InitToken C_InitToken; - CK_C_InitPIN C_InitPIN; - CK_C_SetPIN C_SetPIN; - CK_C_OpenSession C_OpenSession; - CK_C_CloseSession C_CloseSession; - CK_C_CloseAllSessions C_CloseAllSessions; - CK_C_GetSessionInfo C_GetSessionInfo; - CK_C_GetOperationState C_GetOperationState; - CK_C_SetOperationState C_SetOperationState; - CK_C_Login C_Login; - CK_C_Logout C_Logout; - CK_C_CreateObject C_CreateObject; - CK_C_CopyObject C_CopyObject; - CK_C_DestroyObject C_DestroyObject; - CK_C_GetObjectSize C_GetObjectSize; - CK_C_GetAttributeValue C_GetAttributeValue; - CK_C_SetAttributeValue C_SetAttributeValue; - CK_C_FindObjectsInit C_FindObjectsInit; - CK_C_FindObjects C_FindObjects; - CK_C_FindObjectsFinal C_FindObjectsFinal; - CK_C_EncryptInit C_EncryptInit; - CK_C_Encrypt C_Encrypt; - CK_C_EncryptUpdate C_EncryptUpdate; - CK_C_EncryptFinal C_EncryptFinal; - CK_C_DecryptInit C_DecryptInit; - CK_C_Decrypt C_Decrypt; - CK_C_DecryptUpdate C_DecryptUpdate; - CK_C_DecryptFinal C_DecryptFinal; - CK_C_DigestInit C_DigestInit; - CK_C_Digest C_Digest; - CK_C_DigestUpdate C_DigestUpdate; - CK_C_DigestKey C_DigestKey; - CK_C_DigestFinal C_DigestFinal; - CK_C_SignInit C_SignInit; - CK_C_Sign C_Sign; - CK_C_SignUpdate C_SignUpdate; - CK_C_SignFinal C_SignFinal; - CK_C_SignRecoverInit C_SignRecoverInit; - CK_C_SignRecover C_SignRecover; - CK_C_VerifyInit C_VerifyInit; - CK_C_Verify C_Verify; - CK_C_VerifyUpdate C_VerifyUpdate; - CK_C_VerifyFinal C_VerifyFinal; - CK_C_VerifyRecoverInit C_VerifyRecoverInit; - CK_C_VerifyRecover C_VerifyRecover; - CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; - CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; - CK_C_SignEncryptUpdate C_SignEncryptUpdate; - CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; - CK_C_GenerateKey C_GenerateKey; - CK_C_GenerateKeyPair C_GenerateKeyPair; - CK_C_WrapKey C_WrapKey; - CK_C_UnwrapKey C_UnwrapKey; - CK_C_DeriveKey C_DeriveKey; - CK_C_SeedRandom C_SeedRandom; - CK_C_GenerateRandom C_GenerateRandom; - CK_C_GetFunctionStatus C_GetFunctionStatus; - CK_C_CancelFunction C_CancelFunction; - CK_C_WaitForSlotEvent C_WaitForSlotEvent; -}; +_CK_DECLARE_FUNCTION (C_LoginUser, + (ck_session_handle_t session, + ck_user_type_t user_type, + unsigned char *pin, + unsigned long pin_len, + unsigned char *username, + unsigned long username_len)); +_CK_DECLARE_FUNCTION (C_SessionCancel, + (ck_session_handle_t session, + ck_flags_t flags)); -typedef ck_rv_t (*ck_createmutex_t) (void **mutex); -typedef ck_rv_t (*ck_destroymutex_t) (void *mutex); -typedef ck_rv_t (*ck_lockmutex_t) (void *mutex); -typedef ck_rv_t (*ck_unlockmutex_t) (void *mutex); +_CK_DECLARE_FUNCTION (C_MessageEncryptInit, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t key)); +_CK_DECLARE_FUNCTION (C_EncryptMessage, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *associated_data, + unsigned long associated_data_len, + unsigned char *plaintext, + unsigned long plaintext_len, + unsigned char *ciphertext, + unsigned long *ciphertext_len)); +_CK_DECLARE_FUNCTION (C_EncryptMessageBegin, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *associated_data, + unsigned long associated_data_len)); +_CK_DECLARE_FUNCTION (C_EncryptMessageNext, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *plaintext_part, + unsigned long plaintext_part_len, + unsigned char *ciphertext_part, + unsigned long *ciphertext_part_len, + ck_flags_t flags)); +_CK_DECLARE_FUNCTION (C_MessageEncryptFinal, + (ck_session_handle_t session)); +_CK_DECLARE_FUNCTION (C_MessageDecryptInit, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t key)); +_CK_DECLARE_FUNCTION (C_DecryptMessage, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *associated_data, + unsigned long associated_data_len, + unsigned char *ciphertext, + unsigned long ciphertext_len, + unsigned char *plaintext, + unsigned long *plaintext_len)); +_CK_DECLARE_FUNCTION (C_DecryptMessageBegin, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *associated_data, + unsigned long associated_data_len)); +_CK_DECLARE_FUNCTION (C_DecryptMessageNext, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *ciphertext_part, + unsigned long ciphertext_part_len, + unsigned char *plaintext_part, + unsigned long *plaintext_part_len, + ck_flags_t flags)); +_CK_DECLARE_FUNCTION (C_MessageDecryptFinal, + (ck_session_handle_t session)); -struct ck_c_initialize_args +_CK_DECLARE_FUNCTION (C_MessageSignInit, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t key)); +_CK_DECLARE_FUNCTION (C_SignMessage, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *data, + unsigned long data_len, + unsigned char *signature, + unsigned long *signature_len)); +_CK_DECLARE_FUNCTION (C_SignMessageBegin, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len)); +_CK_DECLARE_FUNCTION (C_SignMessageNext, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *data, + unsigned long data_len, + unsigned char *signature, + unsigned long *signature_len)); +_CK_DECLARE_FUNCTION (C_MessageSignFinal, + (ck_session_handle_t session)); + +_CK_DECLARE_FUNCTION (C_MessageVerifyInit, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t key)); +_CK_DECLARE_FUNCTION (C_VerifyMessage, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *data, + unsigned long data_len, + unsigned char *signature, + unsigned long signature_len)); +_CK_DECLARE_FUNCTION (C_VerifyMessageBegin, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len)); +_CK_DECLARE_FUNCTION (C_VerifyMessageNext, + (ck_session_handle_t session, + void *parameter, + unsigned long parameter_len, + unsigned char *data, + unsigned long data_len, + unsigned char *signature, + unsigned long signature_len)); +_CK_DECLARE_FUNCTION (C_MessageVerifyFinal, + (ck_session_handle_t session)); + +_CK_DECLARE_FUNCTION (C_EncapsulateKey, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t public_key, + struct ck_attribute *templ, + unsigned long attribute_count, + unsigned char *ciphertext, + unsigned long *ciphertext_len, + ck_object_handle_t *key_ptr)); +_CK_DECLARE_FUNCTION (C_DecapsulateKey, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t private_key, + struct ck_attribute *templ, + unsigned long attribute_count, + unsigned char *ciphertext, + unsigned long ciphertext_len, + ck_object_handle_t *key_ptr)); +_CK_DECLARE_FUNCTION (C_VerifySignatureInit, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t key, + unsigned char *signature, + unsigned long signature_len)); +_CK_DECLARE_FUNCTION (C_VerifySignature, + (ck_session_handle_t session, + unsigned char *data, + unsigned long data_len)); +_CK_DECLARE_FUNCTION (C_VerifySignatureUpdate, + (ck_session_handle_t session, + unsigned char *part, + unsigned long part_len)); +_CK_DECLARE_FUNCTION (C_VerifySignatureFinal, + (ck_session_handle_t session)); +_CK_DECLARE_FUNCTION (C_GetSessionValidationFlags, + (ck_session_handle_t session, + ck_session_validation_flags_type_t type, + ck_flags_t *flags_ptr)); +_CK_DECLARE_FUNCTION (C_AsyncComplete, + (ck_session_handle_t session, + unsigned char *function_name, + struct ck_async_data *result)); +_CK_DECLARE_FUNCTION (C_AsyncGetID, + (ck_session_handle_t session, + unsigned char *function_name, + unsigned long *id_ptr)); +_CK_DECLARE_FUNCTION (C_AsyncJoin, + (ck_session_handle_t session, + unsigned char *function_name, + unsigned long id, + unsigned char *data, + unsigned long data_len)); +_CK_DECLARE_FUNCTION (C_WrapKeyAuthenticated, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t wrapping_key, + ck_object_handle_t key, + unsigned char *associated_data, + unsigned long associated_data_len, + unsigned char *wrapped_key, + unsigned long *wrapped_key_len)); +_CK_DECLARE_FUNCTION (C_UnwrapKeyAuthenticated, + (ck_session_handle_t session, + struct ck_mechanism *mechanism, + ck_object_handle_t unwrapping_key, + unsigned char *wrapped_key, + unsigned long wrapped_key_len, + struct ck_attribute *templ, + unsigned long attribute_count, + unsigned char *associated_data, + unsigned long associated_data_len, + ck_object_handle_t *key_ptr)); + +#define CK_FUNCTION_LIST_ \ + struct ck_version version; \ + CK_C_Initialize C_Initialize; \ + CK_C_Finalize C_Finalize; \ + CK_C_GetInfo C_GetInfo; \ + CK_C_GetFunctionList C_GetFunctionList; \ + CK_C_GetSlotList C_GetSlotList; \ + CK_C_GetSlotInfo C_GetSlotInfo; \ + CK_C_GetTokenInfo C_GetTokenInfo; \ + CK_C_GetMechanismList C_GetMechanismList; \ + CK_C_GetMechanismInfo C_GetMechanismInfo; \ + CK_C_InitToken C_InitToken; \ + CK_C_InitPIN C_InitPIN; \ + CK_C_SetPIN C_SetPIN; \ + CK_C_OpenSession C_OpenSession; \ + CK_C_CloseSession C_CloseSession; \ + CK_C_CloseAllSessions C_CloseAllSessions; \ + CK_C_GetSessionInfo C_GetSessionInfo; \ + CK_C_GetOperationState C_GetOperationState; \ + CK_C_SetOperationState C_SetOperationState; \ + CK_C_Login C_Login; \ + CK_C_Logout C_Logout; \ + CK_C_CreateObject C_CreateObject; \ + CK_C_CopyObject C_CopyObject; \ + CK_C_DestroyObject C_DestroyObject; \ + CK_C_GetObjectSize C_GetObjectSize; \ + CK_C_GetAttributeValue C_GetAttributeValue; \ + CK_C_SetAttributeValue C_SetAttributeValue; \ + CK_C_FindObjectsInit C_FindObjectsInit; \ + CK_C_FindObjects C_FindObjects; \ + CK_C_FindObjectsFinal C_FindObjectsFinal; \ + CK_C_EncryptInit C_EncryptInit; \ + CK_C_Encrypt C_Encrypt; \ + CK_C_EncryptUpdate C_EncryptUpdate; \ + CK_C_EncryptFinal C_EncryptFinal; \ + CK_C_DecryptInit C_DecryptInit; \ + CK_C_Decrypt C_Decrypt; \ + CK_C_DecryptUpdate C_DecryptUpdate; \ + CK_C_DecryptFinal C_DecryptFinal; \ + CK_C_DigestInit C_DigestInit; \ + CK_C_Digest C_Digest; \ + CK_C_DigestUpdate C_DigestUpdate; \ + CK_C_DigestKey C_DigestKey; \ + CK_C_DigestFinal C_DigestFinal; \ + CK_C_SignInit C_SignInit; \ + CK_C_Sign C_Sign; \ + CK_C_SignUpdate C_SignUpdate; \ + CK_C_SignFinal C_SignFinal; \ + CK_C_SignRecoverInit C_SignRecoverInit; \ + CK_C_SignRecover C_SignRecover; \ + CK_C_VerifyInit C_VerifyInit; \ + CK_C_Verify C_Verify; \ + CK_C_VerifyUpdate C_VerifyUpdate; \ + CK_C_VerifyFinal C_VerifyFinal; \ + CK_C_VerifyRecoverInit C_VerifyRecoverInit; \ + CK_C_VerifyRecover C_VerifyRecover; \ + CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; \ + CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; \ + CK_C_SignEncryptUpdate C_SignEncryptUpdate; \ + CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; \ + CK_C_GenerateKey C_GenerateKey; \ + CK_C_GenerateKeyPair C_GenerateKeyPair; \ + CK_C_WrapKey C_WrapKey; \ + CK_C_UnwrapKey C_UnwrapKey; \ + CK_C_DeriveKey C_DeriveKey; \ + CK_C_SeedRandom C_SeedRandom; \ + CK_C_GenerateRandom C_GenerateRandom; \ + CK_C_GetFunctionStatus C_GetFunctionStatus; \ + CK_C_CancelFunction C_CancelFunction; \ + CK_C_WaitForSlotEvent C_WaitForSlotEvent; + +#define CK_FUNCTION_LIST_3_0_ \ + CK_C_GetInterfaceList C_GetInterfaceList; \ + CK_C_GetInterface C_GetInterface; \ + CK_C_LoginUser C_LoginUser; \ + CK_C_SessionCancel C_SessionCancel; \ + CK_C_MessageEncryptInit C_MessageEncryptInit; \ + CK_C_EncryptMessage C_EncryptMessage; \ + CK_C_EncryptMessageBegin C_EncryptMessageBegin; \ + CK_C_EncryptMessageNext C_EncryptMessageNext; \ + CK_C_MessageEncryptFinal C_MessageEncryptFinal; \ + CK_C_MessageDecryptInit C_MessageDecryptInit; \ + CK_C_DecryptMessage C_DecryptMessage; \ + CK_C_DecryptMessageBegin C_DecryptMessageBegin; \ + CK_C_DecryptMessageNext C_DecryptMessageNext; \ + CK_C_MessageDecryptFinal C_MessageDecryptFinal; \ + CK_C_MessageSignInit C_MessageSignInit; \ + CK_C_SignMessage C_SignMessage; \ + CK_C_SignMessageBegin C_SignMessageBegin; \ + CK_C_SignMessageNext C_SignMessageNext; \ + CK_C_MessageSignFinal C_MessageSignFinal; \ + CK_C_MessageVerifyInit C_MessageVerifyInit; \ + CK_C_VerifyMessage C_VerifyMessage; \ + CK_C_VerifyMessageBegin C_VerifyMessageBegin; \ + CK_C_VerifyMessageNext C_VerifyMessageNext; \ + CK_C_MessageVerifyFinal C_MessageVerifyFinal; + +#define CK_FUNCTION_LIST_3_2_ \ + CK_C_EncapsulateKey C_EncapsulateKey; \ + CK_C_DecapsulateKey C_DecapsulateKey; \ + CK_C_VerifySignatureInit C_VerifySignatureInit; \ + CK_C_VerifySignature C_VerifySignature; \ + CK_C_VerifySignatureUpdate C_VerifySignatureUpdate; \ + CK_C_VerifySignatureFinal C_VerifySignatureFinal; \ + CK_C_GetSessionValidationFlags C_GetSessionValidationFlags; \ + CK_C_AsyncComplete C_AsyncComplete; \ + CK_C_AsyncGetID C_AsyncGetID; \ + CK_C_AsyncJoin C_AsyncJoin; \ + CK_C_WrapKeyAuthenticated C_WrapKeyAuthenticated; \ + CK_C_UnwrapKeyAuthenticated C_UnwrapKeyAuthenticated; + +struct ck_function_list { - ck_createmutex_t create_mutex; - ck_destroymutex_t destroy_mutex; - ck_lockmutex_t lock_mutex; - ck_unlockmutex_t unlock_mutex; - ck_flags_t flags; - void *reserved; + CK_FUNCTION_LIST_ }; +struct ck_function_list_3_0 +{ + CK_FUNCTION_LIST_ + CK_FUNCTION_LIST_3_0_ +}; + +struct ck_function_list_3_2 +{ + CK_FUNCTION_LIST_ + CK_FUNCTION_LIST_3_0_ + CK_FUNCTION_LIST_3_2_ +}; -#define CKF_LIBRARY_CANT_CREATE_OS_THREADS (1UL << 0) -#define CKF_OS_LOCKING_OK (1UL << 1) - -#define CKR_OK (0UL) -#define CKR_CANCEL (1UL) -#define CKR_HOST_MEMORY (2UL) -#define CKR_SLOT_ID_INVALID (3UL) -#define CKR_GENERAL_ERROR (5UL) -#define CKR_FUNCTION_FAILED (6UL) -#define CKR_ARGUMENTS_BAD (7UL) -#define CKR_NO_EVENT (8UL) -#define CKR_NEED_TO_CREATE_THREADS (9UL) -#define CKR_CANT_LOCK (0xaUL) -#define CKR_ATTRIBUTE_READ_ONLY (0x10UL) -#define CKR_ATTRIBUTE_SENSITIVE (0x11UL) -#define CKR_ATTRIBUTE_TYPE_INVALID (0x12UL) -#define CKR_ATTRIBUTE_VALUE_INVALID (0x13UL) -#define CKR_DATA_INVALID (0x20UL) -#define CKR_DATA_LEN_RANGE (0x21UL) -#define CKR_DEVICE_ERROR (0x30UL) -#define CKR_DEVICE_MEMORY (0x31UL) -#define CKR_DEVICE_REMOVED (0x32UL) -#define CKR_ENCRYPTED_DATA_INVALID (0x40UL) -#define CKR_ENCRYPTED_DATA_LEN_RANGE (0x41UL) -#define CKR_FUNCTION_CANCELED (0x50UL) -#define CKR_FUNCTION_NOT_PARALLEL (0x51UL) -#define CKR_FUNCTION_NOT_SUPPORTED (0x54UL) -#define CKR_KEY_HANDLE_INVALID (0x60UL) -#define CKR_KEY_SIZE_RANGE (0x62UL) -#define CKR_KEY_TYPE_INCONSISTENT (0x63UL) -#define CKR_KEY_NOT_NEEDED (0x64UL) -#define CKR_KEY_CHANGED (0x65UL) -#define CKR_KEY_NEEDED (0x66UL) -#define CKR_KEY_INDIGESTIBLE (0x67UL) -#define CKR_KEY_FUNCTION_NOT_PERMITTED (0x68UL) -#define CKR_KEY_NOT_WRAPPABLE (0x69UL) -#define CKR_KEY_UNEXTRACTABLE (0x6aUL) -#define CKR_MECHANISM_INVALID (0x70UL) -#define CKR_MECHANISM_PARAM_INVALID (0x71UL) -#define CKR_OBJECT_HANDLE_INVALID (0x82UL) -#define CKR_OPERATION_ACTIVE (0x90UL) -#define CKR_OPERATION_NOT_INITIALIZED (0x91UL) -#define CKR_PIN_INCORRECT (0xa0UL) -#define CKR_PIN_INVALID (0xa1UL) -#define CKR_PIN_LEN_RANGE (0xa2UL) -#define CKR_PIN_EXPIRED (0xa3UL) -#define CKR_PIN_LOCKED (0xa4UL) -#define CKR_SESSION_CLOSED (0xb0UL) -#define CKR_SESSION_COUNT (0xb1UL) -#define CKR_SESSION_HANDLE_INVALID (0xb3UL) -#define CKR_SESSION_PARALLEL_NOT_SUPPORTED (0xb4UL) -#define CKR_SESSION_READ_ONLY (0xb5UL) -#define CKR_SESSION_EXISTS (0xb6UL) -#define CKR_SESSION_READ_ONLY_EXISTS (0xb7UL) -#define CKR_SESSION_READ_WRITE_SO_EXISTS (0xb8UL) -#define CKR_SIGNATURE_INVALID (0xc0UL) -#define CKR_SIGNATURE_LEN_RANGE (0xc1UL) -#define CKR_TEMPLATE_INCOMPLETE (0xd0UL) -#define CKR_TEMPLATE_INCONSISTENT (0xd1UL) -#define CKR_TOKEN_NOT_PRESENT (0xe0UL) -#define CKR_TOKEN_NOT_RECOGNIZED (0xe1UL) -#define CKR_TOKEN_WRITE_PROTECTED (0xe2UL) -#define CKR_UNWRAPPING_KEY_HANDLE_INVALID (0xf0UL) -#define CKR_UNWRAPPING_KEY_SIZE_RANGE (0xf1UL) -#define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT (0xf2UL) -#define CKR_USER_ALREADY_LOGGED_IN (0x100UL) -#define CKR_USER_NOT_LOGGED_IN (0x101UL) -#define CKR_USER_PIN_NOT_INITIALIZED (0x102UL) -#define CKR_USER_TYPE_INVALID (0x103UL) -#define CKR_USER_ANOTHER_ALREADY_LOGGED_IN (0x104UL) -#define CKR_USER_TOO_MANY_TYPES (0x105UL) -#define CKR_WRAPPED_KEY_INVALID (0x110UL) -#define CKR_WRAPPED_KEY_LEN_RANGE (0x112UL) -#define CKR_WRAPPING_KEY_HANDLE_INVALID (0x113UL) -#define CKR_WRAPPING_KEY_SIZE_RANGE (0x114UL) -#define CKR_WRAPPING_KEY_TYPE_INCONSISTENT (0x115UL) -#define CKR_RANDOM_SEED_NOT_SUPPORTED (0x120UL) -#define CKR_RANDOM_NO_RNG (0x121UL) -#define CKR_DOMAIN_PARAMS_INVALID (0x130UL) -#define CKR_BUFFER_TOO_SMALL (0x150UL) -#define CKR_SAVED_STATE_INVALID (0x160UL) -#define CKR_INFORMATION_SENSITIVE (0x170UL) -#define CKR_STATE_UNSAVEABLE (0x180UL) -#define CKR_CRYPTOKI_NOT_INITIALIZED (0x190UL) -#define CKR_CRYPTOKI_ALREADY_INITIALIZED (0x191UL) -#define CKR_MUTEX_BAD (0x1a0UL) -#define CKR_MUTEX_NOT_LOCKED (0x1a1UL) -#define CKR_FUNCTION_REJECTED (0x200UL) -#define CKR_ECC_POINT_INVALID (CKR_VENDOR_DEFINED + 0x2F) -#define CKR_VENDOR_DEFINED (1UL << 31) /* Compatibility layer. */ @@ -1472,9 +3115,10 @@ typedef struct ck_attribute *CK_ATTRIBUTE_PTR; typedef struct ck_date CK_DATE; typedef struct ck_date *CK_DATE_PTR; -typedef ck_mechanism_type_t *CK_MECHANISM_TYPE_PTR; +typedef struct ck_derived_key CK_DERIVED_KEY; +typedef struct ck_derived_key *CK_DERIVED_KEY_PTR; -typedef ck_rsa_pkcs_mgf_type_t *CK_RSA_PKCS_MGF_TYPE_PTR; +typedef ck_mechanism_type_t *CK_MECHANISM_TYPE_PTR; typedef struct ck_mechanism CK_MECHANISM; typedef struct ck_mechanism *CK_MECHANISM_PTR; @@ -1482,16 +3126,279 @@ typedef struct ck_mechanism *CK_MECHANISM_PTR; typedef struct ck_mechanism_info CK_MECHANISM_INFO; typedef struct ck_mechanism_info *CK_MECHANISM_INFO_PTR; +typedef struct ck_otp_mechanism_info CK_OTP_MECHANISM_INFO; +typedef struct ck_otp_mechanism_info *CK_OTP_MECHANISM_INFO_PTR; + +typedef struct ck_interface CK_INTERFACE; +typedef struct ck_interface *CK_INTERFACE_PTR; +typedef struct ck_interface **CK_INTERFACE_PTR_PTR; + typedef struct ck_function_list CK_FUNCTION_LIST; typedef struct ck_function_list *CK_FUNCTION_LIST_PTR; typedef struct ck_function_list **CK_FUNCTION_LIST_PTR_PTR; +typedef struct ck_function_list_3_0 CK_FUNCTION_LIST_3_0; +typedef struct ck_function_list_3_0 *CK_FUNCTION_LIST_3_0_PTR; +typedef struct ck_function_list_3_0 **CK_FUNCTION_LIST_3_0_PTR_PTR; + +typedef struct ck_function_list_3_2 CK_FUNCTION_LIST_3_2; +typedef struct ck_function_list_3_2 *CK_FUNCTION_LIST_3_2_PTR; +typedef struct ck_function_list_3_2 **CK_FUNCTION_LIST_3_2_PTR_PTR; + typedef struct ck_c_initialize_args CK_C_INITIALIZE_ARGS; typedef struct ck_c_initialize_args *CK_C_INITIALIZE_ARGS_PTR; -typedef CK_ULONG CK_SIGN_PARAMETER_SET_TYPE; +typedef ck_rsa_pkcs_mgf_type_t *CK_RSA_PKCS_MGF_TYPE_PTR; + +typedef struct ck_rsa_pkcs_pss_params CK_RSA_PKCS_PSS_PARAMS; +typedef struct ck_rsa_pkcs_pss_params *CK_RSA_PKCS_PSS_PARAMS_PTR; + +typedef struct ck_rsa_pkcs_oaep_params CK_RSA_PKCS_OAEP_PARAMS; +typedef struct ck_rsa_pkcs_oaep_params *CK_RSA_PKCS_OAEP_PARAMS_PTR; + +typedef struct ck_aes_ctr_params CK_AES_CTR_PARAMS; +typedef struct ck_aes_ctr_params *CK_AES_CTR_PARAMS_PTR; + +typedef struct ck_gcm_params CK_GCM_PARAMS; +typedef struct ck_gcm_params *CK_GCM_PARAMS_PTR; + +typedef struct ck_gcm_wrap_params CK_GCM_WRAP_PARAMS; +typedef struct ck_gcm_wrap_params *CK_GCM_WRAP_PARAMS_PTR; + +typedef struct ck_chacha20_params CK_CHACHA20_PARAMS; +typedef struct ck_chacha20_params *CK_CHACHA20_PARAMS_PTR; + +typedef struct ck_salsa20_params CK_SALSA20_PARAMS; +typedef struct ck_salsa20_params *CK_SALSA20_PARAMS_PTR; + +typedef struct ck_salsa20_chacha20_poly1305_params CK_SALSA20_CHACHA20_POLY1305_PARAMS; +typedef struct ck_salsa20_chacha20_poly1305_params *CK_SALSA20_CHACHA20_POLY1305_PARAMS_PTR; + +typedef struct ck_salsa20_chacha20_poly1305_msg_params CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS; +typedef struct ck_salsa20_chacha20_poly1305_msg_params *CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS_PTR; + +typedef struct ck_ecdh1_derive_params CK_ECDH1_DERIVE_PARAMS; +typedef struct ck_ecdh1_derive_params *CK_ECDH1_DERIVE_PARAMS_PTR; + +typedef struct ck_key_derivation_string_data CK_KEY_DERIVATION_STRING_DATA; +typedef struct ck_key_derivation_string_data *CK_KEY_DERIVATION_STRING_DATA_PTR; + +typedef struct ck_des_cbc_encrypt_data_params CK_DES_CBC_ENCRYPT_DATA_PARAMS; +typedef struct ck_des_cbc_encrypt_data_params *CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR; + +typedef struct ck_aes_cbc_encrypt_data_params CK_AES_CBC_ENCRYPT_DATA_PARAMS; +typedef struct ck_aes_cbc_encrypt_data_params *CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR; + +typedef struct ck_aes_ccm_params CK_AES_CCM_PARAMS; +typedef struct ck_aes_ccm_params *CK_AES_CCM_PARAMS_PTR; + +typedef struct ck_aes_gcm_params CK_AES_GCM_PARAMS; +typedef struct ck_aes_gcm_params *CK_AES_GCM_PARAMS_PTR; + +typedef struct ck_aria_cbc_encrypt_data_params CK_ARIA_CBC_ENCRYPT_DATA_PARAMS; +typedef struct ck_aria_cbc_encrypt_data_params *CK_ARIA_CBC_ENCRYPT_DATA_PARAMS_PTR; + +typedef struct ck_async_data CK_ASYNC_DATA; +typedef struct ck_async_data *CK_ASYNC_DATA_PTR; + +typedef struct ck_camellia_cbc_encrypt_data_params CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS; +typedef struct ck_camellia_cbc_encrypt_data_params *CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS_PTR; + +typedef struct ck_camellia_ctr_params CK_CAMELLIA_CTR_PARAMS; +typedef struct ck_camellia_ctr_params *CK_CAMELLIA_CTR_PARAMS_PTR; + +typedef struct ck_ccm_message_params CK_CCM_MESSAGE_PARAMS; +typedef struct ck_ccm_message_params *CK_CCM_MESSAGE_PARAMS_PTR; + +typedef struct ck_ccm_params CK_CCM_PARAMS; +typedef struct ck_ccm_params *CK_CCM_PARAMS_PTR; + +typedef struct ck_ccm_wrap_params CK_CCM_WRAP_PARAMS; +typedef struct ck_ccm_wrap_params *CK_CCM_WRAP_PARAMS_PTR; + +typedef struct ck_cms_sig_params CK_CMS_SIG_PARAMS; +typedef struct ck_cms_sig_params *CK_CMS_SIG_PARAMS_PTR; + +typedef struct ck_dsa_parameter_gen_param CK_DSA_PARAMETER_GEN_PARAM; +typedef struct ck_dsa_parameter_gen_param *CK_DSA_PARAMETER_GEN_PARAM_PTR; + +typedef struct ck_ecdh_aes_key_wrap_params CK_ECDH_AES_KEY_WRAP_PARAMS; +typedef struct ck_ecdh_aes_key_wrap_params *CK_ECDH_AES_KEY_WRAP_PARAMS_PTR; + +typedef struct ck_ecdh2_derive_params CK_ECDH2_DERIVE_PARAMS; +typedef struct ck_ecdh2_derive_params *CK_ECDH2_DERIVE_PARAMS_PTR; + +typedef struct ck_ecmqv_derive_params CK_ECMQV_DERIVE_PARAMS; +typedef struct ck_ecmqv_derive_params *CK_ECMQV_DERIVE_PARAMS_PTR; + +typedef struct ck_eddsa_params CK_EDDSA_PARAMS; +typedef struct ck_eddsa_params *CK_EDDSA_PARAMS_PTR; + +typedef struct ck_gcm_message_params CK_GCM_MESSAGE_PARAMS; +typedef struct ck_gcm_message_params *CK_GCM_MESSAGE_PARAMS_PTR; + +typedef struct ck_gostr3410_derive_params CK_GOSTR3410_DERIVE_PARAMS; +typedef struct ck_gostr3410_derive_params *CK_GOSTR3410_DERIVE_PARAMS_PTR; + +typedef struct ck_gostr3410_key_wrap_params CK_GOSTR3410_KEY_WRAP_PARAMS; +typedef struct ck_gostr3410_key_wrap_params *CK_GOSTR3410_KEY_WRAP_PARAMS_PTR; + +typedef struct ck_hash_sign_additional_context CK_HASH_SIGN_ADDITIONAL_CONTEXT; +typedef struct ck_hash_sign_additional_context *CK_HASH_SIGN_ADDITIONAL_CONTEXT_PTR; + +typedef struct ck_hkdf_params CK_HKDF_PARAMS; +typedef struct ck_hkdf_params *CK_HKDF_PARAMS_PTR; + +typedef struct ck_kea_derive_params CK_KEA_DERIVE_PARAMS; +typedef struct ck_kea_derive_params *CK_KEA_DERIVE_PARAMS_PTR; + +typedef struct ck_key_wrap_set_oaep_params CK_KEY_WRAP_SET_OAEP_PARAMS; +typedef struct ck_key_wrap_set_oaep_params *CK_KEY_WRAP_SET_OAEP_PARAMS_PTR; + +typedef struct ck_kip_params CK_KIP_PARAMS; +typedef struct ck_kip_params *CK_KIP_PARAMS_PTR; + +typedef struct ck_pbe_params CK_PBE_PARAMS; +typedef struct ck_pbe_params *CK_PBE_PARAMS_PTR; + +typedef struct ck_pkcs5_pbkd2_params CK_PKCS5_PBKD2_PARAMS; +typedef struct ck_pkcs5_pbkd2_params *CK_PKCS5_PBKD2_PARAMS_PTR; +typedef struct ck_pkcs5_pbkd2_params2 CK_PKCS5_PBKD2_PARAMS2; +typedef struct ck_pkcs5_pbkd2_params2 *CK_PKCS5_PBKD2_PARAMS2_PTR; + +typedef struct ck_prf_data_param CK_PRF_DATA_PARAM; +typedef struct ck_prf_data_param *CK_PRF_DATA_PARAM_PTR; + +typedef struct ck_rc2_cbc_params CK_RC2_CBC_PARAMS; +typedef struct ck_rc2_cbc_params *CK_RC2_CBC_PARAMS_PTR; + +typedef struct ck_rc2_mac_general_params CK_RC2_MAC_GENERAL_PARAMS; +typedef struct ck_rc2_mac_general_params *CK_RC2_MAC_GENERAL_PARAMS_PTR; + +typedef struct ck_rc5_cbc_params CK_RC5_CBC_PARAMS; +typedef struct ck_rc5_cbc_params *CK_RC5_CBC_PARAMS_PTR; + +typedef struct ck_rc5_mac_general_params CK_RC5_MAC_GENERAL_PARAMS; +typedef struct ck_rc5_mac_general_params *CK_RC5_MAC_GENERAL_PARAMS_PTR; + +typedef struct ck_rc5_params CK_RC5_PARAMS; +typedef struct ck_rc5_params *CK_RC5_PARAMS_PTR; + +typedef struct ck_rsa_aes_key_wrap_params CK_RSA_AES_KEY_WRAP_PARAMS; +typedef struct ck_rsa_aes_key_wrap_params *CK_RSA_AES_KEY_WRAP_PARAMS_PTR; + +typedef struct ck_seed_cbc_encrypt_data_params CK_SEED_CBC_ENCRYPT_DATA_PARAMS; +typedef struct ck_seed_cbc_encrypt_data_params *CK_SEED_CBC_ENCRYPT_DATA_PARAMS_PTR; + +typedef struct ck_sign_additional_context CK_SIGN_ADDITIONAL_CONTEXT; +typedef struct ck_sign_additional_context *CK_SIGN_ADDITIONAL_CONTEXT_PTR; + +typedef struct ck_skipjack_private_wrap_params CK_SKIPJACK_PRIVATE_WRAP_PARAMS; +typedef struct ck_skipjack_private_wrap_params *CK_SKIPJACK_PRIVATE_WRAP_PARAMS_PTR; + +typedef struct ck_skipjack_relayx_params CK_SKIPJACK_RELAYX_PARAMS; +typedef struct ck_skipjack_relayx_params *CK_SKIPJACK_RELAYX_PARAMS_PTR; + +typedef struct ck_sp800_108_counter_format CK_SP800_108_COUNTER_FORMAT; +typedef struct ck_sp800_108_counter_format *CK_SP800_108_COUNTER_FORMAT_PTR; + +typedef struct ck_sp800_108_dkm_length_format CK_SP800_108_DKM_LENGTH_FORMAT; +typedef struct ck_sp800_108_dkm_length_format *CK_SP800_108_DKM_LENGTH_FORMAT_PTR; + +typedef struct ck_sp800_108_feedback_kdf_params CK_SP800_108_FEEDBACK_KDF_PARAMS; +typedef struct ck_sp800_108_feedback_kdf_params *CK_SP800_108_FEEDBACK_KDF_PARAMS_PTR; + +typedef struct ck_sp800_108_kdf_params CK_SP800_108_KDF_PARAMS; +typedef struct ck_sp800_108_kdf_params *CK_SP800_108_KDF_PARAMS_PTR; + +typedef struct ck_tls12_extended_master_key_derive_params CK_TLS12_EXTENDED_MASTER_KEY_DERIVE_PARAMS; +typedef struct ck_tls12_extended_master_key_derive_params *CK_TLS12_EXTENDED_MASTER_KEY_DERIVE_PARAMS_PTR; + +typedef struct ck_x2ratchet_initialize_params CK_X2RATCHET_INITIALIZE_PARAMS; +typedef struct ck_x2ratchet_initialize_params *CK_X2RATCHET_INITIALIZE_PARAMS_PTR; + +typedef struct ck_x2ratchet_respond_params CK_X2RATCHET_RESPOND_PARAMS; +typedef struct ck_x2ratchet_respond_params *CK_X2RATCHET_RESPOND_PARAMS_PTR; + +typedef struct ck_x3dh_initiate_params CK_X3DH_INITIATE_PARAMS; +typedef struct ck_x3dh_initiate_params *CK_X3DH_INITIATE_PARAMS_PTR; + +typedef struct ck_x3dh_respond_params CK_X3DH_RESPOND_PARAMS; +typedef struct ck_x3dh_respond_params *CK_X3DH_RESPOND_PARAMS_PTR; + +typedef struct ck_x9_42_dh1_derive_params CK_X9_42_DH1_DERIVE_PARAMS; +typedef struct ck_x9_42_dh1_derive_params *CK_X9_42_DH1_DERIVE_PARAMS_PTR; + +typedef struct ck_x9_42_dh2_derive_params CK_X9_42_DH2_DERIVE_PARAMS; +typedef struct ck_x9_42_dh2_derive_params *CK_X9_42_DH2_DERIVE_PARAMS_PTR; + +typedef struct ck_x9_42_mqv_derive_params CK_X9_42_MQV_DERIVE_PARAMS; +typedef struct ck_x9_42_mqv_derive_params *CK_X9_42_MQV_DERIVE_PARAMS_PTR; + +typedef struct ck_xeddsa_params CK_XEDDSA_PARAMS; +typedef struct ck_xeddsa_params *CK_XEDDSA_PARAMS_PTR; + +typedef struct specified_params specifiedParams; +typedef struct specified_params *specifiedParams_PTR; + +typedef struct ck_ike_prf_derive_params CK_IKE_PRF_DERIVE_PARAMS; +typedef struct ck_ike_prf_derive_params *CK_IKE_PRF_DERIVE_PARAMS_PTR; + +typedef struct ck_ike1_extended_derive_params CK_IKE1_EXTENDED_DERIVE_PARAMS; +typedef struct ck_ike1_extended_derive_params *CK_IKE1_EXTENDED_DERIVE_PARAMS_PTR; + +typedef struct ck_ike1_prf_derive_params CK_IKE1_PRF_DERIVE_PARAMS; +typedef struct ck_ike1_prf_derive_params *CK_IKE1_PRF_DERIVE_PARAMS_PTR; + +typedef struct ck_ike2_prf_plus_derive_params CK_IKE2_PRF_PLUS_DERIVE_PARAMS; +typedef struct ck_ike2_prf_plus_derive_params *CK_IKE2_PRF_PLUS_DERIVE_PARAMS_PTR; + +typedef struct ck_ssl3_key_mat_out CK_SSL3_KEY_MAT_OUT; +typedef struct ck_ssl3_key_mat_out *CK_SSL3_KEY_MAT_OUT_PTR; + +typedef struct ck_ssl3_key_mat_params CK_SSL3_KEY_MAT_PARAMS; +typedef struct ck_ssl3_key_mat_params *CK_SSL3_KEY_MAT_PARAMS_PTR; + +typedef struct ck_ssl3_master_key_derive_params CK_SSL3_MASTER_KEY_DERIVE_PARAMS; +typedef struct ck_ssl3_master_key_derive_params *CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR; + +typedef struct ck_ssl3_random_data CK_SSL3_RANDOM_DATA; +typedef struct ck_ssl3_random_data *CK_SSL3_RANDOM_DATA_PTR; + +typedef struct ck_tls_kdf_params CK_TLS_KDF_PARAMS; +typedef struct ck_tls_kdf_params *CK_TLS_KDF_PARAMS_PTR; + +typedef struct ck_tls_mac_params CK_TLS_MAC_PARAMS; +typedef struct ck_tls_mac_params *CK_TLS_MAC_PARAMS_PTR; + +typedef struct ck_tls_prf_params CK_TLS_PRF_PARAMS; +typedef struct ck_tls_prf_params *CK_TLS_PRF_PARAMS_PTR; + +typedef struct ck_tls12_key_mat_params CK_TLS12_KEY_MAT_PARAMS; +typedef struct ck_tls12_key_mat_params *CK_TLS12_KEY_MAT_PARAMS_PTR; + +typedef struct ck_tls12_master_key_derive_params CK_TLS12_MASTER_KEY_DERIVE_PARAMS; +typedef struct ck_tls12_master_key_derive_params *CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR; + +typedef struct ck_wtls_key_mat_out CK_WTLS_KEY_MAT_OUT; +typedef struct ck_wtls_key_mat_out *CK_WTLS_KEY_MAT_OUT_PTR; + +typedef struct ck_wtls_key_mat_params CK_WTLS_KEY_MAT_PARAMS; +typedef struct ck_wtls_key_mat_params *CK_WTLS_KEY_MAT_PARAMS_PTR; + +typedef struct ck_wtls_master_key_derive_params CK_WTLS_MASTER_KEY_DERIVE_PARAMS; +typedef struct ck_wtls_master_key_derive_params *CK_WTLS_MASTER_KEY_DERIVE_PARAMS_PTR; + +typedef struct ck_wtls_prf_params CK_WTLS_PRF_PARAMS; +typedef struct ck_wtls_prf_params *CK_WTLS_PRF_PARAMS_PTR; + +typedef struct ck_wtls_random_data CK_WTLS_RANDOM_DATA; +typedef struct ck_wtls_random_data *CK_WTLS_RANDOM_DATA_PTR; + +#ifndef NULL_PTR #define NULL_PTR NULL +#endif /* Delete the helper macros defined at the top of the file. */ #undef ck_flags_t @@ -1537,45 +3444,282 @@ typedef CK_ULONG CK_SIGN_PARAMETER_SET_TYPE; #undef ck_object_class_t #undef ck_hw_feature_type_t #undef ck_key_type_t +#undef ck_certificate_category_t #undef ck_certificate_type_t #undef ck_attribute_type_t +#undef ck_ec_kdf_type_t +#undef ck_extract_params_t +#undef ck_java_midp_security_domain_t +#undef ck_mac_general_params_t +#undef ck_otp_param_type_t +#undef ck_pkcs5_pbkd2_pseudo_random_function_type_t +#undef ck_pkcs5_pbkdf2_salt_source_type_t +#undef ck_prf_data_type_t +#undef ck_profile_id_t +#undef ck_rc2_params_t +#undef ck_sp800_108_dkm_length_method_t +#undef ck_x2ratchet_kdf_type_t +#undef ck_x3dh_kdf_type_t +#undef ck_x9_42_dh_kdf_type_t +#undef ck_xeddsa_hash_type_t +#undef ck_sp800_108_prf_type_t +#undef ck_hss_levels_t +#undef ck_lms_type_t +#undef ck_lmots_type_t #undef ck_attribute #undef value #undef value_len +#undef count + #undef ck_date #undef ck_mechanism_type_t -#undef ck_rsa_pkcs_mgf_type_t - #undef ck_mechanism #undef parameter #undef parameter_len +#undef params + #undef ck_mechanism_info #undef min_key_size #undef max_key_size +#undef ck_param_type +#undef ck_otp_param +#undef ck_otp_params +#undef ck_otp_signature_info + #undef ck_rv_t #undef ck_notify_t +#undef ck_interface +#undef interface_name_ptr +#undef function_list_ptr + #undef ck_function_list +#undef ck_function_list_3_0 +#undef ck_function_list_3_2 +#undef ck_c_initialize_args #undef ck_createmutex_t #undef ck_destroymutex_t #undef ck_lockmutex_t #undef ck_unlockmutex_t -#undef ck_c_initialize_args #undef create_mutex #undef destroy_mutex #undef lock_mutex #undef unlock_mutex #undef reserved -#endif /* CRYPTOKI_COMPAT */ +#undef ck_rsa_pkcs_mgf_type_t +#undef ck_rsa_pkcs_oaep_source_type_t +#undef hash_alg +#undef s_len +#undef source_data +#undef source_data_len + +#undef ck_generator_function_t +#undef counter_bits +#undef iv_ptr +#undef iv_len +#undef iv_bits +#undef iv_fixed_bits +#undef iv_generator +#undef aad_ptr +#undef aad_len +#undef tag_bits +#undef tag_ptr +#undef block_counter +#undef block_counter_bits +#undef nonce_ptr +#undef nonce_bits +#undef nonce_fixed_bits +#undef nonce_len +#undef nonce_generator +#undef shared_data_len +#undef shared_data +#undef public_data_len +#undef public_data +#undef public_data_len2 +#undef public_data2 +#undef private_data_len +#undef private_data +#undef string_data +#undef string_data_len +#undef data_params +#undef data_len +#undef mac_ptr +#undef mac_len +#undef certificate_handle +#undef signing_mechanism_ptr +#undef digest_mechanism_ptr +#undef content_type +#undef requested_attributes +#undef requested_attributes_len +#undef required_attributes +#undef required_attributes_len +#undef seed_ptr +#undef seed_len +#undef index +#undef aes_key_bits +#undef public_key +#undef flag +#undef context_data_len +#undef context_data +#undef wrap_oid +#undef wrap_oid_len +#undef ukm_ptr +#undef ukm_len +#undef key +#undef extract +#undef expand +#undef prf_hash_mechanism +#undef salt_type +#undef salt_ptr +#undef salt_len +#undef salt_key +#undef info +#undef info_len +#undef is_sender +#undef random_len +#undef random_a +#undef random_b +#undef bc +#undef x_ptr +#undef x_len +#undef mechanism_ptr +#undef init_vector +#undef password_ptr +#undef password_len +#undef iteration +#undef salt_source +#undef salt_source_data +#undef salt_source_data_len +#undef prf_data +#undef prf_data_len +#undef effective_bits +#undef mac_length +#undef word_size +#undef rounds +#undef oaep_params +#undef p_and_g_len +#undef q_len +#undef random_a_ptr +#undef prime_p +#undef base_g +#undef subprime_q +#undef old_wrapped_x_len +#undef old_wrapped_x +#undef old_password_len +#undef old_password +#undef old_public_data_len +#undef old_public_data +#undef old_random_len +#undef old_random_a +#undef new_password_len +#undef new_password +#undef new_public_data_len +#undef new_public_data +#undef new_random_len +#undef new_random_a +#undef little_endian +#undef width_in_bits +#undef dkm_length_method +#undef prf_type +#undef number_of_data_params +#undef data_params_ptr +#undef additional_derived_keys_len +#undef additional_derived_keys +#undef encrypted_header +#undef curve +#undef aead_mechanism +#undef kdf_mechanism +#undef peer_identity +#undef peer_prekey +#undef prekey_signature +#undef onetime_key +#undef own_identity +#undef own_ephemeral +#undef identity_id +#undef prekey_id +#undef onetime_id +#undef initiator_identity +#undef initiator_ephemeral +#undef other_info_len +#undef other_info +#undef prf_mechanism +#undef data_as_key +#undef rekey +#undef ni_ptr +#undef ni_len +#undef nr_ptr +#undef nr_len +#undef new_key +#undef has_key_gxy +#undef key_gxy +#undef extra_data +#undef extra_data_len +#undef has_prev_key +#undef prev_key +#undef cky_i_ptr +#undef cky_i_len +#undef cky_r_ptr +#undef cky_r_len +#undef key_number +#undef has_seed_key +#undef seed_key +#undef seed_data +#undef seed_data_len +#undef client_mac_secret +#undef server_mac_secret +#undef client_key +#undef server_key +#undef iv_client +#undef iv_server +#undef client_random_ptr +#undef client_random_len +#undef server_random_ptr +#undef server_random_len +#undef mac_size_in_bits +#undef key_size_in_bits +#undef iv_size_in_bits +#undef is_export +#undef random_info +#undef returned_key_material +#undef version_ptr +#undef label_length +#undef label_len +#undef label_ptr +#undef server_or_client +#undef output_ptr +#undef output_len_ptr +#undef mac_secret +#undef i_v_ptr +#undef digest_mechanism +#undef sequence_number +#undef ck_hedge_type_t +#undef ck_ml_dsa_parameter_set_type_t +#undef ck_ml_kem_parameter_set_type_t +#undef ck_session_validation_flags_type_t +#undef ck_slh_dsa_parameter_set_type_t +#undef ck_trust_t +#undef ck_validation_authority_type_t +#undef ck_validation_type_t +#undef ck_xmssmt_parameter_set_type_t +#undef ck_xmss_parameter_set_type_t +#undef version_num +#undef object_handle +#undef additional_object_handle +#undef hedge_variant +#undef context_ptr +#undef context_len +#undef session_hash_ptr +#undef session_hash_len +#endif /* CRYPTOKI_COMPAT */ /* System dependencies. */ #if defined(_WIN32) || defined(CRYPTOKI_FORCE_WIN32) @@ -1586,4 +3730,4 @@ typedef CK_ULONG CK_SIGN_PARAMETER_SET_TYPE; } #endif -#endif /* PKCS11_H */ +#endif /* PKCS11_H */ diff --git a/src/provider.c b/src/provider.c index 4fee27a7..412a50c4 100644 --- a/src/provider.c +++ b/src/provider.c @@ -119,6 +119,18 @@ PROVIDER_FN(keyexch_settable_ctx_params); PROVIDER_FN(keyexch_get_ctx_params); PROVIDER_FN(keyexch_gettable_ctx_params); +PROVIDER_FN(kem_newctx); +PROVIDER_FN(kem_freectx); +PROVIDER_FN(kem_dupctx); +PROVIDER_FN(kem_encapsulate_init); +PROVIDER_FN(kem_encapsulate); +PROVIDER_FN(kem_decapsulate_init); +PROVIDER_FN(kem_decapsulate); +PROVIDER_FN(kem_get_ctx_params); +PROVIDER_FN(kem_gettable_ctx_params); +PROVIDER_FN(kem_set_ctx_params); +PROVIDER_FN(kem_settable_ctx_params); + PROVIDER_FN(store_open); PROVIDER_FN(store_set_ctx_params); PROVIDER_FN(store_settable_ctx_params); @@ -211,6 +223,21 @@ static const OSSL_DISPATCH keyexch_functions[] = { OSSL_DISPATCH_END }; +static const OSSL_DISPATCH asym_kem_functions[] = { + {OSSL_FUNC_KEM_NEWCTX, (void (*)(void))kem_newctx}, + {OSSL_FUNC_KEM_FREECTX, (void (*)(void))kem_freectx}, + {OSSL_FUNC_KEM_DUPCTX, (void (*)(void))kem_dupctx}, + {OSSL_FUNC_KEM_ENCAPSULATE_INIT, (void (*)(void))kem_encapsulate_init}, + {OSSL_FUNC_KEM_ENCAPSULATE, (void (*)(void))kem_encapsulate}, + {OSSL_FUNC_KEM_DECAPSULATE_INIT, (void (*)(void))kem_decapsulate_init}, + {OSSL_FUNC_KEM_DECAPSULATE, (void (*)(void))kem_decapsulate}, + {OSSL_FUNC_KEM_GET_CTX_PARAMS, (void (*)(void))kem_get_ctx_params}, + {OSSL_FUNC_KEM_GETTABLE_CTX_PARAMS, (void (*)(void))kem_gettable_ctx_params}, + {OSSL_FUNC_KEM_SET_CTX_PARAMS, (void (*)(void))kem_set_ctx_params}, + {OSSL_FUNC_KEM_SETTABLE_CTX_PARAMS, (void (*)(void))kem_settable_ctx_params}, + OSSL_DISPATCH_END +}; + static const OSSL_DISPATCH store_functions[] = { {OSSL_FUNC_STORE_OPEN, (void (*)(void))store_open}, {OSSL_FUNC_STORE_SET_CTX_PARAMS, (void (*)(void))store_set_ctx_params}, @@ -240,6 +267,11 @@ static const OSSL_ALGORITHM p11_keymgmts[] = { {"ML-DSA-65", FIPS_PROPQ, keymgmt_functions, "PKCS#11 ML-DSA-65 keymgmt functions"}, {"ML-DSA-87", FIPS_PROPQ, keymgmt_functions, "PKCS#11 ML-DSA-87 keymgmt functions"}, #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM + {"ML-KEM-512", FIPS_PROPQ, keymgmt_functions, "PKCS#11 ML-KEM-512 keymgmt functions"}, + {"ML-KEM-768", FIPS_PROPQ, keymgmt_functions, "PKCS#11 ML-KEM-768 keymgmt functions"}, + {"ML-KEM-1024", FIPS_PROPQ, keymgmt_functions, "PKCS#11 ML-KEM-1024 keymgmt functions"}, +#endif /* OPENSSL_NO_ML_KEM */ #ifndef OPENSSL_NO_SLH_DSA {"SLH-DSA-SHA2-128s", FIPS_PROPQ, keymgmt_functions, "PKCS#11 SLH-DSA-SHA2-128s keymgmt functions"}, @@ -289,6 +321,11 @@ static const OSSL_ALGORITHM p11_keyexch[] = { {NULL, NULL, NULL, NULL} }; +static const OSSL_ALGORITHM p11_asym_kem[] = { + {"PKCS11", FIPS_PROPQ, asym_kem_functions, "PKCS#11 asymmetric kem functions"}, + {NULL, NULL, NULL, NULL} +}; + static const OSSL_ALGORITHM p11_storemgmt[] = { {"PKCS11", FIPS_PROPQ, store_functions, "PKCS#11 storage functions"}, {NULL, NULL, NULL, NULL} @@ -445,6 +482,8 @@ static const OSSL_ALGORITHM *provider_query_operation(void *ctx, return p11_asym_cipher; case OSSL_OP_KEYEXCH: return p11_keyexch; + case OSSL_OP_KEM: + return p11_asym_kem; case OSSL_OP_STORE: return p11_storemgmt; } @@ -565,6 +604,7 @@ static const char *keymgmt_query_operation_name(int id) case OSSL_OP_SIGNATURE: case OSSL_OP_ASYM_CIPHER: case OSSL_OP_KEYEXCH: + case OSSL_OP_KEM: return "PKCS11"; } return NULL; @@ -646,7 +686,10 @@ static const OSSL_PARAM *keymgmt_export_types(int selection) static int keymgmt_get_params(void *provkey, OSSL_PARAM params[]) { P11_KEYDATA *keydata = (P11_KEYDATA *)provkey; - const OSSL_PARAM *pub; + const OSSL_PARAM *key_params = NULL; + const OSSL_PARAM *pub = NULL; + OSSL_PARAM *encoded_pub; + OSSL_PARAM *raw_pub; OSSL_PARAM *p; int type, bits, secbits; #if OPENSSL_VERSION_NUMBER >= 0x30600000L @@ -685,42 +728,36 @@ static int keymgmt_get_params(void *provkey, OSSL_PARAM params[]) return 0; #endif /* OPENSSL_VERSION_NUMBER >= 0x30600000L */ - /* EVP_PKEY_get1_encoded_public_key(), not covered by tests */ - p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY); - if (p != NULL && type == EVP_PKEY_EC) { - const OSSL_PARAM *key_params = p11_keydata_get_params(keydata); + encoded_pub = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY); + raw_pub = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY); + if ((encoded_pub != NULL && has_encoded_public_key(type)) || + (raw_pub != NULL && has_raw_public_key(type))) { + key_params = p11_keydata_get_params(keydata); if (key_params == NULL) - return 0; + return 0; pub = OSSL_PARAM_locate_const(key_params, OSSL_PKEY_PARAM_PUB_KEY); if (pub == NULL || pub->data_type != OSSL_PARAM_OCTET_STRING || pub->data == NULL || pub->data_size == 0) return 0; - if (!OSSL_PARAM_set_octet_string(p, pub->data, pub->data_size)) - return 0; } - p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY); - if (p != NULL && is_oneshot_sig_type(type)) { - const OSSL_PARAM *key_params = p11_keydata_get_params(keydata); - - if (key_params == NULL) - return 0; + /* EVP_PKEY_get1_encoded_public_key(), not covered by tests */ + if (encoded_pub != NULL && has_encoded_public_key(type) && + !OSSL_PARAM_set_octet_string(encoded_pub, pub->data, pub->data_size)) + return 0; - pub = OSSL_PARAM_locate_const(key_params, OSSL_PKEY_PARAM_PUB_KEY); - if (pub == NULL || pub->data_type != OSSL_PARAM_OCTET_STRING || - pub->data == NULL || pub->data_size == 0) - return 0; - if (!OSSL_PARAM_set_octet_string(p, pub->data, pub->data_size)) - return 0; - } + if (raw_pub != NULL && has_raw_public_key(type) && + !OSSL_PARAM_set_octet_string(raw_pub, pub->data, pub->data_size)) + return 0; - /* EVP_PKEY_get_default_digest_name(), "pkeyutl -sign -rawin" + /* + * EVP_PKEY_get_default_digest_name(), "pkeyutl -sign -rawin". * Hash-and-sign algorithms such as RSA and ECDSA use SHA256 as the - * default digest. One-shot signature algorithms (EdDSA, ML-DSA, - * SLH-DSA) do not accept an external digest and therefore report - * OSSL_PKEY_PARAM_MANDATORY_DIGEST = "UNDEF". */ + * default digest. One-shot signature algorithms do not accept an + * external digest and therefore report a mandatory digest of UNDEF. + */ if (is_oneshot_sig_type(type)) { p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MANDATORY_DIGEST); if (p != NULL && !OSSL_PARAM_set_utf8_string(p, "UNDEF")) @@ -2055,6 +2092,129 @@ static const OSSL_PARAM *keyexch_settable_ctx_params(void *ctx, void *provctx) } +/******************************************************************************/ +/* Asymmetric kem functions */ +/******************************************************************************/ + +/* Create and initialize asymmetric KEM context. */ +static void *kem_newctx(void *provctx) +{ + return p11_kem_ctx_new(provctx); +} + +/* Free asymmetric KEM context. */ + +static void kem_freectx(void *ctx) +{ + p11_kem_ctx_free(ctx); +} + +/* Duplicate asymmetric KEM context. */ +static void *kem_dupctx(void *ctx) +{ + return p11_kem_ctx_dupctx(ctx); +} + +/* + * Initialize an asymmetric KEM context for encapsulation using + * the recipient's public key. + */ +static int kem_encapsulate_init(void *ctx, void *provkey, + const OSSL_PARAM params[]) +{ + return p11_kem_ctx_init(ctx, provkey, params); +} + +/* Encapsulate a shared secret using an ML-KEM public key. */ +static int kem_encapsulate(void *ctx, unsigned char *out, size_t *outlen, + unsigned char *secret, size_t *secretlen) +{ + return p11_kem_ctx_encapsulate(ctx, out, outlen, secret, secretlen); +} + +/* + * Initialise a context for an asymmetric decapsulation given a provider side + * asymmetric KEM context in the ctx parameter, a pointer to a provider key + * object in the provkey parameter, and a name of the algorithm. + */ +static int kem_decapsulate_init(void *ctx, void *provkey, const OSSL_PARAM params[]) +{ + return p11_kem_ctx_init(ctx, provkey, params); +} + +/* Perform the actual decapsulation. */ +static int kem_decapsulate(void *ctx, unsigned char *out, size_t *outlen, + const unsigned char *in, size_t inlen) +{ + P11_KEM_CTX *kem_ctx = (P11_KEM_CTX *)ctx; + size_t secret_size; + + if (kem_ctx == NULL || outlen == NULL || in == NULL) + return 0; + + secret_size = p11_kem_ctx_get_secret_size(kem_ctx); + if (secret_size == 0) + return 0; + + if (out == NULL) { + *outlen = secret_size; + return 1; + } + + if (*outlen < secret_size) { + *outlen = secret_size; + return 0; + } + + return PKCS11_evp_pkey_decapsulate( + p11_kem_ctx_get_evp_pkey(kem_ctx), + p11_kem_ctx_get_type(kem_ctx), + out, outlen, in, inlen); +} + +/* Return the current asymmetric KEM context parameters. */ +static int kem_get_ctx_params(void *ctx, OSSL_PARAM params[]) +{ + if (ctx == NULL) + return 0; + + (void)params; + return 1; +} + +/* Return the list of gettable asymmetric KEM context parameters. */ +static const OSSL_PARAM *kem_gettable_ctx_params(void *ctx, void *provctx) +{ + static const OSSL_PARAM gettable[] = { + OSSL_PARAM_END + }; + + (void)ctx; + (void)provctx; + return gettable; +} + +/* + * Set asymmetric KEM context parameters. + * OSSL_KEM_PARAM_IKME is not supported because PKCS#11 ML-KEM + * encapsulation uses randomness generated internally by the token. + * This parameter should not be used for purposes other than testing. + */ +static int kem_set_ctx_params(void *ctx, const OSSL_PARAM params[]) +{ + if (ctx == NULL) + return 0; + + (void)params; + return 1; +} + +/* Return the list of gettable asymmetric KEM context parameters. */ +static const OSSL_PARAM *kem_settable_ctx_params(void *ctx, void *provctx) +{ + return kem_gettable_ctx_params(ctx, provctx); +} + /******************************************************************************/ /* Store functions */ /******************************************************************************/ diff --git a/src/provider_helpers.c b/src/provider_helpers.c index 8fceb814..41b5a87a 100644 --- a/src/provider_helpers.c +++ b/src/provider_helpers.c @@ -58,6 +58,18 @@ #define ML_DSA_65_SIG_LEN 3309 #define ML_DSA_87_SIG_LEN 4627 #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM +#define ML_KEM_SHARED_SECRET_BYTES 32 +#define ML_KEM_512_PUBLIC_KEY_BYTES 800 +#define ML_KEM_512_CIPHERTEXT_BYTES 768 +#define ML_KEM_512_SECURITY_BITS 128 +#define ML_KEM_768_PUBLIC_KEY_BYTES 1184 +#define ML_KEM_768_CIPHERTEXT_BYTES 1088 +#define ML_KEM_768_SECURITY_BITS 192 +#define ML_KEM_1024_PUBLIC_KEY_BYTES 1568 +#define ML_KEM_1024_CIPHERTEXT_BYTES 1568 +#define ML_KEM_1024_SECURITY_BITS 256 +#endif /* OPENSSL_NO_ML_KEM */ #ifndef OPENSSL_NO_SLH_DSA #define SLH_DSA_128S_PUB_BYTES 32 #define SLH_DSA_128F_PUB_BYTES 32 @@ -205,6 +217,11 @@ struct p11_keyexch_ctx { int cofactor_mode; /* ECDH only: -1 default, 0 disable, 1 enable */ }; +struct p11_kem_ctx { + PROVIDER_CTX *prov_ctx; + P11_KEYDATA *keydata; /* recipient public/private key */ +}; + /* Internal helper functions */ static void PROVIDER_CTX_get_environment_parameters(PROVIDER_CTX *prov_ctx); static int PROVIDER_CTX_get_specific_parameters(PROVIDER_CTX *prov_ctx); @@ -225,6 +242,9 @@ static int p11_keydata_init_ecx_from_params(P11_KEYDATA *keydata, int type); #ifndef OPENSSL_NO_ML_DSA static int p11_keydata_init_mldsa_from_params(P11_KEYDATA *keydata, int type); #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM +static int p11_keydata_init_mlkem_from_params(P11_KEYDATA *keydata, int type); +#endif /* OPENSSL_NO_ML_KEM */ #ifndef OPENSSL_NO_SLH_DSA static int p11_keydata_init_slhdsa_from_params(P11_KEYDATA *keydata, int type); #endif /* OPENSSL_NO_SLH_DSA */ @@ -710,6 +730,15 @@ int p11_keydata_get_security_bits(const P11_KEYDATA *keydata) return 256; #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM + case EVP_PKEY_ML_KEM_512: + return 128; + case EVP_PKEY_ML_KEM_768: + return 192; + case EVP_PKEY_ML_KEM_1024: + return 256; +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA case EVP_PKEY_SLH_DSA_SHA2_128S: case EVP_PKEY_SLH_DSA_SHA2_128F: @@ -1443,6 +1472,45 @@ int is_oneshot_sig_type(int type) } } +int has_raw_public_key(int type) +{ + if (is_oneshot_sig_type(type)) + return 1; + +#if !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L + switch (type) { + case EVP_PKEY_ML_KEM_512: + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: + return 1; + default: + return 0; + } +#endif /* !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ + return 0; +} + +int has_encoded_public_key(int type) +{ + switch (type) { +#ifndef OPENSSL_NO_EC + case EVP_PKEY_EC: +#endif /* OPENSSL_NO_EC */ +#ifndef OPENSSL_NO_ECX + case EVP_PKEY_X25519: + case EVP_PKEY_X448: +#endif /* OPENSSL_NO_ECX */ +#if !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L + case EVP_PKEY_ML_KEM_512: + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: +#endif /* !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ + return 1; + default: + return 0; + } +} + /******************************************************************************/ /* ASYM CIPHER helper functions */ @@ -2017,6 +2085,158 @@ size_t p11_keyexch_ctx_get_outsize(const P11_KEYEXCH_CTX *keyexch_ctx) return outsize; } +/******************************************************************************/ +/* ASYM KEM helper functions */ +/******************************************************************************/ + +/* Allocate a asymmetric KEM context. */ +P11_KEM_CTX *p11_kem_ctx_new(PROVIDER_CTX *ctx) +{ + P11_KEM_CTX *kem_ctx; + + kem_ctx = OPENSSL_zalloc(sizeof(P11_KEM_CTX)); + if (!kem_ctx) + return NULL; + + kem_ctx->prov_ctx = ctx; + return kem_ctx; +} + +/* Free the asymmetric KEM context and release referenced keys. */ +void p11_kem_ctx_free(P11_KEM_CTX *kem_ctx) +{ + if (kem_ctx == NULL) + return; + + p11_keydata_free(kem_ctx->keydata); + OPENSSL_free(kem_ctx); +} + +/* + * Duplicate a asymmetric KEM context. + * Key objects are shared by reference; mutable context state is copied. + */ +P11_KEM_CTX *p11_kem_ctx_dupctx(P11_KEM_CTX *kem_ctx) +{ + P11_KEM_CTX *dst = NULL; + + if (kem_ctx == NULL) + return NULL; + + dst = p11_kem_ctx_new(kem_ctx->prov_ctx); + if (dst == NULL) + return NULL; + + /* share local keydata by reference */ + if (kem_ctx->keydata != NULL) { + if (!p11_keydata_up_ref(kem_ctx->keydata)) + goto err; + dst->keydata = kem_ctx->keydata; + } + + return dst; + +err: + p11_kem_ctx_free(dst); + return NULL; +} + +/* Initialize an asymmetric KEM context with a key. */ +int p11_kem_ctx_init(P11_KEM_CTX *kem_ctx, P11_KEYDATA *keydata, const OSSL_PARAM params[]) +{ + if (kem_ctx == NULL || keydata == NULL) + return 0; + + (void)params; + + if (!p11_keydata_up_ref(keydata)) + return 0; + + p11_keydata_free(kem_ctx->keydata); + kem_ctx->keydata = keydata; + + return 1; +} + +/* + * Encapsulate a shared secret using a temporary public key copy + * in the default provider. + */ +int p11_kem_ctx_encapsulate(P11_KEM_CTX *kem_ctx, unsigned char *out, + size_t *outlen, unsigned char *secret, size_t *secretlen) +{ + EVP_PKEY *pub = NULL; + EVP_PKEY_CTX *pctx = NULL; + int ok = 0; + + if (kem_ctx == NULL || kem_ctx->keydata == NULL || + outlen == NULL || secretlen == NULL) + return 0; + + pub = pubkey_from_params_default(kem_ctx->keydata); + if (pub == NULL) + return 0; + + pctx = EVP_PKEY_CTX_new(pub, NULL); + if (pctx == NULL) + goto end; + + if (EVP_PKEY_encapsulate_init(pctx, NULL) <= 0) + goto end; + + /* EVP_PKEY_encapsulate() also handles the length query when + * out and secret are NULL. */ + if (EVP_PKEY_encapsulate(pctx, out, outlen, secret, secretlen) <= 0) + goto end; + + ok = 1; + +end: + EVP_PKEY_CTX_free(pctx); + EVP_PKEY_free(pub); + return ok; +} + +/* Return EVP_PKEY associated with asymmetric KEM context. */ +EVP_PKEY *p11_kem_ctx_get_evp_pkey(const P11_KEM_CTX *kem_ctx) +{ + if (kem_ctx == NULL) + return NULL; + + return p11_keydata_get_evp_pkey(kem_ctx->keydata); +} + +/* Return the local key type. */ +int p11_kem_ctx_get_type(const P11_KEM_CTX *kem_ctx) +{ + if (kem_ctx == NULL) + return 0; + + return p11_keydata_get_type(kem_ctx->keydata); +} + +/* Return the shared-secret size for an asymmetric KEM operation. */ +size_t p11_kem_ctx_get_secret_size(const P11_KEM_CTX *kem_ctx) +{ + int type; + + if (kem_ctx == NULL || kem_ctx->keydata == NULL) + return 0; + + type = p11_keydata_get_type(kem_ctx->keydata); + + switch (type) { +#if !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L + case EVP_PKEY_ML_KEM_512: + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: + return ML_KEM_SHARED_SECRET_BYTES; +#endif /* !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L */ + default: + return 0; + } +} + /******************************************************************************/ /* Internal helper functions */ /******************************************************************************/ @@ -2313,6 +2533,11 @@ static OSSL_PARAM *public_params_from_evp_pkey(EVP_PKEY *pkey) case EVP_PKEY_ML_DSA_65: case EVP_PKEY_ML_DSA_87: #endif +#ifndef OPENSSL_NO_ML_KEM + case EVP_PKEY_ML_KEM_512: + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: +#endif /* OPENSSL_NO_ML_KEM */ #ifndef OPENSSL_NO_SLH_DSA case EVP_PKEY_SLH_DSA_SHA2_128S: case EVP_PKEY_SLH_DSA_SHA2_128F: @@ -2403,6 +2628,13 @@ static int p11_keydata_init_from_params(EVP_PKEY *pkey, P11_KEYDATA *keydata) return p11_keydata_init_mldsa_from_params(keydata, type); #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM + case EVP_PKEY_ML_KEM_512: + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: + return p11_keydata_init_mlkem_from_params(keydata, type); +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA case EVP_PKEY_SLH_DSA_SHA2_128S: case EVP_PKEY_SLH_DSA_SHA2_128F: @@ -2627,6 +2859,61 @@ static int p11_keydata_init_mldsa_from_params(P11_KEYDATA *keydata, int type) } #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM +static int p11_keydata_init_mlkem_from_params(P11_KEYDATA *keydata, int type) +{ + const OSSL_PARAM *p; + const char *name = NULL; + size_t keysize = 0; + size_t ciphertext_size = 0; + + switch (type) { + case NID_ML_KEM_512: + name = "ML-KEM-512"; + keysize = ML_KEM_512_PUBLIC_KEY_BYTES; + ciphertext_size = ML_KEM_512_CIPHERTEXT_BYTES; + break; + case NID_ML_KEM_768: + name = "ML-KEM-768"; + keysize = ML_KEM_768_PUBLIC_KEY_BYTES; + ciphertext_size = ML_KEM_768_CIPHERTEXT_BYTES; + break; + case NID_ML_KEM_1024: + name = "ML-KEM-1024"; + keysize = ML_KEM_1024_PUBLIC_KEY_BYTES; + ciphertext_size = ML_KEM_1024_CIPHERTEXT_BYTES; + break; + default: + return 0; + } + + /* + * OSSL_PKEY_PARAM_PUB_KEY is normally returned by + * EVP_PKEY_todata(). Accept ENCODED_PUBLIC_KEY as a fallback; + * both contain the complete FIPS 203 encapsulation key ek. + */ + p = OSSL_PARAM_locate_const(keydata->params, OSSL_PKEY_PARAM_PUB_KEY); + if (p == NULL) { + p = OSSL_PARAM_locate_const(keydata->params, + OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY); + } + + if (p == NULL || p->data_type != OSSL_PARAM_OCTET_STRING || + p->data == NULL || p->data_size != keysize) + return 0; + + if (!p11_dup_param_blob(p, &keydata->pubdata.raw.pub, + &keydata->pubdata.raw.pub_len)) + return 0; + + keydata->type = type; + keydata->name = name; + keydata->keysize = keysize; + keydata->maxsize = ciphertext_size; + return 1; +} +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA static int p11_keydata_init_slhdsa_from_params(P11_KEYDATA *keydata, int type) { @@ -3062,6 +3349,15 @@ static int evp_pkey_get_type_id(const EVP_PKEY *pkey) return EVP_PKEY_ML_DSA_87; #endif /* OPENSSL_NO_ML_DSA */ +#ifndef OPENSSL_NO_ML_KEM + if (EVP_PKEY_is_a(pkey, "ML-KEM-512")) + return EVP_PKEY_ML_KEM_512; + if (EVP_PKEY_is_a(pkey, "ML-KEM-768")) + return EVP_PKEY_ML_KEM_768; + if (EVP_PKEY_is_a(pkey, "ML-KEM-1024")) + return EVP_PKEY_ML_KEM_1024; +#endif /* OPENSSL_NO_ML_KEM */ + #ifndef OPENSSL_NO_SLH_DSA if (EVP_PKEY_is_a(pkey, "SLH-DSA-SHA2-128s")) return EVP_PKEY_SLH_DSA_SHA2_128S; diff --git a/src/provider_helpers.h b/src/provider_helpers.h index 19268513..a960d11c 100644 --- a/src/provider_helpers.h +++ b/src/provider_helpers.h @@ -52,6 +52,7 @@ typedef struct p11_keydata_st P11_KEYDATA; typedef struct p11_signature_ctx P11_SIGNATURE_CTX; typedef struct p11_asym_cipher_ctx P11_ASYM_CIPHER_CTX; typedef struct p11_keyexch_ctx P11_KEYEXCH_CTX; +typedef struct p11_kem_ctx P11_KEM_CTX; /******************************************************************************/ /* PROVIDER interface helpers */ @@ -135,6 +136,8 @@ EVP_MD_CTX *p11_signature_ctx_get_mdctx(P11_SIGNATURE_CTX *sig_ctx); const char *p11_signature_pss_saltlen_to_string(int saltlen); const char *p11_pad_mode_to_string(int pad_mode); int is_oneshot_sig_type(int type); +int has_raw_public_key(int type); +int has_encoded_public_key(int type); /******************************************************************************/ @@ -168,6 +171,7 @@ int p11_asym_cipher_ctx_set_oaep_label(P11_ASYM_CIPHER_CTX *asym_ctx, unsigned char *p11_asym_cipher_ctx_get_oaep_label(const P11_ASYM_CIPHER_CTX *asym_ctx); size_t p11_asym_cipher_ctx_get_oaep_labellen(const P11_ASYM_CIPHER_CTX *asym_ctx); + /******************************************************************************/ /* KEY EXCHANGE helper functions */ /******************************************************************************/ @@ -185,6 +189,20 @@ int p11_keyexch_ctx_get_peer_pub(const P11_KEYEXCH_CTX *keyexch_ctx, int p11_keyexch_ctx_get_type(const P11_KEYEXCH_CTX *keyexch_ctx); size_t p11_keyexch_ctx_get_outsize(const P11_KEYEXCH_CTX *keyexch_ctx); + +/******************************************************************************/ +/* ASYM KEM helper functions */ +/******************************************************************************/ +P11_KEM_CTX *p11_kem_ctx_new(PROVIDER_CTX *ctx); +void p11_kem_ctx_free(P11_KEM_CTX *kem_ctx); +P11_KEM_CTX *p11_kem_ctx_dupctx(P11_KEM_CTX *kem_ctx); +int p11_kem_ctx_init(P11_KEM_CTX *kem_ctx, P11_KEYDATA *keydata, const OSSL_PARAM params[]); +int p11_kem_ctx_encapsulate(P11_KEM_CTX *kem_ctx, unsigned char *out, + size_t *outlen, unsigned char *secret, size_t *secretlen); +EVP_PKEY *p11_kem_ctx_get_evp_pkey(const P11_KEM_CTX *kem_ctx); +int p11_kem_ctx_get_type(const P11_KEM_CTX *kem_ctx); +size_t p11_kem_ctx_get_secret_size(const P11_KEM_CTX *kem_ctx); + #endif /* _PROVIDER_HELPERS_H */ /* vim: set noexpandtab: */ diff --git a/tests/Makefile.am b/tests/Makefile.am index c6a6e514..564a38fc 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -34,7 +34,8 @@ check_PROGRAMS = \ ed448-keygen \ ed25519-keygen-prov \ ed448-keygen-prov \ - mldsa87-keygen-prov + mldsa87-keygen-prov \ + mlkem768-keygen-prov dist_check_SCRIPTS = \ rsa-testpkcs11.softhsm \ rsa-testfork.softhsm \ @@ -78,6 +79,8 @@ dist_check_SCRIPTS = \ provider-mldsa87-check-privkey.softhsm \ provider-mldsa87-keygen.softhsm \ provider-mldsa87-copy.softhsm \ + provider-mlkem768-keygen.softhsm \ + provider-mlkem768-copy.softhsm \ provider-fork-change-slot.softhsm \ provider-case-insensitive.softhsm \ provider-pkcs11-uri-without-token.softhsm \ @@ -87,13 +90,15 @@ dist_check_DATA = \ ec-cert.der ec-privkey.der ec-pubkey.der \ ed25519-cert.der ed25519-privkey.der ed25519-pubkey.der \ ed448-cert.der ed448-privkey.der ed448-pubkey.der \ - mldsa87-cert.der mldsa87-privkey.der mldsa87-pubkey.der + mldsa87-cert.der mldsa87-privkey.der mldsa87-pubkey.der \ + mlkem768-privkey.der mlkem768-pubkey.der ed25519_keygen_SOURCES = ed25519-keygen.c oneshot_common.c ed448_keygen_SOURCES = ed448-keygen.c oneshot_common.c ed25519_keygen_prov_SOURCES = ed25519-keygen-prov.c helpers_prov.c oneshot_common.c ed448_keygen_prov_SOURCES = ed448-keygen-prov.c helpers_prov.c oneshot_common.c mldsa87_keygen_prov_SOURCES = mldsa87-keygen-prov.c helpers_prov.c oneshot_common.c +mlkem768_keygen_prov_SOURCES = mlkem768-keygen-prov.c helpers_prov.c evp_sign_prov_SOURCES = evp-sign-prov.c helpers_prov.c fork_change_slot_prov_SOURCES = fork-change-slot-prov.c helpers_prov.c dup_key_prov_SOURCES = dup-key-prov.c helpers_prov.c diff --git a/tests/mlkem768-keygen-prov.c b/tests/mlkem768-keygen-prov.c new file mode 100644 index 00000000..bf4da4aa --- /dev/null +++ b/tests/mlkem768-keygen-prov.c @@ -0,0 +1,372 @@ +/* + * Copyright © 2026 Mobi - Com Polska Sp. z o.o. + * Author: Małgorzata Olszówka + * All rights reserved. + * + * PKCS#11 provider test + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include "helpers_prov.h" +#include "oneshot_common.h" + +#if !defined(OPENSSL_NO_ML_KEM) && OPENSSL_VERSION_NUMBER >= 0x30500000L + +#include + +#define EVP_PKEY_ML_KEM_768 NID_ML_KEM_768 + +static void error_queue(const char *name) +{ + if (ERR_peek_last_error()) { + fprintf(stderr, "%s generated errors:\n", name); + ERR_print_errors_fp(stderr); + } +} + +static void print_hex(const char *name, const unsigned char *data, size_t len) +{ + size_t i; + + fprintf(stderr, "%s (%zu bytes): ", name, len); + for (i = 0; i < len; i++) + fprintf(stderr, "%02x", data[i]); + fprintf(stderr, "\n"); +} + +/* Test ML-KEM encapsulation and decapsulation. */ +static int mlkem_test(EVP_PKEY *private_key, EVP_PKEY *public_key) +{ + EVP_PKEY_CTX *pkey_ctx = NULL; + unsigned char *ciphertext = NULL; + unsigned char *secret = NULL; + unsigned char *dec_secret = NULL; + size_t ciphertext_len = 0; + size_t secret_len = 0; + size_t dec_secret_len = 0; + size_t ciphertext_size = 0; + size_t secret_size = 0; + size_t dec_secret_size = 0; + int ret = 0; + + if (private_key == NULL || public_key == NULL) + goto cleanup; + + if (!EVP_PKEY_is_a(private_key, "ML-KEM-768") || + !EVP_PKEY_is_a(public_key, "ML-KEM-768")) { + fprintf(stderr, "Keys are not ML-KEM-768 keys\n"); + goto cleanup; + } + + /* Encapsulate using the public key. */ + pkey_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, public_key, NULL); + if (pkey_ctx == NULL) { + fprintf(stderr, "Could not create encapsulation context\n"); + display_openssl_errors(); + goto cleanup; + } + + if (EVP_PKEY_encapsulate_init(pkey_ctx, NULL) <= 0) { + fprintf(stderr, "Could not initialize encapsulation\n"); + display_openssl_errors(); + goto cleanup; + } + + /* Query ciphertext and shared-secret sizes. */ + if (EVP_PKEY_encapsulate(pkey_ctx, NULL, &ciphertext_len, + NULL, &secret_len) <= 0) { + fprintf(stderr, "Could not query encapsulation output sizes\n"); + display_openssl_errors(); + goto cleanup; + } + + if (ciphertext_len == 0 || secret_len == 0) { + fprintf(stderr, "Invalid encapsulation output sizes\n"); + goto cleanup; + } + + ciphertext_size = ciphertext_len; + secret_size = secret_len; + + ciphertext = OPENSSL_malloc(ciphertext_size); + secret = OPENSSL_malloc(secret_size); + if (ciphertext == NULL || secret == NULL) { + fprintf(stderr, "Memory allocation failed\n"); + goto cleanup; + } + + if (EVP_PKEY_encapsulate(pkey_ctx, ciphertext, &ciphertext_len, + secret, &secret_len) <= 0) { + fprintf(stderr, "Encapsulation failed\n"); + display_openssl_errors(); + goto cleanup; + } + + printf("Shared secret encapsulated.\n"); + + EVP_PKEY_CTX_free(pkey_ctx); + pkey_ctx = NULL; + + /* + * Decapsulate using the private key. + */ + pkey_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, private_key, NULL); + if (pkey_ctx == NULL) { + fprintf(stderr, "Could not create decapsulation context\n"); + display_openssl_errors(); + goto cleanup; + } + + if (EVP_PKEY_decapsulate_init(pkey_ctx, NULL) <= 0) { + fprintf(stderr, "Could not initialize decapsulation\n"); + display_openssl_errors(); + goto cleanup; + } + + /* Query the recovered shared-secret size. */ + if (EVP_PKEY_decapsulate(pkey_ctx, NULL, &dec_secret_len, + ciphertext, ciphertext_len) <= 0) { + fprintf(stderr, "Could not query decapsulation output size\n"); + display_openssl_errors(); + goto cleanup; + } + + if (dec_secret_len == 0) { + fprintf(stderr, "Invalid decapsulation output size\n"); + goto cleanup; + } + + dec_secret_size = dec_secret_len; + dec_secret = OPENSSL_malloc(dec_secret_size); + if (dec_secret == NULL) { + fprintf(stderr, "Memory allocation failed\n"); + goto cleanup; + } + + if (EVP_PKEY_decapsulate(pkey_ctx, dec_secret, &dec_secret_len, + ciphertext, ciphertext_len) <= 0) { + fprintf(stderr, "Decapsulation failed\n"); + display_openssl_errors(); + goto cleanup; + } + + if (secret_len != dec_secret_len || + CRYPTO_memcmp(secret, dec_secret, secret_len) != 0) { + fprintf(stderr, "Decapsulated secret does not match the encapsulated secret\n"); + print_hex("Encapsulated secret", secret, secret_len); + print_hex("Decapsulated secret", dec_secret, dec_secret_len); + goto cleanup; + } + + printf("ML-KEM-768 encapsulation/decapsulation successful.\n"); + ret = 1; + +cleanup: + EVP_PKEY_CTX_free(pkey_ctx); + OPENSSL_free(ciphertext); + OPENSSL_clear_free(secret, secret_size); + OPENSSL_clear_free(dec_secret, dec_secret_size); + return ret; +} + +int main(int argc, char *argv[]) +{ + int ret = EXIT_FAILURE; + int rc; + int len; + PKCS11_CTX *ctx = NULL; + PKCS11_SLOT *slots = NULL; + PKCS11_SLOT *slot; + unsigned int nslots = 0; + EVP_PKEY *private_key = NULL; + EVP_PKEY *public_key = NULL; + PKCS11_NID_KGEN mlkem = { + .nid = NID_ML_KEM_768 + }; + PKCS11_params params = { + .sensitive = 1, + .extractable = 0, + }; + PKCS11_KGEN_ATTRS mlkem_kg = { + .type = EVP_PKEY_ML_KEM_768, + .kgen.nid = &mlkem, + .token_label = NULL, + .key_label = NULL, + .key_id = (const unsigned char *)"\x22\x33", + .id_len = 2, + .key_params = ¶ms, + }; + char private_uri[1024]; + char public_uri[1024]; + + if (argc < 5) { + fprintf(stderr, + "usage: %s [MODULE] [TOKEN] [KEY-LABEL] [PIN]\n", + argv[0]); + goto cleanup; + } + + mlkem_kg.token_label = argv[2]; + mlkem_kg.key_label = argv[3]; + + len = snprintf(private_uri, sizeof(private_uri), + "pkcs11:token=%s;object=%s;type=private;pin-value=%s", + argv[2], argv[3], argv[4]); + if (len < 0 || (size_t)len >= sizeof(private_uri)) { + fprintf(stderr, "Private key URI is too long\n"); + goto cleanup; + } + + len = snprintf(public_uri, sizeof(public_uri), + "pkcs11:token=%s;object=%s;type=public", + argv[2], argv[3]); + if (len < 0 || (size_t)len >= sizeof(public_uri)) { + fprintf(stderr, "Public key URI is too long\n"); + goto cleanup; + } + + ctx = PKCS11_CTX_new(); + error_queue("PKCS11_CTX_new"); + CHECK_ERR(ctx == NULL, "PKCS11_CTX_new failed", 3); + + /* Load the PKCS#11 module. */ + rc = PKCS11_CTX_load(ctx, argv[1]); + error_queue("PKCS11_CTX_load"); + CHECK_ERR(rc < 0, "loading PKCS#11 module failed", 4); + + /* Get information on all slots. */ + rc = PKCS11_enumerate_slots(ctx, &slots, &nslots); + error_queue("PKCS11_enumerate_slots"); + CHECK_ERR(rc < 0, "no slots available", 5); + + slot = PKCS11_find_token(ctx, slots, nslots); + error_queue("PKCS11_find_token"); + + while (slot != NULL) { + if (slot->token != NULL && + slot->token->initialized && + slot->token->label != NULL && + strcmp(argv[2], slot->token->label) == 0) + break; + + slot = PKCS11_find_next_token(ctx, slots, nslots, slot); + } + + CHECK_ERR(slot == NULL || slot->token == NULL, + "no token available", 6); + + printf("Found token:\n"); + printf("Slot manufacturer......: %s\n", slot->manufacturer); + printf("Slot description.......: %s\n", slot->description); + printf("Slot token label.......: %s\n", slot->token->label); + printf("Slot token serialnr....: %s\n", slot->token->serialnr); + + rc = PKCS11_login(slot, 0, argv[4]); + error_queue("PKCS11_login"); + CHECK_ERR(rc < 0, "PKCS11_login failed", 7); + + /* + * ML-KEM key generation test. + */ + rc = PKCS11_keygen(slot->token, &mlkem_kg); + error_queue("PKCS11_keygen"); + CHECK_ERR(rc < 0, "Failed to generate a key pair on the token", 8); + + printf("ML-KEM-768 keys generated\n"); + + /* + * Release libp11 resources before initializing pkcs11prov. + */ + PKCS11_release_all_slots(ctx, slots, nslots); + slots = NULL; + nslots = 0; + + PKCS11_CTX_unload(ctx); + PKCS11_CTX_free(ctx); + ctx = NULL; + + /* Load pkcs11prov and default providers. */ + if (!providers_load()) { + display_openssl_errors(); + goto cleanup; + } + + /* Load the generated private key. */ + private_key = load_pkey(private_uri, "provider=pkcs11prov", NULL); + if (private_key == NULL) { + fprintf(stderr, "Cannot load private key: %s\n", private_uri); + display_openssl_errors(); + goto cleanup; + } + + printf("Private key found.\n"); + + /* Load the generated public key. */ + public_key = load_pubkey(public_uri, "provider=pkcs11prov"); + if (public_key == NULL) { + fprintf(stderr, "Cannot load public key: %s\n", public_uri); + display_openssl_errors(); + goto cleanup; + } + + printf("Public key found.\n"); + + if (!mlkem_test(private_key, public_key)) + goto cleanup; + + ret = EXIT_SUCCESS; + +cleanup: + EVP_PKEY_free(private_key); + EVP_PKEY_free(public_key); + + if (slots != NULL) + PKCS11_release_all_slots(ctx, slots, nslots); + + if (ctx != NULL) { + PKCS11_CTX_unload(ctx); + PKCS11_CTX_free(ctx); + } + + providers_cleanup(); + + printf("\n"); + return ret; +} + +#else /* !defined(OPENSSL_NO_ML_KEM) && + OPENSSL_VERSION_NUMBER >= 0x30500000L */ + +#include + +int main(void) +{ + fprintf(stderr, + "Skipped: requires OpenSSL >= 3.5 built with ML-KEM support\n"); + return 77; +} + +#endif /* !defined(OPENSSL_NO_ML_KEM) && + OPENSSL_VERSION_NUMBER >= 0x30500000L */ + +/* vim: set noexpandtab: */ diff --git a/tests/mlkem768-privkey.der b/tests/mlkem768-privkey.der new file mode 100644 index 00000000..49458fee --- /dev/null +++ b/tests/mlkem768-privkey.der @@ -0,0 +1,55 @@ +-----BEGIN PRIVATE KEY----- +MIIJvgIBADALBglghkgBZQMEBAIEggmqMIIJpgRA9EAaf3qDgZGV0zsN2VY2MQL3 +h4xDClHw8H/SX91O3TkGQ7AeoGjJvEwG4y7pAZODZjxkkruaMrO/R/CmTm30FQSC +CWAOy6m3N8DOkiMeBrwLcxD4OJO5WR1lbEwU2J7616iVuU/ZNlwbSnMhyj2yu527 +bELFO4iYeHxMtnmpKZSDQbitRzGlqlLMp53WuoSZtITICQ7Z/HFOvMSwNsYyUF3L +oj//i8VpjHvGCKPWVzpIp2QQ3CTnDJRuNIbLwUl2CZK0UrtlaJAzMW/z0gtJsr0F +VBly8RL66iHB4hMIsZdTsUXXMqQ7pb0kMk64YxL5KlNSKT5BEMPbJzF0NsT9rFAh +YmfTJ35fI3oJ+6+YNLnxGBKaFlPeyZyXA5h48qygsIdbcKGhczWzVLQ5Jcch4JLG +olKOkUVnRJwS2kIAqVR4k4AzFowNYDmyxjmLJjbtOHMQJHmaFEItK2X4Sq+JzHfB +QHQkKMW3ZrVpVZ/xOk7IJYwRWxlP5CSshbIdqZcJWy0glhlC54a/N4IQswkUwo8x +K7slwX1C6Hexma+eWL7WRSaxlnTmUyMv2kGZm31NORQixRDDeLpryFGaJkHS9lqL +fAmisZQ8wzzVSCGH+kpZlHroOB1RCnWiwILdGLAsAkmEOwSw2wpkYqJksBmZIYR/ +qVeKUEaEDEQIuVPxLFiAhA1tZMLiZzMJmIfKAnNQaBLfR3sCk1XM1YgkEj3pgEPx +5yqhyz5WkwAmdj/CsUTxWbP3Mr1b25t2VwYvnGaaEkUKezNzMUv9k3bN53CupR9p +A64hlA3+BFGX4VYItM+2dQkmYqrQk838mghquFkw8RI7Mh0dc4sqTCeHPKZrewT8 +w4n8Jx2bWnLHXF6xox1hMVzx0DI3FS+/uatHRBaKJJ2/kIluwBdlaBOYphcxaCr6 +55qhwkxHmqSFFqZe+L1HyKhTogfFWA+xxgpLRVUSp1d85UaTgDgLxmV+5WmVxS1N +XAul4bi+6gFtdDKx/KnlYMRF1Bo1l2vhCs1BA5wvgYd4eGOaZ2LEZ5UsF8DppU1d +Oc0iYb/foqWYorZdqm4ElYI5Z6lq4JK1xXequXGVJVrmxlPsKcGf4ECgeE6SNmiC +2E0bm6Pfh2QXAy1lurEoi4BKAsLzwrPWESQYZSGsnCmkAQhQcrgbRolCta7qecAx +gREpy3Nmc2mdJCh3RlJAwHZjSmv2FcCCkxKt0qb7oMLkPG8HyQ1d+jttyVqykjnZ +4KhYSXKVc7+Ks4wZS7Bh7LWQlZheSLJ5uwpAczvpN43rZIgcaIRHcyQC13OGTFUU +4cjxkxMs2aQFa5IHKjQGJWL3loGp+3KWYnCi9F6v1ZC7aMU1S5trFKPG0ESPCTOI +R2t1iS2TUAbL83NvARYd4MSxoYPJtQ7aGq3St0Zd9MQ22A3D9Yh/Yz46O5k1EQ7I +lp85wSFD1l9S9SaDkcZyMorIYU8GOHSJWj5UdCph6qbzx1Bxon9W4EFg1FvhNhgq +t3PShMikK2ivoCp2p0LMarW3CGqp15TFtbTuOQxH1sFXym7VHDIqWIO3vBBRrMTG +kI08XFgSasZMCQJvG4TCqJaQZoR7DG6wlcbLkHu5jFkhF1bFgH9ytCMhwkB2ss98 +YcH0QE5fuJDCAZPbtxcvphbzskqOlYs7KTJkA6h1qHM4TCcuFXZNlAQuzFzNaV/d +Nz83ylvW0HVkyBx+/FBgA8vWsByFm6FO3G+CqLqEdoimx2upMi8oWpEfyoHC4nCT +8oU6fBhUCctoCR4JA0F/FM1FpRE2obz0FYhj4oHd1WqZE5sPSAmJ0IOpOpAOB3Yi +tRcYdqzYcarK5GJJd7fIGgD7zM44QZy5YgArdaWFa6H8WGSTLFiI1Dxw6ookSB1m +1AKku2JmTBEft4PYmhqFtXBaqC3CsiiK+ZLVKcbdtnl0MrCFlYduNlqwoMSNlkG0 +Km4Vyn5d6kul4EZj9BPA6VsQ+p8EAr8FqsHsEqymwDHGYBnha1vHaUTFIiRIBV/3 +VXP2msC3VAGFIoCbi3ZTyg9WNDzqODUBArnYIhPleSSYXIU+o0ti0pZj8xV7iFi9 +vEbMDKjulV6mcgEsQCZQ/DKhzEYiSnAO445yeS5vc4owlwr4VK4Jdx8MchrMV7ev +yTVmWmFoKwVX6luRoVkmwKlNaot/EkfT61sHsT1QCwCcMSxJfJnScgTP1XdA92yy +cBiBbDafV5pVRpHwPBicNVHYeUD5x0pwInHXtZR10SFvYo/euwZg9aFm3DccNhBs +ZQafuAS8jDcMvMePqVB5UAVVjEKFNEya2FCqaAy4NgIbgplbuU5gp3ClQFYNGFDk +tmCrd6YX8oFbMB6JwDKUvClGQwKRFGTnY0WfkZtro82Jm1Yv038DoX/bYRbHk7YC +WEhLlhC+6pGFhAG24C849kNBLEYyGk85TB+Gd2EGuZHGVzhbLL2O9BqHc1etjBA0 +aqthdxMCWcRmV5F7SQFHsmZDuZu4Bq4IJXNV2kbUgwqmkx1qu84nssaNuHw0sS6b +mr+ivHj7m6tkxQs8uSVKAXVTYivVBDqru5nA10xnVcpjF1Q3WRJUQmZRO3QwV4Ou +1FO7Z7Y/5WT95H4kxjL6OYu2mbCBjDjokADmeKk7NSnM2FOsxGoIJQYyGFbF+oxA +YZoCFG/0Ikg/mrxBC0NtZJSYglBnR68FKpmztp8ilSOS5LY1ib9jG69YDHYQe1XQ +YHdXO7IRpZQzxiX5gJEaW7WSKWiKq03RSBSpCzKBrGh9EYx/US00hprD9o67aK2K +ZXP0YCMKJ7MNYDT/Z3rDgRs5NW/u03a3iaVFSWsIlIKYZ3Dm3HG1MXfSyn98ITkz +YLFNZJkVM2b86TMDIpBSFw0HQi5g4Au1NG4O7D0Rci2L6ih8yLq1MjeeihT/ASB2 +mD0HEqoPRqL2ixQ8ZEregzsq2nz/BnliSSDDdgrLAKGYaJF3AWmcciXk9Vs+caBt +IoUL9LveuqnPwjvAsMf1KaaAgss9vLVdNpWMOY+Y63YFlmAcaACJOqVCoHAaSXms +OWdarI94EmIt+zLIVAvsrFYlB62nUXSiFx1CtAbBtmtXSHF+6IVC66y0cqSrsofB +lo7mNHlC1KyNBUgYWBt6ZVN6BsU/2XhGfHGVNMxSdAir0h79S79sKJtLCUkG2bfg +5KcDsIP8hjG2bnJpTMwkb1LYjh/a/ssEIzPRDEWxm/r+cNT5KuHDOYZCV4KwlktO +T+/WI9+JioOK92u6kuuI91QkBkOwHqBoybxMBuMu6QGTg2Y8ZJK7mjKzv0fwpk5t +9BU= +-----END PRIVATE KEY----- diff --git a/tests/mlkem768-pubkey.der b/tests/mlkem768-pubkey.der new file mode 100644 index 00000000..eec22a13 --- /dev/null +++ b/tests/mlkem768-pubkey.der @@ -0,0 +1,28 @@ +-----BEGIN PUBLIC KEY----- +MIIEsjALBglghkgBZQMEBAIDggShAPRATl+4kMIBk9u3Fy+mFvOySo6VizspMmQD +qHWoczhMJy4Vdk2UBC7MXM1pX903PzfKW9bQdWTIHH78UGADy9awHIWboU7cb4Ko +uoR2iKbHa6kyLyhakR/KgcLicJPyhTp8GFQJy2gJHgkDQX8UzUWlETahvPQViGPi +gd3VapkTmw9ICYnQg6k6kA4HdiK1Fxh2rNhxqsrkYkl3t8gaAPvMzjhBnLliACt1 +pYVrofxYZJMsWIjUPHDqiiRIHWbUAqS7YmZMER+3g9iaGoW1cFqoLcKyKIr5ktUp +xt22eXQysIWVh242WrCgxI2WQbQqbhXKfl3qS6XgRmP0E8DpWxD6nwQCvwWqwewS +rKbAMcZgGeFrW8dpRMUiJEgFX/dVc/aawLdUAYUigJuLdlPKD1Y0POo4NQECudgi +E+V5JJhchT6jS2LSlmPzFXuIWL28RswMqO6VXqZyASxAJlD8MqHMRiJKcA7jjnJ5 +Lm9zijCXCvhUrgl3HwxyGsxXt6/JNWZaYWgrBVfqW5GhWSbAqU1qi38SR9PrWwex +PVALAJwxLEl8mdJyBM/Vd0D3bLJwGIFsNp9XmlVGkfA8GJw1Udh5QPnHSnAicde1 +lHXRIW9ij967BmD1oWbcNxw2EGxlBp+4BLyMNwy8x4+pUHlQBVWMQoU0TJrYUKpo +DLg2AhuCmVu5TmCncKVAVg0YUOS2YKt3phfygVswHonAMpS8KUZDApEUZOdjRZ+R +m2ujzYmbVi/TfwOhf9thFseTtgJYSEuWEL7qkYWEAbbgLzj2Q0EsRjIaTzlMH4Z3 +YQa5kcZXOFssvY70GodzV62MEDRqq2F3EwJZxGZXkXtJAUeyZkO5m7gGrgglc1Xa +RtSDCqaTHWq7zieyxo24fDSxLpuav6K8ePubq2TFCzy5JUoBdVNiK9UEOqu7mcDX +TGdVymMXVDdZElRCZlE7dDBXg67UU7tntj/lZP3kfiTGMvo5i7aZsIGMOOiQAOZ4 +qTs1KczYU6zEagglBjIYVsX6jEBhmgIUb/QiSD+avEELQ21klJiCUGdHrwUqmbO2 +nyKVI5LktjWJv2Mbr1gMdhB7VdBgd1c7shGllDPGJfmAkRpbtZIpaIqrTdFIFKkL +MoGsaH0RjH9RLTSGmsP2jrtorYplc/RgIwonsw1gNP9nesOBGzk1b+7TdreJpUVJ +awiUgphncObccbUxd9LKf3whOTNgsU1kmRUzZvzpMwMikFIXDQdCLmDgC7U0bg7s +PRFyLYvqKHzIurUyN56KFP8BIHaYPQcSqg9GovaLFDxkSt6DOyrafP8GeWJJIMN2 +CssAoZhokXcBaZxyJeT1Wz5xoG0ihQv0u966qc/CO8Cwx/UppoCCyz28tV02lYw5 +j5jrdgWWYBxoAIk6pUKgcBpJeaw5Z1qsj3gSYi37MshUC+ysViUHradRdKIXHUK0 +BsG2a1dIcX7ohULrrLRypKuyh8GWjuY0eULUrI0FSBhYG3plU3oGxT/ZeEZ8cZU0 +zFJ0CKvSHv1Lv2wom0sJSQbZt+DkpwOwg/yGMbZucmlMzCRvUtiOH9r+ywQjM9EM +RbGb+v5w +-----END PUBLIC KEY----- diff --git a/tests/provider-mlkem768-copy.softhsm b/tests/provider-mlkem768-copy.softhsm new file mode 100755 index 00000000..b9c6ec08 --- /dev/null +++ b/tests/provider-mlkem768-copy.softhsm @@ -0,0 +1,64 @@ +#!/bin/bash + +# Copyright © 2026 Mobi - Com Polska Sp. z o.o. +# Author: Małgorzata Olszówka +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see + +outdir="output.$$" + +# Load common test functions +. ${srcdir}/common.sh + +PRIVATE_KEY="pkcs11:token=libp11-0;id=%01%02%03%04;object=server-key-0;type=private;pin-value=${PIN}" + +# ML-KEM tests require both private and public key objects, as the public +# key cannot be reliably reconstructed from a PKCS#11 private key object. + +# Do the token initialization +init_token "mlkem768" "1" "libp11" ${ID} "server-key" "privkey" "pubkey" "" +if [[ $? -eq 77 ]]; then + echo "ML-KEM-768 key test skipped." + rm -rf "$outdir" + exit 77 +fi + +# Ensure the use of the locally built provider; applies after running 'pkcs11-tool' +unset OPENSSL_ENGINES +export OPENSSL_MODULES="../src/.libs/" +export PKCS11_MODULE_PATH=${MODULE} +echo "OPENSSL_MODULES=${OPENSSL_MODULES}" +echo "PKCS11_MODULE_PATH=${PKCS11_MODULE_PATH}" + +# Load openssl settings +. ${srcdir}/openssl-settings.sh + +# Restore openssl settings +trap cleanup EXIT + +# Run the test +${WRAPPER} ./dup-key-prov ${PRIVATE_KEY} +rc=$? +if [[ $rc -eq 77 ]]; then + echo "Duplicate private key test skipped." + rm -rf "$outdir" + exit 77 +elif [[ $rc -ne 0 ]]; then + echo "Duplicate private key test failed." + exit 1 +fi + +rm -rf "$outdir" + +exit 0 diff --git a/tests/provider-mlkem768-keygen.softhsm b/tests/provider-mlkem768-keygen.softhsm new file mode 100755 index 00000000..8d491f78 --- /dev/null +++ b/tests/provider-mlkem768-keygen.softhsm @@ -0,0 +1,68 @@ +#!/bin/bash + +# Copyright © 2026 Mobi - Com Polska Sp. z o.o. +# Author: Małgorzata Olszówka + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +outdir="output.$$" + +# Load common test functions +. ${srcdir}/common.sh + +# Initialize SoftHSM DB +init_db + +# Create token +init_card "token1" + +unset OPENSSL_ENGINES +export OPENSSL_MODULES="../src/.libs/" +export PKCS11_MODULE_PATH=${MODULE} +echo "OPENSSL_MODULES=${OPENSSL_MODULES}" +echo "PKCS11_MODULE_PATH=${PKCS11_MODULE_PATH}" + +# Load openssl settings +. ${srcdir}/openssl-settings.sh + +# Restore openssl settings +trap cleanup EXIT + +if ! has_mechanism ML-KEM; then + echo "ML-KEM key generation test skipped." + rm -rf "$outdir" + exit 77 +fi + +${WRAPPER} ./mlkem768-keygen-prov ${MODULE} token1 libp11-keylabel ${PIN} +rc=$? +if [[ $rc -eq 77 ]]; then + echo "ML-KEM key generation test skipped." + rm -rf "$outdir" + exit 77 +elif [[ $rc -ne 0 ]]; then + echo "ML-KEM key generation test failed." + exit 1 +fi + +echo "Checking pkcs11-tool result..." +list_objects | grep -q libp11-keylabel +if [[ $? != 0 ]]; then + echo "ML-KEM key was not properly generated." + exit 1 +fi + +rm -rf "$outdir" + +exit 0