libcros 0.2.0

A Rust library that provides easy-to-use functions for interacting with a Chrome device
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

#![allow(non_snake_case, dead_code)]
#[cfg(feature = "tpm2_0")]
use std::fmt;
use std::mem::ManuallyDrop;

use crate::structs::{TPM2B, Tpm2SessionHeader, Tpm2TpmHeader};

#[derive(Debug)]
pub struct NvReadResponse {
  pub params_size: u32,
  pub buffer: TPM2B,
}

#[derive(Debug)]
pub struct TpmsTaggedProperty {
  pub property: u32,
  pub value: u32,
}

#[derive(Debug)]
pub struct TpmlTaggedTpmProperty {
  pub count: u32,
  pub tpm_property: [TpmsTaggedProperty; 1],
}

pub union TpmuCapabilities {
  pub tpm_properties: ManuallyDrop<TpmlTaggedTpmProperty>,
}

impl fmt::Debug for TpmuCapabilities {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    unsafe {
      f.debug_struct("TpmuCapabilities")
        .field("tpm_properties", &self.tpm_properties)
        .finish()
    }
  }
}

#[derive(Debug)]
pub struct TpmsCapabilityData {
  pub capability: u32,
  pub data: TpmuCapabilities,
}

#[derive(Debug)]
pub struct GetCapabilityResponse {
  pub more_data: u8,
  pub capability_data: TpmsCapabilityData,
}

#[derive(Debug)]
pub struct GetRandomResponse {
  pub random_bytes: TPM2B,
}

#[derive(Debug)]
pub struct TpmsNvPublic {
  pub nvIndex: u32,
  pub nameAlg: u16,
  pub attributes: u32,
  pub authPolicy: TPM2B,
  pub dataSize: u16,
}

#[derive(Debug)]
pub struct NvReadPublicResponse {
  pub nvPublic: TpmsNvPublic,
  pub nvName: TPM2B,
}

#[derive(Debug)]
pub struct ReadPublicResponse {
  pub buffer: TPM2B,
}

#[derive(Debug)]
pub struct CreatePrimaryResponse {
  pub object_handle: u32,
}

pub union Tpm2ResponseData {
  pub nvr: ManuallyDrop<NvReadResponse>,
  pub def_space: ManuallyDrop<Tpm2SessionHeader>,
  pub cap: ManuallyDrop<GetCapabilityResponse>,
  pub random: ManuallyDrop<GetRandomResponse>,
  pub nv_read_public: ManuallyDrop<NvReadPublicResponse>,
  pub read_pub: ManuallyDrop<ReadPublicResponse>,
  pub create_primary: ManuallyDrop<CreatePrimaryResponse>,
}

impl fmt::Debug for Tpm2ResponseData {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    unsafe {
      f.debug_struct("Tpm2ResponseData")
        .field("nvr", &self.nvr)
        .field("def_space", &self.def_space)
        .field("cap", &self.cap)
        .field("random", &self.random)
        .field("nv_read_public", &self.nv_read_public)
        .field("read_pub", &self.read_pub)
        .field("create_primary", &self.create_primary)
        .finish()
    }
  }
}

#[derive(Debug)]
pub struct Tpm2Response {
  pub hdr: Tpm2TpmHeader,
  pub data: Tpm2ResponseData,
}