include/sys/crypto/common.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 /*
  25  * Copyright 2013 Saso Kiselkov.  All rights reserved.
  26  */
  27
  28 #ifndef _SYS_CRYPTO_COMMON_H
  29 #define _SYS_CRYPTO_COMMON_H
  30
  31 /*
  32  * Header file for the common data structures of the cryptographic framework
  33  */
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif
  38
  39 #include <sys/types.h>
  40 #include <sys/uio.h>
  41 #include <sys/stream.h>
  42 #include <sys/mutex.h>
  43 #include <sys/condvar.h>
  44
  45
  46 /* Cryptographic Mechanisms */
  47
  48 #define CRYPTO_MAX_MECH_NAME 32
  49 typedef char crypto_mech_name_t[CRYPTO_MAX_MECH_NAME];
  50
  51 typedef uint64_t crypto_mech_type_t;
  52
  53 typedef struct crypto_mechanism {
  54         crypto_mech_type_t      cm_type;        /* mechanism type */
  55         caddr_t                 cm_param;       /* mech. parameter */
  56         size_t                  cm_param_len;   /* mech. parameter len */
  57 } crypto_mechanism_t;
  58
  59 #ifdef  _SYSCALL32
  60
  61 typedef struct crypto_mechanism32 {
  62         crypto_mech_type_t      cm_type;        /* mechanism type */
  63         caddr32_t               cm_param;       /* mech. parameter */
  64         size32_t                cm_param_len;   /* mech. parameter len */
  65 } crypto_mechanism32_t;
  66
  67 #endif  /* _SYSCALL32 */
  68
  69 #ifdef _KERNEL
  70 /* CK_AES_CTR_PARAMS provides parameters to the CKM_AES_CTR mechanism */
  71 typedef struct CK_AES_CTR_PARAMS {
  72         ulong_t ulCounterBits;
  73         uint8_t cb[16];
  74 } CK_AES_CTR_PARAMS;
  75 #endif
  76
  77 /* CK_AES_CCM_PARAMS provides parameters to the CKM_AES_CCM mechanism */
  78 typedef struct CK_AES_CCM_PARAMS {
  79         ulong_t ulMACSize;
  80         ulong_t ulNonceSize;
  81         ulong_t ulAuthDataSize;
  82         ulong_t ulDataSize; /* used for plaintext or ciphertext */
  83         uchar_t *nonce;
  84         uchar_t *authData;
  85 } CK_AES_CCM_PARAMS;
  86
  87 /* CK_AES_GCM_PARAMS provides parameters to the CKM_AES_GCM mechanism */
  88 typedef struct CK_AES_GCM_PARAMS {
  89         uchar_t *pIv;
  90         ulong_t ulIvLen;
  91         ulong_t ulIvBits;
  92         uchar_t *pAAD;
  93         ulong_t ulAADLen;
  94         ulong_t ulTagBits;
  95 } CK_AES_GCM_PARAMS;
  96
  97 /* CK_AES_GMAC_PARAMS provides parameters to the CKM_AES_GMAC mechanism */
  98 typedef struct CK_AES_GMAC_PARAMS {
  99         uchar_t *pIv;
 100         uchar_t *pAAD;
 101         ulong_t ulAADLen;
 102 } CK_AES_GMAC_PARAMS;
 103
 104 #ifdef _KERNEL
 105 /*
 106  * CK_ECDH1_DERIVE_PARAMS provides the parameters to the
 107  * CKM_ECDH1_KEY_DERIVE mechanism
 108  */
 109 typedef struct CK_ECDH1_DERIVE_PARAMS {
 110         ulong_t         kdf;
 111         ulong_t         ulSharedDataLen;
 112         uchar_t         *pSharedData;
 113         ulong_t         ulPublicDataLen;
 114         uchar_t         *pPublicData;
 115 } CK_ECDH1_DERIVE_PARAMS;
 116 #endif
 117
 118 #ifdef _KERNEL
 119 #ifdef  _SYSCALL32
 120
 121 /* needed for 32-bit applications running on 64-bit kernels */
 122 typedef struct CK_AES_CTR_PARAMS32 {
 123         uint32_t ulCounterBits;
 124         uint8_t cb[16];
 125 } CK_AES_CTR_PARAMS32;
 126
 127 /* needed for 32-bit applications running on 64-bit kernels */
 128 typedef struct CK_AES_CCM_PARAMS32 {
 129         uint32_t ulMACSize;
 130         uint32_t ulNonceSize;
 131         uint32_t ulAuthDataSize;
 132         uint32_t ulDataSize;
 133         caddr32_t nonce;
 134         caddr32_t authData;
 135 } CK_AES_CCM_PARAMS32;
 136
 137 /* needed for 32-bit applications running on 64-bit kernels */
 138 typedef struct CK_AES_GCM_PARAMS32 {
 139         caddr32_t pIv;
 140         uint32_t ulIvLen;
 141         uint32_t ulIvBits;
 142         caddr32_t pAAD;
 143         uint32_t ulAADLen;
 144         uint32_t ulTagBits;
 145 } CK_AES_GCM_PARAMS32;
 146
 147 /* needed for 32-bit applications running on 64-bit kernels */
 148 typedef struct CK_AES_GMAC_PARAMS32 {
 149         caddr32_t pIv;
 150         caddr32_t pAAD;
 151         uint32_t ulAADLen;
 152 } CK_AES_GMAC_PARAMS32;
 153
 154 typedef struct CK_ECDH1_DERIVE_PARAMS32 {
 155         uint32_t        kdf;
 156         uint32_t        ulSharedDataLen;
 157         caddr32_t       pSharedData;
 158         uint32_t        ulPublicDataLen;
 159         caddr32_t       pPublicData;
 160 } CK_ECDH1_DERIVE_PARAMS32;
 161
 162 #endif  /* _SYSCALL32 */
 163 #endif /* _KERNEL */
 164
 165 /*
 166  * The measurement unit bit flag for a mechanism's minimum or maximum key size.
 167  * The unit are mechanism dependent.  It can be in bits or in bytes.
 168  */
 169 typedef uint32_t crypto_keysize_unit_t;
 170
 171 /*
 172  * The following bit flags are valid in cm_mech_flags field in
 173  * the crypto_mech_info_t structure of the SPI.
 174  *
 175  * Only the first two bit flags are valid in mi_keysize_unit
 176  * field in the crypto_mechanism_info_t structure of the API.
 177  */
 178 #define CRYPTO_KEYSIZE_UNIT_IN_BITS     0x00000001
 179 #define CRYPTO_KEYSIZE_UNIT_IN_BYTES    0x00000002
 180 #define CRYPTO_CAN_SHARE_OPSTATE        0x00000004 /* supports sharing */
 181
 182
 183 /* Mechanisms supported out-of-the-box */
 184 #define SUN_CKM_MD4                     "CKM_MD4"
 185 #define SUN_CKM_MD5                     "CKM_MD5"
 186 #define SUN_CKM_MD5_HMAC                "CKM_MD5_HMAC"
 187 #define SUN_CKM_MD5_HMAC_GENERAL        "CKM_MD5_HMAC_GENERAL"
 188 #define SUN_CKM_SHA1                    "CKM_SHA_1"
 189 #define SUN_CKM_SHA1_HMAC               "CKM_SHA_1_HMAC"
 190 #define SUN_CKM_SHA1_HMAC_GENERAL       "CKM_SHA_1_HMAC_GENERAL"
 191 #define SUN_CKM_SHA256                  "CKM_SHA256"
 192 #define SUN_CKM_SHA256_HMAC             "CKM_SHA256_HMAC"
 193 #define SUN_CKM_SHA256_HMAC_GENERAL     "CKM_SHA256_HMAC_GENERAL"
 194 #define SUN_CKM_SHA384                  "CKM_SHA384"
 195 #define SUN_CKM_SHA384_HMAC             "CKM_SHA384_HMAC"
 196 #define SUN_CKM_SHA384_HMAC_GENERAL     "CKM_SHA384_HMAC_GENERAL"
 197 #define SUN_CKM_SHA512                  "CKM_SHA512"
 198 #define SUN_CKM_SHA512_HMAC             "CKM_SHA512_HMAC"
 199 #define SUN_CKM_SHA512_HMAC_GENERAL     "CKM_SHA512_HMAC_GENERAL"
 200 #define SUN_CKM_SHA512_224              "CKM_SHA512_224"
 201 #define SUN_CKM_SHA512_256              "CKM_SHA512_256"
 202 #define SUN_CKM_DES_CBC                 "CKM_DES_CBC"
 203 #define SUN_CKM_DES3_CBC                "CKM_DES3_CBC"
 204 #define SUN_CKM_DES_ECB                 "CKM_DES_ECB"
 205 #define SUN_CKM_DES3_ECB                "CKM_DES3_ECB"
 206 #define SUN_CKM_BLOWFISH_CBC            "CKM_BLOWFISH_CBC"
 207 #define SUN_CKM_BLOWFISH_ECB            "CKM_BLOWFISH_ECB"
 208 #define SUN_CKM_AES_CBC                 "CKM_AES_CBC"
 209 #define SUN_CKM_AES_ECB                 "CKM_AES_ECB"
 210 #define SUN_CKM_AES_CTR                 "CKM_AES_CTR"
 211 #define SUN_CKM_AES_CCM                 "CKM_AES_CCM"
 212 #define SUN_CKM_AES_GCM                 "CKM_AES_GCM"
 213 #define SUN_CKM_AES_GMAC                "CKM_AES_GMAC"
 214 #define SUN_CKM_AES_CFB128              "CKM_AES_CFB128"
 215 #define SUN_CKM_RC4                     "CKM_RC4"
 216 #define SUN_CKM_RSA_PKCS                "CKM_RSA_PKCS"
 217 #define SUN_CKM_RSA_X_509               "CKM_RSA_X_509"
 218 #define SUN_CKM_MD5_RSA_PKCS            "CKM_MD5_RSA_PKCS"
 219 #define SUN_CKM_SHA1_RSA_PKCS           "CKM_SHA1_RSA_PKCS"
 220 #define SUN_CKM_SHA256_RSA_PKCS         "CKM_SHA256_RSA_PKCS"
 221 #define SUN_CKM_SHA384_RSA_PKCS         "CKM_SHA384_RSA_PKCS"
 222 #define SUN_CKM_SHA512_RSA_PKCS         "CKM_SHA512_RSA_PKCS"
 223 #define SUN_CKM_EC_KEY_PAIR_GEN         "CKM_EC_KEY_PAIR_GEN"
 224 #define SUN_CKM_ECDH1_DERIVE            "CKM_ECDH1_DERIVE"
 225 #define SUN_CKM_ECDSA_SHA1              "CKM_ECDSA_SHA1"
 226 #define SUN_CKM_ECDSA                   "CKM_ECDSA"
 227
 228 /* Shared operation context format for CKM_RC4 */
 229 typedef struct {
 230 #if defined(__amd64)
 231         uint32_t        i, j;
 232         uint32_t        arr[256];
 233         uint32_t        flag;
 234 #else
 235         uchar_t         arr[256];
 236         uchar_t         i, j;
 237 #endif /* __amd64 */
 238         uint64_t        pad;            /* For 64-bit alignment */
 239 } arcfour_state_t;
 240
 241 /* Data arguments of cryptographic operations */
 242
 243 typedef enum crypto_data_format {
 244         CRYPTO_DATA_RAW = 1,
 245         CRYPTO_DATA_UIO,
 246         CRYPTO_DATA_MBLK
 247 } crypto_data_format_t;
 248
 249 typedef struct crypto_data {
 250         crypto_data_format_t    cd_format;      /* Format identifier    */
 251         off_t                   cd_offset;      /* Offset from the beginning */
 252         size_t                  cd_length;      /* # of bytes in use */
 253         caddr_t                 cd_miscdata;    /* ancillary data */
 254         union {
 255                 /* Raw format */
 256                 iovec_t cdu_raw;                /* Pointer and length       */
 257
 258                 /* uio scatter-gather format */
 259                 uio_t   *cdu_uio;
 260
 261                 /* mblk scatter-gather format */
 262                 mblk_t  *cdu_mp;                /* The mblk chain */
 263
 264         } cdu;  /* Crypto Data Union */
 265 } crypto_data_t;
 266
 267 #define cd_raw          cdu.cdu_raw
 268 #define cd_uio          cdu.cdu_uio
 269 #define cd_mp           cdu.cdu_mp
 270
 271 typedef struct crypto_dual_data {
 272         crypto_data_t           dd_data;        /* The data */
 273         off_t                   dd_offset2;     /* Used by dual operation */
 274         size_t                  dd_len2;        /* # of bytes to take   */
 275 } crypto_dual_data_t;
 276
 277 #define dd_format       dd_data.cd_format
 278 #define dd_offset1      dd_data.cd_offset
 279 #define dd_len1         dd_data.cd_length
 280 #define dd_miscdata     dd_data.cd_miscdata
 281 #define dd_raw          dd_data.cd_raw
 282 #define dd_uio          dd_data.cd_uio
 283 #define dd_mp           dd_data.cd_mp
 284
 285 /* The keys, and their contents */
 286
 287 typedef enum {
 288         CRYPTO_KEY_RAW = 1,     /* ck_data is a cleartext key */
 289         CRYPTO_KEY_REFERENCE,   /* ck_obj_id is an opaque reference */
 290         CRYPTO_KEY_ATTR_LIST    /* ck_attrs is a list of object attributes */
 291 } crypto_key_format_t;
 292
 293 typedef uint64_t crypto_attr_type_t;
 294
 295 /* Attribute types to use for passing a RSA public key or a private key. */
 296 #define SUN_CKA_MODULUS                 0x00000120
 297 #define SUN_CKA_MODULUS_BITS            0x00000121
 298 #define SUN_CKA_PUBLIC_EXPONENT         0x00000122
 299 #define SUN_CKA_PRIVATE_EXPONENT        0x00000123
 300 #define SUN_CKA_PRIME_1                 0x00000124
 301 #define SUN_CKA_PRIME_2                 0x00000125
 302 #define SUN_CKA_EXPONENT_1              0x00000126
 303 #define SUN_CKA_EXPONENT_2              0x00000127
 304 #define SUN_CKA_COEFFICIENT             0x00000128
 305 #define SUN_CKA_PRIME                   0x00000130
 306 #define SUN_CKA_SUBPRIME                0x00000131
 307 #define SUN_CKA_BASE                    0x00000132
 308
 309 #define CKK_EC                  0x00000003UL
 310 #define CKK_GENERIC_SECRET      0x00000010UL
 311 #define CKK_RC4                 0x00000012UL
 312 #define CKK_AES                 0x0000001FUL
 313 #define CKK_DES                 0x00000013UL
 314 #define CKK_DES2                0x00000014UL
 315 #define CKK_DES3                0x00000015UL
 316
 317 #define CKO_PUBLIC_KEY          0x00000002UL
 318 #define CKO_PRIVATE_KEY         0x00000003UL
 319 #define CKA_CLASS               0x00000000UL
 320 #define CKA_VALUE               0x00000011UL
 321 #define CKA_KEY_TYPE            0x00000100UL
 322 #define CKA_VALUE_LEN           0x00000161UL
 323 #define CKA_EC_PARAMS           0x00000180UL
 324 #define CKA_EC_POINT            0x00000181UL
 325
 326 typedef uint32_t        crypto_object_id_t;
 327
 328 typedef struct crypto_object_attribute {
 329         crypto_attr_type_t      oa_type;        /* attribute type */
 330         caddr_t                 oa_value;       /* attribute value */
 331         ssize_t                 oa_value_len;   /* length of attribute value */
 332 } crypto_object_attribute_t;
 333
 334 typedef struct crypto_key {
 335         crypto_key_format_t     ck_format;      /* format identifier */
 336         union {
 337                 /* for CRYPTO_KEY_RAW ck_format */
 338                 struct {
 339                         uint_t  cku_v_length;   /* # of bits in ck_data   */
 340                         void    *cku_v_data;    /* ptr to key value */
 341                 } cku_key_value;
 342
 343                 /* for CRYPTO_KEY_REFERENCE ck_format */
 344                 crypto_object_id_t cku_key_id;  /* reference to object key */
 345
 346                 /* for CRYPTO_KEY_ATTR_LIST ck_format */
 347                 struct {
 348                         uint_t cku_a_count;     /* number of attributes */
 349                         crypto_object_attribute_t *cku_a_oattr;
 350                 } cku_key_attrs;
 351         } cku_data;                             /* Crypto Key union */
 352 } crypto_key_t;
 353
 354 #ifdef  _SYSCALL32
 355
 356 typedef struct crypto_object_attribute32 {
 357         uint64_t        oa_type;        /* attribute type */
 358         caddr32_t       oa_value;       /* attribute value */
 359         ssize32_t       oa_value_len;   /* length of attribute value */
 360 } crypto_object_attribute32_t;
 361
 362 typedef struct crypto_key32 {
 363         crypto_key_format_t     ck_format;      /* format identifier */
 364         union {
 365                 /* for CRYPTO_KEY_RAW ck_format */
 366                 struct {
 367                         uint32_t cku_v_length;  /* # of bytes in ck_data */
 368                         caddr32_t cku_v_data;   /* ptr to key value */
 369                 } cku_key_value;
 370
 371                 /* for CRYPTO_KEY_REFERENCE ck_format */
 372                 crypto_object_id_t cku_key_id; /* reference to object key */
 373
 374                 /* for CRYPTO_KEY_ATTR_LIST ck_format */
 375                 struct {
 376                         uint32_t cku_a_count;   /* number of attributes */
 377                         caddr32_t cku_a_oattr;
 378                 } cku_key_attrs;
 379         } cku_data;                             /* Crypto Key union */
 380 } crypto_key32_t;
 381
 382 #endif  /* _SYSCALL32 */
 383
 384 #define ck_data         cku_data.cku_key_value.cku_v_data
 385 #define ck_length       cku_data.cku_key_value.cku_v_length
 386 #define ck_obj_id       cku_data.cku_key_id
 387 #define ck_count        cku_data.cku_key_attrs.cku_a_count
 388 #define ck_attrs        cku_data.cku_key_attrs.cku_a_oattr
 389
 390 /*
 391  * Raw key lengths are expressed in number of bits.
 392  * The following macro returns the minimum number of
 393  * bytes that can contain the specified number of bits.
 394  * Round up without overflowing the integer type.
 395  */
 396 #define CRYPTO_BITS2BYTES(n) ((n) == 0 ? 0 : (((n) - 1) >> 3) + 1)
 397 #define CRYPTO_BYTES2BITS(n) ((n) << 3)
 398
 399 /* Providers */
 400
 401 typedef enum {
 402         CRYPTO_HW_PROVIDER = 0,
 403         CRYPTO_SW_PROVIDER,
 404         CRYPTO_LOGICAL_PROVIDER
 405 } crypto_provider_type_t;
 406
 407 typedef uint32_t        crypto_provider_id_t;
 408 #define KCF_PROVID_INVALID      ((uint32_t)-1)
 409
 410 typedef struct crypto_provider_entry {
 411         crypto_provider_id_t    pe_provider_id;
 412         uint_t                  pe_mechanism_count;
 413 } crypto_provider_entry_t;
 414
 415 typedef struct crypto_dev_list_entry {
 416         char                    le_dev_name[MAXNAMELEN];
 417         uint_t                  le_dev_instance;
 418         uint_t                  le_mechanism_count;
 419 } crypto_dev_list_entry_t;
 420
 421 /* User type for authentication ioctls and SPI entry points */
 422
 423 typedef enum crypto_user_type {
 424         CRYPTO_SO = 0,
 425         CRYPTO_USER
 426 } crypto_user_type_t;
 427
 428 /* Version for provider management ioctls and SPI entry points */
 429
 430 typedef struct crypto_version {
 431         uchar_t cv_major;
 432         uchar_t cv_minor;
 433 } crypto_version_t;
 434
 435 /* session data structure opaque to the consumer */
 436 typedef void *crypto_session_t;
 437
 438 /* provider data structure opaque to the consumer */
 439 typedef void *crypto_provider_t;
 440
 441 /* Limits used by both consumers and providers */
 442 #define CRYPTO_EXT_SIZE_LABEL           32
 443 #define CRYPTO_EXT_SIZE_MANUF           32
 444 #define CRYPTO_EXT_SIZE_MODEL           16
 445 #define CRYPTO_EXT_SIZE_SERIAL          16
 446 #define CRYPTO_EXT_SIZE_TIME            16
 447
 448 typedef struct crypto_provider_ext_info {
 449         uchar_t                 ei_label[CRYPTO_EXT_SIZE_LABEL];
 450         uchar_t                 ei_manufacturerID[CRYPTO_EXT_SIZE_MANUF];
 451         uchar_t                 ei_model[CRYPTO_EXT_SIZE_MODEL];
 452         uchar_t                 ei_serial_number[CRYPTO_EXT_SIZE_SERIAL];
 453         ulong_t                 ei_flags;
 454         ulong_t                 ei_max_session_count;
 455         ulong_t                 ei_max_pin_len;
 456         ulong_t                 ei_min_pin_len;
 457         ulong_t                 ei_total_public_memory;
 458         ulong_t                 ei_free_public_memory;
 459         ulong_t                 ei_total_private_memory;
 460         ulong_t                 ei_free_private_memory;
 461         crypto_version_t        ei_hardware_version;
 462         crypto_version_t        ei_firmware_version;
 463         uchar_t                 ei_time[CRYPTO_EXT_SIZE_TIME];
 464         int                     ei_hash_max_input_len;
 465         int                     ei_hmac_max_input_len;
 466 } crypto_provider_ext_info_t;
 467
 468 typedef uint_t          crypto_session_id_t;
 469
 470 typedef enum cmd_type {
 471         COPY_FROM_DATA,
 472         COPY_TO_DATA,
 473         COMPARE_TO_DATA,
 474         MD5_DIGEST_DATA,
 475         SHA1_DIGEST_DATA,
 476         SHA2_DIGEST_DATA,
 477         GHASH_DATA
 478 } cmd_type_t;
 479
 480 #define CRYPTO_DO_UPDATE        0x01
 481 #define CRYPTO_DO_FINAL         0x02
 482 #define CRYPTO_DO_MD5           0x04
 483 #define CRYPTO_DO_SHA1          0x08
 484 #define CRYPTO_DO_SIGN          0x10
 485 #define CRYPTO_DO_VERIFY        0x20
 486 #define CRYPTO_DO_SHA2          0x40
 487
 488 #define PROVIDER_OWNS_KEY_SCHEDULE      0x00000001
 489
 490 /*
 491  * Common cryptographic status and error codes.
 492  */
 493 #define CRYPTO_SUCCESS                          0x00000000
 494 #define CRYPTO_CANCEL                           0x00000001
 495 #define CRYPTO_HOST_MEMORY                      0x00000002
 496 #define CRYPTO_GENERAL_ERROR                    0x00000003
 497 #define CRYPTO_FAILED                           0x00000004
 498 #define CRYPTO_ARGUMENTS_BAD                    0x00000005
 499 #define CRYPTO_ATTRIBUTE_READ_ONLY              0x00000006
 500 #define CRYPTO_ATTRIBUTE_SENSITIVE              0x00000007
 501 #define CRYPTO_ATTRIBUTE_TYPE_INVALID           0x00000008
 502 #define CRYPTO_ATTRIBUTE_VALUE_INVALID          0x00000009
 503 #define CRYPTO_CANCELED                         0x0000000A
 504 #define CRYPTO_DATA_INVALID                     0x0000000B
 505 #define CRYPTO_DATA_LEN_RANGE                   0x0000000C
 506 #define CRYPTO_DEVICE_ERROR                     0x0000000D
 507 #define CRYPTO_DEVICE_MEMORY                    0x0000000E
 508 #define CRYPTO_DEVICE_REMOVED                   0x0000000F
 509 #define CRYPTO_ENCRYPTED_DATA_INVALID           0x00000010
 510 #define CRYPTO_ENCRYPTED_DATA_LEN_RANGE         0x00000011
 511 #define CRYPTO_KEY_HANDLE_INVALID               0x00000012
 512 #define CRYPTO_KEY_SIZE_RANGE                   0x00000013
 513 #define CRYPTO_KEY_TYPE_INCONSISTENT            0x00000014
 514 #define CRYPTO_KEY_NOT_NEEDED                   0x00000015
 515 #define CRYPTO_KEY_CHANGED                      0x00000016
 516 #define CRYPTO_KEY_NEEDED                       0x00000017
 517 #define CRYPTO_KEY_INDIGESTIBLE                 0x00000018
 518 #define CRYPTO_KEY_FUNCTION_NOT_PERMITTED       0x00000019
 519 #define CRYPTO_KEY_NOT_WRAPPABLE                0x0000001A
 520 #define CRYPTO_KEY_UNEXTRACTABLE                0x0000001B
 521 #define CRYPTO_MECHANISM_INVALID                0x0000001C
 522 #define CRYPTO_MECHANISM_PARAM_INVALID          0x0000001D
 523 #define CRYPTO_OBJECT_HANDLE_INVALID            0x0000001E
 524 #define CRYPTO_OPERATION_IS_ACTIVE              0x0000001F
 525 #define CRYPTO_OPERATION_NOT_INITIALIZED        0x00000020
 526 #define CRYPTO_PIN_INCORRECT                    0x00000021
 527 #define CRYPTO_PIN_INVALID                      0x00000022
 528 #define CRYPTO_PIN_LEN_RANGE                    0x00000023
 529 #define CRYPTO_PIN_EXPIRED                      0x00000024
 530 #define CRYPTO_PIN_LOCKED                       0x00000025
 531 #define CRYPTO_SESSION_CLOSED                   0x00000026
 532 #define CRYPTO_SESSION_COUNT                    0x00000027
 533 #define CRYPTO_SESSION_HANDLE_INVALID           0x00000028
 534 #define CRYPTO_SESSION_READ_ONLY                0x00000029
 535 #define CRYPTO_SESSION_EXISTS                   0x0000002A
 536 #define CRYPTO_SESSION_READ_ONLY_EXISTS         0x0000002B
 537 #define CRYPTO_SESSION_READ_WRITE_SO_EXISTS     0x0000002C
 538 #define CRYPTO_SIGNATURE_INVALID                0x0000002D
 539 #define CRYPTO_SIGNATURE_LEN_RANGE              0x0000002E
 540 #define CRYPTO_TEMPLATE_INCOMPLETE              0x0000002F
 541 #define CRYPTO_TEMPLATE_INCONSISTENT            0x00000030
 542 #define CRYPTO_UNWRAPPING_KEY_HANDLE_INVALID    0x00000031
 543 #define CRYPTO_UNWRAPPING_KEY_SIZE_RANGE        0x00000032
 544 #define CRYPTO_UNWRAPPING_KEY_TYPE_INCONSISTENT 0x00000033
 545 #define CRYPTO_USER_ALREADY_LOGGED_IN           0x00000034
 546 #define CRYPTO_USER_NOT_LOGGED_IN               0x00000035
 547 #define CRYPTO_USER_PIN_NOT_INITIALIZED         0x00000036
 548 #define CRYPTO_USER_TYPE_INVALID                0x00000037
 549 #define CRYPTO_USER_ANOTHER_ALREADY_LOGGED_IN   0x00000038
 550 #define CRYPTO_USER_TOO_MANY_TYPES              0x00000039
 551 #define CRYPTO_WRAPPED_KEY_INVALID              0x0000003A
 552 #define CRYPTO_WRAPPED_KEY_LEN_RANGE            0x0000003B
 553 #define CRYPTO_WRAPPING_KEY_HANDLE_INVALID      0x0000003C
 554 #define CRYPTO_WRAPPING_KEY_SIZE_RANGE          0x0000003D
 555 #define CRYPTO_WRAPPING_KEY_TYPE_INCONSISTENT   0x0000003E
 556 #define CRYPTO_RANDOM_SEED_NOT_SUPPORTED        0x0000003F
 557 #define CRYPTO_RANDOM_NO_RNG                    0x00000040
 558 #define CRYPTO_DOMAIN_PARAMS_INVALID            0x00000041
 559 #define CRYPTO_BUFFER_TOO_SMALL                 0x00000042
 560 #define CRYPTO_INFORMATION_SENSITIVE            0x00000043
 561 #define CRYPTO_NOT_SUPPORTED                    0x00000044
 562
 563 #define CRYPTO_QUEUED                           0x00000045
 564 #define CRYPTO_BUFFER_TOO_BIG                   0x00000046
 565 #define CRYPTO_INVALID_CONTEXT                  0x00000047
 566 #define CRYPTO_INVALID_MAC                      0x00000048
 567 #define CRYPTO_MECH_NOT_SUPPORTED               0x00000049
 568 #define CRYPTO_INCONSISTENT_ATTRIBUTE           0x0000004A
 569 #define CRYPTO_NO_PERMISSION                    0x0000004B
 570 #define CRYPTO_INVALID_PROVIDER_ID              0x0000004C
 571 #define CRYPTO_VERSION_MISMATCH                 0x0000004D
 572 #define CRYPTO_BUSY                             0x0000004E
 573 #define CRYPTO_UNKNOWN_PROVIDER                 0x0000004F
 574 #define CRYPTO_MODVERIFICATION_FAILED           0x00000050
 575 #define CRYPTO_OLD_CTX_TEMPLATE                 0x00000051
 576 #define CRYPTO_WEAK_KEY                         0x00000052
 577 #define CRYPTO_FIPS140_ERROR                    0x00000053
 578 /*
 579  * Don't forget to update CRYPTO_LAST_ERROR and the error_number_table[]
 580  * in kernelUtil.c when new error code is added.
 581  */
 582 #define CRYPTO_LAST_ERROR                       0x00000053
 583
 584 /*
 585  * Special values that can be used to indicate that information is unavailable
 586  * or that there is not practical limit. These values can be used
 587  * by fields of the SPI crypto_provider_ext_info(9S) structure.
 588  * The value of CRYPTO_UNAVAILABLE_INFO should be the same as
 589  * CK_UNAVAILABLE_INFO in the PKCS#11 spec.
 590  */
 591 #define CRYPTO_UNAVAILABLE_INFO         ((ulong_t)(-1))
 592 #define CRYPTO_EFFECTIVELY_INFINITE     0x0
 593
 594 #ifdef __cplusplus
 595 }
 596 #endif
 597
 598 #endif /* _SYS_CRYPTO_COMMON_H */