1use crate::{Error, ErrorKind, Result, tee_check};
19use crate::{Identity, Uuid};
20use alloc::{ffi::CString, string::String, vec::Vec};
21use optee_utee_sys as raw;
22
23pub enum PropertySet {
28 TeeImplementation,
29 CurrentClient,
30 CurrentTa,
31}
32
33impl PropertySet {
34 fn as_raw(&self) -> raw::TEE_PropSetHandle {
35 match self {
36 PropertySet::TeeImplementation => raw::TEE_PROPSET_TEE_IMPLEMENTATION,
37 PropertySet::CurrentClient => raw::TEE_PROPSET_CURRENT_CLIENT,
38 PropertySet::CurrentTa => raw::TEE_PROPSET_CURRENT_TA,
39 }
40 }
41}
42
43pub trait PropertyValue: Sized {
49 unsafe fn from_raw(set: raw::TEE_PropSetHandle, key: CString) -> Result<Self>;
54}
55
56impl PropertyValue for String {
59 unsafe fn from_raw(set: raw::TEE_PropSetHandle, key: CString) -> Result<Self> {
60 let mut out_size = 0;
61
62 let res = unsafe {
65 raw::TEE_GetPropertyAsString(
66 set,
67 key.as_ptr() as *const _,
68 core::ptr::null_mut(),
69 &mut out_size,
70 )
71 };
72 match res {
73 raw::TEE_SUCCESS => {
74 if out_size == 0 {
75 Ok(String::new())
77 } else {
78 Err(Error::new(ErrorKind::Generic))
79 }
80 }
81 raw::TEE_ERROR_SHORT_BUFFER => {
82 let mut out_buffer = vec![0; out_size];
84 let res = unsafe {
85 raw::TEE_GetPropertyAsString(
86 set,
87 key.as_ptr() as *const _,
88 out_buffer.as_mut_ptr() as *mut _,
89 &mut out_size,
90 )
91 };
92 tee_check(res)?;
93
94 let c_str = core::ffi::CStr::from_bytes_with_nul(&out_buffer)
96 .map_err(|_| Error::new(ErrorKind::BadFormat))?;
97 let result = c_str.to_string_lossy().into_owned();
99
100 Ok(result)
101 }
102 _ => Err(Error::from_raw_error(res)),
103 }
104 }
105}
106
107impl PropertyValue for bool {
108 unsafe fn from_raw(set: raw::TEE_PropSetHandle, key: CString) -> Result<Self> {
109 let mut b: bool = false;
110
111 let res = unsafe { raw::TEE_GetPropertyAsBool(set, key.as_ptr() as *const _, &mut b) };
112 tee_check(res)?;
113
114 Ok(b)
115 }
116}
117
118impl PropertyValue for u32 {
119 unsafe fn from_raw(set: raw::TEE_PropSetHandle, key: CString) -> Result<Self> {
120 let mut value = 0;
121
122 let res = unsafe { raw::TEE_GetPropertyAsU32(set, key.as_ptr() as *const _, &mut value) };
123 tee_check(res)?;
124
125 Ok(value)
126 }
127}
128
129impl PropertyValue for u64 {
130 unsafe fn from_raw(set: raw::TEE_PropSetHandle, key: CString) -> Result<Self> {
131 let mut value = 0;
132
133 let res = unsafe { raw::TEE_GetPropertyAsU64(set, key.as_ptr() as *const _, &mut value) };
134 tee_check(res)?;
135
136 Ok(value)
137 }
138}
139
140impl PropertyValue for Vec<u8> {
141 unsafe fn from_raw(set: raw::TEE_PropSetHandle, key: CString) -> Result<Self> {
142 let mut out_size = 0;
143
144 let res = unsafe {
147 raw::TEE_GetPropertyAsBinaryBlock(
148 set,
149 key.as_ptr() as *const _,
150 core::ptr::null_mut(),
151 &mut out_size,
152 )
153 };
154
155 match res {
156 raw::TEE_SUCCESS => {
157 if out_size == 0 {
158 Ok(vec![])
160 } else {
161 Err(Error::new(ErrorKind::Generic))
162 }
163 }
164 raw::TEE_ERROR_SHORT_BUFFER => {
165 let mut buf = vec![0; out_size];
166
167 let res = unsafe {
168 raw::TEE_GetPropertyAsBinaryBlock(
169 set,
170 key.as_ptr() as *const _,
171 buf.as_mut_ptr() as *mut _,
172 &mut out_size,
173 )
174 };
175 tee_check(res)?;
176 Ok(buf)
177 }
178 _ => Err(Error::from_raw_error(res)),
179 }
180 }
181}
182
183impl PropertyValue for Uuid {
184 unsafe fn from_raw(set: raw::TEE_PropSetHandle, key: CString) -> Result<Self> {
185 let mut raw_uuid = raw::TEE_UUID {
186 timeLow: 0,
187 timeMid: 0,
188 timeHiAndVersion: 0,
189 clockSeqAndNode: [0; 8],
190 };
191
192 let res =
193 unsafe { raw::TEE_GetPropertyAsUUID(set, key.as_ptr() as *const _, &mut raw_uuid) };
194 tee_check(res)?;
195
196 Ok(Uuid::from(raw_uuid))
197 }
198}
199
200impl PropertyValue for Identity {
201 unsafe fn from_raw(set: raw::TEE_PropSetHandle, key: CString) -> Result<Self> {
202 let mut raw_id = raw::TEE_Identity {
204 login: 0,
205 uuid: raw::TEE_UUID {
206 timeLow: 0,
207 timeMid: 0,
208 timeHiAndVersion: 0,
209 clockSeqAndNode: [0; 8],
210 },
211 };
212
213 let res =
214 unsafe { raw::TEE_GetPropertyAsIdentity(set, key.as_ptr() as *const _, &mut raw_id) };
215 tee_check(res)?;
216
217 Ok(Identity::from(raw_id))
218 }
219}
220
221pub trait PropertyKey {
228 type Output: PropertyValue;
229 fn key(&self) -> CString;
230 fn set(&self) -> PropertySet;
231
232 fn get(&self) -> Result<Self::Output> {
233 unsafe { Self::Output::from_raw(self.set().as_raw(), self.key()) }
234 }
235}
236
237#[macro_export]
241macro_rules! define_property_key {
242 (
243 $name:ident,
244 $set:ident,
245 $key:literal,
246 $output:ty
247 ) => {
248 pub struct $name;
249
250 impl PropertyKey for $name {
251 type Output = $output;
252
253 fn key(&self) -> CString {
254 CString::new($key).unwrap_or_default()
255 }
256
257 fn set(&self) -> PropertySet {
258 PropertySet::$set
259 }
260 }
261 };
262}
263
264define_property_key!(TaAppId, CurrentTa, "gpd.ta.appID", Uuid);
280define_property_key!(TaSingleInstance, CurrentTa, "gpd.ta.singleInstance", bool);
281define_property_key!(TaMultiSession, CurrentTa, "gpd.ta.multiSession", bool);
282define_property_key!(
283 TaInstanceKeepAlive,
284 CurrentTa,
285 "gpd.ta.instanceKeepAlive",
286 bool
287);
288define_property_key!(
289 TaInstanceKeepCrashed,
290 CurrentTa,
291 "gpd.ta.instanceKeepCrashed",
292 bool
293);
294define_property_key!(TaDataSize, CurrentTa, "gpd.ta.dataSize", u32);
295define_property_key!(TaStackSize, CurrentTa, "gpd.ta.stackSize", u32);
296define_property_key!(TaVersion, CurrentTa, "gpd.ta.version", String);
297define_property_key!(TaDescription, CurrentTa, "gpd.ta.description", String);
298define_property_key!(TaEndian, CurrentTa, "gpd.ta.endian", u32);
299define_property_key!(
300 TaDoesNotCloseHandleOnCorruptObject,
301 CurrentTa,
302 "gpd.ta.doesNotCloseHandleOnCorruptObject",
303 bool
304);
305define_property_key!(
306 ClientIdentity,
307 CurrentClient,
308 "gpd.client.identity",
309 Identity
310);
311define_property_key!(ClientEndian, CurrentClient, "gpd.client.endian", u32);
312define_property_key!(
313 TeeApiVersion,
314 TeeImplementation,
315 "gpd.tee.apiversion",
316 String
317);
318define_property_key!(
319 TeeInternalCoreVersion,
320 TeeImplementation,
321 "gpd.tee.internalCore.version",
322 u32
323);
324define_property_key!(
325 TeeDescription,
326 TeeImplementation,
327 "gpd.tee.description",
328 String
329);
330define_property_key!(TeeDeviceId, TeeImplementation, "gpd.tee.deviceID", Uuid);
331define_property_key!(
332 TeeSystemTimeProtectionLevel,
333 TeeImplementation,
334 "gpd.tee.systemTime.protectionLevel",
335 u32
336);
337define_property_key!(
338 TeeTaPersistentTimeProtectionLevel,
339 TeeImplementation,
340 "gpd.tee.TAPersistentTime.protectionLevel",
341 u32
342);
343define_property_key!(
344 TeeArithMaxBigIntSize,
345 TeeImplementation,
346 "gpd.tee.arith.maxBigIntSize",
347 u32
348);
349define_property_key!(
350 TeeCryptographyEcc,
351 TeeImplementation,
352 "gpd.tee.cryptography.ecc",
353 bool
354);
355define_property_key!(
356 TeeCryptographyNist,
357 TeeImplementation,
358 "gpd.tee.cryptography.nist",
359 bool
360);
361define_property_key!(
362 TeeCryptographyBsiR,
363 TeeImplementation,
364 "gpd.tee.cryptography.bsi-r",
365 bool
366);
367define_property_key!(
368 TeeCryptographyBsiT,
369 TeeImplementation,
370 "gpd.tee.cryptography.bsi-t",
371 bool
372);
373define_property_key!(
374 TeeCryptographyIetf,
375 TeeImplementation,
376 "gpd.tee.cryptography.ietf",
377 bool
378);
379define_property_key!(
380 TeeCryptographyOcta,
381 TeeImplementation,
382 "gpd.tee.cryptography.octa",
383 bool
384);
385define_property_key!(
386 TeeTrustedStoragePrivateRollbackProtection,
387 TeeImplementation,
388 "gpd.tee.trustedStorage.private.rollbackProtection",
389 u32
390);
391define_property_key!(
392 TeeTrustedStoragePersoRollbackProtection,
393 TeeImplementation,
394 "gpd.tee.trustedStorage.perso.rollbackProtection",
395 u32
396);
397define_property_key!(
398 TeeTrustedStorageProtectedRollbackProtection,
399 TeeImplementation,
400 "gpd.tee.trustedStorage.protected.rollbackProtection",
401 u32
402);
403define_property_key!(
404 TeeTrustedStorageAntiRollbackProtectionLevel,
405 TeeImplementation,
406 "gpd.tee.trustedStorage.antiRollback.protectionLevel",
407 u32
408);
409define_property_key!(
410 TeeTrustedStorageRollbackDetectionProtectionLevel,
411 TeeImplementation,
412 "gpd.tee.trustedStorage.rollbackDetection.protectionLevel",
413 u32
414);
415define_property_key!(
416 TeeTrustedOsImplementationVersion,
417 TeeImplementation,
418 "gpd.tee.trustedos.implementation.version",
419 String
420);
421define_property_key!(
422 TeeTrustedOsImplementationBinaryVersion,
423 TeeImplementation,
424 "gpd.tee.trustedos.implementation.binaryversion",
425 u32
426);
427define_property_key!(
428 TeeTrustedOsManufacturer,
429 TeeImplementation,
430 "gpd.tee.trustedos.manufacturer",
431 String
432);
433define_property_key!(
434 TeeFirmwareImplementationVersion,
435 TeeImplementation,
436 "gpd.tee.firmware.implementation.version",
437 String
438);
439define_property_key!(
440 TeeFirmwareImplementationBinaryVersion,
441 TeeImplementation,
442 "gpd.tee.firmware.implementation.binaryversion",
443 u32
444);
445define_property_key!(
446 TeeFirmwareManufacturer,
447 TeeImplementation,
448 "gpd.tee.firmware.manufacturer",
449 String
450);
451define_property_key!(
452 TeeEventMaxSources,
453 TeeImplementation,
454 "gpd.tee.event.maxSources",
455 u32
456);