/* Copyright (c) OASIS Open 2016. All Rights Reserved./

 * /Distributed under the terms of the OASIS IPR Policy,

 * [http://www.oasis-open.org/policies-guidelines/ipr], AS-IS, WITHOUT ANY

 * IMPLIED OR EXPRESS WARRANTY; there is no warranty of MERCHANTABILITY, FITNESS FOR A

 * PARTICULAR PURPOSE or NONINFRINGEMENT of the rights of others.

 */

/* Latest version of the specification:

 * http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/pkcs11-base-v2.40.html

 */

/* See top of pkcs11.h for information about the macros that

 * must be defined and the structure-packing conventions that

 * must be set before including this file.

 */

#ifndef _PKCS11T_H_

#define _PKCS11T_H_ 1

#define CRYPTOKI_VERSION_MAJOR          2

#define CRYPTOKI_VERSION_MINOR          40

#define CRYPTOKI_VERSION_AMENDMENT      0

#define CK_TRUE         1

#define CK_FALSE        0

#ifndef CK_DISABLE_TRUE_FALSE

#ifndef FALSE

#define FALSE CK_FALSE

#endif

#ifndef TRUE

#define TRUE CK_TRUE

#endif

#endif

/* an unsigned 8-bit value */

typedef unsigned char     CK_BYTE;

/* an unsigned 8-bit character */

typedef CK_BYTE           CK_CHAR;

/* an 8-bit UTF-8 character */

typedef CK_BYTE           CK_UTF8CHAR;

/* a BYTE-sized Boolean flag */

typedef CK_BYTE           CK_BBOOL;

/* an unsigned value, at least 32 bits long */

typedef unsigned long int CK_ULONG;

/* a signed value, the same size as a CK_ULONG */

typedef long int          CK_LONG;

/* at least 32 bits; each bit is a Boolean flag */

typedef CK_ULONG          CK_FLAGS;

/* some special values for certain CK_ULONG variables */

#define CK_UNAVAILABLE_INFORMATION      (~0UL)

#define CK_EFFECTIVELY_INFINITE         0UL

typedef CK_BYTE     CK_PTR   CK_BYTE_PTR;

typedef CK_CHAR     CK_PTR   CK_CHAR_PTR;

typedef CK_UTF8CHAR CK_PTR   CK_UTF8CHAR_PTR;

typedef CK_ULONG    CK_PTR   CK_ULONG_PTR;

typedef void        CK_PTR   CK_VOID_PTR;

/* Pointer to a CK_VOID_PTR-- i.e., pointer to pointer to void */

typedef CK_VOID_PTR CK_PTR CK_VOID_PTR_PTR;

/* The following value is always invalid if used as a session

 * handle or object handle

 */

#define CK_INVALID_HANDLE       0UL

typedef struct CK_VERSION {

  CK_BYTE       major;  /* integer portion of version number */

  CK_BYTE       minor;  /* 1/100ths portion of version number */

} CK_VERSION;

typedef CK_VERSION CK_PTR CK_VERSION_PTR;

typedef struct CK_INFO {

  CK_VERSION    cryptokiVersion;     /* Cryptoki interface ver */

  CK_UTF8CHAR   manufacturerID[32];  /* blank padded */

  CK_FLAGS      flags;               /* must be zero */

  CK_UTF8CHAR   libraryDescription[32];  /* blank padded */

  CK_VERSION    libraryVersion;          /* version of library */

} CK_INFO;

typedef CK_INFO CK_PTR    CK_INFO_PTR;

/* CK_NOTIFICATION enumerates the types of notifications that

 * Cryptoki provides to an application

 */

typedef CK_ULONG CK_NOTIFICATION;

#define CKN_SURRENDER           0UL

#define CKN_OTP_CHANGED         1UL

typedef CK_ULONG          CK_SLOT_ID;

typedef CK_SLOT_ID CK_PTR CK_SLOT_ID_PTR;

/* CK_SLOT_INFO provides information about a slot */

typedef struct CK_SLOT_INFO {

  CK_UTF8CHAR   slotDescription[64];  /* blank padded */

  CK_UTF8CHAR   manufacturerID[32];   /* blank padded */

  CK_FLAGS      flags;

  CK_VERSION    hardwareVersion;  /* version of hardware */

  CK_VERSION    firmwareVersion;  /* version of firmware */

} CK_SLOT_INFO;

/* flags: bit flags that provide capabilities of the slot

 *      Bit Flag              Mask        Meaning

 */

#define CKF_TOKEN_PRESENT     0x00000001UL  /* a token is there */

#define CKF_REMOVABLE_DEVICE  0x00000002UL  /* removable devices*/

#define CKF_HW_SLOT           0x00000004UL  /* hardware slot */

typedef CK_SLOT_INFO CK_PTR CK_SLOT_INFO_PTR;

/* CK_TOKEN_INFO provides information about a token */

typedef struct CK_TOKEN_INFO {

  CK_UTF8CHAR   label[32];           /* blank padded */

  CK_UTF8CHAR   manufacturerID[32];  /* blank padded */

  CK_UTF8CHAR   model[16];           /* blank padded */

  CK_CHAR       serialNumber[16];    /* blank padded */

  CK_FLAGS      flags;               /* see below */

  CK_ULONG      ulMaxSessionCount;     /* max open sessions */

  CK_ULONG      ulSessionCount;        /* sess. now open */

  CK_ULONG      ulMaxRwSessionCount;   /* max R/W sessions */

  CK_ULONG      ulRwSessionCount;      /* R/W sess. now open */

  CK_ULONG      ulMaxPinLen;           /* in bytes */

  CK_ULONG      ulMinPinLen;           /* in bytes */

  CK_ULONG      ulTotalPublicMemory;   /* in bytes */

  CK_ULONG      ulFreePublicMemory;    /* in bytes */

  CK_ULONG      ulTotalPrivateMemory;  /* in bytes */

  CK_ULONG      ulFreePrivateMemory;   /* in bytes */

  CK_VERSION    hardwareVersion;       /* version of hardware */

  CK_VERSION    firmwareVersion;       /* version of firmware */

  CK_CHAR       utcTime[16];           /* time */

} CK_TOKEN_INFO;

/* The flags parameter is defined as follows:

 *      Bit Flag                    Mask        Meaning

 */

#define CKF_RNG                     0x00000001UL  /* has random # generator */

#define CKF_WRITE_PROTECTED         0x00000002UL  /* token is write-protected */

#define CKF_LOGIN_REQUIRED          0x00000004UL  /* user must login */

#define CKF_USER_PIN_INITIALIZED    0x00000008UL  /* normal user's PIN is set */

/* CKF_RESTORE_KEY_NOT_NEEDED.  If it is set,

 * that means that *every* time the state of cryptographic

 * operations of a session is successfully saved, all keys

 * needed to continue those operations are stored in the state

 */

#define CKF_RESTORE_KEY_NOT_NEEDED  0x00000020UL

/* CKF_CLOCK_ON_TOKEN.  If it is set, that means

 * that the token has some sort of clock.  The time on that

 * clock is returned in the token info structure

 */

#define CKF_CLOCK_ON_TOKEN          0x00000040UL

/* CKF_PROTECTED_AUTHENTICATION_PATH.  If it is

 * set, that means that there is some way for the user to login

 * without sending a PIN through the Cryptoki library itself

 */

#define CKF_PROTECTED_AUTHENTICATION_PATH 0x00000100UL

/* CKF_DUAL_CRYPTO_OPERATIONS.  If it is true,

 * that means that a single session with the token can perform

 * dual simultaneous cryptographic operations (digest and

 * encrypt; decrypt and digest; sign and encrypt; and decrypt

 * and sign)

 */

#define CKF_DUAL_CRYPTO_OPERATIONS  0x00000200UL

/* CKF_TOKEN_INITIALIZED. If it is true, the

 * token has been initialized using C_InitializeToken or an

 * equivalent mechanism outside the scope of PKCS #11.

 * Calling C_InitializeToken when this flag is set will cause

 * the token to be reinitialized.

 */

#define CKF_TOKEN_INITIALIZED       0x00000400UL

/* CKF_SECONDARY_AUTHENTICATION. If it is

 * true, the token supports secondary authentication for

 * private key objects.

 */

#define CKF_SECONDARY_AUTHENTICATION  0x00000800UL

/* CKF_USER_PIN_COUNT_LOW. If it is true, an

 * incorrect user login PIN has been entered at least once

 * since the last successful authentication.

 */

#define CKF_USER_PIN_COUNT_LOW       0x00010000UL

/* CKF_USER_PIN_FINAL_TRY. If it is true,

 * supplying an incorrect user PIN will it to become locked.

 */

#define CKF_USER_PIN_FINAL_TRY       0x00020000UL

/* CKF_USER_PIN_LOCKED. If it is true, the

 * user PIN has been locked. User login to the token is not

 * possible.

 */

#define CKF_USER_PIN_LOCKED          0x00040000UL

/* CKF_USER_PIN_TO_BE_CHANGED. If it is true,

 * the user PIN value is the default value set by token

 * initialization or manufacturing, or the PIN has been

 * expired by the card.

 */

#define CKF_USER_PIN_TO_BE_CHANGED   0x00080000UL

/* CKF_SO_PIN_COUNT_LOW. If it is true, an

 * incorrect SO login PIN has been entered at least once since

 * the last successful authentication.

 */

#define CKF_SO_PIN_COUNT_LOW         0x00100000UL

/* CKF_SO_PIN_FINAL_TRY. If it is true,

 * supplying an incorrect SO PIN will it to become locked.

 */

#define CKF_SO_PIN_FINAL_TRY         0x00200000UL

/* CKF_SO_PIN_LOCKED. If it is true, the SO

 * PIN has been locked. SO login to the token is not possible.

 */

#define CKF_SO_PIN_LOCKED            0x00400000UL

/* CKF_SO_PIN_TO_BE_CHANGED. If it is true,

 * the SO PIN value is the default value set by token

 * initialization or manufacturing, or the PIN has been

 * expired by the card.

 */

#define CKF_SO_PIN_TO_BE_CHANGED     0x00800000UL

#define CKF_ERROR_STATE              0x01000000UL

typedef CK_TOKEN_INFO CK_PTR CK_TOKEN_INFO_PTR;

/* CK_SESSION_HANDLE is a Cryptoki-assigned value that

 * identifies a session

 */

typedef CK_ULONG          CK_SESSION_HANDLE;

typedef CK_SESSION_HANDLE CK_PTR CK_SESSION_HANDLE_PTR;

/* CK_USER_TYPE enumerates the types of Cryptoki users */

typedef CK_ULONG          CK_USER_TYPE;

/* Security Officer */

#define CKU_SO                  0UL

/* Normal user */

#define CKU_USER                1UL

/* Context specific */

#define CKU_CONTEXT_SPECIFIC    2UL

/* CK_STATE enumerates the session states */

typedef CK_ULONG          CK_STATE;

#define CKS_RO_PUBLIC_SESSION   0UL

#define CKS_RO_USER_FUNCTIONS   1UL

#define CKS_RW_PUBLIC_SESSION   2UL

#define CKS_RW_USER_FUNCTIONS   3UL

#define CKS_RW_SO_FUNCTIONS     4UL

/* CK_SESSION_INFO provides information about a session */

typedef struct CK_SESSION_INFO {

  CK_SLOT_ID    slotID;

  CK_STATE      state;

  CK_FLAGS      flags;          /* see below */

  CK_ULONG      ulDeviceError;  /* device-dependent error code */

} CK_SESSION_INFO;

/* The flags are defined in the following table:

 *      Bit Flag                Mask        Meaning

 */

#define CKF_RW_SESSION          0x00000002UL /* session is r/w */

#define CKF_SERIAL_SESSION      0x00000004UL /* no parallel    */

typedef CK_SESSION_INFO CK_PTR CK_SESSION_INFO_PTR;

/* CK_OBJECT_HANDLE is a token-specific identifier for an

 * object

 */

typedef CK_ULONG          CK_OBJECT_HANDLE;

typedef CK_OBJECT_HANDLE CK_PTR CK_OBJECT_HANDLE_PTR;

/* CK_OBJECT_CLASS is a value that identifies the classes (or

 * types) of objects that Cryptoki recognizes.  It is defined

 * as follows:

 */

typedef CK_ULONG          CK_OBJECT_CLASS;

/* The following classes of objects are defined: */

#define CKO_DATA              0x00000000UL

#define CKO_CERTIFICATE       0x00000001UL

#define CKO_PUBLIC_KEY        0x00000002UL

#define CKO_PRIVATE_KEY       0x00000003UL

#define CKO_SECRET_KEY        0x00000004UL

#define CKO_HW_FEATURE        0x00000005UL

#define CKO_DOMAIN_PARAMETERS 0x00000006UL

#define CKO_MECHANISM         0x00000007UL

#define CKO_OTP_KEY           0x00000008UL

#define CKO_VENDOR_DEFINED    0x80000000UL

typedef CK_OBJECT_CLASS CK_PTR CK_OBJECT_CLASS_PTR;

/* CK_HW_FEATURE_TYPE is a value that identifies the hardware feature type

 * of an object with CK_OBJECT_CLASS equal to CKO_HW_FEATURE.

 */

typedef CK_ULONG          CK_HW_FEATURE_TYPE;

/* The following hardware feature types are defined */

#define CKH_MONOTONIC_COUNTER  0x00000001UL

#define CKH_CLOCK              0x00000002UL

#define CKH_USER_INTERFACE     0x00000003UL

#define CKH_VENDOR_DEFINED     0x80000000UL

/* CK_KEY_TYPE is a value that identifies a key type */

typedef CK_ULONG          CK_KEY_TYPE;

/* the following key types are defined: */

#define CKK_RSA                 0x00000000UL

#define CKK_DSA                 0x00000001UL

#define CKK_DH                  0x00000002UL

#define CKK_ECDSA               0x00000003UL /* Deprecated */

#define CKK_EC                  0x00000003UL

#define CKK_X9_42_DH            0x00000004UL

#define CKK_KEA                 0x00000005UL

#define CKK_GENERIC_SECRET      0x00000010UL

#define CKK_RC2                 0x00000011UL

#define CKK_RC4                 0x00000012UL

#define CKK_DES                 0x00000013UL

#define CKK_DES2                0x00000014UL

#define CKK_DES3                0x00000015UL

#define CKK_CAST                0x00000016UL

#define CKK_CAST3               0x00000017UL

#define CKK_CAST5               0x00000018UL /* Deprecated */

#define CKK_CAST128             0x00000018UL

#define CKK_RC5                 0x00000019UL

#define CKK_IDEA                0x0000001AUL

#define CKK_SKIPJACK            0x0000001BUL

#define CKK_BATON               0x0000001CUL

#define CKK_JUNIPER             0x0000001DUL

#define CKK_CDMF                0x0000001EUL

#define CKK_AES                 0x0000001FUL

#define CKK_BLOWFISH            0x00000020UL

#define CKK_TWOFISH             0x00000021UL

#define CKK_SECURID             0x00000022UL

#define CKK_HOTP                0x00000023UL

#define CKK_ACTI                0x00000024UL

#define CKK_CAMELLIA            0x00000025UL

#define CKK_ARIA                0x00000026UL

#define CKK_MD5_HMAC            0x00000027UL

#define CKK_SHA_1_HMAC          0x00000028UL

#define CKK_RIPEMD128_HMAC      0x00000029UL

#define CKK_RIPEMD160_HMAC      0x0000002AUL

#define CKK_SHA256_HMAC         0x0000002BUL

#define CKK_SHA384_HMAC         0x0000002CUL

#define CKK_SHA512_HMAC         0x0000002DUL

#define CKK_SHA224_HMAC         0x0000002EUL

#define CKK_SEED                0x0000002FUL

#define CKK_GOSTR3410           0x00000030UL

#define CKK_GOSTR3411           0x00000031UL

#define CKK_GOST28147           0x00000032UL

#define CKK_VENDOR_DEFINED      0x80000000UL

/* CK_CERTIFICATE_TYPE is a value that identifies a certificate

 * type

 */

typedef CK_ULONG          CK_CERTIFICATE_TYPE;

#define CK_CERTIFICATE_CATEGORY_UNSPECIFIED     0UL

#define CK_CERTIFICATE_CATEGORY_TOKEN_USER      1UL

#define CK_CERTIFICATE_CATEGORY_AUTHORITY       2UL

#define CK_CERTIFICATE_CATEGORY_OTHER_ENTITY    3UL

#define CK_SECURITY_DOMAIN_UNSPECIFIED     0UL

#define CK_SECURITY_DOMAIN_MANUFACTURER    1UL

#define CK_SECURITY_DOMAIN_OPERATOR        2UL

#define CK_SECURITY_DOMAIN_THIRD_PARTY     3UL

/* The following certificate types are defined: */

#define CKC_X_509               0x00000000UL

#define CKC_X_509_ATTR_CERT     0x00000001UL

#define CKC_WTLS                0x00000002UL

#define CKC_VENDOR_DEFINED      0x80000000UL

/* CK_ATTRIBUTE_TYPE is a value that identifies an attribute

 * type

 */

typedef CK_ULONG          CK_ATTRIBUTE_TYPE;

/* The CKF_ARRAY_ATTRIBUTE flag identifies an attribute which

 * consists of an array of values.

 */

#define CKF_ARRAY_ATTRIBUTE     0x40000000UL

/* The following OTP-related defines relate to the CKA_OTP_FORMAT attribute */

#define CK_OTP_FORMAT_DECIMAL           0UL

#define CK_OTP_FORMAT_HEXADECIMAL       1UL

#define CK_OTP_FORMAT_ALPHANUMERIC      2UL

#define CK_OTP_FORMAT_BINARY            3UL

/* The following OTP-related defines relate to the CKA_OTP_..._REQUIREMENT

 * attributes

 */

#define CK_OTP_PARAM_IGNORED            0UL

#define CK_OTP_PARAM_OPTIONAL           1UL

#define CK_OTP_PARAM_MANDATORY          2UL

/* The following attribute types are defined: */

#define CKA_CLASS              0x00000000UL

#define CKA_TOKEN              0x00000001UL

#define CKA_PRIVATE            0x00000002UL

#define CKA_LABEL              0x00000003UL

#define CKA_APPLICATION        0x00000010UL

#define CKA_VALUE              0x00000011UL

#define CKA_OBJECT_ID          0x00000012UL

#define CKA_CERTIFICATE_TYPE   0x00000080UL

#define CKA_ISSUER             0x00000081UL

#define CKA_SERIAL_NUMBER      0x00000082UL

#define CKA_AC_ISSUER          0x00000083UL

#define CKA_OWNER              0x00000084UL

#define CKA_ATTR_TYPES         0x00000085UL

#define CKA_TRUSTED            0x00000086UL

#define CKA_CERTIFICATE_CATEGORY        0x00000087UL

#define CKA_JAVA_MIDP_SECURITY_DOMAIN   0x00000088UL

#define CKA_URL                         0x00000089UL

#define CKA_HASH_OF_SUBJECT_PUBLIC_KEY  0x0000008AUL

#define CKA_HASH_OF_ISSUER_PUBLIC_KEY   0x0000008BUL

#define CKA_NAME_HASH_ALGORITHM         0x0000008CUL

#define CKA_CHECK_VALUE                 0x00000090UL

#define CKA_KEY_TYPE           0x00000100UL

#define CKA_SUBJECT            0x00000101UL

#define CKA_ID                 0x00000102UL

#define CKA_SENSITIVE          0x00000103UL

#define CKA_ENCRYPT            0x00000104UL

#define CKA_DECRYPT            0x00000105UL

#define CKA_WRAP               0x00000106UL

#define CKA_UNWRAP             0x00000107UL

#define CKA_SIGN               0x00000108UL

#define CKA_SIGN_RECOVER       0x00000109UL

#define CKA_VERIFY             0x0000010AUL

#define CKA_VERIFY_RECOVER     0x0000010BUL

#define CKA_DERIVE             0x0000010CUL

#define CKA_START_DATE         0x00000110UL

#define CKA_END_DATE           0x00000111UL

#define CKA_MODULUS            0x00000120UL

#define CKA_MODULUS_BITS       0x00000121UL

#define CKA_PUBLIC_EXPONENT    0x00000122UL

#define CKA_PRIVATE_EXPONENT   0x00000123UL

#define CKA_PRIME_1            0x00000124UL

#define CKA_PRIME_2            0x00000125UL

#define CKA_EXPONENT_1         0x00000126UL

#define CKA_EXPONENT_2         0x00000127UL

#define CKA_COEFFICIENT        0x00000128UL

#define CKA_PUBLIC_KEY_INFO    0x00000129UL

#define CKA_PRIME              0x00000130UL

#define CKA_SUBPRIME           0x00000131UL

#define CKA_BASE               0x00000132UL

#define CKA_PRIME_BITS         0x00000133UL

#define CKA_SUBPRIME_BITS      0x00000134UL

#define CKA_SUB_PRIME_BITS     CKA_SUBPRIME_BITS

#define CKA_VALUE_BITS         0x00000160UL

#define CKA_VALUE_LEN          0x00000161UL

#define CKA_EXTRACTABLE        0x00000162UL

#define CKA_LOCAL              0x00000163UL

#define CKA_NEVER_EXTRACTABLE  0x00000164UL

#define CKA_ALWAYS_SENSITIVE   0x00000165UL

#define CKA_KEY_GEN_MECHANISM  0x00000166UL

#define CKA_MODIFIABLE         0x00000170UL

#define CKA_COPYABLE           0x00000171UL