extern crate libc;
pub type int8_t = libc::c_char;
pub type int16_t = libc::c_short;
pub type int32_t = libc::c_int;
pub type int64_t = libc::c_longlong;
pub type uint8_t = libc::c_uchar;
pub type uint16_t = libc::c_ushort;
pub type uint32_t = libc::c_uint;
pub type uint64_t = libc::c_ulonglong;
pub type int_least8_t = libc::c_char;
pub type int_least16_t = libc::c_short;
pub type int_least32_t = libc::c_int;
pub type int_least64_t = libc::c_longlong;
pub type uint_least8_t = libc::c_uchar;
pub type uint_least16_t = libc::c_ushort;
pub type uint_least32_t = libc::c_uint;
pub type uint_least64_t = libc::c_ulonglong;
pub type int_fast8_t = libc::c_char;
pub type int_fast16_t = libc::c_int;
pub type int_fast32_t = libc::c_int;
pub type int_fast64_t = libc::c_longlong;
pub type uint_fast8_t = libc::c_uchar;
pub type uint_fast16_t = libc::c_uint;
pub type uint_fast32_t = libc::c_uint;
pub type uint_fast64_t = libc::c_ulonglong;
pub type intptr_t = libc::c_int;
pub type uintptr_t = libc::c_uint;
pub type intmax_t = libc::c_longlong;
pub type uintmax_t = libc::c_ulonglong;
pub type BYTE = uint8_t;
pub type TSS_BOOL = int8_t;
pub type UINT16 = uint16_t;
pub type UINT32 = uint32_t;
pub type UINT64 = uint64_t;
pub type TSS_UNICODE = uint16_t;
pub type PVOID = *mut libc::c_void;
pub type TPM_BOOL = BYTE;
pub type TPM_LOCALITY_MODIFIER = BYTE;
pub type TPM_COMMAND_CODE = UINT32;
pub type TPM_COUNT_ID = UINT32;
pub type TPM_REDIT_COMMAND = UINT32;
pub type TPM_HANDLE = UINT32;
pub type TPM_AUTHHANDLE = UINT32;
pub type TPM_TRANSHANDLE = UINT32;
pub type TPM_KEYHANDLE = UINT32;
pub type TPM_DIRINDEX = UINT32;
pub type TPM_PCRINDEX = UINT32;
pub type TPM_RESULT = UINT32;
pub type TPM_MODIFIER_INDICATOR = UINT32;
pub type TPM_STRUCTURE_TAG = UINT16;
pub type TPM_RESOURCE_TYPE = UINT32;
pub type TPM_PAYLOAD_TYPE = BYTE;
pub type TPM_ENTITY_TYPE = UINT16;
pub type TPM_KEY_HANDLE = UINT32;
pub type TPM_STARTUP_TYPE = UINT16;
pub type TPM_PROTOCOL_ID = UINT16;
pub type TPM_ALGORITHM_ID = UINT32;
pub type TPM_PHYSICAL_PRESENCE = UINT16;
pub type TPM_MIGRATE_SCHEME = UINT16;
pub type TPM_EK_TYPE = UINT16;
pub type TPM_PLATFORM_SPECIFIC = UINT16;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_STRUCT_VER {
pub major: BYTE,
pub minor: BYTE,
pub revMajor: BYTE,
pub revMinor: BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_STRUCT_VER {
fn clone(&self) -> Struct_tdTPM_STRUCT_VER { *self }
}
impl ::std::default::Default for Struct_tdTPM_STRUCT_VER {
fn default() -> Struct_tdTPM_STRUCT_VER {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_STRUCT_VER = Struct_tdTPM_STRUCT_VER;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_VERSION_BYTE {
pub _bindgen_bitfield_1_: libc::c_int,
}
impl ::std::clone::Clone for Struct_tdTPM_VERSION_BYTE {
fn clone(&self) -> Struct_tdTPM_VERSION_BYTE { *self }
}
impl ::std::default::Default for Struct_tdTPM_VERSION_BYTE {
fn default() -> Struct_tdTPM_VERSION_BYTE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_VERSION_BYTE = Struct_tdTPM_VERSION_BYTE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_VERSION {
pub major: BYTE,
pub minor: BYTE,
pub revMajor: BYTE,
pub revMinor: BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_VERSION {
fn clone(&self) -> Struct_tdTPM_VERSION { *self }
}
impl ::std::default::Default for Struct_tdTPM_VERSION {
fn default() -> Struct_tdTPM_VERSION { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_VERSION = Struct_tdTPM_VERSION;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DIGEST {
pub digest: [BYTE; 20usize],
}
impl ::std::clone::Clone for Struct_tdTPM_DIGEST {
fn clone(&self) -> Struct_tdTPM_DIGEST { *self }
}
impl ::std::default::Default for Struct_tdTPM_DIGEST {
fn default() -> Struct_tdTPM_DIGEST { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_DIGEST = Struct_tdTPM_DIGEST;
pub type TPM_CHOSENID_HASH = TPM_DIGEST;
pub type TPM_COMPOSITE_HASH = TPM_DIGEST;
pub type TPM_DIRVALUE = TPM_DIGEST;
pub type TPM_HMAC = TPM_DIGEST;
pub type TPM_PCRVALUE = TPM_DIGEST;
pub type TPM_AUDITDIGEST = TPM_DIGEST;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_NONCE {
pub nonce: [BYTE; 20usize],
}
impl ::std::clone::Clone for Struct_tdTPM_NONCE {
fn clone(&self) -> Struct_tdTPM_NONCE { *self }
}
impl ::std::default::Default for Struct_tdTPM_NONCE {
fn default() -> Struct_tdTPM_NONCE { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_NONCE = Struct_tdTPM_NONCE;
pub type TPM_DAA_TPM_SEED = TPM_NONCE;
pub type TPM_DAA_CONTEXT_SEED = TPM_NONCE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_AUTHDATA {
pub authdata: [BYTE; 20usize],
}
impl ::std::clone::Clone for Struct_tdTPM_AUTHDATA {
fn clone(&self) -> Struct_tdTPM_AUTHDATA { *self }
}
impl ::std::default::Default for Struct_tdTPM_AUTHDATA {
fn default() -> Struct_tdTPM_AUTHDATA { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_AUTHDATA = Struct_tdTPM_AUTHDATA;
pub type TPM_SECRET = TPM_AUTHDATA;
pub type TPM_ENCAUTH = TPM_AUTHDATA;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_KEY_HANDLE_LIST {
pub loaded: UINT16,
pub handle: *mut TPM_KEY_HANDLE,
}
impl ::std::clone::Clone for Struct_tdTPM_KEY_HANDLE_LIST {
fn clone(&self) -> Struct_tdTPM_KEY_HANDLE_LIST { *self }
}
impl ::std::default::Default for Struct_tdTPM_KEY_HANDLE_LIST {
fn default() -> Struct_tdTPM_KEY_HANDLE_LIST {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_KEY_HANDLE_LIST = Struct_tdTPM_KEY_HANDLE_LIST;
pub type TPM_KEY_USAGE = UINT16;
pub type TPM_SIG_SCHEME = UINT16;
pub type TPM_ENC_SCHEME = UINT16;
pub type TPM_AUTH_DATA_USAGE = BYTE;
pub type TPM_KEY_FLAGS = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CHANGEAUTH_VALIDATE {
pub newAuthSecret: TPM_SECRET,
pub n1: TPM_NONCE,
}
impl ::std::clone::Clone for Struct_tdTPM_CHANGEAUTH_VALIDATE {
fn clone(&self) -> Struct_tdTPM_CHANGEAUTH_VALIDATE { *self }
}
impl ::std::default::Default for Struct_tdTPM_CHANGEAUTH_VALIDATE {
fn default() -> Struct_tdTPM_CHANGEAUTH_VALIDATE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CHANGEAUTH_VALIDATE = Struct_tdTPM_CHANGEAUTH_VALIDATE;
pub type TPM_ACTUAL_COUNT = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_COUNTER_VALUE {
pub tag: TPM_STRUCTURE_TAG,
pub label: [BYTE; 4usize],
pub counter: TPM_ACTUAL_COUNT,
}
impl ::std::clone::Clone for Struct_tdTPM_COUNTER_VALUE {
fn clone(&self) -> Struct_tdTPM_COUNTER_VALUE { *self }
}
impl ::std::default::Default for Struct_tdTPM_COUNTER_VALUE {
fn default() -> Struct_tdTPM_COUNTER_VALUE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_COUNTER_VALUE = Struct_tdTPM_COUNTER_VALUE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_SIGN_INFO {
pub tag: TPM_STRUCTURE_TAG,
pub fixed: [BYTE; 4usize],
pub replay: TPM_NONCE,
pub dataLen: UINT32,
pub data: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_SIGN_INFO {
fn clone(&self) -> Struct_tdTPM_SIGN_INFO { *self }
}
impl ::std::default::Default for Struct_tdTPM_SIGN_INFO {
fn default() -> Struct_tdTPM_SIGN_INFO { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_SIGN_INFO = Struct_tdTPM_SIGN_INFO;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_MSA_COMPOSITE {
pub MSAlist: UINT32,
pub migAuthDigest: *mut TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_MSA_COMPOSITE {
fn clone(&self) -> Struct_tdTPM_MSA_COMPOSITE { *self }
}
impl ::std::default::Default for Struct_tdTPM_MSA_COMPOSITE {
fn default() -> Struct_tdTPM_MSA_COMPOSITE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_MSA_COMPOSITE = Struct_tdTPM_MSA_COMPOSITE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CMK_AUTH {
pub migrationAuthorityDigest: TPM_DIGEST,
pub destinationKeyDigest: TPM_DIGEST,
pub sourceKeyDigest: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_CMK_AUTH {
fn clone(&self) -> Struct_tdTPM_CMK_AUTH { *self }
}
impl ::std::default::Default for Struct_tdTPM_CMK_AUTH {
fn default() -> Struct_tdTPM_CMK_AUTH { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_CMK_AUTH = Struct_tdTPM_CMK_AUTH;
pub type TPM_CMK_DELEGATE = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_SELECT_SIZE {
pub major: BYTE,
pub minor: BYTE,
pub reqSize: UINT16,
}
impl ::std::clone::Clone for Struct_tdTPM_SELECT_SIZE {
fn clone(&self) -> Struct_tdTPM_SELECT_SIZE { *self }
}
impl ::std::default::Default for Struct_tdTPM_SELECT_SIZE {
fn default() -> Struct_tdTPM_SELECT_SIZE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_SELECT_SIZE = Struct_tdTPM_SELECT_SIZE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CMK_MIGAUTH {
pub tag: TPM_STRUCTURE_TAG,
pub msaDigest: TPM_DIGEST,
pub pubKeyDigest: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_CMK_MIGAUTH {
fn clone(&self) -> Struct_tdTPM_CMK_MIGAUTH { *self }
}
impl ::std::default::Default for Struct_tdTPM_CMK_MIGAUTH {
fn default() -> Struct_tdTPM_CMK_MIGAUTH {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CMK_MIGAUTH = Struct_tdTPM_CMK_MIGAUTH;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CMK_SIGTICKET {
pub tag: TPM_STRUCTURE_TAG,
pub verKeyDigest: TPM_DIGEST,
pub signedData: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_CMK_SIGTICKET {
fn clone(&self) -> Struct_tdTPM_CMK_SIGTICKET { *self }
}
impl ::std::default::Default for Struct_tdTPM_CMK_SIGTICKET {
fn default() -> Struct_tdTPM_CMK_SIGTICKET {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CMK_SIGTICKET = Struct_tdTPM_CMK_SIGTICKET;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CMK_MA_APPROVAL {
pub tag: TPM_STRUCTURE_TAG,
pub migrationAuthorityDigest: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_CMK_MA_APPROVAL {
fn clone(&self) -> Struct_tdTPM_CMK_MA_APPROVAL { *self }
}
impl ::std::default::Default for Struct_tdTPM_CMK_MA_APPROVAL {
fn default() -> Struct_tdTPM_CMK_MA_APPROVAL {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CMK_MA_APPROVAL = Struct_tdTPM_CMK_MA_APPROVAL;
pub type TPM_TAG = UINT16;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_PERMANENT_FLAGS {
pub tag: TPM_STRUCTURE_TAG,
pub disable: TSS_BOOL,
pub ownership: TSS_BOOL,
pub deactivated: TSS_BOOL,
pub readPubek: TSS_BOOL,
pub disableOwnerClear: TSS_BOOL,
pub allowMaintenance: TSS_BOOL,
pub physicalPresenceLifetimeLock: TSS_BOOL,
pub physicalPresenceHWEnable: TSS_BOOL,
pub physicalPresenceCMDEnable: TSS_BOOL,
pub CEKPUsed: TSS_BOOL,
pub TPMpost: TSS_BOOL,
pub TPMpostLock: TSS_BOOL,
pub FIPS: TSS_BOOL,
pub Operator: TSS_BOOL,
pub enableRevokeEK: TSS_BOOL,
pub nvLocked: TSS_BOOL,
pub readSRKPub: TSS_BOOL,
pub tpmEstablished: TSS_BOOL,
pub maintenanceDone: TSS_BOOL,
pub disableFullDALogicInfo: TSS_BOOL,
}
impl ::std::clone::Clone for Struct_tdTPM_PERMANENT_FLAGS {
fn clone(&self) -> Struct_tdTPM_PERMANENT_FLAGS { *self }
}
impl ::std::default::Default for Struct_tdTPM_PERMANENT_FLAGS {
fn default() -> Struct_tdTPM_PERMANENT_FLAGS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_PERMANENT_FLAGS = Struct_tdTPM_PERMANENT_FLAGS;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_STCLEAR_FLAGS {
pub tag: TPM_STRUCTURE_TAG,
pub deactivated: TSS_BOOL,
pub disableForceClear: TSS_BOOL,
pub physicalPresence: TSS_BOOL,
pub physicalPresenceLock: TSS_BOOL,
pub bGlobalLock: TSS_BOOL,
}
impl ::std::clone::Clone for Struct_tdTPM_STCLEAR_FLAGS {
fn clone(&self) -> Struct_tdTPM_STCLEAR_FLAGS { *self }
}
impl ::std::default::Default for Struct_tdTPM_STCLEAR_FLAGS {
fn default() -> Struct_tdTPM_STCLEAR_FLAGS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_STCLEAR_FLAGS = Struct_tdTPM_STCLEAR_FLAGS;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_STANY_FLAGS {
pub tag: TPM_STRUCTURE_TAG,
pub postInitialise: TSS_BOOL,
pub localityModifier: TPM_MODIFIER_INDICATOR,
pub transportExclusive: TSS_BOOL,
pub TOSPresent: TSS_BOOL,
}
impl ::std::clone::Clone for Struct_tdTPM_STANY_FLAGS {
fn clone(&self) -> Struct_tdTPM_STANY_FLAGS { *self }
}
impl ::std::default::Default for Struct_tdTPM_STANY_FLAGS {
fn default() -> Struct_tdTPM_STANY_FLAGS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_STANY_FLAGS = Struct_tdTPM_STANY_FLAGS;
pub type TPM_LOCALITY_SELECTION = BYTE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_PCR_SELECTION {
pub sizeOfSelect: UINT16,
pub pcrSelect: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_PCR_SELECTION {
fn clone(&self) -> Struct_tdTPM_PCR_SELECTION { *self }
}
impl ::std::default::Default for Struct_tdTPM_PCR_SELECTION {
fn default() -> Struct_tdTPM_PCR_SELECTION {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_PCR_SELECTION = Struct_tdTPM_PCR_SELECTION;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_PCR_COMPOSITE {
pub select: TPM_PCR_SELECTION,
pub valueSize: UINT32,
pub pcrValue: *mut TPM_PCRVALUE,
}
impl ::std::clone::Clone for Struct_tdTPM_PCR_COMPOSITE {
fn clone(&self) -> Struct_tdTPM_PCR_COMPOSITE { *self }
}
impl ::std::default::Default for Struct_tdTPM_PCR_COMPOSITE {
fn default() -> Struct_tdTPM_PCR_COMPOSITE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_PCR_COMPOSITE = Struct_tdTPM_PCR_COMPOSITE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_PCR_INFO {
pub pcrSelection: TPM_PCR_SELECTION,
pub digestAtRelease: TPM_COMPOSITE_HASH,
pub digestAtCreation: TPM_COMPOSITE_HASH,
}
impl ::std::clone::Clone for Struct_tdTPM_PCR_INFO {
fn clone(&self) -> Struct_tdTPM_PCR_INFO { *self }
}
impl ::std::default::Default for Struct_tdTPM_PCR_INFO {
fn default() -> Struct_tdTPM_PCR_INFO { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_PCR_INFO = Struct_tdTPM_PCR_INFO;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_PCR_INFO_LONG {
pub tag: TPM_STRUCTURE_TAG,
pub localityAtCreation: TPM_LOCALITY_SELECTION,
pub localityAtRelease: TPM_LOCALITY_SELECTION,
pub creationPCRSelection: TPM_PCR_SELECTION,
pub releasePCRSelection: TPM_PCR_SELECTION,
pub digestAtCreation: TPM_COMPOSITE_HASH,
pub digestAtRelease: TPM_COMPOSITE_HASH,
}
impl ::std::clone::Clone for Struct_tdTPM_PCR_INFO_LONG {
fn clone(&self) -> Struct_tdTPM_PCR_INFO_LONG { *self }
}
impl ::std::default::Default for Struct_tdTPM_PCR_INFO_LONG {
fn default() -> Struct_tdTPM_PCR_INFO_LONG {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_PCR_INFO_LONG = Struct_tdTPM_PCR_INFO_LONG;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_PCR_INFO_SHORT {
pub pcrSelection: TPM_PCR_SELECTION,
pub localityAtRelease: TPM_LOCALITY_SELECTION,
pub digestAtRelease: TPM_COMPOSITE_HASH,
}
impl ::std::clone::Clone for Struct_tdTPM_PCR_INFO_SHORT {
fn clone(&self) -> Struct_tdTPM_PCR_INFO_SHORT { *self }
}
impl ::std::default::Default for Struct_tdTPM_PCR_INFO_SHORT {
fn default() -> Struct_tdTPM_PCR_INFO_SHORT {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_PCR_INFO_SHORT = Struct_tdTPM_PCR_INFO_SHORT;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_PCR_ATTRIBUTES {
pub pcrReset: BYTE,
pub pcrExtendLocal: TPM_LOCALITY_SELECTION,
pub pcrResetLocal: TPM_LOCALITY_SELECTION,
}
impl ::std::clone::Clone for Struct_tdTPM_PCR_ATTRIBUTES {
fn clone(&self) -> Struct_tdTPM_PCR_ATTRIBUTES { *self }
}
impl ::std::default::Default for Struct_tdTPM_PCR_ATTRIBUTES {
fn default() -> Struct_tdTPM_PCR_ATTRIBUTES {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_PCR_ATTRIBUTES = Struct_tdTPM_PCR_ATTRIBUTES;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_STORED_DATA {
pub ver: TPM_STRUCT_VER,
pub sealInfoSize: UINT32,
pub sealInfo: *mut BYTE,
pub encDataSize: UINT32,
pub encData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_STORED_DATA {
fn clone(&self) -> Struct_tdTPM_STORED_DATA { *self }
}
impl ::std::default::Default for Struct_tdTPM_STORED_DATA {
fn default() -> Struct_tdTPM_STORED_DATA {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_STORED_DATA = Struct_tdTPM_STORED_DATA;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_STORED_DATA12 {
pub tag: TPM_STRUCTURE_TAG,
pub et: TPM_ENTITY_TYPE,
pub sealInfoSize: UINT32,
pub sealInfo: *mut BYTE,
pub encDataSize: UINT32,
pub encData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_STORED_DATA12 {
fn clone(&self) -> Struct_tdTPM_STORED_DATA12 { *self }
}
impl ::std::default::Default for Struct_tdTPM_STORED_DATA12 {
fn default() -> Struct_tdTPM_STORED_DATA12 {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_STORED_DATA12 = Struct_tdTPM_STORED_DATA12;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_SEALED_DATA {
pub payload: TPM_PAYLOAD_TYPE,
pub authData: TPM_SECRET,
pub tpmProof: TPM_NONCE,
pub storedDigest: TPM_DIGEST,
pub dataSize: UINT32,
pub data: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_SEALED_DATA {
fn clone(&self) -> Struct_tdTPM_SEALED_DATA { *self }
}
impl ::std::default::Default for Struct_tdTPM_SEALED_DATA {
fn default() -> Struct_tdTPM_SEALED_DATA {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_SEALED_DATA = Struct_tdTPM_SEALED_DATA;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_SYMMETRIC_KEY {
pub algId: TPM_ALGORITHM_ID,
pub encScheme: TPM_ENC_SCHEME,
pub size: UINT16,
pub data: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_SYMMETRIC_KEY {
fn clone(&self) -> Struct_tdTPM_SYMMETRIC_KEY { *self }
}
impl ::std::default::Default for Struct_tdTPM_SYMMETRIC_KEY {
fn default() -> Struct_tdTPM_SYMMETRIC_KEY {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_SYMMETRIC_KEY = Struct_tdTPM_SYMMETRIC_KEY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_BOUND_DATA {
pub ver: TPM_STRUCT_VER,
pub payload: TPM_PAYLOAD_TYPE,
pub payloadData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_BOUND_DATA {
fn clone(&self) -> Struct_tdTPM_BOUND_DATA { *self }
}
impl ::std::default::Default for Struct_tdTPM_BOUND_DATA {
fn default() -> Struct_tdTPM_BOUND_DATA {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_BOUND_DATA = Struct_tdTPM_BOUND_DATA;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_KEY_PARMS {
pub algorithmID: TPM_ALGORITHM_ID,
pub encScheme: TPM_ENC_SCHEME,
pub sigScheme: TPM_SIG_SCHEME,
pub parmSize: UINT32,
pub parms: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_KEY_PARMS {
fn clone(&self) -> Struct_tdTPM_KEY_PARMS { *self }
}
impl ::std::default::Default for Struct_tdTPM_KEY_PARMS {
fn default() -> Struct_tdTPM_KEY_PARMS { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_KEY_PARMS = Struct_tdTPM_KEY_PARMS;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_RSA_KEY_PARMS {
pub keyLength: UINT32,
pub numPrimes: UINT32,
pub exponentSize: UINT32,
pub exponent: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_RSA_KEY_PARMS {
fn clone(&self) -> Struct_tdTPM_RSA_KEY_PARMS { *self }
}
impl ::std::default::Default for Struct_tdTPM_RSA_KEY_PARMS {
fn default() -> Struct_tdTPM_RSA_KEY_PARMS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_RSA_KEY_PARMS = Struct_tdTPM_RSA_KEY_PARMS;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_SYMMETRIC_KEY_PARMS {
pub keyLength: UINT32,
pub blockSize: UINT32,
pub ivSize: UINT32,
pub IV: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_SYMMETRIC_KEY_PARMS {
fn clone(&self) -> Struct_tdTPM_SYMMETRIC_KEY_PARMS { *self }
}
impl ::std::default::Default for Struct_tdTPM_SYMMETRIC_KEY_PARMS {
fn default() -> Struct_tdTPM_SYMMETRIC_KEY_PARMS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_SYMMETRIC_KEY_PARMS = Struct_tdTPM_SYMMETRIC_KEY_PARMS;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_STORE_PUBKEY {
pub keyLength: UINT32,
pub key: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_STORE_PUBKEY {
fn clone(&self) -> Struct_tdTPM_STORE_PUBKEY { *self }
}
impl ::std::default::Default for Struct_tdTPM_STORE_PUBKEY {
fn default() -> Struct_tdTPM_STORE_PUBKEY {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_STORE_PUBKEY = Struct_tdTPM_STORE_PUBKEY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_PUBKEY {
pub algorithmParms: TPM_KEY_PARMS,
pub pubKey: TPM_STORE_PUBKEY,
}
impl ::std::clone::Clone for Struct_tdTPM_PUBKEY {
fn clone(&self) -> Struct_tdTPM_PUBKEY { *self }
}
impl ::std::default::Default for Struct_tdTPM_PUBKEY {
fn default() -> Struct_tdTPM_PUBKEY { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_PUBKEY = Struct_tdTPM_PUBKEY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_STORE_PRIVKEY {
pub keyLength: UINT32,
pub key: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_STORE_PRIVKEY {
fn clone(&self) -> Struct_tdTPM_STORE_PRIVKEY { *self }
}
impl ::std::default::Default for Struct_tdTPM_STORE_PRIVKEY {
fn default() -> Struct_tdTPM_STORE_PRIVKEY {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_STORE_PRIVKEY = Struct_tdTPM_STORE_PRIVKEY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_STORE_ASYMKEY {
pub payload: TPM_PAYLOAD_TYPE,
pub usageAuth: TPM_SECRET,
pub migrationAuth: TPM_SECRET,
pub pubDataDigest: TPM_DIGEST,
pub privKey: TPM_STORE_PRIVKEY,
}
impl ::std::clone::Clone for Struct_tdTPM_STORE_ASYMKEY {
fn clone(&self) -> Struct_tdTPM_STORE_ASYMKEY { *self }
}
impl ::std::default::Default for Struct_tdTPM_STORE_ASYMKEY {
fn default() -> Struct_tdTPM_STORE_ASYMKEY {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_STORE_ASYMKEY = Struct_tdTPM_STORE_ASYMKEY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_KEY {
pub ver: TPM_STRUCT_VER,
pub keyUsage: TPM_KEY_USAGE,
pub keyFlags: TPM_KEY_FLAGS,
pub authDataUsage: TPM_AUTH_DATA_USAGE,
pub algorithmParms: TPM_KEY_PARMS,
pub PCRInfoSize: UINT32,
pub PCRInfo: *mut BYTE,
pub pubKey: TPM_STORE_PUBKEY,
pub encSize: UINT32,
pub encData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_KEY {
fn clone(&self) -> Struct_tdTPM_KEY { *self }
}
impl ::std::default::Default for Struct_tdTPM_KEY {
fn default() -> Struct_tdTPM_KEY { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_KEY = Struct_tdTPM_KEY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_KEY12 {
pub tag: TPM_STRUCTURE_TAG,
pub fill: UINT16,
pub keyUsage: TPM_KEY_USAGE,
pub keyFlags: TPM_KEY_FLAGS,
pub authDataUsage: TPM_AUTH_DATA_USAGE,
pub algorithmParms: TPM_KEY_PARMS,
pub PCRInfoSize: UINT32,
pub PCRInfo: *mut BYTE,
pub pubKey: TPM_STORE_PUBKEY,
pub encSize: UINT32,
pub encData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_KEY12 {
fn clone(&self) -> Struct_tdTPM_KEY12 { *self }
}
impl ::std::default::Default for Struct_tdTPM_KEY12 {
fn default() -> Struct_tdTPM_KEY12 { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_KEY12 = Struct_tdTPM_KEY12;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_MIGRATE_ASYMKEY {
pub payload: TPM_PAYLOAD_TYPE,
pub usageAuth: TPM_SECRET,
pub pubDataDigest: TPM_DIGEST,
pub partPrivKeyLen: UINT32,
pub partPrivKey: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_MIGRATE_ASYMKEY {
fn clone(&self) -> Struct_tdTPM_MIGRATE_ASYMKEY { *self }
}
impl ::std::default::Default for Struct_tdTPM_MIGRATE_ASYMKEY {
fn default() -> Struct_tdTPM_MIGRATE_ASYMKEY {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_MIGRATE_ASYMKEY = Struct_tdTPM_MIGRATE_ASYMKEY;
pub type TPM_KEY_CONTROL = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_MIGRATIONKEYAUTH {
pub migrationKey: TPM_PUBKEY,
pub migrationScheme: TPM_MIGRATE_SCHEME,
pub digest: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_MIGRATIONKEYAUTH {
fn clone(&self) -> Struct_tdTPM_MIGRATIONKEYAUTH { *self }
}
impl ::std::default::Default for Struct_tdTPM_MIGRATIONKEYAUTH {
fn default() -> Struct_tdTPM_MIGRATIONKEYAUTH {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_MIGRATIONKEYAUTH = Struct_tdTPM_MIGRATIONKEYAUTH;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CERTIFY_INFO {
pub version: TPM_STRUCT_VER,
pub keyUsage: TPM_KEY_USAGE,
pub keyFlags: TPM_KEY_FLAGS,
pub authDataUsage: TPM_AUTH_DATA_USAGE,
pub algorithmParms: TPM_KEY_PARMS,
pub pubkeyDigest: TPM_DIGEST,
pub data: TPM_NONCE,
pub parentPCRStatus: TPM_BOOL,
pub PCRInfoSize: UINT32,
pub PCRInfo: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_CERTIFY_INFO {
fn clone(&self) -> Struct_tdTPM_CERTIFY_INFO { *self }
}
impl ::std::default::Default for Struct_tdTPM_CERTIFY_INFO {
fn default() -> Struct_tdTPM_CERTIFY_INFO {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CERTIFY_INFO = Struct_tdTPM_CERTIFY_INFO;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CERTIFY_INFO2 {
pub tag: TPM_STRUCTURE_TAG,
pub fill: BYTE,
pub payloadType: TPM_PAYLOAD_TYPE,
pub keyUsage: TPM_KEY_USAGE,
pub keyFlags: TPM_KEY_FLAGS,
pub authDataUsage: TPM_AUTH_DATA_USAGE,
pub algorithmParms: TPM_KEY_PARMS,
pub pubkeyDigest: TPM_DIGEST,
pub data: TPM_NONCE,
pub parentPCRStatus: TPM_BOOL,
pub PCRInfoSize: UINT32,
pub PCRInfo: *mut BYTE,
pub migrationAuthoritySize: UINT32,
pub migrationAuthority: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_CERTIFY_INFO2 {
fn clone(&self) -> Struct_tdTPM_CERTIFY_INFO2 { *self }
}
impl ::std::default::Default for Struct_tdTPM_CERTIFY_INFO2 {
fn default() -> Struct_tdTPM_CERTIFY_INFO2 {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CERTIFY_INFO2 = Struct_tdTPM_CERTIFY_INFO2;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_QUOTE_INFO {
pub version: TPM_STRUCT_VER,
pub fixed: [BYTE; 4usize],
pub compositeHash: TPM_COMPOSITE_HASH,
pub externalData: TPM_NONCE,
}
impl ::std::clone::Clone for Struct_tdTPM_QUOTE_INFO {
fn clone(&self) -> Struct_tdTPM_QUOTE_INFO { *self }
}
impl ::std::default::Default for Struct_tdTPM_QUOTE_INFO {
fn default() -> Struct_tdTPM_QUOTE_INFO {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_QUOTE_INFO = Struct_tdTPM_QUOTE_INFO;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_QUOTE_INFO2 {
pub tag: TPM_STRUCTURE_TAG,
pub fixed: [BYTE; 4usize],
pub externalData: TPM_NONCE,
pub infoShort: TPM_PCR_INFO_SHORT,
}
impl ::std::clone::Clone for Struct_tdTPM_QUOTE_INFO2 {
fn clone(&self) -> Struct_tdTPM_QUOTE_INFO2 { *self }
}
impl ::std::default::Default for Struct_tdTPM_QUOTE_INFO2 {
fn default() -> Struct_tdTPM_QUOTE_INFO2 {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_QUOTE_INFO2 = Struct_tdTPM_QUOTE_INFO2;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_EK_BLOB {
pub tag: TPM_STRUCTURE_TAG,
pub ekType: TPM_EK_TYPE,
pub blobSize: UINT32,
pub blob: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_EK_BLOB {
fn clone(&self) -> Struct_tdTPM_EK_BLOB { *self }
}
impl ::std::default::Default for Struct_tdTPM_EK_BLOB {
fn default() -> Struct_tdTPM_EK_BLOB { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_EK_BLOB = Struct_tdTPM_EK_BLOB;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_EK_BLOB_ACTIVATE {
pub tag: TPM_STRUCTURE_TAG,
pub sessionKey: TPM_SYMMETRIC_KEY,
pub idDigest: TPM_DIGEST,
pub pcrInfo: TPM_PCR_INFO_SHORT,
}
impl ::std::clone::Clone for Struct_tdTPM_EK_BLOB_ACTIVATE {
fn clone(&self) -> Struct_tdTPM_EK_BLOB_ACTIVATE { *self }
}
impl ::std::default::Default for Struct_tdTPM_EK_BLOB_ACTIVATE {
fn default() -> Struct_tdTPM_EK_BLOB_ACTIVATE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_EK_BLOB_ACTIVATE = Struct_tdTPM_EK_BLOB_ACTIVATE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_EK_BLOB_AUTH {
pub tag: TPM_STRUCTURE_TAG,
pub authValue: TPM_SECRET,
}
impl ::std::clone::Clone for Struct_tdTPM_EK_BLOB_AUTH {
fn clone(&self) -> Struct_tdTPM_EK_BLOB_AUTH { *self }
}
impl ::std::default::Default for Struct_tdTPM_EK_BLOB_AUTH {
fn default() -> Struct_tdTPM_EK_BLOB_AUTH {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_EK_BLOB_AUTH = Struct_tdTPM_EK_BLOB_AUTH;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_IDENTITY_CONTENTS {
pub ver: TPM_STRUCT_VER,
pub ordinal: UINT32,
pub labelPrivCADigest: TPM_CHOSENID_HASH,
pub identityPubKey: TPM_PUBKEY,
}
impl ::std::clone::Clone for Struct_tdTPM_IDENTITY_CONTENTS {
fn clone(&self) -> Struct_tdTPM_IDENTITY_CONTENTS { *self }
}
impl ::std::default::Default for Struct_tdTPM_IDENTITY_CONTENTS {
fn default() -> Struct_tdTPM_IDENTITY_CONTENTS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_IDENTITY_CONTENTS = Struct_tdTPM_IDENTITY_CONTENTS;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_IDENTITY_REQ {
pub asymSize: UINT32,
pub symSize: UINT32,
pub asymAlgorithm: TPM_KEY_PARMS,
pub symAlgorithm: TPM_KEY_PARMS,
pub asymBlob: *mut BYTE,
pub symBlob: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_IDENTITY_REQ {
fn clone(&self) -> Struct_tdTPM_IDENTITY_REQ { *self }
}
impl ::std::default::Default for Struct_tdTPM_IDENTITY_REQ {
fn default() -> Struct_tdTPM_IDENTITY_REQ {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_IDENTITY_REQ = Struct_tdTPM_IDENTITY_REQ;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_IDENTITY_PROOF {
pub ver: TPM_STRUCT_VER,
pub labelSize: UINT32,
pub identityBindingSize: UINT32,
pub endorsementSize: UINT32,
pub platformSize: UINT32,
pub conformanceSize: UINT32,
pub identityKey: TPM_PUBKEY,
pub labelArea: *mut BYTE,
pub identityBinding: *mut BYTE,
pub endorsementCredential: *mut BYTE,
pub platformCredential: *mut BYTE,
pub conformanceCredential: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_IDENTITY_PROOF {
fn clone(&self) -> Struct_tdTPM_IDENTITY_PROOF { *self }
}
impl ::std::default::Default for Struct_tdTPM_IDENTITY_PROOF {
fn default() -> Struct_tdTPM_IDENTITY_PROOF {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_IDENTITY_PROOF = Struct_tdTPM_IDENTITY_PROOF;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_ASYM_CA_CONTENTS {
pub sessionKey: TPM_SYMMETRIC_KEY,
pub idDigest: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_ASYM_CA_CONTENTS {
fn clone(&self) -> Struct_tdTPM_ASYM_CA_CONTENTS { *self }
}
impl ::std::default::Default for Struct_tdTPM_ASYM_CA_CONTENTS {
fn default() -> Struct_tdTPM_ASYM_CA_CONTENTS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_ASYM_CA_CONTENTS = Struct_tdTPM_ASYM_CA_CONTENTS;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_SYM_CA_ATTESTATION {
pub credSize: UINT32,
pub algorithm: TPM_KEY_PARMS,
pub credential: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_SYM_CA_ATTESTATION {
fn clone(&self) -> Struct_tdTPM_SYM_CA_ATTESTATION { *self }
}
impl ::std::default::Default for Struct_tdTPM_SYM_CA_ATTESTATION {
fn default() -> Struct_tdTPM_SYM_CA_ATTESTATION {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_SYM_CA_ATTESTATION = Struct_tdTPM_SYM_CA_ATTESTATION;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CURRENT_TICKS {
pub tag: TPM_STRUCTURE_TAG,
pub currentTicks: UINT64,
pub tickRate: UINT16,
pub tickNonce: TPM_NONCE,
}
impl ::std::clone::Clone for Struct_tdTPM_CURRENT_TICKS {
fn clone(&self) -> Struct_tdTPM_CURRENT_TICKS { *self }
}
impl ::std::default::Default for Struct_tdTPM_CURRENT_TICKS {
fn default() -> Struct_tdTPM_CURRENT_TICKS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CURRENT_TICKS = Struct_tdTPM_CURRENT_TICKS;
pub type TPM_TRANSPORT_ATTRIBUTES = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_TRANSPORT_PUBLIC {
pub tag: TPM_STRUCTURE_TAG,
pub transAttributes: TPM_TRANSPORT_ATTRIBUTES,
pub algId: TPM_ALGORITHM_ID,
pub encScheme: TPM_ENC_SCHEME,
}
impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_PUBLIC {
fn clone(&self) -> Struct_tdTPM_TRANSPORT_PUBLIC { *self }
}
impl ::std::default::Default for Struct_tdTPM_TRANSPORT_PUBLIC {
fn default() -> Struct_tdTPM_TRANSPORT_PUBLIC {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_TRANSPORT_PUBLIC = Struct_tdTPM_TRANSPORT_PUBLIC;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_TRANSPORT_INTERNAL {
pub tag: TPM_STRUCTURE_TAG,
pub authData: TPM_AUTHDATA,
pub transPublic: TPM_TRANSPORT_PUBLIC,
pub transHandle: TPM_TRANSHANDLE,
pub transNonceEven: TPM_NONCE,
pub transDigest: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_INTERNAL {
fn clone(&self) -> Struct_tdTPM_TRANSPORT_INTERNAL { *self }
}
impl ::std::default::Default for Struct_tdTPM_TRANSPORT_INTERNAL {
fn default() -> Struct_tdTPM_TRANSPORT_INTERNAL {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_TRANSPORT_INTERNAL = Struct_tdTPM_TRANSPORT_INTERNAL;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_TRANSPORT_LOG_IN {
pub tag: TPM_STRUCTURE_TAG,
pub parameters: TPM_DIGEST,
pub pubKeyHash: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_LOG_IN {
fn clone(&self) -> Struct_tdTPM_TRANSPORT_LOG_IN { *self }
}
impl ::std::default::Default for Struct_tdTPM_TRANSPORT_LOG_IN {
fn default() -> Struct_tdTPM_TRANSPORT_LOG_IN {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_TRANSPORT_LOG_IN = Struct_tdTPM_TRANSPORT_LOG_IN;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_TRANSPORT_LOG_OUT {
pub tag: TPM_STRUCTURE_TAG,
pub currentTicks: TPM_CURRENT_TICKS,
pub parameters: TPM_DIGEST,
pub locality: TPM_MODIFIER_INDICATOR,
}
impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_LOG_OUT {
fn clone(&self) -> Struct_tdTPM_TRANSPORT_LOG_OUT { *self }
}
impl ::std::default::Default for Struct_tdTPM_TRANSPORT_LOG_OUT {
fn default() -> Struct_tdTPM_TRANSPORT_LOG_OUT {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_TRANSPORT_LOG_OUT = Struct_tdTPM_TRANSPORT_LOG_OUT;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_TRANSPORT_AUTH {
pub tag: TPM_STRUCTURE_TAG,
pub authData: TPM_AUTHDATA,
}
impl ::std::clone::Clone for Struct_tdTPM_TRANSPORT_AUTH {
fn clone(&self) -> Struct_tdTPM_TRANSPORT_AUTH { *self }
}
impl ::std::default::Default for Struct_tdTPM_TRANSPORT_AUTH {
fn default() -> Struct_tdTPM_TRANSPORT_AUTH {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_TRANSPORT_AUTH = Struct_tdTPM_TRANSPORT_AUTH;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_AUDIT_EVENT_IN {
pub tag: TPM_STRUCTURE_TAG,
pub inputParms: TPM_DIGEST,
pub auditCount: TPM_COUNTER_VALUE,
}
impl ::std::clone::Clone for Struct_tdTPM_AUDIT_EVENT_IN {
fn clone(&self) -> Struct_tdTPM_AUDIT_EVENT_IN { *self }
}
impl ::std::default::Default for Struct_tdTPM_AUDIT_EVENT_IN {
fn default() -> Struct_tdTPM_AUDIT_EVENT_IN {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_AUDIT_EVENT_IN = Struct_tdTPM_AUDIT_EVENT_IN;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_AUDIT_EVENT_OUT {
pub tag: TPM_STRUCTURE_TAG,
pub ordinal: TPM_COMMAND_CODE,
pub outputParms: TPM_DIGEST,
pub auditCount: TPM_COUNTER_VALUE,
pub returnCode: TPM_RESULT,
}
impl ::std::clone::Clone for Struct_tdTPM_AUDIT_EVENT_OUT {
fn clone(&self) -> Struct_tdTPM_AUDIT_EVENT_OUT { *self }
}
impl ::std::default::Default for Struct_tdTPM_AUDIT_EVENT_OUT {
fn default() -> Struct_tdTPM_AUDIT_EVENT_OUT {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_AUDIT_EVENT_OUT = Struct_tdTPM_AUDIT_EVENT_OUT;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CONTEXT_BLOB {
pub tag: TPM_STRUCTURE_TAG,
pub resourceType: TPM_RESOURCE_TYPE,
pub handle: TPM_HANDLE,
pub label: [BYTE; 16usize],
pub contextCount: UINT32,
pub integrityDigest: TPM_DIGEST,
pub additionalSize: UINT32,
pub additionalData: *mut BYTE,
pub sensitiveSize: UINT32,
pub sensitiveData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_CONTEXT_BLOB {
fn clone(&self) -> Struct_tdTPM_CONTEXT_BLOB { *self }
}
impl ::std::default::Default for Struct_tdTPM_CONTEXT_BLOB {
fn default() -> Struct_tdTPM_CONTEXT_BLOB {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CONTEXT_BLOB = Struct_tdTPM_CONTEXT_BLOB;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CONTEXT_SENSITIVE {
pub tag: TPM_STRUCTURE_TAG,
pub contextNonce: TPM_NONCE,
pub internalSize: UINT32,
pub internalData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_CONTEXT_SENSITIVE {
fn clone(&self) -> Struct_tdTPM_CONTEXT_SENSITIVE { *self }
}
impl ::std::default::Default for Struct_tdTPM_CONTEXT_SENSITIVE {
fn default() -> Struct_tdTPM_CONTEXT_SENSITIVE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CONTEXT_SENSITIVE = Struct_tdTPM_CONTEXT_SENSITIVE;
pub type TPM_NV_INDEX = UINT32;
pub type TPM_NV_PER_ATTRIBUTES = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_NV_ATTRIBUTES {
pub tag: TPM_STRUCTURE_TAG,
pub attributes: TPM_NV_PER_ATTRIBUTES,
}
impl ::std::clone::Clone for Struct_tdTPM_NV_ATTRIBUTES {
fn clone(&self) -> Struct_tdTPM_NV_ATTRIBUTES { *self }
}
impl ::std::default::Default for Struct_tdTPM_NV_ATTRIBUTES {
fn default() -> Struct_tdTPM_NV_ATTRIBUTES {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_NV_ATTRIBUTES = Struct_tdTPM_NV_ATTRIBUTES;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_NV_DATA_PUBLIC {
pub tag: TPM_STRUCTURE_TAG,
pub nvIndex: TPM_NV_INDEX,
pub pcrInfoRead: TPM_PCR_INFO_SHORT,
pub pcrInfoWrite: TPM_PCR_INFO_SHORT,
pub permission: TPM_NV_ATTRIBUTES,
pub bReadSTClear: TPM_BOOL,
pub bWriteSTClear: TPM_BOOL,
pub bWriteDefine: TPM_BOOL,
pub dataSize: UINT32,
}
impl ::std::clone::Clone for Struct_tdTPM_NV_DATA_PUBLIC {
fn clone(&self) -> Struct_tdTPM_NV_DATA_PUBLIC { *self }
}
impl ::std::default::Default for Struct_tdTPM_NV_DATA_PUBLIC {
fn default() -> Struct_tdTPM_NV_DATA_PUBLIC {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_NV_DATA_PUBLIC = Struct_tdTPM_NV_DATA_PUBLIC;
pub type TPM_FAMILY_VERIFICATION = UINT32;
pub type TPM_FAMILY_ID = UINT32;
pub type TPM_DELEGATE_INDEX = UINT32;
pub type TPM_FAMILY_OPERATION = UINT32;
pub type TPM_FAMILY_FLAGS = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_FAMILY_LABEL {
pub label: BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_FAMILY_LABEL {
fn clone(&self) -> Struct_tdTPM_FAMILY_LABEL { *self }
}
impl ::std::default::Default for Struct_tdTPM_FAMILY_LABEL {
fn default() -> Struct_tdTPM_FAMILY_LABEL {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_FAMILY_LABEL = Struct_tdTPM_FAMILY_LABEL;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_FAMILY_TABLE_ENTRY {
pub tag: TPM_STRUCTURE_TAG,
pub label: TPM_FAMILY_LABEL,
pub familyID: TPM_FAMILY_ID,
pub verificationCount: TPM_FAMILY_VERIFICATION,
pub flags: TPM_FAMILY_FLAGS,
}
impl ::std::clone::Clone for Struct_tdTPM_FAMILY_TABLE_ENTRY {
fn clone(&self) -> Struct_tdTPM_FAMILY_TABLE_ENTRY { *self }
}
impl ::std::default::Default for Struct_tdTPM_FAMILY_TABLE_ENTRY {
fn default() -> Struct_tdTPM_FAMILY_TABLE_ENTRY {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_FAMILY_TABLE_ENTRY = Struct_tdTPM_FAMILY_TABLE_ENTRY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DELEGATE_LABEL {
pub label: BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_LABEL {
fn clone(&self) -> Struct_tdTPM_DELEGATE_LABEL { *self }
}
impl ::std::default::Default for Struct_tdTPM_DELEGATE_LABEL {
fn default() -> Struct_tdTPM_DELEGATE_LABEL {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DELEGATE_LABEL = Struct_tdTPM_DELEGATE_LABEL;
pub type TPM_DELEGATE_TYPE = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DELEGATIONS {
pub tag: TPM_STRUCTURE_TAG,
pub delegateType: TPM_DELEGATE_TYPE,
pub per1: UINT32,
pub per2: UINT32,
}
impl ::std::clone::Clone for Struct_tdTPM_DELEGATIONS {
fn clone(&self) -> Struct_tdTPM_DELEGATIONS { *self }
}
impl ::std::default::Default for Struct_tdTPM_DELEGATIONS {
fn default() -> Struct_tdTPM_DELEGATIONS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DELEGATIONS = Struct_tdTPM_DELEGATIONS;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DELEGATE_PUBLIC {
pub tag: TPM_STRUCTURE_TAG,
pub label: TPM_DELEGATE_LABEL,
pub pcrInfo: TPM_PCR_INFO_SHORT,
pub permissions: TPM_DELEGATIONS,
pub familyID: TPM_FAMILY_ID,
pub verificationCount: TPM_FAMILY_VERIFICATION,
}
impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_PUBLIC {
fn clone(&self) -> Struct_tdTPM_DELEGATE_PUBLIC { *self }
}
impl ::std::default::Default for Struct_tdTPM_DELEGATE_PUBLIC {
fn default() -> Struct_tdTPM_DELEGATE_PUBLIC {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DELEGATE_PUBLIC = Struct_tdTPM_DELEGATE_PUBLIC;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DELEGATE_TABLE_ROW {
pub tag: TPM_STRUCTURE_TAG,
pub _pub: TPM_DELEGATE_PUBLIC,
pub authValue: TPM_SECRET,
}
impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_TABLE_ROW {
fn clone(&self) -> Struct_tdTPM_DELEGATE_TABLE_ROW { *self }
}
impl ::std::default::Default for Struct_tdTPM_DELEGATE_TABLE_ROW {
fn default() -> Struct_tdTPM_DELEGATE_TABLE_ROW {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DELEGATE_TABLE_ROW = Struct_tdTPM_DELEGATE_TABLE_ROW;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DELEGATE_SENSITIVE {
pub tag: TPM_STRUCTURE_TAG,
pub authValue: TPM_SECRET,
}
impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_SENSITIVE {
fn clone(&self) -> Struct_tdTPM_DELEGATE_SENSITIVE { *self }
}
impl ::std::default::Default for Struct_tdTPM_DELEGATE_SENSITIVE {
fn default() -> Struct_tdTPM_DELEGATE_SENSITIVE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DELEGATE_SENSITIVE = Struct_tdTPM_DELEGATE_SENSITIVE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DELEGATE_OWNER_BLOB {
pub tag: TPM_STRUCTURE_TAG,
pub _pub: TPM_DELEGATE_PUBLIC,
pub integrityDigest: TPM_DIGEST,
pub additionalSize: UINT32,
pub additionalArea: *mut BYTE,
pub sensitiveSize: UINT32,
pub sensitiveArea: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_OWNER_BLOB {
fn clone(&self) -> Struct_tdTPM_DELEGATE_OWNER_BLOB { *self }
}
impl ::std::default::Default for Struct_tdTPM_DELEGATE_OWNER_BLOB {
fn default() -> Struct_tdTPM_DELEGATE_OWNER_BLOB {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DELEGATE_OWNER_BLOB = Struct_tdTPM_DELEGATE_OWNER_BLOB;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DELEGATE_KEY_BLOB {
pub tag: TPM_STRUCTURE_TAG,
pub _pub: TPM_DELEGATE_PUBLIC,
pub integrityDigest: TPM_DIGEST,
pub pubKeyDigest: TPM_DIGEST,
pub additionalSize: UINT32,
pub additionalArea: *mut BYTE,
pub sensitiveSize: UINT32,
pub sensitiveArea: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_DELEGATE_KEY_BLOB {
fn clone(&self) -> Struct_tdTPM_DELEGATE_KEY_BLOB { *self }
}
impl ::std::default::Default for Struct_tdTPM_DELEGATE_KEY_BLOB {
fn default() -> Struct_tdTPM_DELEGATE_KEY_BLOB {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DELEGATE_KEY_BLOB = Struct_tdTPM_DELEGATE_KEY_BLOB;
pub type TPM_CAPABILITY_AREA = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_CAP_VERSION_INFO {
pub tag: TPM_STRUCTURE_TAG,
pub version: TPM_VERSION,
pub specLevel: UINT16,
pub errataRev: BYTE,
pub tpmVendorID: [BYTE; 4usize],
pub vendorSpecificSize: UINT16,
pub vendorSpecific: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_CAP_VERSION_INFO {
fn clone(&self) -> Struct_tdTPM_CAP_VERSION_INFO { *self }
}
impl ::std::default::Default for Struct_tdTPM_CAP_VERSION_INFO {
fn default() -> Struct_tdTPM_CAP_VERSION_INFO {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_CAP_VERSION_INFO = Struct_tdTPM_CAP_VERSION_INFO;
pub type TPM_DA_STATE = BYTE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DA_ACTION_TYPE {
pub tag: TPM_STRUCTURE_TAG,
pub actions: UINT32,
}
impl ::std::clone::Clone for Struct_tdTPM_DA_ACTION_TYPE {
fn clone(&self) -> Struct_tdTPM_DA_ACTION_TYPE { *self }
}
impl ::std::default::Default for Struct_tdTPM_DA_ACTION_TYPE {
fn default() -> Struct_tdTPM_DA_ACTION_TYPE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DA_ACTION_TYPE = Struct_tdTPM_DA_ACTION_TYPE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DA_INFO {
pub tag: TPM_STRUCTURE_TAG,
pub state: TPM_DA_STATE,
pub currentCount: UINT16,
pub threshholdCount: UINT16,
pub actionAtThreshold: TPM_DA_ACTION_TYPE,
pub actionDependValue: UINT32,
pub vendorDataSize: UINT32,
pub vendorData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_DA_INFO {
fn clone(&self) -> Struct_tdTPM_DA_INFO { *self }
}
impl ::std::default::Default for Struct_tdTPM_DA_INFO {
fn default() -> Struct_tdTPM_DA_INFO { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_DA_INFO = Struct_tdTPM_DA_INFO;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DA_INFO_LIMITED {
pub tag: TPM_STRUCTURE_TAG,
pub state: TPM_DA_STATE,
pub actionAtThreshold: TPM_DA_ACTION_TYPE,
pub vendorDataSize: UINT32,
pub vendorData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_DA_INFO_LIMITED {
fn clone(&self) -> Struct_tdTPM_DA_INFO_LIMITED { *self }
}
impl ::std::default::Default for Struct_tdTPM_DA_INFO_LIMITED {
fn default() -> Struct_tdTPM_DA_INFO_LIMITED {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DA_INFO_LIMITED = Struct_tdTPM_DA_INFO_LIMITED;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DAA_ISSUER {
pub tag: TPM_STRUCTURE_TAG,
pub DAA_digest_R0: TPM_DIGEST,
pub DAA_digest_R1: TPM_DIGEST,
pub DAA_digest_S0: TPM_DIGEST,
pub DAA_digest_S1: TPM_DIGEST,
pub DAA_digest_n: TPM_DIGEST,
pub DAA_digest_gamma: TPM_DIGEST,
pub DAA_generic_q: [BYTE; 26usize],
}
impl ::std::clone::Clone for Struct_tdTPM_DAA_ISSUER {
fn clone(&self) -> Struct_tdTPM_DAA_ISSUER { *self }
}
impl ::std::default::Default for Struct_tdTPM_DAA_ISSUER {
fn default() -> Struct_tdTPM_DAA_ISSUER {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DAA_ISSUER = Struct_tdTPM_DAA_ISSUER;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DAA_TPM {
pub tag: TPM_STRUCTURE_TAG,
pub DAA_digestIssuer: TPM_DIGEST,
pub DAA_digest_v0: TPM_DIGEST,
pub DAA_digest_v1: TPM_DIGEST,
pub DAA_rekey: TPM_DIGEST,
pub DAA_count: UINT32,
}
impl ::std::clone::Clone for Struct_tdTPM_DAA_TPM {
fn clone(&self) -> Struct_tdTPM_DAA_TPM { *self }
}
impl ::std::default::Default for Struct_tdTPM_DAA_TPM {
fn default() -> Struct_tdTPM_DAA_TPM { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_DAA_TPM = Struct_tdTPM_DAA_TPM;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DAA_CONTEXT {
pub tag: TPM_STRUCTURE_TAG,
pub DAA_digestContext: TPM_DIGEST,
pub DAA_digest: TPM_DIGEST,
pub DAA_contextSeed: TPM_DAA_CONTEXT_SEED,
pub DAA_scratch: [BYTE; 256usize],
pub DAA_stage: BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_DAA_CONTEXT {
fn clone(&self) -> Struct_tdTPM_DAA_CONTEXT { *self }
}
impl ::std::default::Default for Struct_tdTPM_DAA_CONTEXT {
fn default() -> Struct_tdTPM_DAA_CONTEXT {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DAA_CONTEXT = Struct_tdTPM_DAA_CONTEXT;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DAA_JOINDATA {
pub DAA_join_u0: [BYTE; 128usize],
pub DAA_join_u1: [BYTE; 138usize],
pub DAA_digest_n0: TPM_DIGEST,
}
impl ::std::clone::Clone for Struct_tdTPM_DAA_JOINDATA {
fn clone(&self) -> Struct_tdTPM_DAA_JOINDATA { *self }
}
impl ::std::default::Default for Struct_tdTPM_DAA_JOINDATA {
fn default() -> Struct_tdTPM_DAA_JOINDATA {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DAA_JOINDATA = Struct_tdTPM_DAA_JOINDATA;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DAA_BLOB {
pub tag: TPM_STRUCTURE_TAG,
pub resourceType: TPM_RESOURCE_TYPE,
pub label: [BYTE; 16usize],
pub blobIntegrity: TPM_DIGEST,
pub additionalSize: UINT32,
pub additionalData: *mut BYTE,
pub sensitiveSize: UINT32,
pub sensitiveData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_DAA_BLOB {
fn clone(&self) -> Struct_tdTPM_DAA_BLOB { *self }
}
impl ::std::default::Default for Struct_tdTPM_DAA_BLOB {
fn default() -> Struct_tdTPM_DAA_BLOB { unsafe { ::std::mem::zeroed() } }
}
pub type TPM_DAA_BLOB = Struct_tdTPM_DAA_BLOB;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTPM_DAA_SENSITIVE {
pub tag: TPM_STRUCTURE_TAG,
pub internalSize: UINT32,
pub internalData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTPM_DAA_SENSITIVE {
fn clone(&self) -> Struct_tdTPM_DAA_SENSITIVE { *self }
}
impl ::std::default::Default for Struct_tdTPM_DAA_SENSITIVE {
fn default() -> Struct_tdTPM_DAA_SENSITIVE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TPM_DAA_SENSITIVE = Struct_tdTPM_DAA_SENSITIVE;
pub type TPM_SYM_MODE = UINT32;
pub type UNICODE = TSS_UNICODE;
pub type TCPA_DIGEST = TPM_DIGEST;
pub type TCPA_NONCE = TPM_NONCE;
pub type TCPA_SALT_NONCE = TPM_NONCE;
pub type TCPA_PUBKEY = TPM_PUBKEY;
pub type TCPA_SECRET = TPM_SECRET;
pub type TCPA_KEY = TPM_KEY;
pub type TCPA_DIRVALUE = TPM_DIRVALUE;
pub type TCPA_COMMAND_CODE = TPM_COMMAND_CODE;
pub type TCPA_BOUND_DATA = TPM_BOUND_DATA;
pub type TCPA_VERSION = TPM_STRUCT_VER;
pub type TCPA_RESULT = TPM_RESULT;
pub type TCPA_PAYLOAD_TYPE = TPM_PAYLOAD_TYPE;
pub type TCPA_STORE_PRIVKEY = TPM_STORE_PRIVKEY;
pub type TCPA_CHOSENID_HASH = TPM_CHOSENID_HASH;
pub type TCPA_SYMMETRIC_KEY = TPM_SYMMETRIC_KEY;
pub type TCPA_PCR_INFO = TPM_PCR_INFO;
pub type TCPA_PCR_SELECTION = TPM_PCR_SELECTION;
pub type TCPA_STORED_DATA = TPM_STORED_DATA;
pub type TCPA_SEALED_DATA = TPM_SEALED_DATA;
pub type TCPA_KEY_FLAGS = TPM_KEY_FLAGS;
pub type TCPA_KEY_PARMS = TPM_KEY_PARMS;
pub type TCPA_STORE_PUBKEY = TPM_STORE_PUBKEY;
pub type TCPA_MIGRATIONKEYAUTH = TPM_MIGRATIONKEYAUTH;
pub type TCPA_RSA_KEY_PARMS = TPM_RSA_KEY_PARMS;
pub type TCPA_CERTIFY_INFO = TPM_CERTIFY_INFO;
pub type TCPA_STORE_ASYMKEY = TPM_STORE_ASYMKEY;
pub type TCPA_ENCAUTH = TPM_ENCAUTH;
pub type TCPA_PCRINDEX = TPM_PCRINDEX;
pub type TCPA_PCRVALUE = TPM_PCRVALUE;
pub type TCPA_DIRINDEX = TPM_DIRINDEX;
pub type TCPA_PROTOCOL_ID = TPM_PROTOCOL_ID;
pub type TCPA_ALGORITHM_ID = TPM_ALGORITHM_ID;
pub type TCPA_ENTITY_TYPE = TPM_ENTITY_TYPE;
pub type TCPA_CAPABILITY_AREA = TPM_CAPABILITY_AREA;
pub type TCPA_HMAC = TPM_HMAC;
pub type TCPA_MIGRATE_SCHEME = TPM_MIGRATE_SCHEME;
pub type TCPA_PHYSICAL_PRESENCE = TPM_PHYSICAL_PRESENCE;
pub type TCPA_KEY_HANDLE = TPM_KEY_HANDLE;
pub type TCPA_KEY_HANDLE_LIST = TPM_KEY_HANDLE_LIST;
pub type TCPA_PCR_COMPOSITE = TPM_PCR_COMPOSITE;
pub type TCPA_AUTH_DATA_USAGE = TPM_AUTH_DATA_USAGE;
pub type TCPA_AUTHDATA = TPM_AUTHDATA;
pub type TCPA_KEY_USAGE = TPM_KEY_USAGE;
pub type TCPA_COMPOSITE_HASH = TPM_COMPOSITE_HASH;
pub type TCPA_QUOTE_INFO = TPM_QUOTE_INFO;
pub type TCPA_TAG = TPM_TAG;
pub type TCPA_ENC_SCHEME = TPM_ENC_SCHEME;
pub type TCPA_SIG_SCHEME = TPM_SIG_SCHEME;
pub type TCPA_STARTUP_TYPE = TPM_STARTUP_TYPE;
pub type TCPA_AUTHHANDLE = TPM_AUTHHANDLE;
pub type TCPA_SYM_CA_ATTESTATION = TPM_SYM_CA_ATTESTATION;
pub type TCPA_ASYM_CA_CONTENTS = TPM_ASYM_CA_CONTENTS;
pub type TCPA_IDENTITY_REQ = TPM_IDENTITY_REQ;
pub type TCPA_IDENTITY_PROOF = TPM_IDENTITY_PROOF;
pub type TCPA_ENCHANDLE = UINT32;
pub type TCPA_EVENTTYPE = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTCPA_AUDIT_EVENT {
pub ordinal: TCPA_COMMAND_CODE,
pub returncode: TCPA_RESULT,
}
impl ::std::clone::Clone for Struct_tdTCPA_AUDIT_EVENT {
fn clone(&self) -> Struct_tdTCPA_AUDIT_EVENT { *self }
}
impl ::std::default::Default for Struct_tdTCPA_AUDIT_EVENT {
fn default() -> Struct_tdTCPA_AUDIT_EVENT {
unsafe { ::std::mem::zeroed() }
}
}
pub type TCPA_AUDIT_EVENT = Struct_tdTCPA_AUDIT_EVENT;
pub type TSS_HANDLE = UINT32;
pub type TSS_FLAG = UINT32;
pub type TSS_RESULT = UINT32;
pub type TSS_HOBJECT = UINT32;
pub type TSS_HCONTEXT = TSS_HOBJECT;
pub type TSS_HPOLICY = TSS_HOBJECT;
pub type TSS_HTPM = TSS_HOBJECT;
pub type TSS_HKEY = TSS_HOBJECT;
pub type TSS_HENCDATA = TSS_HOBJECT;
pub type TSS_HPCRS = TSS_HOBJECT;
pub type TSS_HHASH = TSS_HOBJECT;
pub type TSS_HNVSTORE = TSS_HOBJECT;
pub type TSS_HMIGDATA = TSS_HOBJECT;
pub type TSS_HDELFAMILY = TSS_HOBJECT;
pub type TSS_HDAA_CREDENTIAL = TSS_HOBJECT;
pub type TSS_HDAA_ISSUER_KEY = TSS_HOBJECT;
pub type TSS_HDAA_ARA_KEY = TSS_HOBJECT;
pub type TSS_EVENTTYPE = UINT32;
pub type TSS_MIGRATE_SCHEME = UINT16;
pub type TSS_ALGORITHM_ID = UINT32;
pub type TSS_KEY_USAGE_ID = UINT32;
pub type TSS_KEY_ENC_SCHEME = UINT16;
pub type TSS_KEY_SIG_SCHEME = UINT16;
pub type TSS_KEY_AUTH_DATA_USAGE = BYTE;
pub type TSS_CMK_DELEGATE = UINT32;
pub type TSS_NV_INDEX = UINT32;
pub type TSS_COUNTER_ID = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_VERSION {
pub bMajor: BYTE,
pub bMinor: BYTE,
pub bRevMajor: BYTE,
pub bRevMinor: BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_VERSION {
fn clone(&self) -> Struct_tdTSS_VERSION { *self }
}
impl ::std::default::Default for Struct_tdTSS_VERSION {
fn default() -> Struct_tdTSS_VERSION { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_VERSION = Struct_tdTSS_VERSION;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_PCR_EVENT {
pub versionInfo: TSS_VERSION,
pub ulPcrIndex: UINT32,
pub eventType: TSS_EVENTTYPE,
pub ulPcrValueLength: UINT32,
pub rgbPcrValue: *mut BYTE,
pub ulEventLength: UINT32,
pub rgbEvent: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_PCR_EVENT {
fn clone(&self) -> Struct_tdTSS_PCR_EVENT { *self }
}
impl ::std::default::Default for Struct_tdTSS_PCR_EVENT {
fn default() -> Struct_tdTSS_PCR_EVENT { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_PCR_EVENT = Struct_tdTSS_PCR_EVENT;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_EVENT_CERT {
pub versionInfo: TSS_VERSION,
pub ulCertificateHashLength: UINT32,
pub rgbCertificateHash: *mut BYTE,
pub ulEntityDigestLength: UINT32,
pub rgbentityDigest: *mut BYTE,
pub fDigestChecked: TSS_BOOL,
pub fDigestVerified: TSS_BOOL,
pub ulIssuerLength: UINT32,
pub rgbIssuer: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_EVENT_CERT {
fn clone(&self) -> Struct_tdTSS_EVENT_CERT { *self }
}
impl ::std::default::Default for Struct_tdTSS_EVENT_CERT {
fn default() -> Struct_tdTSS_EVENT_CERT {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_EVENT_CERT = Struct_tdTSS_EVENT_CERT;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_UUID {
pub ulTimeLow: UINT32,
pub usTimeMid: UINT16,
pub usTimeHigh: UINT16,
pub bClockSeqHigh: BYTE,
pub bClockSeqLow: BYTE,
pub rgbNode: [BYTE; 6usize],
}
impl ::std::clone::Clone for Struct_tdTSS_UUID {
fn clone(&self) -> Struct_tdTSS_UUID { *self }
}
impl ::std::default::Default for Struct_tdTSS_UUID {
fn default() -> Struct_tdTSS_UUID { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_UUID = Struct_tdTSS_UUID;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_KM_KEYINFO {
pub versionInfo: TSS_VERSION,
pub keyUUID: TSS_UUID,
pub parentKeyUUID: TSS_UUID,
pub bAuthDataUsage: BYTE,
pub fIsLoaded: TSS_BOOL,
pub ulVendorDataLength: UINT32,
pub rgbVendorData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_KM_KEYINFO {
fn clone(&self) -> Struct_tdTSS_KM_KEYINFO { *self }
}
impl ::std::default::Default for Struct_tdTSS_KM_KEYINFO {
fn default() -> Struct_tdTSS_KM_KEYINFO {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_KM_KEYINFO = Struct_tdTSS_KM_KEYINFO;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_KM_KEYINFO2 {
pub versionInfo: TSS_VERSION,
pub keyUUID: TSS_UUID,
pub parentKeyUUID: TSS_UUID,
pub bAuthDataUsage: BYTE,
pub persistentStorageType: TSS_FLAG,
pub persistentStorageTypeParent: TSS_FLAG,
pub fIsLoaded: TSS_BOOL,
pub ulVendorDataLength: UINT32,
pub rgbVendorData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_KM_KEYINFO2 {
fn clone(&self) -> Struct_tdTSS_KM_KEYINFO2 { *self }
}
impl ::std::default::Default for Struct_tdTSS_KM_KEYINFO2 {
fn default() -> Struct_tdTSS_KM_KEYINFO2 {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_KM_KEYINFO2 = Struct_tdTSS_KM_KEYINFO2;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_NONCE {
pub nonce: [BYTE; 20usize],
}
impl ::std::clone::Clone for Struct_tdTSS_NONCE {
fn clone(&self) -> Struct_tdTSS_NONCE { *self }
}
impl ::std::default::Default for Struct_tdTSS_NONCE {
fn default() -> Struct_tdTSS_NONCE { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_NONCE = Struct_tdTSS_NONCE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_VALIDATION {
pub versionInfo: TSS_VERSION,
pub ulExternalDataLength: UINT32,
pub rgbExternalData: *mut BYTE,
pub ulDataLength: UINT32,
pub rgbData: *mut BYTE,
pub ulValidationDataLength: UINT32,
pub rgbValidationData: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_VALIDATION {
fn clone(&self) -> Struct_tdTSS_VALIDATION { *self }
}
impl ::std::default::Default for Struct_tdTSS_VALIDATION {
fn default() -> Struct_tdTSS_VALIDATION {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_VALIDATION = Struct_tdTSS_VALIDATION;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_CALLBACK {
pub callback: PVOID,
pub appData: PVOID,
pub alg: TSS_ALGORITHM_ID,
}
impl ::std::clone::Clone for Struct_tdTSS_CALLBACK {
fn clone(&self) -> Struct_tdTSS_CALLBACK { *self }
}
impl ::std::default::Default for Struct_tdTSS_CALLBACK {
fn default() -> Struct_tdTSS_CALLBACK { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_CALLBACK = Struct_tdTSS_CALLBACK;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_PK {
pub versionInfo: TSS_VERSION,
pub modulusLength: UINT32,
pub modulus: *mut BYTE,
pub capitalSLength: UINT32,
pub capitalS: *mut BYTE,
pub capitalZLength: UINT32,
pub capitalZ: *mut BYTE,
pub capitalR0Length: UINT32,
pub capitalR0: *mut BYTE,
pub capitalR1Length: UINT32,
pub capitalR1: *mut BYTE,
pub gammaLength: UINT32,
pub gamma: *mut BYTE,
pub capitalGammaLength: UINT32,
pub capitalGamma: *mut BYTE,
pub rhoLength: UINT32,
pub rho: *mut BYTE,
pub capitalYLength: UINT32,
pub capitalYLength2: UINT32,
pub capitalY: *mut *mut BYTE,
pub capitalYPlatformLength: UINT32,
pub issuerBaseNameLength: UINT32,
pub issuerBaseName: *mut BYTE,
pub numPlatformAttributes: UINT32,
pub numIssuerAttributes: UINT32,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_PK {
fn clone(&self) -> Struct_tdTSS_DAA_PK { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_PK {
fn default() -> Struct_tdTSS_DAA_PK { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_DAA_PK = Struct_tdTSS_DAA_PK;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_PK_PROOF {
pub versionInfo: TSS_VERSION,
pub challengeLength: UINT32,
pub challenge: *mut BYTE,
pub responseLength: UINT32,
pub responseLength2: UINT32,
pub response: *mut *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_PK_PROOF {
fn clone(&self) -> Struct_tdTSS_DAA_PK_PROOF { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_PK_PROOF {
fn default() -> Struct_tdTSS_DAA_PK_PROOF {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_PK_PROOF = Struct_tdTSS_DAA_PK_PROOF;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_SK {
pub versionInfo: TSS_VERSION,
pub productPQprimeLength: UINT32,
pub productPQprime: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_SK {
fn clone(&self) -> Struct_tdTSS_DAA_SK { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_SK {
fn default() -> Struct_tdTSS_DAA_SK { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_DAA_SK = Struct_tdTSS_DAA_SK;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_KEY_PAIR {
pub versionInfo: TSS_VERSION,
pub secretKey: TSS_DAA_SK,
pub publicKey: TSS_DAA_PK,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_KEY_PAIR {
fn clone(&self) -> Struct_tdTSS_DAA_KEY_PAIR { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_KEY_PAIR {
fn default() -> Struct_tdTSS_DAA_KEY_PAIR {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_KEY_PAIR = Struct_tdTSS_DAA_KEY_PAIR;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_AR_PK {
pub versionInfo: TSS_VERSION,
pub etaLength: UINT32,
pub eta: *mut BYTE,
pub lambda1Length: UINT32,
pub lambda1: *mut BYTE,
pub lambda2Length: UINT32,
pub lambda2: *mut BYTE,
pub lambda3Length: UINT32,
pub lambda3: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_AR_PK {
fn clone(&self) -> Struct_tdTSS_DAA_AR_PK { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_AR_PK {
fn default() -> Struct_tdTSS_DAA_AR_PK { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_DAA_AR_PK = Struct_tdTSS_DAA_AR_PK;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_AR_SK {
pub versionInfo: TSS_VERSION,
pub x0Length: UINT32,
pub x0: *mut BYTE,
pub x1Length: UINT32,
pub x1: *mut BYTE,
pub x2Length: UINT32,
pub x2: *mut BYTE,
pub x3Length: UINT32,
pub x3: *mut BYTE,
pub x4Length: UINT32,
pub x4: *mut BYTE,
pub x5Length: UINT32,
pub x5: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_AR_SK {
fn clone(&self) -> Struct_tdTSS_DAA_AR_SK { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_AR_SK {
fn default() -> Struct_tdTSS_DAA_AR_SK { unsafe { ::std::mem::zeroed() } }
}
pub type TSS_DAA_AR_SK = Struct_tdTSS_DAA_AR_SK;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_AR_KEY_PAIR {
pub versionInfo: TSS_VERSION,
pub secretKey: TSS_DAA_AR_SK,
pub publicKey: TSS_DAA_AR_PK,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_AR_KEY_PAIR {
fn clone(&self) -> Struct_tdTSS_DAA_AR_KEY_PAIR { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_AR_KEY_PAIR {
fn default() -> Struct_tdTSS_DAA_AR_KEY_PAIR {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_AR_KEY_PAIR = Struct_tdTSS_DAA_AR_KEY_PAIR;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_CRED_ISSUER {
pub versionInfo: TSS_VERSION,
pub capitalALength: UINT32,
pub capitalA: *mut BYTE,
pub eLength: UINT32,
pub e: *mut BYTE,
pub vPrimePrimeLength: UINT32,
pub vPrimePrime: *mut BYTE,
pub attributesIssuerLength: UINT32,
pub attributesIssuerLength2: UINT32,
pub attributesIssuer: *mut *mut BYTE,
pub cPrimeLength: UINT32,
pub cPrime: *mut BYTE,
pub sELength: UINT32,
pub sE: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_CRED_ISSUER {
fn clone(&self) -> Struct_tdTSS_DAA_CRED_ISSUER { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_CRED_ISSUER {
fn default() -> Struct_tdTSS_DAA_CRED_ISSUER {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_CRED_ISSUER = Struct_tdTSS_DAA_CRED_ISSUER;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_CREDENTIAL {
pub versionInfo: TSS_VERSION,
pub capitalALength: UINT32,
pub capitalA: *mut BYTE,
pub exponentLength: UINT32,
pub exponent: *mut BYTE,
pub vBar0Length: UINT32,
pub vBar0: *mut BYTE,
pub vBar1Length: UINT32,
pub vBar1: *mut BYTE,
pub attributesLength: UINT32,
pub attributesLength2: UINT32,
pub attributes: *mut *mut BYTE,
pub issuerPK: TSS_DAA_PK,
pub tpmSpecificEncLength: UINT32,
pub tpmSpecificEnc: *mut BYTE,
pub daaCounter: UINT32,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_CREDENTIAL {
fn clone(&self) -> Struct_tdTSS_DAA_CREDENTIAL { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_CREDENTIAL {
fn default() -> Struct_tdTSS_DAA_CREDENTIAL {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_CREDENTIAL = Struct_tdTSS_DAA_CREDENTIAL;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_ATTRIB_COMMIT {
pub versionInfo: TSS_VERSION,
pub betaLength: UINT32,
pub beta: *mut BYTE,
pub sMuLength: UINT32,
pub sMu: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_ATTRIB_COMMIT {
fn clone(&self) -> Struct_tdTSS_DAA_ATTRIB_COMMIT { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_ATTRIB_COMMIT {
fn default() -> Struct_tdTSS_DAA_ATTRIB_COMMIT {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_ATTRIB_COMMIT = Struct_tdTSS_DAA_ATTRIB_COMMIT;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_CREDENTIAL_REQUEST {
pub versionInfo: TSS_VERSION,
pub capitalULength: UINT32,
pub capitalU: *mut BYTE,
pub capitalNiLength: UINT32,
pub capitalNi: *mut BYTE,
pub authenticationProofLength: UINT32,
pub authenticationProof: *mut BYTE,
pub challengeLength: UINT32,
pub challenge: *mut BYTE,
pub nonceTpmLength: UINT32,
pub nonceTpm: *mut BYTE,
pub noncePlatformLength: UINT32,
pub noncePlatform: *mut BYTE,
pub sF0Length: UINT32,
pub sF0: *mut BYTE,
pub sF1Length: UINT32,
pub sF1: *mut BYTE,
pub sVprimeLength: UINT32,
pub sVprime: *mut BYTE,
pub sVtildePrimeLength: UINT32,
pub sVtildePrime: *mut BYTE,
pub sALength: UINT32,
pub sALength2: UINT32,
pub sA: *mut *mut BYTE,
pub attributeCommitmentsLength: UINT32,
pub attributeCommitments: *mut TSS_DAA_ATTRIB_COMMIT,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_CREDENTIAL_REQUEST {
fn clone(&self) -> Struct_tdTSS_DAA_CREDENTIAL_REQUEST { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_CREDENTIAL_REQUEST {
fn default() -> Struct_tdTSS_DAA_CREDENTIAL_REQUEST {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_CREDENTIAL_REQUEST = Struct_tdTSS_DAA_CREDENTIAL_REQUEST;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_SELECTED_ATTRIB {
pub versionInfo: TSS_VERSION,
pub indicesListLength: UINT32,
pub indicesList: *mut TSS_BOOL,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_SELECTED_ATTRIB {
fn clone(&self) -> Struct_tdTSS_DAA_SELECTED_ATTRIB { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_SELECTED_ATTRIB {
fn default() -> Struct_tdTSS_DAA_SELECTED_ATTRIB {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_SELECTED_ATTRIB = Struct_tdTSS_DAA_SELECTED_ATTRIB;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_PSEUDONYM {
pub versionInfo: TSS_VERSION,
pub payloadFlag: TSS_FLAG,
pub payloadLength: UINT32,
pub payload: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_PSEUDONYM {
fn clone(&self) -> Struct_tdTSS_DAA_PSEUDONYM { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_PSEUDONYM {
fn default() -> Struct_tdTSS_DAA_PSEUDONYM {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_PSEUDONYM = Struct_tdTSS_DAA_PSEUDONYM;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_PSEUDONYM_PLAIN {
pub versionInfo: TSS_VERSION,
pub capitalNvLength: UINT32,
pub capitalNv: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_PSEUDONYM_PLAIN {
fn clone(&self) -> Struct_tdTSS_DAA_PSEUDONYM_PLAIN { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_PSEUDONYM_PLAIN {
fn default() -> Struct_tdTSS_DAA_PSEUDONYM_PLAIN {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_PSEUDONYM_PLAIN = Struct_tdTSS_DAA_PSEUDONYM_PLAIN;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED {
pub versionInfo: TSS_VERSION,
pub delta1Length: UINT32,
pub delta1: *mut BYTE,
pub delta2Length: UINT32,
pub delta2: *mut BYTE,
pub delta3Length: UINT32,
pub delta3: *mut BYTE,
pub delta4Length: UINT32,
pub delta4: *mut BYTE,
pub sTauLength: UINT32,
pub sTau: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED {
fn clone(&self) -> Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED {
fn default() -> Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_PSEUDONYM_ENCRYPTED = Struct_tdTSS_DAA_PSEUDONYM_ENCRYPTED;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_SIGN_CALLBACK {
pub versionInfo: TSS_VERSION,
pub challenge: TSS_HHASH,
pub payloadFlag: TSS_FLAG,
pub payloadLength: UINT32,
pub payload: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_SIGN_CALLBACK {
fn clone(&self) -> Struct_tdTSS_DAA_SIGN_CALLBACK { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_SIGN_CALLBACK {
fn default() -> Struct_tdTSS_DAA_SIGN_CALLBACK {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_SIGN_CALLBACK = Struct_tdTSS_DAA_SIGN_CALLBACK;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_SIGNATURE {
pub versionInfo: TSS_VERSION,
pub zetaLength: UINT32,
pub zeta: *mut BYTE,
pub capitalTLength: UINT32,
pub capitalT: *mut BYTE,
pub challengeLength: UINT32,
pub challenge: *mut BYTE,
pub nonceTpmLength: UINT32,
pub nonceTpm: *mut BYTE,
pub sVLength: UINT32,
pub sV: *mut BYTE,
pub sF0Length: UINT32,
pub sF0: *mut BYTE,
pub sF1Length: UINT32,
pub sF1: *mut BYTE,
pub sELength: UINT32,
pub sE: *mut BYTE,
pub sALength: UINT32,
pub sALength2: UINT32,
pub sA: *mut *mut BYTE,
pub attributeCommitmentsLength: UINT32,
pub attributeCommitments: *mut TSS_DAA_ATTRIB_COMMIT,
pub signedPseudonym: TSS_DAA_PSEUDONYM,
pub callbackResult: TSS_DAA_SIGN_CALLBACK,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_SIGNATURE {
fn clone(&self) -> Struct_tdTSS_DAA_SIGNATURE { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_SIGNATURE {
fn default() -> Struct_tdTSS_DAA_SIGNATURE {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_SIGNATURE = Struct_tdTSS_DAA_SIGNATURE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DAA_IDENTITY_PROOF {
pub versionInfo: TSS_VERSION,
pub endorsementLength: UINT32,
pub endorsementCredential: *mut BYTE,
pub platformLength: UINT32,
pub platform: *mut BYTE,
pub conformanceLength: UINT32,
pub conformance: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_DAA_IDENTITY_PROOF {
fn clone(&self) -> Struct_tdTSS_DAA_IDENTITY_PROOF { *self }
}
impl ::std::default::Default for Struct_tdTSS_DAA_IDENTITY_PROOF {
fn default() -> Struct_tdTSS_DAA_IDENTITY_PROOF {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DAA_IDENTITY_PROOF = Struct_tdTSS_DAA_IDENTITY_PROOF;
pub type TSS_FAMILY_ID = UINT32;
pub type TSS_DELEGATION_LABEL = BYTE;
pub type TSS_DELEGATION_TYPE = UINT32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_PCR_INFO_SHORT {
pub sizeOfSelect: UINT32,
pub selection: *mut BYTE,
pub localityAtRelease: BYTE,
pub sizeOfDigestAtRelease: UINT32,
pub digestAtRelease: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_PCR_INFO_SHORT {
fn clone(&self) -> Struct_tdTSS_PCR_INFO_SHORT { *self }
}
impl ::std::default::Default for Struct_tdTSS_PCR_INFO_SHORT {
fn default() -> Struct_tdTSS_PCR_INFO_SHORT {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_PCR_INFO_SHORT = Struct_tdTSS_PCR_INFO_SHORT;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_FAMILY_TABLE_ENTRY {
pub familyID: TSS_FAMILY_ID,
pub label: TSS_DELEGATION_LABEL,
pub verificationCount: UINT32,
pub enabled: TSS_BOOL,
pub locked: TSS_BOOL,
}
impl ::std::clone::Clone for Struct_tdTSS_FAMILY_TABLE_ENTRY {
fn clone(&self) -> Struct_tdTSS_FAMILY_TABLE_ENTRY { *self }
}
impl ::std::default::Default for Struct_tdTSS_FAMILY_TABLE_ENTRY {
fn default() -> Struct_tdTSS_FAMILY_TABLE_ENTRY {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_FAMILY_TABLE_ENTRY = Struct_tdTSS_FAMILY_TABLE_ENTRY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_DELEGATION_TABLE_ENTRY {
pub tableIndex: UINT32,
pub label: TSS_DELEGATION_LABEL,
pub pcrInfo: TSS_PCR_INFO_SHORT,
pub per1: UINT32,
pub per2: UINT32,
pub familyID: TSS_FAMILY_ID,
pub verificationCount: UINT32,
}
impl ::std::clone::Clone for Struct_tdTSS_DELEGATION_TABLE_ENTRY {
fn clone(&self) -> Struct_tdTSS_DELEGATION_TABLE_ENTRY { *self }
}
impl ::std::default::Default for Struct_tdTSS_DELEGATION_TABLE_ENTRY {
fn default() -> Struct_tdTSS_DELEGATION_TABLE_ENTRY {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_DELEGATION_TABLE_ENTRY = Struct_tdTSS_DELEGATION_TABLE_ENTRY;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tdTSS_PLATFORM_CLASS {
pub platformClassSimpleIdentifier: UINT32,
pub platformClassURISize: UINT32,
pub pPlatformClassURI: *mut BYTE,
}
impl ::std::clone::Clone for Struct_tdTSS_PLATFORM_CLASS {
fn clone(&self) -> Struct_tdTSS_PLATFORM_CLASS { *self }
}
impl ::std::default::Default for Struct_tdTSS_PLATFORM_CLASS {
fn default() -> Struct_tdTSS_PLATFORM_CLASS {
unsafe { ::std::mem::zeroed() }
}
}
pub type TSS_PLATFORM_CLASS = Struct_tdTSS_PLATFORM_CLASS;
pub type Tspicb_CallbackHMACAuth =
::std::option::Option<extern "C" fn(lpAppData: PVOID,
hAuthorizedObject: TSS_HOBJECT,
ReturnOrVerify: TSS_BOOL,
ulPendingFunction: UINT32,
ContinueUse: TSS_BOOL,
ulSizeNonces: UINT32,
rgbNonceEven: *mut BYTE,
rgbNonceOdd: *mut BYTE,
rgbNonceEvenOSAP: *mut BYTE,
rgbNonceOddOSAP: *mut BYTE,
ulSizeDigestHmac: UINT32,
rgbParamDigest: *mut BYTE,
rgbHmacData: *mut BYTE)
-> TSS_RESULT>;
pub type Tspicb_CallbackXorEnc =
::std::option::Option<extern "C" fn(lpAppData: PVOID,
hOSAPObject: TSS_HOBJECT,
hObject: TSS_HOBJECT,
PurposeSecret: TSS_FLAG,
ulSizeNonces: UINT32,
rgbNonceEven: *mut BYTE,
rgbNonceOdd: *mut BYTE,
rgbNonceEvenOSAP: *mut BYTE,
rgbNonceOddOSAP: *mut BYTE,
ulSizeEncAuth: UINT32,
rgbEncAuthUsage: *mut BYTE,
rgbEncAuthMigration: *mut BYTE)
-> TSS_RESULT>;
pub type Tspicb_CallbackTakeOwnership =
::std::option::Option<extern "C" fn(lpAppData: PVOID,
hObject: TSS_HOBJECT,
hObjectPubKey: TSS_HKEY,
ulSizeEncAuth: UINT32,
rgbEncAuth: *mut BYTE) -> TSS_RESULT>;
pub type Tspicb_CallbackSealxMask =
::std::option::Option<extern "C" fn(lpAppData: PVOID, hKey: TSS_HKEY,
hEncData: TSS_HENCDATA,
algID: TSS_ALGORITHM_ID,
ulSizeNonces: UINT32,
rgbNonceEven: *mut BYTE,
rgbNonceOdd: *mut BYTE,
rgbNonceEvenOSAP: *mut BYTE,
rgbNonceOddOSAP: *mut BYTE,
ulDataLength: UINT32,
rgbDataToMask: *mut BYTE,
rgbMaskedData: *mut BYTE)
-> TSS_RESULT>;
pub type Tspicb_CallbackChangeAuthAsym =
::std::option::Option<extern "C" fn(lpAppData: PVOID,
hObject: TSS_HOBJECT,
hObjectPubKey: TSS_HKEY,
ulSizeEncAuth: UINT32,
ulSizeAuthLink: UINT32,
rgbEncAuth: *mut BYTE,
rgbAuthLink: *mut BYTE)
-> TSS_RESULT>;
pub type Tspicb_CollateIdentity =
::std::option::Option<extern "C" fn(lpAppData: PVOID,
ulTCPAPlainIdentityProofLength:
UINT32,
rgbTCPAPlainIdentityProof: *mut BYTE,
algID: TSS_ALGORITHM_ID,
ulSessionKeyLength: UINT32,
rgbSessionKey: *mut BYTE,
pulTCPAIdentityProofLength:
*mut UINT32,
rgbTCPAIdentityProof: *mut BYTE)
-> TSS_RESULT>;
pub type Tspicb_ActivateIdentity =
::std::option::Option<extern "C" fn(lpAppData: PVOID,
ulSessionKeyLength: UINT32,
rgbSessionKey: *mut BYTE,
ulSymCAAttestationBlobLength: UINT32,
rgbSymCAAttestationBlob: *mut BYTE,
pulCredentialLength: *mut UINT32,
rgbCredential: *mut BYTE)
-> TSS_RESULT>;
pub type Tspicb_DAA_Sign =
::std::option::Option<extern "C" fn(lpAppData: PVOID,
daaPublicKey: TSS_HDAA_ISSUER_KEY,
gammasLength: UINT32,
gammas: *mut *mut BYTE,
attributesLength: UINT32,
attributes: *mut *mut BYTE,
randomAttributesLength: UINT32,
randomAttributes: *mut *mut BYTE,
attributeCommitmentsLength: UINT32,
attributeCommitments:
*mut TSS_DAA_ATTRIB_COMMIT,
attributeCommitmentsProof:
*mut TSS_DAA_ATTRIB_COMMIT,
pseudonym:
*mut TSS_DAA_PSEUDONYM_PLAIN,
pseudonymTilde:
*mut TSS_DAA_PSEUDONYM_PLAIN,
pseudonymEncrypted:
*mut TSS_DAA_PSEUDONYM_ENCRYPTED,
pseudonymEncProof:
*mut TSS_DAA_PSEUDONYM_ENCRYPTED,
additionalProof:
*mut *mut TSS_DAA_SIGN_CALLBACK)
-> TSS_RESULT>;
pub type Tspicb_DAA_VerifySignature =
::std::option::Option<extern "C" fn(lpAppData: PVOID,
challengeLength: UINT32,
challenge: *mut BYTE,
additionalProof:
*mut TSS_DAA_SIGN_CALLBACK,
daaPublicKey: TSS_HDAA_ISSUER_KEY,
gammasLength: UINT32,
gammas: *mut *mut BYTE,
sAttributesLength: UINT32,
sAttributes: *mut *mut BYTE,
attributeCommitmentsLength: UINT32,
attributeCommitments:
*mut TSS_DAA_ATTRIB_COMMIT,
attributeCommitmentsProof:
*mut TSS_DAA_ATTRIB_COMMIT,
zetaLength: UINT32, zeta: *mut BYTE,
sFLength: UINT32, sF: *mut BYTE,
pseudonym: *mut TSS_DAA_PSEUDONYM,
pseudonymProof:
*mut TSS_DAA_PSEUDONYM,
isCorrect: *mut TSS_BOOL)
-> TSS_RESULT>;
#[link(name = "tspi")]
extern "C" {
pub fn Tspi_EncodeDER_TssBlob(rawBlobSize: UINT32, rawBlob: *mut BYTE,
blobType: UINT32, derBlobSize: *mut UINT32,
derBlob: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_DecodeBER_TssBlob(berBlobSize: UINT32, berBlob: *mut BYTE,
blobType: *mut UINT32,
rawBlobSize: *mut UINT32,
rawBlob: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_SetAttribUint32(hObject: TSS_HOBJECT, attribFlag: TSS_FLAG,
subFlag: TSS_FLAG, ulAttrib: UINT32)
-> TSS_RESULT;
pub fn Tspi_GetAttribUint32(hObject: TSS_HOBJECT, attribFlag: TSS_FLAG,
subFlag: TSS_FLAG, pulAttrib: *mut UINT32)
-> TSS_RESULT;
pub fn Tspi_SetAttribData(hObject: TSS_HOBJECT, attribFlag: TSS_FLAG,
subFlag: TSS_FLAG, ulAttribDataSize: UINT32,
rgbAttribData: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_GetAttribData(hObject: TSS_HOBJECT, attribFlag: TSS_FLAG,
subFlag: TSS_FLAG,
pulAttribDataSize: *mut UINT32,
prgbAttribData: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_ChangeAuth(hObjectToChange: TSS_HOBJECT,
hParentObject: TSS_HOBJECT,
hNewPolicy: TSS_HPOLICY) -> TSS_RESULT;
pub fn Tspi_ChangeAuthAsym(hObjectToChange: TSS_HOBJECT,
hParentObject: TSS_HOBJECT,
hIdentKey: TSS_HKEY, hNewPolicy: TSS_HPOLICY)
-> TSS_RESULT;
pub fn Tspi_GetPolicyObject(hObject: TSS_HOBJECT, policyType: TSS_FLAG,
phPolicy: *mut TSS_HPOLICY) -> TSS_RESULT;
pub fn Tspi_Context_Create(phContext: *mut TSS_HCONTEXT) -> TSS_RESULT;
pub fn Tspi_Context_Close(hContext: TSS_HCONTEXT) -> TSS_RESULT;
pub fn Tspi_Context_Connect(hContext: TSS_HCONTEXT,
wszDestination: *mut TSS_UNICODE)
-> TSS_RESULT;
pub fn Tspi_Context_FreeMemory(hContext: TSS_HCONTEXT,
rgbMemory: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Context_GetDefaultPolicy(hContext: TSS_HCONTEXT,
phPolicy: *mut TSS_HPOLICY)
-> TSS_RESULT;
pub fn Tspi_Context_CreateObject(hContext: TSS_HCONTEXT,
objectType: TSS_FLAG,
initFlags: TSS_FLAG,
phObject: *mut TSS_HOBJECT)
-> TSS_RESULT;
pub fn Tspi_Context_CloseObject(hContext: TSS_HCONTEXT,
hObject: TSS_HOBJECT) -> TSS_RESULT;
pub fn Tspi_Context_GetCapability(hContext: TSS_HCONTEXT,
capArea: TSS_FLAG,
ulSubCapLength: UINT32,
rgbSubCap: *mut BYTE,
pulRespDataLength: *mut UINT32,
prgbRespData: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_Context_GetTpmObject(hContext: TSS_HCONTEXT,
phTPM: *mut TSS_HTPM) -> TSS_RESULT;
pub fn Tspi_Context_SetTransEncryptionKey(hContext: TSS_HCONTEXT,
hKey: TSS_HKEY) -> TSS_RESULT;
pub fn Tspi_Context_CloseSignTransport(hContext: TSS_HCONTEXT,
hSigningKey: TSS_HKEY,
pValidationData:
*mut TSS_VALIDATION)
-> TSS_RESULT;
pub fn Tspi_Context_LoadKeyByBlob(hContext: TSS_HCONTEXT,
hUnwrappingKey: TSS_HKEY,
ulBlobLength: UINT32,
rgbBlobData: *mut BYTE,
phKey: *mut TSS_HKEY) -> TSS_RESULT;
pub fn Tspi_Context_LoadKeyByUUID(hContext: TSS_HCONTEXT,
persistentStorageType: TSS_FLAG,
uuidData: TSS_UUID,
phKey: *mut TSS_HKEY) -> TSS_RESULT;
pub fn Tspi_Context_RegisterKey(hContext: TSS_HCONTEXT, hKey: TSS_HKEY,
persistentStorageType: TSS_FLAG,
uuidKey: TSS_UUID,
persistentStorageTypeParent: TSS_FLAG,
uuidParentKey: TSS_UUID) -> TSS_RESULT;
pub fn Tspi_Context_UnregisterKey(hContext: TSS_HCONTEXT,
persistentStorageType: TSS_FLAG,
uuidKey: TSS_UUID, phkey: *mut TSS_HKEY)
-> TSS_RESULT;
pub fn Tspi_Context_GetKeyByUUID(hContext: TSS_HCONTEXT,
persistentStorageType: TSS_FLAG,
uuidData: TSS_UUID, phKey: *mut TSS_HKEY)
-> TSS_RESULT;
pub fn Tspi_Context_GetKeyByPublicInfo(hContext: TSS_HCONTEXT,
persistentStorageType: TSS_FLAG,
algID: TSS_ALGORITHM_ID,
ulPublicInfoLength: UINT32,
rgbPublicInfo: *mut BYTE,
phKey: *mut TSS_HKEY)
-> TSS_RESULT;
pub fn Tspi_Context_GetRegisteredKeysByUUID(hContext: TSS_HCONTEXT,
persistentStorageType:
TSS_FLAG,
pUuidData: *mut TSS_UUID,
pulKeyHierarchySize:
*mut UINT32,
ppKeyHierarchy:
*mut *mut TSS_KM_KEYINFO)
-> TSS_RESULT;
pub fn Tspi_Context_GetRegisteredKeysByUUID2(hContext: TSS_HCONTEXT,
persistentStorageType:
TSS_FLAG,
pUuidData: *mut TSS_UUID,
pulKeyHierarchySize:
*mut UINT32,
ppKeyHierarchy:
*mut *mut TSS_KM_KEYINFO2)
-> TSS_RESULT;
pub fn Tspi_Policy_SetSecret(hPolicy: TSS_HPOLICY, secretMode: TSS_FLAG,
ulSecretLength: UINT32, rgbSecret: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_Policy_FlushSecret(hPolicy: TSS_HPOLICY) -> TSS_RESULT;
pub fn Tspi_Policy_AssignToObject(hPolicy: TSS_HPOLICY,
hObject: TSS_HOBJECT) -> TSS_RESULT;
pub fn Tspi_TPM_KeyControlOwner(hTPM: TSS_HTPM, hKey: TSS_HKEY,
attribName: UINT32, attribValue: TSS_BOOL,
pUuidData: *mut TSS_UUID) -> TSS_RESULT;
pub fn Tspi_TPM_CreateEndorsementKey(hTPM: TSS_HTPM, hKey: TSS_HKEY,
pValidationData: *mut TSS_VALIDATION)
-> TSS_RESULT;
pub fn Tspi_TPM_CreateRevocableEndorsementKey(hTPM: TSS_HTPM,
hKey: TSS_HKEY,
pValidationData:
*mut TSS_VALIDATION,
pulEkResetDataLength:
*mut UINT32,
rgbEkResetData:
*mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_RevokeEndorsementKey(hTPM: TSS_HTPM,
ulEkResetDataLength: UINT32,
rgbEkResetData: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_GetPubEndorsementKey(hTPM: TSS_HTPM,
fOwnerAuthorized: TSS_BOOL,
pValidationData: *mut TSS_VALIDATION,
phEndorsementPubKey: *mut TSS_HKEY)
-> TSS_RESULT;
pub fn Tspi_TPM_OwnerGetSRKPubKey(hTPM: TSS_HTPM,
pulPubKeyLength: *mut UINT32,
prgbPubKey: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_TakeOwnership(hTPM: TSS_HTPM, hKeySRK: TSS_HKEY,
hEndorsementPubKey: TSS_HKEY) -> TSS_RESULT;
pub fn Tspi_TPM_ClearOwner(hTPM: TSS_HTPM, fForcedClear: TSS_BOOL)
-> TSS_RESULT;
pub fn Tspi_TPM_CollateIdentityRequest(hTPM: TSS_HTPM, hKeySRK: TSS_HKEY,
hCAPubKey: TSS_HKEY,
ulIdentityLabelLength: UINT32,
rgbIdentityLabelData: *mut BYTE,
hIdentityKey: TSS_HKEY,
algID: TSS_ALGORITHM_ID,
pulTCPAIdentityReqLength:
*mut UINT32,
prgbTCPAIdentityReq:
*mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_ActivateIdentity(hTPM: TSS_HTPM, hIdentKey: TSS_HKEY,
ulAsymCAContentsBlobLength: UINT32,
rgbAsymCAContentsBlob: *mut BYTE,
ulSymCAAttestationBlobLength: UINT32,
rgbSymCAAttestationBlob: *mut BYTE,
pulCredentialLength: *mut UINT32,
prgbCredential: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_CreateMaintenanceArchive(hTPM: TSS_HTPM,
fGenerateRndNumber: TSS_BOOL,
pulRndNumberLength: *mut UINT32,
prgbRndNumber: *mut *mut BYTE,
pulArchiveDataLength:
*mut UINT32,
prgbArchiveData: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_KillMaintenanceFeature(hTPM: TSS_HTPM) -> TSS_RESULT;
pub fn Tspi_TPM_LoadMaintenancePubKey(hTPM: TSS_HTPM,
hMaintenanceKey: TSS_HKEY,
pValidationData:
*mut TSS_VALIDATION)
-> TSS_RESULT;
pub fn Tspi_TPM_CheckMaintenancePubKey(hTPM: TSS_HTPM,
hMaintenanceKey: TSS_HKEY,
pValidationData:
*mut TSS_VALIDATION)
-> TSS_RESULT;
pub fn Tspi_TPM_SetOperatorAuth(hTPM: TSS_HTPM,
hOperatorPolicy: TSS_HPOLICY)
-> TSS_RESULT;
pub fn Tspi_TPM_SetStatus(hTPM: TSS_HTPM, statusFlag: TSS_FLAG,
fTpmState: TSS_BOOL) -> TSS_RESULT;
pub fn Tspi_TPM_GetStatus(hTPM: TSS_HTPM, statusFlag: TSS_FLAG,
pfTpmState: *mut TSS_BOOL) -> TSS_RESULT;
pub fn Tspi_TPM_GetCapability(hTPM: TSS_HTPM, capArea: TSS_FLAG,
ulSubCapLength: UINT32,
rgbSubCap: *mut BYTE,
pulRespDataLength: *mut UINT32,
prgbRespData: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_GetCapabilitySigned(hTPM: TSS_HTPM, hKey: TSS_HKEY,
capArea: TSS_FLAG,
ulSubCapLength: UINT32,
rgbSubCap: *mut BYTE,
pValidationData: *mut TSS_VALIDATION,
pulRespDataLength: *mut UINT32,
prgbRespData: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_SelfTestFull(hTPM: TSS_HTPM) -> TSS_RESULT;
pub fn Tspi_TPM_CertifySelfTest(hTPM: TSS_HTPM, hKey: TSS_HKEY,
pValidationData: *mut TSS_VALIDATION)
-> TSS_RESULT;
pub fn Tspi_TPM_GetTestResult(hTPM: TSS_HTPM,
pulTestResultLength: *mut UINT32,
prgbTestResult: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_GetRandom(hTPM: TSS_HTPM, ulRandomDataLength: UINT32,
prgbRandomData: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_StirRandom(hTPM: TSS_HTPM, ulEntropyDataLength: UINT32,
rgbEntropyData: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_GetEvent(hTPM: TSS_HTPM, ulPcrIndex: UINT32,
ulEventNumber: UINT32,
pPcrEvent: *mut TSS_PCR_EVENT) -> TSS_RESULT;
pub fn Tspi_TPM_GetEvents(hTPM: TSS_HTPM, ulPcrIndex: UINT32,
ulStartNumber: UINT32,
pulEventNumber: *mut UINT32,
prgPcrEvents: *mut *mut TSS_PCR_EVENT)
-> TSS_RESULT;
pub fn Tspi_TPM_GetEventLog(hTPM: TSS_HTPM, pulEventNumber: *mut UINT32,
prgPcrEvents: *mut *mut TSS_PCR_EVENT)
-> TSS_RESULT;
pub fn Tspi_TPM_Quote(hTPM: TSS_HTPM, hIdentKey: TSS_HKEY,
hPcrComposite: TSS_HPCRS,
pValidationData: *mut TSS_VALIDATION) -> TSS_RESULT;
pub fn Tspi_TPM_Quote2(hTPM: TSS_HTPM, hIdentKey: TSS_HKEY,
fAddVersion: TSS_BOOL, hPcrComposite: TSS_HPCRS,
pValidationData: *mut TSS_VALIDATION,
versionInfoSize: *mut UINT32,
versionInfo: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_PcrExtend(hTPM: TSS_HTPM, ulPcrIndex: UINT32,
ulPcrDataLength: UINT32, pbPcrData: *mut BYTE,
pPcrEvent: *mut TSS_PCR_EVENT,
pulPcrValueLength: *mut UINT32,
prgbPcrValue: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_PcrRead(hTPM: TSS_HTPM, ulPcrIndex: UINT32,
pulPcrValueLength: *mut UINT32,
prgbPcrValue: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_PcrReset(hTPM: TSS_HTPM, hPcrComposite: TSS_HPCRS)
-> TSS_RESULT;
pub fn Tspi_TPM_AuthorizeMigrationTicket(hTPM: TSS_HTPM,
hMigrationKey: TSS_HKEY,
migrationScheme:
TSS_MIGRATE_SCHEME,
pulMigTicketLength: *mut UINT32,
prgbMigTicket: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_CMKSetRestrictions(hTPM: TSS_HTPM,
CmkDelegate: TSS_CMK_DELEGATE)
-> TSS_RESULT;
pub fn Tspi_TPM_CMKApproveMA(hTPM: TSS_HTPM, hMaAuthData: TSS_HMIGDATA)
-> TSS_RESULT;
pub fn Tspi_TPM_CMKCreateTicket(hTPM: TSS_HTPM, hVerifyKey: TSS_HKEY,
hSigData: TSS_HMIGDATA) -> TSS_RESULT;
pub fn Tspi_TPM_ReadCounter(hTPM: TSS_HTPM, counterValue: *mut UINT32)
-> TSS_RESULT;
pub fn Tspi_TPM_ReadCurrentTicks(hTPM: TSS_HTPM,
tickCount: *mut TPM_CURRENT_TICKS)
-> TSS_RESULT;
pub fn Tspi_TPM_DirWrite(hTPM: TSS_HTPM, ulDirIndex: UINT32,
ulDirDataLength: UINT32, rgbDirData: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_DirRead(hTPM: TSS_HTPM, ulDirIndex: UINT32,
pulDirDataLength: *mut UINT32,
prgbDirData: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_Delegate_AddFamily(hTPM: TSS_HTPM, bLabel: BYTE,
phFamily: *mut TSS_HDELFAMILY)
-> TSS_RESULT;
pub fn Tspi_TPM_Delegate_GetFamily(hTPM: TSS_HTPM, ulFamilyID: UINT32,
phFamily: *mut TSS_HDELFAMILY)
-> TSS_RESULT;
pub fn Tspi_TPM_Delegate_InvalidateFamily(hTPM: TSS_HTPM,
hFamily: TSS_HDELFAMILY)
-> TSS_RESULT;
pub fn Tspi_TPM_Delegate_CreateDelegation(hObject: TSS_HOBJECT,
bLabel: BYTE, ulFlags: UINT32,
hPcr: TSS_HPCRS,
hFamily: TSS_HDELFAMILY,
hDelegation: TSS_HPOLICY)
-> TSS_RESULT;
pub fn Tspi_TPM_Delegate_CacheOwnerDelegation(hTPM: TSS_HTPM,
hDelegation: TSS_HPOLICY,
ulIndex: UINT32,
ulFlags: UINT32)
-> TSS_RESULT;
pub fn Tspi_TPM_Delegate_UpdateVerificationCount(hTPM: TSS_HTPM,
hDelegation: TSS_HPOLICY)
-> TSS_RESULT;
pub fn Tspi_TPM_Delegate_VerifyDelegation(hDelegation: TSS_HPOLICY)
-> TSS_RESULT;
pub fn Tspi_TPM_Delegate_ReadTables(hContext: TSS_HCONTEXT,
pulFamilyTableSize: *mut UINT32,
ppFamilyTable:
*mut *mut TSS_FAMILY_TABLE_ENTRY,
pulDelegateTableSize: *mut UINT32,
ppDelegateTable:
*mut *mut TSS_DELEGATION_TABLE_ENTRY)
-> TSS_RESULT;
pub fn Tspi_TPM_DAA_JoinInit(hTPM: TSS_HTPM,
hIssuerKey: TSS_HDAA_ISSUER_KEY,
daaCounter: UINT32,
issuerAuthPKsLength: UINT32,
issuerAuthPKs: *mut TSS_HKEY,
issuerAuthPKSignaturesLength: UINT32,
issuerAuthPKSignaturesLength2: UINT32,
issuerAuthPKSignatures: *mut *mut BYTE,
capitalUprimeLength: *mut UINT32,
capitalUprime: *mut *mut BYTE,
identityProof:
*mut *mut TSS_DAA_IDENTITY_PROOF,
joinSessionLength: *mut UINT32,
joinSession: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_TPM_DAA_JoinCreateDaaPubKey(hTPM: TSS_HTPM,
hDAACredential:
TSS_HDAA_CREDENTIAL,
authenticationChallengeLength:
UINT32,
authenticationChallenge:
*mut BYTE,
nonceIssuerLength: UINT32,
nonceIssuer: *mut BYTE,
attributesPlatformLength: UINT32,
attributesPlatformLength2: UINT32,
attributesPlatform:
*mut *mut BYTE,
joinSessionLength: UINT32,
joinSession: *mut BYTE,
credentialRequest:
*mut *mut TSS_DAA_CREDENTIAL_REQUEST)
-> TSS_RESULT;
pub fn Tspi_TPM_DAA_JoinStoreCredential(hTPM: TSS_HTPM,
hDAACredential:
TSS_HDAA_CREDENTIAL,
credIssuer:
*mut TSS_DAA_CRED_ISSUER,
joinSessionLength: UINT32,
joinSession: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_TPM_DAA_Sign(hTPM: TSS_HTPM,
hDAACredential: TSS_HDAA_CREDENTIAL,
hARAKey: TSS_HDAA_ARA_KEY,
revealAttributes: *mut TSS_DAA_SELECTED_ATTRIB,
verifierNonceLength: UINT32,
verifierNonce: *mut BYTE,
verifierBaseNameLength: UINT32,
verifierBaseName: *mut BYTE,
signData: TSS_HOBJECT,
daaSignature: *mut *mut TSS_DAA_SIGNATURE)
-> TSS_RESULT;
pub fn Tspi_TPM_GetAuditDigest(hTPM: TSS_HTPM, hKey: TSS_HKEY,
closeAudit: TSS_BOOL,
pulAuditDigestSize: *mut UINT32,
prgbAuditDigest: *mut *mut BYTE,
pCounterValue: *mut TPM_COUNTER_VALUE,
pValidationData: *mut TSS_VALIDATION,
ordSize: *mut UINT32,
ordList: *mut *mut UINT32) -> TSS_RESULT;
pub fn Tspi_PcrComposite_SelectPcrIndex(hPcrComposite: TSS_HPCRS,
ulPcrIndex: UINT32) -> TSS_RESULT;
pub fn Tspi_PcrComposite_SelectPcrIndexEx(hPcrComposite: TSS_HPCRS,
ulPcrIndex: UINT32,
direction: UINT32)
-> TSS_RESULT;
pub fn Tspi_PcrComposite_SetPcrValue(hPcrComposite: TSS_HPCRS,
ulPcrIndex: UINT32,
ulPcrValueLength: UINT32,
rgbPcrValue: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_PcrComposite_GetPcrValue(hPcrComposite: TSS_HPCRS,
ulPcrIndex: UINT32,
pulPcrValueLength: *mut UINT32,
prgbPcrValue: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_PcrComposite_SetPcrLocality(hPcrComposite: TSS_HPCRS,
LocalityValue: UINT32)
-> TSS_RESULT;
pub fn Tspi_PcrComposite_GetPcrLocality(hPcrComposite: TSS_HPCRS,
pLocalityValue: *mut UINT32)
-> TSS_RESULT;
pub fn Tspi_PcrComposite_GetCompositeHash(hPcrComposite: TSS_HPCRS,
pLen: *mut UINT32,
ppbHashData: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_Key_LoadKey(hKey: TSS_HKEY, hUnwrappingKey: TSS_HKEY)
-> TSS_RESULT;
pub fn Tspi_Key_UnloadKey(hKey: TSS_HKEY) -> TSS_RESULT;
pub fn Tspi_Key_GetPubKey(hKey: TSS_HKEY, pulPubKeyLength: *mut UINT32,
prgbPubKey: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Key_CertifyKey(hKey: TSS_HKEY, hCertifyingKey: TSS_HKEY,
pValidationData: *mut TSS_VALIDATION)
-> TSS_RESULT;
pub fn Tspi_Key_CreateKey(hKey: TSS_HKEY, hWrappingKey: TSS_HKEY,
hPcrComposite: TSS_HPCRS) -> TSS_RESULT;
pub fn Tspi_Key_WrapKey(hKey: TSS_HKEY, hWrappingKey: TSS_HKEY,
hPcrComposite: TSS_HPCRS) -> TSS_RESULT;
pub fn Tspi_Key_CreateMigrationBlob(hKeyToMigrate: TSS_HKEY,
hParentKey: TSS_HKEY,
ulMigTicketLength: UINT32,
rgbMigTicket: *mut BYTE,
pulRandomLength: *mut UINT32,
prgbRandom: *mut *mut BYTE,
pulMigrationBlobLength: *mut UINT32,
prgbMigrationBlob: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_Key_ConvertMigrationBlob(hKeyToMigrate: TSS_HKEY,
hParentKey: TSS_HKEY,
ulRandomLength: UINT32,
rgbRandom: *mut BYTE,
ulMigrationBlobLength: UINT32,
rgbMigrationBlob: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_Key_MigrateKey(hMaKey: TSS_HKEY, hPublicKey: TSS_HKEY,
hMigData: TSS_HKEY) -> TSS_RESULT;
pub fn Tspi_Key_CMKCreateBlob(hKeyToMigrate: TSS_HKEY,
hParentKey: TSS_HKEY,
hMigrationData: TSS_HMIGDATA,
pulRandomLength: *mut UINT32,
prgbRandom: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Key_CMKConvertMigration(hKeyToMigrate: TSS_HKEY,
hParentKey: TSS_HKEY,
hMigrationData: TSS_HMIGDATA,
ulRandomLength: UINT32,
rgbRandom: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Hash_Sign(hHash: TSS_HHASH, hKey: TSS_HKEY,
pulSignatureLength: *mut UINT32,
prgbSignature: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Hash_VerifySignature(hHash: TSS_HHASH, hKey: TSS_HKEY,
ulSignatureLength: UINT32,
rgbSignature: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Hash_SetHashValue(hHash: TSS_HHASH, ulHashValueLength: UINT32,
rgbHashValue: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Hash_GetHashValue(hHash: TSS_HHASH,
pulHashValueLength: *mut UINT32,
prgbHashValue: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_Hash_UpdateHashValue(hHash: TSS_HHASH, ulDataLength: UINT32,
rgbData: *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Hash_TickStampBlob(hHash: TSS_HHASH, hIdentKey: TSS_HKEY,
pValidationData: *mut TSS_VALIDATION)
-> TSS_RESULT;
pub fn Tspi_Data_Bind(hEncData: TSS_HENCDATA, hEncKey: TSS_HKEY,
ulDataLength: UINT32, rgbDataToBind: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_Data_Unbind(hEncData: TSS_HENCDATA, hKey: TSS_HKEY,
pulUnboundDataLength: *mut UINT32,
prgbUnboundData: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_Data_Seal(hEncData: TSS_HENCDATA, hEncKey: TSS_HKEY,
ulDataLength: UINT32, rgbDataToSeal: *mut BYTE,
hPcrComposite: TSS_HPCRS) -> TSS_RESULT;
pub fn Tspi_Data_Unseal(hEncData: TSS_HENCDATA, hKey: TSS_HKEY,
pulUnsealedDataLength: *mut UINT32,
prgbUnsealedData: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_NV_DefineSpace(hNVStore: TSS_HNVSTORE,
hReadPcrComposite: TSS_HPCRS,
hWritePcrComposite: TSS_HPCRS) -> TSS_RESULT;
pub fn Tspi_NV_ReleaseSpace(hNVStore: TSS_HNVSTORE) -> TSS_RESULT;
pub fn Tspi_NV_WriteValue(hNVStore: TSS_HNVSTORE, offset: UINT32,
ulDataLength: UINT32, rgbDataToWrite: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_NV_ReadValue(hNVStore: TSS_HNVSTORE, offset: UINT32,
ulDataLength: *mut UINT32,
rgbDataRead: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_DAA_IssuerKeyVerify(hDAACredential: TSS_HDAA_CREDENTIAL,
hIssuerKey: TSS_HDAA_ISSUER_KEY,
isCorrect: *mut TSS_BOOL) -> TSS_RESULT;
pub fn Tspi_DAA_Issuer_GenerateKey(hIssuerKey: TSS_HDAA_ISSUER_KEY,
issuerBaseNameLength: UINT32,
issuerBaseName: *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_DAA_Issuer_InitCredential(hIssuerKey: TSS_HDAA_ISSUER_KEY,
issuerAuthPK: TSS_HKEY,
identityProof:
*mut TSS_DAA_IDENTITY_PROOF,
capitalUprimeLength: UINT32,
capitalUprime: *mut BYTE,
daaCounter: UINT32,
nonceIssuerLength: *mut UINT32,
nonceIssuer: *mut *mut BYTE,
authenticationChallengeLength:
*mut UINT32,
authenticationChallenge:
*mut *mut BYTE,
joinSessionLength: *mut UINT32,
joinSession: *mut *mut BYTE)
-> TSS_RESULT;
pub fn Tspi_DAA_Issuer_IssueCredential(hIssuerKey: TSS_HDAA_ISSUER_KEY,
credentialRequest:
*mut TSS_DAA_CREDENTIAL_REQUEST,
issuerJoinSessionLength: UINT32,
issuerJoinSession: *mut BYTE,
credIssuer:
*mut *mut TSS_DAA_CRED_ISSUER)
-> TSS_RESULT;
pub fn Tspi_DAA_Verifier_Init(hDAACredential: TSS_HDAA_CREDENTIAL,
nonceVerifierLength: *mut UINT32,
nonceVerifier: *mut *mut BYTE,
baseNameLength: *mut UINT32,
baseName: *mut *mut BYTE) -> TSS_RESULT;
pub fn Tspi_DAA_VerifySignature(hDAACredential: TSS_HDAA_CREDENTIAL,
hIssuerKey: TSS_HDAA_ISSUER_KEY,
hARAKey: TSS_HDAA_ARA_KEY,
hARACondition: TSS_HHASH,
attributesLength: UINT32,
attributesLength2: UINT32,
attributes: *mut *mut BYTE,
verifierNonceLength: UINT32,
verifierNonce: *mut BYTE,
verifierBaseNameLength: UINT32,
verifierBaseName: *mut BYTE,
signData: TSS_HOBJECT,
daaSignature: *mut TSS_DAA_SIGNATURE,
isCorrect: *mut TSS_BOOL) -> TSS_RESULT;
pub fn Tspi_DAA_ARA_GenerateKey(hIssuerKey: TSS_HDAA_ISSUER_KEY,
hARAKey: TSS_HDAA_ARA_KEY) -> TSS_RESULT;
pub fn Tspi_DAA_ARA_RevokeAnonymity(hARAKey: TSS_HDAA_ARA_KEY,
hARACondition: TSS_HHASH,
hIssuerKey: TSS_HDAA_ISSUER_KEY,
encryptedPseudonym:
*mut TSS_DAA_PSEUDONYM_ENCRYPTED,
pseudonym:
*mut *mut TSS_DAA_PSEUDONYM_PLAIN)
-> TSS_RESULT;
}