diff --git a/cryptoki-sys/pkcs11.h b/cryptoki-sys/pkcs11.h index 3d53113..4fb1066 100644 --- a/cryptoki-sys/pkcs11.h +++ b/cryptoki-sys/pkcs11.h @@ -207,6 +207,15 @@ extern "C" { #define string_data pData #define string_data_len ulLen #define data_params pData +#define extract bExtract +#define expand bExpand +#define prf_hash_mechanism prfHashMechanism +#define salt_type ulSaltType +#define salt_ptr pSalt +#define salt_len ulSaltLen +#define salt_key hSaltKey +#define info_ptr pInfo +#define info_len ulInfoLen #endif /* CRYPTOKI_COMPAT */ @@ -402,6 +411,10 @@ typedef unsigned long ck_key_type_t; #define CKK_GOSTR3411 (0x31UL) #define CKK_GOST28147 (0x32UL) #define CKK_EC_EDWARDS (0x40UL) + +/* From version 3.0 */ +#define CKK_HKDF (0x42UL) + #define CKK_VENDOR_DEFINED ((unsigned long) (1UL << 31)) @@ -888,6 +901,10 @@ typedef unsigned long ck_mechanism_type_t; #define CKM_EC_MONTGOMERY_KEY_PAIR_GEN (0x1056UL) #define CKM_EDDSA (0x1057UL) +#define CKM_HKDF_DERIVE (0x402aUL) +#define CKM_HKDF_DATA (0x402bUL) +#define CKM_HKDF_KEY_GEN (0x402cUL) + /* Attribute and other constants related to OTP */ #define CK_OTP_FORMAT_DECIMAL (0UL) #define CK_OTP_FORMAT_HEXADECIMAL (1UL) @@ -1029,6 +1046,22 @@ struct ck_aes_cbc_encrypt_data_params { unsigned long length; }; +#define CKF_HKDF_SALT_NULL (0x01UL) +#define CKF_HKDF_SALT_DATA (0x02UL) +#define CKF_HKDF_SALT_KEY (0x04UL) + +struct ck_hkdf_params { + unsigned char extract; + unsigned char expand; + ck_mechanism_type_t prf_hash_mechanism; + unsigned long salt_type; + unsigned char *salt_ptr; + unsigned long salt_len; + ck_object_handle_t salt_key; + unsigned char *info_ptr; + unsigned long info_len; +}; + #define CKF_HW (1UL << 0) #define CKF_ENCRYPT (1UL << 8) #define CKF_DECRYPT (1UL << 9) @@ -1644,6 +1677,9 @@ typedef struct ck_des_cbc_encrypt_data_params *CK_DES_CBC_ENCRYPT_DATA_PARAMS_PT typedef struct ck_aes_cbc_encrypt_data_params CK_AES_CBC_ENCRYPT_DATA_PARAMS; typedef struct ck_aes_cbc_encrypt_data_params *CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR; +typedef struct ck_hkdf_params CK_HKDF_PARAMS; +typedef struct ck_hkdf_params *CK_HKDF_PARAMS_PTR; + #ifndef NULL_PTR #define NULL_PTR NULL #endif diff --git a/cryptoki-sys/src/bindings/aarch64-apple-darwin.rs b/cryptoki-sys/src/bindings/aarch64-apple-darwin.rs index 81bdfa3..2f966fd 100644 --- a/cryptoki-sys/src/bindings/aarch64-apple-darwin.rs +++ b/cryptoki-sys/src/bindings/aarch64-apple-darwin.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/aarch64-unknown-linux-gnu.rs b/cryptoki-sys/src/bindings/aarch64-unknown-linux-gnu.rs index 81bdfa3..2f966fd 100644 --- a/cryptoki-sys/src/bindings/aarch64-unknown-linux-gnu.rs +++ b/cryptoki-sys/src/bindings/aarch64-unknown-linux-gnu.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/arm-unknown-linux-gnueabi.rs b/cryptoki-sys/src/bindings/arm-unknown-linux-gnueabi.rs index b688e71..bdfeb2a 100644 --- a/cryptoki-sys/src/bindings/arm-unknown-linux-gnueabi.rs +++ b/cryptoki-sys/src/bindings/arm-unknown-linux-gnueabi.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/generic.rs b/cryptoki-sys/src/bindings/generic.rs index e7b388c..fc44971 100644 --- a/cryptoki-sys/src/bindings/generic.rs +++ b/cryptoki-sys/src/bindings/generic.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -996,6 +1003,29 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[cfg_attr(windows, repr(packed))] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -1629,6 +1659,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/i686-unknown-linux-gnu.rs b/cryptoki-sys/src/bindings/i686-unknown-linux-gnu.rs index b688e71..bdfeb2a 100644 --- a/cryptoki-sys/src/bindings/i686-unknown-linux-gnu.rs +++ b/cryptoki-sys/src/bindings/i686-unknown-linux-gnu.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/loongarch64-unknown-linux-gnu.rs b/cryptoki-sys/src/bindings/loongarch64-unknown-linux-gnu.rs index 81bdfa3..2f966fd 100644 --- a/cryptoki-sys/src/bindings/loongarch64-unknown-linux-gnu.rs +++ b/cryptoki-sys/src/bindings/loongarch64-unknown-linux-gnu.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/powerpc64-unknown-linux-gnu.rs b/cryptoki-sys/src/bindings/powerpc64-unknown-linux-gnu.rs index 81bdfa3..2f966fd 100644 --- a/cryptoki-sys/src/bindings/powerpc64-unknown-linux-gnu.rs +++ b/cryptoki-sys/src/bindings/powerpc64-unknown-linux-gnu.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/x86_64-apple-darwin.rs b/cryptoki-sys/src/bindings/x86_64-apple-darwin.rs index 81bdfa3..2f966fd 100644 --- a/cryptoki-sys/src/bindings/x86_64-apple-darwin.rs +++ b/cryptoki-sys/src/bindings/x86_64-apple-darwin.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/x86_64-pc-windows-msvc.rs b/cryptoki-sys/src/bindings/x86_64-pc-windows-msvc.rs index ed9d0b5..2981864 100644 --- a/cryptoki-sys/src/bindings/x86_64-pc-windows-msvc.rs +++ b/cryptoki-sys/src/bindings/x86_64-pc-windows-msvc.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C, packed)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 38usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 26usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/x86_64-unknown-freebsd.rs b/cryptoki-sys/src/bindings/x86_64-unknown-freebsd.rs index 81bdfa3..2f966fd 100644 --- a/cryptoki-sys/src/bindings/x86_64-unknown-freebsd.rs +++ b/cryptoki-sys/src/bindings/x86_64-unknown-freebsd.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki-sys/src/bindings/x86_64-unknown-linux-gnu.rs b/cryptoki-sys/src/bindings/x86_64-unknown-linux-gnu.rs index 81bdfa3..2f966fd 100644 --- a/cryptoki-sys/src/bindings/x86_64-unknown-linux-gnu.rs +++ b/cryptoki-sys/src/bindings/x86_64-unknown-linux-gnu.rs @@ -91,6 +91,7 @@ pub const CKK_GOSTR3410: CK_KEY_TYPE = 48; pub const CKK_GOSTR3411: CK_KEY_TYPE = 49; pub const CKK_GOST28147: CK_KEY_TYPE = 50; pub const CKK_EC_EDWARDS: CK_KEY_TYPE = 64; +pub const CKK_HKDF: CK_KEY_TYPE = 66; pub const CKC_X_509: CK_CERTIFICATE_TYPE = 0; pub const CKC_X_509_ATTR_CERT: CK_CERTIFICATE_TYPE = 1; pub const CKC_WTLS: CK_CERTIFICATE_TYPE = 2; @@ -530,6 +531,9 @@ pub const CKM_RSA_PKCS_OAEP_TPM_1_1: CK_MECHANISM_TYPE = 16386; pub const CKM_EC_EDWARDS_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4181; pub const CKM_EC_MONTGOMERY_KEY_PAIR_GEN: CK_MECHANISM_TYPE = 4182; pub const CKM_EDDSA: CK_MECHANISM_TYPE = 4183; +pub const CKM_HKDF_DERIVE: CK_MECHANISM_TYPE = 16426; +pub const CKM_HKDF_DATA: CK_MECHANISM_TYPE = 16427; +pub const CKM_HKDF_KEY_GEN: CK_MECHANISM_TYPE = 16428; pub const CK_OTP_FORMAT_DECIMAL: CK_ULONG = 0; pub const CK_OTP_FORMAT_HEXADECIMAL: CK_ULONG = 1; pub const CK_OTP_FORMAT_ALPHANUMERIC: CK_ULONG = 2; @@ -566,6 +570,9 @@ pub const CKD_SHA256_KDF: CK_EC_KDF_TYPE = 6; pub const CKD_SHA384_KDF: CK_EC_KDF_TYPE = 7; pub const CKD_SHA512_KDF: CK_EC_KDF_TYPE = 8; pub const CKD_CPDIVERSIFY_KDF: CK_EC_KDF_TYPE = 9; +pub const CKF_HKDF_SALT_NULL: CK_FLAGS = 1; +pub const CKF_HKDF_SALT_DATA: CK_FLAGS = 2; +pub const CKF_HKDF_SALT_KEY: CK_FLAGS = 4; pub const CKF_HW: CK_FLAGS = 1; pub const CKF_ENCRYPT: CK_FLAGS = 256; pub const CKF_DECRYPT: CK_FLAGS = 512; @@ -2105,6 +2112,133 @@ impl Default for ck_aes_cbc_encrypt_data_params { } } } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ck_hkdf_params { + pub bExtract: ::std::os::raw::c_uchar, + pub bExpand: ::std::os::raw::c_uchar, + pub prfHashMechanism: CK_MECHANISM_TYPE, + pub ulSaltType: ::std::os::raw::c_ulong, + pub pSalt: *mut ::std::os::raw::c_uchar, + pub ulSaltLen: ::std::os::raw::c_ulong, + pub hSaltKey: CK_OBJECT_HANDLE, + pub pInfo: *mut ::std::os::raw::c_uchar, + pub ulInfoLen: ::std::os::raw::c_ulong, +} +#[test] +fn bindgen_test_layout_ck_hkdf_params() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ck_hkdf_params)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExtract) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExtract) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bExpand) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(bExpand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).prfHashMechanism) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(prfHashMechanism) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltType) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSalt) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pSalt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulSaltLen) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulSaltLen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hSaltKey) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(hSaltKey) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pInfo) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(pInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ulInfoLen) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(ck_hkdf_params), + "::", + stringify!(ulInfoLen) + ) + ); +} +impl Default for ck_hkdf_params { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} pub type CK_RV = ::std::os::raw::c_ulong; pub type CK_NOTIFY = ::std::option::Option< unsafe extern "C" fn( @@ -3517,6 +3651,8 @@ pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS = ck_des_cbc_encrypt_data_params; pub type CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_des_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS = ck_aes_cbc_encrypt_data_params; pub type CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR = *mut ck_aes_cbc_encrypt_data_params; +pub type CK_HKDF_PARAMS = ck_hkdf_params; +pub type CK_HKDF_PARAMS_PTR = *mut ck_hkdf_params; extern crate libloading; pub struct Pkcs11 { __library: ::libloading::Library, diff --git a/cryptoki/src/mechanism/hkdf.rs b/cryptoki/src/mechanism/hkdf.rs new file mode 100644 index 0000000..a3c8ad6 --- /dev/null +++ b/cryptoki/src/mechanism/hkdf.rs @@ -0,0 +1,116 @@ +//! Mechanisms of hash-based key derive function (HKDF) +//! See: + +use std::{convert::TryInto, marker::PhantomData, ptr::null_mut, slice}; + +use cryptoki_sys::{CKF_HKDF_SALT_DATA, CKF_HKDF_SALT_KEY, CKF_HKDF_SALT_NULL}; + +use crate::object::ObjectHandle; + +use super::MechanismType; + +#[derive(Debug, Clone, Copy)] +/// The salt for the extract stage. +pub enum HkdfSalt<'a> { + /// CKF_HKDF_SALT_NULL no salt is supplied. + Null, + /// CKF_HKDF_SALT_DATA salt is supplied as a data in pSalt with length ulSaltLen. + Data(&'a [u8]), + /// CKF_HKDF_SALT_KEY salt is supplied as a key in hSaltKey + Key(ObjectHandle), +} + +/// HKDF parameters. +/// +/// This structure wraps a `CK_HKDF_PARAMS` structure. +#[derive(Debug, Clone, Copy)] +#[repr(transparent)] +pub struct HkdfParams<'a> { + inner: cryptoki_sys::CK_HKDF_PARAMS, + /// Marker type to ensure we don't outlive the data + _marker: PhantomData<&'a [u8]>, +} + +impl<'a> HkdfParams<'a> { + /// Construct parameters for hash-based key derive function (HKDF). + /// + /// # Arguments + /// + /// * `extract` - Whether to execute the extract portion of HKDF. + /// + /// * `expand` - Whether to execute the expand portion of HKDF. + /// + /// * `prf_hash_mechanism` - The base hash used for the HMAC in the underlying HKDF operation + /// + /// * `salt` - The salt for the extract stage. + /// + /// * `info` - The info string for the expand stage. + pub fn new( + extract: bool, + expand: bool, + prf_hash_mechanism: MechanismType, + salt: HkdfSalt, + info: &'a [u8], + ) -> Self { + Self { + inner: cryptoki_sys::CK_HKDF_PARAMS { + bExtract: extract as u8, + bExpand: expand as u8, + prfHashMechanism: *prf_hash_mechanism, + ulSaltType: match salt { + HkdfSalt::Null => CKF_HKDF_SALT_NULL, + HkdfSalt::Data(_) => CKF_HKDF_SALT_DATA, + HkdfSalt::Key(_) => CKF_HKDF_SALT_KEY, + }, + pSalt: match salt { + HkdfSalt::Data(data) => data.as_ptr() as *mut _, + _ => null_mut(), + }, + ulSaltLen: match salt { + HkdfSalt::Data(data) => data + .len() + .try_into() + .expect("salt length does not fit in CK_ULONG"), + _ => 0, + }, + hSaltKey: match salt { + HkdfSalt::Key(key) => key.handle(), + _ => 0, + }, + pInfo: info.as_ptr() as *mut _, + ulInfoLen: info + .len() + .try_into() + .expect("info length does not fit in CK_ULONG"), + }, + _marker: PhantomData, + } + } + + /// Whether to execute the extract portion of HKDF. + pub fn extract(&self) -> bool { + self.inner.bExtract != 0 + } + + /// Whether to execute the expand portion of HKDF. + pub fn expand(&self) -> bool { + self.inner.bExpand != 0 + } + + /// The salt for the extract stage. + pub fn salt(&self) -> HkdfSalt<'a> { + match self.inner.ulSaltType { + CKF_HKDF_SALT_NULL => HkdfSalt::Null, + CKF_HKDF_SALT_DATA => HkdfSalt::Data(unsafe { + slice::from_raw_parts(self.inner.pSalt, self.inner.ulSaltLen as _) + }), + CKF_HKDF_SALT_KEY => HkdfSalt::Key(ObjectHandle::new(self.inner.hSaltKey)), + _ => unreachable!(), + } + } + + /// The info string for the expand stage. + pub fn info(&self) -> &'a [u8] { + unsafe { slice::from_raw_parts(self.inner.pInfo, self.inner.ulInfoLen as _) } + } +} diff --git a/cryptoki/src/mechanism/mod.rs b/cryptoki/src/mechanism/mod.rs index c18f2b5..5210b60 100644 --- a/cryptoki/src/mechanism/mod.rs +++ b/cryptoki/src/mechanism/mod.rs @@ -5,6 +5,7 @@ pub mod aead; pub mod ekdf; pub mod elliptic_curve; +pub mod hkdf; mod mechanism_info; pub mod rsa; @@ -281,6 +282,18 @@ impl MechanismType { val: CKM_GENERIC_SECRET_KEY_GEN, }; + // HKDF + /// HKDF key generation mechanism + pub const HKDF_KEY_GEN: MechanismType = MechanismType { + val: CKM_HKDF_KEY_GEN, + }; + /// HKDF-DERIVE mechanism + pub const HKDF_DERIVE: MechanismType = MechanismType { + val: CKM_HKDF_DERIVE, + }; + /// HKDF-DATA mechanism + pub const HKDF_DATA: MechanismType = MechanismType { val: CKM_HKDF_DATA }; + pub(crate) fn stringify(mech: CK_MECHANISM_TYPE) -> String { match mech { CKM_RSA_PKCS_KEY_PAIR_GEN => String::from(stringify!(CKM_RSA_PKCS_KEY_PAIR_GEN)), @@ -637,6 +650,9 @@ impl MechanismType { String::from(stringify!(CKM_EC_MONTGOMERY_KEY_PAIR_GEN)) } CKM_EDDSA => String::from(stringify!(CKM_EDDSA)), + CKM_HKDF_KEY_GEN => String::from(stringify!(CKM_HKDF_KEY_GEN)), + CKM_HKDF_DERIVE => String::from(stringify!(CKM_HKDF_DERIVE)), + CKM_HKDF_DATA => String::from(stringify!(CKM_HKDF_DATA)), _ => format!("unknown {mech:08x}"), } } @@ -712,6 +728,9 @@ impl TryFrom for MechanismType { CKM_SHA384_HMAC => Ok(MechanismType::SHA384_HMAC), CKM_SHA512_HMAC => Ok(MechanismType::SHA512_HMAC), CKM_GENERIC_SECRET_KEY_GEN => Ok(MechanismType::GENERIC_SECRET_KEY_GEN), + CKM_HKDF_KEY_GEN => Ok(MechanismType::HKDF_KEY_GEN), + CKM_HKDF_DERIVE => Ok(MechanismType::HKDF_DERIVE), + CKM_HKDF_DATA => Ok(MechanismType::HKDF_DATA), other => { error!("Mechanism type {} is not supported.", other); Err(Error::NotSupported) @@ -894,6 +913,14 @@ pub enum Mechanism<'a> { Sha256Hmac, /// GENERIC-SECRET-KEY-GEN mechanism GenericSecretKeyGen, + + // HKDF + /// HKDF key gen mechanism + HkdfKeyGen, + /// HKDF-DERIVE mechanism + HkdfDerive(hkdf::HkdfParams<'a>), + /// HKDF-DATA mechanism + HkdfData(hkdf::HkdfParams<'a>), } impl Mechanism<'_> { @@ -957,6 +984,10 @@ impl Mechanism<'_> { Mechanism::Sha256Hmac => MechanismType::SHA256_HMAC, Mechanism::GenericSecretKeyGen => MechanismType::GENERIC_SECRET_KEY_GEN, + + Mechanism::HkdfKeyGen => MechanismType::HKDF_KEY_GEN, + Mechanism::HkdfDerive(_) => MechanismType::HKDF_DERIVE, + Mechanism::HkdfData(_) => MechanismType::HKDF_DATA, } } } @@ -988,6 +1019,9 @@ impl From<&Mechanism<'_>> for CK_MECHANISM { | Mechanism::Sha512RsaPkcsPss(params) => make_mechanism(mechanism, params), Mechanism::RsaPkcsOaep(params) => make_mechanism(mechanism, params), Mechanism::Ecdh1Derive(params) => make_mechanism(mechanism, params), + Mechanism::HkdfDerive(params) | Mechanism::HkdfData(params) => { + make_mechanism(mechanism, params) + } // Mechanisms without parameters Mechanism::AesKeyGen | Mechanism::AesEcb @@ -1023,7 +1057,8 @@ impl From<&Mechanism<'_>> for CK_MECHANISM { | Mechanism::Sha384RsaPkcs | Mechanism::Sha512RsaPkcs | Mechanism::Sha256Hmac - | Mechanism::GenericSecretKeyGen => CK_MECHANISM { + | Mechanism::GenericSecretKeyGen + | Mechanism::HkdfKeyGen => CK_MECHANISM { mechanism, pParameter: null_mut(), ulParameterLen: 0, diff --git a/cryptoki/src/object.rs b/cryptoki/src/object.rs index d66d97c..19c74de 100644 --- a/cryptoki/src/object.rs +++ b/cryptoki/src/object.rs @@ -1192,6 +1192,9 @@ impl KeyType { val: CKK_EC_MONTGOMERY, }; + /// HKDF key + pub const HKDF: KeyType = KeyType { val: CKK_HKDF }; + fn stringify(key_type: CK_KEY_TYPE) -> String { match key_type { CKK_RSA => String::from(stringify!(CKK_RSA)), @@ -1236,6 +1239,8 @@ impl KeyType { CKK_GOSTR3411 => String::from(stringify!(CKK_GOSTR3411)), CKK_GOST28147 => String::from(stringify!(CKK_GOST28147)), CKK_EC_EDWARDS => String::from(stringify!(CKK_EC_EDWARDS)), + CKK_EC_MONTGOMERY => String::from(stringify!(CKK_EC_MONTGOMERY)), + CKK_HKDF => String::from(stringify!(CKK_HKDF)), _ => format!("unknown ({key_type:08x})"), } } @@ -1309,6 +1314,7 @@ impl TryFrom for KeyType { CKK_GOST28147 => Ok(KeyType::GOST28147), CKK_EC_EDWARDS => Ok(KeyType::EC_EDWARDS), CKK_EC_MONTGOMERY => Ok(KeyType::EC_MONTGOMERY), + CKK_HKDF => Ok(KeyType::HKDF), _ => { error!("Key type {} is not supported.", key_type); Err(Error::NotSupported)