sys/crypto/ioctl.h

	ioctl.h revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_CRYPTO_IOCTL_H
#define _SYS_CRYPTO_IOCTL_H

#pragma ident   "%Z%%M% %I% %E% SMI"

#ifdef  __cplusplus
extern "C" {
#endif

#include <sys/types.h>
#include <sys/crypto/spi.h>
#include <sys/crypto/common.h>

#define CRYPTO_MAX_ATTRIBUTE_COUNT  128

#define CRYPTO_IOFLAGS_RW_SESSION   0x00000001

#define CRYPTO(x)       (('y' << 8) | (x))

/*
 * General Purpose Ioctls
 */

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;
} 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;
} 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;
} 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

/* crypto_mechanism_t is defined in <sys/crypto/common.h> */

typedef struct crypto_mechanism32 {
    crypto_mech_type_t  cm_type;    /* mech. type */
    caddr32_t       cm_param;   /* mech. parameter */
    size32_t        cm_param_len;   /* mech. parameter len */
} crypto_mechanism32_t;

/* crypto_object_attribute_t is defined in <sys/crypto/common.h> */

typedef struct crypto_object_attribute32 {
    uint64_t    oa_type;    /* attribute type */
    caddr32_t   oa_value;   /* attribute value */
    ssize32_t   oa_value_len;   /* length of attribute value */
} crypto_object_attribute32_t;

/* crypto_key_t is defined in <sys/crypto/common.h> */

typedef struct crypto_key32 {
    crypto_key_format_t ck_format;  /* format identifier */
    union {
        /* for CRYPTO_KEY_RAW ck_format */
        struct {
            uint32_t cku_v_length;  /* # of bytes in ck_data */
            caddr32_t cku_v_data;   /* ptr to key value */
        } cku_key_value;

        /* for CRYPTO_KEY_REFERENCE ck_format */
        crypto_object_id_t cku_key_id; /* reference to object key */

        /* for CRYPTO_KEY_ATTR_LIST ck_format */
        struct {
            uint32_t cku_a_count;   /* number of attributes */
            caddr32_t cku_a_oattr;
        } cku_key_attrs;
    } cku_data;             /* Crypto Key union */
} crypto_key32_t;

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;
} 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;
} 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)

#ifdef  __cplusplus
}
#endif

#endif  /* _SYS_CRYPTO_IOCTL_H */