1extern crate libc;
2
3pub type int8_t = libc::c_char;
6pub type int16_t = libc::c_short;
7pub type int32_t = libc::c_int;
8pub type int64_t = libc::c_longlong;
9pub type uint8_t = libc::c_uchar;
10pub type uint16_t = libc::c_ushort;
11pub type uint32_t = libc::c_uint;
12pub type uint64_t = libc::c_ulonglong;
13pub type int_least8_t = libc::c_char;
14pub type int_least16_t = libc::c_short;
15pub type int_least32_t = libc::c_int;
16pub type int_least64_t = libc::c_longlong;
17pub type uint_least8_t = libc::c_uchar;
18pub type uint_least16_t = libc::c_ushort;
19pub type uint_least32_t = libc::c_uint;
20pub type uint_least64_t = libc::c_ulonglong;
21pub type int_fast8_t = libc::c_char;
22pub type int_fast16_t = libc::c_int;
23pub type int_fast32_t = libc::c_int;
24pub type int_fast64_t = libc::c_longlong;
25pub type uint_fast8_t = libc::c_uchar;
26pub type uint_fast16_t = libc::c_uint;
27pub type uint_fast32_t = libc::c_uint;
28pub type uint_fast64_t = libc::c_ulonglong;
29pub type intptr_t = libc::c_int;
30pub type uintptr_t = libc::c_uint;
31pub type intmax_t = libc::c_longlong;
32pub type uintmax_t = libc::c_ulonglong;
33pub type BYTE = uint8_t;
34pub type TSS_BOOL = int8_t;
35pub type UINT16 = uint16_t;
36pub type UINT32 = uint32_t;
37pub type UINT64 = uint64_t;
38pub type TSS_UNICODE = uint16_t;
39pub type PVOID = *mut libc::c_void;
40pub type TPM_BOOL = BYTE;
41pub type TPM_LOCALITY_MODIFIER = BYTE;
42pub type TPM_COMMAND_CODE = UINT32;
43pub type TPM_COUNT_ID = UINT32;
44pub type TPM_REDIT_COMMAND = UINT32;
45pub type TPM_HANDLE = UINT32;
46pub type TPM_AUTHHANDLE = UINT32;
47pub type TPM_TRANSHANDLE = UINT32;
48pub type TPM_KEYHANDLE = UINT32;
49pub type TPM_DIRINDEX = UINT32;
50pub type TPM_PCRINDEX = UINT32;
51pub type TPM_RESULT = UINT32;
52pub type TPM_MODIFIER_INDICATOR = UINT32;
53pub type TPM_STRUCTURE_TAG = UINT16;
54pub type TPM_RESOURCE_TYPE = UINT32;
55pub type TPM_PAYLOAD_TYPE = BYTE;
56pub type TPM_ENTITY_TYPE = UINT16;
57pub type TPM_KEY_HANDLE = UINT32;
58pub type TPM_STARTUP_TYPE = UINT16;
59pub type TPM_PROTOCOL_ID = UINT16;
60pub type TPM_ALGORITHM_ID = UINT32;
61pub type TPM_PHYSICAL_PRESENCE = UINT16;
62pub type TPM_MIGRATE_SCHEME = UINT16;
63pub type TPM_EK_TYPE = UINT16;
64pub type TPM_PLATFORM_SPECIFIC = UINT16;
65#[repr(C)]
66#[derive(Copy)]
67pub struct Struct_tdTPM_STRUCT_VER {
68 pub major: BYTE,
69 pub minor: BYTE,
70 pub revMajor: BYTE,
71 pub revMinor: BYTE,
72}
73impl ::std::clone::Clone for Struct_tdTPM_STRUCT_VER {
74 fn clone(&self) -> Struct_tdTPM_STRUCT_VER { *self }
75}
76impl ::std::default::Default for Struct_tdTPM_STRUCT_VER {
77 fn default() -> Struct_tdTPM_STRUCT_VER {
78 unsafe { ::std::mem::zeroed() }
79 }
80}
81pub type TPM_STRUCT_VER = Struct_tdTPM_STRUCT_VER;
82#[repr(C)]
83#[derive(Copy)]
84pub struct Struct_tdTPM_VERSION_BYTE {
85 pub _bindgen_bitfield_1_: libc::c_int,
86}
87impl ::std::clone::Clone for Struct_tdTPM_VERSION_BYTE {
88 fn clone(&self) -> Struct_tdTPM_VERSION_BYTE { *self }
89}
90impl ::std::default::Default for Struct_tdTPM_VERSION_BYTE {
91 fn default() -> Struct_tdTPM_VERSION_BYTE {
92 unsafe { ::std::mem::zeroed() }
93 }
94}
95pub type TPM_VERSION_BYTE = Struct_tdTPM_VERSION_BYTE;
96#[repr(C)]
97#[derive(Copy)]
98pub struct Struct_tdTPM_VERSION {
99 pub major: BYTE,
100 pub minor: BYTE,
101 pub revMajor: BYTE,
102 pub revMinor: BYTE,
103}
104impl ::std::clone::Clone for Struct_tdTPM_VERSION {
105 fn clone(&self) -> Struct_tdTPM_VERSION { *self }
106}
107impl ::std::default::Default for Struct_tdTPM_VERSION {
108 fn default() -> Struct_tdTPM_VERSION { unsafe { ::std::mem::zeroed() } }
109}
110pub type TPM_VERSION = Struct_tdTPM_VERSION;
111#[repr(C)]
112#[derive(Copy)]
113pub struct Struct_tdTPM_DIGEST {
114 pub digest: [BYTE; 20usize],
115}
116impl ::std::clone::Clone for Struct_tdTPM_DIGEST {
117 fn clone(&self) -> Struct_tdTPM_DIGEST { *self }
118}
119impl ::std::default::Default for Struct_tdTPM_DIGEST {
120 fn default() -> Struct_tdTPM_DIGEST { unsafe { ::std::mem::zeroed() } }
121}
122pub type TPM_DIGEST = Struct_tdTPM_DIGEST;
123pub type TPM_CHOSENID_HASH = TPM_DIGEST;
124pub type TPM_COMPOSITE_HASH = TPM_DIGEST;
125pub type TPM_DIRVALUE = TPM_DIGEST;
126pub type TPM_HMAC = TPM_DIGEST;
127pub type TPM_PCRVALUE = TPM_DIGEST;
128pub type TPM_AUDITDIGEST = TPM_DIGEST;
129#[repr(C)]
130#[derive(Copy)]
131pub struct Struct_tdTPM_NONCE {
132 pub nonce: [BYTE; 20usize],
133}
134impl ::std::clone::Clone for Struct_tdTPM_NONCE {
135 fn clone(&self) -> Struct_tdTPM_NONCE { *self }
136}
137impl ::std::default::Default for Struct_tdTPM_NONCE {
138 fn default() -> Struct_tdTPM_NONCE { unsafe { ::std::mem::zeroed() } }
139}
140pub type TPM_NONCE = Struct_tdTPM_NONCE;
141pub type TPM_DAA_TPM_SEED = TPM_NONCE;
142pub type TPM_DAA_CONTEXT_SEED = TPM_NONCE;
143#[repr(C)]
144#[derive(Copy)]
145pub struct Struct_tdTPM_AUTHDATA {
146 pub authdata: [BYTE; 20usize],
147}
148impl ::std::clone::Clone for Struct_tdTPM_AUTHDATA {
149 fn clone(&self) -> Struct_tdTPM_AUTHDATA { *self }
150}
151impl ::std::default::Default for Struct_tdTPM_AUTHDATA {
152 fn default() -> Struct_tdTPM_AUTHDATA { unsafe { ::std::mem::zeroed() } }
153}
154pub type TPM_AUTHDATA = Struct_tdTPM_AUTHDATA;
155pub type TPM_SECRET = TPM_AUTHDATA;
156pub type TPM_ENCAUTH = TPM_AUTHDATA;
157#[repr(C)]
158#[derive(Copy)]
159pub struct Struct_tdTPM_KEY_HANDLE_LIST {
160 pub loaded: UINT16,
161 pub handle: *mut TPM_KEY_HANDLE,
162}
163impl ::std::clone::Clone for Struct_tdTPM_KEY_HANDLE_LIST {
164 fn clone(&self) -> Struct_tdTPM_KEY_HANDLE_LIST { *self }
165}
166impl ::std::default::Default for Struct_tdTPM_KEY_HANDLE_LIST {
167 fn default() -> Struct_tdTPM_KEY_HANDLE_LIST {
168 unsafe { ::std::mem::zeroed() }
169 }
170}
171pub type TPM_KEY_HANDLE_LIST = Struct_tdTPM_KEY_HANDLE_LIST;
172pub type TPM_KEY_USAGE = UINT16;
173pub type TPM_SIG_SCHEME = UINT16;
174pub type TPM_ENC_SCHEME = UINT16;
175pub type TPM_AUTH_DATA_USAGE = BYTE;
176pub type TPM_KEY_FLAGS = UINT32;
177#[repr(C)]
178#[derive(Copy)]
179pub struct Struct_tdTPM_CHANGEAUTH_VALIDATE {
180 pub newAuthSecret: TPM_SECRET,
181 pub n1: TPM_NONCE,
182}
183impl ::std::clone::Clone for Struct_tdTPM_CHANGEAUTH_VALIDATE {
184 fn clone(&self) -> Struct_tdTPM_CHANGEAUTH_VALIDATE { *self }
185}
186impl ::std::default::Default for Struct_tdTPM_CHANGEAUTH_VALIDATE {
187 fn default() -> Struct_tdTPM_CHANGEAUTH_VALIDATE {
188 unsafe { ::std::mem::zeroed() }
189 }
190}
191pub type TPM_CHANGEAUTH_VALIDATE = Struct_tdTPM_CHANGEAUTH_VALIDATE;
192pub type TPM_ACTUAL_COUNT = UINT32;
193#[repr(C)]
194#[derive(Copy)]
195pub struct Struct_tdTPM_COUNTER_VALUE {
196 pub tag: TPM_STRUCTURE_TAG,
197 pub label: [BYTE; 4usize],
198 pub counter: TPM_ACTUAL_COUNT,
199}
200impl ::std::clone::Clone for Struct_tdTPM_COUNTER_VALUE {
201 fn clone(&self) -> Struct_tdTPM_COUNTER_VALUE { *self }
202}
203impl ::std::default::Default for Struct_tdTPM_COUNTER_VALUE {
204 fn default() -> Struct_tdTPM_COUNTER_VALUE {
205 unsafe { ::std::mem::zeroed() }
206 }
207}
208pub type TPM_COUNTER_VALUE = Struct_tdTPM_COUNTER_VALUE;
209#[repr(C)]
210#[derive(Copy)]
211pub struct Struct_tdTPM_SIGN_INFO {
212 pub tag: TPM_STRUCTURE_TAG,
213 pub fixed: [BYTE; 4usize],
214 pub replay: TPM_NONCE,
215 pub dataLen: UINT32,
216 pub data: *mut BYTE,
217}
218impl ::std::clone::Clone for Struct_tdTPM_SIGN_INFO {
219 fn clone(&self) -> Struct_tdTPM_SIGN_INFO { *self }
220}
221impl ::std::default::Default for Struct_tdTPM_SIGN_INFO {
222 fn default() -> Struct_tdTPM_SIGN_INFO { unsafe { ::std::mem::zeroed() } }
223}
224pub type TPM_SIGN_INFO = Struct_tdTPM_SIGN_INFO;
225#[repr(C)]
226#[derive(Copy)]
227pub struct Struct_tdTPM_MSA_COMPOSITE {
228 pub MSAlist: UINT32,
229 pub migAuthDigest: *mut TPM_DIGEST,
230}
231impl ::std::clone::Clone for Struct_tdTPM_MSA_COMPOSITE {
232 fn clone(&self) -> Struct_tdTPM_MSA_COMPOSITE { *self }
233}
234impl ::std::default::Default for Struct_tdTPM_MSA_COMPOSITE {
235 fn default() -> Struct_tdTPM_MSA_COMPOSITE {
236 unsafe { ::std::mem::zeroed() }
237 }
238}
239pub type TPM_MSA_COMPOSITE = Struct_tdTPM_MSA_COMPOSITE;
240#[repr(C)]
241#[derive(Copy)]
242pub struct Struct_tdTPM_CMK_AUTH {
243 pub migrationAuthorityDigest: TPM_DIGEST,
244 pub destinationKeyDigest: TPM_DIGEST,
245 pub sourceKeyDigest: TPM_DIGEST,
246}
247impl ::std::clone::Clone for Struct_tdTPM_CMK_AUTH {
248 fn clone(&self) -> Struct_tdTPM_CMK_AUTH { *self }
249}
250impl ::std::default::Default for Struct_tdTPM_CMK_AUTH {
251 fn default() -> Struct_tdTPM_CMK_AUTH { unsafe { ::std::mem::zeroed() } }
252}
253pub type TPM_CMK_AUTH = Struct_tdTPM_CMK_AUTH;
254pub type TPM_CMK_DELEGATE = UINT32;
255#[repr(C)]
256#[derive(Copy)]
257pub struct Struct_tdTPM_SELECT_SIZE {
258 pub major: BYTE,
259 pub minor: BYTE,
260 pub reqSize: UINT16,
261}
262impl ::std::clone::Clone for Struct_tdTPM_SELECT_SIZE {
263 fn clone(&self) -> Struct_tdTPM_SELECT_SIZE { *self }
264}
265impl ::std::default::Default for Struct_tdTPM_SELECT_SIZE {
266 fn default() -> Struct_tdTPM_SELECT_SIZE {
267 unsafe { ::std::mem::zeroed() }
268 }
269}
270pub type TPM_SELECT_SIZE = Struct_tdTPM_SELECT_SIZE;
271#[repr(C)]
272#[derive(Copy)]
273pub struct Struct_tdTPM_CMK_MIGAUTH {
274 pub tag: TPM_STRUCTURE_TAG,
275 pub msaDigest: TPM_DIGEST,
276 pub pubKeyDigest: TPM_DIGEST,
277}
278impl ::std::clone::Clone for Struct_tdTPM_CMK_MIGAUTH {
279 fn clone(&self) -> Struct_tdTPM_CMK_MIGAUTH { *self }
280}
281impl ::std::default::Default for Struct_tdTPM_CMK_MIGAUTH {
282 fn default() -> Struct_tdTPM_CMK_MIGAUTH {
283 unsafe { ::std::mem::zeroed() }
284 }
285}
286pub type TPM_CMK_MIGAUTH = Struct_tdTPM_CMK_MIGAUTH;
287#[repr(C)]
288#[derive(Copy)]
289pub struct Struct_tdTPM_CMK_SIGTICKET {
290 pub tag: TPM_STRUCTURE_TAG,
291 pub verKeyDigest: TPM_DIGEST,
292 pub signedData: TPM_DIGEST,
293}
294impl ::std::clone::Clone for Struct_tdTPM_CMK_SIGTICKET {
295 fn clone(&self) -> Struct_tdTPM_CMK_SIGTICKET { *self }
296}
297impl ::std::default::Default for Struct_tdTPM_CMK_SIGTICKET {
298 fn default() -> Struct_tdTPM_CMK_SIGTICKET {
299 unsafe { ::std::mem::zeroed() }
300 }
301}
302pub type TPM_CMK_SIGTICKET = Struct_tdTPM_CMK_SIGTICKET;
303#[repr(C)]
304#[derive(Copy)]
305pub struct Struct_tdTPM_CMK_MA_APPROVAL {
306 pub tag: TPM_STRUCTURE_TAG,
307 pub migrationAuthorityDigest: TPM_DIGEST,
308}
309impl ::std::clone::Clone for Struct_tdTPM_CMK_MA_APPROVAL {
310 fn clone(&self) -> Struct_tdTPM_CMK_MA_APPROVAL { *self }
311}
312impl ::std::default::Default for Struct_tdTPM_CMK_MA_APPROVAL {
313 fn default() -> Struct_tdTPM_CMK_MA_APPROVAL {
314 unsafe { ::std::mem::zeroed() }
315 }
316}
317pub type TPM_CMK_MA_APPROVAL = Struct_tdTPM_CMK_MA_APPROVAL;
318pub type TPM_TAG = UINT16;
319#[repr(C)]
320#[derive(Copy)]
321pub struct Struct_tdTPM_PERMANENT_FLAGS {
322 pub tag: TPM_STRUCTURE_TAG,
323 pub disable: TSS_BOOL,
324 pub ownership: TSS_BOOL,
325 pub deactivated: TSS_BOOL,
326 pub readPubek: TSS_BOOL,
327 pub disableOwnerClear: TSS_BOOL,
328 pub allowMaintenance: TSS_BOOL,
329 pub physicalPresenceLifetimeLock: TSS_BOOL,
330 pub physicalPresenceHWEnable: TSS_BOOL,
331 pub physicalPresenceCMDEnable: TSS_BOOL,
332 pub CEKPUsed: TSS_BOOL,
333 pub TPMpost: TSS_BOOL,
334 pub TPMpostLock: TSS_BOOL,
335 pub FIPS: TSS_BOOL,
336 pub Operator: TSS_BOOL,
337 pub enableRevokeEK: TSS_BOOL,
338 pub nvLocked: TSS_BOOL,
339 pub readSRKPub: TSS_BOOL,
340 pub tpmEstablished: TSS_BOOL,
341 pub maintenanceDone: TSS_BOOL,
342 pub disableFullDALogicInfo: TSS_BOOL,
343}
344impl ::std::clone::Clone for Struct_tdTPM_PERMANENT_FLAGS {
345 fn clone(&self) -> Struct_tdTPM_PERMANENT_FLAGS { *self }
346}
347impl ::std::default::Default for Struct_tdTPM_PERMANENT_FLAGS {
348 fn default() -> Struct_tdTPM_PERMANENT_FLAGS {
349 unsafe { ::std::mem::zeroed() }
350 }
351}
352pub type TPM_PERMANENT_FLAGS = Struct_tdTPM_PERMANENT_FLAGS;
353#[repr(C)]
354#[derive(Copy)]
355pub struct Struct_tdTPM_STCLEAR_FLAGS {
356 pub tag: TPM_STRUCTURE_TAG,
357 pub deactivated: TSS_BOOL,
358 pub disableForceClear: TSS_BOOL,
359 pub physicalPresence: TSS_BOOL,
360 pub physicalPresenceLock: TSS_BOOL,
361 pub bGlobalLock: TSS_BOOL,
362}
363impl ::std::clone::Clone for Struct_tdTPM_STCLEAR_FLAGS {
364 fn clone(&self) -> Struct_tdTPM_STCLEAR_FLAGS { *self }
365}
366impl ::std::default::Default for Struct_tdTPM_STCLEAR_FLAGS {
367 fn default() -> Struct_tdTPM_STCLEAR_FLAGS {
368 unsafe { ::std::mem::zeroed() }
369 }
370}
371pub type TPM_STCLEAR_FLAGS = Struct_tdTPM_STCLEAR_FLAGS;
372#[repr(C)]
373#[derive(Copy)]
374pub struct Struct_tdTPM_STANY_FLAGS {
375 pub tag: TPM_STRUCTURE_TAG,
376 pub postInitialise: TSS_BOOL,
377 pub localityModifier: TPM_MODIFIER_INDICATOR,
378 pub transportExclusive: TSS_BOOL,
379 pub TOSPresent: TSS_BOOL,
380}
381impl ::std::clone::Clone for Struct_tdTPM_STANY_FLAGS {
382 fn clone(&self) -> Struct_tdTPM_STANY_FLAGS { *self }
383}
384impl ::std::default::Default for Struct_tdTPM_STANY_FLAGS {
385 fn default() -> Struct_tdTPM_STANY_FLAGS {
386 unsafe { ::std::mem::zeroed() }
387 }
388}
389pub type TPM_STANY_FLAGS = Struct_tdTPM_STANY_FLAGS;
390pub type TPM_LOCALITY_SELECTION = BYTE;
391#[repr(C)]
392#[derive(Copy)]
393pub struct Struct_tdTPM_PCR_SELECTION {
394 pub sizeOfSelect: UINT16,
395 pub pcrSelect: *mut BYTE,
396}
397impl ::std::clone::Clone for Struct_tdTPM_PCR_SELECTION {
398 fn clone(&self) -> Struct_tdTPM_PCR_SELECTION { *self }
399}
400impl ::std::default::Default for Struct_tdTPM_PCR_SELECTION {
401 fn default() -> Struct_tdTPM_PCR_SELECTION {
402 unsafe { ::std::mem::zeroed() }
403 }
404}
405pub type TPM_PCR_SELECTION = Struct_tdTPM_PCR_SELECTION;
406#[repr(C)]
407#[derive(Copy)]
408pub struct Struct_tdTPM_PCR_COMPOSITE {
409 pub select: TPM_PCR_SELECTION,
410 pub valueSize: UINT32,
411 pub pcrValue: *mut TPM_PCRVALUE,
412}
413impl ::std::clone::Clone for Struct_tdTPM_PCR_COMPOSITE {
414 fn clone(&self) -> Struct_tdTPM_PCR_COMPOSITE { *self }
415}
416impl ::std::default::Default for Struct_tdTPM_PCR_COMPOSITE {
417 fn default() -> Struct_tdTPM_PCR_COMPOSITE {
418 unsafe { ::std::mem::zeroed() }
419 }
420}
421pub type TPM_PCR_COMPOSITE = Struct_tdTPM_PCR_COMPOSITE;
422#[repr(C)]
423#[derive(Copy)]
424pub struct Struct_tdTPM_PCR_INFO {
425 pub pcrSelection: TPM_PCR_SELECTION,
426 pub digestAtRelease: TPM_COMPOSITE_HASH,
427 pub digestAtCreation: TPM_COMPOSITE_HASH,
428}
429impl ::std::clone::Clone for Struct_tdTPM_PCR_INFO {
430 fn clone(&self) -> Struct_tdTPM_PCR_INFO { *self }
431}
432impl ::std::default::Default for Struct_tdTPM_PCR_INFO {
433 fn default() -> Struct_tdTPM_PCR_INFO { unsafe { ::std::mem::zeroed() } }
434}
435pub type TPM_PCR_INFO = Struct_tdTPM_PCR_INFO;
436#[repr(C)]
437#[derive(Copy)]
438pub struct Struct_tdTPM_PCR_INFO_LONG {
439 pub tag: TPM_STRUCTURE_TAG,
440 pub localityAtCreation: TPM_LOCALITY_SELECTION,
441 pub localityAtRelease: TPM_LOCALITY_SELECTION,
442 pub creationPCRSelection: TPM_PCR_SELECTION,
443 pub releasePCRSelection: TPM_PCR_SELECTION,
444 pub digestAtCreation: TPM_COMPOSITE_HASH,
445 pub digestAtRelease: TPM_COMPOSITE_HASH,
446}
447impl ::std::clone::Clone for Struct_tdTPM_PCR_INFO_LONG {
448 fn clone(&self) -> Struct_tdTPM_PCR_INFO_LONG { *self }
449}
450impl ::std::default::Default for Struct_tdTPM_PCR_INFO_LONG {
451 fn default() -> Struct_tdTPM_PCR_INFO_LONG {
452 unsafe { ::std::mem::zeroed() }
453 }
454}
455pub type TPM_PCR_INFO_LONG = Struct_tdTPM_PCR_INFO_LONG;
456#[repr(C)]
457#[derive(Copy)]
458pub struct Struct_tdTPM_PCR_INFO_SHORT {
459 pub pcrSelection: TPM_PCR_SELECTION,
460 pub localityAtRelease: TPM_LOCALITY_SELECTION,
461 pub digestAtRelease: TPM_COMPOSITE_HASH,
462}
463impl ::std::clone::Clone for Struct_tdTPM_PCR_INFO_SHORT {
464 fn clone(&self) -> Struct_tdTPM_PCR_INFO_SHORT { *self }
465}
466impl ::std::default::Default for Struct_tdTPM_PCR_INFO_SHORT {
467 fn default() -> Struct_tdTPM_PCR_INFO_SHORT {
468 unsafe { ::std::mem::zeroed() }
469 }
470}
471pub type TPM_PCR_INFO_SHORT = Struct_tdTPM_PCR_INFO_SHORT;
472#[repr(C)]
473#[derive(Copy)]
474pub struct Struct_tdTPM_PCR_ATTRIBUTES {
475 pub pcrReset: BYTE,
476 pub pcrExtendLocal: TPM_LOCALITY_SELECTION,
477 pub pcrResetLocal: TPM_LOCALITY_SELECTION,
478}
479impl ::std::clone::Clone for Struct_tdTPM_PCR_ATTRIBUTES {
480 fn clone(&self) -> Struct_tdTPM_PCR_ATTRIBUTES { *self }
481}
482impl ::std::default::Default for Struct_tdTPM_PCR_ATTRIBUTES {
483 fn default() -> Struct_tdTPM_PCR_ATTRIBUTES {
484 unsafe { ::std::mem::zeroed() }
485 }
486}
487pub type TPM_PCR_ATTRIBUTES = Struct_tdTPM_PCR_ATTRIBUTES;
488#[repr(C)]
489#[derive(Copy)]
490pub struct Struct_tdTPM_STORED_DATA {
491 pub ver: TPM_STRUCT_VER,
492 pub sealInfoSize: UINT32,
493 pub sealInfo: *mut BYTE,
494 pub encDataSize: UINT32,
495 pub encData: *mut BYTE,
496}
497impl ::std::clone::Clone for Struct_tdTPM_STORED_DATA {
498 fn clone(&self) -> Struct_tdTPM_STORED_DATA { *self }
499}
500impl ::std::default::Default for Struct_tdTPM_STORED_DATA {
501 fn default() -> Struct_tdTPM_STORED_DATA {
502 unsafe { ::std::mem::zeroed() }
503 }
504}
505pub type TPM_STORED_DATA = Struct_tdTPM_STORED_DATA;
506#[repr(C)]
507#[derive(Copy)]
508pub struct Struct_tdTPM_STORED_DATA12 {
509 pub tag: TPM_STRUCTURE_TAG,
510 pub et: TPM_ENTITY_TYPE,
511 pub sealInfoSize: UINT32,
512 pub sealInfo: *mut BYTE,
513 pub encDataSize: UINT32,
514 pub encData: *mut BYTE,
515}
516impl ::std::clone::Clone for Struct_tdTPM_STORED_DATA12 {
517 fn clone(&self) -> Struct_tdTPM_STORED_DATA12 { *self }
518}
519impl ::std::default::Default for Struct_tdTPM_STORED_DATA12 {
520 fn default() -> Struct_tdTPM_STORED_DATA12 {
521 unsafe { ::std::mem::zeroed() }
522 }
523}
524pub type TPM_STORED_DATA12 = Struct_tdTPM_STORED_DATA12;
525#[repr(C)]
526#[derive(Copy)]
527pub struct Struct_tdTPM_SEALED_DATA {
528 pub payload: TPM_PAYLOAD_TYPE,
529 pub authData: TPM_SECRET,
530 pub tpmProof: TPM_NONCE,
531 pub storedDigest: TPM_DIGEST,
532 pub dataSize: UINT32,
533 pub data: *mut BYTE,
534}
535impl ::std::clone::Clone for Struct_tdTPM_SEALED_DATA {
536 fn clone(&self) -> Struct_tdTPM_SEALED_DATA { *self }
537}
538impl ::std::default::Default for Struct_tdTPM_SEALED_DATA {
539 fn default() -> Struct_tdTPM_SEALED_DATA {
540 unsafe { ::std::mem::zeroed() }
541 }
542}
543pub type TPM_SEALED_DATA = Struct_tdTPM_SEALED_DATA;
544#[repr(C)]
545#[derive(Copy)]
546pub struct Struct_tdTPM_SYMMETRIC_KEY {
547 pub algId: TPM_ALGORITHM_ID,
548 pub encScheme: TPM_ENC_SCHEME,
549 pub size: UINT16,
550 pub data: *mut BYTE,
551}
552impl ::std::clone::Clone for Struct_tdTPM_SYMMETRIC_KEY {
553 fn clone(&self) -> Struct_tdTPM_SYMMETRIC_KEY { *self }
554}
555impl ::std::default::Default for Struct_tdTPM_SYMMETRIC_KEY {
556 fn default() -> Struct_tdTPM_SYMMETRIC_KEY {
557 unsafe { ::std::mem::zeroed() }
558 }
559}
560pub type TPM_SYMMETRIC_KEY = Struct_tdTPM_SYMMETRIC_KEY;
561#[repr(C)]
562#[derive(Copy)]
563pub struct Struct_tdTPM_BOUND_DATA {
564 pub ver: TPM_STRUCT_VER,
565 pub payload: TPM_PAYLOAD_TYPE,
566 pub payloadData: *mut BYTE,
567}
568impl ::std::clone::Clone for Struct_tdTPM_BOUND_DATA {
569 fn clone(&self) -> Struct_tdTPM_BOUND_DATA { *self }
570}
571impl ::std::default::Default for Struct_tdTPM_BOUND_DATA {
572 fn default() -> Struct_tdTPM_BOUND_DATA {
573 unsafe { ::std::mem::zeroed() }
574 }
575}
576pub type TPM_BOUND_DATA = Struct_tdTPM_BOUND_DATA;
577#[repr(C)]
578#[derive(Copy)]
579pub struct Struct_tdTPM_KEY_PARMS {
580 pub algorithmID: TPM_ALGORITHM_ID,
581 pub encScheme: TPM_ENC_SCHEME,
582 pub sigScheme: TPM_SIG_SCHEME,
583 pub parmSize: UINT32,
584 pub parms: *mut BYTE,
585}
586impl ::std::clone::Clone for Struct_tdTPM_KEY_PARMS {
587 fn clone(&self) -> Struct_tdTPM_KEY_PARMS { *self }
588}
589impl ::std::default::Default for Struct_tdTPM_KEY_PARMS {
590 fn default() -> Struct_tdTPM_KEY_PARMS { unsafe { ::std::mem::zeroed() } }
591}
592pub type TPM_KEY_PARMS = Struct_tdTPM_KEY_PARMS;
593#[repr(C)]
594#[derive(Copy)]
595pub struct Struct_tdTPM_RSA_KEY_PARMS {
596 pub keyLength: UINT32,
597 pub numPrimes: UINT32,
598 pub exponentSize: UINT32,
599 pub exponent: *mut BYTE,
600}
601impl ::std::clone::Clone for Struct_tdTPM_RSA_KEY_PARMS {
602 fn clone(&self) -> Struct_tdTPM_RSA_KEY_PARMS { *self }
603}
604impl ::std::default::Default for Struct_tdTPM_RSA_KEY_PARMS {
605 fn default() -> Struct_tdTPM_RSA_KEY_PARMS {
606 unsafe { ::std::mem::zeroed() }
607 }
608}
609pub type TPM_RSA_KEY_PARMS = Struct_tdTPM_RSA_KEY_PARMS;
610#[repr(C)]
611#[derive(Copy)]
612pub struct Struct_tdTPM_SYMMETRIC_KEY_PARMS {
613 pub keyLength: UINT32,
614 pub blockSize: UINT32,
615 pub ivSize: UINT32,
616 pub IV: *mut BYTE,
617}
618impl ::std::clone::Clone for Struct_tdTPM_SYMMETRIC_KEY_PARMS {
619 fn clone(&self) -> Struct_tdTPM_SYMMETRIC_KEY_PARMS { *self }
620}
621impl ::std::default::Default for Struct_tdTPM_SYMMETRIC_KEY_PARMS {
622 fn default() -> Struct_tdTPM_SYMMETRIC_KEY_PARMS {
623 unsafe { ::std::mem::zeroed() }
624 }
625}
626pub type TPM_SYMMETRIC_KEY_PARMS = Struct_tdTPM_SYMMETRIC_KEY_PARMS;
627#[repr(C)]
628#[derive(Copy)]
629pub struct Struct_tdTPM_STORE_PUBKEY {
630 pub keyLength: UINT32,
631 pub key: *mut BYTE,
632}
633impl ::std::clone::Clone for Struct_tdTPM_STORE_PUBKEY {
634 fn clone(&self) -> Struct_tdTPM_STORE_PUBKEY { *self }
635}
636impl ::std::default::Default for Struct_tdTPM_STORE_PUBKEY {
637 fn default() -> Struct_tdTPM_STORE_PUBKEY {
638 unsafe { ::std::mem::zeroed() }
639 }
640}
641pub type TPM_STORE_PUBKEY = Struct_tdTPM_STORE_PUBKEY;
642#[repr(C)]
643#[derive(Copy)]
644pub struct Struct_tdTPM_PUBKEY {
645 pub algorithmParms: TPM_KEY_PARMS,
646 pub pubKey: TPM_STORE_PUBKEY,
647}
648impl ::std::clone::Clone for Struct_tdTPM_PUBKEY {
649 fn clone(&self) -> Struct_tdTPM_PUBKEY { *self }
650}
651impl ::std::default::Default for Struct_tdTPM_PUBKEY {
652 fn default() -> Struct_tdTPM_PUBKEY { unsafe { ::std::mem::zeroed() } }
653}
654pub type TPM_PUBKEY = Struct_tdTPM_PUBKEY;
655#[repr(C)]
656#[derive(Copy)]
657pub struct Struct_tdTPM_STORE_PRIVKEY {
658 pub keyLength: UINT32,
659 pub key: *mut BYTE,
660}
661impl ::std::clone::Clone for Struct_tdTPM_STORE_PRIVKEY {
662 fn clone(&self) -> Struct_tdTPM_STORE_PRIVKEY { *self }
663}
664impl ::std::default::Default for Struct_tdTPM_STORE_PRIVKEY {
665 fn default() -> Struct_tdTPM_STORE_PRIVKEY {
666 unsafe { ::std::mem::zeroed() }
667 }
668}
669pub type TPM_STORE_PRIVKEY = Struct_tdTPM_STORE_PRIVKEY;
670#[repr(C)]
671#[derive(Copy)]
672pub struct Struct_tdTPM_STORE_ASYMKEY {
673 pub payload: TPM_PAYLOAD_TYPE,
674 pub usageAuth: TPM_SECRET,
675 pub migrationAuth: TPM_SECRET,
676 pub pubDataDigest: TPM_DIGEST,
677 pub privKey: TPM_STORE_PRIVKEY,
678}
679impl ::std::clone::Clone for Struct_tdTPM_STORE_ASYMKEY {
680 fn clone(&self) -> Struct_tdTPM_STORE_ASYMKEY { *self }
681}
682impl ::std::default::Default for Struct_tdTPM_STORE_ASYMKEY {
683 fn default() -> Struct_tdTPM_STORE_ASYMKEY {
684 unsafe { ::std::mem::zeroed() }
685 }
686}
687pub type TPM_STORE_ASYMKEY = Struct_tdTPM_STORE_ASYMKEY;
688#[repr(C)]
689#[derive(Copy)]
690pub struct Struct_tdTPM_KEY {
691 pub ver: TPM_STRUCT_VER,
692 pub keyUsage: TPM_KEY_USAGE,
693 pub keyFlags: TPM_KEY_FLAGS,
694 pub authDataUsage: TPM_AUTH_DATA_USAGE,
695 pub algorithmParms: TPM_KEY_PARMS,
696 pub PCRInfoSize: UINT32,
697 pub PCRInfo: *mut BYTE,
698 pub pubKey: TPM_STORE_PUBKEY,
699 pub encSize: UINT32,
700 pub encData: *mut BYTE,
701}
702impl ::std::clone::Clone for Struct_tdTPM_KEY {
703 fn clone(&self) -> Struct_tdTPM_KEY { *self }
704}
705impl ::std::default::Default for Struct_tdTPM_KEY {
706 fn default() -> Struct_tdTPM_KEY { unsafe { ::std::mem::zeroed() } }
707}
708pub type TPM_KEY = Struct_tdTPM_KEY;
709#[repr(C)]
710#[derive(Copy)]
711pub struct Struct_tdTPM_KEY12 {
712 pub tag: TPM_STRUCTURE_TAG,
713 pub fill: UINT16,
714 pub keyUsage: TPM_KEY_USAGE,
715 pub keyFlags: TPM_KEY_FLAGS,
716 pub authDataUsage: TPM_AUTH_DATA_USAGE,
717 pub algorithmParms: TPM_KEY_PARMS,
718 pub PCRInfoSize: UINT32,
719 pub PCRInfo: *mut BYTE,
720 pub pubKey: TPM_STORE_PUBKEY,
721 pub encSize: UINT32,
722 pub encData: *mut BYTE,
723}
724impl ::std::clone::Clone for Struct_tdTPM_KEY12 {
725 fn clone(&self) -> Struct_tdTPM_KEY12 { *self }
726}
727impl ::std::default::Default for Struct_tdTPM_KEY12 {
728 fn default() -> Struct_tdTPM_KEY12 { unsafe { ::std::mem::zeroed() } }
729}
730pub type TPM_KEY12 = Struct_tdTPM_KEY12;
731#[repr(C)]
732#[derive(Copy)]
733pub struct Struct_tdTPM_MIGRATE_ASYMKEY {
734 pub payload: TPM_PAYLOAD_TYPE,
735 pub usageAuth: TPM_SECRET,
736 pub pubDataDigest: TPM_DIGEST,
737 pub partPrivKeyLen: UINT32,
738 pub partPrivKey: *mut BYTE,
739}
740impl ::std::clone::Clone for Struct_tdTPM_MIGRATE_ASYMKEY {
741 fn clone(&self) -> Struct_tdTPM_MIGRATE_ASYMKEY { *self }
742}
743impl ::std::default::Default for Struct_tdTPM_MIGRATE_ASYMKEY {
744 fn default() -> Struct_tdTPM_MIGRATE_ASYMKEY {
745 unsafe { ::std::mem::zeroed() }
746 }
747}
748pub type TPM_MIGRATE_ASYMKEY = Struct_tdTPM_MIGRATE_ASYMKEY;
749pub type TPM_KEY_CONTROL = UINT32;
750#[repr(C)]
751#[derive(Copy)]
752pub struct Struct_tdTPM_MIGRATIONKEYAUTH {
753 pub migrationKey: TPM_PUBKEY,
754 pub migrationScheme: TPM_MIGRATE_SCHEME,
755 pub digest: TPM_DIGEST,
756}
757impl ::std::clone::Clone for Struct_tdTPM_MIGRATIONKEYAUTH {
758 fn clone(&self) -> Struct_tdTPM_MIGRATIONKEYAUTH { *self }
759}
760impl ::std::default::Default for Struct_tdTPM_MIGRATIONKEYAUTH {
761 fn default() -> Struct_tdTPM_MIGRATIONKEYAUTH {
762 unsafe { ::std::mem::zeroed() }
763 }
764}
765pub type TPM_MIGRATIONKEYAUTH = Struct_tdTPM_MIGRATIONKEYAUTH;
766#[repr(C)]
767#[derive(Copy)]
768pub struct Struct_tdTPM_CERTIFY_INFO {
769 pub version: TPM_STRUCT_VER,
770 pub keyUsage: TPM_KEY_USAGE,
771 pub keyFlags: TPM_KEY_FLAGS,
772 pub authDataUsage: TPM_AUTH_DATA_USAGE,
773 pub algorithmParms: TPM_KEY_PARMS,
774 pub pubkeyDigest: TPM_DIGEST,
775 pub data: TPM_NONCE,
776 pub parentPCRStatus: TPM_BOOL,
777 pub PCRInfoSize: UINT32,
778 pub PCRInfo: *mut BYTE,
779}
780impl ::std::clone::Clone for Struct_tdTPM_CERTIFY_INFO {
781 fn clone(&self) -> Struct_tdTPM_CERTIFY_INFO { *self }
782}
783impl ::std::default::Default for Struct_tdTPM_CERTIFY_INFO {
784 fn default() -> Struct_tdTPM_CERTIFY_INFO {
785 unsafe { ::std::mem::zeroed() }
786 }
787}
788pub type TPM_CERTIFY_INFO = Struct_tdTPM_CERTIFY_INFO;
789#[repr(C)]
790#[derive(Copy)]
791pub struct Struct_tdTPM_CERTIFY_INFO2 {
792 pub tag: TPM_STRUCTURE_TAG,
793 pub fill: BYTE,
794 pub payloadType: TPM_PAYLOAD_TYPE,
795 pub keyUsage: TPM_KEY_USAGE,
796 pub keyFlags: TPM_KEY_FLAGS,
797 pub authDataUsage: TPM_AUTH_DATA_USAGE,
798 pub algorithmParms: TPM_KEY_PARMS,
799 pub pubkeyDigest: TPM_DIGEST,
800 pub data: TPM_NONCE,
801 pub parentPCRStatus: TPM_BOOL,
802 pub PCRInfoSize: UINT32,
803 pub PCRInfo: *mut BYTE,
804 pub migrationAuthoritySize: UINT32,
805 pub migrationAuthority: *mut BYTE,
806}
807impl ::std::clone::Clone for Struct_tdTPM_CERTIFY_INFO2 {
808 fn clone(&self) -> Struct_tdTPM_CERTIFY_INFO2 { *self }
809}
810impl ::std::default::Default for Struct_tdTPM_CERTIFY_INFO2 {
811 fn default() -> Struct_tdTPM_CERTIFY_INFO2 {
812 unsafe { ::std::mem::zeroed() }
813 }
814}
815pub type TPM_CERTIFY_INFO2 = Struct_tdTPM_CERTIFY_INFO2;
816#[repr(C)]
817#[derive(Copy)]
818pub struct Struct_tdTPM_QUOTE_INFO {
819 pub version: TPM_STRUCT_VER,
820 pub fixed: [BYTE; 4usize],
821 pub compositeHash: TPM_COMPOSITE_HASH,
822 pub externalData: TPM_NONCE,
823}
824impl ::std::clone::Clone for Struct_tdTPM_QUOTE_INFO {
825 fn clone(&self) -> Struct_tdTPM_QUOTE_INFO { *self }
826}
827impl ::std::default::Default for Struct_tdTPM_QUOTE_INFO {
828 fn default() -> Struct_tdTPM_QUOTE_INFO {
829 unsafe { ::std::mem::zeroed() }
830 }
831}
832pub type TPM_QUOTE_INFO = Struct_tdTPM_QUOTE_INFO;
833#[repr(C)]
834#[derive(Copy)]
835pub struct Struct_tdTPM_QUOTE_INFO2 {
836 pub tag: TPM_STRUCTURE_TAG,
837 pub fixed: [BYTE; 4usize],
838 pub externalData: TPM_NONCE,
839 pub infoShort: TPM_PCR_INFO_SHORT,
840}
841impl ::std::clone::Clone for Struct_tdTPM_QUOTE_INFO2 {
842 fn clone(&self) -> Struct_tdTPM_QUOTE_INFO2 { *self }
843}
844impl ::std::default::Default for Struct_tdTPM_QUOTE_INFO2 {
845 fn default() -> Struct_tdTPM_QUOTE_INFO2 {
846 unsafe { ::std::mem::zeroed() }
847 }
848}
849pub type TPM_QUOTE_INFO2 = Struct_tdTPM_QUOTE_INFO2;
850#[repr(C)]
851#[derive(Copy)]
852pub struct Struct_tdTPM_EK_BLOB {
853 pub tag: TPM_STRUCTURE_TAG,
854 pub ekType: TPM_EK_TYPE,
855 pub blobSize: UINT32,
856 pub blob: *mut BYTE,
857}
858impl ::std::clone::Clone for Struct_tdTPM_EK_BLOB {
859 fn clone(&self) -> Struct_tdTPM_EK_BLOB { *self }
860}
861impl ::std::default::Default for Struct_tdTPM_EK_BLOB {
862 fn default() -> Struct_tdTPM_EK_BLOB { unsafe { ::std::mem::zeroed() } }
863}
864pub type TPM_EK_BLOB = Struct_tdTPM_EK_BLOB;
865#[repr(C)]
866#[derive(Copy)]
867pub struct Struct_tdTPM_EK_BLOB_ACTIVATE {
868 pub tag: TPM_STRUCTURE_TAG,
869 pub sessionKey: TPM_SYMMETRIC_KEY,
870 pub idDigest: TPM_DIGEST,
871 pub pcrInfo: TPM_PCR_INFO_SHORT,
872}
873impl ::std::clone::Clone for Struct_tdTPM_EK_BLOB_ACTIVATE {
874 fn clone(&self) -> Struct_tdTPM_EK_BLOB_ACTIVATE { *self }
875}
876impl ::std::default::Default for Struct_tdTPM_EK_BLOB_ACTIVATE {
877 fn default() -> Struct_tdTPM_EK_BLOB_ACTIVATE {
878 unsafe { ::std::mem::zeroed() }
879 }
880}
881pub type TPM_EK_BLOB_ACTIVATE = Struct_tdTPM_EK_BLOB_ACTIVATE;
882#[repr(C)]
883#[derive(Copy)]
884pub struct Struct_tdTPM_EK_BLOB_AUTH {
885 pub tag: TPM_STRUCTURE_TAG,
886 pub authValue: TPM_SECRET,
887}
888impl ::std::clone::Clone for Struct_tdTPM_EK_BLOB_AUTH {
889 fn clone(&self) -> Struct_tdTPM_EK_BLOB_AUTH { *self }
890}
891impl ::std::default::Default for Struct_tdTPM_EK_BLOB_AUTH {
892 fn default() -> Struct_tdTPM_EK_BLOB_AUTH {
893 unsafe { ::std::mem::zeroed() }
894 }
895}
896pub type TPM_EK_BLOB_AUTH = Struct_tdTPM_EK_BLOB_AUTH;
897#[repr(C)]
898#[derive(Copy)]
899pub struct Struct_tdTPM_IDENTITY_CONTENTS {
900 pub ver: TPM_STRUCT_VER,
901 pub ordinal: UINT32,
902 pub labelPrivCADigest: TPM_CHOSENID_HASH,
903 pub identityPubKey: TPM_PUBKEY,
904}
905impl ::std::clone::Clone for Struct_tdTPM_IDENTITY_CONTENTS {
906 fn clone(&self) -> Struct_tdTPM_IDENTITY_CONTENTS { *self }
907}
908impl ::std::default::Default for Struct_tdTPM_IDENTITY_CONTENTS {
909 fn default() -> Struct_tdTPM_IDENTITY_CONTENTS {
910 unsafe { ::std::mem::zeroed() }
911 }
912}
913pub type TPM_IDENTITY_CONTENTS = Struct_tdTPM_IDENTITY_CONTENTS;
914#[repr(C)]
915#[derive(Copy)]
916pub struct Struct_tdTPM_IDENTITY_REQ {
917 pub asymSize: UINT32,
918 pub symSize: UINT32,
919 pub asymAlgorithm: TPM_KEY_PARMS,
920 pub symAlgorithm: TPM_KEY_PARMS,
921 pub asymBlob: *mut BYTE,
922 pub symBlob: *mut BYTE,
923}
924impl ::std::clone::Clone for Struct_tdTPM_IDENTITY_REQ {
925 fn clone(&self) -> Struct_tdTPM_IDENTITY_REQ { *self }
926}
927impl ::std::default::Default for Struct_tdTPM_IDENTITY_REQ {
928 fn default() -> Struct_tdTPM_IDENTITY_REQ {
929 unsafe { ::std::mem::zeroed() }
930 }
931}
932pub type TPM_IDENTITY_REQ = Struct_tdTPM_IDENTITY_REQ;
933#[repr(C)]
934#[derive(Copy)]
935pub struct Struct_tdTPM_IDENTITY_PROOF {
936 pub ver: TPM_STRUCT_VER,
937 pub labelSize: UINT32,
938 pub identityBindingSize: UINT32,
939 pub endorsementSize: UINT32,
940 pub platformSize: UINT32,
941 pub conformanceSize: UINT32,
942 pub identityKey: TPM_PUBKEY,
943 pub labelArea: *mut BYTE,
944 pub identityBinding: *mut BYTE,
945 pub endorsementCredential: *mut BYTE,
946 pub platformCredential: *mut BYTE,
947 pub conformanceCredential: *mut BYTE,
948}
949impl ::std::clone::Clone for Struct_tdTPM_IDENTITY_PROOF {
950 fn clone(&self) -> Struct_tdTPM_IDENTITY_PROOF { *self }
951}
952impl ::std::default::Default for Struct_tdTPM_IDENTITY_PROOF {
953 fn default() -> Struct_tdTPM_IDENTITY_PROOF {
954 unsafe { ::std::mem::zeroed() }
955 }
956}
957pub type TPM_IDENTITY_PROOF = Struct_tdTPM_IDENTITY_PROOF;
958#[repr(C)]
959#[derive(Copy)]
960pub struct Struct_tdTPM_ASYM_CA_CONTENTS {
961 pub sessionKey: TPM_SYMMETRIC_KEY,
962 pub idDigest: TPM_DIGEST,
963}
964impl ::std::clone::Clone for Struct_tdTPM_ASYM_CA_CONTENTS {
965 fn clone(&self) -> Struct_tdTPM_ASYM_CA_CONTENTS { *self }
966}
967impl ::std::default::Default for Struct_tdTPM_ASYM_CA_CONTENTS {
968 fn default() -> Struct_tdTPM_ASYM_CA_CONTENTS {
969 unsafe { ::std::mem::zeroed() }
970 }
971}
972pub type TPM_ASYM_CA_CONTENTS = Struct_tdTPM_ASYM_CA_CONTENTS;
973#[repr(C)]
974#[derive(Copy)]
975pub struct Struct_tdTPM_SYM_CA_ATTESTATION {
976 pub credSize: UINT32,
977 pub algorithm: TPM_KEY_PARMS,
978 pub credential: *mut BYTE,
979}
980impl ::std::clone::Clone for Struct_tdTPM_SYM_CA_ATTESTATION {
981 fn clone(&self) -> Struct_tdTPM_SYM_CA_ATTESTATION { *self }
982}
983impl ::std::default::Default for Struct_tdTPM_SYM_CA_ATTESTATION {
984 fn default() -> Struct_tdTPM_SYM_CA_ATTESTATION {
985 unsafe { ::std::mem::zeroed() }
986 }
987}
988pub type TPM_SYM_CA_ATTESTATION = Struct_tdTPM_SYM_CA_ATTESTATION;
989#[repr(C)]
990#[derive(Copy)]
991pub struct Struct_tdTPM_CURRENT_TICKS {
992 pub tag: TPM_STRUCTURE_TAG,
993 pub currentTicks: UINT64,
994 pub tickRate: UINT16,
995 pub tickNonce: TPM_NONCE,
996}
997impl ::std::clone::Clone for Struct_tdTPM_CURRENT_TICKS {
998 fn clone(&self) -> Struct_tdTPM_CURRENT_TICKS { *self }
999}
1000impl ::std::default::Default for Struct_tdTPM_CURRENT_TICKS {
1001 fn default() -> Struct_tdTPM_CURRENT_TICKS {
1002 unsafe { ::std::mem::zeroed() }
1003 }
1004}
1005pub type TPM_CURRENT_TICKS = Struct_tdTPM_CURRENT_TICKS;
1006pub type TPM_TRANSPORT_ATTRIBUTES = UINT32;
1007#[repr(C)]
1008#[derive(Copy)]
1009pub struct Struct_tdTPM_TRANSPORT_PUBLIC {
1010 pub tag: TPM_STRUCTURE_TAG,
1011 pub transAttributes: TPM_TRANSPORT_ATTRIBUTES,
1012 pub algId: TPM_ALGORITHM_ID,
1013 pub encScheme: TPM_ENC_SCHEME,
1014}
1015impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_PUBLIC {
1016 fn clone(&self) -> Struct_tdTPM_TRANSPORT_PUBLIC { *self }
1017}
1018impl ::std::default::Default for Struct_tdTPM_TRANSPORT_PUBLIC {
1019 fn default() -> Struct_tdTPM_TRANSPORT_PUBLIC {
1020 unsafe { ::std::mem::zeroed() }
1021 }
1022}
1023pub type TPM_TRANSPORT_PUBLIC = Struct_tdTPM_TRANSPORT_PUBLIC;
1024#[repr(C)]
1025#[derive(Copy)]
1026pub struct Struct_tdTPM_TRANSPORT_INTERNAL {
1027 pub tag: TPM_STRUCTURE_TAG,
1028 pub authData: TPM_AUTHDATA,
1029 pub transPublic: TPM_TRANSPORT_PUBLIC,
1030 pub transHandle: TPM_TRANSHANDLE,
1031 pub transNonceEven: TPM_NONCE,
1032 pub transDigest: TPM_DIGEST,
1033}
1034impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_INTERNAL {
1035 fn clone(&self) -> Struct_tdTPM_TRANSPORT_INTERNAL { *self }
1036}
1037impl ::std::default::Default for Struct_tdTPM_TRANSPORT_INTERNAL {
1038 fn default() -> Struct_tdTPM_TRANSPORT_INTERNAL {
1039 unsafe { ::std::mem::zeroed() }
1040 }
1041}
1042pub type TPM_TRANSPORT_INTERNAL = Struct_tdTPM_TRANSPORT_INTERNAL;
1043#[repr(C)]
1044#[derive(Copy)]
1045pub struct Struct_tdTPM_TRANSPORT_LOG_IN {
1046 pub tag: TPM_STRUCTURE_TAG,
1047 pub parameters: TPM_DIGEST,
1048 pub pubKeyHash: TPM_DIGEST,
1049}
1050impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_LOG_IN {
1051 fn clone(&self) -> Struct_tdTPM_TRANSPORT_LOG_IN { *self }
1052}
1053impl ::std::default::Default for Struct_tdTPM_TRANSPORT_LOG_IN {
1054 fn default() -> Struct_tdTPM_TRANSPORT_LOG_IN {
1055 unsafe { ::std::mem::zeroed() }
1056 }
1057}
1058pub type TPM_TRANSPORT_LOG_IN = Struct_tdTPM_TRANSPORT_LOG_IN;
1059#[repr(C)]
1060#[derive(Copy)]
1061pub struct Struct_tdTPM_TRANSPORT_LOG_OUT {
1062 pub tag: TPM_STRUCTURE_TAG,
1063 pub currentTicks: TPM_CURRENT_TICKS,
1064 pub parameters: TPM_DIGEST,
1065 pub locality: TPM_MODIFIER_INDICATOR,
1066}
1067impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_LOG_OUT {
1068 fn clone(&self) -> Struct_tdTPM_TRANSPORT_LOG_OUT { *self }
1069}
1070impl ::std::default::Default for Struct_tdTPM_TRANSPORT_LOG_OUT {
1071 fn default() -> Struct_tdTPM_TRANSPORT_LOG_OUT {
1072 unsafe { ::std::mem::zeroed() }
1073 }
1074}
1075pub type TPM_TRANSPORT_LOG_OUT = Struct_tdTPM_TRANSPORT_LOG_OUT;
1076#[repr(C)]
1077#[derive(Copy)]
1078pub struct Struct_tdTPM_TRANSPORT_AUTH {
1079 pub tag: TPM_STRUCTURE_TAG,
1080 pub authData: TPM_AUTHDATA,
1081}
1082impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_AUTH {
1083 fn clone(&self) -> Struct_tdTPM_TRANSPORT_AUTH { *self }
1084}
1085impl ::std::default::Default for Struct_tdTPM_TRANSPORT_AUTH {
1086 fn default() -> Struct_tdTPM_TRANSPORT_AUTH {
1087 unsafe { ::std::mem::zeroed() }
1088 }
1089}
1090pub type TPM_TRANSPORT_AUTH = Struct_tdTPM_TRANSPORT_AUTH;
1091#[repr(C)]
1092#[derive(Copy)]
1093pub struct Struct_tdTPM_AUDIT_EVENT_IN {
1094 pub tag: TPM_STRUCTURE_TAG,
1095 pub inputParms: TPM_DIGEST,
1096 pub auditCount: TPM_COUNTER_VALUE,
1097}
1098impl ::std::clone::Clone for Struct_tdTPM_AUDIT_EVENT_IN {
1099 fn clone(&self) -> Struct_tdTPM_AUDIT_EVENT_IN { *self }
1100}
1101impl ::std::default::Default for Struct_tdTPM_AUDIT_EVENT_IN {
1102 fn default() -> Struct_tdTPM_AUDIT_EVENT_IN {
1103 unsafe { ::std::mem::zeroed() }
1104 }
1105}
1106pub type TPM_AUDIT_EVENT_IN = Struct_tdTPM_AUDIT_EVENT_IN;
1107#[repr(C)]
1108#[derive(Copy)]
1109pub struct Struct_tdTPM_AUDIT_EVENT_OUT {
1110 pub tag: TPM_STRUCTURE_TAG,
1111 pub ordinal: TPM_COMMAND_CODE,
1112 pub outputParms: TPM_DIGEST,
1113 pub auditCount: TPM_COUNTER_VALUE,
1114 pub returnCode: TPM_RESULT,
1115}
1116impl ::std::clone::Clone for Struct_tdTPM_AUDIT_EVENT_OUT {
1117 fn clone(&self) -> Struct_tdTPM_AUDIT_EVENT_OUT { *self }
1118}
1119impl ::std::default::Default for Struct_tdTPM_AUDIT_EVENT_OUT {
1120 fn default() -> Struct_tdTPM_AUDIT_EVENT_OUT {
1121 unsafe { ::std::mem::zeroed() }
1122 }
1123}
1124pub type TPM_AUDIT_EVENT_OUT = Struct_tdTPM_AUDIT_EVENT_OUT;
1125#[repr(C)]
1126#[derive(Copy)]
1127pub struct Struct_tdTPM_CONTEXT_BLOB {
1128 pub tag: TPM_STRUCTURE_TAG,
1129 pub resourceType: TPM_RESOURCE_TYPE,
1130 pub handle: TPM_HANDLE,
1131 pub label: [BYTE; 16usize],
1132 pub contextCount: UINT32,
1133 pub integrityDigest: TPM_DIGEST,
1134 pub additionalSize: UINT32,
1135 pub additionalData: *mut BYTE,
1136 pub sensitiveSize: UINT32,
1137 pub sensitiveData: *mut BYTE,
1138}
1139impl ::std::clone::Clone for Struct_tdTPM_CONTEXT_BLOB {
1140 fn clone(&self) -> Struct_tdTPM_CONTEXT_BLOB { *self }
1141}
1142impl ::std::default::Default for Struct_tdTPM_CONTEXT_BLOB {
1143 fn default() -> Struct_tdTPM_CONTEXT_BLOB {
1144 unsafe { ::std::mem::zeroed() }
1145 }
1146}
1147pub type TPM_CONTEXT_BLOB = Struct_tdTPM_CONTEXT_BLOB;
1148#[repr(C)]
1149#[derive(Copy)]
1150pub struct Struct_tdTPM_CONTEXT_SENSITIVE {
1151 pub tag: TPM_STRUCTURE_TAG,
1152 pub contextNonce: TPM_NONCE,
1153 pub internalSize: UINT32,
1154 pub internalData: *mut BYTE,
1155}
1156impl ::std::clone::Clone for Struct_tdTPM_CONTEXT_SENSITIVE {
1157 fn clone(&self) -> Struct_tdTPM_CONTEXT_SENSITIVE { *self }
1158}
1159impl ::std::default::Default for Struct_tdTPM_CONTEXT_SENSITIVE {
1160 fn default() -> Struct_tdTPM_CONTEXT_SENSITIVE {
1161 unsafe { ::std::mem::zeroed() }
1162 }
1163}
1164pub type TPM_CONTEXT_SENSITIVE = Struct_tdTPM_CONTEXT_SENSITIVE;
1165pub type TPM_NV_INDEX = UINT32;
1166pub type TPM_NV_PER_ATTRIBUTES = UINT32;
1167#[repr(C)]
1168#[derive(Copy)]
1169pub struct Struct_tdTPM_NV_ATTRIBUTES {
1170 pub tag: TPM_STRUCTURE_TAG,
1171 pub attributes: TPM_NV_PER_ATTRIBUTES,
1172}
1173impl ::std::clone::Clone for Struct_tdTPM_NV_ATTRIBUTES {
1174 fn clone(&self) -> Struct_tdTPM_NV_ATTRIBUTES { *self }
1175}
1176impl ::std::default::Default for Struct_tdTPM_NV_ATTRIBUTES {
1177 fn default() -> Struct_tdTPM_NV_ATTRIBUTES {
1178 unsafe { ::std::mem::zeroed() }
1179 }
1180}
1181pub type TPM_NV_ATTRIBUTES = Struct_tdTPM_NV_ATTRIBUTES;
1182#[repr(C)]
1183#[derive(Copy)]
1184pub struct Struct_tdTPM_NV_DATA_PUBLIC {
1185 pub tag: TPM_STRUCTURE_TAG,
1186 pub nvIndex: TPM_NV_INDEX,
1187 pub pcrInfoRead: TPM_PCR_INFO_SHORT,
1188 pub pcrInfoWrite: TPM_PCR_INFO_SHORT,
1189 pub permission: TPM_NV_ATTRIBUTES,
1190 pub bReadSTClear: TPM_BOOL,
1191 pub bWriteSTClear: TPM_BOOL,
1192 pub bWriteDefine: TPM_BOOL,
1193 pub dataSize: UINT32,
1194}
1195impl ::std::clone::Clone for Struct_tdTPM_NV_DATA_PUBLIC {
1196 fn clone(&self) -> Struct_tdTPM_NV_DATA_PUBLIC { *self }
1197}
1198impl ::std::default::Default for Struct_tdTPM_NV_DATA_PUBLIC {
1199 fn default() -> Struct_tdTPM_NV_DATA_PUBLIC {
1200 unsafe { ::std::mem::zeroed() }
1201 }
1202}
1203pub type TPM_NV_DATA_PUBLIC = Struct_tdTPM_NV_DATA_PUBLIC;
1204pub type TPM_FAMILY_VERIFICATION = UINT32;
1205pub type TPM_FAMILY_ID = UINT32;
1206pub type TPM_DELEGATE_INDEX = UINT32;
1207pub type TPM_FAMILY_OPERATION = UINT32;
1208pub type TPM_FAMILY_FLAGS = UINT32;
1209#[repr(C)]
1210#[derive(Copy)]
1211pub struct Struct_tdTPM_FAMILY_LABEL {
1212 pub label: BYTE,
1213}
1214impl ::std::clone::Clone for Struct_tdTPM_FAMILY_LABEL {
1215 fn clone(&self) -> Struct_tdTPM_FAMILY_LABEL { *self }
1216}
1217impl ::std::default::Default for Struct_tdTPM_FAMILY_LABEL {
1218 fn default() -> Struct_tdTPM_FAMILY_LABEL {
1219 unsafe { ::std::mem::zeroed() }
1220 }
1221}
1222pub type TPM_FAMILY_LABEL = Struct_tdTPM_FAMILY_LABEL;
1223#[repr(C)]
1224#[derive(Copy)]
1225pub struct Struct_tdTPM_FAMILY_TABLE_ENTRY {
1226 pub tag: TPM_STRUCTURE_TAG,
1227 pub label: TPM_FAMILY_LABEL,
1228 pub familyID: TPM_FAMILY_ID,
1229 pub verificationCount: TPM_FAMILY_VERIFICATION,
1230 pub flags: TPM_FAMILY_FLAGS,
1231}
1232impl ::std::clone::Clone for Struct_tdTPM_FAMILY_TABLE_ENTRY {
1233 fn clone(&self) -> Struct_tdTPM_FAMILY_TABLE_ENTRY { *self }
1234}
1235impl ::std::default::Default for Struct_tdTPM_FAMILY_TABLE_ENTRY {
1236 fn default() -> Struct_tdTPM_FAMILY_TABLE_ENTRY {
1237 unsafe { ::std::mem::zeroed() }
1238 }
1239}
1240pub type TPM_FAMILY_TABLE_ENTRY = Struct_tdTPM_FAMILY_TABLE_ENTRY;
1241#[repr(C)]
1242#[derive(Copy)]
1243pub struct Struct_tdTPM_DELEGATE_LABEL {
1244 pub label: BYTE,
1245}
1246impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_LABEL {
1247 fn clone(&self) -> Struct_tdTPM_DELEGATE_LABEL { *self }
1248}
1249impl ::std::default::Default for Struct_tdTPM_DELEGATE_LABEL {
1250 fn default() -> Struct_tdTPM_DELEGATE_LABEL {
1251 unsafe { ::std::mem::zeroed() }
1252 }
1253}
1254pub type TPM_DELEGATE_LABEL = Struct_tdTPM_DELEGATE_LABEL;
1255pub type TPM_DELEGATE_TYPE = UINT32;
1256#[repr(C)]
1257#[derive(Copy)]
1258pub struct Struct_tdTPM_DELEGATIONS {
1259 pub tag: TPM_STRUCTURE_TAG,
1260 pub delegateType: TPM_DELEGATE_TYPE,
1261 pub per1: UINT32,
1262 pub per2: UINT32,
1263}
1264impl ::std::clone::Clone for Struct_tdTPM_DELEGATIONS {
1265 fn clone(&self) -> Struct_tdTPM_DELEGATIONS { *self }
1266}
1267impl ::std::default::Default for Struct_tdTPM_DELEGATIONS {
1268 fn default() -> Struct_tdTPM_DELEGATIONS {
1269 unsafe { ::std::mem::zeroed() }
1270 }
1271}
1272pub type TPM_DELEGATIONS = Struct_tdTPM_DELEGATIONS;
1273#[repr(C)]
1274#[derive(Copy)]
1275pub struct Struct_tdTPM_DELEGATE_PUBLIC {
1276 pub tag: TPM_STRUCTURE_TAG,
1277 pub label: TPM_DELEGATE_LABEL,
1278 pub pcrInfo: TPM_PCR_INFO_SHORT,
1279 pub permissions: TPM_DELEGATIONS,
1280 pub familyID: TPM_FAMILY_ID,
1281 pub verificationCount: TPM_FAMILY_VERIFICATION,
1282}
1283impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_PUBLIC {
1284 fn clone(&self) -> Struct_tdTPM_DELEGATE_PUBLIC { *self }
1285}
1286impl ::std::default::Default for Struct_tdTPM_DELEGATE_PUBLIC {
1287 fn default() -> Struct_tdTPM_DELEGATE_PUBLIC {
1288 unsafe { ::std::mem::zeroed() }
1289 }
1290}
1291pub type TPM_DELEGATE_PUBLIC = Struct_tdTPM_DELEGATE_PUBLIC;
1292#[repr(C)]
1293#[derive(Copy)]
1294pub struct Struct_tdTPM_DELEGATE_TABLE_ROW {
1295 pub tag: TPM_STRUCTURE_TAG,
1296 pub _pub: TPM_DELEGATE_PUBLIC,
1297 pub authValue: TPM_SECRET,
1298}
1299impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_TABLE_ROW {
1300 fn clone(&self) -> Struct_tdTPM_DELEGATE_TABLE_ROW { *self }
1301}
1302impl ::std::default::Default for Struct_tdTPM_DELEGATE_TABLE_ROW {
1303 fn default() -> Struct_tdTPM_DELEGATE_TABLE_ROW {
1304 unsafe { ::std::mem::zeroed() }
1305 }
1306}
1307pub type TPM_DELEGATE_TABLE_ROW = Struct_tdTPM_DELEGATE_TABLE_ROW;
1308#[repr(C)]
1309#[derive(Copy)]
1310pub struct Struct_tdTPM_DELEGATE_SENSITIVE {
1311 pub tag: TPM_STRUCTURE_TAG,
1312 pub authValue: TPM_SECRET,
1313}
1314impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_SENSITIVE {
1315 fn clone(&self) -> Struct_tdTPM_DELEGATE_SENSITIVE { *self }
1316}
1317impl ::std::default::Default for Struct_tdTPM_DELEGATE_SENSITIVE {
1318 fn default() -> Struct_tdTPM_DELEGATE_SENSITIVE {
1319 unsafe { ::std::mem::zeroed() }
1320 }
1321}
1322pub type TPM_DELEGATE_SENSITIVE = Struct_tdTPM_DELEGATE_SENSITIVE;
1323#[repr(C)]
1324#[derive(Copy)]
1325pub struct Struct_tdTPM_DELEGATE_OWNER_BLOB {
1326 pub tag: TPM_STRUCTURE_TAG,
1327 pub _pub: TPM_DELEGATE_PUBLIC,
1328 pub integrityDigest: TPM_DIGEST,
1329 pub additionalSize: UINT32,
1330 pub additionalArea: *mut BYTE,
1331 pub sensitiveSize: UINT32,
1332 pub sensitiveArea: *mut BYTE,
1333}
1334impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_OWNER_BLOB {
1335 fn clone(&self) -> Struct_tdTPM_DELEGATE_OWNER_BLOB { *self }
1336}
1337impl ::std::default::Default for Struct_tdTPM_DELEGATE_OWNER_BLOB {
1338 fn default() -> Struct_tdTPM_DELEGATE_OWNER_BLOB {
1339 unsafe { ::std::mem::zeroed() }
1340 }
1341}
1342pub type TPM_DELEGATE_OWNER_BLOB = Struct_tdTPM_DELEGATE_OWNER_BLOB;
1343#[repr(C)]
1344#[derive(Copy)]
1345pub struct Struct_tdTPM_DELEGATE_KEY_BLOB {
1346 pub tag: TPM_STRUCTURE_TAG,
1347 pub _pub: TPM_DELEGATE_PUBLIC,
1348 pub integrityDigest: TPM_DIGEST,
1349 pub pubKeyDigest: TPM_DIGEST,
1350 pub additionalSize: UINT32,
1351 pub additionalArea: *mut BYTE,
1352 pub sensitiveSize: UINT32,
1353 pub sensitiveArea: *mut BYTE,
1354}
1355impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_KEY_BLOB {
1356 fn clone(&self) -> Struct_tdTPM_DELEGATE_KEY_BLOB { *self }
1357}
1358impl ::std::default::Default for Struct_tdTPM_DELEGATE_KEY_BLOB {
1359 fn default() -> Struct_tdTPM_DELEGATE_KEY_BLOB {
1360 unsafe { ::std::mem::zeroed() }
1361 }
1362}
1363pub type TPM_DELEGATE_KEY_BLOB = Struct_tdTPM_DELEGATE_KEY_BLOB;
1364pub type TPM_CAPABILITY_AREA = UINT32;
1365#[repr(C)]
1366#[derive(Copy)]
1367pub struct Struct_tdTPM_CAP_VERSION_INFO {
1368 pub tag: TPM_STRUCTURE_TAG,
1369 pub version: TPM_VERSION,
1370 pub specLevel: UINT16,
1371 pub errataRev: BYTE,
1372 pub tpmVendorID: [BYTE; 4usize],
1373 pub vendorSpecificSize: UINT16,
1374 pub vendorSpecific: *mut BYTE,
1375}
1376impl ::std::clone::Clone for Struct_tdTPM_CAP_VERSION_INFO {
1377 fn clone(&self) -> Struct_tdTPM_CAP_VERSION_INFO { *self }
1378}
1379impl ::std::default::Default for Struct_tdTPM_CAP_VERSION_INFO {
1380 fn default() -> Struct_tdTPM_CAP_VERSION_INFO {
1381 unsafe { ::std::mem::zeroed() }
1382 }
1383}
1384pub type TPM_CAP_VERSION_INFO = Struct_tdTPM_CAP_VERSION_INFO;
1385pub type TPM_DA_STATE = BYTE;
1386#[repr(C)]
1387#[derive(Copy)]
1388pub struct Struct_tdTPM_DA_ACTION_TYPE {
1389 pub tag: TPM_STRUCTURE_TAG,
1390 pub actions: UINT32,
1391}
1392impl ::std::clone::Clone for Struct_tdTPM_DA_ACTION_TYPE {
1393 fn clone(&self) -> Struct_tdTPM_DA_ACTION_TYPE { *self }
1394}
1395impl ::std::default::Default for Struct_tdTPM_DA_ACTION_TYPE {
1396 fn default() -> Struct_tdTPM_DA_ACTION_TYPE {
1397 unsafe { ::std::mem::zeroed() }
1398 }
1399}
1400pub type TPM_DA_ACTION_TYPE = Struct_tdTPM_DA_ACTION_TYPE;
1401#[repr(C)]
1402#[derive(Copy)]
1403pub struct Struct_tdTPM_DA_INFO {
1404 pub tag: TPM_STRUCTURE_TAG,
1405 pub state: TPM_DA_STATE,
1406 pub currentCount: UINT16,
1407 pub threshholdCount: UINT16,
1408 pub actionAtThreshold: TPM_DA_ACTION_TYPE,
1409 pub actionDependValue: UINT32,
1410 pub vendorDataSize: UINT32,
1411 pub vendorData: *mut BYTE,
1412}
1413impl ::std::clone::Clone for Struct_tdTPM_DA_INFO {
1414 fn clone(&self) -> Struct_tdTPM_DA_INFO { *self }
1415}
1416impl ::std::default::Default for Struct_tdTPM_DA_INFO {
1417 fn default() -> Struct_tdTPM_DA_INFO { unsafe { ::std::mem::zeroed() } }
1418}
1419pub type TPM_DA_INFO = Struct_tdTPM_DA_INFO;
1420#[repr(C)]
1421#[derive(Copy)]
1422pub struct Struct_tdTPM_DA_INFO_LIMITED {
1423 pub tag: TPM_STRUCTURE_TAG,
1424 pub state: TPM_DA_STATE,
1425 pub actionAtThreshold: TPM_DA_ACTION_TYPE,
1426 pub vendorDataSize: UINT32,
1427 pub vendorData: *mut BYTE,
1428}
1429impl ::std::clone::Clone for Struct_tdTPM_DA_INFO_LIMITED {
1430 fn clone(&self) -> Struct_tdTPM_DA_INFO_LIMITED { *self }
1431}
1432impl ::std::default::Default for Struct_tdTPM_DA_INFO_LIMITED {
1433 fn default() -> Struct_tdTPM_DA_INFO_LIMITED {
1434 unsafe { ::std::mem::zeroed() }
1435 }
1436}
1437pub type TPM_DA_INFO_LIMITED = Struct_tdTPM_DA_INFO_LIMITED;
1438#[repr(C)]
1439#[derive(Copy)]
1440pub struct Struct_tdTPM_DAA_ISSUER {
1441 pub tag: TPM_STRUCTURE_TAG,
1442 pub DAA_digest_R0: TPM_DIGEST,
1443 pub DAA_digest_R1: TPM_DIGEST,
1444 pub DAA_digest_S0: TPM_DIGEST,
1445 pub DAA_digest_S1: TPM_DIGEST,
1446 pub DAA_digest_n: TPM_DIGEST,
1447 pub DAA_digest_gamma: TPM_DIGEST,
1448 pub DAA_generic_q: [BYTE; 26usize],
1449}
1450impl ::std::clone::Clone for Struct_tdTPM_DAA_ISSUER {
1451 fn clone(&self) -> Struct_tdTPM_DAA_ISSUER { *self }
1452}
1453impl ::std::default::Default for Struct_tdTPM_DAA_ISSUER {
1454 fn default() -> Struct_tdTPM_DAA_ISSUER {
1455 unsafe { ::std::mem::zeroed() }
1456 }
1457}
1458pub type TPM_DAA_ISSUER = Struct_tdTPM_DAA_ISSUER;
1459#[repr(C)]
1460#[derive(Copy)]
1461pub struct Struct_tdTPM_DAA_TPM {
1462 pub tag: TPM_STRUCTURE_TAG,
1463 pub DAA_digestIssuer: TPM_DIGEST,
1464 pub DAA_digest_v0: TPM_DIGEST,
1465 pub DAA_digest_v1: TPM_DIGEST,
1466 pub DAA_rekey: TPM_DIGEST,
1467 pub DAA_count: UINT32,
1468}
1469impl ::std::clone::Clone for Struct_tdTPM_DAA_TPM {
1470 fn clone(&self) -> Struct_tdTPM_DAA_TPM { *self }
1471}
1472impl ::std::default::Default for Struct_tdTPM_DAA_TPM {
1473 fn default() -> Struct_tdTPM_DAA_TPM { unsafe { ::std::mem::zeroed() } }
1474}
1475pub type TPM_DAA_TPM = Struct_tdTPM_DAA_TPM;
1476#[repr(C)]
1477#[derive(Copy)]
1478pub struct Struct_tdTPM_DAA_CONTEXT {
1479 pub tag: TPM_STRUCTURE_TAG,
1480 pub DAA_digestContext: TPM_DIGEST,
1481 pub DAA_digest: TPM_DIGEST,
1482 pub DAA_contextSeed: TPM_DAA_CONTEXT_SEED,
1483 pub DAA_scratch: [BYTE; 256usize],
1484 pub DAA_stage: BYTE,
1485}
1486impl ::std::clone::Clone for Struct_tdTPM_DAA_CONTEXT {
1487 fn clone(&self) -> Struct_tdTPM_DAA_CONTEXT { *self }
1488}
1489impl ::std::default::Default for Struct_tdTPM_DAA_CONTEXT {
1490 fn default() -> Struct_tdTPM_DAA_CONTEXT {
1491 unsafe { ::std::mem::zeroed() }
1492 }
1493}
1494pub type TPM_DAA_CONTEXT = Struct_tdTPM_DAA_CONTEXT;
1495#[repr(C)]
1496#[derive(Copy)]
1497pub struct Struct_tdTPM_DAA_JOINDATA {
1498 pub DAA_join_u0: [BYTE; 128usize],
1499 pub DAA_join_u1: [BYTE; 138usize],
1500 pub DAA_digest_n0: TPM_DIGEST,
1501}
1502impl ::std::clone::Clone for Struct_tdTPM_DAA_JOINDATA {
1503 fn clone(&self) -> Struct_tdTPM_DAA_JOINDATA { *self }
1504}
1505impl ::std::default::Default for Struct_tdTPM_DAA_JOINDATA {
1506 fn default() -> Struct_tdTPM_DAA_JOINDATA {
1507 unsafe { ::std::mem::zeroed() }
1508 }
1509}
1510pub type TPM_DAA_JOINDATA = Struct_tdTPM_DAA_JOINDATA;
1511#[repr(C)]
1512#[derive(Copy)]
1513pub struct Struct_tdTPM_DAA_BLOB {
1514 pub tag: TPM_STRUCTURE_TAG,
1515 pub resourceType: TPM_RESOURCE_TYPE,
1516 pub label: [BYTE; 16usize],
1517 pub blobIntegrity: TPM_DIGEST,
1518 pub additionalSize: UINT32,
1519 pub additionalData: *mut BYTE,
1520 pub sensitiveSize: UINT32,
1521 pub sensitiveData: *mut BYTE,
1522}
1523impl ::std::clone::Clone for Struct_tdTPM_DAA_BLOB {
1524 fn clone(&self) -> Struct_tdTPM_DAA_BLOB { *self }
1525}
1526impl ::std::default::Default for Struct_tdTPM_DAA_BLOB {
1527 fn default() -> Struct_tdTPM_DAA_BLOB { unsafe { ::std::mem::zeroed() } }
1528}
1529pub type TPM_DAA_BLOB = Struct_tdTPM_DAA_BLOB;
1530#[repr(C)]
1531#[derive(Copy)]
1532pub struct Struct_tdTPM_DAA_SENSITIVE {
1533 pub tag: TPM_STRUCTURE_TAG,
1534 pub internalSize: UINT32,
1535 pub internalData: *mut BYTE,
1536}
1537impl ::std::clone::Clone for Struct_tdTPM_DAA_SENSITIVE {
1538 fn clone(&self) -> Struct_tdTPM_DAA_SENSITIVE { *self }
1539}
1540impl ::std::default::Default for Struct_tdTPM_DAA_SENSITIVE {
1541 fn default() -> Struct_tdTPM_DAA_SENSITIVE {
1542 unsafe { ::std::mem::zeroed() }
1543 }
1544}
1545pub type TPM_DAA_SENSITIVE = Struct_tdTPM_DAA_SENSITIVE;
1546pub type TPM_SYM_MODE = UINT32;
1547pub type UNICODE = TSS_UNICODE;
1548pub type TCPA_DIGEST = TPM_DIGEST;
1549pub type TCPA_NONCE = TPM_NONCE;
1550pub type TCPA_SALT_NONCE = TPM_NONCE;
1551pub type TCPA_PUBKEY = TPM_PUBKEY;
1552pub type TCPA_SECRET = TPM_SECRET;
1553pub type TCPA_KEY = TPM_KEY;
1554pub type TCPA_DIRVALUE = TPM_DIRVALUE;
1555pub type TCPA_COMMAND_CODE = TPM_COMMAND_CODE;
1556pub type TCPA_BOUND_DATA = TPM_BOUND_DATA;
1557pub type TCPA_VERSION = TPM_STRUCT_VER;
1558pub type TCPA_RESULT = TPM_RESULT;
1559pub type TCPA_PAYLOAD_TYPE = TPM_PAYLOAD_TYPE;
1560pub type TCPA_STORE_PRIVKEY = TPM_STORE_PRIVKEY;
1561pub type TCPA_CHOSENID_HASH = TPM_CHOSENID_HASH;
1562pub type TCPA_SYMMETRIC_KEY = TPM_SYMMETRIC_KEY;
1563pub type TCPA_PCR_INFO = TPM_PCR_INFO;
1564pub type TCPA_PCR_SELECTION = TPM_PCR_SELECTION;
1565pub type TCPA_STORED_DATA = TPM_STORED_DATA;
1566pub type TCPA_SEALED_DATA = TPM_SEALED_DATA;
1567pub type TCPA_KEY_FLAGS = TPM_KEY_FLAGS;
1568pub type TCPA_KEY_PARMS = TPM_KEY_PARMS;
1569pub type TCPA_STORE_PUBKEY = TPM_STORE_PUBKEY;
1570pub type TCPA_MIGRATIONKEYAUTH = TPM_MIGRATIONKEYAUTH;
1571pub type TCPA_RSA_KEY_PARMS = TPM_RSA_KEY_PARMS;
1572pub type TCPA_CERTIFY_INFO = TPM_CERTIFY_INFO;
1573pub type TCPA_STORE_ASYMKEY = TPM_STORE_ASYMKEY;
1574pub type TCPA_ENCAUTH = TPM_ENCAUTH;
1575pub type TCPA_PCRINDEX = TPM_PCRINDEX;
1576pub type TCPA_PCRVALUE = TPM_PCRVALUE;
1577pub type TCPA_DIRINDEX = TPM_DIRINDEX;
1578pub type TCPA_PROTOCOL_ID = TPM_PROTOCOL_ID;
1579pub type TCPA_ALGORITHM_ID = TPM_ALGORITHM_ID;
1580pub type TCPA_ENTITY_TYPE = TPM_ENTITY_TYPE;
1581pub type TCPA_CAPABILITY_AREA = TPM_CAPABILITY_AREA;
1582pub type TCPA_HMAC = TPM_HMAC;
1583pub type TCPA_MIGRATE_SCHEME = TPM_MIGRATE_SCHEME;
1584pub type TCPA_PHYSICAL_PRESENCE = TPM_PHYSICAL_PRESENCE;
1585pub type TCPA_KEY_HANDLE = TPM_KEY_HANDLE;
1586pub type TCPA_KEY_HANDLE_LIST = TPM_KEY_HANDLE_LIST;
1587pub type TCPA_PCR_COMPOSITE = TPM_PCR_COMPOSITE;
1588pub type TCPA_AUTH_DATA_USAGE = TPM_AUTH_DATA_USAGE;
1589pub type TCPA_AUTHDATA = TPM_AUTHDATA;
1590pub type TCPA_KEY_USAGE = TPM_KEY_USAGE;
1591pub type TCPA_COMPOSITE_HASH = TPM_COMPOSITE_HASH;
1592pub type TCPA_QUOTE_INFO = TPM_QUOTE_INFO;
1593pub type TCPA_TAG = TPM_TAG;
1594pub type TCPA_ENC_SCHEME = TPM_ENC_SCHEME;
1595pub type TCPA_SIG_SCHEME = TPM_SIG_SCHEME;
1596pub type TCPA_STARTUP_TYPE = TPM_STARTUP_TYPE;
1597pub type TCPA_AUTHHANDLE = TPM_AUTHHANDLE;
1598pub type TCPA_SYM_CA_ATTESTATION = TPM_SYM_CA_ATTESTATION;
1599pub type TCPA_ASYM_CA_CONTENTS = TPM_ASYM_CA_CONTENTS;
1600pub type TCPA_IDENTITY_REQ = TPM_IDENTITY_REQ;
1601pub type TCPA_IDENTITY_PROOF = TPM_IDENTITY_PROOF;
1602pub type TCPA_ENCHANDLE = UINT32;
1603pub type TCPA_EVENTTYPE = UINT32;
1604#[repr(C)]
1605#[derive(Copy)]
1606pub struct Struct_tdTCPA_AUDIT_EVENT {
1607 pub ordinal: TCPA_COMMAND_CODE,
1608 pub returncode: TCPA_RESULT,
1609}
1610impl ::std::clone::Clone for Struct_tdTCPA_AUDIT_EVENT {
1611 fn clone(&self) -> Struct_tdTCPA_AUDIT_EVENT { *self }
1612}
1613impl ::std::default::Default for Struct_tdTCPA_AUDIT_EVENT {
1614 fn default() -> Struct_tdTCPA_AUDIT_EVENT {
1615 unsafe { ::std::mem::zeroed() }
1616 }
1617}
1618pub type TCPA_AUDIT_EVENT = Struct_tdTCPA_AUDIT_EVENT;
1619pub type TSS_HANDLE = UINT32;
1620pub type TSS_FLAG = UINT32;
1621pub type TSS_RESULT = UINT32;
1622pub type TSS_HOBJECT = UINT32;
1623pub type TSS_HCONTEXT = TSS_HOBJECT;
1624pub type TSS_HPOLICY = TSS_HOBJECT;
1625pub type TSS_HTPM = TSS_HOBJECT;
1626pub type TSS_HKEY = TSS_HOBJECT;
1627pub type TSS_HENCDATA = TSS_HOBJECT;
1628pub type TSS_HPCRS = TSS_HOBJECT;
1629pub type TSS_HHASH = TSS_HOBJECT;
1630pub type TSS_HNVSTORE = TSS_HOBJECT;
1631pub type TSS_HMIGDATA = TSS_HOBJECT;
1632pub type TSS_HDELFAMILY = TSS_HOBJECT;
1633pub type TSS_HDAA_CREDENTIAL = TSS_HOBJECT;
1634pub type TSS_HDAA_ISSUER_KEY = TSS_HOBJECT;
1635pub type TSS_HDAA_ARA_KEY = TSS_HOBJECT;
1636pub type TSS_EVENTTYPE = UINT32;
1637pub type TSS_MIGRATE_SCHEME = UINT16;
1638pub type TSS_ALGORITHM_ID = UINT32;
1639pub type TSS_KEY_USAGE_ID = UINT32;
1640pub type TSS_KEY_ENC_SCHEME = UINT16;
1641pub type TSS_KEY_SIG_SCHEME = UINT16;
1642pub type TSS_KEY_AUTH_DATA_USAGE = BYTE;
1643pub type TSS_CMK_DELEGATE = UINT32;
1644pub type TSS_NV_INDEX = UINT32;
1645pub type TSS_COUNTER_ID = UINT32;
1646#[repr(C)]
1647#[derive(Copy)]
1648pub struct Struct_tdTSS_VERSION {
1649 pub bMajor: BYTE,
1650 pub bMinor: BYTE,
1651 pub bRevMajor: BYTE,
1652 pub bRevMinor: BYTE,
1653}
1654impl ::std::clone::Clone for Struct_tdTSS_VERSION {
1655 fn clone(&self) -> Struct_tdTSS_VERSION { *self }
1656}
1657impl ::std::default::Default for Struct_tdTSS_VERSION {
1658 fn default() -> Struct_tdTSS_VERSION { unsafe { ::std::mem::zeroed() } }
1659}
1660pub type TSS_VERSION = Struct_tdTSS_VERSION;
1661#[repr(C)]
1662#[derive(Copy)]
1663pub struct Struct_tdTSS_PCR_EVENT {
1664 pub versionInfo: TSS_VERSION,
1665 pub ulPcrIndex: UINT32,
1666 pub eventType: TSS_EVENTTYPE,
1667 pub ulPcrValueLength: UINT32,
1668 pub rgbPcrValue: *mut BYTE,
1669 pub ulEventLength: UINT32,
1670 pub rgbEvent: *mut BYTE,
1671}
1672impl ::std::clone::Clone for Struct_tdTSS_PCR_EVENT {
1673 fn clone(&self) -> Struct_tdTSS_PCR_EVENT { *self }
1674}
1675impl ::std::default::Default for Struct_tdTSS_PCR_EVENT {
1676 fn default() -> Struct_tdTSS_PCR_EVENT { unsafe { ::std::mem::zeroed() } }
1677}
1678pub type TSS_PCR_EVENT = Struct_tdTSS_PCR_EVENT;
1679#[repr(C)]
1680#[derive(Copy)]
1681pub struct Struct_tdTSS_EVENT_CERT {
1682 pub versionInfo: TSS_VERSION,
1683 pub ulCertificateHashLength: UINT32,
1684 pub rgbCertificateHash: *mut BYTE,
1685 pub ulEntityDigestLength: UINT32,
1686 pub rgbentityDigest: *mut BYTE,
1687 pub fDigestChecked: TSS_BOOL,
1688 pub fDigestVerified: TSS_BOOL,
1689 pub ulIssuerLength: UINT32,
1690 pub rgbIssuer: *mut BYTE,
1691}
1692impl ::std::clone::Clone for Struct_tdTSS_EVENT_CERT {
1693 fn clone(&self) -> Struct_tdTSS_EVENT_CERT { *self }
1694}
1695impl ::std::default::Default for Struct_tdTSS_EVENT_CERT {
1696 fn default() -> Struct_tdTSS_EVENT_CERT {
1697 unsafe { ::std::mem::zeroed() }
1698 }
1699}
1700pub type TSS_EVENT_CERT = Struct_tdTSS_EVENT_CERT;
1701#[repr(C)]
1702#[derive(Copy)]
1703pub struct Struct_tdTSS_UUID {
1704 pub ulTimeLow: UINT32,
1705 pub usTimeMid: UINT16,
1706 pub usTimeHigh: UINT16,
1707 pub bClockSeqHigh: BYTE,
1708 pub bClockSeqLow: BYTE,
1709 pub rgbNode: [BYTE; 6usize],
1710}
1711impl ::std::clone::Clone for Struct_tdTSS_UUID {
1712 fn clone(&self) -> Struct_tdTSS_UUID { *self }
1713}
1714impl ::std::default::Default for Struct_tdTSS_UUID {
1715 fn default() -> Struct_tdTSS_UUID { unsafe { ::std::mem::zeroed() } }
1716}
1717pub type TSS_UUID = Struct_tdTSS_UUID;
1718#[repr(C)]
1719#[derive(Copy)]
1720pub struct Struct_tdTSS_KM_KEYINFO {
1721 pub versionInfo: TSS_VERSION,
1722 pub keyUUID: TSS_UUID,
1723 pub parentKeyUUID: TSS_UUID,
1724 pub bAuthDataUsage: BYTE,
1725 pub fIsLoaded: TSS_BOOL,
1726 pub ulVendorDataLength: UINT32,
1727 pub rgbVendorData: *mut BYTE,
1728}
1729impl ::std::clone::Clone for Struct_tdTSS_KM_KEYINFO {
1730 fn clone(&self) -> Struct_tdTSS_KM_KEYINFO { *self }
1731}
1732impl ::std::default::Default for Struct_tdTSS_KM_KEYINFO {
1733 fn default() -> Struct_tdTSS_KM_KEYINFO {
1734 unsafe { ::std::mem::zeroed() }
1735 }
1736}
1737pub type TSS_KM_KEYINFO = Struct_tdTSS_KM_KEYINFO;
1738#[repr(C)]
1739#[derive(Copy)]
1740pub struct Struct_tdTSS_KM_KEYINFO2 {
1741 pub versionInfo: TSS_VERSION,
1742 pub keyUUID: TSS_UUID,
1743 pub parentKeyUUID: TSS_UUID,
1744 pub bAuthDataUsage: BYTE,
1745 pub persistentStorageType: TSS_FLAG,
1746 pub persistentStorageTypeParent: TSS_FLAG,
1747 pub fIsLoaded: TSS_BOOL,
1748 pub ulVendorDataLength: UINT32,
1749 pub rgbVendorData: *mut BYTE,
1750}
1751impl ::std::clone::Clone for Struct_tdTSS_KM_KEYINFO2 {
1752 fn clone(&self) -> Struct_tdTSS_KM_KEYINFO2 { *self }
1753}
1754impl ::std::default::Default for Struct_tdTSS_KM_KEYINFO2 {
1755 fn default() -> Struct_tdTSS_KM_KEYINFO2 {
1756 unsafe { ::std::mem::zeroed() }
1757 }
1758}
1759pub type TSS_KM_KEYINFO2 = Struct_tdTSS_KM_KEYINFO2;
1760#[repr(C)]
1761#[derive(Copy)]
1762pub struct Struct_tdTSS_NONCE {
1763 pub nonce: [BYTE; 20usize],
1764}
1765impl ::std::clone::Clone for Struct_tdTSS_NONCE {
1766 fn clone(&self) -> Struct_tdTSS_NONCE { *self }
1767}
1768impl ::std::default::Default for Struct_tdTSS_NONCE {
1769 fn default() -> Struct_tdTSS_NONCE { unsafe { ::std::mem::zeroed() } }
1770}
1771pub type TSS_NONCE = Struct_tdTSS_NONCE;
1772#[repr(C)]
1773#[derive(Copy)]
1774pub struct Struct_tdTSS_VALIDATION {
1775 pub versionInfo: TSS_VERSION,
1776 pub ulExternalDataLength: UINT32,
1777 pub rgbExternalData: *mut BYTE,
1778 pub ulDataLength: UINT32,
1779 pub rgbData: *mut BYTE,
1780 pub ulValidationDataLength: UINT32,
1781 pub rgbValidationData: *mut BYTE,
1782}
1783impl ::std::clone::Clone for Struct_tdTSS_VALIDATION {
1784 fn clone(&self) -> Struct_tdTSS_VALIDATION { *self }
1785}
1786impl ::std::default::Default for Struct_tdTSS_VALIDATION {
1787 fn default() -> Struct_tdTSS_VALIDATION {
1788 unsafe { ::std::mem::zeroed() }
1789 }
1790}
1791pub type TSS_VALIDATION = Struct_tdTSS_VALIDATION;
1792#[repr(C)]
1793#[derive(Copy)]
1794pub struct Struct_tdTSS_CALLBACK {
1795 pub callback: PVOID,
1796 pub appData: PVOID,
1797 pub alg: TSS_ALGORITHM_ID,
1798}
1799impl ::std::clone::Clone for Struct_tdTSS_CALLBACK {
1800 fn clone(&self) -> Struct_tdTSS_CALLBACK { *self }
1801}
1802impl ::std::default::Default for Struct_tdTSS_CALLBACK {
1803 fn default() -> Struct_tdTSS_CALLBACK { unsafe { ::std::mem::zeroed() } }
1804}
1805pub type TSS_CALLBACK = Struct_tdTSS_CALLBACK;
1806#[repr(C)]
1807#[derive(Copy)]
1808pub struct Struct_tdTSS_DAA_PK {
1809 pub versionInfo: TSS_VERSION,
1810 pub modulusLength: UINT32,
1811 pub modulus: *mut BYTE,
1812 pub capitalSLength: UINT32,
1813 pub capitalS: *mut BYTE,
1814 pub capitalZLength: UINT32,
1815 pub capitalZ: *mut BYTE,
1816 pub capitalR0Length: UINT32,
1817 pub capitalR0: *mut BYTE,
1818 pub capitalR1Length: UINT32,
1819 pub capitalR1: *mut BYTE,
1820 pub gammaLength: UINT32,
1821 pub gamma: *mut BYTE,
1822 pub capitalGammaLength: UINT32,
1823 pub capitalGamma: *mut BYTE,
1824 pub rhoLength: UINT32,
1825 pub rho: *mut BYTE,
1826 pub capitalYLength: UINT32,
1827 pub capitalYLength2: UINT32,
1828 pub capitalY: *mut *mut BYTE,
1829 pub capitalYPlatformLength: UINT32,
1830 pub issuerBaseNameLength: UINT32,
1831 pub issuerBaseName: *mut BYTE,
1832 pub numPlatformAttributes: UINT32,
1833 pub numIssuerAttributes: UINT32,
1834}
1835impl ::std::clone::Clone for Struct_tdTSS_DAA_PK {
1836 fn clone(&self) -> Struct_tdTSS_DAA_PK { *self }
1837}
1838impl ::std::default::Default for Struct_tdTSS_DAA_PK {
1839 fn default() -> Struct_tdTSS_DAA_PK { unsafe { ::std::mem::zeroed() } }
1840}
1841pub type TSS_DAA_PK = Struct_tdTSS_DAA_PK;
1842#[repr(C)]
1843#[derive(Copy)]
1844pub struct Struct_tdTSS_DAA_PK_PROOF {
1845 pub versionInfo: TSS_VERSION,
1846 pub challengeLength: UINT32,
1847 pub challenge: *mut BYTE,
1848 pub responseLength: UINT32,
1849 pub responseLength2: UINT32,
1850 pub response: *mut *mut BYTE,
1851}
1852impl ::std::clone::Clone for Struct_tdTSS_DAA_PK_PROOF {
1853 fn clone(&self) -> Struct_tdTSS_DAA_PK_PROOF { *self }
1854}
1855impl ::std::default::Default for Struct_tdTSS_DAA_PK_PROOF {
1856 fn default() -> Struct_tdTSS_DAA_PK_PROOF {
1857 unsafe { ::std::mem::zeroed() }
1858 }
1859}
1860pub type TSS_DAA_PK_PROOF = Struct_tdTSS_DAA_PK_PROOF;
1861#[repr(C)]
1862#[derive(Copy)]
1863pub struct Struct_tdTSS_DAA_SK {
1864 pub versionInfo: TSS_VERSION,
1865 pub productPQprimeLength: UINT32,
1866 pub productPQprime: *mut BYTE,
1867}
1868impl ::std::clone::Clone for Struct_tdTSS_DAA_SK {
1869 fn clone(&self) -> Struct_tdTSS_DAA_SK { *self }
1870}
1871impl ::std::default::Default for Struct_tdTSS_DAA_SK {
1872 fn default() -> Struct_tdTSS_DAA_SK { unsafe { ::std::mem::zeroed() } }
1873}
1874pub type TSS_DAA_SK = Struct_tdTSS_DAA_SK;
1875#[repr(C)]
1876#[derive(Copy)]
1877pub struct Struct_tdTSS_DAA_KEY_PAIR {
1878 pub versionInfo: TSS_VERSION,
1879 pub secretKey: TSS_DAA_SK,
1880 pub publicKey: TSS_DAA_PK,
1881}
1882impl ::std::clone::Clone for Struct_tdTSS_DAA_KEY_PAIR {
1883 fn clone(&self) -> Struct_tdTSS_DAA_KEY_PAIR { *self }
1884}
1885impl ::std::default::Default for Struct_tdTSS_DAA_KEY_PAIR {
1886 fn default() -> Struct_tdTSS_DAA_KEY_PAIR {
1887 unsafe { ::std::mem::zeroed() }
1888 }
1889}
1890pub type TSS_DAA_KEY_PAIR = Struct_tdTSS_DAA_KEY_PAIR;
1891#[repr(C)]
1892#[derive(Copy)]
1893pub struct Struct_tdTSS_DAA_AR_PK {
1894 pub versionInfo: TSS_VERSION,
1895 pub etaLength: UINT32,
1896 pub eta: *mut BYTE,
1897 pub lambda1Length: UINT32,
1898 pub lambda1: *mut BYTE,
1899 pub lambda2Length: UINT32,
1900 pub lambda2: *mut BYTE,
1901 pub lambda3Length: UINT32,
1902 pub lambda3: *mut BYTE,
1903}
1904impl ::std::clone::Clone for Struct_tdTSS_DAA_AR_PK {
1905 fn clone(&self) -> Struct_tdTSS_DAA_AR_PK { *self }
1906}
1907impl ::std::default::Default for Struct_tdTSS_DAA_AR_PK {
1908 fn default() -> Struct_tdTSS_DAA_AR_PK { unsafe { ::std::mem::zeroed() } }
1909}
1910pub type TSS_DAA_AR_PK = Struct_tdTSS_DAA_AR_PK;
1911#[repr(C)]
1912#[derive(Copy)]
1913pub struct Struct_tdTSS_DAA_AR_SK {
1914 pub versionInfo: TSS_VERSION,
1915 pub x0Length: UINT32,
1916 pub x0: *mut BYTE,
1917 pub x1Length: UINT32,
1918 pub x1: *mut BYTE,
1919 pub x2Length: UINT32,
1920 pub x2: *mut BYTE,
1921 pub x3Length: UINT32,
1922 pub x3: *mut BYTE,
1923 pub x4Length: UINT32,
1924 pub x4: *mut BYTE,
1925 pub x5Length: UINT32,
1926 pub x5: *mut BYTE,
1927}
1928impl ::std::clone::Clone for Struct_tdTSS_DAA_AR_SK {
1929 fn clone(&self) -> Struct_tdTSS_DAA_AR_SK { *self }
1930}
1931impl ::std::default::Default for Struct_tdTSS_DAA_AR_SK {
1932 fn default() -> Struct_tdTSS_DAA_AR_SK { unsafe { ::std::mem::zeroed() } }
1933}
1934pub type TSS_DAA_AR_SK = Struct_tdTSS_DAA_AR_SK;
1935#[repr(C)]
1936#[derive(Copy)]
1937pub struct Struct_tdTSS_DAA_AR_KEY_PAIR {
1938 pub versionInfo: TSS_VERSION,
1939 pub secretKey: TSS_DAA_AR_SK,
1940 pub publicKey: TSS_DAA_AR_PK,
1941}
1942impl ::std::clone::Clone for Struct_tdTSS_DAA_AR_KEY_PAIR {
1943 fn clone(&self) -> Struct_tdTSS_DAA_AR_KEY_PAIR { *self }
1944}
1945impl ::std::default::Default for Struct_tdTSS_DAA_AR_KEY_PAIR {
1946 fn default() -> Struct_tdTSS_DAA_AR_KEY_PAIR {
1947 unsafe { ::std::mem::zeroed() }
1948 }
1949}
1950pub type TSS_DAA_AR_KEY_PAIR = Struct_tdTSS_DAA_AR_KEY_PAIR;
1951#[repr(C)]
1952#[derive(Copy)]
1953pub struct Struct_tdTSS_DAA_CRED_ISSUER {
1954 pub versionInfo: TSS_VERSION,
1955 pub capitalALength: UINT32,
1956 pub capitalA: *mut BYTE,
1957 pub eLength: UINT32,
1958 pub e: *mut BYTE,
1959 pub vPrimePrimeLength: UINT32,
1960 pub vPrimePrime: *mut BYTE,
1961 pub attributesIssuerLength: UINT32,
1962 pub attributesIssuerLength2: UINT32,
1963 pub attributesIssuer: *mut *mut BYTE,
1964 pub cPrimeLength: UINT32,
1965 pub cPrime: *mut BYTE,
1966 pub sELength: UINT32,
1967 pub sE: *mut BYTE,
1968}
1969impl ::std::clone::Clone for Struct_tdTSS_DAA_CRED_ISSUER {
1970 fn clone(&self) -> Struct_tdTSS_DAA_CRED_ISSUER { *self }
1971}
1972impl ::std::default::Default for Struct_tdTSS_DAA_CRED_ISSUER {
1973 fn default() -> Struct_tdTSS_DAA_CRED_ISSUER {
1974 unsafe { ::std::mem::zeroed() }
1975 }
1976}
1977pub type TSS_DAA_CRED_ISSUER = Struct_tdTSS_DAA_CRED_ISSUER;
1978#[repr(C)]
1979#[derive(Copy)]
1980pub struct Struct_tdTSS_DAA_CREDENTIAL {
1981 pub versionInfo: TSS_VERSION,
1982 pub capitalALength: UINT32,
1983 pub capitalA: *mut BYTE,
1984 pub exponentLength: UINT32,
1985 pub exponent: *mut BYTE,
1986 pub vBar0Length: UINT32,
1987 pub vBar0: *mut BYTE,
1988 pub vBar1Length: UINT32,
1989 pub vBar1: *mut BYTE,
1990 pub attributesLength: UINT32,
1991 pub attributesLength2: UINT32,
1992 pub attributes: *mut *mut BYTE,
1993 pub issuerPK: TSS_DAA_PK,
1994 pub tpmSpecificEncLength: UINT32,
1995 pub tpmSpecificEnc: *mut BYTE,
1996 pub daaCounter: UINT32,
1997}
1998impl ::std::clone::Clone for Struct_tdTSS_DAA_CREDENTIAL {
1999 fn clone(&self) -> Struct_tdTSS_DAA_CREDENTIAL { *self }
2000}
2001impl ::std::default::Default for Struct_tdTSS_DAA_CREDENTIAL {
2002 fn default() -> Struct_tdTSS_DAA_CREDENTIAL {
2003 unsafe { ::std::mem::zeroed() }
2004 }
2005}
2006pub type TSS_DAA_CREDENTIAL = Struct_tdTSS_DAA_CREDENTIAL;
2007#[repr(C)]
2008#[derive(Copy)]
2009pub struct Struct_tdTSS_DAA_ATTRIB_COMMIT {
2010 pub versionInfo: TSS_VERSION,
2011 pub betaLength: UINT32,
2012 pub beta: *mut BYTE,
2013 pub sMuLength: UINT32,
2014 pub sMu: *mut BYTE,
2015}
2016impl ::std::clone::Clone for Struct_tdTSS_DAA_ATTRIB_COMMIT {
2017 fn clone(&self) -> Struct_tdTSS_DAA_ATTRIB_COMMIT { *self }
2018}
2019impl ::std::default::Default for Struct_tdTSS_DAA_ATTRIB_COMMIT {
2020 fn default() -> Struct_tdTSS_DAA_ATTRIB_COMMIT {
2021 unsafe { ::std::mem::zeroed() }
2022 }
2023}
2024pub type TSS_DAA_ATTRIB_COMMIT = Struct_tdTSS_DAA_ATTRIB_COMMIT;
2025#[repr(C)]
2026#[derive(Copy)]
2027pub struct Struct_tdTSS_DAA_CREDENTIAL_REQUEST {
2028 pub versionInfo: TSS_VERSION,
2029 pub capitalULength: UINT32,
2030 pub capitalU: *mut BYTE,
2031 pub capitalNiLength: UINT32,
2032 pub capitalNi: *mut BYTE,
2033 pub authenticationProofLength: UINT32,
2034 pub authenticationProof: *mut BYTE,
2035 pub challengeLength: UINT32,
2036 pub challenge: *mut BYTE,
2037 pub nonceTpmLength: UINT32,
2038 pub nonceTpm: *mut BYTE,
2039 pub noncePlatformLength: UINT32,
2040 pub noncePlatform: *mut BYTE,
2041 pub sF0Length: UINT32,
2042 pub sF0: *mut BYTE,
2043 pub sF1Length: UINT32,
2044 pub sF1: *mut BYTE,
2045 pub sVprimeLength: UINT32,
2046 pub sVprime: *mut BYTE,
2047 pub sVtildePrimeLength: UINT32,
2048 pub sVtildePrime: *mut BYTE,
2049 pub sALength: UINT32,
2050 pub sALength2: UINT32,
2051 pub sA: *mut *mut BYTE,
2052 pub attributeCommitmentsLength: UINT32,
2053 pub attributeCommitments: *mut TSS_DAA_ATTRIB_COMMIT,
2054}
2055impl ::std::clone::Clone for Struct_tdTSS_DAA_CREDENTIAL_REQUEST {
2056 fn clone(&self) -> Struct_tdTSS_DAA_CREDENTIAL_REQUEST { *self }
2057}
2058impl ::std::default::Default for Struct_tdTSS_DAA_CREDENTIAL_REQUEST {
2059 fn default() -> Struct_tdTSS_DAA_CREDENTIAL_REQUEST {
2060 unsafe { ::std::mem::zeroed() }
2061 }
2062}
2063pub type TSS_DAA_CREDENTIAL_REQUEST = Struct_tdTSS_DAA_CREDENTIAL_REQUEST;
2064#[repr(C)]
2065#[derive(Copy)]
2066pub struct Struct_tdTSS_DAA_SELECTED_ATTRIB {
2067 pub versionInfo: TSS_VERSION,
2068 pub indicesListLength: UINT32,
2069 pub indicesList: *mut TSS_BOOL,
2070}
2071impl ::std::clone::Clone for Struct_tdTSS_DAA_SELECTED_ATTRIB {
2072 fn clone(&self) -> Struct_tdTSS_DAA_SELECTED_ATTRIB { *self }
2073}
2074impl ::std::default::Default for Struct_tdTSS_DAA_SELECTED_ATTRIB {
2075 fn default() -> Struct_tdTSS_DAA_SELECTED_ATTRIB {
2076 unsafe { ::std::mem::zeroed() }
2077 }
2078}
2079pub type TSS_DAA_SELECTED_ATTRIB = Struct_tdTSS_DAA_SELECTED_ATTRIB;
2080#[repr(C)]
2081#[derive(Copy)]
2082pub struct Struct_tdTSS_DAA_PSEUDONYM {
2083 pub versionInfo: TSS_VERSION,
2084 pub payloadFlag: TSS_FLAG,
2085 pub payloadLength: UINT32,
2086 pub payload: *mut BYTE,
2087}
2088impl ::std::clone::Clone for Struct_tdTSS_DAA_PSEUDONYM {
2089 fn clone(&self) -> Struct_tdTSS_DAA_PSEUDONYM { *self }
2090}
2091impl ::std::default::Default for Struct_tdTSS_DAA_PSEUDONYM {
2092 fn default() -> Struct_tdTSS_DAA_PSEUDONYM {
2093 unsafe { ::std::mem::zeroed() }
2094 }
2095}
2096pub type TSS_DAA_PSEUDONYM = Struct_tdTSS_DAA_PSEUDONYM;
2097#[repr(C)]
2098#[derive(Copy)]
2099pub struct Struct_tdTSS_DAA_PSEUDONYM_PLAIN {
2100 pub versionInfo: TSS_VERSION,
2101 pub capitalNvLength: UINT32,
2102 pub capitalNv: *mut BYTE,
2103}
2104impl ::std::clone::Clone for Struct_tdTSS_DAA_PSEUDONYM_PLAIN {
2105 fn clone(&self) -> Struct_tdTSS_DAA_PSEUDONYM_PLAIN { *self }
2106}
2107impl ::std::default::Default for Struct_tdTSS_DAA_PSEUDONYM_PLAIN {
2108 fn default() -> Struct_tdTSS_DAA_PSEUDONYM_PLAIN {
2109 unsafe { ::std::mem::zeroed() }
2110 }
2111}
2112pub type TSS_DAA_PSEUDONYM_PLAIN = Struct_tdTSS_DAA_PSEUDONYM_PLAIN;
2113#[repr(C)]
2114#[derive(Copy)]
2115pub struct Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED {
2116 pub versionInfo: TSS_VERSION,
2117 pub delta1Length: UINT32,
2118 pub delta1: *mut BYTE,
2119 pub delta2Length: UINT32,
2120 pub delta2: *mut BYTE,
2121 pub delta3Length: UINT32,
2122 pub delta3: *mut BYTE,
2123 pub delta4Length: UINT32,
2124 pub delta4: *mut BYTE,
2125 pub sTauLength: UINT32,
2126 pub sTau: *mut BYTE,
2127}
2128impl ::std::clone::Clone for Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED {
2129 fn clone(&self) -> Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED { *self }
2130}
2131impl ::std::default::Default for Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED {
2132 fn default() -> Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED {
2133 unsafe { ::std::mem::zeroed() }
2134 }
2135}
2136pub type TSS_DAA_PSEUDONYM_ENCRYPTED = Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED;
2137#[repr(C)]
2138#[derive(Copy)]
2139pub struct Struct_tdTSS_DAA_SIGN_CALLBACK {
2140 pub versionInfo: TSS_VERSION,
2141 pub challenge: TSS_HHASH,
2142 pub payloadFlag: TSS_FLAG,
2143 pub payloadLength: UINT32,
2144 pub payload: *mut BYTE,
2145}
2146impl ::std::clone::Clone for Struct_tdTSS_DAA_SIGN_CALLBACK {
2147 fn clone(&self) -> Struct_tdTSS_DAA_SIGN_CALLBACK { *self }
2148}
2149impl ::std::default::Default for Struct_tdTSS_DAA_SIGN_CALLBACK {
2150 fn default() -> Struct_tdTSS_DAA_SIGN_CALLBACK {
2151 unsafe { ::std::mem::zeroed() }
2152 }
2153}
2154pub type TSS_DAA_SIGN_CALLBACK = Struct_tdTSS_DAA_SIGN_CALLBACK;
2155#[repr(C)]
2156#[derive(Copy)]
2157pub struct Struct_tdTSS_DAA_SIGNATURE {
2158 pub versionInfo: TSS_VERSION,
2159 pub zetaLength: UINT32,
2160 pub zeta: *mut BYTE,
2161 pub capitalTLength: UINT32,
2162 pub capitalT: *mut BYTE,
2163 pub challengeLength: UINT32,
2164 pub challenge: *mut BYTE,
2165 pub nonceTpmLength: UINT32,
2166 pub nonceTpm: *mut BYTE,
2167 pub sVLength: UINT32,
2168 pub sV: *mut BYTE,
2169 pub sF0Length: UINT32,
2170 pub sF0: *mut BYTE,
2171 pub sF1Length: UINT32,
2172 pub sF1: *mut BYTE,
2173 pub sELength: UINT32,
2174 pub sE: *mut BYTE,
2175 pub sALength: UINT32,
2176 pub sALength2: UINT32,
2177 pub sA: *mut *mut BYTE,
2178 pub attributeCommitmentsLength: UINT32,
2179 pub attributeCommitments: *mut TSS_DAA_ATTRIB_COMMIT,
2180 pub signedPseudonym: TSS_DAA_PSEUDONYM,
2181 pub callbackResult: TSS_DAA_SIGN_CALLBACK,
2182}
2183impl ::std::clone::Clone for Struct_tdTSS_DAA_SIGNATURE {
2184 fn clone(&self) -> Struct_tdTSS_DAA_SIGNATURE { *self }
2185}
2186impl ::std::default::Default for Struct_tdTSS_DAA_SIGNATURE {
2187 fn default() -> Struct_tdTSS_DAA_SIGNATURE {
2188 unsafe { ::std::mem::zeroed() }
2189 }
2190}
2191pub type TSS_DAA_SIGNATURE = Struct_tdTSS_DAA_SIGNATURE;
2192#[repr(C)]
2193#[derive(Copy)]
2194pub struct Struct_tdTSS_DAA_IDENTITY_PROOF {
2195 pub versionInfo: TSS_VERSION,
2196 pub endorsementLength: UINT32,
2197 pub endorsementCredential: *mut BYTE,
2198 pub platformLength: UINT32,
2199 pub platform: *mut BYTE,
2200 pub conformanceLength: UINT32,
2201 pub conformance: *mut BYTE,
2202}
2203impl ::std::clone::Clone for Struct_tdTSS_DAA_IDENTITY_PROOF {
2204 fn clone(&self) -> Struct_tdTSS_DAA_IDENTITY_PROOF { *self }
2205}
2206impl ::std::default::Default for Struct_tdTSS_DAA_IDENTITY_PROOF {
2207 fn default() -> Struct_tdTSS_DAA_IDENTITY_PROOF {
2208 unsafe { ::std::mem::zeroed() }
2209 }
2210}
2211pub type TSS_DAA_IDENTITY_PROOF = Struct_tdTSS_DAA_IDENTITY_PROOF;
2212pub type TSS_FAMILY_ID = UINT32;
2213pub type TSS_DELEGATION_LABEL = BYTE;
2214pub type TSS_DELEGATION_TYPE = UINT32;
2215#[repr(C)]
2216#[derive(Copy)]
2217pub struct Struct_tdTSS_PCR_INFO_SHORT {
2218 pub sizeOfSelect: UINT32,
2219 pub selection: *mut BYTE,
2220 pub localityAtRelease: BYTE,
2221 pub sizeOfDigestAtRelease: UINT32,
2222 pub digestAtRelease: *mut BYTE,
2223}
2224impl ::std::clone::Clone for Struct_tdTSS_PCR_INFO_SHORT {
2225 fn clone(&self) -> Struct_tdTSS_PCR_INFO_SHORT { *self }
2226}
2227impl ::std::default::Default for Struct_tdTSS_PCR_INFO_SHORT {
2228 fn default() -> Struct_tdTSS_PCR_INFO_SHORT {
2229 unsafe { ::std::mem::zeroed() }
2230 }
2231}
2232pub type TSS_PCR_INFO_SHORT = Struct_tdTSS_PCR_INFO_SHORT;
2233#[repr(C)]
2234#[derive(Copy)]
2235pub struct Struct_tdTSS_FAMILY_TABLE_ENTRY {
2236 pub familyID: TSS_FAMILY_ID,
2237 pub label: TSS_DELEGATION_LABEL,
2238 pub verificationCount: UINT32,
2239 pub enabled: TSS_BOOL,
2240 pub locked: TSS_BOOL,
2241}
2242impl ::std::clone::Clone for Struct_tdTSS_FAMILY_TABLE_ENTRY {
2243 fn clone(&self) -> Struct_tdTSS_FAMILY_TABLE_ENTRY { *self }
2244}
2245impl ::std::default::Default for Struct_tdTSS_FAMILY_TABLE_ENTRY {
2246 fn default() -> Struct_tdTSS_FAMILY_TABLE_ENTRY {
2247 unsafe { ::std::mem::zeroed() }
2248 }
2249}
2250pub type TSS_FAMILY_TABLE_ENTRY = Struct_tdTSS_FAMILY_TABLE_ENTRY;
2251#[repr(C)]
2252#[derive(Copy)]
2253pub struct Struct_tdTSS_DELEGATION_TABLE_ENTRY {
2254 pub tableIndex: UINT32,
2255 pub label: TSS_DELEGATION_LABEL,
2256 pub pcrInfo: TSS_PCR_INFO_SHORT,
2257 pub per1: UINT32,
2258 pub per2: UINT32,
2259 pub familyID: TSS_FAMILY_ID,
2260 pub verificationCount: UINT32,
2261}
2262impl ::std::clone::Clone for Struct_tdTSS_DELEGATION_TABLE_ENTRY {
2263 fn clone(&self) -> Struct_tdTSS_DELEGATION_TABLE_ENTRY { *self }
2264}
2265impl ::std::default::Default for Struct_tdTSS_DELEGATION_TABLE_ENTRY {
2266 fn default() -> Struct_tdTSS_DELEGATION_TABLE_ENTRY {
2267 unsafe { ::std::mem::zeroed() }
2268 }
2269}
2270pub type TSS_DELEGATION_TABLE_ENTRY = Struct_tdTSS_DELEGATION_TABLE_ENTRY;
2271#[repr(C)]
2272#[derive(Copy)]
2273pub struct Struct_tdTSS_PLATFORM_CLASS {
2274 pub platformClassSimpleIdentifier: UINT32,
2275 pub platformClassURISize: UINT32,
2276 pub pPlatformClassURI: *mut BYTE,
2277}
2278impl ::std::clone::Clone for Struct_tdTSS_PLATFORM_CLASS {
2279 fn clone(&self) -> Struct_tdTSS_PLATFORM_CLASS { *self }
2280}
2281impl ::std::default::Default for Struct_tdTSS_PLATFORM_CLASS {
2282 fn default() -> Struct_tdTSS_PLATFORM_CLASS {
2283 unsafe { ::std::mem::zeroed() }
2284 }
2285}
2286pub type TSS_PLATFORM_CLASS = Struct_tdTSS_PLATFORM_CLASS;
2287pub type Tspicb_CallbackHMACAuth =
2288 ::std::option::Option<extern "C" fn(lpAppData: PVOID,
2289 hAuthorizedObject: TSS_HOBJECT,
2290 ReturnOrVerify: TSS_BOOL,
2291 ulPendingFunction: UINT32,
2292 ContinueUse: TSS_BOOL,
2293 ulSizeNonces: UINT32,
2294 rgbNonceEven: *mut BYTE,
2295 rgbNonceOdd: *mut BYTE,
2296 rgbNonceEvenOSAP: *mut BYTE,
2297 rgbNonceOddOSAP: *mut BYTE,
2298 ulSizeDigestHmac: UINT32,
2299 rgbParamDigest: *mut BYTE,
2300 rgbHmacData: *mut BYTE)
2301 -> TSS_RESULT>;
2302pub type Tspicb_CallbackXorEnc =
2303 ::std::option::Option<extern "C" fn(lpAppData: PVOID,
2304 hOSAPObject: TSS_HOBJECT,
2305 hObject: TSS_HOBJECT,
2306 PurposeSecret: TSS_FLAG,
2307 ulSizeNonces: UINT32,
2308 rgbNonceEven: *mut BYTE,
2309 rgbNonceOdd: *mut BYTE,
2310 rgbNonceEvenOSAP: *mut BYTE,
2311 rgbNonceOddOSAP: *mut BYTE,
2312 ulSizeEncAuth: UINT32,
2313 rgbEncAuthUsage: *mut BYTE,
2314 rgbEncAuthMigration: *mut BYTE)
2315 -> TSS_RESULT>;
2316pub type Tspicb_CallbackTakeOwnership =
2317 ::std::option::Option<extern "C" fn(lpAppData: PVOID,
2318 hObject: TSS_HOBJECT,
2319 hObjectPubKey: TSS_HKEY,
2320 ulSizeEncAuth: UINT32,
2321 rgbEncAuth: *mut BYTE) -> TSS_RESULT>;
2322pub type Tspicb_CallbackSealxMask =
2323 ::std::option::Option<extern "C" fn(lpAppData: PVOID, hKey: TSS_HKEY,
2324 hEncData: TSS_HENCDATA,
2325 algID: TSS_ALGORITHM_ID,
2326 ulSizeNonces: UINT32,
2327 rgbNonceEven: *mut BYTE,
2328 rgbNonceOdd: *mut BYTE,
2329 rgbNonceEvenOSAP: *mut BYTE,
2330 rgbNonceOddOSAP: *mut BYTE,
2331 ulDataLength: UINT32,
2332 rgbDataToMask: *mut BYTE,
2333 rgbMaskedData: *mut BYTE)
2334 -> TSS_RESULT>;
2335pub type Tspicb_CallbackChangeAuthAsym =
2336 ::std::option::Option<extern "C" fn(lpAppData: PVOID,
2337 hObject: TSS_HOBJECT,
2338 hObjectPubKey: TSS_HKEY,
2339 ulSizeEncAuth: UINT32,
2340 ulSizeAuthLink: UINT32,
2341 rgbEncAuth: *mut BYTE,
2342 rgbAuthLink: *mut BYTE)
2343 -> TSS_RESULT>;
2344pub type Tspicb_CollateIdentity =
2345 ::std::option::Option<extern "C" fn(lpAppData: PVOID,
2346 ulTCPAPlainIdentityProofLength:
2347 UINT32,
2348 rgbTCPAPlainIdentityProof: *mut BYTE,
2349 algID: TSS_ALGORITHM_ID,
2350 ulSessionKeyLength: UINT32,
2351 rgbSessionKey: *mut BYTE,
2352 pulTCPAIdentityProofLength:
2353 *mut UINT32,
2354 rgbTCPAIdentityProof: *mut BYTE)
2355 -> TSS_RESULT>;
2356pub type Tspicb_ActivateIdentity =
2357 ::std::option::Option<extern "C" fn(lpAppData: PVOID,
2358 ulSessionKeyLength: UINT32,
2359 rgbSessionKey: *mut BYTE,
2360 ulSymCAAttestationBlobLength: UINT32,
2361 rgbSymCAAttestationBlob: *mut BYTE,
2362 pulCredentialLength: *mut UINT32,
2363 rgbCredential: *mut BYTE)
2364 -> TSS_RESULT>;
2365pub type Tspicb_DAA_Sign =
2366 ::std::option::Option<extern "C" fn(lpAppData: PVOID,
2367 daaPublicKey: TSS_HDAA_ISSUER_KEY,
2368 gammasLength: UINT32,
2369 gammas: *mut *mut BYTE,
2370 attributesLength: UINT32,
2371 attributes: *mut *mut BYTE,
2372 randomAttributesLength: UINT32,
2373 randomAttributes: *mut *mut BYTE,
2374 attributeCommitmentsLength: UINT32,
2375 attributeCommitments:
2376 *mut TSS_DAA_ATTRIB_COMMIT,
2377 attributeCommitmentsProof:
2378 *mut TSS_DAA_ATTRIB_COMMIT,
2379 pseudonym:
2380 *mut TSS_DAA_PSEUDONYM_PLAIN,
2381 pseudonymTilde:
2382 *mut TSS_DAA_PSEUDONYM_PLAIN,
2383 pseudonymEncrypted:
2384 *mut TSS_DAA_PSEUDONYM_ENCRYPTED,
2385 pseudonymEncProof:
2386 *mut TSS_DAA_PSEUDONYM_ENCRYPTED,
2387 additionalProof:
2388 *mut *mut TSS_DAA_SIGN_CALLBACK)
2389 -> TSS_RESULT>;
2390pub type Tspicb_DAA_VerifySignature =
2391 ::std::option::Option<extern "C" fn(lpAppData: PVOID,
2392 challengeLength: UINT32,
2393 challenge: *mut BYTE,
2394 additionalProof:
2395 *mut TSS_DAA_SIGN_CALLBACK,
2396 daaPublicKey: TSS_HDAA_ISSUER_KEY,
2397 gammasLength: UINT32,
2398 gammas: *mut *mut BYTE,
2399 sAttributesLength: UINT32,
2400 sAttributes: *mut *mut BYTE,
2401 attributeCommitmentsLength: UINT32,
2402 attributeCommitments:
2403 *mut TSS_DAA_ATTRIB_COMMIT,
2404 attributeCommitmentsProof:
2405 *mut TSS_DAA_ATTRIB_COMMIT,
2406 zetaLength: UINT32, zeta: *mut BYTE,
2407 sFLength: UINT32, sF: *mut BYTE,
2408 pseudonym: *mut TSS_DAA_PSEUDONYM,
2409 pseudonymProof:
2410 *mut TSS_DAA_PSEUDONYM,
2411 isCorrect: *mut TSS_BOOL)
2412 -> TSS_RESULT>;
2413#[link(name = "tspi")]
2414extern "C" {
2415 pub fn Tspi_EncodeDER_TssBlob(rawBlobSize: UINT32, rawBlob: *mut BYTE,
2416 blobType: UINT32, derBlobSize: *mut UINT32,
2417 derBlob: *mut BYTE) -> TSS_RESULT;
2418 pub fn Tspi_DecodeBER_TssBlob(berBlobSize: UINT32, berBlob: *mut BYTE,
2419 blobType: *mut UINT32,
2420 rawBlobSize: *mut UINT32,
2421 rawBlob: *mut BYTE) -> TSS_RESULT;
2422 pub fn Tspi_SetAttribUint32(hObject: TSS_HOBJECT, attribFlag: TSS_FLAG,
2423 subFlag: TSS_FLAG, ulAttrib: UINT32)
2424 -> TSS_RESULT;
2425 pub fn Tspi_GetAttribUint32(hObject: TSS_HOBJECT, attribFlag: TSS_FLAG,
2426 subFlag: TSS_FLAG, pulAttrib: *mut UINT32)
2427 -> TSS_RESULT;
2428 pub fn Tspi_SetAttribData(hObject: TSS_HOBJECT, attribFlag: TSS_FLAG,
2429 subFlag: TSS_FLAG, ulAttribDataSize: UINT32,
2430 rgbAttribData: *mut BYTE) -> TSS_RESULT;
2431 pub fn Tspi_GetAttribData(hObject: TSS_HOBJECT, attribFlag: TSS_FLAG,
2432 subFlag: TSS_FLAG,
2433 pulAttribDataSize: *mut UINT32,
2434 prgbAttribData: *mut *mut BYTE) -> TSS_RESULT;
2435 pub fn Tspi_ChangeAuth(hObjectToChange: TSS_HOBJECT,
2436 hParentObject: TSS_HOBJECT,
2437 hNewPolicy: TSS_HPOLICY) -> TSS_RESULT;
2438 pub fn Tspi_ChangeAuthAsym(hObjectToChange: TSS_HOBJECT,
2439 hParentObject: TSS_HOBJECT,
2440 hIdentKey: TSS_HKEY, hNewPolicy: TSS_HPOLICY)
2441 -> TSS_RESULT;
2442 pub fn Tspi_GetPolicyObject(hObject: TSS_HOBJECT, policyType: TSS_FLAG,
2443 phPolicy: *mut TSS_HPOLICY) -> TSS_RESULT;
2444 pub fn Tspi_Context_Create(phContext: *mut TSS_HCONTEXT) -> TSS_RESULT;
2445 pub fn Tspi_Context_Close(hContext: TSS_HCONTEXT) -> TSS_RESULT;
2446 pub fn Tspi_Context_Connect(hContext: TSS_HCONTEXT,
2447 wszDestination: *mut TSS_UNICODE)
2448 -> TSS_RESULT;
2449 pub fn Tspi_Context_FreeMemory(hContext: TSS_HCONTEXT,
2450 rgbMemory: *mut BYTE) -> TSS_RESULT;
2451 pub fn Tspi_Context_GetDefaultPolicy(hContext: TSS_HCONTEXT,
2452 phPolicy: *mut TSS_HPOLICY)
2453 -> TSS_RESULT;
2454 pub fn Tspi_Context_CreateObject(hContext: TSS_HCONTEXT,
2455 objectType: TSS_FLAG,
2456 initFlags: TSS_FLAG,
2457 phObject: *mut TSS_HOBJECT)
2458 -> TSS_RESULT;
2459 pub fn Tspi_Context_CloseObject(hContext: TSS_HCONTEXT,
2460 hObject: TSS_HOBJECT) -> TSS_RESULT;
2461 pub fn Tspi_Context_GetCapability(hContext: TSS_HCONTEXT,
2462 capArea: TSS_FLAG,
2463 ulSubCapLength: UINT32,
2464 rgbSubCap: *mut BYTE,
2465 pulRespDataLength: *mut UINT32,
2466 prgbRespData: *mut *mut BYTE)
2467 -> TSS_RESULT;
2468 pub fn Tspi_Context_GetTpmObject(hContext: TSS_HCONTEXT,
2469 phTPM: *mut TSS_HTPM) -> TSS_RESULT;
2470 pub fn Tspi_Context_SetTransEncryptionKey(hContext: TSS_HCONTEXT,
2471 hKey: TSS_HKEY) -> TSS_RESULT;
2472 pub fn Tspi_Context_CloseSignTransport(hContext: TSS_HCONTEXT,
2473 hSigningKey: TSS_HKEY,
2474 pValidationData:
2475 *mut TSS_VALIDATION)
2476 -> TSS_RESULT;
2477 pub fn Tspi_Context_LoadKeyByBlob(hContext: TSS_HCONTEXT,
2478 hUnwrappingKey: TSS_HKEY,
2479 ulBlobLength: UINT32,
2480 rgbBlobData: *mut BYTE,
2481 phKey: *mut TSS_HKEY) -> TSS_RESULT;
2482 pub fn Tspi_Context_LoadKeyByUUID(hContext: TSS_HCONTEXT,
2483 persistentStorageType: TSS_FLAG,
2484 uuidData: TSS_UUID,
2485 phKey: *mut TSS_HKEY) -> TSS_RESULT;
2486 pub fn Tspi_Context_RegisterKey(hContext: TSS_HCONTEXT, hKey: TSS_HKEY,
2487 persistentStorageType: TSS_FLAG,
2488 uuidKey: TSS_UUID,
2489 persistentStorageTypeParent: TSS_FLAG,
2490 uuidParentKey: TSS_UUID) -> TSS_RESULT;
2491 pub fn Tspi_Context_UnregisterKey(hContext: TSS_HCONTEXT,
2492 persistentStorageType: TSS_FLAG,
2493 uuidKey: TSS_UUID, phkey: *mut TSS_HKEY)
2494 -> TSS_RESULT;
2495 pub fn Tspi_Context_GetKeyByUUID(hContext: TSS_HCONTEXT,
2496 persistentStorageType: TSS_FLAG,
2497 uuidData: TSS_UUID, phKey: *mut TSS_HKEY)
2498 -> TSS_RESULT;
2499 pub fn Tspi_Context_GetKeyByPublicInfo(hContext: TSS_HCONTEXT,
2500 persistentStorageType: TSS_FLAG,
2501 algID: TSS_ALGORITHM_ID,
2502 ulPublicInfoLength: UINT32,
2503 rgbPublicInfo: *mut BYTE,
2504 phKey: *mut TSS_HKEY)
2505 -> TSS_RESULT;
2506 pub fn Tspi_Context_GetRegisteredKeysByUUID(hContext: TSS_HCONTEXT,
2507 persistentStorageType:
2508 TSS_FLAG,
2509 pUuidData: *mut TSS_UUID,
2510 pulKeyHierarchySize:
2511 *mut UINT32,
2512 ppKeyHierarchy:
2513 *mut *mut TSS_KM_KEYINFO)
2514 -> TSS_RESULT;
2515 pub fn Tspi_Context_GetRegisteredKeysByUUID2(hContext: TSS_HCONTEXT,
2516 persistentStorageType:
2517 TSS_FLAG,
2518 pUuidData: *mut TSS_UUID,
2519 pulKeyHierarchySize:
2520 *mut UINT32,
2521 ppKeyHierarchy:
2522 *mut *mut TSS_KM_KEYINFO2)
2523 -> TSS_RESULT;
2524 pub fn Tspi_Policy_SetSecret(hPolicy: TSS_HPOLICY, secretMode: TSS_FLAG,
2525 ulSecretLength: UINT32, rgbSecret: *mut BYTE)
2526 -> TSS_RESULT;
2527 pub fn Tspi_Policy_FlushSecret(hPolicy: TSS_HPOLICY) -> TSS_RESULT;
2528 pub fn Tspi_Policy_AssignToObject(hPolicy: TSS_HPOLICY,
2529 hObject: TSS_HOBJECT) -> TSS_RESULT;
2530 pub fn Tspi_TPM_KeyControlOwner(hTPM: TSS_HTPM, hKey: TSS_HKEY,
2531 attribName: UINT32, attribValue: TSS_BOOL,
2532 pUuidData: *mut TSS_UUID) -> TSS_RESULT;
2533 pub fn Tspi_TPM_CreateEndorsementKey(hTPM: TSS_HTPM, hKey: TSS_HKEY,
2534 pValidationData: *mut TSS_VALIDATION)
2535 -> TSS_RESULT;
2536 pub fn Tspi_TPM_CreateRevocableEndorsementKey(hTPM: TSS_HTPM,
2537 hKey: TSS_HKEY,
2538 pValidationData:
2539 *mut TSS_VALIDATION,
2540 pulEkResetDataLength:
2541 *mut UINT32,
2542 rgbEkResetData:
2543 *mut *mut BYTE)
2544 -> TSS_RESULT;
2545 pub fn Tspi_TPM_RevokeEndorsementKey(hTPM: TSS_HTPM,
2546 ulEkResetDataLength: UINT32,
2547 rgbEkResetData: *mut BYTE)
2548 -> TSS_RESULT;
2549 pub fn Tspi_TPM_GetPubEndorsementKey(hTPM: TSS_HTPM,
2550 fOwnerAuthorized: TSS_BOOL,
2551 pValidationData: *mut TSS_VALIDATION,
2552 phEndorsementPubKey: *mut TSS_HKEY)
2553 -> TSS_RESULT;
2554 pub fn Tspi_TPM_OwnerGetSRKPubKey(hTPM: TSS_HTPM,
2555 pulPubKeyLength: *mut UINT32,
2556 prgbPubKey: *mut *mut BYTE)
2557 -> TSS_RESULT;
2558 pub fn Tspi_TPM_TakeOwnership(hTPM: TSS_HTPM, hKeySRK: TSS_HKEY,
2559 hEndorsementPubKey: TSS_HKEY) -> TSS_RESULT;
2560 pub fn Tspi_TPM_ClearOwner(hTPM: TSS_HTPM, fForcedClear: TSS_BOOL)
2561 -> TSS_RESULT;
2562 pub fn Tspi_TPM_CollateIdentityRequest(hTPM: TSS_HTPM, hKeySRK: TSS_HKEY,
2563 hCAPubKey: TSS_HKEY,
2564 ulIdentityLabelLength: UINT32,
2565 rgbIdentityLabelData: *mut BYTE,
2566 hIdentityKey: TSS_HKEY,
2567 algID: TSS_ALGORITHM_ID,
2568 pulTCPAIdentityReqLength:
2569 *mut UINT32,
2570 prgbTCPAIdentityReq:
2571 *mut *mut BYTE) -> TSS_RESULT;
2572 pub fn Tspi_TPM_ActivateIdentity(hTPM: TSS_HTPM, hIdentKey: TSS_HKEY,
2573 ulAsymCAContentsBlobLength: UINT32,
2574 rgbAsymCAContentsBlob: *mut BYTE,
2575 ulSymCAAttestationBlobLength: UINT32,
2576 rgbSymCAAttestationBlob: *mut BYTE,
2577 pulCredentialLength: *mut UINT32,
2578 prgbCredential: *mut *mut BYTE)
2579 -> TSS_RESULT;
2580 pub fn Tspi_TPM_CreateMaintenanceArchive(hTPM: TSS_HTPM,
2581 fGenerateRndNumber: TSS_BOOL,
2582 pulRndNumberLength: *mut UINT32,
2583 prgbRndNumber: *mut *mut BYTE,
2584 pulArchiveDataLength:
2585 *mut UINT32,
2586 prgbArchiveData: *mut *mut BYTE)
2587 -> TSS_RESULT;
2588 pub fn Tspi_TPM_KillMaintenanceFeature(hTPM: TSS_HTPM) -> TSS_RESULT;
2589 pub fn Tspi_TPM_LoadMaintenancePubKey(hTPM: TSS_HTPM,
2590 hMaintenanceKey: TSS_HKEY,
2591 pValidationData:
2592 *mut TSS_VALIDATION)
2593 -> TSS_RESULT;
2594 pub fn Tspi_TPM_CheckMaintenancePubKey(hTPM: TSS_HTPM,
2595 hMaintenanceKey: TSS_HKEY,
2596 pValidationData:
2597 *mut TSS_VALIDATION)
2598 -> TSS_RESULT;
2599 pub fn Tspi_TPM_SetOperatorAuth(hTPM: TSS_HTPM,
2600 hOperatorPolicy: TSS_HPOLICY)
2601 -> TSS_RESULT;
2602 pub fn Tspi_TPM_SetStatus(hTPM: TSS_HTPM, statusFlag: TSS_FLAG,
2603 fTpmState: TSS_BOOL) -> TSS_RESULT;
2604 pub fn Tspi_TPM_GetStatus(hTPM: TSS_HTPM, statusFlag: TSS_FLAG,
2605 pfTpmState: *mut TSS_BOOL) -> TSS_RESULT;
2606 pub fn Tspi_TPM_GetCapability(hTPM: TSS_HTPM, capArea: TSS_FLAG,
2607 ulSubCapLength: UINT32,
2608 rgbSubCap: *mut BYTE,
2609 pulRespDataLength: *mut UINT32,
2610 prgbRespData: *mut *mut BYTE) -> TSS_RESULT;
2611 pub fn Tspi_TPM_GetCapabilitySigned(hTPM: TSS_HTPM, hKey: TSS_HKEY,
2612 capArea: TSS_FLAG,
2613 ulSubCapLength: UINT32,
2614 rgbSubCap: *mut BYTE,
2615 pValidationData: *mut TSS_VALIDATION,
2616 pulRespDataLength: *mut UINT32,
2617 prgbRespData: *mut *mut BYTE)
2618 -> TSS_RESULT;
2619 pub fn Tspi_TPM_SelfTestFull(hTPM: TSS_HTPM) -> TSS_RESULT;
2620 pub fn Tspi_TPM_CertifySelfTest(hTPM: TSS_HTPM, hKey: TSS_HKEY,
2621 pValidationData: *mut TSS_VALIDATION)
2622 -> TSS_RESULT;
2623 pub fn Tspi_TPM_GetTestResult(hTPM: TSS_HTPM,
2624 pulTestResultLength: *mut UINT32,
2625 prgbTestResult: *mut *mut BYTE)
2626 -> TSS_RESULT;
2627 pub fn Tspi_TPM_GetRandom(hTPM: TSS_HTPM, ulRandomDataLength: UINT32,
2628 prgbRandomData: *mut *mut BYTE) -> TSS_RESULT;
2629 pub fn Tspi_TPM_StirRandom(hTPM: TSS_HTPM, ulEntropyDataLength: UINT32,
2630 rgbEntropyData: *mut BYTE) -> TSS_RESULT;
2631 pub fn Tspi_TPM_GetEvent(hTPM: TSS_HTPM, ulPcrIndex: UINT32,
2632 ulEventNumber: UINT32,
2633 pPcrEvent: *mut TSS_PCR_EVENT) -> TSS_RESULT;
2634 pub fn Tspi_TPM_GetEvents(hTPM: TSS_HTPM, ulPcrIndex: UINT32,
2635 ulStartNumber: UINT32,
2636 pulEventNumber: *mut UINT32,
2637 prgPcrEvents: *mut *mut TSS_PCR_EVENT)
2638 -> TSS_RESULT;
2639 pub fn Tspi_TPM_GetEventLog(hTPM: TSS_HTPM, pulEventNumber: *mut UINT32,
2640 prgPcrEvents: *mut *mut TSS_PCR_EVENT)
2641 -> TSS_RESULT;
2642 pub fn Tspi_TPM_Quote(hTPM: TSS_HTPM, hIdentKey: TSS_HKEY,
2643 hPcrComposite: TSS_HPCRS,
2644 pValidationData: *mut TSS_VALIDATION) -> TSS_RESULT;
2645 pub fn Tspi_TPM_Quote2(hTPM: TSS_HTPM, hIdentKey: TSS_HKEY,
2646 fAddVersion: TSS_BOOL, hPcrComposite: TSS_HPCRS,
2647 pValidationData: *mut TSS_VALIDATION,
2648 versionInfoSize: *mut UINT32,
2649 versionInfo: *mut *mut BYTE) -> TSS_RESULT;
2650 pub fn Tspi_TPM_PcrExtend(hTPM: TSS_HTPM, ulPcrIndex: UINT32,
2651 ulPcrDataLength: UINT32, pbPcrData: *mut BYTE,
2652 pPcrEvent: *mut TSS_PCR_EVENT,
2653 pulPcrValueLength: *mut UINT32,
2654 prgbPcrValue: *mut *mut BYTE) -> TSS_RESULT;
2655 pub fn Tspi_TPM_PcrRead(hTPM: TSS_HTPM, ulPcrIndex: UINT32,
2656 pulPcrValueLength: *mut UINT32,
2657 prgbPcrValue: *mut *mut BYTE) -> TSS_RESULT;
2658 pub fn Tspi_TPM_PcrReset(hTPM: TSS_HTPM, hPcrComposite: TSS_HPCRS)
2659 -> TSS_RESULT;
2660 pub fn Tspi_TPM_AuthorizeMigrationTicket(hTPM: TSS_HTPM,
2661 hMigrationKey: TSS_HKEY,
2662 migrationScheme:
2663 TSS_MIGRATE_SCHEME,
2664 pulMigTicketLength: *mut UINT32,
2665 prgbMigTicket: *mut *mut BYTE)
2666 -> TSS_RESULT;
2667 pub fn Tspi_TPM_CMKSetRestrictions(hTPM: TSS_HTPM,
2668 CmkDelegate: TSS_CMK_DELEGATE)
2669 -> TSS_RESULT;
2670 pub fn Tspi_TPM_CMKApproveMA(hTPM: TSS_HTPM, hMaAuthData: TSS_HMIGDATA)
2671 -> TSS_RESULT;
2672 pub fn Tspi_TPM_CMKCreateTicket(hTPM: TSS_HTPM, hVerifyKey: TSS_HKEY,
2673 hSigData: TSS_HMIGDATA) -> TSS_RESULT;
2674 pub fn Tspi_TPM_ReadCounter(hTPM: TSS_HTPM, counterValue: *mut UINT32)
2675 -> TSS_RESULT;
2676 pub fn Tspi_TPM_ReadCurrentTicks(hTPM: TSS_HTPM,
2677 tickCount: *mut TPM_CURRENT_TICKS)
2678 -> TSS_RESULT;
2679 pub fn Tspi_TPM_DirWrite(hTPM: TSS_HTPM, ulDirIndex: UINT32,
2680 ulDirDataLength: UINT32, rgbDirData: *mut BYTE)
2681 -> TSS_RESULT;
2682 pub fn Tspi_TPM_DirRead(hTPM: TSS_HTPM, ulDirIndex: UINT32,
2683 pulDirDataLength: *mut UINT32,
2684 prgbDirData: *mut *mut BYTE) -> TSS_RESULT;
2685 pub fn Tspi_TPM_Delegate_AddFamily(hTPM: TSS_HTPM, bLabel: BYTE,
2686 phFamily: *mut TSS_HDELFAMILY)
2687 -> TSS_RESULT;
2688 pub fn Tspi_TPM_Delegate_GetFamily(hTPM: TSS_HTPM, ulFamilyID: UINT32,
2689 phFamily: *mut TSS_HDELFAMILY)
2690 -> TSS_RESULT;
2691 pub fn Tspi_TPM_Delegate_InvalidateFamily(hTPM: TSS_HTPM,
2692 hFamily: TSS_HDELFAMILY)
2693 -> TSS_RESULT;
2694 pub fn Tspi_TPM_Delegate_CreateDelegation(hObject: TSS_HOBJECT,
2695 bLabel: BYTE, ulFlags: UINT32,
2696 hPcr: TSS_HPCRS,
2697 hFamily: TSS_HDELFAMILY,
2698 hDelegation: TSS_HPOLICY)
2699 -> TSS_RESULT;
2700 pub fn Tspi_TPM_Delegate_CacheOwnerDelegation(hTPM: TSS_HTPM,
2701 hDelegation: TSS_HPOLICY,
2702 ulIndex: UINT32,
2703 ulFlags: UINT32)
2704 -> TSS_RESULT;
2705 pub fn Tspi_TPM_Delegate_UpdateVerificationCount(hTPM: TSS_HTPM,
2706 hDelegation: TSS_HPOLICY)
2707 -> TSS_RESULT;
2708 pub fn Tspi_TPM_Delegate_VerifyDelegation(hDelegation: TSS_HPOLICY)
2709 -> TSS_RESULT;
2710 pub fn Tspi_TPM_Delegate_ReadTables(hContext: TSS_HCONTEXT,
2711 pulFamilyTableSize: *mut UINT32,
2712 ppFamilyTable:
2713 *mut *mut TSS_FAMILY_TABLE_ENTRY,
2714 pulDelegateTableSize: *mut UINT32,
2715 ppDelegateTable:
2716 *mut *mut TSS_DELEGATION_TABLE_ENTRY)
2717 -> TSS_RESULT;
2718 pub fn Tspi_TPM_DAA_JoinInit(hTPM: TSS_HTPM,
2719 hIssuerKey: TSS_HDAA_ISSUER_KEY,
2720 daaCounter: UINT32,
2721 issuerAuthPKsLength: UINT32,
2722 issuerAuthPKs: *mut TSS_HKEY,
2723 issuerAuthPKSignaturesLength: UINT32,
2724 issuerAuthPKSignaturesLength2: UINT32,
2725 issuerAuthPKSignatures: *mut *mut BYTE,
2726 capitalUprimeLength: *mut UINT32,
2727 capitalUprime: *mut *mut BYTE,
2728 identityProof:
2729 *mut *mut TSS_DAA_IDENTITY_PROOF,
2730 joinSessionLength: *mut UINT32,
2731 joinSession: *mut *mut BYTE) -> TSS_RESULT;
2732 pub fn Tspi_TPM_DAA_JoinCreateDaaPubKey(hTPM: TSS_HTPM,
2733 hDAACredential:
2734 TSS_HDAA_CREDENTIAL,
2735 authenticationChallengeLength:
2736 UINT32,
2737 authenticationChallenge:
2738 *mut BYTE,
2739 nonceIssuerLength: UINT32,
2740 nonceIssuer: *mut BYTE,
2741 attributesPlatformLength: UINT32,
2742 attributesPlatformLength2: UINT32,
2743 attributesPlatform:
2744 *mut *mut BYTE,
2745 joinSessionLength: UINT32,
2746 joinSession: *mut BYTE,
2747 credentialRequest:
2748 *mut *mut TSS_DAA_CREDENTIAL_REQUEST)
2749 -> TSS_RESULT;
2750 pub fn Tspi_TPM_DAA_JoinStoreCredential(hTPM: TSS_HTPM,
2751 hDAACredential:
2752 TSS_HDAA_CREDENTIAL,
2753 credIssuer:
2754 *mut TSS_DAA_CRED_ISSUER,
2755 joinSessionLength: UINT32,
2756 joinSession: *mut BYTE)
2757 -> TSS_RESULT;
2758 pub fn Tspi_TPM_DAA_Sign(hTPM: TSS_HTPM,
2759 hDAACredential: TSS_HDAA_CREDENTIAL,
2760 hARAKey: TSS_HDAA_ARA_KEY,
2761 revealAttributes: *mut TSS_DAA_SELECTED_ATTRIB,
2762 verifierNonceLength: UINT32,
2763 verifierNonce: *mut BYTE,
2764 verifierBaseNameLength: UINT32,
2765 verifierBaseName: *mut BYTE,
2766 signData: TSS_HOBJECT,
2767 daaSignature: *mut *mut TSS_DAA_SIGNATURE)
2768 -> TSS_RESULT;
2769 pub fn Tspi_TPM_GetAuditDigest(hTPM: TSS_HTPM, hKey: TSS_HKEY,
2770 closeAudit: TSS_BOOL,
2771 pulAuditDigestSize: *mut UINT32,
2772 prgbAuditDigest: *mut *mut BYTE,
2773 pCounterValue: *mut TPM_COUNTER_VALUE,
2774 pValidationData: *mut TSS_VALIDATION,
2775 ordSize: *mut UINT32,
2776 ordList: *mut *mut UINT32) -> TSS_RESULT;
2777 pub fn Tspi_PcrComposite_SelectPcrIndex(hPcrComposite: TSS_HPCRS,
2778 ulPcrIndex: UINT32) -> TSS_RESULT;
2779 pub fn Tspi_PcrComposite_SelectPcrIndexEx(hPcrComposite: TSS_HPCRS,
2780 ulPcrIndex: UINT32,
2781 direction: UINT32)
2782 -> TSS_RESULT;
2783 pub fn Tspi_PcrComposite_SetPcrValue(hPcrComposite: TSS_HPCRS,
2784 ulPcrIndex: UINT32,
2785 ulPcrValueLength: UINT32,
2786 rgbPcrValue: *mut BYTE)
2787 -> TSS_RESULT;
2788 pub fn Tspi_PcrComposite_GetPcrValue(hPcrComposite: TSS_HPCRS,
2789 ulPcrIndex: UINT32,
2790 pulPcrValueLength: *mut UINT32,
2791 prgbPcrValue: *mut *mut BYTE)
2792 -> TSS_RESULT;
2793 pub fn Tspi_PcrComposite_SetPcrLocality(hPcrComposite: TSS_HPCRS,
2794 LocalityValue: UINT32)
2795 -> TSS_RESULT;
2796 pub fn Tspi_PcrComposite_GetPcrLocality(hPcrComposite: TSS_HPCRS,
2797 pLocalityValue: *mut UINT32)
2798 -> TSS_RESULT;
2799 pub fn Tspi_PcrComposite_GetCompositeHash(hPcrComposite: TSS_HPCRS,
2800 pLen: *mut UINT32,
2801 ppbHashData: *mut *mut BYTE)
2802 -> TSS_RESULT;
2803 pub fn Tspi_Key_LoadKey(hKey: TSS_HKEY, hUnwrappingKey: TSS_HKEY)
2804 -> TSS_RESULT;
2805 pub fn Tspi_Key_UnloadKey(hKey: TSS_HKEY) -> TSS_RESULT;
2806 pub fn Tspi_Key_GetPubKey(hKey: TSS_HKEY, pulPubKeyLength: *mut UINT32,
2807 prgbPubKey: *mut *mut BYTE) -> TSS_RESULT;
2808 pub fn Tspi_Key_CertifyKey(hKey: TSS_HKEY, hCertifyingKey: TSS_HKEY,
2809 pValidationData: *mut TSS_VALIDATION)
2810 -> TSS_RESULT;
2811 pub fn Tspi_Key_CreateKey(hKey: TSS_HKEY, hWrappingKey: TSS_HKEY,
2812 hPcrComposite: TSS_HPCRS) -> TSS_RESULT;
2813 pub fn Tspi_Key_WrapKey(hKey: TSS_HKEY, hWrappingKey: TSS_HKEY,
2814 hPcrComposite: TSS_HPCRS) -> TSS_RESULT;
2815 pub fn Tspi_Key_CreateMigrationBlob(hKeyToMigrate: TSS_HKEY,
2816 hParentKey: TSS_HKEY,
2817 ulMigTicketLength: UINT32,
2818 rgbMigTicket: *mut BYTE,
2819 pulRandomLength: *mut UINT32,
2820 prgbRandom: *mut *mut BYTE,
2821 pulMigrationBlobLength: *mut UINT32,
2822 prgbMigrationBlob: *mut *mut BYTE)
2823 -> TSS_RESULT;
2824 pub fn Tspi_Key_ConvertMigrationBlob(hKeyToMigrate: TSS_HKEY,
2825 hParentKey: TSS_HKEY,
2826 ulRandomLength: UINT32,
2827 rgbRandom: *mut BYTE,
2828 ulMigrationBlobLength: UINT32,
2829 rgbMigrationBlob: *mut BYTE)
2830 -> TSS_RESULT;
2831 pub fn Tspi_Key_MigrateKey(hMaKey: TSS_HKEY, hPublicKey: TSS_HKEY,
2832 hMigData: TSS_HKEY) -> TSS_RESULT;
2833 pub fn Tspi_Key_CMKCreateBlob(hKeyToMigrate: TSS_HKEY,
2834 hParentKey: TSS_HKEY,
2835 hMigrationData: TSS_HMIGDATA,
2836 pulRandomLength: *mut UINT32,
2837 prgbRandom: *mut *mut BYTE) -> TSS_RESULT;
2838 pub fn Tspi_Key_CMKConvertMigration(hKeyToMigrate: TSS_HKEY,
2839 hParentKey: TSS_HKEY,
2840 hMigrationData: TSS_HMIGDATA,
2841 ulRandomLength: UINT32,
2842 rgbRandom: *mut BYTE) -> TSS_RESULT;
2843 pub fn Tspi_Hash_Sign(hHash: TSS_HHASH, hKey: TSS_HKEY,
2844 pulSignatureLength: *mut UINT32,
2845 prgbSignature: *mut *mut BYTE) -> TSS_RESULT;
2846 pub fn Tspi_Hash_VerifySignature(hHash: TSS_HHASH, hKey: TSS_HKEY,
2847 ulSignatureLength: UINT32,
2848 rgbSignature: *mut BYTE) -> TSS_RESULT;
2849 pub fn Tspi_Hash_SetHashValue(hHash: TSS_HHASH, ulHashValueLength: UINT32,
2850 rgbHashValue: *mut BYTE) -> TSS_RESULT;
2851 pub fn Tspi_Hash_GetHashValue(hHash: TSS_HHASH,
2852 pulHashValueLength: *mut UINT32,
2853 prgbHashValue: *mut *mut BYTE)
2854 -> TSS_RESULT;
2855 pub fn Tspi_Hash_UpdateHashValue(hHash: TSS_HHASH, ulDataLength: UINT32,
2856 rgbData: *mut BYTE) -> TSS_RESULT;
2857 pub fn Tspi_Hash_TickStampBlob(hHash: TSS_HHASH, hIdentKey: TSS_HKEY,
2858 pValidationData: *mut TSS_VALIDATION)
2859 -> TSS_RESULT;
2860 pub fn Tspi_Data_Bind(hEncData: TSS_HENCDATA, hEncKey: TSS_HKEY,
2861 ulDataLength: UINT32, rgbDataToBind: *mut BYTE)
2862 -> TSS_RESULT;
2863 pub fn Tspi_Data_Unbind(hEncData: TSS_HENCDATA, hKey: TSS_HKEY,
2864 pulUnboundDataLength: *mut UINT32,
2865 prgbUnboundData: *mut *mut BYTE) -> TSS_RESULT;
2866 pub fn Tspi_Data_Seal(hEncData: TSS_HENCDATA, hEncKey: TSS_HKEY,
2867 ulDataLength: UINT32, rgbDataToSeal: *mut BYTE,
2868 hPcrComposite: TSS_HPCRS) -> TSS_RESULT;
2869 pub fn Tspi_Data_Unseal(hEncData: TSS_HENCDATA, hKey: TSS_HKEY,
2870 pulUnsealedDataLength: *mut UINT32,
2871 prgbUnsealedData: *mut *mut BYTE) -> TSS_RESULT;
2872 pub fn Tspi_NV_DefineSpace(hNVStore: TSS_HNVSTORE,
2873 hReadPcrComposite: TSS_HPCRS,
2874 hWritePcrComposite: TSS_HPCRS) -> TSS_RESULT;
2875 pub fn Tspi_NV_ReleaseSpace(hNVStore: TSS_HNVSTORE) -> TSS_RESULT;
2876 pub fn Tspi_NV_WriteValue(hNVStore: TSS_HNVSTORE, offset: UINT32,
2877 ulDataLength: UINT32, rgbDataToWrite: *mut BYTE)
2878 -> TSS_RESULT;
2879 pub fn Tspi_NV_ReadValue(hNVStore: TSS_HNVSTORE, offset: UINT32,
2880 ulDataLength: *mut UINT32,
2881 rgbDataRead: *mut *mut BYTE) -> TSS_RESULT;
2882 pub fn Tspi_DAA_IssuerKeyVerify(hDAACredential: TSS_HDAA_CREDENTIAL,
2883 hIssuerKey: TSS_HDAA_ISSUER_KEY,
2884 isCorrect: *mut TSS_BOOL) -> TSS_RESULT;
2885 pub fn Tspi_DAA_Issuer_GenerateKey(hIssuerKey: TSS_HDAA_ISSUER_KEY,
2886 issuerBaseNameLength: UINT32,
2887 issuerBaseName: *mut BYTE)
2888 -> TSS_RESULT;
2889 pub fn Tspi_DAA_Issuer_InitCredential(hIssuerKey: TSS_HDAA_ISSUER_KEY,
2890 issuerAuthPK: TSS_HKEY,
2891 identityProof:
2892 *mut TSS_DAA_IDENTITY_PROOF,
2893 capitalUprimeLength: UINT32,
2894 capitalUprime: *mut BYTE,
2895 daaCounter: UINT32,
2896 nonceIssuerLength: *mut UINT32,
2897 nonceIssuer: *mut *mut BYTE,
2898 authenticationChallengeLength:
2899 *mut UINT32,
2900 authenticationChallenge:
2901 *mut *mut BYTE,
2902 joinSessionLength: *mut UINT32,
2903 joinSession: *mut *mut BYTE)
2904 -> TSS_RESULT;
2905 pub fn Tspi_DAA_Issuer_IssueCredential(hIssuerKey: TSS_HDAA_ISSUER_KEY,
2906 credentialRequest:
2907 *mut TSS_DAA_CREDENTIAL_REQUEST,
2908 issuerJoinSessionLength: UINT32,
2909 issuerJoinSession: *mut BYTE,
2910 credIssuer:
2911 *mut *mut TSS_DAA_CRED_ISSUER)
2912 -> TSS_RESULT;
2913 pub fn Tspi_DAA_Verifier_Init(hDAACredential: TSS_HDAA_CREDENTIAL,
2914 nonceVerifierLength: *mut UINT32,
2915 nonceVerifier: *mut *mut BYTE,
2916 baseNameLength: *mut UINT32,
2917 baseName: *mut *mut BYTE) -> TSS_RESULT;
2918 pub fn Tspi_DAA_VerifySignature(hDAACredential: TSS_HDAA_CREDENTIAL,
2919 hIssuerKey: TSS_HDAA_ISSUER_KEY,
2920 hARAKey: TSS_HDAA_ARA_KEY,
2921 hARACondition: TSS_HHASH,
2922 attributesLength: UINT32,
2923 attributesLength2: UINT32,
2924 attributes: *mut *mut BYTE,
2925 verifierNonceLength: UINT32,
2926 verifierNonce: *mut BYTE,
2927 verifierBaseNameLength: UINT32,
2928 verifierBaseName: *mut BYTE,
2929 signData: TSS_HOBJECT,
2930 daaSignature: *mut TSS_DAA_SIGNATURE,
2931 isCorrect: *mut TSS_BOOL) -> TSS_RESULT;
2932 pub fn Tspi_DAA_ARA_GenerateKey(hIssuerKey: TSS_HDAA_ISSUER_KEY,
2933 hARAKey: TSS_HDAA_ARA_KEY) -> TSS_RESULT;
2934 pub fn Tspi_DAA_ARA_RevokeAnonymity(hARAKey: TSS_HDAA_ARA_KEY,
2935 hARACondition: TSS_HHASH,
2936 hIssuerKey: TSS_HDAA_ISSUER_KEY,
2937 encryptedPseudonym:
2938 *mut TSS_DAA_PSEUDONYM_ENCRYPTED,
2939 pseudonym:
2940 *mut *mut TSS_DAA_PSEUDONYM_PLAIN)
2941 -> TSS_RESULT;
2942}