1pub const SYMCRYPT_CODE_VERSION_API: u32 = 103;
4pub const SYMCRYPT_CODE_VERSION_MINOR: u32 = 4;
5pub const SYMCRYPT_CODE_VERSION_PATCH: u32 = 2;
6pub const SYMCRYPT_MD5_RESULT_SIZE: u32 = 16;
7pub const SYMCRYPT_SHA1_RESULT_SIZE: u32 = 20;
8pub const SYMCRYPT_SHA256_RESULT_SIZE: u32 = 32;
9pub const SYMCRYPT_SHA384_RESULT_SIZE: u32 = 48;
10pub const SYMCRYPT_SHA512_RESULT_SIZE: u32 = 64;
11pub const SYMCRYPT_SHA3_256_RESULT_SIZE: u32 = 32;
12pub const SYMCRYPT_SHA3_384_RESULT_SIZE: u32 = 48;
13pub const SYMCRYPT_SHA3_512_RESULT_SIZE: u32 = 64;
14pub const SYMCRYPT_AES_BLOCK_SIZE: u32 = 16;
15pub const SYMCRYPT_FLAG_ECKEY_ECDSA: u32 = 4096;
16pub const SYMCRYPT_FLAG_ECKEY_ECDH: u32 = 8192;
17pub const SYMCRYPT_FLAG_RSAKEY_SIGN: u32 = 4096;
18pub const SYMCRYPT_FLAG_RSAKEY_ENCRYPT: u32 = 8192;
19pub const SYMCRYPT_FLAG_RSA_PKCS1_NO_ASN1: u32 = 1;
20pub const SYMCRYPT_FLAG_RSA_PKCS1_OPTIONAL_HASH_OID: u32 = 2;
21pub const SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR: SYMCRYPT_ERROR = 0;
22pub const SYMCRYPT_ERROR_SYMCRYPT_UNUSED: SYMCRYPT_ERROR = 32768;
23pub const SYMCRYPT_ERROR_SYMCRYPT_WRONG_KEY_SIZE: SYMCRYPT_ERROR = 32769;
24pub const SYMCRYPT_ERROR_SYMCRYPT_WRONG_BLOCK_SIZE: SYMCRYPT_ERROR = 32770;
25pub const SYMCRYPT_ERROR_SYMCRYPT_WRONG_DATA_SIZE: SYMCRYPT_ERROR = 32771;
26pub const SYMCRYPT_ERROR_SYMCRYPT_WRONG_NONCE_SIZE: SYMCRYPT_ERROR = 32772;
27pub const SYMCRYPT_ERROR_SYMCRYPT_WRONG_TAG_SIZE: SYMCRYPT_ERROR = 32773;
28pub const SYMCRYPT_ERROR_SYMCRYPT_WRONG_ITERATION_COUNT: SYMCRYPT_ERROR = 32774;
29pub const SYMCRYPT_ERROR_SYMCRYPT_AUTHENTICATION_FAILURE: SYMCRYPT_ERROR = 32775;
30pub const SYMCRYPT_ERROR_SYMCRYPT_EXTERNAL_FAILURE: SYMCRYPT_ERROR = 32776;
31pub const SYMCRYPT_ERROR_SYMCRYPT_FIPS_FAILURE: SYMCRYPT_ERROR = 32777;
32pub const SYMCRYPT_ERROR_SYMCRYPT_HARDWARE_FAILURE: SYMCRYPT_ERROR = 32778;
33pub const SYMCRYPT_ERROR_SYMCRYPT_NOT_IMPLEMENTED: SYMCRYPT_ERROR = 32779;
34pub const SYMCRYPT_ERROR_SYMCRYPT_INVALID_BLOB: SYMCRYPT_ERROR = 32780;
35pub const SYMCRYPT_ERROR_SYMCRYPT_BUFFER_TOO_SMALL: SYMCRYPT_ERROR = 32781;
36pub const SYMCRYPT_ERROR_SYMCRYPT_INVALID_ARGUMENT: SYMCRYPT_ERROR = 32782;
37pub const SYMCRYPT_ERROR_SYMCRYPT_MEMORY_ALLOCATION_FAILURE: SYMCRYPT_ERROR = 32783;
38pub const SYMCRYPT_ERROR_SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE: SYMCRYPT_ERROR = 32784;
39pub const SYMCRYPT_ERROR_SYMCRYPT_INCOMPATIBLE_FORMAT: SYMCRYPT_ERROR = 32785;
40pub const SYMCRYPT_ERROR_SYMCRYPT_VALUE_TOO_LARGE: SYMCRYPT_ERROR = 32786;
41pub const SYMCRYPT_ERROR_SYMCRYPT_SESSION_REPLAY_FAILURE: SYMCRYPT_ERROR = 32787;
42pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_NO_OTS_KEYS_LEFT: SYMCRYPT_ERROR = 32788;
43pub const SYMCRYPT_ERROR_SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH: SYMCRYPT_ERROR = 32789;
44pub type SYMCRYPT_ERROR = ::std::os::raw::c_uint;
45pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_NULL: _SYMCRYPT_ECURVE_TYPE = 0;
46pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS: _SYMCRYPT_ECURVE_TYPE = 1;
47pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS: _SYMCRYPT_ECURVE_TYPE = 2;
48pub const _SYMCRYPT_ECURVE_TYPE_SYMCRYPT_ECURVE_TYPE_MONTGOMERY: _SYMCRYPT_ECURVE_TYPE = 3;
49pub type _SYMCRYPT_ECURVE_TYPE = ::std::os::raw::c_uint;
50pub use self::_SYMCRYPT_ECURVE_TYPE as SYMCRYPT_ECURVE_TYPE;
51pub type BYTE = u8;
52pub type SIZE_T = usize;
53pub type UINT8 = u8;
54pub type UINT32 = u32;
55pub type UINT64 = u64;
56pub type PUINT64 = *mut u64;
57pub type PBYTE = *mut BYTE;
58pub type PCBYTE = *const BYTE;
59pub type PCUINT32 = *const UINT32;
60pub type PCUINT64 = *const UINT64;
61pub type PVOID = *mut ::std::os::raw::c_void;
62pub type PCVOID = *const ::std::os::raw::c_void;
63pub type BOOLEAN = BYTE;
64pub type __m128i = [::std::os::raw::c_longlong; 2usize];
65pub type SYMCRYPT_BLOCKCIPHER = _SYMCRYPT_BLOCKCIPHER;
66pub type PCSYMCRYPT_BLOCKCIPHER = *const SYMCRYPT_BLOCKCIPHER;
67#[repr(C)]
68#[repr(align(16))]
69#[derive(Debug, Copy, Clone)]
70pub struct _SYMCRYPT_MD2_CHAINING_STATE {
71 pub C: [BYTE; 16usize],
72 pub X: [BYTE; 48usize],
73}
74#[test]
75fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() {
76 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> =
77 ::std::mem::MaybeUninit::uninit();
78 let ptr = UNINIT.as_ptr();
79 assert_eq!(
80 ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(),
81 64usize,
82 concat!("Size of: ", stringify!(_SYMCRYPT_MD2_CHAINING_STATE))
83 );
84 assert_eq!(
85 ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(),
86 16usize,
87 concat!("Alignment of ", stringify!(_SYMCRYPT_MD2_CHAINING_STATE))
88 );
89 assert_eq!(
90 unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize },
91 0usize,
92 concat!(
93 "Offset of field: ",
94 stringify!(_SYMCRYPT_MD2_CHAINING_STATE),
95 "::",
96 stringify!(C)
97 )
98 );
99 assert_eq!(
100 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
101 16usize,
102 concat!(
103 "Offset of field: ",
104 stringify!(_SYMCRYPT_MD2_CHAINING_STATE),
105 "::",
106 stringify!(X)
107 )
108 );
109}
110impl Default for _SYMCRYPT_MD2_CHAINING_STATE {
111 fn default() -> Self {
112 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
113 unsafe {
114 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
115 s.assume_init()
116 }
117 }
118}
119pub type SYMCRYPT_MD2_CHAINING_STATE = _SYMCRYPT_MD2_CHAINING_STATE;
120#[repr(C)]
121#[repr(align(16))]
122#[derive(Debug, Copy, Clone)]
123pub struct _SYMCRYPT_MD2_STATE {
124 pub bytesInBuffer: UINT32,
125 pub magic: SIZE_T,
126 pub dataLengthL: UINT64,
127 pub dataLengthH: UINT64,
128 pub buffer: [BYTE; 16usize],
129 pub chain: SYMCRYPT_MD2_CHAINING_STATE,
130}
131#[test]
132fn bindgen_test_layout__SYMCRYPT_MD2_STATE() {
133 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit();
134 let ptr = UNINIT.as_ptr();
135 assert_eq!(
136 ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(),
137 112usize,
138 concat!("Size of: ", stringify!(_SYMCRYPT_MD2_STATE))
139 );
140 assert_eq!(
141 ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(),
142 16usize,
143 concat!("Alignment of ", stringify!(_SYMCRYPT_MD2_STATE))
144 );
145 assert_eq!(
146 unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize },
147 0usize,
148 concat!(
149 "Offset of field: ",
150 stringify!(_SYMCRYPT_MD2_STATE),
151 "::",
152 stringify!(bytesInBuffer)
153 )
154 );
155 assert_eq!(
156 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
157 8usize,
158 concat!(
159 "Offset of field: ",
160 stringify!(_SYMCRYPT_MD2_STATE),
161 "::",
162 stringify!(magic)
163 )
164 );
165 assert_eq!(
166 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize },
167 16usize,
168 concat!(
169 "Offset of field: ",
170 stringify!(_SYMCRYPT_MD2_STATE),
171 "::",
172 stringify!(dataLengthL)
173 )
174 );
175 assert_eq!(
176 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize },
177 24usize,
178 concat!(
179 "Offset of field: ",
180 stringify!(_SYMCRYPT_MD2_STATE),
181 "::",
182 stringify!(dataLengthH)
183 )
184 );
185 assert_eq!(
186 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
187 32usize,
188 concat!(
189 "Offset of field: ",
190 stringify!(_SYMCRYPT_MD2_STATE),
191 "::",
192 stringify!(buffer)
193 )
194 );
195 assert_eq!(
196 unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize },
197 48usize,
198 concat!(
199 "Offset of field: ",
200 stringify!(_SYMCRYPT_MD2_STATE),
201 "::",
202 stringify!(chain)
203 )
204 );
205}
206impl Default for _SYMCRYPT_MD2_STATE {
207 fn default() -> Self {
208 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
209 unsafe {
210 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
211 s.assume_init()
212 }
213 }
214}
215pub type SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE;
216#[repr(C)]
217#[repr(align(16))]
218#[derive(Debug, Default, Copy, Clone)]
219pub struct _SYMCRYPT_MD4_CHAINING_STATE {
220 pub H: [UINT32; 4usize],
221}
222#[test]
223fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() {
224 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> =
225 ::std::mem::MaybeUninit::uninit();
226 let ptr = UNINIT.as_ptr();
227 assert_eq!(
228 ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(),
229 16usize,
230 concat!("Size of: ", stringify!(_SYMCRYPT_MD4_CHAINING_STATE))
231 );
232 assert_eq!(
233 ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(),
234 16usize,
235 concat!("Alignment of ", stringify!(_SYMCRYPT_MD4_CHAINING_STATE))
236 );
237 assert_eq!(
238 unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize },
239 0usize,
240 concat!(
241 "Offset of field: ",
242 stringify!(_SYMCRYPT_MD4_CHAINING_STATE),
243 "::",
244 stringify!(H)
245 )
246 );
247}
248pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE;
249#[repr(C)]
250#[repr(align(16))]
251#[derive(Debug, Copy, Clone)]
252pub struct _SYMCRYPT_MD4_STATE {
253 pub bytesInBuffer: UINT32,
254 pub magic: SIZE_T,
255 pub dataLengthL: UINT64,
256 pub dataLengthH: UINT64,
257 pub buffer: [BYTE; 64usize],
258 pub chain: SYMCRYPT_MD4_CHAINING_STATE,
259}
260#[test]
261fn bindgen_test_layout__SYMCRYPT_MD4_STATE() {
262 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit();
263 let ptr = UNINIT.as_ptr();
264 assert_eq!(
265 ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(),
266 112usize,
267 concat!("Size of: ", stringify!(_SYMCRYPT_MD4_STATE))
268 );
269 assert_eq!(
270 ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(),
271 16usize,
272 concat!("Alignment of ", stringify!(_SYMCRYPT_MD4_STATE))
273 );
274 assert_eq!(
275 unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize },
276 0usize,
277 concat!(
278 "Offset of field: ",
279 stringify!(_SYMCRYPT_MD4_STATE),
280 "::",
281 stringify!(bytesInBuffer)
282 )
283 );
284 assert_eq!(
285 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
286 8usize,
287 concat!(
288 "Offset of field: ",
289 stringify!(_SYMCRYPT_MD4_STATE),
290 "::",
291 stringify!(magic)
292 )
293 );
294 assert_eq!(
295 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize },
296 16usize,
297 concat!(
298 "Offset of field: ",
299 stringify!(_SYMCRYPT_MD4_STATE),
300 "::",
301 stringify!(dataLengthL)
302 )
303 );
304 assert_eq!(
305 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize },
306 24usize,
307 concat!(
308 "Offset of field: ",
309 stringify!(_SYMCRYPT_MD4_STATE),
310 "::",
311 stringify!(dataLengthH)
312 )
313 );
314 assert_eq!(
315 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
316 32usize,
317 concat!(
318 "Offset of field: ",
319 stringify!(_SYMCRYPT_MD4_STATE),
320 "::",
321 stringify!(buffer)
322 )
323 );
324 assert_eq!(
325 unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize },
326 96usize,
327 concat!(
328 "Offset of field: ",
329 stringify!(_SYMCRYPT_MD4_STATE),
330 "::",
331 stringify!(chain)
332 )
333 );
334}
335impl Default for _SYMCRYPT_MD4_STATE {
336 fn default() -> Self {
337 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
338 unsafe {
339 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
340 s.assume_init()
341 }
342 }
343}
344pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE;
345#[repr(C)]
346#[repr(align(16))]
347#[derive(Debug, Default, Copy, Clone)]
348pub struct _SYMCRYPT_MD5_CHAINING_STATE {
349 pub H: [UINT32; 4usize],
350}
351#[test]
352fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() {
353 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> =
354 ::std::mem::MaybeUninit::uninit();
355 let ptr = UNINIT.as_ptr();
356 assert_eq!(
357 ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(),
358 16usize,
359 concat!("Size of: ", stringify!(_SYMCRYPT_MD5_CHAINING_STATE))
360 );
361 assert_eq!(
362 ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(),
363 16usize,
364 concat!("Alignment of ", stringify!(_SYMCRYPT_MD5_CHAINING_STATE))
365 );
366 assert_eq!(
367 unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize },
368 0usize,
369 concat!(
370 "Offset of field: ",
371 stringify!(_SYMCRYPT_MD5_CHAINING_STATE),
372 "::",
373 stringify!(H)
374 )
375 );
376}
377pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE;
378#[repr(C)]
379#[repr(align(16))]
380#[derive(Debug, Copy, Clone)]
381pub struct _SYMCRYPT_MD5_STATE {
382 pub bytesInBuffer: UINT32,
383 pub magic: SIZE_T,
384 pub dataLengthL: UINT64,
385 pub dataLengthH: UINT64,
386 pub buffer: [BYTE; 64usize],
387 pub chain: SYMCRYPT_MD5_CHAINING_STATE,
388}
389#[test]
390fn bindgen_test_layout__SYMCRYPT_MD5_STATE() {
391 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit();
392 let ptr = UNINIT.as_ptr();
393 assert_eq!(
394 ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(),
395 112usize,
396 concat!("Size of: ", stringify!(_SYMCRYPT_MD5_STATE))
397 );
398 assert_eq!(
399 ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(),
400 16usize,
401 concat!("Alignment of ", stringify!(_SYMCRYPT_MD5_STATE))
402 );
403 assert_eq!(
404 unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize },
405 0usize,
406 concat!(
407 "Offset of field: ",
408 stringify!(_SYMCRYPT_MD5_STATE),
409 "::",
410 stringify!(bytesInBuffer)
411 )
412 );
413 assert_eq!(
414 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
415 8usize,
416 concat!(
417 "Offset of field: ",
418 stringify!(_SYMCRYPT_MD5_STATE),
419 "::",
420 stringify!(magic)
421 )
422 );
423 assert_eq!(
424 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize },
425 16usize,
426 concat!(
427 "Offset of field: ",
428 stringify!(_SYMCRYPT_MD5_STATE),
429 "::",
430 stringify!(dataLengthL)
431 )
432 );
433 assert_eq!(
434 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize },
435 24usize,
436 concat!(
437 "Offset of field: ",
438 stringify!(_SYMCRYPT_MD5_STATE),
439 "::",
440 stringify!(dataLengthH)
441 )
442 );
443 assert_eq!(
444 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
445 32usize,
446 concat!(
447 "Offset of field: ",
448 stringify!(_SYMCRYPT_MD5_STATE),
449 "::",
450 stringify!(buffer)
451 )
452 );
453 assert_eq!(
454 unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize },
455 96usize,
456 concat!(
457 "Offset of field: ",
458 stringify!(_SYMCRYPT_MD5_STATE),
459 "::",
460 stringify!(chain)
461 )
462 );
463}
464impl Default for _SYMCRYPT_MD5_STATE {
465 fn default() -> Self {
466 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
467 unsafe {
468 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
469 s.assume_init()
470 }
471 }
472}
473pub type SYMCRYPT_MD5_STATE = _SYMCRYPT_MD5_STATE;
474pub type PSYMCRYPT_MD5_STATE = *mut _SYMCRYPT_MD5_STATE;
475pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE;
476#[repr(C)]
477#[repr(align(16))]
478#[derive(Debug, Default, Copy, Clone)]
479pub struct _SYMCRYPT_SHA1_CHAINING_STATE {
480 pub H: [UINT32; 5usize],
481}
482#[test]
483fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() {
484 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> =
485 ::std::mem::MaybeUninit::uninit();
486 let ptr = UNINIT.as_ptr();
487 assert_eq!(
488 ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(),
489 32usize,
490 concat!("Size of: ", stringify!(_SYMCRYPT_SHA1_CHAINING_STATE))
491 );
492 assert_eq!(
493 ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(),
494 16usize,
495 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA1_CHAINING_STATE))
496 );
497 assert_eq!(
498 unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize },
499 0usize,
500 concat!(
501 "Offset of field: ",
502 stringify!(_SYMCRYPT_SHA1_CHAINING_STATE),
503 "::",
504 stringify!(H)
505 )
506 );
507}
508pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE;
509#[repr(C)]
510#[repr(align(16))]
511#[derive(Debug, Copy, Clone)]
512pub struct _SYMCRYPT_SHA1_STATE {
513 pub bytesInBuffer: UINT32,
514 pub magic: SIZE_T,
515 pub dataLengthL: UINT64,
516 pub dataLengthH: UINT64,
517 pub buffer: [BYTE; 64usize],
518 pub chain: SYMCRYPT_SHA1_CHAINING_STATE,
519}
520#[test]
521fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() {
522 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit();
523 let ptr = UNINIT.as_ptr();
524 assert_eq!(
525 ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(),
526 128usize,
527 concat!("Size of: ", stringify!(_SYMCRYPT_SHA1_STATE))
528 );
529 assert_eq!(
530 ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(),
531 16usize,
532 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA1_STATE))
533 );
534 assert_eq!(
535 unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize },
536 0usize,
537 concat!(
538 "Offset of field: ",
539 stringify!(_SYMCRYPT_SHA1_STATE),
540 "::",
541 stringify!(bytesInBuffer)
542 )
543 );
544 assert_eq!(
545 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
546 8usize,
547 concat!(
548 "Offset of field: ",
549 stringify!(_SYMCRYPT_SHA1_STATE),
550 "::",
551 stringify!(magic)
552 )
553 );
554 assert_eq!(
555 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize },
556 16usize,
557 concat!(
558 "Offset of field: ",
559 stringify!(_SYMCRYPT_SHA1_STATE),
560 "::",
561 stringify!(dataLengthL)
562 )
563 );
564 assert_eq!(
565 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize },
566 24usize,
567 concat!(
568 "Offset of field: ",
569 stringify!(_SYMCRYPT_SHA1_STATE),
570 "::",
571 stringify!(dataLengthH)
572 )
573 );
574 assert_eq!(
575 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
576 32usize,
577 concat!(
578 "Offset of field: ",
579 stringify!(_SYMCRYPT_SHA1_STATE),
580 "::",
581 stringify!(buffer)
582 )
583 );
584 assert_eq!(
585 unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize },
586 96usize,
587 concat!(
588 "Offset of field: ",
589 stringify!(_SYMCRYPT_SHA1_STATE),
590 "::",
591 stringify!(chain)
592 )
593 );
594}
595impl Default for _SYMCRYPT_SHA1_STATE {
596 fn default() -> Self {
597 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
598 unsafe {
599 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
600 s.assume_init()
601 }
602 }
603}
604pub type SYMCRYPT_SHA1_STATE = _SYMCRYPT_SHA1_STATE;
605pub type PSYMCRYPT_SHA1_STATE = *mut _SYMCRYPT_SHA1_STATE;
606pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE;
607#[repr(C)]
608#[repr(align(16))]
609#[derive(Debug, Default, Copy, Clone)]
610pub struct _SYMCRYPT_SHA256_CHAINING_STATE {
611 pub H: [UINT32; 8usize],
612}
613#[test]
614fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() {
615 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> =
616 ::std::mem::MaybeUninit::uninit();
617 let ptr = UNINIT.as_ptr();
618 assert_eq!(
619 ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(),
620 32usize,
621 concat!("Size of: ", stringify!(_SYMCRYPT_SHA256_CHAINING_STATE))
622 );
623 assert_eq!(
624 ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(),
625 16usize,
626 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA256_CHAINING_STATE))
627 );
628 assert_eq!(
629 unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize },
630 0usize,
631 concat!(
632 "Offset of field: ",
633 stringify!(_SYMCRYPT_SHA256_CHAINING_STATE),
634 "::",
635 stringify!(H)
636 )
637 );
638}
639pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE;
640#[repr(C)]
641#[repr(align(16))]
642#[derive(Debug, Copy, Clone)]
643pub struct _SYMCRYPT_SHA256_STATE {
644 pub bytesInBuffer: UINT32,
645 pub magic: SIZE_T,
646 pub dataLengthL: UINT64,
647 pub dataLengthH: UINT64,
648 pub buffer: [BYTE; 64usize],
649 pub chain: SYMCRYPT_SHA256_CHAINING_STATE,
650}
651#[test]
652fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() {
653 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> =
654 ::std::mem::MaybeUninit::uninit();
655 let ptr = UNINIT.as_ptr();
656 assert_eq!(
657 ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(),
658 128usize,
659 concat!("Size of: ", stringify!(_SYMCRYPT_SHA256_STATE))
660 );
661 assert_eq!(
662 ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(),
663 16usize,
664 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA256_STATE))
665 );
666 assert_eq!(
667 unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize },
668 0usize,
669 concat!(
670 "Offset of field: ",
671 stringify!(_SYMCRYPT_SHA256_STATE),
672 "::",
673 stringify!(bytesInBuffer)
674 )
675 );
676 assert_eq!(
677 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
678 8usize,
679 concat!(
680 "Offset of field: ",
681 stringify!(_SYMCRYPT_SHA256_STATE),
682 "::",
683 stringify!(magic)
684 )
685 );
686 assert_eq!(
687 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize },
688 16usize,
689 concat!(
690 "Offset of field: ",
691 stringify!(_SYMCRYPT_SHA256_STATE),
692 "::",
693 stringify!(dataLengthL)
694 )
695 );
696 assert_eq!(
697 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize },
698 24usize,
699 concat!(
700 "Offset of field: ",
701 stringify!(_SYMCRYPT_SHA256_STATE),
702 "::",
703 stringify!(dataLengthH)
704 )
705 );
706 assert_eq!(
707 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
708 32usize,
709 concat!(
710 "Offset of field: ",
711 stringify!(_SYMCRYPT_SHA256_STATE),
712 "::",
713 stringify!(buffer)
714 )
715 );
716 assert_eq!(
717 unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize },
718 96usize,
719 concat!(
720 "Offset of field: ",
721 stringify!(_SYMCRYPT_SHA256_STATE),
722 "::",
723 stringify!(chain)
724 )
725 );
726}
727impl Default for _SYMCRYPT_SHA256_STATE {
728 fn default() -> Self {
729 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
730 unsafe {
731 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
732 s.assume_init()
733 }
734 }
735}
736pub type SYMCRYPT_SHA256_STATE = _SYMCRYPT_SHA256_STATE;
737pub type PSYMCRYPT_SHA256_STATE = *mut _SYMCRYPT_SHA256_STATE;
738pub type PCSYMCRYPT_SHA256_STATE = *const SYMCRYPT_SHA256_STATE;
739#[repr(C)]
740#[repr(align(16))]
741#[derive(Debug, Default, Copy, Clone)]
742pub struct _SYMCRYPT_SHA512_CHAINING_STATE {
743 pub H: [UINT64; 8usize],
744}
745#[test]
746fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() {
747 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> =
748 ::std::mem::MaybeUninit::uninit();
749 let ptr = UNINIT.as_ptr();
750 assert_eq!(
751 ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(),
752 64usize,
753 concat!("Size of: ", stringify!(_SYMCRYPT_SHA512_CHAINING_STATE))
754 );
755 assert_eq!(
756 ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(),
757 16usize,
758 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA512_CHAINING_STATE))
759 );
760 assert_eq!(
761 unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize },
762 0usize,
763 concat!(
764 "Offset of field: ",
765 stringify!(_SYMCRYPT_SHA512_CHAINING_STATE),
766 "::",
767 stringify!(H)
768 )
769 );
770}
771pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE;
772#[repr(C)]
773#[repr(align(16))]
774#[derive(Debug, Copy, Clone)]
775pub struct _SYMCRYPT_SHA512_STATE {
776 pub bytesInBuffer: UINT32,
777 pub magic: SIZE_T,
778 pub dataLengthL: UINT64,
779 pub dataLengthH: UINT64,
780 pub buffer: [BYTE; 128usize],
781 pub chain: SYMCRYPT_SHA512_CHAINING_STATE,
782}
783#[test]
784fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() {
785 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> =
786 ::std::mem::MaybeUninit::uninit();
787 let ptr = UNINIT.as_ptr();
788 assert_eq!(
789 ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(),
790 224usize,
791 concat!("Size of: ", stringify!(_SYMCRYPT_SHA512_STATE))
792 );
793 assert_eq!(
794 ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(),
795 16usize,
796 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA512_STATE))
797 );
798 assert_eq!(
799 unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize },
800 0usize,
801 concat!(
802 "Offset of field: ",
803 stringify!(_SYMCRYPT_SHA512_STATE),
804 "::",
805 stringify!(bytesInBuffer)
806 )
807 );
808 assert_eq!(
809 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
810 8usize,
811 concat!(
812 "Offset of field: ",
813 stringify!(_SYMCRYPT_SHA512_STATE),
814 "::",
815 stringify!(magic)
816 )
817 );
818 assert_eq!(
819 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize },
820 16usize,
821 concat!(
822 "Offset of field: ",
823 stringify!(_SYMCRYPT_SHA512_STATE),
824 "::",
825 stringify!(dataLengthL)
826 )
827 );
828 assert_eq!(
829 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize },
830 24usize,
831 concat!(
832 "Offset of field: ",
833 stringify!(_SYMCRYPT_SHA512_STATE),
834 "::",
835 stringify!(dataLengthH)
836 )
837 );
838 assert_eq!(
839 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
840 32usize,
841 concat!(
842 "Offset of field: ",
843 stringify!(_SYMCRYPT_SHA512_STATE),
844 "::",
845 stringify!(buffer)
846 )
847 );
848 assert_eq!(
849 unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize },
850 160usize,
851 concat!(
852 "Offset of field: ",
853 stringify!(_SYMCRYPT_SHA512_STATE),
854 "::",
855 stringify!(chain)
856 )
857 );
858}
859impl Default for _SYMCRYPT_SHA512_STATE {
860 fn default() -> Self {
861 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
862 unsafe {
863 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
864 s.assume_init()
865 }
866 }
867}
868pub type SYMCRYPT_SHA512_STATE = _SYMCRYPT_SHA512_STATE;
869pub type PSYMCRYPT_SHA512_STATE = *mut _SYMCRYPT_SHA512_STATE;
870pub type PCSYMCRYPT_SHA512_STATE = *const SYMCRYPT_SHA512_STATE;
871#[repr(C)]
872#[repr(align(16))]
873#[derive(Debug, Copy, Clone)]
874pub struct _SYMCRYPT_SHA384_STATE {
875 pub bytesInBuffer: UINT32,
876 pub magic: SIZE_T,
877 pub dataLengthL: UINT64,
878 pub dataLengthH: UINT64,
879 pub buffer: [BYTE; 128usize],
880 pub chain: SYMCRYPT_SHA512_CHAINING_STATE,
881}
882#[test]
883fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() {
884 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> =
885 ::std::mem::MaybeUninit::uninit();
886 let ptr = UNINIT.as_ptr();
887 assert_eq!(
888 ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(),
889 224usize,
890 concat!("Size of: ", stringify!(_SYMCRYPT_SHA384_STATE))
891 );
892 assert_eq!(
893 ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(),
894 16usize,
895 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA384_STATE))
896 );
897 assert_eq!(
898 unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize },
899 0usize,
900 concat!(
901 "Offset of field: ",
902 stringify!(_SYMCRYPT_SHA384_STATE),
903 "::",
904 stringify!(bytesInBuffer)
905 )
906 );
907 assert_eq!(
908 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
909 8usize,
910 concat!(
911 "Offset of field: ",
912 stringify!(_SYMCRYPT_SHA384_STATE),
913 "::",
914 stringify!(magic)
915 )
916 );
917 assert_eq!(
918 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize },
919 16usize,
920 concat!(
921 "Offset of field: ",
922 stringify!(_SYMCRYPT_SHA384_STATE),
923 "::",
924 stringify!(dataLengthL)
925 )
926 );
927 assert_eq!(
928 unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize },
929 24usize,
930 concat!(
931 "Offset of field: ",
932 stringify!(_SYMCRYPT_SHA384_STATE),
933 "::",
934 stringify!(dataLengthH)
935 )
936 );
937 assert_eq!(
938 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
939 32usize,
940 concat!(
941 "Offset of field: ",
942 stringify!(_SYMCRYPT_SHA384_STATE),
943 "::",
944 stringify!(buffer)
945 )
946 );
947 assert_eq!(
948 unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize },
949 160usize,
950 concat!(
951 "Offset of field: ",
952 stringify!(_SYMCRYPT_SHA384_STATE),
953 "::",
954 stringify!(chain)
955 )
956 );
957}
958impl Default for _SYMCRYPT_SHA384_STATE {
959 fn default() -> Self {
960 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
961 unsafe {
962 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
963 s.assume_init()
964 }
965 }
966}
967pub type SYMCRYPT_SHA384_STATE = _SYMCRYPT_SHA384_STATE;
968pub type PSYMCRYPT_SHA384_STATE = *mut _SYMCRYPT_SHA384_STATE;
969pub type PCSYMCRYPT_SHA384_STATE = *const SYMCRYPT_SHA384_STATE;
970#[repr(C)]
971#[repr(align(16))]
972#[derive(Debug, Default, Copy, Clone)]
973pub struct _SYMCRYPT_KECCAK_STATE {
974 pub state: [UINT64; 25usize],
975 pub inputBlockSize: UINT32,
976 pub stateIndex: UINT32,
977 pub paddingValue: UINT8,
978 pub squeezeMode: BOOLEAN,
979}
980#[test]
981fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() {
982 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> =
983 ::std::mem::MaybeUninit::uninit();
984 let ptr = UNINIT.as_ptr();
985 assert_eq!(
986 ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(),
987 224usize,
988 concat!("Size of: ", stringify!(_SYMCRYPT_KECCAK_STATE))
989 );
990 assert_eq!(
991 ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(),
992 16usize,
993 concat!("Alignment of ", stringify!(_SYMCRYPT_KECCAK_STATE))
994 );
995 assert_eq!(
996 unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
997 0usize,
998 concat!(
999 "Offset of field: ",
1000 stringify!(_SYMCRYPT_KECCAK_STATE),
1001 "::",
1002 stringify!(state)
1003 )
1004 );
1005 assert_eq!(
1006 unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize },
1007 200usize,
1008 concat!(
1009 "Offset of field: ",
1010 stringify!(_SYMCRYPT_KECCAK_STATE),
1011 "::",
1012 stringify!(inputBlockSize)
1013 )
1014 );
1015 assert_eq!(
1016 unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize },
1017 204usize,
1018 concat!(
1019 "Offset of field: ",
1020 stringify!(_SYMCRYPT_KECCAK_STATE),
1021 "::",
1022 stringify!(stateIndex)
1023 )
1024 );
1025 assert_eq!(
1026 unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize },
1027 208usize,
1028 concat!(
1029 "Offset of field: ",
1030 stringify!(_SYMCRYPT_KECCAK_STATE),
1031 "::",
1032 stringify!(paddingValue)
1033 )
1034 );
1035 assert_eq!(
1036 unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize },
1037 209usize,
1038 concat!(
1039 "Offset of field: ",
1040 stringify!(_SYMCRYPT_KECCAK_STATE),
1041 "::",
1042 stringify!(squeezeMode)
1043 )
1044 );
1045}
1046pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE;
1047#[repr(C)]
1048#[repr(align(16))]
1049#[derive(Debug, Default, Copy, Clone)]
1050pub struct _SYMCRYPT_SHA3_256_STATE {
1051 pub ks: SYMCRYPT_KECCAK_STATE,
1052 pub magic: SIZE_T,
1053}
1054#[test]
1055fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() {
1056 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> =
1057 ::std::mem::MaybeUninit::uninit();
1058 let ptr = UNINIT.as_ptr();
1059 assert_eq!(
1060 ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(),
1061 240usize,
1062 concat!("Size of: ", stringify!(_SYMCRYPT_SHA3_256_STATE))
1063 );
1064 assert_eq!(
1065 ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(),
1066 16usize,
1067 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA3_256_STATE))
1068 );
1069 assert_eq!(
1070 unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize },
1071 0usize,
1072 concat!(
1073 "Offset of field: ",
1074 stringify!(_SYMCRYPT_SHA3_256_STATE),
1075 "::",
1076 stringify!(ks)
1077 )
1078 );
1079 assert_eq!(
1080 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1081 224usize,
1082 concat!(
1083 "Offset of field: ",
1084 stringify!(_SYMCRYPT_SHA3_256_STATE),
1085 "::",
1086 stringify!(magic)
1087 )
1088 );
1089}
1090pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE;
1091pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE;
1092pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE;
1093#[repr(C)]
1094#[repr(align(16))]
1095#[derive(Debug, Default, Copy, Clone)]
1096pub struct _SYMCRYPT_SHA3_384_STATE {
1097 pub ks: SYMCRYPT_KECCAK_STATE,
1098 pub magic: SIZE_T,
1099}
1100#[test]
1101fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() {
1102 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> =
1103 ::std::mem::MaybeUninit::uninit();
1104 let ptr = UNINIT.as_ptr();
1105 assert_eq!(
1106 ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(),
1107 240usize,
1108 concat!("Size of: ", stringify!(_SYMCRYPT_SHA3_384_STATE))
1109 );
1110 assert_eq!(
1111 ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(),
1112 16usize,
1113 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA3_384_STATE))
1114 );
1115 assert_eq!(
1116 unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize },
1117 0usize,
1118 concat!(
1119 "Offset of field: ",
1120 stringify!(_SYMCRYPT_SHA3_384_STATE),
1121 "::",
1122 stringify!(ks)
1123 )
1124 );
1125 assert_eq!(
1126 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1127 224usize,
1128 concat!(
1129 "Offset of field: ",
1130 stringify!(_SYMCRYPT_SHA3_384_STATE),
1131 "::",
1132 stringify!(magic)
1133 )
1134 );
1135}
1136pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE;
1137pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE;
1138pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE;
1139#[repr(C)]
1140#[repr(align(16))]
1141#[derive(Debug, Default, Copy, Clone)]
1142pub struct _SYMCRYPT_SHA3_512_STATE {
1143 pub ks: SYMCRYPT_KECCAK_STATE,
1144 pub magic: SIZE_T,
1145}
1146#[test]
1147fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() {
1148 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> =
1149 ::std::mem::MaybeUninit::uninit();
1150 let ptr = UNINIT.as_ptr();
1151 assert_eq!(
1152 ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(),
1153 240usize,
1154 concat!("Size of: ", stringify!(_SYMCRYPT_SHA3_512_STATE))
1155 );
1156 assert_eq!(
1157 ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(),
1158 16usize,
1159 concat!("Alignment of ", stringify!(_SYMCRYPT_SHA3_512_STATE))
1160 );
1161 assert_eq!(
1162 unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize },
1163 0usize,
1164 concat!(
1165 "Offset of field: ",
1166 stringify!(_SYMCRYPT_SHA3_512_STATE),
1167 "::",
1168 stringify!(ks)
1169 )
1170 );
1171 assert_eq!(
1172 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1173 224usize,
1174 concat!(
1175 "Offset of field: ",
1176 stringify!(_SYMCRYPT_SHA3_512_STATE),
1177 "::",
1178 stringify!(magic)
1179 )
1180 );
1181}
1182pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE;
1183pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE;
1184pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE;
1185#[repr(C)]
1186#[repr(align(16))]
1187#[derive(Debug, Default, Copy, Clone)]
1188pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY {
1189 pub ks: SYMCRYPT_KECCAK_STATE,
1190 pub magic: SIZE_T,
1191}
1192#[test]
1193fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() {
1194 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> =
1195 ::std::mem::MaybeUninit::uninit();
1196 let ptr = UNINIT.as_ptr();
1197 assert_eq!(
1198 ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(),
1199 240usize,
1200 concat!("Size of: ", stringify!(_SYMCRYPT_KMAC128_EXPANDED_KEY))
1201 );
1202 assert_eq!(
1203 ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(),
1204 16usize,
1205 concat!("Alignment of ", stringify!(_SYMCRYPT_KMAC128_EXPANDED_KEY))
1206 );
1207 assert_eq!(
1208 unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize },
1209 0usize,
1210 concat!(
1211 "Offset of field: ",
1212 stringify!(_SYMCRYPT_KMAC128_EXPANDED_KEY),
1213 "::",
1214 stringify!(ks)
1215 )
1216 );
1217 assert_eq!(
1218 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1219 224usize,
1220 concat!(
1221 "Offset of field: ",
1222 stringify!(_SYMCRYPT_KMAC128_EXPANDED_KEY),
1223 "::",
1224 stringify!(magic)
1225 )
1226 );
1227}
1228pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY;
1229#[repr(C)]
1230#[repr(align(16))]
1231#[derive(Debug, Default, Copy, Clone)]
1232pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY {
1233 pub ks: SYMCRYPT_KECCAK_STATE,
1234 pub magic: SIZE_T,
1235}
1236#[test]
1237fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() {
1238 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> =
1239 ::std::mem::MaybeUninit::uninit();
1240 let ptr = UNINIT.as_ptr();
1241 assert_eq!(
1242 ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(),
1243 240usize,
1244 concat!("Size of: ", stringify!(_SYMCRYPT_KMAC256_EXPANDED_KEY))
1245 );
1246 assert_eq!(
1247 ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(),
1248 16usize,
1249 concat!("Alignment of ", stringify!(_SYMCRYPT_KMAC256_EXPANDED_KEY))
1250 );
1251 assert_eq!(
1252 unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize },
1253 0usize,
1254 concat!(
1255 "Offset of field: ",
1256 stringify!(_SYMCRYPT_KMAC256_EXPANDED_KEY),
1257 "::",
1258 stringify!(ks)
1259 )
1260 );
1261 assert_eq!(
1262 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1263 224usize,
1264 concat!(
1265 "Offset of field: ",
1266 stringify!(_SYMCRYPT_KMAC256_EXPANDED_KEY),
1267 "::",
1268 stringify!(magic)
1269 )
1270 );
1271}
1272pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY;
1273#[repr(C)]
1274#[repr(align(16))]
1275#[derive(Copy, Clone)]
1276pub union _SYMCRYPT_HASH_STATE {
1277 pub md2State: SYMCRYPT_MD2_STATE,
1278 pub md4State: SYMCRYPT_MD4_STATE,
1279 pub md5State: SYMCRYPT_MD5_STATE,
1280 pub sha1State: SYMCRYPT_SHA1_STATE,
1281 pub sha256State: SYMCRYPT_SHA256_STATE,
1282 pub sha384State: SYMCRYPT_SHA384_STATE,
1283 pub sha512State: SYMCRYPT_SHA512_STATE,
1284 pub sha3_256State: SYMCRYPT_SHA3_256_STATE,
1285 pub sha3_384State: SYMCRYPT_SHA3_384_STATE,
1286 pub sha3_512State: SYMCRYPT_SHA3_512_STATE,
1287}
1288#[test]
1289fn bindgen_test_layout__SYMCRYPT_HASH_STATE() {
1290 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit();
1291 let ptr = UNINIT.as_ptr();
1292 assert_eq!(
1293 ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(),
1294 240usize,
1295 concat!("Size of: ", stringify!(_SYMCRYPT_HASH_STATE))
1296 );
1297 assert_eq!(
1298 ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(),
1299 16usize,
1300 concat!("Alignment of ", stringify!(_SYMCRYPT_HASH_STATE))
1301 );
1302 assert_eq!(
1303 unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize },
1304 0usize,
1305 concat!(
1306 "Offset of field: ",
1307 stringify!(_SYMCRYPT_HASH_STATE),
1308 "::",
1309 stringify!(md2State)
1310 )
1311 );
1312 assert_eq!(
1313 unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize },
1314 0usize,
1315 concat!(
1316 "Offset of field: ",
1317 stringify!(_SYMCRYPT_HASH_STATE),
1318 "::",
1319 stringify!(md4State)
1320 )
1321 );
1322 assert_eq!(
1323 unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize },
1324 0usize,
1325 concat!(
1326 "Offset of field: ",
1327 stringify!(_SYMCRYPT_HASH_STATE),
1328 "::",
1329 stringify!(md5State)
1330 )
1331 );
1332 assert_eq!(
1333 unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize },
1334 0usize,
1335 concat!(
1336 "Offset of field: ",
1337 stringify!(_SYMCRYPT_HASH_STATE),
1338 "::",
1339 stringify!(sha1State)
1340 )
1341 );
1342 assert_eq!(
1343 unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize },
1344 0usize,
1345 concat!(
1346 "Offset of field: ",
1347 stringify!(_SYMCRYPT_HASH_STATE),
1348 "::",
1349 stringify!(sha256State)
1350 )
1351 );
1352 assert_eq!(
1353 unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize },
1354 0usize,
1355 concat!(
1356 "Offset of field: ",
1357 stringify!(_SYMCRYPT_HASH_STATE),
1358 "::",
1359 stringify!(sha384State)
1360 )
1361 );
1362 assert_eq!(
1363 unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize },
1364 0usize,
1365 concat!(
1366 "Offset of field: ",
1367 stringify!(_SYMCRYPT_HASH_STATE),
1368 "::",
1369 stringify!(sha512State)
1370 )
1371 );
1372 assert_eq!(
1373 unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize },
1374 0usize,
1375 concat!(
1376 "Offset of field: ",
1377 stringify!(_SYMCRYPT_HASH_STATE),
1378 "::",
1379 stringify!(sha3_256State)
1380 )
1381 );
1382 assert_eq!(
1383 unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize },
1384 0usize,
1385 concat!(
1386 "Offset of field: ",
1387 stringify!(_SYMCRYPT_HASH_STATE),
1388 "::",
1389 stringify!(sha3_384State)
1390 )
1391 );
1392 assert_eq!(
1393 unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize },
1394 0usize,
1395 concat!(
1396 "Offset of field: ",
1397 stringify!(_SYMCRYPT_HASH_STATE),
1398 "::",
1399 stringify!(sha3_512State)
1400 )
1401 );
1402}
1403impl Default for _SYMCRYPT_HASH_STATE {
1404 fn default() -> Self {
1405 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1406 unsafe {
1407 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1408 s.assume_init()
1409 }
1410 }
1411}
1412pub type SYMCRYPT_HASH_STATE = _SYMCRYPT_HASH_STATE;
1413pub type SYMCRYPT_HASH = _SYMCRYPT_HASH;
1414pub type PCSYMCRYPT_HASH = *const SYMCRYPT_HASH;
1415pub type PSYMCRYPT_HASH_INIT_FUNC = ::std::option::Option<unsafe extern "C" fn(pState: PVOID)>;
1416pub type PSYMCRYPT_HASH_APPEND_FUNC =
1417 ::std::option::Option<unsafe extern "C" fn(pState: PVOID, pbData: PCBYTE, cbData: SIZE_T)>;
1418pub type PSYMCRYPT_HASH_RESULT_FUNC =
1419 ::std::option::Option<unsafe extern "C" fn(pState: PVOID, pbResult: PVOID)>;
1420pub type PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC = ::std::option::Option<
1421 unsafe extern "C" fn(pChain: PVOID, pbData: PCBYTE, cbData: SIZE_T, pcbRemaining: *mut SIZE_T),
1422>;
1423pub type PSYMCRYPT_HASH_STATE_COPY_FUNC =
1424 ::std::option::Option<unsafe extern "C" fn(pStateSrc: PCVOID, pStateDst: PVOID)>;
1425#[repr(C)]
1426#[repr(align(16))]
1427#[derive(Debug, Default, Copy, Clone)]
1428pub struct _SYMCRYPT_HASH {
1429 pub initFunc: PSYMCRYPT_HASH_INIT_FUNC,
1430 pub appendFunc: PSYMCRYPT_HASH_APPEND_FUNC,
1431 pub resultFunc: PSYMCRYPT_HASH_RESULT_FUNC,
1432 pub appendBlockFunc: PSYMCRYPT_HASH_APPEND_BLOCKS_FUNC,
1433 pub stateCopyFunc: PSYMCRYPT_HASH_STATE_COPY_FUNC,
1434 pub stateSize: UINT32,
1435 pub resultSize: UINT32,
1436 pub inputBlockSize: UINT32,
1437 pub chainOffset: UINT32,
1438 pub chainSize: UINT32,
1439}
1440#[test]
1441fn bindgen_test_layout__SYMCRYPT_HASH() {
1442 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit();
1443 let ptr = UNINIT.as_ptr();
1444 assert_eq!(
1445 ::std::mem::size_of::<_SYMCRYPT_HASH>(),
1446 64usize,
1447 concat!("Size of: ", stringify!(_SYMCRYPT_HASH))
1448 );
1449 assert_eq!(
1450 ::std::mem::align_of::<_SYMCRYPT_HASH>(),
1451 16usize,
1452 concat!("Alignment of ", stringify!(_SYMCRYPT_HASH))
1453 );
1454 assert_eq!(
1455 unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize },
1456 0usize,
1457 concat!(
1458 "Offset of field: ",
1459 stringify!(_SYMCRYPT_HASH),
1460 "::",
1461 stringify!(initFunc)
1462 )
1463 );
1464 assert_eq!(
1465 unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize },
1466 8usize,
1467 concat!(
1468 "Offset of field: ",
1469 stringify!(_SYMCRYPT_HASH),
1470 "::",
1471 stringify!(appendFunc)
1472 )
1473 );
1474 assert_eq!(
1475 unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize },
1476 16usize,
1477 concat!(
1478 "Offset of field: ",
1479 stringify!(_SYMCRYPT_HASH),
1480 "::",
1481 stringify!(resultFunc)
1482 )
1483 );
1484 assert_eq!(
1485 unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize },
1486 24usize,
1487 concat!(
1488 "Offset of field: ",
1489 stringify!(_SYMCRYPT_HASH),
1490 "::",
1491 stringify!(appendBlockFunc)
1492 )
1493 );
1494 assert_eq!(
1495 unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize },
1496 32usize,
1497 concat!(
1498 "Offset of field: ",
1499 stringify!(_SYMCRYPT_HASH),
1500 "::",
1501 stringify!(stateCopyFunc)
1502 )
1503 );
1504 assert_eq!(
1505 unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize },
1506 40usize,
1507 concat!(
1508 "Offset of field: ",
1509 stringify!(_SYMCRYPT_HASH),
1510 "::",
1511 stringify!(stateSize)
1512 )
1513 );
1514 assert_eq!(
1515 unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize },
1516 44usize,
1517 concat!(
1518 "Offset of field: ",
1519 stringify!(_SYMCRYPT_HASH),
1520 "::",
1521 stringify!(resultSize)
1522 )
1523 );
1524 assert_eq!(
1525 unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize },
1526 48usize,
1527 concat!(
1528 "Offset of field: ",
1529 stringify!(_SYMCRYPT_HASH),
1530 "::",
1531 stringify!(inputBlockSize)
1532 )
1533 );
1534 assert_eq!(
1535 unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize },
1536 52usize,
1537 concat!(
1538 "Offset of field: ",
1539 stringify!(_SYMCRYPT_HASH),
1540 "::",
1541 stringify!(chainOffset)
1542 )
1543 );
1544 assert_eq!(
1545 unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize },
1546 56usize,
1547 concat!(
1548 "Offset of field: ",
1549 stringify!(_SYMCRYPT_HASH),
1550 "::",
1551 stringify!(chainSize)
1552 )
1553 );
1554}
1555#[repr(C)]
1556#[repr(align(16))]
1557#[derive(Debug, Default, Copy, Clone)]
1558pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY {
1559 pub innerState: SYMCRYPT_MD5_CHAINING_STATE,
1560 pub outerState: SYMCRYPT_MD5_CHAINING_STATE,
1561 pub magic: SIZE_T,
1562}
1563#[test]
1564fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() {
1565 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> =
1566 ::std::mem::MaybeUninit::uninit();
1567 let ptr = UNINIT.as_ptr();
1568 assert_eq!(
1569 ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(),
1570 48usize,
1571 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY))
1572 );
1573 assert_eq!(
1574 ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(),
1575 16usize,
1576 concat!("Alignment of ", stringify!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY))
1577 );
1578 assert_eq!(
1579 unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize },
1580 0usize,
1581 concat!(
1582 "Offset of field: ",
1583 stringify!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY),
1584 "::",
1585 stringify!(innerState)
1586 )
1587 );
1588 assert_eq!(
1589 unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize },
1590 16usize,
1591 concat!(
1592 "Offset of field: ",
1593 stringify!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY),
1594 "::",
1595 stringify!(outerState)
1596 )
1597 );
1598 assert_eq!(
1599 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1600 32usize,
1601 concat!(
1602 "Offset of field: ",
1603 stringify!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY),
1604 "::",
1605 stringify!(magic)
1606 )
1607 );
1608}
1609pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY;
1610pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY;
1611pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY;
1612#[repr(C)]
1613#[repr(align(16))]
1614#[derive(Debug, Copy, Clone)]
1615pub struct _SYMCRYPT_HMAC_MD5_STATE {
1616 pub hash: SYMCRYPT_MD5_STATE,
1617 pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY,
1618 pub magic: SIZE_T,
1619}
1620#[test]
1621fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() {
1622 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> =
1623 ::std::mem::MaybeUninit::uninit();
1624 let ptr = UNINIT.as_ptr();
1625 assert_eq!(
1626 ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(),
1627 128usize,
1628 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_MD5_STATE))
1629 );
1630 assert_eq!(
1631 ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(),
1632 16usize,
1633 concat!("Alignment of ", stringify!(_SYMCRYPT_HMAC_MD5_STATE))
1634 );
1635 assert_eq!(
1636 unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
1637 0usize,
1638 concat!(
1639 "Offset of field: ",
1640 stringify!(_SYMCRYPT_HMAC_MD5_STATE),
1641 "::",
1642 stringify!(hash)
1643 )
1644 );
1645 assert_eq!(
1646 unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize },
1647 112usize,
1648 concat!(
1649 "Offset of field: ",
1650 stringify!(_SYMCRYPT_HMAC_MD5_STATE),
1651 "::",
1652 stringify!(pKey)
1653 )
1654 );
1655 assert_eq!(
1656 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1657 120usize,
1658 concat!(
1659 "Offset of field: ",
1660 stringify!(_SYMCRYPT_HMAC_MD5_STATE),
1661 "::",
1662 stringify!(magic)
1663 )
1664 );
1665}
1666impl Default for _SYMCRYPT_HMAC_MD5_STATE {
1667 fn default() -> Self {
1668 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1669 unsafe {
1670 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1671 s.assume_init()
1672 }
1673 }
1674}
1675pub type SYMCRYPT_HMAC_MD5_STATE = _SYMCRYPT_HMAC_MD5_STATE;
1676pub type PSYMCRYPT_HMAC_MD5_STATE = *mut _SYMCRYPT_HMAC_MD5_STATE;
1677pub type PCSYMCRYPT_HMAC_MD5_STATE = *const SYMCRYPT_HMAC_MD5_STATE;
1678#[repr(C)]
1679#[repr(align(16))]
1680#[derive(Debug, Default, Copy, Clone)]
1681pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY {
1682 pub innerState: SYMCRYPT_SHA1_CHAINING_STATE,
1683 pub outerState: SYMCRYPT_SHA1_CHAINING_STATE,
1684 pub magic: SIZE_T,
1685}
1686#[test]
1687fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() {
1688 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> =
1689 ::std::mem::MaybeUninit::uninit();
1690 let ptr = UNINIT.as_ptr();
1691 assert_eq!(
1692 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(),
1693 80usize,
1694 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY))
1695 );
1696 assert_eq!(
1697 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(),
1698 16usize,
1699 concat!(
1700 "Alignment of ",
1701 stringify!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY)
1702 )
1703 );
1704 assert_eq!(
1705 unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize },
1706 0usize,
1707 concat!(
1708 "Offset of field: ",
1709 stringify!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY),
1710 "::",
1711 stringify!(innerState)
1712 )
1713 );
1714 assert_eq!(
1715 unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize },
1716 32usize,
1717 concat!(
1718 "Offset of field: ",
1719 stringify!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY),
1720 "::",
1721 stringify!(outerState)
1722 )
1723 );
1724 assert_eq!(
1725 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1726 64usize,
1727 concat!(
1728 "Offset of field: ",
1729 stringify!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY),
1730 "::",
1731 stringify!(magic)
1732 )
1733 );
1734}
1735pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY;
1736pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY;
1737pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY;
1738#[repr(C)]
1739#[repr(align(16))]
1740#[derive(Debug, Copy, Clone)]
1741pub struct _SYMCRYPT_HMAC_SHA1_STATE {
1742 pub hash: SYMCRYPT_SHA1_STATE,
1743 pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY,
1744 pub magic: SIZE_T,
1745}
1746#[test]
1747fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() {
1748 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> =
1749 ::std::mem::MaybeUninit::uninit();
1750 let ptr = UNINIT.as_ptr();
1751 assert_eq!(
1752 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(),
1753 144usize,
1754 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_SHA1_STATE))
1755 );
1756 assert_eq!(
1757 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(),
1758 16usize,
1759 concat!("Alignment of ", stringify!(_SYMCRYPT_HMAC_SHA1_STATE))
1760 );
1761 assert_eq!(
1762 unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
1763 0usize,
1764 concat!(
1765 "Offset of field: ",
1766 stringify!(_SYMCRYPT_HMAC_SHA1_STATE),
1767 "::",
1768 stringify!(hash)
1769 )
1770 );
1771 assert_eq!(
1772 unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize },
1773 128usize,
1774 concat!(
1775 "Offset of field: ",
1776 stringify!(_SYMCRYPT_HMAC_SHA1_STATE),
1777 "::",
1778 stringify!(pKey)
1779 )
1780 );
1781 assert_eq!(
1782 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1783 136usize,
1784 concat!(
1785 "Offset of field: ",
1786 stringify!(_SYMCRYPT_HMAC_SHA1_STATE),
1787 "::",
1788 stringify!(magic)
1789 )
1790 );
1791}
1792impl Default for _SYMCRYPT_HMAC_SHA1_STATE {
1793 fn default() -> Self {
1794 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1795 unsafe {
1796 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1797 s.assume_init()
1798 }
1799 }
1800}
1801pub type SYMCRYPT_HMAC_SHA1_STATE = _SYMCRYPT_HMAC_SHA1_STATE;
1802pub type PSYMCRYPT_HMAC_SHA1_STATE = *mut _SYMCRYPT_HMAC_SHA1_STATE;
1803pub type PCSYMCRYPT_HMAC_SHA1_STATE = *const SYMCRYPT_HMAC_SHA1_STATE;
1804#[repr(C)]
1805#[repr(align(16))]
1806#[derive(Debug, Default, Copy, Clone)]
1807pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY {
1808 pub innerState: SYMCRYPT_SHA256_CHAINING_STATE,
1809 pub outerState: SYMCRYPT_SHA256_CHAINING_STATE,
1810 pub magic: SIZE_T,
1811}
1812#[test]
1813fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() {
1814 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> =
1815 ::std::mem::MaybeUninit::uninit();
1816 let ptr = UNINIT.as_ptr();
1817 assert_eq!(
1818 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(),
1819 80usize,
1820 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY))
1821 );
1822 assert_eq!(
1823 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(),
1824 16usize,
1825 concat!(
1826 "Alignment of ",
1827 stringify!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY)
1828 )
1829 );
1830 assert_eq!(
1831 unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize },
1832 0usize,
1833 concat!(
1834 "Offset of field: ",
1835 stringify!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY),
1836 "::",
1837 stringify!(innerState)
1838 )
1839 );
1840 assert_eq!(
1841 unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize },
1842 32usize,
1843 concat!(
1844 "Offset of field: ",
1845 stringify!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY),
1846 "::",
1847 stringify!(outerState)
1848 )
1849 );
1850 assert_eq!(
1851 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1852 64usize,
1853 concat!(
1854 "Offset of field: ",
1855 stringify!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY),
1856 "::",
1857 stringify!(magic)
1858 )
1859 );
1860}
1861pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY;
1862pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY;
1863pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY;
1864#[repr(C)]
1865#[repr(align(16))]
1866#[derive(Debug, Copy, Clone)]
1867pub struct _SYMCRYPT_HMAC_SHA256_STATE {
1868 pub hash: SYMCRYPT_SHA256_STATE,
1869 pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY,
1870 pub magic: SIZE_T,
1871}
1872#[test]
1873fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() {
1874 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> =
1875 ::std::mem::MaybeUninit::uninit();
1876 let ptr = UNINIT.as_ptr();
1877 assert_eq!(
1878 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(),
1879 144usize,
1880 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_SHA256_STATE))
1881 );
1882 assert_eq!(
1883 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(),
1884 16usize,
1885 concat!("Alignment of ", stringify!(_SYMCRYPT_HMAC_SHA256_STATE))
1886 );
1887 assert_eq!(
1888 unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
1889 0usize,
1890 concat!(
1891 "Offset of field: ",
1892 stringify!(_SYMCRYPT_HMAC_SHA256_STATE),
1893 "::",
1894 stringify!(hash)
1895 )
1896 );
1897 assert_eq!(
1898 unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize },
1899 128usize,
1900 concat!(
1901 "Offset of field: ",
1902 stringify!(_SYMCRYPT_HMAC_SHA256_STATE),
1903 "::",
1904 stringify!(pKey)
1905 )
1906 );
1907 assert_eq!(
1908 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1909 136usize,
1910 concat!(
1911 "Offset of field: ",
1912 stringify!(_SYMCRYPT_HMAC_SHA256_STATE),
1913 "::",
1914 stringify!(magic)
1915 )
1916 );
1917}
1918impl Default for _SYMCRYPT_HMAC_SHA256_STATE {
1919 fn default() -> Self {
1920 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1921 unsafe {
1922 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1923 s.assume_init()
1924 }
1925 }
1926}
1927pub type SYMCRYPT_HMAC_SHA256_STATE = _SYMCRYPT_HMAC_SHA256_STATE;
1928pub type PSYMCRYPT_HMAC_SHA256_STATE = *mut _SYMCRYPT_HMAC_SHA256_STATE;
1929pub type PCSYMCRYPT_HMAC_SHA256_STATE = *const SYMCRYPT_HMAC_SHA256_STATE;
1930#[repr(C)]
1931#[repr(align(16))]
1932#[derive(Debug, Default, Copy, Clone)]
1933pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY {
1934 pub innerState: SYMCRYPT_SHA512_CHAINING_STATE,
1935 pub outerState: SYMCRYPT_SHA512_CHAINING_STATE,
1936 pub magic: SIZE_T,
1937}
1938#[test]
1939fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() {
1940 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> =
1941 ::std::mem::MaybeUninit::uninit();
1942 let ptr = UNINIT.as_ptr();
1943 assert_eq!(
1944 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(),
1945 144usize,
1946 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY))
1947 );
1948 assert_eq!(
1949 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(),
1950 16usize,
1951 concat!(
1952 "Alignment of ",
1953 stringify!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY)
1954 )
1955 );
1956 assert_eq!(
1957 unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize },
1958 0usize,
1959 concat!(
1960 "Offset of field: ",
1961 stringify!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY),
1962 "::",
1963 stringify!(innerState)
1964 )
1965 );
1966 assert_eq!(
1967 unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize },
1968 64usize,
1969 concat!(
1970 "Offset of field: ",
1971 stringify!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY),
1972 "::",
1973 stringify!(outerState)
1974 )
1975 );
1976 assert_eq!(
1977 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1978 128usize,
1979 concat!(
1980 "Offset of field: ",
1981 stringify!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY),
1982 "::",
1983 stringify!(magic)
1984 )
1985 );
1986}
1987pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY;
1988pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY;
1989pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY;
1990#[repr(C)]
1991#[repr(align(16))]
1992#[derive(Debug, Copy, Clone)]
1993pub struct _SYMCRYPT_HMAC_SHA384_STATE {
1994 pub hash: SYMCRYPT_SHA384_STATE,
1995 pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY,
1996 pub magic: SIZE_T,
1997}
1998#[test]
1999fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() {
2000 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> =
2001 ::std::mem::MaybeUninit::uninit();
2002 let ptr = UNINIT.as_ptr();
2003 assert_eq!(
2004 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(),
2005 240usize,
2006 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_SHA384_STATE))
2007 );
2008 assert_eq!(
2009 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(),
2010 16usize,
2011 concat!("Alignment of ", stringify!(_SYMCRYPT_HMAC_SHA384_STATE))
2012 );
2013 assert_eq!(
2014 unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
2015 0usize,
2016 concat!(
2017 "Offset of field: ",
2018 stringify!(_SYMCRYPT_HMAC_SHA384_STATE),
2019 "::",
2020 stringify!(hash)
2021 )
2022 );
2023 assert_eq!(
2024 unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize },
2025 224usize,
2026 concat!(
2027 "Offset of field: ",
2028 stringify!(_SYMCRYPT_HMAC_SHA384_STATE),
2029 "::",
2030 stringify!(pKey)
2031 )
2032 );
2033 assert_eq!(
2034 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
2035 232usize,
2036 concat!(
2037 "Offset of field: ",
2038 stringify!(_SYMCRYPT_HMAC_SHA384_STATE),
2039 "::",
2040 stringify!(magic)
2041 )
2042 );
2043}
2044impl Default for _SYMCRYPT_HMAC_SHA384_STATE {
2045 fn default() -> Self {
2046 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2047 unsafe {
2048 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2049 s.assume_init()
2050 }
2051 }
2052}
2053pub type SYMCRYPT_HMAC_SHA384_STATE = _SYMCRYPT_HMAC_SHA384_STATE;
2054pub type PSYMCRYPT_HMAC_SHA384_STATE = *mut _SYMCRYPT_HMAC_SHA384_STATE;
2055pub type PCSYMCRYPT_HMAC_SHA384_STATE = *const SYMCRYPT_HMAC_SHA384_STATE;
2056#[repr(C)]
2057#[repr(align(16))]
2058#[derive(Debug, Default, Copy, Clone)]
2059pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY {
2060 pub innerState: SYMCRYPT_SHA512_CHAINING_STATE,
2061 pub outerState: SYMCRYPT_SHA512_CHAINING_STATE,
2062 pub magic: SIZE_T,
2063}
2064#[test]
2065fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() {
2066 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> =
2067 ::std::mem::MaybeUninit::uninit();
2068 let ptr = UNINIT.as_ptr();
2069 assert_eq!(
2070 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(),
2071 144usize,
2072 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY))
2073 );
2074 assert_eq!(
2075 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(),
2076 16usize,
2077 concat!(
2078 "Alignment of ",
2079 stringify!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY)
2080 )
2081 );
2082 assert_eq!(
2083 unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize },
2084 0usize,
2085 concat!(
2086 "Offset of field: ",
2087 stringify!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY),
2088 "::",
2089 stringify!(innerState)
2090 )
2091 );
2092 assert_eq!(
2093 unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize },
2094 64usize,
2095 concat!(
2096 "Offset of field: ",
2097 stringify!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY),
2098 "::",
2099 stringify!(outerState)
2100 )
2101 );
2102 assert_eq!(
2103 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
2104 128usize,
2105 concat!(
2106 "Offset of field: ",
2107 stringify!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY),
2108 "::",
2109 stringify!(magic)
2110 )
2111 );
2112}
2113pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY;
2114pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY;
2115pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY;
2116#[repr(C)]
2117#[repr(align(16))]
2118#[derive(Debug, Copy, Clone)]
2119pub struct _SYMCRYPT_HMAC_SHA512_STATE {
2120 pub hash: SYMCRYPT_SHA512_STATE,
2121 pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY,
2122 pub magic: SIZE_T,
2123}
2124#[test]
2125fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() {
2126 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> =
2127 ::std::mem::MaybeUninit::uninit();
2128 let ptr = UNINIT.as_ptr();
2129 assert_eq!(
2130 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(),
2131 240usize,
2132 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_SHA512_STATE))
2133 );
2134 assert_eq!(
2135 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(),
2136 16usize,
2137 concat!("Alignment of ", stringify!(_SYMCRYPT_HMAC_SHA512_STATE))
2138 );
2139 assert_eq!(
2140 unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
2141 0usize,
2142 concat!(
2143 "Offset of field: ",
2144 stringify!(_SYMCRYPT_HMAC_SHA512_STATE),
2145 "::",
2146 stringify!(hash)
2147 )
2148 );
2149 assert_eq!(
2150 unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize },
2151 224usize,
2152 concat!(
2153 "Offset of field: ",
2154 stringify!(_SYMCRYPT_HMAC_SHA512_STATE),
2155 "::",
2156 stringify!(pKey)
2157 )
2158 );
2159 assert_eq!(
2160 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
2161 232usize,
2162 concat!(
2163 "Offset of field: ",
2164 stringify!(_SYMCRYPT_HMAC_SHA512_STATE),
2165 "::",
2166 stringify!(magic)
2167 )
2168 );
2169}
2170impl Default for _SYMCRYPT_HMAC_SHA512_STATE {
2171 fn default() -> Self {
2172 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2173 unsafe {
2174 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2175 s.assume_init()
2176 }
2177 }
2178}
2179pub type SYMCRYPT_HMAC_SHA512_STATE = _SYMCRYPT_HMAC_SHA512_STATE;
2180pub type PSYMCRYPT_HMAC_SHA512_STATE = *mut _SYMCRYPT_HMAC_SHA512_STATE;
2181pub type PCSYMCRYPT_HMAC_SHA512_STATE = *const SYMCRYPT_HMAC_SHA512_STATE;
2182#[repr(C)]
2183#[repr(align(16))]
2184#[derive(Copy, Clone)]
2185pub struct _SYMCRYPT_HMAC_EXPANDED_KEY {
2186 pub pHash: PCSYMCRYPT_HASH,
2187 pub __bindgen_padding_0: u64,
2188 pub innerState: SYMCRYPT_HASH_STATE,
2189 pub outerState: SYMCRYPT_HASH_STATE,
2190 pub magic: SIZE_T,
2191}
2192#[test]
2193fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() {
2194 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> =
2195 ::std::mem::MaybeUninit::uninit();
2196 let ptr = UNINIT.as_ptr();
2197 assert_eq!(
2198 ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(),
2199 512usize,
2200 concat!("Size of: ", stringify!(_SYMCRYPT_HMAC_EXPANDED_KEY))
2201 );
2202 assert_eq!(
2203 ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(),
2204 16usize,
2205 concat!("Alignment of ", stringify!(_SYMCRYPT_HMAC_EXPANDED_KEY))
2206 );
2207 assert_eq!(
2208 unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize },
2209 0usize,
2210 concat!(
2211 "Offset of field: ",
2212 stringify!(_SYMCRYPT_HMAC_EXPANDED_KEY),
2213 "::",
2214 stringify!(pHash)
2215 )
2216 );
2217 assert_eq!(
2218 unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize },
2219 16usize,
2220 concat!(
2221 "Offset of field: ",
2222 stringify!(_SYMCRYPT_HMAC_EXPANDED_KEY),
2223 "::",
2224 stringify!(innerState)
2225 )
2226 );
2227 assert_eq!(
2228 unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize },
2229 256usize,
2230 concat!(
2231 "Offset of field: ",
2232 stringify!(_SYMCRYPT_HMAC_EXPANDED_KEY),
2233 "::",
2234 stringify!(outerState)
2235 )
2236 );
2237 assert_eq!(
2238 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
2239 496usize,
2240 concat!(
2241 "Offset of field: ",
2242 stringify!(_SYMCRYPT_HMAC_EXPANDED_KEY),
2243 "::",
2244 stringify!(magic)
2245 )
2246 );
2247}
2248impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY {
2249 fn default() -> Self {
2250 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2251 unsafe {
2252 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2253 s.assume_init()
2254 }
2255 }
2256}
2257pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY;
2258#[repr(C)]
2259#[repr(align(16))]
2260#[derive(Copy, Clone)]
2261pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY {
2262 pub generic: SYMCRYPT_HMAC_EXPANDED_KEY,
2263}
2264#[test]
2265fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() {
2266 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> =
2267 ::std::mem::MaybeUninit::uninit();
2268 let ptr = UNINIT.as_ptr();
2269 assert_eq!(
2270 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(),
2271 512usize,
2272 concat!(
2273 "Size of: ",
2274 stringify!(_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY)
2275 )
2276 );
2277 assert_eq!(
2278 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(),
2279 16usize,
2280 concat!(
2281 "Alignment of ",
2282 stringify!(_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY)
2283 )
2284 );
2285 assert_eq!(
2286 unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize },
2287 0usize,
2288 concat!(
2289 "Offset of field: ",
2290 stringify!(_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY),
2291 "::",
2292 stringify!(generic)
2293 )
2294 );
2295}
2296impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY {
2297 fn default() -> Self {
2298 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2299 unsafe {
2300 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2301 s.assume_init()
2302 }
2303 }
2304}
2305pub type SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY;
2306#[repr(C)]
2307#[repr(align(16))]
2308#[derive(Copy, Clone)]
2309pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY {
2310 pub generic: SYMCRYPT_HMAC_EXPANDED_KEY,
2311}
2312#[test]
2313fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() {
2314 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> =
2315 ::std::mem::MaybeUninit::uninit();
2316 let ptr = UNINIT.as_ptr();
2317 assert_eq!(
2318 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(),
2319 512usize,
2320 concat!(
2321 "Size of: ",
2322 stringify!(_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY)
2323 )
2324 );
2325 assert_eq!(
2326 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(),
2327 16usize,
2328 concat!(
2329 "Alignment of ",
2330 stringify!(_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY)
2331 )
2332 );
2333 assert_eq!(
2334 unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize },
2335 0usize,
2336 concat!(
2337 "Offset of field: ",
2338 stringify!(_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY),
2339 "::",
2340 stringify!(generic)
2341 )
2342 );
2343}
2344impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY {
2345 fn default() -> Self {
2346 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2347 unsafe {
2348 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2349 s.assume_init()
2350 }
2351 }
2352}
2353pub type SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY;
2354#[repr(C)]
2355#[repr(align(16))]
2356#[derive(Copy, Clone)]
2357pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY {
2358 pub generic: SYMCRYPT_HMAC_EXPANDED_KEY,
2359}
2360#[test]
2361fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() {
2362 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> =
2363 ::std::mem::MaybeUninit::uninit();
2364 let ptr = UNINIT.as_ptr();
2365 assert_eq!(
2366 ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(),
2367 512usize,
2368 concat!(
2369 "Size of: ",
2370 stringify!(_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY)
2371 )
2372 );
2373 assert_eq!(
2374 ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(),
2375 16usize,
2376 concat!(
2377 "Alignment of ",
2378 stringify!(_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY)
2379 )
2380 );
2381 assert_eq!(
2382 unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize },
2383 0usize,
2384 concat!(
2385 "Offset of field: ",
2386 stringify!(_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY),
2387 "::",
2388 stringify!(generic)
2389 )
2390 );
2391}
2392impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY {
2393 fn default() -> Self {
2394 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2395 unsafe {
2396 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2397 s.assume_init()
2398 }
2399 }
2400}
2401pub type SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY;
2402#[repr(C)]
2403#[repr(align(16))]
2404#[derive(Debug, Copy, Clone)]
2405pub struct _SYMCRYPT_AES_EXPANDED_KEY {
2406 pub RoundKey: [[[BYTE; 4usize]; 4usize]; 29usize],
2407 pub lastEncRoundKey: *mut [[BYTE; 4usize]; 4usize],
2408 pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize],
2409 pub magic: SIZE_T,
2410}
2411#[test]
2412fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() {
2413 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> =
2414 ::std::mem::MaybeUninit::uninit();
2415 let ptr = UNINIT.as_ptr();
2416 assert_eq!(
2417 ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(),
2418 496usize,
2419 concat!("Size of: ", stringify!(_SYMCRYPT_AES_EXPANDED_KEY))
2420 );
2421 assert_eq!(
2422 ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(),
2423 16usize,
2424 concat!("Alignment of ", stringify!(_SYMCRYPT_AES_EXPANDED_KEY))
2425 );
2426 assert_eq!(
2427 unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize },
2428 0usize,
2429 concat!(
2430 "Offset of field: ",
2431 stringify!(_SYMCRYPT_AES_EXPANDED_KEY),
2432 "::",
2433 stringify!(RoundKey)
2434 )
2435 );
2436 assert_eq!(
2437 unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize },
2438 464usize,
2439 concat!(
2440 "Offset of field: ",
2441 stringify!(_SYMCRYPT_AES_EXPANDED_KEY),
2442 "::",
2443 stringify!(lastEncRoundKey)
2444 )
2445 );
2446 assert_eq!(
2447 unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize },
2448 472usize,
2449 concat!(
2450 "Offset of field: ",
2451 stringify!(_SYMCRYPT_AES_EXPANDED_KEY),
2452 "::",
2453 stringify!(lastDecRoundKey)
2454 )
2455 );
2456 assert_eq!(
2457 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
2458 480usize,
2459 concat!(
2460 "Offset of field: ",
2461 stringify!(_SYMCRYPT_AES_EXPANDED_KEY),
2462 "::",
2463 stringify!(magic)
2464 )
2465 );
2466}
2467impl Default for _SYMCRYPT_AES_EXPANDED_KEY {
2468 fn default() -> Self {
2469 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2470 unsafe {
2471 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2472 s.assume_init()
2473 }
2474 }
2475}
2476pub type SYMCRYPT_AES_EXPANDED_KEY = _SYMCRYPT_AES_EXPANDED_KEY;
2477pub type PSYMCRYPT_AES_EXPANDED_KEY = *mut _SYMCRYPT_AES_EXPANDED_KEY;
2478pub type PCSYMCRYPT_AES_EXPANDED_KEY = *const SYMCRYPT_AES_EXPANDED_KEY;
2479#[repr(C)]
2480#[repr(align(16))]
2481#[derive(Debug, Copy, Clone)]
2482pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY {
2483 pub aesKey: SYMCRYPT_AES_EXPANDED_KEY,
2484 pub K1: [BYTE; 16usize],
2485 pub K2: [BYTE; 16usize],
2486 pub magic: SIZE_T,
2487}
2488#[test]
2489fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() {
2490 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> =
2491 ::std::mem::MaybeUninit::uninit();
2492 let ptr = UNINIT.as_ptr();
2493 assert_eq!(
2494 ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(),
2495 544usize,
2496 concat!("Size of: ", stringify!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY))
2497 );
2498 assert_eq!(
2499 ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(),
2500 16usize,
2501 concat!("Alignment of ", stringify!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY))
2502 );
2503 assert_eq!(
2504 unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize },
2505 0usize,
2506 concat!(
2507 "Offset of field: ",
2508 stringify!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY),
2509 "::",
2510 stringify!(aesKey)
2511 )
2512 );
2513 assert_eq!(
2514 unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize },
2515 496usize,
2516 concat!(
2517 "Offset of field: ",
2518 stringify!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY),
2519 "::",
2520 stringify!(K1)
2521 )
2522 );
2523 assert_eq!(
2524 unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize },
2525 512usize,
2526 concat!(
2527 "Offset of field: ",
2528 stringify!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY),
2529 "::",
2530 stringify!(K2)
2531 )
2532 );
2533 assert_eq!(
2534 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
2535 528usize,
2536 concat!(
2537 "Offset of field: ",
2538 stringify!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY),
2539 "::",
2540 stringify!(magic)
2541 )
2542 );
2543}
2544impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY {
2545 fn default() -> Self {
2546 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2547 unsafe {
2548 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2549 s.assume_init()
2550 }
2551 }
2552}
2553pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY;
2554#[repr(C)]
2555#[repr(align(16))]
2556#[derive(Copy, Clone)]
2557pub union _SYMCRYPT_MAC_EXPANDED_KEY {
2558 pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY,
2559 pub sha1Key: SYMCRYPT_HMAC_SHA1_EXPANDED_KEY,
2560 pub sha256Key: SYMCRYPT_HMAC_SHA256_EXPANDED_KEY,
2561 pub sha384Key: SYMCRYPT_HMAC_SHA384_EXPANDED_KEY,
2562 pub sha512Key: SYMCRYPT_HMAC_SHA512_EXPANDED_KEY,
2563 pub sha3_256Key: SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY,
2564 pub sha3_384Key: SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY,
2565 pub sha3_512Key: SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY,
2566 pub aescmacKey: SYMCRYPT_AES_CMAC_EXPANDED_KEY,
2567 pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY,
2568 pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY,
2569}
2570#[test]
2571fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() {
2572 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> =
2573 ::std::mem::MaybeUninit::uninit();
2574 let ptr = UNINIT.as_ptr();
2575 assert_eq!(
2576 ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(),
2577 544usize,
2578 concat!("Size of: ", stringify!(_SYMCRYPT_MAC_EXPANDED_KEY))
2579 );
2580 assert_eq!(
2581 ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(),
2582 16usize,
2583 concat!("Alignment of ", stringify!(_SYMCRYPT_MAC_EXPANDED_KEY))
2584 );
2585 assert_eq!(
2586 unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize },
2587 0usize,
2588 concat!(
2589 "Offset of field: ",
2590 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2591 "::",
2592 stringify!(md5Key)
2593 )
2594 );
2595 assert_eq!(
2596 unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize },
2597 0usize,
2598 concat!(
2599 "Offset of field: ",
2600 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2601 "::",
2602 stringify!(sha1Key)
2603 )
2604 );
2605 assert_eq!(
2606 unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize },
2607 0usize,
2608 concat!(
2609 "Offset of field: ",
2610 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2611 "::",
2612 stringify!(sha256Key)
2613 )
2614 );
2615 assert_eq!(
2616 unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize },
2617 0usize,
2618 concat!(
2619 "Offset of field: ",
2620 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2621 "::",
2622 stringify!(sha384Key)
2623 )
2624 );
2625 assert_eq!(
2626 unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize },
2627 0usize,
2628 concat!(
2629 "Offset of field: ",
2630 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2631 "::",
2632 stringify!(sha512Key)
2633 )
2634 );
2635 assert_eq!(
2636 unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize },
2637 0usize,
2638 concat!(
2639 "Offset of field: ",
2640 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2641 "::",
2642 stringify!(sha3_256Key)
2643 )
2644 );
2645 assert_eq!(
2646 unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize },
2647 0usize,
2648 concat!(
2649 "Offset of field: ",
2650 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2651 "::",
2652 stringify!(sha3_384Key)
2653 )
2654 );
2655 assert_eq!(
2656 unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize },
2657 0usize,
2658 concat!(
2659 "Offset of field: ",
2660 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2661 "::",
2662 stringify!(sha3_512Key)
2663 )
2664 );
2665 assert_eq!(
2666 unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize },
2667 0usize,
2668 concat!(
2669 "Offset of field: ",
2670 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2671 "::",
2672 stringify!(aescmacKey)
2673 )
2674 );
2675 assert_eq!(
2676 unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize },
2677 0usize,
2678 concat!(
2679 "Offset of field: ",
2680 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2681 "::",
2682 stringify!(kmac128Key)
2683 )
2684 );
2685 assert_eq!(
2686 unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize },
2687 0usize,
2688 concat!(
2689 "Offset of field: ",
2690 stringify!(_SYMCRYPT_MAC_EXPANDED_KEY),
2691 "::",
2692 stringify!(kmac256Key)
2693 )
2694 );
2695}
2696impl Default for _SYMCRYPT_MAC_EXPANDED_KEY {
2697 fn default() -> Self {
2698 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2699 unsafe {
2700 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2701 s.assume_init()
2702 }
2703 }
2704}
2705pub type SYMCRYPT_MAC_EXPANDED_KEY = _SYMCRYPT_MAC_EXPANDED_KEY;
2706pub type PSYMCRYPT_MAC_EXPAND_KEY = ::std::option::Option<
2707 unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR,
2708>;
2709pub type PSYMCRYPT_MAC_INIT =
2710 ::std::option::Option<unsafe extern "C" fn(pState: PVOID, pExpandedKey: PCVOID)>;
2711pub type PSYMCRYPT_MAC_APPEND =
2712 ::std::option::Option<unsafe extern "C" fn(pState: PVOID, pbData: PCBYTE, cbData: SIZE_T)>;
2713pub type PSYMCRYPT_MAC_RESULT =
2714 ::std::option::Option<unsafe extern "C" fn(pState: PVOID, pbResult: PVOID)>;
2715#[repr(C)]
2716#[derive(Debug, Copy, Clone)]
2717pub struct _SYMCRYPT_MAC {
2718 pub expandKeyFunc: PSYMCRYPT_MAC_EXPAND_KEY,
2719 pub initFunc: PSYMCRYPT_MAC_INIT,
2720 pub appendFunc: PSYMCRYPT_MAC_APPEND,
2721 pub resultFunc: PSYMCRYPT_MAC_RESULT,
2722 pub expandedKeySize: SIZE_T,
2723 pub stateSize: SIZE_T,
2724 pub resultSize: SIZE_T,
2725 pub ppHashAlgorithm: *const PCSYMCRYPT_HASH,
2726 pub outerChainingStateOffset: UINT32,
2727}
2728#[test]
2729fn bindgen_test_layout__SYMCRYPT_MAC() {
2730 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit();
2731 let ptr = UNINIT.as_ptr();
2732 assert_eq!(
2733 ::std::mem::size_of::<_SYMCRYPT_MAC>(),
2734 72usize,
2735 concat!("Size of: ", stringify!(_SYMCRYPT_MAC))
2736 );
2737 assert_eq!(
2738 ::std::mem::align_of::<_SYMCRYPT_MAC>(),
2739 8usize,
2740 concat!("Alignment of ", stringify!(_SYMCRYPT_MAC))
2741 );
2742 assert_eq!(
2743 unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize },
2744 0usize,
2745 concat!(
2746 "Offset of field: ",
2747 stringify!(_SYMCRYPT_MAC),
2748 "::",
2749 stringify!(expandKeyFunc)
2750 )
2751 );
2752 assert_eq!(
2753 unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize },
2754 8usize,
2755 concat!(
2756 "Offset of field: ",
2757 stringify!(_SYMCRYPT_MAC),
2758 "::",
2759 stringify!(initFunc)
2760 )
2761 );
2762 assert_eq!(
2763 unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize },
2764 16usize,
2765 concat!(
2766 "Offset of field: ",
2767 stringify!(_SYMCRYPT_MAC),
2768 "::",
2769 stringify!(appendFunc)
2770 )
2771 );
2772 assert_eq!(
2773 unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize },
2774 24usize,
2775 concat!(
2776 "Offset of field: ",
2777 stringify!(_SYMCRYPT_MAC),
2778 "::",
2779 stringify!(resultFunc)
2780 )
2781 );
2782 assert_eq!(
2783 unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize },
2784 32usize,
2785 concat!(
2786 "Offset of field: ",
2787 stringify!(_SYMCRYPT_MAC),
2788 "::",
2789 stringify!(expandedKeySize)
2790 )
2791 );
2792 assert_eq!(
2793 unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize },
2794 40usize,
2795 concat!(
2796 "Offset of field: ",
2797 stringify!(_SYMCRYPT_MAC),
2798 "::",
2799 stringify!(stateSize)
2800 )
2801 );
2802 assert_eq!(
2803 unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize },
2804 48usize,
2805 concat!(
2806 "Offset of field: ",
2807 stringify!(_SYMCRYPT_MAC),
2808 "::",
2809 stringify!(resultSize)
2810 )
2811 );
2812 assert_eq!(
2813 unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize },
2814 56usize,
2815 concat!(
2816 "Offset of field: ",
2817 stringify!(_SYMCRYPT_MAC),
2818 "::",
2819 stringify!(ppHashAlgorithm)
2820 )
2821 );
2822 assert_eq!(
2823 unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize },
2824 64usize,
2825 concat!(
2826 "Offset of field: ",
2827 stringify!(_SYMCRYPT_MAC),
2828 "::",
2829 stringify!(outerChainingStateOffset)
2830 )
2831 );
2832}
2833impl Default for _SYMCRYPT_MAC {
2834 fn default() -> Self {
2835 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2836 unsafe {
2837 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2838 s.assume_init()
2839 }
2840 }
2841}
2842pub type SYMCRYPT_MAC = _SYMCRYPT_MAC;
2843pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC;
2844#[repr(C)]
2845#[repr(align(16))]
2846#[derive(Copy, Clone)]
2847pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS {
2848 pub aes: SYMCRYPT_AES_EXPANDED_KEY,
2849}
2850#[test]
2851fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() {
2852 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> =
2853 ::std::mem::MaybeUninit::uninit();
2854 let ptr = UNINIT.as_ptr();
2855 assert_eq!(
2856 ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(),
2857 496usize,
2858 concat!(
2859 "Size of: ",
2860 stringify!(_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS)
2861 )
2862 );
2863 assert_eq!(
2864 ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(),
2865 16usize,
2866 concat!(
2867 "Alignment of ",
2868 stringify!(_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS)
2869 )
2870 );
2871 assert_eq!(
2872 unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize },
2873 0usize,
2874 concat!(
2875 "Offset of field: ",
2876 stringify!(_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS),
2877 "::",
2878 stringify!(aes)
2879 )
2880 );
2881}
2882impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS {
2883 fn default() -> Self {
2884 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2885 unsafe {
2886 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2887 s.assume_init()
2888 }
2889 }
2890}
2891pub type SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS = _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS;
2892#[repr(C)]
2893#[repr(align(16))]
2894#[derive(Copy, Clone)]
2895pub union _SYMCRYPT_GF128_ELEMENT {
2896 pub ull: [UINT64; 2usize],
2897 pub m128i: __m128i,
2898 pub ul: [UINT32; 4usize],
2899}
2900#[test]
2901fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() {
2902 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> =
2903 ::std::mem::MaybeUninit::uninit();
2904 let ptr = UNINIT.as_ptr();
2905 assert_eq!(
2906 ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(),
2907 16usize,
2908 concat!("Size of: ", stringify!(_SYMCRYPT_GF128_ELEMENT))
2909 );
2910 assert_eq!(
2911 ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(),
2912 16usize,
2913 concat!("Alignment of ", stringify!(_SYMCRYPT_GF128_ELEMENT))
2914 );
2915 assert_eq!(
2916 unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize },
2917 0usize,
2918 concat!(
2919 "Offset of field: ",
2920 stringify!(_SYMCRYPT_GF128_ELEMENT),
2921 "::",
2922 stringify!(ull)
2923 )
2924 );
2925 assert_eq!(
2926 unsafe { ::std::ptr::addr_of!((*ptr).m128i) as usize - ptr as usize },
2927 0usize,
2928 concat!(
2929 "Offset of field: ",
2930 stringify!(_SYMCRYPT_GF128_ELEMENT),
2931 "::",
2932 stringify!(m128i)
2933 )
2934 );
2935 assert_eq!(
2936 unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize },
2937 0usize,
2938 concat!(
2939 "Offset of field: ",
2940 stringify!(_SYMCRYPT_GF128_ELEMENT),
2941 "::",
2942 stringify!(ul)
2943 )
2944 );
2945}
2946impl Default for _SYMCRYPT_GF128_ELEMENT {
2947 fn default() -> Self {
2948 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2949 unsafe {
2950 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2951 s.assume_init()
2952 }
2953 }
2954}
2955pub type SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT;
2956#[repr(C)]
2957#[repr(align(16))]
2958#[derive(Copy, Clone)]
2959pub struct _SYMCRYPT_GHASH_EXPANDED_KEY {
2960 pub table: [SYMCRYPT_GF128_ELEMENT; 128usize],
2961}
2962#[test]
2963fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() {
2964 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> =
2965 ::std::mem::MaybeUninit::uninit();
2966 let ptr = UNINIT.as_ptr();
2967 assert_eq!(
2968 ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(),
2969 2048usize,
2970 concat!("Size of: ", stringify!(_SYMCRYPT_GHASH_EXPANDED_KEY))
2971 );
2972 assert_eq!(
2973 ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(),
2974 16usize,
2975 concat!("Alignment of ", stringify!(_SYMCRYPT_GHASH_EXPANDED_KEY))
2976 );
2977 assert_eq!(
2978 unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize },
2979 0usize,
2980 concat!(
2981 "Offset of field: ",
2982 stringify!(_SYMCRYPT_GHASH_EXPANDED_KEY),
2983 "::",
2984 stringify!(table)
2985 )
2986 );
2987}
2988impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY {
2989 fn default() -> Self {
2990 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2991 unsafe {
2992 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2993 s.assume_init()
2994 }
2995 }
2996}
2997pub type SYMCRYPT_GHASH_EXPANDED_KEY = _SYMCRYPT_GHASH_EXPANDED_KEY;
2998#[repr(C)]
2999#[repr(align(16))]
3000#[derive(Copy, Clone)]
3001pub struct _SYMCRYPT_GCM_EXPANDED_KEY {
3002 pub ghashKey: SYMCRYPT_GHASH_EXPANDED_KEY,
3003 pub pBlockCipher: PCSYMCRYPT_BLOCKCIPHER,
3004 pub __bindgen_padding_0: u64,
3005 pub blockcipherKey: SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS,
3006 pub cbKey: SIZE_T,
3007 pub abKey: [BYTE; 32usize],
3008 pub magic: SIZE_T,
3009}
3010#[test]
3011fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() {
3012 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> =
3013 ::std::mem::MaybeUninit::uninit();
3014 let ptr = UNINIT.as_ptr();
3015 assert_eq!(
3016 ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(),
3017 2608usize,
3018 concat!("Size of: ", stringify!(_SYMCRYPT_GCM_EXPANDED_KEY))
3019 );
3020 assert_eq!(
3021 ::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(),
3022 16usize,
3023 concat!("Alignment of ", stringify!(_SYMCRYPT_GCM_EXPANDED_KEY))
3024 );
3025 assert_eq!(
3026 unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize },
3027 0usize,
3028 concat!(
3029 "Offset of field: ",
3030 stringify!(_SYMCRYPT_GCM_EXPANDED_KEY),
3031 "::",
3032 stringify!(ghashKey)
3033 )
3034 );
3035 assert_eq!(
3036 unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize },
3037 2048usize,
3038 concat!(
3039 "Offset of field: ",
3040 stringify!(_SYMCRYPT_GCM_EXPANDED_KEY),
3041 "::",
3042 stringify!(pBlockCipher)
3043 )
3044 );
3045 assert_eq!(
3046 unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize },
3047 2064usize,
3048 concat!(
3049 "Offset of field: ",
3050 stringify!(_SYMCRYPT_GCM_EXPANDED_KEY),
3051 "::",
3052 stringify!(blockcipherKey)
3053 )
3054 );
3055 assert_eq!(
3056 unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize },
3057 2560usize,
3058 concat!(
3059 "Offset of field: ",
3060 stringify!(_SYMCRYPT_GCM_EXPANDED_KEY),
3061 "::",
3062 stringify!(cbKey)
3063 )
3064 );
3065 assert_eq!(
3066 unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize },
3067 2568usize,
3068 concat!(
3069 "Offset of field: ",
3070 stringify!(_SYMCRYPT_GCM_EXPANDED_KEY),
3071 "::",
3072 stringify!(abKey)
3073 )
3074 );
3075 assert_eq!(
3076 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
3077 2600usize,
3078 concat!(
3079 "Offset of field: ",
3080 stringify!(_SYMCRYPT_GCM_EXPANDED_KEY),
3081 "::",
3082 stringify!(magic)
3083 )
3084 );
3085}
3086impl Default for _SYMCRYPT_GCM_EXPANDED_KEY {
3087 fn default() -> Self {
3088 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3089 unsafe {
3090 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3091 s.assume_init()
3092 }
3093 }
3094}
3095pub type SYMCRYPT_GCM_EXPANDED_KEY = _SYMCRYPT_GCM_EXPANDED_KEY;
3096pub type PSYMCRYPT_GCM_EXPANDED_KEY = *mut _SYMCRYPT_GCM_EXPANDED_KEY;
3097pub type PCSYMCRYPT_GCM_EXPANDED_KEY = *const SYMCRYPT_GCM_EXPANDED_KEY;
3098#[repr(C)]
3099#[repr(align(16))]
3100#[derive(Copy, Clone)]
3101pub struct _SYMCRYPT_GCM_STATE {
3102 pub pKey: PCSYMCRYPT_GCM_EXPANDED_KEY,
3103 pub cbData: UINT64,
3104 pub cbAuthData: UINT64,
3105 pub bytesInMacBlock: SIZE_T,
3106 pub ghashState: SYMCRYPT_GF128_ELEMENT,
3107 pub counterBlock: [BYTE; 16usize],
3108 pub macBlock: [BYTE; 16usize],
3109 pub keystreamBlock: [BYTE; 16usize],
3110 pub magic: SIZE_T,
3111}
3112#[test]
3113fn bindgen_test_layout__SYMCRYPT_GCM_STATE() {
3114 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit();
3115 let ptr = UNINIT.as_ptr();
3116 assert_eq!(
3117 ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(),
3118 112usize,
3119 concat!("Size of: ", stringify!(_SYMCRYPT_GCM_STATE))
3120 );
3121 assert_eq!(
3122 ::std::mem::align_of::<_SYMCRYPT_GCM_STATE>(),
3123 16usize,
3124 concat!("Alignment of ", stringify!(_SYMCRYPT_GCM_STATE))
3125 );
3126 assert_eq!(
3127 unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize },
3128 0usize,
3129 concat!(
3130 "Offset of field: ",
3131 stringify!(_SYMCRYPT_GCM_STATE),
3132 "::",
3133 stringify!(pKey)
3134 )
3135 );
3136 assert_eq!(
3137 unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize },
3138 8usize,
3139 concat!(
3140 "Offset of field: ",
3141 stringify!(_SYMCRYPT_GCM_STATE),
3142 "::",
3143 stringify!(cbData)
3144 )
3145 );
3146 assert_eq!(
3147 unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize },
3148 16usize,
3149 concat!(
3150 "Offset of field: ",
3151 stringify!(_SYMCRYPT_GCM_STATE),
3152 "::",
3153 stringify!(cbAuthData)
3154 )
3155 );
3156 assert_eq!(
3157 unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize },
3158 24usize,
3159 concat!(
3160 "Offset of field: ",
3161 stringify!(_SYMCRYPT_GCM_STATE),
3162 "::",
3163 stringify!(bytesInMacBlock)
3164 )
3165 );
3166 assert_eq!(
3167 unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize },
3168 32usize,
3169 concat!(
3170 "Offset of field: ",
3171 stringify!(_SYMCRYPT_GCM_STATE),
3172 "::",
3173 stringify!(ghashState)
3174 )
3175 );
3176 assert_eq!(
3177 unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize },
3178 48usize,
3179 concat!(
3180 "Offset of field: ",
3181 stringify!(_SYMCRYPT_GCM_STATE),
3182 "::",
3183 stringify!(counterBlock)
3184 )
3185 );
3186 assert_eq!(
3187 unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize },
3188 64usize,
3189 concat!(
3190 "Offset of field: ",
3191 stringify!(_SYMCRYPT_GCM_STATE),
3192 "::",
3193 stringify!(macBlock)
3194 )
3195 );
3196 assert_eq!(
3197 unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize },
3198 80usize,
3199 concat!(
3200 "Offset of field: ",
3201 stringify!(_SYMCRYPT_GCM_STATE),
3202 "::",
3203 stringify!(keystreamBlock)
3204 )
3205 );
3206 assert_eq!(
3207 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
3208 96usize,
3209 concat!(
3210 "Offset of field: ",
3211 stringify!(_SYMCRYPT_GCM_STATE),
3212 "::",
3213 stringify!(magic)
3214 )
3215 );
3216}
3217impl Default for _SYMCRYPT_GCM_STATE {
3218 fn default() -> Self {
3219 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3220 unsafe {
3221 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3222 s.assume_init()
3223 }
3224 }
3225}
3226pub type SYMCRYPT_GCM_STATE = _SYMCRYPT_GCM_STATE;
3227pub type PSYMCRYPT_GCM_STATE = *mut _SYMCRYPT_GCM_STATE;
3228pub type PCSYMCRYPT_GCM_STATE = *const SYMCRYPT_GCM_STATE;
3229pub type PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY = ::std::option::Option<
3230 unsafe extern "C" fn(pExpandedKey: PVOID, pbKey: PCBYTE, cbKey: SIZE_T) -> SYMCRYPT_ERROR,
3231>;
3232pub type PSYMCRYPT_BLOCKCIPHER_CRYPT =
3233 ::std::option::Option<unsafe extern "C" fn(pExpandedKey: PCVOID, pbSrc: PCBYTE, pbDst: PBYTE)>;
3234pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB = ::std::option::Option<
3235 unsafe extern "C" fn(pExpandedKey: PCVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T),
3236>;
3237pub type PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE = ::std::option::Option<
3238 unsafe extern "C" fn(
3239 pExpandedKey: PCVOID,
3240 pbChainingValue: PBYTE,
3241 pbSrc: PCBYTE,
3242 pbDst: PBYTE,
3243 cbData: SIZE_T,
3244 ),
3245>;
3246pub type PSYMCRYPT_BLOCKCIPHER_MAC_MODE = ::std::option::Option<
3247 unsafe extern "C" fn(
3248 pExpandedKey: PCVOID,
3249 pbChainingValue: PBYTE,
3250 pbSrc: PCBYTE,
3251 cbData: SIZE_T,
3252 ),
3253>;
3254pub type PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE = ::std::option::Option<
3255 unsafe extern "C" fn(pState: PVOID, pbSrc: PCBYTE, pbDst: PBYTE, cbData: SIZE_T),
3256>;
3257#[repr(C)]
3258#[derive(Debug, Default, Copy, Clone)]
3259pub struct _SYMCRYPT_BLOCKCIPHER {
3260 pub expandKeyFunc: PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY,
3261 pub encryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT,
3262 pub decryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT,
3263 pub ecbEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB,
3264 pub ecbDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB,
3265 pub cbcEncryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE,
3266 pub cbcDecryptFunc: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE,
3267 pub cbcMacFunc: PSYMCRYPT_BLOCKCIPHER_MAC_MODE,
3268 pub ctrMsb64Func: PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE,
3269 pub gcmEncryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE,
3270 pub gcmDecryptPartFunc: PSYMCRYPT_BLOCKCIPHER_AEADPART_MODE,
3271 pub blockSize: SIZE_T,
3272 pub expandedKeySize: SIZE_T,
3273}
3274#[test]
3275fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() {
3276 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> =
3277 ::std::mem::MaybeUninit::uninit();
3278 let ptr = UNINIT.as_ptr();
3279 assert_eq!(
3280 ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(),
3281 104usize,
3282 concat!("Size of: ", stringify!(_SYMCRYPT_BLOCKCIPHER))
3283 );
3284 assert_eq!(
3285 ::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>(),
3286 8usize,
3287 concat!("Alignment of ", stringify!(_SYMCRYPT_BLOCKCIPHER))
3288 );
3289 assert_eq!(
3290 unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize },
3291 0usize,
3292 concat!(
3293 "Offset of field: ",
3294 stringify!(_SYMCRYPT_BLOCKCIPHER),
3295 "::",
3296 stringify!(expandKeyFunc)
3297 )
3298 );
3299 assert_eq!(
3300 unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize },
3301 8usize,
3302 concat!(
3303 "Offset of field: ",
3304 stringify!(_SYMCRYPT_BLOCKCIPHER),
3305 "::",
3306 stringify!(encryptFunc)
3307 )
3308 );
3309 assert_eq!(
3310 unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize },
3311 16usize,
3312 concat!(
3313 "Offset of field: ",
3314 stringify!(_SYMCRYPT_BLOCKCIPHER),
3315 "::",
3316 stringify!(decryptFunc)
3317 )
3318 );
3319 assert_eq!(
3320 unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize },
3321 24usize,
3322 concat!(
3323 "Offset of field: ",
3324 stringify!(_SYMCRYPT_BLOCKCIPHER),
3325 "::",
3326 stringify!(ecbEncryptFunc)
3327 )
3328 );
3329 assert_eq!(
3330 unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize },
3331 32usize,
3332 concat!(
3333 "Offset of field: ",
3334 stringify!(_SYMCRYPT_BLOCKCIPHER),
3335 "::",
3336 stringify!(ecbDecryptFunc)
3337 )
3338 );
3339 assert_eq!(
3340 unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize },
3341 40usize,
3342 concat!(
3343 "Offset of field: ",
3344 stringify!(_SYMCRYPT_BLOCKCIPHER),
3345 "::",
3346 stringify!(cbcEncryptFunc)
3347 )
3348 );
3349 assert_eq!(
3350 unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize },
3351 48usize,
3352 concat!(
3353 "Offset of field: ",
3354 stringify!(_SYMCRYPT_BLOCKCIPHER),
3355 "::",
3356 stringify!(cbcDecryptFunc)
3357 )
3358 );
3359 assert_eq!(
3360 unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize },
3361 56usize,
3362 concat!(
3363 "Offset of field: ",
3364 stringify!(_SYMCRYPT_BLOCKCIPHER),
3365 "::",
3366 stringify!(cbcMacFunc)
3367 )
3368 );
3369 assert_eq!(
3370 unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize },
3371 64usize,
3372 concat!(
3373 "Offset of field: ",
3374 stringify!(_SYMCRYPT_BLOCKCIPHER),
3375 "::",
3376 stringify!(ctrMsb64Func)
3377 )
3378 );
3379 assert_eq!(
3380 unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize },
3381 72usize,
3382 concat!(
3383 "Offset of field: ",
3384 stringify!(_SYMCRYPT_BLOCKCIPHER),
3385 "::",
3386 stringify!(gcmEncryptPartFunc)
3387 )
3388 );
3389 assert_eq!(
3390 unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize },
3391 80usize,
3392 concat!(
3393 "Offset of field: ",
3394 stringify!(_SYMCRYPT_BLOCKCIPHER),
3395 "::",
3396 stringify!(gcmDecryptPartFunc)
3397 )
3398 );
3399 assert_eq!(
3400 unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize },
3401 88usize,
3402 concat!(
3403 "Offset of field: ",
3404 stringify!(_SYMCRYPT_BLOCKCIPHER),
3405 "::",
3406 stringify!(blockSize)
3407 )
3408 );
3409 assert_eq!(
3410 unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize },
3411 96usize,
3412 concat!(
3413 "Offset of field: ",
3414 stringify!(_SYMCRYPT_BLOCKCIPHER),
3415 "::",
3416 stringify!(expandedKeySize)
3417 )
3418 );
3419}
3420#[repr(C)]
3421#[repr(align(16))]
3422#[derive(Copy, Clone)]
3423pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY {
3424 pub macKey: SYMCRYPT_MAC_EXPANDED_KEY,
3425 pub macAlg: PCSYMCRYPT_MAC,
3426}
3427#[test]
3428fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() {
3429 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> =
3430 ::std::mem::MaybeUninit::uninit();
3431 let ptr = UNINIT.as_ptr();
3432 assert_eq!(
3433 ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(),
3434 560usize,
3435 concat!("Size of: ", stringify!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY))
3436 );
3437 assert_eq!(
3438 ::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(),
3439 16usize,
3440 concat!(
3441 "Alignment of ",
3442 stringify!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY)
3443 )
3444 );
3445 assert_eq!(
3446 unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize },
3447 0usize,
3448 concat!(
3449 "Offset of field: ",
3450 stringify!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY),
3451 "::",
3452 stringify!(macKey)
3453 )
3454 );
3455 assert_eq!(
3456 unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize },
3457 544usize,
3458 concat!(
3459 "Offset of field: ",
3460 stringify!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY),
3461 "::",
3462 stringify!(macAlg)
3463 )
3464 );
3465}
3466impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY {
3467 fn default() -> Self {
3468 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3469 unsafe {
3470 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3471 s.assume_init()
3472 }
3473 }
3474}
3475pub type SYMCRYPT_TLSPRF1_2_EXPANDED_KEY = _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY;
3476pub type PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *mut _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY;
3477pub type PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY = *const SYMCRYPT_TLSPRF1_2_EXPANDED_KEY;
3478#[repr(C)]
3479#[repr(align(16))]
3480#[derive(Copy, Clone)]
3481pub struct _SYMCRYPT_HKDF_EXPANDED_KEY {
3482 pub macKey: SYMCRYPT_MAC_EXPANDED_KEY,
3483 pub macAlg: PCSYMCRYPT_MAC,
3484}
3485#[test]
3486fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() {
3487 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> =
3488 ::std::mem::MaybeUninit::uninit();
3489 let ptr = UNINIT.as_ptr();
3490 assert_eq!(
3491 ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(),
3492 560usize,
3493 concat!("Size of: ", stringify!(_SYMCRYPT_HKDF_EXPANDED_KEY))
3494 );
3495 assert_eq!(
3496 ::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(),
3497 16usize,
3498 concat!("Alignment of ", stringify!(_SYMCRYPT_HKDF_EXPANDED_KEY))
3499 );
3500 assert_eq!(
3501 unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize },
3502 0usize,
3503 concat!(
3504 "Offset of field: ",
3505 stringify!(_SYMCRYPT_HKDF_EXPANDED_KEY),
3506 "::",
3507 stringify!(macKey)
3508 )
3509 );
3510 assert_eq!(
3511 unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize },
3512 544usize,
3513 concat!(
3514 "Offset of field: ",
3515 stringify!(_SYMCRYPT_HKDF_EXPANDED_KEY),
3516 "::",
3517 stringify!(macAlg)
3518 )
3519 );
3520}
3521impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY {
3522 fn default() -> Self {
3523 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3524 unsafe {
3525 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3526 s.assume_init()
3527 }
3528 }
3529}
3530pub type SYMCRYPT_HKDF_EXPANDED_KEY = _SYMCRYPT_HKDF_EXPANDED_KEY;
3531pub type PSYMCRYPT_HKDF_EXPANDED_KEY = *mut _SYMCRYPT_HKDF_EXPANDED_KEY;
3532pub type PCSYMCRYPT_HKDF_EXPANDED_KEY = *const SYMCRYPT_HKDF_EXPANDED_KEY;
3533pub type SYMCRYPT_INT = _SYMCRYPT_INT;
3534pub type PSYMCRYPT_INT = *mut SYMCRYPT_INT;
3535pub type SYMCRYPT_DIVISOR = _SYMCRYPT_DIVISOR;
3536pub type SYMCRYPT_MODULUS = _SYMCRYPT_MODULUS;
3537pub type PSYMCRYPT_MODULUS = *mut SYMCRYPT_MODULUS;
3538pub type SYMCRYPT_MODELEMENT = _SYMCRYPT_MODELEMENT;
3539pub type PSYMCRYPT_MODELEMENT = *mut SYMCRYPT_MODELEMENT;
3540pub type SYMCRYPT_ECPOINT = _SYMCRYPT_ECPOINT;
3541pub type PSYMCRYPT_ECPOINT = *mut SYMCRYPT_ECPOINT;
3542#[repr(C)]
3543#[repr(align(32))]
3544#[derive(Copy, Clone)]
3545pub struct _SYMCRYPT_INT {
3546 pub type_: UINT32,
3547 pub nDigits: UINT32,
3548 pub cbSize: UINT32,
3549 pub magic: SIZE_T,
3550 pub __bindgen_padding_0: [u32; 2usize],
3551 pub ti: _SYMCRYPT_INT__bindgen_ty_1,
3552}
3553#[repr(C)]
3554#[derive(Copy, Clone)]
3555pub union _SYMCRYPT_INT__bindgen_ty_1 {
3556 pub fdef: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1,
3557}
3558#[repr(C)]
3559#[derive(Debug, Default, Copy, Clone)]
3560pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 {
3561 pub uint32: [UINT32; 1usize],
3562}
3563#[test]
3564fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() {
3565 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> =
3566 ::std::mem::MaybeUninit::uninit();
3567 let ptr = UNINIT.as_ptr();
3568 assert_eq!(
3569 ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(),
3570 4usize,
3571 concat!(
3572 "Size of: ",
3573 stringify!(_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1)
3574 )
3575 );
3576 assert_eq!(
3577 ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(),
3578 4usize,
3579 concat!(
3580 "Alignment of ",
3581 stringify!(_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1)
3582 )
3583 );
3584 assert_eq!(
3585 unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize },
3586 0usize,
3587 concat!(
3588 "Offset of field: ",
3589 stringify!(_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1),
3590 "::",
3591 stringify!(uint32)
3592 )
3593 );
3594}
3595#[test]
3596fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() {
3597 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> =
3598 ::std::mem::MaybeUninit::uninit();
3599 let ptr = UNINIT.as_ptr();
3600 assert_eq!(
3601 ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(),
3602 4usize,
3603 concat!("Size of: ", stringify!(_SYMCRYPT_INT__bindgen_ty_1))
3604 );
3605 assert_eq!(
3606 ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(),
3607 4usize,
3608 concat!("Alignment of ", stringify!(_SYMCRYPT_INT__bindgen_ty_1))
3609 );
3610 assert_eq!(
3611 unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize },
3612 0usize,
3613 concat!(
3614 "Offset of field: ",
3615 stringify!(_SYMCRYPT_INT__bindgen_ty_1),
3616 "::",
3617 stringify!(fdef)
3618 )
3619 );
3620}
3621impl Default for _SYMCRYPT_INT__bindgen_ty_1 {
3622 fn default() -> Self {
3623 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3624 unsafe {
3625 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3626 s.assume_init()
3627 }
3628 }
3629}
3630#[test]
3631fn bindgen_test_layout__SYMCRYPT_INT() {
3632 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit();
3633 let ptr = UNINIT.as_ptr();
3634 assert_eq!(
3635 ::std::mem::size_of::<_SYMCRYPT_INT>(),
3636 64usize,
3637 concat!("Size of: ", stringify!(_SYMCRYPT_INT))
3638 );
3639 assert_eq!(
3640 ::std::mem::align_of::<_SYMCRYPT_INT>(),
3641 32usize,
3642 concat!("Alignment of ", stringify!(_SYMCRYPT_INT))
3643 );
3644 assert_eq!(
3645 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
3646 0usize,
3647 concat!(
3648 "Offset of field: ",
3649 stringify!(_SYMCRYPT_INT),
3650 "::",
3651 stringify!(type_)
3652 )
3653 );
3654 assert_eq!(
3655 unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize },
3656 4usize,
3657 concat!(
3658 "Offset of field: ",
3659 stringify!(_SYMCRYPT_INT),
3660 "::",
3661 stringify!(nDigits)
3662 )
3663 );
3664 assert_eq!(
3665 unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize },
3666 8usize,
3667 concat!(
3668 "Offset of field: ",
3669 stringify!(_SYMCRYPT_INT),
3670 "::",
3671 stringify!(cbSize)
3672 )
3673 );
3674 assert_eq!(
3675 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
3676 16usize,
3677 concat!(
3678 "Offset of field: ",
3679 stringify!(_SYMCRYPT_INT),
3680 "::",
3681 stringify!(magic)
3682 )
3683 );
3684 assert_eq!(
3685 unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize },
3686 32usize,
3687 concat!(
3688 "Offset of field: ",
3689 stringify!(_SYMCRYPT_INT),
3690 "::",
3691 stringify!(ti)
3692 )
3693 );
3694}
3695impl Default for _SYMCRYPT_INT {
3696 fn default() -> Self {
3697 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3698 unsafe {
3699 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3700 s.assume_init()
3701 }
3702 }
3703}
3704#[repr(C)]
3705#[repr(align(32))]
3706#[derive(Copy, Clone)]
3707pub struct _SYMCRYPT_DIVISOR {
3708 pub type_: UINT32,
3709 pub nDigits: UINT32,
3710 pub cbSize: UINT32,
3711 pub nBits: UINT32,
3712 pub magic: SIZE_T,
3713 pub td: _SYMCRYPT_DIVISOR__bindgen_ty_1,
3714 pub Int: SYMCRYPT_INT,
3715}
3716#[repr(C)]
3717#[derive(Copy, Clone)]
3718pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 {
3719 pub fdef: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1,
3720}
3721#[repr(C)]
3722#[derive(Debug, Default, Copy, Clone)]
3723pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 {
3724 pub W: UINT64,
3725}
3726#[test]
3727fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() {
3728 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> =
3729 ::std::mem::MaybeUninit::uninit();
3730 let ptr = UNINIT.as_ptr();
3731 assert_eq!(
3732 ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(),
3733 8usize,
3734 concat!(
3735 "Size of: ",
3736 stringify!(_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1)
3737 )
3738 );
3739 assert_eq!(
3740 ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(),
3741 8usize,
3742 concat!(
3743 "Alignment of ",
3744 stringify!(_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1)
3745 )
3746 );
3747 assert_eq!(
3748 unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize },
3749 0usize,
3750 concat!(
3751 "Offset of field: ",
3752 stringify!(_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1),
3753 "::",
3754 stringify!(W)
3755 )
3756 );
3757}
3758#[test]
3759fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() {
3760 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> =
3761 ::std::mem::MaybeUninit::uninit();
3762 let ptr = UNINIT.as_ptr();
3763 assert_eq!(
3764 ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(),
3765 8usize,
3766 concat!("Size of: ", stringify!(_SYMCRYPT_DIVISOR__bindgen_ty_1))
3767 );
3768 assert_eq!(
3769 ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(),
3770 8usize,
3771 concat!("Alignment of ", stringify!(_SYMCRYPT_DIVISOR__bindgen_ty_1))
3772 );
3773 assert_eq!(
3774 unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize },
3775 0usize,
3776 concat!(
3777 "Offset of field: ",
3778 stringify!(_SYMCRYPT_DIVISOR__bindgen_ty_1),
3779 "::",
3780 stringify!(fdef)
3781 )
3782 );
3783}
3784impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 {
3785 fn default() -> Self {
3786 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3787 unsafe {
3788 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3789 s.assume_init()
3790 }
3791 }
3792}
3793#[test]
3794fn bindgen_test_layout__SYMCRYPT_DIVISOR() {
3795 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit();
3796 let ptr = UNINIT.as_ptr();
3797 assert_eq!(
3798 ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(),
3799 96usize,
3800 concat!("Size of: ", stringify!(_SYMCRYPT_DIVISOR))
3801 );
3802 assert_eq!(
3803 ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(),
3804 32usize,
3805 concat!("Alignment of ", stringify!(_SYMCRYPT_DIVISOR))
3806 );
3807 assert_eq!(
3808 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
3809 0usize,
3810 concat!(
3811 "Offset of field: ",
3812 stringify!(_SYMCRYPT_DIVISOR),
3813 "::",
3814 stringify!(type_)
3815 )
3816 );
3817 assert_eq!(
3818 unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize },
3819 4usize,
3820 concat!(
3821 "Offset of field: ",
3822 stringify!(_SYMCRYPT_DIVISOR),
3823 "::",
3824 stringify!(nDigits)
3825 )
3826 );
3827 assert_eq!(
3828 unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize },
3829 8usize,
3830 concat!(
3831 "Offset of field: ",
3832 stringify!(_SYMCRYPT_DIVISOR),
3833 "::",
3834 stringify!(cbSize)
3835 )
3836 );
3837 assert_eq!(
3838 unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize },
3839 12usize,
3840 concat!(
3841 "Offset of field: ",
3842 stringify!(_SYMCRYPT_DIVISOR),
3843 "::",
3844 stringify!(nBits)
3845 )
3846 );
3847 assert_eq!(
3848 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
3849 16usize,
3850 concat!(
3851 "Offset of field: ",
3852 stringify!(_SYMCRYPT_DIVISOR),
3853 "::",
3854 stringify!(magic)
3855 )
3856 );
3857 assert_eq!(
3858 unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize },
3859 24usize,
3860 concat!(
3861 "Offset of field: ",
3862 stringify!(_SYMCRYPT_DIVISOR),
3863 "::",
3864 stringify!(td)
3865 )
3866 );
3867 assert_eq!(
3868 unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize },
3869 32usize,
3870 concat!(
3871 "Offset of field: ",
3872 stringify!(_SYMCRYPT_DIVISOR),
3873 "::",
3874 stringify!(Int)
3875 )
3876 );
3877}
3878impl Default for _SYMCRYPT_DIVISOR {
3879 fn default() -> Self {
3880 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3881 unsafe {
3882 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3883 s.assume_init()
3884 }
3885 }
3886}
3887#[repr(C)]
3888#[repr(align(32))]
3889#[derive(Copy, Clone)]
3890pub struct _SYMCRYPT_MODULUS {
3891 pub type_: UINT32,
3892 pub nDigits: UINT32,
3893 pub cbSize: UINT32,
3894 pub flags: UINT32,
3895 pub cbModElement: UINT32,
3896 pub inv64: UINT64,
3897 pub magic: SIZE_T,
3898 pub tm: _SYMCRYPT_MODULUS__bindgen_ty_1,
3899 pub __bindgen_padding_0: [u64; 2usize],
3900 pub Divisor: SYMCRYPT_DIVISOR,
3901}
3902#[repr(C)]
3903#[derive(Copy, Clone)]
3904pub union _SYMCRYPT_MODULUS__bindgen_ty_1 {
3905 pub montgomery: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1,
3906 pub pseudoMersenne: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2,
3907}
3908#[repr(C)]
3909#[derive(Debug, Copy, Clone)]
3910pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 {
3911 pub Rsqr: PCUINT32,
3912}
3913#[test]
3914fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() {
3915 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> =
3916 ::std::mem::MaybeUninit::uninit();
3917 let ptr = UNINIT.as_ptr();
3918 assert_eq!(
3919 ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(),
3920 8usize,
3921 concat!(
3922 "Size of: ",
3923 stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1)
3924 )
3925 );
3926 assert_eq!(
3927 ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(),
3928 8usize,
3929 concat!(
3930 "Alignment of ",
3931 stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1)
3932 )
3933 );
3934 assert_eq!(
3935 unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize },
3936 0usize,
3937 concat!(
3938 "Offset of field: ",
3939 stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1),
3940 "::",
3941 stringify!(Rsqr)
3942 )
3943 );
3944}
3945impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 {
3946 fn default() -> Self {
3947 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3948 unsafe {
3949 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3950 s.assume_init()
3951 }
3952 }
3953}
3954#[repr(C)]
3955#[derive(Debug, Default, Copy, Clone)]
3956pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 {
3957 pub k: UINT32,
3958}
3959#[test]
3960fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() {
3961 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> =
3962 ::std::mem::MaybeUninit::uninit();
3963 let ptr = UNINIT.as_ptr();
3964 assert_eq!(
3965 ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(),
3966 4usize,
3967 concat!(
3968 "Size of: ",
3969 stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2)
3970 )
3971 );
3972 assert_eq!(
3973 ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(),
3974 4usize,
3975 concat!(
3976 "Alignment of ",
3977 stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2)
3978 )
3979 );
3980 assert_eq!(
3981 unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize },
3982 0usize,
3983 concat!(
3984 "Offset of field: ",
3985 stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2),
3986 "::",
3987 stringify!(k)
3988 )
3989 );
3990}
3991#[test]
3992fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() {
3993 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> =
3994 ::std::mem::MaybeUninit::uninit();
3995 let ptr = UNINIT.as_ptr();
3996 assert_eq!(
3997 ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(),
3998 8usize,
3999 concat!("Size of: ", stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1))
4000 );
4001 assert_eq!(
4002 ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(),
4003 8usize,
4004 concat!("Alignment of ", stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1))
4005 );
4006 assert_eq!(
4007 unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize },
4008 0usize,
4009 concat!(
4010 "Offset of field: ",
4011 stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1),
4012 "::",
4013 stringify!(montgomery)
4014 )
4015 );
4016 assert_eq!(
4017 unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize },
4018 0usize,
4019 concat!(
4020 "Offset of field: ",
4021 stringify!(_SYMCRYPT_MODULUS__bindgen_ty_1),
4022 "::",
4023 stringify!(pseudoMersenne)
4024 )
4025 );
4026}
4027impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 {
4028 fn default() -> Self {
4029 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4030 unsafe {
4031 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4032 s.assume_init()
4033 }
4034 }
4035}
4036#[test]
4037fn bindgen_test_layout__SYMCRYPT_MODULUS() {
4038 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit();
4039 let ptr = UNINIT.as_ptr();
4040 assert_eq!(
4041 ::std::mem::size_of::<_SYMCRYPT_MODULUS>(),
4042 160usize,
4043 concat!("Size of: ", stringify!(_SYMCRYPT_MODULUS))
4044 );
4045 assert_eq!(
4046 ::std::mem::align_of::<_SYMCRYPT_MODULUS>(),
4047 32usize,
4048 concat!("Alignment of ", stringify!(_SYMCRYPT_MODULUS))
4049 );
4050 assert_eq!(
4051 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
4052 0usize,
4053 concat!(
4054 "Offset of field: ",
4055 stringify!(_SYMCRYPT_MODULUS),
4056 "::",
4057 stringify!(type_)
4058 )
4059 );
4060 assert_eq!(
4061 unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize },
4062 4usize,
4063 concat!(
4064 "Offset of field: ",
4065 stringify!(_SYMCRYPT_MODULUS),
4066 "::",
4067 stringify!(nDigits)
4068 )
4069 );
4070 assert_eq!(
4071 unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize },
4072 8usize,
4073 concat!(
4074 "Offset of field: ",
4075 stringify!(_SYMCRYPT_MODULUS),
4076 "::",
4077 stringify!(cbSize)
4078 )
4079 );
4080 assert_eq!(
4081 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
4082 12usize,
4083 concat!(
4084 "Offset of field: ",
4085 stringify!(_SYMCRYPT_MODULUS),
4086 "::",
4087 stringify!(flags)
4088 )
4089 );
4090 assert_eq!(
4091 unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize },
4092 16usize,
4093 concat!(
4094 "Offset of field: ",
4095 stringify!(_SYMCRYPT_MODULUS),
4096 "::",
4097 stringify!(cbModElement)
4098 )
4099 );
4100 assert_eq!(
4101 unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize },
4102 24usize,
4103 concat!(
4104 "Offset of field: ",
4105 stringify!(_SYMCRYPT_MODULUS),
4106 "::",
4107 stringify!(inv64)
4108 )
4109 );
4110 assert_eq!(
4111 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
4112 32usize,
4113 concat!(
4114 "Offset of field: ",
4115 stringify!(_SYMCRYPT_MODULUS),
4116 "::",
4117 stringify!(magic)
4118 )
4119 );
4120 assert_eq!(
4121 unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize },
4122 40usize,
4123 concat!(
4124 "Offset of field: ",
4125 stringify!(_SYMCRYPT_MODULUS),
4126 "::",
4127 stringify!(tm)
4128 )
4129 );
4130 assert_eq!(
4131 unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize },
4132 64usize,
4133 concat!(
4134 "Offset of field: ",
4135 stringify!(_SYMCRYPT_MODULUS),
4136 "::",
4137 stringify!(Divisor)
4138 )
4139 );
4140}
4141impl Default for _SYMCRYPT_MODULUS {
4142 fn default() -> Self {
4143 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4144 unsafe {
4145 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4146 s.assume_init()
4147 }
4148 }
4149}
4150#[repr(C)]
4151#[repr(align(32))]
4152#[derive(Copy, Clone)]
4153pub struct _SYMCRYPT_MODELEMENT {
4154 pub d: _SYMCRYPT_MODELEMENT__bindgen_ty_1,
4155}
4156#[repr(C)]
4157#[derive(Copy, Clone)]
4158pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 {
4159 pub uint32: [UINT32; 1usize],
4160}
4161#[test]
4162fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() {
4163 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> =
4164 ::std::mem::MaybeUninit::uninit();
4165 let ptr = UNINIT.as_ptr();
4166 assert_eq!(
4167 ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(),
4168 4usize,
4169 concat!("Size of: ", stringify!(_SYMCRYPT_MODELEMENT__bindgen_ty_1))
4170 );
4171 assert_eq!(
4172 ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(),
4173 4usize,
4174 concat!(
4175 "Alignment of ",
4176 stringify!(_SYMCRYPT_MODELEMENT__bindgen_ty_1)
4177 )
4178 );
4179 assert_eq!(
4180 unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize },
4181 0usize,
4182 concat!(
4183 "Offset of field: ",
4184 stringify!(_SYMCRYPT_MODELEMENT__bindgen_ty_1),
4185 "::",
4186 stringify!(uint32)
4187 )
4188 );
4189}
4190impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 {
4191 fn default() -> Self {
4192 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4193 unsafe {
4194 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4195 s.assume_init()
4196 }
4197 }
4198}
4199#[test]
4200fn bindgen_test_layout__SYMCRYPT_MODELEMENT() {
4201 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit();
4202 let ptr = UNINIT.as_ptr();
4203 assert_eq!(
4204 ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(),
4205 32usize,
4206 concat!("Size of: ", stringify!(_SYMCRYPT_MODELEMENT))
4207 );
4208 assert_eq!(
4209 ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(),
4210 32usize,
4211 concat!("Alignment of ", stringify!(_SYMCRYPT_MODELEMENT))
4212 );
4213 assert_eq!(
4214 unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
4215 0usize,
4216 concat!(
4217 "Offset of field: ",
4218 stringify!(_SYMCRYPT_MODELEMENT),
4219 "::",
4220 stringify!(d)
4221 )
4222 );
4223}
4224impl Default for _SYMCRYPT_MODELEMENT {
4225 fn default() -> Self {
4226 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4227 unsafe {
4228 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4229 s.assume_init()
4230 }
4231 }
4232}
4233#[repr(C)]
4234#[repr(align(32))]
4235#[derive(Debug, Copy, Clone)]
4236pub struct _SYMCRYPT_RSAKEY {
4237 pub fAlgorithmInfo: UINT32,
4238 pub cbTotalSize: UINT32,
4239 pub hasPrivateKey: BOOLEAN,
4240 pub nSetBitsOfModulus: UINT32,
4241 pub nBitsOfModulus: UINT32,
4242 pub nDigitsOfModulus: UINT32,
4243 pub nPubExp: UINT32,
4244 pub nPrimes: UINT32,
4245 pub nBitsOfPrimes: [UINT32; 2usize],
4246 pub nDigitsOfPrimes: [UINT32; 2usize],
4247 pub nMaxDigitsOfPrimes: UINT32,
4248 pub au64PubExp: [UINT64; 1usize],
4249 pub pbPrimes: [PBYTE; 2usize],
4250 pub pbCrtInverses: [PBYTE; 2usize],
4251 pub pbPrivExps: [PBYTE; 1usize],
4252 pub pbCrtPrivExps: [PBYTE; 2usize],
4253 pub pmModulus: PSYMCRYPT_MODULUS,
4254 pub pmPrimes: [PSYMCRYPT_MODULUS; 2usize],
4255 pub peCrtInverses: [PSYMCRYPT_MODELEMENT; 2usize],
4256 pub piPrivExps: [PSYMCRYPT_INT; 1usize],
4257 pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize],
4258 pub magic: SIZE_T,
4259}
4260#[test]
4261fn bindgen_test_layout__SYMCRYPT_RSAKEY() {
4262 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit();
4263 let ptr = UNINIT.as_ptr();
4264 assert_eq!(
4265 ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(),
4266 192usize,
4267 concat!("Size of: ", stringify!(_SYMCRYPT_RSAKEY))
4268 );
4269 assert_eq!(
4270 ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(),
4271 32usize,
4272 concat!("Alignment of ", stringify!(_SYMCRYPT_RSAKEY))
4273 );
4274 assert_eq!(
4275 unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize },
4276 0usize,
4277 concat!(
4278 "Offset of field: ",
4279 stringify!(_SYMCRYPT_RSAKEY),
4280 "::",
4281 stringify!(fAlgorithmInfo)
4282 )
4283 );
4284 assert_eq!(
4285 unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize },
4286 4usize,
4287 concat!(
4288 "Offset of field: ",
4289 stringify!(_SYMCRYPT_RSAKEY),
4290 "::",
4291 stringify!(cbTotalSize)
4292 )
4293 );
4294 assert_eq!(
4295 unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize },
4296 8usize,
4297 concat!(
4298 "Offset of field: ",
4299 stringify!(_SYMCRYPT_RSAKEY),
4300 "::",
4301 stringify!(hasPrivateKey)
4302 )
4303 );
4304 assert_eq!(
4305 unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize },
4306 12usize,
4307 concat!(
4308 "Offset of field: ",
4309 stringify!(_SYMCRYPT_RSAKEY),
4310 "::",
4311 stringify!(nSetBitsOfModulus)
4312 )
4313 );
4314 assert_eq!(
4315 unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize },
4316 16usize,
4317 concat!(
4318 "Offset of field: ",
4319 stringify!(_SYMCRYPT_RSAKEY),
4320 "::",
4321 stringify!(nBitsOfModulus)
4322 )
4323 );
4324 assert_eq!(
4325 unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize },
4326 20usize,
4327 concat!(
4328 "Offset of field: ",
4329 stringify!(_SYMCRYPT_RSAKEY),
4330 "::",
4331 stringify!(nDigitsOfModulus)
4332 )
4333 );
4334 assert_eq!(
4335 unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize },
4336 24usize,
4337 concat!(
4338 "Offset of field: ",
4339 stringify!(_SYMCRYPT_RSAKEY),
4340 "::",
4341 stringify!(nPubExp)
4342 )
4343 );
4344 assert_eq!(
4345 unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize },
4346 28usize,
4347 concat!(
4348 "Offset of field: ",
4349 stringify!(_SYMCRYPT_RSAKEY),
4350 "::",
4351 stringify!(nPrimes)
4352 )
4353 );
4354 assert_eq!(
4355 unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize },
4356 32usize,
4357 concat!(
4358 "Offset of field: ",
4359 stringify!(_SYMCRYPT_RSAKEY),
4360 "::",
4361 stringify!(nBitsOfPrimes)
4362 )
4363 );
4364 assert_eq!(
4365 unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize },
4366 40usize,
4367 concat!(
4368 "Offset of field: ",
4369 stringify!(_SYMCRYPT_RSAKEY),
4370 "::",
4371 stringify!(nDigitsOfPrimes)
4372 )
4373 );
4374 assert_eq!(
4375 unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize },
4376 48usize,
4377 concat!(
4378 "Offset of field: ",
4379 stringify!(_SYMCRYPT_RSAKEY),
4380 "::",
4381 stringify!(nMaxDigitsOfPrimes)
4382 )
4383 );
4384 assert_eq!(
4385 unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize },
4386 56usize,
4387 concat!(
4388 "Offset of field: ",
4389 stringify!(_SYMCRYPT_RSAKEY),
4390 "::",
4391 stringify!(au64PubExp)
4392 )
4393 );
4394 assert_eq!(
4395 unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize },
4396 64usize,
4397 concat!(
4398 "Offset of field: ",
4399 stringify!(_SYMCRYPT_RSAKEY),
4400 "::",
4401 stringify!(pbPrimes)
4402 )
4403 );
4404 assert_eq!(
4405 unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize },
4406 80usize,
4407 concat!(
4408 "Offset of field: ",
4409 stringify!(_SYMCRYPT_RSAKEY),
4410 "::",
4411 stringify!(pbCrtInverses)
4412 )
4413 );
4414 assert_eq!(
4415 unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize },
4416 96usize,
4417 concat!(
4418 "Offset of field: ",
4419 stringify!(_SYMCRYPT_RSAKEY),
4420 "::",
4421 stringify!(pbPrivExps)
4422 )
4423 );
4424 assert_eq!(
4425 unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize },
4426 104usize,
4427 concat!(
4428 "Offset of field: ",
4429 stringify!(_SYMCRYPT_RSAKEY),
4430 "::",
4431 stringify!(pbCrtPrivExps)
4432 )
4433 );
4434 assert_eq!(
4435 unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize },
4436 120usize,
4437 concat!(
4438 "Offset of field: ",
4439 stringify!(_SYMCRYPT_RSAKEY),
4440 "::",
4441 stringify!(pmModulus)
4442 )
4443 );
4444 assert_eq!(
4445 unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize },
4446 128usize,
4447 concat!(
4448 "Offset of field: ",
4449 stringify!(_SYMCRYPT_RSAKEY),
4450 "::",
4451 stringify!(pmPrimes)
4452 )
4453 );
4454 assert_eq!(
4455 unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize },
4456 144usize,
4457 concat!(
4458 "Offset of field: ",
4459 stringify!(_SYMCRYPT_RSAKEY),
4460 "::",
4461 stringify!(peCrtInverses)
4462 )
4463 );
4464 assert_eq!(
4465 unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize },
4466 160usize,
4467 concat!(
4468 "Offset of field: ",
4469 stringify!(_SYMCRYPT_RSAKEY),
4470 "::",
4471 stringify!(piPrivExps)
4472 )
4473 );
4474 assert_eq!(
4475 unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize },
4476 168usize,
4477 concat!(
4478 "Offset of field: ",
4479 stringify!(_SYMCRYPT_RSAKEY),
4480 "::",
4481 stringify!(piCrtPrivExps)
4482 )
4483 );
4484 assert_eq!(
4485 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
4486 184usize,
4487 concat!(
4488 "Offset of field: ",
4489 stringify!(_SYMCRYPT_RSAKEY),
4490 "::",
4491 stringify!(magic)
4492 )
4493 );
4494}
4495impl Default for _SYMCRYPT_RSAKEY {
4496 fn default() -> Self {
4497 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4498 unsafe {
4499 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4500 s.assume_init()
4501 }
4502 }
4503}
4504pub type SYMCRYPT_RSAKEY = _SYMCRYPT_RSAKEY;
4505pub type PSYMCRYPT_RSAKEY = *mut SYMCRYPT_RSAKEY;
4506pub type PCSYMCRYPT_RSAKEY = *const SYMCRYPT_RSAKEY;
4507pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_INVALID:
4508 _SYMCRYPT_ECPOINT_COORDINATES = 0;
4509pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE:
4510 _SYMCRYPT_ECPOINT_COORDINATES = 17;
4511pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_AFFINE:
4512 _SYMCRYPT_ECPOINT_COORDINATES = 34;
4513pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_PROJECTIVE:
4514 _SYMCRYPT_ECPOINT_COORDINATES = 51;
4515pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_JACOBIAN:
4516 _SYMCRYPT_ECPOINT_COORDINATES = 67;
4517pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_EXTENDED_PROJECTIVE:
4518 _SYMCRYPT_ECPOINT_COORDINATES = 84;
4519pub const _SYMCRYPT_ECPOINT_COORDINATES_SYMCRYPT_ECPOINT_COORDINATES_SINGLE_PROJECTIVE:
4520 _SYMCRYPT_ECPOINT_COORDINATES = 98;
4521pub type _SYMCRYPT_ECPOINT_COORDINATES = ::std::os::raw::c_uint;
4522pub use self::_SYMCRYPT_ECPOINT_COORDINATES as SYMCRYPT_ECPOINT_COORDINATES;
4523#[repr(C)]
4524#[derive(Debug, Copy, Clone)]
4525pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP {
4526 pub window: UINT32,
4527 pub nPrecompPoints: UINT32,
4528 pub nRecodedDigits: UINT32,
4529 pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize],
4530}
4531#[test]
4532fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() {
4533 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> =
4534 ::std::mem::MaybeUninit::uninit();
4535 let ptr = UNINIT.as_ptr();
4536 assert_eq!(
4537 ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(),
4538 528usize,
4539 concat!("Size of: ", stringify!(_SYMCRYPT_ECURVE_INFO_PRECOMP))
4540 );
4541 assert_eq!(
4542 ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(),
4543 8usize,
4544 concat!("Alignment of ", stringify!(_SYMCRYPT_ECURVE_INFO_PRECOMP))
4545 );
4546 assert_eq!(
4547 unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
4548 0usize,
4549 concat!(
4550 "Offset of field: ",
4551 stringify!(_SYMCRYPT_ECURVE_INFO_PRECOMP),
4552 "::",
4553 stringify!(window)
4554 )
4555 );
4556 assert_eq!(
4557 unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize },
4558 4usize,
4559 concat!(
4560 "Offset of field: ",
4561 stringify!(_SYMCRYPT_ECURVE_INFO_PRECOMP),
4562 "::",
4563 stringify!(nPrecompPoints)
4564 )
4565 );
4566 assert_eq!(
4567 unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize },
4568 8usize,
4569 concat!(
4570 "Offset of field: ",
4571 stringify!(_SYMCRYPT_ECURVE_INFO_PRECOMP),
4572 "::",
4573 stringify!(nRecodedDigits)
4574 )
4575 );
4576 assert_eq!(
4577 unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize },
4578 16usize,
4579 concat!(
4580 "Offset of field: ",
4581 stringify!(_SYMCRYPT_ECURVE_INFO_PRECOMP),
4582 "::",
4583 stringify!(poPrecompPoints)
4584 )
4585 );
4586}
4587impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP {
4588 fn default() -> Self {
4589 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4590 unsafe {
4591 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4592 s.assume_init()
4593 }
4594 }
4595}
4596pub type SYMCRYPT_ECURVE_INFO_PRECOMP = _SYMCRYPT_ECURVE_INFO_PRECOMP;
4597pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS:
4598 _SYMCRYPT_INTERNAL_ECURVE_TYPE = 1;
4599pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_TWISTED_EDWARDS:
4600 _SYMCRYPT_INTERNAL_ECURVE_TYPE = 2;
4601pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_MONTGOMERY:
4602 _SYMCRYPT_INTERNAL_ECURVE_TYPE = 3;
4603pub const _SYMCRYPT_INTERNAL_ECURVE_TYPE_SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS_AM3:
4604 _SYMCRYPT_INTERNAL_ECURVE_TYPE = 4;
4605pub type _SYMCRYPT_INTERNAL_ECURVE_TYPE = ::std::os::raw::c_uint;
4606pub use self::_SYMCRYPT_INTERNAL_ECURVE_TYPE as SYMCRYPT_INTERNAL_ECURVE_TYPE;
4607#[repr(C)]
4608#[repr(align(32))]
4609#[derive(Copy, Clone)]
4610pub struct _SYMCRYPT_ECURVE {
4611 pub version: UINT32,
4612 pub type_: SYMCRYPT_INTERNAL_ECURVE_TYPE,
4613 pub eCoordinates: SYMCRYPT_ECPOINT_COORDINATES,
4614 pub FModBitsize: UINT32,
4615 pub FModDigits: UINT32,
4616 pub FModBytesize: UINT32,
4617 pub GOrdBitsize: UINT32,
4618 pub GOrdDigits: UINT32,
4619 pub GOrdBytesize: UINT32,
4620 pub cbModElement: UINT32,
4621 pub cbAlloc: UINT32,
4622 pub cbScratchCommon: UINT32,
4623 pub cbScratchScalar: UINT32,
4624 pub cbScratchScalarMulti: UINT32,
4625 pub cbScratchGetSetValue: UINT32,
4626 pub cbScratchEckey: UINT32,
4627 pub coFactorPower: UINT32,
4628 pub PrivateKeyDefaultFormat: UINT32,
4629 pub HighBitRestrictionNumOfBits: UINT32,
4630 pub HighBitRestrictionPosition: UINT32,
4631 pub HighBitRestrictionValue: UINT32,
4632 pub info: _SYMCRYPT_ECURVE__bindgen_ty_1,
4633 pub FMod: PSYMCRYPT_MODULUS,
4634 pub GOrd: PSYMCRYPT_MODULUS,
4635 pub A: PSYMCRYPT_MODELEMENT,
4636 pub B: PSYMCRYPT_MODELEMENT,
4637 pub G: PSYMCRYPT_ECPOINT,
4638 pub H: PSYMCRYPT_INT,
4639 pub magic: SIZE_T,
4640}
4641#[repr(C)]
4642#[derive(Copy, Clone)]
4643pub union _SYMCRYPT_ECURVE__bindgen_ty_1 {
4644 pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP,
4645}
4646#[test]
4647fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() {
4648 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> =
4649 ::std::mem::MaybeUninit::uninit();
4650 let ptr = UNINIT.as_ptr();
4651 assert_eq!(
4652 ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(),
4653 528usize,
4654 concat!("Size of: ", stringify!(_SYMCRYPT_ECURVE__bindgen_ty_1))
4655 );
4656 assert_eq!(
4657 ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(),
4658 8usize,
4659 concat!("Alignment of ", stringify!(_SYMCRYPT_ECURVE__bindgen_ty_1))
4660 );
4661 assert_eq!(
4662 unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize },
4663 0usize,
4664 concat!(
4665 "Offset of field: ",
4666 stringify!(_SYMCRYPT_ECURVE__bindgen_ty_1),
4667 "::",
4668 stringify!(sw)
4669 )
4670 );
4671}
4672impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 {
4673 fn default() -> Self {
4674 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4675 unsafe {
4676 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4677 s.assume_init()
4678 }
4679 }
4680}
4681#[test]
4682fn bindgen_test_layout__SYMCRYPT_ECURVE() {
4683 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit();
4684 let ptr = UNINIT.as_ptr();
4685 assert_eq!(
4686 ::std::mem::size_of::<_SYMCRYPT_ECURVE>(),
4687 672usize,
4688 concat!("Size of: ", stringify!(_SYMCRYPT_ECURVE))
4689 );
4690 assert_eq!(
4691 ::std::mem::align_of::<_SYMCRYPT_ECURVE>(),
4692 32usize,
4693 concat!("Alignment of ", stringify!(_SYMCRYPT_ECURVE))
4694 );
4695 assert_eq!(
4696 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
4697 0usize,
4698 concat!(
4699 "Offset of field: ",
4700 stringify!(_SYMCRYPT_ECURVE),
4701 "::",
4702 stringify!(version)
4703 )
4704 );
4705 assert_eq!(
4706 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
4707 4usize,
4708 concat!(
4709 "Offset of field: ",
4710 stringify!(_SYMCRYPT_ECURVE),
4711 "::",
4712 stringify!(type_)
4713 )
4714 );
4715 assert_eq!(
4716 unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize },
4717 8usize,
4718 concat!(
4719 "Offset of field: ",
4720 stringify!(_SYMCRYPT_ECURVE),
4721 "::",
4722 stringify!(eCoordinates)
4723 )
4724 );
4725 assert_eq!(
4726 unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize },
4727 12usize,
4728 concat!(
4729 "Offset of field: ",
4730 stringify!(_SYMCRYPT_ECURVE),
4731 "::",
4732 stringify!(FModBitsize)
4733 )
4734 );
4735 assert_eq!(
4736 unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize },
4737 16usize,
4738 concat!(
4739 "Offset of field: ",
4740 stringify!(_SYMCRYPT_ECURVE),
4741 "::",
4742 stringify!(FModDigits)
4743 )
4744 );
4745 assert_eq!(
4746 unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize },
4747 20usize,
4748 concat!(
4749 "Offset of field: ",
4750 stringify!(_SYMCRYPT_ECURVE),
4751 "::",
4752 stringify!(FModBytesize)
4753 )
4754 );
4755 assert_eq!(
4756 unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize },
4757 24usize,
4758 concat!(
4759 "Offset of field: ",
4760 stringify!(_SYMCRYPT_ECURVE),
4761 "::",
4762 stringify!(GOrdBitsize)
4763 )
4764 );
4765 assert_eq!(
4766 unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize },
4767 28usize,
4768 concat!(
4769 "Offset of field: ",
4770 stringify!(_SYMCRYPT_ECURVE),
4771 "::",
4772 stringify!(GOrdDigits)
4773 )
4774 );
4775 assert_eq!(
4776 unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize },
4777 32usize,
4778 concat!(
4779 "Offset of field: ",
4780 stringify!(_SYMCRYPT_ECURVE),
4781 "::",
4782 stringify!(GOrdBytesize)
4783 )
4784 );
4785 assert_eq!(
4786 unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize },
4787 36usize,
4788 concat!(
4789 "Offset of field: ",
4790 stringify!(_SYMCRYPT_ECURVE),
4791 "::",
4792 stringify!(cbModElement)
4793 )
4794 );
4795 assert_eq!(
4796 unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize },
4797 40usize,
4798 concat!(
4799 "Offset of field: ",
4800 stringify!(_SYMCRYPT_ECURVE),
4801 "::",
4802 stringify!(cbAlloc)
4803 )
4804 );
4805 assert_eq!(
4806 unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize },
4807 44usize,
4808 concat!(
4809 "Offset of field: ",
4810 stringify!(_SYMCRYPT_ECURVE),
4811 "::",
4812 stringify!(cbScratchCommon)
4813 )
4814 );
4815 assert_eq!(
4816 unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize },
4817 48usize,
4818 concat!(
4819 "Offset of field: ",
4820 stringify!(_SYMCRYPT_ECURVE),
4821 "::",
4822 stringify!(cbScratchScalar)
4823 )
4824 );
4825 assert_eq!(
4826 unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize },
4827 52usize,
4828 concat!(
4829 "Offset of field: ",
4830 stringify!(_SYMCRYPT_ECURVE),
4831 "::",
4832 stringify!(cbScratchScalarMulti)
4833 )
4834 );
4835 assert_eq!(
4836 unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize },
4837 56usize,
4838 concat!(
4839 "Offset of field: ",
4840 stringify!(_SYMCRYPT_ECURVE),
4841 "::",
4842 stringify!(cbScratchGetSetValue)
4843 )
4844 );
4845 assert_eq!(
4846 unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize },
4847 60usize,
4848 concat!(
4849 "Offset of field: ",
4850 stringify!(_SYMCRYPT_ECURVE),
4851 "::",
4852 stringify!(cbScratchEckey)
4853 )
4854 );
4855 assert_eq!(
4856 unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize },
4857 64usize,
4858 concat!(
4859 "Offset of field: ",
4860 stringify!(_SYMCRYPT_ECURVE),
4861 "::",
4862 stringify!(coFactorPower)
4863 )
4864 );
4865 assert_eq!(
4866 unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize },
4867 68usize,
4868 concat!(
4869 "Offset of field: ",
4870 stringify!(_SYMCRYPT_ECURVE),
4871 "::",
4872 stringify!(PrivateKeyDefaultFormat)
4873 )
4874 );
4875 assert_eq!(
4876 unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize },
4877 72usize,
4878 concat!(
4879 "Offset of field: ",
4880 stringify!(_SYMCRYPT_ECURVE),
4881 "::",
4882 stringify!(HighBitRestrictionNumOfBits)
4883 )
4884 );
4885 assert_eq!(
4886 unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize },
4887 76usize,
4888 concat!(
4889 "Offset of field: ",
4890 stringify!(_SYMCRYPT_ECURVE),
4891 "::",
4892 stringify!(HighBitRestrictionPosition)
4893 )
4894 );
4895 assert_eq!(
4896 unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize },
4897 80usize,
4898 concat!(
4899 "Offset of field: ",
4900 stringify!(_SYMCRYPT_ECURVE),
4901 "::",
4902 stringify!(HighBitRestrictionValue)
4903 )
4904 );
4905 assert_eq!(
4906 unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize },
4907 88usize,
4908 concat!(
4909 "Offset of field: ",
4910 stringify!(_SYMCRYPT_ECURVE),
4911 "::",
4912 stringify!(info)
4913 )
4914 );
4915 assert_eq!(
4916 unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize },
4917 616usize,
4918 concat!(
4919 "Offset of field: ",
4920 stringify!(_SYMCRYPT_ECURVE),
4921 "::",
4922 stringify!(FMod)
4923 )
4924 );
4925 assert_eq!(
4926 unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize },
4927 624usize,
4928 concat!(
4929 "Offset of field: ",
4930 stringify!(_SYMCRYPT_ECURVE),
4931 "::",
4932 stringify!(GOrd)
4933 )
4934 );
4935 assert_eq!(
4936 unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize },
4937 632usize,
4938 concat!(
4939 "Offset of field: ",
4940 stringify!(_SYMCRYPT_ECURVE),
4941 "::",
4942 stringify!(A)
4943 )
4944 );
4945 assert_eq!(
4946 unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize },
4947 640usize,
4948 concat!(
4949 "Offset of field: ",
4950 stringify!(_SYMCRYPT_ECURVE),
4951 "::",
4952 stringify!(B)
4953 )
4954 );
4955 assert_eq!(
4956 unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize },
4957 648usize,
4958 concat!(
4959 "Offset of field: ",
4960 stringify!(_SYMCRYPT_ECURVE),
4961 "::",
4962 stringify!(G)
4963 )
4964 );
4965 assert_eq!(
4966 unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize },
4967 656usize,
4968 concat!(
4969 "Offset of field: ",
4970 stringify!(_SYMCRYPT_ECURVE),
4971 "::",
4972 stringify!(H)
4973 )
4974 );
4975 assert_eq!(
4976 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
4977 664usize,
4978 concat!(
4979 "Offset of field: ",
4980 stringify!(_SYMCRYPT_ECURVE),
4981 "::",
4982 stringify!(magic)
4983 )
4984 );
4985}
4986impl Default for _SYMCRYPT_ECURVE {
4987 fn default() -> Self {
4988 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4989 unsafe {
4990 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4991 s.assume_init()
4992 }
4993 }
4994}
4995pub type SYMCRYPT_ECURVE = _SYMCRYPT_ECURVE;
4996pub type PSYMCRYPT_ECURVE = *mut SYMCRYPT_ECURVE;
4997pub type PCSYMCRYPT_ECURVE = *const SYMCRYPT_ECURVE;
4998#[repr(C)]
4999#[repr(align(32))]
5000#[derive(Debug, Copy, Clone)]
5001pub struct _SYMCRYPT_ECPOINT {
5002 pub normalized: BOOLEAN,
5003 pub pCurve: PCSYMCRYPT_ECURVE,
5004 pub magic: SIZE_T,
5005}
5006#[test]
5007fn bindgen_test_layout__SYMCRYPT_ECPOINT() {
5008 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit();
5009 let ptr = UNINIT.as_ptr();
5010 assert_eq!(
5011 ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(),
5012 32usize,
5013 concat!("Size of: ", stringify!(_SYMCRYPT_ECPOINT))
5014 );
5015 assert_eq!(
5016 ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(),
5017 32usize,
5018 concat!("Alignment of ", stringify!(_SYMCRYPT_ECPOINT))
5019 );
5020 assert_eq!(
5021 unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize },
5022 0usize,
5023 concat!(
5024 "Offset of field: ",
5025 stringify!(_SYMCRYPT_ECPOINT),
5026 "::",
5027 stringify!(normalized)
5028 )
5029 );
5030 assert_eq!(
5031 unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize },
5032 8usize,
5033 concat!(
5034 "Offset of field: ",
5035 stringify!(_SYMCRYPT_ECPOINT),
5036 "::",
5037 stringify!(pCurve)
5038 )
5039 );
5040 assert_eq!(
5041 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
5042 16usize,
5043 concat!(
5044 "Offset of field: ",
5045 stringify!(_SYMCRYPT_ECPOINT),
5046 "::",
5047 stringify!(magic)
5048 )
5049 );
5050}
5051impl Default for _SYMCRYPT_ECPOINT {
5052 fn default() -> Self {
5053 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5054 unsafe {
5055 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5056 s.assume_init()
5057 }
5058 }
5059}
5060#[repr(C)]
5061#[repr(align(32))]
5062#[derive(Debug, Copy, Clone)]
5063pub struct _SYMCRYPT_ECKEY {
5064 pub fAlgorithmInfo: UINT32,
5065 pub hasPrivateKey: BOOLEAN,
5066 pub pCurve: PCSYMCRYPT_ECURVE,
5067 pub poPublicKey: PSYMCRYPT_ECPOINT,
5068 pub piPrivateKey: PSYMCRYPT_INT,
5069 pub magic: SIZE_T,
5070}
5071#[test]
5072fn bindgen_test_layout__SYMCRYPT_ECKEY() {
5073 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit();
5074 let ptr = UNINIT.as_ptr();
5075 assert_eq!(
5076 ::std::mem::size_of::<_SYMCRYPT_ECKEY>(),
5077 64usize,
5078 concat!("Size of: ", stringify!(_SYMCRYPT_ECKEY))
5079 );
5080 assert_eq!(
5081 ::std::mem::align_of::<_SYMCRYPT_ECKEY>(),
5082 32usize,
5083 concat!("Alignment of ", stringify!(_SYMCRYPT_ECKEY))
5084 );
5085 assert_eq!(
5086 unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize },
5087 0usize,
5088 concat!(
5089 "Offset of field: ",
5090 stringify!(_SYMCRYPT_ECKEY),
5091 "::",
5092 stringify!(fAlgorithmInfo)
5093 )
5094 );
5095 assert_eq!(
5096 unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize },
5097 4usize,
5098 concat!(
5099 "Offset of field: ",
5100 stringify!(_SYMCRYPT_ECKEY),
5101 "::",
5102 stringify!(hasPrivateKey)
5103 )
5104 );
5105 assert_eq!(
5106 unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize },
5107 8usize,
5108 concat!(
5109 "Offset of field: ",
5110 stringify!(_SYMCRYPT_ECKEY),
5111 "::",
5112 stringify!(pCurve)
5113 )
5114 );
5115 assert_eq!(
5116 unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize },
5117 16usize,
5118 concat!(
5119 "Offset of field: ",
5120 stringify!(_SYMCRYPT_ECKEY),
5121 "::",
5122 stringify!(poPublicKey)
5123 )
5124 );
5125 assert_eq!(
5126 unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize },
5127 24usize,
5128 concat!(
5129 "Offset of field: ",
5130 stringify!(_SYMCRYPT_ECKEY),
5131 "::",
5132 stringify!(piPrivateKey)
5133 )
5134 );
5135 assert_eq!(
5136 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
5137 32usize,
5138 concat!(
5139 "Offset of field: ",
5140 stringify!(_SYMCRYPT_ECKEY),
5141 "::",
5142 stringify!(magic)
5143 )
5144 );
5145}
5146impl Default for _SYMCRYPT_ECKEY {
5147 fn default() -> Self {
5148 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5149 unsafe {
5150 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5151 s.assume_init()
5152 }
5153 }
5154}
5155pub type SYMCRYPT_ECKEY = _SYMCRYPT_ECKEY;
5156pub type PSYMCRYPT_ECKEY = *mut SYMCRYPT_ECKEY;
5157pub type PCSYMCRYPT_ECKEY = *const SYMCRYPT_ECKEY;
5158extern "C" {
5159 pub fn SymCryptWipe(pbData: PVOID, cbData: SIZE_T);
5160}
5161extern "C" {
5162 pub fn SymCryptLoadMsbFirstUint64(
5163 pbSrc: PCBYTE,
5164 cbSrc: SIZE_T,
5165 pDst: PUINT64,
5166 ) -> SYMCRYPT_ERROR;
5167}
5168extern "C" {
5169 pub fn SymCryptStoreMsbFirstUint64(src: UINT64, pbDst: PBYTE, cbDst: SIZE_T) -> SYMCRYPT_ERROR;
5170}
5171extern "C" {
5172 pub fn SymCryptModuleInit(api: UINT32, minor: UINT32);
5173}
5174extern "C" {
5175 pub fn SymCryptMd5(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE);
5176}
5177extern "C" {
5178 pub fn SymCryptMd5Init(pState: PSYMCRYPT_MD5_STATE);
5179}
5180extern "C" {
5181 pub fn SymCryptMd5Append(pState: PSYMCRYPT_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T);
5182}
5183extern "C" {
5184 pub fn SymCryptMd5Result(pState: PSYMCRYPT_MD5_STATE, pbResult: PBYTE);
5185}
5186extern "C" {
5187 pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE);
5188}
5189extern "C" {
5190 pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH;
5191}
5192extern "C" {
5193 pub fn SymCryptSha1(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE);
5194}
5195extern "C" {
5196 pub fn SymCryptSha1Init(pState: PSYMCRYPT_SHA1_STATE);
5197}
5198extern "C" {
5199 pub fn SymCryptSha1Append(pState: PSYMCRYPT_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T);
5200}
5201extern "C" {
5202 pub fn SymCryptSha1Result(pState: PSYMCRYPT_SHA1_STATE, pbResult: PBYTE);
5203}
5204extern "C" {
5205 pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE);
5206}
5207extern "C" {
5208 pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH;
5209}
5210extern "C" {
5211 pub fn SymCryptSha256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE);
5212}
5213extern "C" {
5214 pub fn SymCryptSha256Init(pState: PSYMCRYPT_SHA256_STATE);
5215}
5216extern "C" {
5217 pub fn SymCryptSha256Append(pState: PSYMCRYPT_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T);
5218}
5219extern "C" {
5220 pub fn SymCryptSha256Result(pState: PSYMCRYPT_SHA256_STATE, pbResult: PBYTE);
5221}
5222extern "C" {
5223 pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE);
5224}
5225extern "C" {
5226 pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH;
5227}
5228extern "C" {
5229 pub fn SymCryptSha384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE);
5230}
5231extern "C" {
5232 pub fn SymCryptSha384Init(pState: PSYMCRYPT_SHA384_STATE);
5233}
5234extern "C" {
5235 pub fn SymCryptSha384Append(pState: PSYMCRYPT_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T);
5236}
5237extern "C" {
5238 pub fn SymCryptSha384Result(pState: PSYMCRYPT_SHA384_STATE, pbResult: PBYTE);
5239}
5240extern "C" {
5241 pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE);
5242}
5243extern "C" {
5244 pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH;
5245}
5246extern "C" {
5247 pub fn SymCryptSha512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE);
5248}
5249extern "C" {
5250 pub fn SymCryptSha512Init(pState: PSYMCRYPT_SHA512_STATE);
5251}
5252extern "C" {
5253 pub fn SymCryptSha512Append(pState: PSYMCRYPT_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T);
5254}
5255extern "C" {
5256 pub fn SymCryptSha512Result(pState: PSYMCRYPT_SHA512_STATE, pbResult: PBYTE);
5257}
5258extern "C" {
5259 pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE);
5260}
5261extern "C" {
5262 pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH;
5263}
5264extern "C" {
5265 pub fn SymCryptSha3_256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE);
5266}
5267extern "C" {
5268 pub fn SymCryptSha3_256Init(pState: PSYMCRYPT_SHA3_256_STATE);
5269}
5270extern "C" {
5271 pub fn SymCryptSha3_256Append(pState: PSYMCRYPT_SHA3_256_STATE, pbData: PCBYTE, cbData: SIZE_T);
5272}
5273extern "C" {
5274 pub fn SymCryptSha3_256Result(pState: PSYMCRYPT_SHA3_256_STATE, pbResult: PBYTE);
5275}
5276extern "C" {
5277 pub fn SymCryptSha3_256StateCopy(
5278 pSrc: PCSYMCRYPT_SHA3_256_STATE,
5279 pDst: PSYMCRYPT_SHA3_256_STATE,
5280 );
5281}
5282extern "C" {
5283 pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH;
5284}
5285extern "C" {
5286 pub fn SymCryptSha3_384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE);
5287}
5288extern "C" {
5289 pub fn SymCryptSha3_384Init(pState: PSYMCRYPT_SHA3_384_STATE);
5290}
5291extern "C" {
5292 pub fn SymCryptSha3_384Append(pState: PSYMCRYPT_SHA3_384_STATE, pbData: PCBYTE, cbData: SIZE_T);
5293}
5294extern "C" {
5295 pub fn SymCryptSha3_384Result(pState: PSYMCRYPT_SHA3_384_STATE, pbResult: PBYTE);
5296}
5297extern "C" {
5298 pub fn SymCryptSha3_384StateCopy(
5299 pSrc: PCSYMCRYPT_SHA3_384_STATE,
5300 pDst: PSYMCRYPT_SHA3_384_STATE,
5301 );
5302}
5303extern "C" {
5304 pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH;
5305}
5306extern "C" {
5307 pub fn SymCryptSha3_512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE);
5308}
5309extern "C" {
5310 pub fn SymCryptSha3_512Init(pState: PSYMCRYPT_SHA3_512_STATE);
5311}
5312extern "C" {
5313 pub fn SymCryptSha3_512Append(pState: PSYMCRYPT_SHA3_512_STATE, pbData: PCBYTE, cbData: SIZE_T);
5314}
5315extern "C" {
5316 pub fn SymCryptSha3_512Result(pState: PSYMCRYPT_SHA3_512_STATE, pbResult: PBYTE);
5317}
5318extern "C" {
5319 pub fn SymCryptSha3_512StateCopy(
5320 pSrc: PCSYMCRYPT_SHA3_512_STATE,
5321 pDst: PSYMCRYPT_SHA3_512_STATE,
5322 );
5323}
5324extern "C" {
5325 pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH;
5326}
5327extern "C" {
5328 pub fn SymCryptHmacMd5ExpandKey(
5329 pExpandedKey: PSYMCRYPT_HMAC_MD5_EXPANDED_KEY,
5330 pbKey: PCBYTE,
5331 cbKey: SIZE_T,
5332 ) -> SYMCRYPT_ERROR;
5333}
5334extern "C" {
5335 pub fn SymCryptHmacMd5(
5336 pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY,
5337 pbData: PCBYTE,
5338 cbData: SIZE_T,
5339 pbResult: PBYTE,
5340 );
5341}
5342extern "C" {
5343 pub fn SymCryptHmacMd5StateCopy(
5344 pSrc: PCSYMCRYPT_HMAC_MD5_STATE,
5345 pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY,
5346 pDst: PSYMCRYPT_HMAC_MD5_STATE,
5347 );
5348}
5349extern "C" {
5350 pub fn SymCryptHmacMd5Init(
5351 pState: PSYMCRYPT_HMAC_MD5_STATE,
5352 pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY,
5353 );
5354}
5355extern "C" {
5356 pub fn SymCryptHmacMd5Append(pState: PSYMCRYPT_HMAC_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T);
5357}
5358extern "C" {
5359 pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE);
5360}
5361extern "C" {
5362 pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC;
5363}
5364extern "C" {
5365 pub fn SymCryptHmacSha1ExpandKey(
5366 pExpandedKey: PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY,
5367 pbKey: PCBYTE,
5368 cbKey: SIZE_T,
5369 ) -> SYMCRYPT_ERROR;
5370}
5371extern "C" {
5372 pub fn SymCryptHmacSha1(
5373 pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY,
5374 pbData: PCBYTE,
5375 cbData: SIZE_T,
5376 pbResult: PBYTE,
5377 );
5378}
5379extern "C" {
5380 pub fn SymCryptHmacSha1StateCopy(
5381 pSrc: PCSYMCRYPT_HMAC_SHA1_STATE,
5382 pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY,
5383 pDst: PSYMCRYPT_HMAC_SHA1_STATE,
5384 );
5385}
5386extern "C" {
5387 pub fn SymCryptHmacSha1Init(
5388 pState: PSYMCRYPT_HMAC_SHA1_STATE,
5389 pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY,
5390 );
5391}
5392extern "C" {
5393 pub fn SymCryptHmacSha1Append(
5394 pState: PSYMCRYPT_HMAC_SHA1_STATE,
5395 pbData: PCBYTE,
5396 cbData: SIZE_T,
5397 );
5398}
5399extern "C" {
5400 pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE);
5401}
5402extern "C" {
5403 pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC;
5404}
5405extern "C" {
5406 pub fn SymCryptHmacSha256ExpandKey(
5407 pExpandedKey: PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY,
5408 pbKey: PCBYTE,
5409 cbKey: SIZE_T,
5410 ) -> SYMCRYPT_ERROR;
5411}
5412extern "C" {
5413 pub fn SymCryptHmacSha256(
5414 pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY,
5415 pbData: PCBYTE,
5416 cbData: SIZE_T,
5417 pbResult: PBYTE,
5418 );
5419}
5420extern "C" {
5421 pub fn SymCryptHmacSha256StateCopy(
5422 pSrc: PCSYMCRYPT_HMAC_SHA256_STATE,
5423 pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY,
5424 pDst: PSYMCRYPT_HMAC_SHA256_STATE,
5425 );
5426}
5427extern "C" {
5428 pub fn SymCryptHmacSha256Init(
5429 pState: PSYMCRYPT_HMAC_SHA256_STATE,
5430 pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY,
5431 );
5432}
5433extern "C" {
5434 pub fn SymCryptHmacSha256Append(
5435 pState: PSYMCRYPT_HMAC_SHA256_STATE,
5436 pbData: PCBYTE,
5437 cbData: SIZE_T,
5438 );
5439}
5440extern "C" {
5441 pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE);
5442}
5443extern "C" {
5444 pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC;
5445}
5446extern "C" {
5447 pub fn SymCryptHmacSha384ExpandKey(
5448 pExpandedKey: PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY,
5449 pbKey: PCBYTE,
5450 cbKey: SIZE_T,
5451 ) -> SYMCRYPT_ERROR;
5452}
5453extern "C" {
5454 pub fn SymCryptHmacSha384(
5455 pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY,
5456 pbData: PCBYTE,
5457 cbData: SIZE_T,
5458 pbResult: PBYTE,
5459 );
5460}
5461extern "C" {
5462 pub fn SymCryptHmacSha384StateCopy(
5463 pSrc: PCSYMCRYPT_HMAC_SHA384_STATE,
5464 pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY,
5465 pDst: PSYMCRYPT_HMAC_SHA384_STATE,
5466 );
5467}
5468extern "C" {
5469 pub fn SymCryptHmacSha384Init(
5470 pState: PSYMCRYPT_HMAC_SHA384_STATE,
5471 pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY,
5472 );
5473}
5474extern "C" {
5475 pub fn SymCryptHmacSha384Append(
5476 pState: PSYMCRYPT_HMAC_SHA384_STATE,
5477 pbData: PCBYTE,
5478 cbData: SIZE_T,
5479 );
5480}
5481extern "C" {
5482 pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE);
5483}
5484extern "C" {
5485 pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC;
5486}
5487extern "C" {
5488 pub fn SymCryptHmacSha512ExpandKey(
5489 pExpandedKey: PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY,
5490 pbKey: PCBYTE,
5491 cbKey: SIZE_T,
5492 ) -> SYMCRYPT_ERROR;
5493}
5494extern "C" {
5495 pub fn SymCryptHmacSha512(
5496 pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY,
5497 pbData: PCBYTE,
5498 cbData: SIZE_T,
5499 pbResult: PBYTE,
5500 );
5501}
5502extern "C" {
5503 pub fn SymCryptHmacSha512StateCopy(
5504 pSrc: PCSYMCRYPT_HMAC_SHA512_STATE,
5505 pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY,
5506 pDst: PSYMCRYPT_HMAC_SHA512_STATE,
5507 );
5508}
5509extern "C" {
5510 pub fn SymCryptHmacSha512Init(
5511 pState: PSYMCRYPT_HMAC_SHA512_STATE,
5512 pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY,
5513 );
5514}
5515extern "C" {
5516 pub fn SymCryptHmacSha512Append(
5517 pState: PSYMCRYPT_HMAC_SHA512_STATE,
5518 pbData: PCBYTE,
5519 cbData: SIZE_T,
5520 );
5521}
5522extern "C" {
5523 pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE);
5524}
5525extern "C" {
5526 pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC;
5527}
5528extern "C" {
5529 pub fn SymCryptChaCha20Poly1305Encrypt(
5530 pbKey: PCBYTE,
5531 cbKey: SIZE_T,
5532 pbNonce: PCBYTE,
5533 cbNonce: SIZE_T,
5534 pbAuthData: PCBYTE,
5535 cbAuthData: SIZE_T,
5536 pbSrc: PCBYTE,
5537 pbDst: PBYTE,
5538 cbData: SIZE_T,
5539 pbTag: PBYTE,
5540 cbTag: SIZE_T,
5541 ) -> SYMCRYPT_ERROR;
5542}
5543extern "C" {
5544 pub fn SymCryptChaCha20Poly1305Decrypt(
5545 pbKey: PCBYTE,
5546 cbKey: SIZE_T,
5547 pbNonce: PCBYTE,
5548 cbNonce: SIZE_T,
5549 pbAuthData: PCBYTE,
5550 cbAuthData: SIZE_T,
5551 pbSrc: PCBYTE,
5552 pbDst: PBYTE,
5553 cbData: SIZE_T,
5554 pbTag: PCBYTE,
5555 cbTag: SIZE_T,
5556 ) -> SYMCRYPT_ERROR;
5557}
5558extern "C" {
5559 pub fn SymCryptAesExpandKey(
5560 pExpandedKey: PSYMCRYPT_AES_EXPANDED_KEY,
5561 pbKey: PCBYTE,
5562 cbKey: SIZE_T,
5563 ) -> SYMCRYPT_ERROR;
5564}
5565extern "C" {
5566 pub fn SymCryptAesCbcEncrypt(
5567 pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY,
5568 pbChainingValue: PBYTE,
5569 pbSrc: PCBYTE,
5570 pbDst: PBYTE,
5571 cbData: SIZE_T,
5572 );
5573}
5574extern "C" {
5575 pub fn SymCryptAesCbcDecrypt(
5576 pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY,
5577 pbChainingValue: PBYTE,
5578 pbSrc: PCBYTE,
5579 pbDst: PBYTE,
5580 cbData: SIZE_T,
5581 );
5582}
5583extern "C" {
5584 pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER;
5585}
5586extern "C" {
5587 pub fn SymCryptGcmValidateParameters(
5588 pBlockCipher: PCSYMCRYPT_BLOCKCIPHER,
5589 cbNonce: SIZE_T,
5590 cbAssociatedData: UINT64,
5591 cbData: UINT64,
5592 cbTag: SIZE_T,
5593 ) -> SYMCRYPT_ERROR;
5594}
5595extern "C" {
5596 pub fn SymCryptGcmExpandKey(
5597 pExpandedKey: PSYMCRYPT_GCM_EXPANDED_KEY,
5598 pBlockCipher: PCSYMCRYPT_BLOCKCIPHER,
5599 pbKey: PCBYTE,
5600 cbKey: SIZE_T,
5601 ) -> SYMCRYPT_ERROR;
5602}
5603extern "C" {
5604 pub fn SymCryptGcmEncrypt(
5605 pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY,
5606 pbNonce: PCBYTE,
5607 cbNonce: SIZE_T,
5608 pbAuthData: PCBYTE,
5609 cbAuthData: SIZE_T,
5610 pbSrc: PCBYTE,
5611 pbDst: PBYTE,
5612 cbData: SIZE_T,
5613 pbTag: PBYTE,
5614 cbTag: SIZE_T,
5615 );
5616}
5617extern "C" {
5618 pub fn SymCryptGcmDecrypt(
5619 pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY,
5620 pbNonce: PCBYTE,
5621 cbNonce: SIZE_T,
5622 pbAuthData: PCBYTE,
5623 cbAuthData: SIZE_T,
5624 pbSrc: PCBYTE,
5625 pbDst: PBYTE,
5626 cbData: SIZE_T,
5627 pbTag: PCBYTE,
5628 cbTag: SIZE_T,
5629 ) -> SYMCRYPT_ERROR;
5630}
5631extern "C" {
5632 pub fn SymCryptGcmInit(
5633 pState: PSYMCRYPT_GCM_STATE,
5634 pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY,
5635 pbNonce: PCBYTE,
5636 cbNonce: SIZE_T,
5637 );
5638}
5639extern "C" {
5640 pub fn SymCryptGcmStateCopy(
5641 pSrc: PCSYMCRYPT_GCM_STATE,
5642 pExpandedKeyCopy: PCSYMCRYPT_GCM_EXPANDED_KEY,
5643 pDst: PSYMCRYPT_GCM_STATE,
5644 );
5645}
5646extern "C" {
5647 pub fn SymCryptGcmAuthPart(pState: PSYMCRYPT_GCM_STATE, pbAuthData: PCBYTE, cbData: SIZE_T);
5648}
5649extern "C" {
5650 pub fn SymCryptGcmEncryptPart(
5651 pState: PSYMCRYPT_GCM_STATE,
5652 pbSrc: PCBYTE,
5653 pbDst: PBYTE,
5654 cbData: SIZE_T,
5655 );
5656}
5657extern "C" {
5658 pub fn SymCryptGcmEncryptFinal(pState: PSYMCRYPT_GCM_STATE, pbTag: PBYTE, cbTag: SIZE_T);
5659}
5660extern "C" {
5661 pub fn SymCryptGcmDecryptPart(
5662 pState: PSYMCRYPT_GCM_STATE,
5663 pbSrc: PCBYTE,
5664 pbDst: PBYTE,
5665 cbData: SIZE_T,
5666 );
5667}
5668extern "C" {
5669 pub fn SymCryptGcmDecryptFinal(
5670 pState: PSYMCRYPT_GCM_STATE,
5671 pbTag: PCBYTE,
5672 cbTag: SIZE_T,
5673 ) -> SYMCRYPT_ERROR;
5674}
5675extern "C" {
5676 pub fn SymCryptTlsPrf1_2ExpandKey(
5677 pExpandedKey: PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY,
5678 macAlgorithm: PCSYMCRYPT_MAC,
5679 pbKey: PCBYTE,
5680 cbKey: SIZE_T,
5681 ) -> SYMCRYPT_ERROR;
5682}
5683extern "C" {
5684 pub fn SymCryptTlsPrf1_2Derive(
5685 pExpandedKey: PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY,
5686 pbLabel: PCBYTE,
5687 cbLabel: SIZE_T,
5688 pbSeed: PCBYTE,
5689 cbSeed: SIZE_T,
5690 pbResult: PBYTE,
5691 cbResult: SIZE_T,
5692 ) -> SYMCRYPT_ERROR;
5693}
5694extern "C" {
5695 pub fn SymCryptTlsPrf1_2(
5696 macAlgorithm: PCSYMCRYPT_MAC,
5697 pbKey: PCBYTE,
5698 cbKey: SIZE_T,
5699 pbLabel: PCBYTE,
5700 cbLabel: SIZE_T,
5701 pbSeed: PCBYTE,
5702 cbSeed: SIZE_T,
5703 pbResult: PBYTE,
5704 cbResult: SIZE_T,
5705 ) -> SYMCRYPT_ERROR;
5706}
5707extern "C" {
5708 pub fn SymCryptHkdfExpandKey(
5709 pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY,
5710 macAlgorithm: PCSYMCRYPT_MAC,
5711 pbIkm: PCBYTE,
5712 cbIkm: SIZE_T,
5713 pbSalt: PCBYTE,
5714 cbSalt: SIZE_T,
5715 ) -> SYMCRYPT_ERROR;
5716}
5717extern "C" {
5718 pub fn SymCryptHkdfExtractPrk(
5719 macAlgorithm: PCSYMCRYPT_MAC,
5720 pbIkm: PCBYTE,
5721 cbIkm: SIZE_T,
5722 pbSalt: PCBYTE,
5723 cbSalt: SIZE_T,
5724 pbPrk: PBYTE,
5725 cbPrk: SIZE_T,
5726 ) -> SYMCRYPT_ERROR;
5727}
5728extern "C" {
5729 pub fn SymCryptHkdfPrkExpandKey(
5730 pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY,
5731 macAlgorithm: PCSYMCRYPT_MAC,
5732 pbPrk: PCBYTE,
5733 cbPrk: SIZE_T,
5734 ) -> SYMCRYPT_ERROR;
5735}
5736extern "C" {
5737 pub fn SymCryptHkdfDerive(
5738 pExpandedKey: PCSYMCRYPT_HKDF_EXPANDED_KEY,
5739 pbInfo: PCBYTE,
5740 cbInfo: SIZE_T,
5741 pbResult: PBYTE,
5742 cbResult: SIZE_T,
5743 ) -> SYMCRYPT_ERROR;
5744}
5745extern "C" {
5746 pub fn SymCryptHkdf(
5747 macAlgorithm: PCSYMCRYPT_MAC,
5748 pbIkm: PCBYTE,
5749 cbIkm: SIZE_T,
5750 pbSalt: PCBYTE,
5751 cbSalt: SIZE_T,
5752 pbInfo: PCBYTE,
5753 cbInfo: SIZE_T,
5754 pbResult: PBYTE,
5755 cbResult: SIZE_T,
5756 ) -> SYMCRYPT_ERROR;
5757}
5758extern "C" {
5759 pub fn SymCryptRandom(pbRandom: PBYTE, cbRandom: SIZE_T);
5760}
5761pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_LSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 1;
5762pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_MSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 2;
5763pub type _SYMCRYPT_NUMBER_FORMAT = ::std::os::raw::c_uint;
5764pub use self::_SYMCRYPT_NUMBER_FORMAT as SYMCRYPT_NUMBER_FORMAT;
5765#[repr(C)]
5766#[derive(Debug, Default, Copy, Clone)]
5767pub struct _SYMCRYPT_RSA_PARAMS {
5768 pub version: UINT32,
5769 pub nBitsOfModulus: UINT32,
5770 pub nPrimes: UINT32,
5771 pub nPubExp: UINT32,
5772}
5773#[test]
5774fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() {
5775 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSA_PARAMS> = ::std::mem::MaybeUninit::uninit();
5776 let ptr = UNINIT.as_ptr();
5777 assert_eq!(
5778 ::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>(),
5779 16usize,
5780 concat!("Size of: ", stringify!(_SYMCRYPT_RSA_PARAMS))
5781 );
5782 assert_eq!(
5783 ::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>(),
5784 4usize,
5785 concat!("Alignment of ", stringify!(_SYMCRYPT_RSA_PARAMS))
5786 );
5787 assert_eq!(
5788 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
5789 0usize,
5790 concat!(
5791 "Offset of field: ",
5792 stringify!(_SYMCRYPT_RSA_PARAMS),
5793 "::",
5794 stringify!(version)
5795 )
5796 );
5797 assert_eq!(
5798 unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize },
5799 4usize,
5800 concat!(
5801 "Offset of field: ",
5802 stringify!(_SYMCRYPT_RSA_PARAMS),
5803 "::",
5804 stringify!(nBitsOfModulus)
5805 )
5806 );
5807 assert_eq!(
5808 unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize },
5809 8usize,
5810 concat!(
5811 "Offset of field: ",
5812 stringify!(_SYMCRYPT_RSA_PARAMS),
5813 "::",
5814 stringify!(nPrimes)
5815 )
5816 );
5817 assert_eq!(
5818 unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize },
5819 12usize,
5820 concat!(
5821 "Offset of field: ",
5822 stringify!(_SYMCRYPT_RSA_PARAMS),
5823 "::",
5824 stringify!(nPubExp)
5825 )
5826 );
5827}
5828pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS;
5829pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS;
5830pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID =
5831 0;
5832pub type _SYMCRYPT_ECURVE_GEN_ALG_ID = ::std::os::raw::c_uint;
5833pub use self::_SYMCRYPT_ECURVE_GEN_ALG_ID as SYMCRYPT_ECURVE_GEN_ALG_ID;
5834#[repr(C)]
5835#[derive(Debug, Copy, Clone)]
5836pub struct _SYMCRYPT_ECURVE_PARAMS {
5837 pub version: UINT32,
5838 pub type_: SYMCRYPT_ECURVE_TYPE,
5839 pub algId: SYMCRYPT_ECURVE_GEN_ALG_ID,
5840 pub cbFieldLength: UINT32,
5841 pub cbSubgroupOrder: UINT32,
5842 pub cbCofactor: UINT32,
5843 pub cbSeed: UINT32,
5844}
5845#[test]
5846fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() {
5847 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> =
5848 ::std::mem::MaybeUninit::uninit();
5849 let ptr = UNINIT.as_ptr();
5850 assert_eq!(
5851 ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(),
5852 28usize,
5853 concat!("Size of: ", stringify!(_SYMCRYPT_ECURVE_PARAMS))
5854 );
5855 assert_eq!(
5856 ::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>(),
5857 4usize,
5858 concat!("Alignment of ", stringify!(_SYMCRYPT_ECURVE_PARAMS))
5859 );
5860 assert_eq!(
5861 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
5862 0usize,
5863 concat!(
5864 "Offset of field: ",
5865 stringify!(_SYMCRYPT_ECURVE_PARAMS),
5866 "::",
5867 stringify!(version)
5868 )
5869 );
5870 assert_eq!(
5871 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
5872 4usize,
5873 concat!(
5874 "Offset of field: ",
5875 stringify!(_SYMCRYPT_ECURVE_PARAMS),
5876 "::",
5877 stringify!(type_)
5878 )
5879 );
5880 assert_eq!(
5881 unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize },
5882 8usize,
5883 concat!(
5884 "Offset of field: ",
5885 stringify!(_SYMCRYPT_ECURVE_PARAMS),
5886 "::",
5887 stringify!(algId)
5888 )
5889 );
5890 assert_eq!(
5891 unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize },
5892 12usize,
5893 concat!(
5894 "Offset of field: ",
5895 stringify!(_SYMCRYPT_ECURVE_PARAMS),
5896 "::",
5897 stringify!(cbFieldLength)
5898 )
5899 );
5900 assert_eq!(
5901 unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize },
5902 16usize,
5903 concat!(
5904 "Offset of field: ",
5905 stringify!(_SYMCRYPT_ECURVE_PARAMS),
5906 "::",
5907 stringify!(cbSubgroupOrder)
5908 )
5909 );
5910 assert_eq!(
5911 unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize },
5912 20usize,
5913 concat!(
5914 "Offset of field: ",
5915 stringify!(_SYMCRYPT_ECURVE_PARAMS),
5916 "::",
5917 stringify!(cbCofactor)
5918 )
5919 );
5920 assert_eq!(
5921 unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize },
5922 24usize,
5923 concat!(
5924 "Offset of field: ",
5925 stringify!(_SYMCRYPT_ECURVE_PARAMS),
5926 "::",
5927 stringify!(cbSeed)
5928 )
5929 );
5930}
5931impl Default for _SYMCRYPT_ECURVE_PARAMS {
5932 fn default() -> Self {
5933 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5934 unsafe {
5935 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5936 s.assume_init()
5937 }
5938 }
5939}
5940pub type SYMCRYPT_ECURVE_PARAMS = _SYMCRYPT_ECURVE_PARAMS;
5941pub type PCSYMCRYPT_ECURVE_PARAMS = *const SYMCRYPT_ECURVE_PARAMS;
5942pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_X: _SYMCRYPT_ECPOINT_FORMAT = 1;
5943pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_XY: _SYMCRYPT_ECPOINT_FORMAT = 2;
5944pub type _SYMCRYPT_ECPOINT_FORMAT = ::std::os::raw::c_uint;
5945pub use self::_SYMCRYPT_ECPOINT_FORMAT as SYMCRYPT_ECPOINT_FORMAT;
5946extern "C" {
5947 pub fn SymCryptRsakeyAllocate(
5948 pParams: PCSYMCRYPT_RSA_PARAMS,
5949 flags: UINT32,
5950 ) -> PSYMCRYPT_RSAKEY;
5951}
5952extern "C" {
5953 pub fn SymCryptRsakeyFree(pkObj: PSYMCRYPT_RSAKEY);
5954}
5955extern "C" {
5956 pub fn SymCryptEcurveAllocate(
5957 pParams: PCSYMCRYPT_ECURVE_PARAMS,
5958 flags: UINT32,
5959 ) -> PSYMCRYPT_ECURVE;
5960}
5961extern "C" {
5962 pub fn SymCryptEcurveFree(pCurve: PSYMCRYPT_ECURVE);
5963}
5964extern "C" {
5965 pub fn SymCryptEckeyAllocate(pCurve: PCSYMCRYPT_ECURVE) -> PSYMCRYPT_ECKEY;
5966}
5967extern "C" {
5968 pub fn SymCryptEckeyFree(pkObj: PSYMCRYPT_ECKEY);
5969}
5970extern "C" {
5971 pub fn SymCryptRsakeyHasPrivateKey(pkRsakey: PCSYMCRYPT_RSAKEY) -> BOOLEAN;
5972}
5973extern "C" {
5974 pub fn SymCryptRsakeySizeofModulus(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32;
5975}
5976extern "C" {
5977 pub fn SymCryptRsakeyModulusBits(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32;
5978}
5979extern "C" {
5980 pub fn SymCryptRsakeySizeofPublicExponent(pRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32;
5981}
5982extern "C" {
5983 pub fn SymCryptRsakeySizeofPrime(pkRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32;
5984}
5985extern "C" {
5986 pub fn SymCryptRsakeyGetNumberOfPublicExponents(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32;
5987}
5988extern "C" {
5989 pub fn SymCryptRsakeyGetNumberOfPrimes(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32;
5990}
5991extern "C" {
5992 pub fn SymCryptRsakeyGenerate(
5993 pkRsakey: PSYMCRYPT_RSAKEY,
5994 pu64PubExp: PCUINT64,
5995 nPubExp: UINT32,
5996 flags: UINT32,
5997 ) -> SYMCRYPT_ERROR;
5998}
5999extern "C" {
6000 pub fn SymCryptRsakeySetValue(
6001 pbModulus: PCBYTE,
6002 cbModulus: SIZE_T,
6003 pu64PubExp: PCUINT64,
6004 nPubExp: UINT32,
6005 ppPrimes: *mut PCBYTE,
6006 pcbPrimes: *mut SIZE_T,
6007 nPrimes: UINT32,
6008 numFormat: SYMCRYPT_NUMBER_FORMAT,
6009 flags: UINT32,
6010 pkRsakey: PSYMCRYPT_RSAKEY,
6011 ) -> SYMCRYPT_ERROR;
6012}
6013extern "C" {
6014 pub fn SymCryptRsakeyGetValue(
6015 pkRsakey: PCSYMCRYPT_RSAKEY,
6016 pbModulus: PBYTE,
6017 cbModulus: SIZE_T,
6018 pu64PubExp: PUINT64,
6019 nPubExp: UINT32,
6020 ppPrimes: *mut PBYTE,
6021 pcbPrimes: *mut SIZE_T,
6022 nPrimes: UINT32,
6023 numFormat: SYMCRYPT_NUMBER_FORMAT,
6024 flags: UINT32,
6025 ) -> SYMCRYPT_ERROR;
6026}
6027extern "C" {
6028 pub fn SymCryptRsakeyGetCrtValue(
6029 pkRsakey: PCSYMCRYPT_RSAKEY,
6030 ppCrtExponents: *mut PBYTE,
6031 pcbCrtExponents: *mut SIZE_T,
6032 nCrtExponents: UINT32,
6033 pbCrtCoefficient: PBYTE,
6034 cbCrtCoefficient: SIZE_T,
6035 pbPrivateExponent: PBYTE,
6036 cbPrivateExponent: SIZE_T,
6037 numFormat: SYMCRYPT_NUMBER_FORMAT,
6038 flags: UINT32,
6039 ) -> SYMCRYPT_ERROR;
6040}
6041extern "C" {
6042 pub fn SymCryptRsakeyExtendKeyUsage(
6043 pkRsakey: PSYMCRYPT_RSAKEY,
6044 flags: UINT32,
6045 ) -> SYMCRYPT_ERROR;
6046}
6047extern "C" {
6048 pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32;
6049}
6050extern "C" {
6051 pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS;
6052}
6053extern "C" {
6054 pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS;
6055}
6056extern "C" {
6057 pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS;
6058}
6059extern "C" {
6060 pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS;
6061}
6062extern "C" {
6063 pub fn SymCryptEckeySizeofPublicKey(
6064 pkEckey: PCSYMCRYPT_ECKEY,
6065 ecPointFormat: SYMCRYPT_ECPOINT_FORMAT,
6066 ) -> UINT32;
6067}
6068extern "C" {
6069 pub fn SymCryptEckeySizeofPrivateKey(pkEckey: PCSYMCRYPT_ECKEY) -> UINT32;
6070}
6071extern "C" {
6072 pub fn SymCryptEckeySetValue(
6073 pbPrivateKey: PCBYTE,
6074 cbPrivateKey: SIZE_T,
6075 pbPublicKey: PCBYTE,
6076 cbPublicKey: SIZE_T,
6077 numFormat: SYMCRYPT_NUMBER_FORMAT,
6078 ecPointFormat: SYMCRYPT_ECPOINT_FORMAT,
6079 flags: UINT32,
6080 pEckey: PSYMCRYPT_ECKEY,
6081 ) -> SYMCRYPT_ERROR;
6082}
6083extern "C" {
6084 pub fn SymCryptEckeySetRandom(flags: UINT32, pEckey: PSYMCRYPT_ECKEY) -> SYMCRYPT_ERROR;
6085}
6086extern "C" {
6087 pub fn SymCryptEckeyGetValue(
6088 pEckey: PCSYMCRYPT_ECKEY,
6089 pbPrivateKey: PBYTE,
6090 cbPrivateKey: SIZE_T,
6091 pbPublicKey: PBYTE,
6092 cbPublicKey: SIZE_T,
6093 numFormat: SYMCRYPT_NUMBER_FORMAT,
6094 ecPointFormat: SYMCRYPT_ECPOINT_FORMAT,
6095 flags: UINT32,
6096 ) -> SYMCRYPT_ERROR;
6097}
6098extern "C" {
6099 pub fn SymCryptRsaPkcs1Encrypt(
6100 pkRsakey: PCSYMCRYPT_RSAKEY,
6101 pbSrc: PCBYTE,
6102 cbSrc: SIZE_T,
6103 flags: UINT32,
6104 nfDst: SYMCRYPT_NUMBER_FORMAT,
6105 pbDst: PBYTE,
6106 cbDst: SIZE_T,
6107 pcbDst: *mut SIZE_T,
6108 ) -> SYMCRYPT_ERROR;
6109}
6110extern "C" {
6111 pub fn SymCryptRsaPkcs1Decrypt(
6112 pkRsakey: PCSYMCRYPT_RSAKEY,
6113 pbSrc: PCBYTE,
6114 cbSrc: SIZE_T,
6115 nfSrc: SYMCRYPT_NUMBER_FORMAT,
6116 flags: UINT32,
6117 pbDst: PBYTE,
6118 cbDst: SIZE_T,
6119 pcbDst: *mut SIZE_T,
6120 ) -> SYMCRYPT_ERROR;
6121}
6122extern "C" {
6123 pub fn SymCryptRsaOaepEncrypt(
6124 pkRsakey: PCSYMCRYPT_RSAKEY,
6125 pbSrc: PCBYTE,
6126 cbSrc: SIZE_T,
6127 hashAlgorithm: PCSYMCRYPT_HASH,
6128 pbLabel: PCBYTE,
6129 cbLabel: SIZE_T,
6130 flags: UINT32,
6131 nfDst: SYMCRYPT_NUMBER_FORMAT,
6132 pbDst: PBYTE,
6133 cbDst: SIZE_T,
6134 pcbDst: *mut SIZE_T,
6135 ) -> SYMCRYPT_ERROR;
6136}
6137extern "C" {
6138 pub fn SymCryptRsaOaepDecrypt(
6139 pkRsakey: PCSYMCRYPT_RSAKEY,
6140 pbSrc: PCBYTE,
6141 cbSrc: SIZE_T,
6142 nfSrc: SYMCRYPT_NUMBER_FORMAT,
6143 hashAlgorithm: PCSYMCRYPT_HASH,
6144 pbLabel: PCBYTE,
6145 cbLabel: SIZE_T,
6146 flags: UINT32,
6147 pbDst: PBYTE,
6148 cbDst: SIZE_T,
6149 pcbDst: *mut SIZE_T,
6150 ) -> SYMCRYPT_ERROR;
6151}
6152#[repr(C)]
6153#[derive(Debug, Copy, Clone)]
6154pub struct _SYMCRYPT_OID {
6155 pub cbOID: UINT32,
6156 pub pbOID: PCBYTE,
6157}
6158#[test]
6159fn bindgen_test_layout__SYMCRYPT_OID() {
6160 const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit();
6161 let ptr = UNINIT.as_ptr();
6162 assert_eq!(
6163 ::std::mem::size_of::<_SYMCRYPT_OID>(),
6164 16usize,
6165 concat!("Size of: ", stringify!(_SYMCRYPT_OID))
6166 );
6167 assert_eq!(
6168 ::std::mem::align_of::<_SYMCRYPT_OID>(),
6169 8usize,
6170 concat!("Alignment of ", stringify!(_SYMCRYPT_OID))
6171 );
6172 assert_eq!(
6173 unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize },
6174 0usize,
6175 concat!(
6176 "Offset of field: ",
6177 stringify!(_SYMCRYPT_OID),
6178 "::",
6179 stringify!(cbOID)
6180 )
6181 );
6182 assert_eq!(
6183 unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize },
6184 8usize,
6185 concat!(
6186 "Offset of field: ",
6187 stringify!(_SYMCRYPT_OID),
6188 "::",
6189 stringify!(pbOID)
6190 )
6191 );
6192}
6193impl Default for _SYMCRYPT_OID {
6194 fn default() -> Self {
6195 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6196 unsafe {
6197 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6198 s.assume_init()
6199 }
6200 }
6201}
6202pub type SYMCRYPT_OID = _SYMCRYPT_OID;
6203pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID;
6204extern "C" {
6205 pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize];
6206}
6207extern "C" {
6208 pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize];
6209}
6210extern "C" {
6211 pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize];
6212}
6213extern "C" {
6214 pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize];
6215}
6216extern "C" {
6217 pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize];
6218}
6219extern "C" {
6220 pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize];
6221}
6222extern "C" {
6223 pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize];
6224}
6225extern "C" {
6226 pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize];
6227}
6228extern "C" {
6229 pub fn SymCryptRsaPkcs1Sign(
6230 pkRsakey: PCSYMCRYPT_RSAKEY,
6231 pbHashValue: PCBYTE,
6232 cbHashValue: SIZE_T,
6233 pHashOIDs: PCSYMCRYPT_OID,
6234 nOIDCount: SIZE_T,
6235 flags: UINT32,
6236 nfSignature: SYMCRYPT_NUMBER_FORMAT,
6237 pbSignature: PBYTE,
6238 cbSignature: SIZE_T,
6239 pcbSignature: *mut SIZE_T,
6240 ) -> SYMCRYPT_ERROR;
6241}
6242extern "C" {
6243 pub fn SymCryptRsaPkcs1Verify(
6244 pkRsakey: PCSYMCRYPT_RSAKEY,
6245 pbHashValue: PCBYTE,
6246 cbHashValue: SIZE_T,
6247 pbSignature: PCBYTE,
6248 cbSignature: SIZE_T,
6249 nfSignature: SYMCRYPT_NUMBER_FORMAT,
6250 pHashOID: PCSYMCRYPT_OID,
6251 nOIDCount: SIZE_T,
6252 flags: UINT32,
6253 ) -> SYMCRYPT_ERROR;
6254}
6255extern "C" {
6256 pub fn SymCryptRsaPssSign(
6257 pkRsakey: PCSYMCRYPT_RSAKEY,
6258 pbHashValue: PCBYTE,
6259 cbHashValue: SIZE_T,
6260 hashAlgorithm: PCSYMCRYPT_HASH,
6261 cbSalt: SIZE_T,
6262 flags: UINT32,
6263 nfSignature: SYMCRYPT_NUMBER_FORMAT,
6264 pbSignature: PBYTE,
6265 cbSignature: SIZE_T,
6266 pcbSignature: *mut SIZE_T,
6267 ) -> SYMCRYPT_ERROR;
6268}
6269extern "C" {
6270 pub fn SymCryptRsaPssVerify(
6271 pkRsakey: PCSYMCRYPT_RSAKEY,
6272 pbHashValue: PCBYTE,
6273 cbHashValue: SIZE_T,
6274 pbSignature: PCBYTE,
6275 cbSignature: SIZE_T,
6276 nfSignature: SYMCRYPT_NUMBER_FORMAT,
6277 hashAlgorithm: PCSYMCRYPT_HASH,
6278 cbSalt: SIZE_T,
6279 flags: UINT32,
6280 ) -> SYMCRYPT_ERROR;
6281}
6282extern "C" {
6283 pub fn SymCryptEcDsaSign(
6284 pKey: PCSYMCRYPT_ECKEY,
6285 pbHashValue: PCBYTE,
6286 cbHashValue: SIZE_T,
6287 format: SYMCRYPT_NUMBER_FORMAT,
6288 flags: UINT32,
6289 pbSignature: PBYTE,
6290 cbSignature: SIZE_T,
6291 ) -> SYMCRYPT_ERROR;
6292}
6293extern "C" {
6294 pub fn SymCryptEcDsaVerify(
6295 pKey: PCSYMCRYPT_ECKEY,
6296 pbHashValue: PCBYTE,
6297 cbHashValue: SIZE_T,
6298 pbSignature: PCBYTE,
6299 cbSignature: SIZE_T,
6300 format: SYMCRYPT_NUMBER_FORMAT,
6301 flags: UINT32,
6302 ) -> SYMCRYPT_ERROR;
6303}
6304extern "C" {
6305 pub fn SymCryptEcDhSecretAgreement(
6306 pkPrivate: PCSYMCRYPT_ECKEY,
6307 pkPublic: PCSYMCRYPT_ECKEY,
6308 format: SYMCRYPT_NUMBER_FORMAT,
6309 flags: UINT32,
6310 pbAgreedSecret: PBYTE,
6311 cbAgreedSecret: SIZE_T,
6312 ) -> SYMCRYPT_ERROR;
6313}