630 lines
20 KiB
C
630 lines
20 KiB
C
/*
|
|
* 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_OPS_IMPL_H
|
|
#define _SYS_CRYPTO_OPS_IMPL_H
|
|
|
|
/*
|
|
* Scheduler internal structures.
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <sys/zfs_context.h>
|
|
#include <sys/crypto/api.h>
|
|
#include <sys/crypto/spi.h>
|
|
#include <sys/crypto/impl.h>
|
|
#include <sys/crypto/common.h>
|
|
|
|
/*
|
|
* The parameters needed for each function group are batched
|
|
* in one structure. This is much simpler than having a
|
|
* separate structure for each function.
|
|
*
|
|
* In some cases, a field is generically named to keep the
|
|
* structure small. The comments indicate these cases.
|
|
*/
|
|
typedef struct kcf_digest_ops_params {
|
|
crypto_session_id_t do_sid;
|
|
crypto_mech_type_t do_framework_mechtype;
|
|
crypto_mechanism_t do_mech;
|
|
crypto_data_t *do_data;
|
|
crypto_data_t *do_digest;
|
|
crypto_key_t *do_digest_key; /* Argument for digest_key() */
|
|
} kcf_digest_ops_params_t;
|
|
|
|
typedef struct kcf_mac_ops_params {
|
|
crypto_session_id_t mo_sid;
|
|
crypto_mech_type_t mo_framework_mechtype;
|
|
crypto_mechanism_t mo_mech;
|
|
crypto_key_t *mo_key;
|
|
crypto_data_t *mo_data;
|
|
crypto_data_t *mo_mac;
|
|
crypto_spi_ctx_template_t mo_templ;
|
|
} kcf_mac_ops_params_t;
|
|
|
|
typedef struct kcf_encrypt_ops_params {
|
|
crypto_session_id_t eo_sid;
|
|
crypto_mech_type_t eo_framework_mechtype;
|
|
crypto_mechanism_t eo_mech;
|
|
crypto_key_t *eo_key;
|
|
crypto_data_t *eo_plaintext;
|
|
crypto_data_t *eo_ciphertext;
|
|
crypto_spi_ctx_template_t eo_templ;
|
|
} kcf_encrypt_ops_params_t;
|
|
|
|
typedef struct kcf_decrypt_ops_params {
|
|
crypto_session_id_t dop_sid;
|
|
crypto_mech_type_t dop_framework_mechtype;
|
|
crypto_mechanism_t dop_mech;
|
|
crypto_key_t *dop_key;
|
|
crypto_data_t *dop_ciphertext;
|
|
crypto_data_t *dop_plaintext;
|
|
crypto_spi_ctx_template_t dop_templ;
|
|
} kcf_decrypt_ops_params_t;
|
|
|
|
typedef struct kcf_sign_ops_params {
|
|
crypto_session_id_t so_sid;
|
|
crypto_mech_type_t so_framework_mechtype;
|
|
crypto_mechanism_t so_mech;
|
|
crypto_key_t *so_key;
|
|
crypto_data_t *so_data;
|
|
crypto_data_t *so_signature;
|
|
crypto_spi_ctx_template_t so_templ;
|
|
} kcf_sign_ops_params_t;
|
|
|
|
typedef struct kcf_verify_ops_params {
|
|
crypto_session_id_t vo_sid;
|
|
crypto_mech_type_t vo_framework_mechtype;
|
|
crypto_mechanism_t vo_mech;
|
|
crypto_key_t *vo_key;
|
|
crypto_data_t *vo_data;
|
|
crypto_data_t *vo_signature;
|
|
crypto_spi_ctx_template_t vo_templ;
|
|
} kcf_verify_ops_params_t;
|
|
|
|
typedef struct kcf_encrypt_mac_ops_params {
|
|
crypto_session_id_t em_sid;
|
|
crypto_mech_type_t em_framework_encr_mechtype;
|
|
crypto_mechanism_t em_encr_mech;
|
|
crypto_key_t *em_encr_key;
|
|
crypto_mech_type_t em_framework_mac_mechtype;
|
|
crypto_mechanism_t em_mac_mech;
|
|
crypto_key_t *em_mac_key;
|
|
crypto_data_t *em_plaintext;
|
|
crypto_dual_data_t *em_ciphertext;
|
|
crypto_data_t *em_mac;
|
|
crypto_spi_ctx_template_t em_encr_templ;
|
|
crypto_spi_ctx_template_t em_mac_templ;
|
|
} kcf_encrypt_mac_ops_params_t;
|
|
|
|
typedef struct kcf_mac_decrypt_ops_params {
|
|
crypto_session_id_t md_sid;
|
|
crypto_mech_type_t md_framework_mac_mechtype;
|
|
crypto_mechanism_t md_mac_mech;
|
|
crypto_key_t *md_mac_key;
|
|
crypto_mech_type_t md_framework_decr_mechtype;
|
|
crypto_mechanism_t md_decr_mech;
|
|
crypto_key_t *md_decr_key;
|
|
crypto_dual_data_t *md_ciphertext;
|
|
crypto_data_t *md_mac;
|
|
crypto_data_t *md_plaintext;
|
|
crypto_spi_ctx_template_t md_mac_templ;
|
|
crypto_spi_ctx_template_t md_decr_templ;
|
|
} kcf_mac_decrypt_ops_params_t;
|
|
|
|
typedef struct kcf_random_number_ops_params {
|
|
crypto_session_id_t rn_sid;
|
|
uchar_t *rn_buf;
|
|
size_t rn_buflen;
|
|
uint_t rn_entropy_est;
|
|
uint32_t rn_flags;
|
|
} kcf_random_number_ops_params_t;
|
|
|
|
/*
|
|
* so_pd is useful when the provider descriptor (pd) supplying the
|
|
* provider handle is different from the pd supplying the ops vector.
|
|
* This is the case for session open/close where so_pd can be the pd
|
|
* of a logical provider. The pd supplying the ops vector is passed
|
|
* as an argument to kcf_submit_request().
|
|
*/
|
|
typedef struct kcf_session_ops_params {
|
|
crypto_session_id_t *so_sid_ptr;
|
|
crypto_session_id_t so_sid;
|
|
crypto_user_type_t so_user_type;
|
|
char *so_pin;
|
|
size_t so_pin_len;
|
|
kcf_provider_desc_t *so_pd;
|
|
} kcf_session_ops_params_t;
|
|
|
|
typedef struct kcf_object_ops_params {
|
|
crypto_session_id_t oo_sid;
|
|
crypto_object_id_t oo_object_id;
|
|
crypto_object_attribute_t *oo_template;
|
|
uint_t oo_attribute_count;
|
|
crypto_object_id_t *oo_object_id_ptr;
|
|
size_t *oo_object_size;
|
|
void **oo_find_init_pp_ptr;
|
|
void *oo_find_pp;
|
|
uint_t oo_max_object_count;
|
|
uint_t *oo_object_count_ptr;
|
|
} kcf_object_ops_params_t;
|
|
|
|
/*
|
|
* ko_key is used to encode wrapping key in key_wrap() and
|
|
* unwrapping key in key_unwrap(). ko_key_template and
|
|
* ko_key_attribute_count are used to encode public template
|
|
* and public template attr count in key_generate_pair().
|
|
* kops->ko_key_object_id_ptr is used to encode public key
|
|
* in key_generate_pair().
|
|
*/
|
|
typedef struct kcf_key_ops_params {
|
|
crypto_session_id_t ko_sid;
|
|
crypto_mech_type_t ko_framework_mechtype;
|
|
crypto_mechanism_t ko_mech;
|
|
crypto_object_attribute_t *ko_key_template;
|
|
uint_t ko_key_attribute_count;
|
|
crypto_object_id_t *ko_key_object_id_ptr;
|
|
crypto_object_attribute_t *ko_private_key_template;
|
|
uint_t ko_private_key_attribute_count;
|
|
crypto_object_id_t *ko_private_key_object_id_ptr;
|
|
crypto_key_t *ko_key;
|
|
uchar_t *ko_wrapped_key;
|
|
size_t *ko_wrapped_key_len_ptr;
|
|
crypto_object_attribute_t *ko_out_template1;
|
|
crypto_object_attribute_t *ko_out_template2;
|
|
uint_t ko_out_attribute_count1;
|
|
uint_t ko_out_attribute_count2;
|
|
} kcf_key_ops_params_t;
|
|
|
|
/*
|
|
* po_pin and po_pin_len are used to encode new_pin and new_pin_len
|
|
* when wrapping set_pin() function parameters.
|
|
*
|
|
* po_pd is useful when the provider descriptor (pd) supplying the
|
|
* provider handle is different from the pd supplying the ops vector.
|
|
* This is true for the ext_info provider entry point where po_pd
|
|
* can be the pd of a logical provider. The pd supplying the ops vector
|
|
* is passed as an argument to kcf_submit_request().
|
|
*/
|
|
typedef struct kcf_provmgmt_ops_params {
|
|
crypto_session_id_t po_sid;
|
|
char *po_pin;
|
|
size_t po_pin_len;
|
|
char *po_old_pin;
|
|
size_t po_old_pin_len;
|
|
char *po_label;
|
|
crypto_provider_ext_info_t *po_ext_info;
|
|
kcf_provider_desc_t *po_pd;
|
|
} kcf_provmgmt_ops_params_t;
|
|
|
|
/*
|
|
* The operation type within a function group.
|
|
*/
|
|
typedef enum kcf_op_type {
|
|
/* common ops for all mechanisms */
|
|
KCF_OP_INIT = 1,
|
|
KCF_OP_SINGLE, /* pkcs11 sense. So, INIT is already done */
|
|
KCF_OP_UPDATE,
|
|
KCF_OP_FINAL,
|
|
KCF_OP_ATOMIC,
|
|
|
|
/* digest_key op */
|
|
KCF_OP_DIGEST_KEY,
|
|
|
|
/* mac specific op */
|
|
KCF_OP_MAC_VERIFY_ATOMIC,
|
|
|
|
/* mac/cipher specific op */
|
|
KCF_OP_MAC_VERIFY_DECRYPT_ATOMIC,
|
|
|
|
/* sign_recover ops */
|
|
KCF_OP_SIGN_RECOVER_INIT,
|
|
KCF_OP_SIGN_RECOVER,
|
|
KCF_OP_SIGN_RECOVER_ATOMIC,
|
|
|
|
/* verify_recover ops */
|
|
KCF_OP_VERIFY_RECOVER_INIT,
|
|
KCF_OP_VERIFY_RECOVER,
|
|
KCF_OP_VERIFY_RECOVER_ATOMIC,
|
|
|
|
/* random number ops */
|
|
KCF_OP_RANDOM_SEED,
|
|
KCF_OP_RANDOM_GENERATE,
|
|
|
|
/* session management ops */
|
|
KCF_OP_SESSION_OPEN,
|
|
KCF_OP_SESSION_CLOSE,
|
|
KCF_OP_SESSION_LOGIN,
|
|
KCF_OP_SESSION_LOGOUT,
|
|
|
|
/* object management ops */
|
|
KCF_OP_OBJECT_CREATE,
|
|
KCF_OP_OBJECT_COPY,
|
|
KCF_OP_OBJECT_DESTROY,
|
|
KCF_OP_OBJECT_GET_SIZE,
|
|
KCF_OP_OBJECT_GET_ATTRIBUTE_VALUE,
|
|
KCF_OP_OBJECT_SET_ATTRIBUTE_VALUE,
|
|
KCF_OP_OBJECT_FIND_INIT,
|
|
KCF_OP_OBJECT_FIND,
|
|
KCF_OP_OBJECT_FIND_FINAL,
|
|
|
|
/* key management ops */
|
|
KCF_OP_KEY_GENERATE,
|
|
KCF_OP_KEY_GENERATE_PAIR,
|
|
KCF_OP_KEY_WRAP,
|
|
KCF_OP_KEY_UNWRAP,
|
|
KCF_OP_KEY_DERIVE,
|
|
KCF_OP_KEY_CHECK,
|
|
|
|
/* provider management ops */
|
|
KCF_OP_MGMT_EXTINFO,
|
|
KCF_OP_MGMT_INITTOKEN,
|
|
KCF_OP_MGMT_INITPIN,
|
|
KCF_OP_MGMT_SETPIN
|
|
} kcf_op_type_t;
|
|
|
|
/*
|
|
* The operation groups that need wrapping of parameters. This is somewhat
|
|
* similar to the function group type in spi.h except that this also includes
|
|
* all the functions that don't have a mechanism.
|
|
*
|
|
* The wrapper macros should never take these enum values as an argument.
|
|
* Rather, they are assigned in the macro itself since they are known
|
|
* from the macro name.
|
|
*/
|
|
typedef enum kcf_op_group {
|
|
KCF_OG_DIGEST = 1,
|
|
KCF_OG_MAC,
|
|
KCF_OG_ENCRYPT,
|
|
KCF_OG_DECRYPT,
|
|
KCF_OG_SIGN,
|
|
KCF_OG_VERIFY,
|
|
KCF_OG_ENCRYPT_MAC,
|
|
KCF_OG_MAC_DECRYPT,
|
|
KCF_OG_RANDOM,
|
|
KCF_OG_SESSION,
|
|
KCF_OG_OBJECT,
|
|
KCF_OG_KEY,
|
|
KCF_OG_PROVMGMT,
|
|
KCF_OG_NOSTORE_KEY
|
|
} kcf_op_group_t;
|
|
|
|
/*
|
|
* The kcf_op_type_t enum values used here should be only for those
|
|
* operations for which there is a k-api routine in sys/crypto/api.h.
|
|
*/
|
|
#define IS_INIT_OP(ftype) ((ftype) == KCF_OP_INIT)
|
|
#define IS_SINGLE_OP(ftype) ((ftype) == KCF_OP_SINGLE)
|
|
#define IS_UPDATE_OP(ftype) ((ftype) == KCF_OP_UPDATE)
|
|
#define IS_FINAL_OP(ftype) ((ftype) == KCF_OP_FINAL)
|
|
#define IS_ATOMIC_OP(ftype) ( \
|
|
(ftype) == KCF_OP_ATOMIC || (ftype) == KCF_OP_MAC_VERIFY_ATOMIC || \
|
|
(ftype) == KCF_OP_MAC_VERIFY_DECRYPT_ATOMIC || \
|
|
(ftype) == KCF_OP_SIGN_RECOVER_ATOMIC || \
|
|
(ftype) == KCF_OP_VERIFY_RECOVER_ATOMIC)
|
|
|
|
/*
|
|
* Keep the parameters associated with a request around.
|
|
* We need to pass them to the SPI.
|
|
*/
|
|
typedef struct kcf_req_params {
|
|
kcf_op_group_t rp_opgrp;
|
|
kcf_op_type_t rp_optype;
|
|
|
|
union {
|
|
kcf_digest_ops_params_t digest_params;
|
|
kcf_mac_ops_params_t mac_params;
|
|
kcf_encrypt_ops_params_t encrypt_params;
|
|
kcf_decrypt_ops_params_t decrypt_params;
|
|
kcf_sign_ops_params_t sign_params;
|
|
kcf_verify_ops_params_t verify_params;
|
|
kcf_encrypt_mac_ops_params_t encrypt_mac_params;
|
|
kcf_mac_decrypt_ops_params_t mac_decrypt_params;
|
|
kcf_random_number_ops_params_t random_number_params;
|
|
kcf_session_ops_params_t session_params;
|
|
kcf_object_ops_params_t object_params;
|
|
kcf_key_ops_params_t key_params;
|
|
kcf_provmgmt_ops_params_t provmgmt_params;
|
|
} rp_u;
|
|
} kcf_req_params_t;
|
|
|
|
|
|
/*
|
|
* The ioctl/k-api code should bundle the parameters into a kcf_req_params_t
|
|
* structure before calling a scheduler routine. The following macros are
|
|
* available for that purpose.
|
|
*
|
|
* For the most part, the macro arguments closely correspond to the
|
|
* function parameters. In some cases, we use generic names. The comments
|
|
* for the structure should indicate these cases.
|
|
*/
|
|
#define KCF_WRAP_DIGEST_OPS_PARAMS(req, ftype, _sid, _mech, _key, \
|
|
_data, _digest) { \
|
|
kcf_digest_ops_params_t *dops = &(req)->rp_u.digest_params; \
|
|
crypto_mechanism_t *mechp = _mech; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_DIGEST; \
|
|
(req)->rp_optype = ftype; \
|
|
dops->do_sid = _sid; \
|
|
if (mechp != NULL) { \
|
|
dops->do_mech = *mechp; \
|
|
dops->do_framework_mechtype = mechp->cm_type; \
|
|
} \
|
|
dops->do_digest_key = _key; \
|
|
dops->do_data = _data; \
|
|
dops->do_digest = _digest; \
|
|
}
|
|
|
|
#define KCF_WRAP_MAC_OPS_PARAMS(req, ftype, _sid, _mech, _key, \
|
|
_data, _mac, _templ) { \
|
|
kcf_mac_ops_params_t *mops = &(req)->rp_u.mac_params; \
|
|
crypto_mechanism_t *mechp = _mech; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_MAC; \
|
|
(req)->rp_optype = ftype; \
|
|
mops->mo_sid = _sid; \
|
|
if (mechp != NULL) { \
|
|
mops->mo_mech = *mechp; \
|
|
mops->mo_framework_mechtype = mechp->cm_type; \
|
|
} \
|
|
mops->mo_key = _key; \
|
|
mops->mo_data = _data; \
|
|
mops->mo_mac = _mac; \
|
|
mops->mo_templ = _templ; \
|
|
}
|
|
|
|
#define KCF_WRAP_ENCRYPT_OPS_PARAMS(req, ftype, _sid, _mech, _key, \
|
|
_plaintext, _ciphertext, _templ) { \
|
|
kcf_encrypt_ops_params_t *cops = &(req)->rp_u.encrypt_params; \
|
|
crypto_mechanism_t *mechp = _mech; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_ENCRYPT; \
|
|
(req)->rp_optype = ftype; \
|
|
cops->eo_sid = _sid; \
|
|
if (mechp != NULL) { \
|
|
cops->eo_mech = *mechp; \
|
|
cops->eo_framework_mechtype = mechp->cm_type; \
|
|
} \
|
|
cops->eo_key = _key; \
|
|
cops->eo_plaintext = _plaintext; \
|
|
cops->eo_ciphertext = _ciphertext; \
|
|
cops->eo_templ = _templ; \
|
|
}
|
|
|
|
#define KCF_WRAP_DECRYPT_OPS_PARAMS(req, ftype, _sid, _mech, _key, \
|
|
_ciphertext, _plaintext, _templ) { \
|
|
kcf_decrypt_ops_params_t *cops = &(req)->rp_u.decrypt_params; \
|
|
crypto_mechanism_t *mechp = _mech; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_DECRYPT; \
|
|
(req)->rp_optype = ftype; \
|
|
cops->dop_sid = _sid; \
|
|
if (mechp != NULL) { \
|
|
cops->dop_mech = *mechp; \
|
|
cops->dop_framework_mechtype = mechp->cm_type; \
|
|
} \
|
|
cops->dop_key = _key; \
|
|
cops->dop_ciphertext = _ciphertext; \
|
|
cops->dop_plaintext = _plaintext; \
|
|
cops->dop_templ = _templ; \
|
|
}
|
|
|
|
#define KCF_WRAP_SIGN_OPS_PARAMS(req, ftype, _sid, _mech, _key, \
|
|
_data, _signature, _templ) { \
|
|
kcf_sign_ops_params_t *sops = &(req)->rp_u.sign_params; \
|
|
crypto_mechanism_t *mechp = _mech; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_SIGN; \
|
|
(req)->rp_optype = ftype; \
|
|
sops->so_sid = _sid; \
|
|
if (mechp != NULL) { \
|
|
sops->so_mech = *mechp; \
|
|
sops->so_framework_mechtype = mechp->cm_type; \
|
|
} \
|
|
sops->so_key = _key; \
|
|
sops->so_data = _data; \
|
|
sops->so_signature = _signature; \
|
|
sops->so_templ = _templ; \
|
|
}
|
|
|
|
#define KCF_WRAP_VERIFY_OPS_PARAMS(req, ftype, _sid, _mech, _key, \
|
|
_data, _signature, _templ) { \
|
|
kcf_verify_ops_params_t *vops = &(req)->rp_u.verify_params; \
|
|
crypto_mechanism_t *mechp = _mech; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_VERIFY; \
|
|
(req)->rp_optype = ftype; \
|
|
vops->vo_sid = _sid; \
|
|
if (mechp != NULL) { \
|
|
vops->vo_mech = *mechp; \
|
|
vops->vo_framework_mechtype = mechp->cm_type; \
|
|
} \
|
|
vops->vo_key = _key; \
|
|
vops->vo_data = _data; \
|
|
vops->vo_signature = _signature; \
|
|
vops->vo_templ = _templ; \
|
|
}
|
|
|
|
#define KCF_WRAP_ENCRYPT_MAC_OPS_PARAMS(req, ftype, _sid, _encr_key, \
|
|
_mac_key, _plaintext, _ciphertext, _mac, _encr_templ, _mac_templ) { \
|
|
kcf_encrypt_mac_ops_params_t *cmops = &(req)->rp_u.encrypt_mac_params; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_ENCRYPT_MAC; \
|
|
(req)->rp_optype = ftype; \
|
|
cmops->em_sid = _sid; \
|
|
cmops->em_encr_key = _encr_key; \
|
|
cmops->em_mac_key = _mac_key; \
|
|
cmops->em_plaintext = _plaintext; \
|
|
cmops->em_ciphertext = _ciphertext; \
|
|
cmops->em_mac = _mac; \
|
|
cmops->em_encr_templ = _encr_templ; \
|
|
cmops->em_mac_templ = _mac_templ; \
|
|
}
|
|
|
|
#define KCF_WRAP_MAC_DECRYPT_OPS_PARAMS(req, ftype, _sid, _mac_key, \
|
|
_decr_key, _ciphertext, _mac, _plaintext, _mac_templ, _decr_templ) { \
|
|
kcf_mac_decrypt_ops_params_t *cmops = &(req)->rp_u.mac_decrypt_params; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_MAC_DECRYPT; \
|
|
(req)->rp_optype = ftype; \
|
|
cmops->md_sid = _sid; \
|
|
cmops->md_mac_key = _mac_key; \
|
|
cmops->md_decr_key = _decr_key; \
|
|
cmops->md_ciphertext = _ciphertext; \
|
|
cmops->md_mac = _mac; \
|
|
cmops->md_plaintext = _plaintext; \
|
|
cmops->md_mac_templ = _mac_templ; \
|
|
cmops->md_decr_templ = _decr_templ; \
|
|
}
|
|
|
|
#define KCF_WRAP_RANDOM_OPS_PARAMS(req, ftype, _sid, _buf, _buflen, \
|
|
_est, _flags) { \
|
|
kcf_random_number_ops_params_t *rops = \
|
|
&(req)->rp_u.random_number_params; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_RANDOM; \
|
|
(req)->rp_optype = ftype; \
|
|
rops->rn_sid = _sid; \
|
|
rops->rn_buf = _buf; \
|
|
rops->rn_buflen = _buflen; \
|
|
rops->rn_entropy_est = _est; \
|
|
rops->rn_flags = _flags; \
|
|
}
|
|
|
|
#define KCF_WRAP_SESSION_OPS_PARAMS(req, ftype, _sid_ptr, _sid, \
|
|
_user_type, _pin, _pin_len, _pd) { \
|
|
kcf_session_ops_params_t *sops = &(req)->rp_u.session_params; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_SESSION; \
|
|
(req)->rp_optype = ftype; \
|
|
sops->so_sid_ptr = _sid_ptr; \
|
|
sops->so_sid = _sid; \
|
|
sops->so_user_type = _user_type; \
|
|
sops->so_pin = _pin; \
|
|
sops->so_pin_len = _pin_len; \
|
|
sops->so_pd = _pd; \
|
|
}
|
|
|
|
#define KCF_WRAP_OBJECT_OPS_PARAMS(req, ftype, _sid, _object_id, \
|
|
_template, _attribute_count, _object_id_ptr, _object_size, \
|
|
_find_init_pp_ptr, _find_pp, _max_object_count, _object_count_ptr) { \
|
|
kcf_object_ops_params_t *jops = &(req)->rp_u.object_params; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_OBJECT; \
|
|
(req)->rp_optype = ftype; \
|
|
jops->oo_sid = _sid; \
|
|
jops->oo_object_id = _object_id; \
|
|
jops->oo_template = _template; \
|
|
jops->oo_attribute_count = _attribute_count; \
|
|
jops->oo_object_id_ptr = _object_id_ptr; \
|
|
jops->oo_object_size = _object_size; \
|
|
jops->oo_find_init_pp_ptr = _find_init_pp_ptr; \
|
|
jops->oo_find_pp = _find_pp; \
|
|
jops->oo_max_object_count = _max_object_count; \
|
|
jops->oo_object_count_ptr = _object_count_ptr; \
|
|
}
|
|
|
|
#define KCF_WRAP_KEY_OPS_PARAMS(req, ftype, _sid, _mech, _key_template, \
|
|
_key_attribute_count, _key_object_id_ptr, _private_key_template, \
|
|
_private_key_attribute_count, _private_key_object_id_ptr, \
|
|
_key, _wrapped_key, _wrapped_key_len_ptr) { \
|
|
kcf_key_ops_params_t *kops = &(req)->rp_u.key_params; \
|
|
crypto_mechanism_t *mechp = _mech; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_KEY; \
|
|
(req)->rp_optype = ftype; \
|
|
kops->ko_sid = _sid; \
|
|
if (mechp != NULL) { \
|
|
kops->ko_mech = *mechp; \
|
|
kops->ko_framework_mechtype = mechp->cm_type; \
|
|
} \
|
|
kops->ko_key_template = _key_template; \
|
|
kops->ko_key_attribute_count = _key_attribute_count; \
|
|
kops->ko_key_object_id_ptr = _key_object_id_ptr; \
|
|
kops->ko_private_key_template = _private_key_template; \
|
|
kops->ko_private_key_attribute_count = _private_key_attribute_count; \
|
|
kops->ko_private_key_object_id_ptr = _private_key_object_id_ptr; \
|
|
kops->ko_key = _key; \
|
|
kops->ko_wrapped_key = _wrapped_key; \
|
|
kops->ko_wrapped_key_len_ptr = _wrapped_key_len_ptr; \
|
|
}
|
|
|
|
#define KCF_WRAP_PROVMGMT_OPS_PARAMS(req, ftype, _sid, _old_pin, \
|
|
_old_pin_len, _pin, _pin_len, _label, _ext_info, _pd) { \
|
|
kcf_provmgmt_ops_params_t *pops = &(req)->rp_u.provmgmt_params; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_PROVMGMT; \
|
|
(req)->rp_optype = ftype; \
|
|
pops->po_sid = _sid; \
|
|
pops->po_pin = _pin; \
|
|
pops->po_pin_len = _pin_len; \
|
|
pops->po_old_pin = _old_pin; \
|
|
pops->po_old_pin_len = _old_pin_len; \
|
|
pops->po_label = _label; \
|
|
pops->po_ext_info = _ext_info; \
|
|
pops->po_pd = _pd; \
|
|
}
|
|
|
|
#define KCF_WRAP_NOSTORE_KEY_OPS_PARAMS(req, ftype, _sid, _mech, \
|
|
_key_template, _key_attribute_count, _private_key_template, \
|
|
_private_key_attribute_count, _key, _out_template1, \
|
|
_out_attribute_count1, _out_template2, _out_attribute_count2) { \
|
|
kcf_key_ops_params_t *kops = &(req)->rp_u.key_params; \
|
|
crypto_mechanism_t *mechp = _mech; \
|
|
\
|
|
(req)->rp_opgrp = KCF_OG_NOSTORE_KEY; \
|
|
(req)->rp_optype = ftype; \
|
|
kops->ko_sid = _sid; \
|
|
if (mechp != NULL) { \
|
|
kops->ko_mech = *mechp; \
|
|
kops->ko_framework_mechtype = mechp->cm_type; \
|
|
} \
|
|
kops->ko_key_template = _key_template; \
|
|
kops->ko_key_attribute_count = _key_attribute_count; \
|
|
kops->ko_key_object_id_ptr = NULL; \
|
|
kops->ko_private_key_template = _private_key_template; \
|
|
kops->ko_private_key_attribute_count = _private_key_attribute_count; \
|
|
kops->ko_private_key_object_id_ptr = NULL; \
|
|
kops->ko_key = _key; \
|
|
kops->ko_wrapped_key = NULL; \
|
|
kops->ko_wrapped_key_len_ptr = 0; \
|
|
kops->ko_out_template1 = _out_template1; \
|
|
kops->ko_out_template2 = _out_template2; \
|
|
kops->ko_out_attribute_count1 = _out_attribute_count1; \
|
|
kops->ko_out_attribute_count2 = _out_attribute_count2; \
|
|
}
|
|
|
|
#define KCF_SET_PROVIDER_MECHNUM(fmtype, pd, mechp) \
|
|
(mechp)->cm_type = \
|
|
KCF_TO_PROV_MECHNUM(pd, fmtype);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _SYS_CRYPTO_OPS_IMPL_H */
|