From 20484959ae177bf7b1126f4cc279e522bcfca30b Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Fri, 31 Jan 2025 15:45:06 +0100 Subject: [PATCH 01/11] checkout v103.8.0 --- symcrypt-sys/symcrypt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/symcrypt-sys/symcrypt b/symcrypt-sys/symcrypt index 171f6973..53be637d 160000 --- a/symcrypt-sys/symcrypt +++ b/symcrypt-sys/symcrypt @@ -1 +1 @@ -Subproject commit 171f6973dab9b76f0dc61d966d3e977021325bc1 +Subproject commit 53be637dab201a4c9d95e1cf58040c85d71cf3c2 From b8eec19f041f33d57399245c6be3741b9efeab0d Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Fri, 31 Jan 2025 15:55:23 +0100 Subject: [PATCH 02/11] generate new bindings --- scripts/generate-all-bindings.ps1 | 2 + symcrypt-bindgen/src/main.rs | 1 + symcrypt-sys/inc/buildInfo.h | 10 +- symcrypt-sys/inc/symcrypt_internal_shared.inc | 33 + .../src/bindings/aarch64_pc_windows_msvc.rs | 1394 ++++++++++++++--- .../src/bindings/aarch64_unknown_linux_gnu.rs | 1390 +++++++++++++--- .../src/bindings/x86_64_pc_windows_msvc.rs | 1394 ++++++++++++++--- .../src/bindings/x86_64_unknown_linux_gnu.rs | 1390 +++++++++++++--- 8 files changed, 4849 insertions(+), 765 deletions(-) create mode 100644 symcrypt-sys/inc/symcrypt_internal_shared.inc diff --git a/scripts/generate-all-bindings.ps1 b/scripts/generate-all-bindings.ps1 index f386acdc..40fc153d 100644 --- a/scripts/generate-all-bindings.ps1 +++ b/scripts/generate-all-bindings.ps1 @@ -34,9 +34,11 @@ $PSNativeCommandUseErrorActionPreference = $True Push-Location "$PSScriptRoot/.." # Move to the root of the project git submodule update --init +git -C symcrypt-sys/symcrypt/3rdparty/jitterentropy-library submodule update --init python3 "./symcrypt-sys/symcrypt/scripts/version.py" --build-info mv -Force "./symcrypt-sys/symcrypt/inc/buildInfo.h" "./symcrypt-sys/inc/" +mv -Force "./symcrypt-sys/symcrypt/inc/symcrypt_internal_shared.inc" "./symcrypt-sys/inc/" $bindingsDir = "./symcrypt-sys/src/bindings" # is relative to the project root if (Test-Path $bindingsDir) { diff --git a/symcrypt-bindgen/src/main.rs b/symcrypt-bindgen/src/main.rs index bdfae19a..0479305a 100644 --- a/symcrypt-bindgen/src/main.rs +++ b/symcrypt-bindgen/src/main.rs @@ -49,6 +49,7 @@ fn main() { // Clang arguments .clang_arg("-v") .clang_args(["-target", triple]) + .clang_arg(format!("-I{}/inc", symcrypt_sys_crate.display())) .clang_arg(format!("-I{}/symcrypt/inc", symcrypt_sys_crate.display())) .clang_arg(format!("-I{}/symcrypt/lib", symcrypt_sys_crate.display())) diff --git a/symcrypt-sys/inc/buildInfo.h b/symcrypt-sys/inc/buildInfo.h index 24038889..fb984057 100644 --- a/symcrypt-sys/inc/buildInfo.h +++ b/symcrypt-sys/inc/buildInfo.h @@ -1,8 +1,8 @@ #include "symcrypt_internal_shared.inc" -#define _SYMCRYPT_JOIN(a, b) #a "." #b -#define _SYMCRYPT_EXPAND_JOIN(a, b) _SYMCRYPT_JOIN(a, b) +#define _SYMCRYPT_STRING_INT(a) #a +#define _SYMCRYPT_STRING(a) _SYMCRYPT_STRING_INT(a) #define SYMCRYPT_BUILD_INFO_BRANCH "" -#define SYMCRYPT_BUILD_INFO_COMMIT "2024-04-12T07:54:16+02:00_171f697" -#define SYMCRYPT_BUILD_INFO_VERSION _SYMCRYPT_EXPAND_JOIN(_SYMCRYPT_EXPAND_JOIN(SYMCRYPT_CODE_VERSION_API, SYMCRYPT_CODE_VERSION_MINOR), SYMCRYPT_CODE_VERSION_PATCH) -#define SYMCRYPT_BUILD_INFO_TIMESTAMP "2025-01-14T14:29:07" +#define SYMCRYPT_BUILD_INFO_COMMIT "2025-01-28T01:44:15+01:00_53be637" +#define SYMCRYPT_BUILD_INFO_VERSION _SYMCRYPT_STRING(SYMCRYPT_CODE_VERSION_API) "." _SYMCRYPT_STRING(SYMCRYPT_CODE_VERSION_MINOR) "." _SYMCRYPT_STRING(SYMCRYPT_CODE_VERSION_PATCH) +#define SYMCRYPT_BUILD_INFO_TIMESTAMP "2025-01-31T15:53:40" diff --git a/symcrypt-sys/inc/symcrypt_internal_shared.inc b/symcrypt-sys/inc/symcrypt_internal_shared.inc new file mode 100644 index 00000000..f89b662f --- /dev/null +++ b/symcrypt-sys/inc/symcrypt_internal_shared.inc @@ -0,0 +1,33 @@ +// +// symcrypt_internal_shared.inc +// Copyright (c) Microsoft Corporation. Licensed under the MIT license. +// +// This is the file that contains the SymCrypt version information and defines SYMCRYPT_DEBUG. +// It is included in both C and ASM such that the values are the same on both sides. +// We use the C preprocessor to set ASM constants, as we already need to use the C preprocessor for +// symcryptasm processing (see scripts/symcryptasm_processor.py). +// +// In previous releases we had a numbering system with major/minor version number. +// This worked well with the sequential servicing imposed by SourceDepot. +// With the switch to Git this no longer works due to having multiple branches. +// We move to having the version here only specify the API and minor version number +// These will NOT be changed for every build. The API version only changes when there are +// breaking changes to the API in symcrypt.h. (Note: symcrypt_low_level.h is not stable and can change +// at any time.) The minor version is changed at regular intervals, but not necessarily at +// every build of the library. +// +// Separate from these numbers the build system includes information about the branch, +// last commit, build time, etc. +// +// The API numbering starts at 100 to avoid number conflicts with the old system. +// + +#define SYMCRYPT_CODE_VERSION_API 103 +#define SYMCRYPT_CODE_VERSION_MINOR 8 +#define SYMCRYPT_CODE_VERSION_PATCH 0 + +#if defined(DBG) +#define SYMCRYPT_DEBUG 1 +#else +#define SYMCRYPT_DEBUG 0 +#endif diff --git a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs index 57e7b9b6..ee1327b4 100644 --- a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs @@ -1,8 +1,8 @@ /* automatically generated by rust-bindgen 0.71.1 */ pub const SYMCRYPT_CODE_VERSION_API: u32 = 103; -pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 4; -pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 2; +pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 8; +pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 0; pub const SYMCRYPT_MD5_RESULT_SIZE: u32 = 16; pub const SYMCRYPT_SHA1_RESULT_SIZE: u32 = 20; pub const SYMCRYPT_SHA256_RESULT_SIZE: u32 = 32; @@ -39,6 +39,8 @@ pub const SYMCRYPT_ERROR_SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE: SYMCRYPT_ERROR pub const SYMCRYPT_ERROR_SYMCRYPT_INCOMPATIBLE_FORMAT: SYMCRYPT_ERROR = 32785; pub const SYMCRYPT_ERROR_SYMCRYPT_VALUE_TOO_LARGE: SYMCRYPT_ERROR = 32786; pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787; +pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788; +pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789; pub type SYMCRYPT_ERROR = ::std::os::raw::c_int; pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0; pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1; @@ -64,6 +66,209 @@ pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER; pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD2_CHAINING_STATE { + pub C: [BYTE; 16usize], + pub X: [BYTE; 48usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), + 64usize, + "Size of _SYMCRYPT_MD2_CHAINING_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" + ); +} +impl Default for _SYMCRYPT_MD2_CHAINING_STATE { + 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 SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD2_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 16usize], + pub chain: SYMCRYPT_MD2_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD2_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD2_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MD2_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MD2_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_MD2_STATE::chain" + ); +} +impl Default for _SYMCRYPT_MD2_STATE { + 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 SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_MD4_CHAINING_STATE { + pub H: [UINT32; 4usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + 16usize, + "Size of _SYMCRYPT_MD4_CHAINING_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" + ); +} +pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD4_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 64usize], + pub chain: SYMCRYPT_MD4_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD4_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD4_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MD4_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MD4_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 96usize, + "Offset of field: _SYMCRYPT_MD4_STATE::chain" + ); +} +impl Default for _SYMCRYPT_MD4_STATE { + 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 SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; +#[repr(C)] +#[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_MD5_CHAINING_STATE { pub H: [UINT32; 4usize], @@ -353,6 +558,73 @@ pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA224_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 64usize], + pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA224_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA224_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 96usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::chain" + ); +} +impl Default for _SYMCRYPT_SHA224_STATE { + 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 SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; +#[repr(C)] +#[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_SHA512_CHAINING_STATE { pub H: [UINT64; 8usize], @@ -519,60 +791,228 @@ pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KECCAK_STATE { - pub state: [UINT64; 25usize], - pub inputBlockSize: UINT32, - pub stateIndex: UINT32, - pub paddingValue: UINT8, - pub squeezeMode: BOOLEAN, +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA512_224_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 128usize], + pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } #[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = +fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" + "Size of _SYMCRYPT_SHA512_224_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" + "Alignment of _SYMCRYPT_SHA512_224_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" + "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 160usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" ); } -pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +impl Default for _SYMCRYPT_SHA512_224_STATE { + 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 SYMCRYPT_SHA512_224_STATE = _SYMCRYPT_SHA512_224_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_256_STATE { +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA512_256_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 128usize], + pub chain: SYMCRYPT_SHA512_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA512_256_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA512_256_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 160usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" + ); +} +impl Default for _SYMCRYPT_SHA512_256_STATE { + 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 SYMCRYPT_SHA512_256_STATE = _SYMCRYPT_SHA512_256_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KECCAK_STATE { + pub state: [UINT64; 25usize], + pub inputBlockSize: UINT32, + pub stateIndex: UINT32, + pub paddingValue: UINT8, + pub squeezeMode: BOOLEAN, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), + 224usize, + "Size of _SYMCRYPT_KECCAK_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_KECCAK_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::state" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, + 200usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, + 204usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, + 208usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, + 209usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + ); +} +pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_224_STATE { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_224_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA3_224_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" + ); +} +pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_256_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } @@ -674,9 +1114,265 @@ fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" ); } -pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; -pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; -pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; +pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; +pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; +pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), + 240usize, + "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), + 240usize, + "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_OID { + pub cbOID: UINT32, + pub pbOID: PCBYTE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_OID() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_OID>(), + 16usize, + "Size of _SYMCRYPT_OID" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_OID>(), + 8usize, + "Alignment of _SYMCRYPT_OID" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_OID::cbOID" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_OID::pbOID" + ); +} +impl Default for _SYMCRYPT_OID { + 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 SYMCRYPT_OID = _SYMCRYPT_OID; +pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; +} +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union _SYMCRYPT_HASH_STATE { + pub md2State: SYMCRYPT_MD2_STATE, + pub md4State: SYMCRYPT_MD4_STATE, + pub md5State: SYMCRYPT_MD5_STATE, + pub sha1State: SYMCRYPT_SHA1_STATE, + pub sha224State: SYMCRYPT_SHA224_STATE, + pub sha256State: SYMCRYPT_SHA256_STATE, + pub sha384State: SYMCRYPT_SHA384_STATE, + pub sha512State: SYMCRYPT_SHA512_STATE, + pub sha512_224State: SYMCRYPT_SHA512_224_STATE, + pub sha512_256State: SYMCRYPT_SHA512_256_STATE, + pub sha3_224State: SYMCRYPT_SHA3_224_STATE, + pub sha3_256State: SYMCRYPT_SHA3_256_STATE, + pub sha3_384State: SYMCRYPT_SHA3_384_STATE, + pub sha3_512State: SYMCRYPT_SHA3_512_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), + 240usize, + "Size of _SYMCRYPT_HASH_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HASH_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md2State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md4State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md5State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" + ); +} +impl Default for _SYMCRYPT_HASH_STATE { + 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 SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE; pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; @@ -958,6 +1654,46 @@ pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, @@ -1051,85 +1787,316 @@ pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { +pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_STATE { + pub hash: SYMCRYPT_SHA384_STATE, + pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA384_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 232usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA384_STATE { + 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 SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; +pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; +pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_STATE { + pub hash: SYMCRYPT_SHA512_STATE, + pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA512_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 232usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA512_STATE { + 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 SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; +pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; +pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" ); } -pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_STATE { - pub hash: SYMCRYPT_SHA384_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { + pub pHash: PCSYMCRYPT_HASH, + pub __bindgen_padding_0: u64, + pub innerState: SYMCRYPT_HASH_STATE, + pub outerState: SYMCRYPT_HASH_STATE, pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = +fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" + "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 256usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" + 496usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" ); } -impl Default for _SYMCRYPT_HMAC_SHA384_STATE { +impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1138,91 +2105,146 @@ impl Default for _SYMCRYPT_HMAC_SHA384_STATE { } } } -pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; -pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; -pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" + "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" ); } -pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_STATE { - pub hash: SYMCRYPT_SHA512_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub magic: SIZE_T, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" + "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" + "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" ); } -impl Default for _SYMCRYPT_HMAC_SHA512_STATE { +impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1231,9 +2253,7 @@ impl Default for _SYMCRYPT_HMAC_SHA512_STATE { } } } -pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; -pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; -pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +pub type SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Copy, Clone)] @@ -1352,10 +2372,19 @@ pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, + pub sha224Key: SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, + pub sha512_224Key: SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, + pub sha512_256Key: SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, + pub sha3_224Key: SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, + pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, + pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, + pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY, + pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, + pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, } #[test] fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { @@ -1382,6 +2411,11 @@ fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, 0usize, @@ -1397,11 +2431,51 @@ fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" + ); } impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { fn default() -> Self { @@ -4204,6 +5278,18 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } +extern "C" { + pub fn SymCryptRsakeySetValueFromPrivateExponent( + pbModulus: PCBYTE, + cbModulus: SIZE_T, + u64PubExp: UINT64, + pbPrivateExponent: PCBYTE, + cbPrivateExponent: SIZE_T, + numFormat: SYMCRYPT_NUMBER_FORMAT, + flags: UINT32, + pkRsakey: PSYMCRYPT_RSAKEY, + ) -> SYMCRYPT_ERROR; +} extern "C" { pub fn SymCryptRsakeyGetValue( pkRsakey: PCSYMCRYPT_RSAKEY, @@ -4347,80 +5433,6 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_OID { - pub cbOID: UINT32, - pub pbOID: PCBYTE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} -impl Default for _SYMCRYPT_OID { - 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 SYMCRYPT_OID = _SYMCRYPT_OID; -pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; -} extern "C" { pub fn SymCryptRsaPkcs1Sign( pkRsakey: PCSYMCRYPT_RSAKEY, diff --git a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs index 379bc490..b1c9e4df 100644 --- a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs @@ -1,8 +1,8 @@ /* automatically generated by rust-bindgen 0.71.1 */ pub const SYMCRYPT_CODE_VERSION_API: u32 = 103; -pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 4; -pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 2; +pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 8; +pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 0; pub const SYMCRYPT_MD5_RESULT_SIZE: u32 = 16; pub const SYMCRYPT_SHA1_RESULT_SIZE: u32 = 20; pub const SYMCRYPT_SHA256_RESULT_SIZE: u32 = 32; @@ -39,6 +39,8 @@ pub const SYMCRYPT_ERROR_SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE: SYMCRYPT_ERROR pub const SYMCRYPT_ERROR_SYMCRYPT_INCOMPATIBLE_FORMAT: SYMCRYPT_ERROR = 32785; pub const SYMCRYPT_ERROR_SYMCRYPT_VALUE_TOO_LARGE: SYMCRYPT_ERROR = 32786; pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787; +pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788; +pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789; pub type SYMCRYPT_ERROR = ::std::os::raw::c_uint; pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0; pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1; @@ -63,6 +65,209 @@ pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER; pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD2_CHAINING_STATE { + pub C: [BYTE; 16usize], + pub X: [BYTE; 48usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), + 64usize, + "Size of _SYMCRYPT_MD2_CHAINING_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" + ); +} +impl Default for _SYMCRYPT_MD2_CHAINING_STATE { + 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 SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD2_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 16usize], + pub chain: SYMCRYPT_MD2_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD2_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD2_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MD2_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MD2_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_MD2_STATE::chain" + ); +} +impl Default for _SYMCRYPT_MD2_STATE { + 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 SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_MD4_CHAINING_STATE { + pub H: [UINT32; 4usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + 16usize, + "Size of _SYMCRYPT_MD4_CHAINING_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" + ); +} +pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD4_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 64usize], + pub chain: SYMCRYPT_MD4_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD4_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD4_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MD4_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MD4_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 96usize, + "Offset of field: _SYMCRYPT_MD4_STATE::chain" + ); +} +impl Default for _SYMCRYPT_MD4_STATE { + 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 SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; +#[repr(C)] +#[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_MD5_CHAINING_STATE { pub H: [UINT32; 4usize], @@ -352,6 +557,73 @@ pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA224_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 64usize], + pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA224_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA224_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 96usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::chain" + ); +} +impl Default for _SYMCRYPT_SHA224_STATE { + 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 SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; +#[repr(C)] +#[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_SHA512_CHAINING_STATE { pub H: [UINT64; 8usize], @@ -518,60 +790,228 @@ pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KECCAK_STATE { - pub state: [UINT64; 25usize], - pub inputBlockSize: UINT32, - pub stateIndex: UINT32, - pub paddingValue: UINT8, - pub squeezeMode: BOOLEAN, +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA512_224_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 128usize], + pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } #[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = +fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" + "Size of _SYMCRYPT_SHA512_224_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" + "Alignment of _SYMCRYPT_SHA512_224_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" + "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 160usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" ); } -pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +impl Default for _SYMCRYPT_SHA512_224_STATE { + 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 SYMCRYPT_SHA512_224_STATE = _SYMCRYPT_SHA512_224_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_256_STATE { +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA512_256_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 128usize], + pub chain: SYMCRYPT_SHA512_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA512_256_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA512_256_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 160usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" + ); +} +impl Default for _SYMCRYPT_SHA512_256_STATE { + 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 SYMCRYPT_SHA512_256_STATE = _SYMCRYPT_SHA512_256_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KECCAK_STATE { + pub state: [UINT64; 25usize], + pub inputBlockSize: UINT32, + pub stateIndex: UINT32, + pub paddingValue: UINT8, + pub squeezeMode: BOOLEAN, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), + 224usize, + "Size of _SYMCRYPT_KECCAK_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_KECCAK_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::state" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, + 200usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, + 204usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, + 208usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, + 209usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + ); +} +pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_224_STATE { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_224_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA3_224_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" + ); +} +pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_256_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } @@ -668,14 +1108,262 @@ fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" + ); +} +pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; +pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; +pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), + 240usize, + "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), + 240usize, + "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_OID { + pub cbOID: UINT32, + pub pbOID: PCBYTE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_OID() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_OID>(), + 16usize, + "Size of _SYMCRYPT_OID" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_OID>(), + 8usize, + "Alignment of _SYMCRYPT_OID" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_OID::cbOID" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_OID::pbOID" + ); +} +impl Default for _SYMCRYPT_OID { + 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 SYMCRYPT_OID = _SYMCRYPT_OID; +pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +extern "C" { + pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; +} +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union _SYMCRYPT_HASH_STATE { + pub md2State: SYMCRYPT_MD2_STATE, + pub md4State: SYMCRYPT_MD4_STATE, + pub md5State: SYMCRYPT_MD5_STATE, + pub sha1State: SYMCRYPT_SHA1_STATE, + pub sha224State: SYMCRYPT_SHA224_STATE, + pub sha256State: SYMCRYPT_SHA256_STATE, + pub sha384State: SYMCRYPT_SHA384_STATE, + pub sha512State: SYMCRYPT_SHA512_STATE, + pub sha512_224State: SYMCRYPT_SHA512_224_STATE, + pub sha512_256State: SYMCRYPT_SHA512_256_STATE, + pub sha3_224State: SYMCRYPT_SHA3_224_STATE, + pub sha3_256State: SYMCRYPT_SHA3_256_STATE, + pub sha3_384State: SYMCRYPT_SHA3_384_STATE, + pub sha3_512State: SYMCRYPT_SHA3_512_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), + 240usize, + "Size of _SYMCRYPT_HASH_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HASH_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md2State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md4State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md5State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" ); } -pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; -pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; -pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; +impl Default for _SYMCRYPT_HASH_STATE { + 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 SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE; pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; @@ -957,6 +1645,46 @@ pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, @@ -1044,91 +1772,322 @@ impl Default for _SYMCRYPT_HMAC_SHA256_STATE { } } } -pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; -pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; -pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; +pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; +pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; +pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_STATE { + pub hash: SYMCRYPT_SHA384_STATE, + pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA384_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 232usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA384_STATE { + 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 SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; +pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; +pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_STATE { + pub hash: SYMCRYPT_SHA512_STATE, + pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA512_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 232usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA512_STATE { + 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 SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; +pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; +pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { +pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" ); } -pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_STATE { - pub hash: SYMCRYPT_SHA384_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { + pub pHash: PCSYMCRYPT_HASH, + pub __bindgen_padding_0: u64, + pub innerState: SYMCRYPT_HASH_STATE, + pub outerState: SYMCRYPT_HASH_STATE, pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = +fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" + "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 256usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" + 496usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" ); } -impl Default for _SYMCRYPT_HMAC_SHA384_STATE { +impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1137,91 +2096,146 @@ impl Default for _SYMCRYPT_HMAC_SHA384_STATE { } } } -pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; -pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; -pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" + "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" ); } -pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_STATE { - pub hash: SYMCRYPT_SHA512_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub magic: SIZE_T, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" + "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" + "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" ); } -impl Default for _SYMCRYPT_HMAC_SHA512_STATE { +impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1230,9 +2244,7 @@ impl Default for _SYMCRYPT_HMAC_SHA512_STATE { } } } -pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; -pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; -pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +pub type SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Copy, Clone)] @@ -1351,10 +2363,19 @@ pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, + pub sha224Key: SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, + pub sha512_224Key: SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, + pub sha512_256Key: SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, + pub sha3_224Key: SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, + pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, + pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, + pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY, + pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, + pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, } #[test] fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { @@ -1381,6 +2402,11 @@ fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, 0usize, @@ -1396,11 +2422,51 @@ fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" + ); } impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { fn default() -> Self { @@ -3922,6 +4988,18 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } +extern "C" { + pub fn SymCryptRsakeySetValueFromPrivateExponent( + pbModulus: PCBYTE, + cbModulus: SIZE_T, + u64PubExp: UINT64, + pbPrivateExponent: PCBYTE, + cbPrivateExponent: SIZE_T, + numFormat: SYMCRYPT_NUMBER_FORMAT, + flags: UINT32, + pkRsakey: PSYMCRYPT_RSAKEY, + ) -> SYMCRYPT_ERROR; +} extern "C" { pub fn SymCryptRsakeyGetValue( pkRsakey: PCSYMCRYPT_RSAKEY, @@ -4061,72 +5139,6 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_OID { - pub cbOID: UINT32, - pub pbOID: PCBYTE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} -impl Default for _SYMCRYPT_OID { - 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 SYMCRYPT_OID = _SYMCRYPT_OID; -pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -extern "C" { - pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; -} extern "C" { pub fn SymCryptRsaPkcs1Sign( pkRsakey: PCSYMCRYPT_RSAKEY, diff --git a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs index 6e943a6d..07970b27 100644 --- a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs @@ -1,8 +1,8 @@ /* automatically generated by rust-bindgen 0.71.1 */ pub const SYMCRYPT_CODE_VERSION_API: u32 = 103; -pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 4; -pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 2; +pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 8; +pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 0; pub const SYMCRYPT_MD5_RESULT_SIZE: u32 = 16; pub const SYMCRYPT_SHA1_RESULT_SIZE: u32 = 20; pub const SYMCRYPT_SHA256_RESULT_SIZE: u32 = 32; @@ -39,6 +39,8 @@ pub const SYMCRYPT_ERROR_SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE: SYMCRYPT_ERROR pub const SYMCRYPT_ERROR_SYMCRYPT_INCOMPATIBLE_FORMAT: SYMCRYPT_ERROR = 32785; pub const SYMCRYPT_ERROR_SYMCRYPT_VALUE_TOO_LARGE: SYMCRYPT_ERROR = 32786; pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787; +pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788; +pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789; pub type SYMCRYPT_ERROR = ::std::os::raw::c_int; pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0; pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1; @@ -65,6 +67,209 @@ pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER; pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD2_CHAINING_STATE { + pub C: [BYTE; 16usize], + pub X: [BYTE; 48usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), + 64usize, + "Size of _SYMCRYPT_MD2_CHAINING_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" + ); +} +impl Default for _SYMCRYPT_MD2_CHAINING_STATE { + 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 SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD2_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 16usize], + pub chain: SYMCRYPT_MD2_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD2_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD2_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MD2_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MD2_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_MD2_STATE::chain" + ); +} +impl Default for _SYMCRYPT_MD2_STATE { + 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 SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_MD4_CHAINING_STATE { + pub H: [UINT32; 4usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + 16usize, + "Size of _SYMCRYPT_MD4_CHAINING_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" + ); +} +pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD4_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 64usize], + pub chain: SYMCRYPT_MD4_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD4_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD4_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MD4_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MD4_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 96usize, + "Offset of field: _SYMCRYPT_MD4_STATE::chain" + ); +} +impl Default for _SYMCRYPT_MD4_STATE { + 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 SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; +#[repr(C)] +#[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_MD5_CHAINING_STATE { pub H: [UINT32; 4usize], @@ -354,6 +559,73 @@ pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA224_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 64usize], + pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA224_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA224_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 96usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::chain" + ); +} +impl Default for _SYMCRYPT_SHA224_STATE { + 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 SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; +#[repr(C)] +#[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_SHA512_CHAINING_STATE { pub H: [UINT64; 8usize], @@ -520,60 +792,228 @@ pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KECCAK_STATE { - pub state: [UINT64; 25usize], - pub inputBlockSize: UINT32, - pub stateIndex: UINT32, - pub paddingValue: UINT8, - pub squeezeMode: BOOLEAN, +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA512_224_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 128usize], + pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } #[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = +fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" + "Size of _SYMCRYPT_SHA512_224_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" + "Alignment of _SYMCRYPT_SHA512_224_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" + "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 160usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" ); } -pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +impl Default for _SYMCRYPT_SHA512_224_STATE { + 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 SYMCRYPT_SHA512_224_STATE = _SYMCRYPT_SHA512_224_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_256_STATE { +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA512_256_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 128usize], + pub chain: SYMCRYPT_SHA512_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA512_256_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA512_256_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 160usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" + ); +} +impl Default for _SYMCRYPT_SHA512_256_STATE { + 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 SYMCRYPT_SHA512_256_STATE = _SYMCRYPT_SHA512_256_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KECCAK_STATE { + pub state: [UINT64; 25usize], + pub inputBlockSize: UINT32, + pub stateIndex: UINT32, + pub paddingValue: UINT8, + pub squeezeMode: BOOLEAN, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), + 224usize, + "Size of _SYMCRYPT_KECCAK_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_KECCAK_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::state" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, + 200usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, + 204usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, + 208usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, + 209usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + ); +} +pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_224_STATE { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_224_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA3_224_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" + ); +} +pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_256_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } @@ -675,9 +1115,265 @@ fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" ); } -pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; -pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; -pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; +pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; +pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; +pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), + 240usize, + "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), + 240usize, + "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_OID { + pub cbOID: UINT32, + pub pbOID: PCBYTE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_OID() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_OID>(), + 16usize, + "Size of _SYMCRYPT_OID" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_OID>(), + 8usize, + "Alignment of _SYMCRYPT_OID" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_OID::cbOID" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_OID::pbOID" + ); +} +impl Default for _SYMCRYPT_OID { + 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 SYMCRYPT_OID = _SYMCRYPT_OID; +pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; +} +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union _SYMCRYPT_HASH_STATE { + pub md2State: SYMCRYPT_MD2_STATE, + pub md4State: SYMCRYPT_MD4_STATE, + pub md5State: SYMCRYPT_MD5_STATE, + pub sha1State: SYMCRYPT_SHA1_STATE, + pub sha224State: SYMCRYPT_SHA224_STATE, + pub sha256State: SYMCRYPT_SHA256_STATE, + pub sha384State: SYMCRYPT_SHA384_STATE, + pub sha512State: SYMCRYPT_SHA512_STATE, + pub sha512_224State: SYMCRYPT_SHA512_224_STATE, + pub sha512_256State: SYMCRYPT_SHA512_256_STATE, + pub sha3_224State: SYMCRYPT_SHA3_224_STATE, + pub sha3_256State: SYMCRYPT_SHA3_256_STATE, + pub sha3_384State: SYMCRYPT_SHA3_384_STATE, + pub sha3_512State: SYMCRYPT_SHA3_512_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), + 240usize, + "Size of _SYMCRYPT_HASH_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HASH_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md2State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md4State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md5State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" + ); +} +impl Default for _SYMCRYPT_HASH_STATE { + 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 SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE; pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; @@ -959,6 +1655,46 @@ pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, @@ -1052,85 +1788,316 @@ pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { +pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_STATE { + pub hash: SYMCRYPT_SHA384_STATE, + pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA384_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 232usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA384_STATE { + 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 SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; +pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; +pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_STATE { + pub hash: SYMCRYPT_SHA512_STATE, + pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA512_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 232usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA512_STATE { + 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 SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; +pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; +pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" ); } -pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_STATE { - pub hash: SYMCRYPT_SHA384_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { + pub pHash: PCSYMCRYPT_HASH, + pub __bindgen_padding_0: u64, + pub innerState: SYMCRYPT_HASH_STATE, + pub outerState: SYMCRYPT_HASH_STATE, pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = +fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" + "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 256usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" + 496usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" ); } -impl Default for _SYMCRYPT_HMAC_SHA384_STATE { +impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1139,91 +2106,146 @@ impl Default for _SYMCRYPT_HMAC_SHA384_STATE { } } } -pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; -pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; -pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" + "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" ); } -pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_STATE { - pub hash: SYMCRYPT_SHA512_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub magic: SIZE_T, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" + "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" + "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" ); } -impl Default for _SYMCRYPT_HMAC_SHA512_STATE { +impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1232,9 +2254,7 @@ impl Default for _SYMCRYPT_HMAC_SHA512_STATE { } } } -pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; -pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; -pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +pub type SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Copy, Clone)] @@ -1353,10 +2373,19 @@ pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, + pub sha224Key: SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, + pub sha512_224Key: SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, + pub sha512_256Key: SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, + pub sha3_224Key: SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, + pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, + pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, + pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY, + pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, + pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, } #[test] fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { @@ -1383,6 +2412,11 @@ fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, 0usize, @@ -1398,11 +2432,51 @@ fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" + ); } impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { fn default() -> Self { @@ -3938,6 +5012,18 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } +extern "C" { + pub fn SymCryptRsakeySetValueFromPrivateExponent( + pbModulus: PCBYTE, + cbModulus: SIZE_T, + u64PubExp: UINT64, + pbPrivateExponent: PCBYTE, + cbPrivateExponent: SIZE_T, + numFormat: SYMCRYPT_NUMBER_FORMAT, + flags: UINT32, + pkRsakey: PSYMCRYPT_RSAKEY, + ) -> SYMCRYPT_ERROR; +} extern "C" { pub fn SymCryptRsakeyGetValue( pkRsakey: PCSYMCRYPT_RSAKEY, @@ -4081,80 +5167,6 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_OID { - pub cbOID: UINT32, - pub pbOID: PCBYTE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} -impl Default for _SYMCRYPT_OID { - 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 SYMCRYPT_OID = _SYMCRYPT_OID; -pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; -} extern "C" { pub fn SymCryptRsaPkcs1Sign( pkRsakey: PCSYMCRYPT_RSAKEY, diff --git a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs index 25b001ca..8bda4666 100644 --- a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs @@ -1,8 +1,8 @@ /* automatically generated by rust-bindgen 0.71.1 */ pub const SYMCRYPT_CODE_VERSION_API: u32 = 103; -pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 4; -pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 2; +pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 8; +pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 0; pub const SYMCRYPT_MD5_RESULT_SIZE: u32 = 16; pub const SYMCRYPT_SHA1_RESULT_SIZE: u32 = 20; pub const SYMCRYPT_SHA256_RESULT_SIZE: u32 = 32; @@ -39,6 +39,8 @@ pub const SYMCRYPT_ERROR_SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE: SYMCRYPT_ERROR pub const SYMCRYPT_ERROR_SYMCRYPT_INCOMPATIBLE_FORMAT: SYMCRYPT_ERROR = 32785; pub const SYMCRYPT_ERROR_SYMCRYPT_VALUE_TOO_LARGE: SYMCRYPT_ERROR = 32786; pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787; +pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788; +pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789; pub type SYMCRYPT_ERROR = ::std::os::raw::c_uint; pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0; pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1; @@ -64,6 +66,209 @@ pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER; pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD2_CHAINING_STATE { + pub C: [BYTE; 16usize], + pub X: [BYTE; 48usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), + 64usize, + "Size of _SYMCRYPT_MD2_CHAINING_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" + ); +} +impl Default for _SYMCRYPT_MD2_CHAINING_STATE { + 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 SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD2_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 16usize], + pub chain: SYMCRYPT_MD2_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD2_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD2_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MD2_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MD2_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_MD2_STATE::chain" + ); +} +impl Default for _SYMCRYPT_MD2_STATE { + 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 SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_MD4_CHAINING_STATE { + pub H: [UINT32; 4usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + 16usize, + "Size of _SYMCRYPT_MD4_CHAINING_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" + ); +} +pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MD4_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 64usize], + pub chain: SYMCRYPT_MD4_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD4_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_MD4_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MD4_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MD4_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 96usize, + "Offset of field: _SYMCRYPT_MD4_STATE::chain" + ); +} +impl Default for _SYMCRYPT_MD4_STATE { + 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 SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; +#[repr(C)] +#[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_MD5_CHAINING_STATE { pub H: [UINT32; 4usize], @@ -353,6 +558,73 @@ pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA224_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 64usize], + pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA224_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA224_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 96usize, + "Offset of field: _SYMCRYPT_SHA224_STATE::chain" + ); +} +impl Default for _SYMCRYPT_SHA224_STATE { + 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 SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; +#[repr(C)] +#[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_SHA512_CHAINING_STATE { pub H: [UINT64; 8usize], @@ -519,60 +791,228 @@ pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KECCAK_STATE { - pub state: [UINT64; 25usize], - pub inputBlockSize: UINT32, - pub stateIndex: UINT32, - pub paddingValue: UINT8, - pub squeezeMode: BOOLEAN, +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA512_224_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 128usize], + pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } #[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = +fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" + "Size of _SYMCRYPT_SHA512_224_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" + "Alignment of _SYMCRYPT_SHA512_224_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" + "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 160usize, + "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" ); } -pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +impl Default for _SYMCRYPT_SHA512_224_STATE { + 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 SYMCRYPT_SHA512_224_STATE = _SYMCRYPT_SHA512_224_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_256_STATE { +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_SHA512_256_STATE { + pub bytesInBuffer: UINT32, + pub magic: SIZE_T, + pub dataLengthL: UINT64, + pub dataLengthH: UINT64, + pub buffer: [BYTE; 128usize], + pub chain: SYMCRYPT_SHA512_CHAINING_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA512_256_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA512_256_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, + 160usize, + "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" + ); +} +impl Default for _SYMCRYPT_SHA512_256_STATE { + 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 SYMCRYPT_SHA512_256_STATE = _SYMCRYPT_SHA512_256_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KECCAK_STATE { + pub state: [UINT64; 25usize], + pub inputBlockSize: UINT32, + pub stateIndex: UINT32, + pub paddingValue: UINT8, + pub squeezeMode: BOOLEAN, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), + 224usize, + "Size of _SYMCRYPT_KECCAK_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_KECCAK_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::state" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, + 200usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, + 204usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, + 208usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, + 209usize, + "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + ); +} +pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_224_STATE { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_224_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_SHA3_224_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" + ); +} +pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_256_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } @@ -669,14 +1109,262 @@ fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" + ); +} +pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; +pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; +pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), + 240usize, + "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { + pub ks: SYMCRYPT_KECCAK_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), + 240usize, + "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_OID { + pub cbOID: UINT32, + pub pbOID: PCBYTE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_OID() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_OID>(), + 16usize, + "Size of _SYMCRYPT_OID" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_OID>(), + 8usize, + "Alignment of _SYMCRYPT_OID" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_OID::cbOID" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_OID::pbOID" + ); +} +impl Default for _SYMCRYPT_OID { + 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 SYMCRYPT_OID = _SYMCRYPT_OID; +pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +extern "C" { + pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; +} +extern "C" { + pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; +} +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union _SYMCRYPT_HASH_STATE { + pub md2State: SYMCRYPT_MD2_STATE, + pub md4State: SYMCRYPT_MD4_STATE, + pub md5State: SYMCRYPT_MD5_STATE, + pub sha1State: SYMCRYPT_SHA1_STATE, + pub sha224State: SYMCRYPT_SHA224_STATE, + pub sha256State: SYMCRYPT_SHA256_STATE, + pub sha384State: SYMCRYPT_SHA384_STATE, + pub sha512State: SYMCRYPT_SHA512_STATE, + pub sha512_224State: SYMCRYPT_SHA512_224_STATE, + pub sha512_256State: SYMCRYPT_SHA512_256_STATE, + pub sha3_224State: SYMCRYPT_SHA3_224_STATE, + pub sha3_256State: SYMCRYPT_SHA3_256_STATE, + pub sha3_384State: SYMCRYPT_SHA3_384_STATE, + pub sha3_512State: SYMCRYPT_SHA3_512_STATE, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), + 240usize, + "Size of _SYMCRYPT_HASH_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HASH_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md2State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md4State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::md5State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" ); } -pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; -pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; -pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; +impl Default for _SYMCRYPT_HASH_STATE { + 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 SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE; pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; @@ -958,6 +1646,46 @@ pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, @@ -1045,91 +1773,322 @@ impl Default for _SYMCRYPT_HMAC_SHA256_STATE { } } } -pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; -pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; -pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; +pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; +pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; +pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_STATE { + pub hash: SYMCRYPT_SHA384_STATE, + pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA384_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 232usize, + "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA384_STATE { + 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 SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; +pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; +pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_STATE { + pub hash: SYMCRYPT_SHA512_STATE, + pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA512_STATE" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, + 224usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 232usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA512_STATE { + 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 SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; +pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; +pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { + pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, + pub magic: SIZE_T, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" + ); + assert_eq!( + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 128usize, + "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" + ); +} +pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { +pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" + "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" + "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" ); } -pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_STATE { - pub hash: SYMCRYPT_SHA384_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { + pub pHash: PCSYMCRYPT_HASH, + pub __bindgen_padding_0: u64, + pub innerState: SYMCRYPT_HASH_STATE, + pub outerState: SYMCRYPT_HASH_STATE, pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = +fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" + "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" + unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, + 256usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" + 496usize, + "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" ); } -impl Default for _SYMCRYPT_HMAC_SHA384_STATE { +impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1138,91 +2097,146 @@ impl Default for _SYMCRYPT_HMAC_SHA384_STATE { } } } -pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; -pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; -pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" + "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" + "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" ); } -pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_STATE { - pub hash: SYMCRYPT_SHA512_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub magic: SIZE_T, +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" + "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" + "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" + ); +} +impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { + 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 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { + pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + 512usize, + "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" ); } -impl Default for _SYMCRYPT_HMAC_SHA512_STATE { +impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1231,9 +2245,7 @@ impl Default for _SYMCRYPT_HMAC_SHA512_STATE { } } } -pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; -pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; -pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +pub type SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Copy, Clone)] @@ -1352,10 +2364,19 @@ pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, + pub sha224Key: SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, + pub sha512_224Key: SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, + pub sha512_256Key: SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, + pub sha3_224Key: SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, + pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, + pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, + pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY, + pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, + pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, } #[test] fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { @@ -1382,6 +2403,11 @@ fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, 0usize, @@ -1397,11 +2423,51 @@ fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, 0usize, "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" + ); } impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { fn default() -> Self { @@ -3922,6 +4988,18 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } +extern "C" { + pub fn SymCryptRsakeySetValueFromPrivateExponent( + pbModulus: PCBYTE, + cbModulus: SIZE_T, + u64PubExp: UINT64, + pbPrivateExponent: PCBYTE, + cbPrivateExponent: SIZE_T, + numFormat: SYMCRYPT_NUMBER_FORMAT, + flags: UINT32, + pkRsakey: PSYMCRYPT_RSAKEY, + ) -> SYMCRYPT_ERROR; +} extern "C" { pub fn SymCryptRsakeyGetValue( pkRsakey: PCSYMCRYPT_RSAKEY, @@ -4061,72 +5139,6 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_OID { - pub cbOID: UINT32, - pub pbOID: PCBYTE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} -impl Default for _SYMCRYPT_OID { - 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 SYMCRYPT_OID = _SYMCRYPT_OID; -pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -extern "C" { - pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; -} extern "C" { pub fn SymCryptRsaPkcs1Sign( pkRsakey: PCSYMCRYPT_RSAKEY, From bf76094423c371fb1ec8e7b0d45efaac8d4534fc Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 09:01:25 +0100 Subject: [PATCH 03/11] update links to symcrypt binaries --- .github/workflows/builld.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/builld.yml b/.github/workflows/builld.yml index 2a5afcc5..5ccd4ed4 100644 --- a/.github/workflows/builld.yml +++ b/.github/workflows/builld.yml @@ -16,19 +16,19 @@ jobs: include: - target: x86_64-pc-windows-msvc os: windows-latest - symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.4.2/symcrypt-windows-amd64-release-103.4.2-171f697.zip" + symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.8.0/symcrypt-windows-amd64-release-103.8.0-53be637d.zip" run-tests: true - target: aarch64-pc-windows-msvc os: windows-latest - symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.4.2/symcrypt-windows-arm64-release-103.4.2-171f697.zip" + symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.8.0/symcrypt-windows-arm64-release-103.8.0-53be637d.zip" run-tests: false # Windows doesn't support ARM64 emulation - target: x86_64-unknown-linux-gnu - symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.4.2/symcrypt-linux-generic-amd64-release-103.4.2-171f697.tar.gz" + symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.8.0/symcrypt-linux-generic-amd64-release-103.8.0-53be637.tar.gz" os: ubuntu-latest run-tests: true - target: aarch64-unknown-linux-gnu os: ubuntu-latest - symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.4.2/symcrypt-linux-generic-arm64-release-103.4.2-171f697.tar.gz" + symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.8.0/symcrypt-linux-generic-arm64-release-103.8.0-53be637.tar.gz" run-tests: false runs-on: ${{ matrix.os }} From 03a55036dd6c244e8184bb3ee381280d06dff53a Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 09:54:57 +0100 Subject: [PATCH 04/11] opaque md5 types --- symcrypt-sys/src/bindings.rs | 2 + .../src/bindings/aarch64_pc_windows_msvc.rs | 98 +------------------ .../src/bindings/aarch64_unknown_linux_gnu.rs | 98 +------------------ .../src/bindings/x86_64_pc_windows_msvc.rs | 98 +------------------ .../src/bindings/x86_64_unknown_linux_gnu.rs | 98 +------------------ 5 files changed, 10 insertions(+), 384 deletions(-) diff --git a/symcrypt-sys/src/bindings.rs b/symcrypt-sys/src/bindings.rs index a0d615d3..ebb87255 100644 --- a/symcrypt-sys/src/bindings.rs +++ b/symcrypt-sys/src/bindings.rs @@ -1,3 +1,5 @@ +#![allow(improper_ctypes)] // bindgen uses u128 for opaque types which is not officially stable yet + #[cfg(all(target_os = "windows", target_arch = "x86_64"))] mod x86_64_pc_windows_msvc; #[cfg(all(target_os = "windows", target_arch = "x86_64"))] diff --git a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs index ee1327b4..c3488e61 100644 --- a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs @@ -270,46 +270,11 @@ pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD5_CHAINING_STATE { - pub H: [UINT32; 4usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H" - ); -} -pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] pub struct _SYMCRYPT_MD5_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_MD5_CHAINING_STATE, + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), 112usize, @@ -320,45 +285,6 @@ fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { 16usize, "Alignment of _SYMCRYPT_MD5_STATE" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD5_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD5_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD5_STATE::chain" - ); -} -impl Default for _SYMCRYPT_MD5_STATE { - 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 SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; @@ -1469,15 +1395,10 @@ fn bindgen_test_layout__SYMCRYPT_HASH() { #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { - pub innerState: SYMCRYPT_MD5_CHAINING_STATE, - pub outerState: SYMCRYPT_MD5_CHAINING_STATE, - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 3usize], } #[test] fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), 48usize, @@ -1488,21 +1409,6 @@ fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic" - ); } pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; diff --git a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs index b1c9e4df..65ccd67f 100644 --- a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs @@ -269,46 +269,11 @@ pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD5_CHAINING_STATE { - pub H: [UINT32; 4usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H" - ); -} -pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] pub struct _SYMCRYPT_MD5_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_MD5_CHAINING_STATE, + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), 112usize, @@ -319,45 +284,6 @@ fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { 16usize, "Alignment of _SYMCRYPT_MD5_STATE" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD5_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD5_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD5_STATE::chain" - ); -} -impl Default for _SYMCRYPT_MD5_STATE { - 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 SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; @@ -1460,15 +1386,10 @@ fn bindgen_test_layout__SYMCRYPT_HASH() { #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { - pub innerState: SYMCRYPT_MD5_CHAINING_STATE, - pub outerState: SYMCRYPT_MD5_CHAINING_STATE, - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 3usize], } #[test] fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), 48usize, @@ -1479,21 +1400,6 @@ fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic" - ); } pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; diff --git a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs index 07970b27..177ec187 100644 --- a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs @@ -271,46 +271,11 @@ pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD5_CHAINING_STATE { - pub H: [UINT32; 4usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H" - ); -} -pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] pub struct _SYMCRYPT_MD5_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_MD5_CHAINING_STATE, + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), 112usize, @@ -321,45 +286,6 @@ fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { 16usize, "Alignment of _SYMCRYPT_MD5_STATE" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD5_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD5_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD5_STATE::chain" - ); -} -impl Default for _SYMCRYPT_MD5_STATE { - 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 SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; @@ -1470,15 +1396,10 @@ fn bindgen_test_layout__SYMCRYPT_HASH() { #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { - pub innerState: SYMCRYPT_MD5_CHAINING_STATE, - pub outerState: SYMCRYPT_MD5_CHAINING_STATE, - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 3usize], } #[test] fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), 48usize, @@ -1489,21 +1410,6 @@ fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic" - ); } pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; diff --git a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs index 8bda4666..0207efe5 100644 --- a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs @@ -270,46 +270,11 @@ pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD5_CHAINING_STATE { - pub H: [UINT32; 4usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H" - ); -} -pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] pub struct _SYMCRYPT_MD5_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_MD5_CHAINING_STATE, + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), 112usize, @@ -320,45 +285,6 @@ fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { 16usize, "Alignment of _SYMCRYPT_MD5_STATE" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD5_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD5_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD5_STATE::chain" - ); -} -impl Default for _SYMCRYPT_MD5_STATE { - 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 SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; @@ -1461,15 +1387,10 @@ fn bindgen_test_layout__SYMCRYPT_HASH() { #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { - pub innerState: SYMCRYPT_MD5_CHAINING_STATE, - pub outerState: SYMCRYPT_MD5_CHAINING_STATE, - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 3usize], } #[test] fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), 48usize, @@ -1480,21 +1401,6 @@ fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic" - ); } pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; From 0dcbc5aa6aab782860c9ac045a7d5f4e4d9454b7 Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 09:58:54 +0100 Subject: [PATCH 05/11] update bindgen script --- symcrypt-bindgen/src/main.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/symcrypt-bindgen/src/main.rs b/symcrypt-bindgen/src/main.rs index 0479305a..b9d10cf4 100644 --- a/symcrypt-bindgen/src/main.rs +++ b/symcrypt-bindgen/src/main.rs @@ -109,6 +109,10 @@ fn main() { .allowlist_function("SymCryptLoadMsbFirstUint64") .allowlist_function("SymCryptStoreMsbFirstUint64") + // Opaque types + .opaque_type("_SYMCRYPT_MD5_STATE") + .opaque_type("_SYMCRYPT_HMAC_MD5_EXPANDED_KEY") + .generate_comments(true) .derive_default(true) .generate() From 14bcd8bc8bfe03092992adf7c8ac1f4668b1592e Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 10:48:38 +0100 Subject: [PATCH 06/11] more opaque types --- symcrypt-bindgen/src/main.rs | 13 +- .../src/bindings/aarch64_pc_windows_msvc.rs | 3219 +++-------------- .../src/bindings/aarch64_unknown_linux_gnu.rs | 2821 ++------------- .../src/bindings/x86_64_pc_windows_msvc.rs | 2839 ++------------- .../src/bindings/x86_64_unknown_linux_gnu.rs | 2821 ++------------- 5 files changed, 1503 insertions(+), 10210 deletions(-) diff --git a/symcrypt-bindgen/src/main.rs b/symcrypt-bindgen/src/main.rs index b9d10cf4..6a922b3c 100644 --- a/symcrypt-bindgen/src/main.rs +++ b/symcrypt-bindgen/src/main.rs @@ -42,7 +42,7 @@ fn main() { std::fs::create_dir_all(out_dir).expect("Unable to create output directory"); - let bindings = bindgen::builder() + let mut builder = bindgen::builder() .header(wrapper_header.display().to_string()) .rust_target(bindgen::RustTarget::from_str(&rust_target).unwrap()) @@ -107,12 +107,15 @@ fn main() { .allowlist_function("SymCryptWipe") .allowlist_function("SymCryptRandom") .allowlist_function("SymCryptLoadMsbFirstUint64") - .allowlist_function("SymCryptStoreMsbFirstUint64") + .allowlist_function("SymCryptStoreMsbFirstUint64"); - // Opaque types - .opaque_type("_SYMCRYPT_MD5_STATE") - .opaque_type("_SYMCRYPT_HMAC_MD5_EXPANDED_KEY") + // Opaque types + builder = builder + .opaque_type(format!("_SYMCRYPT_.*_STATE")) + .opaque_type(format!("_SYMCRYPT_.*_EXPANDED_KEY")) + .opaque_type("_SYMCRYPT_BLOCKCIPHER"); + let bindings = builder .generate_comments(true) .derive_default(true) .generate() diff --git a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs index c3488e61..7e384d7a 100644 --- a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs @@ -48,7 +48,6 @@ pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS: _SYMCRYPT_ pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_MONTGOMERY: _SYMCRYPT_ECURVE_TYPE = 3; pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_int; pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE; -pub type UINT8 = ::std::os::raw::c_uchar; pub type BYTE = ::std::os::raw::c_uchar; pub type UINT32 = ::std::os::raw::c_uint; pub type UINT64 = ::std::os::raw::c_ulonglong; @@ -66,314 +65,212 @@ pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER; pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD2_CHAINING_STATE { - pub C: [BYTE; 16usize], - pub X: [BYTE; 48usize], +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_MD5_STATE { + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" - ); +fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" + ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD5_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" + "Alignment of _SYMCRYPT_MD5_STATE" ); } -impl Default for _SYMCRYPT_MD2_CHAINING_STATE { - 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 SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE; +pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; +pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; +pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD2_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 16usize], - pub chain: SYMCRYPT_MD2_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA1_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD2_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA1_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_SHA1_STATE" ); +} +pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE; +pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE; +pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA256_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD2_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA256_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD2_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MD2_STATE::chain" + "Alignment of _SYMCRYPT_SHA256_STATE" ); } -impl Default for _SYMCRYPT_MD2_STATE { - 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 SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; +pub type SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE; +pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; +pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD4_CHAINING_STATE { - pub H: [UINT32; 4usize], +pub struct _SYMCRYPT_SHA512_STATE { + pub _bindgen_opaque_blob: [u128; 14usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD4_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA512_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_SHA512_STATE" ); } -pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; +pub type SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE; +pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE; +pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD4_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_MD4_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA384_STATE { + pub _bindgen_opaque_blob: [u128; 14usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD4_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_SHA384_STATE" ); +} +pub type SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE; +pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; +pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_256_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD4_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_256_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD4_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD4_STATE::chain" + "Alignment of _SYMCRYPT_SHA3_256_STATE" ); } -impl Default for _SYMCRYPT_MD4_STATE { - 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 SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; +pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; +pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; +pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD5_STATE { - pub _bindgen_opaque_blob: [u128; 7usize], +pub struct _SYMCRYPT_SHA3_384_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { +fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD5_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD5_STATE" + "Alignment of _SYMCRYPT_SHA3_384_STATE" ); } -pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; -pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; -pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; +pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; +pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; +pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA1_CHAINING_STATE { - pub H: [UINT32; 5usize], +pub struct _SYMCRYPT_SHA3_512_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA1_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_512_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), 16usize, - "Alignment of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_SHA3_512_STATE" ); } -pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE; +pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; +pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; +pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; #[repr(C)] -#[repr(align(16))] #[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA1_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA1_CHAINING_STATE, +pub struct _SYMCRYPT_OID { + pub cbOID: UINT32, + pub pbOID: PCBYTE, } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_OID() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_OID>(), 16usize, - "Alignment of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer" + "Size of _SYMCRYPT_OID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_OID>(), 8usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH" + "Alignment of _SYMCRYPT_OID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::buffer" + unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_OID::cbOID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::chain" + unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_OID::pbOID" ); } -impl Default for _SYMCRYPT_SHA1_STATE { +impl Default for _SYMCRYPT_OID { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -382,2491 +279,457 @@ impl Default for _SYMCRYPT_SHA1_STATE { } } } -pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE; -pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE; -pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA256_CHAINING_STATE { - pub H: [UINT32; 8usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H" - ); +pub type SYMCRYPT_OID = _SYMCRYPT_OID; +pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE; -#[repr(C)] +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; +} +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; +} +pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; +pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; +pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; +pub type PSYMCRYPT_HASH_APPEND_FUNC = + ::std::option::Option; +pub type PSYMCRYPT_HASH_RESULT_FUNC = + ::std::option::Option; +pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option< + unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T), +>; +pub type PSYMCRYPT_HASH_STATE_COPY_FUNC = + ::std::option::Option; +#[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA256_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HASH { + pub initFunc: PSYMCRYPT_HASH_INIT_FUNC, + pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC, + pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC, + pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC, + pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC, + pub stateSize: UINT32, + pub resultSize: UINT32, + pub inputBlockSize: UINT32, + pub chainOffset: UINT32, + pub chainSize: UINT32, } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_HASH() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA256_STATE" + ::std::mem::size_of::<_SYMCRYPT_HASH>(), + 64usize, + "Size of _SYMCRYPT_HASH" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HASH>(), 16usize, - "Alignment of _SYMCRYPT_SHA256_STATE" + "Alignment of _SYMCRYPT_HASH" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer" + "Offset of field: _SYMCRYPT_HASH::initFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, 8usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::magic" + "Offset of field: _SYMCRYPT_HASH::appendFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, 16usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL" + "Offset of field: _SYMCRYPT_HASH::resultFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, 24usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH" + "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, 32usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA256_STATE { - 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 SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE; -pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; -pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA224_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA256_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" + "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, + 40usize, + "Offset of field: _SYMCRYPT_HASH::stateSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" + unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, + 44usize, + "Offset of field: _SYMCRYPT_HASH::resultSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" + unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_HASH::inputBlockSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" + unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, + 52usize, + "Offset of field: _SYMCRYPT_HASH::chainOffset" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::chain" + unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, + 56usize, + "Offset of field: _SYMCRYPT_HASH::chainSize" ); } -impl Default for _SYMCRYPT_SHA224_STATE { - 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 SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_CHAINING_STATE { - pub H: [UINT64; 8usize], +pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 3usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_SHA512_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), + 48usize, + "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); } -pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE; +pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_MD5_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), + 128usize, + "Size of _SYMCRYPT_HMAC_MD5_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), 16usize, - "Alignment of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_HMAC_MD5_STATE" ); +} +pub type SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE; +pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE; +pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 5usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), 16usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH" + "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" ); +} +pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA1_STATE { + pub _bindgen_opaque_blob: [u128; 9usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::buffer" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA1_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::chain" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" ); } -impl Default for _SYMCRYPT_SHA512_STATE { - 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 SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE; -pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE; -pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE; +pub type SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE; +pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE; +pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA384_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 5usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA384_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_SHA384_STATE" + "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA384_STATE { - 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 SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE; -pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; -pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_224_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_224_STATE { - 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 SYMCRYPT_SHA512_224_STATE = _SYMCRYPT_SHA512_224_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_256_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_256_STATE { - 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 SYMCRYPT_SHA512_256_STATE = _SYMCRYPT_SHA512_256_STATE; +pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KECCAK_STATE { - pub state: [UINT64; 25usize], - pub inputBlockSize: UINT32, - pub stateIndex: UINT32, - pub paddingValue: UINT8, - pub squeezeMode: BOOLEAN, +pub struct _SYMCRYPT_HMAC_SHA256_STATE { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), - 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA256_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" + "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" ); } -pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; +pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; +pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; +pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_224_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, +pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_224_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" + "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" ); } -pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; +pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_256_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, +pub struct _SYMCRYPT_HMAC_SHA384_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), 240usize, - "Size of _SYMCRYPT_SHA3_256_STATE" + "Size of _SYMCRYPT_HMAC_SHA384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::magic" + "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" ); } -pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; -pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; -pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; +pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; +pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; +pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_384_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, +pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_384_STATE" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::magic" + "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" ); } -pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; -pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; -pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; +pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_512_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, +pub struct _SYMCRYPT_HMAC_SHA512_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), 240usize, - "Size of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; -pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; -pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_OID { - pub cbOID: UINT32, - pub pbOID: PCBYTE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} -impl Default for _SYMCRYPT_OID { - 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 SYMCRYPT_OID = _SYMCRYPT_OID; -pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; -} -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_HASH_STATE { - pub md2State: SYMCRYPT_MD2_STATE, - pub md4State: SYMCRYPT_MD4_STATE, - pub md5State: SYMCRYPT_MD5_STATE, - pub sha1State: SYMCRYPT_SHA1_STATE, - pub sha224State: SYMCRYPT_SHA224_STATE, - pub sha256State: SYMCRYPT_SHA256_STATE, - pub sha384State: SYMCRYPT_SHA384_STATE, - pub sha512State: SYMCRYPT_SHA512_STATE, - pub sha512_224State: SYMCRYPT_SHA512_224_STATE, - pub sha512_256State: SYMCRYPT_SHA512_256_STATE, - pub sha3_224State: SYMCRYPT_SHA3_224_STATE, - pub sha3_256State: SYMCRYPT_SHA3_256_STATE, - pub sha3_384State: SYMCRYPT_SHA3_384_STATE, - pub sha3_512State: SYMCRYPT_SHA3_512_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), - 240usize, - "Size of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md2State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md4State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md5State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" - ); -} -impl Default for _SYMCRYPT_HASH_STATE { - 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 SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE; -pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; -pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; -pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; -pub type PSYMCRYPT_HASH_APPEND_FUNC = - ::std::option::Option; -pub type PSYMCRYPT_HASH_RESULT_FUNC = - ::std::option::Option; -pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option< - unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T), ->; -pub type PSYMCRYPT_HASH_STATE_COPY_FUNC = - ::std::option::Option; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HASH { - pub initFunc: PSYMCRYPT_HASH_INIT_FUNC, - pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC, - pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC, - pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC, - pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC, - pub stateSize: UINT32, - pub resultSize: UINT32, - pub inputBlockSize: UINT32, - pub chainOffset: UINT32, - pub chainSize: UINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH>(), - 64usize, - "Size of _SYMCRYPT_HASH" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH>(), - 16usize, - "Alignment of _SYMCRYPT_HASH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_HASH::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HASH::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_HASH::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_HASH::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_HASH::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_HASH::chainOffset" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_HASH::chainSize" - ); -} -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { - pub _bindgen_opaque_blob: [u128; 3usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 48usize, - "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); -} -pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_MD5_STATE { - pub hash: SYMCRYPT_MD5_STATE, - pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 128usize, - "Size of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 112usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_MD5_STATE { - 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 SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE; -pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE; -pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA1_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA1_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA1_STATE { - pub hash: SYMCRYPT_SHA1_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA1_STATE { - 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 SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE; -pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE; -pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA256_STATE { - pub hash: SYMCRYPT_SHA256_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA256_STATE { - 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 SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; -pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; -pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_STATE { - pub hash: SYMCRYPT_SHA384_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA384_STATE { - 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 SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; -pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; -pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_STATE { - pub hash: SYMCRYPT_SHA512_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA512_STATE { - 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 SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; -pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; -pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { - pub pHash: PCSYMCRYPT_HASH, - pub __bindgen_padding_0: u64, - pub innerState: SYMCRYPT_HASH_STATE, - pub outerState: SYMCRYPT_HASH_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 256usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_AES_EXPANDED_KEY { - pub RoundKey: [[[BYTE; 4usize]; 4usize]; 29usize], - pub lastEncRoundKey: *mut [[BYTE; 4usize]; 4usize], - pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize], - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 496usize, - "Size of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize }, - 464usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize }, - 472usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 480usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic" - ); -} -impl Default for _SYMCRYPT_AES_EXPANDED_KEY { - 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 SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; -pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; -pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY { - pub aesKey: SYMCRYPT_AES_EXPANDED_KEY, - pub K1: [BYTE; 16usize], - pub K2: [BYTE; 16usize], - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize }, - 512usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 528usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic" - ); -} -impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { - 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 SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MAC_EXPANDED_KEY { - pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, - pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, - pub sha224Key: SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, - pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, - pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, - pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub sha512_224Key: SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, - pub sha512_256Key: SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, - pub sha3_224Key: SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, - pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, - pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, - pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, - pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY, - pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, - pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" - ); -} -impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { - 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 SYMCRYPT_MAC_EXPANDED_KEY = _SYMCRYPT_MAC_EXPANDED_KEY; -pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_MAC_INIT = - ::std::option::Option; -pub type PSYMCRYPT_MAC_APPEND = - ::std::option::Option; -pub type PSYMCRYPT_MAC_RESULT = - ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MAC { - pub expandKeyFunc: PSYMCRYPT_MAC_EXPAND_KEY, - pub initFunc: PSYMCRYPT_MAC_INIT, - pub appendFunc: PSYMCRYPT_MAC_APPEND, - pub resultFunc: PSYMCRYPT_MAC_RESULT, - pub expandedKeySize: SIZE_T, - pub stateSize: SIZE_T, - pub resultSize: SIZE_T, - pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, - pub outerChainingStateOffset: UINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC>(), - 72usize, - "Size of _SYMCRYPT_MAC" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC>(), - 8usize, - "Alignment of _SYMCRYPT_MAC" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} -impl Default for _SYMCRYPT_MAC { - 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 SYMCRYPT_MAC = _SYMCRYPT_MAC; -pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { - pub aes: SYMCRYPT_AES_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 496usize, - "Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes" - ); -} -impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { - 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 SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS = _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS; -pub type poly8_t = ::std::os::raw::c_uchar; -pub type poly16_t = ::std::os::raw::c_ushort; -pub type poly32_t = ::std::os::raw::c_uint; -pub type poly64_t = ::std::os::raw::c_ulonglong; -#[repr(C)] -#[derive(Copy, Clone)] -pub union __n64 { - pub n64_u64: [::std::os::raw::c_ulonglong; 1usize], - pub n64_u32: [::std::os::raw::c_uint; 2usize], - pub n64_u16: [::std::os::raw::c_ushort; 4usize], - pub n64_u8: [::std::os::raw::c_uchar; 8usize], - pub n64_i64: [::std::os::raw::c_longlong; 1usize], - pub n64_i32: [::std::os::raw::c_int; 2usize], - pub n64_i16: [::std::os::raw::c_short; 4usize], - pub n64_i8: [::std::os::raw::c_char; 8usize], - pub n64_p64: [poly64_t; 1usize], - pub n64_p32: [poly32_t; 2usize], - pub n64_p16: [poly16_t; 4usize], - pub n64_p8: [poly8_t; 8usize], - pub n64_f32: [f32; 2usize], - pub n64_f64: [f64; 1usize], -} -#[test] -fn bindgen_test_layout___n64() { - const UNINIT: ::std::mem::MaybeUninit<__n64> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!(::std::mem::size_of::<__n64>(), 8usize, "Size of __n64"); - assert_eq!( - ::std::mem::align_of::<__n64>(), - 8usize, - "Alignment of __n64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_u64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_u64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_u32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_u32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_u16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_u16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_u8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_u8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_i64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_i64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_i32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_i32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_i16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_i16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_i8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_i8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_p64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_p64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_p32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_p32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_p16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_p16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_p8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_p8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_f32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_f32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_f64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_f64" - ); -} -impl Default for __n64 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union __n128 { - pub n128_u64: [::std::os::raw::c_ulonglong; 2usize], - pub n128_u32: [::std::os::raw::c_uint; 4usize], - pub n128_u16: [::std::os::raw::c_ushort; 8usize], - pub n128_u8: [::std::os::raw::c_uchar; 16usize], - pub n128_i64: [::std::os::raw::c_longlong; 2usize], - pub n128_i32: [::std::os::raw::c_int; 4usize], - pub n128_i16: [::std::os::raw::c_short; 8usize], - pub n128_i8: [::std::os::raw::c_char; 16usize], - pub n128_p64: [poly64_t; 2usize], - pub n128_p32: [poly32_t; 4usize], - pub n128_p16: [poly16_t; 8usize], - pub n128_p8: [poly8_t; 16usize], - pub n128_f32: [f32; 4usize], - pub n128_f64: [f64; 2usize], - pub s: __n128__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct __n128__bindgen_ty_1 { - pub low64: __n64, - pub high64: __n64, -} -#[test] -fn bindgen_test_layout___n128__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<__n128__bindgen_ty_1> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<__n128__bindgen_ty_1>(), - 16usize, - "Size of __n128__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<__n128__bindgen_ty_1>(), - 8usize, - "Alignment of __n128__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).low64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128__bindgen_ty_1::low64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).high64) as usize - ptr as usize }, - 8usize, - "Offset of field: __n128__bindgen_ty_1::high64" - ); -} -impl Default for __n128__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout___n128() { - const UNINIT: ::std::mem::MaybeUninit<__n128> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!(::std::mem::size_of::<__n128>(), 16usize, "Size of __n128"); - assert_eq!( - ::std::mem::align_of::<__n128>(), - 16usize, - "Alignment of __n128" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_u64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_u64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_u32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_u32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_u16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_u16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_u8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_u8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_i64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_i64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_i32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_i32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_i16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_i16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_i8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_i8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_p64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_p64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_p32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_p32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_p16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_p16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_p8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_p8" + "Size of _SYMCRYPT_HMAC_SHA512_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_f32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_f32" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" ); +} +pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; +pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; +pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_AES_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 31usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_f64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_f64" + ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + 496usize, + "Size of _SYMCRYPT_AES_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::s" + ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" ); } -impl Default for __n128 { - 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 SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; +pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; +pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; +pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< + unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, +>; +pub type PSYMCRYPT_MAC_INIT = + ::std::option::Option; +pub type PSYMCRYPT_MAC_APPEND = + ::std::option::Option; +pub type PSYMCRYPT_MAC_RESULT = + ::std::option::Option; #[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_GF128_ELEMENT { - pub ull: [UINT64; 2usize], - pub n128: __n128, - pub ul: [UINT32; 4usize], +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_MAC { + pub expandKeyFunc: PSYMCRYPT_MAC_EXPAND_KEY, + pub initFunc: PSYMCRYPT_MAC_INIT, + pub appendFunc: PSYMCRYPT_MAC_APPEND, + pub resultFunc: PSYMCRYPT_MAC_RESULT, + pub expandedKeySize: SIZE_T, + pub stateSize: SIZE_T, + pub resultSize: SIZE_T, + pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, + pub outerChainingStateOffset: UINT32, } #[test] -fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_MAC() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Size of _SYMCRYPT_GF128_ELEMENT" + ::std::mem::size_of::<_SYMCRYPT_MAC>(), + 72usize, + "Size of _SYMCRYPT_MAC" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Alignment of _SYMCRYPT_GF128_ELEMENT" + ::std::mem::align_of::<_SYMCRYPT_MAC>(), + 8usize, + "Alignment of _SYMCRYPT_MAC" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ull" + "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::n128" + unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_MAC::initFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ul" + unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_MAC::appendFunc" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, + 24usize, + "Offset of field: _SYMCRYPT_MAC::resultFunc" ); -} -impl Default for _SYMCRYPT_GF128_ELEMENT { - 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 SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_GHASH_EXPANDED_KEY { - pub table: [SYMCRYPT_GF128_ELEMENT; 128usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 2048usize, - "Size of _SYMCRYPT_GHASH_EXPANDED_KEY" + unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, + 32usize, + "Offset of field: _SYMCRYPT_MAC::expandedKeySize" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY" + unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, + 40usize, + "Offset of field: _SYMCRYPT_MAC::stateSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table" + unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_MAC::resultSize" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, + 56usize, + "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, + 64usize, + "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" ); } -impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { +impl Default for _SYMCRYPT_MAC { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -2875,24 +738,15 @@ impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { } } } -pub type SYMCRYPT_GHASH_EXPANDED_KEY = _SYMCRYPT_GHASH_EXPANDED_KEY; +pub type SYMCRYPT_MAC = _SYMCRYPT_MAC; +pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_GCM_EXPANDED_KEY { - pub ghashKey: SYMCRYPT_GHASH_EXPANDED_KEY, - pub pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, - pub __bindgen_padding_0: u64, - pub blockcipherKey: SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS, - pub cbKey: SIZE_T, - pub abKey: [BYTE; 32usize], - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 163usize], } #[test] fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), 2608usize, @@ -2903,36 +757,6 @@ fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_GCM_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize }, - 2048usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize }, - 2064usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize }, - 2560usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize }, - 2568usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 2600usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic" - ); } impl Default for _SYMCRYPT_GCM_EXPANDED_KEY { fn default() -> Self { @@ -2948,22 +772,12 @@ pub type PSYMCRYPT_GCM_EXPANDED_KEY = *mut _SYMCRYPT_GCM_EXPANDED_KEY; pub type PCSYMCRYPT_GCM_EXPANDED_KEY = *const SYMCRYPT_GCM_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_GCM_STATE { - pub pKey: PCSYMCRYPT_GCM_EXPANDED_KEY, - pub cbData: UINT64, - pub cbAuthData: UINT64, - pub bytesInMacBlock: SIZE_T, - pub ghashState: SYMCRYPT_GF128_ELEMENT, - pub counterBlock: [BYTE; 16usize], - pub macBlock: [BYTE; 16usize], - pub keystreamBlock: [BYTE; 16usize], - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(), 112usize, @@ -2974,114 +788,18 @@ fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { 16usize, "Alignment of _SYMCRYPT_GCM_STATE" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_GCM_STATE::ghashState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_GCM_STATE::counterBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_GCM_STATE::macBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_GCM_STATE::magic" - ); -} -impl Default for _SYMCRYPT_GCM_STATE { - 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 SYMCRYPT_GCM_STATE = _SYMCRYPT_GCM_STATE; pub type PSYMCRYPT_GCM_STATE = *mut _SYMCRYPT_GCM_STATE; pub type PCSYMCRYPT_GCM_STATE = *const SYMCRYPT_GCM_STATE; -pub type PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT = - ::std::option::Option; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PCVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T), ->; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE = ::std::option::Option< - unsafe extern "C" fn( - pExpandedKey: PCVOID, - pbChainingValue: PBYTE, - pbSrc: PCBYTE, - pbDst: PBYTE, - cbData: SIZE_T, - ), ->; -pub type PSYMCRYPT_BLOCKCIPHER_MAC_MODE = ::std::option::Option< - unsafe extern "C" fn( - pExpandedKey: PCVOID, - pbChainingValue: PBYTE, - pbSrc: PCBYTE, - cbData: SIZE_T, - ), ->; -pub type PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE = ::std::option::Option< - unsafe extern "C" fn(pState: PVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T), ->; #[repr(C)] +#[repr(align(8))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_BLOCKCIPHER { - pub expandKeyFunc: PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY, - pub encryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT, - pub decryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT, - pub ecbEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB, - pub ecbDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB, - pub cbcEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub cbcDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub cbcMacFunc: PSYMCRYPT_BLOCKCIPHER_MAC_MODE, - pub ctrMsb64Func: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub gcmEncryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE, - pub gcmDecryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE, - pub blockSize: SIZE_T, - pub expandedKeySize: SIZE_T, + pub _bindgen_opaque_blob: [u64; 13usize], } #[test] fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(), 104usize, @@ -3092,84 +810,14 @@ fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { 8usize, "Alignment of _SYMCRYPT_BLOCKCIPHER" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize" - ); } #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { - pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, - pub macAlg: PCSYMCRYPT_MAC, + pub _bindgen_opaque_blob: [u128; 35usize], } #[test] fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), 560usize, @@ -3180,16 +828,6 @@ fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg" - ); } impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { fn default() -> Self { @@ -3205,16 +843,11 @@ pub type PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *mut _SYMCRYPT_TLSPRF1_2_EXPANDED_KE pub type PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *const SYMCRYPT_TLSPRF1_2_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_HKDF_EXPANDED_KEY { - pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, - pub macAlg: PCSYMCRYPT_MAC, + pub _bindgen_opaque_blob: [u128; 35usize], } #[test] fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), 560usize, @@ -3225,16 +858,6 @@ fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg" - ); } impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { fn default() -> Self { diff --git a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs index 65ccd67f..b8104230 100644 --- a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs @@ -50,7 +50,6 @@ pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_uint; pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE; pub type BYTE = u8; pub type SIZE_T = usize; -pub type UINT8 = u8; pub type UINT32 = u32; pub type UINT64 = u64; pub type PUINT64 = *mut u64; @@ -65,314 +64,212 @@ pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER; pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD2_CHAINING_STATE { - pub C: [BYTE; 16usize], - pub X: [BYTE; 48usize], +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_MD5_STATE { + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" - ); +fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" + ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD5_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" + "Alignment of _SYMCRYPT_MD5_STATE" ); } -impl Default for _SYMCRYPT_MD2_CHAINING_STATE { - 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 SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE; +pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; +pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; +pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD2_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 16usize], - pub chain: SYMCRYPT_MD2_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA1_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD2_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA1_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_SHA1_STATE" ); +} +pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE; +pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE; +pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA256_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD2_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA256_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD2_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MD2_STATE::chain" + "Alignment of _SYMCRYPT_SHA256_STATE" ); } -impl Default for _SYMCRYPT_MD2_STATE { - 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 SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; +pub type SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE; +pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; +pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD4_CHAINING_STATE { - pub H: [UINT32; 4usize], +pub struct _SYMCRYPT_SHA512_STATE { + pub _bindgen_opaque_blob: [u128; 14usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD4_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA512_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_SHA512_STATE" ); } -pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; +pub type SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE; +pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE; +pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD4_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_MD4_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA384_STATE { + pub _bindgen_opaque_blob: [u128; 14usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD4_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_SHA384_STATE" ); +} +pub type SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE; +pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; +pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_256_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD4_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_256_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD4_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD4_STATE::chain" + "Alignment of _SYMCRYPT_SHA3_256_STATE" ); } -impl Default for _SYMCRYPT_MD4_STATE { - 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 SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; +pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; +pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; +pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD5_STATE { - pub _bindgen_opaque_blob: [u128; 7usize], +pub struct _SYMCRYPT_SHA3_384_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { +fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD5_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD5_STATE" + "Alignment of _SYMCRYPT_SHA3_384_STATE" ); } -pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; -pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; -pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; +pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; +pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; +pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA1_CHAINING_STATE { - pub H: [UINT32; 5usize], +pub struct _SYMCRYPT_SHA3_512_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA1_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_512_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), 16usize, - "Alignment of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_SHA3_512_STATE" ); } -pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE; +pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; +pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; +pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; #[repr(C)] -#[repr(align(16))] #[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA1_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA1_CHAINING_STATE, +pub struct _SYMCRYPT_OID { + pub cbOID: UINT32, + pub pbOID: PCBYTE, } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_OID() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_OID>(), 16usize, - "Alignment of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer" + "Size of _SYMCRYPT_OID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_OID>(), 8usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH" + "Alignment of _SYMCRYPT_OID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::buffer" + unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_OID::cbOID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::chain" + unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_OID::pbOID" ); } -impl Default for _SYMCRYPT_SHA1_STATE { +impl Default for _SYMCRYPT_OID { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -381,2009 +278,366 @@ impl Default for _SYMCRYPT_SHA1_STATE { } } } -pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE; -pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE; -pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA256_CHAINING_STATE { - pub H: [UINT32; 8usize], +pub type SYMCRYPT_OID = _SYMCRYPT_OID; +pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +extern "C" { + pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H" - ); +extern "C" { + pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA256_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +extern "C" { + pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::chain" - ); +extern "C" { + pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -impl Default for _SYMCRYPT_SHA256_STATE { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } +extern "C" { + pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE; -pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; -pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA224_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +extern "C" { + pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::chain" - ); +extern "C" { + pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -impl Default for _SYMCRYPT_SHA224_STATE { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } +extern "C" { + pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; +pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; +pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; +pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; +pub type PSYMCRYPT_HASH_APPEND_FUNC = + ::std::option::Option; +pub type PSYMCRYPT_HASH_RESULT_FUNC = + ::std::option::Option; +pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option< + unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T), +>; +pub type PSYMCRYPT_HASH_STATE_COPY_FUNC = + ::std::option::Option; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_CHAINING_STATE { - pub H: [UINT64; 8usize], +pub struct _SYMCRYPT_HASH { + pub initFunc: PSYMCRYPT_HASH_INIT_FUNC, + pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC, + pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC, + pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC, + pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC, + pub stateSize: UINT32, + pub resultSize: UINT32, + pub inputBlockSize: UINT32, + pub chainOffset: UINT32, + pub chainSize: UINT32, } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_HASH() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_HASH>(), 64usize, - "Size of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H" - ); -} -pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_STATE { - 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 SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE; -pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE; -pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA384_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA384_STATE" + "Size of _SYMCRYPT_HASH" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HASH>(), 16usize, - "Alignment of _SYMCRYPT_SHA384_STATE" + "Alignment of _SYMCRYPT_HASH" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer" + "Offset of field: _SYMCRYPT_HASH::initFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, 8usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::magic" + "Offset of field: _SYMCRYPT_HASH::appendFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, 16usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL" + "Offset of field: _SYMCRYPT_HASH::resultFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, 24usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH" + "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, 32usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::chain" + "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" ); -} -impl Default for _SYMCRYPT_SHA384_STATE { - 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 SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE; -pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; -pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_224_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_224_STATE" + unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, + 40usize, + "Offset of field: _SYMCRYPT_HASH::stateSize" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_224_STATE" + unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, + 44usize, + "Offset of field: _SYMCRYPT_HASH::resultSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" + unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_HASH::inputBlockSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, + 52usize, + "Offset of field: _SYMCRYPT_HASH::chainOffset" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_224_STATE { - 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 SYMCRYPT_SHA512_224_STATE = _SYMCRYPT_SHA512_224_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_256_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_256_STATE { - 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 SYMCRYPT_SHA512_256_STATE = _SYMCRYPT_SHA512_256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KECCAK_STATE { - pub state: [UINT64; 25usize], - pub inputBlockSize: UINT32, - pub stateIndex: UINT32, - pub paddingValue: UINT8, - pub squeezeMode: BOOLEAN, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), - 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" - ); -} -pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_224_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_256_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; -pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; -pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_384_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; -pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; -pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_512_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; -pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; -pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_OID { - pub cbOID: UINT32, - pub pbOID: PCBYTE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} -impl Default for _SYMCRYPT_OID { - 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 SYMCRYPT_OID = _SYMCRYPT_OID; -pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -extern "C" { - pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; -} -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_HASH_STATE { - pub md2State: SYMCRYPT_MD2_STATE, - pub md4State: SYMCRYPT_MD4_STATE, - pub md5State: SYMCRYPT_MD5_STATE, - pub sha1State: SYMCRYPT_SHA1_STATE, - pub sha224State: SYMCRYPT_SHA224_STATE, - pub sha256State: SYMCRYPT_SHA256_STATE, - pub sha384State: SYMCRYPT_SHA384_STATE, - pub sha512State: SYMCRYPT_SHA512_STATE, - pub sha512_224State: SYMCRYPT_SHA512_224_STATE, - pub sha512_256State: SYMCRYPT_SHA512_256_STATE, - pub sha3_224State: SYMCRYPT_SHA3_224_STATE, - pub sha3_256State: SYMCRYPT_SHA3_256_STATE, - pub sha3_384State: SYMCRYPT_SHA3_384_STATE, - pub sha3_512State: SYMCRYPT_SHA3_512_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), - 240usize, - "Size of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md2State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md4State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md5State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" - ); -} -impl Default for _SYMCRYPT_HASH_STATE { - 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 SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE; -pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; -pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; -pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; -pub type PSYMCRYPT_HASH_APPEND_FUNC = - ::std::option::Option; -pub type PSYMCRYPT_HASH_RESULT_FUNC = - ::std::option::Option; -pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option< - unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T), ->; -pub type PSYMCRYPT_HASH_STATE_COPY_FUNC = - ::std::option::Option; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HASH { - pub initFunc: PSYMCRYPT_HASH_INIT_FUNC, - pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC, - pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC, - pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC, - pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC, - pub stateSize: UINT32, - pub resultSize: UINT32, - pub inputBlockSize: UINT32, - pub chainOffset: UINT32, - pub chainSize: UINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH>(), - 64usize, - "Size of _SYMCRYPT_HASH" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH>(), - 16usize, - "Alignment of _SYMCRYPT_HASH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_HASH::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HASH::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_HASH::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_HASH::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_HASH::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_HASH::chainOffset" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_HASH::chainSize" - ); -} -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { - pub _bindgen_opaque_blob: [u128; 3usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 48usize, - "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); -} -pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_MD5_STATE { - pub hash: SYMCRYPT_MD5_STATE, - pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 128usize, - "Size of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 112usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_MD5_STATE { - 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 SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE; -pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE; -pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA1_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA1_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA1_STATE { - pub hash: SYMCRYPT_SHA1_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA1_STATE { - 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 SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE; -pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE; -pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA256_STATE { - pub hash: SYMCRYPT_SHA256_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA256_STATE { - 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 SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; -pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; -pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_STATE { - pub hash: SYMCRYPT_SHA384_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA384_STATE { - 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 SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; -pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; -pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_STATE { - pub hash: SYMCRYPT_SHA512_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA512_STATE { - 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 SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; -pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; -pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { - pub pHash: PCSYMCRYPT_HASH, - pub __bindgen_padding_0: u64, - pub innerState: SYMCRYPT_HASH_STATE, - pub outerState: SYMCRYPT_HASH_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 256usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } + unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, + 56usize, + "Offset of field: _SYMCRYPT_HASH::chainSize" + ); } -pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 3usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), + 48usize, + "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_MD5_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), + 128usize, + "Size of _SYMCRYPT_HMAC_MD5_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_MD5_STATE" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE; +pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE; +pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 5usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA1_STATE { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA1_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE; +pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE; +pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_AES_EXPANDED_KEY { - pub RoundKey: [[[BYTE; 4usize]; 4usize]; 29usize], - pub lastEncRoundKey: *mut [[BYTE; 4usize]; 4usize], - pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize], - pub magic: SIZE_T, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 5usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 496usize, - "Size of _SYMCRYPT_AES_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize }, - 464usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize }, - 472usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 480usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic" + "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_AES_EXPANDED_KEY { - 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 SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; -pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; -pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY { - pub aesKey: SYMCRYPT_AES_EXPANDED_KEY, - pub K1: [BYTE; 16usize], - pub K2: [BYTE; 16usize], - pub magic: SIZE_T, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA256_STATE { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA256_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), 16usize, - "Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize }, - 512usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 528usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic" + "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" ); } -impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { - 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 SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; +pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; +pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MAC_EXPANDED_KEY { - pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, - pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, - pub sha224Key: SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, - pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, - pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, - pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub sha512_224Key: SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, - pub sha512_256Key: SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, - pub sha3_224Key: SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, - pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, - pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, - pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, - pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY, - pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, - pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_MAC_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" + "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" ); +} +pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA384_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" ); +} +pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; +pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; +pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 9usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" ); +} +pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA512_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" ); +} +pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; +pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; +pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_AES_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 31usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" + ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + 496usize, + "Size of _SYMCRYPT_AES_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" + ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { - 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 SYMCRYPT_MAC_EXPANDED_KEY = _SYMCRYPT_MAC_EXPANDED_KEY; +pub type SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; +pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; +pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, >; @@ -2479,145 +733,11 @@ pub type SYMCRYPT_MAC = _SYMCRYPT_MAC; pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { - pub aes: SYMCRYPT_AES_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 496usize, - "Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes" - ); -} -impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { - 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 SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS = _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS; -pub type uint8x16_t = [u8; 16usize]; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_GF128_ELEMENT { - pub ull: [UINT64; 2usize], - pub n128: uint8x16_t, - pub ul: [UINT32; 4usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Size of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Alignment of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ull" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::n128" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ul" - ); -} -impl Default for _SYMCRYPT_GF128_ELEMENT { - 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 SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_GHASH_EXPANDED_KEY { - pub table: [SYMCRYPT_GF128_ELEMENT; 128usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 2048usize, - "Size of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table" - ); -} -impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { - 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 SYMCRYPT_GHASH_EXPANDED_KEY = _SYMCRYPT_GHASH_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_GCM_EXPANDED_KEY { - pub ghashKey: SYMCRYPT_GHASH_EXPANDED_KEY, - pub pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, - pub __bindgen_padding_0: u64, - pub blockcipherKey: SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS, - pub cbKey: SIZE_T, - pub abKey: [BYTE; 32usize], - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 163usize], } #[test] fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), 2608usize, @@ -2628,36 +748,6 @@ fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_GCM_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize }, - 2048usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize }, - 2064usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize }, - 2560usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize }, - 2568usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 2600usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic" - ); } impl Default for _SYMCRYPT_GCM_EXPANDED_KEY { fn default() -> Self { @@ -2673,22 +763,12 @@ pub type PSYMCRYPT_GCM_EXPANDED_KEY = *mut _SYMCRYPT_GCM_EXPANDED_KEY; pub type PCSYMCRYPT_GCM_EXPANDED_KEY = *const SYMCRYPT_GCM_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_GCM_STATE { - pub pKey: PCSYMCRYPT_GCM_EXPANDED_KEY, - pub cbData: UINT64, - pub cbAuthData: UINT64, - pub bytesInMacBlock: SIZE_T, - pub ghashState: SYMCRYPT_GF128_ELEMENT, - pub counterBlock: [BYTE; 16usize], - pub macBlock: [BYTE; 16usize], - pub keystreamBlock: [BYTE; 16usize], - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(), 112usize, @@ -2699,114 +779,18 @@ fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { 16usize, "Alignment of _SYMCRYPT_GCM_STATE" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_GCM_STATE::ghashState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_GCM_STATE::counterBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_GCM_STATE::macBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_GCM_STATE::magic" - ); -} -impl Default for _SYMCRYPT_GCM_STATE { - 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 SYMCRYPT_GCM_STATE = _SYMCRYPT_GCM_STATE; pub type PSYMCRYPT_GCM_STATE = *mut _SYMCRYPT_GCM_STATE; pub type PCSYMCRYPT_GCM_STATE = *const SYMCRYPT_GCM_STATE; -pub type PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT = - ::std::option::Option; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PCVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T), ->; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE = ::std::option::Option< - unsafe extern "C" fn( - pExpandedKey: PCVOID, - pbChainingValue: PBYTE, - pbSrc: PCBYTE, - pbDst: PBYTE, - cbData: SIZE_T, - ), ->; -pub type PSYMCRYPT_BLOCKCIPHER_MAC_MODE = ::std::option::Option< - unsafe extern "C" fn( - pExpandedKey: PCVOID, - pbChainingValue: PBYTE, - pbSrc: PCBYTE, - cbData: SIZE_T, - ), ->; -pub type PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE = ::std::option::Option< - unsafe extern "C" fn(pState: PVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T), ->; #[repr(C)] +#[repr(align(8))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_BLOCKCIPHER { - pub expandKeyFunc: PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY, - pub encryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT, - pub decryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT, - pub ecbEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB, - pub ecbDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB, - pub cbcEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub cbcDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub cbcMacFunc: PSYMCRYPT_BLOCKCIPHER_MAC_MODE, - pub ctrMsb64Func: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub gcmEncryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE, - pub gcmDecryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE, - pub blockSize: SIZE_T, - pub expandedKeySize: SIZE_T, + pub _bindgen_opaque_blob: [u64; 13usize], } #[test] fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(), 104usize, @@ -2817,84 +801,14 @@ fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { 8usize, "Alignment of _SYMCRYPT_BLOCKCIPHER" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize" - ); } #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { - pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, - pub macAlg: PCSYMCRYPT_MAC, + pub _bindgen_opaque_blob: [u128; 35usize], } #[test] fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), 560usize, @@ -2905,16 +819,6 @@ fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg" - ); } impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { fn default() -> Self { @@ -2930,16 +834,11 @@ pub type PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *mut _SYMCRYPT_TLSPRF1_2_EXPANDED_KE pub type PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *const SYMCRYPT_TLSPRF1_2_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_HKDF_EXPANDED_KEY { - pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, - pub macAlg: PCSYMCRYPT_MAC, + pub _bindgen_opaque_blob: [u128; 35usize], } #[test] fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), 560usize, @@ -2950,16 +849,6 @@ fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg" - ); } impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { fn default() -> Self { diff --git a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs index 177ec187..7e384d7a 100644 --- a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs @@ -48,7 +48,6 @@ pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS: _SYMCRYPT_ pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_MONTGOMERY: _SYMCRYPT_ECURVE_TYPE = 3; pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_int; pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE; -pub type UINT8 = ::std::os::raw::c_uchar; pub type BYTE = ::std::os::raw::c_uchar; pub type UINT32 = ::std::os::raw::c_uint; pub type UINT64 = ::std::os::raw::c_ulonglong; @@ -62,319 +61,216 @@ pub type PCUINT64 = *const UINT64; pub type PVOID = *mut ::std::os::raw::c_void; pub type PCVOID = *const ::std::os::raw::c_void; pub type BOOLEAN = BYTE; -pub type __m128i = [::std::os::raw::c_longlong; 2usize]; pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER; pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD2_CHAINING_STATE { - pub C: [BYTE; 16usize], - pub X: [BYTE; 48usize], +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_MD5_STATE { + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" - ); +fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" + ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD5_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" + "Alignment of _SYMCRYPT_MD5_STATE" ); } -impl Default for _SYMCRYPT_MD2_CHAINING_STATE { - 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 SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE; +pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; +pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; +pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD2_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 16usize], - pub chain: SYMCRYPT_MD2_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA1_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD2_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA1_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_SHA1_STATE" ); +} +pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE; +pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE; +pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA256_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD2_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA256_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD2_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MD2_STATE::chain" + "Alignment of _SYMCRYPT_SHA256_STATE" ); } -impl Default for _SYMCRYPT_MD2_STATE { - 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 SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; +pub type SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE; +pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; +pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD4_CHAINING_STATE { - pub H: [UINT32; 4usize], +pub struct _SYMCRYPT_SHA512_STATE { + pub _bindgen_opaque_blob: [u128; 14usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD4_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA512_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_SHA512_STATE" ); } -pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; +pub type SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE; +pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE; +pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD4_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_MD4_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA384_STATE { + pub _bindgen_opaque_blob: [u128; 14usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD4_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_SHA384_STATE" ); +} +pub type SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE; +pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; +pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_256_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD4_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_256_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD4_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD4_STATE::chain" + "Alignment of _SYMCRYPT_SHA3_256_STATE" ); } -impl Default for _SYMCRYPT_MD4_STATE { - 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 SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; +pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; +pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; +pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD5_STATE { - pub _bindgen_opaque_blob: [u128; 7usize], +pub struct _SYMCRYPT_SHA3_384_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { +fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD5_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD5_STATE" + "Alignment of _SYMCRYPT_SHA3_384_STATE" ); } -pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; -pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; -pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; +pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; +pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; +pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA1_CHAINING_STATE { - pub H: [UINT32; 5usize], +pub struct _SYMCRYPT_SHA3_512_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA1_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_512_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), 16usize, - "Alignment of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_SHA3_512_STATE" ); } -pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE; +pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; +pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; +pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; #[repr(C)] -#[repr(align(16))] #[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA1_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA1_CHAINING_STATE, +pub struct _SYMCRYPT_OID { + pub cbOID: UINT32, + pub pbOID: PCBYTE, } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_OID() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_OID>(), 16usize, - "Alignment of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer" + "Size of _SYMCRYPT_OID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_OID>(), 8usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH" + "Alignment of _SYMCRYPT_OID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::buffer" + unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_OID::cbOID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::chain" + unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_OID::pbOID" ); } -impl Default for _SYMCRYPT_SHA1_STATE { +impl Default for _SYMCRYPT_OID { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -383,2017 +279,374 @@ impl Default for _SYMCRYPT_SHA1_STATE { } } } -pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE; -pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE; -pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA256_CHAINING_STATE { - pub H: [UINT32; 8usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H" - ); +pub type SYMCRYPT_OID = _SYMCRYPT_OID; +pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA256_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::chain" - ); +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -impl Default for _SYMCRYPT_SHA256_STATE { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE; -pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; -pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA224_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::chain" - ); +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -impl Default for _SYMCRYPT_SHA224_STATE { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; +#[link(name = "symcrypt", kind = "dylib")] +extern "C" { + pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; +} +pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; +pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; +pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; +pub type PSYMCRYPT_HASH_APPEND_FUNC = + ::std::option::Option; +pub type PSYMCRYPT_HASH_RESULT_FUNC = + ::std::option::Option; +pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option< + unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T), +>; +pub type PSYMCRYPT_HASH_STATE_COPY_FUNC = + ::std::option::Option; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_CHAINING_STATE { - pub H: [UINT64; 8usize], +pub struct _SYMCRYPT_HASH { + pub initFunc: PSYMCRYPT_HASH_INIT_FUNC, + pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC, + pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC, + pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC, + pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC, + pub stateSize: UINT32, + pub resultSize: UINT32, + pub inputBlockSize: UINT32, + pub chainOffset: UINT32, + pub chainSize: UINT32, } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_HASH() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_HASH>(), 64usize, - "Size of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H" - ); -} -pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_STATE" + "Size of _SYMCRYPT_HASH" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HASH>(), 16usize, - "Alignment of _SYMCRYPT_SHA512_STATE" + "Alignment of _SYMCRYPT_HASH" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer" + "Offset of field: _SYMCRYPT_HASH::initFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, 8usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::magic" + "Offset of field: _SYMCRYPT_HASH::appendFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, 16usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL" + "Offset of field: _SYMCRYPT_HASH::resultFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, 24usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH" + "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, 32usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_STATE { - 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 SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE; -pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE; -pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA384_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL" + "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH" + unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, + 40usize, + "Offset of field: _SYMCRYPT_HASH::stateSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::buffer" + unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, + 44usize, + "Offset of field: _SYMCRYPT_HASH::resultSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::chain" + unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_HASH::inputBlockSize" ); -} -impl Default for _SYMCRYPT_SHA384_STATE { - 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 SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE; -pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; -pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_224_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_224_STATE" + unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, + 52usize, + "Offset of field: _SYMCRYPT_HASH::chainOffset" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_224_STATE { - 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 SYMCRYPT_SHA512_224_STATE = _SYMCRYPT_SHA512_224_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_256_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_256_STATE { - 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 SYMCRYPT_SHA512_256_STATE = _SYMCRYPT_SHA512_256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KECCAK_STATE { - pub state: [UINT64; 25usize], - pub inputBlockSize: UINT32, - pub stateIndex: UINT32, - pub paddingValue: UINT8, - pub squeezeMode: BOOLEAN, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), - 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" - ); -} -pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_224_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_256_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; -pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; -pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_384_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; -pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; -pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_512_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; -pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; -pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_OID { - pub cbOID: UINT32, - pub pbOID: PCBYTE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} -impl Default for _SYMCRYPT_OID { - 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 SYMCRYPT_OID = _SYMCRYPT_OID; -pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; -} -#[link(name = "symcrypt", kind = "dylib")] -extern "C" { - pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; -} -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_HASH_STATE { - pub md2State: SYMCRYPT_MD2_STATE, - pub md4State: SYMCRYPT_MD4_STATE, - pub md5State: SYMCRYPT_MD5_STATE, - pub sha1State: SYMCRYPT_SHA1_STATE, - pub sha224State: SYMCRYPT_SHA224_STATE, - pub sha256State: SYMCRYPT_SHA256_STATE, - pub sha384State: SYMCRYPT_SHA384_STATE, - pub sha512State: SYMCRYPT_SHA512_STATE, - pub sha512_224State: SYMCRYPT_SHA512_224_STATE, - pub sha512_256State: SYMCRYPT_SHA512_256_STATE, - pub sha3_224State: SYMCRYPT_SHA3_224_STATE, - pub sha3_256State: SYMCRYPT_SHA3_256_STATE, - pub sha3_384State: SYMCRYPT_SHA3_384_STATE, - pub sha3_512State: SYMCRYPT_SHA3_512_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), - 240usize, - "Size of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md2State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md4State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md5State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" - ); -} -impl Default for _SYMCRYPT_HASH_STATE { - 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 SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE; -pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; -pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; -pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; -pub type PSYMCRYPT_HASH_APPEND_FUNC = - ::std::option::Option; -pub type PSYMCRYPT_HASH_RESULT_FUNC = - ::std::option::Option; -pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option< - unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T), ->; -pub type PSYMCRYPT_HASH_STATE_COPY_FUNC = - ::std::option::Option; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HASH { - pub initFunc: PSYMCRYPT_HASH_INIT_FUNC, - pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC, - pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC, - pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC, - pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC, - pub stateSize: UINT32, - pub resultSize: UINT32, - pub inputBlockSize: UINT32, - pub chainOffset: UINT32, - pub chainSize: UINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH>(), - 64usize, - "Size of _SYMCRYPT_HASH" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH>(), - 16usize, - "Alignment of _SYMCRYPT_HASH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_HASH::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HASH::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_HASH::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_HASH::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_HASH::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_HASH::chainOffset" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_HASH::chainSize" - ); -} -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { - pub _bindgen_opaque_blob: [u128; 3usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 48usize, - "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); -} -pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_MD5_STATE { - pub hash: SYMCRYPT_MD5_STATE, - pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 128usize, - "Size of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 112usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_MD5_STATE { - 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 SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE; -pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE; -pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA1_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA1_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA1_STATE { - pub hash: SYMCRYPT_SHA1_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA1_STATE { - 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 SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE; -pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE; -pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA256_STATE { - pub hash: SYMCRYPT_SHA256_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA256_STATE { - 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 SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; -pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; -pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_STATE { - pub hash: SYMCRYPT_SHA384_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA384_STATE { - 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 SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; -pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; -pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_STATE { - pub hash: SYMCRYPT_SHA512_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA512_STATE { - 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 SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; -pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; -pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { - pub pHash: PCSYMCRYPT_HASH, - pub __bindgen_padding_0: u64, - pub innerState: SYMCRYPT_HASH_STATE, - pub outerState: SYMCRYPT_HASH_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 256usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } + unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, + 56usize, + "Offset of field: _SYMCRYPT_HASH::chainSize" + ); } -pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 3usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), + 48usize, + "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_MD5_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), + 128usize, + "Size of _SYMCRYPT_HMAC_MD5_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_MD5_STATE" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE; +pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE; +pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 5usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA1_STATE { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA1_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE; +pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE; +pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_AES_EXPANDED_KEY { - pub RoundKey: [[[BYTE; 4usize]; 4usize]; 29usize], - pub lastEncRoundKey: *mut [[BYTE; 4usize]; 4usize], - pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize], - pub magic: SIZE_T, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 5usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 496usize, - "Size of _SYMCRYPT_AES_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize }, - 464usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize }, - 472usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 480usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic" + "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_AES_EXPANDED_KEY { - 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 SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; -pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; -pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY { - pub aesKey: SYMCRYPT_AES_EXPANDED_KEY, - pub K1: [BYTE; 16usize], - pub K2: [BYTE; 16usize], - pub magic: SIZE_T, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA256_STATE { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA256_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), 16usize, - "Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize }, - 512usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 528usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic" + "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" ); } -impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { - 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 SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; +pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; +pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MAC_EXPANDED_KEY { - pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, - pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, - pub sha224Key: SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, - pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, - pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, - pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub sha512_224Key: SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, - pub sha512_256Key: SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, - pub sha3_224Key: SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, - pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, - pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, - pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, - pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY, - pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, - pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_MAC_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" + "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" ); +} +pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA384_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" ); +} +pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; +pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; +pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 9usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" ); +} +pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA512_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" ); +} +pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; +pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; +pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_AES_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 31usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" + ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + 496usize, + "Size of _SYMCRYPT_AES_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" + ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { - 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 SYMCRYPT_MAC_EXPANDED_KEY = _SYMCRYPT_MAC_EXPANDED_KEY; +pub type SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; +pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; +pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, >; @@ -2489,144 +742,11 @@ pub type SYMCRYPT_MAC = _SYMCRYPT_MAC; pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { - pub aes: SYMCRYPT_AES_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 496usize, - "Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes" - ); -} -impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { - 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 SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS = _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_GF128_ELEMENT { - pub ull: [UINT64; 2usize], - pub m128i: __m128i, - pub ul: [UINT32; 4usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Size of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Alignment of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ull" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).m128i) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::m128i" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ul" - ); -} -impl Default for _SYMCRYPT_GF128_ELEMENT { - 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 SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_GHASH_EXPANDED_KEY { - pub table: [SYMCRYPT_GF128_ELEMENT; 128usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 2048usize, - "Size of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table" - ); -} -impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { - 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 SYMCRYPT_GHASH_EXPANDED_KEY = _SYMCRYPT_GHASH_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_GCM_EXPANDED_KEY { - pub ghashKey: SYMCRYPT_GHASH_EXPANDED_KEY, - pub pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, - pub __bindgen_padding_0: u64, - pub blockcipherKey: SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS, - pub cbKey: SIZE_T, - pub abKey: [BYTE; 32usize], - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 163usize], } #[test] fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), 2608usize, @@ -2637,36 +757,6 @@ fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_GCM_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize }, - 2048usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize }, - 2064usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize }, - 2560usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize }, - 2568usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 2600usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic" - ); } impl Default for _SYMCRYPT_GCM_EXPANDED_KEY { fn default() -> Self { @@ -2682,22 +772,12 @@ pub type PSYMCRYPT_GCM_EXPANDED_KEY = *mut _SYMCRYPT_GCM_EXPANDED_KEY; pub type PCSYMCRYPT_GCM_EXPANDED_KEY = *const SYMCRYPT_GCM_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_GCM_STATE { - pub pKey: PCSYMCRYPT_GCM_EXPANDED_KEY, - pub cbData: UINT64, - pub cbAuthData: UINT64, - pub bytesInMacBlock: SIZE_T, - pub ghashState: SYMCRYPT_GF128_ELEMENT, - pub counterBlock: [BYTE; 16usize], - pub macBlock: [BYTE; 16usize], - pub keystreamBlock: [BYTE; 16usize], - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(), 112usize, @@ -2708,114 +788,18 @@ fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { 16usize, "Alignment of _SYMCRYPT_GCM_STATE" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_GCM_STATE::ghashState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_GCM_STATE::counterBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_GCM_STATE::macBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_GCM_STATE::magic" - ); -} -impl Default for _SYMCRYPT_GCM_STATE { - 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 SYMCRYPT_GCM_STATE = _SYMCRYPT_GCM_STATE; pub type PSYMCRYPT_GCM_STATE = *mut _SYMCRYPT_GCM_STATE; pub type PCSYMCRYPT_GCM_STATE = *const SYMCRYPT_GCM_STATE; -pub type PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT = - ::std::option::Option; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PCVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T), ->; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE = ::std::option::Option< - unsafe extern "C" fn( - pExpandedKey: PCVOID, - pbChainingValue: PBYTE, - pbSrc: PCBYTE, - pbDst: PBYTE, - cbData: SIZE_T, - ), ->; -pub type PSYMCRYPT_BLOCKCIPHER_MAC_MODE = ::std::option::Option< - unsafe extern "C" fn( - pExpandedKey: PCVOID, - pbChainingValue: PBYTE, - pbSrc: PCBYTE, - cbData: SIZE_T, - ), ->; -pub type PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE = ::std::option::Option< - unsafe extern "C" fn(pState: PVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T), ->; #[repr(C)] +#[repr(align(8))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_BLOCKCIPHER { - pub expandKeyFunc: PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY, - pub encryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT, - pub decryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT, - pub ecbEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB, - pub ecbDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB, - pub cbcEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub cbcDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub cbcMacFunc: PSYMCRYPT_BLOCKCIPHER_MAC_MODE, - pub ctrMsb64Func: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub gcmEncryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE, - pub gcmDecryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE, - pub blockSize: SIZE_T, - pub expandedKeySize: SIZE_T, + pub _bindgen_opaque_blob: [u64; 13usize], } #[test] fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(), 104usize, @@ -2826,84 +810,14 @@ fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { 8usize, "Alignment of _SYMCRYPT_BLOCKCIPHER" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize" - ); } #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { - pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, - pub macAlg: PCSYMCRYPT_MAC, + pub _bindgen_opaque_blob: [u128; 35usize], } #[test] fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), 560usize, @@ -2914,16 +828,6 @@ fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg" - ); } impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { fn default() -> Self { @@ -2939,16 +843,11 @@ pub type PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *mut _SYMCRYPT_TLSPRF1_2_EXPANDED_KE pub type PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *const SYMCRYPT_TLSPRF1_2_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_HKDF_EXPANDED_KEY { - pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, - pub macAlg: PCSYMCRYPT_MAC, + pub _bindgen_opaque_blob: [u128; 35usize], } #[test] fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), 560usize, @@ -2959,16 +858,6 @@ fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg" - ); } impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { fn default() -> Self { diff --git a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs index 0207efe5..b8104230 100644 --- a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs @@ -50,7 +50,6 @@ pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_uint; pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE; pub type BYTE = u8; pub type SIZE_T = usize; -pub type UINT8 = u8; pub type UINT32 = u32; pub type UINT64 = u64; pub type PUINT64 = *mut u64; @@ -61,319 +60,216 @@ pub type PCUINT64 = *const UINT64; pub type PVOID = *mut ::std::os::raw::c_void; pub type PCVOID = *const ::std::os::raw::c_void; pub type BOOLEAN = BYTE; -pub type __m128i = [::std::os::raw::c_longlong; 2usize]; pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER; pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD2_CHAINING_STATE { - pub C: [BYTE; 16usize], - pub X: [BYTE; 48usize], +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_MD5_STATE { + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" - ); +fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" + ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), + 112usize, + "Size of _SYMCRYPT_MD5_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" + "Alignment of _SYMCRYPT_MD5_STATE" ); } -impl Default for _SYMCRYPT_MD2_CHAINING_STATE { - 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 SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE; +pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; +pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; +pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD2_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 16usize], - pub chain: SYMCRYPT_MD2_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA1_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD2_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA1_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_SHA1_STATE" ); +} +pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE; +pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE; +pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA256_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD2_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), + 128usize, + "Size of _SYMCRYPT_SHA256_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD2_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MD2_STATE::chain" + "Alignment of _SYMCRYPT_SHA256_STATE" ); } -impl Default for _SYMCRYPT_MD2_STATE { - 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 SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; +pub type SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE; +pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; +pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD4_CHAINING_STATE { - pub H: [UINT32; 4usize], +pub struct _SYMCRYPT_SHA512_STATE { + pub _bindgen_opaque_blob: [u128; 14usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD4_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA512_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_SHA512_STATE" ); } -pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; +pub type SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE; +pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE; +pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MD4_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_MD4_CHAINING_STATE, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA384_STATE { + pub _bindgen_opaque_blob: [u128; 14usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD4_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), + 224usize, + "Size of _SYMCRYPT_SHA384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" + "Alignment of _SYMCRYPT_SHA384_STATE" ); +} +pub type SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE; +pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; +pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_SHA3_256_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD4_STATE::magic" + ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_256_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), 16usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD4_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD4_STATE::chain" + "Alignment of _SYMCRYPT_SHA3_256_STATE" ); } -impl Default for _SYMCRYPT_MD4_STATE { - 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 SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; +pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; +pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; +pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MD5_STATE { - pub _bindgen_opaque_blob: [u128; 7usize], +pub struct _SYMCRYPT_SHA3_384_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { +fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD5_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_384_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), 16usize, - "Alignment of _SYMCRYPT_MD5_STATE" + "Alignment of _SYMCRYPT_SHA3_384_STATE" ); } -pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE; -pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE; -pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; +pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; +pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; +pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA1_CHAINING_STATE { - pub H: [UINT32; 5usize], +pub struct _SYMCRYPT_SHA3_512_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA1_CHAINING_STATE" + ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), + 240usize, + "Size of _SYMCRYPT_SHA3_512_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), 16usize, - "Alignment of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H" + "Alignment of _SYMCRYPT_SHA3_512_STATE" ); } -pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE; +pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; +pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; +pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; #[repr(C)] -#[repr(align(16))] #[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA1_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA1_CHAINING_STATE, +pub struct _SYMCRYPT_OID { + pub cbOID: UINT32, + pub pbOID: PCBYTE, } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_OID() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_OID>(), 16usize, - "Alignment of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer" + "Size of _SYMCRYPT_OID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_OID>(), 8usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH" + "Alignment of _SYMCRYPT_OID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::buffer" + unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, + 0usize, + "Offset of field: _SYMCRYPT_OID::cbOID" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::chain" + unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, + 8usize, + "Offset of field: _SYMCRYPT_OID::pbOID" ); } -impl Default for _SYMCRYPT_SHA1_STATE { +impl Default for _SYMCRYPT_OID { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -382,2009 +278,366 @@ impl Default for _SYMCRYPT_SHA1_STATE { } } } -pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE; -pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE; -pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA256_CHAINING_STATE { - pub H: [UINT32; 8usize], +pub type SYMCRYPT_OID = _SYMCRYPT_OID; +pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +extern "C" { + pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H" - ); +extern "C" { + pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA256_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +extern "C" { + pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::chain" - ); +extern "C" { + pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -impl Default for _SYMCRYPT_SHA256_STATE { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } +extern "C" { + pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE; -pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE; -pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA224_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 64usize], - pub chain: SYMCRYPT_SHA256_CHAINING_STATE, +extern "C" { + pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::chain" - ); +extern "C" { + pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -impl Default for _SYMCRYPT_SHA224_STATE { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } +extern "C" { + pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } -pub type SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; +pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; +pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; +pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; +pub type PSYMCRYPT_HASH_APPEND_FUNC = + ::std::option::Option; +pub type PSYMCRYPT_HASH_RESULT_FUNC = + ::std::option::Option; +pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option< + unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T), +>; +pub type PSYMCRYPT_HASH_STATE_COPY_FUNC = + ::std::option::Option; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_CHAINING_STATE { - pub H: [UINT64; 8usize], +pub struct _SYMCRYPT_HASH { + pub initFunc: PSYMCRYPT_HASH_INIT_FUNC, + pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC, + pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC, + pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC, + pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC, + pub stateSize: UINT32, + pub resultSize: UINT32, + pub inputBlockSize: UINT32, + pub chainOffset: UINT32, + pub chainSize: UINT32, } #[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_HASH() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), + ::std::mem::size_of::<_SYMCRYPT_HASH>(), 64usize, - "Size of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H" - ); -} -pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_STATE { - 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 SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE; -pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE; -pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA384_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA384_STATE" + "Size of _SYMCRYPT_HASH" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), + ::std::mem::align_of::<_SYMCRYPT_HASH>(), 16usize, - "Alignment of _SYMCRYPT_SHA384_STATE" + "Alignment of _SYMCRYPT_HASH" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer" + "Offset of field: _SYMCRYPT_HASH::initFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, 8usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::magic" + "Offset of field: _SYMCRYPT_HASH::appendFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, 16usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL" + "Offset of field: _SYMCRYPT_HASH::resultFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, 24usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH" + "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, 32usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::chain" + "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" ); -} -impl Default for _SYMCRYPT_SHA384_STATE { - 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 SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE; -pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE; -pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_224_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_224_STATE" + unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, + 40usize, + "Offset of field: _SYMCRYPT_HASH::stateSize" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_224_STATE" + unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, + 44usize, + "Offset of field: _SYMCRYPT_HASH::resultSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" + unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, + 48usize, + "Offset of field: _SYMCRYPT_HASH::inputBlockSize" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" + unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, + 52usize, + "Offset of field: _SYMCRYPT_HASH::chainOffset" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_224_STATE { - 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 SYMCRYPT_SHA512_224_STATE = _SYMCRYPT_SHA512_224_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_SHA512_256_STATE { - pub bytesInBuffer: UINT32, - pub magic: SIZE_T, - pub dataLengthL: UINT64, - pub dataLengthH: UINT64, - pub buffer: [BYTE; 128usize], - pub chain: SYMCRYPT_SHA512_CHAINING_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" - ); -} -impl Default for _SYMCRYPT_SHA512_256_STATE { - 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 SYMCRYPT_SHA512_256_STATE = _SYMCRYPT_SHA512_256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KECCAK_STATE { - pub state: [UINT64; 25usize], - pub inputBlockSize: UINT32, - pub stateIndex: UINT32, - pub paddingValue: UINT8, - pub squeezeMode: BOOLEAN, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), - 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" - ); -} -pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_224_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_256_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; -pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; -pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_384_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; -pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; -pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_SHA3_512_STATE { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" - ); -} -pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; -pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; -pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { - pub ks: SYMCRYPT_KECCAK_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_OID { - pub cbOID: UINT32, - pub pbOID: PCBYTE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} -impl Default for _SYMCRYPT_OID { - 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 SYMCRYPT_OID = _SYMCRYPT_OID; -pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -extern "C" { - pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; -} -extern "C" { - pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; -} -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_HASH_STATE { - pub md2State: SYMCRYPT_MD2_STATE, - pub md4State: SYMCRYPT_MD4_STATE, - pub md5State: SYMCRYPT_MD5_STATE, - pub sha1State: SYMCRYPT_SHA1_STATE, - pub sha224State: SYMCRYPT_SHA224_STATE, - pub sha256State: SYMCRYPT_SHA256_STATE, - pub sha384State: SYMCRYPT_SHA384_STATE, - pub sha512State: SYMCRYPT_SHA512_STATE, - pub sha512_224State: SYMCRYPT_SHA512_224_STATE, - pub sha512_256State: SYMCRYPT_SHA512_256_STATE, - pub sha3_224State: SYMCRYPT_SHA3_224_STATE, - pub sha3_256State: SYMCRYPT_SHA3_256_STATE, - pub sha3_384State: SYMCRYPT_SHA3_384_STATE, - pub sha3_512State: SYMCRYPT_SHA3_512_STATE, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), - 240usize, - "Size of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md2State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md4State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md5State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" - ); -} -impl Default for _SYMCRYPT_HASH_STATE { - 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 SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE; -pub type SYMCRYPT_HASH = _SYMCRYPT_HASH; -pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH; -pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option; -pub type PSYMCRYPT_HASH_APPEND_FUNC = - ::std::option::Option; -pub type PSYMCRYPT_HASH_RESULT_FUNC = - ::std::option::Option; -pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option< - unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T), ->; -pub type PSYMCRYPT_HASH_STATE_COPY_FUNC = - ::std::option::Option; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HASH { - pub initFunc: PSYMCRYPT_HASH_INIT_FUNC, - pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC, - pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC, - pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC, - pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC, - pub stateSize: UINT32, - pub resultSize: UINT32, - pub inputBlockSize: UINT32, - pub chainOffset: UINT32, - pub chainSize: UINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH>(), - 64usize, - "Size of _SYMCRYPT_HASH" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH>(), - 16usize, - "Alignment of _SYMCRYPT_HASH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_HASH::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HASH::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_HASH::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_HASH::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_HASH::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_HASH::chainOffset" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_HASH::chainSize" - ); -} -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { - pub _bindgen_opaque_blob: [u128; 3usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 48usize, - "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); -} -pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_MD5_STATE { - pub hash: SYMCRYPT_MD5_STATE, - pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 128usize, - "Size of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 112usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_MD5_STATE { - 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 SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE; -pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE; -pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA1_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA1_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA1_STATE { - pub hash: SYMCRYPT_SHA1_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA1_STATE { - 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 SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE; -pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE; -pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA256_STATE { - pub hash: SYMCRYPT_SHA256_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA256_STATE { - 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 SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; -pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; -pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA384_STATE { - pub hash: SYMCRYPT_SHA384_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA384_STATE { - 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 SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; -pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; -pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_STATE { - pub hash: SYMCRYPT_SHA512_STATE, - pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_SHA512_STATE { - 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 SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; -pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; -pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { - pub innerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" - ); -} -pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { - pub pHash: PCSYMCRYPT_HASH, - pub __bindgen_padding_0: u64, - pub innerState: SYMCRYPT_HASH_STATE, - pub outerState: SYMCRYPT_HASH_STATE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 256usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" - ); -} -impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } + unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, + 56usize, + "Offset of field: _SYMCRYPT_HASH::chainSize" + ); } -pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 3usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), + 48usize, + "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_MD5_STATE { + pub _bindgen_opaque_blob: [u128; 8usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), + 128usize, + "Size of _SYMCRYPT_HMAC_MD5_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_MD5_STATE" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE; +pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE; +pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 5usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { - pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA1_STATE { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA1_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" + "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" ); } -impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { - 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 SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE; +pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE; +pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_AES_EXPANDED_KEY { - pub RoundKey: [[[BYTE; 4usize]; 4usize]; 29usize], - pub lastEncRoundKey: *mut [[BYTE; 4usize]; 4usize], - pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize], - pub magic: SIZE_T, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 5usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 496usize, - "Size of _SYMCRYPT_AES_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), + 80usize, + "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize }, - 464usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize }, - 472usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 480usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic" + "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_AES_EXPANDED_KEY { - 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 SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; -pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; -pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY { - pub aesKey: SYMCRYPT_AES_EXPANDED_KEY, - pub K1: [BYTE; 16usize], - pub K2: [BYTE; 16usize], - pub magic: SIZE_T, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA256_STATE { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA256_STATE" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), 16usize, - "Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize }, - 512usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 528usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic" + "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" ); } -impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { - 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 SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; +pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE; +pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE; +pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MAC_EXPANDED_KEY { - pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, - pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, - pub sha224Key: SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, - pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, - pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, - pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, - pub sha512_224Key: SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, - pub sha512_256Key: SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, - pub sha3_224Key: SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, - pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, - pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, - pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, - pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY, - pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, - pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 9usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_MAC_EXPANDED_KEY" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), 16usize, - "Alignment of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" + "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" ); +} +pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA384_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA384_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" ); +} +pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE; +pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE; +pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 9usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 144usize, + "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" ); +} +pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_HMAC_SHA512_STATE { + pub _bindgen_opaque_blob: [u128; 15usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" + ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 240usize, + "Size of _SYMCRYPT_HMAC_SHA512_STATE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" + ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), + 16usize, + "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" ); +} +pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE; +pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE; +pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SYMCRYPT_AES_EXPANDED_KEY { + pub _bindgen_opaque_blob: [u128; 31usize], +} +#[test] +fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" + ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + 496usize, + "Size of _SYMCRYPT_AES_EXPANDED_KEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" + ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), + 16usize, + "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" ); } -impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { - 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 SYMCRYPT_MAC_EXPANDED_KEY = _SYMCRYPT_MAC_EXPANDED_KEY; +pub type SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; +pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; +pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, >; @@ -2480,144 +733,11 @@ pub type SYMCRYPT_MAC = _SYMCRYPT_MAC; pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { - pub aes: SYMCRYPT_AES_EXPANDED_KEY, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 496usize, - "Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes" - ); -} -impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { - 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 SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS = _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_GF128_ELEMENT { - pub ull: [UINT64; 2usize], - pub m128i: __m128i, - pub ul: [UINT32; 4usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Size of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Alignment of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ull" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).m128i) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::m128i" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ul" - ); -} -impl Default for _SYMCRYPT_GF128_ELEMENT { - 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 SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_GHASH_EXPANDED_KEY { - pub table: [SYMCRYPT_GF128_ELEMENT; 128usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 2048usize, - "Size of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table" - ); -} -impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { - 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 SYMCRYPT_GHASH_EXPANDED_KEY = _SYMCRYPT_GHASH_EXPANDED_KEY; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_GCM_EXPANDED_KEY { - pub ghashKey: SYMCRYPT_GHASH_EXPANDED_KEY, - pub pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, - pub __bindgen_padding_0: u64, - pub blockcipherKey: SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS, - pub cbKey: SIZE_T, - pub abKey: [BYTE; 32usize], - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 163usize], } #[test] fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), 2608usize, @@ -2628,36 +748,6 @@ fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_GCM_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize }, - 2048usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize }, - 2064usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize }, - 2560usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize }, - 2568usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 2600usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic" - ); } impl Default for _SYMCRYPT_GCM_EXPANDED_KEY { fn default() -> Self { @@ -2673,22 +763,12 @@ pub type PSYMCRYPT_GCM_EXPANDED_KEY = *mut _SYMCRYPT_GCM_EXPANDED_KEY; pub type PCSYMCRYPT_GCM_EXPANDED_KEY = *const SYMCRYPT_GCM_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_GCM_STATE { - pub pKey: PCSYMCRYPT_GCM_EXPANDED_KEY, - pub cbData: UINT64, - pub cbAuthData: UINT64, - pub bytesInMacBlock: SIZE_T, - pub ghashState: SYMCRYPT_GF128_ELEMENT, - pub counterBlock: [BYTE; 16usize], - pub macBlock: [BYTE; 16usize], - pub keystreamBlock: [BYTE; 16usize], - pub magic: SIZE_T, + pub _bindgen_opaque_blob: [u128; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(), 112usize, @@ -2699,114 +779,18 @@ fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { 16usize, "Alignment of _SYMCRYPT_GCM_STATE" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_GCM_STATE::ghashState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_GCM_STATE::counterBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_GCM_STATE::macBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_GCM_STATE::magic" - ); -} -impl Default for _SYMCRYPT_GCM_STATE { - 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 SYMCRYPT_GCM_STATE = _SYMCRYPT_GCM_STATE; pub type PSYMCRYPT_GCM_STATE = *mut _SYMCRYPT_GCM_STATE; pub type PCSYMCRYPT_GCM_STATE = *const SYMCRYPT_GCM_STATE; -pub type PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT = - ::std::option::Option; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PCVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T), ->; -pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE = ::std::option::Option< - unsafe extern "C" fn( - pExpandedKey: PCVOID, - pbChainingValue: PBYTE, - pbSrc: PCBYTE, - pbDst: PBYTE, - cbData: SIZE_T, - ), ->; -pub type PSYMCRYPT_BLOCKCIPHER_MAC_MODE = ::std::option::Option< - unsafe extern "C" fn( - pExpandedKey: PCVOID, - pbChainingValue: PBYTE, - pbSrc: PCBYTE, - cbData: SIZE_T, - ), ->; -pub type PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE = ::std::option::Option< - unsafe extern "C" fn(pState: PVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T), ->; #[repr(C)] +#[repr(align(8))] #[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_BLOCKCIPHER { - pub expandKeyFunc: PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY, - pub encryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT, - pub decryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT, - pub ecbEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB, - pub ecbDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB, - pub cbcEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub cbcDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub cbcMacFunc: PSYMCRYPT_BLOCKCIPHER_MAC_MODE, - pub ctrMsb64Func: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE, - pub gcmEncryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE, - pub gcmDecryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE, - pub blockSize: SIZE_T, - pub expandedKeySize: SIZE_T, + pub _bindgen_opaque_blob: [u64; 13usize], } #[test] fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(), 104usize, @@ -2817,84 +801,14 @@ fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { 8usize, "Alignment of _SYMCRYPT_BLOCKCIPHER" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize" - ); } #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { - pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, - pub macAlg: PCSYMCRYPT_MAC, + pub _bindgen_opaque_blob: [u128; 35usize], } #[test] fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), 560usize, @@ -2905,16 +819,6 @@ fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg" - ); } impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { fn default() -> Self { @@ -2930,16 +834,11 @@ pub type PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *mut _SYMCRYPT_TLSPRF1_2_EXPANDED_KE pub type PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *const SYMCRYPT_TLSPRF1_2_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] -#[derive(Copy, Clone)] pub struct _SYMCRYPT_HKDF_EXPANDED_KEY { - pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, - pub macAlg: PCSYMCRYPT_MAC, + pub _bindgen_opaque_blob: [u128; 35usize], } #[test] fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), 560usize, @@ -2950,16 +849,6 @@ fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { 16usize, "Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg" - ); } impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { fn default() -> Self { From 21583abdeaa6967ce08cd513ed4ffc83907f4af6 Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 11:03:31 +0100 Subject: [PATCH 07/11] more opaque types --- symcrypt-bindgen/src/main.rs | 9 +- .../src/bindings/aarch64_pc_windows_msvc.rs | 1146 ++-------------- .../src/bindings/aarch64_unknown_linux_gnu.rs | 1147 ++--------------- .../src/bindings/x86_64_pc_windows_msvc.rs | 1146 ++-------------- .../src/bindings/x86_64_unknown_linux_gnu.rs | 1147 ++--------------- 5 files changed, 374 insertions(+), 4221 deletions(-) diff --git a/symcrypt-bindgen/src/main.rs b/symcrypt-bindgen/src/main.rs index 6a922b3c..82770337 100644 --- a/symcrypt-bindgen/src/main.rs +++ b/symcrypt-bindgen/src/main.rs @@ -113,7 +113,14 @@ fn main() { builder = builder .opaque_type(format!("_SYMCRYPT_.*_STATE")) .opaque_type(format!("_SYMCRYPT_.*_EXPANDED_KEY")) - .opaque_type("_SYMCRYPT_BLOCKCIPHER"); + .opaque_type("_SYMCRYPT_BLOCKCIPHER") + .opaque_type("_SYMCRYPT_ECURVE") + .opaque_type("_SYMCRYPT_INT") + .opaque_type("_SYMCRYPT_DIVISOR") + .opaque_type("_SYMCRYPT_MODULUS") + .opaque_type("_SYMCRYPT_ECKEY") + .opaque_type("_SYMCRYPT_RSAKEY") + .opaque_type("_SYMCRYPT_MAC"); let bindings = builder .generate_comments(true) diff --git a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs index 7e384d7a..b28c8357 100644 --- a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs @@ -55,7 +55,6 @@ pub type ULONG_PTR = ::std::os::raw::c_ulonglong; pub type SIZE_T = ULONG_PTR; pub type PBYTE = *mut BYTE; pub type PCBYTE = *const BYTE; -pub type PCUINT32 = *const UINT32; pub type PUINT64 = *mut UINT64; pub type PCUINT64 = *const UINT64; pub type PVOID = *mut ::std::os::raw::c_void; @@ -647,32 +646,14 @@ fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { pub type SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; -pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_MAC_INIT = - ::std::option::Option; -pub type PSYMCRYPT_MAC_APPEND = - ::std::option::Option; -pub type PSYMCRYPT_MAC_RESULT = - ::std::option::Option; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[repr(align(8))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_MAC { - pub expandKeyFunc: PSYMCRYPT_MAC_EXPAND_KEY, - pub initFunc: PSYMCRYPT_MAC_INIT, - pub appendFunc: PSYMCRYPT_MAC_APPEND, - pub resultFunc: PSYMCRYPT_MAC_RESULT, - pub expandedKeySize: SIZE_T, - pub stateSize: SIZE_T, - pub resultSize: SIZE_T, - pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, - pub outerChainingStateOffset: UINT32, + pub _bindgen_opaque_blob: [u64; 9usize], } #[test] fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_MAC>(), 72usize, @@ -683,60 +664,6 @@ fn bindgen_test_layout__SYMCRYPT_MAC() { 8usize, "Alignment of _SYMCRYPT_MAC" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} -impl Default for _SYMCRYPT_MAC { - 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 SYMCRYPT_MAC = _SYMCRYPT_MAC; pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; @@ -871,80 +798,27 @@ impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { pub type SYMCRYPT_HKDF_EXPANDED_KEY = _SYMCRYPT_HKDF_EXPANDED_KEY; pub type PSYMCRYPT_HKDF_EXPANDED_KEY = *mut _SYMCRYPT_HKDF_EXPANDED_KEY; pub type PCSYMCRYPT_HKDF_EXPANDED_KEY = *const SYMCRYPT_HKDF_EXPANDED_KEY; -pub type SYMCRYPT_INT = _SYMCRYPT_INT; -pub type PSYMCRYPT_INT = *mut SYMCRYPT_INT; -pub type SYMCRYPT_DIVISOR = _SYMCRYPT_DIVISOR; -pub type SYMCRYPT_MODULUS = _SYMCRYPT_MODULUS; -pub type PSYMCRYPT_MODULUS = *mut SYMCRYPT_MODULUS; -pub type SYMCRYPT_MODELEMENT = _SYMCRYPT_MODELEMENT; -pub type PSYMCRYPT_MODELEMENT = *mut SYMCRYPT_MODELEMENT; pub type SYMCRYPT_ECPOINT = _SYMCRYPT_ECPOINT; pub type PSYMCRYPT_ECPOINT = *mut SYMCRYPT_ECPOINT; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_INT { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub magic: SIZE_T, - pub __bindgen_padding_0: u64, - pub ti: _SYMCRYPT_INT__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_INT__bindgen_ty_1 { - pub fdef: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 { - pub uint32: [UINT32; 1usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32" - ); +pub struct _SYMCRYPT_RSAKEY { + pub _bindgen_opaque_blob: [u8; 192usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_RSAKEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 32usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1" + ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), + 192usize, + "Size of _SYMCRYPT_RSAKEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(), + ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), 32usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef" + "Alignment of _SYMCRYPT_RSAKEY" ); } -impl Default for _SYMCRYPT_INT__bindgen_ty_1 { +impl Default for _SYMCRYPT_RSAKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -953,47 +827,54 @@ impl Default for _SYMCRYPT_INT__bindgen_ty_1 { } } } +pub type SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY; +pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY; +pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { + pub window: UINT32, + pub nPrecompPoints: UINT32, + pub nRecodedDigits: UINT32, + pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], +} #[test] -fn bindgen_test_layout__SYMCRYPT_INT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = + ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT>(), - 64usize, - "Size of _SYMCRYPT_INT" + ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), + 528usize, + "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT>(), - 32usize, - "Alignment of _SYMCRYPT_INT" + ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), + 8usize, + "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_INT::type_" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, 4usize, - "Offset of field: _SYMCRYPT_INT::nDigits" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, 8usize, - "Offset of field: _SYMCRYPT_INT::cbSize" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, 16usize, - "Offset of field: _SYMCRYPT_INT::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_INT::ti" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" ); } -impl Default for _SYMCRYPT_INT { +impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1002,71 +883,39 @@ impl Default for _SYMCRYPT_INT { } } } +pub type SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_DIVISOR { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub nBits: UINT32, - pub magic: SIZE_T, - pub td: _SYMCRYPT_DIVISOR__bindgen_ty_1, - pub Int: SYMCRYPT_INT, +pub struct _SYMCRYPT_ECURVE { + pub _bindgen_opaque_blob: [u8; 672usize], } #[repr(C)] #[derive(Copy, Clone)] -pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 { - pub fdef: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 { - pub W: UINT64, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W" - ); +pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { + pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, } #[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> = +fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1" + ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), + 528usize, + "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), + ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1" + "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef" + "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" ); } -impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { +impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1076,56 +925,19 @@ impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { } } #[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(), - 96usize, - "Size of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(), - 32usize, - "Alignment of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_DIVISOR::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_DIVISOR::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_DIVISOR::nBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_DIVISOR::magic" - ); +fn bindgen_test_layout__SYMCRYPT_ECURVE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_DIVISOR::td" + ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), + 672usize, + "Size of _SYMCRYPT_ECURVE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), 32usize, - "Offset of field: _SYMCRYPT_DIVISOR::Int" + "Alignment of _SYMCRYPT_ECURVE" ); } -impl Default for _SYMCRYPT_DIVISOR { +impl Default for _SYMCRYPT_ECURVE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1134,115 +946,48 @@ impl Default for _SYMCRYPT_DIVISOR { } } } +pub type SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE; +pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE; +pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_MODULUS { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub flags: UINT32, - pub cbModElement: UINT32, - pub inv64: UINT64, - pub magic: SIZE_T, - pub tm: _SYMCRYPT_MODULUS__bindgen_ty_1, - pub __bindgen_padding_0: [u64; 2usize], - pub Divisor: SYMCRYPT_DIVISOR, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MODULUS__bindgen_ty_1 { - pub montgomery: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1, - pub pseudoMersenne: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2, -} -#[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { - pub Rsqr: PCUINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr" - ); -} -impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 { - pub k: UINT32, +pub struct _SYMCRYPT_ECPOINT { + pub normalized: BOOLEAN, + pub pCurve: PCSYMCRYPT_ECURVE, + pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_ECPOINT() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" + ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), + 32usize, + "Size of _SYMCRYPT_ECPOINT" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" + ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), + 32usize, + "Alignment of _SYMCRYPT_ECPOINT" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1" + "Offset of field: _SYMCRYPT_ECPOINT::normalized" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), + unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery" + "Offset of field: _SYMCRYPT_ECPOINT::pCurve" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_ECPOINT::magic" ); } -impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { +impl Default for _SYMCRYPT_ECPOINT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1250,693 +995,14 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { s.assume_init() } } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS>(), - 160usize, - "Size of _SYMCRYPT_MODULUS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS>(), - 32usize, - "Alignment of _SYMCRYPT_MODULUS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_MODULUS::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MODULUS::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_MODULUS::flags" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MODULUS::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MODULUS::inv64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MODULUS::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MODULUS::tm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MODULUS::Divisor" - ); -} -impl Default for _SYMCRYPT_MODULUS { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_MODELEMENT { - pub d: _SYMCRYPT_MODELEMENT__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 { - pub uint32: [UINT32; 1usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32" - ); -} -impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Size of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Alignment of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT::d" - ); -} -impl Default for _SYMCRYPT_MODELEMENT { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_RSAKEY { - pub fAlgorithmInfo: UINT32, - pub cbTotalSize: UINT32, - pub hasPrivateKey: BOOLEAN, - pub nSetBitsOfModulus: UINT32, - pub nBitsOfModulus: UINT32, - pub nDigitsOfModulus: UINT32, - pub nPubExp: UINT32, - pub nPrimes: UINT32, - pub nBitsOfPrimes: [UINT32; 2usize], - pub nDigitsOfPrimes: [UINT32; 2usize], - pub nMaxDigitsOfPrimes: UINT32, - pub au64PubExp: [UINT64; 1usize], - pub pbPrimes: [PBYTE; 2usize], - pub pbCrtInverses: [PBYTE; 2usize], - pub pbPrivExps: [PBYTE; 1usize], - pub pbCrtPrivExps: [PBYTE; 2usize], - pub pmModulus: PSYMCRYPT_MODULUS, - pub pmPrimes: [PSYMCRYPT_MODULUS; 2usize], - pub peCrtInverses: [PSYMCRYPT_MODELEMENT; 2usize], - pub piPrivExps: [PSYMCRYPT_INT; 1usize], - pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize], - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_RSAKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), - 192usize, - "Size of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), - 32usize, - "Alignment of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_RSAKEY::au64PubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize }, - 104usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize }, - 144usize, - "Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_RSAKEY::piPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize }, - 168usize, - "Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 184usize, - "Offset of field: _SYMCRYPT_RSAKEY::magic" - ); -} -impl Default for _SYMCRYPT_RSAKEY { - 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 SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY; -pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY; -pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_INVALID: - _SYMCRYPT_ECPOINT_COORDINATES = 0; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE: - _SYMCRYPT_ECPOINT_COORDINATES = 17; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_AFFINE: - _SYMCRYPT_ECPOINT_COORDINATES = 34; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 51; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_JACOBIAN: - _SYMCRYPT_ECPOINT_COORDINATES = 67; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_EXTENDED_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 84; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 98; -pub type _SYMCRYPT_ECPOINT_COORDINATES = ::std::os::raw::c_int; -pub use self::_SYMCRYPT_ECPOINT_COORDINATES as SYMCRYPT_ECPOINT_COORDINATES; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { - pub window: UINT32, - pub nPrecompPoints: UINT32, - pub nRecodedDigits: UINT32, - pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 528usize, - "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" - ); -} -impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { - 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 SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 1; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_TWISTED_EDWARDS: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 2; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_MONTGOMERY: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 3; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS_AM3: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 4; -pub type _SYMCRYPT_INTERNAL_ECURVE_TYPE = ::std::os::raw::c_int; -pub use self::_SYMCRYPT_INTERNAL_ECURVE_TYPE as SYMCRYPT_INTERNAL_ECURVE_TYPE; -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_ECURVE { - pub version: UINT32, - pub type_: SYMCRYPT_INTERNAL_ECURVE_TYPE, - pub eCoordinates: SYMCRYPT_ECPOINT_COORDINATES, - pub FModBitsize: UINT32, - pub FModDigits: UINT32, - pub FModBytesize: UINT32, - pub GOrdBitsize: UINT32, - pub GOrdDigits: UINT32, - pub GOrdBytesize: UINT32, - pub cbModElement: UINT32, - pub cbAlloc: UINT32, - pub cbScratchCommon: UINT32, - pub cbScratchScalar: UINT32, - pub cbScratchScalarMulti: UINT32, - pub cbScratchGetSetValue: UINT32, - pub cbScratchEckey: UINT32, - pub coFactorPower: UINT32, - pub PrivateKeyDefaultFormat: UINT32, - pub HighBitRestrictionNumOfBits: UINT32, - pub HighBitRestrictionPosition: UINT32, - pub HighBitRestrictionValue: UINT32, - pub info: _SYMCRYPT_ECURVE__bindgen_ty_1, - pub FMod: PSYMCRYPT_MODULUS, - pub GOrd: PSYMCRYPT_MODULUS, - pub A: PSYMCRYPT_MODELEMENT, - pub B: PSYMCRYPT_MODELEMENT, - pub G: PSYMCRYPT_ECPOINT, - pub H: PSYMCRYPT_INT, - pub magic: SIZE_T, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { - pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 528usize, - "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" - ); -} -impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), - 672usize, - "Size of _SYMCRYPT_ECURVE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), - 32usize, - "Alignment of _SYMCRYPT_ECURVE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE::eCoordinates" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE::FModDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 36usize, - "Offset of field: _SYMCRYPT_ECURVE::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_ECURVE::cbAlloc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize }, - 60usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_ECURVE::coFactorPower" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize }, - 68usize, - "Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize }, - 76usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_ECURVE::info" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize }, - 616usize, - "Offset of field: _SYMCRYPT_ECURVE::FMod" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize }, - 624usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrd" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize }, - 632usize, - "Offset of field: _SYMCRYPT_ECURVE::A" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 640usize, - "Offset of field: _SYMCRYPT_ECURVE::B" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize }, - 648usize, - "Offset of field: _SYMCRYPT_ECURVE::G" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 656usize, - "Offset of field: _SYMCRYPT_ECURVE::H" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 664usize, - "Offset of field: _SYMCRYPT_ECURVE::magic" - ); -} -impl Default for _SYMCRYPT_ECURVE { - 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 SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE; -pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE; -pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE; -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECPOINT { - pub normalized: BOOLEAN, - pub pCurve: PCSYMCRYPT_ECURVE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECPOINT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Size of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Alignment of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECPOINT::normalized" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECPOINT::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECPOINT::magic" - ); -} -impl Default for _SYMCRYPT_ECPOINT { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECKEY { - pub fAlgorithmInfo: UINT32, - pub hasPrivateKey: BOOLEAN, - pub pCurve: PCSYMCRYPT_ECURVE, - pub poPublicKey: PSYMCRYPT_ECPOINT, - pub piPrivateKey: PSYMCRYPT_INT, - pub magic: SIZE_T, +} +#[repr(C)] +#[repr(align(32))] +pub struct _SYMCRYPT_ECKEY { + pub _bindgen_opaque_blob: [u8; 64usize], } #[test] fn bindgen_test_layout__SYMCRYPT_ECKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_ECKEY>(), 64usize, @@ -1947,36 +1013,6 @@ fn bindgen_test_layout__SYMCRYPT_ECKEY() { 32usize, "Alignment of _SYMCRYPT_ECKEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECKEY::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECKEY::poPublicKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECKEY::piPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECKEY::magic" - ); } impl Default for _SYMCRYPT_ECKEY { fn default() -> Self { diff --git a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs index b8104230..9251ad34 100644 --- a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs @@ -55,7 +55,6 @@ pub type UINT64 = u64; pub type PUINT64 = *mut u64; pub type PBYTE = *mut BYTE; pub type PCBYTE = *const BYTE; -pub type PCUINT32 = *const UINT32; pub type PCUINT64 = *const UINT64; pub type PVOID = *mut ::std::os::raw::c_void; pub type PCVOID = *const ::std::os::raw::c_void; @@ -638,32 +637,14 @@ fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { pub type SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; -pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_MAC_INIT = - ::std::option::Option; -pub type PSYMCRYPT_MAC_APPEND = - ::std::option::Option; -pub type PSYMCRYPT_MAC_RESULT = - ::std::option::Option; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[repr(align(8))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_MAC { - pub expandKeyFunc: PSYMCRYPT_MAC_EXPAND_KEY, - pub initFunc: PSYMCRYPT_MAC_INIT, - pub appendFunc: PSYMCRYPT_MAC_APPEND, - pub resultFunc: PSYMCRYPT_MAC_RESULT, - pub expandedKeySize: SIZE_T, - pub stateSize: SIZE_T, - pub resultSize: SIZE_T, - pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, - pub outerChainingStateOffset: UINT32, + pub _bindgen_opaque_blob: [u64; 9usize], } #[test] fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_MAC>(), 72usize, @@ -674,60 +655,6 @@ fn bindgen_test_layout__SYMCRYPT_MAC() { 8usize, "Alignment of _SYMCRYPT_MAC" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} -impl Default for _SYMCRYPT_MAC { - 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 SYMCRYPT_MAC = _SYMCRYPT_MAC; pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; @@ -862,79 +789,27 @@ impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { pub type SYMCRYPT_HKDF_EXPANDED_KEY = _SYMCRYPT_HKDF_EXPANDED_KEY; pub type PSYMCRYPT_HKDF_EXPANDED_KEY = *mut _SYMCRYPT_HKDF_EXPANDED_KEY; pub type PCSYMCRYPT_HKDF_EXPANDED_KEY = *const SYMCRYPT_HKDF_EXPANDED_KEY; -pub type SYMCRYPT_INT = _SYMCRYPT_INT; -pub type PSYMCRYPT_INT = *mut SYMCRYPT_INT; -pub type SYMCRYPT_DIVISOR = _SYMCRYPT_DIVISOR; -pub type SYMCRYPT_MODULUS = _SYMCRYPT_MODULUS; -pub type PSYMCRYPT_MODULUS = *mut SYMCRYPT_MODULUS; -pub type SYMCRYPT_MODELEMENT = _SYMCRYPT_MODELEMENT; -pub type PSYMCRYPT_MODELEMENT = *mut SYMCRYPT_MODELEMENT; pub type SYMCRYPT_ECPOINT = _SYMCRYPT_ECPOINT; pub type PSYMCRYPT_ECPOINT = *mut SYMCRYPT_ECPOINT; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_INT { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub magic: SIZE_T, - pub __bindgen_padding_0: [u32; 2usize], - pub ti: _SYMCRYPT_INT__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_INT__bindgen_ty_1 { - pub fdef: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 { - pub uint32: [UINT32; 1usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32" - ); +pub struct _SYMCRYPT_RSAKEY { + pub _bindgen_opaque_blob: [u8; 192usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1" - ); +fn bindgen_test_layout__SYMCRYPT_RSAKEY() { assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1" + ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), + 192usize, + "Size of _SYMCRYPT_RSAKEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef" + ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), + 32usize, + "Alignment of _SYMCRYPT_RSAKEY" ); } -impl Default for _SYMCRYPT_INT__bindgen_ty_1 { +impl Default for _SYMCRYPT_RSAKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -943,47 +818,54 @@ impl Default for _SYMCRYPT_INT__bindgen_ty_1 { } } } +pub type SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY; +pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY; +pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { + pub window: UINT32, + pub nPrecompPoints: UINT32, + pub nRecodedDigits: UINT32, + pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], +} #[test] -fn bindgen_test_layout__SYMCRYPT_INT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = + ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT>(), - 64usize, - "Size of _SYMCRYPT_INT" + ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), + 528usize, + "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT>(), - 32usize, - "Alignment of _SYMCRYPT_INT" + ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), + 8usize, + "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_INT::type_" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, 4usize, - "Offset of field: _SYMCRYPT_INT::nDigits" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, 8usize, - "Offset of field: _SYMCRYPT_INT::cbSize" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, 16usize, - "Offset of field: _SYMCRYPT_INT::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_INT::ti" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" ); } -impl Default for _SYMCRYPT_INT { +impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -992,71 +874,39 @@ impl Default for _SYMCRYPT_INT { } } } +pub type SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_DIVISOR { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub nBits: UINT32, - pub magic: SIZE_T, - pub td: _SYMCRYPT_DIVISOR__bindgen_ty_1, - pub Int: SYMCRYPT_INT, +pub struct _SYMCRYPT_ECURVE { + pub _bindgen_opaque_blob: [u8; 672usize], } #[repr(C)] #[derive(Copy, Clone)] -pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 { - pub fdef: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 { - pub W: UINT64, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W" - ); +pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { + pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, } #[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> = +fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1" + ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), + 528usize, + "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), + ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1" + "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef" + "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" ); } -impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { +impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1066,56 +916,19 @@ impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { } } #[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(), - 96usize, - "Size of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(), - 32usize, - "Alignment of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_DIVISOR::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_DIVISOR::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_DIVISOR::nBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_DIVISOR::magic" - ); +fn bindgen_test_layout__SYMCRYPT_ECURVE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_DIVISOR::td" + ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), + 672usize, + "Size of _SYMCRYPT_ECURVE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), 32usize, - "Offset of field: _SYMCRYPT_DIVISOR::Int" + "Alignment of _SYMCRYPT_ECURVE" ); } -impl Default for _SYMCRYPT_DIVISOR { +impl Default for _SYMCRYPT_ECURVE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1124,115 +937,48 @@ impl Default for _SYMCRYPT_DIVISOR { } } } +pub type SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE; +pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE; +pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_MODULUS { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub flags: UINT32, - pub cbModElement: UINT32, - pub inv64: UINT64, - pub magic: SIZE_T, - pub tm: _SYMCRYPT_MODULUS__bindgen_ty_1, - pub __bindgen_padding_0: [u64; 2usize], - pub Divisor: SYMCRYPT_DIVISOR, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MODULUS__bindgen_ty_1 { - pub montgomery: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1, - pub pseudoMersenne: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2, -} -#[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { - pub Rsqr: PCUINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr" - ); -} -impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 { - pub k: UINT32, +pub struct _SYMCRYPT_ECPOINT { + pub normalized: BOOLEAN, + pub pCurve: PCSYMCRYPT_ECURVE, + pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_ECPOINT() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" + ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), + 32usize, + "Size of _SYMCRYPT_ECPOINT" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" + ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), + 32usize, + "Alignment of _SYMCRYPT_ECPOINT" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1" + "Offset of field: _SYMCRYPT_ECPOINT::normalized" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), + unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery" + "Offset of field: _SYMCRYPT_ECPOINT::pCurve" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_ECPOINT::magic" ); } -impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { +impl Default for _SYMCRYPT_ECPOINT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1240,693 +986,14 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { s.assume_init() } } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS>(), - 160usize, - "Size of _SYMCRYPT_MODULUS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS>(), - 32usize, - "Alignment of _SYMCRYPT_MODULUS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_MODULUS::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MODULUS::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_MODULUS::flags" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MODULUS::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MODULUS::inv64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MODULUS::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MODULUS::tm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MODULUS::Divisor" - ); -} -impl Default for _SYMCRYPT_MODULUS { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_MODELEMENT { - pub d: _SYMCRYPT_MODELEMENT__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 { - pub uint32: [UINT32; 1usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32" - ); -} -impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Size of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Alignment of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT::d" - ); -} -impl Default for _SYMCRYPT_MODELEMENT { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_RSAKEY { - pub fAlgorithmInfo: UINT32, - pub cbTotalSize: UINT32, - pub hasPrivateKey: BOOLEAN, - pub nSetBitsOfModulus: UINT32, - pub nBitsOfModulus: UINT32, - pub nDigitsOfModulus: UINT32, - pub nPubExp: UINT32, - pub nPrimes: UINT32, - pub nBitsOfPrimes: [UINT32; 2usize], - pub nDigitsOfPrimes: [UINT32; 2usize], - pub nMaxDigitsOfPrimes: UINT32, - pub au64PubExp: [UINT64; 1usize], - pub pbPrimes: [PBYTE; 2usize], - pub pbCrtInverses: [PBYTE; 2usize], - pub pbPrivExps: [PBYTE; 1usize], - pub pbCrtPrivExps: [PBYTE; 2usize], - pub pmModulus: PSYMCRYPT_MODULUS, - pub pmPrimes: [PSYMCRYPT_MODULUS; 2usize], - pub peCrtInverses: [PSYMCRYPT_MODELEMENT; 2usize], - pub piPrivExps: [PSYMCRYPT_INT; 1usize], - pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize], - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_RSAKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), - 192usize, - "Size of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), - 32usize, - "Alignment of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_RSAKEY::au64PubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize }, - 104usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize }, - 144usize, - "Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_RSAKEY::piPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize }, - 168usize, - "Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 184usize, - "Offset of field: _SYMCRYPT_RSAKEY::magic" - ); -} -impl Default for _SYMCRYPT_RSAKEY { - 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 SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY; -pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY; -pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_INVALID: - _SYMCRYPT_ECPOINT_COORDINATES = 0; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE: - _SYMCRYPT_ECPOINT_COORDINATES = 17; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_AFFINE: - _SYMCRYPT_ECPOINT_COORDINATES = 34; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 51; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_JACOBIAN: - _SYMCRYPT_ECPOINT_COORDINATES = 67; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_EXTENDED_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 84; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 98; -pub type _SYMCRYPT_ECPOINT_COORDINATES = ::std::os::raw::c_uint; -pub use self::_SYMCRYPT_ECPOINT_COORDINATES as SYMCRYPT_ECPOINT_COORDINATES; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { - pub window: UINT32, - pub nPrecompPoints: UINT32, - pub nRecodedDigits: UINT32, - pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 528usize, - "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" - ); -} -impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { - 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 SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 1; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_TWISTED_EDWARDS: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 2; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_MONTGOMERY: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 3; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS_AM3: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 4; -pub type _SYMCRYPT_INTERNAL_ECURVE_TYPE = ::std::os::raw::c_uint; -pub use self::_SYMCRYPT_INTERNAL_ECURVE_TYPE as SYMCRYPT_INTERNAL_ECURVE_TYPE; -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_ECURVE { - pub version: UINT32, - pub type_: SYMCRYPT_INTERNAL_ECURVE_TYPE, - pub eCoordinates: SYMCRYPT_ECPOINT_COORDINATES, - pub FModBitsize: UINT32, - pub FModDigits: UINT32, - pub FModBytesize: UINT32, - pub GOrdBitsize: UINT32, - pub GOrdDigits: UINT32, - pub GOrdBytesize: UINT32, - pub cbModElement: UINT32, - pub cbAlloc: UINT32, - pub cbScratchCommon: UINT32, - pub cbScratchScalar: UINT32, - pub cbScratchScalarMulti: UINT32, - pub cbScratchGetSetValue: UINT32, - pub cbScratchEckey: UINT32, - pub coFactorPower: UINT32, - pub PrivateKeyDefaultFormat: UINT32, - pub HighBitRestrictionNumOfBits: UINT32, - pub HighBitRestrictionPosition: UINT32, - pub HighBitRestrictionValue: UINT32, - pub info: _SYMCRYPT_ECURVE__bindgen_ty_1, - pub FMod: PSYMCRYPT_MODULUS, - pub GOrd: PSYMCRYPT_MODULUS, - pub A: PSYMCRYPT_MODELEMENT, - pub B: PSYMCRYPT_MODELEMENT, - pub G: PSYMCRYPT_ECPOINT, - pub H: PSYMCRYPT_INT, - pub magic: SIZE_T, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { - pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 528usize, - "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" - ); -} -impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), - 672usize, - "Size of _SYMCRYPT_ECURVE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), - 32usize, - "Alignment of _SYMCRYPT_ECURVE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE::eCoordinates" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE::FModDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 36usize, - "Offset of field: _SYMCRYPT_ECURVE::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_ECURVE::cbAlloc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize }, - 60usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_ECURVE::coFactorPower" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize }, - 68usize, - "Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize }, - 76usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_ECURVE::info" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize }, - 616usize, - "Offset of field: _SYMCRYPT_ECURVE::FMod" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize }, - 624usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrd" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize }, - 632usize, - "Offset of field: _SYMCRYPT_ECURVE::A" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 640usize, - "Offset of field: _SYMCRYPT_ECURVE::B" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize }, - 648usize, - "Offset of field: _SYMCRYPT_ECURVE::G" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 656usize, - "Offset of field: _SYMCRYPT_ECURVE::H" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 664usize, - "Offset of field: _SYMCRYPT_ECURVE::magic" - ); -} -impl Default for _SYMCRYPT_ECURVE { - 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 SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE; -pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE; -pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE; -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECPOINT { - pub normalized: BOOLEAN, - pub pCurve: PCSYMCRYPT_ECURVE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECPOINT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Size of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Alignment of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECPOINT::normalized" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECPOINT::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECPOINT::magic" - ); -} -impl Default for _SYMCRYPT_ECPOINT { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECKEY { - pub fAlgorithmInfo: UINT32, - pub hasPrivateKey: BOOLEAN, - pub pCurve: PCSYMCRYPT_ECURVE, - pub poPublicKey: PSYMCRYPT_ECPOINT, - pub piPrivateKey: PSYMCRYPT_INT, - pub magic: SIZE_T, +} +#[repr(C)] +#[repr(align(32))] +pub struct _SYMCRYPT_ECKEY { + pub _bindgen_opaque_blob: [u8; 64usize], } #[test] fn bindgen_test_layout__SYMCRYPT_ECKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_ECKEY>(), 64usize, @@ -1937,36 +1004,6 @@ fn bindgen_test_layout__SYMCRYPT_ECKEY() { 32usize, "Alignment of _SYMCRYPT_ECKEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECKEY::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECKEY::poPublicKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECKEY::piPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECKEY::magic" - ); } impl Default for _SYMCRYPT_ECKEY { fn default() -> Self { diff --git a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs index 7e384d7a..b28c8357 100644 --- a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs @@ -55,7 +55,6 @@ pub type ULONG_PTR = ::std::os::raw::c_ulonglong; pub type SIZE_T = ULONG_PTR; pub type PBYTE = *mut BYTE; pub type PCBYTE = *const BYTE; -pub type PCUINT32 = *const UINT32; pub type PUINT64 = *mut UINT64; pub type PCUINT64 = *const UINT64; pub type PVOID = *mut ::std::os::raw::c_void; @@ -647,32 +646,14 @@ fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { pub type SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; -pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_MAC_INIT = - ::std::option::Option; -pub type PSYMCRYPT_MAC_APPEND = - ::std::option::Option; -pub type PSYMCRYPT_MAC_RESULT = - ::std::option::Option; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[repr(align(8))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_MAC { - pub expandKeyFunc: PSYMCRYPT_MAC_EXPAND_KEY, - pub initFunc: PSYMCRYPT_MAC_INIT, - pub appendFunc: PSYMCRYPT_MAC_APPEND, - pub resultFunc: PSYMCRYPT_MAC_RESULT, - pub expandedKeySize: SIZE_T, - pub stateSize: SIZE_T, - pub resultSize: SIZE_T, - pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, - pub outerChainingStateOffset: UINT32, + pub _bindgen_opaque_blob: [u64; 9usize], } #[test] fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_MAC>(), 72usize, @@ -683,60 +664,6 @@ fn bindgen_test_layout__SYMCRYPT_MAC() { 8usize, "Alignment of _SYMCRYPT_MAC" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} -impl Default for _SYMCRYPT_MAC { - 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 SYMCRYPT_MAC = _SYMCRYPT_MAC; pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; @@ -871,80 +798,27 @@ impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { pub type SYMCRYPT_HKDF_EXPANDED_KEY = _SYMCRYPT_HKDF_EXPANDED_KEY; pub type PSYMCRYPT_HKDF_EXPANDED_KEY = *mut _SYMCRYPT_HKDF_EXPANDED_KEY; pub type PCSYMCRYPT_HKDF_EXPANDED_KEY = *const SYMCRYPT_HKDF_EXPANDED_KEY; -pub type SYMCRYPT_INT = _SYMCRYPT_INT; -pub type PSYMCRYPT_INT = *mut SYMCRYPT_INT; -pub type SYMCRYPT_DIVISOR = _SYMCRYPT_DIVISOR; -pub type SYMCRYPT_MODULUS = _SYMCRYPT_MODULUS; -pub type PSYMCRYPT_MODULUS = *mut SYMCRYPT_MODULUS; -pub type SYMCRYPT_MODELEMENT = _SYMCRYPT_MODELEMENT; -pub type PSYMCRYPT_MODELEMENT = *mut SYMCRYPT_MODELEMENT; pub type SYMCRYPT_ECPOINT = _SYMCRYPT_ECPOINT; pub type PSYMCRYPT_ECPOINT = *mut SYMCRYPT_ECPOINT; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_INT { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub magic: SIZE_T, - pub __bindgen_padding_0: u64, - pub ti: _SYMCRYPT_INT__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_INT__bindgen_ty_1 { - pub fdef: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 { - pub uint32: [UINT32; 1usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32" - ); +pub struct _SYMCRYPT_RSAKEY { + pub _bindgen_opaque_blob: [u8; 192usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); +fn bindgen_test_layout__SYMCRYPT_RSAKEY() { assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 32usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1" + ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), + 192usize, + "Size of _SYMCRYPT_RSAKEY" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(), + ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), 32usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef" + "Alignment of _SYMCRYPT_RSAKEY" ); } -impl Default for _SYMCRYPT_INT__bindgen_ty_1 { +impl Default for _SYMCRYPT_RSAKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -953,47 +827,54 @@ impl Default for _SYMCRYPT_INT__bindgen_ty_1 { } } } +pub type SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY; +pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY; +pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { + pub window: UINT32, + pub nPrecompPoints: UINT32, + pub nRecodedDigits: UINT32, + pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], +} #[test] -fn bindgen_test_layout__SYMCRYPT_INT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = + ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT>(), - 64usize, - "Size of _SYMCRYPT_INT" + ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), + 528usize, + "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT>(), - 32usize, - "Alignment of _SYMCRYPT_INT" + ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), + 8usize, + "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_INT::type_" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, 4usize, - "Offset of field: _SYMCRYPT_INT::nDigits" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, 8usize, - "Offset of field: _SYMCRYPT_INT::cbSize" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, 16usize, - "Offset of field: _SYMCRYPT_INT::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_INT::ti" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" ); } -impl Default for _SYMCRYPT_INT { +impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1002,71 +883,39 @@ impl Default for _SYMCRYPT_INT { } } } +pub type SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_DIVISOR { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub nBits: UINT32, - pub magic: SIZE_T, - pub td: _SYMCRYPT_DIVISOR__bindgen_ty_1, - pub Int: SYMCRYPT_INT, +pub struct _SYMCRYPT_ECURVE { + pub _bindgen_opaque_blob: [u8; 672usize], } #[repr(C)] #[derive(Copy, Clone)] -pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 { - pub fdef: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 { - pub W: UINT64, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W" - ); +pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { + pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, } #[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> = +fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1" + ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), + 528usize, + "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), + ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1" + "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef" + "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" ); } -impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { +impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1076,56 +925,19 @@ impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { } } #[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(), - 96usize, - "Size of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(), - 32usize, - "Alignment of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_DIVISOR::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_DIVISOR::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_DIVISOR::nBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_DIVISOR::magic" - ); +fn bindgen_test_layout__SYMCRYPT_ECURVE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_DIVISOR::td" + ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), + 672usize, + "Size of _SYMCRYPT_ECURVE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), 32usize, - "Offset of field: _SYMCRYPT_DIVISOR::Int" + "Alignment of _SYMCRYPT_ECURVE" ); } -impl Default for _SYMCRYPT_DIVISOR { +impl Default for _SYMCRYPT_ECURVE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1134,115 +946,48 @@ impl Default for _SYMCRYPT_DIVISOR { } } } +pub type SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE; +pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE; +pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_MODULUS { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub flags: UINT32, - pub cbModElement: UINT32, - pub inv64: UINT64, - pub magic: SIZE_T, - pub tm: _SYMCRYPT_MODULUS__bindgen_ty_1, - pub __bindgen_padding_0: [u64; 2usize], - pub Divisor: SYMCRYPT_DIVISOR, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MODULUS__bindgen_ty_1 { - pub montgomery: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1, - pub pseudoMersenne: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2, -} -#[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { - pub Rsqr: PCUINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr" - ); -} -impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 { - pub k: UINT32, +pub struct _SYMCRYPT_ECPOINT { + pub normalized: BOOLEAN, + pub pCurve: PCSYMCRYPT_ECURVE, + pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_ECPOINT() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" + ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), + 32usize, + "Size of _SYMCRYPT_ECPOINT" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" + ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), + 32usize, + "Alignment of _SYMCRYPT_ECPOINT" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1" + "Offset of field: _SYMCRYPT_ECPOINT::normalized" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), + unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery" + "Offset of field: _SYMCRYPT_ECPOINT::pCurve" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_ECPOINT::magic" ); } -impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { +impl Default for _SYMCRYPT_ECPOINT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1250,693 +995,14 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { s.assume_init() } } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS>(), - 160usize, - "Size of _SYMCRYPT_MODULUS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS>(), - 32usize, - "Alignment of _SYMCRYPT_MODULUS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_MODULUS::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MODULUS::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_MODULUS::flags" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MODULUS::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MODULUS::inv64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MODULUS::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MODULUS::tm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MODULUS::Divisor" - ); -} -impl Default for _SYMCRYPT_MODULUS { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_MODELEMENT { - pub d: _SYMCRYPT_MODELEMENT__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 { - pub uint32: [UINT32; 1usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32" - ); -} -impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Size of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Alignment of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT::d" - ); -} -impl Default for _SYMCRYPT_MODELEMENT { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_RSAKEY { - pub fAlgorithmInfo: UINT32, - pub cbTotalSize: UINT32, - pub hasPrivateKey: BOOLEAN, - pub nSetBitsOfModulus: UINT32, - pub nBitsOfModulus: UINT32, - pub nDigitsOfModulus: UINT32, - pub nPubExp: UINT32, - pub nPrimes: UINT32, - pub nBitsOfPrimes: [UINT32; 2usize], - pub nDigitsOfPrimes: [UINT32; 2usize], - pub nMaxDigitsOfPrimes: UINT32, - pub au64PubExp: [UINT64; 1usize], - pub pbPrimes: [PBYTE; 2usize], - pub pbCrtInverses: [PBYTE; 2usize], - pub pbPrivExps: [PBYTE; 1usize], - pub pbCrtPrivExps: [PBYTE; 2usize], - pub pmModulus: PSYMCRYPT_MODULUS, - pub pmPrimes: [PSYMCRYPT_MODULUS; 2usize], - pub peCrtInverses: [PSYMCRYPT_MODELEMENT; 2usize], - pub piPrivExps: [PSYMCRYPT_INT; 1usize], - pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize], - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_RSAKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), - 192usize, - "Size of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), - 32usize, - "Alignment of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_RSAKEY::au64PubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize }, - 104usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize }, - 144usize, - "Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_RSAKEY::piPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize }, - 168usize, - "Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 184usize, - "Offset of field: _SYMCRYPT_RSAKEY::magic" - ); -} -impl Default for _SYMCRYPT_RSAKEY { - 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 SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY; -pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY; -pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_INVALID: - _SYMCRYPT_ECPOINT_COORDINATES = 0; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE: - _SYMCRYPT_ECPOINT_COORDINATES = 17; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_AFFINE: - _SYMCRYPT_ECPOINT_COORDINATES = 34; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 51; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_JACOBIAN: - _SYMCRYPT_ECPOINT_COORDINATES = 67; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_EXTENDED_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 84; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 98; -pub type _SYMCRYPT_ECPOINT_COORDINATES = ::std::os::raw::c_int; -pub use self::_SYMCRYPT_ECPOINT_COORDINATES as SYMCRYPT_ECPOINT_COORDINATES; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { - pub window: UINT32, - pub nPrecompPoints: UINT32, - pub nRecodedDigits: UINT32, - pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 528usize, - "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" - ); -} -impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { - 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 SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 1; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_TWISTED_EDWARDS: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 2; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_MONTGOMERY: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 3; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS_AM3: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 4; -pub type _SYMCRYPT_INTERNAL_ECURVE_TYPE = ::std::os::raw::c_int; -pub use self::_SYMCRYPT_INTERNAL_ECURVE_TYPE as SYMCRYPT_INTERNAL_ECURVE_TYPE; -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_ECURVE { - pub version: UINT32, - pub type_: SYMCRYPT_INTERNAL_ECURVE_TYPE, - pub eCoordinates: SYMCRYPT_ECPOINT_COORDINATES, - pub FModBitsize: UINT32, - pub FModDigits: UINT32, - pub FModBytesize: UINT32, - pub GOrdBitsize: UINT32, - pub GOrdDigits: UINT32, - pub GOrdBytesize: UINT32, - pub cbModElement: UINT32, - pub cbAlloc: UINT32, - pub cbScratchCommon: UINT32, - pub cbScratchScalar: UINT32, - pub cbScratchScalarMulti: UINT32, - pub cbScratchGetSetValue: UINT32, - pub cbScratchEckey: UINT32, - pub coFactorPower: UINT32, - pub PrivateKeyDefaultFormat: UINT32, - pub HighBitRestrictionNumOfBits: UINT32, - pub HighBitRestrictionPosition: UINT32, - pub HighBitRestrictionValue: UINT32, - pub info: _SYMCRYPT_ECURVE__bindgen_ty_1, - pub FMod: PSYMCRYPT_MODULUS, - pub GOrd: PSYMCRYPT_MODULUS, - pub A: PSYMCRYPT_MODELEMENT, - pub B: PSYMCRYPT_MODELEMENT, - pub G: PSYMCRYPT_ECPOINT, - pub H: PSYMCRYPT_INT, - pub magic: SIZE_T, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { - pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 528usize, - "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" - ); -} -impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), - 672usize, - "Size of _SYMCRYPT_ECURVE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), - 32usize, - "Alignment of _SYMCRYPT_ECURVE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE::eCoordinates" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE::FModDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 36usize, - "Offset of field: _SYMCRYPT_ECURVE::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_ECURVE::cbAlloc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize }, - 60usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_ECURVE::coFactorPower" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize }, - 68usize, - "Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize }, - 76usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_ECURVE::info" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize }, - 616usize, - "Offset of field: _SYMCRYPT_ECURVE::FMod" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize }, - 624usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrd" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize }, - 632usize, - "Offset of field: _SYMCRYPT_ECURVE::A" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 640usize, - "Offset of field: _SYMCRYPT_ECURVE::B" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize }, - 648usize, - "Offset of field: _SYMCRYPT_ECURVE::G" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 656usize, - "Offset of field: _SYMCRYPT_ECURVE::H" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 664usize, - "Offset of field: _SYMCRYPT_ECURVE::magic" - ); -} -impl Default for _SYMCRYPT_ECURVE { - 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 SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE; -pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE; -pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE; -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECPOINT { - pub normalized: BOOLEAN, - pub pCurve: PCSYMCRYPT_ECURVE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECPOINT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Size of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Alignment of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECPOINT::normalized" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECPOINT::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECPOINT::magic" - ); -} -impl Default for _SYMCRYPT_ECPOINT { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECKEY { - pub fAlgorithmInfo: UINT32, - pub hasPrivateKey: BOOLEAN, - pub pCurve: PCSYMCRYPT_ECURVE, - pub poPublicKey: PSYMCRYPT_ECPOINT, - pub piPrivateKey: PSYMCRYPT_INT, - pub magic: SIZE_T, +} +#[repr(C)] +#[repr(align(32))] +pub struct _SYMCRYPT_ECKEY { + pub _bindgen_opaque_blob: [u8; 64usize], } #[test] fn bindgen_test_layout__SYMCRYPT_ECKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_ECKEY>(), 64usize, @@ -1947,36 +1013,6 @@ fn bindgen_test_layout__SYMCRYPT_ECKEY() { 32usize, "Alignment of _SYMCRYPT_ECKEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECKEY::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECKEY::poPublicKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECKEY::piPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECKEY::magic" - ); } impl Default for _SYMCRYPT_ECKEY { fn default() -> Self { diff --git a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs index b8104230..9251ad34 100644 --- a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs @@ -55,7 +55,6 @@ pub type UINT64 = u64; pub type PUINT64 = *mut u64; pub type PBYTE = *mut BYTE; pub type PCBYTE = *const BYTE; -pub type PCUINT32 = *const UINT32; pub type PCUINT64 = *const UINT64; pub type PVOID = *mut ::std::os::raw::c_void; pub type PCVOID = *const ::std::os::raw::c_void; @@ -638,32 +637,14 @@ fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { pub type SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY; pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY; pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY; -pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option< - unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR, ->; -pub type PSYMCRYPT_MAC_INIT = - ::std::option::Option; -pub type PSYMCRYPT_MAC_APPEND = - ::std::option::Option; -pub type PSYMCRYPT_MAC_RESULT = - ::std::option::Option; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[repr(align(8))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_MAC { - pub expandKeyFunc: PSYMCRYPT_MAC_EXPAND_KEY, - pub initFunc: PSYMCRYPT_MAC_INIT, - pub appendFunc: PSYMCRYPT_MAC_APPEND, - pub resultFunc: PSYMCRYPT_MAC_RESULT, - pub expandedKeySize: SIZE_T, - pub stateSize: SIZE_T, - pub resultSize: SIZE_T, - pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, - pub outerChainingStateOffset: UINT32, + pub _bindgen_opaque_blob: [u64; 9usize], } #[test] fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_MAC>(), 72usize, @@ -674,60 +655,6 @@ fn bindgen_test_layout__SYMCRYPT_MAC() { 8usize, "Alignment of _SYMCRYPT_MAC" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} -impl Default for _SYMCRYPT_MAC { - 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 SYMCRYPT_MAC = _SYMCRYPT_MAC; pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; @@ -862,79 +789,27 @@ impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { pub type SYMCRYPT_HKDF_EXPANDED_KEY = _SYMCRYPT_HKDF_EXPANDED_KEY; pub type PSYMCRYPT_HKDF_EXPANDED_KEY = *mut _SYMCRYPT_HKDF_EXPANDED_KEY; pub type PCSYMCRYPT_HKDF_EXPANDED_KEY = *const SYMCRYPT_HKDF_EXPANDED_KEY; -pub type SYMCRYPT_INT = _SYMCRYPT_INT; -pub type PSYMCRYPT_INT = *mut SYMCRYPT_INT; -pub type SYMCRYPT_DIVISOR = _SYMCRYPT_DIVISOR; -pub type SYMCRYPT_MODULUS = _SYMCRYPT_MODULUS; -pub type PSYMCRYPT_MODULUS = *mut SYMCRYPT_MODULUS; -pub type SYMCRYPT_MODELEMENT = _SYMCRYPT_MODELEMENT; -pub type PSYMCRYPT_MODELEMENT = *mut SYMCRYPT_MODELEMENT; pub type SYMCRYPT_ECPOINT = _SYMCRYPT_ECPOINT; pub type PSYMCRYPT_ECPOINT = *mut SYMCRYPT_ECPOINT; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_INT { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub magic: SIZE_T, - pub __bindgen_padding_0: [u32; 2usize], - pub ti: _SYMCRYPT_INT__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_INT__bindgen_ty_1 { - pub fdef: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 { - pub uint32: [UINT32; 1usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32" - ); +pub struct _SYMCRYPT_RSAKEY { + pub _bindgen_opaque_blob: [u8; 192usize], } #[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1" - ); +fn bindgen_test_layout__SYMCRYPT_RSAKEY() { assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1" + ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), + 192usize, + "Size of _SYMCRYPT_RSAKEY" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef" + ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), + 32usize, + "Alignment of _SYMCRYPT_RSAKEY" ); } -impl Default for _SYMCRYPT_INT__bindgen_ty_1 { +impl Default for _SYMCRYPT_RSAKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -943,47 +818,54 @@ impl Default for _SYMCRYPT_INT__bindgen_ty_1 { } } } +pub type SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY; +pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY; +pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { + pub window: UINT32, + pub nPrecompPoints: UINT32, + pub nRecodedDigits: UINT32, + pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], +} #[test] -fn bindgen_test_layout__SYMCRYPT_INT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = + ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT>(), - 64usize, - "Size of _SYMCRYPT_INT" + ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), + 528usize, + "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT>(), - 32usize, - "Alignment of _SYMCRYPT_INT" + ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), + 8usize, + "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_INT::type_" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, 4usize, - "Offset of field: _SYMCRYPT_INT::nDigits" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, 8usize, - "Offset of field: _SYMCRYPT_INT::cbSize" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, 16usize, - "Offset of field: _SYMCRYPT_INT::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_INT::ti" + "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" ); } -impl Default for _SYMCRYPT_INT { +impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -992,71 +874,39 @@ impl Default for _SYMCRYPT_INT { } } } +pub type SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_DIVISOR { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub nBits: UINT32, - pub magic: SIZE_T, - pub td: _SYMCRYPT_DIVISOR__bindgen_ty_1, - pub Int: SYMCRYPT_INT, +pub struct _SYMCRYPT_ECURVE { + pub _bindgen_opaque_blob: [u8; 672usize], } #[repr(C)] #[derive(Copy, Clone)] -pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 { - pub fdef: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 { - pub W: UINT64, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W" - ); +pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { + pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, } #[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> = +fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1" + ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), + 528usize, + "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), + ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1" + "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef" + "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" ); } -impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { +impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1066,56 +916,19 @@ impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { } } #[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(), - 96usize, - "Size of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(), - 32usize, - "Alignment of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_DIVISOR::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_DIVISOR::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_DIVISOR::nBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_DIVISOR::magic" - ); +fn bindgen_test_layout__SYMCRYPT_ECURVE() { assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_DIVISOR::td" + ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), + 672usize, + "Size of _SYMCRYPT_ECURVE" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize }, + ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), 32usize, - "Offset of field: _SYMCRYPT_DIVISOR::Int" + "Alignment of _SYMCRYPT_ECURVE" ); } -impl Default for _SYMCRYPT_DIVISOR { +impl Default for _SYMCRYPT_ECURVE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1124,115 +937,48 @@ impl Default for _SYMCRYPT_DIVISOR { } } } +pub type SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE; +pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE; +pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE; #[repr(C)] #[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_MODULUS { - pub type_: UINT32, - pub nDigits: UINT32, - pub cbSize: UINT32, - pub flags: UINT32, - pub cbModElement: UINT32, - pub inv64: UINT64, - pub magic: SIZE_T, - pub tm: _SYMCRYPT_MODULUS__bindgen_ty_1, - pub __bindgen_padding_0: [u64; 2usize], - pub Divisor: SYMCRYPT_DIVISOR, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MODULUS__bindgen_ty_1 { - pub montgomery: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1, - pub pseudoMersenne: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2, -} -#[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { - pub Rsqr: PCUINT32, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr" - ); -} -impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[derive(Debug, Default, Copy, Clone)] -pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 { - pub k: UINT32, +pub struct _SYMCRYPT_ECPOINT { + pub normalized: BOOLEAN, + pub pCurve: PCSYMCRYPT_ECURVE, + pub magic: SIZE_T, } #[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> = - ::std::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__SYMCRYPT_ECPOINT() { + const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" + ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), + 32usize, + "Size of _SYMCRYPT_ECPOINT" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" + ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), + 32usize, + "Alignment of _SYMCRYPT_ECPOINT" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1" + "Offset of field: _SYMCRYPT_ECPOINT::normalized" ); assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), + unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery" + "Offset of field: _SYMCRYPT_ECPOINT::pCurve" ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne" + unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, + 16usize, + "Offset of field: _SYMCRYPT_ECPOINT::magic" ); } -impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { +impl Default for _SYMCRYPT_ECPOINT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { @@ -1240,693 +986,14 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { s.assume_init() } } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS>(), - 160usize, - "Size of _SYMCRYPT_MODULUS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS>(), - 32usize, - "Alignment of _SYMCRYPT_MODULUS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_MODULUS::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MODULUS::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_MODULUS::flags" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MODULUS::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MODULUS::inv64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MODULUS::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MODULUS::tm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MODULUS::Divisor" - ); -} -impl Default for _SYMCRYPT_MODULUS { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_MODELEMENT { - pub d: _SYMCRYPT_MODELEMENT__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 { - pub uint32: [UINT32; 1usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32" - ); -} -impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Size of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Alignment of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT::d" - ); -} -impl Default for _SYMCRYPT_MODELEMENT { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_RSAKEY { - pub fAlgorithmInfo: UINT32, - pub cbTotalSize: UINT32, - pub hasPrivateKey: BOOLEAN, - pub nSetBitsOfModulus: UINT32, - pub nBitsOfModulus: UINT32, - pub nDigitsOfModulus: UINT32, - pub nPubExp: UINT32, - pub nPrimes: UINT32, - pub nBitsOfPrimes: [UINT32; 2usize], - pub nDigitsOfPrimes: [UINT32; 2usize], - pub nMaxDigitsOfPrimes: UINT32, - pub au64PubExp: [UINT64; 1usize], - pub pbPrimes: [PBYTE; 2usize], - pub pbCrtInverses: [PBYTE; 2usize], - pub pbPrivExps: [PBYTE; 1usize], - pub pbCrtPrivExps: [PBYTE; 2usize], - pub pmModulus: PSYMCRYPT_MODULUS, - pub pmPrimes: [PSYMCRYPT_MODULUS; 2usize], - pub peCrtInverses: [PSYMCRYPT_MODELEMENT; 2usize], - pub piPrivExps: [PSYMCRYPT_INT; 1usize], - pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize], - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_RSAKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), - 192usize, - "Size of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), - 32usize, - "Alignment of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_RSAKEY::au64PubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize }, - 104usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize }, - 144usize, - "Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_RSAKEY::piPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize }, - 168usize, - "Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 184usize, - "Offset of field: _SYMCRYPT_RSAKEY::magic" - ); -} -impl Default for _SYMCRYPT_RSAKEY { - 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 SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY; -pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY; -pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_INVALID: - _SYMCRYPT_ECPOINT_COORDINATES = 0; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE: - _SYMCRYPT_ECPOINT_COORDINATES = 17; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_AFFINE: - _SYMCRYPT_ECPOINT_COORDINATES = 34; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 51; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_JACOBIAN: - _SYMCRYPT_ECPOINT_COORDINATES = 67; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_EXTENDED_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 84; -pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE_PROJECTIVE: - _SYMCRYPT_ECPOINT_COORDINATES = 98; -pub type _SYMCRYPT_ECPOINT_COORDINATES = ::std::os::raw::c_uint; -pub use self::_SYMCRYPT_ECPOINT_COORDINATES as SYMCRYPT_ECPOINT_COORDINATES; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { - pub window: UINT32, - pub nPrecompPoints: UINT32, - pub nRecodedDigits: UINT32, - pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 528usize, - "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" - ); -} -impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { - 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 SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 1; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_TWISTED_EDWARDS: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 2; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_MONTGOMERY: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 3; -pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS_AM3: - _SYMCRYPT_INTERNAL_ECURVE_TYPE = 4; -pub type _SYMCRYPT_INTERNAL_ECURVE_TYPE = ::std::os::raw::c_uint; -pub use self::_SYMCRYPT_INTERNAL_ECURVE_TYPE as SYMCRYPT_INTERNAL_ECURVE_TYPE; -#[repr(C)] -#[repr(align(32))] -#[derive(Copy, Clone)] -pub struct _SYMCRYPT_ECURVE { - pub version: UINT32, - pub type_: SYMCRYPT_INTERNAL_ECURVE_TYPE, - pub eCoordinates: SYMCRYPT_ECPOINT_COORDINATES, - pub FModBitsize: UINT32, - pub FModDigits: UINT32, - pub FModBytesize: UINT32, - pub GOrdBitsize: UINT32, - pub GOrdDigits: UINT32, - pub GOrdBytesize: UINT32, - pub cbModElement: UINT32, - pub cbAlloc: UINT32, - pub cbScratchCommon: UINT32, - pub cbScratchScalar: UINT32, - pub cbScratchScalarMulti: UINT32, - pub cbScratchGetSetValue: UINT32, - pub cbScratchEckey: UINT32, - pub coFactorPower: UINT32, - pub PrivateKeyDefaultFormat: UINT32, - pub HighBitRestrictionNumOfBits: UINT32, - pub HighBitRestrictionPosition: UINT32, - pub HighBitRestrictionValue: UINT32, - pub info: _SYMCRYPT_ECURVE__bindgen_ty_1, - pub FMod: PSYMCRYPT_MODULUS, - pub GOrd: PSYMCRYPT_MODULUS, - pub A: PSYMCRYPT_MODELEMENT, - pub B: PSYMCRYPT_MODELEMENT, - pub G: PSYMCRYPT_ECPOINT, - pub H: PSYMCRYPT_INT, - pub magic: SIZE_T, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { - pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 528usize, - "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" - ); -} -impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), - 672usize, - "Size of _SYMCRYPT_ECURVE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), - 32usize, - "Alignment of _SYMCRYPT_ECURVE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE::eCoordinates" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE::FModDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 36usize, - "Offset of field: _SYMCRYPT_ECURVE::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_ECURVE::cbAlloc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize }, - 60usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_ECURVE::coFactorPower" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize }, - 68usize, - "Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize }, - 76usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_ECURVE::info" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize }, - 616usize, - "Offset of field: _SYMCRYPT_ECURVE::FMod" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize }, - 624usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrd" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize }, - 632usize, - "Offset of field: _SYMCRYPT_ECURVE::A" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 640usize, - "Offset of field: _SYMCRYPT_ECURVE::B" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize }, - 648usize, - "Offset of field: _SYMCRYPT_ECURVE::G" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 656usize, - "Offset of field: _SYMCRYPT_ECURVE::H" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 664usize, - "Offset of field: _SYMCRYPT_ECURVE::magic" - ); -} -impl Default for _SYMCRYPT_ECURVE { - 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 SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE; -pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE; -pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE; -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECPOINT { - pub normalized: BOOLEAN, - pub pCurve: PCSYMCRYPT_ECURVE, - pub magic: SIZE_T, -} -#[test] -fn bindgen_test_layout__SYMCRYPT_ECPOINT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Size of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Alignment of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECPOINT::normalized" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECPOINT::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECPOINT::magic" - ); -} -impl Default for _SYMCRYPT_ECPOINT { - fn default() -> Self { - let mut s = ::std::mem::MaybeUninit::::uninit(); - unsafe { - ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); - s.assume_init() - } - } -} -#[repr(C)] -#[repr(align(32))] -#[derive(Debug, Copy, Clone)] -pub struct _SYMCRYPT_ECKEY { - pub fAlgorithmInfo: UINT32, - pub hasPrivateKey: BOOLEAN, - pub pCurve: PCSYMCRYPT_ECURVE, - pub poPublicKey: PSYMCRYPT_ECPOINT, - pub piPrivateKey: PSYMCRYPT_INT, - pub magic: SIZE_T, +} +#[repr(C)] +#[repr(align(32))] +pub struct _SYMCRYPT_ECKEY { + pub _bindgen_opaque_blob: [u8; 64usize], } #[test] fn bindgen_test_layout__SYMCRYPT_ECKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_ECKEY>(), 64usize, @@ -1937,36 +1004,6 @@ fn bindgen_test_layout__SYMCRYPT_ECKEY() { 32usize, "Alignment of _SYMCRYPT_ECKEY" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECKEY::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECKEY::poPublicKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECKEY::piPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECKEY::magic" - ); } impl Default for _SYMCRYPT_ECKEY { fn default() -> Self { From 7e22e50c60f9b07cc5b24deaa85aa4a38cf7c2f4 Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 11:09:26 +0100 Subject: [PATCH 08/11] more opaque types --- symcrypt-bindgen/src/main.rs | 1 + .../src/bindings/aarch64_pc_windows_msvc.rs | 68 +------------------ .../src/bindings/aarch64_unknown_linux_gnu.rs | 68 +------------------ .../src/bindings/x86_64_pc_windows_msvc.rs | 68 +------------------ .../src/bindings/x86_64_unknown_linux_gnu.rs | 68 +------------------ 5 files changed, 13 insertions(+), 260 deletions(-) diff --git a/symcrypt-bindgen/src/main.rs b/symcrypt-bindgen/src/main.rs index 82770337..e04efa3c 100644 --- a/symcrypt-bindgen/src/main.rs +++ b/symcrypt-bindgen/src/main.rs @@ -115,6 +115,7 @@ fn main() { .opaque_type(format!("_SYMCRYPT_.*_EXPANDED_KEY")) .opaque_type("_SYMCRYPT_BLOCKCIPHER") .opaque_type("_SYMCRYPT_ECURVE") + .opaque_type("_SYMCRYPT_ECURVE_PARAMS") .opaque_type("_SYMCRYPT_INT") .opaque_type("_SYMCRYPT_DIVISOR") .opaque_type("_SYMCRYPT_MODULUS") diff --git a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs index b28c8357..8d636dd3 100644 --- a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs @@ -42,12 +42,6 @@ pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787 pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788; pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789; pub type SYMCRYPT_ERROR = ::std::os::raw::c_int; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS: _SYMCRYPT_ECURVE_TYPE = 2; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_MONTGOMERY: _SYMCRYPT_ECURVE_TYPE = 3; -pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_int; -pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE; pub type BYTE = ::std::os::raw::c_uchar; pub type UINT32 = ::std::os::raw::c_uint; pub type UINT64 = ::std::os::raw::c_ulonglong; @@ -1695,26 +1689,14 @@ fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() { } pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS; pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS; -pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID = - 0; -pub type _SYMCRYPT_ECURVE_GEN_ALG_ID = ::std::os::raw::c_int; -pub use self::_SYMCRYPT_ECURVE_GEN_ALG_ID as SYMCRYPT_ECURVE_GEN_ALG_ID; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_ECURVE_PARAMS { - pub version: UINT32, - pub type_: SYMCRYPT_ECURVE_TYPE, - pub algId: SYMCRYPT_ECURVE_GEN_ALG_ID, - pub cbFieldLength: UINT32, - pub cbSubgroupOrder: UINT32, - pub cbCofactor: UINT32, - pub cbSeed: UINT32, + pub _bindgen_opaque_blob: [u32; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(), 28usize, @@ -1725,50 +1707,6 @@ fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { 4usize, "Alignment of _SYMCRYPT_ECURVE_PARAMS" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed" - ); -} -impl Default for _SYMCRYPT_ECURVE_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 SYMCRYPT_ECURVE_PARAMS = _SYMCRYPT_ECURVE_PARAMS; pub type PCSYMCRYPT_ECURVE_PARAMS = *const SYMCRYPT_ECURVE_PARAMS; diff --git a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs index 9251ad34..9b345d0d 100644 --- a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs @@ -42,12 +42,6 @@ pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787 pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788; pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789; pub type SYMCRYPT_ERROR = ::std::os::raw::c_uint; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS: _SYMCRYPT_ECURVE_TYPE = 2; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_MONTGOMERY: _SYMCRYPT_ECURVE_TYPE = 3; -pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_uint; -pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE; pub type BYTE = u8; pub type SIZE_T = usize; pub type UINT32 = u32; @@ -1672,26 +1666,14 @@ fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() { } pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS; pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS; -pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID = - 0; -pub type _SYMCRYPT_ECURVE_GEN_ALG_ID = ::std::os::raw::c_uint; -pub use self::_SYMCRYPT_ECURVE_GEN_ALG_ID as SYMCRYPT_ECURVE_GEN_ALG_ID; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_ECURVE_PARAMS { - pub version: UINT32, - pub type_: SYMCRYPT_ECURVE_TYPE, - pub algId: SYMCRYPT_ECURVE_GEN_ALG_ID, - pub cbFieldLength: UINT32, - pub cbSubgroupOrder: UINT32, - pub cbCofactor: UINT32, - pub cbSeed: UINT32, + pub _bindgen_opaque_blob: [u32; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(), 28usize, @@ -1702,50 +1684,6 @@ fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { 4usize, "Alignment of _SYMCRYPT_ECURVE_PARAMS" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed" - ); -} -impl Default for _SYMCRYPT_ECURVE_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 SYMCRYPT_ECURVE_PARAMS = _SYMCRYPT_ECURVE_PARAMS; pub type PCSYMCRYPT_ECURVE_PARAMS = *const SYMCRYPT_ECURVE_PARAMS; diff --git a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs index b28c8357..8d636dd3 100644 --- a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs @@ -42,12 +42,6 @@ pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787 pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788; pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789; pub type SYMCRYPT_ERROR = ::std::os::raw::c_int; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS: _SYMCRYPT_ECURVE_TYPE = 2; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_MONTGOMERY: _SYMCRYPT_ECURVE_TYPE = 3; -pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_int; -pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE; pub type BYTE = ::std::os::raw::c_uchar; pub type UINT32 = ::std::os::raw::c_uint; pub type UINT64 = ::std::os::raw::c_ulonglong; @@ -1695,26 +1689,14 @@ fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() { } pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS; pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS; -pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID = - 0; -pub type _SYMCRYPT_ECURVE_GEN_ALG_ID = ::std::os::raw::c_int; -pub use self::_SYMCRYPT_ECURVE_GEN_ALG_ID as SYMCRYPT_ECURVE_GEN_ALG_ID; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_ECURVE_PARAMS { - pub version: UINT32, - pub type_: SYMCRYPT_ECURVE_TYPE, - pub algId: SYMCRYPT_ECURVE_GEN_ALG_ID, - pub cbFieldLength: UINT32, - pub cbSubgroupOrder: UINT32, - pub cbCofactor: UINT32, - pub cbSeed: UINT32, + pub _bindgen_opaque_blob: [u32; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(), 28usize, @@ -1725,50 +1707,6 @@ fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { 4usize, "Alignment of _SYMCRYPT_ECURVE_PARAMS" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed" - ); -} -impl Default for _SYMCRYPT_ECURVE_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 SYMCRYPT_ECURVE_PARAMS = _SYMCRYPT_ECURVE_PARAMS; pub type PCSYMCRYPT_ECURVE_PARAMS = *const SYMCRYPT_ECURVE_PARAMS; diff --git a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs index 9251ad34..9b345d0d 100644 --- a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs @@ -42,12 +42,6 @@ pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787 pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788; pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789; pub type SYMCRYPT_ERROR = ::std::os::raw::c_uint; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS: _SYMCRYPT_ECURVE_TYPE = 2; -pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_MONTGOMERY: _SYMCRYPT_ECURVE_TYPE = 3; -pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_uint; -pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE; pub type BYTE = u8; pub type SIZE_T = usize; pub type UINT32 = u32; @@ -1672,26 +1666,14 @@ fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() { } pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS; pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS; -pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID = - 0; -pub type _SYMCRYPT_ECURVE_GEN_ALG_ID = ::std::os::raw::c_uint; -pub use self::_SYMCRYPT_ECURVE_GEN_ALG_ID as SYMCRYPT_ECURVE_GEN_ALG_ID; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] pub struct _SYMCRYPT_ECURVE_PARAMS { - pub version: UINT32, - pub type_: SYMCRYPT_ECURVE_TYPE, - pub algId: SYMCRYPT_ECURVE_GEN_ALG_ID, - pub cbFieldLength: UINT32, - pub cbSubgroupOrder: UINT32, - pub cbCofactor: UINT32, - pub cbSeed: UINT32, + pub _bindgen_opaque_blob: [u32; 7usize], } #[test] fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(), 28usize, @@ -1702,50 +1684,6 @@ fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { 4usize, "Alignment of _SYMCRYPT_ECURVE_PARAMS" ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed" - ); -} -impl Default for _SYMCRYPT_ECURVE_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 SYMCRYPT_ECURVE_PARAMS = _SYMCRYPT_ECURVE_PARAMS; pub type PCSYMCRYPT_ECURVE_PARAMS = *const SYMCRYPT_ECURVE_PARAMS; From 13d68df7d3175a00690395d47bede21e662b1e98 Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 11:16:13 +0100 Subject: [PATCH 09/11] apply windows fix to every platform --- jitterentropy-sys2/jitterentropy | 1 + symcrypt-bindgen/src/main.rs | 49 ++++++++--------- .../src/bindings/aarch64_pc_windows_msvc.rs | 52 +++++++++---------- .../src/bindings/aarch64_unknown_linux_gnu.rs | 26 ++++++++++ .../src/bindings/x86_64_pc_windows_msvc.rs | 52 +++++++++---------- .../src/bindings/x86_64_unknown_linux_gnu.rs | 26 ++++++++++ 6 files changed, 128 insertions(+), 78 deletions(-) create mode 160000 jitterentropy-sys2/jitterentropy diff --git a/jitterentropy-sys2/jitterentropy b/jitterentropy-sys2/jitterentropy new file mode 160000 index 00000000..16c9e5c9 --- /dev/null +++ b/jitterentropy-sys2/jitterentropy @@ -0,0 +1 @@ +Subproject commit 16c9e5c93e614f0df25f1cb30d0730102e6f4e41 diff --git a/symcrypt-bindgen/src/main.rs b/symcrypt-bindgen/src/main.rs index e04efa3c..03ca1e0c 100644 --- a/symcrypt-bindgen/src/main.rs +++ b/symcrypt-bindgen/src/main.rs @@ -133,7 +133,7 @@ fn main() { .write_to_file(&bindings_file) .expect("Couldn't write bindings!"); - fix_bindings_for_windows(triple, &bindings_file); + fix_bindings_for_windows(&bindings_file); } fn get_parent_n(path: &Path, n: usize) -> PathBuf { @@ -164,32 +164,29 @@ fn get_rust_version_from_cargo_metadata() -> String { } #[allow(clippy::collapsible_if)] -fn fix_bindings_for_windows(triple: &str, bindings_file: &str) { - if triple.contains("windows") { - println!("Fixing bindings for Windows"); - let link_str = "#[link(name = \"symcrypt\", kind = \"dylib\")]"; - let regex_exp1 = regex::Regex::new(r"pub static \w+: \[SYMCRYPT_OID; \d+usize\];").unwrap(); - let regex_exp2 = regex::Regex::new(r"pub static \w+: PCSYMCRYPT_\w+;").unwrap(); - let bindings_content = - std::fs::read_to_string(bindings_file).expect("Unable to read bindings file"); - - let mut out_content = Vec::new(); - let lines: Vec<&str> = bindings_content.lines().collect(); - out_content.push(lines[0]); - - for i in 1..lines.len() { - if lines[i - 1].contains("extern \"C\" {") { - if regex_exp1.is_match(lines[i]) || regex_exp2.is_match(lines[i]) { - out_content.pop(); - out_content.push(link_str); - out_content.push(lines[i - 1]); - } +fn fix_bindings_for_windows(bindings_file: &str) { + println!("Fixing bindings for Windows"); + let link_str = r#"#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))]"#; + let regex_exp1 = regex::Regex::new(r"pub static \w+: \[SYMCRYPT_OID; \d+usize\];").unwrap(); + let regex_exp2 = regex::Regex::new(r"pub static \w+: PCSYMCRYPT_\w+;").unwrap(); + let bindings_content = + std::fs::read_to_string(bindings_file).expect("Unable to read bindings file"); + + let mut out_content = Vec::new(); + let lines: Vec<&str> = bindings_content.lines().collect(); + out_content.push(lines[0]); + + for i in 1..lines.len() { + if lines[i - 1].contains("extern \"C\" {") { + if regex_exp1.is_match(lines[i]) || regex_exp2.is_match(lines[i]) { + out_content.pop(); + out_content.push(link_str); + out_content.push(lines[i - 1]); } - out_content.push(lines[i]); } - - out_content.push(""); // Add an empty line at the end - std::fs::write(bindings_file, out_content.join("\n")) - .expect("Unable to write bindings file"); + out_content.push(lines[i]); } + + out_content.push(""); // Add an empty line at the end + std::fs::write(bindings_file, out_content.join("\n")).expect("Unable to write bindings file"); } diff --git a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs index 8d636dd3..da1ba5d8 100644 --- a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs @@ -274,35 +274,35 @@ impl Default for _SYMCRYPT_OID { } pub type SYMCRYPT_OID = _SYMCRYPT_OID; pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } @@ -1051,7 +1051,7 @@ extern "C" { extern "C" { pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH; } @@ -1070,7 +1070,7 @@ extern "C" { extern "C" { pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH; } @@ -1089,7 +1089,7 @@ extern "C" { extern "C" { pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH; } @@ -1108,7 +1108,7 @@ extern "C" { extern "C" { pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH; } @@ -1127,7 +1127,7 @@ extern "C" { extern "C" { pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH; } @@ -1149,7 +1149,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_256_STATE, ); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH; } @@ -1171,7 +1171,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_384_STATE, ); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH; } @@ -1193,7 +1193,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_512_STATE, ); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH; } @@ -1231,7 +1231,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC; } @@ -1273,7 +1273,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC; } @@ -1315,7 +1315,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC; } @@ -1357,7 +1357,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC; } @@ -1399,7 +1399,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC; } @@ -1458,7 +1458,7 @@ extern "C" { cbData: SIZE_T, ); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER; } @@ -1830,19 +1830,19 @@ extern "C" { extern "C" { pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS; } diff --git a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs index 9b345d0d..2b9502b1 100644 --- a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs @@ -273,27 +273,35 @@ impl Default for _SYMCRYPT_OID { } pub type SYMCRYPT_OID = _SYMCRYPT_OID; pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } @@ -1042,6 +1050,7 @@ extern "C" { extern "C" { pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH; } @@ -1060,6 +1069,7 @@ extern "C" { extern "C" { pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH; } @@ -1078,6 +1088,7 @@ extern "C" { extern "C" { pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH; } @@ -1096,6 +1107,7 @@ extern "C" { extern "C" { pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH; } @@ -1114,6 +1126,7 @@ extern "C" { extern "C" { pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH; } @@ -1135,6 +1148,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_256_STATE, ); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH; } @@ -1156,6 +1170,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_384_STATE, ); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH; } @@ -1177,6 +1192,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_512_STATE, ); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH; } @@ -1214,6 +1230,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC; } @@ -1255,6 +1272,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC; } @@ -1296,6 +1314,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC; } @@ -1337,6 +1356,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC; } @@ -1378,6 +1398,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC; } @@ -1436,6 +1457,7 @@ extern "C" { cbData: SIZE_T, ); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER; } @@ -1807,15 +1829,19 @@ extern "C" { extern "C" { pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS; } diff --git a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs index 8d636dd3..da1ba5d8 100644 --- a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs @@ -274,35 +274,35 @@ impl Default for _SYMCRYPT_OID { } pub type SYMCRYPT_OID = _SYMCRYPT_OID; pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } @@ -1051,7 +1051,7 @@ extern "C" { extern "C" { pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH; } @@ -1070,7 +1070,7 @@ extern "C" { extern "C" { pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH; } @@ -1089,7 +1089,7 @@ extern "C" { extern "C" { pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH; } @@ -1108,7 +1108,7 @@ extern "C" { extern "C" { pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH; } @@ -1127,7 +1127,7 @@ extern "C" { extern "C" { pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH; } @@ -1149,7 +1149,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_256_STATE, ); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH; } @@ -1171,7 +1171,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_384_STATE, ); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH; } @@ -1193,7 +1193,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_512_STATE, ); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH; } @@ -1231,7 +1231,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC; } @@ -1273,7 +1273,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC; } @@ -1315,7 +1315,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC; } @@ -1357,7 +1357,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC; } @@ -1399,7 +1399,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC; } @@ -1458,7 +1458,7 @@ extern "C" { cbData: SIZE_T, ); } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER; } @@ -1830,19 +1830,19 @@ extern "C" { extern "C" { pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS; } -#[link(name = "symcrypt", kind = "dylib")] +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS; } diff --git a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs index 9b345d0d..2b9502b1 100644 --- a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs @@ -273,27 +273,35 @@ impl Default for _SYMCRYPT_OID { } pub type SYMCRYPT_OID = _SYMCRYPT_OID; pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } @@ -1042,6 +1050,7 @@ extern "C" { extern "C" { pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH; } @@ -1060,6 +1069,7 @@ extern "C" { extern "C" { pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH; } @@ -1078,6 +1088,7 @@ extern "C" { extern "C" { pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH; } @@ -1096,6 +1107,7 @@ extern "C" { extern "C" { pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH; } @@ -1114,6 +1126,7 @@ extern "C" { extern "C" { pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH; } @@ -1135,6 +1148,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_256_STATE, ); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH; } @@ -1156,6 +1170,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_384_STATE, ); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH; } @@ -1177,6 +1192,7 @@ extern "C" { pDst: PSYMCRYPT_SHA3_512_STATE, ); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH; } @@ -1214,6 +1230,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC; } @@ -1255,6 +1272,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC; } @@ -1296,6 +1314,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC; } @@ -1337,6 +1356,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC; } @@ -1378,6 +1398,7 @@ extern "C" { extern "C" { pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC; } @@ -1436,6 +1457,7 @@ extern "C" { cbData: SIZE_T, ); } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER; } @@ -1807,15 +1829,19 @@ extern "C" { extern "C" { pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS; } +#[cfg_attr(target_os = "windows", link(name = "symcrypt", kind = "dylib"))] extern "C" { pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS; } From b2d28ae7d7aa23388cb30f597b579daedc01980c Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 11:21:38 +0100 Subject: [PATCH 10/11] remove jitterenropy submodule --- jitterentropy-sys2/jitterentropy | 1 - 1 file changed, 1 deletion(-) delete mode 160000 jitterentropy-sys2/jitterentropy diff --git a/jitterentropy-sys2/jitterentropy b/jitterentropy-sys2/jitterentropy deleted file mode 160000 index 16c9e5c9..00000000 --- a/jitterentropy-sys2/jitterentropy +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 16c9e5c93e614f0df25f1cb30d0730102e6f4e41 From 2cb863fc3b8c004b6a1d336a04405811c1073aa2 Mon Sep 17 00:00:00 2001 From: Vaiz <4908982+Vaiz@users.noreply.github.com> Date: Mon, 3 Feb 2025 11:23:06 +0100 Subject: [PATCH 11/11] clippy fixes --- symcrypt-bindgen/src/main.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/symcrypt-bindgen/src/main.rs b/symcrypt-bindgen/src/main.rs index 03ca1e0c..3b742013 100644 --- a/symcrypt-bindgen/src/main.rs +++ b/symcrypt-bindgen/src/main.rs @@ -111,8 +111,8 @@ fn main() { // Opaque types builder = builder - .opaque_type(format!("_SYMCRYPT_.*_STATE")) - .opaque_type(format!("_SYMCRYPT_.*_EXPANDED_KEY")) + .opaque_type("_SYMCRYPT_.*_STATE") + .opaque_type("_SYMCRYPT_.*_EXPANDED_KEY") .opaque_type("_SYMCRYPT_BLOCKCIPHER") .opaque_type("_SYMCRYPT_ECURVE") .opaque_type("_SYMCRYPT_ECURVE_PARAMS")