diff --git a/module/icp/include/sys/crypto/impl.h b/module/icp/include/sys/crypto/impl.h index 0f37f3f63532..8ebc4be483ba 100644 --- a/module/icp/include/sys/crypto/impl.h +++ b/module/icp/include/sys/crypto/impl.h @@ -1,1363 +1,1359 @@ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #ifndef _SYS_CRYPTO_IMPL_H #define _SYS_CRYPTO_IMPL_H /* * Kernel Cryptographic Framework private implementation definitions. */ #include #include #include #include -#include #ifdef __cplusplus extern "C" { #endif #define KCF_MODULE "kcf" /* * Prefixes convention: structures internal to the kernel cryptographic * framework start with 'kcf_'. Exposed structure start with 'crypto_'. */ /* Provider stats. Not protected. */ typedef struct kcf_prov_stats { kstat_named_t ps_ops_total; kstat_named_t ps_ops_passed; kstat_named_t ps_ops_failed; kstat_named_t ps_ops_busy_rval; } kcf_prov_stats_t; /* Various kcf stats. Not protected. */ typedef struct kcf_stats { kstat_named_t ks_thrs_in_pool; kstat_named_t ks_idle_thrs; kstat_named_t ks_minthrs; kstat_named_t ks_maxthrs; kstat_named_t ks_swq_njobs; kstat_named_t ks_swq_maxjobs; kstat_named_t ks_taskq_threads; kstat_named_t ks_taskq_minalloc; kstat_named_t ks_taskq_maxalloc; } kcf_stats_t; /* * Keep all the information needed by the scheduler from * this provider. */ typedef struct kcf_sched_info { /* The number of operations dispatched. */ uint64_t ks_ndispatches; /* The number of operations that failed. */ uint64_t ks_nfails; /* The number of operations that returned CRYPTO_BUSY. */ uint64_t ks_nbusy_rval; /* taskq used to dispatch crypto requests */ taskq_t *ks_taskq; } kcf_sched_info_t; /* * pd_irefcnt approximates the number of inflight requests to the * provider. Though we increment this counter during registration for * other purposes, that base value is mostly same across all providers. * So, it is a good measure of the load on a provider when it is not * in a busy state. Once a provider notifies it is busy, requests * backup in the taskq. So, we use tq_nalloc in that case which gives * the number of task entries in the task queue. Note that we do not * acquire any locks here as it is not critical to get the exact number * and the lock contention may be too costly for this code path. */ #define KCF_PROV_LOAD(pd) ((pd)->pd_state != KCF_PROV_BUSY ? \ (pd)->pd_irefcnt : (pd)->pd_sched_info.ks_taskq->tq_nalloc) #define KCF_PROV_INCRSTATS(pd, error) { \ (pd)->pd_sched_info.ks_ndispatches++; \ if (error == CRYPTO_BUSY) \ (pd)->pd_sched_info.ks_nbusy_rval++; \ else if (error != CRYPTO_SUCCESS && error != CRYPTO_QUEUED) \ (pd)->pd_sched_info.ks_nfails++; \ } /* * The following two macros should be * #define KCF_OPS_CLASSSIZE (KCF_LAST_OPSCLASS - KCF_FIRST_OPSCLASS + 2) * #define KCF_MAXMECHTAB KCF_MAXCIPHER * * However, doing that would involve reorganizing the header file a bit. * When impl.h is broken up (bug# 4703218), this will be done. For now, * we hardcode these values. */ #define KCF_OPS_CLASSSIZE 8 #define KCF_MAXMECHTAB 32 /* * Valid values for the state of a provider. The order of * the elements is important. * * Routines which get a provider or the list of providers * should pick only those that are either in KCF_PROV_READY state * or in KCF_PROV_BUSY state. */ typedef enum { KCF_PROV_ALLOCATED = 1, KCF_PROV_UNVERIFIED, KCF_PROV_VERIFICATION_FAILED, /* * state < KCF_PROV_READY means the provider can not * be used at all. */ KCF_PROV_READY, KCF_PROV_BUSY, /* * state > KCF_PROV_BUSY means the provider can not * be used for new requests. */ KCF_PROV_FAILED, /* * Threads setting the following two states should do so only * if the current state < KCF_PROV_DISABLED. */ KCF_PROV_DISABLED, KCF_PROV_REMOVED, KCF_PROV_FREED } kcf_prov_state_t; #define KCF_IS_PROV_UNVERIFIED(pd) ((pd)->pd_state == KCF_PROV_UNVERIFIED) #define KCF_IS_PROV_USABLE(pd) ((pd)->pd_state == KCF_PROV_READY || \ (pd)->pd_state == KCF_PROV_BUSY) #define KCF_IS_PROV_REMOVED(pd) ((pd)->pd_state >= KCF_PROV_REMOVED) /* Internal flags valid for pd_flags field */ #define KCF_PROV_RESTRICTED 0x40000000 #define KCF_LPROV_MEMBER 0x80000000 /* is member of a logical provider */ /* * A provider descriptor structure. There is one such structure per * provider. It is allocated and initialized at registration time and * freed when the provider unregisters. * * pd_prov_type: Provider type, hardware or software * pd_sid: Session ID of the provider used by kernel clients. * This is valid only for session-oriented providers. * pd_refcnt: Reference counter to this provider descriptor * pd_irefcnt: References held by the framework internal structs * pd_lock: lock protects pd_state and pd_provider_list * pd_state: State value of the provider * pd_provider_list: Used to cross-reference logical providers and their * members. Not used for software providers. * pd_resume_cv: cv to wait for state to change from KCF_PROV_BUSY * pd_prov_handle: Provider handle specified by provider * pd_ops_vector: The ops vector specified by Provider * pd_mech_indx: Lookup table which maps a core framework mechanism * number to an index in pd_mechanisms array * pd_mechanisms: Array of mechanisms supported by the provider, specified * by the provider during registration * pd_sched_info: Scheduling information associated with the provider * pd_mech_list_count: The number of entries in pi_mechanisms, specified * by the provider during registration * pd_name: Device name or module name * pd_instance: Device instance * pd_module_id: Module ID returned by modload * pd_mctlp: Pointer to modctl structure for this provider * pd_remove_cv: cv to wait on while the provider queue drains * pd_description: Provider description string * pd_flags bitwise OR of pi_flags from crypto_provider_info_t * and other internal flags defined above. * pd_hash_limit Maximum data size that hash mechanisms of this provider * can support. * pd_kcf_prov_handle: KCF-private handle assigned by KCF * pd_prov_id: Identification # assigned by KCF to provider * pd_kstat: kstat associated with the provider * pd_ks_data: kstat data */ typedef struct kcf_provider_desc { crypto_provider_type_t pd_prov_type; crypto_session_id_t pd_sid; uint_t pd_refcnt; uint_t pd_irefcnt; kmutex_t pd_lock; kcf_prov_state_t pd_state; struct kcf_provider_list *pd_provider_list; kcondvar_t pd_resume_cv; crypto_provider_handle_t pd_prov_handle; crypto_ops_t *pd_ops_vector; ushort_t pd_mech_indx[KCF_OPS_CLASSSIZE]\ [KCF_MAXMECHTAB]; crypto_mech_info_t *pd_mechanisms; kcf_sched_info_t pd_sched_info; uint_t pd_mech_list_count; // char *pd_name; // uint_t pd_instance; // int pd_module_id; // struct modctl *pd_mctlp; kcondvar_t pd_remove_cv; char *pd_description; uint_t pd_flags; uint_t pd_hash_limit; crypto_kcf_provider_handle_t pd_kcf_prov_handle; crypto_provider_id_t pd_prov_id; kstat_t *pd_kstat; kcf_prov_stats_t pd_ks_data; } kcf_provider_desc_t; /* useful for making a list of providers */ typedef struct kcf_provider_list { struct kcf_provider_list *pl_next; struct kcf_provider_desc *pl_provider; } kcf_provider_list_t; /* atomic operations in linux implicitly form a memory barrier */ #define membar_exit() /* * If a component has a reference to a kcf_provider_desc_t, * it REFHOLD()s. A new provider descriptor which is referenced only * by the providers table has a reference counter of one. */ #define KCF_PROV_REFHOLD(desc) { \ atomic_add_32(&(desc)->pd_refcnt, 1); \ ASSERT((desc)->pd_refcnt != 0); \ } #define KCF_PROV_IREFHOLD(desc) { \ atomic_add_32(&(desc)->pd_irefcnt, 1); \ ASSERT((desc)->pd_irefcnt != 0); \ } #define KCF_PROV_IREFRELE(desc) { \ ASSERT((desc)->pd_irefcnt != 0); \ membar_exit(); \ if (atomic_add_32_nv(&(desc)->pd_irefcnt, -1) == 0) { \ cv_broadcast(&(desc)->pd_remove_cv); \ } \ } #define KCF_PROV_REFHELD(desc) ((desc)->pd_refcnt >= 1) #define KCF_PROV_REFRELE(desc) { \ ASSERT((desc)->pd_refcnt != 0); \ membar_exit(); \ if (atomic_add_32_nv(&(desc)->pd_refcnt, -1) == 0) { \ kcf_provider_zero_refcnt((desc)); \ } \ } /* list of crypto_mech_info_t valid as the second mech in a dual operation */ typedef struct crypto_mech_info_list { struct crypto_mech_info_list *ml_next; crypto_mech_type_t ml_kcf_mechid; /* KCF's id */ crypto_mech_info_t ml_mech_info; } crypto_mech_info_list_t; /* * An element in a mechanism provider descriptors chain. * The kcf_prov_mech_desc_t is duplicated in every chain the provider belongs * to. This is a small tradeoff memory vs mutex spinning time to access the * common provider field. */ typedef struct kcf_prov_mech_desc { struct kcf_mech_entry *pm_me; /* Back to the head */ struct kcf_prov_mech_desc *pm_next; /* Next in the chain */ crypto_mech_info_t pm_mech_info; /* Provider mech info */ crypto_mech_info_list_t *pm_mi_list; /* list for duals */ kcf_provider_desc_t *pm_prov_desc; /* Common desc. */ } kcf_prov_mech_desc_t; /* and the notation shortcuts ... */ #define pm_provider_type pm_prov_desc.pd_provider_type #define pm_provider_handle pm_prov_desc.pd_provider_handle #define pm_ops_vector pm_prov_desc.pd_ops_vector /* * A mechanism entry in an xxx_mech_tab[]. me_pad was deemed * to be unnecessary and removed. */ typedef struct kcf_mech_entry { crypto_mech_name_t me_name; /* mechanism name */ crypto_mech_type_t me_mechid; /* Internal id for mechanism */ kmutex_t me_mutex; /* access protection */ kcf_prov_mech_desc_t *me_hw_prov_chain; /* list of HW providers */ kcf_prov_mech_desc_t *me_sw_prov; /* SW provider */ /* * Number of HW providers in the chain. There is only one * SW provider. So, we need only a count of HW providers. */ int me_num_hwprov; /* * When a SW provider is present, this is the generation number that * ensures no objects from old SW providers are used in the new one */ uint32_t me_gen_swprov; /* * threshold for using hardware providers for this mech */ size_t me_threshold; } kcf_mech_entry_t; /* * A policy descriptor structure. It is allocated and initialized * when administrative ioctls load disabled mechanisms. * * pd_prov_type: Provider type, hardware or software * pd_name: Device name or module name. * pd_instance: Device instance. * pd_refcnt: Reference counter for this policy descriptor * pd_mutex: Protects array and count of disabled mechanisms. * pd_disabled_count: Count of disabled mechanisms. * pd_disabled_mechs: Array of disabled mechanisms. */ typedef struct kcf_policy_desc { crypto_provider_type_t pd_prov_type; char *pd_name; uint_t pd_instance; uint_t pd_refcnt; kmutex_t pd_mutex; uint_t pd_disabled_count; crypto_mech_name_t *pd_disabled_mechs; } kcf_policy_desc_t; /* * If a component has a reference to a kcf_policy_desc_t, * it REFHOLD()s. A new policy descriptor which is referenced only * by the policy table has a reference count of one. */ #define KCF_POLICY_REFHOLD(desc) { \ atomic_add_32(&(desc)->pd_refcnt, 1); \ ASSERT((desc)->pd_refcnt != 0); \ } /* * Releases a reference to a policy descriptor. When the last * reference is released, the descriptor is freed. */ #define KCF_POLICY_REFRELE(desc) { \ ASSERT((desc)->pd_refcnt != 0); \ membar_exit(); \ if (atomic_add_32_nv(&(desc)->pd_refcnt, -1) == 0) \ kcf_policy_free_desc(desc); \ } /* * This entry stores the name of a software module and its * mechanisms. The mechanisms are 'hints' that are used to * trigger loading of the module. */ typedef struct kcf_soft_conf_entry { struct kcf_soft_conf_entry *ce_next; char *ce_name; crypto_mech_name_t *ce_mechs; uint_t ce_count; } kcf_soft_conf_entry_t; extern kmutex_t soft_config_mutex; extern kcf_soft_conf_entry_t *soft_config_list; /* * Global tables. The sizes are from the predefined PKCS#11 v2.20 mechanisms, * with a margin of few extra empty entry points */ #define KCF_MAXDIGEST 16 /* Digests */ #define KCF_MAXCIPHER 64 /* Ciphers */ #define KCF_MAXMAC 40 /* Message authentication codes */ #define KCF_MAXSIGN 24 /* Sign/Verify */ #define KCF_MAXKEYOPS 116 /* Key generation and derivation */ #define KCF_MAXMISC 16 /* Others ... */ #define KCF_MAXMECHS KCF_MAXDIGEST + KCF_MAXCIPHER + KCF_MAXMAC + \ KCF_MAXSIGN + KCF_MAXKEYOPS + \ KCF_MAXMISC extern kcf_mech_entry_t kcf_digest_mechs_tab[]; extern kcf_mech_entry_t kcf_cipher_mechs_tab[]; extern kcf_mech_entry_t kcf_mac_mechs_tab[]; extern kcf_mech_entry_t kcf_sign_mechs_tab[]; extern kcf_mech_entry_t kcf_keyops_mechs_tab[]; extern kcf_mech_entry_t kcf_misc_mechs_tab[]; extern kmutex_t kcf_mech_tabs_lock; typedef enum { KCF_DIGEST_CLASS = 1, KCF_CIPHER_CLASS, KCF_MAC_CLASS, KCF_SIGN_CLASS, KCF_KEYOPS_CLASS, KCF_MISC_CLASS } kcf_ops_class_t; #define KCF_FIRST_OPSCLASS KCF_DIGEST_CLASS #define KCF_LAST_OPSCLASS KCF_MISC_CLASS /* The table of all the kcf_xxx_mech_tab[]s, indexed by kcf_ops_class */ typedef struct kcf_mech_entry_tab { int met_size; /* Size of the met_tab[] */ kcf_mech_entry_t *met_tab; /* the table */ } kcf_mech_entry_tab_t; extern kcf_mech_entry_tab_t kcf_mech_tabs_tab[]; #define KCF_MECHID(class, index) \ (((crypto_mech_type_t)(class) << 32) | (crypto_mech_type_t)(index)) #define KCF_MECH2CLASS(mech_type) ((kcf_ops_class_t)((mech_type) >> 32)) #define KCF_MECH2INDEX(mech_type) ((int)(mech_type)) #define KCF_TO_PROV_MECH_INDX(pd, mech_type) \ ((pd)->pd_mech_indx[KCF_MECH2CLASS(mech_type)] \ [KCF_MECH2INDEX(mech_type)]) #define KCF_TO_PROV_MECHINFO(pd, mech_type) \ ((pd)->pd_mechanisms[KCF_TO_PROV_MECH_INDX(pd, mech_type)]) #define KCF_TO_PROV_MECHNUM(pd, mech_type) \ (KCF_TO_PROV_MECHINFO(pd, mech_type).cm_mech_number) #define KCF_CAN_SHARE_OPSTATE(pd, mech_type) \ ((KCF_TO_PROV_MECHINFO(pd, mech_type).cm_mech_flags) & \ CRYPTO_CAN_SHARE_OPSTATE) /* ps_refcnt is protected by cm_lock in the crypto_minor structure */ typedef struct crypto_provider_session { struct crypto_provider_session *ps_next; crypto_session_id_t ps_session; kcf_provider_desc_t *ps_provider; kcf_provider_desc_t *ps_real_provider; uint_t ps_refcnt; } crypto_provider_session_t; typedef struct crypto_session_data { kmutex_t sd_lock; kcondvar_t sd_cv; uint32_t sd_flags; int sd_pre_approved_amount; crypto_ctx_t *sd_digest_ctx; crypto_ctx_t *sd_encr_ctx; crypto_ctx_t *sd_decr_ctx; crypto_ctx_t *sd_sign_ctx; crypto_ctx_t *sd_verify_ctx; crypto_ctx_t *sd_sign_recover_ctx; crypto_ctx_t *sd_verify_recover_ctx; kcf_provider_desc_t *sd_provider; void *sd_find_init_cookie; crypto_provider_session_t *sd_provider_session; } crypto_session_data_t; #define CRYPTO_SESSION_IN_USE 0x00000001 #define CRYPTO_SESSION_IS_BUSY 0x00000002 #define CRYPTO_SESSION_IS_CLOSED 0x00000004 #define KCF_MAX_PIN_LEN 1024 /* * Per-minor info. * * cm_lock protects everything in this structure except for cm_refcnt. */ typedef struct crypto_minor { uint_t cm_refcnt; kmutex_t cm_lock; kcondvar_t cm_cv; crypto_session_data_t **cm_session_table; uint_t cm_session_table_count; kcf_provider_desc_t **cm_provider_array; uint_t cm_provider_count; crypto_provider_session_t *cm_provider_session; } crypto_minor_t; /* * Return codes for internal functions */ #define KCF_SUCCESS 0x0 /* Successful call */ #define KCF_INVALID_MECH_NUMBER 0x1 /* invalid mechanism number */ #define KCF_INVALID_MECH_NAME 0x2 /* invalid mechanism name */ #define KCF_INVALID_MECH_CLASS 0x3 /* invalid mechanism class */ #define KCF_MECH_TAB_FULL 0x4 /* Need more room in the mech tabs. */ #define KCF_INVALID_INDX ((ushort_t)-1) /* * kCF internal mechanism and function group for tracking RNG providers. */ #define SUN_RANDOM "random" #define CRYPTO_FG_RANDOM 0x80000000 /* generate_random() */ /* * Wrappers for ops vectors. In the wrapper definitions below, the pd * argument always corresponds to a pointer to a provider descriptor * of type kcf_prov_desc_t. */ #define KCF_PROV_CONTROL_OPS(pd) ((pd)->pd_ops_vector->co_control_ops) #define KCF_PROV_CTX_OPS(pd) ((pd)->pd_ops_vector->co_ctx_ops) #define KCF_PROV_DIGEST_OPS(pd) ((pd)->pd_ops_vector->co_digest_ops) #define KCF_PROV_CIPHER_OPS(pd) ((pd)->pd_ops_vector->co_cipher_ops) #define KCF_PROV_MAC_OPS(pd) ((pd)->pd_ops_vector->co_mac_ops) #define KCF_PROV_SIGN_OPS(pd) ((pd)->pd_ops_vector->co_sign_ops) #define KCF_PROV_VERIFY_OPS(pd) ((pd)->pd_ops_vector->co_verify_ops) #define KCF_PROV_DUAL_OPS(pd) ((pd)->pd_ops_vector->co_dual_ops) #define KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) \ ((pd)->pd_ops_vector->co_dual_cipher_mac_ops) #define KCF_PROV_RANDOM_OPS(pd) ((pd)->pd_ops_vector->co_random_ops) #define KCF_PROV_SESSION_OPS(pd) ((pd)->pd_ops_vector->co_session_ops) #define KCF_PROV_OBJECT_OPS(pd) ((pd)->pd_ops_vector->co_object_ops) #define KCF_PROV_KEY_OPS(pd) ((pd)->pd_ops_vector->co_key_ops) #define KCF_PROV_PROVIDER_OPS(pd) ((pd)->pd_ops_vector->co_provider_ops) #define KCF_PROV_MECH_OPS(pd) ((pd)->pd_ops_vector->co_mech_ops) #define KCF_PROV_NOSTORE_KEY_OPS(pd) \ ((pd)->pd_ops_vector->co_nostore_key_ops) /* * Wrappers for crypto_control_ops(9S) entry points. */ #define KCF_PROV_STATUS(pd, status) ( \ (KCF_PROV_CONTROL_OPS(pd) && \ KCF_PROV_CONTROL_OPS(pd)->provider_status) ? \ KCF_PROV_CONTROL_OPS(pd)->provider_status( \ (pd)->pd_prov_handle, status) : \ CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_ctx_ops(9S) entry points. */ #define KCF_PROV_CREATE_CTX_TEMPLATE(pd, mech, key, template, size, req) ( \ (KCF_PROV_CTX_OPS(pd) && KCF_PROV_CTX_OPS(pd)->create_ctx_template) ? \ KCF_PROV_CTX_OPS(pd)->create_ctx_template( \ (pd)->pd_prov_handle, mech, key, template, size, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_FREE_CONTEXT(pd, ctx) ( \ (KCF_PROV_CTX_OPS(pd) && KCF_PROV_CTX_OPS(pd)->free_context) ? \ KCF_PROV_CTX_OPS(pd)->free_context(ctx) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_COPYIN_MECH(pd, umech, kmech, errorp, mode) ( \ (KCF_PROV_MECH_OPS(pd) && KCF_PROV_MECH_OPS(pd)->copyin_mechanism) ? \ KCF_PROV_MECH_OPS(pd)->copyin_mechanism( \ (pd)->pd_prov_handle, umech, kmech, errorp, mode) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_COPYOUT_MECH(pd, kmech, umech, errorp, mode) ( \ (KCF_PROV_MECH_OPS(pd) && KCF_PROV_MECH_OPS(pd)->copyout_mechanism) ? \ KCF_PROV_MECH_OPS(pd)->copyout_mechanism( \ (pd)->pd_prov_handle, kmech, umech, errorp, mode) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_FREE_MECH(pd, prov_mech) ( \ (KCF_PROV_MECH_OPS(pd) && KCF_PROV_MECH_OPS(pd)->free_mechanism) ? \ KCF_PROV_MECH_OPS(pd)->free_mechanism( \ (pd)->pd_prov_handle, prov_mech) : CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_digest_ops(9S) entry points. */ #define KCF_PROV_DIGEST_INIT(pd, ctx, mech, req) ( \ (KCF_PROV_DIGEST_OPS(pd) && KCF_PROV_DIGEST_OPS(pd)->digest_init) ? \ KCF_PROV_DIGEST_OPS(pd)->digest_init(ctx, mech, req) : \ CRYPTO_NOT_SUPPORTED) /* * The _ (underscore) in _digest is needed to avoid replacing the * function digest(). */ #define KCF_PROV_DIGEST(pd, ctx, data, _digest, req) ( \ (KCF_PROV_DIGEST_OPS(pd) && KCF_PROV_DIGEST_OPS(pd)->digest) ? \ KCF_PROV_DIGEST_OPS(pd)->digest(ctx, data, _digest, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DIGEST_UPDATE(pd, ctx, data, req) ( \ (KCF_PROV_DIGEST_OPS(pd) && KCF_PROV_DIGEST_OPS(pd)->digest_update) ? \ KCF_PROV_DIGEST_OPS(pd)->digest_update(ctx, data, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DIGEST_KEY(pd, ctx, key, req) ( \ (KCF_PROV_DIGEST_OPS(pd) && KCF_PROV_DIGEST_OPS(pd)->digest_key) ? \ KCF_PROV_DIGEST_OPS(pd)->digest_key(ctx, key, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DIGEST_FINAL(pd, ctx, digest, req) ( \ (KCF_PROV_DIGEST_OPS(pd) && KCF_PROV_DIGEST_OPS(pd)->digest_final) ? \ KCF_PROV_DIGEST_OPS(pd)->digest_final(ctx, digest, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DIGEST_ATOMIC(pd, session, mech, data, digest, req) ( \ (KCF_PROV_DIGEST_OPS(pd) && KCF_PROV_DIGEST_OPS(pd)->digest_atomic) ? \ KCF_PROV_DIGEST_OPS(pd)->digest_atomic( \ (pd)->pd_prov_handle, session, mech, data, digest, req) : \ CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_cipher_ops(9S) entry points. */ #define KCF_PROV_ENCRYPT_INIT(pd, ctx, mech, key, template, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->encrypt_init) ? \ KCF_PROV_CIPHER_OPS(pd)->encrypt_init(ctx, mech, key, template, \ req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_ENCRYPT(pd, ctx, plaintext, ciphertext, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->encrypt) ? \ KCF_PROV_CIPHER_OPS(pd)->encrypt(ctx, plaintext, ciphertext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_ENCRYPT_UPDATE(pd, ctx, plaintext, ciphertext, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->encrypt_update) ? \ KCF_PROV_CIPHER_OPS(pd)->encrypt_update(ctx, plaintext, \ ciphertext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_ENCRYPT_FINAL(pd, ctx, ciphertext, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->encrypt_final) ? \ KCF_PROV_CIPHER_OPS(pd)->encrypt_final(ctx, ciphertext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_ENCRYPT_ATOMIC(pd, session, mech, key, plaintext, ciphertext, \ template, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->encrypt_atomic) ? \ KCF_PROV_CIPHER_OPS(pd)->encrypt_atomic( \ (pd)->pd_prov_handle, session, mech, key, plaintext, ciphertext, \ template, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DECRYPT_INIT(pd, ctx, mech, key, template, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->decrypt_init) ? \ KCF_PROV_CIPHER_OPS(pd)->decrypt_init(ctx, mech, key, template, \ req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DECRYPT(pd, ctx, ciphertext, plaintext, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->decrypt) ? \ KCF_PROV_CIPHER_OPS(pd)->decrypt(ctx, ciphertext, plaintext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DECRYPT_UPDATE(pd, ctx, ciphertext, plaintext, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->decrypt_update) ? \ KCF_PROV_CIPHER_OPS(pd)->decrypt_update(ctx, ciphertext, \ plaintext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DECRYPT_FINAL(pd, ctx, plaintext, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->decrypt_final) ? \ KCF_PROV_CIPHER_OPS(pd)->decrypt_final(ctx, plaintext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DECRYPT_ATOMIC(pd, session, mech, key, ciphertext, plaintext, \ template, req) ( \ (KCF_PROV_CIPHER_OPS(pd) && KCF_PROV_CIPHER_OPS(pd)->decrypt_atomic) ? \ KCF_PROV_CIPHER_OPS(pd)->decrypt_atomic( \ (pd)->pd_prov_handle, session, mech, key, ciphertext, plaintext, \ template, req) : \ CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_mac_ops(9S) entry points. */ #define KCF_PROV_MAC_INIT(pd, ctx, mech, key, template, req) ( \ (KCF_PROV_MAC_OPS(pd) && KCF_PROV_MAC_OPS(pd)->mac_init) ? \ KCF_PROV_MAC_OPS(pd)->mac_init(ctx, mech, key, template, req) \ : CRYPTO_NOT_SUPPORTED) /* * The _ (underscore) in _mac is needed to avoid replacing the * function mac(). */ #define KCF_PROV_MAC(pd, ctx, data, _mac, req) ( \ (KCF_PROV_MAC_OPS(pd) && KCF_PROV_MAC_OPS(pd)->mac) ? \ KCF_PROV_MAC_OPS(pd)->mac(ctx, data, _mac, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_UPDATE(pd, ctx, data, req) ( \ (KCF_PROV_MAC_OPS(pd) && KCF_PROV_MAC_OPS(pd)->mac_update) ? \ KCF_PROV_MAC_OPS(pd)->mac_update(ctx, data, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_FINAL(pd, ctx, mac, req) ( \ (KCF_PROV_MAC_OPS(pd) && KCF_PROV_MAC_OPS(pd)->mac_final) ? \ KCF_PROV_MAC_OPS(pd)->mac_final(ctx, mac, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_ATOMIC(pd, session, mech, key, data, mac, template, \ req) ( \ (KCF_PROV_MAC_OPS(pd) && KCF_PROV_MAC_OPS(pd)->mac_atomic) ? \ KCF_PROV_MAC_OPS(pd)->mac_atomic( \ (pd)->pd_prov_handle, session, mech, key, data, mac, template, \ req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_VERIFY_ATOMIC(pd, session, mech, key, data, mac, \ template, req) ( \ (KCF_PROV_MAC_OPS(pd) && KCF_PROV_MAC_OPS(pd)->mac_verify_atomic) ? \ KCF_PROV_MAC_OPS(pd)->mac_verify_atomic( \ (pd)->pd_prov_handle, session, mech, key, data, mac, template, \ req) : \ CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_sign_ops(9S) entry points. */ #define KCF_PROV_SIGN_INIT(pd, ctx, mech, key, template, req) ( \ (KCF_PROV_SIGN_OPS(pd) && KCF_PROV_SIGN_OPS(pd)->sign_init) ? \ KCF_PROV_SIGN_OPS(pd)->sign_init( \ ctx, mech, key, template, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SIGN(pd, ctx, data, sig, req) ( \ (KCF_PROV_SIGN_OPS(pd) && KCF_PROV_SIGN_OPS(pd)->sign) ? \ KCF_PROV_SIGN_OPS(pd)->sign(ctx, data, sig, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SIGN_UPDATE(pd, ctx, data, req) ( \ (KCF_PROV_SIGN_OPS(pd) && KCF_PROV_SIGN_OPS(pd)->sign_update) ? \ KCF_PROV_SIGN_OPS(pd)->sign_update(ctx, data, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SIGN_FINAL(pd, ctx, sig, req) ( \ (KCF_PROV_SIGN_OPS(pd) && KCF_PROV_SIGN_OPS(pd)->sign_final) ? \ KCF_PROV_SIGN_OPS(pd)->sign_final(ctx, sig, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SIGN_ATOMIC(pd, session, mech, key, data, template, \ sig, req) ( \ (KCF_PROV_SIGN_OPS(pd) && KCF_PROV_SIGN_OPS(pd)->sign_atomic) ? \ KCF_PROV_SIGN_OPS(pd)->sign_atomic( \ (pd)->pd_prov_handle, session, mech, key, data, sig, template, \ req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SIGN_RECOVER_INIT(pd, ctx, mech, key, template, \ req) ( \ (KCF_PROV_SIGN_OPS(pd) && KCF_PROV_SIGN_OPS(pd)->sign_recover_init) ? \ KCF_PROV_SIGN_OPS(pd)->sign_recover_init(ctx, mech, key, template, \ req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SIGN_RECOVER(pd, ctx, data, sig, req) ( \ (KCF_PROV_SIGN_OPS(pd) && KCF_PROV_SIGN_OPS(pd)->sign_recover) ? \ KCF_PROV_SIGN_OPS(pd)->sign_recover(ctx, data, sig, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SIGN_RECOVER_ATOMIC(pd, session, mech, key, data, template, \ sig, req) ( \ (KCF_PROV_SIGN_OPS(pd) && \ KCF_PROV_SIGN_OPS(pd)->sign_recover_atomic) ? \ KCF_PROV_SIGN_OPS(pd)->sign_recover_atomic( \ (pd)->pd_prov_handle, session, mech, key, data, sig, template, \ req) : CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_verify_ops(9S) entry points. */ #define KCF_PROV_VERIFY_INIT(pd, ctx, mech, key, template, req) ( \ (KCF_PROV_VERIFY_OPS(pd) && KCF_PROV_VERIFY_OPS(pd)->verify_init) ? \ KCF_PROV_VERIFY_OPS(pd)->verify_init(ctx, mech, key, template, \ req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_VERIFY(pd, ctx, data, sig, req) ( \ (KCF_PROV_VERIFY_OPS(pd) && KCF_PROV_VERIFY_OPS(pd)->do_verify) ? \ KCF_PROV_VERIFY_OPS(pd)->do_verify(ctx, data, sig, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_VERIFY_UPDATE(pd, ctx, data, req) ( \ (KCF_PROV_VERIFY_OPS(pd) && KCF_PROV_VERIFY_OPS(pd)->verify_update) ? \ KCF_PROV_VERIFY_OPS(pd)->verify_update(ctx, data, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_VERIFY_FINAL(pd, ctx, sig, req) ( \ (KCF_PROV_VERIFY_OPS(pd) && KCF_PROV_VERIFY_OPS(pd)->verify_final) ? \ KCF_PROV_VERIFY_OPS(pd)->verify_final(ctx, sig, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_VERIFY_ATOMIC(pd, session, mech, key, data, template, sig, \ req) ( \ (KCF_PROV_VERIFY_OPS(pd) && KCF_PROV_VERIFY_OPS(pd)->verify_atomic) ? \ KCF_PROV_VERIFY_OPS(pd)->verify_atomic( \ (pd)->pd_prov_handle, session, mech, key, data, sig, template, \ req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_VERIFY_RECOVER_INIT(pd, ctx, mech, key, template, \ req) ( \ (KCF_PROV_VERIFY_OPS(pd) && \ KCF_PROV_VERIFY_OPS(pd)->verify_recover_init) ? \ KCF_PROV_VERIFY_OPS(pd)->verify_recover_init(ctx, mech, key, \ template, req) : CRYPTO_NOT_SUPPORTED) /* verify_recover() CSPI routine has different argument order than verify() */ #define KCF_PROV_VERIFY_RECOVER(pd, ctx, sig, data, req) ( \ (KCF_PROV_VERIFY_OPS(pd) && KCF_PROV_VERIFY_OPS(pd)->verify_recover) ? \ KCF_PROV_VERIFY_OPS(pd)->verify_recover(ctx, sig, data, req) : \ CRYPTO_NOT_SUPPORTED) /* * verify_recover_atomic() CSPI routine has different argument order * than verify_atomic(). */ #define KCF_PROV_VERIFY_RECOVER_ATOMIC(pd, session, mech, key, sig, \ template, data, req) ( \ (KCF_PROV_VERIFY_OPS(pd) && \ KCF_PROV_VERIFY_OPS(pd)->verify_recover_atomic) ? \ KCF_PROV_VERIFY_OPS(pd)->verify_recover_atomic( \ (pd)->pd_prov_handle, session, mech, key, sig, data, template, \ req) : CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_dual_ops(9S) entry points. */ #define KCF_PROV_DIGEST_ENCRYPT_UPDATE(digest_ctx, encrypt_ctx, plaintext, \ ciphertext, req) ( \ (KCF_PROV_DUAL_OPS(pd) && \ KCF_PROV_DUAL_OPS(pd)->digest_encrypt_update) ? \ KCF_PROV_DUAL_OPS(pd)->digest_encrypt_update( \ digest_ctx, encrypt_ctx, plaintext, ciphertext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DECRYPT_DIGEST_UPDATE(decrypt_ctx, digest_ctx, ciphertext, \ plaintext, req) ( \ (KCF_PROV_DUAL_OPS(pd) && \ KCF_PROV_DUAL_OPS(pd)->decrypt_digest_update) ? \ KCF_PROV_DUAL_OPS(pd)->decrypt_digest_update( \ decrypt_ctx, digest_ctx, ciphertext, plaintext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SIGN_ENCRYPT_UPDATE(sign_ctx, encrypt_ctx, plaintext, \ ciphertext, req) ( \ (KCF_PROV_DUAL_OPS(pd) && \ KCF_PROV_DUAL_OPS(pd)->sign_encrypt_update) ? \ KCF_PROV_DUAL_OPS(pd)->sign_encrypt_update( \ sign_ctx, encrypt_ctx, plaintext, ciphertext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_DECRYPT_VERIFY_UPDATE(decrypt_ctx, verify_ctx, ciphertext, \ plaintext, req) ( \ (KCF_PROV_DUAL_OPS(pd) && \ KCF_PROV_DUAL_OPS(pd)->decrypt_verify_update) ? \ KCF_PROV_DUAL_OPS(pd)->decrypt_verify_update( \ decrypt_ctx, verify_ctx, ciphertext, plaintext, req) : \ CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_dual_cipher_mac_ops(9S) entry points. */ #define KCF_PROV_ENCRYPT_MAC_INIT(pd, ctx, encr_mech, encr_key, mac_mech, \ mac_key, encr_ctx_template, mac_ctx_template, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac_init) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac_init( \ ctx, encr_mech, encr_key, mac_mech, mac_key, encr_ctx_template, \ mac_ctx_template, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_ENCRYPT_MAC(pd, ctx, plaintext, ciphertext, mac, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac( \ ctx, plaintext, ciphertext, mac, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_ENCRYPT_MAC_UPDATE(pd, ctx, plaintext, ciphertext, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac_update) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac_update( \ ctx, plaintext, ciphertext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_ENCRYPT_MAC_FINAL(pd, ctx, ciphertext, mac, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac_final) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac_final( \ ctx, ciphertext, mac, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_ENCRYPT_MAC_ATOMIC(pd, session, encr_mech, encr_key, \ mac_mech, mac_key, plaintext, ciphertext, mac, \ encr_ctx_template, mac_ctx_template, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac_atomic) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->encrypt_mac_atomic( \ (pd)->pd_prov_handle, session, encr_mech, encr_key, \ mac_mech, mac_key, plaintext, ciphertext, mac, \ encr_ctx_template, mac_ctx_template, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_DECRYPT_INIT(pd, ctx, mac_mech, mac_key, decr_mech, \ decr_key, mac_ctx_template, decr_ctx_template, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt_init) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt_init( \ ctx, mac_mech, mac_key, decr_mech, decr_key, mac_ctx_template, \ decr_ctx_template, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_DECRYPT(pd, ctx, ciphertext, mac, plaintext, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt( \ ctx, ciphertext, mac, plaintext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_DECRYPT_UPDATE(pd, ctx, ciphertext, plaintext, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt_update) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt_update( \ ctx, ciphertext, plaintext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_DECRYPT_FINAL(pd, ctx, mac, plaintext, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt_final) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt_final( \ ctx, mac, plaintext, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_DECRYPT_ATOMIC(pd, session, mac_mech, mac_key, \ decr_mech, decr_key, ciphertext, mac, plaintext, \ mac_ctx_template, decr_ctx_template, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt_atomic) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_decrypt_atomic( \ (pd)->pd_prov_handle, session, mac_mech, mac_key, \ decr_mech, decr_key, ciphertext, mac, plaintext, \ mac_ctx_template, decr_ctx_template, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_MAC_VERIFY_DECRYPT_ATOMIC(pd, session, mac_mech, mac_key, \ decr_mech, decr_key, ciphertext, mac, plaintext, \ mac_ctx_template, decr_ctx_template, req) ( \ (KCF_PROV_DUAL_CIPHER_MAC_OPS(pd) && \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_verify_decrypt_atomic \ != NULL) ? \ KCF_PROV_DUAL_CIPHER_MAC_OPS(pd)->mac_verify_decrypt_atomic( \ (pd)->pd_prov_handle, session, mac_mech, mac_key, \ decr_mech, decr_key, ciphertext, mac, plaintext, \ mac_ctx_template, decr_ctx_template, req) : \ CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_random_number_ops(9S) entry points. */ #define KCF_PROV_SEED_RANDOM(pd, session, buf, len, est, flags, req) ( \ (KCF_PROV_RANDOM_OPS(pd) && KCF_PROV_RANDOM_OPS(pd)->seed_random) ? \ KCF_PROV_RANDOM_OPS(pd)->seed_random((pd)->pd_prov_handle, \ session, buf, len, est, flags, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_GENERATE_RANDOM(pd, session, buf, len, req) ( \ (KCF_PROV_RANDOM_OPS(pd) && \ KCF_PROV_RANDOM_OPS(pd)->generate_random) ? \ KCF_PROV_RANDOM_OPS(pd)->generate_random((pd)->pd_prov_handle, \ session, buf, len, req) : CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_session_ops(9S) entry points. * * ops_pd is the provider descriptor that supplies the ops_vector. * pd is the descriptor that supplies the provider handle. * Only session open/close needs two handles. */ #define KCF_PROV_SESSION_OPEN(ops_pd, session, req, pd) ( \ (KCF_PROV_SESSION_OPS(ops_pd) && \ KCF_PROV_SESSION_OPS(ops_pd)->session_open) ? \ KCF_PROV_SESSION_OPS(ops_pd)->session_open((pd)->pd_prov_handle, \ session, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SESSION_CLOSE(ops_pd, session, req, pd) ( \ (KCF_PROV_SESSION_OPS(ops_pd) && \ KCF_PROV_SESSION_OPS(ops_pd)->session_close) ? \ KCF_PROV_SESSION_OPS(ops_pd)->session_close((pd)->pd_prov_handle, \ session, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SESSION_LOGIN(pd, session, user_type, pin, len, req) ( \ (KCF_PROV_SESSION_OPS(pd) && \ KCF_PROV_SESSION_OPS(pd)->session_login) ? \ KCF_PROV_SESSION_OPS(pd)->session_login((pd)->pd_prov_handle, \ session, user_type, pin, len, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SESSION_LOGOUT(pd, session, req) ( \ (KCF_PROV_SESSION_OPS(pd) && \ KCF_PROV_SESSION_OPS(pd)->session_logout) ? \ KCF_PROV_SESSION_OPS(pd)->session_logout((pd)->pd_prov_handle, \ session, req) : CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_object_ops(9S) entry points. */ #define KCF_PROV_OBJECT_CREATE(pd, session, template, count, object, req) ( \ (KCF_PROV_OBJECT_OPS(pd) && KCF_PROV_OBJECT_OPS(pd)->object_create) ? \ KCF_PROV_OBJECT_OPS(pd)->object_create((pd)->pd_prov_handle, \ session, template, count, object, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_OBJECT_COPY(pd, session, object, template, count, \ new_object, req) ( \ (KCF_PROV_OBJECT_OPS(pd) && KCF_PROV_OBJECT_OPS(pd)->object_copy) ? \ KCF_PROV_OBJECT_OPS(pd)->object_copy((pd)->pd_prov_handle, \ session, object, template, count, new_object, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_OBJECT_DESTROY(pd, session, object, req) ( \ (KCF_PROV_OBJECT_OPS(pd) && KCF_PROV_OBJECT_OPS(pd)->object_destroy) ? \ KCF_PROV_OBJECT_OPS(pd)->object_destroy((pd)->pd_prov_handle, \ session, object, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_OBJECT_GET_SIZE(pd, session, object, size, req) ( \ (KCF_PROV_OBJECT_OPS(pd) && \ KCF_PROV_OBJECT_OPS(pd)->object_get_size) ? \ KCF_PROV_OBJECT_OPS(pd)->object_get_size((pd)->pd_prov_handle, \ session, object, size, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_OBJECT_GET_ATTRIBUTE_VALUE(pd, session, object, template, \ count, req) ( \ (KCF_PROV_OBJECT_OPS(pd) && \ KCF_PROV_OBJECT_OPS(pd)->object_get_attribute_value) ? \ KCF_PROV_OBJECT_OPS(pd)->object_get_attribute_value( \ (pd)->pd_prov_handle, session, object, template, count, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_OBJECT_SET_ATTRIBUTE_VALUE(pd, session, object, template, \ count, req) ( \ (KCF_PROV_OBJECT_OPS(pd) && \ KCF_PROV_OBJECT_OPS(pd)->object_set_attribute_value) ? \ KCF_PROV_OBJECT_OPS(pd)->object_set_attribute_value( \ (pd)->pd_prov_handle, session, object, template, count, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_OBJECT_FIND_INIT(pd, session, template, count, ppriv, \ req) ( \ (KCF_PROV_OBJECT_OPS(pd) && \ KCF_PROV_OBJECT_OPS(pd)->object_find_init) ? \ KCF_PROV_OBJECT_OPS(pd)->object_find_init((pd)->pd_prov_handle, \ session, template, count, ppriv, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_OBJECT_FIND(pd, ppriv, objects, max_objects, object_count, \ req) ( \ (KCF_PROV_OBJECT_OPS(pd) && KCF_PROV_OBJECT_OPS(pd)->object_find) ? \ KCF_PROV_OBJECT_OPS(pd)->object_find( \ (pd)->pd_prov_handle, ppriv, objects, max_objects, object_count, \ req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_OBJECT_FIND_FINAL(pd, ppriv, req) ( \ (KCF_PROV_OBJECT_OPS(pd) && \ KCF_PROV_OBJECT_OPS(pd)->object_find_final) ? \ KCF_PROV_OBJECT_OPS(pd)->object_find_final( \ (pd)->pd_prov_handle, ppriv, req) : CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_key_ops(9S) entry points. */ #define KCF_PROV_KEY_GENERATE(pd, session, mech, template, count, object, \ req) ( \ (KCF_PROV_KEY_OPS(pd) && KCF_PROV_KEY_OPS(pd)->key_generate) ? \ KCF_PROV_KEY_OPS(pd)->key_generate((pd)->pd_prov_handle, \ session, mech, template, count, object, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_KEY_GENERATE_PAIR(pd, session, mech, pub_template, \ pub_count, priv_template, priv_count, pub_key, priv_key, req) ( \ (KCF_PROV_KEY_OPS(pd) && KCF_PROV_KEY_OPS(pd)->key_generate_pair) ? \ KCF_PROV_KEY_OPS(pd)->key_generate_pair((pd)->pd_prov_handle, \ session, mech, pub_template, pub_count, priv_template, \ priv_count, pub_key, priv_key, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_KEY_WRAP(pd, session, mech, wrapping_key, key, wrapped_key, \ wrapped_key_len, req) ( \ (KCF_PROV_KEY_OPS(pd) && KCF_PROV_KEY_OPS(pd)->key_wrap) ? \ KCF_PROV_KEY_OPS(pd)->key_wrap((pd)->pd_prov_handle, \ session, mech, wrapping_key, key, wrapped_key, wrapped_key_len, \ req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_KEY_UNWRAP(pd, session, mech, unwrapping_key, wrapped_key, \ wrapped_key_len, template, count, key, req) ( \ (KCF_PROV_KEY_OPS(pd) && KCF_PROV_KEY_OPS(pd)->key_unwrap) ? \ KCF_PROV_KEY_OPS(pd)->key_unwrap((pd)->pd_prov_handle, \ session, mech, unwrapping_key, wrapped_key, wrapped_key_len, \ template, count, key, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_KEY_DERIVE(pd, session, mech, base_key, template, count, \ key, req) ( \ (KCF_PROV_KEY_OPS(pd) && KCF_PROV_KEY_OPS(pd)->key_derive) ? \ KCF_PROV_KEY_OPS(pd)->key_derive((pd)->pd_prov_handle, \ session, mech, base_key, template, count, key, req) : \ CRYPTO_NOT_SUPPORTED) #define KCF_PROV_KEY_CHECK(pd, mech, key) ( \ (KCF_PROV_KEY_OPS(pd) && KCF_PROV_KEY_OPS(pd)->key_check) ? \ KCF_PROV_KEY_OPS(pd)->key_check((pd)->pd_prov_handle, mech, key) : \ CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_provider_management_ops(9S) entry points. * * ops_pd is the provider descriptor that supplies the ops_vector. * pd is the descriptor that supplies the provider handle. * Only ext_info needs two handles. */ #define KCF_PROV_EXT_INFO(ops_pd, provext_info, req, pd) ( \ (KCF_PROV_PROVIDER_OPS(ops_pd) && \ KCF_PROV_PROVIDER_OPS(ops_pd)->ext_info) ? \ KCF_PROV_PROVIDER_OPS(ops_pd)->ext_info((pd)->pd_prov_handle, \ provext_info, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_INIT_TOKEN(pd, pin, pin_len, label, req) ( \ (KCF_PROV_PROVIDER_OPS(pd) && KCF_PROV_PROVIDER_OPS(pd)->init_token) ? \ KCF_PROV_PROVIDER_OPS(pd)->init_token((pd)->pd_prov_handle, \ pin, pin_len, label, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_INIT_PIN(pd, session, pin, pin_len, req) ( \ (KCF_PROV_PROVIDER_OPS(pd) && KCF_PROV_PROVIDER_OPS(pd)->init_pin) ? \ KCF_PROV_PROVIDER_OPS(pd)->init_pin((pd)->pd_prov_handle, \ session, pin, pin_len, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_SET_PIN(pd, session, old_pin, old_len, new_pin, new_len, \ req) ( \ (KCF_PROV_PROVIDER_OPS(pd) && KCF_PROV_PROVIDER_OPS(pd)->set_pin) ? \ KCF_PROV_PROVIDER_OPS(pd)->set_pin((pd)->pd_prov_handle, \ session, old_pin, old_len, new_pin, new_len, req) : \ CRYPTO_NOT_SUPPORTED) /* * Wrappers for crypto_nostore_key_ops(9S) entry points. */ #define KCF_PROV_NOSTORE_KEY_GENERATE(pd, session, mech, template, count, \ out_template, out_count, req) ( \ (KCF_PROV_NOSTORE_KEY_OPS(pd) && \ KCF_PROV_NOSTORE_KEY_OPS(pd)->nostore_key_generate) ? \ KCF_PROV_NOSTORE_KEY_OPS(pd)->nostore_key_generate( \ (pd)->pd_prov_handle, session, mech, template, count, \ out_template, out_count, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_NOSTORE_KEY_GENERATE_PAIR(pd, session, mech, pub_template, \ pub_count, priv_template, priv_count, out_pub_template, \ out_pub_count, out_priv_template, out_priv_count, req) ( \ (KCF_PROV_NOSTORE_KEY_OPS(pd) && \ KCF_PROV_NOSTORE_KEY_OPS(pd)->nostore_key_generate_pair) ? \ KCF_PROV_NOSTORE_KEY_OPS(pd)->nostore_key_generate_pair( \ (pd)->pd_prov_handle, session, mech, pub_template, pub_count, \ priv_template, priv_count, out_pub_template, out_pub_count, \ out_priv_template, out_priv_count, req) : CRYPTO_NOT_SUPPORTED) #define KCF_PROV_NOSTORE_KEY_DERIVE(pd, session, mech, base_key, template, \ count, out_template, out_count, req) ( \ (KCF_PROV_NOSTORE_KEY_OPS(pd) && \ KCF_PROV_NOSTORE_KEY_OPS(pd)->nostore_key_derive) ? \ KCF_PROV_NOSTORE_KEY_OPS(pd)->nostore_key_derive( \ (pd)->pd_prov_handle, session, mech, base_key, template, count, \ out_template, out_count, req) : CRYPTO_NOT_SUPPORTED) /* * The following routines are exported by the kcf module (/kernel/misc/kcf) * to the crypto and cryptoadmin modules. */ /* Digest/mac/cipher entry points that take a provider descriptor and session */ extern int crypto_digest_single(crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); extern int crypto_mac_single(crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); extern int crypto_encrypt_single(crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); extern int crypto_decrypt_single(crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); /* Other private digest/mac/cipher entry points not exported through k-API */ extern int crypto_digest_key_prov(crypto_context_t, crypto_key_t *, crypto_call_req_t *); /* Private sign entry points exported by KCF */ extern int crypto_sign_single(crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); extern int crypto_sign_recover_single(crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); /* Private verify entry points exported by KCF */ extern int crypto_verify_single(crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); extern int crypto_verify_recover_single(crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); /* Private dual operations entry points exported by KCF */ extern int crypto_digest_encrypt_update(crypto_context_t, crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); extern int crypto_decrypt_digest_update(crypto_context_t, crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); extern int crypto_sign_encrypt_update(crypto_context_t, crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); extern int crypto_decrypt_verify_update(crypto_context_t, crypto_context_t, crypto_data_t *, crypto_data_t *, crypto_call_req_t *); /* Random Number Generation */ int crypto_seed_random(crypto_provider_handle_t provider, uchar_t *buf, size_t len, crypto_call_req_t *req); int crypto_generate_random(crypto_provider_handle_t provider, uchar_t *buf, size_t len, crypto_call_req_t *req); /* Provider Management */ int crypto_get_provider_info(crypto_provider_id_t id, crypto_provider_info_t **info, crypto_call_req_t *req); int crypto_get_provider_mechanisms(crypto_minor_t *, crypto_provider_id_t id, uint_t *count, crypto_mech_name_t **list); int crypto_init_token(crypto_provider_handle_t provider, char *pin, size_t pin_len, char *label, crypto_call_req_t *); int crypto_init_pin(crypto_provider_handle_t provider, char *pin, size_t pin_len, crypto_call_req_t *req); int crypto_set_pin(crypto_provider_handle_t provider, char *old_pin, size_t old_len, char *new_pin, size_t new_len, crypto_call_req_t *req); void crypto_free_provider_list(crypto_provider_entry_t *list, uint_t count); void crypto_free_provider_info(crypto_provider_info_t *info); /* Administrative */ int crypto_get_dev_list(uint_t *count, crypto_dev_list_entry_t **list); int crypto_get_soft_list(uint_t *count, char **list, size_t *len); int crypto_get_dev_info(char *name, uint_t instance, uint_t *count, crypto_mech_name_t **list); int crypto_get_soft_info(caddr_t name, uint_t *count, crypto_mech_name_t **list); int crypto_load_dev_disabled(char *name, uint_t instance, uint_t count, crypto_mech_name_t *list); int crypto_load_soft_disabled(caddr_t name, uint_t count, crypto_mech_name_t *list); int crypto_unload_soft_module(caddr_t path); int crypto_load_soft_config(caddr_t name, uint_t count, crypto_mech_name_t *list); int crypto_load_door(uint_t did); void crypto_free_mech_list(crypto_mech_name_t *list, uint_t count); void crypto_free_dev_list(crypto_dev_list_entry_t *list, uint_t count); /* Miscellaneous */ int crypto_get_mechanism_number(caddr_t name, crypto_mech_type_t *number); -int crypto_get_function_list(crypto_provider_id_t id, - crypto_function_list_t **list, int kmflag); -void crypto_free_function_list(crypto_function_list_t *list); int crypto_build_permitted_mech_names(kcf_provider_desc_t *, crypto_mech_name_t **, uint_t *, int); extern void kcf_destroy_mech_tabs(void); extern void kcf_init_mech_tabs(void); extern int kcf_add_mech_provider(short, kcf_provider_desc_t *, kcf_prov_mech_desc_t **); extern void kcf_remove_mech_provider(char *, kcf_provider_desc_t *); extern int kcf_get_mech_entry(crypto_mech_type_t, kcf_mech_entry_t **); extern kcf_provider_desc_t *kcf_alloc_provider_desc(crypto_provider_info_t *); extern void kcf_provider_zero_refcnt(kcf_provider_desc_t *); extern void kcf_free_provider_desc(kcf_provider_desc_t *); extern void kcf_soft_config_init(void); extern int get_sw_provider_for_mech(crypto_mech_name_t, char **); extern crypto_mech_type_t crypto_mech2id_common(char *, boolean_t); extern void undo_register_provider(kcf_provider_desc_t *, boolean_t); extern void redo_register_provider(kcf_provider_desc_t *); extern void kcf_rnd_init(void); extern boolean_t kcf_rngprov_check(void); extern int kcf_rnd_get_pseudo_bytes(uint8_t *, size_t); extern int kcf_rnd_get_bytes(uint8_t *, size_t, boolean_t, boolean_t); extern int random_add_pseudo_entropy(uint8_t *, size_t, uint_t); extern void kcf_rnd_schedule_timeout(boolean_t); extern int crypto_uio_data(crypto_data_t *, uchar_t *, int, cmd_type_t, void *, void (*update)(void)); extern int crypto_mblk_data(crypto_data_t *, uchar_t *, int, cmd_type_t, void *, void (*update)(void)); extern int crypto_put_output_data(uchar_t *, crypto_data_t *, int); extern int crypto_get_input_data(crypto_data_t *, uchar_t **, uchar_t *); extern int crypto_copy_key_to_ctx(crypto_key_t *, crypto_key_t **, size_t *, int kmflag); extern int crypto_digest_data(crypto_data_t *, void *, uchar_t *, void (*update)(void), void (*final)(void), uchar_t); extern int crypto_update_iov(void *, crypto_data_t *, crypto_data_t *, int (*cipher)(void *, caddr_t, size_t, crypto_data_t *), void (*copy_block)(uint8_t *, uint64_t *)); extern int crypto_update_uio(void *, crypto_data_t *, crypto_data_t *, int (*cipher)(void *, caddr_t, size_t, crypto_data_t *), void (*copy_block)(uint8_t *, uint64_t *)); extern int crypto_update_mp(void *, crypto_data_t *, crypto_data_t *, int (*cipher)(void *, caddr_t, size_t, crypto_data_t *), void (*copy_block)(uint8_t *, uint64_t *)); extern int crypto_get_key_attr(crypto_key_t *, crypto_attr_type_t, uchar_t **, ssize_t *); /* Access to the provider's table */ extern void kcf_prov_tab_destroy(void); extern void kcf_prov_tab_init(void); extern int kcf_prov_tab_add_provider(kcf_provider_desc_t *); extern int kcf_prov_tab_rem_provider(crypto_provider_id_t); extern kcf_provider_desc_t *kcf_prov_tab_lookup_by_name(char *); extern kcf_provider_desc_t *kcf_prov_tab_lookup_by_dev(char *, uint_t); extern int kcf_get_hw_prov_tab(uint_t *, kcf_provider_desc_t ***, int, char *, uint_t, boolean_t); extern int kcf_get_slot_list(uint_t *, kcf_provider_desc_t ***, boolean_t); extern void kcf_free_provider_tab(uint_t, kcf_provider_desc_t **); extern kcf_provider_desc_t *kcf_prov_tab_lookup(crypto_provider_id_t); extern int kcf_get_sw_prov(crypto_mech_type_t, kcf_provider_desc_t **, kcf_mech_entry_t **, boolean_t); /* Access to the policy table */ extern boolean_t is_mech_disabled(kcf_provider_desc_t *, crypto_mech_name_t); extern boolean_t is_mech_disabled_byname(crypto_provider_type_t, char *, uint_t, crypto_mech_name_t); extern void kcf_policy_tab_init(void); extern void kcf_policy_free_desc(kcf_policy_desc_t *); extern void kcf_policy_remove_by_name(char *, uint_t *, crypto_mech_name_t **); extern void kcf_policy_remove_by_dev(char *, uint_t, uint_t *, crypto_mech_name_t **); extern kcf_policy_desc_t *kcf_policy_lookup_by_name(char *); extern kcf_policy_desc_t *kcf_policy_lookup_by_dev(char *, uint_t); extern int kcf_policy_load_soft_disabled(char *, uint_t, crypto_mech_name_t *, uint_t *, crypto_mech_name_t **); extern int kcf_policy_load_dev_disabled(char *, uint_t, uint_t, crypto_mech_name_t *, uint_t *, crypto_mech_name_t **); extern boolean_t in_soft_config_list(char *); #ifdef __cplusplus } #endif #endif /* _SYS_CRYPTO_IMPL_H */ diff --git a/module/icp/include/sys/crypto/ioctl.h b/module/icp/include/sys/crypto/ioctl.h deleted file mode 100644 index 6e371e343945..000000000000 --- a/module/icp/include/sys/crypto/ioctl.h +++ /dev/null @@ -1,1480 +0,0 @@ -/* - * CDDL HEADER START - * - * The contents of this file are subject to the terms of the - * Common Development and Distribution License (the "License"). - * You may not use this file except in compliance with the License. - * - * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE - * or http://www.opensolaris.org/os/licensing. - * See the License for the specific language governing permissions - * and limitations under the License. - * - * When distributing Covered Code, include this CDDL HEADER in each - * file and include the License file at usr/src/OPENSOLARIS.LICENSE. - * If applicable, add the following below this CDDL HEADER, with the - * fields enclosed by brackets "[]" replaced with your own identifying - * information: Portions Copyright [yyyy] [name of copyright owner] - * - * CDDL HEADER END - */ - -/* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved. - * Use is subject to license terms. - */ - -#ifndef _SYS_CRYPTO_IOCTL_H -#define _SYS_CRYPTO_IOCTL_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include -#include -#include - -#define CRYPTO_MAX_ATTRIBUTE_COUNT 128 - -#define CRYPTO_IOFLAGS_RW_SESSION 0x00000001 - -#define CRYPTO(x) (('y' << 8) | (x)) - -#define MAX_NUM_THRESHOLD 7 - -/* the PKCS11 Mechanisms */ -#define CKM_RC4 0x00000111 -#define CKM_DES3_ECB 0x00000132 -#define CKM_DES3_CBC 0x00000133 -#define CKM_MD5 0x00000210 -#define CKM_SHA_1 0x00000220 -#define CKM_AES_ECB 0x00001081 -#define CKM_AES_CBC 0x00001082 - -/* - * General Purpose Ioctls - */ - -typedef struct fl_mechs_threshold { - int mech_type; - uint32_t mech_threshold; -} fl_mechs_threshold_t; - -typedef struct crypto_function_list { - boolean_t fl_digest_init; - boolean_t fl_digest; - boolean_t fl_digest_update; - boolean_t fl_digest_key; - boolean_t fl_digest_final; - - boolean_t fl_encrypt_init; - boolean_t fl_encrypt; - boolean_t fl_encrypt_update; - boolean_t fl_encrypt_final; - - boolean_t fl_decrypt_init; - boolean_t fl_decrypt; - boolean_t fl_decrypt_update; - boolean_t fl_decrypt_final; - - boolean_t fl_mac_init; - boolean_t fl_mac; - boolean_t fl_mac_update; - boolean_t fl_mac_final; - - boolean_t fl_sign_init; - boolean_t fl_sign; - boolean_t fl_sign_update; - boolean_t fl_sign_final; - boolean_t fl_sign_recover_init; - boolean_t fl_sign_recover; - - boolean_t fl_verify_init; - boolean_t fl_verify; - boolean_t fl_verify_update; - boolean_t fl_verify_final; - boolean_t fl_verify_recover_init; - boolean_t fl_verify_recover; - - boolean_t fl_digest_encrypt_update; - boolean_t fl_decrypt_digest_update; - boolean_t fl_sign_encrypt_update; - boolean_t fl_decrypt_verify_update; - - boolean_t fl_seed_random; - boolean_t fl_generate_random; - - boolean_t fl_session_open; - boolean_t fl_session_close; - boolean_t fl_session_login; - boolean_t fl_session_logout; - - boolean_t fl_object_create; - boolean_t fl_object_copy; - boolean_t fl_object_destroy; - boolean_t fl_object_get_size; - boolean_t fl_object_get_attribute_value; - boolean_t fl_object_set_attribute_value; - boolean_t fl_object_find_init; - boolean_t fl_object_find; - boolean_t fl_object_find_final; - - boolean_t fl_key_generate; - boolean_t fl_key_generate_pair; - boolean_t fl_key_wrap; - boolean_t fl_key_unwrap; - boolean_t fl_key_derive; - - boolean_t fl_init_token; - boolean_t fl_init_pin; - boolean_t fl_set_pin; - - boolean_t prov_is_limited; - uint32_t prov_hash_threshold; - uint32_t prov_hash_limit; - - int total_threshold_count; - fl_mechs_threshold_t fl_threshold[MAX_NUM_THRESHOLD]; -} crypto_function_list_t; - -typedef struct crypto_get_function_list { - uint_t fl_return_value; - crypto_provider_id_t fl_provider_id; - crypto_function_list_t fl_list; -} crypto_get_function_list_t; - -typedef struct crypto_get_mechanism_number { - uint_t pn_return_value; - caddr_t pn_mechanism_string; - size_t pn_mechanism_len; - crypto_mech_type_t pn_internal_number; -} crypto_get_mechanism_number_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_get_mechanism_number32 { - uint32_t pn_return_value; - caddr32_t pn_mechanism_string; - size32_t pn_mechanism_len; - crypto_mech_type_t pn_internal_number; -} crypto_get_mechanism_number32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_GET_FUNCTION_LIST CRYPTO(20) -#define CRYPTO_GET_MECHANISM_NUMBER CRYPTO(21) - -/* - * Session Ioctls - */ - -typedef uint32_t crypto_flags_t; - -typedef struct crypto_open_session { - uint_t os_return_value; - crypto_session_id_t os_session; - crypto_flags_t os_flags; - crypto_provider_id_t os_provider_id; -} crypto_open_session_t; - -typedef struct crypto_close_session { - uint_t cs_return_value; - crypto_session_id_t cs_session; -} crypto_close_session_t; - -typedef struct crypto_close_all_sessions { - uint_t as_return_value; - crypto_provider_id_t as_provider_id; -} crypto_close_all_sessions_t; - -#define CRYPTO_OPEN_SESSION CRYPTO(30) -#define CRYPTO_CLOSE_SESSION CRYPTO(31) -#define CRYPTO_CLOSE_ALL_SESSIONS CRYPTO(32) - -/* - * Login Ioctls - */ -typedef struct crypto_login { - uint_t co_return_value; - crypto_session_id_t co_session; - uint_t co_user_type; - uint_t co_pin_len; - caddr_t co_pin; -} crypto_login_t; - -typedef struct crypto_logout { - uint_t cl_return_value; - crypto_session_id_t cl_session; -} crypto_logout_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -typedef struct crypto_login32 { - uint32_t co_return_value; - crypto_session_id_t co_session; - uint32_t co_user_type; - uint32_t co_pin_len; - caddr32_t co_pin; -} crypto_login32_t; - -typedef struct crypto_logout32 { - uint32_t cl_return_value; - crypto_session_id_t cl_session; -} crypto_logout32_t; - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_LOGIN CRYPTO(40) -#define CRYPTO_LOGOUT CRYPTO(41) - -/* - * Cryptographic Ioctls - */ -typedef struct crypto_encrypt { - uint_t ce_return_value; - crypto_session_id_t ce_session; - size_t ce_datalen; - caddr_t ce_databuf; - size_t ce_encrlen; - caddr_t ce_encrbuf; - uint_t ce_flags; -} crypto_encrypt_t; - -typedef struct crypto_encrypt_init { - uint_t ei_return_value; - crypto_session_id_t ei_session; - crypto_mechanism_t ei_mech; - crypto_key_t ei_key; -} crypto_encrypt_init_t; - -typedef struct crypto_encrypt_update { - uint_t eu_return_value; - crypto_session_id_t eu_session; - size_t eu_datalen; - caddr_t eu_databuf; - size_t eu_encrlen; - caddr_t eu_encrbuf; -} crypto_encrypt_update_t; - -typedef struct crypto_encrypt_final { - uint_t ef_return_value; - crypto_session_id_t ef_session; - size_t ef_encrlen; - caddr_t ef_encrbuf; -} crypto_encrypt_final_t; - -typedef struct crypto_decrypt { - uint_t cd_return_value; - crypto_session_id_t cd_session; - size_t cd_encrlen; - caddr_t cd_encrbuf; - size_t cd_datalen; - caddr_t cd_databuf; - uint_t cd_flags; -} crypto_decrypt_t; - -typedef struct crypto_decrypt_init { - uint_t di_return_value; - crypto_session_id_t di_session; - crypto_mechanism_t di_mech; - crypto_key_t di_key; -} crypto_decrypt_init_t; - -typedef struct crypto_decrypt_update { - uint_t du_return_value; - crypto_session_id_t du_session; - size_t du_encrlen; - caddr_t du_encrbuf; - size_t du_datalen; - caddr_t du_databuf; -} crypto_decrypt_update_t; - -typedef struct crypto_decrypt_final { - uint_t df_return_value; - crypto_session_id_t df_session; - size_t df_datalen; - caddr_t df_databuf; -} crypto_decrypt_final_t; - -typedef struct crypto_digest { - uint_t cd_return_value; - crypto_session_id_t cd_session; - size_t cd_datalen; - caddr_t cd_databuf; - size_t cd_digestlen; - caddr_t cd_digestbuf; -} crypto_digest_t; - -typedef struct crypto_digest_init { - uint_t di_return_value; - crypto_session_id_t di_session; - crypto_mechanism_t di_mech; -} crypto_digest_init_t; - -typedef struct crypto_digest_update { - uint_t du_return_value; - crypto_session_id_t du_session; - size_t du_datalen; - caddr_t du_databuf; -} crypto_digest_update_t; - -typedef struct crypto_digest_key { - uint_t dk_return_value; - crypto_session_id_t dk_session; - crypto_key_t dk_key; -} crypto_digest_key_t; - -typedef struct crypto_digest_final { - uint_t df_return_value; - crypto_session_id_t df_session; - size_t df_digestlen; - caddr_t df_digestbuf; -} crypto_digest_final_t; - -typedef struct crypto_mac { - uint_t cm_return_value; - crypto_session_id_t cm_session; - size_t cm_datalen; - caddr_t cm_databuf; - size_t cm_maclen; - caddr_t cm_macbuf; -} crypto_mac_t; - -typedef struct crypto_mac_init { - uint_t mi_return_value; - crypto_session_id_t mi_session; - crypto_mechanism_t mi_mech; - crypto_key_t mi_key; -} crypto_mac_init_t; - -typedef struct crypto_mac_update { - uint_t mu_return_value; - crypto_session_id_t mu_session; - size_t mu_datalen; - caddr_t mu_databuf; -} crypto_mac_update_t; - -typedef struct crypto_mac_final { - uint_t mf_return_value; - crypto_session_id_t mf_session; - size_t mf_maclen; - caddr_t mf_macbuf; -} crypto_mac_final_t; - -typedef struct crypto_sign { - uint_t cs_return_value; - crypto_session_id_t cs_session; - size_t cs_datalen; - caddr_t cs_databuf; - size_t cs_signlen; - caddr_t cs_signbuf; -} crypto_sign_t; - -typedef struct crypto_sign_init { - uint_t si_return_value; - crypto_session_id_t si_session; - crypto_mechanism_t si_mech; - crypto_key_t si_key; -} crypto_sign_init_t; - -typedef struct crypto_sign_update { - uint_t su_return_value; - crypto_session_id_t su_session; - size_t su_datalen; - caddr_t su_databuf; -} crypto_sign_update_t; - -typedef struct crypto_sign_final { - uint_t sf_return_value; - crypto_session_id_t sf_session; - size_t sf_signlen; - caddr_t sf_signbuf; -} crypto_sign_final_t; - -typedef struct crypto_sign_recover_init { - uint_t ri_return_value; - crypto_session_id_t ri_session; - crypto_mechanism_t ri_mech; - crypto_key_t ri_key; -} crypto_sign_recover_init_t; - -typedef struct crypto_sign_recover { - uint_t sr_return_value; - crypto_session_id_t sr_session; - size_t sr_datalen; - caddr_t sr_databuf; - size_t sr_signlen; - caddr_t sr_signbuf; -} crypto_sign_recover_t; - -typedef struct crypto_verify { - uint_t cv_return_value; - crypto_session_id_t cv_session; - size_t cv_datalen; - caddr_t cv_databuf; - size_t cv_signlen; - caddr_t cv_signbuf; -} crypto_verify_t; - -typedef struct crypto_verify_init { - uint_t vi_return_value; - crypto_session_id_t vi_session; - crypto_mechanism_t vi_mech; - crypto_key_t vi_key; -} crypto_verify_init_t; - -typedef struct crypto_verify_update { - uint_t vu_return_value; - crypto_session_id_t vu_session; - size_t vu_datalen; - caddr_t vu_databuf; -} crypto_verify_update_t; - -typedef struct crypto_verify_final { - uint_t vf_return_value; - crypto_session_id_t vf_session; - size_t vf_signlen; - caddr_t vf_signbuf; -} crypto_verify_final_t; - -typedef struct crypto_verify_recover_init { - uint_t ri_return_value; - crypto_session_id_t ri_session; - crypto_mechanism_t ri_mech; - crypto_key_t ri_key; -} crypto_verify_recover_init_t; - -typedef struct crypto_verify_recover { - uint_t vr_return_value; - crypto_session_id_t vr_session; - size_t vr_signlen; - caddr_t vr_signbuf; - size_t vr_datalen; - caddr_t vr_databuf; -} crypto_verify_recover_t; - -typedef struct crypto_digest_encrypt_update { - uint_t eu_return_value; - crypto_session_id_t eu_session; - size_t eu_datalen; - caddr_t eu_databuf; - size_t eu_encrlen; - caddr_t eu_encrbuf; -} crypto_digest_encrypt_update_t; - -typedef struct crypto_decrypt_digest_update { - uint_t du_return_value; - crypto_session_id_t du_session; - size_t du_encrlen; - caddr_t du_encrbuf; - size_t du_datalen; - caddr_t du_databuf; -} crypto_decrypt_digest_update_t; - -typedef struct crypto_sign_encrypt_update { - uint_t eu_return_value; - crypto_session_id_t eu_session; - size_t eu_datalen; - caddr_t eu_databuf; - size_t eu_encrlen; - caddr_t eu_encrbuf; -} crypto_sign_encrypt_update_t; - -typedef struct crypto_decrypt_verify_update { - uint_t vu_return_value; - crypto_session_id_t vu_session; - size_t vu_encrlen; - caddr_t vu_encrbuf; - size_t vu_datalen; - caddr_t vu_databuf; -} crypto_decrypt_verify_update_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -typedef struct crypto_encrypt32 { - uint32_t ce_return_value; - crypto_session_id_t ce_session; - size32_t ce_datalen; - caddr32_t ce_databuf; - size32_t ce_encrlen; - caddr32_t ce_encrbuf; - uint32_t ce_flags; -} crypto_encrypt32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_encrypt_init32 { - uint32_t ei_return_value; - crypto_session_id_t ei_session; - crypto_mechanism32_t ei_mech; - crypto_key32_t ei_key; -} crypto_encrypt_init32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -typedef struct crypto_encrypt_update32 { - uint32_t eu_return_value; - crypto_session_id_t eu_session; - size32_t eu_datalen; - caddr32_t eu_databuf; - size32_t eu_encrlen; - caddr32_t eu_encrbuf; -} crypto_encrypt_update32_t; - -typedef struct crypto_encrypt_final32 { - uint32_t ef_return_value; - crypto_session_id_t ef_session; - size32_t ef_encrlen; - caddr32_t ef_encrbuf; -} crypto_encrypt_final32_t; - -typedef struct crypto_decrypt32 { - uint32_t cd_return_value; - crypto_session_id_t cd_session; - size32_t cd_encrlen; - caddr32_t cd_encrbuf; - size32_t cd_datalen; - caddr32_t cd_databuf; - uint32_t cd_flags; -} crypto_decrypt32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_decrypt_init32 { - uint32_t di_return_value; - crypto_session_id_t di_session; - crypto_mechanism32_t di_mech; - crypto_key32_t di_key; -} crypto_decrypt_init32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -typedef struct crypto_decrypt_update32 { - uint32_t du_return_value; - crypto_session_id_t du_session; - size32_t du_encrlen; - caddr32_t du_encrbuf; - size32_t du_datalen; - caddr32_t du_databuf; -} crypto_decrypt_update32_t; - -typedef struct crypto_decrypt_final32 { - uint32_t df_return_value; - crypto_session_id_t df_session; - size32_t df_datalen; - caddr32_t df_databuf; -} crypto_decrypt_final32_t; - -typedef struct crypto_digest32 { - uint32_t cd_return_value; - crypto_session_id_t cd_session; - size32_t cd_datalen; - caddr32_t cd_databuf; - size32_t cd_digestlen; - caddr32_t cd_digestbuf; -} crypto_digest32_t; - -typedef struct crypto_digest_init32 { - uint32_t di_return_value; - crypto_session_id_t di_session; - crypto_mechanism32_t di_mech; -} crypto_digest_init32_t; - -typedef struct crypto_digest_update32 { - uint32_t du_return_value; - crypto_session_id_t du_session; - size32_t du_datalen; - caddr32_t du_databuf; -} crypto_digest_update32_t; - -typedef struct crypto_digest_key32 { - uint32_t dk_return_value; - crypto_session_id_t dk_session; - crypto_key32_t dk_key; -} crypto_digest_key32_t; - -typedef struct crypto_digest_final32 { - uint32_t df_return_value; - crypto_session_id_t df_session; - size32_t df_digestlen; - caddr32_t df_digestbuf; -} crypto_digest_final32_t; - -typedef struct crypto_mac32 { - uint32_t cm_return_value; - crypto_session_id_t cm_session; - size32_t cm_datalen; - caddr32_t cm_databuf; - size32_t cm_maclen; - caddr32_t cm_macbuf; -} crypto_mac32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_mac_init32 { - uint32_t mi_return_value; - crypto_session_id_t mi_session; - crypto_mechanism32_t mi_mech; - crypto_key32_t mi_key; -} crypto_mac_init32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -typedef struct crypto_mac_update32 { - uint32_t mu_return_value; - crypto_session_id_t mu_session; - size32_t mu_datalen; - caddr32_t mu_databuf; -} crypto_mac_update32_t; - -typedef struct crypto_mac_final32 { - uint32_t mf_return_value; - crypto_session_id_t mf_session; - size32_t mf_maclen; - caddr32_t mf_macbuf; -} crypto_mac_final32_t; - -typedef struct crypto_sign32 { - uint32_t cs_return_value; - crypto_session_id_t cs_session; - size32_t cs_datalen; - caddr32_t cs_databuf; - size32_t cs_signlen; - caddr32_t cs_signbuf; -} crypto_sign32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_sign_init32 { - uint32_t si_return_value; - crypto_session_id_t si_session; - crypto_mechanism32_t si_mech; - crypto_key32_t si_key; -} crypto_sign_init32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -typedef struct crypto_sign_update32 { - uint32_t su_return_value; - crypto_session_id_t su_session; - size32_t su_datalen; - caddr32_t su_databuf; -} crypto_sign_update32_t; - -typedef struct crypto_sign_final32 { - uint32_t sf_return_value; - crypto_session_id_t sf_session; - size32_t sf_signlen; - caddr32_t sf_signbuf; -} crypto_sign_final32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_sign_recover_init32 { - uint32_t ri_return_value; - crypto_session_id_t ri_session; - crypto_mechanism32_t ri_mech; - crypto_key32_t ri_key; -} crypto_sign_recover_init32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -typedef struct crypto_sign_recover32 { - uint32_t sr_return_value; - crypto_session_id_t sr_session; - size32_t sr_datalen; - caddr32_t sr_databuf; - size32_t sr_signlen; - caddr32_t sr_signbuf; -} crypto_sign_recover32_t; - -typedef struct crypto_verify32 { - uint32_t cv_return_value; - crypto_session_id_t cv_session; - size32_t cv_datalen; - caddr32_t cv_databuf; - size32_t cv_signlen; - caddr32_t cv_signbuf; -} crypto_verify32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_verify_init32 { - uint32_t vi_return_value; - crypto_session_id_t vi_session; - crypto_mechanism32_t vi_mech; - crypto_key32_t vi_key; -} crypto_verify_init32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -typedef struct crypto_verify_update32 { - uint32_t vu_return_value; - crypto_session_id_t vu_session; - size32_t vu_datalen; - caddr32_t vu_databuf; -} crypto_verify_update32_t; - -typedef struct crypto_verify_final32 { - uint32_t vf_return_value; - crypto_session_id_t vf_session; - size32_t vf_signlen; - caddr32_t vf_signbuf; -} crypto_verify_final32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_verify_recover_init32 { - uint32_t ri_return_value; - crypto_session_id_t ri_session; - crypto_mechanism32_t ri_mech; - crypto_key32_t ri_key; -} crypto_verify_recover_init32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -typedef struct crypto_verify_recover32 { - uint32_t vr_return_value; - crypto_session_id_t vr_session; - size32_t vr_signlen; - caddr32_t vr_signbuf; - size32_t vr_datalen; - caddr32_t vr_databuf; -} crypto_verify_recover32_t; - -typedef struct crypto_digest_encrypt_update32 { - uint32_t eu_return_value; - crypto_session_id_t eu_session; - size32_t eu_datalen; - caddr32_t eu_databuf; - size32_t eu_encrlen; - caddr32_t eu_encrbuf; -} crypto_digest_encrypt_update32_t; - -typedef struct crypto_decrypt_digest_update32 { - uint32_t du_return_value; - crypto_session_id_t du_session; - size32_t du_encrlen; - caddr32_t du_encrbuf; - size32_t du_datalen; - caddr32_t du_databuf; -} crypto_decrypt_digest_update32_t; - -typedef struct crypto_sign_encrypt_update32 { - uint32_t eu_return_value; - crypto_session_id_t eu_session; - size32_t eu_datalen; - caddr32_t eu_databuf; - size32_t eu_encrlen; - caddr32_t eu_encrbuf; -} crypto_sign_encrypt_update32_t; - -typedef struct crypto_decrypt_verify_update32 { - uint32_t vu_return_value; - crypto_session_id_t vu_session; - size32_t vu_encrlen; - caddr32_t vu_encrbuf; - size32_t vu_datalen; - caddr32_t vu_databuf; -} crypto_decrypt_verify_update32_t; - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_ENCRYPT CRYPTO(50) -#define CRYPTO_ENCRYPT_INIT CRYPTO(51) -#define CRYPTO_ENCRYPT_UPDATE CRYPTO(52) -#define CRYPTO_ENCRYPT_FINAL CRYPTO(53) -#define CRYPTO_DECRYPT CRYPTO(54) -#define CRYPTO_DECRYPT_INIT CRYPTO(55) -#define CRYPTO_DECRYPT_UPDATE CRYPTO(56) -#define CRYPTO_DECRYPT_FINAL CRYPTO(57) - -#define CRYPTO_DIGEST CRYPTO(58) -#define CRYPTO_DIGEST_INIT CRYPTO(59) -#define CRYPTO_DIGEST_UPDATE CRYPTO(60) -#define CRYPTO_DIGEST_KEY CRYPTO(61) -#define CRYPTO_DIGEST_FINAL CRYPTO(62) -#define CRYPTO_MAC CRYPTO(63) -#define CRYPTO_MAC_INIT CRYPTO(64) -#define CRYPTO_MAC_UPDATE CRYPTO(65) -#define CRYPTO_MAC_FINAL CRYPTO(66) - -#define CRYPTO_SIGN CRYPTO(67) -#define CRYPTO_SIGN_INIT CRYPTO(68) -#define CRYPTO_SIGN_UPDATE CRYPTO(69) -#define CRYPTO_SIGN_FINAL CRYPTO(70) -#define CRYPTO_SIGN_RECOVER_INIT CRYPTO(71) -#define CRYPTO_SIGN_RECOVER CRYPTO(72) -#define CRYPTO_VERIFY CRYPTO(73) -#define CRYPTO_VERIFY_INIT CRYPTO(74) -#define CRYPTO_VERIFY_UPDATE CRYPTO(75) -#define CRYPTO_VERIFY_FINAL CRYPTO(76) -#define CRYPTO_VERIFY_RECOVER_INIT CRYPTO(77) -#define CRYPTO_VERIFY_RECOVER CRYPTO(78) - -#define CRYPTO_DIGEST_ENCRYPT_UPDATE CRYPTO(79) -#define CRYPTO_DECRYPT_DIGEST_UPDATE CRYPTO(80) -#define CRYPTO_SIGN_ENCRYPT_UPDATE CRYPTO(81) -#define CRYPTO_DECRYPT_VERIFY_UPDATE CRYPTO(82) - -/* - * Random Number Ioctls - */ -typedef struct crypto_seed_random { - uint_t sr_return_value; - crypto_session_id_t sr_session; - size_t sr_seedlen; - caddr_t sr_seedbuf; -} crypto_seed_random_t; - -typedef struct crypto_generate_random { - uint_t gr_return_value; - crypto_session_id_t gr_session; - caddr_t gr_buf; - size_t gr_buflen; -} crypto_generate_random_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -typedef struct crypto_seed_random32 { - uint32_t sr_return_value; - crypto_session_id_t sr_session; - size32_t sr_seedlen; - caddr32_t sr_seedbuf; -} crypto_seed_random32_t; - -typedef struct crypto_generate_random32 { - uint32_t gr_return_value; - crypto_session_id_t gr_session; - caddr32_t gr_buf; - size32_t gr_buflen; -} crypto_generate_random32_t; - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_SEED_RANDOM CRYPTO(90) -#define CRYPTO_GENERATE_RANDOM CRYPTO(91) - -/* - * Object Management Ioctls - */ -typedef struct crypto_object_create { - uint_t oc_return_value; - crypto_session_id_t oc_session; - crypto_object_id_t oc_handle; - uint_t oc_count; - caddr_t oc_attributes; -} crypto_object_create_t; - -typedef struct crypto_object_copy { - uint_t oc_return_value; - crypto_session_id_t oc_session; - crypto_object_id_t oc_handle; - crypto_object_id_t oc_new_handle; - uint_t oc_count; - caddr_t oc_new_attributes; -} crypto_object_copy_t; - -typedef struct crypto_object_destroy { - uint_t od_return_value; - crypto_session_id_t od_session; - crypto_object_id_t od_handle; -} crypto_object_destroy_t; - -typedef struct crypto_object_get_attribute_value { - uint_t og_return_value; - crypto_session_id_t og_session; - crypto_object_id_t og_handle; - uint_t og_count; - caddr_t og_attributes; -} crypto_object_get_attribute_value_t; - -typedef struct crypto_object_get_size { - uint_t gs_return_value; - crypto_session_id_t gs_session; - crypto_object_id_t gs_handle; - size_t gs_size; -} crypto_object_get_size_t; - -typedef struct crypto_object_set_attribute_value { - uint_t sa_return_value; - crypto_session_id_t sa_session; - crypto_object_id_t sa_handle; - uint_t sa_count; - caddr_t sa_attributes; -} crypto_object_set_attribute_value_t; - -typedef struct crypto_object_find_init { - uint_t fi_return_value; - crypto_session_id_t fi_session; - uint_t fi_count; - caddr_t fi_attributes; -} crypto_object_find_init_t; - -typedef struct crypto_object_find_update { - uint_t fu_return_value; - crypto_session_id_t fu_session; - uint_t fu_max_count; - uint_t fu_count; - caddr_t fu_handles; -} crypto_object_find_update_t; - -typedef struct crypto_object_find_final { - uint_t ff_return_value; - crypto_session_id_t ff_session; -} crypto_object_find_final_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -typedef struct crypto_object_create32 { - uint32_t oc_return_value; - crypto_session_id_t oc_session; - crypto_object_id_t oc_handle; - uint32_t oc_count; - caddr32_t oc_attributes; -} crypto_object_create32_t; - -typedef struct crypto_object_copy32 { - uint32_t oc_return_value; - crypto_session_id_t oc_session; - crypto_object_id_t oc_handle; - crypto_object_id_t oc_new_handle; - uint32_t oc_count; - caddr32_t oc_new_attributes; -} crypto_object_copy32_t; - -typedef struct crypto_object_destroy32 { - uint32_t od_return_value; - crypto_session_id_t od_session; - crypto_object_id_t od_handle; -} crypto_object_destroy32_t; - -typedef struct crypto_object_get_attribute_value32 { - uint32_t og_return_value; - crypto_session_id_t og_session; - crypto_object_id_t og_handle; - uint32_t og_count; - caddr32_t og_attributes; -} crypto_object_get_attribute_value32_t; - -typedef struct crypto_object_get_size32 { - uint32_t gs_return_value; - crypto_session_id_t gs_session; - crypto_object_id_t gs_handle; - size32_t gs_size; -} crypto_object_get_size32_t; - -typedef struct crypto_object_set_attribute_value32 { - uint32_t sa_return_value; - crypto_session_id_t sa_session; - crypto_object_id_t sa_handle; - uint32_t sa_count; - caddr32_t sa_attributes; -} crypto_object_set_attribute_value32_t; - -typedef struct crypto_object_find_init32 { - uint32_t fi_return_value; - crypto_session_id_t fi_session; - uint32_t fi_count; - caddr32_t fi_attributes; -} crypto_object_find_init32_t; - -typedef struct crypto_object_find_update32 { - uint32_t fu_return_value; - crypto_session_id_t fu_session; - uint32_t fu_max_count; - uint32_t fu_count; - caddr32_t fu_handles; -} crypto_object_find_update32_t; - -typedef struct crypto_object_find_final32 { - uint32_t ff_return_value; - crypto_session_id_t ff_session; -} crypto_object_find_final32_t; - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_OBJECT_CREATE CRYPTO(100) -#define CRYPTO_OBJECT_COPY CRYPTO(101) -#define CRYPTO_OBJECT_DESTROY CRYPTO(102) -#define CRYPTO_OBJECT_GET_ATTRIBUTE_VALUE CRYPTO(103) -#define CRYPTO_OBJECT_GET_SIZE CRYPTO(104) -#define CRYPTO_OBJECT_SET_ATTRIBUTE_VALUE CRYPTO(105) -#define CRYPTO_OBJECT_FIND_INIT CRYPTO(106) -#define CRYPTO_OBJECT_FIND_UPDATE CRYPTO(107) -#define CRYPTO_OBJECT_FIND_FINAL CRYPTO(108) - -/* - * Key Generation Ioctls - */ -typedef struct crypto_object_generate_key { - uint_t gk_return_value; - crypto_session_id_t gk_session; - crypto_object_id_t gk_handle; - crypto_mechanism_t gk_mechanism; - uint_t gk_count; - caddr_t gk_attributes; -} crypto_object_generate_key_t; - -typedef struct crypto_object_generate_key_pair { - uint_t kp_return_value; - crypto_session_id_t kp_session; - crypto_object_id_t kp_public_handle; - crypto_object_id_t kp_private_handle; - uint_t kp_public_count; - uint_t kp_private_count; - caddr_t kp_public_attributes; - caddr_t kp_private_attributes; - crypto_mechanism_t kp_mechanism; -} crypto_object_generate_key_pair_t; - -typedef struct crypto_object_wrap_key { - uint_t wk_return_value; - crypto_session_id_t wk_session; - crypto_mechanism_t wk_mechanism; - crypto_key_t wk_wrapping_key; - crypto_object_id_t wk_object_handle; - size_t wk_wrapped_key_len; - caddr_t wk_wrapped_key; -} crypto_object_wrap_key_t; - -typedef struct crypto_object_unwrap_key { - uint_t uk_return_value; - crypto_session_id_t uk_session; - crypto_mechanism_t uk_mechanism; - crypto_key_t uk_unwrapping_key; - crypto_object_id_t uk_object_handle; - size_t uk_wrapped_key_len; - caddr_t uk_wrapped_key; - uint_t uk_count; - caddr_t uk_attributes; -} crypto_object_unwrap_key_t; - -typedef struct crypto_derive_key { - uint_t dk_return_value; - crypto_session_id_t dk_session; - crypto_mechanism_t dk_mechanism; - crypto_key_t dk_base_key; - crypto_object_id_t dk_object_handle; - uint_t dk_count; - caddr_t dk_attributes; -} crypto_derive_key_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_object_generate_key32 { - uint32_t gk_return_value; - crypto_session_id_t gk_session; - crypto_object_id_t gk_handle; - crypto_mechanism32_t gk_mechanism; - uint32_t gk_count; - caddr32_t gk_attributes; -} crypto_object_generate_key32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -typedef struct crypto_object_generate_key_pair32 { - uint32_t kp_return_value; - crypto_session_id_t kp_session; - crypto_object_id_t kp_public_handle; - crypto_object_id_t kp_private_handle; - uint32_t kp_public_count; - uint32_t kp_private_count; - caddr32_t kp_public_attributes; - caddr32_t kp_private_attributes; - crypto_mechanism32_t kp_mechanism; -} crypto_object_generate_key_pair32_t; - -typedef struct crypto_object_wrap_key32 { - uint32_t wk_return_value; - crypto_session_id_t wk_session; - crypto_mechanism32_t wk_mechanism; - crypto_key32_t wk_wrapping_key; - crypto_object_id_t wk_object_handle; - size32_t wk_wrapped_key_len; - caddr32_t wk_wrapped_key; -} crypto_object_wrap_key32_t; - -typedef struct crypto_object_unwrap_key32 { - uint32_t uk_return_value; - crypto_session_id_t uk_session; - crypto_mechanism32_t uk_mechanism; - crypto_key32_t uk_unwrapping_key; - crypto_object_id_t uk_object_handle; - size32_t uk_wrapped_key_len; - caddr32_t uk_wrapped_key; - uint32_t uk_count; - caddr32_t uk_attributes; -} crypto_object_unwrap_key32_t; - -typedef struct crypto_derive_key32 { - uint32_t dk_return_value; - crypto_session_id_t dk_session; - crypto_mechanism32_t dk_mechanism; - crypto_key32_t dk_base_key; - crypto_object_id_t dk_object_handle; - uint32_t dk_count; - caddr32_t dk_attributes; -} crypto_derive_key32_t; - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_GENERATE_KEY CRYPTO(110) -#define CRYPTO_GENERATE_KEY_PAIR CRYPTO(111) -#define CRYPTO_WRAP_KEY CRYPTO(112) -#define CRYPTO_UNWRAP_KEY CRYPTO(113) -#define CRYPTO_DERIVE_KEY CRYPTO(114) - -/* - * Provider Management Ioctls - */ - -typedef struct crypto_get_provider_list { - uint_t pl_return_value; - uint_t pl_count; - crypto_provider_entry_t pl_list[1]; -} crypto_get_provider_list_t; - -typedef struct crypto_provider_data { - uchar_t pd_prov_desc[CRYPTO_PROVIDER_DESCR_MAX_LEN]; - uchar_t pd_label[CRYPTO_EXT_SIZE_LABEL]; - uchar_t pd_manufacturerID[CRYPTO_EXT_SIZE_MANUF]; - uchar_t pd_model[CRYPTO_EXT_SIZE_MODEL]; - uchar_t pd_serial_number[CRYPTO_EXT_SIZE_SERIAL]; - ulong_t pd_flags; - ulong_t pd_max_session_count; - ulong_t pd_session_count; - ulong_t pd_max_rw_session_count; - ulong_t pd_rw_session_count; - ulong_t pd_max_pin_len; - ulong_t pd_min_pin_len; - ulong_t pd_total_public_memory; - ulong_t pd_free_public_memory; - ulong_t pd_total_private_memory; - ulong_t pd_free_private_memory; - crypto_version_t pd_hardware_version; - crypto_version_t pd_firmware_version; - uchar_t pd_time[CRYPTO_EXT_SIZE_TIME]; -} crypto_provider_data_t; - -typedef struct crypto_get_provider_info { - uint_t gi_return_value; - crypto_provider_id_t gi_provider_id; - crypto_provider_data_t gi_provider_data; -} crypto_get_provider_info_t; - -typedef struct crypto_get_provider_mechanisms { - uint_t pm_return_value; - crypto_provider_id_t pm_provider_id; - uint_t pm_count; - crypto_mech_name_t pm_list[1]; -} crypto_get_provider_mechanisms_t; - -typedef struct crypto_get_provider_mechanism_info { - uint_t mi_return_value; - crypto_provider_id_t mi_provider_id; - crypto_mech_name_t mi_mechanism_name; - uint32_t mi_min_key_size; - uint32_t mi_max_key_size; - uint32_t mi_flags; -} crypto_get_provider_mechanism_info_t; - -typedef struct crypto_init_token { - uint_t it_return_value; - crypto_provider_id_t it_provider_id; - caddr_t it_pin; - size_t it_pin_len; - caddr_t it_label; -} crypto_init_token_t; - -typedef struct crypto_init_pin { - uint_t ip_return_value; - crypto_session_id_t ip_session; - caddr_t ip_pin; - size_t ip_pin_len; -} crypto_init_pin_t; - -typedef struct crypto_set_pin { - uint_t sp_return_value; - crypto_session_id_t sp_session; - caddr_t sp_old_pin; - size_t sp_old_len; - caddr_t sp_new_pin; - size_t sp_new_len; -} crypto_set_pin_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -typedef struct crypto_get_provider_list32 { - uint32_t pl_return_value; - uint32_t pl_count; - crypto_provider_entry_t pl_list[1]; -} crypto_get_provider_list32_t; - -typedef struct crypto_version32 { - uchar_t cv_major; - uchar_t cv_minor; -} crypto_version32_t; - -typedef struct crypto_provider_data32 { - uchar_t pd_prov_desc[CRYPTO_PROVIDER_DESCR_MAX_LEN]; - uchar_t pd_label[CRYPTO_EXT_SIZE_LABEL]; - uchar_t pd_manufacturerID[CRYPTO_EXT_SIZE_MANUF]; - uchar_t pd_model[CRYPTO_EXT_SIZE_MODEL]; - uchar_t pd_serial_number[CRYPTO_EXT_SIZE_SERIAL]; - uint32_t pd_flags; - uint32_t pd_max_session_count; - uint32_t pd_session_count; - uint32_t pd_max_rw_session_count; - uint32_t pd_rw_session_count; - uint32_t pd_max_pin_len; - uint32_t pd_min_pin_len; - uint32_t pd_total_public_memory; - uint32_t pd_free_public_memory; - uint32_t pd_total_private_memory; - uint32_t pd_free_private_memory; - crypto_version32_t pd_hardware_version; - crypto_version32_t pd_firmware_version; - uchar_t pd_time[CRYPTO_EXT_SIZE_TIME]; -} crypto_provider_data32_t; - -typedef struct crypto_get_provider_info32 { - uint32_t gi_return_value; - crypto_provider_id_t gi_provider_id; - crypto_provider_data32_t gi_provider_data; -} crypto_get_provider_info32_t; - -typedef struct crypto_get_provider_mechanisms32 { - uint32_t pm_return_value; - crypto_provider_id_t pm_provider_id; - uint32_t pm_count; - crypto_mech_name_t pm_list[1]; -} crypto_get_provider_mechanisms32_t; - -typedef struct crypto_init_token32 { - uint32_t it_return_value; - crypto_provider_id_t it_provider_id; - caddr32_t it_pin; - size32_t it_pin_len; - caddr32_t it_label; -} crypto_init_token32_t; - -typedef struct crypto_init_pin32 { - uint32_t ip_return_value; - crypto_session_id_t ip_session; - caddr32_t ip_pin; - size32_t ip_pin_len; -} crypto_init_pin32_t; - -typedef struct crypto_set_pin32 { - uint32_t sp_return_value; - crypto_session_id_t sp_session; - caddr32_t sp_old_pin; - size32_t sp_old_len; - caddr32_t sp_new_pin; - size32_t sp_new_len; -} crypto_set_pin32_t; - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_GET_PROVIDER_LIST CRYPTO(120) -#define CRYPTO_GET_PROVIDER_INFO CRYPTO(121) -#define CRYPTO_GET_PROVIDER_MECHANISMS CRYPTO(122) -#define CRYPTO_GET_PROVIDER_MECHANISM_INFO CRYPTO(123) -#define CRYPTO_INIT_TOKEN CRYPTO(124) -#define CRYPTO_INIT_PIN CRYPTO(125) -#define CRYPTO_SET_PIN CRYPTO(126) - -/* - * No (Key) Store Key Generation Ioctls - */ -typedef struct crypto_nostore_generate_key { - uint_t ngk_return_value; - crypto_session_id_t ngk_session; - crypto_mechanism_t ngk_mechanism; - uint_t ngk_in_count; - uint_t ngk_out_count; - caddr_t ngk_in_attributes; - caddr_t ngk_out_attributes; -} crypto_nostore_generate_key_t; - -typedef struct crypto_nostore_generate_key_pair { - uint_t nkp_return_value; - crypto_session_id_t nkp_session; - uint_t nkp_in_public_count; - uint_t nkp_in_private_count; - uint_t nkp_out_public_count; - uint_t nkp_out_private_count; - caddr_t nkp_in_public_attributes; - caddr_t nkp_in_private_attributes; - caddr_t nkp_out_public_attributes; - caddr_t nkp_out_private_attributes; - crypto_mechanism_t nkp_mechanism; -} crypto_nostore_generate_key_pair_t; - -typedef struct crypto_nostore_derive_key { - uint_t ndk_return_value; - crypto_session_id_t ndk_session; - crypto_mechanism_t ndk_mechanism; - crypto_key_t ndk_base_key; - uint_t ndk_in_count; - uint_t ndk_out_count; - caddr_t ndk_in_attributes; - caddr_t ndk_out_attributes; -} crypto_nostore_derive_key_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -typedef struct crypto_nostore_generate_key32 { - uint32_t ngk_return_value; - crypto_session_id_t ngk_session; - crypto_mechanism32_t ngk_mechanism; - uint32_t ngk_in_count; - uint32_t ngk_out_count; - caddr32_t ngk_in_attributes; - caddr32_t ngk_out_attributes; -} crypto_nostore_generate_key32_t; - -typedef struct crypto_nostore_generate_key_pair32 { - uint32_t nkp_return_value; - crypto_session_id_t nkp_session; - uint32_t nkp_in_public_count; - uint32_t nkp_in_private_count; - uint32_t nkp_out_public_count; - uint32_t nkp_out_private_count; - caddr32_t nkp_in_public_attributes; - caddr32_t nkp_in_private_attributes; - caddr32_t nkp_out_public_attributes; - caddr32_t nkp_out_private_attributes; - crypto_mechanism32_t nkp_mechanism; -} crypto_nostore_generate_key_pair32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack(4) -#endif - -typedef struct crypto_nostore_derive_key32 { - uint32_t ndk_return_value; - crypto_session_id_t ndk_session; - crypto_mechanism32_t ndk_mechanism; - crypto_key32_t ndk_base_key; - uint32_t ndk_in_count; - uint32_t ndk_out_count; - caddr32_t ndk_in_attributes; - caddr32_t ndk_out_attributes; -} crypto_nostore_derive_key32_t; - -#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 -#pragma pack() -#endif - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_NOSTORE_GENERATE_KEY CRYPTO(127) -#define CRYPTO_NOSTORE_GENERATE_KEY_PAIR CRYPTO(128) -#define CRYPTO_NOSTORE_DERIVE_KEY CRYPTO(129) - -/* - * Mechanism Ioctls - */ - -typedef struct crypto_get_mechanism_list { - uint_t ml_return_value; - uint_t ml_count; - crypto_mech_name_t ml_list[1]; -} crypto_get_mechanism_list_t; - -typedef struct crypto_get_all_mechanism_info { - uint_t mi_return_value; - crypto_mech_name_t mi_mechanism_name; - uint_t mi_count; - crypto_mechanism_info_t mi_list[1]; -} crypto_get_all_mechanism_info_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -typedef struct crypto_get_mechanism_list32 { - uint32_t ml_return_value; - uint32_t ml_count; - crypto_mech_name_t ml_list[1]; -} crypto_get_mechanism_list32_t; - -typedef struct crypto_get_all_mechanism_info32 { - uint32_t mi_return_value; - crypto_mech_name_t mi_mechanism_name; - uint32_t mi_count; - crypto_mechanism_info32_t mi_list[1]; -} crypto_get_all_mechanism_info32_t; - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_GET_MECHANISM_LIST CRYPTO(140) -#define CRYPTO_GET_ALL_MECHANISM_INFO CRYPTO(141) - -#ifdef __cplusplus -} -#endif - -#endif /* _SYS_CRYPTO_IOCTL_H */ diff --git a/module/icp/include/sys/crypto/ioctladmin.h b/module/icp/include/sys/crypto/ioctladmin.h deleted file mode 100644 index 24babd7755cc..000000000000 --- a/module/icp/include/sys/crypto/ioctladmin.h +++ /dev/null @@ -1,136 +0,0 @@ -/* - * CDDL HEADER START - * - * The contents of this file are subject to the terms of the - * Common Development and Distribution License, Version 1.0 only - * (the "License"). You may not use this file except in compliance - * with the License. - * - * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE - * or http://www.opensolaris.org/os/licensing. - * See the License for the specific language governing permissions - * and limitations under the License. - * - * When distributing Covered Code, include this CDDL HEADER in each - * file and include the License file at usr/src/OPENSOLARIS.LICENSE. - * If applicable, add the following below this CDDL HEADER, with the - * fields enclosed by brackets "[]" replaced with your own identifying - * information: Portions Copyright [yyyy] [name of copyright owner] - * - * CDDL HEADER END - */ -/* - * Copyright 2005 Sun Microsystems, Inc. All rights reserved. - * Use is subject to license terms. - */ - -#ifndef _SYS_CRYPTO_IOCTLADMIN_H -#define _SYS_CRYPTO_IOCTLADMIN_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#define ADMIN_IOCTL_DEVICE "/dev/cryptoadm" - -#define CRYPTOADMIN(x) (('y' << 8) | (x)) - -/* - * Administrative IOCTLs - */ - -typedef struct crypto_get_dev_list { - uint_t dl_return_value; - uint_t dl_dev_count; - crypto_dev_list_entry_t dl_devs[1]; -} crypto_get_dev_list_t; - -typedef struct crypto_get_soft_list { - uint_t sl_return_value; - uint_t sl_soft_count; - size_t sl_soft_len; - caddr_t sl_soft_names; -} crypto_get_soft_list_t; - -typedef struct crypto_get_dev_info { - uint_t di_return_value; - char di_dev_name[MAXNAMELEN]; - uint_t di_dev_instance; - uint_t di_count; - crypto_mech_name_t di_list[1]; -} crypto_get_dev_info_t; - -typedef struct crypto_get_soft_info { - uint_t si_return_value; - char si_name[MAXNAMELEN]; - uint_t si_count; - crypto_mech_name_t si_list[1]; -} crypto_get_soft_info_t; - -typedef struct crypto_load_dev_disabled { - uint_t dd_return_value; - char dd_dev_name[MAXNAMELEN]; - uint_t dd_dev_instance; - uint_t dd_count; - crypto_mech_name_t dd_list[1]; -} crypto_load_dev_disabled_t; - -typedef struct crypto_load_soft_disabled { - uint_t sd_return_value; - char sd_name[MAXNAMELEN]; - uint_t sd_count; - crypto_mech_name_t sd_list[1]; -} crypto_load_soft_disabled_t; - -typedef struct crypto_unload_soft_module { - uint_t sm_return_value; - char sm_name[MAXNAMELEN]; -} crypto_unload_soft_module_t; - -typedef struct crypto_load_soft_config { - uint_t sc_return_value; - char sc_name[MAXNAMELEN]; - uint_t sc_count; - crypto_mech_name_t sc_list[1]; -} crypto_load_soft_config_t; - -typedef struct crypto_load_door { - uint_t ld_return_value; - uint_t ld_did; -} crypto_load_door_t; - -#ifdef _KERNEL -#ifdef _SYSCALL32 - -typedef struct crypto_get_soft_list32 { - uint32_t sl_return_value; - uint32_t sl_soft_count; - size32_t sl_soft_len; - caddr32_t sl_soft_names; -} crypto_get_soft_list32_t; - -#endif /* _SYSCALL32 */ -#endif /* _KERNEL */ - -#define CRYPTO_GET_VERSION CRYPTOADMIN(1) -#define CRYPTO_GET_DEV_LIST CRYPTOADMIN(2) -#define CRYPTO_GET_SOFT_LIST CRYPTOADMIN(3) -#define CRYPTO_GET_DEV_INFO CRYPTOADMIN(4) -#define CRYPTO_GET_SOFT_INFO CRYPTOADMIN(5) -#define CRYPTO_LOAD_DEV_DISABLED CRYPTOADMIN(8) -#define CRYPTO_LOAD_SOFT_DISABLED CRYPTOADMIN(9) -#define CRYPTO_UNLOAD_SOFT_MODULE CRYPTOADMIN(10) -#define CRYPTO_LOAD_SOFT_CONFIG CRYPTOADMIN(11) -#define CRYPTO_POOL_CREATE CRYPTOADMIN(12) -#define CRYPTO_POOL_WAIT CRYPTOADMIN(13) -#define CRYPTO_POOL_RUN CRYPTOADMIN(14) -#define CRYPTO_LOAD_DOOR CRYPTOADMIN(15) - -#ifdef __cplusplus -} -#endif - -#endif /* _SYS_CRYPTO_IOCTLADMIN_H */