1 // Copyright 2017 Marcus Heese 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 #![allow(non_camel_case_types, non_snake_case)] 15 16 // Cryptoki's packed structs interfere with the Clone trait, so we implement Copy and use this 17 macro_rules! packed_clone { 18 ($name:ty) => ( 19 impl Clone for $name { fn clone(&self) -> $name { *self } } 20 ) 21 } 22 23 // packed structs only needed on Windows, pkcs11.h mentions 24 macro_rules! cryptoki_aligned { 25 ($decl:item) => { 26 #[cfg(windows)] 27 #[repr(packed, C)] 28 $decl 29 #[cfg(not(windows))] 30 #[repr(C)] 31 $decl 32 } 33 } 34 35 use std; 36 use std::mem; 37 use std::slice; 38 use std::ptr; 39 use num_bigint::BigUint; 40 41 use functions::*; 42 use super::CkFrom; 43 44 45 pub const CK_TRUE: CK_BBOOL = 1; 46 pub const CK_FALSE: CK_BBOOL = 0; 47 48 //// an unsigned 8-bit value 49 pub type CK_BYTE = u8; 50 pub type CK_BYTE_PTR = *mut CK_BYTE; 51 52 /// an unsigned 8-bit character 53 pub type CK_CHAR = CK_BYTE; 54 pub type CK_CHAR_PTR = *mut CK_CHAR; 55 56 /// an 8-bit UTF-8 character 57 pub type CK_UTF8CHAR = CK_BYTE; 58 pub type CK_UTF8CHAR_PTR = *mut CK_UTF8CHAR; 59 60 /// a BYTE-sized Boolean flag 61 pub type CK_BBOOL = CK_BYTE; 62 63 /// an unsigned value, at least 32 bits long 64 #[cfg(windows)] 65 pub type CK_ULONG = u32; 66 #[cfg(not(windows))] 67 pub type CK_ULONG = usize; 68 pub type CK_ULONG_PTR = *mut CK_ULONG; 69 70 /// a signed value, the same size as a CK_ULONG 71 #[cfg(windows)] 72 pub type CK_LONG = i32; 73 #[cfg(not(windows))] 74 pub type CK_LONG = isize; 75 76 77 /// at least 32 bits; each bit is a Boolean flag 78 pub type CK_FLAGS = CK_ULONG; 79 80 /* some special values for certain CK_ULONG variables */ 81 pub const CK_UNAVAILABLE_INFORMATION: CK_ULONG = !0; 82 pub const CK_EFFECTIVELY_INFINITE: CK_ULONG = 0; 83 84 #[derive(Debug)] 85 #[repr(u8)] 86 pub enum CK_VOID { 87 #[doc(hidden)] __Variant1, 88 #[doc(hidden)] __Variant2, 89 } 90 pub type CK_VOID_PTR = *mut CK_VOID; 91 92 /// Pointer to a CK_VOID_PTR-- i.e., pointer to pointer to void 93 pub type CK_VOID_PTR_PTR = *mut CK_VOID_PTR; 94 95 /// The following value is always invalid if used as a session 96 /// handle or object handle 97 pub const CK_INVALID_HANDLE: CK_ULONG = 0; 98 99 cryptoki_aligned! { 100 #[derive(Debug, Copy, Default)] 101 pub struct CK_VERSION { 102 pub major: CK_BYTE, /* integer portion of version number */ 103 pub minor: CK_BYTE, /* 1/100ths portion of version number */ 104 } 105 } 106 packed_clone!(CK_VERSION); 107 108 pub type CK_VERSION_PTR = *mut CK_VERSION; 109 110 cryptoki_aligned! { 111 #[derive(Debug, Copy, Default)] 112 pub struct CK_INFO { 113 /* manufacturerID and libraryDecription have been changed from 114 * CK_CHAR to CK_UTF8CHAR for v2.10 */ 115 pub cryptokiVersion: CK_VERSION, /* Cryptoki interface ver */ 116 pub manufacturerID: [CK_UTF8CHAR; 32], /* blank padded */ 117 pub flags: CK_FLAGS, /* must be zero */ 118 pub libraryDescription: [CK_UTF8CHAR; 32], /* blank padded */ 119 pub libraryVersion: CK_VERSION, /* version of library */ 120 } 121 } 122 packed_clone!(CK_INFO); 123 124 impl CK_INFO { new() -> CK_INFO125 pub fn new() -> CK_INFO { 126 CK_INFO { 127 cryptokiVersion: Default::default(), 128 manufacturerID: [32; 32], 129 flags: 0, 130 libraryDescription: [32; 32], 131 libraryVersion: Default::default(), 132 } 133 } 134 } 135 136 pub type CK_INFO_PTR = *mut CK_INFO; 137 138 /// CK_NOTIFICATION enumerates the types of notifications that 139 /// Cryptoki provides to an application 140 pub type CK_NOTIFICATION = CK_ULONG; 141 142 pub const CKN_SURRENDER: CK_NOTIFICATION = 0; 143 pub const CKN_OTP_CHANGED: CK_NOTIFICATION = 1; 144 145 pub type CK_SLOT_ID = CK_ULONG; 146 pub type CK_SLOT_ID_PTR = *mut CK_SLOT_ID; 147 148 cryptoki_aligned! { 149 /// CK_SLOT_INFO provides information about a slot 150 pub struct CK_SLOT_INFO { 151 /// slotDescription and manufacturerID have been changed from 152 /// CK_CHAR to CK_UTF8CHAR for v2.10 153 pub slotDescription: [CK_UTF8CHAR; 64], /* blank padded */ 154 pub manufacturerID: [CK_UTF8CHAR; 32], /* blank padded */ 155 pub flags: CK_FLAGS, 156 157 /// version of hardware 158 pub hardwareVersion: CK_VERSION, /* version of hardware */ 159 /// version of firmware 160 pub firmwareVersion: CK_VERSION, /* version of firmware */ 161 } 162 } 163 164 impl Default for CK_SLOT_INFO { default() -> CK_SLOT_INFO165 fn default() -> CK_SLOT_INFO { 166 CK_SLOT_INFO { 167 slotDescription: [32; 64], 168 manufacturerID: [32; 32], 169 flags: 0, 170 hardwareVersion: Default::default(), 171 firmwareVersion: Default::default(), 172 } 173 } 174 } 175 176 impl std::fmt::Debug for CK_SLOT_INFO { fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result177 fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { 178 let sd = self.slotDescription.to_vec(); 179 fmt 180 .debug_struct("CK_SLOT_INFO") 181 .field("slotDescription", &sd) 182 .field("manufacturerID", &self.manufacturerID) 183 .field("flags", &self.flags) 184 .field("hardwareVersion", &self.hardwareVersion) 185 .field("firmwareVersion", &self.firmwareVersion) 186 .finish() 187 } 188 } 189 190 /// a token is there 191 pub const CKF_TOKEN_PRESENT: CK_FLAGS = 0x00000001; 192 /// removable devices 193 pub const CKF_REMOVABLE_DEVICE: CK_FLAGS = 0x00000002; 194 /// hardware slot 195 pub const CKF_HW_SLOT: CK_FLAGS = 0x00000004; 196 197 pub type CK_SLOT_INFO_PTR = *mut CK_SLOT_INFO; 198 199 cryptoki_aligned! { 200 #[derive(Debug, Copy)] 201 pub struct CK_TOKEN_INFO { 202 /* label, manufacturerID, and model have been changed from 203 * CK_CHAR to CK_UTF8CHAR for v2.10 */ 204 pub label: [CK_UTF8CHAR; 32], /* blank padded */ 205 pub manufacturerID: [CK_UTF8CHAR; 32], /* blank padded */ 206 pub model: [CK_UTF8CHAR; 16], /* blank padded */ 207 pub serialNumber: [CK_CHAR; 16], /* blank padded */ 208 pub flags: CK_FLAGS, /* see below */ 209 pub ulMaxSessionCount: CK_ULONG, /* max open sessions */ 210 pub ulSessionCount: CK_ULONG, /* sess. now open */ 211 pub ulMaxRwSessionCount: CK_ULONG, /* max R/W sessions */ 212 pub ulRwSessionCount: CK_ULONG, /* R/W sess. now open */ 213 pub ulMaxPinLen: CK_ULONG, /* in bytes */ 214 pub ulMinPinLen: CK_ULONG, /* in bytes */ 215 pub ulTotalPublicMemory: CK_ULONG, /* in bytes */ 216 pub ulFreePublicMemory: CK_ULONG, /* in bytes */ 217 pub ulTotalPrivateMemory: CK_ULONG, /* in bytes */ 218 pub ulFreePrivateMemory: CK_ULONG, /* in bytes */ 219 pub hardwareVersion: CK_VERSION, /* version of hardware */ 220 pub firmwareVersion: CK_VERSION, /* version of firmware */ 221 pub utcTime: [CK_CHAR; 16], /* time */ 222 } 223 } 224 packed_clone!(CK_TOKEN_INFO); 225 226 impl Default for CK_TOKEN_INFO { default() -> CK_TOKEN_INFO227 fn default() -> CK_TOKEN_INFO { 228 CK_TOKEN_INFO { 229 label: [32; 32], 230 manufacturerID: [32; 32], 231 model: [32; 16], 232 serialNumber: [32; 16], 233 flags: 0, 234 ulMaxSessionCount: 0, 235 ulSessionCount: 0, 236 ulMaxRwSessionCount: 0, 237 ulRwSessionCount: 0, 238 ulMaxPinLen: 0, 239 ulMinPinLen: 0, 240 ulTotalPublicMemory: 0, 241 ulFreePublicMemory: 0, 242 ulTotalPrivateMemory: 0, 243 ulFreePrivateMemory: 0, 244 hardwareVersion: Default::default(), 245 firmwareVersion: Default::default(), 246 utcTime: [0; 16], 247 } 248 } 249 } 250 251 /// has random # generator 252 pub const CKF_RNG: CK_FLAGS = 0x00000001; 253 254 /// token is write-protected 255 pub const CKF_WRITE_PROTECTED: CK_FLAGS = 0x00000002; 256 257 /// user must login 258 pub const CKF_LOGIN_REQUIRED: CK_FLAGS = 0x00000004; 259 260 /// normal user's PIN is set 261 pub const CKF_USER_PIN_INITIALIZED: CK_FLAGS = 0x00000008; 262 263 /// CKF_RESTORE_KEY_NOT_NEEDED. If it is set, 264 /// that means that *every* time the state of cryptographic 265 /// operations of a session is successfully saved, all keys 266 /// needed to continue those operations are stored in the state 267 pub const CKF_RESTORE_KEY_NOT_NEEDED: CK_FLAGS = 0x00000020; 268 269 /// CKF_CLOCK_ON_TOKEN. If it is set, that means 270 /// that the token has some sort of clock. The time on that 271 /// clock is returned in the token info structure 272 pub const CKF_CLOCK_ON_TOKEN: CK_FLAGS = 0x00000040; 273 274 /// CKF_PROTECTED_AUTHENTICATION_PATH. If it is 275 /// set, that means that there is some way for the user to login 276 /// without sending a PIN through the Cryptoki library itself 277 pub const CKF_PROTECTED_AUTHENTICATION_PATH: CK_FLAGS = 0x00000100; 278 279 /// CKF_DUAL_CRYPTO_OPERATIONS. If it is true, 280 /// that means that a single session with the token can perform 281 /// dual simultaneous cryptographic operations (digest and 282 /// encrypt; decrypt and digest; sign and encrypt; and decrypt 283 /// and sign) 284 pub const CKF_DUAL_CRYPTO_OPERATIONS: CK_FLAGS = 0x00000200; 285 286 /// CKF_TOKEN_INITIALIZED. If it is true, the 287 /// token has been initialized using C_InitializeToken or an 288 /// equivalent mechanism outside the scope of PKCS #11. 289 /// Calling C_InitializeToken when this flag is set will cause 290 /// the token to be reinitialized. 291 pub const CKF_TOKEN_INITIALIZED: CK_FLAGS = 0x00000400; 292 293 /// CKF_SECONDARY_AUTHENTICATION. If it is 294 /// true, the token supports secondary authentication for 295 /// private key objects. 296 pub const CKF_SECONDARY_AUTHENTICATION: CK_FLAGS = 0x00000800; 297 298 /// CKF_USER_PIN_COUNT_LOW. If it is true, an 299 /// incorrect user login PIN has been entered at least once 300 /// since the last successful authentication. 301 pub const CKF_USER_PIN_COUNT_LOW: CK_FLAGS = 0x00010000; 302 303 /// CKF_USER_PIN_FINAL_TRY. If it is true, 304 /// supplying an incorrect user PIN will it to become locked. 305 pub const CKF_USER_PIN_FINAL_TRY: CK_FLAGS = 0x00020000; 306 307 /// CKF_USER_PIN_LOCKED. If it is true, the 308 /// user PIN has been locked. User login to the token is not 309 /// possible. 310 pub const CKF_USER_PIN_LOCKED: CK_FLAGS = 0x00040000; 311 312 /// CKF_USER_PIN_TO_BE_CHANGED. If it is true, 313 /// the user PIN value is the default value set by token 314 /// initialization or manufacturing, or the PIN has been 315 /// expired by the card. 316 pub const CKF_USER_PIN_TO_BE_CHANGED: CK_FLAGS = 0x00080000; 317 318 /// CKF_SO_PIN_COUNT_LOW. If it is true, an 319 /// incorrect SO login PIN has been entered at least once since 320 /// the last successful authentication. 321 pub const CKF_SO_PIN_COUNT_LOW: CK_FLAGS = 0x00100000; 322 323 /// CKF_SO_PIN_FINAL_TRY. If it is true, 324 /// supplying an incorrect SO PIN will it to become locked. 325 pub const CKF_SO_PIN_FINAL_TRY: CK_FLAGS = 0x00200000; 326 327 /// CKF_SO_PIN_LOCKED. If it is true, the SO 328 /// PIN has been locked. SO login to the token is not possible. 329 pub const CKF_SO_PIN_LOCKED: CK_FLAGS = 0x00400000; 330 331 /// CKF_SO_PIN_TO_BE_CHANGED. If it is true, 332 /// the SO PIN value is the default value set by token 333 /// initialization or manufacturing, or the PIN has been 334 /// expired by the card. 335 pub const CKF_SO_PIN_TO_BE_CHANGED: CK_FLAGS = 0x00800000; 336 337 pub const CKF_ERROR_STATE: CK_FLAGS = 0x01000000; 338 339 pub type CK_TOKEN_INFO_PTR = *mut CK_TOKEN_INFO; 340 341 /// CK_SESSION_HANDLE is a Cryptoki-assigned value that 342 /// identifies a session 343 pub type CK_SESSION_HANDLE = CK_ULONG; 344 pub type CK_SESSION_HANDLE_PTR = *mut CK_SESSION_HANDLE; 345 346 /// CK_USER_TYPE enumerates the types of Cryptoki users 347 pub type CK_USER_TYPE = CK_ULONG; 348 349 /// Security Officer 350 pub const CKU_SO: CK_USER_TYPE = 0; 351 /// Normal user 352 pub const CKU_USER: CK_USER_TYPE = 1; 353 /// Context specific 354 pub const CKU_CONTEXT_SPECIFIC: CK_USER_TYPE = 2; 355 356 /// CK_STATE enumerates the session states 357 type CK_STATE = CK_ULONG; 358 pub const CKS_RO_PUBLIC_SESSION: CK_STATE = 0; 359 pub const CKS_RO_USER_FUNCTIONS: CK_STATE = 1; 360 pub const CKS_RW_PUBLIC_SESSION: CK_STATE = 2; 361 pub const CKS_RW_USER_FUNCTIONS: CK_STATE = 3; 362 pub const CKS_RW_SO_FUNCTIONS: CK_STATE = 4; 363 364 cryptoki_aligned! { 365 #[derive(Debug, Default, Copy)] 366 pub struct CK_SESSION_INFO { 367 pub slotID: CK_SLOT_ID, 368 pub state: CK_STATE, 369 pub flags: CK_FLAGS, 370 /// device-dependent error code 371 pub ulDeviceError: CK_ULONG, 372 } 373 } 374 packed_clone!(CK_SESSION_INFO); 375 376 /// session is r/w 377 pub const CKF_RW_SESSION: CK_FLAGS = 0x00000002; 378 /// no parallel 379 pub const CKF_SERIAL_SESSION: CK_FLAGS = 0x00000004; 380 381 pub type CK_SESSION_INFO_PTR = *mut CK_SESSION_INFO; 382 383 /// CK_OBJECT_HANDLE is a token-specific identifier for an 384 /// object 385 pub type CK_OBJECT_HANDLE = CK_ULONG; 386 pub type CK_OBJECT_HANDLE_PTR = *mut CK_OBJECT_HANDLE; 387 388 /// CK_OBJECT_CLASS is a value that identifies the classes (or 389 /// types) of objects that Cryptoki recognizes. It is defined 390 /// as follows: 391 pub type CK_OBJECT_CLASS = CK_ULONG; 392 393 /// The following classes of objects are defined: 394 pub const CKO_DATA: CK_OBJECT_CLASS = 0x00000000; 395 pub const CKO_CERTIFICATE: CK_OBJECT_CLASS = 0x00000001; 396 pub const CKO_PUBLIC_KEY: CK_OBJECT_CLASS = 0x00000002; 397 pub const CKO_PRIVATE_KEY: CK_OBJECT_CLASS = 0x00000003; 398 pub const CKO_SECRET_KEY: CK_OBJECT_CLASS = 0x00000004; 399 pub const CKO_HW_FEATURE: CK_OBJECT_CLASS = 0x00000005; 400 pub const CKO_DOMAIN_PARAMETERS: CK_OBJECT_CLASS = 0x00000006; 401 pub const CKO_MECHANISM: CK_OBJECT_CLASS = 0x00000007; 402 pub const CKO_OTP_KEY: CK_OBJECT_CLASS = 0x00000008; 403 pub const CKO_VENDOR_DEFINED: CK_OBJECT_CLASS = 0x80000000; 404 405 pub type CK_OBJECT_CLASS_PTR = *mut CK_OBJECT_CLASS; 406 407 /// CK_HW_FEATURE_TYPE is a value that identifies the hardware feature type 408 /// of an object with CK_OBJECT_CLASS equal to CKO_HW_FEATURE. 409 pub type CK_HW_FEATURE_TYPE = CK_ULONG; 410 411 /// The following hardware feature types are defined 412 pub const CKH_MONOTONIC_COUNTER: CK_HW_FEATURE_TYPE = 0x00000001; 413 pub const CKH_CLOCK: CK_HW_FEATURE_TYPE = 0x00000002; 414 pub const CKH_USER_INTERFACE: CK_HW_FEATURE_TYPE = 0x00000003; 415 pub const CKH_VENDOR_DEFINED: CK_HW_FEATURE_TYPE = 0x80000000; 416 417 /// CK_KEY_TYPE is a value that identifies a key type 418 pub type CK_KEY_TYPE = CK_ULONG; 419 420 /// the following key types are defined: 421 pub const CKK_RSA: CK_KEY_TYPE = 0x00000000; 422 pub const CKK_DSA: CK_KEY_TYPE = 0x00000001; 423 pub const CKK_DH: CK_KEY_TYPE = 0x00000002; 424 pub const CKK_ECDSA: CK_KEY_TYPE = CKK_EC; 425 pub const CKK_EC: CK_KEY_TYPE = 0x00000003; 426 pub const CKK_X9_42_DH: CK_KEY_TYPE = 0x00000004; 427 pub const CKK_KEA: CK_KEY_TYPE = 0x00000005; 428 pub const CKK_GENERIC_SECRET: CK_KEY_TYPE = 0x00000010; 429 pub const CKK_RC2: CK_KEY_TYPE = 0x00000011; 430 pub const CKK_RC4: CK_KEY_TYPE = 0x00000012; 431 pub const CKK_DES: CK_KEY_TYPE = 0x00000013; 432 pub const CKK_DES2: CK_KEY_TYPE = 0x00000014; 433 pub const CKK_DES3: CK_KEY_TYPE = 0x00000015; 434 pub const CKK_CAST: CK_KEY_TYPE = 0x00000016; 435 pub const CKK_CAST3: CK_KEY_TYPE = 0x00000017; 436 pub const CKK_CAST5: CK_KEY_TYPE = CKK_CAST128; 437 pub const CKK_CAST128: CK_KEY_TYPE = 0x00000018; 438 pub const CKK_RC5: CK_KEY_TYPE = 0x00000019; 439 pub const CKK_IDEA: CK_KEY_TYPE = 0x0000001A; 440 pub const CKK_SKIPJACK: CK_KEY_TYPE = 0x0000001B; 441 pub const CKK_BATON: CK_KEY_TYPE = 0x0000001C; 442 pub const CKK_JUNIPER: CK_KEY_TYPE = 0x0000001D; 443 pub const CKK_CDMF: CK_KEY_TYPE = 0x0000001E; 444 pub const CKK_AES: CK_KEY_TYPE = 0x0000001F; 445 pub const CKK_BLOWFISH: CK_KEY_TYPE = 0x00000020; 446 pub const CKK_TWOFISH: CK_KEY_TYPE = 0x00000021; 447 pub const CKK_SECURID: CK_KEY_TYPE = 0x00000022; 448 pub const CKK_HOTP: CK_KEY_TYPE = 0x00000023; 449 pub const CKK_ACTI: CK_KEY_TYPE = 0x00000024; 450 pub const CKK_CAMELLIA: CK_KEY_TYPE = 0x00000025; 451 pub const CKK_ARIA: CK_KEY_TYPE = 0x00000026; 452 pub const CKK_MD5_HMAC: CK_KEY_TYPE = 0x00000027; 453 pub const CKK_SHA_1_HMAC: CK_KEY_TYPE = 0x00000028; 454 pub const CKK_RIPEMD128_HMAC: CK_KEY_TYPE = 0x00000029; 455 pub const CKK_RIPEMD160_HMAC: CK_KEY_TYPE = 0x0000002A; 456 pub const CKK_SHA256_HMAC: CK_KEY_TYPE = 0x0000002B; 457 pub const CKK_SHA384_HMAC: CK_KEY_TYPE = 0x0000002C; 458 pub const CKK_SHA512_HMAC: CK_KEY_TYPE = 0x0000002D; 459 pub const CKK_SHA224_HMAC: CK_KEY_TYPE = 0x0000002E; 460 pub const CKK_SEED: CK_KEY_TYPE = 0x0000002F; 461 pub const CKK_GOSTR3410: CK_KEY_TYPE = 0x00000030; 462 pub const CKK_GOSTR3411: CK_KEY_TYPE = 0x00000031; 463 pub const CKK_GOST28147: CK_KEY_TYPE = 0x00000032; 464 pub const CKK_VENDOR_DEFINED: CK_KEY_TYPE = 0x80000000; 465 466 /// CK_CERTIFICATE_TYPE is a value that identifies a certificate 467 /// type 468 pub type CK_CERTIFICATE_TYPE = CK_ULONG; 469 470 pub const CK_CERTIFICATE_CATEGORY_UNSPECIFIED: CK_ULONG = 0; 471 pub const CK_CERTIFICATE_CATEGORY_TOKEN_USER: CK_ULONG = 1; 472 pub const CK_CERTIFICATE_CATEGORY_AUTHORITY: CK_ULONG = 2; 473 pub const CK_CERTIFICATE_CATEGORY_OTHER_ENTITY: CK_ULONG = 3; 474 475 pub const CK_SECURITY_DOMAIN_UNSPECIFIED: CK_ULONG = 0; 476 pub const CK_SECURITY_DOMAIN_MANUFACTURER: CK_ULONG = 1; 477 pub const CK_SECURITY_DOMAIN_OPERATOR: CK_ULONG = 2; 478 pub const CK_SECURITY_DOMAIN_THIRD_PARTY: CK_ULONG = 3; 479 480 /// The following certificate types are defined: 481 pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0x00000000; 482 pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 0x00000001; 483 pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 0x00000002; 484 pub const CKC_VENDOR_DEFINED: CK_CERTIFICATE_TYPE = 0x80000000; 485 486 /// CK_ATTRIBUTE_TYPE is a value that identifies an attribute 487 /// type 488 pub type CK_ATTRIBUTE_TYPE = CK_ULONG; 489 490 /// The CKF_ARRAY_ATTRIBUTE flag identifies an attribute which 491 /// consists of an array of values. 492 pub const CKF_ARRAY_ATTRIBUTE: CK_FLAGS = 0x40000000; 493 494 /// The following OTP-related defines relate to the CKA_OTP_FORMAT attribute 495 pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; 496 pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; 497 pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; 498 pub const CK_OTP_FORMAT_BINARY: CK_ULONG = 3; 499 500 /// The following OTP-related defines relate to the CKA_OTP_..._REQUIREMENT 501 /// attributes 502 pub const CK_OTP_PARAM_IGNORED: CK_ULONG = 0; 503 pub const CK_OTP_PARAM_OPTIONAL: CK_ULONG = 1; 504 pub const CK_OTP_PARAM_MANDATORY: CK_ULONG = 2; 505 506 /// The following attribute types are defined: 507 pub const CKA_CLASS: CK_ATTRIBUTE_TYPE = 0x00000000; 508 pub const CKA_TOKEN: CK_ATTRIBUTE_TYPE = 0x00000001; 509 pub const CKA_PRIVATE: CK_ATTRIBUTE_TYPE = 0x00000002; 510 pub const CKA_LABEL: CK_ATTRIBUTE_TYPE = 0x00000003; 511 pub const CKA_APPLICATION: CK_ATTRIBUTE_TYPE = 0x00000010; 512 pub const CKA_VALUE: CK_ATTRIBUTE_TYPE = 0x00000011; 513 pub const CKA_OBJECT_ID: CK_ATTRIBUTE_TYPE = 0x00000012; 514 pub const CKA_CERTIFICATE_TYPE: CK_ATTRIBUTE_TYPE = 0x00000080; 515 pub const CKA_ISSUER: CK_ATTRIBUTE_TYPE = 0x00000081; 516 pub const CKA_SERIAL_NUMBER: CK_ATTRIBUTE_TYPE = 0x00000082; 517 pub const CKA_AC_ISSUER: CK_ATTRIBUTE_TYPE = 0x00000083; 518 pub const CKA_OWNER: CK_ATTRIBUTE_TYPE = 0x00000084; 519 pub const CKA_ATTR_TYPES: CK_ATTRIBUTE_TYPE = 0x00000085; 520 pub const CKA_TRUSTED: CK_ATTRIBUTE_TYPE = 0x00000086; 521 pub const CKA_CERTIFICATE_CATEGORY: CK_ATTRIBUTE_TYPE = 0x00000087; 522 pub const CKA_JAVA_MIDP_SECURITY_DOMAIN: CK_ATTRIBUTE_TYPE = 0x00000088; 523 pub const CKA_URL: CK_ATTRIBUTE_TYPE = 0x00000089; 524 pub const CKA_HASH_OF_SUBJECT_PUBLIC_KEY: CK_ATTRIBUTE_TYPE = 0x0000008A; 525 pub const CKA_HASH_OF_ISSUER_PUBLIC_KEY: CK_ATTRIBUTE_TYPE = 0x0000008B; 526 pub const CKA_NAME_HASH_ALGORITHM: CK_ATTRIBUTE_TYPE = 0x0000008C; 527 pub const CKA_CHECK_VALUE: CK_ATTRIBUTE_TYPE = 0x00000090; 528 529 pub const CKA_KEY_TYPE: CK_ATTRIBUTE_TYPE = 0x00000100; 530 pub const CKA_SUBJECT: CK_ATTRIBUTE_TYPE = 0x00000101; 531 pub const CKA_ID: CK_ATTRIBUTE_TYPE = 0x00000102; 532 pub const CKA_SENSITIVE: CK_ATTRIBUTE_TYPE = 0x00000103; 533 pub const CKA_ENCRYPT: CK_ATTRIBUTE_TYPE = 0x00000104; 534 pub const CKA_DECRYPT: CK_ATTRIBUTE_TYPE = 0x00000105; 535 pub const CKA_WRAP: CK_ATTRIBUTE_TYPE = 0x00000106; 536 pub const CKA_UNWRAP: CK_ATTRIBUTE_TYPE = 0x00000107; 537 pub const CKA_SIGN: CK_ATTRIBUTE_TYPE = 0x00000108; 538 pub const CKA_SIGN_RECOVER: CK_ATTRIBUTE_TYPE = 0x00000109; 539 pub const CKA_VERIFY: CK_ATTRIBUTE_TYPE = 0x0000010A; 540 pub const CKA_VERIFY_RECOVER: CK_ATTRIBUTE_TYPE = 0x0000010B; 541 pub const CKA_DERIVE: CK_ATTRIBUTE_TYPE = 0x0000010C; 542 pub const CKA_START_DATE: CK_ATTRIBUTE_TYPE = 0x00000110; 543 pub const CKA_END_DATE: CK_ATTRIBUTE_TYPE = 0x00000111; 544 pub const CKA_MODULUS: CK_ATTRIBUTE_TYPE = 0x00000120; 545 pub const CKA_MODULUS_BITS: CK_ATTRIBUTE_TYPE = 0x00000121; 546 pub const CKA_PUBLIC_EXPONENT: CK_ATTRIBUTE_TYPE = 0x00000122; 547 pub const CKA_PRIVATE_EXPONENT: CK_ATTRIBUTE_TYPE = 0x00000123; 548 pub const CKA_PRIME_1: CK_ATTRIBUTE_TYPE = 0x00000124; 549 pub const CKA_PRIME_2: CK_ATTRIBUTE_TYPE = 0x00000125; 550 pub const CKA_EXPONENT_1: CK_ATTRIBUTE_TYPE = 0x00000126; 551 pub const CKA_EXPONENT_2: CK_ATTRIBUTE_TYPE = 0x00000127; 552 pub const CKA_COEFFICIENT: CK_ATTRIBUTE_TYPE = 0x00000128; 553 pub const CKA_PUBLIC_KEY_INFO: CK_ATTRIBUTE_TYPE = 0x00000129; 554 pub const CKA_PRIME: CK_ATTRIBUTE_TYPE = 0x00000130; 555 pub const CKA_SUBPRIME: CK_ATTRIBUTE_TYPE = 0x00000131; 556 pub const CKA_BASE: CK_ATTRIBUTE_TYPE = 0x00000132; 557 558 pub const CKA_PRIME_BITS: CK_ATTRIBUTE_TYPE = 0x00000133; 559 pub const CKA_SUBPRIME_BITS: CK_ATTRIBUTE_TYPE = 0x00000134; 560 pub const CKA_SUB_PRIME_BITS: CK_ATTRIBUTE_TYPE = CKA_SUBPRIME_BITS; 561 562 pub const CKA_VALUE_BITS: CK_ATTRIBUTE_TYPE = 0x00000160; 563 pub const CKA_VALUE_LEN: CK_ATTRIBUTE_TYPE = 0x00000161; 564 pub const CKA_EXTRACTABLE: CK_ATTRIBUTE_TYPE = 0x00000162; 565 pub const CKA_LOCAL: CK_ATTRIBUTE_TYPE = 0x00000163; 566 pub const CKA_NEVER_EXTRACTABLE: CK_ATTRIBUTE_TYPE = 0x00000164; 567 pub const CKA_ALWAYS_SENSITIVE: CK_ATTRIBUTE_TYPE = 0x00000165; 568 pub const CKA_KEY_GEN_MECHANISM: CK_ATTRIBUTE_TYPE = 0x00000166; 569 570 pub const CKA_MODIFIABLE: CK_ATTRIBUTE_TYPE = 0x00000170; 571 pub const CKA_COPYABLE: CK_ATTRIBUTE_TYPE = 0x00000171; 572 573 pub const CKA_DESTROYABLE: CK_ATTRIBUTE_TYPE = 0x00000172; 574 575 pub const CKA_ECDSA_PARAMS: CK_ATTRIBUTE_TYPE = CKA_EC_PARAMS; 576 pub const CKA_EC_PARAMS: CK_ATTRIBUTE_TYPE = 0x00000180; 577 578 pub const CKA_EC_POINT: CK_ATTRIBUTE_TYPE = 0x00000181; 579 580 pub const CKA_SECONDARY_AUTH: CK_ATTRIBUTE_TYPE = 0x00000200; /* Deprecated */ 581 pub const CKA_AUTH_PIN_FLAGS: CK_ATTRIBUTE_TYPE = 0x00000201; /* Deprecated */ 582 583 pub const CKA_ALWAYS_AUTHENTICATE: CK_ATTRIBUTE_TYPE = 0x00000202; 584 585 pub const CKA_WRAP_WITH_TRUSTED: CK_ATTRIBUTE_TYPE = 0x00000210; 586 pub const CKA_WRAP_TEMPLATE: CK_ATTRIBUTE_TYPE = (CKF_ARRAY_ATTRIBUTE | 0x00000211); 587 pub const CKA_UNWRAP_TEMPLATE: CK_ATTRIBUTE_TYPE = (CKF_ARRAY_ATTRIBUTE | 0x00000212); 588 pub const CKA_DERIVE_TEMPLATE: CK_ATTRIBUTE_TYPE = (CKF_ARRAY_ATTRIBUTE | 0x00000213); 589 590 pub const CKA_OTP_FORMAT: CK_ATTRIBUTE_TYPE = 0x00000220; 591 pub const CKA_OTP_LENGTH: CK_ATTRIBUTE_TYPE = 0x00000221; 592 pub const CKA_OTP_TIME_INTERVAL: CK_ATTRIBUTE_TYPE = 0x00000222; 593 pub const CKA_OTP_USER_FRIENDLY_MODE: CK_ATTRIBUTE_TYPE = 0x00000223; 594 pub const CKA_OTP_CHALLENGE_REQUIREMENT: CK_ATTRIBUTE_TYPE = 0x00000224; 595 pub const CKA_OTP_TIME_REQUIREMENT: CK_ATTRIBUTE_TYPE = 0x00000225; 596 pub const CKA_OTP_COUNTER_REQUIREMENT: CK_ATTRIBUTE_TYPE = 0x00000226; 597 pub const CKA_OTP_PIN_REQUIREMENT: CK_ATTRIBUTE_TYPE = 0x00000227; 598 pub const CKA_OTP_COUNTER: CK_ATTRIBUTE_TYPE = 0x0000022E; 599 pub const CKA_OTP_TIME: CK_ATTRIBUTE_TYPE = 0x0000022F; 600 pub const CKA_OTP_USER_IDENTIFIER: CK_ATTRIBUTE_TYPE = 0x0000022A; 601 pub const CKA_OTP_SERVICE_IDENTIFIER: CK_ATTRIBUTE_TYPE = 0x0000022B; 602 pub const CKA_OTP_SERVICE_LOGO: CK_ATTRIBUTE_TYPE = 0x0000022C; 603 pub const CKA_OTP_SERVICE_LOGO_TYPE: CK_ATTRIBUTE_TYPE = 0x0000022D; 604 605 pub const CKA_GOSTR3410_PARAMS: CK_ATTRIBUTE_TYPE = 0x00000250; 606 pub const CKA_GOSTR3411_PARAMS: CK_ATTRIBUTE_TYPE = 0x00000251; 607 pub const CKA_GOST28147_PARAMS: CK_ATTRIBUTE_TYPE = 0x00000252; 608 609 pub const CKA_HW_FEATURE_TYPE: CK_ATTRIBUTE_TYPE = 0x00000300; 610 pub const CKA_RESET_ON_INIT: CK_ATTRIBUTE_TYPE = 0x00000301; 611 pub const CKA_HAS_RESET: CK_ATTRIBUTE_TYPE = 0x00000302; 612 613 pub const CKA_PIXEL_X: CK_ATTRIBUTE_TYPE = 0x00000400; 614 pub const CKA_PIXEL_Y: CK_ATTRIBUTE_TYPE = 0x00000401; 615 pub const CKA_RESOLUTION: CK_ATTRIBUTE_TYPE = 0x00000402; 616 pub const CKA_CHAR_ROWS: CK_ATTRIBUTE_TYPE = 0x00000403; 617 pub const CKA_CHAR_COLUMNS: CK_ATTRIBUTE_TYPE = 0x00000404; 618 pub const CKA_COLOR: CK_ATTRIBUTE_TYPE = 0x00000405; 619 pub const CKA_BITS_PER_PIXEL: CK_ATTRIBUTE_TYPE = 0x00000406; 620 pub const CKA_CHAR_SETS: CK_ATTRIBUTE_TYPE = 0x00000480; 621 pub const CKA_ENCODING_METHODS: CK_ATTRIBUTE_TYPE = 0x00000481; 622 pub const CKA_MIME_TYPES: CK_ATTRIBUTE_TYPE = 0x00000482; 623 pub const CKA_MECHANISM_TYPE: CK_ATTRIBUTE_TYPE = 0x00000500; 624 pub const CKA_REQUIRED_CMS_ATTRIBUTES: CK_ATTRIBUTE_TYPE = 0x00000501; 625 pub const CKA_DEFAULT_CMS_ATTRIBUTES: CK_ATTRIBUTE_TYPE = 0x00000502; 626 pub const CKA_SUPPORTED_CMS_ATTRIBUTES: CK_ATTRIBUTE_TYPE = 0x00000503; 627 pub const CKA_ALLOWED_MECHANISMS: CK_ATTRIBUTE_TYPE = (CKF_ARRAY_ATTRIBUTE | 0x00000600); 628 629 pub const CKA_VENDOR_DEFINED: CK_ATTRIBUTE_TYPE = 0x80000000; 630 631 cryptoki_aligned! { 632 /// CK_ATTRIBUTE is a structure that includes the type, length 633 /// and value of an attribute 634 #[derive(Copy)] 635 pub struct CK_ATTRIBUTE { 636 pub attrType: CK_ATTRIBUTE_TYPE, 637 pub pValue: CK_VOID_PTR, 638 /// in bytes 639 pub ulValueLen: CK_ULONG, 640 } 641 } 642 packed_clone!(CK_ATTRIBUTE); 643 644 pub type CK_ATTRIBUTE_PTR = *mut CK_ATTRIBUTE; 645 646 impl Default for CK_ATTRIBUTE { default() -> Self647 fn default() -> Self { 648 Self { 649 attrType: CKA_VENDOR_DEFINED, 650 pValue: ptr::null_mut(), 651 ulValueLen: 0, 652 } 653 } 654 } 655 656 impl std::fmt::Debug for CK_ATTRIBUTE { fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result657 fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { 658 let attrType = format!("0x{:x}", self.attrType); 659 let data = unsafe { slice::from_raw_parts(self.pValue as *const u8, self.ulValueLen as usize) }; 660 fmt 661 .debug_struct("CK_ATTRIBUTE") 662 .field("attrType", &attrType) 663 .field("pValue", &data) 664 .field("ulValueLen", &self.ulValueLen) 665 .finish() 666 } 667 } 668 669 impl CK_ATTRIBUTE { new(attrType: CK_ATTRIBUTE_TYPE) -> Self670 pub fn new(attrType: CK_ATTRIBUTE_TYPE) -> Self { 671 Self { 672 attrType, 673 pValue: ptr::null_mut(), 674 ulValueLen: 0, 675 } 676 } 677 with_bool(mut self, b: &CK_BBOOL) -> Self678 pub fn with_bool(mut self, b: &CK_BBOOL) -> Self { 679 self.pValue = b as *const CK_BBOOL as CK_VOID_PTR; 680 self.ulValueLen = 1; 681 self 682 } 683 set_bool(&mut self, b: &CK_BBOOL)684 pub fn set_bool(&mut self, b: &CK_BBOOL) { 685 self.pValue = b as *const CK_BBOOL as CK_VOID_PTR; 686 if self.ulValueLen == 0 { 687 self.ulValueLen = 1; 688 } 689 } 690 get_bool(&self) -> bool691 pub fn get_bool(&self) -> bool { 692 let data: CK_BBOOL = unsafe { mem::transmute_copy(&*self.pValue) }; 693 CkFrom::from(data) 694 } 695 with_ck_ulong(mut self, val: &CK_ULONG) -> Self696 pub fn with_ck_ulong(mut self, val: &CK_ULONG) -> Self { 697 self.pValue = val as *const _ as CK_VOID_PTR; 698 self.ulValueLen = std::mem::size_of::<CK_ULONG>() as CK_ULONG; 699 self 700 } 701 set_ck_ulong(&mut self, val: &CK_ULONG)702 pub fn set_ck_ulong(&mut self, val: &CK_ULONG) { 703 self.pValue = val as *const _ as CK_VOID_PTR; 704 if self.ulValueLen == 0 { 705 self.ulValueLen = std::mem::size_of::<CK_ULONG>() as CK_ULONG; 706 } 707 } 708 get_ck_ulong(&self) -> CK_ULONG709 pub fn get_ck_ulong(&self) -> CK_ULONG { 710 unsafe { mem::transmute_copy(&*self.pValue) } 711 } 712 with_ck_long(mut self, val: &CK_LONG) -> Self713 pub fn with_ck_long(mut self, val: &CK_LONG) -> Self { 714 self.pValue = val as *const _ as CK_VOID_PTR; 715 self.ulValueLen = std::mem::size_of::<CK_LONG>() as CK_ULONG; 716 self 717 } 718 set_ck_long(&mut self, val: &CK_LONG)719 pub fn set_ck_long(&mut self, val: &CK_LONG) { 720 self.pValue = val as *const _ as CK_VOID_PTR; 721 if self.ulValueLen == 0 { 722 self.ulValueLen = std::mem::size_of::<CK_LONG>() as CK_ULONG; 723 } 724 } 725 get_ck_long(&self) -> CK_LONG726 pub fn get_ck_long(&self) -> CK_LONG { 727 unsafe { mem::transmute_copy(&*self.pValue) } 728 } 729 with_biginteger(mut self, val: &[u8]) -> Self730 pub fn with_biginteger(mut self, val: &[u8]) -> Self { 731 self.pValue = val.as_ptr() as CK_VOID_PTR; 732 self.ulValueLen = val.len() as CK_ULONG; 733 self 734 } 735 set_biginteger(&mut self, val: &[u8])736 pub fn set_biginteger(&mut self, val: &[u8]) { 737 self.pValue = val.as_ptr() as CK_VOID_PTR; 738 if self.ulValueLen == 0 { 739 self.ulValueLen = val.len() as CK_ULONG; 740 } 741 } 742 get_biginteger(&self) -> BigUint743 pub fn get_biginteger(&self) -> BigUint { 744 let slice = unsafe { slice::from_raw_parts(self.pValue as CK_BYTE_PTR, self.ulValueLen as usize) }; 745 BigUint::from_bytes_le(slice) 746 } 747 with_bytes(mut self, val: &[CK_BYTE]) -> Self748 pub fn with_bytes(mut self, val: &[CK_BYTE]) -> Self { 749 self.pValue = val.as_ptr() as CK_VOID_PTR; 750 self.ulValueLen = val.len() as CK_ULONG; 751 self 752 } 753 set_bytes(&mut self, val: &[CK_BYTE])754 pub fn set_bytes(&mut self, val: &[CK_BYTE]) { 755 self.pValue = val.as_ptr() as CK_VOID_PTR; 756 if self.ulValueLen == 0 { 757 self.ulValueLen = val.len() as CK_ULONG; 758 } 759 } 760 get_bytes(&self) -> Vec<CK_BYTE>761 pub fn get_bytes(&self) -> Vec<CK_BYTE> { 762 let slice = unsafe { slice::from_raw_parts(self.pValue as CK_BYTE_PTR, self.ulValueLen as usize) }; 763 Vec::from(slice) 764 } 765 with_string(mut self, str: &String) -> Self766 pub fn with_string(mut self, str: &String) -> Self { 767 self.pValue = str.as_ptr() as CK_VOID_PTR; 768 self.ulValueLen = str.len() as CK_ULONG; 769 self 770 } 771 set_string(&mut self, str: &String)772 pub fn set_string(&mut self, str: &String) { 773 self.pValue = str.as_ptr() as CK_VOID_PTR; 774 if self.ulValueLen == 0 { 775 self.ulValueLen = str.len() as CK_ULONG; 776 } 777 } 778 get_string(&self) -> String779 pub fn get_string(&self) -> String { 780 let slice = unsafe { slice::from_raw_parts(self.pValue as CK_BYTE_PTR, self.ulValueLen as usize) }; 781 String::from_utf8_lossy(slice).into_owned() 782 } 783 with_date(mut self, date: &CK_DATE) -> Self784 pub fn with_date(mut self, date: &CK_DATE) -> Self { 785 self.pValue = (date as *const CK_DATE) as CK_VOID_PTR; 786 self.ulValueLen = mem::size_of::<CK_DATE>() as CK_ULONG; 787 self 788 } 789 set_date(&mut self, date: &CK_DATE)790 pub fn set_date(&mut self, date: &CK_DATE) { 791 self.pValue = (date as *const CK_DATE) as CK_VOID_PTR; 792 if self.ulValueLen == 0 { 793 self.ulValueLen = mem::size_of::<CK_DATE>() as CK_ULONG; 794 } 795 } 796 get_date(&self) -> CK_DATE797 pub fn get_date(&self) -> CK_DATE { 798 unsafe { mem::transmute_copy(&*self.pValue) } 799 } 800 801 // this works for C structs and primitives, but not for vectors, slices, strings 802 //pub fn set_ptr<T>(&mut self, val: &T) { 803 // self.pValue = (val as *const T) as CK_VOID_PTR; 804 //} 805 } 806 807 //trait CkAttributeFrom<T> { 808 // fn from_ck(T, CK_ATTRIBUTE_TYPE) -> Self; 809 //} 810 // 811 //trait CkAttributeInto<T> { 812 // fn into_attribute(self, CK_ATTRIBUTE_TYPE) -> CK_ATTRIBUTE; 813 //} 814 // 815 //impl<T> CkAttributeInto<T> for T where CK_ATTRIBUTE: CkAttributeFrom<T> { 816 // fn into_attribute(self, attrType: CK_ATTRIBUTE_TYPE) -> CK_ATTRIBUTE { 817 // CkAttributeFrom::from_ck(self, attrType) 818 // } 819 //} 820 // 821 //impl CkAttributeFrom<bool> for CK_ATTRIBUTE { 822 // fn from_ck(b: bool, attrType: CK_ATTRIBUTE_TYPE) -> CK_ATTRIBUTE { 823 // let val: CK_BBOOL = if b { 1 } else { 0 }; 824 // let ret = Self { 825 // attrType: attrType, 826 // pValue: &val as *const u8 as *const CK_VOID, 827 // ulValueLen: 1, 828 // }; 829 // println!("{:?}", ret); 830 // ret 831 // } 832 //} 833 834 cryptoki_aligned! { 835 /// CK_DATE is a structure that defines a date 836 #[derive(Debug, Default, Copy)] 837 pub struct CK_DATE { 838 /// the year ("1900" - "9999") 839 pub year: [CK_CHAR; 4], 840 /// the month ("01" - "12") 841 pub month: [CK_CHAR; 2], 842 /// the day ("01" - "31") 843 pub day: [CK_CHAR; 2], 844 } 845 } 846 packed_clone!(CK_DATE); 847 848 /// CK_MECHANISM_TYPE is a value that identifies a mechanism 849 /// type 850 pub type CK_MECHANISM_TYPE = CK_ULONG; 851 852 /// the following mechanism types are defined: 853 pub const CKM_RSA_PKCS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0x00000000; 854 pub const CKM_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000001; 855 pub const CKM_RSA_9796: CK_MECHANISM_TYPE = 0x00000002; 856 pub const CKM_RSA_X_509: CK_MECHANISM_TYPE = 0x00000003; 857 858 pub const CKM_MD2_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000004; 859 pub const CKM_MD5_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000005; 860 pub const CKM_SHA1_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000006; 861 862 pub const CKM_RIPEMD128_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000007; 863 pub const CKM_RIPEMD160_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000008; 864 pub const CKM_RSA_PKCS_OAEP: CK_MECHANISM_TYPE = 0x00000009; 865 866 pub const CKM_RSA_X9_31_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0x0000000A; 867 pub const CKM_RSA_X9_31: CK_MECHANISM_TYPE = 0x0000000B; 868 pub const CKM_SHA1_RSA_X9_31: CK_MECHANISM_TYPE = 0x0000000C; 869 pub const CKM_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 0x0000000D; 870 pub const CKM_SHA1_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 0x0000000E; 871 872 pub const CKM_DSA_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0x00000010; 873 pub const CKM_DSA: CK_MECHANISM_TYPE = 0x00000011; 874 pub const CKM_DSA_SHA1: CK_MECHANISM_TYPE = 0x00000012; 875 pub const CKM_DSA_SHA224: CK_MECHANISM_TYPE = 0x00000013; 876 pub const CKM_DSA_SHA256: CK_MECHANISM_TYPE = 0x00000014; 877 pub const CKM_DSA_SHA384: CK_MECHANISM_TYPE = 0x00000015; 878 pub const CKM_DSA_SHA512: CK_MECHANISM_TYPE = 0x00000016; 879 880 pub const CKM_DH_PKCS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0x00000020; 881 pub const CKM_DH_PKCS_DERIVE: CK_MECHANISM_TYPE = 0x00000021; 882 883 pub const CKM_X9_42_DH_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0x00000030; 884 pub const CKM_X9_42_DH_DERIVE: CK_MECHANISM_TYPE = 0x00000031; 885 pub const CKM_X9_42_DH_HYBRID_DERIVE: CK_MECHANISM_TYPE = 0x00000032; 886 pub const CKM_X9_42_MQV_DERIVE: CK_MECHANISM_TYPE = 0x00000033; 887 888 pub const CKM_SHA256_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000040; 889 pub const CKM_SHA384_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000041; 890 pub const CKM_SHA512_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000042; 891 pub const CKM_SHA256_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 0x00000043; 892 pub const CKM_SHA384_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 0x00000044; 893 pub const CKM_SHA512_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 0x00000045; 894 895 pub const CKM_SHA224_RSA_PKCS: CK_MECHANISM_TYPE = 0x00000046; 896 pub const CKM_SHA224_RSA_PKCS_PSS: CK_MECHANISM_TYPE = 0x00000047; 897 898 pub const CKM_SHA512_224: CK_MECHANISM_TYPE = 0x00000048; 899 pub const CKM_SHA512_224_HMAC: CK_MECHANISM_TYPE = 0x00000049; 900 pub const CKM_SHA512_224_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x0000004A; 901 pub const CKM_SHA512_224_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x0000004B; 902 pub const CKM_SHA512_256: CK_MECHANISM_TYPE = 0x0000004C; 903 pub const CKM_SHA512_256_HMAC: CK_MECHANISM_TYPE = 0x0000004D; 904 pub const CKM_SHA512_256_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x0000004E; 905 pub const CKM_SHA512_256_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x0000004F; 906 907 pub const CKM_SHA512_T: CK_MECHANISM_TYPE = 0x00000050; 908 pub const CKM_SHA512_T_HMAC: CK_MECHANISM_TYPE = 0x00000051; 909 pub const CKM_SHA512_T_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000052; 910 pub const CKM_SHA512_T_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x00000053; 911 912 pub const CKM_RC2_KEY_GEN: CK_MECHANISM_TYPE = 0x00000100; 913 pub const CKM_RC2_ECB: CK_MECHANISM_TYPE = 0x00000101; 914 pub const CKM_RC2_CBC: CK_MECHANISM_TYPE = 0x00000102; 915 pub const CKM_RC2_MAC: CK_MECHANISM_TYPE = 0x00000103; 916 917 pub const CKM_RC2_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000104; 918 pub const CKM_RC2_CBC_PAD: CK_MECHANISM_TYPE = 0x00000105; 919 920 pub const CKM_RC4_KEY_GEN: CK_MECHANISM_TYPE = 0x00000110; 921 pub const CKM_RC4: CK_MECHANISM_TYPE = 0x00000111; 922 pub const CKM_DES_KEY_GEN: CK_MECHANISM_TYPE = 0x00000120; 923 pub const CKM_DES_ECB: CK_MECHANISM_TYPE = 0x00000121; 924 pub const CKM_DES_CBC: CK_MECHANISM_TYPE = 0x00000122; 925 pub const CKM_DES_MAC: CK_MECHANISM_TYPE = 0x00000123; 926 927 pub const CKM_DES_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000124; 928 pub const CKM_DES_CBC_PAD: CK_MECHANISM_TYPE = 0x00000125; 929 930 pub const CKM_DES2_KEY_GEN: CK_MECHANISM_TYPE = 0x00000130; 931 pub const CKM_DES3_KEY_GEN: CK_MECHANISM_TYPE = 0x00000131; 932 pub const CKM_DES3_ECB: CK_MECHANISM_TYPE = 0x00000132; 933 pub const CKM_DES3_CBC: CK_MECHANISM_TYPE = 0x00000133; 934 pub const CKM_DES3_MAC: CK_MECHANISM_TYPE = 0x00000134; 935 936 pub const CKM_DES3_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000135; 937 pub const CKM_DES3_CBC_PAD: CK_MECHANISM_TYPE = 0x00000136; 938 pub const CKM_DES3_CMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000137; 939 pub const CKM_DES3_CMAC: CK_MECHANISM_TYPE = 0x00000138; 940 pub const CKM_CDMF_KEY_GEN: CK_MECHANISM_TYPE = 0x00000140; 941 pub const CKM_CDMF_ECB: CK_MECHANISM_TYPE = 0x00000141; 942 pub const CKM_CDMF_CBC: CK_MECHANISM_TYPE = 0x00000142; 943 pub const CKM_CDMF_MAC: CK_MECHANISM_TYPE = 0x00000143; 944 pub const CKM_CDMF_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000144; 945 pub const CKM_CDMF_CBC_PAD: CK_MECHANISM_TYPE = 0x00000145; 946 947 pub const CKM_DES_OFB64: CK_MECHANISM_TYPE = 0x00000150; 948 pub const CKM_DES_OFB8: CK_MECHANISM_TYPE = 0x00000151; 949 pub const CKM_DES_CFB64: CK_MECHANISM_TYPE = 0x00000152; 950 pub const CKM_DES_CFB8: CK_MECHANISM_TYPE = 0x00000153; 951 952 pub const CKM_MD2: CK_MECHANISM_TYPE = 0x00000200; 953 954 pub const CKM_MD2_HMAC: CK_MECHANISM_TYPE = 0x00000201; 955 pub const CKM_MD2_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000202; 956 957 pub const CKM_MD5: CK_MECHANISM_TYPE = 0x00000210; 958 959 pub const CKM_MD5_HMAC: CK_MECHANISM_TYPE = 0x00000211; 960 pub const CKM_MD5_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000212; 961 962 pub const CKM_SHA_1: CK_MECHANISM_TYPE = 0x00000220; 963 964 pub const CKM_SHA_1_HMAC: CK_MECHANISM_TYPE = 0x00000221; 965 pub const CKM_SHA_1_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000222; 966 967 pub const CKM_RIPEMD128: CK_MECHANISM_TYPE = 0x00000230; 968 pub const CKM_RIPEMD128_HMAC: CK_MECHANISM_TYPE = 0x00000231; 969 pub const CKM_RIPEMD128_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000232; 970 pub const CKM_RIPEMD160: CK_MECHANISM_TYPE = 0x00000240; 971 pub const CKM_RIPEMD160_HMAC: CK_MECHANISM_TYPE = 0x00000241; 972 pub const CKM_RIPEMD160_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000242; 973 974 pub const CKM_SHA256: CK_MECHANISM_TYPE = 0x00000250; 975 pub const CKM_SHA256_HMAC: CK_MECHANISM_TYPE = 0x00000251; 976 pub const CKM_SHA256_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000252; 977 pub const CKM_SHA224: CK_MECHANISM_TYPE = 0x00000255; 978 pub const CKM_SHA224_HMAC: CK_MECHANISM_TYPE = 0x00000256; 979 pub const CKM_SHA224_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000257; 980 pub const CKM_SHA384: CK_MECHANISM_TYPE = 0x00000260; 981 pub const CKM_SHA384_HMAC: CK_MECHANISM_TYPE = 0x00000261; 982 pub const CKM_SHA384_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000262; 983 pub const CKM_SHA512: CK_MECHANISM_TYPE = 0x00000270; 984 pub const CKM_SHA512_HMAC: CK_MECHANISM_TYPE = 0x00000271; 985 pub const CKM_SHA512_HMAC_GENERAL: CK_MECHANISM_TYPE = 0x00000272; 986 pub const CKM_SECURID_KEY_GEN: CK_MECHANISM_TYPE = 0x00000280; 987 pub const CKM_SECURID: CK_MECHANISM_TYPE = 0x00000282; 988 pub const CKM_HOTP_KEY_GEN: CK_MECHANISM_TYPE = 0x00000290; 989 pub const CKM_HOTP: CK_MECHANISM_TYPE = 0x00000291; 990 pub const CKM_ACTI: CK_MECHANISM_TYPE = 0x000002A0; 991 pub const CKM_ACTI_KEY_GEN: CK_MECHANISM_TYPE = 0x000002A1; 992 993 pub const CKM_CAST_KEY_GEN: CK_MECHANISM_TYPE = 0x00000300; 994 pub const CKM_CAST_ECB: CK_MECHANISM_TYPE = 0x00000301; 995 pub const CKM_CAST_CBC: CK_MECHANISM_TYPE = 0x00000302; 996 pub const CKM_CAST_MAC: CK_MECHANISM_TYPE = 0x00000303; 997 pub const CKM_CAST_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000304; 998 pub const CKM_CAST_CBC_PAD: CK_MECHANISM_TYPE = 0x00000305; 999 pub const CKM_CAST3_KEY_GEN: CK_MECHANISM_TYPE = 0x00000310; 1000 pub const CKM_CAST3_ECB: CK_MECHANISM_TYPE = 0x00000311; 1001 pub const CKM_CAST3_CBC: CK_MECHANISM_TYPE = 0x00000312; 1002 pub const CKM_CAST3_MAC: CK_MECHANISM_TYPE = 0x00000313; 1003 pub const CKM_CAST3_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000314; 1004 pub const CKM_CAST3_CBC_PAD: CK_MECHANISM_TYPE = 0x00000315; 1005 /// Note that CAST128 and CAST5 are the same algorithm 1006 pub const CKM_CAST5_KEY_GEN: CK_MECHANISM_TYPE = 0x00000320; 1007 pub const CKM_CAST128_KEY_GEN: CK_MECHANISM_TYPE = 0x00000320; 1008 pub const CKM_CAST5_ECB: CK_MECHANISM_TYPE = 0x00000321; 1009 pub const CKM_CAST128_ECB: CK_MECHANISM_TYPE = 0x00000321; 1010 pub const CKM_CAST5_CBC: CK_MECHANISM_TYPE = CKM_CAST128_CBC; 1011 pub const CKM_CAST128_CBC: CK_MECHANISM_TYPE = 0x00000322; 1012 pub const CKM_CAST5_MAC: CK_MECHANISM_TYPE = CKM_CAST128_MAC; 1013 pub const CKM_CAST128_MAC: CK_MECHANISM_TYPE = 0x00000323; 1014 pub const CKM_CAST5_MAC_GENERAL: CK_MECHANISM_TYPE = CKM_CAST128_MAC_GENERAL; 1015 pub const CKM_CAST128_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000324; 1016 pub const CKM_CAST5_CBC_PAD: CK_MECHANISM_TYPE = CKM_CAST128_CBC_PAD; 1017 pub const CKM_CAST128_CBC_PAD: CK_MECHANISM_TYPE = 0x00000325; 1018 pub const CKM_RC5_KEY_GEN: CK_MECHANISM_TYPE = 0x00000330; 1019 pub const CKM_RC5_ECB: CK_MECHANISM_TYPE = 0x00000331; 1020 pub const CKM_RC5_CBC: CK_MECHANISM_TYPE = 0x00000332; 1021 pub const CKM_RC5_MAC: CK_MECHANISM_TYPE = 0x00000333; 1022 pub const CKM_RC5_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000334; 1023 pub const CKM_RC5_CBC_PAD: CK_MECHANISM_TYPE = 0x00000335; 1024 pub const CKM_IDEA_KEY_GEN: CK_MECHANISM_TYPE = 0x00000340; 1025 pub const CKM_IDEA_ECB: CK_MECHANISM_TYPE = 0x00000341; 1026 pub const CKM_IDEA_CBC: CK_MECHANISM_TYPE = 0x00000342; 1027 pub const CKM_IDEA_MAC: CK_MECHANISM_TYPE = 0x00000343; 1028 pub const CKM_IDEA_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000344; 1029 pub const CKM_IDEA_CBC_PAD: CK_MECHANISM_TYPE = 0x00000345; 1030 pub const CKM_GENERIC_SECRET_KEY_GEN: CK_MECHANISM_TYPE = 0x00000350; 1031 pub const CKM_CONCATENATE_BASE_AND_KEY: CK_MECHANISM_TYPE = 0x00000360; 1032 pub const CKM_CONCATENATE_BASE_AND_DATA: CK_MECHANISM_TYPE = 0x00000362; 1033 pub const CKM_CONCATENATE_DATA_AND_BASE: CK_MECHANISM_TYPE = 0x00000363; 1034 pub const CKM_XOR_BASE_AND_DATA: CK_MECHANISM_TYPE = 0x00000364; 1035 pub const CKM_EXTRACT_KEY_FROM_KEY: CK_MECHANISM_TYPE = 0x00000365; 1036 pub const CKM_SSL3_PRE_MASTER_KEY_GEN: CK_MECHANISM_TYPE = 0x00000370; 1037 pub const CKM_SSL3_MASTER_KEY_DERIVE: CK_MECHANISM_TYPE = 0x00000371; 1038 pub const CKM_SSL3_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 0x00000372; 1039 1040 pub const CKM_SSL3_MASTER_KEY_DERIVE_DH: CK_MECHANISM_TYPE = 0x00000373; 1041 pub const CKM_TLS_PRE_MASTER_KEY_GEN: CK_MECHANISM_TYPE = 0x00000374; 1042 pub const CKM_TLS_MASTER_KEY_DERIVE: CK_MECHANISM_TYPE = 0x00000375; 1043 pub const CKM_TLS_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 0x00000376; 1044 pub const CKM_TLS_MASTER_KEY_DERIVE_DH: CK_MECHANISM_TYPE = 0x00000377; 1045 1046 pub const CKM_TLS_PRF: CK_MECHANISM_TYPE = 0x00000378; 1047 1048 pub const CKM_SSL3_MD5_MAC: CK_MECHANISM_TYPE = 0x00000380; 1049 pub const CKM_SSL3_SHA1_MAC: CK_MECHANISM_TYPE = 0x00000381; 1050 pub const CKM_MD5_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x00000390; 1051 pub const CKM_MD2_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x00000391; 1052 pub const CKM_SHA1_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x00000392; 1053 1054 pub const CKM_SHA256_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x00000393; 1055 pub const CKM_SHA384_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x00000394; 1056 pub const CKM_SHA512_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x00000395; 1057 pub const CKM_SHA224_KEY_DERIVATION: CK_MECHANISM_TYPE = 0x00000396; 1058 1059 pub const CKM_PBE_MD2_DES_CBC: CK_MECHANISM_TYPE = 0x000003A0; 1060 pub const CKM_PBE_MD5_DES_CBC: CK_MECHANISM_TYPE = 0x000003A1; 1061 pub const CKM_PBE_MD5_CAST_CBC: CK_MECHANISM_TYPE = 0x000003A2; 1062 pub const CKM_PBE_MD5_CAST3_CBC: CK_MECHANISM_TYPE = 0x000003A3; 1063 pub const CKM_PBE_MD5_CAST5_CBC: CK_MECHANISM_TYPE = CKM_PBE_MD5_CAST128_CBC; 1064 pub const CKM_PBE_MD5_CAST128_CBC: CK_MECHANISM_TYPE = 0x000003A4; 1065 pub const CKM_PBE_SHA1_CAST5_CBC: CK_MECHANISM_TYPE = CKM_PBE_SHA1_CAST128_CBC; 1066 pub const CKM_PBE_SHA1_CAST128_CBC: CK_MECHANISM_TYPE = 0x000003A5; 1067 pub const CKM_PBE_SHA1_RC4_128: CK_MECHANISM_TYPE = 0x000003A6; 1068 pub const CKM_PBE_SHA1_RC4_40: CK_MECHANISM_TYPE = 0x000003A7; 1069 pub const CKM_PBE_SHA1_DES3_EDE_CBC: CK_MECHANISM_TYPE = 0x000003A8; 1070 pub const CKM_PBE_SHA1_DES2_EDE_CBC: CK_MECHANISM_TYPE = 0x000003A9; 1071 pub const CKM_PBE_SHA1_RC2_128_CBC: CK_MECHANISM_TYPE = 0x000003AA; 1072 pub const CKM_PBE_SHA1_RC2_40_CBC: CK_MECHANISM_TYPE = 0x000003AB; 1073 1074 pub const CKM_PKCS5_PBKD2: CK_MECHANISM_TYPE = 0x000003B0; 1075 1076 pub const CKM_PBA_SHA1_WITH_SHA1_HMAC: CK_MECHANISM_TYPE = 0x000003C0; 1077 1078 pub const CKM_WTLS_PRE_MASTER_KEY_GEN: CK_MECHANISM_TYPE = 0x000003D0; 1079 pub const CKM_WTLS_MASTER_KEY_DERIVE: CK_MECHANISM_TYPE = 0x000003D1; 1080 pub const CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC: CK_MECHANISM_TYPE = 0x000003D2; 1081 pub const CKM_WTLS_PRF: CK_MECHANISM_TYPE = 0x000003D3; 1082 pub const CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 0x000003D4; 1083 pub const CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 0x000003D5; 1084 1085 pub const CKM_TLS10_MAC_SERVER: CK_MECHANISM_TYPE = 0x000003D6; 1086 pub const CKM_TLS10_MAC_CLIENT: CK_MECHANISM_TYPE = 0x000003D7; 1087 pub const CKM_TLS12_MAC: CK_MECHANISM_TYPE = 0x000003D8; 1088 pub const CKM_TLS12_KDF: CK_MECHANISM_TYPE = 0x000003D9; 1089 pub const CKM_TLS12_MASTER_KEY_DERIVE: CK_MECHANISM_TYPE = 0x000003E0; 1090 pub const CKM_TLS12_KEY_AND_MAC_DERIVE: CK_MECHANISM_TYPE = 0x000003E1; 1091 pub const CKM_TLS12_MASTER_KEY_DERIVE_DH: CK_MECHANISM_TYPE = 0x000003E2; 1092 pub const CKM_TLS12_KEY_SAFE_DERIVE: CK_MECHANISM_TYPE = 0x000003E3; 1093 pub const CKM_TLS_MAC: CK_MECHANISM_TYPE = 0x000003E4; 1094 pub const CKM_TLS_KDF: CK_MECHANISM_TYPE = 0x000003E5; 1095 1096 pub const CKM_KEY_WRAP_LYNKS: CK_MECHANISM_TYPE = 0x00000400; 1097 pub const CKM_KEY_WRAP_SET_OAEP: CK_MECHANISM_TYPE = 0x00000401; 1098 1099 pub const CKM_CMS_SIG: CK_MECHANISM_TYPE = 0x00000500; 1100 pub const CKM_KIP_DERIVE: CK_MECHANISM_TYPE = 0x00000510; 1101 pub const CKM_KIP_WRAP: CK_MECHANISM_TYPE = 0x00000511; 1102 pub const CKM_KIP_MAC: CK_MECHANISM_TYPE = 0x00000512; 1103 1104 pub const CKM_CAMELLIA_KEY_GEN: CK_MECHANISM_TYPE = 0x00000550; 1105 pub const CKM_CAMELLIA_ECB: CK_MECHANISM_TYPE = 0x00000551; 1106 pub const CKM_CAMELLIA_CBC: CK_MECHANISM_TYPE = 0x00000552; 1107 pub const CKM_CAMELLIA_MAC: CK_MECHANISM_TYPE = 0x00000553; 1108 pub const CKM_CAMELLIA_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000554; 1109 pub const CKM_CAMELLIA_CBC_PAD: CK_MECHANISM_TYPE = 0x00000555; 1110 pub const CKM_CAMELLIA_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00000556; 1111 pub const CKM_CAMELLIA_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00000557; 1112 pub const CKM_CAMELLIA_CTR: CK_MECHANISM_TYPE = 0x00000558; 1113 1114 pub const CKM_ARIA_KEY_GEN: CK_MECHANISM_TYPE = 0x00000560; 1115 pub const CKM_ARIA_ECB: CK_MECHANISM_TYPE = 0x00000561; 1116 pub const CKM_ARIA_CBC: CK_MECHANISM_TYPE = 0x00000562; 1117 pub const CKM_ARIA_MAC: CK_MECHANISM_TYPE = 0x00000563; 1118 pub const CKM_ARIA_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000564; 1119 pub const CKM_ARIA_CBC_PAD: CK_MECHANISM_TYPE = 0x00000565; 1120 pub const CKM_ARIA_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00000566; 1121 pub const CKM_ARIA_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00000567; 1122 1123 pub const CKM_SEED_KEY_GEN: CK_MECHANISM_TYPE = 0x00000650; 1124 pub const CKM_SEED_ECB: CK_MECHANISM_TYPE = 0x00000651; 1125 pub const CKM_SEED_CBC: CK_MECHANISM_TYPE = 0x00000652; 1126 pub const CKM_SEED_MAC: CK_MECHANISM_TYPE = 0x00000653; 1127 pub const CKM_SEED_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00000654; 1128 pub const CKM_SEED_CBC_PAD: CK_MECHANISM_TYPE = 0x00000655; 1129 pub const CKM_SEED_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00000656; 1130 pub const CKM_SEED_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00000657; 1131 1132 pub const CKM_SKIPJACK_KEY_GEN: CK_MECHANISM_TYPE = 0x00001000; 1133 pub const CKM_SKIPJACK_ECB64: CK_MECHANISM_TYPE = 0x00001001; 1134 pub const CKM_SKIPJACK_CBC64: CK_MECHANISM_TYPE = 0x00001002; 1135 pub const CKM_SKIPJACK_OFB64: CK_MECHANISM_TYPE = 0x00001003; 1136 pub const CKM_SKIPJACK_CFB64: CK_MECHANISM_TYPE = 0x00001004; 1137 pub const CKM_SKIPJACK_CFB32: CK_MECHANISM_TYPE = 0x00001005; 1138 pub const CKM_SKIPJACK_CFB16: CK_MECHANISM_TYPE = 0x00001006; 1139 pub const CKM_SKIPJACK_CFB8: CK_MECHANISM_TYPE = 0x00001007; 1140 pub const CKM_SKIPJACK_WRAP: CK_MECHANISM_TYPE = 0x00001008; 1141 pub const CKM_SKIPJACK_PRIVATE_WRAP: CK_MECHANISM_TYPE = 0x00001009; 1142 pub const CKM_SKIPJACK_RELAYX: CK_MECHANISM_TYPE = 0x0000100a; 1143 pub const CKM_KEA_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0x00001010; 1144 pub const CKM_KEA_KEY_DERIVE: CK_MECHANISM_TYPE = 0x00001011; 1145 pub const CKM_KEA_DERIVE: CK_MECHANISM_TYPE = 0x00001012; 1146 pub const CKM_FORTEZZA_TIMESTAMP: CK_MECHANISM_TYPE = 0x00001020; 1147 pub const CKM_BATON_KEY_GEN: CK_MECHANISM_TYPE = 0x00001030; 1148 pub const CKM_BATON_ECB128: CK_MECHANISM_TYPE = 0x00001031; 1149 pub const CKM_BATON_ECB96: CK_MECHANISM_TYPE = 0x00001032; 1150 pub const CKM_BATON_CBC128: CK_MECHANISM_TYPE = 0x00001033; 1151 pub const CKM_BATON_COUNTER: CK_MECHANISM_TYPE = 0x00001034; 1152 pub const CKM_BATON_SHUFFLE: CK_MECHANISM_TYPE = 0x00001035; 1153 pub const CKM_BATON_WRAP: CK_MECHANISM_TYPE = 0x00001036; 1154 1155 pub const CKM_ECDSA_KEY_PAIR_GEN: CK_MECHANISM_TYPE = CKM_EC_KEY_PAIR_GEN; 1156 pub const CKM_EC_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0x00001040; 1157 1158 pub const CKM_ECDSA: CK_MECHANISM_TYPE = 0x00001041; 1159 pub const CKM_ECDSA_SHA1: CK_MECHANISM_TYPE = 0x00001042; 1160 pub const CKM_ECDSA_SHA224: CK_MECHANISM_TYPE = 0x00001043; 1161 pub const CKM_ECDSA_SHA256: CK_MECHANISM_TYPE = 0x00001044; 1162 pub const CKM_ECDSA_SHA384: CK_MECHANISM_TYPE = 0x00001045; 1163 pub const CKM_ECDSA_SHA512: CK_MECHANISM_TYPE = 0x00001046; 1164 1165 pub const CKM_ECDH1_DERIVE: CK_MECHANISM_TYPE = 0x00001050; 1166 pub const CKM_ECDH1_COFACTOR_DERIVE: CK_MECHANISM_TYPE = 0x00001051; 1167 pub const CKM_ECMQV_DERIVE: CK_MECHANISM_TYPE = 0x00001052; 1168 1169 pub const CKM_ECDH_AES_KEY_WRAP: CK_MECHANISM_TYPE = 0x00001053; 1170 pub const CKM_RSA_AES_KEY_WRAP: CK_MECHANISM_TYPE = 0x00001054; 1171 1172 pub const CKM_JUNIPER_KEY_GEN: CK_MECHANISM_TYPE = 0x00001060; 1173 pub const CKM_JUNIPER_ECB128: CK_MECHANISM_TYPE = 0x00001061; 1174 pub const CKM_JUNIPER_CBC128: CK_MECHANISM_TYPE = 0x00001062; 1175 pub const CKM_JUNIPER_COUNTER: CK_MECHANISM_TYPE = 0x00001063; 1176 pub const CKM_JUNIPER_SHUFFLE: CK_MECHANISM_TYPE = 0x00001064; 1177 pub const CKM_JUNIPER_WRAP: CK_MECHANISM_TYPE = 0x00001065; 1178 pub const CKM_FASTHASH: CK_MECHANISM_TYPE = 0x00001070; 1179 1180 pub const CKM_AES_KEY_GEN: CK_MECHANISM_TYPE = 0x00001080; 1181 pub const CKM_AES_ECB: CK_MECHANISM_TYPE = 0x00001081; 1182 pub const CKM_AES_CBC: CK_MECHANISM_TYPE = 0x00001082; 1183 pub const CKM_AES_MAC: CK_MECHANISM_TYPE = 0x00001083; 1184 pub const CKM_AES_MAC_GENERAL: CK_MECHANISM_TYPE = 0x00001084; 1185 pub const CKM_AES_CBC_PAD: CK_MECHANISM_TYPE = 0x00001085; 1186 pub const CKM_AES_CTR: CK_MECHANISM_TYPE = 0x00001086; 1187 pub const CKM_AES_GCM: CK_MECHANISM_TYPE = 0x00001087; 1188 pub const CKM_AES_CCM: CK_MECHANISM_TYPE = 0x00001088; 1189 pub const CKM_AES_CTS: CK_MECHANISM_TYPE = 0x00001089; 1190 pub const CKM_AES_CMAC: CK_MECHANISM_TYPE = 0x0000108A; 1191 pub const CKM_AES_CMAC_GENERAL: CK_MECHANISM_TYPE = 0x0000108B; 1192 1193 pub const CKM_AES_XCBC_MAC: CK_MECHANISM_TYPE = 0x0000108C; 1194 pub const CKM_AES_XCBC_MAC_96: CK_MECHANISM_TYPE = 0x0000108D; 1195 pub const CKM_AES_GMAC: CK_MECHANISM_TYPE = 0x0000108E; 1196 1197 pub const CKM_BLOWFISH_KEY_GEN: CK_MECHANISM_TYPE = 0x00001090; 1198 pub const CKM_BLOWFISH_CBC: CK_MECHANISM_TYPE = 0x00001091; 1199 pub const CKM_TWOFISH_KEY_GEN: CK_MECHANISM_TYPE = 0x00001092; 1200 pub const CKM_TWOFISH_CBC: CK_MECHANISM_TYPE = 0x00001093; 1201 pub const CKM_BLOWFISH_CBC_PAD: CK_MECHANISM_TYPE = 0x00001094; 1202 pub const CKM_TWOFISH_CBC_PAD: CK_MECHANISM_TYPE = 0x00001095; 1203 1204 pub const CKM_DES_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00001100; 1205 pub const CKM_DES_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00001101; 1206 pub const CKM_DES3_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00001102; 1207 pub const CKM_DES3_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00001103; 1208 pub const CKM_AES_ECB_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00001104; 1209 pub const CKM_AES_CBC_ENCRYPT_DATA: CK_MECHANISM_TYPE = 0x00001105; 1210 1211 pub const CKM_GOSTR3410_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 0x00001200; 1212 pub const CKM_GOSTR3410: CK_MECHANISM_TYPE = 0x00001201; 1213 pub const CKM_GOSTR3410_WITH_GOSTR3411: CK_MECHANISM_TYPE = 0x00001202; 1214 pub const CKM_GOSTR3410_KEY_WRAP: CK_MECHANISM_TYPE = 0x00001203; 1215 pub const CKM_GOSTR3410_DERIVE: CK_MECHANISM_TYPE = 0x00001204; 1216 pub const CKM_GOSTR3411: CK_MECHANISM_TYPE = 0x00001210; 1217 pub const CKM_GOSTR3411_HMAC: CK_MECHANISM_TYPE = 0x00001211; 1218 pub const CKM_GOST28147_KEY_GEN: CK_MECHANISM_TYPE = 0x00001220; 1219 pub const CKM_GOST28147_ECB: CK_MECHANISM_TYPE = 0x00001221; 1220 pub const CKM_GOST28147: CK_MECHANISM_TYPE = 0x00001222; 1221 pub const CKM_GOST28147_MAC: CK_MECHANISM_TYPE = 0x00001223; 1222 pub const CKM_GOST28147_KEY_WRAP: CK_MECHANISM_TYPE = 0x00001224; 1223 1224 pub const CKM_DSA_PARAMETER_GEN: CK_MECHANISM_TYPE = 0x00002000; 1225 pub const CKM_DH_PKCS_PARAMETER_GEN: CK_MECHANISM_TYPE = 0x00002001; 1226 pub const CKM_X9_42_DH_PARAMETER_GEN: CK_MECHANISM_TYPE = 0x00002002; 1227 pub const CKM_DSA_PROBABLISTIC_PARAMETER_GEN: CK_MECHANISM_TYPE = 0x00002003; 1228 pub const CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN: CK_MECHANISM_TYPE = 0x00002004; 1229 1230 pub const CKM_AES_OFB: CK_MECHANISM_TYPE = 0x00002104; 1231 pub const CKM_AES_CFB64: CK_MECHANISM_TYPE = 0x00002105; 1232 pub const CKM_AES_CFB8: CK_MECHANISM_TYPE = 0x00002106; 1233 pub const CKM_AES_CFB128: CK_MECHANISM_TYPE = 0x00002107; 1234 1235 pub const CKM_AES_CFB1: CK_MECHANISM_TYPE = 0x00002108; 1236 /// WAS: 0x00001090 1237 pub const CKM_AES_KEY_WRAP: CK_MECHANISM_TYPE = 0x00002109; 1238 /// WAS: 0x00001091 1239 pub const CKM_AES_KEY_WRAP_PAD: CK_MECHANISM_TYPE = 0x0000210A; 1240 1241 pub const CKM_RSA_PKCS_TPM_1_1: CK_MECHANISM_TYPE = 0x00004001; 1242 pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 0x00004002; 1243 1244 pub const CKM_VENDOR_DEFINED: CK_MECHANISM_TYPE = 0x80000000; 1245 1246 pub type CK_MECHANISM_TYPE_PTR = *mut CK_MECHANISM_TYPE; 1247 1248 cryptoki_aligned! { 1249 /// CK_MECHANISM is a structure that specifies a particular 1250 /// mechanism 1251 #[derive(Debug, Copy)] 1252 pub struct CK_MECHANISM { 1253 pub mechanism: CK_MECHANISM_TYPE, 1254 pub pParameter: CK_VOID_PTR, 1255 /// in bytes 1256 pub ulParameterLen: CK_ULONG, 1257 } 1258 } 1259 packed_clone!(CK_MECHANISM); 1260 1261 pub type CK_MECHANISM_PTR = *mut CK_MECHANISM; 1262 1263 cryptoki_aligned! { 1264 /// CK_MECHANISM_INFO provides information about a particular 1265 /// mechanism 1266 #[derive(Debug, Default, Copy)] 1267 pub struct CK_MECHANISM_INFO { 1268 pub ulMinKeySize: CK_ULONG, 1269 pub ulMaxKeySize: CK_ULONG, 1270 pub flags: CK_FLAGS, 1271 } 1272 } 1273 packed_clone!(CK_MECHANISM_INFO); 1274 1275 /// The flags are defined as follows: 1276 pub const CKF_HW: CK_FLAGS = 0x00000001; /* performed by HW */ 1277 1278 /// Specify whether or not a mechanism can be used for a particular task 1279 pub const CKF_ENCRYPT: CK_FLAGS = 0x00000100; 1280 pub const CKF_DECRYPT: CK_FLAGS = 0x00000200; 1281 pub const CKF_DIGEST: CK_FLAGS = 0x00000400; 1282 pub const CKF_SIGN: CK_FLAGS = 0x00000800; 1283 pub const CKF_SIGN_RECOVER: CK_FLAGS = 0x00001000; 1284 pub const CKF_VERIFY: CK_FLAGS = 0x00002000; 1285 pub const CKF_VERIFY_RECOVER: CK_FLAGS = 0x00004000; 1286 pub const CKF_GENERATE: CK_FLAGS = 0x00008000; 1287 pub const CKF_GENERATE_KEY_PAIR: CK_FLAGS = 0x00010000; 1288 pub const CKF_WRAP: CK_FLAGS = 0x00020000; 1289 pub const CKF_UNWRAP: CK_FLAGS = 0x00040000; 1290 pub const CKF_DERIVE: CK_FLAGS = 0x00080000; 1291 1292 /// Describe a token's EC capabilities not available in mechanism 1293 /// information. 1294 pub const CKF_EC_F_P: CK_FLAGS = 0x00100000; 1295 pub const CKF_EC_F_2M: CK_FLAGS = 0x00200000; 1296 pub const CKF_EC_ECPARAMETERS: CK_FLAGS = 0x00400000; 1297 pub const CKF_EC_NAMEDCURVE: CK_FLAGS = 0x00800000; 1298 pub const CKF_EC_UNCOMPRESS: CK_FLAGS = 0x01000000; 1299 pub const CKF_EC_COMPRESS: CK_FLAGS = 0x02000000; 1300 1301 pub const CKF_EXTENSION: CK_FLAGS = 0x80000000; 1302 1303 pub type CK_MECHANISM_INFO_PTR = *mut CK_MECHANISM_INFO; 1304 1305 /// CK_RV is a value that identifies the return value of a 1306 /// Cryptoki function 1307 pub type CK_RV = CK_ULONG; 1308 pub const CKR_OK: CK_RV = 0x00000000; 1309 pub const CKR_CANCEL: CK_RV = 0x00000001; 1310 pub const CKR_HOST_MEMORY: CK_RV = 0x00000002; 1311 pub const CKR_SLOT_ID_INVALID: CK_RV = 0x00000003; 1312 pub const CKR_GENERAL_ERROR: CK_RV = 0x00000005; 1313 pub const CKR_FUNCTION_FAILED: CK_RV = 0x00000006; 1314 pub const CKR_ARGUMENTS_BAD: CK_RV = 0x00000007; 1315 pub const CKR_NO_EVENT: CK_RV = 0x00000008; 1316 pub const CKR_NEED_TO_CREATE_THREADS: CK_RV = 0x00000009; 1317 pub const CKR_CANT_LOCK: CK_RV = 0x0000000A; 1318 pub const CKR_ATTRIBUTE_READ_ONLY: CK_RV = 0x00000010; 1319 pub const CKR_ATTRIBUTE_SENSITIVE: CK_RV = 0x00000011; 1320 pub const CKR_ATTRIBUTE_TYPE_INVALID: CK_RV = 0x00000012; 1321 pub const CKR_ATTRIBUTE_VALUE_INVALID: CK_RV = 0x00000013; 1322 pub const CKR_ACTION_PROHIBITED: CK_RV = 0x0000001B; 1323 pub const CKR_DATA_INVALID: CK_RV = 0x00000020; 1324 pub const CKR_DATA_LEN_RANGE: CK_RV = 0x00000021; 1325 pub const CKR_DEVICE_ERROR: CK_RV = 0x00000030; 1326 pub const CKR_DEVICE_MEMORY: CK_RV = 0x00000031; 1327 pub const CKR_DEVICE_REMOVED: CK_RV = 0x00000032; 1328 pub const CKR_ENCRYPTED_DATA_INVALID: CK_RV = 0x00000040; 1329 pub const CKR_ENCRYPTED_DATA_LEN_RANGE: CK_RV = 0x00000041; 1330 pub const CKR_FUNCTION_CANCELED: CK_RV = 0x00000050; 1331 pub const CKR_FUNCTION_NOT_PARALLEL: CK_RV = 0x00000051; 1332 pub const CKR_FUNCTION_NOT_SUPPORTED: CK_RV = 0x00000054; 1333 pub const CKR_KEY_HANDLE_INVALID: CK_RV = 0x00000060; 1334 pub const CKR_KEY_SIZE_RANGE: CK_RV = 0x00000062; 1335 pub const CKR_KEY_TYPE_INCONSISTENT: CK_RV = 0x00000063; 1336 pub const CKR_KEY_NOT_NEEDED: CK_RV = 0x00000064; 1337 pub const CKR_KEY_CHANGED: CK_RV = 0x00000065; 1338 pub const CKR_KEY_NEEDED: CK_RV = 0x00000066; 1339 pub const CKR_KEY_INDIGESTIBLE: CK_RV = 0x00000067; 1340 pub const CKR_KEY_FUNCTION_NOT_PERMITTED: CK_RV = 0x00000068; 1341 pub const CKR_KEY_NOT_WRAPPABLE: CK_RV = 0x00000069; 1342 pub const CKR_KEY_UNEXTRACTABLE: CK_RV = 0x0000006A; 1343 pub const CKR_MECHANISM_INVALID: CK_RV = 0x00000070; 1344 pub const CKR_MECHANISM_PARAM_INVALID: CK_RV = 0x00000071; 1345 pub const CKR_OBJECT_HANDLE_INVALID: CK_RV = 0x00000082; 1346 pub const CKR_OPERATION_ACTIVE: CK_RV = 0x00000090; 1347 pub const CKR_OPERATION_NOT_INITIALIZED: CK_RV = 0x00000091; 1348 pub const CKR_PIN_INCORRECT: CK_RV = 0x000000A0; 1349 pub const CKR_PIN_INVALID: CK_RV = 0x000000A1; 1350 pub const CKR_PIN_LEN_RANGE: CK_RV = 0x000000A2; 1351 pub const CKR_PIN_EXPIRED: CK_RV = 0x000000A3; 1352 pub const CKR_PIN_LOCKED: CK_RV = 0x000000A4; 1353 pub const CKR_SESSION_CLOSED: CK_RV = 0x000000B0; 1354 pub const CKR_SESSION_COUNT: CK_RV = 0x000000B1; 1355 pub const CKR_SESSION_HANDLE_INVALID: CK_RV = 0x000000B3; 1356 pub const CKR_SESSION_PARALLEL_NOT_SUPPORTED: CK_RV = 0x000000B4; 1357 pub const CKR_SESSION_READ_ONLY: CK_RV = 0x000000B5; 1358 pub const CKR_SESSION_EXISTS: CK_RV = 0x000000B6; 1359 pub const CKR_SESSION_READ_ONLY_EXISTS: CK_RV = 0x000000B7; 1360 pub const CKR_SESSION_READ_WRITE_SO_EXISTS: CK_RV = 0x000000B8; 1361 pub const CKR_SIGNATURE_INVALID: CK_RV = 0x000000C0; 1362 pub const CKR_SIGNATURE_LEN_RANGE: CK_RV = 0x000000C1; 1363 pub const CKR_TEMPLATE_INCOMPLETE: CK_RV = 0x000000D0; 1364 pub const CKR_TEMPLATE_INCONSISTENT: CK_RV = 0x000000D1; 1365 pub const CKR_TOKEN_NOT_PRESENT: CK_RV = 0x000000E0; 1366 pub const CKR_TOKEN_NOT_RECOGNIZED: CK_RV = 0x000000E1; 1367 pub const CKR_TOKEN_WRITE_PROTECTED: CK_RV = 0x000000E2; 1368 pub const CKR_UNWRAPPING_KEY_HANDLE_INVALID: CK_RV = 0x000000F0; 1369 pub const CKR_UNWRAPPING_KEY_SIZE_RANGE: CK_RV = 0x000000F1; 1370 pub const CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT: CK_RV = 0x000000F2; 1371 pub const CKR_USER_ALREADY_LOGGED_IN: CK_RV = 0x00000100; 1372 pub const CKR_USER_NOT_LOGGED_IN: CK_RV = 0x00000101; 1373 pub const CKR_USER_PIN_NOT_INITIALIZED: CK_RV = 0x00000102; 1374 pub const CKR_USER_TYPE_INVALID: CK_RV = 0x00000103; 1375 pub const CKR_USER_ANOTHER_ALREADY_LOGGED_IN: CK_RV = 0x00000104; 1376 pub const CKR_USER_TOO_MANY_TYPES: CK_RV = 0x00000105; 1377 pub const CKR_WRAPPED_KEY_INVALID: CK_RV = 0x00000110; 1378 pub const CKR_WRAPPED_KEY_LEN_RANGE: CK_RV = 0x00000112; 1379 pub const CKR_WRAPPING_KEY_HANDLE_INVALID: CK_RV = 0x00000113; 1380 pub const CKR_WRAPPING_KEY_SIZE_RANGE: CK_RV = 0x00000114; 1381 pub const CKR_WRAPPING_KEY_TYPE_INCONSISTENT: CK_RV = 0x00000115; 1382 pub const CKR_RANDOM_SEED_NOT_SUPPORTED: CK_RV = 0x00000120; 1383 pub const CKR_RANDOM_NO_RNG: CK_RV = 0x00000121; 1384 pub const CKR_DOMAIN_PARAMS_INVALID: CK_RV = 0x00000130; 1385 pub const CKR_CURVE_NOT_SUPPORTED: CK_RV = 0x00000140; 1386 pub const CKR_BUFFER_TOO_SMALL: CK_RV = 0x00000150; 1387 pub const CKR_SAVED_STATE_INVALID: CK_RV = 0x00000160; 1388 pub const CKR_INFORMATION_SENSITIVE: CK_RV = 0x00000170; 1389 pub const CKR_STATE_UNSAVEABLE: CK_RV = 0x00000180; 1390 pub const CKR_CRYPTOKI_NOT_INITIALIZED: CK_RV = 0x00000190; 1391 pub const CKR_CRYPTOKI_ALREADY_INITIALIZED: CK_RV = 0x00000191; 1392 pub const CKR_MUTEX_BAD: CK_RV = 0x000001A0; 1393 pub const CKR_MUTEX_NOT_LOCKED: CK_RV = 0x000001A1; 1394 pub const CKR_NEW_PIN_MODE: CK_RV = 0x000001B0; 1395 pub const CKR_NEXT_OTP: CK_RV = 0x000001B1; 1396 pub const CKR_EXCEEDED_MAX_ITERATIONS: CK_RV = 0x000001B5; 1397 pub const CKR_FIPS_SELF_TEST_FAILED: CK_RV = 0x000001B6; 1398 pub const CKR_LIBRARY_LOAD_FAILED: CK_RV = 0x000001B7; 1399 pub const CKR_PIN_TOO_WEAK: CK_RV = 0x000001B8; 1400 pub const CKR_PUBLIC_KEY_INVALID: CK_RV = 0x000001B9; 1401 pub const CKR_FUNCTION_REJECTED: CK_RV = 0x00000200; 1402 pub const CKR_VENDOR_DEFINED: CK_RV = 0x80000000; 1403 1404 /// CK_NOTIFY is an application callback that processes events 1405 pub type CK_NOTIFY = Option<extern "C" fn(CK_SESSION_HANDLE, CK_NOTIFICATION, CK_VOID_PTR) -> CK_RV>; 1406 1407 cryptoki_aligned! { 1408 /// CK_FUNCTION_LIST is a structure holding a Cryptoki spec 1409 /// version and pointers of appropriate types to all the 1410 /// Cryptoki functions 1411 #[derive(Debug, Copy)] 1412 pub struct CK_FUNCTION_LIST { 1413 pub version: CK_VERSION, 1414 pub C_Initialize: Option<C_Initialize>, 1415 pub C_Finalize: Option<C_Finalize>, 1416 pub C_GetInfo: Option<C_GetInfo>, 1417 pub C_GetFunctionList: Option<C_GetFunctionList>, 1418 pub C_GetSlotList: Option<C_GetSlotList>, 1419 pub C_GetSlotInfo: Option<C_GetSlotInfo>, 1420 pub C_GetTokenInfo: Option<C_GetTokenInfo>, 1421 pub C_GetMechanismList: Option<C_GetMechanismList>, 1422 pub C_GetMechanismInfo: Option<C_GetMechanismInfo>, 1423 pub C_InitToken: Option<C_InitToken>, 1424 pub C_InitPIN: Option<C_InitPIN>, 1425 pub C_SetPIN: Option<C_SetPIN>, 1426 pub C_OpenSession: Option<C_OpenSession>, 1427 pub C_CloseSession: Option<C_CloseSession>, 1428 pub C_CloseAllSessions: Option<C_CloseAllSessions>, 1429 pub C_GetSessionInfo: Option<C_GetSessionInfo>, 1430 pub C_GetOperationState: Option<C_GetOperationState>, 1431 pub C_SetOperationState: Option<C_SetOperationState>, 1432 pub C_Login: Option<C_Login>, 1433 pub C_Logout: Option<C_Logout>, 1434 pub C_CreateObject: Option<C_CreateObject>, 1435 pub C_CopyObject: Option<C_CopyObject>, 1436 pub C_DestroyObject: Option<C_DestroyObject>, 1437 pub C_GetObjectSize: Option<C_GetObjectSize>, 1438 pub C_GetAttributeValue: Option<C_GetAttributeValue>, 1439 pub C_SetAttributeValue: Option<C_SetAttributeValue>, 1440 pub C_FindObjectsInit: Option<C_FindObjectsInit>, 1441 pub C_FindObjects: Option<C_FindObjects>, 1442 pub C_FindObjectsFinal: Option<C_FindObjectsFinal>, 1443 pub C_EncryptInit: Option<C_EncryptInit>, 1444 pub C_Encrypt: Option<C_Encrypt>, 1445 pub C_EncryptUpdate: Option<C_EncryptUpdate>, 1446 pub C_EncryptFinal: Option<C_EncryptFinal>, 1447 pub C_DecryptInit: Option<C_DecryptInit>, 1448 pub C_Decrypt: Option<C_Decrypt>, 1449 pub C_DecryptUpdate: Option<C_DecryptUpdate>, 1450 pub C_DecryptFinal: Option<C_DecryptFinal>, 1451 pub C_DigestInit: Option<C_DigestInit>, 1452 pub C_Digest: Option<C_Digest>, 1453 pub C_DigestUpdate: Option<C_DigestUpdate>, 1454 pub C_DigestKey: Option<C_DigestKey>, 1455 pub C_DigestFinal: Option<C_DigestFinal>, 1456 pub C_SignInit: Option<C_SignInit>, 1457 pub C_Sign: Option<C_Sign>, 1458 pub C_SignUpdate: Option<C_SignUpdate>, 1459 pub C_SignFinal: Option<C_SignFinal>, 1460 pub C_SignRecoverInit: Option<C_SignRecoverInit>, 1461 pub C_SignRecover: Option<C_SignRecover>, 1462 pub C_VerifyInit: Option<C_VerifyInit>, 1463 pub C_Verify: Option<C_Verify>, 1464 pub C_VerifyUpdate: Option<C_VerifyUpdate>, 1465 pub C_VerifyFinal: Option<C_VerifyFinal>, 1466 pub C_VerifyRecoverInit: Option<C_VerifyRecoverInit>, 1467 pub C_VerifyRecover: Option<C_VerifyRecover>, 1468 pub C_DigestEncryptUpdate: Option<C_DigestEncryptUpdate>, 1469 pub C_DecryptDigestUpdate: Option<C_DecryptDigestUpdate>, 1470 pub C_SignEncryptUpdate: Option<C_SignEncryptUpdate>, 1471 pub C_DecryptVerifyUpdate: Option<C_DecryptVerifyUpdate>, 1472 pub C_GenerateKey: Option<C_GenerateKey>, 1473 pub C_GenerateKeyPair: Option<C_GenerateKeyPair>, 1474 pub C_WrapKey: Option<C_WrapKey>, 1475 pub C_UnwrapKey: Option<C_UnwrapKey>, 1476 pub C_DeriveKey: Option<C_DeriveKey>, 1477 pub C_SeedRandom: Option<C_SeedRandom>, 1478 pub C_GenerateRandom: Option<C_GenerateRandom>, 1479 pub C_GetFunctionStatus: Option<C_GetFunctionStatus>, 1480 pub C_CancelFunction: Option<C_CancelFunction>, 1481 pub C_WaitForSlotEvent: Option<C_WaitForSlotEvent>, 1482 } 1483 } 1484 packed_clone!(CK_FUNCTION_LIST); 1485 pub type CK_FUNCTION_LIST_PTR = *mut CK_FUNCTION_LIST; 1486 pub type CK_FUNCTION_LIST_PTR_PTR = *mut CK_FUNCTION_LIST_PTR; 1487 1488 /// CK_CREATEMUTEX is an application callback for creating a 1489 /// mutex object 1490 pub type CK_CREATEMUTEX = Option<extern "C" fn(CK_VOID_PTR_PTR) -> CK_RV>; 1491 /// CK_DESTROYMUTEX is an application callback for destroying a 1492 /// mutex object 1493 pub type CK_DESTROYMUTEX = Option<extern "C" fn(CK_VOID_PTR) -> CK_RV>; 1494 /// CK_LOCKMUTEX is an application callback for locking a mutex 1495 pub type CK_LOCKMUTEX = Option<extern "C" fn(CK_VOID_PTR) -> CK_RV>; 1496 /// CK_UNLOCKMUTEX is an application callback for unlocking a 1497 /// mutex 1498 pub type CK_UNLOCKMUTEX = Option<extern "C" fn(CK_VOID_PTR) -> CK_RV>; 1499 1500 cryptoki_aligned! { 1501 /// CK_C_INITIALIZE_ARGS provides the optional arguments to 1502 /// C_Initialize 1503 #[derive(Debug, Copy)] 1504 pub struct CK_C_INITIALIZE_ARGS { 1505 pub CreateMutex: CK_CREATEMUTEX, 1506 pub DestroyMutex: CK_DESTROYMUTEX, 1507 pub LockMutex: CK_LOCKMUTEX, 1508 pub UnlockMutex: CK_UNLOCKMUTEX, 1509 pub flags: CK_FLAGS, 1510 pub pReserved: CK_VOID_PTR, 1511 } 1512 } 1513 packed_clone!(CK_C_INITIALIZE_ARGS); 1514 1515 // TODO: we need to make this the default and implement a new 1516 // function 1517 impl Default for CK_C_INITIALIZE_ARGS { default() -> Self1518 fn default() -> Self { 1519 Self::new() 1520 } 1521 } 1522 1523 impl CK_C_INITIALIZE_ARGS { new() -> CK_C_INITIALIZE_ARGS1524 pub fn new() -> CK_C_INITIALIZE_ARGS { 1525 CK_C_INITIALIZE_ARGS { 1526 flags: CKF_OS_LOCKING_OK, 1527 CreateMutex: None, 1528 DestroyMutex: None, 1529 LockMutex: None, 1530 UnlockMutex: None, 1531 pReserved: ptr::null_mut(), 1532 } 1533 } 1534 } 1535 1536 pub const CKF_LIBRARY_CANT_CREATE_OS_THREADS: CK_FLAGS = 0x00000001; 1537 pub const CKF_OS_LOCKING_OK: CK_FLAGS = 0x00000002; 1538 1539 pub type CK_C_INITIALIZE_ARGS_PTR = *mut CK_C_INITIALIZE_ARGS; 1540 1541 /// CKF_DONT_BLOCK is for the function C_WaitForSlotEvent 1542 pub const CKF_DONT_BLOCK: CK_FLAGS = 1; 1543 1544 /// CK_RSA_PKCS_MGF_TYPE is used to indicate the Message 1545 /// Generation Function (MGF) applied to a message block when 1546 /// formatting a message block for the PKCS #1 OAEP encryption 1547 /// scheme. 1548 pub type CK_RSA_PKCS_MGF_TYPE = CK_ULONG; 1549 1550 pub type CK_RSA_PKCS_MGF_TYPE_PTR = *mut CK_RSA_PKCS_MGF_TYPE; 1551 1552 /// The following MGFs are defined 1553 pub const CKG_MGF1_SHA1: CK_RSA_PKCS_MGF_TYPE = 0x00000001; 1554 pub const CKG_MGF1_SHA256: CK_RSA_PKCS_MGF_TYPE = 0x00000002; 1555 pub const CKG_MGF1_SHA384: CK_RSA_PKCS_MGF_TYPE = 0x00000003; 1556 pub const CKG_MGF1_SHA512: CK_RSA_PKCS_MGF_TYPE = 0x00000004; 1557 pub const CKG_MGF1_SHA224: CK_RSA_PKCS_MGF_TYPE = 0x00000005; 1558 1559 /// CK_RSA_PKCS_OAEP_SOURCE_TYPE is used to indicate the source 1560 /// of the encoding parameter when formatting a message block 1561 /// for the PKCS #1 OAEP encryption scheme. 1562 pub type CK_RSA_PKCS_OAEP_SOURCE_TYPE = CK_ULONG; 1563 1564 pub type CK_RSA_PKCS_OAEP_SOURCE_TYPE_PTR = *mut CK_RSA_PKCS_OAEP_SOURCE_TYPE; 1565 1566 /// The following encoding parameter sources are defined 1567 pub const CKZ_DATA_SPECIFIED: CK_RSA_PKCS_OAEP_SOURCE_TYPE = 0x00000001; 1568 1569 cryptoki_aligned! { 1570 /// CK_RSA_PKCS_OAEP_PARAMS provides the parameters to the 1571 /// CKM_RSA_PKCS_OAEP mechanism. 1572 #[derive(Debug, Copy)] 1573 pub struct CK_RSA_PKCS_OAEP_PARAMS { 1574 pub hashAlg: CK_MECHANISM_TYPE, 1575 pub mgf: CK_RSA_PKCS_MGF_TYPE, 1576 pub source: CK_RSA_PKCS_OAEP_SOURCE_TYPE, 1577 pub pSourceData: CK_VOID_PTR, 1578 pub ulSourceDataLen: CK_ULONG, 1579 } 1580 } 1581 packed_clone!(CK_RSA_PKCS_OAEP_PARAMS); 1582 1583 pub type CK_RSA_PKCS_OAEP_PARAMS_PTR = *mut CK_RSA_PKCS_OAEP_PARAMS; 1584 1585 cryptoki_aligned! { 1586 /// CK_RSA_PKCS_PSS_PARAMS provides the parameters to the 1587 /// CKM_RSA_PKCS_PSS mechanism(s). 1588 #[derive(Debug, Copy)] 1589 pub struct CK_RSA_PKCS_PSS_PARAMS { 1590 pub hashAlg: CK_MECHANISM_TYPE, 1591 pub mgf: CK_RSA_PKCS_MGF_TYPE, 1592 pub sLen: CK_ULONG, 1593 } 1594 } 1595 packed_clone!(CK_RSA_PKCS_PSS_PARAMS); 1596 1597 pub type CK_RSA_PKCS_PSS_PARAMS_PTR = *mut CK_RSA_PKCS_PSS_PARAMS; 1598 1599 pub type CK_EC_KDF_TYPE = CK_ULONG; 1600 1601 /* The following EC Key Derivation Functions are defined */ 1602 pub const CKD_NULL: CK_EC_KDF_TYPE = 0x00000001; 1603 pub const CKD_SHA1_KDF: CK_EC_KDF_TYPE = 0x00000002; 1604 1605 /* The following X9.42 DH key derivation functions are defined */ 1606 pub const CKD_SHA1_KDF_ASN1: CK_X9_42_DH_KDF_TYPE = 0x00000003; 1607 pub const CKD_SHA1_KDF_CONCATENATE: CK_X9_42_DH_KDF_TYPE = 0x00000004; 1608 pub const CKD_SHA224_KDF: CK_X9_42_DH_KDF_TYPE = 0x00000005; 1609 pub const CKD_SHA256_KDF: CK_X9_42_DH_KDF_TYPE = 0x00000006; 1610 pub const CKD_SHA384_KDF: CK_X9_42_DH_KDF_TYPE = 0x00000007; 1611 pub const CKD_SHA512_KDF: CK_X9_42_DH_KDF_TYPE = 0x00000008; 1612 pub const CKD_CPDIVERSIFY_KDF: CK_X9_42_DH_KDF_TYPE = 0x00000009; 1613 1614 cryptoki_aligned! { 1615 /// CK_ECDH1_DERIVE_PARAMS provides the parameters to the 1616 /// CKM_ECDH1_DERIVE and CKM_ECDH1_COFACTOR_DERIVE mechanisms, 1617 /// where each party contributes one key pair. 1618 pub struct CK_ECDH1_DERIVE_PARAMS { 1619 pub kdf: CK_EC_KDF_TYPE, 1620 pub ulSharedDataLen: CK_ULONG, 1621 pub pSharedData: CK_BYTE_PTR, 1622 pub ulPublicDataLen: CK_ULONG, 1623 pub pPublicData: CK_BYTE_PTR, 1624 } 1625 } 1626 1627 pub type CK_ECDH1_DERIVE_PARAMS_PTR = *mut CK_ECDH1_DERIVE_PARAMS; 1628 1629 cryptoki_aligned! { 1630 /// CK_ECDH2_DERIVE_PARAMS provides the parameters to the 1631 /// CKM_ECMQV_DERIVE mechanism, where each party contributes two key pairs. 1632 #[derive(Debug, Copy)] 1633 pub struct CK_ECDH2_DERIVE_PARAMS { 1634 pub kdf: CK_EC_KDF_TYPE, 1635 pub ulSharedDataLen: CK_ULONG, 1636 pub pSharedData: CK_BYTE_PTR, 1637 pub ulPublicDataLen: CK_ULONG, 1638 pub pPublicData: CK_BYTE_PTR, 1639 pub ulPrivateDataLen: CK_ULONG, 1640 pub hPrivateData: CK_OBJECT_HANDLE, 1641 pub ulPublicDataLen2: CK_ULONG, 1642 pub pPublicData2: CK_BYTE_PTR, 1643 } 1644 } 1645 packed_clone!(CK_ECDH2_DERIVE_PARAMS); 1646 1647 pub type CK_ECDH2_DERIVE_PARAMS_PTR = *mut CK_ECDH2_DERIVE_PARAMS; 1648 1649 cryptoki_aligned! { 1650 #[derive(Debug, Copy)] 1651 pub struct CK_ECMQV_DERIVE_PARAMS { 1652 pub kdf: CK_EC_KDF_TYPE, 1653 pub ulSharedDataLen: CK_ULONG, 1654 pub pSharedData: CK_BYTE_PTR, 1655 pub ulPublicDataLen: CK_ULONG, 1656 pub pPublicData: CK_BYTE_PTR, 1657 pub ulPrivateDataLen: CK_ULONG, 1658 pub hPrivateData: CK_OBJECT_HANDLE, 1659 pub ulPublicDataLen2: CK_ULONG, 1660 pub pPublicData2: CK_BYTE_PTR, 1661 pub publicKey: CK_OBJECT_HANDLE, 1662 } 1663 } 1664 packed_clone!(CK_ECMQV_DERIVE_PARAMS); 1665 1666 pub type CK_ECMQV_DERIVE_PARAMS_PTR = *mut CK_ECMQV_DERIVE_PARAMS; 1667 1668 /// Typedefs and defines for the CKM_X9_42_DH_KEY_PAIR_GEN and the 1669 /// CKM_X9_42_DH_PARAMETER_GEN mechanisms 1670 pub type CK_X9_42_DH_KDF_TYPE = CK_ULONG; 1671 pub type CK_X9_42_DH_KDF_TYPE_PTR = *mut CK_X9_42_DH_KDF_TYPE; 1672 1673 cryptoki_aligned! { 1674 /// CK_X9_42_DH1_DERIVE_PARAMS provides the parameters to the 1675 /// CKM_X9_42_DH_DERIVE key derivation mechanism, where each party 1676 /// contributes one key pair 1677 #[derive(Debug, Copy)] 1678 pub struct CK_X9_42_DH1_DERIVE_PARAMS { 1679 pub kdf: CK_X9_42_DH_KDF_TYPE, 1680 pub ulOtherInfoLen: CK_ULONG, 1681 pub pOtherInfo: CK_BYTE_PTR, 1682 pub ulPublicDataLen: CK_ULONG, 1683 pub pPublicData: CK_BYTE_PTR, 1684 } 1685 } 1686 packed_clone!(CK_X9_42_DH1_DERIVE_PARAMS); 1687 1688 pub type CK_X9_42_DH1_DERIVE_PARAMS_PTR = *mut CK_X9_42_DH1_DERIVE_PARAMS; 1689 1690 cryptoki_aligned! { 1691 /// CK_X9_42_DH2_DERIVE_PARAMS provides the parameters to the 1692 /// CKM_X9_42_DH_HYBRID_DERIVE and CKM_X9_42_MQV_DERIVE key derivation 1693 /// mechanisms, where each party contributes two key pairs 1694 #[derive(Debug, Copy)] 1695 pub struct CK_X9_42_DH2_DERIVE_PARAMS { 1696 pub kdf: CK_X9_42_DH_KDF_TYPE, 1697 pub ulOtherInfoLen: CK_ULONG, 1698 pub pOtherInfo: CK_BYTE_PTR, 1699 pub ulPublicDataLen: CK_ULONG, 1700 pub pPublicData: CK_BYTE_PTR, 1701 pub ulPrivateDataLen: CK_ULONG, 1702 pub hPrivateData: CK_OBJECT_HANDLE, 1703 pub ulPublicDataLen2: CK_ULONG, 1704 pub pPublicData2: CK_BYTE_PTR, 1705 } 1706 } 1707 packed_clone!(CK_X9_42_DH2_DERIVE_PARAMS); 1708 1709 pub type CK_X9_42_DH2_DERIVE_PARAMS_PTR = *mut CK_X9_42_DH2_DERIVE_PARAMS; 1710 1711 cryptoki_aligned! { 1712 #[derive(Debug, Copy)] 1713 pub struct CK_X9_42_MQV_DERIVE_PARAMS { 1714 pub kdf: CK_X9_42_DH_KDF_TYPE, 1715 pub ulOtherInfoLen: CK_ULONG, 1716 pub pOtherInfo: CK_BYTE_PTR, 1717 pub ulPublicDataLen: CK_ULONG, 1718 pub pPublicData: CK_BYTE_PTR, 1719 pub ulPrivateDataLen: CK_ULONG, 1720 pub hPrivateData: CK_OBJECT_HANDLE, 1721 pub ulPublicDataLen2: CK_ULONG, 1722 pub pPublicData2: CK_BYTE_PTR, 1723 pub publicKey: CK_OBJECT_HANDLE, 1724 } 1725 } 1726 packed_clone!(CK_X9_42_MQV_DERIVE_PARAMS); 1727 1728 pub type CK_X9_42_MQV_DERIVE_PARAMS_PTR = *mut CK_X9_42_MQV_DERIVE_PARAMS; 1729 1730 cryptoki_aligned! { 1731 /// CK_KEA_DERIVE_PARAMS provides the parameters to the 1732 /// CKM_KEA_DERIVE mechanism 1733 #[derive(Debug, Copy)] 1734 pub struct CK_KEA_DERIVE_PARAMS { 1735 pub isSender: CK_BBOOL, 1736 pub ulRandomLen: CK_ULONG, 1737 pub pRandomA: CK_BYTE_PTR, 1738 pub pRandomB: CK_BYTE_PTR, 1739 pub ulPublicDataLen: CK_ULONG, 1740 pub pPublicData: CK_BYTE_PTR, 1741 } 1742 } 1743 packed_clone!(CK_KEA_DERIVE_PARAMS); 1744 1745 pub type CK_KEA_DERIVE_PARAMS_PTR = *mut CK_KEA_DERIVE_PARAMS; 1746 1747 /// CK_RC2_PARAMS provides the parameters to the CKM_RC2_ECB and 1748 /// CKM_RC2_MAC mechanisms. An instance of CK_RC2_PARAMS just 1749 /// holds the effective keysize 1750 pub type CK_RC2_PARAMS = CK_ULONG; 1751 1752 pub type CK_RC2_PARAMS_PTR = *mut CK_RC2_PARAMS; 1753 1754 cryptoki_aligned! { 1755 /// CK_RC2_CBC_PARAMS provides the parameters to the CKM_RC2_CBC 1756 /// mechanism 1757 #[derive(Debug, Copy)] 1758 pub struct CK_RC2_CBC_PARAMS { 1759 /// effective bits (1-1024) 1760 pub ulEffectiveBits: CK_ULONG, 1761 /// IV for CBC mode 1762 pub iv: [CK_BYTE; 8], 1763 } 1764 } 1765 packed_clone!(CK_RC2_CBC_PARAMS); 1766 1767 pub type CK_RC2_CBC_PARAMS_PTR = *mut CK_RC2_CBC_PARAMS; 1768 1769 1770 cryptoki_aligned! { 1771 /// CK_RC2_MAC_GENERAL_PARAMS provides the parameters for the 1772 /// CKM_RC2_MAC_GENERAL mechanism 1773 #[derive(Debug, Copy)] 1774 pub struct CK_RC2_MAC_GENERAL_PARAMS { 1775 /// effective bits (1-1024) 1776 pub ulEffectiveBits: CK_ULONG, 1777 /// Length of MAC in bytes 1778 pub ulMacLength: CK_ULONG, 1779 } 1780 } 1781 packed_clone!(CK_RC2_MAC_GENERAL_PARAMS); 1782 1783 pub type CK_RC2_MAC_GENERAL_PARAMS_PTR = *mut CK_RC2_MAC_GENERAL_PARAMS; 1784 1785 1786 cryptoki_aligned! { 1787 /// CK_RC5_PARAMS provides the parameters to the CKM_RC5_ECB and 1788 /// CKM_RC5_MAC mechanisms 1789 #[derive(Debug, Copy)] 1790 pub struct CK_RC5_PARAMS { 1791 /// wordsize in bits 1792 pub ulWordsize: CK_ULONG, 1793 /// number of rounds 1794 pub ulRounds: CK_ULONG, 1795 } 1796 } 1797 packed_clone!(CK_RC5_PARAMS); 1798 1799 pub type CK_RC5_PARAMS_PTR = *mut CK_RC5_PARAMS; 1800 1801 1802 cryptoki_aligned! { 1803 /// CK_RC5_CBC_PARAMS provides the parameters to the CKM_RC5_CBC 1804 /// mechanism 1805 #[derive(Debug, Copy)] 1806 pub struct CK_RC5_CBC_PARAMS { 1807 /// wordsize in bits 1808 pub ulWordsize: CK_ULONG, 1809 /// number of rounds 1810 pub ulRounds: CK_ULONG, 1811 /// pointer to IV 1812 pub pIv: CK_BYTE_PTR, 1813 /// length of IV in bytes 1814 pub ulIvLen: CK_ULONG, 1815 } 1816 } 1817 packed_clone!(CK_RC5_CBC_PARAMS); 1818 1819 pub type CK_RC5_CBC_PARAMS_PTR = *mut CK_RC5_CBC_PARAMS; 1820 1821 1822 cryptoki_aligned! { 1823 /// CK_RC5_MAC_GENERAL_PARAMS provides the parameters for the 1824 /// CKM_RC5_MAC_GENERAL mechanism 1825 #[derive(Debug, Copy)] 1826 pub struct CK_RC5_MAC_GENERAL_PARAMS { 1827 /// wordsize in bits 1828 pub ulWordsize: CK_ULONG, 1829 /// number of rounds 1830 pub ulRounds: CK_ULONG, 1831 /// Length of MAC in bytes 1832 pub ulMacLength: CK_ULONG, 1833 } 1834 } 1835 packed_clone!(CK_RC5_MAC_GENERAL_PARAMS); 1836 1837 pub type CK_RC5_MAC_GENERAL_PARAMS_PTR = *mut CK_RC5_MAC_GENERAL_PARAMS; 1838 1839 /// CK_MAC_GENERAL_PARAMS provides the parameters to most block 1840 /// ciphers' MAC_GENERAL mechanisms. Its value is the length of 1841 /// the MAC 1842 pub type CK_MAC_GENERAL_PARAMS = CK_ULONG; 1843 1844 pub type CK_MAC_GENERAL_PARAMS_PTR = *mut CK_MAC_GENERAL_PARAMS; 1845 1846 cryptoki_aligned! { 1847 #[derive(Debug, Copy)] 1848 pub struct CK_DES_CBC_ENCRYPT_DATA_PARAMS { 1849 pub iv: [CK_BYTE; 8], 1850 pub pData: CK_BYTE_PTR, 1851 pub length: CK_ULONG, 1852 } 1853 } 1854 packed_clone!(CK_DES_CBC_ENCRYPT_DATA_PARAMS); 1855 1856 pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_DES_CBC_ENCRYPT_DATA_PARAMS; 1857 1858 cryptoki_aligned! { 1859 #[derive(Debug, Copy)] 1860 pub struct CK_AES_CBC_ENCRYPT_DATA_PARAMS { 1861 pub iv: [CK_BYTE; 16], 1862 pub pData: CK_BYTE_PTR, 1863 pub length: CK_ULONG, 1864 } 1865 } 1866 packed_clone!(CK_AES_CBC_ENCRYPT_DATA_PARAMS); 1867 1868 pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_AES_CBC_ENCRYPT_DATA_PARAMS; 1869 1870 cryptoki_aligned! { 1871 /// CK_SKIPJACK_PRIVATE_WRAP_PARAMS provides the parameters to the 1872 /// CKM_SKIPJACK_PRIVATE_WRAP mechanism 1873 #[derive(Debug, Copy)] 1874 pub struct CK_SKIPJACK_PRIVATE_WRAP_PARAMS { 1875 pub ulPasswordLen: CK_ULONG, 1876 pub pPassword: CK_BYTE_PTR, 1877 pub ulPublicDataLen: CK_ULONG, 1878 pub pPublicData: CK_BYTE_PTR, 1879 pub ulPAndGLen: CK_ULONG, 1880 pub ulQLen: CK_ULONG, 1881 pub ulRandomLen: CK_ULONG, 1882 pub pRandomA: CK_BYTE_PTR, 1883 pub pPrimeP: CK_BYTE_PTR, 1884 pub pBaseG: CK_BYTE_PTR, 1885 pub pSubprimeQ: CK_BYTE_PTR, 1886 } 1887 } 1888 packed_clone!(CK_SKIPJACK_PRIVATE_WRAP_PARAMS); 1889 1890 pub type CK_SKIPJACK_PRIVATE_WRAP_PARAMS_PTR = *mut CK_SKIPJACK_PRIVATE_WRAP_PARAMS; 1891 1892 cryptoki_aligned! { 1893 /// CK_SKIPJACK_RELAYX_PARAMS provides the parameters to the 1894 /// CKM_SKIPJACK_RELAYX mechanism 1895 #[derive(Debug, Copy)] 1896 pub struct CK_SKIPJACK_RELAYX_PARAMS { 1897 pub ulOldWrappedXLen: CK_ULONG, 1898 pub pOldWrappedX: CK_BYTE_PTR, 1899 pub ulOldPasswordLen: CK_ULONG, 1900 pub pOldPassword: CK_BYTE_PTR, 1901 pub ulOldPublicDataLen: CK_ULONG, 1902 pub pOldPublicData: CK_BYTE_PTR, 1903 pub ulOldRandomLen: CK_ULONG, 1904 pub pOldRandomA: CK_BYTE_PTR, 1905 pub ulNewPasswordLen: CK_ULONG, 1906 pub pNewPassword: CK_BYTE_PTR, 1907 pub ulNewPublicDataLen: CK_ULONG, 1908 pub pNewPublicData: CK_BYTE_PTR, 1909 pub ulNewRandomLen: CK_ULONG, 1910 pub pNewRandomA: CK_BYTE_PTR, 1911 } 1912 } 1913 packed_clone!(CK_SKIPJACK_RELAYX_PARAMS); 1914 1915 pub type CK_SKIPJACK_RELAYX_PARAMS_PTR = *mut CK_SKIPJACK_RELAYX_PARAMS; 1916 1917 cryptoki_aligned! { 1918 #[derive(Debug, Copy)] 1919 pub struct CK_PBE_PARAMS { 1920 pub pInitVector: CK_BYTE_PTR, 1921 pub pPassword: CK_UTF8CHAR_PTR, 1922 pub ulPasswordLen: CK_ULONG, 1923 pub pSalt: CK_BYTE_PTR, 1924 pub ulSaltLen: CK_ULONG, 1925 pub ulIteration: CK_ULONG, 1926 } 1927 } 1928 packed_clone!(CK_PBE_PARAMS); 1929 1930 pub type CK_PBE_PARAMS_PTR = *mut CK_PBE_PARAMS; 1931 1932 cryptoki_aligned! { 1933 /// CK_KEY_WRAP_SET_OAEP_PARAMS provides the parameters to the 1934 /// CKM_KEY_WRAP_SET_OAEP mechanism 1935 #[derive(Debug, Copy)] 1936 pub struct CK_KEY_WRAP_SET_OAEP_PARAMS { 1937 /// block contents byte 1938 pub bBC: CK_BYTE, 1939 /// extra data 1940 pub pX: CK_BYTE_PTR, 1941 /// length of extra data in bytes 1942 pub ulXLen: CK_ULONG, 1943 } 1944 } 1945 packed_clone!(CK_KEY_WRAP_SET_OAEP_PARAMS); 1946 1947 pub type CK_KEY_WRAP_SET_OAEP_PARAMS_PTR = *mut CK_KEY_WRAP_SET_OAEP_PARAMS; 1948 1949 cryptoki_aligned! { 1950 #[derive(Debug, Copy)] 1951 pub struct CK_SSL3_RANDOM_DATA { 1952 pub pClientRandom: CK_BYTE_PTR, 1953 pub ulClientRandomLen: CK_ULONG, 1954 pub pServerRandom: CK_BYTE_PTR, 1955 pub ulServerRandomLen: CK_ULONG, 1956 } 1957 } 1958 packed_clone!(CK_SSL3_RANDOM_DATA); 1959 1960 cryptoki_aligned! { 1961 #[derive(Debug, Copy)] 1962 pub struct CK_SSL3_MASTER_KEY_DERIVE_PARAMS { 1963 pub RandomInfo: CK_SSL3_RANDOM_DATA, 1964 pub pVersion: CK_VERSION_PTR, 1965 } 1966 } 1967 packed_clone!(CK_SSL3_MASTER_KEY_DERIVE_PARAMS); 1968 1969 pub type CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR = *mut CK_SSL3_MASTER_KEY_DERIVE_PARAMS; 1970 1971 cryptoki_aligned! { 1972 #[derive(Debug, Copy)] 1973 pub struct CK_SSL3_KEY_MAT_OUT { 1974 pub hClientMacSecret: CK_OBJECT_HANDLE, 1975 pub hServerMacSecret: CK_OBJECT_HANDLE, 1976 pub hClientKey: CK_OBJECT_HANDLE, 1977 pub hServerKey: CK_OBJECT_HANDLE, 1978 pub pIVClient: CK_BYTE_PTR, 1979 pub pIVServer: CK_BYTE_PTR, 1980 } 1981 } 1982 packed_clone!(CK_SSL3_KEY_MAT_OUT); 1983 1984 pub type CK_SSL3_KEY_MAT_OUT_PTR = *mut CK_SSL3_KEY_MAT_OUT; 1985 1986 cryptoki_aligned! { 1987 #[derive(Debug, Copy)] 1988 pub struct CK_SSL3_KEY_MAT_PARAMS { 1989 pub ulMacSizeInBits: CK_ULONG, 1990 pub ulKeySizeInBits: CK_ULONG, 1991 pub ulIVSizeInBits: CK_ULONG, 1992 pub bIsExport: CK_BBOOL, 1993 pub RandomInfo: CK_SSL3_RANDOM_DATA, 1994 pub pReturnedKeyMaterial: CK_SSL3_KEY_MAT_OUT_PTR, 1995 } 1996 } 1997 packed_clone!(CK_SSL3_KEY_MAT_PARAMS); 1998 1999 pub type CK_SSL3_KEY_MAT_PARAMS_PTR = *mut CK_SSL3_KEY_MAT_PARAMS; 2000 2001 cryptoki_aligned! { 2002 #[derive(Debug, Copy)] 2003 pub struct CK_TLS_PRF_PARAMS { 2004 pub pSeed: CK_BYTE_PTR, 2005 pub ulSeedLen: CK_ULONG, 2006 pub pLabel: CK_BYTE_PTR, 2007 pub ulLabelLen: CK_ULONG, 2008 pub pOutput: CK_BYTE_PTR, 2009 pub pulOutputLen: CK_ULONG_PTR, 2010 } 2011 } 2012 packed_clone!(CK_TLS_PRF_PARAMS); 2013 2014 pub type CK_TLS_PRF_PARAMS_PTR = *mut CK_TLS_PRF_PARAMS; 2015 2016 cryptoki_aligned! { 2017 #[derive(Debug, Copy)] 2018 pub struct CK_WTLS_RANDOM_DATA { 2019 pub pClientRandom: CK_BYTE_PTR, 2020 pub ulClientRandomLen: CK_ULONG, 2021 pub pServerRandom: CK_BYTE_PTR, 2022 pub ulServerRandomLen: CK_ULONG, 2023 } 2024 } 2025 packed_clone!(CK_WTLS_RANDOM_DATA); 2026 2027 pub type CK_WTLS_RANDOM_DATA_PTR = *mut CK_WTLS_RANDOM_DATA; 2028 2029 cryptoki_aligned! { 2030 #[derive(Debug, Copy)] 2031 pub struct CK_WTLS_MASTER_KEY_DERIVE_PARAMS { 2032 pub DigestMechanism: CK_MECHANISM_TYPE, 2033 pub RandomInfo: CK_WTLS_RANDOM_DATA, 2034 pub pVersion: CK_BYTE_PTR, 2035 } 2036 } 2037 packed_clone!(CK_WTLS_MASTER_KEY_DERIVE_PARAMS); 2038 2039 pub type CK_WTLS_MASTER_KEY_DERIVE_PARAMS_PTR = *mut CK_WTLS_MASTER_KEY_DERIVE_PARAMS; 2040 2041 cryptoki_aligned! { 2042 #[derive(Debug, Copy)] 2043 pub struct CK_WTLS_PRF_PARAMS { 2044 pub DigestMechanism: CK_MECHANISM_TYPE, 2045 pub pSeed: CK_BYTE_PTR, 2046 pub ulSeedLen: CK_ULONG, 2047 pub pLabel: CK_BYTE_PTR, 2048 pub ulLabelLen: CK_ULONG, 2049 pub pOutput: CK_BYTE_PTR, 2050 pub pulOutputLen: CK_ULONG_PTR, 2051 } 2052 } 2053 packed_clone!(CK_WTLS_PRF_PARAMS); 2054 2055 pub type CK_WTLS_PRF_PARAMS_PTR = *mut CK_WTLS_PRF_PARAMS; 2056 2057 cryptoki_aligned! { 2058 #[derive(Debug, Copy)] 2059 pub struct CK_WTLS_KEY_MAT_OUT { 2060 pub hMacSecret: CK_OBJECT_HANDLE, 2061 pub hKey: CK_OBJECT_HANDLE, 2062 pub pIV: CK_BYTE_PTR, 2063 } 2064 } 2065 packed_clone!(CK_WTLS_KEY_MAT_OUT); 2066 2067 pub type CK_WTLS_KEY_MAT_OUT_PTR = *mut CK_WTLS_KEY_MAT_OUT; 2068 2069 cryptoki_aligned! { 2070 #[derive(Debug, Copy)] 2071 pub struct CK_WTLS_KEY_MAT_PARAMS { 2072 pub DigestMechanism: CK_MECHANISM_TYPE, 2073 pub ulMacSizeInBits: CK_ULONG, 2074 pub ulKeySizeInBits: CK_ULONG, 2075 pub ulIVSizeInBits: CK_ULONG, 2076 pub ulSequenceNumber: CK_ULONG, 2077 pub bIsExport: CK_BBOOL, 2078 pub RandomInfo: CK_WTLS_RANDOM_DATA, 2079 pub pReturnedKeyMaterial: CK_WTLS_KEY_MAT_OUT_PTR, 2080 } 2081 } 2082 packed_clone!(CK_WTLS_KEY_MAT_PARAMS); 2083 2084 pub type CK_WTLS_KEY_MAT_PARAMS_PTR = *mut CK_WTLS_KEY_MAT_PARAMS; 2085 2086 cryptoki_aligned! { 2087 #[derive(Debug, Copy)] 2088 pub struct CK_CMS_SIG_PARAMS { 2089 pub certificateHandle: CK_OBJECT_HANDLE, 2090 pub pSigningMechanism: CK_MECHANISM_PTR, 2091 pub pDigestMechanism: CK_MECHANISM_PTR, 2092 pub pContentType: CK_UTF8CHAR_PTR, 2093 pub pRequestedAttributes: CK_BYTE_PTR, 2094 pub ulRequestedAttributesLen: CK_ULONG, 2095 pub pRequiredAttributes: CK_BYTE_PTR, 2096 pub ulRequiredAttributesLen: CK_ULONG, 2097 } 2098 } 2099 packed_clone!(CK_CMS_SIG_PARAMS); 2100 2101 pub type CK_CMS_SIG_PARAMS_PTR = *mut CK_CMS_SIG_PARAMS; 2102 2103 cryptoki_aligned! { 2104 #[derive(Debug, Copy)] 2105 pub struct CK_KEY_DERIVATION_STRING_DATA { 2106 pub pData: CK_BYTE_PTR, 2107 pub ulLen: CK_ULONG, 2108 } 2109 } 2110 packed_clone!(CK_KEY_DERIVATION_STRING_DATA); 2111 2112 pub type CK_KEY_DERIVATION_STRING_DATA_PTR = *mut CK_KEY_DERIVATION_STRING_DATA; 2113 2114 2115 /// The CK_EXTRACT_PARAMS is used for the 2116 /// CKM_EXTRACT_KEY_FROM_KEY mechanism. It specifies which bit 2117 /// of the base key should be used as the first bit of the 2118 /// derived key 2119 pub type CK_EXTRACT_PARAMS = CK_ULONG; 2120 2121 pub type CK_EXTRACT_PARAMS_PTR = *mut CK_EXTRACT_PARAMS; 2122 2123 /// CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE is used to 2124 /// indicate the Pseudo-Random Function (PRF) used to generate 2125 /// key bits using PKCS #5 PBKDF2. 2126 pub type CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = CK_ULONG; 2127 2128 pub type CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE_PTR = *mut CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE; 2129 2130 pub const CKP_PKCS5_PBKD2_HMAC_SHA1: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = 0x00000001; 2131 pub const CKP_PKCS5_PBKD2_HMAC_GOSTR3411: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = 0x00000002; 2132 pub const CKP_PKCS5_PBKD2_HMAC_SHA224: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = 0x00000003; 2133 pub const CKP_PKCS5_PBKD2_HMAC_SHA256: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = 0x00000004; 2134 pub const CKP_PKCS5_PBKD2_HMAC_SHA384: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = 0x00000005; 2135 pub const CKP_PKCS5_PBKD2_HMAC_SHA512: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = 0x00000006; 2136 pub const CKP_PKCS5_PBKD2_HMAC_SHA512_224: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = 0x00000007; 2137 pub const CKP_PKCS5_PBKD2_HMAC_SHA512_256: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE = 0x00000008; 2138 2139 /// CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE is used to indicate the 2140 /// source of the salt value when deriving a key using PKCS #5 2141 /// PBKDF2. 2142 pub type CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE = CK_ULONG; 2143 2144 pub type CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE_PTR = *mut CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE; 2145 2146 /// The following salt value sources are defined in PKCS #5 v2.0. 2147 pub const CKZ_SALT_SPECIFIED: CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE = 0x00000001; 2148 2149 cryptoki_aligned! { 2150 /// CK_PKCS5_PBKD2_PARAMS is a structure that provides the 2151 /// parameters to the CKM_PKCS5_PBKD2 mechanism. 2152 #[derive(Debug, Copy)] 2153 pub struct CK_PKCS5_PBKD2_PARAMS { 2154 pub saltSource: CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE, 2155 pub pSaltSourceData: CK_VOID_PTR, 2156 pub ulSaltSourceDataLen: CK_ULONG, 2157 pub iterations: CK_ULONG, 2158 pub prf: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE, 2159 pub pPrfData: CK_VOID_PTR, 2160 pub ulPrfDataLen: CK_ULONG, 2161 pub pPassword: CK_UTF8CHAR_PTR, 2162 pub ulPasswordLen: CK_ULONG_PTR, 2163 } 2164 } 2165 packed_clone!(CK_PKCS5_PBKD2_PARAMS); 2166 2167 pub type CK_PKCS5_PBKD2_PARAMS_PTR = *mut CK_PKCS5_PBKD2_PARAMS; 2168 2169 cryptoki_aligned! { 2170 /// CK_PKCS5_PBKD2_PARAMS2 is a corrected version of the CK_PKCS5_PBKD2_PARAMS 2171 /// structure that provides the parameters to the CKM_PKCS5_PBKD2 mechanism 2172 /// noting that the ulPasswordLen field is a CK_ULONG and not a CK_ULONG_PTR. 2173 #[derive(Debug, Copy)] 2174 pub struct CK_PKCS5_PBKD2_PARAMS2 { 2175 pub saltSource: CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE, 2176 pub pSaltSourceData: CK_VOID_PTR, 2177 pub ulSaltSourceDataLen: CK_ULONG, 2178 pub iterations: CK_ULONG, 2179 pub prf: CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE, 2180 pub pPrfData: CK_VOID_PTR, 2181 pub ulPrfDataLen: CK_ULONG, 2182 pub pPassword: CK_UTF8CHAR_PTR, 2183 pub ulPasswordLen: CK_ULONG, 2184 } 2185 } 2186 packed_clone!(CK_PKCS5_PBKD2_PARAMS2); 2187 2188 pub type CK_PKCS5_PBKD2_PARAMS2_PTR = *mut CK_PKCS5_PBKD2_PARAMS2; 2189 2190 pub type CK_OTP_PARAM_TYPE = CK_ULONG; 2191 /// backward compatibility 2192 pub type CK_PARAM_TYPE = CK_OTP_PARAM_TYPE; 2193 2194 cryptoki_aligned! { 2195 #[derive(Debug, Copy)] 2196 pub struct CK_OTP_PARAM { 2197 pub paramType: CK_OTP_PARAM_TYPE, 2198 pub pValue: CK_VOID_PTR, 2199 pub ulValueLen: CK_ULONG, 2200 } 2201 } 2202 packed_clone!(CK_OTP_PARAM); 2203 2204 pub type CK_OTP_PARAM_PTR = *mut CK_OTP_PARAM; 2205 2206 cryptoki_aligned! { 2207 #[derive(Debug, Copy)] 2208 pub struct CK_OTP_PARAMS { 2209 pub pParams: CK_OTP_PARAM_PTR, 2210 pub ulCount: CK_ULONG, 2211 } 2212 } 2213 packed_clone!(CK_OTP_PARAMS); 2214 2215 pub type CK_OTP_PARAMS_PTR = *mut CK_OTP_PARAMS; 2216 2217 cryptoki_aligned! { 2218 #[derive(Debug, Copy)] 2219 pub struct CK_OTP_SIGNATURE_INFO { 2220 pub pParams: CK_OTP_PARAM_PTR, 2221 pub ulCount: CK_ULONG, 2222 } 2223 } 2224 packed_clone!(CK_OTP_SIGNATURE_INFO); 2225 2226 pub type CK_OTP_SIGNATURE_INFO_PTR = *mut CK_OTP_SIGNATURE_INFO; 2227 2228 pub const CK_OTP_VALUE: CK_ULONG = 0; 2229 pub const CK_OTP_PIN: CK_ULONG = 1; 2230 pub const CK_OTP_CHALLENGE: CK_ULONG = 2; 2231 pub const CK_OTP_TIME: CK_ULONG = 3; 2232 pub const CK_OTP_COUNTER: CK_ULONG = 4; 2233 pub const CK_OTP_FLAGS: CK_ULONG = 5; 2234 pub const CK_OTP_OUTPUT_LENGTH: CK_ULONG = 6; 2235 pub const CK_OTP_OUTPUT_FORMAT: CK_ULONG = 7; 2236 2237 pub const CKF_NEXT_OTP: CK_FLAGS = 0x00000001; 2238 pub const CKF_EXCLUDE_TIME: CK_FLAGS = 0x00000002; 2239 pub const CKF_EXCLUDE_COUNTER: CK_FLAGS = 0x00000004; 2240 pub const CKF_EXCLUDE_CHALLENGE: CK_FLAGS = 0x00000008; 2241 pub const CKF_EXCLUDE_PIN: CK_FLAGS = 0x00000010; 2242 pub const CKF_USER_FRIENDLY_OTP: CK_FLAGS = 0x00000020; 2243 2244 cryptoki_aligned! { 2245 #[derive(Debug, Copy)] 2246 pub struct CK_KIP_PARAMS { 2247 pub pMechanism: CK_MECHANISM_PTR, 2248 pub hKey: CK_OBJECT_HANDLE, 2249 pub pSeed: CK_BYTE_PTR, 2250 pub ulSeedLen: CK_ULONG, 2251 } 2252 } 2253 packed_clone!(CK_KIP_PARAMS); 2254 2255 pub type CK_KIP_PARAMS_PTR = *mut CK_KIP_PARAMS; 2256 2257 cryptoki_aligned! { 2258 #[derive(Debug, Copy)] 2259 pub struct CK_AES_CTR_PARAMS { 2260 pub ulCounterBits: CK_ULONG, 2261 pub cb: [CK_BYTE; 16], 2262 } 2263 } 2264 packed_clone!(CK_AES_CTR_PARAMS); 2265 2266 pub type CK_AES_CTR_PARAMS_PTR = *mut CK_AES_CTR_PARAMS; 2267 2268 cryptoki_aligned! { 2269 #[derive(Debug, Copy)] 2270 pub struct CK_GCM_PARAMS { 2271 pub pIv: CK_BYTE_PTR, 2272 pub ulIvLen: CK_ULONG, 2273 pub ulIvBits: CK_ULONG, 2274 pub pAAD: CK_BYTE_PTR, 2275 pub ulAADLen: CK_ULONG, 2276 pub ulTagBits: CK_ULONG, 2277 } 2278 } 2279 packed_clone!(CK_GCM_PARAMS); 2280 2281 pub type CK_GCM_PARAMS_PTR = *mut CK_GCM_PARAMS; 2282 2283 cryptoki_aligned! { 2284 #[derive(Debug, Copy)] 2285 pub struct CK_CCM_PARAMS { 2286 pub ulDataLen: CK_ULONG, 2287 pub pNonce: CK_BYTE_PTR, 2288 pub ulNonceLen: CK_ULONG, 2289 pub pAAD: CK_BYTE_PTR, 2290 pub ulAADLen: CK_ULONG, 2291 pub ulMACLen: CK_ULONG, 2292 } 2293 } 2294 packed_clone!(CK_CCM_PARAMS); 2295 2296 pub type CK_CCM_PARAMS_PTR = *mut CK_CCM_PARAMS; 2297 2298 cryptoki_aligned! { 2299 /// Deprecated. Use CK_GCM_PARAMS 2300 #[derive(Debug, Copy)] 2301 pub struct CK_AES_GCM_PARAMS { 2302 pub pIv: CK_BYTE_PTR, 2303 pub ulIvLen: CK_ULONG, 2304 pub ulIvBits: CK_ULONG, 2305 pub pAAD: CK_BYTE_PTR, 2306 pub ulAADLen: CK_ULONG, 2307 pub ulTagBits: CK_ULONG, 2308 } 2309 } 2310 packed_clone!(CK_AES_GCM_PARAMS); 2311 2312 pub type CK_AES_GCM_PARAMS_PTR = *mut CK_AES_GCM_PARAMS; 2313 2314 cryptoki_aligned! { 2315 /// Deprecated. Use CK_CCM_PARAMS 2316 #[derive(Debug, Copy)] 2317 pub struct CK_AES_CCM_PARAMS { 2318 pub ulDataLen: CK_ULONG, 2319 pub pNonce: CK_BYTE_PTR, 2320 pub ulNonceLen: CK_ULONG, 2321 pub pAAD: CK_BYTE_PTR, 2322 pub ulAADLen: CK_ULONG, 2323 pub ulMACLen: CK_ULONG, 2324 } 2325 } 2326 packed_clone!(CK_AES_CCM_PARAMS); 2327 2328 pub type CK_AES_CCM_PARAMS_PTR = *mut CK_AES_CCM_PARAMS; 2329 2330 cryptoki_aligned! { 2331 #[derive(Debug, Copy)] 2332 pub struct CK_CAMELLIA_CTR_PARAMS { 2333 pub ulCounterBits: CK_ULONG, 2334 pub cb: [CK_BYTE; 16], 2335 } 2336 } 2337 packed_clone!(CK_CAMELLIA_CTR_PARAMS); 2338 2339 pub type CK_CAMELLIA_CTR_PARAMS_PTR = *mut CK_CAMELLIA_CTR_PARAMS; 2340 2341 cryptoki_aligned! { 2342 #[derive(Debug, Copy)] 2343 pub struct CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS { 2344 pub iv: [CK_BYTE; 16], 2345 pub pData: CK_BYTE_PTR, 2346 pub length: CK_ULONG, 2347 } 2348 } 2349 packed_clone!(CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS); 2350 2351 pub type CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS; 2352 2353 cryptoki_aligned! { 2354 #[derive(Debug, Copy)] 2355 pub struct CK_ARIA_CBC_ENCRYPT_DATA_PARAMS { 2356 pub iv: [CK_BYTE; 16], 2357 pub pData: CK_BYTE_PTR, 2358 pub length: CK_ULONG, 2359 } 2360 } 2361 packed_clone!(CK_ARIA_CBC_ENCRYPT_DATA_PARAMS); 2362 2363 pub type CK_ARIA_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_ARIA_CBC_ENCRYPT_DATA_PARAMS; 2364 2365 cryptoki_aligned! { 2366 #[derive(Debug, Copy)] 2367 pub struct CK_DSA_PARAMETER_GEN_PARAM { 2368 pub hash: CK_MECHANISM_TYPE, 2369 pub pSeed: CK_BYTE_PTR, 2370 pub ulSeedLen: CK_ULONG, 2371 pub ulIndex: CK_ULONG, 2372 } 2373 } 2374 packed_clone!(CK_DSA_PARAMETER_GEN_PARAM); 2375 2376 pub type CK_DSA_PARAMETER_GEN_PARAM_PTR = *mut CK_DSA_PARAMETER_GEN_PARAM; 2377 2378 cryptoki_aligned! { 2379 #[derive(Debug, Copy)] 2380 pub struct CK_ECDH_AES_KEY_WRAP_PARAMS { 2381 pub ulAESKeyBits: CK_ULONG, 2382 pub kdf: CK_EC_KDF_TYPE, 2383 pub ulSharedDataLen: CK_ULONG, 2384 pub pSharedData: CK_BYTE_PTR, 2385 } 2386 } 2387 packed_clone!(CK_ECDH_AES_KEY_WRAP_PARAMS); 2388 2389 pub type CK_ECDH_AES_KEY_WRAP_PARAMS_PTR = *mut CK_ECDH_AES_KEY_WRAP_PARAMS; 2390 2391 pub type CK_JAVA_MIDP_SECURITY_DOMAIN = CK_ULONG; 2392 2393 pub type CK_CERTIFICATE_CATEGORY = CK_ULONG; 2394 2395 cryptoki_aligned! { 2396 #[derive(Debug, Copy)] 2397 pub struct CK_RSA_AES_KEY_WRAP_PARAMS { 2398 pub ulAESKeyBits: CK_ULONG, 2399 pub pOAEPParams: CK_RSA_PKCS_OAEP_PARAMS_PTR, 2400 } 2401 } 2402 packed_clone!(CK_RSA_AES_KEY_WRAP_PARAMS); 2403 2404 pub type CK_RSA_AES_KEY_WRAP_PARAMS_PTR = *mut CK_RSA_AES_KEY_WRAP_PARAMS; 2405 2406 cryptoki_aligned! { 2407 #[derive(Debug, Copy)] 2408 pub struct CK_TLS12_MASTER_KEY_DERIVE_PARAMS { 2409 pub RandomInfo: CK_SSL3_RANDOM_DATA, 2410 pub pVersion: CK_VERSION_PTR, 2411 pub prfHashMechanism: CK_MECHANISM_TYPE, 2412 } 2413 } 2414 packed_clone!(CK_TLS12_MASTER_KEY_DERIVE_PARAMS); 2415 2416 pub type CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR = *mut CK_TLS12_MASTER_KEY_DERIVE_PARAMS; 2417 2418 cryptoki_aligned! { 2419 #[derive(Debug, Copy)] 2420 pub struct CK_TLS12_KEY_MAT_PARAMS { 2421 pub ulMacSizeInBits: CK_ULONG, 2422 pub ulKeySizeInBits: CK_ULONG, 2423 pub ulIVSizeInBits: CK_ULONG, 2424 pub bIsExport: CK_BBOOL, 2425 pub RandomInfo: CK_SSL3_RANDOM_DATA, 2426 pub pReturnedKeyMaterial: CK_SSL3_KEY_MAT_OUT_PTR, 2427 pub prfHashMechanism: CK_MECHANISM_TYPE, 2428 } 2429 } 2430 packed_clone!(CK_TLS12_KEY_MAT_PARAMS); 2431 2432 pub type CK_TLS12_KEY_MAT_PARAMS_PTR = *mut CK_TLS12_KEY_MAT_PARAMS; 2433 2434 cryptoki_aligned! { 2435 #[derive(Debug, Copy)] 2436 pub struct CK_TLS_KDF_PARAMS { 2437 pub prfMechanism: CK_MECHANISM_TYPE, 2438 pub pLabel: CK_BYTE_PTR, 2439 pub ulLabelLength: CK_ULONG, 2440 pub RandomInfo: CK_SSL3_RANDOM_DATA, 2441 pub pContextData: CK_BYTE_PTR, 2442 pub ulContextDataLength: CK_ULONG, 2443 } 2444 } 2445 packed_clone!(CK_TLS_KDF_PARAMS); 2446 2447 pub type CK_TLS_KDF_PARAMS_PTR = *mut CK_TLS_KDF_PARAMS; 2448 2449 cryptoki_aligned! { 2450 #[derive(Debug, Copy)] 2451 pub struct CK_TLS_MAC_PARAMS { 2452 pub prfHashMechanism: CK_MECHANISM_TYPE, 2453 pub ulMacLength: CK_ULONG, 2454 pub ulServerOrClient: CK_ULONG, 2455 } 2456 } 2457 packed_clone!(CK_TLS_MAC_PARAMS); 2458 2459 pub type CK_TLS_MAC_PARAMS_PTR = *mut CK_TLS_MAC_PARAMS; 2460 2461 cryptoki_aligned! { 2462 #[derive(Debug, Copy)] 2463 pub struct CK_GOSTR3410_DERIVE_PARAMS { 2464 pub kdf: CK_EC_KDF_TYPE, 2465 pub pPublicData: CK_BYTE_PTR, 2466 pub ulPublicDataLen: CK_ULONG, 2467 pub pUKM: CK_BYTE_PTR, 2468 pub ulUKMLen: CK_ULONG, 2469 } 2470 } 2471 packed_clone!(CK_GOSTR3410_DERIVE_PARAMS); 2472 2473 pub type CK_GOSTR3410_DERIVE_PARAMS_PTR = *mut CK_GOSTR3410_DERIVE_PARAMS; 2474 2475 cryptoki_aligned! { 2476 #[derive(Debug, Copy)] 2477 pub struct CK_GOSTR3410_KEY_WRAP_PARAMS { 2478 pub pWrapOID: CK_BYTE_PTR, 2479 pub ulWrapOIDLen: CK_ULONG, 2480 pub pUKM: CK_BYTE_PTR, 2481 pub ulUKMLen: CK_ULONG, 2482 pub hKey: CK_OBJECT_HANDLE, 2483 } 2484 } 2485 packed_clone!(CK_GOSTR3410_KEY_WRAP_PARAMS); 2486 2487 pub type CK_GOSTR3410_KEY_WRAP_PARAMS_PTR = *mut CK_GOSTR3410_KEY_WRAP_PARAMS; 2488 2489 cryptoki_aligned! { 2490 #[derive(Debug, Copy)] 2491 pub struct CK_SEED_CBC_ENCRYPT_DATA_PARAMS { 2492 pub iv: [CK_BYTE; 16], 2493 pub pData: CK_BYTE_PTR, 2494 pub length: CK_ULONG, 2495 } 2496 } 2497 packed_clone!(CK_SEED_CBC_ENCRYPT_DATA_PARAMS); 2498 2499 pub type CK_SEED_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut CK_SEED_CBC_ENCRYPT_DATA_PARAMS; 2500