1pub const CRYPTOKI_VERSION_MAJOR: CK_BYTE = 3;
4pub const CRYPTOKI_VERSION_MINOR: CK_BYTE = 1;
5pub const CRYPTOKI_VERSION_AMENDMENT: CK_BYTE = 0;
6pub const CK_EFFECTIVELY_INFINITE: CK_ULONG = 0;
7pub const CK_INVALID_HANDLE: CK_ULONG = 0;
8pub const CK_TRUE: CK_BBOOL = 1;
9pub const CK_FALSE: CK_BBOOL = 0;
10pub const CK_CERTIFICATE_CATEGORY_UNSPECIFIED: CK_ULONG = 0;
11pub const CK_CERTIFICATE_CATEGORY_TOKEN_USER: CK_ULONG = 1;
12pub const CK_CERTIFICATE_CATEGORY_AUTHORITY: CK_ULONG = 2;
13pub const CK_CERTIFICATE_CATEGORY_OTHER_ENTITY: CK_ULONG = 3;
14pub const CK_OTP_VALUE: CK_ULONG = 0;
15pub const CK_OTP_PIN: CK_ULONG = 1;
16pub const CK_OTP_CHALLENGE: CK_ULONG = 2;
17pub const CK_OTP_TIME: CK_ULONG = 3;
18pub const CK_OTP_COUNTER: CK_ULONG = 4;
19pub const CK_OTP_FLAGS: CK_ULONG = 5;
20pub const CK_OTP_OUTPUT_LENGTH: CK_ULONG = 6;
21pub const CK_OTP_OUTPUT_FORMAT: CK_ULONG = 7;
22pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0;
23pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1;
24pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2;
25pub const CK_OTP_FORMAT_BINARY: CK_ULONG = 3;
26pub const CK_OTP_PARAM_IGNORED: CK_ULONG = 0;
27pub const CK_OTP_PARAM_OPTIONAL: CK_ULONG = 1;
28pub const CK_OTP_PARAM_MANDATORY: CK_ULONG = 2;
29pub const CK_SECURITY_DOMAIN_UNSPECIFIED: CK_ULONG = 0;
30pub const CK_SECURITY_DOMAIN_MANUFACTURER: CK_ULONG = 1;
31pub const CK_SECURITY_DOMAIN_OPERATOR: CK_ULONG = 2;
32pub const CK_SECURITY_DOMAIN_THIRD_PARTY: CK_ULONG = 3;
33pub const CK_SP800_108_ITERATION_VARIABLE: CK_ULONG = 1;
34pub const CK_SP800_108_OPTIONAL_COUNTER: CK_ULONG = 2;
35pub const CK_SP800_108_COUNTER: CK_ULONG = 2;
36pub const CK_SP800_108_DKM_LENGTH: CK_ULONG = 3;
37pub const CK_SP800_108_BYTE_ARRAY: CK_ULONG = 4;
38pub const CK_SP800_108_DKM_LENGTH_SUM_OF_KEYS: CK_ULONG = 1;
39pub const CK_SP800_108_DKM_LENGTH_SUM_OF_SEGMENTS: CK_ULONG = 2;
40pub const CKA_CLASS: CK_ATTRIBUTE_TYPE = 0;
41pub const CKA_TOKEN: CK_ATTRIBUTE_TYPE = 1;
42pub const CKA_PRIVATE: CK_ATTRIBUTE_TYPE = 2;
43pub const CKA_LABEL: CK_ATTRIBUTE_TYPE = 3;
44pub const CKA_UNIQUE_ID: CK_ATTRIBUTE_TYPE = 4;
45pub const CKA_APPLICATION: CK_ATTRIBUTE_TYPE = 16;
46pub const CKA_VALUE: CK_ATTRIBUTE_TYPE = 17;
47pub const CKA_OBJECT_ID: CK_ATTRIBUTE_TYPE = 18;
48pub const CKA_CERTIFICATE_TYPE: CK_ATTRIBUTE_TYPE = 128;
49pub const CKA_ISSUER: CK_ATTRIBUTE_TYPE = 129;
50pub const CKA_SERIAL_NUMBER: CK_ATTRIBUTE_TYPE = 130;
51pub const CKA_AC_ISSUER: CK_ATTRIBUTE_TYPE = 131;
52pub const CKA_OWNER: CK_ATTRIBUTE_TYPE = 132;
53pub const CKA_ATTR_TYPES: CK_ATTRIBUTE_TYPE = 133;
54pub const CKA_TRUSTED: CK_ATTRIBUTE_TYPE = 134;
55pub const CKA_CERTIFICATE_CATEGORY: CK_ATTRIBUTE_TYPE = 135;
56pub const CKA_JAVA_MIDP_SECURITY_DOMAIN: CK_ATTRIBUTE_TYPE = 136;
57pub const CKA_URL: CK_ATTRIBUTE_TYPE = 137;
58pub const CKA_HASH_OF_SUBJECT_PUBLIC_KEY: CK_ATTRIBUTE_TYPE = 138;
59pub const CKA_HASH_OF_ISSUER_PUBLIC_KEY: CK_ATTRIBUTE_TYPE = 139;
60pub const CKA_NAME_HASH_ALGORITHM: CK_ATTRIBUTE_TYPE = 140;
61pub const CKA_CHECK_VALUE: CK_ATTRIBUTE_TYPE = 144;
62pub const CKA_KEY_TYPE: CK_ATTRIBUTE_TYPE = 256;
63pub const CKA_SUBJECT: CK_ATTRIBUTE_TYPE = 257;
64pub const CKA_ID: CK_ATTRIBUTE_TYPE = 258;
65pub const CKA_SENSITIVE: CK_ATTRIBUTE_TYPE = 259;
66pub const CKA_ENCRYPT: CK_ATTRIBUTE_TYPE = 260;
67pub const CKA_DECRYPT: CK_ATTRIBUTE_TYPE = 261;
68pub const CKA_WRAP: CK_ATTRIBUTE_TYPE = 262;
69pub const CKA_UNWRAP: CK_ATTRIBUTE_TYPE = 263;
70pub const CKA_SIGN: CK_ATTRIBUTE_TYPE = 264;
71pub const CKA_SIGN_RECOVER: CK_ATTRIBUTE_TYPE = 265;
72pub const CKA_VERIFY: CK_ATTRIBUTE_TYPE = 266;
73pub const CKA_VERIFY_RECOVER: CK_ATTRIBUTE_TYPE = 267;
74pub const CKA_DERIVE: CK_ATTRIBUTE_TYPE = 268;
75pub const CKA_START_DATE: CK_ATTRIBUTE_TYPE = 272;
76pub const CKA_END_DATE: CK_ATTRIBUTE_TYPE = 273;
77pub const CKA_MODULUS: CK_ATTRIBUTE_TYPE = 288;
78pub const CKA_MODULUS_BITS: CK_ATTRIBUTE_TYPE = 289;
79pub const CKA_PUBLIC_EXPONENT: CK_ATTRIBUTE_TYPE = 290;
80pub const CKA_PRIVATE_EXPONENT: CK_ATTRIBUTE_TYPE = 291;
81pub const CKA_PRIME_1: CK_ATTRIBUTE_TYPE = 292;
82pub const CKA_PRIME_2: CK_ATTRIBUTE_TYPE = 293;
83pub const CKA_EXPONENT_1: CK_ATTRIBUTE_TYPE = 294;
84pub const CKA_EXPONENT_2: CK_ATTRIBUTE_TYPE = 295;
85pub const CKA_COEFFICIENT: CK_ATTRIBUTE_TYPE = 296;
86pub const CKA_PUBLIC_KEY_INFO: CK_ATTRIBUTE_TYPE = 297;
87pub const CKA_PRIME: CK_ATTRIBUTE_TYPE = 304;
88pub const CKA_SUBPRIME: CK_ATTRIBUTE_TYPE = 305;
89pub const CKA_BASE: CK_ATTRIBUTE_TYPE = 306;
90pub const CKA_PRIME_BITS: CK_ATTRIBUTE_TYPE = 307;
91pub const CKA_SUBPRIME_BITS: CK_ATTRIBUTE_TYPE = 308;
92pub const CKA_SUB_PRIME_BITS: CK_ATTRIBUTE_TYPE = 308;
93pub const CKA_VALUE_BITS: CK_ATTRIBUTE_TYPE = 352;
94pub const CKA_VALUE_LEN: CK_ATTRIBUTE_TYPE = 353;
95pub const CKA_EXTRACTABLE: CK_ATTRIBUTE_TYPE = 354;
96pub const CKA_LOCAL: CK_ATTRIBUTE_TYPE = 355;
97pub const CKA_NEVER_EXTRACTABLE: CK_ATTRIBUTE_TYPE = 356;
98pub const CKA_ALWAYS_SENSITIVE: CK_ATTRIBUTE_TYPE = 357;
99pub const CKA_KEY_GEN_MECHANISM: CK_ATTRIBUTE_TYPE = 358;
100pub const CKA_MODIFIABLE: CK_ATTRIBUTE_TYPE = 368;
101pub const CKA_COPYABLE: CK_ATTRIBUTE_TYPE = 369;
102pub const CKA_DESTROYABLE: CK_ATTRIBUTE_TYPE = 370;
103pub const CKA_EC_PARAMS: CK_ATTRIBUTE_TYPE = 384;
104pub const CKA_EC_POINT: CK_ATTRIBUTE_TYPE = 385;
105pub const CKA_ALWAYS_AUTHENTICATE: CK_ATTRIBUTE_TYPE = 514;
106pub const CKA_WRAP_WITH_TRUSTED: CK_ATTRIBUTE_TYPE = 528;
107pub const CKA_OTP_FORMAT: CK_ATTRIBUTE_TYPE = 544;
108pub const CKA_OTP_LENGTH: CK_ATTRIBUTE_TYPE = 545;
109pub const CKA_OTP_TIME_INTERVAL: CK_ATTRIBUTE_TYPE = 546;
110pub const CKA_OTP_USER_FRIENDLY_MODE: CK_ATTRIBUTE_TYPE = 547;
111pub const CKA_OTP_CHALLENGE_REQUIREMENT: CK_ATTRIBUTE_TYPE = 548;
112pub const CKA_OTP_TIME_REQUIREMENT: CK_ATTRIBUTE_TYPE = 549;
113pub const CKA_OTP_COUNTER_REQUIREMENT: CK_ATTRIBUTE_TYPE = 550;
114pub const CKA_OTP_PIN_REQUIREMENT: CK_ATTRIBUTE_TYPE = 551;
115pub const CKA_OTP_COUNTER: CK_ATTRIBUTE_TYPE = 558;
116pub const CKA_OTP_TIME: CK_ATTRIBUTE_TYPE = 559;
117pub const CKA_OTP_USER_IDENTIFIER: CK_ATTRIBUTE_TYPE = 554;
118pub const CKA_OTP_SERVICE_IDENTIFIER: CK_ATTRIBUTE_TYPE = 555;
119pub const CKA_OTP_SERVICE_LOGO: CK_ATTRIBUTE_TYPE = 556;
120pub const CKA_OTP_SERVICE_LOGO_TYPE: CK_ATTRIBUTE_TYPE = 557;
121pub const CKA_GOSTR3410_PARAMS: CK_ATTRIBUTE_TYPE = 592;
122pub const CKA_GOSTR3411_PARAMS: CK_ATTRIBUTE_TYPE = 593;
123pub const CKA_GOST28147_PARAMS: CK_ATTRIBUTE_TYPE = 594;
124pub const CKA_HW_FEATURE_TYPE: CK_ATTRIBUTE_TYPE = 768;
125pub const CKA_RESET_ON_INIT: CK_ATTRIBUTE_TYPE = 769;
126pub const CKA_HAS_RESET: CK_ATTRIBUTE_TYPE = 770;
127pub const CKA_PIXEL_X: CK_ATTRIBUTE_TYPE = 1024;
128pub const CKA_PIXEL_Y: CK_ATTRIBUTE_TYPE = 1025;
129pub const CKA_RESOLUTION: CK_ATTRIBUTE_TYPE = 1026;
130pub const CKA_CHAR_ROWS: CK_ATTRIBUTE_TYPE = 1027;
131pub const CKA_CHAR_COLUMNS: CK_ATTRIBUTE_TYPE = 1028;
132pub const CKA_COLOR: CK_ATTRIBUTE_TYPE = 1029;
133pub const CKA_BITS_PER_PIXEL: CK_ATTRIBUTE_TYPE = 1030;
134pub const CKA_CHAR_SETS: CK_ATTRIBUTE_TYPE = 1152;
135pub const CKA_ENCODING_METHODS: CK_ATTRIBUTE_TYPE = 1153;
136pub const CKA_MIME_TYPES: CK_ATTRIBUTE_TYPE = 1154;
137pub const CKA_MECHANISM_TYPE: CK_ATTRIBUTE_TYPE = 1280;
138pub const CKA_REQUIRED_CMS_ATTRIBUTES: CK_ATTRIBUTE_TYPE = 1281;
139pub const CKA_DEFAULT_CMS_ATTRIBUTES: CK_ATTRIBUTE_TYPE = 1282;
140pub const CKA_SUPPORTED_CMS_ATTRIBUTES: CK_ATTRIBUTE_TYPE = 1283;
141pub const CKA_PROFILE_ID: CK_ATTRIBUTE_TYPE = 1537;
142pub const CKA_X2RATCHET_BAG: CK_ATTRIBUTE_TYPE = 1538;
143pub const CKA_X2RATCHET_BAGSIZE: CK_ATTRIBUTE_TYPE = 1539;
144pub const CKA_X2RATCHET_BOBS1STMSG: CK_ATTRIBUTE_TYPE = 1540;
145pub const CKA_X2RATCHET_CKR: CK_ATTRIBUTE_TYPE = 1541;
146pub const CKA_X2RATCHET_CKS: CK_ATTRIBUTE_TYPE = 1542;
147pub const CKA_X2RATCHET_DHP: CK_ATTRIBUTE_TYPE = 1543;
148pub const CKA_X2RATCHET_DHR: CK_ATTRIBUTE_TYPE = 1544;
149pub const CKA_X2RATCHET_DHS: CK_ATTRIBUTE_TYPE = 1545;
150pub const CKA_X2RATCHET_HKR: CK_ATTRIBUTE_TYPE = 1546;
151pub const CKA_X2RATCHET_HKS: CK_ATTRIBUTE_TYPE = 1547;
152pub const CKA_X2RATCHET_ISALICE: CK_ATTRIBUTE_TYPE = 1548;
153pub const CKA_X2RATCHET_NHKR: CK_ATTRIBUTE_TYPE = 1549;
154pub const CKA_X2RATCHET_NHKS: CK_ATTRIBUTE_TYPE = 1550;
155pub const CKA_X2RATCHET_NR: CK_ATTRIBUTE_TYPE = 1551;
156pub const CKA_X2RATCHET_NS: CK_ATTRIBUTE_TYPE = 1552;
157pub const CKA_X2RATCHET_PNS: CK_ATTRIBUTE_TYPE = 1553;
158pub const CKA_X2RATCHET_RK: CK_ATTRIBUTE_TYPE = 1554;
159pub const CKA_HSS_LEVELS: CK_ATTRIBUTE_TYPE = 1559;
160pub const CKA_HSS_LMS_TYPE: CK_ATTRIBUTE_TYPE = 1560;
161pub const CKA_HSS_LMOTS_TYPE: CK_ATTRIBUTE_TYPE = 1561;
162pub const CKA_HSS_LMS_TYPES: CK_ATTRIBUTE_TYPE = 1562;
163pub const CKA_HSS_LMOTS_TYPES: CK_ATTRIBUTE_TYPE = 1563;
164pub const CKA_HSS_KEYS_REMAINING: CK_ATTRIBUTE_TYPE = 1564;
165pub const CKA_VENDOR_DEFINED: CK_ATTRIBUTE_TYPE = 2147483648;
166pub const CKA_WRAP_TEMPLATE: CK_ATTRIBUTE_TYPE = 1073742353;
167pub const CKA_UNWRAP_TEMPLATE: CK_ATTRIBUTE_TYPE = 1073742354;
168pub const CKA_DERIVE_TEMPLATE: CK_ATTRIBUTE_TYPE = 1073742355;
169pub const CKA_ALLOWED_MECHANISMS: CK_ATTRIBUTE_TYPE = 1073743360;
170pub const CKA_ECDSA_PARAMS: CK_ATTRIBUTE_TYPE = 384;
171pub const CKA_SECONDARY_AUTH: CK_ATTRIBUTE_TYPE = 512;
172pub const CKA_AUTH_PIN_FLAGS: CK_ATTRIBUTE_TYPE = 513;
173pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0;
174pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1;
175pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2;
176pub const CKC_VENDOR_DEFINED: CK_CERTIFICATE_TYPE = 2147483648;
177pub const CKD_NULL: CK_EC_KDF_TYPE = 1;
178pub const CKD_SHA1_KDF: CK_EC_KDF_TYPE = 2;
179pub const CKD_SHA1_KDF_ASN1: CK_EC_KDF_TYPE = 3;
180pub const CKD_SHA1_KDF_CONCATENATE: CK_EC_KDF_TYPE = 4;
181pub const CKD_SHA224_KDF: CK_EC_KDF_TYPE = 5;
182pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6;
183pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7;
184pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8;
185pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9;
186pub const CKD_SHA3_224_KDF: CK_EC_KDF_TYPE = 10;
187pub const CKD_SHA3_256_KDF: CK_EC_KDF_TYPE = 11;
188pub const CKD_SHA3_384_KDF: CK_EC_KDF_TYPE = 12;
189pub const CKD_SHA3_512_KDF: CK_EC_KDF_TYPE = 13;
190pub const CKD_SHA1_KDF_SP800: CK_EC_KDF_TYPE = 14;
191pub const CKD_SHA224_KDF_SP800: CK_EC_KDF_TYPE = 15;
192pub const CKD_SHA256_KDF_SP800: CK_EC_KDF_TYPE = 16;
193pub const CKD_SHA384_KDF_SP800: CK_EC_KDF_TYPE = 17;
194pub const CKD_SHA512_KDF_SP800: CK_EC_KDF_TYPE = 18;
195pub const CKD_SHA3_224_KDF_SP800: CK_EC_KDF_TYPE = 19;
196pub const CKD_SHA3_256_KDF_SP800: CK_EC_KDF_TYPE = 20;
197pub const CKD_SHA3_384_KDF_SP800: CK_EC_KDF_TYPE = 21;
198pub const CKD_SHA3_512_KDF_SP800: CK_EC_KDF_TYPE = 22;
199pub const CKD_BLAKE2B_160_KDF: CK_EC_KDF_TYPE = 23;
200pub const CKD_BLAKE2B_256_KDF: CK_EC_KDF_TYPE = 24;
201pub const CKD_BLAKE2B_384_KDF: CK_EC_KDF_TYPE = 25;
202pub const CKD_BLAKE2B_512_KDF: CK_EC_KDF_TYPE = 26;
203pub const CKF_ARRAY_ATTRIBUTE: CK_FLAGS = 1073741824;
204pub const CKF_LIBRARY_CANT_CREATE_OS_THREADS: CK_FLAGS = 1;
205pub const CKF_OS_LOCKING_OK: CK_FLAGS = 2;
206pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1;
207pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2;
208pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4;
209pub const CKF_INTERFACE_FORK_SAFE: CK_FLAGS = 1;
210pub const CKF_HW: CK_FLAGS = 1;
211pub const CKF_MESSAGE_ENCRYPT: CK_FLAGS = 2;
212pub const CKF_MESSAGE_DECRYPT: CK_FLAGS = 4;
213pub const CKF_MESSAGE_SIGN: CK_FLAGS = 8;
214pub const CKF_MESSAGE_VERIFY: CK_FLAGS = 16;
215pub const CKF_MULTI_MESSAGE: CK_FLAGS = 32;
216pub const CKF_MULTI_MESSGE: CK_FLAGS = 32;
217pub const CKF_FIND_OBJECTS: CK_FLAGS = 64;
218pub const CKF_ENCRYPT: CK_FLAGS = 256;
219pub const CKF_DECRYPT: CK_FLAGS = 512;
220pub const CKF_DIGEST: CK_FLAGS = 1024;
221pub const CKF_SIGN: CK_FLAGS = 2048;
222pub const CKF_SIGN_RECOVER: CK_FLAGS = 4096;
223pub const CKF_VERIFY: CK_FLAGS = 8192;
224pub const CKF_VERIFY_RECOVER: CK_FLAGS = 16384;
225pub const CKF_GENERATE: CK_FLAGS = 32768;
226pub const CKF_GENERATE_KEY_PAIR: CK_FLAGS = 65536;
227pub const CKF_WRAP: CK_FLAGS = 131072;
228pub const CKF_UNWRAP: CK_FLAGS = 262144;
229pub const CKF_DERIVE: CK_FLAGS = 524288;
230pub const CKF_EC_F_P: CK_FLAGS = 1048576;
231pub const CKF_EC_F_2M: CK_FLAGS = 2097152;
232pub const CKF_EC_ECPARAMETERS: CK_FLAGS = 4194304;
233pub const CKF_EC_OID: CK_FLAGS = 8388608;
234pub const CKF_EC_UNCOMPRESS: CK_FLAGS = 16777216;
235pub const CKF_EC_COMPRESS: CK_FLAGS = 33554432;
236pub const CKF_EC_CURVENAME: CK_FLAGS = 67108864;
237pub const CKF_EXTENSION: CK_FLAGS = 2147483648;
238pub const CKF_EC_NAMEDCURVE: CK_FLAGS = 8388608;
239pub const CKF_END_OF_MESSAGE: CK_FLAGS = 1;
240pub const CKF_NEXT_OTP: CK_FLAGS = 1;
241pub const CKF_EXCLUDE_TIME: CK_FLAGS = 2;
242pub const CKF_EXCLUDE_COUNTER: CK_FLAGS = 4;
243pub const CKF_EXCLUDE_CHALLENGE: CK_FLAGS = 8;
244pub const CKF_EXCLUDE_PIN: CK_FLAGS = 16;
245pub const CKF_USER_FRIENDLY_OTP: CK_FLAGS = 32;
246pub const CKF_DONT_BLOCK: CK_FLAGS = 1;
247pub const CKF_RW_SESSION: CK_FLAGS = 2;
248pub const CKF_SERIAL_SESSION: CK_FLAGS = 4;
249pub const CKF_TOKEN_PRESENT: CK_FLAGS = 1;
250pub const CKF_REMOVABLE_DEVICE: CK_FLAGS = 2;
251pub const CKF_HW_SLOT: CK_FLAGS = 4;
252pub const CKF_RNG: CK_FLAGS = 1;
253pub const CKF_WRITE_PROTECTED: CK_FLAGS = 2;
254pub const CKF_LOGIN_REQUIRED: CK_FLAGS = 4;
255pub const CKF_USER_PIN_INITIALIZED: CK_FLAGS = 8;
256pub const CKF_RESTORE_KEY_NOT_NEEDED: CK_FLAGS = 32;
257pub const CKF_CLOCK_ON_TOKEN: CK_FLAGS = 64;
258pub const CKF_PROTECTED_AUTHENTICATION_PATH: CK_FLAGS = 256;
259pub const CKF_DUAL_CRYPTO_OPERATIONS: CK_FLAGS = 512;
260pub const CKF_TOKEN_INITIALIZED: CK_FLAGS = 1024;
261pub const CKF_SECONDARY_AUTHENTICATION: CK_FLAGS = 2048;
262pub const CKF_USER_PIN_COUNT_LOW: CK_FLAGS = 65536;
263pub const CKF_USER_PIN_FINAL_TRY: CK_FLAGS = 131072;
264pub const CKF_USER_PIN_LOCKED: CK_FLAGS = 262144;
265pub const CKF_USER_PIN_TO_BE_CHANGED: CK_FLAGS = 524288;
266pub const CKF_SO_PIN_COUNT_LOW: CK_FLAGS = 1048576;
267pub const CKF_SO_PIN_FINAL_TRY: CK_FLAGS = 2097152;
268pub const CKF_SO_PIN_LOCKED: CK_FLAGS = 4194304;
269pub const CKF_SO_PIN_TO_BE_CHANGED: CK_FLAGS = 8388608;
270pub const CKF_ERROR_STATE: CK_FLAGS = 16777216;
271pub const CKG_NO_GENERATE: CK_GENERATOR_FUNCTION = 0;
272pub const CKG_GENERATE: CK_GENERATOR_FUNCTION = 1;
273pub const CKG_GENERATE_COUNTER: CK_GENERATOR_FUNCTION = 2;
274pub const CKG_GENERATE_RANDOM: CK_GENERATOR_FUNCTION = 3;
275pub const CKG_GENERATE_COUNTER_XOR: CK_GENERATOR_FUNCTION = 4;
276pub const CKG_MGF1_SHA1: CK_GENERATOR_FUNCTION = 1;
277pub const CKG_MGF1_SHA256: CK_GENERATOR_FUNCTION = 2;
278pub const CKG_MGF1_SHA384: CK_GENERATOR_FUNCTION = 3;
279pub const CKG_MGF1_SHA512: CK_GENERATOR_FUNCTION = 4;
280pub const CKG_MGF1_SHA224: CK_GENERATOR_FUNCTION = 5;
281pub const CKG_MGF1_SHA3_224: CK_GENERATOR_FUNCTION = 6;
282pub const CKG_MGF1_SHA3_256: CK_GENERATOR_FUNCTION = 7;
283pub const CKG_MGF1_SHA3_384: CK_GENERATOR_FUNCTION = 8;
284pub const CKG_MGF1_SHA3_512: CK_GENERATOR_FUNCTION = 9;
285pub const CKH_MONOTONIC_COUNTER: CK_HW_FEATURE_TYPE = 1;
286pub const CKH_CLOCK: CK_HW_FEATURE_TYPE = 2;
287pub const CKH_USER_INTERFACE: CK_HW_FEATURE_TYPE = 3;
288pub const CKH_VENDOR_DEFINED: CK_HW_FEATURE_TYPE = 2147483648;
289pub const CKK_RSA: CK_KEY_TYPE = 0;
290pub const CKK_DSA: CK_KEY_TYPE = 1;
291pub const CKK_DH: CK_KEY_TYPE = 2;
292pub const CKK_EC: CK_KEY_TYPE = 3;
293pub const CKK_X9_42_DH: CK_KEY_TYPE = 4;
294pub const CKK_KEA: CK_KEY_TYPE = 5;
295pub const CKK_GENERIC_SECRET: CK_KEY_TYPE = 16;
296pub const CKK_RC2: CK_KEY_TYPE = 17;
297pub const CKK_RC4: CK_KEY_TYPE = 18;
298pub const CKK_DES: CK_KEY_TYPE = 19;
299pub const CKK_DES2: CK_KEY_TYPE = 20;
300pub const CKK_DES3: CK_KEY_TYPE = 21;
301pub const CKK_CAST: CK_KEY_TYPE = 22;
302pub const CKK_CAST3: CK_KEY_TYPE = 23;
303pub const CKK_CAST128: CK_KEY_TYPE = 24;
304pub const CKK_RC5: CK_KEY_TYPE = 25;
305pub const CKK_IDEA: CK_KEY_TYPE = 26;
306pub const CKK_SKIPJACK: CK_KEY_TYPE = 27;
307pub const CKK_BATON: CK_KEY_TYPE = 28;
308pub const CKK_JUNIPER: CK_KEY_TYPE = 29;
309pub const CKK_CDMF: CK_KEY_TYPE = 30;
310pub const CKK_AES: CK_KEY_TYPE = 31;
311pub const CKK_BLOWFISH: CK_KEY_TYPE = 32;
312pub const CKK_TWOFISH: CK_KEY_TYPE = 33;
313pub const CKK_SECURID: CK_KEY_TYPE = 34;
314pub const CKK_HOTP: CK_KEY_TYPE = 35;
315pub const CKK_ACTI: CK_KEY_TYPE = 36;
316pub const CKK_CAMELLIA: CK_KEY_TYPE = 37;
317pub const CKK_ARIA: CK_KEY_TYPE = 38;
318pub const CKK_MD5_HMAC: CK_KEY_TYPE = 39;
319pub const CKK_SHA_1_HMAC: CK_KEY_TYPE = 40;
320pub const CKK_RIPEMD128_HMAC: CK_KEY_TYPE = 41;
321pub const CKK_RIPEMD160_HMAC: CK_KEY_TYPE = 42;
322pub const CKK_SHA256_HMAC: CK_KEY_TYPE = 43;
323pub const CKK_SHA384_HMAC: CK_KEY_TYPE = 44;
324pub const CKK_SHA512_HMAC: CK_KEY_TYPE = 45;
325pub const CKK_SHA224_HMAC: CK_KEY_TYPE = 46;
326pub const CKK_SEED: CK_KEY_TYPE = 47;
327pub const CKK_GOSTR3410: CK_KEY_TYPE = 48;
328pub const CKK_GOSTR3411: CK_KEY_TYPE = 49;
329pub const CKK_GOST28147: CK_KEY_TYPE = 50;
330pub const CKK_CHACHA20: CK_KEY_TYPE = 51;
331pub const CKK_POLY1305: CK_KEY_TYPE = 52;
332pub const CKK_AES_XTS: CK_KEY_TYPE = 53;
333pub const CKK_SHA3_224_HMAC: CK_KEY_TYPE = 54;
334pub const CKK_SHA3_256_HMAC: CK_KEY_TYPE = 55;
335pub const CKK_SHA3_384_HMAC: CK_KEY_TYPE = 56;
336pub const CKK_SHA3_512_HMAC: CK_KEY_TYPE = 57;
337pub const CKK_BLAKE2B_160_HMAC: CK_KEY_TYPE = 58;
338pub const CKK_BLAKE2B_256_HMAC: CK_KEY_TYPE = 59;
339pub const CKK_BLAKE2B_384_HMAC: CK_KEY_TYPE = 60;
340pub const CKK_BLAKE2B_512_HMAC: CK_KEY_TYPE = 61;
341pub const CKK_SALSA20: CK_KEY_TYPE = 62;
342pub const CKK_X2RATCHET: CK_KEY_TYPE = 63;
343pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64;
344pub const CKK_EC_MONTGOMERY: CK_KEY_TYPE = 65;
345pub const CKK_HKDF: CK_KEY_TYPE = 66;
346pub const CKK_SHA512_224_HMAC: CK_KEY_TYPE = 67;
347pub const CKK_SHA512_256_HMAC: CK_KEY_TYPE = 68;
348pub const CKK_SHA512_T_HMAC: CK_KEY_TYPE = 69;
349pub const CKK_HSS: CK_KEY_TYPE = 70;
350pub const CKK_VENDOR_DEFINED: CK_KEY_TYPE = 2147483648;
351pub const CKK_ECDSA: CK_KEY_TYPE = 3;
352pub const CKK_CAST5: CK_KEY_TYPE = 24;
353pub const CKM_RSA_PKCS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0;
354pub const CKM_RSA_PKCS: CK_MECHANISM_TYPE = 1;
355pub const CKM_RSA_9796: CK_MECHANISM_TYPE = 2;
356pub const CKM_RSA_X_509: CK_MECHANISM_TYPE = 3;
357pub const CKM_MD2_RSA_PKCS: CK_MECHANISM_TYPE = 4;
358pub const CKM_MD5_RSA_PKCS: CK_MECHANISM_TYPE = 5;
359pub const CKM_SHA1_RSA_PKCS: CK_MECHANISM_TYPE = 6;
360pub const CKM_RIPEMD128_RSA_PKCS: CK_MECHANISM_TYPE = 7;
361pub const CKM_RIPEMD160_RSA_PKCS: CK_MECHANISM_TYPE = 8;
362pub const CKM_RSA_PKCS_OAEP: CK_MECHANISM_TYPE = 9;
363pub const CKM_RSA_X9_31_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 10;
364pub const CKM_RSA_X9_31: CK_MECHANISM_TYPE = 11;
365pub const CKM_SHA1_RSA_X9_31: CK_MECHANISM_TYPE = 12;
366pub const CKM_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 13;
367pub const CKM_SHA1_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 14;
368pub const CKM_DSA_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 16;
369pub const CKM_DSA: CK_MECHANISM_TYPE = 17;
370pub const CKM_DSA_SHA1: CK_MECHANISM_TYPE = 18;
371pub const CKM_DSA_SHA224: CK_MECHANISM_TYPE = 19;
372pub const CKM_DSA_SHA256: CK_MECHANISM_TYPE = 20;
373pub const CKM_DSA_SHA384: CK_MECHANISM_TYPE = 21;
374pub const CKM_DSA_SHA512: CK_MECHANISM_TYPE = 22;
375pub const CKM_DSA_SHA3_224: CK_MECHANISM_TYPE = 24;
376pub const CKM_DSA_SHA3_256: CK_MECHANISM_TYPE = 25;
377pub const CKM_DSA_SHA3_384: CK_MECHANISM_TYPE = 26;
378pub const CKM_DSA_SHA3_512: CK_MECHANISM_TYPE = 27;
379pub const CKM_DH_PKCS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 32;
380pub const CKM_DH_PKCS_DERIVE: CK_MECHANISM_TYPE = 33;
381pub const CKM_X9_42_DH_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 48;
382pub const CKM_X9_42_DH_DERIVE: CK_MECHANISM_TYPE = 49;
383pub const CKM_X9_42_DH_HYBRID_DERIVE: CK_MECHANISM_TYPE = 50;
384pub const CKM_X9_42_MQV_DERIVE: CK_MECHANISM_TYPE = 51;
385pub const CKM_SHA256_RSA_PKCS: CK_MECHANISM_TYPE = 64;
386pub const CKM_SHA384_RSA_PKCS: CK_MECHANISM_TYPE = 65;
387pub const CKM_SHA512_RSA_PKCS: CK_MECHANISM_TYPE = 66;
388pub const CKM_SHA256_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 67;
389pub const CKM_SHA384_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 68;
390pub const CKM_SHA512_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 69;
391pub const CKM_SHA224_RSA_PKCS: CK_MECHANISM_TYPE = 70;
392pub const CKM_SHA224_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 71;
393pub const CKM_SHA512_224: CK_MECHANISM_TYPE = 72;
394pub const CKM_SHA512_224_HMAC: CK_MECHANISM_TYPE = 73;
395pub const CKM_SHA512_224_HMAC_GENERAL: CK_MECHANISM_TYPE = 74;
396pub const CKM_SHA512_224_KEY_DERIVATION: CK_MECHANISM_TYPE = 75;
397pub const CKM_SHA512_256: CK_MECHANISM_TYPE = 76;
398pub const CKM_SHA512_256_HMAC: CK_MECHANISM_TYPE = 77;
399pub const CKM_SHA512_256_HMAC_GENERAL: CK_MECHANISM_TYPE = 78;
400pub const CKM_SHA512_256_KEY_DERIVATION: CK_MECHANISM_TYPE = 79;
401pub const CKM_SHA512_T: CK_MECHANISM_TYPE = 80;
402pub const CKM_SHA512_T_HMAC: CK_MECHANISM_TYPE = 81;
403pub const CKM_SHA512_T_HMAC_GENERAL: CK_MECHANISM_TYPE = 82;
404pub const CKM_SHA512_T_KEY_DERIVATION: CK_MECHANISM_TYPE = 83;
405pub const CKM_SHA3_256_RSA_PKCS: CK_MECHANISM_TYPE = 96;
406pub const CKM_SHA3_384_RSA_PKCS: CK_MECHANISM_TYPE = 97;
407pub const CKM_SHA3_512_RSA_PKCS: CK_MECHANISM_TYPE = 98;
408pub const CKM_SHA3_256_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 99;
409pub const CKM_SHA3_384_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 100;
410pub const CKM_SHA3_512_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 101;
411pub const CKM_SHA3_224_RSA_PKCS: CK_MECHANISM_TYPE = 102;
412pub const CKM_SHA3_224_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 103;
413pub const CKM_RC2_KEY_GEN: CK_MECHANISM_TYPE = 256;
414pub const CKM_RC2_ECB: CK_MECHANISM_TYPE = 257;
415pub const CKM_RC2_CBC: CK_MECHANISM_TYPE = 258;
416pub const CKM_RC2_MAC: CK_MECHANISM_TYPE = 259;
417pub const CKM_RC2_MAC_GENERAL: CK_MECHANISM_TYPE = 260;
418pub const CKM_RC2_CBC_PAD: CK_MECHANISM_TYPE = 261;
419pub const CKM_RC4_KEY_GEN: CK_MECHANISM_TYPE = 272;
420pub const CKM_RC4: CK_MECHANISM_TYPE = 273;
421pub const CKM_DES_KEY_GEN: CK_MECHANISM_TYPE = 288;
422pub const CKM_DES_ECB: CK_MECHANISM_TYPE = 289;
423pub const CKM_DES_CBC: CK_MECHANISM_TYPE = 290;
424pub const CKM_DES_MAC: CK_MECHANISM_TYPE = 291;
425pub const CKM_DES_MAC_GENERAL: CK_MECHANISM_TYPE = 292;
426pub const CKM_DES_CBC_PAD: CK_MECHANISM_TYPE = 293;
427pub const CKM_DES2_KEY_GEN: CK_MECHANISM_TYPE = 304;
428pub const CKM_DES3_KEY_GEN: CK_MECHANISM_TYPE = 305;
429pub const CKM_DES3_ECB: CK_MECHANISM_TYPE = 306;
430pub const CKM_DES3_CBC: CK_MECHANISM_TYPE = 307;
431pub const CKM_DES3_MAC: CK_MECHANISM_TYPE = 308;
432pub const CKM_DES3_MAC_GENERAL: CK_MECHANISM_TYPE = 309;
433pub const CKM_DES3_CBC_PAD: CK_MECHANISM_TYPE = 310;
434pub const CKM_DES3_CMAC_GENERAL: CK_MECHANISM_TYPE = 311;
435pub const CKM_DES3_CMAC: CK_MECHANISM_TYPE = 312;
436pub const CKM_CDMF_KEY_GEN: CK_MECHANISM_TYPE = 320;
437pub const CKM_CDMF_ECB: CK_MECHANISM_TYPE = 321;
438pub const CKM_CDMF_CBC: CK_MECHANISM_TYPE = 322;
439pub const CKM_CDMF_MAC: CK_MECHANISM_TYPE = 323;
440pub const CKM_CDMF_MAC_GENERAL: CK_MECHANISM_TYPE = 324;
441pub const CKM_CDMF_CBC_PAD: CK_MECHANISM_TYPE = 325;
442pub const CKM_DES_OFB64: CK_MECHANISM_TYPE = 336;
443pub const CKM_DES_OFB8: CK_MECHANISM_TYPE = 337;
444pub const CKM_DES_CFB64: CK_MECHANISM_TYPE = 338;
445pub const CKM_DES_CFB8: CK_MECHANISM_TYPE = 339;
446pub const CKM_MD2: CK_MECHANISM_TYPE = 512;
447pub const CKM_MD2_HMAC: CK_MECHANISM_TYPE = 513;
448pub const CKM_MD2_HMAC_GENERAL: CK_MECHANISM_TYPE = 514;
449pub const CKM_MD5: CK_MECHANISM_TYPE = 528;
450pub const CKM_MD5_HMAC: CK_MECHANISM_TYPE = 529;
451pub const CKM_MD5_HMAC_GENERAL: CK_MECHANISM_TYPE = 530;
452pub const CKM_SHA_1: CK_MECHANISM_TYPE = 544;
453pub const CKM_SHA_1_HMAC: CK_MECHANISM_TYPE = 545;
454pub const CKM_SHA_1_HMAC_GENERAL: CK_MECHANISM_TYPE = 546;
455pub const CKM_RIPEMD128: CK_MECHANISM_TYPE = 560;
456pub const CKM_RIPEMD128_HMAC: CK_MECHANISM_TYPE = 561;
457pub const CKM_RIPEMD128_HMAC_GENERAL: CK_MECHANISM_TYPE = 562;
458pub const CKM_RIPEMD160: CK_MECHANISM_TYPE = 576;
459pub const CKM_RIPEMD160_HMAC: CK_MECHANISM_TYPE = 577;
460pub const CKM_RIPEMD160_HMAC_GENERAL: CK_MECHANISM_TYPE = 578;
461pub const CKM_SHA256: CK_MECHANISM_TYPE = 592;
462pub const CKM_SHA256_HMAC: CK_MECHANISM_TYPE = 593;
463pub const CKM_SHA256_HMAC_GENERAL: CK_MECHANISM_TYPE = 594;
464pub const CKM_SHA224: CK_MECHANISM_TYPE = 597;
465pub const CKM_SHA224_HMAC: CK_MECHANISM_TYPE = 598;
466pub const CKM_SHA224_HMAC_GENERAL: CK_MECHANISM_TYPE = 599;
467pub const CKM_SHA384: CK_MECHANISM_TYPE = 608;
468pub const CKM_SHA384_HMAC: CK_MECHANISM_TYPE = 609;
469pub const CKM_SHA384_HMAC_GENERAL: CK_MECHANISM_TYPE = 610;
470pub const CKM_SHA512: CK_MECHANISM_TYPE = 624;
471pub const CKM_SHA512_HMAC: CK_MECHANISM_TYPE = 625;
472pub const CKM_SHA512_HMAC_GENERAL: CK_MECHANISM_TYPE = 626;
473pub const CKM_SECURID_KEY_GEN: CK_MECHANISM_TYPE = 640;
474pub const CKM_SECURID: CK_MECHANISM_TYPE = 642;
475pub const CKM_HOTP_KEY_GEN: CK_MECHANISM_TYPE = 656;
476pub const CKM_HOTP: CK_MECHANISM_TYPE = 657;
477pub const CKM_ACTI: CK_MECHANISM_TYPE = 672;
478pub const CKM_ACTI_KEY_GEN: CK_MECHANISM_TYPE = 673;
479pub const CKM_SHA3_256: CK_MECHANISM_TYPE = 688;
480pub const CKM_SHA3_256_HMAC: CK_MECHANISM_TYPE = 689;
481pub const CKM_SHA3_256_HMAC_GENERAL: CK_MECHANISM_TYPE = 690;
482pub const CKM_SHA3_256_KEY_GEN: CK_MECHANISM_TYPE = 691;
483pub const CKM_SHA3_224: CK_MECHANISM_TYPE = 693;
484pub const CKM_SHA3_224_HMAC: CK_MECHANISM_TYPE = 694;
485pub const CKM_SHA3_224_HMAC_GENERAL: CK_MECHANISM_TYPE = 695;
486pub const CKM_SHA3_224_KEY_GEN: CK_MECHANISM_TYPE = 696;
487pub const CKM_SHA3_384: CK_MECHANISM_TYPE = 704;
488pub const CKM_SHA3_384_HMAC: CK_MECHANISM_TYPE = 705;
489pub const CKM_SHA3_384_HMAC_GENERAL: CK_MECHANISM_TYPE = 706;
490pub const CKM_SHA3_384_KEY_GEN: CK_MECHANISM_TYPE = 707;
491pub const CKM_SHA3_512: CK_MECHANISM_TYPE = 720;
492pub const CKM_SHA3_512_HMAC: CK_MECHANISM_TYPE = 721;
493pub const CKM_SHA3_512_HMAC_GENERAL: CK_MECHANISM_TYPE = 722;
494pub const CKM_SHA3_512_KEY_GEN: CK_MECHANISM_TYPE = 723;
495pub const CKM_CAST_KEY_GEN: CK_MECHANISM_TYPE = 768;
496pub const CKM_CAST_ECB: CK_MECHANISM_TYPE = 769;
497pub const CKM_CAST_CBC: CK_MECHANISM_TYPE = 770;
498pub const CKM_CAST_MAC: CK_MECHANISM_TYPE = 771;
499pub const CKM_CAST_MAC_GENERAL: CK_MECHANISM_TYPE = 772;
500pub const CKM_CAST_CBC_PAD: CK_MECHANISM_TYPE = 773;
501pub const CKM_CAST3_KEY_GEN: CK_MECHANISM_TYPE = 784;
502pub const CKM_CAST3_ECB: CK_MECHANISM_TYPE = 785;
503pub const CKM_CAST3_CBC: CK_MECHANISM_TYPE = 786;
504pub const CKM_CAST3_MAC: CK_MECHANISM_TYPE = 787;
505pub const CKM_CAST3_MAC_GENERAL: CK_MECHANISM_TYPE = 788;
506pub const CKM_CAST3_CBC_PAD: CK_MECHANISM_TYPE = 789;
507pub const CKM_CAST128_KEY_GEN: CK_MECHANISM_TYPE = 800;
508pub const CKM_CAST5_ECB: CK_MECHANISM_TYPE = 801;
509pub const CKM_CAST128_ECB: CK_MECHANISM_TYPE = 801;
510pub const CKM_CAST128_MAC: CK_MECHANISM_TYPE = 803;
511pub const CKM_CAST128_CBC: CK_MECHANISM_TYPE = 802;
512pub const CKM_CAST128_MAC_GENERAL: CK_MECHANISM_TYPE = 804;
513pub const CKM_CAST128_CBC_PAD: CK_MECHANISM_TYPE = 805;
514pub const CKM_RC5_KEY_GEN: CK_MECHANISM_TYPE = 816;
515pub const CKM_RC5_ECB: CK_MECHANISM_TYPE = 817;
516pub const CKM_RC5_CBC: CK_MECHANISM_TYPE = 818;
517pub const CKM_RC5_MAC: CK_MECHANISM_TYPE = 819;
518pub const CKM_RC5_MAC_GENERAL: CK_MECHANISM_TYPE = 820;
519pub const CKM_RC5_CBC_PAD: CK_MECHANISM_TYPE = 821;
520pub const CKM_IDEA_KEY_GEN: CK_MECHANISM_TYPE = 832;
521pub const CKM_IDEA_ECB: CK_MECHANISM_TYPE = 833;
522pub const CKM_IDEA_CBC: CK_MECHANISM_TYPE = 834;
523pub const CKM_IDEA_MAC: CK_MECHANISM_TYPE = 835;
524pub const CKM_IDEA_MAC_GENERAL: CK_MECHANISM_TYPE = 836;
525pub const CKM_IDEA_CBC_PAD: CK_MECHANISM_TYPE = 837;
526pub const CKM_GENERIC_SECRET_KEY_GEN: CK_MECHANISM_TYPE = 848;
527pub const CKM_CONCATENATE_BASE_AND_KEY: CK_MECHANISM_TYPE = 864;
528pub const CKM_CONCATENATE_BASE_AND_DATA: CK_MECHANISM_TYPE = 866;
529pub const CKM_CONCATENATE_DATA_AND_BASE: CK_MECHANISM_TYPE = 867;
530pub const CKM_XOR_BASE_AND_DATA: CK_MECHANISM_TYPE = 868;
531pub const CKM_EXTRACT_KEY_FROM_KEY: CK_MECHANISM_TYPE = 869;
532pub const CKM_SSL3_PRE_MASTER_KEY_GEN: CK_MECHANISM_TYPE = 880;
533pub const CKM_SSL3_MASTER_KEY_DERIVE: CK_MECHANISM_TYPE = 881;
534pub const CKM_SSL3_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 882;
535pub const CKM_SSL3_MASTER_KEY_DERIVE_DH: CK_MECHANISM_TYPE = 883;
536pub const CKM_TLS_PRE_MASTER_KEY_GEN: CK_MECHANISM_TYPE = 884;
537pub const CKM_TLS_MASTER_KEY_DERIVE: CK_MECHANISM_TYPE = 885;
538pub const CKM_TLS_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 886;
539pub const CKM_TLS_MASTER_KEY_DERIVE_DH: CK_MECHANISM_TYPE = 887;
540pub const CKM_TLS_PRF: CK_MECHANISM_TYPE = 888;
541pub const CKM_SSL3_MD5_MAC: CK_MECHANISM_TYPE = 896;
542pub const CKM_SSL3_SHA1_MAC: CK_MECHANISM_TYPE = 897;
543pub const CKM_MD5_KEY_DERIVATION: CK_MECHANISM_TYPE = 912;
544pub const CKM_MD2_KEY_DERIVATION: CK_MECHANISM_TYPE = 913;
545pub const CKM_SHA1_KEY_DERIVATION: CK_MECHANISM_TYPE = 914;
546pub const CKM_SHA256_KEY_DERIVATION: CK_MECHANISM_TYPE = 915;
547pub const CKM_SHA384_KEY_DERIVATION: CK_MECHANISM_TYPE = 916;
548pub const CKM_SHA512_KEY_DERIVATION: CK_MECHANISM_TYPE = 917;
549pub const CKM_SHA224_KEY_DERIVATION: CK_MECHANISM_TYPE = 918;
550pub const CKM_SHA3_256_KEY_DERIVATION: CK_MECHANISM_TYPE = 919;
551pub const CKM_SHA3_256_KEY_DERIVE: CK_MECHANISM_TYPE = 919;
552pub const CKM_SHA3_224_KEY_DERIVATION: CK_MECHANISM_TYPE = 920;
553pub const CKM_SHA3_224_KEY_DERIVE: CK_MECHANISM_TYPE = 920;
554pub const CKM_SHA3_384_KEY_DERIVATION: CK_MECHANISM_TYPE = 921;
555pub const CKM_SHA3_384_KEY_DERIVE: CK_MECHANISM_TYPE = 921;
556pub const CKM_SHA3_512_KEY_DERIVATION: CK_MECHANISM_TYPE = 922;
557pub const CKM_SHA3_512_KEY_DERIVE: CK_MECHANISM_TYPE = 922;
558pub const CKM_SHAKE_128_KEY_DERIVATION: CK_MECHANISM_TYPE = 923;
559pub const CKM_SHAKE_128_KEY_DERIVE: CK_MECHANISM_TYPE = 923;
560pub const CKM_SHAKE_256_KEY_DERIVATION: CK_MECHANISM_TYPE = 924;
561pub const CKM_SHAKE_256_KEY_DERIVE: CK_MECHANISM_TYPE = 924;
562pub const CKM_PBE_MD2_DES_CBC: CK_MECHANISM_TYPE = 928;
563pub const CKM_PBE_MD5_DES_CBC: CK_MECHANISM_TYPE = 929;
564pub const CKM_PBE_MD5_CAST_CBC: CK_MECHANISM_TYPE = 930;
565pub const CKM_PBE_MD5_CAST3_CBC: CK_MECHANISM_TYPE = 931;
566pub const CKM_PBE_MD5_CAST128_CBC: CK_MECHANISM_TYPE = 932;
567pub const CKM_PBE_SHA1_CAST128_CBC: CK_MECHANISM_TYPE = 933;
568pub const CKM_PBE_SHA1_RC4_128: CK_MECHANISM_TYPE = 934;
569pub const CKM_PBE_SHA1_RC4_40: CK_MECHANISM_TYPE = 935;
570pub const CKM_PBE_SHA1_DES3_EDE_CBC: CK_MECHANISM_TYPE = 936;
571pub const CKM_PBE_SHA1_DES2_EDE_CBC: CK_MECHANISM_TYPE = 937;
572pub const CKM_PBE_SHA1_RC2_128_CBC: CK_MECHANISM_TYPE = 938;
573pub const CKM_PBE_SHA1_RC2_40_CBC: CK_MECHANISM_TYPE = 939;
574pub const CKM_PKCS5_PBKD2: CK_MECHANISM_TYPE = 944;
575pub const CKM_PBA_SHA1_WITH_SHA1_HMAC: CK_MECHANISM_TYPE = 960;
576pub const CKM_WTLS_PRE_MASTER_KEY_GEN: CK_MECHANISM_TYPE = 976;
577pub const CKM_WTLS_MASTER_KEY_DERIVE: CK_MECHANISM_TYPE = 977;
578pub const CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC: CK_MECHANISM_TYPE = 978;
579pub const CKM_WTLS_PRF: CK_MECHANISM_TYPE = 979;
580pub const CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 980;
581pub const CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 981;
582pub const CKM_TLS10_MAC_SERVER: CK_MECHANISM_TYPE = 982;
583pub const CKM_TLS10_MAC_CLIENT: CK_MECHANISM_TYPE = 983;
584pub const CKM_TLS12_MAC: CK_MECHANISM_TYPE = 984;
585pub const CKM_TLS12_KDF: CK_MECHANISM_TYPE = 985;
586pub const CKM_TLS12_MASTER_KEY_DERIVE: CK_MECHANISM_TYPE = 992;
587pub const CKM_TLS12_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 993;
588pub const CKM_TLS12_MASTER_KEY_DERIVE_DH: CK_MECHANISM_TYPE = 994;
589pub const CKM_TLS12_KEY_SAFE_DERIVE: CK_MECHANISM_TYPE = 995;
590pub const CKM_TLS_MAC: CK_MECHANISM_TYPE = 996;
591pub const CKM_TLS_KDF: CK_MECHANISM_TYPE = 997;
592pub const CKM_KEY_WRAP_LYNKS: CK_MECHANISM_TYPE = 1024;
593pub const CKM_KEY_WRAP_SET_OAEP: CK_MECHANISM_TYPE = 1025;
594pub const CKM_CMS_SIG: CK_MECHANISM_TYPE = 1280;
595pub const CKM_KIP_DERIVE: CK_MECHANISM_TYPE = 1296;
596pub const CKM_KIP_WRAP: CK_MECHANISM_TYPE = 1297;
597pub const CKM_KIP_MAC: CK_MECHANISM_TYPE = 1298;
598pub const CKM_CAMELLIA_KEY_GEN: CK_MECHANISM_TYPE = 1360;
599pub const CKM_CAMELLIA_ECB: CK_MECHANISM_TYPE = 1361;
600pub const CKM_CAMELLIA_CBC: CK_MECHANISM_TYPE = 1362;
601pub const CKM_CAMELLIA_MAC: CK_MECHANISM_TYPE = 1363;
602pub const CKM_CAMELLIA_MAC_GENERAL: CK_MECHANISM_TYPE = 1364;
603pub const CKM_CAMELLIA_CBC_PAD: CK_MECHANISM_TYPE = 1365;
604pub const CKM_CAMELLIA_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 1366;
605pub const CKM_CAMELLIA_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 1367;
606pub const CKM_CAMELLIA_CTR: CK_MECHANISM_TYPE = 1368;
607pub const CKM_ARIA_KEY_GEN: CK_MECHANISM_TYPE = 1376;
608pub const CKM_ARIA_ECB: CK_MECHANISM_TYPE = 1377;
609pub const CKM_ARIA_CBC: CK_MECHANISM_TYPE = 1378;
610pub const CKM_ARIA_MAC: CK_MECHANISM_TYPE = 1379;
611pub const CKM_ARIA_MAC_GENERAL: CK_MECHANISM_TYPE = 1380;
612pub const CKM_ARIA_CBC_PAD: CK_MECHANISM_TYPE = 1381;
613pub const CKM_ARIA_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 1382;
614pub const CKM_ARIA_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 1383;
615pub const CKM_SEED_KEY_GEN: CK_MECHANISM_TYPE = 1616;
616pub const CKM_SEED_ECB: CK_MECHANISM_TYPE = 1617;
617pub const CKM_SEED_CBC: CK_MECHANISM_TYPE = 1618;
618pub const CKM_SEED_MAC: CK_MECHANISM_TYPE = 1619;
619pub const CKM_SEED_MAC_GENERAL: CK_MECHANISM_TYPE = 1620;
620pub const CKM_SEED_CBC_PAD: CK_MECHANISM_TYPE = 1621;
621pub const CKM_SEED_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 1622;
622pub const CKM_SEED_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 1623;
623pub const CKM_SKIPJACK_KEY_GEN: CK_MECHANISM_TYPE = 4096;
624pub const CKM_SKIPJACK_ECB64: CK_MECHANISM_TYPE = 4097;
625pub const CKM_SKIPJACK_CBC64: CK_MECHANISM_TYPE = 4098;
626pub const CKM_SKIPJACK_OFB64: CK_MECHANISM_TYPE = 4099;
627pub const CKM_SKIPJACK_CFB64: CK_MECHANISM_TYPE = 4100;
628pub const CKM_SKIPJACK_CFB32: CK_MECHANISM_TYPE = 4101;
629pub const CKM_SKIPJACK_CFB16: CK_MECHANISM_TYPE = 4102;
630pub const CKM_SKIPJACK_CFB8: CK_MECHANISM_TYPE = 4103;
631pub const CKM_SKIPJACK_WRAP: CK_MECHANISM_TYPE = 4104;
632pub const CKM_SKIPJACK_PRIVATE_WRAP: CK_MECHANISM_TYPE = 4105;
633pub const CKM_SKIPJACK_RELAYX: CK_MECHANISM_TYPE = 4106;
634pub const CKM_KEA_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4112;
635pub const CKM_KEA_KEY_DERIVE: CK_MECHANISM_TYPE = 4113;
636pub const CKM_KEA_DERIVE: CK_MECHANISM_TYPE = 4114;
637pub const CKM_FORTEZZA_TIMESTAMP: CK_MECHANISM_TYPE = 4128;
638pub const CKM_BATON_KEY_GEN: CK_MECHANISM_TYPE = 4144;
639pub const CKM_BATON_ECB128: CK_MECHANISM_TYPE = 4145;
640pub const CKM_BATON_ECB96: CK_MECHANISM_TYPE = 4146;
641pub const CKM_BATON_CBC128: CK_MECHANISM_TYPE = 4147;
642pub const CKM_BATON_COUNTER: CK_MECHANISM_TYPE = 4148;
643pub const CKM_BATON_SHUFFLE: CK_MECHANISM_TYPE = 4149;
644pub const CKM_BATON_WRAP: CK_MECHANISM_TYPE = 4150;
645pub const CKM_EC_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4160;
646pub const CKM_ECDSA: CK_MECHANISM_TYPE = 4161;
647pub const CKM_ECDSA_SHA1: CK_MECHANISM_TYPE = 4162;
648pub const CKM_ECDSA_SHA224: CK_MECHANISM_TYPE = 4163;
649pub const CKM_ECDSA_SHA256: CK_MECHANISM_TYPE = 4164;
650pub const CKM_ECDSA_SHA384: CK_MECHANISM_TYPE = 4165;
651pub const CKM_ECDSA_SHA512: CK_MECHANISM_TYPE = 4166;
652pub const CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS: CK_MECHANISM_TYPE = 5131;
653pub const CKM_ECDH1_DERIVE: CK_MECHANISM_TYPE = 4176;
654pub const CKM_ECDH1_COFACTOR_DERIVE: CK_MECHANISM_TYPE = 4177;
655pub const CKM_ECMQV_DERIVE: CK_MECHANISM_TYPE = 4178;
656pub const CKM_ECDH_AES_KEY_WRAP: CK_MECHANISM_TYPE = 4179;
657pub const CKM_RSA_AES_KEY_WRAP: CK_MECHANISM_TYPE = 4180;
658pub const CKM_JUNIPER_KEY_GEN: CK_MECHANISM_TYPE = 4192;
659pub const CKM_JUNIPER_ECB128: CK_MECHANISM_TYPE = 4193;
660pub const CKM_JUNIPER_CBC128: CK_MECHANISM_TYPE = 4194;
661pub const CKM_JUNIPER_COUNTER: CK_MECHANISM_TYPE = 4195;
662pub const CKM_JUNIPER_SHUFFLE: CK_MECHANISM_TYPE = 4196;
663pub const CKM_JUNIPER_WRAP: CK_MECHANISM_TYPE = 4197;
664pub const CKM_FASTHASH: CK_MECHANISM_TYPE = 4208;
665pub const CKM_AES_XTS: CK_MECHANISM_TYPE = 4209;
666pub const CKM_AES_XTS_KEY_GEN: CK_MECHANISM_TYPE = 4210;
667pub const CKM_AES_KEY_GEN: CK_MECHANISM_TYPE = 4224;
668pub const CKM_AES_ECB: CK_MECHANISM_TYPE = 4225;
669pub const CKM_AES_CBC: CK_MECHANISM_TYPE = 4226;
670pub const CKM_AES_MAC: CK_MECHANISM_TYPE = 4227;
671pub const CKM_AES_MAC_GENERAL: CK_MECHANISM_TYPE = 4228;
672pub const CKM_AES_CBC_PAD: CK_MECHANISM_TYPE = 4229;
673pub const CKM_AES_CTR: CK_MECHANISM_TYPE = 4230;
674pub const CKM_AES_GCM: CK_MECHANISM_TYPE = 4231;
675pub const CKM_AES_CCM: CK_MECHANISM_TYPE = 4232;
676pub const CKM_AES_CTS: CK_MECHANISM_TYPE = 4233;
677pub const CKM_AES_CMAC: CK_MECHANISM_TYPE = 4234;
678pub const CKM_AES_CMAC_GENERAL: CK_MECHANISM_TYPE = 4235;
679pub const CKM_AES_XCBC_MAC: CK_MECHANISM_TYPE = 4236;
680pub const CKM_AES_XCBC_MAC_96: CK_MECHANISM_TYPE = 4237;
681pub const CKM_AES_GMAC: CK_MECHANISM_TYPE = 4238;
682pub const CKM_BLOWFISH_KEY_GEN: CK_MECHANISM_TYPE = 4240;
683pub const CKM_BLOWFISH_CBC: CK_MECHANISM_TYPE = 4241;
684pub const CKM_TWOFISH_KEY_GEN: CK_MECHANISM_TYPE = 4242;
685pub const CKM_TWOFISH_CBC: CK_MECHANISM_TYPE = 4243;
686pub const CKM_BLOWFISH_CBC_PAD: CK_MECHANISM_TYPE = 4244;
687pub const CKM_TWOFISH_CBC_PAD: CK_MECHANISM_TYPE = 4245;
688pub const CKM_DES_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 4352;
689pub const CKM_DES_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 4353;
690pub const CKM_DES3_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 4354;
691pub const CKM_DES3_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 4355;
692pub const CKM_AES_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 4356;
693pub const CKM_AES_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 4357;
694pub const CKM_GOSTR3410_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4608;
695pub const CKM_GOSTR3410: CK_MECHANISM_TYPE = 4609;
696pub const CKM_GOSTR3410_WITH_GOSTR3411: CK_MECHANISM_TYPE = 4610;
697pub const CKM_GOSTR3410_KEY_WRAP: CK_MECHANISM_TYPE = 4611;
698pub const CKM_GOSTR3410_DERIVE: CK_MECHANISM_TYPE = 4612;
699pub const CKM_GOSTR3411: CK_MECHANISM_TYPE = 4624;
700pub const CKM_GOSTR3411_HMAC: CK_MECHANISM_TYPE = 4625;
701pub const CKM_GOST28147_KEY_GEN: CK_MECHANISM_TYPE = 4640;
702pub const CKM_GOST28147_ECB: CK_MECHANISM_TYPE = 4641;
703pub const CKM_GOST28147: CK_MECHANISM_TYPE = 4642;
704pub const CKM_GOST28147_MAC: CK_MECHANISM_TYPE = 4643;
705pub const CKM_GOST28147_KEY_WRAP: CK_MECHANISM_TYPE = 4644;
706pub const CKM_CHACHA20_KEY_GEN: CK_MECHANISM_TYPE = 4645;
707pub const CKM_CHACHA20: CK_MECHANISM_TYPE = 4646;
708pub const CKM_POLY1305_KEY_GEN: CK_MECHANISM_TYPE = 4647;
709pub const CKM_POLY1305: CK_MECHANISM_TYPE = 4648;
710pub const CKM_DSA_PARAMETER_GEN: CK_MECHANISM_TYPE = 8192;
711pub const CKM_DH_PKCS_PARAMETER_GEN: CK_MECHANISM_TYPE = 8193;
712pub const CKM_X9_42_DH_PARAMETER_GEN: CK_MECHANISM_TYPE = 8194;
713pub const CKM_DSA_PROBABILISTIC_PARAMETER_GEN: CK_MECHANISM_TYPE = 8195;
714pub const CKM_DSA_PROBABLISTIC_PARAMETER_GEN: CK_MECHANISM_TYPE = 8195;
715pub const CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN: CK_MECHANISM_TYPE = 8196;
716pub const CKM_DSA_FIPS_G_GEN: CK_MECHANISM_TYPE = 8197;
717pub const CKM_AES_OFB: CK_MECHANISM_TYPE = 8452;
718pub const CKM_AES_CFB64: CK_MECHANISM_TYPE = 8453;
719pub const CKM_AES_CFB8: CK_MECHANISM_TYPE = 8454;
720pub const CKM_AES_CFB128: CK_MECHANISM_TYPE = 8455;
721pub const CKM_AES_CFB1: CK_MECHANISM_TYPE = 8456;
722pub const CKM_AES_KEY_WRAP: CK_MECHANISM_TYPE = 8457;
723pub const CKM_AES_KEY_WRAP_PAD: CK_MECHANISM_TYPE = 8458;
724pub const CKM_AES_KEY_WRAP_KWP: CK_MECHANISM_TYPE = 8459;
725pub const CKM_AES_KEY_WRAP_PKCS7: CK_MECHANISM_TYPE = 8460;
726pub const CKM_RSA_PKCS_TPM_1_1: CK_MECHANISM_TYPE = 16385;
727pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386;
728pub const CKM_SHA_1_KEY_GEN: CK_MECHANISM_TYPE = 16387;
729pub const CKM_SHA224_KEY_GEN: CK_MECHANISM_TYPE = 16388;
730pub const CKM_SHA256_KEY_GEN: CK_MECHANISM_TYPE = 16389;
731pub const CKM_SHA384_KEY_GEN: CK_MECHANISM_TYPE = 16390;
732pub const CKM_SHA512_KEY_GEN: CK_MECHANISM_TYPE = 16391;
733pub const CKM_SHA512_224_KEY_GEN: CK_MECHANISM_TYPE = 16392;
734pub const CKM_SHA512_256_KEY_GEN: CK_MECHANISM_TYPE = 16393;
735pub const CKM_SHA512_T_KEY_GEN: CK_MECHANISM_TYPE = 16394;
736pub const CKM_NULL: CK_MECHANISM_TYPE = 16395;
737pub const CKM_BLAKE2B_160: CK_MECHANISM_TYPE = 16396;
738pub const CKM_BLAKE2B_160_HMAC: CK_MECHANISM_TYPE = 16397;
739pub const CKM_BLAKE2B_160_HMAC_GENERAL: CK_MECHANISM_TYPE = 16398;
740pub const CKM_BLAKE2B_160_KEY_DERIVE: CK_MECHANISM_TYPE = 16399;
741pub const CKM_BLAKE2B_160_KEY_GEN: CK_MECHANISM_TYPE = 16400;
742pub const CKM_BLAKE2B_256: CK_MECHANISM_TYPE = 16401;
743pub const CKM_BLAKE2B_256_HMAC: CK_MECHANISM_TYPE = 16402;
744pub const CKM_BLAKE2B_256_HMAC_GENERAL: CK_MECHANISM_TYPE = 16403;
745pub const CKM_BLAKE2B_256_KEY_DERIVE: CK_MECHANISM_TYPE = 16404;
746pub const CKM_BLAKE2B_256_KEY_GEN: CK_MECHANISM_TYPE = 16405;
747pub const CKM_BLAKE2B_384: CK_MECHANISM_TYPE = 16406;
748pub const CKM_BLAKE2B_384_HMAC: CK_MECHANISM_TYPE = 16407;
749pub const CKM_BLAKE2B_384_HMAC_GENERAL: CK_MECHANISM_TYPE = 16408;
750pub const CKM_BLAKE2B_384_KEY_DERIVE: CK_MECHANISM_TYPE = 16409;
751pub const CKM_BLAKE2B_384_KEY_GEN: CK_MECHANISM_TYPE = 16410;
752pub const CKM_BLAKE2B_512: CK_MECHANISM_TYPE = 16411;
753pub const CKM_BLAKE2B_512_HMAC: CK_MECHANISM_TYPE = 16412;
754pub const CKM_BLAKE2B_512_HMAC_GENERAL: CK_MECHANISM_TYPE = 16413;
755pub const CKM_BLAKE2B_512_KEY_DERIVE: CK_MECHANISM_TYPE = 16414;
756pub const CKM_BLAKE2B_512_KEY_GEN: CK_MECHANISM_TYPE = 16415;
757pub const CKM_SALSA20: CK_MECHANISM_TYPE = 16416;
758pub const CKM_CHACHA20_POLY1305: CK_MECHANISM_TYPE = 16417;
759pub const CKM_SALSA20_POLY1305: CK_MECHANISM_TYPE = 16418;
760pub const CKM_X3DH_INITIALIZE: CK_MECHANISM_TYPE = 16419;
761pub const CKM_X3DH_RESPOND: CK_MECHANISM_TYPE = 16420;
762pub const CKM_X2RATCHET_INITIALIZE: CK_MECHANISM_TYPE = 16421;
763pub const CKM_X2RATCHET_RESPOND: CK_MECHANISM_TYPE = 16422;
764pub const CKM_X2RATCHET_ENCRYPT: CK_MECHANISM_TYPE = 16423;
765pub const CKM_X2RATCHET_DECRYPT: CK_MECHANISM_TYPE = 16424;
766pub const CKM_XEDDSA: CK_MECHANISM_TYPE = 16425;
767pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426;
768pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427;
769pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428;
770pub const CKM_SALSA20_KEY_GEN: CK_MECHANISM_TYPE = 16429;
771pub const CKM_ECDSA_SHA3_224: CK_MECHANISM_TYPE = 4167;
772pub const CKM_ECDSA_SHA3_256: CK_MECHANISM_TYPE = 4168;
773pub const CKM_ECDSA_SHA3_384: CK_MECHANISM_TYPE = 4169;
774pub const CKM_ECDSA_SHA3_512: CK_MECHANISM_TYPE = 4170;
775pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181;
776pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182;
777pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183;
778pub const CKM_SP800_108_COUNTER_KDF: CK_MECHANISM_TYPE = 940;
779pub const CKM_SP800_108_FEEDBACK_KDF: CK_MECHANISM_TYPE = 941;
780pub const CKM_SP800_108_DOUBLE_PIPELINE_KDF: CK_MECHANISM_TYPE = 942;
781pub const CKM_IKE2_PRF_PLUS_DERIVE: CK_MECHANISM_TYPE = 16430;
782pub const CKM_IKE_PRF_DERIVE: CK_MECHANISM_TYPE = 16431;
783pub const CKM_IKE1_PRF_DERIVE: CK_MECHANISM_TYPE = 16432;
784pub const CKM_IKE1_EXTENDED_DERIVE: CK_MECHANISM_TYPE = 16433;
785pub const CKM_HSS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 16434;
786pub const CKM_HSS: CK_MECHANISM_TYPE = 16435;
787pub const CKM_VENDOR_DEFINED: CK_MECHANISM_TYPE = 2147483648;
788pub const CKM_CAST5_KEY_GEN: CK_MECHANISM_TYPE = 800;
789pub const CKM_CAST5_CBC: CK_MECHANISM_TYPE = 802;
790pub const CKM_CAST5_MAC: CK_MECHANISM_TYPE = 803;
791pub const CKM_CAST5_MAC_GENERAL: CK_MECHANISM_TYPE = 804;
792pub const CKM_CAST5_CBC_PAD: CK_MECHANISM_TYPE = 805;
793pub const CKM_PBE_MD5_CAST5_CBC: CK_MECHANISM_TYPE = 932;
794pub const CKM_PBE_SHA1_CAST5_CBC: CK_MECHANISM_TYPE = 933;
795pub const CKM_ECDSA_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4160;
796pub const CKN_SURRENDER: CK_NOTIFICATION = 0;
797pub const CKN_OTP_CHANGED: CK_NOTIFICATION = 1;
798pub const CKO_DATA: CK_OBJECT_CLASS = 0;
799pub const CKO_CERTIFICATE: CK_OBJECT_CLASS = 1;
800pub const CKO_PUBLIC_KEY: CK_OBJECT_CLASS = 2;
801pub const CKO_PRIVATE_KEY: CK_OBJECT_CLASS = 3;
802pub const CKO_SECRET_KEY: CK_OBJECT_CLASS = 4;
803pub const CKO_HW_FEATURE: CK_OBJECT_CLASS = 5;
804pub const CKO_DOMAIN_PARAMETERS: CK_OBJECT_CLASS = 6;
805pub const CKO_MECHANISM: CK_OBJECT_CLASS = 7;
806pub const CKO_OTP_KEY: CK_OBJECT_CLASS = 8;
807pub const CKO_PROFILE: CK_OBJECT_CLASS = 9;
808pub const CKO_VENDOR_DEFINED: CK_OBJECT_CLASS = 2147483648;
809pub const CKP_INVALID_ID: CK_PROFILE_ID = 0;
810pub const CKP_BASELINE_PROVIDER: CK_PROFILE_ID = 1;
811pub const CKP_EXTENDED_PROVIDER: CK_PROFILE_ID = 2;
812pub const CKP_AUTHENTICATION_TOKEN: CK_PROFILE_ID = 3;
813pub const CKP_PUBLIC_CERTIFICATES_TOKEN: CK_PROFILE_ID = 4;
814pub const CKP_COMPLETE_PROVIDER: CK_PROFILE_ID = 5;
815pub const CKP_HKDF_TLS_TOKEN: CK_PROFILE_ID = 6;
816pub const CKP_VENDOR_DEFINED: CK_PROFILE_ID = 2147483648;
817pub const CKP_PKCS5_PBKD2_HMAC_SHA1: CK_PROFILE_ID = 1;
818pub const CKP_PKCS5_PBKD2_HMAC_GOSTR3411: CK_PROFILE_ID = 2;
819pub const CKP_PKCS5_PBKD2_HMAC_SHA224: CK_PROFILE_ID = 3;
820pub const CKP_PKCS5_PBKD2_HMAC_SHA256: CK_PROFILE_ID = 4;
821pub const CKP_PKCS5_PBKD2_HMAC_SHA384: CK_PROFILE_ID = 5;
822pub const CKP_PKCS5_PBKD2_HMAC_SHA512: CK_PROFILE_ID = 6;
823pub const CKP_PKCS5_PBKD2_HMAC_SHA512_224: CK_PROFILE_ID = 7;
824pub const CKP_PKCS5_PBKD2_HMAC_SHA512_256: CK_PROFILE_ID = 8;
825pub const CKR_OK: CK_RV = 0;
826pub const CKR_CANCEL: CK_RV = 1;
827pub const CKR_HOST_MEMORY: CK_RV = 2;
828pub const CKR_SLOT_ID_INVALID: CK_RV = 3;
829pub const CKR_GENERAL_ERROR: CK_RV = 5;
830pub const CKR_FUNCTION_FAILED: CK_RV = 6;
831pub const CKR_ARGUMENTS_BAD: CK_RV = 7;
832pub const CKR_NO_EVENT: CK_RV = 8;
833pub const CKR_NEED_TO_CREATE_THREADS: CK_RV = 9;
834pub const CKR_CANT_LOCK: CK_RV = 10;
835pub const CKR_ATTRIBUTE_READ_ONLY: CK_RV = 16;
836pub const CKR_ATTRIBUTE_SENSITIVE: CK_RV = 17;
837pub const CKR_ATTRIBUTE_TYPE_INVALID: CK_RV = 18;
838pub const CKR_ATTRIBUTE_VALUE_INVALID: CK_RV = 19;
839pub const CKR_ACTION_PROHIBITED: CK_RV = 27;
840pub const CKR_DATA_INVALID: CK_RV = 32;
841pub const CKR_DATA_LEN_RANGE: CK_RV = 33;
842pub const CKR_DEVICE_ERROR: CK_RV = 48;
843pub const CKR_DEVICE_MEMORY: CK_RV = 49;
844pub const CKR_DEVICE_REMOVED: CK_RV = 50;
845pub const CKR_ENCRYPTED_DATA_INVALID: CK_RV = 64;
846pub const CKR_ENCRYPTED_DATA_LEN_RANGE: CK_RV = 65;
847pub const CKR_AEAD_DECRYPT_FAILED: CK_RV = 66;
848pub const CKR_FUNCTION_CANCELED: CK_RV = 80;
849pub const CKR_FUNCTION_NOT_PARALLEL: CK_RV = 81;
850pub const CKR_FUNCTION_NOT_SUPPORTED: CK_RV = 84;
851pub const CKR_KEY_HANDLE_INVALID: CK_RV = 96;
852pub const CKR_KEY_SIZE_RANGE: CK_RV = 98;
853pub const CKR_KEY_TYPE_INCONSISTENT: CK_RV = 99;
854pub const CKR_KEY_NOT_NEEDED: CK_RV = 100;
855pub const CKR_KEY_CHANGED: CK_RV = 101;
856pub const CKR_KEY_NEEDED: CK_RV = 102;
857pub const CKR_KEY_INDIGESTIBLE: CK_RV = 103;
858pub const CKR_KEY_FUNCTION_NOT_PERMITTED: CK_RV = 104;
859pub const CKR_KEY_NOT_WRAPPABLE: CK_RV = 105;
860pub const CKR_KEY_UNEXTRACTABLE: CK_RV = 106;
861pub const CKR_MECHANISM_INVALID: CK_RV = 112;
862pub const CKR_MECHANISM_PARAM_INVALID: CK_RV = 113;
863pub const CKR_OBJECT_HANDLE_INVALID: CK_RV = 130;
864pub const CKR_OPERATION_ACTIVE: CK_RV = 144;
865pub const CKR_OPERATION_NOT_INITIALIZED: CK_RV = 145;
866pub const CKR_PIN_INCORRECT: CK_RV = 160;
867pub const CKR_PIN_INVALID: CK_RV = 161;
868pub const CKR_PIN_LEN_RANGE: CK_RV = 162;
869pub const CKR_PIN_EXPIRED: CK_RV = 163;
870pub const CKR_PIN_LOCKED: CK_RV = 164;
871pub const CKR_SESSION_CLOSED: CK_RV = 176;
872pub const CKR_SESSION_COUNT: CK_RV = 177;
873pub const CKR_SESSION_HANDLE_INVALID: CK_RV = 179;
874pub const CKR_SESSION_PARALLEL_NOT_SUPPORTED: CK_RV = 180;
875pub const CKR_SESSION_READ_ONLY: CK_RV = 181;
876pub const CKR_SESSION_EXISTS: CK_RV = 182;
877pub const CKR_SESSION_READ_ONLY_EXISTS: CK_RV = 183;
878pub const CKR_SESSION_READ_WRITE_SO_EXISTS: CK_RV = 184;
879pub const CKR_SIGNATURE_INVALID: CK_RV = 192;
880pub const CKR_SIGNATURE_LEN_RANGE: CK_RV = 193;
881pub const CKR_TEMPLATE_INCOMPLETE: CK_RV = 208;
882pub const CKR_TEMPLATE_INCONSISTENT: CK_RV = 209;
883pub const CKR_TOKEN_NOT_PRESENT: CK_RV = 224;
884pub const CKR_TOKEN_NOT_RECOGNIZED: CK_RV = 225;
885pub const CKR_TOKEN_WRITE_PROTECTED: CK_RV = 226;
886pub const CKR_UNWRAPPING_KEY_HANDLE_INVALID: CK_RV = 240;
887pub const CKR_UNWRAPPING_KEY_SIZE_RANGE: CK_RV = 241;
888pub const CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT: CK_RV = 242;
889pub const CKR_USER_ALREADY_LOGGED_IN: CK_RV = 256;
890pub const CKR_USER_NOT_LOGGED_IN: CK_RV = 257;
891pub const CKR_USER_PIN_NOT_INITIALIZED: CK_RV = 258;
892pub const CKR_USER_TYPE_INVALID: CK_RV = 259;
893pub const CKR_USER_ANOTHER_ALREADY_LOGGED_IN: CK_RV = 260;
894pub const CKR_USER_TOO_MANY_TYPES: CK_RV = 261;
895pub const CKR_WRAPPED_KEY_INVALID: CK_RV = 272;
896pub const CKR_WRAPPED_KEY_LEN_RANGE: CK_RV = 274;
897pub const CKR_WRAPPING_KEY_HANDLE_INVALID: CK_RV = 275;
898pub const CKR_WRAPPING_KEY_SIZE_RANGE: CK_RV = 276;
899pub const CKR_WRAPPING_KEY_TYPE_INCONSISTENT: CK_RV = 277;
900pub const CKR_RANDOM_SEED_NOT_SUPPORTED: CK_RV = 288;
901pub const CKR_RANDOM_NO_RNG: CK_RV = 289;
902pub const CKR_DOMAIN_PARAMS_INVALID: CK_RV = 304;
903pub const CKR_CURVE_NOT_SUPPORTED: CK_RV = 320;
904pub const CKR_BUFFER_TOO_SMALL: CK_RV = 336;
905pub const CKR_SAVED_STATE_INVALID: CK_RV = 352;
906pub const CKR_INFORMATION_SENSITIVE: CK_RV = 368;
907pub const CKR_STATE_UNSAVEABLE: CK_RV = 384;
908pub const CKR_CRYPTOKI_NOT_INITIALIZED: CK_RV = 400;
909pub const CKR_CRYPTOKI_ALREADY_INITIALIZED: CK_RV = 401;
910pub const CKR_MUTEX_BAD: CK_RV = 416;
911pub const CKR_MUTEX_NOT_LOCKED: CK_RV = 417;
912pub const CKR_NEW_PIN_MODE: CK_RV = 432;
913pub const CKR_NEXT_OTP: CK_RV = 433;
914pub const CKR_EXCEEDED_MAX_ITERATIONS: CK_RV = 437;
915pub const CKR_FIPS_SELF_TEST_FAILED: CK_RV = 438;
916pub const CKR_LIBRARY_LOAD_FAILED: CK_RV = 439;
917pub const CKR_PIN_TOO_WEAK: CK_RV = 440;
918pub const CKR_PUBLIC_KEY_INVALID: CK_RV = 441;
919pub const CKR_FUNCTION_REJECTED: CK_RV = 512;
920pub const CKR_TOKEN_RESOURCE_EXCEEDED: CK_RV = 513;
921pub const CKR_OPERATION_CANCEL_FAILED: CK_RV = 514;
922pub const CKR_KEY_EXHAUSTED: CK_RV = 515;
923pub const CKR_VENDOR_DEFINED: CK_RV = 2147483648;
924pub const CKS_RO_PUBLIC_SESSION: CK_STATE = 0;
925pub const CKS_RO_USER_FUNCTIONS: CK_STATE = 1;
926pub const CKS_RW_PUBLIC_SESSION: CK_STATE = 2;
927pub const CKS_RW_USER_FUNCTIONS: CK_STATE = 3;
928pub const CKS_RW_SO_FUNCTIONS: CK_STATE = 4;
929pub const CKU_SO: CK_USER_TYPE = 0;
930pub const CKU_USER: CK_USER_TYPE = 1;
931pub const CKU_CONTEXT_SPECIFIC: CK_USER_TYPE = 2;
932pub const CKZ_DATA_SPECIFIED: CK_RSA_PKCS_OAEP_SOURCE_TYPE = 1;
933pub const CKZ_SALT_SPECIFIED: CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE = 1;
934pub type CK_BBOOL = ::std::os::raw::c_uchar;
935pub type CK_BYTE = ::std::os::raw::c_uchar;
936pub type CK_CHAR = ::std::os::raw::c_uchar;
937pub type CK_UTF8CHAR = ::std::os::raw::c_uchar;
938pub type CK_ULONG = ::std::os::raw::c_ulong;
939pub type CK_BBOOL_PTR = *mut CK_BBOOL;
940pub type CK_BYTE_PTR = *mut CK_BYTE;
941pub type CK_CHAR_PTR = *mut CK_CHAR;
942pub type CK_UTF8CHAR_PTR = *mut CK_UTF8CHAR;
943pub type CK_ULONG_PTR = *mut CK_ULONG;
944pub type CK_VOID_PTR = *mut ::std::os::raw::c_void;
945pub type CK_VOID_PTR_PTR = *mut *mut ::std::os::raw::c_void;
946pub type CK_ATTRIBUTE_TYPE = CK_ULONG;
947pub type CK_ATTRIBUTE_TYPE_PTR = *mut CK_ATTRIBUTE_TYPE;
948pub type CK_CERTIFICATE_CATEGORY = CK_ULONG;
949pub type CK_CERTIFICATE_CATEGORY_PTR = *mut CK_CERTIFICATE_CATEGORY;
950pub type CK_CERTIFICATE_TYPE = CK_ULONG;
951pub type CK_CERTIFICATE_TYPE_PTR = *mut CK_CERTIFICATE_TYPE;
952pub type CK_EC_KDF_TYPE = CK_ULONG;
953pub type CK_EC_KDF_TYPE_PTR = *mut CK_EC_KDF_TYPE;
954pub type CK_EXTRACT_PARAMS = CK_ULONG;
955pub type CK_EXTRACT_PARAMS_PTR = *mut CK_EXTRACT_PARAMS;
956pub type CK_FLAGS = CK_ULONG;
957pub type CK_FLAGS_PTR = *mut CK_FLAGS;
958pub type CK_GENERATOR_FUNCTION = CK_ULONG;
959pub type CK_GENERATOR_FUNCTION_PTR = *mut CK_GENERATOR_FUNCTION;
960pub type CK_HSS_LEVELS = CK_ULONG;
961pub type CK_HSS_LEVELS_PTR = *mut CK_HSS_LEVELS;
962pub type CK_HW_FEATURE_TYPE = CK_ULONG;
963pub type CK_HW_FEATURE_TYPE_PTR = *mut CK_HW_FEATURE_TYPE;
964pub type CK_JAVA_MIDP_SECURITY_DOMAIN = CK_ULONG;
965pub type CK_JAVA_MIDP_SECURITY_DOMAIN_PTR = *mut CK_JAVA_MIDP_SECURITY_DOMAIN;
966pub type CK_KEY_TYPE = CK_ULONG;
967pub type CK_KEY_TYPE_PTR = *mut CK_KEY_TYPE;
968pub type CK_LMS_TYPE = CK_ULONG;
969pub type CK_LMS_TYPE_PTR = *mut CK_LMS_TYPE;
970pub type CK_LMOTS_TYPE = CK_ULONG;
971pub type CK_LMOTS_TYPE_PTR = *mut CK_LMOTS_TYPE;
972pub type CK_MAC_GENERAL_PARAMS = CK_ULONG;
973pub type CK_MAC_GENERAL_PARAMS_PTR = *mut CK_MAC_GENERAL_PARAMS;
974pub type CK_MECHANISM_TYPE = CK_ULONG;
975pub type CK_MECHANISM_TYPE_PTR = *mut CK_MECHANISM_TYPE;
976pub type CK_NOTIFICATION = CK_ULONG;
977pub type CK_NOTIFICATION_PTR = *mut CK_NOTIFICATION;
978pub type CK_OBJECT_CLASS = CK_ULONG;
979pub type CK_OBJECT_CLASS_PTR = *mut CK_OBJECT_CLASS;
980pub type CK_OBJECT_HANDLE = CK_ULONG;
981pub type CK_OBJECT_HANDLE_PTR = *mut CK_OBJECT_HANDLE;
982pub type CK_OTP_PARAM_TYPE = CK_ULONG;
983pub type CK_OTP_PARAM_TYPE_PTR = *mut CK_OTP_PARAM_TYPE;
984pub type CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = CK_ULONG;
985pub type CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE_PTR =
986 *mut CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE;
987pub type CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE = CK_ULONG;
988pub type CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE_PTR = *mut CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE;
989pub type CK_PRF_DATA_TYPE = CK_ULONG;
990pub type CK_PRF_DATA_TYPE_PTR = *mut CK_PRF_DATA_TYPE;
991pub type CK_PROFILE_ID = CK_ULONG;
992pub type CK_PROFILE_ID_PTR = *mut CK_PROFILE_ID;
993pub type CK_RC2_PARAMS = CK_ULONG;
994pub type CK_RC2_PARAMS_PTR = *mut CK_RC2_PARAMS;
995pub type CK_RSA_PKCS_MGF_TYPE = CK_ULONG;
996pub type CK_RSA_PKCS_MGF_TYPE_PTR = *mut CK_RSA_PKCS_MGF_TYPE;
997pub type CK_RSA_PKCS_OAEP_SOURCE_TYPE = CK_ULONG;
998pub type CK_RSA_PKCS_OAEP_SOURCE_TYPE_PTR = *mut CK_RSA_PKCS_OAEP_SOURCE_TYPE;
999pub type CK_RV = CK_ULONG;
1000pub type CK_RV_PTR = *mut CK_RV;
1001pub type CK_SESSION_HANDLE = CK_ULONG;
1002pub type CK_SESSION_HANDLE_PTR = *mut CK_SESSION_HANDLE;
1003pub type CK_SLOT_ID = CK_ULONG;
1004pub type CK_SLOT_ID_PTR = *mut CK_SLOT_ID;
1005pub type CK_SP800_108_DKM_LENGTH_METHOD = CK_ULONG;
1006pub type CK_SP800_108_DKM_LENGTH_METHOD_PTR = *mut CK_SP800_108_DKM_LENGTH_METHOD;
1007pub type CK_STATE = CK_ULONG;
1008pub type CK_STATE_PTR = *mut CK_STATE;
1009pub type CK_USER_TYPE = CK_ULONG;
1010pub type CK_USER_TYPE_PTR = *mut CK_USER_TYPE;
1011pub type CK_X2RATCHET_KDF_TYPE = CK_ULONG;
1012pub type CK_X2RATCHET_KDF_TYPE_PTR = *mut CK_X2RATCHET_KDF_TYPE;
1013pub type CK_X3DH_KDF_TYPE = CK_ULONG;
1014pub type CK_X3DH_KDF_TYPE_PTR = *mut CK_X3DH_KDF_TYPE;
1015pub type CK_X9_42_DH_KDF_TYPE = CK_ULONG;
1016pub type CK_X9_42_DH_KDF_TYPE_PTR = *mut CK_X9_42_DH_KDF_TYPE;
1017pub type CK_XEDDSA_HASH_TYPE = CK_ULONG;
1018pub type CK_XEDDSA_HASH_TYPE_PTR = *mut CK_XEDDSA_HASH_TYPE;
1019pub type CK_ATTRIBUTE_PTR = *mut CK_ATTRIBUTE;
1020pub type CK_ATTRIBUTE_PTR_PTR = *mut *mut CK_ATTRIBUTE;
1021pub type CK_C_INITIALIZE_ARGS_PTR = *mut CK_C_INITIALIZE_ARGS;
1022pub type CK_C_INITIALIZE_ARGS_PTR_PTR = *mut *mut CK_C_INITIALIZE_ARGS;
1023pub type CK_DATE_PTR = *mut CK_DATE;
1024pub type CK_DATE_PTR_PTR = *mut *mut CK_DATE;
1025pub type CK_DERIVED_KEY_PTR = *mut CK_DERIVED_KEY;
1026pub type CK_DERIVED_KEY_PTR_PTR = *mut *mut CK_DERIVED_KEY;
1027pub type CK_FUNCTION_LIST_PTR = *mut CK_FUNCTION_LIST;
1028pub type CK_FUNCTION_LIST_PTR_PTR = *mut *mut CK_FUNCTION_LIST;
1029pub type CK_FUNCTION_LIST_3_0_PTR = *mut CK_FUNCTION_LIST_3_0;
1030pub type CK_FUNCTION_LIST_3_0_PTR_PTR = *mut *mut CK_FUNCTION_LIST_3_0;
1031pub type CK_INFO_PTR = *mut CK_INFO;
1032pub type CK_INFO_PTR_PTR = *mut *mut CK_INFO;
1033pub type CK_INTERFACE_PTR = *mut CK_INTERFACE;
1034pub type CK_INTERFACE_PTR_PTR = *mut *mut CK_INTERFACE;
1035pub type CK_MECHANISM_PTR = *mut CK_MECHANISM;
1036pub type CK_MECHANISM_PTR_PTR = *mut *mut CK_MECHANISM;
1037pub type CK_MECHANISM_INFO_PTR = *mut CK_MECHANISM_INFO;
1038pub type CK_MECHANISM_INFO_PTR_PTR = *mut *mut CK_MECHANISM_INFO;
1039pub type CK_SESSION_INFO_PTR = *mut CK_SESSION_INFO;
1040pub type CK_SESSION_INFO_PTR_PTR = *mut *mut CK_SESSION_INFO;
1041pub type CK_SLOT_INFO_PTR = *mut CK_SLOT_INFO;
1042pub type CK_SLOT_INFO_PTR_PTR = *mut *mut CK_SLOT_INFO;
1043pub type CK_TOKEN_INFO_PTR = *mut CK_TOKEN_INFO;
1044pub type CK_TOKEN_INFO_PTR_PTR = *mut *mut CK_TOKEN_INFO;
1045pub type CK_VERSION_PTR = *mut CK_VERSION;
1046pub type CK_VERSION_PTR_PTR = *mut *mut CK_VERSION;
1047pub type CK_NOTIFY = ::std::option::Option<
1048 unsafe extern "C" fn(
1049 arg1: CK_SESSION_HANDLE,
1050 arg2: CK_NOTIFICATION,
1051 arg3: *mut ::std::os::raw::c_void,
1052 ) -> CK_RV,
1053>;
1054pub type CK_CREATEMUTEX =
1055 ::std::option::Option<unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void) -> CK_RV>;
1056pub type CK_DESTROYMUTEX =
1057 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> CK_RV>;
1058pub type CK_LOCKMUTEX =
1059 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> CK_RV>;
1060pub type CK_UNLOCKMUTEX =
1061 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> CK_RV>;
1062#[repr(C)]
1063#[cfg_attr(windows, repr(packed))]
1064#[derive(Debug, Copy, Clone)]
1065pub struct CK_ATTRIBUTE {
1066 pub type_: CK_ATTRIBUTE_TYPE,
1067 pub pValue: *mut ::std::os::raw::c_void,
1068 pub ulValueLen: CK_ULONG,
1069}
1070impl Default for CK_ATTRIBUTE {
1071 fn default() -> Self {
1072 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1073 unsafe {
1074 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1075 s.assume_init()
1076 }
1077 }
1078}
1079#[repr(C)]
1080#[cfg_attr(windows, repr(packed))]
1081#[derive(Debug, Copy, Clone)]
1082pub struct CK_C_INITIALIZE_ARGS {
1083 pub CreateMutex: CK_CREATEMUTEX,
1084 pub DestroyMutex: CK_DESTROYMUTEX,
1085 pub LockMutex: CK_LOCKMUTEX,
1086 pub UnlockMutex: CK_UNLOCKMUTEX,
1087 pub flags: CK_FLAGS,
1088 pub pReserved: *mut ::std::os::raw::c_void,
1089}
1090impl Default for CK_C_INITIALIZE_ARGS {
1091 fn default() -> Self {
1092 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1093 unsafe {
1094 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1095 s.assume_init()
1096 }
1097 }
1098}
1099#[repr(C)]
1100#[derive(Debug, Default, Copy, Clone)]
1101pub struct CK_DATE {
1102 pub year: [CK_CHAR; 4usize],
1103 pub month: [CK_CHAR; 2usize],
1104 pub day: [CK_CHAR; 2usize],
1105}
1106#[repr(C)]
1107#[cfg_attr(windows, repr(packed))]
1108#[derive(Debug, Copy, Clone)]
1109pub struct CK_DERIVED_KEY {
1110 pub pTemplate: *mut CK_ATTRIBUTE,
1111 pub ulAttributeCount: CK_ULONG,
1112 pub phKey: *mut CK_OBJECT_HANDLE,
1113}
1114impl Default for CK_DERIVED_KEY {
1115 fn default() -> Self {
1116 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1117 unsafe {
1118 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1119 s.assume_init()
1120 }
1121 }
1122}
1123#[repr(C)]
1124#[derive(Debug, Default, Copy, Clone)]
1125pub struct CK_VERSION {
1126 pub major: CK_BYTE,
1127 pub minor: CK_BYTE,
1128}
1129#[repr(C)]
1130#[cfg_attr(windows, repr(packed))]
1131#[derive(Debug, Default, Copy, Clone)]
1132pub struct CK_INFO {
1133 pub cryptokiVersion: CK_VERSION,
1134 pub manufacturerID: [CK_UTF8CHAR; 32usize],
1135 pub flags: CK_FLAGS,
1136 pub libraryDescription: [CK_UTF8CHAR; 32usize],
1137 pub libraryVersion: CK_VERSION,
1138}
1139#[repr(C)]
1140#[cfg_attr(windows, repr(packed))]
1141#[derive(Debug, Copy, Clone)]
1142pub struct CK_INTERFACE {
1143 pub pInterfaceName: *mut CK_CHAR,
1144 pub pFunctionList: *mut ::std::os::raw::c_void,
1145 pub flags: CK_FLAGS,
1146}
1147impl Default for CK_INTERFACE {
1148 fn default() -> Self {
1149 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1150 unsafe {
1151 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1152 s.assume_init()
1153 }
1154 }
1155}
1156#[repr(C)]
1157#[cfg_attr(windows, repr(packed))]
1158#[derive(Debug, Copy, Clone)]
1159pub struct CK_MECHANISM {
1160 pub mechanism: CK_MECHANISM_TYPE,
1161 pub pParameter: *mut ::std::os::raw::c_void,
1162 pub ulParameterLen: CK_ULONG,
1163}
1164impl Default for CK_MECHANISM {
1165 fn default() -> Self {
1166 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1167 unsafe {
1168 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1169 s.assume_init()
1170 }
1171 }
1172}
1173#[repr(C)]
1174#[cfg_attr(windows, repr(packed))]
1175#[derive(Debug, Default, Copy, Clone)]
1176pub struct CK_MECHANISM_INFO {
1177 pub ulMinKeySize: CK_ULONG,
1178 pub ulMaxKeySize: CK_ULONG,
1179 pub flags: CK_FLAGS,
1180}
1181#[repr(C)]
1182#[cfg_attr(windows, repr(packed))]
1183#[derive(Debug, Default, Copy, Clone)]
1184pub struct CK_SESSION_INFO {
1185 pub slotID: CK_SLOT_ID,
1186 pub state: CK_STATE,
1187 pub flags: CK_FLAGS,
1188 pub ulDeviceError: CK_ULONG,
1189}
1190#[repr(C)]
1191#[cfg_attr(windows, repr(packed))]
1192#[derive(Debug, Copy, Clone)]
1193pub struct CK_SLOT_INFO {
1194 pub slotDescription: [CK_UTF8CHAR; 64usize],
1195 pub manufacturerID: [CK_UTF8CHAR; 32usize],
1196 pub flags: CK_FLAGS,
1197 pub hardwareVersion: CK_VERSION,
1198 pub firmwareVersion: CK_VERSION,
1199}
1200impl Default for CK_SLOT_INFO {
1201 fn default() -> Self {
1202 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1203 unsafe {
1204 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1205 s.assume_init()
1206 }
1207 }
1208}
1209#[repr(C)]
1210#[cfg_attr(windows, repr(packed))]
1211#[derive(Debug, Default, Copy, Clone)]
1212pub struct CK_TOKEN_INFO {
1213 pub label: [CK_UTF8CHAR; 32usize],
1214 pub manufacturerID: [CK_UTF8CHAR; 32usize],
1215 pub model: [CK_UTF8CHAR; 16usize],
1216 pub serialNumber: [CK_CHAR; 16usize],
1217 pub flags: CK_FLAGS,
1218 pub ulMaxSessionCount: CK_ULONG,
1219 pub ulSessionCount: CK_ULONG,
1220 pub ulMaxRwSessionCount: CK_ULONG,
1221 pub ulRwSessionCount: CK_ULONG,
1222 pub ulMaxPinLen: CK_ULONG,
1223 pub ulMinPinLen: CK_ULONG,
1224 pub ulTotalPublicMemory: CK_ULONG,
1225 pub ulFreePublicMemory: CK_ULONG,
1226 pub ulTotalPrivateMemory: CK_ULONG,
1227 pub ulFreePrivateMemory: CK_ULONG,
1228 pub hardwareVersion: CK_VERSION,
1229 pub firmwareVersion: CK_VERSION,
1230 pub utcTime: [CK_CHAR; 16usize],
1231}
1232pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_AES_CBC_ENCRYPT_DATA_PARAMS;
1233pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR_PTR = *mut *mut CK_AES_CBC_ENCRYPT_DATA_PARAMS;
1234pub type CK_AES_CCM_PARAMS_PTR = *mut CK_AES_CCM_PARAMS;
1235pub type CK_AES_CCM_PARAMS_PTR_PTR = *mut *mut CK_AES_CCM_PARAMS;
1236pub type CK_AES_CTR_PARAMS_PTR = *mut CK_AES_CTR_PARAMS;
1237pub type CK_AES_CTR_PARAMS_PTR_PTR = *mut *mut CK_AES_CTR_PARAMS;
1238pub type CK_AES_GCM_PARAMS_PTR = *mut CK_AES_GCM_PARAMS;
1239pub type CK_AES_GCM_PARAMS_PTR_PTR = *mut *mut CK_AES_GCM_PARAMS;
1240pub type CK_ARIA_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_ARIA_CBC_ENCRYPT_DATA_PARAMS;
1241pub type CK_ARIA_CBC_ENCRYPT_DATA_PARAMS_PTR_PTR = *mut *mut CK_ARIA_CBC_ENCRYPT_DATA_PARAMS;
1242pub type CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS;
1243pub type CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS_PTR_PTR =
1244 *mut *mut CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS;
1245pub type CK_CAMELLIA_CTR_PARAMS_PTR = *mut CK_CAMELLIA_CTR_PARAMS;
1246pub type CK_CAMELLIA_CTR_PARAMS_PTR_PTR = *mut *mut CK_CAMELLIA_CTR_PARAMS;
1247pub type CK_CCM_MESSAGE_PARAMS_PTR = *mut CK_CCM_MESSAGE_PARAMS;
1248pub type CK_CCM_MESSAGE_PARAMS_PTR_PTR = *mut *mut CK_CCM_MESSAGE_PARAMS;
1249pub type CK_CCM_PARAMS_PTR = *mut CK_CCM_PARAMS;
1250pub type CK_CCM_PARAMS_PTR_PTR = *mut *mut CK_CCM_PARAMS;
1251pub type CK_CHACHA20_PARAMS_PTR = *mut CK_CHACHA20_PARAMS;
1252pub type CK_CHACHA20_PARAMS_PTR_PTR = *mut *mut CK_CHACHA20_PARAMS;
1253pub type CK_CMS_SIG_PARAMS_PTR = *mut CK_CMS_SIG_PARAMS;
1254pub type CK_CMS_SIG_PARAMS_PTR_PTR = *mut *mut CK_CMS_SIG_PARAMS;
1255pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_DES_CBC_ENCRYPT_DATA_PARAMS;
1256pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR_PTR = *mut *mut CK_DES_CBC_ENCRYPT_DATA_PARAMS;
1257pub type CK_DSA_PARAMETER_GEN_PARAM_PTR = *mut CK_DSA_PARAMETER_GEN_PARAM;
1258pub type CK_DSA_PARAMETER_GEN_PARAM_PTR_PTR = *mut *mut CK_DSA_PARAMETER_GEN_PARAM;
1259pub type CK_ECDH_AES_KEY_WRAP_PARAMS_PTR = *mut CK_ECDH_AES_KEY_WRAP_PARAMS;
1260pub type CK_ECDH_AES_KEY_WRAP_PARAMS_PTR_PTR = *mut *mut CK_ECDH_AES_KEY_WRAP_PARAMS;
1261pub type CK_ECDH1_DERIVE_PARAMS_PTR = *mut CK_ECDH1_DERIVE_PARAMS;
1262pub type CK_ECDH1_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_ECDH1_DERIVE_PARAMS;
1263pub type CK_ECDH2_DERIVE_PARAMS_PTR = *mut CK_ECDH2_DERIVE_PARAMS;
1264pub type CK_ECDH2_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_ECDH2_DERIVE_PARAMS;
1265pub type CK_ECMQV_DERIVE_PARAMS_PTR = *mut CK_ECMQV_DERIVE_PARAMS;
1266pub type CK_ECMQV_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_ECMQV_DERIVE_PARAMS;
1267pub type CK_EDDSA_PARAMS_PTR = *mut CK_EDDSA_PARAMS;
1268pub type CK_EDDSA_PARAMS_PTR_PTR = *mut *mut CK_EDDSA_PARAMS;
1269pub type CK_GCM_MESSAGE_PARAMS_PTR = *mut CK_GCM_MESSAGE_PARAMS;
1270pub type CK_GCM_MESSAGE_PARAMS_PTR_PTR = *mut *mut CK_GCM_MESSAGE_PARAMS;
1271pub type CK_GCM_PARAMS_PTR = *mut CK_GCM_PARAMS;
1272pub type CK_GCM_PARAMS_PTR_PTR = *mut *mut CK_GCM_PARAMS;
1273pub type CK_GOSTR3410_DERIVE_PARAMS_PTR = *mut CK_GOSTR3410_DERIVE_PARAMS;
1274pub type CK_GOSTR3410_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_GOSTR3410_DERIVE_PARAMS;
1275pub type CK_GOSTR3410_KEY_WRAP_PARAMS_PTR = *mut CK_GOSTR3410_KEY_WRAP_PARAMS;
1276pub type CK_GOSTR3410_KEY_WRAP_PARAMS_PTR_PTR = *mut *mut CK_GOSTR3410_KEY_WRAP_PARAMS;
1277pub type CK_HKDF_PARAMS_PTR = *mut CK_HKDF_PARAMS;
1278pub type CK_HKDF_PARAMS_PTR_PTR = *mut *mut CK_HKDF_PARAMS;
1279pub type CK_IKE_PRF_DERIVE_PARAMS_PTR = *mut CK_IKE_PRF_DERIVE_PARAMS;
1280pub type CK_IKE_PRF_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_IKE_PRF_DERIVE_PARAMS;
1281pub type CK_IKE1_EXTENDED_DERIVE_PARAMS_PTR = *mut CK_IKE1_EXTENDED_DERIVE_PARAMS;
1282pub type CK_IKE1_EXTENDED_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_IKE1_EXTENDED_DERIVE_PARAMS;
1283pub type CK_IKE1_PRF_DERIVE_PARAMS_PTR = *mut CK_IKE1_PRF_DERIVE_PARAMS;
1284pub type CK_IKE1_PRF_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_IKE1_PRF_DERIVE_PARAMS;
1285pub type CK_IKE2_PRF_PLUS_DERIVE_PARAMS_PTR = *mut CK_IKE2_PRF_PLUS_DERIVE_PARAMS;
1286pub type CK_IKE2_PRF_PLUS_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_IKE2_PRF_PLUS_DERIVE_PARAMS;
1287pub type CK_KEA_DERIVE_PARAMS_PTR = *mut CK_KEA_DERIVE_PARAMS;
1288pub type CK_KEA_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_KEA_DERIVE_PARAMS;
1289pub type CK_KEY_DERIVATION_STRING_DATA_PTR = *mut CK_KEY_DERIVATION_STRING_DATA;
1290pub type CK_KEY_DERIVATION_STRING_DATA_PTR_PTR = *mut *mut CK_KEY_DERIVATION_STRING_DATA;
1291pub type CK_KEY_WRAP_SET_OAEP_PARAMS_PTR = *mut CK_KEY_WRAP_SET_OAEP_PARAMS;
1292pub type CK_KEY_WRAP_SET_OAEP_PARAMS_PTR_PTR = *mut *mut CK_KEY_WRAP_SET_OAEP_PARAMS;
1293pub type CK_KIP_PARAMS_PTR = *mut CK_KIP_PARAMS;
1294pub type CK_KIP_PARAMS_PTR_PTR = *mut *mut CK_KIP_PARAMS;
1295pub type CK_OTP_PARAM_PTR = *mut CK_OTP_PARAM;
1296pub type CK_OTP_PARAM_PTR_PTR = *mut *mut CK_OTP_PARAM;
1297pub type CK_OTP_PARAMS_PTR = *mut CK_OTP_PARAMS;
1298pub type CK_OTP_PARAMS_PTR_PTR = *mut *mut CK_OTP_PARAMS;
1299pub type CK_OTP_SIGNATURE_INFO_PTR = *mut CK_OTP_SIGNATURE_INFO;
1300pub type CK_OTP_SIGNATURE_INFO_PTR_PTR = *mut *mut CK_OTP_SIGNATURE_INFO;
1301pub type CK_PBE_PARAMS_PTR = *mut CK_PBE_PARAMS;
1302pub type CK_PBE_PARAMS_PTR_PTR = *mut *mut CK_PBE_PARAMS;
1303pub type CK_PKCS5_PBKD2_PARAMS_PTR = *mut CK_PKCS5_PBKD2_PARAMS;
1304pub type CK_PKCS5_PBKD2_PARAMS_PTR_PTR = *mut *mut CK_PKCS5_PBKD2_PARAMS;
1305pub type CK_PKCS5_PBKD2_PARAMS2_PTR = *mut CK_PKCS5_PBKD2_PARAMS2;
1306pub type CK_PKCS5_PBKD2_PARAMS2_PTR_PTR = *mut *mut CK_PKCS5_PBKD2_PARAMS2;
1307pub type CK_PRF_DATA_PARAM_PTR = *mut CK_PRF_DATA_PARAM;
1308pub type CK_PRF_DATA_PARAM_PTR_PTR = *mut *mut CK_PRF_DATA_PARAM;
1309pub type CK_RC2_CBC_PARAMS_PTR = *mut CK_RC2_CBC_PARAMS;
1310pub type CK_RC2_CBC_PARAMS_PTR_PTR = *mut *mut CK_RC2_CBC_PARAMS;
1311pub type CK_RC2_MAC_GENERAL_PARAMS_PTR = *mut CK_RC2_MAC_GENERAL_PARAMS;
1312pub type CK_RC2_MAC_GENERAL_PARAMS_PTR_PTR = *mut *mut CK_RC2_MAC_GENERAL_PARAMS;
1313pub type CK_RC5_CBC_PARAMS_PTR = *mut CK_RC5_CBC_PARAMS;
1314pub type CK_RC5_CBC_PARAMS_PTR_PTR = *mut *mut CK_RC5_CBC_PARAMS;
1315pub type CK_RC5_MAC_GENERAL_PARAMS_PTR = *mut CK_RC5_MAC_GENERAL_PARAMS;
1316pub type CK_RC5_MAC_GENERAL_PARAMS_PTR_PTR = *mut *mut CK_RC5_MAC_GENERAL_PARAMS;
1317pub type CK_RC5_PARAMS_PTR = *mut CK_RC5_PARAMS;
1318pub type CK_RC5_PARAMS_PTR_PTR = *mut *mut CK_RC5_PARAMS;
1319pub type CK_RSA_AES_KEY_WRAP_PARAMS_PTR = *mut CK_RSA_AES_KEY_WRAP_PARAMS;
1320pub type CK_RSA_AES_KEY_WRAP_PARAMS_PTR_PTR = *mut *mut CK_RSA_AES_KEY_WRAP_PARAMS;
1321pub type CK_RSA_PKCS_OAEP_PARAMS_PTR = *mut CK_RSA_PKCS_OAEP_PARAMS;
1322pub type CK_RSA_PKCS_OAEP_PARAMS_PTR_PTR = *mut *mut CK_RSA_PKCS_OAEP_PARAMS;
1323pub type CK_RSA_PKCS_PSS_PARAMS_PTR = *mut CK_RSA_PKCS_PSS_PARAMS;
1324pub type CK_RSA_PKCS_PSS_PARAMS_PTR_PTR = *mut *mut CK_RSA_PKCS_PSS_PARAMS;
1325pub type CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS_PTR = *mut CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS;
1326pub type CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS_PTR_PTR =
1327 *mut *mut CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS;
1328pub type CK_SALSA20_CHACHA20_POLY1305_PARAMS_PTR = *mut CK_SALSA20_CHACHA20_POLY1305_PARAMS;
1329pub type CK_SALSA20_CHACHA20_POLY1305_PARAMS_PTR_PTR =
1330 *mut *mut CK_SALSA20_CHACHA20_POLY1305_PARAMS;
1331pub type CK_SALSA20_PARAMS_PTR = *mut CK_SALSA20_PARAMS;
1332pub type CK_SALSA20_PARAMS_PTR_PTR = *mut *mut CK_SALSA20_PARAMS;
1333pub type CK_SEED_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_SEED_CBC_ENCRYPT_DATA_PARAMS;
1334pub type CK_SEED_CBC_ENCRYPT_DATA_PARAMS_PTR_PTR = *mut *mut CK_SEED_CBC_ENCRYPT_DATA_PARAMS;
1335pub type CK_SKIPJACK_PRIVATE_WRAP_PARAMS_PTR = *mut CK_SKIPJACK_PRIVATE_WRAP_PARAMS;
1336pub type CK_SKIPJACK_PRIVATE_WRAP_PARAMS_PTR_PTR = *mut *mut CK_SKIPJACK_PRIVATE_WRAP_PARAMS;
1337pub type CK_SKIPJACK_RELAYX_PARAMS_PTR = *mut CK_SKIPJACK_RELAYX_PARAMS;
1338pub type CK_SKIPJACK_RELAYX_PARAMS_PTR_PTR = *mut *mut CK_SKIPJACK_RELAYX_PARAMS;
1339pub type CK_SP800_108_COUNTER_FORMAT_PTR = *mut CK_SP800_108_COUNTER_FORMAT;
1340pub type CK_SP800_108_COUNTER_FORMAT_PTR_PTR = *mut *mut CK_SP800_108_COUNTER_FORMAT;
1341pub type CK_SP800_108_DKM_LENGTH_FORMAT_PTR = *mut CK_SP800_108_DKM_LENGTH_FORMAT;
1342pub type CK_SP800_108_DKM_LENGTH_FORMAT_PTR_PTR = *mut *mut CK_SP800_108_DKM_LENGTH_FORMAT;
1343pub type CK_SP800_108_FEEDBACK_KDF_PARAMS_PTR = *mut CK_SP800_108_FEEDBACK_KDF_PARAMS;
1344pub type CK_SP800_108_FEEDBACK_KDF_PARAMS_PTR_PTR = *mut *mut CK_SP800_108_FEEDBACK_KDF_PARAMS;
1345pub type CK_SP800_108_KDF_PARAMS_PTR = *mut CK_SP800_108_KDF_PARAMS;
1346pub type CK_SP800_108_KDF_PARAMS_PTR_PTR = *mut *mut CK_SP800_108_KDF_PARAMS;
1347pub type CK_X2RATCHET_INITIALIZE_PARAMS_PTR = *mut CK_X2RATCHET_INITIALIZE_PARAMS;
1348pub type CK_X2RATCHET_INITIALIZE_PARAMS_PTR_PTR = *mut *mut CK_X2RATCHET_INITIALIZE_PARAMS;
1349pub type CK_X2RATCHET_RESPOND_PARAMS_PTR = *mut CK_X2RATCHET_RESPOND_PARAMS;
1350pub type CK_X2RATCHET_RESPOND_PARAMS_PTR_PTR = *mut *mut CK_X2RATCHET_RESPOND_PARAMS;
1351pub type CK_X3DH_INITIATE_PARAMS_PTR = *mut CK_X3DH_INITIATE_PARAMS;
1352pub type CK_X3DH_INITIATE_PARAMS_PTR_PTR = *mut *mut CK_X3DH_INITIATE_PARAMS;
1353pub type CK_X3DH_RESPOND_PARAMS_PTR = *mut CK_X3DH_RESPOND_PARAMS;
1354pub type CK_X3DH_RESPOND_PARAMS_PTR_PTR = *mut *mut CK_X3DH_RESPOND_PARAMS;
1355pub type CK_X9_42_DH1_DERIVE_PARAMS_PTR = *mut CK_X9_42_DH1_DERIVE_PARAMS;
1356pub type CK_X9_42_DH1_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_X9_42_DH1_DERIVE_PARAMS;
1357pub type CK_X9_42_DH2_DERIVE_PARAMS_PTR = *mut CK_X9_42_DH2_DERIVE_PARAMS;
1358pub type CK_X9_42_DH2_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_X9_42_DH2_DERIVE_PARAMS;
1359pub type CK_X9_42_MQV_DERIVE_PARAMS_PTR = *mut CK_X9_42_MQV_DERIVE_PARAMS;
1360pub type CK_X9_42_MQV_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_X9_42_MQV_DERIVE_PARAMS;
1361pub type CK_XEDDSA_PARAMS_PTR = *mut CK_XEDDSA_PARAMS;
1362pub type CK_XEDDSA_PARAMS_PTR_PTR = *mut *mut CK_XEDDSA_PARAMS;
1363pub type specifiedParams_PTR = *mut specifiedParams;
1364pub type specifiedParams_PTR_PTR = *mut *mut specifiedParams;
1365#[repr(C)]
1366#[cfg_attr(windows, repr(packed))]
1367#[derive(Debug, Copy, Clone)]
1368pub struct CK_AES_CBC_ENCRYPT_DATA_PARAMS {
1369 pub iv: [CK_BYTE; 16usize],
1370 pub pData: *mut CK_BYTE,
1371 pub length: CK_ULONG,
1372}
1373impl Default for CK_AES_CBC_ENCRYPT_DATA_PARAMS {
1374 fn default() -> Self {
1375 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1376 unsafe {
1377 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1378 s.assume_init()
1379 }
1380 }
1381}
1382#[repr(C)]
1383#[cfg_attr(windows, repr(packed))]
1384#[derive(Debug, Copy, Clone)]
1385pub struct CK_AES_CCM_PARAMS {
1386 pub ulDataLen: CK_ULONG,
1387 pub pNonce: *mut CK_BYTE,
1388 pub ulNonceLen: CK_ULONG,
1389 pub pAAD: *mut CK_BYTE,
1390 pub ulAADLen: CK_ULONG,
1391 pub ulMACLen: CK_ULONG,
1392}
1393impl Default for CK_AES_CCM_PARAMS {
1394 fn default() -> Self {
1395 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1396 unsafe {
1397 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1398 s.assume_init()
1399 }
1400 }
1401}
1402#[repr(C)]
1403#[cfg_attr(windows, repr(packed))]
1404#[derive(Debug, Default, Copy, Clone)]
1405pub struct CK_AES_CTR_PARAMS {
1406 pub ulCounterBits: CK_ULONG,
1407 pub cb: [CK_BYTE; 16usize],
1408}
1409#[repr(C)]
1410#[cfg_attr(windows, repr(packed))]
1411#[derive(Debug, Copy, Clone)]
1412pub struct CK_AES_GCM_PARAMS {
1413 pub pIv: *mut CK_BYTE,
1414 pub ulIvLen: CK_ULONG,
1415 pub ulIvBits: CK_ULONG,
1416 pub pAAD: *mut CK_BYTE,
1417 pub ulAADLen: CK_ULONG,
1418 pub ulTagBits: CK_ULONG,
1419}
1420impl Default for CK_AES_GCM_PARAMS {
1421 fn default() -> Self {
1422 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1423 unsafe {
1424 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1425 s.assume_init()
1426 }
1427 }
1428}
1429#[repr(C)]
1430#[cfg_attr(windows, repr(packed))]
1431#[derive(Debug, Copy, Clone)]
1432pub struct CK_ARIA_CBC_ENCRYPT_DATA_PARAMS {
1433 pub iv: [CK_BYTE; 16usize],
1434 pub pData: *mut CK_BYTE,
1435 pub length: CK_ULONG,
1436}
1437impl Default for CK_ARIA_CBC_ENCRYPT_DATA_PARAMS {
1438 fn default() -> Self {
1439 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1440 unsafe {
1441 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1442 s.assume_init()
1443 }
1444 }
1445}
1446#[repr(C)]
1447#[cfg_attr(windows, repr(packed))]
1448#[derive(Debug, Copy, Clone)]
1449pub struct CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS {
1450 pub iv: [CK_BYTE; 16usize],
1451 pub pData: *mut CK_BYTE,
1452 pub length: CK_ULONG,
1453}
1454impl Default for CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS {
1455 fn default() -> Self {
1456 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1457 unsafe {
1458 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1459 s.assume_init()
1460 }
1461 }
1462}
1463#[repr(C)]
1464#[cfg_attr(windows, repr(packed))]
1465#[derive(Debug, Default, Copy, Clone)]
1466pub struct CK_CAMELLIA_CTR_PARAMS {
1467 pub ulCounterBits: CK_ULONG,
1468 pub cb: [CK_BYTE; 16usize],
1469}
1470#[repr(C)]
1471#[cfg_attr(windows, repr(packed))]
1472#[derive(Debug, Copy, Clone)]
1473pub struct CK_CCM_MESSAGE_PARAMS {
1474 pub ulDataLen: CK_ULONG,
1475 pub pNonce: *mut CK_BYTE,
1476 pub ulNonceLen: CK_ULONG,
1477 pub ulNonceFixedBits: CK_ULONG,
1478 pub nonceGenerator: CK_GENERATOR_FUNCTION,
1479 pub pMAC: *mut CK_BYTE,
1480 pub ulMACLen: CK_ULONG,
1481}
1482impl Default for CK_CCM_MESSAGE_PARAMS {
1483 fn default() -> Self {
1484 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1485 unsafe {
1486 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1487 s.assume_init()
1488 }
1489 }
1490}
1491#[repr(C)]
1492#[cfg_attr(windows, repr(packed))]
1493#[derive(Debug, Copy, Clone)]
1494pub struct CK_CCM_PARAMS {
1495 pub ulDataLen: CK_ULONG,
1496 pub pNonce: *mut CK_BYTE,
1497 pub ulNonceLen: CK_ULONG,
1498 pub pAAD: *mut CK_BYTE,
1499 pub ulAADLen: CK_ULONG,
1500 pub ulMACLen: CK_ULONG,
1501}
1502impl Default for CK_CCM_PARAMS {
1503 fn default() -> Self {
1504 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1505 unsafe {
1506 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1507 s.assume_init()
1508 }
1509 }
1510}
1511#[repr(C)]
1512#[cfg_attr(windows, repr(packed))]
1513#[derive(Debug, Copy, Clone)]
1514pub struct CK_CHACHA20_PARAMS {
1515 pub pBlockCounter: *mut CK_BYTE,
1516 pub blockCounterBits: CK_ULONG,
1517 pub pNonce: *mut CK_BYTE,
1518 pub ulNonceBits: CK_ULONG,
1519}
1520impl Default for CK_CHACHA20_PARAMS {
1521 fn default() -> Self {
1522 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1523 unsafe {
1524 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1525 s.assume_init()
1526 }
1527 }
1528}
1529#[repr(C)]
1530#[cfg_attr(windows, repr(packed))]
1531#[derive(Debug, Copy, Clone)]
1532pub struct CK_CMS_SIG_PARAMS {
1533 pub certificateHandle: CK_OBJECT_HANDLE,
1534 pub pSigningMechanism: *mut CK_MECHANISM,
1535 pub pDigestMechanism: *mut CK_MECHANISM,
1536 pub pContentType: *mut CK_UTF8CHAR,
1537 pub pRequestedAttributes: *mut CK_BYTE,
1538 pub ulRequestedAttributesLen: CK_ULONG,
1539 pub pRequiredAttributes: *mut CK_BYTE,
1540 pub ulRequiredAttributesLen: CK_ULONG,
1541}
1542impl Default for CK_CMS_SIG_PARAMS {
1543 fn default() -> Self {
1544 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1545 unsafe {
1546 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1547 s.assume_init()
1548 }
1549 }
1550}
1551#[repr(C)]
1552#[cfg_attr(windows, repr(packed))]
1553#[derive(Debug, Copy, Clone)]
1554pub struct CK_DES_CBC_ENCRYPT_DATA_PARAMS {
1555 pub iv: [CK_BYTE; 8usize],
1556 pub pData: *mut CK_BYTE,
1557 pub length: CK_ULONG,
1558}
1559impl Default for CK_DES_CBC_ENCRYPT_DATA_PARAMS {
1560 fn default() -> Self {
1561 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1562 unsafe {
1563 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1564 s.assume_init()
1565 }
1566 }
1567}
1568#[repr(C)]
1569#[cfg_attr(windows, repr(packed))]
1570#[derive(Debug, Copy, Clone)]
1571pub struct CK_DSA_PARAMETER_GEN_PARAM {
1572 pub hash: CK_MECHANISM_TYPE,
1573 pub pSeed: *mut CK_BYTE,
1574 pub ulSeedLen: CK_ULONG,
1575 pub ulIndex: CK_ULONG,
1576}
1577impl Default for CK_DSA_PARAMETER_GEN_PARAM {
1578 fn default() -> Self {
1579 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1580 unsafe {
1581 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1582 s.assume_init()
1583 }
1584 }
1585}
1586#[repr(C)]
1587#[cfg_attr(windows, repr(packed))]
1588#[derive(Debug, Copy, Clone)]
1589pub struct CK_ECDH_AES_KEY_WRAP_PARAMS {
1590 pub ulAESKeyBits: CK_ULONG,
1591 pub kdf: CK_EC_KDF_TYPE,
1592 pub ulSharedDataLen: CK_ULONG,
1593 pub pSharedData: *mut CK_BYTE,
1594}
1595impl Default for CK_ECDH_AES_KEY_WRAP_PARAMS {
1596 fn default() -> Self {
1597 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1598 unsafe {
1599 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1600 s.assume_init()
1601 }
1602 }
1603}
1604#[repr(C)]
1605#[cfg_attr(windows, repr(packed))]
1606#[derive(Debug, Copy, Clone)]
1607pub struct CK_ECDH1_DERIVE_PARAMS {
1608 pub kdf: CK_EC_KDF_TYPE,
1609 pub ulSharedDataLen: CK_ULONG,
1610 pub pSharedData: *mut CK_BYTE,
1611 pub ulPublicDataLen: CK_ULONG,
1612 pub pPublicData: *mut CK_BYTE,
1613}
1614impl Default for CK_ECDH1_DERIVE_PARAMS {
1615 fn default() -> Self {
1616 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1617 unsafe {
1618 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1619 s.assume_init()
1620 }
1621 }
1622}
1623#[repr(C)]
1624#[cfg_attr(windows, repr(packed))]
1625#[derive(Debug, Copy, Clone)]
1626pub struct CK_ECDH2_DERIVE_PARAMS {
1627 pub kdf: CK_EC_KDF_TYPE,
1628 pub ulSharedDataLen: CK_ULONG,
1629 pub pSharedData: *mut CK_BYTE,
1630 pub ulPublicDataLen: CK_ULONG,
1631 pub pPublicData: *mut CK_BYTE,
1632 pub ulPrivateDataLen: CK_ULONG,
1633 pub hPrivateData: CK_OBJECT_HANDLE,
1634 pub ulPublicDataLen2: CK_ULONG,
1635 pub pPublicData2: *mut CK_BYTE,
1636}
1637impl Default for CK_ECDH2_DERIVE_PARAMS {
1638 fn default() -> Self {
1639 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1640 unsafe {
1641 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1642 s.assume_init()
1643 }
1644 }
1645}
1646#[repr(C)]
1647#[cfg_attr(windows, repr(packed))]
1648#[derive(Debug, Copy, Clone)]
1649pub struct CK_ECMQV_DERIVE_PARAMS {
1650 pub kdf: CK_EC_KDF_TYPE,
1651 pub ulSharedDataLen: CK_ULONG,
1652 pub pSharedData: *mut CK_BYTE,
1653 pub ulPublicDataLen: CK_ULONG,
1654 pub pPublicData: *mut CK_BYTE,
1655 pub ulPrivateDataLen: CK_ULONG,
1656 pub hPrivateData: CK_OBJECT_HANDLE,
1657 pub ulPublicDataLen2: CK_ULONG,
1658 pub pPublicData2: *mut CK_BYTE,
1659 pub publicKey: CK_OBJECT_HANDLE,
1660}
1661impl Default for CK_ECMQV_DERIVE_PARAMS {
1662 fn default() -> Self {
1663 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1664 unsafe {
1665 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1666 s.assume_init()
1667 }
1668 }
1669}
1670#[repr(C)]
1671#[cfg_attr(windows, repr(packed))]
1672#[derive(Debug, Copy, Clone)]
1673pub struct CK_EDDSA_PARAMS {
1674 pub phFlag: CK_BBOOL,
1675 pub ulContextDataLen: CK_ULONG,
1676 pub pContextData: *mut CK_BYTE,
1677}
1678impl Default for CK_EDDSA_PARAMS {
1679 fn default() -> Self {
1680 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1681 unsafe {
1682 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1683 s.assume_init()
1684 }
1685 }
1686}
1687#[repr(C)]
1688#[cfg_attr(windows, repr(packed))]
1689#[derive(Debug, Copy, Clone)]
1690pub struct CK_GCM_MESSAGE_PARAMS {
1691 pub pIv: *mut CK_BYTE,
1692 pub ulIvLen: CK_ULONG,
1693 pub ulIvFixedBits: CK_ULONG,
1694 pub ivGenerator: CK_GENERATOR_FUNCTION,
1695 pub pTag: *mut CK_BYTE,
1696 pub ulTagBits: CK_ULONG,
1697}
1698impl Default for CK_GCM_MESSAGE_PARAMS {
1699 fn default() -> Self {
1700 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1701 unsafe {
1702 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1703 s.assume_init()
1704 }
1705 }
1706}
1707#[repr(C)]
1708#[cfg_attr(windows, repr(packed))]
1709#[derive(Debug, Copy, Clone)]
1710pub struct CK_GCM_PARAMS {
1711 pub pIv: *mut CK_BYTE,
1712 pub ulIvLen: CK_ULONG,
1713 pub ulIvBits: CK_ULONG,
1714 pub pAAD: *mut CK_BYTE,
1715 pub ulAADLen: CK_ULONG,
1716 pub ulTagBits: CK_ULONG,
1717}
1718impl Default for CK_GCM_PARAMS {
1719 fn default() -> Self {
1720 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1721 unsafe {
1722 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1723 s.assume_init()
1724 }
1725 }
1726}
1727#[repr(C)]
1728#[cfg_attr(windows, repr(packed))]
1729#[derive(Debug, Copy, Clone)]
1730pub struct CK_GOSTR3410_DERIVE_PARAMS {
1731 pub kdf: CK_EC_KDF_TYPE,
1732 pub pPublicData: *mut CK_BYTE,
1733 pub ulPublicDataLen: CK_ULONG,
1734 pub pUKM: *mut CK_BYTE,
1735 pub ulUKMLen: CK_ULONG,
1736}
1737impl Default for CK_GOSTR3410_DERIVE_PARAMS {
1738 fn default() -> Self {
1739 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1740 unsafe {
1741 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1742 s.assume_init()
1743 }
1744 }
1745}
1746#[repr(C)]
1747#[cfg_attr(windows, repr(packed))]
1748#[derive(Debug, Copy, Clone)]
1749pub struct CK_GOSTR3410_KEY_WRAP_PARAMS {
1750 pub pWrapOID: *mut CK_BYTE,
1751 pub ulWrapOIDLen: CK_ULONG,
1752 pub pUKM: *mut CK_BYTE,
1753 pub ulUKMLen: CK_ULONG,
1754 pub hKey: CK_OBJECT_HANDLE,
1755}
1756impl Default for CK_GOSTR3410_KEY_WRAP_PARAMS {
1757 fn default() -> Self {
1758 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1759 unsafe {
1760 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1761 s.assume_init()
1762 }
1763 }
1764}
1765#[repr(C)]
1766#[cfg_attr(windows, repr(packed))]
1767#[derive(Debug, Copy, Clone)]
1768pub struct CK_HKDF_PARAMS {
1769 pub bExtract: CK_BBOOL,
1770 pub bExpand: CK_BBOOL,
1771 pub prfHashMechanism: CK_MECHANISM_TYPE,
1772 pub ulSaltType: CK_ULONG,
1773 pub pSalt: *mut CK_BYTE,
1774 pub ulSaltLen: CK_ULONG,
1775 pub hSaltKey: CK_OBJECT_HANDLE,
1776 pub pInfo: *mut CK_BYTE,
1777 pub ulInfoLen: CK_ULONG,
1778}
1779impl Default for CK_HKDF_PARAMS {
1780 fn default() -> Self {
1781 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1782 unsafe {
1783 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1784 s.assume_init()
1785 }
1786 }
1787}
1788#[repr(C)]
1789#[cfg_attr(windows, repr(packed))]
1790#[derive(Debug, Copy, Clone)]
1791pub struct CK_IKE_PRF_DERIVE_PARAMS {
1792 pub prfMechanism: CK_MECHANISM_TYPE,
1793 pub bDataAsKey: CK_BBOOL,
1794 pub bRekey: CK_BBOOL,
1795 pub pNi: *mut CK_BYTE,
1796 pub ulNiLen: CK_ULONG,
1797 pub pNr: *mut CK_BYTE,
1798 pub ulNrLen: CK_ULONG,
1799 pub hNewKey: CK_OBJECT_HANDLE,
1800}
1801impl Default for CK_IKE_PRF_DERIVE_PARAMS {
1802 fn default() -> Self {
1803 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1804 unsafe {
1805 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1806 s.assume_init()
1807 }
1808 }
1809}
1810#[repr(C)]
1811#[cfg_attr(windows, repr(packed))]
1812#[derive(Debug, Copy, Clone)]
1813pub struct CK_IKE1_EXTENDED_DERIVE_PARAMS {
1814 pub prfMechanism: CK_MECHANISM_TYPE,
1815 pub bHasKeygxy: CK_BBOOL,
1816 pub hKeygxy: CK_OBJECT_HANDLE,
1817 pub pExtraData: *mut CK_BYTE,
1818 pub ulExtraDataLen: CK_ULONG,
1819}
1820impl Default for CK_IKE1_EXTENDED_DERIVE_PARAMS {
1821 fn default() -> Self {
1822 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1823 unsafe {
1824 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1825 s.assume_init()
1826 }
1827 }
1828}
1829#[repr(C)]
1830#[cfg_attr(windows, repr(packed))]
1831#[derive(Debug, Copy, Clone)]
1832pub struct CK_IKE1_PRF_DERIVE_PARAMS {
1833 pub prfMechanism: CK_MECHANISM_TYPE,
1834 pub bHasPrevKey: CK_BBOOL,
1835 pub hKeygxy: CK_OBJECT_HANDLE,
1836 pub hPrevKey: CK_OBJECT_HANDLE,
1837 pub pCKYi: *mut CK_BYTE,
1838 pub ulCKYiLen: CK_ULONG,
1839 pub pCKYr: *mut CK_BYTE,
1840 pub ulCKYrLen: CK_ULONG,
1841 pub keyNumber: CK_BYTE,
1842}
1843impl Default for CK_IKE1_PRF_DERIVE_PARAMS {
1844 fn default() -> Self {
1845 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1846 unsafe {
1847 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1848 s.assume_init()
1849 }
1850 }
1851}
1852#[repr(C)]
1853#[cfg_attr(windows, repr(packed))]
1854#[derive(Debug, Copy, Clone)]
1855pub struct CK_IKE2_PRF_PLUS_DERIVE_PARAMS {
1856 pub prfMechanism: CK_MECHANISM_TYPE,
1857 pub bHasSeedKey: CK_BBOOL,
1858 pub hSeedKey: CK_OBJECT_HANDLE,
1859 pub pSeedData: *mut CK_BYTE,
1860 pub ulSeedDataLen: CK_ULONG,
1861}
1862impl Default for CK_IKE2_PRF_PLUS_DERIVE_PARAMS {
1863 fn default() -> Self {
1864 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1865 unsafe {
1866 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1867 s.assume_init()
1868 }
1869 }
1870}
1871#[repr(C)]
1872#[cfg_attr(windows, repr(packed))]
1873#[derive(Debug, Copy, Clone)]
1874pub struct CK_KEA_DERIVE_PARAMS {
1875 pub isSender: CK_BBOOL,
1876 pub ulRandomLen: CK_ULONG,
1877 pub RandomA: *mut CK_BYTE,
1878 pub RandomB: *mut CK_BYTE,
1879 pub ulPublicDataLen: CK_ULONG,
1880 pub PublicData: *mut CK_BYTE,
1881}
1882impl Default for CK_KEA_DERIVE_PARAMS {
1883 fn default() -> Self {
1884 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1885 unsafe {
1886 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1887 s.assume_init()
1888 }
1889 }
1890}
1891#[repr(C)]
1892#[cfg_attr(windows, repr(packed))]
1893#[derive(Debug, Copy, Clone)]
1894pub struct CK_KEY_DERIVATION_STRING_DATA {
1895 pub pData: *mut CK_BYTE,
1896 pub ulLen: CK_ULONG,
1897}
1898impl Default for CK_KEY_DERIVATION_STRING_DATA {
1899 fn default() -> Self {
1900 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1901 unsafe {
1902 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1903 s.assume_init()
1904 }
1905 }
1906}
1907#[repr(C)]
1908#[cfg_attr(windows, repr(packed))]
1909#[derive(Debug, Copy, Clone)]
1910pub struct CK_KEY_WRAP_SET_OAEP_PARAMS {
1911 pub bBC: CK_BYTE,
1912 pub pX: *mut CK_BYTE,
1913 pub ulXLen: CK_ULONG,
1914}
1915impl Default for CK_KEY_WRAP_SET_OAEP_PARAMS {
1916 fn default() -> Self {
1917 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1918 unsafe {
1919 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1920 s.assume_init()
1921 }
1922 }
1923}
1924#[repr(C)]
1925#[cfg_attr(windows, repr(packed))]
1926#[derive(Debug, Copy, Clone)]
1927pub struct CK_KIP_PARAMS {
1928 pub pMechanism: *mut CK_MECHANISM,
1929 pub hKey: CK_OBJECT_HANDLE,
1930 pub pSeed: *mut CK_BYTE,
1931 pub ulSeedLen: CK_ULONG,
1932}
1933impl Default for CK_KIP_PARAMS {
1934 fn default() -> Self {
1935 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1936 unsafe {
1937 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1938 s.assume_init()
1939 }
1940 }
1941}
1942#[repr(C)]
1943#[cfg_attr(windows, repr(packed))]
1944#[derive(Debug, Copy, Clone)]
1945pub struct CK_OTP_PARAM {
1946 pub type_: CK_OTP_PARAM_TYPE,
1947 pub pValue: *mut ::std::os::raw::c_void,
1948 pub ulValueLen: CK_ULONG,
1949}
1950impl Default for CK_OTP_PARAM {
1951 fn default() -> Self {
1952 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1953 unsafe {
1954 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1955 s.assume_init()
1956 }
1957 }
1958}
1959#[repr(C)]
1960#[cfg_attr(windows, repr(packed))]
1961#[derive(Debug, Copy, Clone)]
1962pub struct CK_OTP_PARAMS {
1963 pub pParams: *mut CK_OTP_PARAM,
1964 pub ulCount: CK_ULONG,
1965}
1966impl Default for CK_OTP_PARAMS {
1967 fn default() -> Self {
1968 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1969 unsafe {
1970 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1971 s.assume_init()
1972 }
1973 }
1974}
1975#[repr(C)]
1976#[cfg_attr(windows, repr(packed))]
1977#[derive(Debug, Copy, Clone)]
1978pub struct CK_OTP_SIGNATURE_INFO {
1979 pub pParams: *mut CK_OTP_PARAM,
1980 pub ulCount: CK_ULONG,
1981}
1982impl Default for CK_OTP_SIGNATURE_INFO {
1983 fn default() -> Self {
1984 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1985 unsafe {
1986 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1987 s.assume_init()
1988 }
1989 }
1990}
1991#[repr(C)]
1992#[cfg_attr(windows, repr(packed))]
1993#[derive(Debug, Copy, Clone)]
1994pub struct CK_PBE_PARAMS {
1995 pub pInitVector: *mut CK_BYTE,
1996 pub pPassword: *mut CK_UTF8CHAR,
1997 pub ulPasswordLen: CK_ULONG,
1998 pub pSalt: *mut CK_BYTE,
1999 pub ulSaltLen: CK_ULONG,
2000 pub ulIteration: CK_ULONG,
2001}
2002impl Default for CK_PBE_PARAMS {
2003 fn default() -> Self {
2004 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2005 unsafe {
2006 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2007 s.assume_init()
2008 }
2009 }
2010}
2011#[repr(C)]
2012#[cfg_attr(windows, repr(packed))]
2013#[derive(Debug, Copy, Clone)]
2014pub struct CK_PKCS5_PBKD2_PARAMS {
2015 pub saltSource: CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE,
2016 pub pSaltSourceData: *mut ::std::os::raw::c_void,
2017 pub ulSaltSourceDataLen: CK_ULONG,
2018 pub iterations: CK_ULONG,
2019 pub prf: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE,
2020 pub pPrfData: *mut ::std::os::raw::c_void,
2021 pub ulPrfDataLen: CK_ULONG,
2022 pub pPassword: *mut CK_UTF8CHAR,
2023 pub ulPasswordLen: *mut CK_ULONG,
2024}
2025impl Default for CK_PKCS5_PBKD2_PARAMS {
2026 fn default() -> Self {
2027 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2028 unsafe {
2029 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2030 s.assume_init()
2031 }
2032 }
2033}
2034#[repr(C)]
2035#[cfg_attr(windows, repr(packed))]
2036#[derive(Debug, Copy, Clone)]
2037pub struct CK_PKCS5_PBKD2_PARAMS2 {
2038 pub saltSource: CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE,
2039 pub pSaltSourceData: *mut ::std::os::raw::c_void,
2040 pub ulSaltSourceDataLen: CK_ULONG,
2041 pub iterations: CK_ULONG,
2042 pub prf: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE,
2043 pub pPrfData: *mut ::std::os::raw::c_void,
2044 pub ulPrfDataLen: CK_ULONG,
2045 pub pPassword: *mut CK_UTF8CHAR,
2046 pub ulPasswordLen: CK_ULONG,
2047}
2048impl Default for CK_PKCS5_PBKD2_PARAMS2 {
2049 fn default() -> Self {
2050 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2051 unsafe {
2052 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2053 s.assume_init()
2054 }
2055 }
2056}
2057#[repr(C)]
2058#[cfg_attr(windows, repr(packed))]
2059#[derive(Debug, Copy, Clone)]
2060pub struct CK_PRF_DATA_PARAM {
2061 pub type_: CK_PRF_DATA_TYPE,
2062 pub pValue: *mut ::std::os::raw::c_void,
2063 pub ulValueLen: CK_ULONG,
2064}
2065impl Default for CK_PRF_DATA_PARAM {
2066 fn default() -> Self {
2067 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2068 unsafe {
2069 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2070 s.assume_init()
2071 }
2072 }
2073}
2074#[repr(C)]
2075#[cfg_attr(windows, repr(packed))]
2076#[derive(Debug, Default, Copy, Clone)]
2077pub struct CK_RC2_CBC_PARAMS {
2078 pub ulEffectiveBits: CK_ULONG,
2079 pub iv: [CK_BYTE; 8usize],
2080}
2081#[repr(C)]
2082#[cfg_attr(windows, repr(packed))]
2083#[derive(Debug, Default, Copy, Clone)]
2084pub struct CK_RC2_MAC_GENERAL_PARAMS {
2085 pub ulEffectiveBits: CK_ULONG,
2086 pub ulMacLength: CK_ULONG,
2087}
2088#[repr(C)]
2089#[cfg_attr(windows, repr(packed))]
2090#[derive(Debug, Copy, Clone)]
2091pub struct CK_RC5_CBC_PARAMS {
2092 pub ulWordsize: CK_ULONG,
2093 pub ulRounds: CK_ULONG,
2094 pub pIv: *mut CK_BYTE,
2095 pub ulIvLen: CK_ULONG,
2096}
2097impl Default for CK_RC5_CBC_PARAMS {
2098 fn default() -> Self {
2099 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2100 unsafe {
2101 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2102 s.assume_init()
2103 }
2104 }
2105}
2106#[repr(C)]
2107#[cfg_attr(windows, repr(packed))]
2108#[derive(Debug, Default, Copy, Clone)]
2109pub struct CK_RC5_MAC_GENERAL_PARAMS {
2110 pub ulWordsize: CK_ULONG,
2111 pub ulRounds: CK_ULONG,
2112 pub ulMacLength: CK_ULONG,
2113}
2114#[repr(C)]
2115#[cfg_attr(windows, repr(packed))]
2116#[derive(Debug, Default, Copy, Clone)]
2117pub struct CK_RC5_PARAMS {
2118 pub ulWordsize: CK_ULONG,
2119 pub ulRounds: CK_ULONG,
2120}
2121#[repr(C)]
2122#[cfg_attr(windows, repr(packed))]
2123#[derive(Debug, Copy, Clone)]
2124pub struct CK_RSA_AES_KEY_WRAP_PARAMS {
2125 pub ulAESKeyBits: CK_ULONG,
2126 pub pOAEPParams: *mut CK_RSA_PKCS_OAEP_PARAMS,
2127}
2128impl Default for CK_RSA_AES_KEY_WRAP_PARAMS {
2129 fn default() -> Self {
2130 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2131 unsafe {
2132 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2133 s.assume_init()
2134 }
2135 }
2136}
2137#[repr(C)]
2138#[cfg_attr(windows, repr(packed))]
2139#[derive(Debug, Copy, Clone)]
2140pub struct CK_RSA_PKCS_OAEP_PARAMS {
2141 pub hashAlg: CK_MECHANISM_TYPE,
2142 pub mgf: CK_RSA_PKCS_MGF_TYPE,
2143 pub source: CK_RSA_PKCS_OAEP_SOURCE_TYPE,
2144 pub pSourceData: *mut ::std::os::raw::c_void,
2145 pub ulSourceDataLen: CK_ULONG,
2146}
2147impl Default for CK_RSA_PKCS_OAEP_PARAMS {
2148 fn default() -> Self {
2149 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2150 unsafe {
2151 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2152 s.assume_init()
2153 }
2154 }
2155}
2156#[repr(C)]
2157#[cfg_attr(windows, repr(packed))]
2158#[derive(Debug, Default, Copy, Clone)]
2159pub struct CK_RSA_PKCS_PSS_PARAMS {
2160 pub hashAlg: CK_MECHANISM_TYPE,
2161 pub mgf: CK_RSA_PKCS_MGF_TYPE,
2162 pub sLen: CK_ULONG,
2163}
2164#[repr(C)]
2165#[cfg_attr(windows, repr(packed))]
2166#[derive(Debug, Copy, Clone)]
2167pub struct CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS {
2168 pub pNonce: *mut CK_BYTE,
2169 pub ulNonceLen: CK_ULONG,
2170 pub pTag: *mut CK_BYTE,
2171}
2172impl Default for CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS {
2173 fn default() -> Self {
2174 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2175 unsafe {
2176 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2177 s.assume_init()
2178 }
2179 }
2180}
2181#[repr(C)]
2182#[cfg_attr(windows, repr(packed))]
2183#[derive(Debug, Copy, Clone)]
2184pub struct CK_SALSA20_CHACHA20_POLY1305_PARAMS {
2185 pub pNonce: *mut CK_BYTE,
2186 pub ulNonceLen: CK_ULONG,
2187 pub pAAD: *mut CK_BYTE,
2188 pub ulAADLen: CK_ULONG,
2189}
2190impl Default for CK_SALSA20_CHACHA20_POLY1305_PARAMS {
2191 fn default() -> Self {
2192 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2193 unsafe {
2194 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2195 s.assume_init()
2196 }
2197 }
2198}
2199#[repr(C)]
2200#[cfg_attr(windows, repr(packed))]
2201#[derive(Debug, Copy, Clone)]
2202pub struct CK_SALSA20_PARAMS {
2203 pub pBlockCounter: *mut CK_BYTE,
2204 pub pNonce: *mut CK_BYTE,
2205 pub ulNonceBits: CK_ULONG,
2206}
2207impl Default for CK_SALSA20_PARAMS {
2208 fn default() -> Self {
2209 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2210 unsafe {
2211 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2212 s.assume_init()
2213 }
2214 }
2215}
2216#[repr(C)]
2217#[cfg_attr(windows, repr(packed))]
2218#[derive(Debug, Copy, Clone)]
2219pub struct CK_SEED_CBC_ENCRYPT_DATA_PARAMS {
2220 pub iv: [CK_BYTE; 16usize],
2221 pub pData: *mut CK_BYTE,
2222 pub length: CK_ULONG,
2223}
2224impl Default for CK_SEED_CBC_ENCRYPT_DATA_PARAMS {
2225 fn default() -> Self {
2226 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2227 unsafe {
2228 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2229 s.assume_init()
2230 }
2231 }
2232}
2233#[repr(C)]
2234#[cfg_attr(windows, repr(packed))]
2235#[derive(Debug, Copy, Clone)]
2236pub struct CK_SKIPJACK_PRIVATE_WRAP_PARAMS {
2237 pub ulPasswordLen: CK_ULONG,
2238 pub pPassword: *mut CK_BYTE,
2239 pub ulPublicDataLen: CK_ULONG,
2240 pub pPublicData: *mut CK_BYTE,
2241 pub ulPAndGLen: CK_ULONG,
2242 pub ulQLen: CK_ULONG,
2243 pub ulRandomLen: CK_ULONG,
2244 pub pRandomA: *mut CK_BYTE,
2245 pub pPrimeP: *mut CK_BYTE,
2246 pub pBaseG: *mut CK_BYTE,
2247 pub pSubprimeQ: *mut CK_BYTE,
2248}
2249impl Default for CK_SKIPJACK_PRIVATE_WRAP_PARAMS {
2250 fn default() -> Self {
2251 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2252 unsafe {
2253 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2254 s.assume_init()
2255 }
2256 }
2257}
2258#[repr(C)]
2259#[cfg_attr(windows, repr(packed))]
2260#[derive(Debug, Copy, Clone)]
2261pub struct CK_SKIPJACK_RELAYX_PARAMS {
2262 pub ulOldWrappedXLen: CK_ULONG,
2263 pub pOldWrappedX: *mut CK_BYTE,
2264 pub ulOldPasswordLen: CK_ULONG,
2265 pub pOldPassword: *mut CK_BYTE,
2266 pub ulOldPublicDataLen: CK_ULONG,
2267 pub pOldPublicData: *mut CK_BYTE,
2268 pub ulOldRandomLen: CK_ULONG,
2269 pub pOldRandomA: *mut CK_BYTE,
2270 pub ulNewPasswordLen: CK_ULONG,
2271 pub pNewPassword: *mut CK_BYTE,
2272 pub ulNewPublicDataLen: CK_ULONG,
2273 pub pNewPublicData: *mut CK_BYTE,
2274 pub ulNewRandomLen: CK_ULONG,
2275 pub pNewRandomA: *mut CK_BYTE,
2276}
2277impl Default for CK_SKIPJACK_RELAYX_PARAMS {
2278 fn default() -> Self {
2279 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2280 unsafe {
2281 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2282 s.assume_init()
2283 }
2284 }
2285}
2286#[repr(C)]
2287#[cfg_attr(windows, repr(packed))]
2288#[derive(Debug, Default, Copy, Clone)]
2289pub struct CK_SP800_108_COUNTER_FORMAT {
2290 pub bLittleEndian: CK_BBOOL,
2291 pub ulWidthInBits: CK_ULONG,
2292}
2293#[repr(C)]
2294#[cfg_attr(windows, repr(packed))]
2295#[derive(Debug, Default, Copy, Clone)]
2296pub struct CK_SP800_108_DKM_LENGTH_FORMAT {
2297 pub dkmLengthMethod: CK_SP800_108_DKM_LENGTH_METHOD,
2298 pub bLittleEndian: CK_BBOOL,
2299 pub ulWidthInBits: CK_ULONG,
2300}
2301pub type CK_SP800_108_PRF_TYPE = CK_MECHANISM_TYPE;
2302#[repr(C)]
2303#[cfg_attr(windows, repr(packed))]
2304#[derive(Debug, Copy, Clone)]
2305pub struct CK_SP800_108_FEEDBACK_KDF_PARAMS {
2306 pub prfType: CK_SP800_108_PRF_TYPE,
2307 pub ulNumberOfDataParams: CK_ULONG,
2308 pub pDataParams: *mut CK_PRF_DATA_PARAM,
2309 pub ulIVLen: CK_ULONG,
2310 pub pIV: *mut CK_BYTE,
2311 pub ulAdditionalDerivedKeys: CK_ULONG,
2312 pub pAdditionalDerivedKeys: *mut CK_DERIVED_KEY,
2313}
2314impl Default for CK_SP800_108_FEEDBACK_KDF_PARAMS {
2315 fn default() -> Self {
2316 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2317 unsafe {
2318 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2319 s.assume_init()
2320 }
2321 }
2322}
2323#[repr(C)]
2324#[cfg_attr(windows, repr(packed))]
2325#[derive(Debug, Copy, Clone)]
2326pub struct CK_SP800_108_KDF_PARAMS {
2327 pub prfType: CK_SP800_108_PRF_TYPE,
2328 pub ulNumberOfDataParams: CK_ULONG,
2329 pub pDataParams: *mut CK_PRF_DATA_PARAM,
2330 pub ulAdditionalDerivedKeys: CK_ULONG,
2331 pub pAdditionalDerivedKeys: *mut CK_DERIVED_KEY,
2332}
2333impl Default for CK_SP800_108_KDF_PARAMS {
2334 fn default() -> Self {
2335 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2336 unsafe {
2337 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2338 s.assume_init()
2339 }
2340 }
2341}
2342#[repr(C)]
2343#[cfg_attr(windows, repr(packed))]
2344#[derive(Debug, Copy, Clone)]
2345pub struct CK_X2RATCHET_INITIALIZE_PARAMS {
2346 pub sk: *mut CK_BYTE,
2347 pub peer_public_prekey: CK_OBJECT_HANDLE,
2348 pub peer_public_identity: CK_OBJECT_HANDLE,
2349 pub own_public_identity: CK_OBJECT_HANDLE,
2350 pub bEncryptedHeader: CK_BBOOL,
2351 pub eCurve: CK_ULONG,
2352 pub aeadMechanism: CK_MECHANISM_TYPE,
2353 pub kdfMechanism: CK_X2RATCHET_KDF_TYPE,
2354}
2355impl Default for CK_X2RATCHET_INITIALIZE_PARAMS {
2356 fn default() -> Self {
2357 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2358 unsafe {
2359 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2360 s.assume_init()
2361 }
2362 }
2363}
2364#[repr(C)]
2365#[cfg_attr(windows, repr(packed))]
2366#[derive(Debug, Copy, Clone)]
2367pub struct CK_X2RATCHET_RESPOND_PARAMS {
2368 pub sk: *mut CK_BYTE,
2369 pub own_prekey: CK_OBJECT_HANDLE,
2370 pub initiator_identity: CK_OBJECT_HANDLE,
2371 pub own_public_identity: CK_OBJECT_HANDLE,
2372 pub bEncryptedHeader: CK_BBOOL,
2373 pub eCurve: CK_ULONG,
2374 pub aeadMechanism: CK_MECHANISM_TYPE,
2375 pub kdfMechanism: CK_X2RATCHET_KDF_TYPE,
2376}
2377impl Default for CK_X2RATCHET_RESPOND_PARAMS {
2378 fn default() -> Self {
2379 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2380 unsafe {
2381 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2382 s.assume_init()
2383 }
2384 }
2385}
2386#[repr(C)]
2387#[cfg_attr(windows, repr(packed))]
2388#[derive(Debug, Copy, Clone)]
2389pub struct CK_X3DH_INITIATE_PARAMS {
2390 pub kdf: CK_X3DH_KDF_TYPE,
2391 pub pPeer_identity: CK_OBJECT_HANDLE,
2392 pub pPeer_prekey: CK_OBJECT_HANDLE,
2393 pub pPrekey_signature: *mut CK_BYTE,
2394 pub pOnetime_key: *mut CK_BYTE,
2395 pub pOwn_identity: CK_OBJECT_HANDLE,
2396 pub pOwn_ephemeral: CK_OBJECT_HANDLE,
2397}
2398impl Default for CK_X3DH_INITIATE_PARAMS {
2399 fn default() -> Self {
2400 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2401 unsafe {
2402 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2403 s.assume_init()
2404 }
2405 }
2406}
2407#[repr(C)]
2408#[cfg_attr(windows, repr(packed))]
2409#[derive(Debug, Copy, Clone)]
2410pub struct CK_X3DH_RESPOND_PARAMS {
2411 pub kdf: CK_X3DH_KDF_TYPE,
2412 pub pIdentity_id: *mut CK_BYTE,
2413 pub pPrekey_id: *mut CK_BYTE,
2414 pub pOnetime_id: *mut CK_BYTE,
2415 pub pInitiator_identity: CK_OBJECT_HANDLE,
2416 pub pInitiator_ephemeral: *mut CK_BYTE,
2417}
2418impl Default for CK_X3DH_RESPOND_PARAMS {
2419 fn default() -> Self {
2420 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2421 unsafe {
2422 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2423 s.assume_init()
2424 }
2425 }
2426}
2427#[repr(C)]
2428#[cfg_attr(windows, repr(packed))]
2429#[derive(Debug, Copy, Clone)]
2430pub struct CK_X9_42_DH1_DERIVE_PARAMS {
2431 pub kdf: CK_X9_42_DH_KDF_TYPE,
2432 pub ulOtherInfoLen: CK_ULONG,
2433 pub pOtherInfo: *mut CK_BYTE,
2434 pub ulPublicDataLen: CK_ULONG,
2435 pub pPublicData: *mut CK_BYTE,
2436}
2437impl Default for CK_X9_42_DH1_DERIVE_PARAMS {
2438 fn default() -> Self {
2439 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2440 unsafe {
2441 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2442 s.assume_init()
2443 }
2444 }
2445}
2446#[repr(C)]
2447#[cfg_attr(windows, repr(packed))]
2448#[derive(Debug, Copy, Clone)]
2449pub struct CK_X9_42_DH2_DERIVE_PARAMS {
2450 pub kdf: CK_X9_42_DH_KDF_TYPE,
2451 pub ulOtherInfoLen: CK_ULONG,
2452 pub pOtherInfo: *mut CK_BYTE,
2453 pub ulPublicDataLen: CK_ULONG,
2454 pub pPublicData: *mut CK_BYTE,
2455 pub ulPrivateDataLen: CK_ULONG,
2456 pub hPrivateData: CK_OBJECT_HANDLE,
2457 pub ulPublicDataLen2: CK_ULONG,
2458 pub pPublicData2: *mut CK_BYTE,
2459}
2460impl Default for CK_X9_42_DH2_DERIVE_PARAMS {
2461 fn default() -> Self {
2462 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2463 unsafe {
2464 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2465 s.assume_init()
2466 }
2467 }
2468}
2469#[repr(C)]
2470#[cfg_attr(windows, repr(packed))]
2471#[derive(Debug, Copy, Clone)]
2472pub struct CK_X9_42_MQV_DERIVE_PARAMS {
2473 pub kdf: CK_X9_42_DH_KDF_TYPE,
2474 pub ulOtherInfoLen: CK_ULONG,
2475 pub OtherInfo: *mut CK_BYTE,
2476 pub ulPublicDataLen: CK_ULONG,
2477 pub PublicData: *mut CK_BYTE,
2478 pub ulPrivateDataLen: CK_ULONG,
2479 pub hPrivateData: CK_OBJECT_HANDLE,
2480 pub ulPublicDataLen2: CK_ULONG,
2481 pub PublicData2: *mut CK_BYTE,
2482 pub publicKey: CK_OBJECT_HANDLE,
2483}
2484impl Default for CK_X9_42_MQV_DERIVE_PARAMS {
2485 fn default() -> Self {
2486 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2487 unsafe {
2488 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2489 s.assume_init()
2490 }
2491 }
2492}
2493#[repr(C)]
2494#[cfg_attr(windows, repr(packed))]
2495#[derive(Debug, Default, Copy, Clone)]
2496pub struct CK_XEDDSA_PARAMS {
2497 pub hash: CK_XEDDSA_HASH_TYPE,
2498}
2499#[repr(C)]
2500#[cfg_attr(windows, repr(packed))]
2501#[derive(Debug, Default, Copy, Clone)]
2502pub struct specifiedParams {
2503 pub levels: CK_HSS_LEVELS,
2504 pub lm_type: [CK_LMS_TYPE; 8usize],
2505 pub lm_ots_type: [CK_LMOTS_TYPE; 8usize],
2506}
2507pub type CK_SSL3_KEY_MAT_OUT_PTR = *mut CK_SSL3_KEY_MAT_OUT;
2508pub type CK_SSL3_KEY_MAT_OUT_PTR_PTR = *mut *mut CK_SSL3_KEY_MAT_OUT;
2509pub type CK_SSL3_KEY_MAT_PARAMS_PTR = *mut CK_SSL3_KEY_MAT_PARAMS;
2510pub type CK_SSL3_KEY_MAT_PARAMS_PTR_PTR = *mut *mut CK_SSL3_KEY_MAT_PARAMS;
2511pub type CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR = *mut CK_SSL3_MASTER_KEY_DERIVE_PARAMS;
2512pub type CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_SSL3_MASTER_KEY_DERIVE_PARAMS;
2513pub type CK_SSL3_RANDOM_DATA_PTR = *mut CK_SSL3_RANDOM_DATA;
2514pub type CK_SSL3_RANDOM_DATA_PTR_PTR = *mut *mut CK_SSL3_RANDOM_DATA;
2515pub type CK_TLS_KDF_PARAMS_PTR = *mut CK_TLS_KDF_PARAMS;
2516pub type CK_TLS_KDF_PARAMS_PTR_PTR = *mut *mut CK_TLS_KDF_PARAMS;
2517pub type CK_TLS_MAC_PARAMS_PTR = *mut CK_TLS_MAC_PARAMS;
2518pub type CK_TLS_MAC_PARAMS_PTR_PTR = *mut *mut CK_TLS_MAC_PARAMS;
2519pub type CK_TLS_PRF_PARAMS_PTR = *mut CK_TLS_PRF_PARAMS;
2520pub type CK_TLS_PRF_PARAMS_PTR_PTR = *mut *mut CK_TLS_PRF_PARAMS;
2521pub type CK_TLS12_KEY_MAT_PARAMS_PTR = *mut CK_TLS12_KEY_MAT_PARAMS;
2522pub type CK_TLS12_KEY_MAT_PARAMS_PTR_PTR = *mut *mut CK_TLS12_KEY_MAT_PARAMS;
2523pub type CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR = *mut CK_TLS12_MASTER_KEY_DERIVE_PARAMS;
2524pub type CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_TLS12_MASTER_KEY_DERIVE_PARAMS;
2525pub type CK_WTLS_KEY_MAT_OUT_PTR = *mut CK_WTLS_KEY_MAT_OUT;
2526pub type CK_WTLS_KEY_MAT_OUT_PTR_PTR = *mut *mut CK_WTLS_KEY_MAT_OUT;
2527pub type CK_WTLS_KEY_MAT_PARAMS_PTR = *mut CK_WTLS_KEY_MAT_PARAMS;
2528pub type CK_WTLS_KEY_MAT_PARAMS_PTR_PTR = *mut *mut CK_WTLS_KEY_MAT_PARAMS;
2529pub type CK_WTLS_MASTER_KEY_DERIVE_PARAMS_PTR = *mut CK_WTLS_MASTER_KEY_DERIVE_PARAMS;
2530pub type CK_WTLS_MASTER_KEY_DERIVE_PARAMS_PTR_PTR = *mut *mut CK_WTLS_MASTER_KEY_DERIVE_PARAMS;
2531pub type CK_WTLS_PRF_PARAMS_PTR = *mut CK_WTLS_PRF_PARAMS;
2532pub type CK_WTLS_PRF_PARAMS_PTR_PTR = *mut *mut CK_WTLS_PRF_PARAMS;
2533pub type CK_WTLS_RANDOM_DATA_PTR = *mut CK_WTLS_RANDOM_DATA;
2534pub type CK_WTLS_RANDOM_DATA_PTR_PTR = *mut *mut CK_WTLS_RANDOM_DATA;
2535#[repr(C)]
2536#[cfg_attr(windows, repr(packed))]
2537#[derive(Debug, Copy, Clone)]
2538pub struct CK_SSL3_KEY_MAT_OUT {
2539 pub hClientMacSecret: CK_OBJECT_HANDLE,
2540 pub hServerMacSecret: CK_OBJECT_HANDLE,
2541 pub hClientKey: CK_OBJECT_HANDLE,
2542 pub hServerKey: CK_OBJECT_HANDLE,
2543 pub pIVClient: *mut CK_BYTE,
2544 pub pIVServer: *mut CK_BYTE,
2545}
2546impl Default for CK_SSL3_KEY_MAT_OUT {
2547 fn default() -> Self {
2548 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2549 unsafe {
2550 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2551 s.assume_init()
2552 }
2553 }
2554}
2555#[repr(C)]
2556#[cfg_attr(windows, repr(packed))]
2557#[derive(Debug, Copy, Clone)]
2558pub struct CK_SSL3_RANDOM_DATA {
2559 pub pClientRandom: *mut CK_BYTE,
2560 pub ulClientRandomLen: CK_ULONG,
2561 pub pServerRandom: *mut CK_BYTE,
2562 pub ulServerRandomLen: CK_ULONG,
2563}
2564impl Default for CK_SSL3_RANDOM_DATA {
2565 fn default() -> Self {
2566 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2567 unsafe {
2568 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2569 s.assume_init()
2570 }
2571 }
2572}
2573#[repr(C)]
2574#[cfg_attr(windows, repr(packed))]
2575#[derive(Debug, Copy, Clone)]
2576pub struct CK_SSL3_KEY_MAT_PARAMS {
2577 pub ulMacSizeInBits: CK_ULONG,
2578 pub ulKeySizeInBits: CK_ULONG,
2579 pub ulIVSizeInBits: CK_ULONG,
2580 pub bIsExport: CK_BBOOL,
2581 pub RandomInfo: CK_SSL3_RANDOM_DATA,
2582 pub pReturnedKeyMaterial: *mut CK_SSL3_KEY_MAT_OUT,
2583}
2584impl Default for CK_SSL3_KEY_MAT_PARAMS {
2585 fn default() -> Self {
2586 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2587 unsafe {
2588 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2589 s.assume_init()
2590 }
2591 }
2592}
2593#[repr(C)]
2594#[cfg_attr(windows, repr(packed))]
2595#[derive(Debug, Copy, Clone)]
2596pub struct CK_SSL3_MASTER_KEY_DERIVE_PARAMS {
2597 pub RandomInfo: CK_SSL3_RANDOM_DATA,
2598 pub pVersion: *mut CK_VERSION,
2599}
2600impl Default for CK_SSL3_MASTER_KEY_DERIVE_PARAMS {
2601 fn default() -> Self {
2602 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2603 unsafe {
2604 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2605 s.assume_init()
2606 }
2607 }
2608}
2609#[repr(C)]
2610#[cfg_attr(windows, repr(packed))]
2611#[derive(Debug, Copy, Clone)]
2612pub struct CK_TLS_KDF_PARAMS {
2613 pub prfMechanism: CK_MECHANISM_TYPE,
2614 pub pLabel: *mut CK_BYTE,
2615 pub ulLabelLength: CK_ULONG,
2616 pub RandomInfo: CK_SSL3_RANDOM_DATA,
2617 pub pContextData: *mut CK_BYTE,
2618 pub ulContextDataLength: CK_ULONG,
2619}
2620impl Default for CK_TLS_KDF_PARAMS {
2621 fn default() -> Self {
2622 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2623 unsafe {
2624 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2625 s.assume_init()
2626 }
2627 }
2628}
2629#[repr(C)]
2630#[cfg_attr(windows, repr(packed))]
2631#[derive(Debug, Default, Copy, Clone)]
2632pub struct CK_TLS_MAC_PARAMS {
2633 pub prfHashMechanism: CK_MECHANISM_TYPE,
2634 pub ulMacLength: CK_ULONG,
2635 pub ulServerOrClient: CK_ULONG,
2636}
2637#[repr(C)]
2638#[cfg_attr(windows, repr(packed))]
2639#[derive(Debug, Copy, Clone)]
2640pub struct CK_TLS_PRF_PARAMS {
2641 pub pSeed: *mut CK_BYTE,
2642 pub ulSeedLen: CK_ULONG,
2643 pub pLabel: *mut CK_BYTE,
2644 pub ulLabelLen: CK_ULONG,
2645 pub pOutput: *mut CK_BYTE,
2646 pub pulOutputLen: *mut CK_ULONG,
2647}
2648impl Default for CK_TLS_PRF_PARAMS {
2649 fn default() -> Self {
2650 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2651 unsafe {
2652 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2653 s.assume_init()
2654 }
2655 }
2656}
2657#[repr(C)]
2658#[cfg_attr(windows, repr(packed))]
2659#[derive(Debug, Copy, Clone)]
2660pub struct CK_TLS12_KEY_MAT_PARAMS {
2661 pub ulMacSizeInBits: CK_ULONG,
2662 pub ulKeySizeInBits: CK_ULONG,
2663 pub ulIVSizeInBits: CK_ULONG,
2664 pub bIsExport: CK_BBOOL,
2665 pub RandomInfo: CK_SSL3_RANDOM_DATA,
2666 pub pReturnedKeyMaterial: *mut CK_SSL3_KEY_MAT_OUT,
2667 pub prfHashMechanism: CK_MECHANISM_TYPE,
2668}
2669impl Default for CK_TLS12_KEY_MAT_PARAMS {
2670 fn default() -> Self {
2671 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2672 unsafe {
2673 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2674 s.assume_init()
2675 }
2676 }
2677}
2678#[repr(C)]
2679#[cfg_attr(windows, repr(packed))]
2680#[derive(Debug, Copy, Clone)]
2681pub struct CK_TLS12_MASTER_KEY_DERIVE_PARAMS {
2682 pub RandomInfo: CK_SSL3_RANDOM_DATA,
2683 pub pVersion: *mut CK_VERSION,
2684 pub prfHashMechanism: CK_MECHANISM_TYPE,
2685}
2686impl Default for CK_TLS12_MASTER_KEY_DERIVE_PARAMS {
2687 fn default() -> Self {
2688 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2689 unsafe {
2690 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2691 s.assume_init()
2692 }
2693 }
2694}
2695#[repr(C)]
2696#[cfg_attr(windows, repr(packed))]
2697#[derive(Debug, Copy, Clone)]
2698pub struct CK_WTLS_KEY_MAT_OUT {
2699 pub hMacSecret: CK_OBJECT_HANDLE,
2700 pub hKey: CK_OBJECT_HANDLE,
2701 pub pIV: *mut CK_BYTE,
2702}
2703impl Default for CK_WTLS_KEY_MAT_OUT {
2704 fn default() -> Self {
2705 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2706 unsafe {
2707 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2708 s.assume_init()
2709 }
2710 }
2711}
2712#[repr(C)]
2713#[cfg_attr(windows, repr(packed))]
2714#[derive(Debug, Copy, Clone)]
2715pub struct CK_WTLS_RANDOM_DATA {
2716 pub pClientRandom: *mut CK_BYTE,
2717 pub ulClientRandomLen: CK_ULONG,
2718 pub pServerRandom: *mut CK_BYTE,
2719 pub ulServerRandomLen: CK_ULONG,
2720}
2721impl Default for CK_WTLS_RANDOM_DATA {
2722 fn default() -> Self {
2723 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2724 unsafe {
2725 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2726 s.assume_init()
2727 }
2728 }
2729}
2730#[repr(C)]
2731#[cfg_attr(windows, repr(packed))]
2732#[derive(Debug, Copy, Clone)]
2733pub struct CK_WTLS_KEY_MAT_PARAMS {
2734 pub DigestMechanism: CK_MECHANISM_TYPE,
2735 pub ulMacSizeInBits: CK_ULONG,
2736 pub ulKeySizeInBits: CK_ULONG,
2737 pub ulIVSizeInBits: CK_ULONG,
2738 pub ulSequenceNumber: CK_ULONG,
2739 pub bIsExport: CK_BBOOL,
2740 pub RandomInfo: CK_WTLS_RANDOM_DATA,
2741 pub pReturnedKeyMaterial: *mut CK_WTLS_KEY_MAT_OUT,
2742}
2743impl Default for CK_WTLS_KEY_MAT_PARAMS {
2744 fn default() -> Self {
2745 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2746 unsafe {
2747 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2748 s.assume_init()
2749 }
2750 }
2751}
2752#[repr(C)]
2753#[cfg_attr(windows, repr(packed))]
2754#[derive(Debug, Copy, Clone)]
2755pub struct CK_WTLS_MASTER_KEY_DERIVE_PARAMS {
2756 pub DigestMechanism: CK_MECHANISM_TYPE,
2757 pub RandomInfo: CK_WTLS_RANDOM_DATA,
2758 pub pVersion: *mut CK_BYTE,
2759}
2760impl Default for CK_WTLS_MASTER_KEY_DERIVE_PARAMS {
2761 fn default() -> Self {
2762 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2763 unsafe {
2764 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2765 s.assume_init()
2766 }
2767 }
2768}
2769#[repr(C)]
2770#[cfg_attr(windows, repr(packed))]
2771#[derive(Debug, Copy, Clone)]
2772pub struct CK_WTLS_PRF_PARAMS {
2773 pub DigestMechanism: CK_MECHANISM_TYPE,
2774 pub pSeed: *mut CK_BYTE,
2775 pub ulSeedLen: CK_ULONG,
2776 pub pLabel: *mut CK_BYTE,
2777 pub ulLabelLen: CK_ULONG,
2778 pub pOutput: *mut CK_BYTE,
2779 pub pulOutputLen: *mut CK_ULONG,
2780}
2781impl Default for CK_WTLS_PRF_PARAMS {
2782 fn default() -> Self {
2783 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2784 unsafe {
2785 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2786 s.assume_init()
2787 }
2788 }
2789}
2790pub type CK_C_Initialize =
2791 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> CK_RV>;
2792pub type CK_C_Finalize =
2793 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> CK_RV>;
2794pub type CK_C_GetInfo = ::std::option::Option<unsafe extern "C" fn(arg1: *mut CK_INFO) -> CK_RV>;
2795pub type CK_C_GetFunctionList =
2796 ::std::option::Option<unsafe extern "C" fn(arg1: *mut *mut CK_FUNCTION_LIST) -> CK_RV>;
2797pub type CK_C_GetSlotList = ::std::option::Option<
2798 unsafe extern "C" fn(arg1: CK_BBOOL, arg2: *mut CK_SLOT_ID, arg3: *mut CK_ULONG) -> CK_RV,
2799>;
2800pub type CK_C_GetSlotInfo =
2801 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SLOT_ID, arg2: *mut CK_SLOT_INFO) -> CK_RV>;
2802pub type CK_C_GetTokenInfo = ::std::option::Option<
2803 unsafe extern "C" fn(arg1: CK_SLOT_ID, arg2: *mut CK_TOKEN_INFO) -> CK_RV,
2804>;
2805pub type CK_C_GetMechanismList = ::std::option::Option<
2806 unsafe extern "C" fn(
2807 arg1: CK_SLOT_ID,
2808 arg2: *mut CK_MECHANISM_TYPE,
2809 arg3: *mut CK_ULONG,
2810 ) -> CK_RV,
2811>;
2812pub type CK_C_GetMechanismInfo = ::std::option::Option<
2813 unsafe extern "C" fn(
2814 arg1: CK_SLOT_ID,
2815 arg2: CK_MECHANISM_TYPE,
2816 arg3: *mut CK_MECHANISM_INFO,
2817 ) -> CK_RV,
2818>;
2819pub type CK_C_InitToken = ::std::option::Option<
2820 unsafe extern "C" fn(
2821 arg1: CK_SLOT_ID,
2822 arg2: *mut CK_UTF8CHAR,
2823 arg3: CK_ULONG,
2824 arg4: *mut CK_UTF8CHAR,
2825 ) -> CK_RV,
2826>;
2827pub type CK_C_InitPIN = ::std::option::Option<
2828 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_UTF8CHAR, arg3: CK_ULONG) -> CK_RV,
2829>;
2830pub type CK_C_SetPIN = ::std::option::Option<
2831 unsafe extern "C" fn(
2832 arg1: CK_SESSION_HANDLE,
2833 arg2: *mut CK_UTF8CHAR,
2834 arg3: CK_ULONG,
2835 arg4: *mut CK_UTF8CHAR,
2836 arg5: CK_ULONG,
2837 ) -> CK_RV,
2838>;
2839pub type CK_C_OpenSession = ::std::option::Option<
2840 unsafe extern "C" fn(
2841 arg1: CK_SLOT_ID,
2842 arg2: CK_FLAGS,
2843 arg3: *mut ::std::os::raw::c_void,
2844 arg4: CK_NOTIFY,
2845 arg5: *mut CK_SESSION_HANDLE,
2846 ) -> CK_RV,
2847>;
2848pub type CK_C_CloseSession =
2849 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
2850pub type CK_C_CloseAllSessions =
2851 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SLOT_ID) -> CK_RV>;
2852pub type CK_C_GetSessionInfo = ::std::option::Option<
2853 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_SESSION_INFO) -> CK_RV,
2854>;
2855pub type CK_C_GetOperationState = ::std::option::Option<
2856 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: *mut CK_ULONG) -> CK_RV,
2857>;
2858pub type CK_C_SetOperationState = ::std::option::Option<
2859 unsafe extern "C" fn(
2860 arg1: CK_SESSION_HANDLE,
2861 arg2: *mut CK_BYTE,
2862 arg3: CK_ULONG,
2863 arg4: CK_OBJECT_HANDLE,
2864 arg5: CK_OBJECT_HANDLE,
2865 ) -> CK_RV,
2866>;
2867pub type CK_C_Login = ::std::option::Option<
2868 unsafe extern "C" fn(
2869 arg1: CK_SESSION_HANDLE,
2870 arg2: CK_USER_TYPE,
2871 arg3: *mut CK_UTF8CHAR,
2872 arg4: CK_ULONG,
2873 ) -> CK_RV,
2874>;
2875pub type CK_C_Logout =
2876 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
2877pub type CK_C_CreateObject = ::std::option::Option<
2878 unsafe extern "C" fn(
2879 arg1: CK_SESSION_HANDLE,
2880 arg2: *mut CK_ATTRIBUTE,
2881 arg3: CK_ULONG,
2882 arg4: *mut CK_OBJECT_HANDLE,
2883 ) -> CK_RV,
2884>;
2885pub type CK_C_CopyObject = ::std::option::Option<
2886 unsafe extern "C" fn(
2887 arg1: CK_SESSION_HANDLE,
2888 arg2: CK_OBJECT_HANDLE,
2889 arg3: *mut CK_ATTRIBUTE,
2890 arg4: CK_ULONG,
2891 arg5: *mut CK_OBJECT_HANDLE,
2892 ) -> CK_RV,
2893>;
2894pub type CK_C_DestroyObject = ::std::option::Option<
2895 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: CK_OBJECT_HANDLE) -> CK_RV,
2896>;
2897pub type CK_C_GetObjectSize = ::std::option::Option<
2898 unsafe extern "C" fn(
2899 arg1: CK_SESSION_HANDLE,
2900 arg2: CK_OBJECT_HANDLE,
2901 arg3: *mut CK_ULONG,
2902 ) -> CK_RV,
2903>;
2904pub type CK_C_GetAttributeValue = ::std::option::Option<
2905 unsafe extern "C" fn(
2906 arg1: CK_SESSION_HANDLE,
2907 arg2: CK_OBJECT_HANDLE,
2908 arg3: *mut CK_ATTRIBUTE,
2909 arg4: CK_ULONG,
2910 ) -> CK_RV,
2911>;
2912pub type CK_C_SetAttributeValue = ::std::option::Option<
2913 unsafe extern "C" fn(
2914 arg1: CK_SESSION_HANDLE,
2915 arg2: CK_OBJECT_HANDLE,
2916 arg3: *mut CK_ATTRIBUTE,
2917 arg4: CK_ULONG,
2918 ) -> CK_RV,
2919>;
2920pub type CK_C_FindObjectsInit = ::std::option::Option<
2921 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_ATTRIBUTE, arg3: CK_ULONG) -> CK_RV,
2922>;
2923pub type CK_C_FindObjects = ::std::option::Option<
2924 unsafe extern "C" fn(
2925 arg1: CK_SESSION_HANDLE,
2926 arg2: *mut CK_OBJECT_HANDLE,
2927 arg3: CK_ULONG,
2928 arg4: *mut CK_ULONG,
2929 ) -> CK_RV,
2930>;
2931pub type CK_C_FindObjectsFinal =
2932 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
2933pub type CK_C_EncryptInit = ::std::option::Option<
2934 unsafe extern "C" fn(
2935 arg1: CK_SESSION_HANDLE,
2936 arg2: *mut CK_MECHANISM,
2937 arg3: CK_OBJECT_HANDLE,
2938 ) -> CK_RV,
2939>;
2940pub type CK_C_Encrypt = ::std::option::Option<
2941 unsafe extern "C" fn(
2942 arg1: CK_SESSION_HANDLE,
2943 arg2: *mut CK_BYTE,
2944 arg3: CK_ULONG,
2945 arg4: *mut CK_BYTE,
2946 arg5: *mut CK_ULONG,
2947 ) -> CK_RV,
2948>;
2949pub type CK_C_EncryptUpdate = ::std::option::Option<
2950 unsafe extern "C" fn(
2951 arg1: CK_SESSION_HANDLE,
2952 arg2: *mut CK_BYTE,
2953 arg3: CK_ULONG,
2954 arg4: *mut CK_BYTE,
2955 arg5: *mut CK_ULONG,
2956 ) -> CK_RV,
2957>;
2958pub type CK_C_EncryptFinal = ::std::option::Option<
2959 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: *mut CK_ULONG) -> CK_RV,
2960>;
2961pub type CK_C_DecryptInit = ::std::option::Option<
2962 unsafe extern "C" fn(
2963 arg1: CK_SESSION_HANDLE,
2964 arg2: *mut CK_MECHANISM,
2965 arg3: CK_OBJECT_HANDLE,
2966 ) -> CK_RV,
2967>;
2968pub type CK_C_Decrypt = ::std::option::Option<
2969 unsafe extern "C" fn(
2970 arg1: CK_SESSION_HANDLE,
2971 arg2: *mut CK_BYTE,
2972 arg3: CK_ULONG,
2973 arg4: *mut CK_BYTE,
2974 arg5: *mut CK_ULONG,
2975 ) -> CK_RV,
2976>;
2977pub type CK_C_DecryptUpdate = ::std::option::Option<
2978 unsafe extern "C" fn(
2979 arg1: CK_SESSION_HANDLE,
2980 arg2: *mut CK_BYTE,
2981 arg3: CK_ULONG,
2982 arg4: *mut CK_BYTE,
2983 arg5: *mut CK_ULONG,
2984 ) -> CK_RV,
2985>;
2986pub type CK_C_DecryptFinal = ::std::option::Option<
2987 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: *mut CK_ULONG) -> CK_RV,
2988>;
2989pub type CK_C_DigestInit = ::std::option::Option<
2990 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_MECHANISM) -> CK_RV,
2991>;
2992pub type CK_C_Digest = ::std::option::Option<
2993 unsafe extern "C" fn(
2994 arg1: CK_SESSION_HANDLE,
2995 arg2: *mut CK_BYTE,
2996 arg3: CK_ULONG,
2997 arg4: *mut CK_BYTE,
2998 arg5: *mut CK_ULONG,
2999 ) -> CK_RV,
3000>;
3001pub type CK_C_DigestUpdate = ::std::option::Option<
3002 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3003>;
3004pub type CK_C_DigestKey = ::std::option::Option<
3005 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: CK_OBJECT_HANDLE) -> CK_RV,
3006>;
3007pub type CK_C_DigestFinal = ::std::option::Option<
3008 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: *mut CK_ULONG) -> CK_RV,
3009>;
3010pub type CK_C_SignInit = ::std::option::Option<
3011 unsafe extern "C" fn(
3012 arg1: CK_SESSION_HANDLE,
3013 arg2: *mut CK_MECHANISM,
3014 arg3: CK_OBJECT_HANDLE,
3015 ) -> CK_RV,
3016>;
3017pub type CK_C_Sign = ::std::option::Option<
3018 unsafe extern "C" fn(
3019 arg1: CK_SESSION_HANDLE,
3020 arg2: *mut CK_BYTE,
3021 arg3: CK_ULONG,
3022 arg4: *mut CK_BYTE,
3023 arg5: *mut CK_ULONG,
3024 ) -> CK_RV,
3025>;
3026pub type CK_C_SignUpdate = ::std::option::Option<
3027 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3028>;
3029pub type CK_C_SignFinal = ::std::option::Option<
3030 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: *mut CK_ULONG) -> CK_RV,
3031>;
3032pub type CK_C_SignRecoverInit = ::std::option::Option<
3033 unsafe extern "C" fn(
3034 arg1: CK_SESSION_HANDLE,
3035 arg2: *mut CK_MECHANISM,
3036 arg3: CK_OBJECT_HANDLE,
3037 ) -> CK_RV,
3038>;
3039pub type CK_C_SignRecover = ::std::option::Option<
3040 unsafe extern "C" fn(
3041 arg1: CK_SESSION_HANDLE,
3042 arg2: *mut CK_BYTE,
3043 arg3: CK_ULONG,
3044 arg4: *mut CK_BYTE,
3045 arg5: *mut CK_ULONG,
3046 ) -> CK_RV,
3047>;
3048pub type CK_C_VerifyInit = ::std::option::Option<
3049 unsafe extern "C" fn(
3050 arg1: CK_SESSION_HANDLE,
3051 arg2: *mut CK_MECHANISM,
3052 arg3: CK_OBJECT_HANDLE,
3053 ) -> CK_RV,
3054>;
3055pub type CK_C_Verify = ::std::option::Option<
3056 unsafe extern "C" fn(
3057 arg1: CK_SESSION_HANDLE,
3058 arg2: *mut CK_BYTE,
3059 arg3: CK_ULONG,
3060 arg4: *mut CK_BYTE,
3061 arg5: CK_ULONG,
3062 ) -> CK_RV,
3063>;
3064pub type CK_C_VerifyUpdate = ::std::option::Option<
3065 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3066>;
3067pub type CK_C_VerifyFinal = ::std::option::Option<
3068 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3069>;
3070pub type CK_C_VerifyRecoverInit = ::std::option::Option<
3071 unsafe extern "C" fn(
3072 arg1: CK_SESSION_HANDLE,
3073 arg2: *mut CK_MECHANISM,
3074 arg3: CK_OBJECT_HANDLE,
3075 ) -> CK_RV,
3076>;
3077pub type CK_C_VerifyRecover = ::std::option::Option<
3078 unsafe extern "C" fn(
3079 arg1: CK_SESSION_HANDLE,
3080 arg2: *mut CK_BYTE,
3081 arg3: CK_ULONG,
3082 arg4: *mut CK_BYTE,
3083 arg5: *mut CK_ULONG,
3084 ) -> CK_RV,
3085>;
3086pub type CK_C_DigestEncryptUpdate = ::std::option::Option<
3087 unsafe extern "C" fn(
3088 arg1: CK_SESSION_HANDLE,
3089 arg2: *mut CK_BYTE,
3090 arg3: CK_ULONG,
3091 arg4: *mut CK_BYTE,
3092 arg5: *mut CK_ULONG,
3093 ) -> CK_RV,
3094>;
3095pub type CK_C_DecryptDigestUpdate = ::std::option::Option<
3096 unsafe extern "C" fn(
3097 arg1: CK_SESSION_HANDLE,
3098 arg2: *mut CK_BYTE,
3099 arg3: CK_ULONG,
3100 arg4: *mut CK_BYTE,
3101 arg5: *mut CK_ULONG,
3102 ) -> CK_RV,
3103>;
3104pub type CK_C_SignEncryptUpdate = ::std::option::Option<
3105 unsafe extern "C" fn(
3106 arg1: CK_SESSION_HANDLE,
3107 arg2: *mut CK_BYTE,
3108 arg3: CK_ULONG,
3109 arg4: *mut CK_BYTE,
3110 arg5: *mut CK_ULONG,
3111 ) -> CK_RV,
3112>;
3113pub type CK_C_DecryptVerifyUpdate = ::std::option::Option<
3114 unsafe extern "C" fn(
3115 arg1: CK_SESSION_HANDLE,
3116 arg2: *mut CK_BYTE,
3117 arg3: CK_ULONG,
3118 arg4: *mut CK_BYTE,
3119 arg5: *mut CK_ULONG,
3120 ) -> CK_RV,
3121>;
3122pub type CK_C_GenerateKey = ::std::option::Option<
3123 unsafe extern "C" fn(
3124 arg1: CK_SESSION_HANDLE,
3125 arg2: *mut CK_MECHANISM,
3126 arg3: *mut CK_ATTRIBUTE,
3127 arg4: CK_ULONG,
3128 arg5: *mut CK_OBJECT_HANDLE,
3129 ) -> CK_RV,
3130>;
3131pub type CK_C_GenerateKeyPair = ::std::option::Option<
3132 unsafe extern "C" fn(
3133 arg1: CK_SESSION_HANDLE,
3134 arg2: *mut CK_MECHANISM,
3135 arg3: *mut CK_ATTRIBUTE,
3136 arg4: CK_ULONG,
3137 arg5: *mut CK_ATTRIBUTE,
3138 arg6: CK_ULONG,
3139 arg7: *mut CK_OBJECT_HANDLE,
3140 arg8: *mut CK_OBJECT_HANDLE,
3141 ) -> CK_RV,
3142>;
3143pub type CK_C_WrapKey = ::std::option::Option<
3144 unsafe extern "C" fn(
3145 arg1: CK_SESSION_HANDLE,
3146 arg2: *mut CK_MECHANISM,
3147 arg3: CK_OBJECT_HANDLE,
3148 arg4: CK_OBJECT_HANDLE,
3149 arg5: *mut CK_BYTE,
3150 arg6: *mut CK_ULONG,
3151 ) -> CK_RV,
3152>;
3153pub type CK_C_UnwrapKey = ::std::option::Option<
3154 unsafe extern "C" fn(
3155 arg1: CK_SESSION_HANDLE,
3156 arg2: *mut CK_MECHANISM,
3157 arg3: CK_OBJECT_HANDLE,
3158 arg4: *mut CK_BYTE,
3159 arg5: CK_ULONG,
3160 arg6: *mut CK_ATTRIBUTE,
3161 arg7: CK_ULONG,
3162 arg8: *mut CK_OBJECT_HANDLE,
3163 ) -> CK_RV,
3164>;
3165pub type CK_C_DeriveKey = ::std::option::Option<
3166 unsafe extern "C" fn(
3167 arg1: CK_SESSION_HANDLE,
3168 arg2: *mut CK_MECHANISM,
3169 arg3: CK_OBJECT_HANDLE,
3170 arg4: *mut CK_ATTRIBUTE,
3171 arg5: CK_ULONG,
3172 arg6: *mut CK_OBJECT_HANDLE,
3173 ) -> CK_RV,
3174>;
3175pub type CK_C_SeedRandom = ::std::option::Option<
3176 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3177>;
3178pub type CK_C_GenerateRandom = ::std::option::Option<
3179 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3180>;
3181pub type CK_C_GetFunctionStatus =
3182 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
3183pub type CK_C_CancelFunction =
3184 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
3185pub type CK_C_WaitForSlotEvent = ::std::option::Option<
3186 unsafe extern "C" fn(
3187 arg1: CK_FLAGS,
3188 arg2: *mut CK_SLOT_ID,
3189 arg3: *mut ::std::os::raw::c_void,
3190 ) -> CK_RV,
3191>;
3192pub type CK_C_GetInterfaceList = ::std::option::Option<
3193 unsafe extern "C" fn(arg1: *mut CK_INTERFACE, arg2: *mut CK_ULONG) -> CK_RV,
3194>;
3195pub type CK_C_GetInterface = ::std::option::Option<
3196 unsafe extern "C" fn(
3197 arg1: *mut CK_UTF8CHAR,
3198 arg2: *mut CK_VERSION,
3199 arg3: *mut *mut CK_INTERFACE,
3200 arg4: CK_FLAGS,
3201 ) -> CK_RV,
3202>;
3203pub type CK_C_LoginUser = ::std::option::Option<
3204 unsafe extern "C" fn(
3205 arg1: CK_SESSION_HANDLE,
3206 arg2: CK_USER_TYPE,
3207 arg3: *mut CK_UTF8CHAR,
3208 arg4: CK_ULONG,
3209 arg5: *mut CK_UTF8CHAR,
3210 arg6: CK_ULONG,
3211 ) -> CK_RV,
3212>;
3213pub type CK_C_SessionCancel =
3214 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: CK_FLAGS) -> CK_RV>;
3215pub type CK_C_MessageEncryptInit = ::std::option::Option<
3216 unsafe extern "C" fn(
3217 arg1: CK_SESSION_HANDLE,
3218 arg2: *mut CK_MECHANISM,
3219 arg3: CK_OBJECT_HANDLE,
3220 ) -> CK_RV,
3221>;
3222pub type CK_C_EncryptMessage = ::std::option::Option<
3223 unsafe extern "C" fn(
3224 arg1: CK_SESSION_HANDLE,
3225 arg2: *mut ::std::os::raw::c_void,
3226 arg3: CK_ULONG,
3227 arg4: *mut CK_BYTE,
3228 arg5: CK_ULONG,
3229 arg6: *mut CK_BYTE,
3230 arg7: CK_ULONG,
3231 arg8: *mut CK_BYTE,
3232 arg9: *mut CK_ULONG,
3233 ) -> CK_RV,
3234>;
3235pub type CK_C_EncryptMessageBegin = ::std::option::Option<
3236 unsafe extern "C" fn(
3237 arg1: CK_SESSION_HANDLE,
3238 arg2: *mut ::std::os::raw::c_void,
3239 arg3: CK_ULONG,
3240 arg4: *mut CK_BYTE,
3241 arg5: CK_ULONG,
3242 ) -> CK_RV,
3243>;
3244pub type CK_C_EncryptMessageNext = ::std::option::Option<
3245 unsafe extern "C" fn(
3246 arg1: CK_SESSION_HANDLE,
3247 arg2: *mut ::std::os::raw::c_void,
3248 arg3: CK_ULONG,
3249 arg4: *mut CK_BYTE,
3250 arg5: CK_ULONG,
3251 arg6: *mut CK_BYTE,
3252 arg7: *mut CK_ULONG,
3253 arg8: CK_FLAGS,
3254 ) -> CK_RV,
3255>;
3256pub type CK_C_MessageEncryptFinal =
3257 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
3258pub type CK_C_MessageDecryptInit = ::std::option::Option<
3259 unsafe extern "C" fn(
3260 arg1: CK_SESSION_HANDLE,
3261 arg2: *mut CK_MECHANISM,
3262 arg3: CK_OBJECT_HANDLE,
3263 ) -> CK_RV,
3264>;
3265pub type CK_C_DecryptMessage = ::std::option::Option<
3266 unsafe extern "C" fn(
3267 arg1: CK_SESSION_HANDLE,
3268 arg2: *mut ::std::os::raw::c_void,
3269 arg3: CK_ULONG,
3270 arg4: *mut CK_BYTE,
3271 arg5: CK_ULONG,
3272 arg6: *mut CK_BYTE,
3273 arg7: CK_ULONG,
3274 arg8: *mut CK_BYTE,
3275 arg9: *mut CK_ULONG,
3276 ) -> CK_RV,
3277>;
3278pub type CK_C_DecryptMessageBegin = ::std::option::Option<
3279 unsafe extern "C" fn(
3280 arg1: CK_SESSION_HANDLE,
3281 arg2: *mut ::std::os::raw::c_void,
3282 arg3: CK_ULONG,
3283 arg4: *mut CK_BYTE,
3284 arg5: CK_ULONG,
3285 ) -> CK_RV,
3286>;
3287pub type CK_C_DecryptMessageNext = ::std::option::Option<
3288 unsafe extern "C" fn(
3289 arg1: CK_SESSION_HANDLE,
3290 arg2: *mut ::std::os::raw::c_void,
3291 arg3: CK_ULONG,
3292 arg4: *mut CK_BYTE,
3293 arg5: CK_ULONG,
3294 arg6: *mut CK_BYTE,
3295 arg7: *mut CK_ULONG,
3296 arg8: CK_FLAGS,
3297 ) -> CK_RV,
3298>;
3299pub type CK_C_MessageDecryptFinal =
3300 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
3301pub type CK_C_MessageSignInit = ::std::option::Option<
3302 unsafe extern "C" fn(
3303 arg1: CK_SESSION_HANDLE,
3304 arg2: *mut CK_MECHANISM,
3305 arg3: CK_OBJECT_HANDLE,
3306 ) -> CK_RV,
3307>;
3308pub type CK_C_SignMessage = ::std::option::Option<
3309 unsafe extern "C" fn(
3310 arg1: CK_SESSION_HANDLE,
3311 arg2: *mut ::std::os::raw::c_void,
3312 arg3: CK_ULONG,
3313 arg4: *mut CK_BYTE,
3314 arg5: CK_ULONG,
3315 arg6: *mut CK_BYTE,
3316 arg7: *mut CK_ULONG,
3317 ) -> CK_RV,
3318>;
3319pub type CK_C_SignMessageBegin = ::std::option::Option<
3320 unsafe extern "C" fn(
3321 arg1: CK_SESSION_HANDLE,
3322 arg2: *mut ::std::os::raw::c_void,
3323 arg3: CK_ULONG,
3324 ) -> CK_RV,
3325>;
3326pub type CK_C_SignMessageNext = ::std::option::Option<
3327 unsafe extern "C" fn(
3328 arg1: CK_SESSION_HANDLE,
3329 arg2: *mut ::std::os::raw::c_void,
3330 arg3: CK_ULONG,
3331 arg4: *mut CK_BYTE,
3332 arg5: CK_ULONG,
3333 arg6: *mut CK_BYTE,
3334 arg7: *mut CK_ULONG,
3335 ) -> CK_RV,
3336>;
3337pub type CK_C_MessageSignFinal =
3338 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
3339pub type CK_C_MessageVerifyInit = ::std::option::Option<
3340 unsafe extern "C" fn(
3341 arg1: CK_SESSION_HANDLE,
3342 arg2: *mut CK_MECHANISM,
3343 arg3: CK_OBJECT_HANDLE,
3344 ) -> CK_RV,
3345>;
3346pub type CK_C_VerifyMessage = ::std::option::Option<
3347 unsafe extern "C" fn(
3348 arg1: CK_SESSION_HANDLE,
3349 arg2: *mut ::std::os::raw::c_void,
3350 arg3: CK_ULONG,
3351 arg4: *mut CK_BYTE,
3352 arg5: CK_ULONG,
3353 arg6: *mut CK_BYTE,
3354 arg7: CK_ULONG,
3355 ) -> CK_RV,
3356>;
3357pub type CK_C_VerifyMessageBegin = ::std::option::Option<
3358 unsafe extern "C" fn(
3359 arg1: CK_SESSION_HANDLE,
3360 arg2: *mut ::std::os::raw::c_void,
3361 arg3: CK_ULONG,
3362 ) -> CK_RV,
3363>;
3364pub type CK_C_VerifyMessageNext = ::std::option::Option<
3365 unsafe extern "C" fn(
3366 arg1: CK_SESSION_HANDLE,
3367 arg2: *mut ::std::os::raw::c_void,
3368 arg3: CK_ULONG,
3369 arg4: *mut CK_BYTE,
3370 arg5: CK_ULONG,
3371 arg6: *mut CK_BYTE,
3372 arg7: CK_ULONG,
3373 ) -> CK_RV,
3374>;
3375pub type CK_C_MessageVerifyFinal =
3376 ::std::option::Option<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV>;
3377#[repr(C)]
3378#[cfg_attr(windows, repr(packed))]
3379#[derive(Debug, Default, Copy, Clone)]
3380pub struct CK_FUNCTION_LIST_3_0 {
3381 pub version: CK_VERSION,
3382 pub C_Initialize: CK_C_Initialize,
3383 pub C_Finalize: CK_C_Finalize,
3384 pub C_GetInfo: CK_C_GetInfo,
3385 pub C_GetFunctionList: CK_C_GetFunctionList,
3386 pub C_GetSlotList: CK_C_GetSlotList,
3387 pub C_GetSlotInfo: CK_C_GetSlotInfo,
3388 pub C_GetTokenInfo: CK_C_GetTokenInfo,
3389 pub C_GetMechanismList: CK_C_GetMechanismList,
3390 pub C_GetMechanismInfo: CK_C_GetMechanismInfo,
3391 pub C_InitToken: CK_C_InitToken,
3392 pub C_InitPIN: CK_C_InitPIN,
3393 pub C_SetPIN: CK_C_SetPIN,
3394 pub C_OpenSession: CK_C_OpenSession,
3395 pub C_CloseSession: CK_C_CloseSession,
3396 pub C_CloseAllSessions: CK_C_CloseAllSessions,
3397 pub C_GetSessionInfo: CK_C_GetSessionInfo,
3398 pub C_GetOperationState: CK_C_GetOperationState,
3399 pub C_SetOperationState: CK_C_SetOperationState,
3400 pub C_Login: CK_C_Login,
3401 pub C_Logout: CK_C_Logout,
3402 pub C_CreateObject: CK_C_CreateObject,
3403 pub C_CopyObject: CK_C_CopyObject,
3404 pub C_DestroyObject: CK_C_DestroyObject,
3405 pub C_GetObjectSize: CK_C_GetObjectSize,
3406 pub C_GetAttributeValue: CK_C_GetAttributeValue,
3407 pub C_SetAttributeValue: CK_C_SetAttributeValue,
3408 pub C_FindObjectsInit: CK_C_FindObjectsInit,
3409 pub C_FindObjects: CK_C_FindObjects,
3410 pub C_FindObjectsFinal: CK_C_FindObjectsFinal,
3411 pub C_EncryptInit: CK_C_EncryptInit,
3412 pub C_Encrypt: CK_C_Encrypt,
3413 pub C_EncryptUpdate: CK_C_EncryptUpdate,
3414 pub C_EncryptFinal: CK_C_EncryptFinal,
3415 pub C_DecryptInit: CK_C_DecryptInit,
3416 pub C_Decrypt: CK_C_Decrypt,
3417 pub C_DecryptUpdate: CK_C_DecryptUpdate,
3418 pub C_DecryptFinal: CK_C_DecryptFinal,
3419 pub C_DigestInit: CK_C_DigestInit,
3420 pub C_Digest: CK_C_Digest,
3421 pub C_DigestUpdate: CK_C_DigestUpdate,
3422 pub C_DigestKey: CK_C_DigestKey,
3423 pub C_DigestFinal: CK_C_DigestFinal,
3424 pub C_SignInit: CK_C_SignInit,
3425 pub C_Sign: CK_C_Sign,
3426 pub C_SignUpdate: CK_C_SignUpdate,
3427 pub C_SignFinal: CK_C_SignFinal,
3428 pub C_SignRecoverInit: CK_C_SignRecoverInit,
3429 pub C_SignRecover: CK_C_SignRecover,
3430 pub C_VerifyInit: CK_C_VerifyInit,
3431 pub C_Verify: CK_C_Verify,
3432 pub C_VerifyUpdate: CK_C_VerifyUpdate,
3433 pub C_VerifyFinal: CK_C_VerifyFinal,
3434 pub C_VerifyRecoverInit: CK_C_VerifyRecoverInit,
3435 pub C_VerifyRecover: CK_C_VerifyRecover,
3436 pub C_DigestEncryptUpdate: CK_C_DigestEncryptUpdate,
3437 pub C_DecryptDigestUpdate: CK_C_DecryptDigestUpdate,
3438 pub C_SignEncryptUpdate: CK_C_SignEncryptUpdate,
3439 pub C_DecryptVerifyUpdate: CK_C_DecryptVerifyUpdate,
3440 pub C_GenerateKey: CK_C_GenerateKey,
3441 pub C_GenerateKeyPair: CK_C_GenerateKeyPair,
3442 pub C_WrapKey: CK_C_WrapKey,
3443 pub C_UnwrapKey: CK_C_UnwrapKey,
3444 pub C_DeriveKey: CK_C_DeriveKey,
3445 pub C_SeedRandom: CK_C_SeedRandom,
3446 pub C_GenerateRandom: CK_C_GenerateRandom,
3447 pub C_GetFunctionStatus: CK_C_GetFunctionStatus,
3448 pub C_CancelFunction: CK_C_CancelFunction,
3449 pub C_WaitForSlotEvent: CK_C_WaitForSlotEvent,
3450 pub C_GetInterfaceList: CK_C_GetInterfaceList,
3451 pub C_GetInterface: CK_C_GetInterface,
3452 pub C_LoginUser: CK_C_LoginUser,
3453 pub C_SessionCancel: CK_C_SessionCancel,
3454 pub C_MessageEncryptInit: CK_C_MessageEncryptInit,
3455 pub C_EncryptMessage: CK_C_EncryptMessage,
3456 pub C_EncryptMessageBegin: CK_C_EncryptMessageBegin,
3457 pub C_EncryptMessageNext: CK_C_EncryptMessageNext,
3458 pub C_MessageEncryptFinal: CK_C_MessageEncryptFinal,
3459 pub C_MessageDecryptInit: CK_C_MessageDecryptInit,
3460 pub C_DecryptMessage: CK_C_DecryptMessage,
3461 pub C_DecryptMessageBegin: CK_C_DecryptMessageBegin,
3462 pub C_DecryptMessageNext: CK_C_DecryptMessageNext,
3463 pub C_MessageDecryptFinal: CK_C_MessageDecryptFinal,
3464 pub C_MessageSignInit: CK_C_MessageSignInit,
3465 pub C_SignMessage: CK_C_SignMessage,
3466 pub C_SignMessageBegin: CK_C_SignMessageBegin,
3467 pub C_SignMessageNext: CK_C_SignMessageNext,
3468 pub C_MessageSignFinal: CK_C_MessageSignFinal,
3469 pub C_MessageVerifyInit: CK_C_MessageVerifyInit,
3470 pub C_VerifyMessage: CK_C_VerifyMessage,
3471 pub C_VerifyMessageBegin: CK_C_VerifyMessageBegin,
3472 pub C_VerifyMessageNext: CK_C_VerifyMessageNext,
3473 pub C_MessageVerifyFinal: CK_C_MessageVerifyFinal,
3474}
3475#[repr(C)]
3476#[cfg_attr(windows, repr(packed))]
3477#[derive(Debug, Default, Copy, Clone)]
3478pub struct CK_FUNCTION_LIST {
3479 pub version: CK_VERSION,
3480 pub C_Initialize: CK_C_Initialize,
3481 pub C_Finalize: CK_C_Finalize,
3482 pub C_GetInfo: CK_C_GetInfo,
3483 pub C_GetFunctionList: CK_C_GetFunctionList,
3484 pub C_GetSlotList: CK_C_GetSlotList,
3485 pub C_GetSlotInfo: CK_C_GetSlotInfo,
3486 pub C_GetTokenInfo: CK_C_GetTokenInfo,
3487 pub C_GetMechanismList: CK_C_GetMechanismList,
3488 pub C_GetMechanismInfo: CK_C_GetMechanismInfo,
3489 pub C_InitToken: CK_C_InitToken,
3490 pub C_InitPIN: CK_C_InitPIN,
3491 pub C_SetPIN: CK_C_SetPIN,
3492 pub C_OpenSession: CK_C_OpenSession,
3493 pub C_CloseSession: CK_C_CloseSession,
3494 pub C_CloseAllSessions: CK_C_CloseAllSessions,
3495 pub C_GetSessionInfo: CK_C_GetSessionInfo,
3496 pub C_GetOperationState: CK_C_GetOperationState,
3497 pub C_SetOperationState: CK_C_SetOperationState,
3498 pub C_Login: CK_C_Login,
3499 pub C_Logout: CK_C_Logout,
3500 pub C_CreateObject: CK_C_CreateObject,
3501 pub C_CopyObject: CK_C_CopyObject,
3502 pub C_DestroyObject: CK_C_DestroyObject,
3503 pub C_GetObjectSize: CK_C_GetObjectSize,
3504 pub C_GetAttributeValue: CK_C_GetAttributeValue,
3505 pub C_SetAttributeValue: CK_C_SetAttributeValue,
3506 pub C_FindObjectsInit: CK_C_FindObjectsInit,
3507 pub C_FindObjects: CK_C_FindObjects,
3508 pub C_FindObjectsFinal: CK_C_FindObjectsFinal,
3509 pub C_EncryptInit: CK_C_EncryptInit,
3510 pub C_Encrypt: CK_C_Encrypt,
3511 pub C_EncryptUpdate: CK_C_EncryptUpdate,
3512 pub C_EncryptFinal: CK_C_EncryptFinal,
3513 pub C_DecryptInit: CK_C_DecryptInit,
3514 pub C_Decrypt: CK_C_Decrypt,
3515 pub C_DecryptUpdate: CK_C_DecryptUpdate,
3516 pub C_DecryptFinal: CK_C_DecryptFinal,
3517 pub C_DigestInit: CK_C_DigestInit,
3518 pub C_Digest: CK_C_Digest,
3519 pub C_DigestUpdate: CK_C_DigestUpdate,
3520 pub C_DigestKey: CK_C_DigestKey,
3521 pub C_DigestFinal: CK_C_DigestFinal,
3522 pub C_SignInit: CK_C_SignInit,
3523 pub C_Sign: CK_C_Sign,
3524 pub C_SignUpdate: CK_C_SignUpdate,
3525 pub C_SignFinal: CK_C_SignFinal,
3526 pub C_SignRecoverInit: CK_C_SignRecoverInit,
3527 pub C_SignRecover: CK_C_SignRecover,
3528 pub C_VerifyInit: CK_C_VerifyInit,
3529 pub C_Verify: CK_C_Verify,
3530 pub C_VerifyUpdate: CK_C_VerifyUpdate,
3531 pub C_VerifyFinal: CK_C_VerifyFinal,
3532 pub C_VerifyRecoverInit: CK_C_VerifyRecoverInit,
3533 pub C_VerifyRecover: CK_C_VerifyRecover,
3534 pub C_DigestEncryptUpdate: CK_C_DigestEncryptUpdate,
3535 pub C_DecryptDigestUpdate: CK_C_DecryptDigestUpdate,
3536 pub C_SignEncryptUpdate: CK_C_SignEncryptUpdate,
3537 pub C_DecryptVerifyUpdate: CK_C_DecryptVerifyUpdate,
3538 pub C_GenerateKey: CK_C_GenerateKey,
3539 pub C_GenerateKeyPair: CK_C_GenerateKeyPair,
3540 pub C_WrapKey: CK_C_WrapKey,
3541 pub C_UnwrapKey: CK_C_UnwrapKey,
3542 pub C_DeriveKey: CK_C_DeriveKey,
3543 pub C_SeedRandom: CK_C_SeedRandom,
3544 pub C_GenerateRandom: CK_C_GenerateRandom,
3545 pub C_GetFunctionStatus: CK_C_GetFunctionStatus,
3546 pub C_CancelFunction: CK_C_CancelFunction,
3547 pub C_WaitForSlotEvent: CK_C_WaitForSlotEvent,
3548}
3549pub struct Pkcs11 {
3550 __library: ::libloading::Library,
3551 pub C_Initialize: Result<
3552 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> CK_RV,
3553 ::libloading::Error,
3554 >,
3555 pub C_Finalize: Result<
3556 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> CK_RV,
3557 ::libloading::Error,
3558 >,
3559 pub C_GetInfo: Result<unsafe extern "C" fn(arg1: *mut CK_INFO) -> CK_RV, ::libloading::Error>,
3560 pub C_GetFunctionList: Result<
3561 unsafe extern "C" fn(arg1: *mut *mut CK_FUNCTION_LIST) -> CK_RV,
3562 ::libloading::Error,
3563 >,
3564 pub C_GetSlotList: Result<
3565 unsafe extern "C" fn(arg1: CK_BBOOL, arg2: *mut CK_SLOT_ID, arg3: *mut CK_ULONG) -> CK_RV,
3566 ::libloading::Error,
3567 >,
3568 pub C_GetSlotInfo: Result<
3569 unsafe extern "C" fn(arg1: CK_SLOT_ID, arg2: *mut CK_SLOT_INFO) -> CK_RV,
3570 ::libloading::Error,
3571 >,
3572 pub C_GetTokenInfo: Result<
3573 unsafe extern "C" fn(arg1: CK_SLOT_ID, arg2: *mut CK_TOKEN_INFO) -> CK_RV,
3574 ::libloading::Error,
3575 >,
3576 pub C_GetMechanismList: Result<
3577 unsafe extern "C" fn(
3578 arg1: CK_SLOT_ID,
3579 arg2: *mut CK_MECHANISM_TYPE,
3580 arg3: *mut CK_ULONG,
3581 ) -> CK_RV,
3582 ::libloading::Error,
3583 >,
3584 pub C_GetMechanismInfo: Result<
3585 unsafe extern "C" fn(
3586 arg1: CK_SLOT_ID,
3587 arg2: CK_MECHANISM_TYPE,
3588 arg3: *mut CK_MECHANISM_INFO,
3589 ) -> CK_RV,
3590 ::libloading::Error,
3591 >,
3592 pub C_InitToken: Result<
3593 unsafe extern "C" fn(
3594 arg1: CK_SLOT_ID,
3595 arg2: *mut CK_UTF8CHAR,
3596 arg3: CK_ULONG,
3597 arg4: *mut CK_UTF8CHAR,
3598 ) -> CK_RV,
3599 ::libloading::Error,
3600 >,
3601 pub C_InitPIN: Result<
3602 unsafe extern "C" fn(
3603 arg1: CK_SESSION_HANDLE,
3604 arg2: *mut CK_UTF8CHAR,
3605 arg3: CK_ULONG,
3606 ) -> CK_RV,
3607 ::libloading::Error,
3608 >,
3609 pub C_SetPIN: Result<
3610 unsafe extern "C" fn(
3611 arg1: CK_SESSION_HANDLE,
3612 arg2: *mut CK_UTF8CHAR,
3613 arg3: CK_ULONG,
3614 arg4: *mut CK_UTF8CHAR,
3615 arg5: CK_ULONG,
3616 ) -> CK_RV,
3617 ::libloading::Error,
3618 >,
3619 pub C_OpenSession: Result<
3620 unsafe extern "C" fn(
3621 arg1: CK_SLOT_ID,
3622 arg2: CK_FLAGS,
3623 arg3: *mut ::std::os::raw::c_void,
3624 arg4: CK_NOTIFY,
3625 arg5: *mut CK_SESSION_HANDLE,
3626 ) -> CK_RV,
3627 ::libloading::Error,
3628 >,
3629 pub C_CloseSession:
3630 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
3631 pub C_CloseAllSessions:
3632 Result<unsafe extern "C" fn(arg1: CK_SLOT_ID) -> CK_RV, ::libloading::Error>,
3633 pub C_GetSessionInfo: Result<
3634 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_SESSION_INFO) -> CK_RV,
3635 ::libloading::Error,
3636 >,
3637 pub C_GetOperationState: Result<
3638 unsafe extern "C" fn(
3639 arg1: CK_SESSION_HANDLE,
3640 arg2: *mut CK_BYTE,
3641 arg3: *mut CK_ULONG,
3642 ) -> CK_RV,
3643 ::libloading::Error,
3644 >,
3645 pub C_SetOperationState: Result<
3646 unsafe extern "C" fn(
3647 arg1: CK_SESSION_HANDLE,
3648 arg2: *mut CK_BYTE,
3649 arg3: CK_ULONG,
3650 arg4: CK_OBJECT_HANDLE,
3651 arg5: CK_OBJECT_HANDLE,
3652 ) -> CK_RV,
3653 ::libloading::Error,
3654 >,
3655 pub C_Login: Result<
3656 unsafe extern "C" fn(
3657 arg1: CK_SESSION_HANDLE,
3658 arg2: CK_USER_TYPE,
3659 arg3: *mut CK_UTF8CHAR,
3660 arg4: CK_ULONG,
3661 ) -> CK_RV,
3662 ::libloading::Error,
3663 >,
3664 pub C_Logout:
3665 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
3666 pub C_CreateObject: Result<
3667 unsafe extern "C" fn(
3668 arg1: CK_SESSION_HANDLE,
3669 arg2: *mut CK_ATTRIBUTE,
3670 arg3: CK_ULONG,
3671 arg4: *mut CK_OBJECT_HANDLE,
3672 ) -> CK_RV,
3673 ::libloading::Error,
3674 >,
3675 pub C_CopyObject: Result<
3676 unsafe extern "C" fn(
3677 arg1: CK_SESSION_HANDLE,
3678 arg2: CK_OBJECT_HANDLE,
3679 arg3: *mut CK_ATTRIBUTE,
3680 arg4: CK_ULONG,
3681 arg5: *mut CK_OBJECT_HANDLE,
3682 ) -> CK_RV,
3683 ::libloading::Error,
3684 >,
3685 pub C_DestroyObject: Result<
3686 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: CK_OBJECT_HANDLE) -> CK_RV,
3687 ::libloading::Error,
3688 >,
3689 pub C_GetObjectSize: Result<
3690 unsafe extern "C" fn(
3691 arg1: CK_SESSION_HANDLE,
3692 arg2: CK_OBJECT_HANDLE,
3693 arg3: *mut CK_ULONG,
3694 ) -> CK_RV,
3695 ::libloading::Error,
3696 >,
3697 pub C_GetAttributeValue: Result<
3698 unsafe extern "C" fn(
3699 arg1: CK_SESSION_HANDLE,
3700 arg2: CK_OBJECT_HANDLE,
3701 arg3: *mut CK_ATTRIBUTE,
3702 arg4: CK_ULONG,
3703 ) -> CK_RV,
3704 ::libloading::Error,
3705 >,
3706 pub C_SetAttributeValue: Result<
3707 unsafe extern "C" fn(
3708 arg1: CK_SESSION_HANDLE,
3709 arg2: CK_OBJECT_HANDLE,
3710 arg3: *mut CK_ATTRIBUTE,
3711 arg4: CK_ULONG,
3712 ) -> CK_RV,
3713 ::libloading::Error,
3714 >,
3715 pub C_FindObjectsInit: Result<
3716 unsafe extern "C" fn(
3717 arg1: CK_SESSION_HANDLE,
3718 arg2: *mut CK_ATTRIBUTE,
3719 arg3: CK_ULONG,
3720 ) -> CK_RV,
3721 ::libloading::Error,
3722 >,
3723 pub C_FindObjects: Result<
3724 unsafe extern "C" fn(
3725 arg1: CK_SESSION_HANDLE,
3726 arg2: *mut CK_OBJECT_HANDLE,
3727 arg3: CK_ULONG,
3728 arg4: *mut CK_ULONG,
3729 ) -> CK_RV,
3730 ::libloading::Error,
3731 >,
3732 pub C_FindObjectsFinal:
3733 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
3734 pub C_EncryptInit: Result<
3735 unsafe extern "C" fn(
3736 arg1: CK_SESSION_HANDLE,
3737 arg2: *mut CK_MECHANISM,
3738 arg3: CK_OBJECT_HANDLE,
3739 ) -> CK_RV,
3740 ::libloading::Error,
3741 >,
3742 pub C_Encrypt: Result<
3743 unsafe extern "C" fn(
3744 arg1: CK_SESSION_HANDLE,
3745 arg2: *mut CK_BYTE,
3746 arg3: CK_ULONG,
3747 arg4: *mut CK_BYTE,
3748 arg5: *mut CK_ULONG,
3749 ) -> CK_RV,
3750 ::libloading::Error,
3751 >,
3752 pub C_EncryptUpdate: Result<
3753 unsafe extern "C" fn(
3754 arg1: CK_SESSION_HANDLE,
3755 arg2: *mut CK_BYTE,
3756 arg3: CK_ULONG,
3757 arg4: *mut CK_BYTE,
3758 arg5: *mut CK_ULONG,
3759 ) -> CK_RV,
3760 ::libloading::Error,
3761 >,
3762 pub C_EncryptFinal: Result<
3763 unsafe extern "C" fn(
3764 arg1: CK_SESSION_HANDLE,
3765 arg2: *mut CK_BYTE,
3766 arg3: *mut CK_ULONG,
3767 ) -> CK_RV,
3768 ::libloading::Error,
3769 >,
3770 pub C_DecryptInit: Result<
3771 unsafe extern "C" fn(
3772 arg1: CK_SESSION_HANDLE,
3773 arg2: *mut CK_MECHANISM,
3774 arg3: CK_OBJECT_HANDLE,
3775 ) -> CK_RV,
3776 ::libloading::Error,
3777 >,
3778 pub C_Decrypt: Result<
3779 unsafe extern "C" fn(
3780 arg1: CK_SESSION_HANDLE,
3781 arg2: *mut CK_BYTE,
3782 arg3: CK_ULONG,
3783 arg4: *mut CK_BYTE,
3784 arg5: *mut CK_ULONG,
3785 ) -> CK_RV,
3786 ::libloading::Error,
3787 >,
3788 pub C_DecryptUpdate: Result<
3789 unsafe extern "C" fn(
3790 arg1: CK_SESSION_HANDLE,
3791 arg2: *mut CK_BYTE,
3792 arg3: CK_ULONG,
3793 arg4: *mut CK_BYTE,
3794 arg5: *mut CK_ULONG,
3795 ) -> CK_RV,
3796 ::libloading::Error,
3797 >,
3798 pub C_DecryptFinal: Result<
3799 unsafe extern "C" fn(
3800 arg1: CK_SESSION_HANDLE,
3801 arg2: *mut CK_BYTE,
3802 arg3: *mut CK_ULONG,
3803 ) -> CK_RV,
3804 ::libloading::Error,
3805 >,
3806 pub C_DigestInit: Result<
3807 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_MECHANISM) -> CK_RV,
3808 ::libloading::Error,
3809 >,
3810 pub C_Digest: Result<
3811 unsafe extern "C" fn(
3812 arg1: CK_SESSION_HANDLE,
3813 arg2: *mut CK_BYTE,
3814 arg3: CK_ULONG,
3815 arg4: *mut CK_BYTE,
3816 arg5: *mut CK_ULONG,
3817 ) -> CK_RV,
3818 ::libloading::Error,
3819 >,
3820 pub C_DigestUpdate: Result<
3821 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3822 ::libloading::Error,
3823 >,
3824 pub C_DigestKey: Result<
3825 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: CK_OBJECT_HANDLE) -> CK_RV,
3826 ::libloading::Error,
3827 >,
3828 pub C_DigestFinal: Result<
3829 unsafe extern "C" fn(
3830 arg1: CK_SESSION_HANDLE,
3831 arg2: *mut CK_BYTE,
3832 arg3: *mut CK_ULONG,
3833 ) -> CK_RV,
3834 ::libloading::Error,
3835 >,
3836 pub C_SignInit: Result<
3837 unsafe extern "C" fn(
3838 arg1: CK_SESSION_HANDLE,
3839 arg2: *mut CK_MECHANISM,
3840 arg3: CK_OBJECT_HANDLE,
3841 ) -> CK_RV,
3842 ::libloading::Error,
3843 >,
3844 pub C_Sign: Result<
3845 unsafe extern "C" fn(
3846 arg1: CK_SESSION_HANDLE,
3847 arg2: *mut CK_BYTE,
3848 arg3: CK_ULONG,
3849 arg4: *mut CK_BYTE,
3850 arg5: *mut CK_ULONG,
3851 ) -> CK_RV,
3852 ::libloading::Error,
3853 >,
3854 pub C_SignUpdate: Result<
3855 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3856 ::libloading::Error,
3857 >,
3858 pub C_SignFinal: Result<
3859 unsafe extern "C" fn(
3860 arg1: CK_SESSION_HANDLE,
3861 arg2: *mut CK_BYTE,
3862 arg3: *mut CK_ULONG,
3863 ) -> CK_RV,
3864 ::libloading::Error,
3865 >,
3866 pub C_SignRecoverInit: Result<
3867 unsafe extern "C" fn(
3868 arg1: CK_SESSION_HANDLE,
3869 arg2: *mut CK_MECHANISM,
3870 arg3: CK_OBJECT_HANDLE,
3871 ) -> CK_RV,
3872 ::libloading::Error,
3873 >,
3874 pub C_SignRecover: Result<
3875 unsafe extern "C" fn(
3876 arg1: CK_SESSION_HANDLE,
3877 arg2: *mut CK_BYTE,
3878 arg3: CK_ULONG,
3879 arg4: *mut CK_BYTE,
3880 arg5: *mut CK_ULONG,
3881 ) -> CK_RV,
3882 ::libloading::Error,
3883 >,
3884 pub C_VerifyInit: Result<
3885 unsafe extern "C" fn(
3886 arg1: CK_SESSION_HANDLE,
3887 arg2: *mut CK_MECHANISM,
3888 arg3: CK_OBJECT_HANDLE,
3889 ) -> CK_RV,
3890 ::libloading::Error,
3891 >,
3892 pub C_Verify: Result<
3893 unsafe extern "C" fn(
3894 arg1: CK_SESSION_HANDLE,
3895 arg2: *mut CK_BYTE,
3896 arg3: CK_ULONG,
3897 arg4: *mut CK_BYTE,
3898 arg5: CK_ULONG,
3899 ) -> CK_RV,
3900 ::libloading::Error,
3901 >,
3902 pub C_VerifyUpdate: Result<
3903 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3904 ::libloading::Error,
3905 >,
3906 pub C_VerifyFinal: Result<
3907 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
3908 ::libloading::Error,
3909 >,
3910 pub C_VerifyRecoverInit: Result<
3911 unsafe extern "C" fn(
3912 arg1: CK_SESSION_HANDLE,
3913 arg2: *mut CK_MECHANISM,
3914 arg3: CK_OBJECT_HANDLE,
3915 ) -> CK_RV,
3916 ::libloading::Error,
3917 >,
3918 pub C_VerifyRecover: Result<
3919 unsafe extern "C" fn(
3920 arg1: CK_SESSION_HANDLE,
3921 arg2: *mut CK_BYTE,
3922 arg3: CK_ULONG,
3923 arg4: *mut CK_BYTE,
3924 arg5: *mut CK_ULONG,
3925 ) -> CK_RV,
3926 ::libloading::Error,
3927 >,
3928 pub C_DigestEncryptUpdate: Result<
3929 unsafe extern "C" fn(
3930 arg1: CK_SESSION_HANDLE,
3931 arg2: *mut CK_BYTE,
3932 arg3: CK_ULONG,
3933 arg4: *mut CK_BYTE,
3934 arg5: *mut CK_ULONG,
3935 ) -> CK_RV,
3936 ::libloading::Error,
3937 >,
3938 pub C_DecryptDigestUpdate: Result<
3939 unsafe extern "C" fn(
3940 arg1: CK_SESSION_HANDLE,
3941 arg2: *mut CK_BYTE,
3942 arg3: CK_ULONG,
3943 arg4: *mut CK_BYTE,
3944 arg5: *mut CK_ULONG,
3945 ) -> CK_RV,
3946 ::libloading::Error,
3947 >,
3948 pub C_SignEncryptUpdate: Result<
3949 unsafe extern "C" fn(
3950 arg1: CK_SESSION_HANDLE,
3951 arg2: *mut CK_BYTE,
3952 arg3: CK_ULONG,
3953 arg4: *mut CK_BYTE,
3954 arg5: *mut CK_ULONG,
3955 ) -> CK_RV,
3956 ::libloading::Error,
3957 >,
3958 pub C_DecryptVerifyUpdate: Result<
3959 unsafe extern "C" fn(
3960 arg1: CK_SESSION_HANDLE,
3961 arg2: *mut CK_BYTE,
3962 arg3: CK_ULONG,
3963 arg4: *mut CK_BYTE,
3964 arg5: *mut CK_ULONG,
3965 ) -> CK_RV,
3966 ::libloading::Error,
3967 >,
3968 pub C_GenerateKey: Result<
3969 unsafe extern "C" fn(
3970 arg1: CK_SESSION_HANDLE,
3971 arg2: *mut CK_MECHANISM,
3972 arg3: *mut CK_ATTRIBUTE,
3973 arg4: CK_ULONG,
3974 arg5: *mut CK_OBJECT_HANDLE,
3975 ) -> CK_RV,
3976 ::libloading::Error,
3977 >,
3978 pub C_GenerateKeyPair: Result<
3979 unsafe extern "C" fn(
3980 arg1: CK_SESSION_HANDLE,
3981 arg2: *mut CK_MECHANISM,
3982 arg3: *mut CK_ATTRIBUTE,
3983 arg4: CK_ULONG,
3984 arg5: *mut CK_ATTRIBUTE,
3985 arg6: CK_ULONG,
3986 arg7: *mut CK_OBJECT_HANDLE,
3987 arg8: *mut CK_OBJECT_HANDLE,
3988 ) -> CK_RV,
3989 ::libloading::Error,
3990 >,
3991 pub C_WrapKey: Result<
3992 unsafe extern "C" fn(
3993 arg1: CK_SESSION_HANDLE,
3994 arg2: *mut CK_MECHANISM,
3995 arg3: CK_OBJECT_HANDLE,
3996 arg4: CK_OBJECT_HANDLE,
3997 arg5: *mut CK_BYTE,
3998 arg6: *mut CK_ULONG,
3999 ) -> CK_RV,
4000 ::libloading::Error,
4001 >,
4002 pub C_UnwrapKey: Result<
4003 unsafe extern "C" fn(
4004 arg1: CK_SESSION_HANDLE,
4005 arg2: *mut CK_MECHANISM,
4006 arg3: CK_OBJECT_HANDLE,
4007 arg4: *mut CK_BYTE,
4008 arg5: *mut CK_ULONG,
4009 arg6: *mut CK_ATTRIBUTE,
4010 arg7: CK_ULONG,
4011 arg8: *mut CK_OBJECT_HANDLE,
4012 ) -> CK_RV,
4013 ::libloading::Error,
4014 >,
4015 pub C_DeriveKey: Result<
4016 unsafe extern "C" fn(
4017 arg1: CK_SESSION_HANDLE,
4018 arg2: *mut CK_MECHANISM,
4019 arg3: CK_OBJECT_HANDLE,
4020 arg4: *mut CK_ATTRIBUTE,
4021 arg5: CK_ULONG,
4022 arg6: *mut CK_OBJECT_HANDLE,
4023 ) -> CK_RV,
4024 ::libloading::Error,
4025 >,
4026 pub C_SeedRandom: Result<
4027 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
4028 ::libloading::Error,
4029 >,
4030 pub C_GenerateRandom: Result<
4031 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: *mut CK_BYTE, arg3: CK_ULONG) -> CK_RV,
4032 ::libloading::Error,
4033 >,
4034 pub C_GetFunctionStatus:
4035 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
4036 pub C_CancelFunction:
4037 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
4038 pub C_WaitForSlotEvent: Result<
4039 unsafe extern "C" fn(
4040 arg1: CK_FLAGS,
4041 arg2: *mut CK_SLOT_ID,
4042 arg3: *mut ::std::os::raw::c_void,
4043 ) -> CK_RV,
4044 ::libloading::Error,
4045 >,
4046 pub C_GetInterfaceList: Result<
4047 unsafe extern "C" fn(arg1: *mut CK_INTERFACE, arg2: *mut CK_ULONG) -> CK_RV,
4048 ::libloading::Error,
4049 >,
4050 pub C_GetInterface: Result<
4051 unsafe extern "C" fn(
4052 arg1: *mut CK_UTF8CHAR,
4053 arg2: *mut CK_VERSION,
4054 arg3: *mut *mut CK_INTERFACE,
4055 arg4: CK_FLAGS,
4056 ) -> CK_RV,
4057 ::libloading::Error,
4058 >,
4059 pub C_LoginUser: Result<
4060 unsafe extern "C" fn(
4061 arg1: CK_SESSION_HANDLE,
4062 arg2: CK_USER_TYPE,
4063 arg3: *mut CK_UTF8CHAR,
4064 arg4: CK_ULONG,
4065 arg5: *mut CK_UTF8CHAR,
4066 arg6: CK_ULONG,
4067 ) -> CK_RV,
4068 ::libloading::Error,
4069 >,
4070 pub C_SessionCancel: Result<
4071 unsafe extern "C" fn(arg1: CK_SESSION_HANDLE, arg2: CK_FLAGS) -> CK_RV,
4072 ::libloading::Error,
4073 >,
4074 pub C_MessageEncryptInit: Result<
4075 unsafe extern "C" fn(
4076 arg1: CK_SESSION_HANDLE,
4077 arg2: *mut CK_MECHANISM,
4078 arg3: CK_OBJECT_HANDLE,
4079 ) -> CK_RV,
4080 ::libloading::Error,
4081 >,
4082 pub C_EncryptMessage: Result<
4083 unsafe extern "C" fn(
4084 arg1: CK_SESSION_HANDLE,
4085 arg2: *mut ::std::os::raw::c_void,
4086 arg3: CK_ULONG,
4087 arg4: *mut CK_BYTE,
4088 arg5: CK_ULONG,
4089 arg6: *mut CK_BYTE,
4090 arg7: CK_ULONG,
4091 arg8: *mut CK_BYTE,
4092 arg9: *mut CK_ULONG,
4093 ) -> CK_RV,
4094 ::libloading::Error,
4095 >,
4096 pub C_EncryptMessageBegin: Result<
4097 unsafe extern "C" fn(
4098 arg1: CK_SESSION_HANDLE,
4099 arg2: *mut ::std::os::raw::c_void,
4100 arg3: CK_ULONG,
4101 arg4: *mut CK_BYTE,
4102 arg5: CK_ULONG,
4103 ) -> CK_RV,
4104 ::libloading::Error,
4105 >,
4106 pub C_EncryptMessageNext: Result<
4107 unsafe extern "C" fn(
4108 arg1: CK_SESSION_HANDLE,
4109 arg2: *mut ::std::os::raw::c_void,
4110 arg3: CK_ULONG,
4111 arg4: *mut CK_BYTE,
4112 arg5: CK_ULONG,
4113 arg6: *mut CK_BYTE,
4114 arg7: *mut CK_ULONG,
4115 arg8: CK_FLAGS,
4116 ) -> CK_RV,
4117 ::libloading::Error,
4118 >,
4119 pub C_MessageEncryptFinal:
4120 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
4121 pub C_MessageDecryptInit: Result<
4122 unsafe extern "C" fn(
4123 arg1: CK_SESSION_HANDLE,
4124 arg2: *mut CK_MECHANISM,
4125 arg3: CK_OBJECT_HANDLE,
4126 ) -> CK_RV,
4127 ::libloading::Error,
4128 >,
4129 pub C_DecryptMessage: Result<
4130 unsafe extern "C" fn(
4131 arg1: CK_SESSION_HANDLE,
4132 arg2: *mut ::std::os::raw::c_void,
4133 arg3: CK_ULONG,
4134 arg4: *mut CK_BYTE,
4135 arg5: CK_ULONG,
4136 arg6: *mut CK_BYTE,
4137 arg7: CK_ULONG,
4138 arg8: *mut CK_BYTE,
4139 arg9: *mut CK_ULONG,
4140 ) -> CK_RV,
4141 ::libloading::Error,
4142 >,
4143 pub C_DecryptMessageBegin: Result<
4144 unsafe extern "C" fn(
4145 arg1: CK_SESSION_HANDLE,
4146 arg2: *mut ::std::os::raw::c_void,
4147 arg3: CK_ULONG,
4148 arg4: *mut CK_BYTE,
4149 arg5: CK_ULONG,
4150 ) -> CK_RV,
4151 ::libloading::Error,
4152 >,
4153 pub C_DecryptMessageNext: Result<
4154 unsafe extern "C" fn(
4155 arg1: CK_SESSION_HANDLE,
4156 arg2: *mut ::std::os::raw::c_void,
4157 arg3: CK_ULONG,
4158 arg4: *mut CK_BYTE,
4159 arg5: CK_ULONG,
4160 arg6: *mut CK_BYTE,
4161 arg7: *mut CK_ULONG,
4162 arg8: CK_FLAGS,
4163 ) -> CK_RV,
4164 ::libloading::Error,
4165 >,
4166 pub C_MessageDecryptFinal:
4167 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
4168 pub C_MessageSignInit: Result<
4169 unsafe extern "C" fn(
4170 arg1: CK_SESSION_HANDLE,
4171 arg2: *mut CK_MECHANISM,
4172 arg3: CK_OBJECT_HANDLE,
4173 ) -> CK_RV,
4174 ::libloading::Error,
4175 >,
4176 pub C_SignMessage: Result<
4177 unsafe extern "C" fn(
4178 arg1: CK_SESSION_HANDLE,
4179 arg2: *mut ::std::os::raw::c_void,
4180 arg3: CK_ULONG,
4181 arg4: *mut CK_BYTE,
4182 arg5: CK_ULONG,
4183 arg6: *mut CK_BYTE,
4184 arg7: *mut CK_ULONG,
4185 ) -> CK_RV,
4186 ::libloading::Error,
4187 >,
4188 pub C_SignMessageBegin: Result<
4189 unsafe extern "C" fn(
4190 arg1: CK_SESSION_HANDLE,
4191 arg2: *mut ::std::os::raw::c_void,
4192 arg3: CK_ULONG,
4193 ) -> CK_RV,
4194 ::libloading::Error,
4195 >,
4196 pub C_SignMessageNext: Result<
4197 unsafe extern "C" fn(
4198 arg1: CK_SESSION_HANDLE,
4199 arg2: *mut ::std::os::raw::c_void,
4200 arg3: CK_ULONG,
4201 arg4: *mut CK_BYTE,
4202 arg5: CK_ULONG,
4203 arg6: *mut CK_BYTE,
4204 arg7: *mut CK_ULONG,
4205 ) -> CK_RV,
4206 ::libloading::Error,
4207 >,
4208 pub C_MessageSignFinal:
4209 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
4210 pub C_MessageVerifyInit: Result<
4211 unsafe extern "C" fn(
4212 arg1: CK_SESSION_HANDLE,
4213 arg2: *mut CK_MECHANISM,
4214 arg3: CK_OBJECT_HANDLE,
4215 ) -> CK_RV,
4216 ::libloading::Error,
4217 >,
4218 pub C_VerifyMessage: Result<
4219 unsafe extern "C" fn(
4220 arg1: CK_SESSION_HANDLE,
4221 arg2: *mut ::std::os::raw::c_void,
4222 arg3: CK_ULONG,
4223 arg4: *mut CK_BYTE,
4224 arg5: CK_ULONG,
4225 arg6: *mut CK_BYTE,
4226 arg7: CK_ULONG,
4227 ) -> CK_RV,
4228 ::libloading::Error,
4229 >,
4230 pub C_VerifyMessageBegin: Result<
4231 unsafe extern "C" fn(
4232 arg1: CK_SESSION_HANDLE,
4233 arg2: *mut ::std::os::raw::c_void,
4234 arg3: CK_ULONG,
4235 ) -> CK_RV,
4236 ::libloading::Error,
4237 >,
4238 pub C_VerifyMessageNext: Result<
4239 unsafe extern "C" fn(
4240 arg1: CK_SESSION_HANDLE,
4241 arg2: *mut ::std::os::raw::c_void,
4242 arg3: CK_ULONG,
4243 arg4: *mut CK_BYTE,
4244 arg5: CK_ULONG,
4245 arg6: *mut CK_BYTE,
4246 arg7: CK_ULONG,
4247 ) -> CK_RV,
4248 ::libloading::Error,
4249 >,
4250 pub C_MessageVerifyFinal:
4251 Result<unsafe extern "C" fn(arg1: CK_SESSION_HANDLE) -> CK_RV, ::libloading::Error>,
4252}
4253impl Pkcs11 {
4254 pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
4255 where
4256 P: AsRef<::std::ffi::OsStr>,
4257 {
4258 let library = ::libloading::Library::new(path)?;
4259 Self::from_library(library)
4260 }
4261 pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
4262 where
4263 L: Into<::libloading::Library>,
4264 {
4265 let __library = library.into();
4266 let C_Initialize = __library.get(b"C_Initialize\0").map(|sym| *sym);
4267 let C_Finalize = __library.get(b"C_Finalize\0").map(|sym| *sym);
4268 let C_GetInfo = __library.get(b"C_GetInfo\0").map(|sym| *sym);
4269 let C_GetFunctionList = __library.get(b"C_GetFunctionList\0").map(|sym| *sym);
4270 let C_GetSlotList = __library.get(b"C_GetSlotList\0").map(|sym| *sym);
4271 let C_GetSlotInfo = __library.get(b"C_GetSlotInfo\0").map(|sym| *sym);
4272 let C_GetTokenInfo = __library.get(b"C_GetTokenInfo\0").map(|sym| *sym);
4273 let C_GetMechanismList = __library.get(b"C_GetMechanismList\0").map(|sym| *sym);
4274 let C_GetMechanismInfo = __library.get(b"C_GetMechanismInfo\0").map(|sym| *sym);
4275 let C_InitToken = __library.get(b"C_InitToken\0").map(|sym| *sym);
4276 let C_InitPIN = __library.get(b"C_InitPIN\0").map(|sym| *sym);
4277 let C_SetPIN = __library.get(b"C_SetPIN\0").map(|sym| *sym);
4278 let C_OpenSession = __library.get(b"C_OpenSession\0").map(|sym| *sym);
4279 let C_CloseSession = __library.get(b"C_CloseSession\0").map(|sym| *sym);
4280 let C_CloseAllSessions = __library.get(b"C_CloseAllSessions\0").map(|sym| *sym);
4281 let C_GetSessionInfo = __library.get(b"C_GetSessionInfo\0").map(|sym| *sym);
4282 let C_GetOperationState = __library.get(b"C_GetOperationState\0").map(|sym| *sym);
4283 let C_SetOperationState = __library.get(b"C_SetOperationState\0").map(|sym| *sym);
4284 let C_Login = __library.get(b"C_Login\0").map(|sym| *sym);
4285 let C_Logout = __library.get(b"C_Logout\0").map(|sym| *sym);
4286 let C_CreateObject = __library.get(b"C_CreateObject\0").map(|sym| *sym);
4287 let C_CopyObject = __library.get(b"C_CopyObject\0").map(|sym| *sym);
4288 let C_DestroyObject = __library.get(b"C_DestroyObject\0").map(|sym| *sym);
4289 let C_GetObjectSize = __library.get(b"C_GetObjectSize\0").map(|sym| *sym);
4290 let C_GetAttributeValue = __library.get(b"C_GetAttributeValue\0").map(|sym| *sym);
4291 let C_SetAttributeValue = __library.get(b"C_SetAttributeValue\0").map(|sym| *sym);
4292 let C_FindObjectsInit = __library.get(b"C_FindObjectsInit\0").map(|sym| *sym);
4293 let C_FindObjects = __library.get(b"C_FindObjects\0").map(|sym| *sym);
4294 let C_FindObjectsFinal = __library.get(b"C_FindObjectsFinal\0").map(|sym| *sym);
4295 let C_EncryptInit = __library.get(b"C_EncryptInit\0").map(|sym| *sym);
4296 let C_Encrypt = __library.get(b"C_Encrypt\0").map(|sym| *sym);
4297 let C_EncryptUpdate = __library.get(b"C_EncryptUpdate\0").map(|sym| *sym);
4298 let C_EncryptFinal = __library.get(b"C_EncryptFinal\0").map(|sym| *sym);
4299 let C_DecryptInit = __library.get(b"C_DecryptInit\0").map(|sym| *sym);
4300 let C_Decrypt = __library.get(b"C_Decrypt\0").map(|sym| *sym);
4301 let C_DecryptUpdate = __library.get(b"C_DecryptUpdate\0").map(|sym| *sym);
4302 let C_DecryptFinal = __library.get(b"C_DecryptFinal\0").map(|sym| *sym);
4303 let C_DigestInit = __library.get(b"C_DigestInit\0").map(|sym| *sym);
4304 let C_Digest = __library.get(b"C_Digest\0").map(|sym| *sym);
4305 let C_DigestUpdate = __library.get(b"C_DigestUpdate\0").map(|sym| *sym);
4306 let C_DigestKey = __library.get(b"C_DigestKey\0").map(|sym| *sym);
4307 let C_DigestFinal = __library.get(b"C_DigestFinal\0").map(|sym| *sym);
4308 let C_SignInit = __library.get(b"C_SignInit\0").map(|sym| *sym);
4309 let C_Sign = __library.get(b"C_Sign\0").map(|sym| *sym);
4310 let C_SignUpdate = __library.get(b"C_SignUpdate\0").map(|sym| *sym);
4311 let C_SignFinal = __library.get(b"C_SignFinal\0").map(|sym| *sym);
4312 let C_SignRecoverInit = __library.get(b"C_SignRecoverInit\0").map(|sym| *sym);
4313 let C_SignRecover = __library.get(b"C_SignRecover\0").map(|sym| *sym);
4314 let C_VerifyInit = __library.get(b"C_VerifyInit\0").map(|sym| *sym);
4315 let C_Verify = __library.get(b"C_Verify\0").map(|sym| *sym);
4316 let C_VerifyUpdate = __library.get(b"C_VerifyUpdate\0").map(|sym| *sym);
4317 let C_VerifyFinal = __library.get(b"C_VerifyFinal\0").map(|sym| *sym);
4318 let C_VerifyRecoverInit = __library.get(b"C_VerifyRecoverInit\0").map(|sym| *sym);
4319 let C_VerifyRecover = __library.get(b"C_VerifyRecover\0").map(|sym| *sym);
4320 let C_DigestEncryptUpdate = __library.get(b"C_DigestEncryptUpdate\0").map(|sym| *sym);
4321 let C_DecryptDigestUpdate = __library.get(b"C_DecryptDigestUpdate\0").map(|sym| *sym);
4322 let C_SignEncryptUpdate = __library.get(b"C_SignEncryptUpdate\0").map(|sym| *sym);
4323 let C_DecryptVerifyUpdate = __library.get(b"C_DecryptVerifyUpdate\0").map(|sym| *sym);
4324 let C_GenerateKey = __library.get(b"C_GenerateKey\0").map(|sym| *sym);
4325 let C_GenerateKeyPair = __library.get(b"C_GenerateKeyPair\0").map(|sym| *sym);
4326 let C_WrapKey = __library.get(b"C_WrapKey\0").map(|sym| *sym);
4327 let C_UnwrapKey = __library.get(b"C_UnwrapKey\0").map(|sym| *sym);
4328 let C_DeriveKey = __library.get(b"C_DeriveKey\0").map(|sym| *sym);
4329 let C_SeedRandom = __library.get(b"C_SeedRandom\0").map(|sym| *sym);
4330 let C_GenerateRandom = __library.get(b"C_GenerateRandom\0").map(|sym| *sym);
4331 let C_GetFunctionStatus = __library.get(b"C_GetFunctionStatus\0").map(|sym| *sym);
4332 let C_CancelFunction = __library.get(b"C_CancelFunction\0").map(|sym| *sym);
4333 let C_WaitForSlotEvent = __library.get(b"C_WaitForSlotEvent\0").map(|sym| *sym);
4334 let C_GetInterfaceList = __library.get(b"C_GetInterfaceList\0").map(|sym| *sym);
4335 let C_GetInterface = __library.get(b"C_GetInterface\0").map(|sym| *sym);
4336 let C_LoginUser = __library.get(b"C_LoginUser\0").map(|sym| *sym);
4337 let C_SessionCancel = __library.get(b"C_SessionCancel\0").map(|sym| *sym);
4338 let C_MessageEncryptInit = __library.get(b"C_MessageEncryptInit\0").map(|sym| *sym);
4339 let C_EncryptMessage = __library.get(b"C_EncryptMessage\0").map(|sym| *sym);
4340 let C_EncryptMessageBegin = __library.get(b"C_EncryptMessageBegin\0").map(|sym| *sym);
4341 let C_EncryptMessageNext = __library.get(b"C_EncryptMessageNext\0").map(|sym| *sym);
4342 let C_MessageEncryptFinal = __library.get(b"C_MessageEncryptFinal\0").map(|sym| *sym);
4343 let C_MessageDecryptInit = __library.get(b"C_MessageDecryptInit\0").map(|sym| *sym);
4344 let C_DecryptMessage = __library.get(b"C_DecryptMessage\0").map(|sym| *sym);
4345 let C_DecryptMessageBegin = __library.get(b"C_DecryptMessageBegin\0").map(|sym| *sym);
4346 let C_DecryptMessageNext = __library.get(b"C_DecryptMessageNext\0").map(|sym| *sym);
4347 let C_MessageDecryptFinal = __library.get(b"C_MessageDecryptFinal\0").map(|sym| *sym);
4348 let C_MessageSignInit = __library.get(b"C_MessageSignInit\0").map(|sym| *sym);
4349 let C_SignMessage = __library.get(b"C_SignMessage\0").map(|sym| *sym);
4350 let C_SignMessageBegin = __library.get(b"C_SignMessageBegin\0").map(|sym| *sym);
4351 let C_SignMessageNext = __library.get(b"C_SignMessageNext\0").map(|sym| *sym);
4352 let C_MessageSignFinal = __library.get(b"C_MessageSignFinal\0").map(|sym| *sym);
4353 let C_MessageVerifyInit = __library.get(b"C_MessageVerifyInit\0").map(|sym| *sym);
4354 let C_VerifyMessage = __library.get(b"C_VerifyMessage\0").map(|sym| *sym);
4355 let C_VerifyMessageBegin = __library.get(b"C_VerifyMessageBegin\0").map(|sym| *sym);
4356 let C_VerifyMessageNext = __library.get(b"C_VerifyMessageNext\0").map(|sym| *sym);
4357 let C_MessageVerifyFinal = __library.get(b"C_MessageVerifyFinal\0").map(|sym| *sym);
4358 Ok(Pkcs11 {
4359 __library,
4360 C_Initialize,
4361 C_Finalize,
4362 C_GetInfo,
4363 C_GetFunctionList,
4364 C_GetSlotList,
4365 C_GetSlotInfo,
4366 C_GetTokenInfo,
4367 C_GetMechanismList,
4368 C_GetMechanismInfo,
4369 C_InitToken,
4370 C_InitPIN,
4371 C_SetPIN,
4372 C_OpenSession,
4373 C_CloseSession,
4374 C_CloseAllSessions,
4375 C_GetSessionInfo,
4376 C_GetOperationState,
4377 C_SetOperationState,
4378 C_Login,
4379 C_Logout,
4380 C_CreateObject,
4381 C_CopyObject,
4382 C_DestroyObject,
4383 C_GetObjectSize,
4384 C_GetAttributeValue,
4385 C_SetAttributeValue,
4386 C_FindObjectsInit,
4387 C_FindObjects,
4388 C_FindObjectsFinal,
4389 C_EncryptInit,
4390 C_Encrypt,
4391 C_EncryptUpdate,
4392 C_EncryptFinal,
4393 C_DecryptInit,
4394 C_Decrypt,
4395 C_DecryptUpdate,
4396 C_DecryptFinal,
4397 C_DigestInit,
4398 C_Digest,
4399 C_DigestUpdate,
4400 C_DigestKey,
4401 C_DigestFinal,
4402 C_SignInit,
4403 C_Sign,
4404 C_SignUpdate,
4405 C_SignFinal,
4406 C_SignRecoverInit,
4407 C_SignRecover,
4408 C_VerifyInit,
4409 C_Verify,
4410 C_VerifyUpdate,
4411 C_VerifyFinal,
4412 C_VerifyRecoverInit,
4413 C_VerifyRecover,
4414 C_DigestEncryptUpdate,
4415 C_DecryptDigestUpdate,
4416 C_SignEncryptUpdate,
4417 C_DecryptVerifyUpdate,
4418 C_GenerateKey,
4419 C_GenerateKeyPair,
4420 C_WrapKey,
4421 C_UnwrapKey,
4422 C_DeriveKey,
4423 C_SeedRandom,
4424 C_GenerateRandom,
4425 C_GetFunctionStatus,
4426 C_CancelFunction,
4427 C_WaitForSlotEvent,
4428 C_GetInterfaceList,
4429 C_GetInterface,
4430 C_LoginUser,
4431 C_SessionCancel,
4432 C_MessageEncryptInit,
4433 C_EncryptMessage,
4434 C_EncryptMessageBegin,
4435 C_EncryptMessageNext,
4436 C_MessageEncryptFinal,
4437 C_MessageDecryptInit,
4438 C_DecryptMessage,
4439 C_DecryptMessageBegin,
4440 C_DecryptMessageNext,
4441 C_MessageDecryptFinal,
4442 C_MessageSignInit,
4443 C_SignMessage,
4444 C_SignMessageBegin,
4445 C_SignMessageNext,
4446 C_MessageSignFinal,
4447 C_MessageVerifyInit,
4448 C_VerifyMessage,
4449 C_VerifyMessageBegin,
4450 C_VerifyMessageNext,
4451 C_MessageVerifyFinal,
4452 })
4453 }
4454 pub unsafe fn C_Initialize(&self, arg1: *mut ::std::os::raw::c_void) -> CK_RV {
4455 (self
4456 .C_Initialize
4457 .as_ref()
4458 .expect("Expected function, got error."))(arg1)
4459 }
4460 pub unsafe fn C_Finalize(&self, arg1: *mut ::std::os::raw::c_void) -> CK_RV {
4461 (self
4462 .C_Finalize
4463 .as_ref()
4464 .expect("Expected function, got error."))(arg1)
4465 }
4466 pub unsafe fn C_GetInfo(&self, arg1: *mut CK_INFO) -> CK_RV {
4467 (self
4468 .C_GetInfo
4469 .as_ref()
4470 .expect("Expected function, got error."))(arg1)
4471 }
4472 pub unsafe fn C_GetFunctionList(&self, arg1: *mut *mut CK_FUNCTION_LIST) -> CK_RV {
4473 (self
4474 .C_GetFunctionList
4475 .as_ref()
4476 .expect("Expected function, got error."))(arg1)
4477 }
4478 pub unsafe fn C_GetSlotList(
4479 &self,
4480 arg1: CK_BBOOL,
4481 arg2: *mut CK_SLOT_ID,
4482 arg3: *mut CK_ULONG,
4483 ) -> CK_RV {
4484 (self
4485 .C_GetSlotList
4486 .as_ref()
4487 .expect("Expected function, got error."))(arg1, arg2, arg3)
4488 }
4489 pub unsafe fn C_GetSlotInfo(&self, arg1: CK_SLOT_ID, arg2: *mut CK_SLOT_INFO) -> CK_RV {
4490 (self
4491 .C_GetSlotInfo
4492 .as_ref()
4493 .expect("Expected function, got error."))(arg1, arg2)
4494 }
4495 pub unsafe fn C_GetTokenInfo(&self, arg1: CK_SLOT_ID, arg2: *mut CK_TOKEN_INFO) -> CK_RV {
4496 (self
4497 .C_GetTokenInfo
4498 .as_ref()
4499 .expect("Expected function, got error."))(arg1, arg2)
4500 }
4501 pub unsafe fn C_GetMechanismList(
4502 &self,
4503 arg1: CK_SLOT_ID,
4504 arg2: *mut CK_MECHANISM_TYPE,
4505 arg3: *mut CK_ULONG,
4506 ) -> CK_RV {
4507 (self
4508 .C_GetMechanismList
4509 .as_ref()
4510 .expect("Expected function, got error."))(arg1, arg2, arg3)
4511 }
4512 pub unsafe fn C_GetMechanismInfo(
4513 &self,
4514 arg1: CK_SLOT_ID,
4515 arg2: CK_MECHANISM_TYPE,
4516 arg3: *mut CK_MECHANISM_INFO,
4517 ) -> CK_RV {
4518 (self
4519 .C_GetMechanismInfo
4520 .as_ref()
4521 .expect("Expected function, got error."))(arg1, arg2, arg3)
4522 }
4523 pub unsafe fn C_InitToken(
4524 &self,
4525 arg1: CK_SLOT_ID,
4526 arg2: *mut CK_UTF8CHAR,
4527 arg3: CK_ULONG,
4528 arg4: *mut CK_UTF8CHAR,
4529 ) -> CK_RV {
4530 (self
4531 .C_InitToken
4532 .as_ref()
4533 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4)
4534 }
4535 pub unsafe fn C_InitPIN(
4536 &self,
4537 arg1: CK_SESSION_HANDLE,
4538 arg2: *mut CK_UTF8CHAR,
4539 arg3: CK_ULONG,
4540 ) -> CK_RV {
4541 (self
4542 .C_InitPIN
4543 .as_ref()
4544 .expect("Expected function, got error."))(arg1, arg2, arg3)
4545 }
4546 pub unsafe fn C_SetPIN(
4547 &self,
4548 arg1: CK_SESSION_HANDLE,
4549 arg2: *mut CK_UTF8CHAR,
4550 arg3: CK_ULONG,
4551 arg4: *mut CK_UTF8CHAR,
4552 arg5: CK_ULONG,
4553 ) -> CK_RV {
4554 (self
4555 .C_SetPIN
4556 .as_ref()
4557 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4558 }
4559 pub unsafe fn C_OpenSession(
4560 &self,
4561 arg1: CK_SLOT_ID,
4562 arg2: CK_FLAGS,
4563 arg3: *mut ::std::os::raw::c_void,
4564 arg4: CK_NOTIFY,
4565 arg5: *mut CK_SESSION_HANDLE,
4566 ) -> CK_RV {
4567 (self
4568 .C_OpenSession
4569 .as_ref()
4570 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4571 }
4572 pub unsafe fn C_CloseSession(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
4573 (self
4574 .C_CloseSession
4575 .as_ref()
4576 .expect("Expected function, got error."))(arg1)
4577 }
4578 pub unsafe fn C_CloseAllSessions(&self, arg1: CK_SLOT_ID) -> CK_RV {
4579 (self
4580 .C_CloseAllSessions
4581 .as_ref()
4582 .expect("Expected function, got error."))(arg1)
4583 }
4584 pub unsafe fn C_GetSessionInfo(
4585 &self,
4586 arg1: CK_SESSION_HANDLE,
4587 arg2: *mut CK_SESSION_INFO,
4588 ) -> CK_RV {
4589 (self
4590 .C_GetSessionInfo
4591 .as_ref()
4592 .expect("Expected function, got error."))(arg1, arg2)
4593 }
4594 pub unsafe fn C_GetOperationState(
4595 &self,
4596 arg1: CK_SESSION_HANDLE,
4597 arg2: *mut CK_BYTE,
4598 arg3: *mut CK_ULONG,
4599 ) -> CK_RV {
4600 (self
4601 .C_GetOperationState
4602 .as_ref()
4603 .expect("Expected function, got error."))(arg1, arg2, arg3)
4604 }
4605 pub unsafe fn C_SetOperationState(
4606 &self,
4607 arg1: CK_SESSION_HANDLE,
4608 arg2: *mut CK_BYTE,
4609 arg3: CK_ULONG,
4610 arg4: CK_OBJECT_HANDLE,
4611 arg5: CK_OBJECT_HANDLE,
4612 ) -> CK_RV {
4613 (self
4614 .C_SetOperationState
4615 .as_ref()
4616 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4617 }
4618 pub unsafe fn C_Login(
4619 &self,
4620 arg1: CK_SESSION_HANDLE,
4621 arg2: CK_USER_TYPE,
4622 arg3: *mut CK_UTF8CHAR,
4623 arg4: CK_ULONG,
4624 ) -> CK_RV {
4625 (self
4626 .C_Login
4627 .as_ref()
4628 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4)
4629 }
4630 pub unsafe fn C_Logout(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
4631 (self
4632 .C_Logout
4633 .as_ref()
4634 .expect("Expected function, got error."))(arg1)
4635 }
4636 pub unsafe fn C_CreateObject(
4637 &self,
4638 arg1: CK_SESSION_HANDLE,
4639 arg2: *mut CK_ATTRIBUTE,
4640 arg3: CK_ULONG,
4641 arg4: *mut CK_OBJECT_HANDLE,
4642 ) -> CK_RV {
4643 (self
4644 .C_CreateObject
4645 .as_ref()
4646 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4)
4647 }
4648 pub unsafe fn C_CopyObject(
4649 &self,
4650 arg1: CK_SESSION_HANDLE,
4651 arg2: CK_OBJECT_HANDLE,
4652 arg3: *mut CK_ATTRIBUTE,
4653 arg4: CK_ULONG,
4654 arg5: *mut CK_OBJECT_HANDLE,
4655 ) -> CK_RV {
4656 (self
4657 .C_CopyObject
4658 .as_ref()
4659 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4660 }
4661 pub unsafe fn C_DestroyObject(&self, arg1: CK_SESSION_HANDLE, arg2: CK_OBJECT_HANDLE) -> CK_RV {
4662 (self
4663 .C_DestroyObject
4664 .as_ref()
4665 .expect("Expected function, got error."))(arg1, arg2)
4666 }
4667 pub unsafe fn C_GetObjectSize(
4668 &self,
4669 arg1: CK_SESSION_HANDLE,
4670 arg2: CK_OBJECT_HANDLE,
4671 arg3: *mut CK_ULONG,
4672 ) -> CK_RV {
4673 (self
4674 .C_GetObjectSize
4675 .as_ref()
4676 .expect("Expected function, got error."))(arg1, arg2, arg3)
4677 }
4678 pub unsafe fn C_GetAttributeValue(
4679 &self,
4680 arg1: CK_SESSION_HANDLE,
4681 arg2: CK_OBJECT_HANDLE,
4682 arg3: *mut CK_ATTRIBUTE,
4683 arg4: CK_ULONG,
4684 ) -> CK_RV {
4685 (self
4686 .C_GetAttributeValue
4687 .as_ref()
4688 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4)
4689 }
4690 pub unsafe fn C_SetAttributeValue(
4691 &self,
4692 arg1: CK_SESSION_HANDLE,
4693 arg2: CK_OBJECT_HANDLE,
4694 arg3: *mut CK_ATTRIBUTE,
4695 arg4: CK_ULONG,
4696 ) -> CK_RV {
4697 (self
4698 .C_SetAttributeValue
4699 .as_ref()
4700 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4)
4701 }
4702 pub unsafe fn C_FindObjectsInit(
4703 &self,
4704 arg1: CK_SESSION_HANDLE,
4705 arg2: *mut CK_ATTRIBUTE,
4706 arg3: CK_ULONG,
4707 ) -> CK_RV {
4708 (self
4709 .C_FindObjectsInit
4710 .as_ref()
4711 .expect("Expected function, got error."))(arg1, arg2, arg3)
4712 }
4713 pub unsafe fn C_FindObjects(
4714 &self,
4715 arg1: CK_SESSION_HANDLE,
4716 arg2: *mut CK_OBJECT_HANDLE,
4717 arg3: CK_ULONG,
4718 arg4: *mut CK_ULONG,
4719 ) -> CK_RV {
4720 (self
4721 .C_FindObjects
4722 .as_ref()
4723 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4)
4724 }
4725 pub unsafe fn C_FindObjectsFinal(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
4726 (self
4727 .C_FindObjectsFinal
4728 .as_ref()
4729 .expect("Expected function, got error."))(arg1)
4730 }
4731 pub unsafe fn C_EncryptInit(
4732 &self,
4733 arg1: CK_SESSION_HANDLE,
4734 arg2: *mut CK_MECHANISM,
4735 arg3: CK_OBJECT_HANDLE,
4736 ) -> CK_RV {
4737 (self
4738 .C_EncryptInit
4739 .as_ref()
4740 .expect("Expected function, got error."))(arg1, arg2, arg3)
4741 }
4742 pub unsafe fn C_Encrypt(
4743 &self,
4744 arg1: CK_SESSION_HANDLE,
4745 arg2: *mut CK_BYTE,
4746 arg3: CK_ULONG,
4747 arg4: *mut CK_BYTE,
4748 arg5: *mut CK_ULONG,
4749 ) -> CK_RV {
4750 (self
4751 .C_Encrypt
4752 .as_ref()
4753 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4754 }
4755 pub unsafe fn C_EncryptUpdate(
4756 &self,
4757 arg1: CK_SESSION_HANDLE,
4758 arg2: *mut CK_BYTE,
4759 arg3: CK_ULONG,
4760 arg4: *mut CK_BYTE,
4761 arg5: *mut CK_ULONG,
4762 ) -> CK_RV {
4763 (self
4764 .C_EncryptUpdate
4765 .as_ref()
4766 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4767 }
4768 pub unsafe fn C_EncryptFinal(
4769 &self,
4770 arg1: CK_SESSION_HANDLE,
4771 arg2: *mut CK_BYTE,
4772 arg3: *mut CK_ULONG,
4773 ) -> CK_RV {
4774 (self
4775 .C_EncryptFinal
4776 .as_ref()
4777 .expect("Expected function, got error."))(arg1, arg2, arg3)
4778 }
4779 pub unsafe fn C_DecryptInit(
4780 &self,
4781 arg1: CK_SESSION_HANDLE,
4782 arg2: *mut CK_MECHANISM,
4783 arg3: CK_OBJECT_HANDLE,
4784 ) -> CK_RV {
4785 (self
4786 .C_DecryptInit
4787 .as_ref()
4788 .expect("Expected function, got error."))(arg1, arg2, arg3)
4789 }
4790 pub unsafe fn C_Decrypt(
4791 &self,
4792 arg1: CK_SESSION_HANDLE,
4793 arg2: *mut CK_BYTE,
4794 arg3: CK_ULONG,
4795 arg4: *mut CK_BYTE,
4796 arg5: *mut CK_ULONG,
4797 ) -> CK_RV {
4798 (self
4799 .C_Decrypt
4800 .as_ref()
4801 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4802 }
4803 pub unsafe fn C_DecryptUpdate(
4804 &self,
4805 arg1: CK_SESSION_HANDLE,
4806 arg2: *mut CK_BYTE,
4807 arg3: CK_ULONG,
4808 arg4: *mut CK_BYTE,
4809 arg5: *mut CK_ULONG,
4810 ) -> CK_RV {
4811 (self
4812 .C_DecryptUpdate
4813 .as_ref()
4814 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4815 }
4816 pub unsafe fn C_DecryptFinal(
4817 &self,
4818 arg1: CK_SESSION_HANDLE,
4819 arg2: *mut CK_BYTE,
4820 arg3: *mut CK_ULONG,
4821 ) -> CK_RV {
4822 (self
4823 .C_DecryptFinal
4824 .as_ref()
4825 .expect("Expected function, got error."))(arg1, arg2, arg3)
4826 }
4827 pub unsafe fn C_DigestInit(&self, arg1: CK_SESSION_HANDLE, arg2: *mut CK_MECHANISM) -> CK_RV {
4828 (self
4829 .C_DigestInit
4830 .as_ref()
4831 .expect("Expected function, got error."))(arg1, arg2)
4832 }
4833 pub unsafe fn C_Digest(
4834 &self,
4835 arg1: CK_SESSION_HANDLE,
4836 arg2: *mut CK_BYTE,
4837 arg3: CK_ULONG,
4838 arg4: *mut CK_BYTE,
4839 arg5: *mut CK_ULONG,
4840 ) -> CK_RV {
4841 (self
4842 .C_Digest
4843 .as_ref()
4844 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4845 }
4846 pub unsafe fn C_DigestUpdate(
4847 &self,
4848 arg1: CK_SESSION_HANDLE,
4849 arg2: *mut CK_BYTE,
4850 arg3: CK_ULONG,
4851 ) -> CK_RV {
4852 (self
4853 .C_DigestUpdate
4854 .as_ref()
4855 .expect("Expected function, got error."))(arg1, arg2, arg3)
4856 }
4857 pub unsafe fn C_DigestKey(&self, arg1: CK_SESSION_HANDLE, arg2: CK_OBJECT_HANDLE) -> CK_RV {
4858 (self
4859 .C_DigestKey
4860 .as_ref()
4861 .expect("Expected function, got error."))(arg1, arg2)
4862 }
4863 pub unsafe fn C_DigestFinal(
4864 &self,
4865 arg1: CK_SESSION_HANDLE,
4866 arg2: *mut CK_BYTE,
4867 arg3: *mut CK_ULONG,
4868 ) -> CK_RV {
4869 (self
4870 .C_DigestFinal
4871 .as_ref()
4872 .expect("Expected function, got error."))(arg1, arg2, arg3)
4873 }
4874 pub unsafe fn C_SignInit(
4875 &self,
4876 arg1: CK_SESSION_HANDLE,
4877 arg2: *mut CK_MECHANISM,
4878 arg3: CK_OBJECT_HANDLE,
4879 ) -> CK_RV {
4880 (self
4881 .C_SignInit
4882 .as_ref()
4883 .expect("Expected function, got error."))(arg1, arg2, arg3)
4884 }
4885 pub unsafe fn C_Sign(
4886 &self,
4887 arg1: CK_SESSION_HANDLE,
4888 arg2: *mut CK_BYTE,
4889 arg3: CK_ULONG,
4890 arg4: *mut CK_BYTE,
4891 arg5: *mut CK_ULONG,
4892 ) -> CK_RV {
4893 (self.C_Sign.as_ref().expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4894 }
4895 pub unsafe fn C_SignUpdate(
4896 &self,
4897 arg1: CK_SESSION_HANDLE,
4898 arg2: *mut CK_BYTE,
4899 arg3: CK_ULONG,
4900 ) -> CK_RV {
4901 (self
4902 .C_SignUpdate
4903 .as_ref()
4904 .expect("Expected function, got error."))(arg1, arg2, arg3)
4905 }
4906 pub unsafe fn C_SignFinal(
4907 &self,
4908 arg1: CK_SESSION_HANDLE,
4909 arg2: *mut CK_BYTE,
4910 arg3: *mut CK_ULONG,
4911 ) -> CK_RV {
4912 (self
4913 .C_SignFinal
4914 .as_ref()
4915 .expect("Expected function, got error."))(arg1, arg2, arg3)
4916 }
4917 pub unsafe fn C_SignRecoverInit(
4918 &self,
4919 arg1: CK_SESSION_HANDLE,
4920 arg2: *mut CK_MECHANISM,
4921 arg3: CK_OBJECT_HANDLE,
4922 ) -> CK_RV {
4923 (self
4924 .C_SignRecoverInit
4925 .as_ref()
4926 .expect("Expected function, got error."))(arg1, arg2, arg3)
4927 }
4928 pub unsafe fn C_SignRecover(
4929 &self,
4930 arg1: CK_SESSION_HANDLE,
4931 arg2: *mut CK_BYTE,
4932 arg3: CK_ULONG,
4933 arg4: *mut CK_BYTE,
4934 arg5: *mut CK_ULONG,
4935 ) -> CK_RV {
4936 (self
4937 .C_SignRecover
4938 .as_ref()
4939 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4940 }
4941 pub unsafe fn C_VerifyInit(
4942 &self,
4943 arg1: CK_SESSION_HANDLE,
4944 arg2: *mut CK_MECHANISM,
4945 arg3: CK_OBJECT_HANDLE,
4946 ) -> CK_RV {
4947 (self
4948 .C_VerifyInit
4949 .as_ref()
4950 .expect("Expected function, got error."))(arg1, arg2, arg3)
4951 }
4952 pub unsafe fn C_Verify(
4953 &self,
4954 arg1: CK_SESSION_HANDLE,
4955 arg2: *mut CK_BYTE,
4956 arg3: CK_ULONG,
4957 arg4: *mut CK_BYTE,
4958 arg5: CK_ULONG,
4959 ) -> CK_RV {
4960 (self
4961 .C_Verify
4962 .as_ref()
4963 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
4964 }
4965 pub unsafe fn C_VerifyUpdate(
4966 &self,
4967 arg1: CK_SESSION_HANDLE,
4968 arg2: *mut CK_BYTE,
4969 arg3: CK_ULONG,
4970 ) -> CK_RV {
4971 (self
4972 .C_VerifyUpdate
4973 .as_ref()
4974 .expect("Expected function, got error."))(arg1, arg2, arg3)
4975 }
4976 pub unsafe fn C_VerifyFinal(
4977 &self,
4978 arg1: CK_SESSION_HANDLE,
4979 arg2: *mut CK_BYTE,
4980 arg3: CK_ULONG,
4981 ) -> CK_RV {
4982 (self
4983 .C_VerifyFinal
4984 .as_ref()
4985 .expect("Expected function, got error."))(arg1, arg2, arg3)
4986 }
4987 pub unsafe fn C_VerifyRecoverInit(
4988 &self,
4989 arg1: CK_SESSION_HANDLE,
4990 arg2: *mut CK_MECHANISM,
4991 arg3: CK_OBJECT_HANDLE,
4992 ) -> CK_RV {
4993 (self
4994 .C_VerifyRecoverInit
4995 .as_ref()
4996 .expect("Expected function, got error."))(arg1, arg2, arg3)
4997 }
4998 pub unsafe fn C_VerifyRecover(
4999 &self,
5000 arg1: CK_SESSION_HANDLE,
5001 arg2: *mut CK_BYTE,
5002 arg3: CK_ULONG,
5003 arg4: *mut CK_BYTE,
5004 arg5: *mut CK_ULONG,
5005 ) -> CK_RV {
5006 (self
5007 .C_VerifyRecover
5008 .as_ref()
5009 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
5010 }
5011 pub unsafe fn C_DigestEncryptUpdate(
5012 &self,
5013 arg1: CK_SESSION_HANDLE,
5014 arg2: *mut CK_BYTE,
5015 arg3: CK_ULONG,
5016 arg4: *mut CK_BYTE,
5017 arg5: *mut CK_ULONG,
5018 ) -> CK_RV {
5019 (self
5020 .C_DigestEncryptUpdate
5021 .as_ref()
5022 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
5023 }
5024 pub unsafe fn C_DecryptDigestUpdate(
5025 &self,
5026 arg1: CK_SESSION_HANDLE,
5027 arg2: *mut CK_BYTE,
5028 arg3: CK_ULONG,
5029 arg4: *mut CK_BYTE,
5030 arg5: *mut CK_ULONG,
5031 ) -> CK_RV {
5032 (self
5033 .C_DecryptDigestUpdate
5034 .as_ref()
5035 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
5036 }
5037 pub unsafe fn C_SignEncryptUpdate(
5038 &self,
5039 arg1: CK_SESSION_HANDLE,
5040 arg2: *mut CK_BYTE,
5041 arg3: CK_ULONG,
5042 arg4: *mut CK_BYTE,
5043 arg5: *mut CK_ULONG,
5044 ) -> CK_RV {
5045 (self
5046 .C_SignEncryptUpdate
5047 .as_ref()
5048 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
5049 }
5050 pub unsafe fn C_DecryptVerifyUpdate(
5051 &self,
5052 arg1: CK_SESSION_HANDLE,
5053 arg2: *mut CK_BYTE,
5054 arg3: CK_ULONG,
5055 arg4: *mut CK_BYTE,
5056 arg5: *mut CK_ULONG,
5057 ) -> CK_RV {
5058 (self
5059 .C_DecryptVerifyUpdate
5060 .as_ref()
5061 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
5062 }
5063 pub unsafe fn C_GenerateKey(
5064 &self,
5065 arg1: CK_SESSION_HANDLE,
5066 arg2: *mut CK_MECHANISM,
5067 arg3: *mut CK_ATTRIBUTE,
5068 arg4: CK_ULONG,
5069 arg5: *mut CK_OBJECT_HANDLE,
5070 ) -> CK_RV {
5071 (self
5072 .C_GenerateKey
5073 .as_ref()
5074 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
5075 }
5076 pub unsafe fn C_GenerateKeyPair(
5077 &self,
5078 arg1: CK_SESSION_HANDLE,
5079 arg2: *mut CK_MECHANISM,
5080 arg3: *mut CK_ATTRIBUTE,
5081 arg4: CK_ULONG,
5082 arg5: *mut CK_ATTRIBUTE,
5083 arg6: CK_ULONG,
5084 arg7: *mut CK_OBJECT_HANDLE,
5085 arg8: *mut CK_OBJECT_HANDLE,
5086 ) -> CK_RV {
5087 (self
5088 .C_GenerateKeyPair
5089 .as_ref()
5090 .expect("Expected function, got error."))(
5091 arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
5092 )
5093 }
5094 pub unsafe fn C_WrapKey(
5095 &self,
5096 arg1: CK_SESSION_HANDLE,
5097 arg2: *mut CK_MECHANISM,
5098 arg3: CK_OBJECT_HANDLE,
5099 arg4: CK_OBJECT_HANDLE,
5100 arg5: *mut CK_BYTE,
5101 arg6: *mut CK_ULONG,
5102 ) -> CK_RV {
5103 (self
5104 .C_WrapKey
5105 .as_ref()
5106 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5, arg6)
5107 }
5108 pub unsafe fn C_UnwrapKey(
5109 &self,
5110 arg1: CK_SESSION_HANDLE,
5111 arg2: *mut CK_MECHANISM,
5112 arg3: CK_OBJECT_HANDLE,
5113 arg4: *mut CK_BYTE,
5114 arg5: *mut CK_ULONG,
5115 arg6: *mut CK_ATTRIBUTE,
5116 arg7: CK_ULONG,
5117 arg8: *mut CK_OBJECT_HANDLE,
5118 ) -> CK_RV {
5119 (self
5120 .C_UnwrapKey
5121 .as_ref()
5122 .expect("Expected function, got error."))(
5123 arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
5124 )
5125 }
5126 pub unsafe fn C_DeriveKey(
5127 &self,
5128 arg1: CK_SESSION_HANDLE,
5129 arg2: *mut CK_MECHANISM,
5130 arg3: CK_OBJECT_HANDLE,
5131 arg4: *mut CK_ATTRIBUTE,
5132 arg5: CK_ULONG,
5133 arg6: *mut CK_OBJECT_HANDLE,
5134 ) -> CK_RV {
5135 (self
5136 .C_DeriveKey
5137 .as_ref()
5138 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5, arg6)
5139 }
5140 pub unsafe fn C_SeedRandom(
5141 &self,
5142 arg1: CK_SESSION_HANDLE,
5143 arg2: *mut CK_BYTE,
5144 arg3: CK_ULONG,
5145 ) -> CK_RV {
5146 (self
5147 .C_SeedRandom
5148 .as_ref()
5149 .expect("Expected function, got error."))(arg1, arg2, arg3)
5150 }
5151 pub unsafe fn C_GenerateRandom(
5152 &self,
5153 arg1: CK_SESSION_HANDLE,
5154 arg2: *mut CK_BYTE,
5155 arg3: CK_ULONG,
5156 ) -> CK_RV {
5157 (self
5158 .C_GenerateRandom
5159 .as_ref()
5160 .expect("Expected function, got error."))(arg1, arg2, arg3)
5161 }
5162 pub unsafe fn C_GetFunctionStatus(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
5163 (self
5164 .C_GetFunctionStatus
5165 .as_ref()
5166 .expect("Expected function, got error."))(arg1)
5167 }
5168 pub unsafe fn C_CancelFunction(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
5169 (self
5170 .C_CancelFunction
5171 .as_ref()
5172 .expect("Expected function, got error."))(arg1)
5173 }
5174 pub unsafe fn C_WaitForSlotEvent(
5175 &self,
5176 arg1: CK_FLAGS,
5177 arg2: *mut CK_SLOT_ID,
5178 arg3: *mut ::std::os::raw::c_void,
5179 ) -> CK_RV {
5180 (self
5181 .C_WaitForSlotEvent
5182 .as_ref()
5183 .expect("Expected function, got error."))(arg1, arg2, arg3)
5184 }
5185 pub unsafe fn C_GetInterfaceList(&self, arg1: *mut CK_INTERFACE, arg2: *mut CK_ULONG) -> CK_RV {
5186 (self
5187 .C_GetInterfaceList
5188 .as_ref()
5189 .expect("Expected function, got error."))(arg1, arg2)
5190 }
5191 pub unsafe fn C_GetInterface(
5192 &self,
5193 arg1: *mut CK_UTF8CHAR,
5194 arg2: *mut CK_VERSION,
5195 arg3: *mut *mut CK_INTERFACE,
5196 arg4: CK_FLAGS,
5197 ) -> CK_RV {
5198 (self
5199 .C_GetInterface
5200 .as_ref()
5201 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4)
5202 }
5203 pub unsafe fn C_LoginUser(
5204 &self,
5205 arg1: CK_SESSION_HANDLE,
5206 arg2: CK_USER_TYPE,
5207 arg3: *mut CK_UTF8CHAR,
5208 arg4: CK_ULONG,
5209 arg5: *mut CK_UTF8CHAR,
5210 arg6: CK_ULONG,
5211 ) -> CK_RV {
5212 (self
5213 .C_LoginUser
5214 .as_ref()
5215 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5, arg6)
5216 }
5217 pub unsafe fn C_SessionCancel(&self, arg1: CK_SESSION_HANDLE, arg2: CK_FLAGS) -> CK_RV {
5218 (self
5219 .C_SessionCancel
5220 .as_ref()
5221 .expect("Expected function, got error."))(arg1, arg2)
5222 }
5223 pub unsafe fn C_MessageEncryptInit(
5224 &self,
5225 arg1: CK_SESSION_HANDLE,
5226 arg2: *mut CK_MECHANISM,
5227 arg3: CK_OBJECT_HANDLE,
5228 ) -> CK_RV {
5229 (self
5230 .C_MessageEncryptInit
5231 .as_ref()
5232 .expect("Expected function, got error."))(arg1, arg2, arg3)
5233 }
5234 pub unsafe fn C_EncryptMessage(
5235 &self,
5236 arg1: CK_SESSION_HANDLE,
5237 arg2: *mut ::std::os::raw::c_void,
5238 arg3: CK_ULONG,
5239 arg4: *mut CK_BYTE,
5240 arg5: CK_ULONG,
5241 arg6: *mut CK_BYTE,
5242 arg7: CK_ULONG,
5243 arg8: *mut CK_BYTE,
5244 arg9: *mut CK_ULONG,
5245 ) -> CK_RV {
5246 (self
5247 .C_EncryptMessage
5248 .as_ref()
5249 .expect("Expected function, got error."))(
5250 arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
5251 )
5252 }
5253 pub unsafe fn C_EncryptMessageBegin(
5254 &self,
5255 arg1: CK_SESSION_HANDLE,
5256 arg2: *mut ::std::os::raw::c_void,
5257 arg3: CK_ULONG,
5258 arg4: *mut CK_BYTE,
5259 arg5: CK_ULONG,
5260 ) -> CK_RV {
5261 (self
5262 .C_EncryptMessageBegin
5263 .as_ref()
5264 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
5265 }
5266 pub unsafe fn C_EncryptMessageNext(
5267 &self,
5268 arg1: CK_SESSION_HANDLE,
5269 arg2: *mut ::std::os::raw::c_void,
5270 arg3: CK_ULONG,
5271 arg4: *mut CK_BYTE,
5272 arg5: CK_ULONG,
5273 arg6: *mut CK_BYTE,
5274 arg7: *mut CK_ULONG,
5275 arg8: CK_FLAGS,
5276 ) -> CK_RV {
5277 (self
5278 .C_EncryptMessageNext
5279 .as_ref()
5280 .expect("Expected function, got error."))(
5281 arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
5282 )
5283 }
5284 pub unsafe fn C_MessageEncryptFinal(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
5285 (self
5286 .C_MessageEncryptFinal
5287 .as_ref()
5288 .expect("Expected function, got error."))(arg1)
5289 }
5290 pub unsafe fn C_MessageDecryptInit(
5291 &self,
5292 arg1: CK_SESSION_HANDLE,
5293 arg2: *mut CK_MECHANISM,
5294 arg3: CK_OBJECT_HANDLE,
5295 ) -> CK_RV {
5296 (self
5297 .C_MessageDecryptInit
5298 .as_ref()
5299 .expect("Expected function, got error."))(arg1, arg2, arg3)
5300 }
5301 pub unsafe fn C_DecryptMessage(
5302 &self,
5303 arg1: CK_SESSION_HANDLE,
5304 arg2: *mut ::std::os::raw::c_void,
5305 arg3: CK_ULONG,
5306 arg4: *mut CK_BYTE,
5307 arg5: CK_ULONG,
5308 arg6: *mut CK_BYTE,
5309 arg7: CK_ULONG,
5310 arg8: *mut CK_BYTE,
5311 arg9: *mut CK_ULONG,
5312 ) -> CK_RV {
5313 (self
5314 .C_DecryptMessage
5315 .as_ref()
5316 .expect("Expected function, got error."))(
5317 arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
5318 )
5319 }
5320 pub unsafe fn C_DecryptMessageBegin(
5321 &self,
5322 arg1: CK_SESSION_HANDLE,
5323 arg2: *mut ::std::os::raw::c_void,
5324 arg3: CK_ULONG,
5325 arg4: *mut CK_BYTE,
5326 arg5: CK_ULONG,
5327 ) -> CK_RV {
5328 (self
5329 .C_DecryptMessageBegin
5330 .as_ref()
5331 .expect("Expected function, got error."))(arg1, arg2, arg3, arg4, arg5)
5332 }
5333 pub unsafe fn C_DecryptMessageNext(
5334 &self,
5335 arg1: CK_SESSION_HANDLE,
5336 arg2: *mut ::std::os::raw::c_void,
5337 arg3: CK_ULONG,
5338 arg4: *mut CK_BYTE,
5339 arg5: CK_ULONG,
5340 arg6: *mut CK_BYTE,
5341 arg7: *mut CK_ULONG,
5342 arg8: CK_FLAGS,
5343 ) -> CK_RV {
5344 (self
5345 .C_DecryptMessageNext
5346 .as_ref()
5347 .expect("Expected function, got error."))(
5348 arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
5349 )
5350 }
5351 pub unsafe fn C_MessageDecryptFinal(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
5352 (self
5353 .C_MessageDecryptFinal
5354 .as_ref()
5355 .expect("Expected function, got error."))(arg1)
5356 }
5357 pub unsafe fn C_MessageSignInit(
5358 &self,
5359 arg1: CK_SESSION_HANDLE,
5360 arg2: *mut CK_MECHANISM,
5361 arg3: CK_OBJECT_HANDLE,
5362 ) -> CK_RV {
5363 (self
5364 .C_MessageSignInit
5365 .as_ref()
5366 .expect("Expected function, got error."))(arg1, arg2, arg3)
5367 }
5368 pub unsafe fn C_SignMessage(
5369 &self,
5370 arg1: CK_SESSION_HANDLE,
5371 arg2: *mut ::std::os::raw::c_void,
5372 arg3: CK_ULONG,
5373 arg4: *mut CK_BYTE,
5374 arg5: CK_ULONG,
5375 arg6: *mut CK_BYTE,
5376 arg7: *mut CK_ULONG,
5377 ) -> CK_RV {
5378 (self
5379 .C_SignMessage
5380 .as_ref()
5381 .expect("Expected function, got error."))(
5382 arg1, arg2, arg3, arg4, arg5, arg6, arg7
5383 )
5384 }
5385 pub unsafe fn C_SignMessageBegin(
5386 &self,
5387 arg1: CK_SESSION_HANDLE,
5388 arg2: *mut ::std::os::raw::c_void,
5389 arg3: CK_ULONG,
5390 ) -> CK_RV {
5391 (self
5392 .C_SignMessageBegin
5393 .as_ref()
5394 .expect("Expected function, got error."))(arg1, arg2, arg3)
5395 }
5396 pub unsafe fn C_SignMessageNext(
5397 &self,
5398 arg1: CK_SESSION_HANDLE,
5399 arg2: *mut ::std::os::raw::c_void,
5400 arg3: CK_ULONG,
5401 arg4: *mut CK_BYTE,
5402 arg5: CK_ULONG,
5403 arg6: *mut CK_BYTE,
5404 arg7: *mut CK_ULONG,
5405 ) -> CK_RV {
5406 (self
5407 .C_SignMessageNext
5408 .as_ref()
5409 .expect("Expected function, got error."))(
5410 arg1, arg2, arg3, arg4, arg5, arg6, arg7
5411 )
5412 }
5413 pub unsafe fn C_MessageSignFinal(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
5414 (self
5415 .C_MessageSignFinal
5416 .as_ref()
5417 .expect("Expected function, got error."))(arg1)
5418 }
5419 pub unsafe fn C_MessageVerifyInit(
5420 &self,
5421 arg1: CK_SESSION_HANDLE,
5422 arg2: *mut CK_MECHANISM,
5423 arg3: CK_OBJECT_HANDLE,
5424 ) -> CK_RV {
5425 (self
5426 .C_MessageVerifyInit
5427 .as_ref()
5428 .expect("Expected function, got error."))(arg1, arg2, arg3)
5429 }
5430 pub unsafe fn C_VerifyMessage(
5431 &self,
5432 arg1: CK_SESSION_HANDLE,
5433 arg2: *mut ::std::os::raw::c_void,
5434 arg3: CK_ULONG,
5435 arg4: *mut CK_BYTE,
5436 arg5: CK_ULONG,
5437 arg6: *mut CK_BYTE,
5438 arg7: CK_ULONG,
5439 ) -> CK_RV {
5440 (self
5441 .C_VerifyMessage
5442 .as_ref()
5443 .expect("Expected function, got error."))(
5444 arg1, arg2, arg3, arg4, arg5, arg6, arg7
5445 )
5446 }
5447 pub unsafe fn C_VerifyMessageBegin(
5448 &self,
5449 arg1: CK_SESSION_HANDLE,
5450 arg2: *mut ::std::os::raw::c_void,
5451 arg3: CK_ULONG,
5452 ) -> CK_RV {
5453 (self
5454 .C_VerifyMessageBegin
5455 .as_ref()
5456 .expect("Expected function, got error."))(arg1, arg2, arg3)
5457 }
5458 pub unsafe fn C_VerifyMessageNext(
5459 &self,
5460 arg1: CK_SESSION_HANDLE,
5461 arg2: *mut ::std::os::raw::c_void,
5462 arg3: CK_ULONG,
5463 arg4: *mut CK_BYTE,
5464 arg5: CK_ULONG,
5465 arg6: *mut CK_BYTE,
5466 arg7: CK_ULONG,
5467 ) -> CK_RV {
5468 (self
5469 .C_VerifyMessageNext
5470 .as_ref()
5471 .expect("Expected function, got error."))(
5472 arg1, arg2, arg3, arg4, arg5, arg6, arg7
5473 )
5474 }
5475 pub unsafe fn C_MessageVerifyFinal(&self, arg1: CK_SESSION_HANDLE) -> CK_RV {
5476 (self
5477 .C_MessageVerifyFinal
5478 .as_ref()
5479 .expect("Expected function, got error."))(arg1)
5480 }
5481}