1 /*
2 * Copyright (C) 2022 Huawei Technologies Co., Ltd.
3 * Licensed under the Mulan PSL v2.
4 * You can use this software according to the terms and conditions of the Mulan PSL v2.
5 * You may obtain a copy of Mulan PSL v2 at:
6 * http://license.coscl.org.cn/MulanPSL2
7 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
8 * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
9 * PURPOSE.
10 * See the Mulan PSL v2 for more details.
11 */
12 #include "string.h"
13 #include "securec.h"
14 #include "tee_log.h"
15 #include "monad.h"
16
IRSetUp(IntermediateReprestation * ir)17 int IRSetUp(IntermediateReprestation *ir)
18 {
19 int ret;
20
21 ret = DisbalanceGroupElement(ir->mrpl, ir->mrplSize, IRSetUp);
22 if (ret != 0) {
23 tloge("[%s]:DisbalanceGroupElement failed\n", __func__);
24 return -1;
25 }
26
27 tlogi("[%s]:IRSetUp success\n", __func__);
28 return 0;
29 }
30
IRTearDown(IntermediateReprestation * ir)31 int IRTearDown(IntermediateReprestation *ir)
32 {
33 int ret;
34
35 ret = BalanceGroupElement(ir->mrpl, ir->mrplSize, IRTearDown);
36 if (ret != 0) {
37 tloge("[%s]:BalanceGroupElement failed\n", __func__);
38 return -1;
39 }
40
41 tlogi("[%s]:IRTearDown success\n", __func__);
42 return 0;
43 }
44
45 /* Persistent Object Functions */
CreatePersistentObject(IntermediateReprestation * ir)46 int CreatePersistentObject(IntermediateReprestation *ir)
47 {
48 TestVector *tv = ir->tv;
49 tv->createObjectLen = strnlen(tv->createObjectID, TEE_DATA_MAX_POSITION);
50 tv->initialDataLen = strnlen(tv->initialData, TEE_DATA_MAX_POSITION);
51 TEE_Result res = TEE_CreatePersistentObject(tv->storageID, tv->createObjectID, tv->createObjectLen,
52 tv->createFlags, tv->attributes, tv->initialData, tv->initialDataLen, &(ir->object));
53 if (res != TEE_SUCCESS) {
54 tloge("[%s]:TEE_CreatePersistentObject failed, 0x%x\n", __func__, res);
55 return res;
56 }
57
58 int ret = DisbalanceGroupElement(ir->mrpl, ir->mrplSize, CreatePersistentObject);
59 if (ret != 0) {
60 tloge("[%s]:DisbalanceGroupElement failed\n", __func__);
61 return -1;
62 }
63
64 tlogi("[%s]:TEE_CreatePersistentObject success\n", __func__);
65 return 0;
66 }
67
DeletePersistentObject(IntermediateReprestation * ir)68 int DeletePersistentObject(IntermediateReprestation *ir)
69 {
70 TEE_Result res = TEE_CloseAndDeletePersistentObject1(ir->object);
71 if (res != TEE_SUCCESS) {
72 tloge("[%s]:TEE_CloseAndDeletePersistentObject1 failed, 0x%x\n", __func__, res);
73 return res;
74 }
75
76 int ret = BalanceGroupElement(ir->mrpl, ir->mrplSize, DeletePersistentObject);
77 if (ret != 0) {
78 tloge("[%s]:BalanceGroupElement failed\n", __func__);
79 return -1;
80 }
81
82 tlogi("[%s]:TEE_CloseAndDeletePersistentObject1 success\n", __func__);
83 return 0;
84 }
85
OpenPersistentObject(IntermediateReprestation * ir)86 int OpenPersistentObject(IntermediateReprestation *ir)
87 {
88 TestVector *tv = ir->tv;
89 tv->openObjectLen = strnlen(tv->openObjectID, TEE_DATA_MAX_POSITION);
90 TEE_Result res = TEE_OpenPersistentObject(tv->storageID, tv->openObjectID, tv->openObjectLen,
91 tv->openFlags, &(ir->object));
92 if (res != TEE_SUCCESS) {
93 tloge("[%s]:TEE_OpenPersistentObject failed, 0x%x\n", __func__, res);
94 return res;
95 }
96 tlogi("[%s]:TEE_OpenPersistentObject success\n", __func__);
97 return 0;
98 }
99
CloseObject(IntermediateReprestation * ir)100 int CloseObject(IntermediateReprestation *ir)
101 {
102 TEE_CloseObject(ir->object);
103 ir->object = TEE_HANDLE_NULL;
104 tlogi("[%s]:TEE_CloseObject finish\n", __func__);
105 return 0;
106 }
107
SyncPersistentObject(IntermediateReprestation * ir)108 int SyncPersistentObject(IntermediateReprestation *ir)
109 {
110 TEE_Result res = TEE_SyncPersistentObject(ir->object);
111 if (res != TEE_SUCCESS) {
112 tloge("[%s]:TEE_SyncPersistentObject failed, 0x%x\n", __func__, res);
113 return res;
114 }
115 tlogi("[%s]:TEE_SyncPersistentObject success\n", __func__);
116 return 0;
117 }
118
SeekObject(IntermediateReprestation * ir)119 int SeekObject(IntermediateReprestation *ir)
120 {
121 TestVector *tv = ir->tv;
122 TEE_Result res = TEE_SeekObjectData(ir->object, tv->seekOffset, tv->whence);
123 if (res != TEE_SUCCESS) {
124 tloge("[%s]:TEE_SeekObjectData failed, 0x%x\n", __func__, res);
125 return res;
126 }
127 tlogi("[%s]:TEE_SeekObjectData success\n", __func__);
128 return 0;
129 }
130
WriteObject(IntermediateReprestation * ir)131 int WriteObject(IntermediateReprestation *ir)
132 {
133 TestVector *tv = ir->tv;
134 tv->writeBufferLen = strnlen(tv->writeBuffer, TEE_DATA_MAX_POSITION);
135 TEE_Result res = TEE_WriteObjectData(ir->object, tv->writeBuffer, tv->writeBufferLen);
136 if (res != TEE_SUCCESS) {
137 tloge("[%s]:TEE_WriteObjectData failed, 0x%x\n", __func__, res);
138 return res;
139 }
140 tlogi("[%s]:TEE_WriteObjectData success\n", __func__);
141 return 0;
142 }
143
ReadObject(IntermediateReprestation * ir)144 int ReadObject(IntermediateReprestation *ir)
145 {
146 TestVector *tv = ir->tv;
147 TEE_Result res = TEE_ReadObjectData(ir->object, (void *)ir->readBuffer, tv->readBufferLen, &(ir->readCount));
148 if (res != TEE_SUCCESS) {
149 tloge("[%s]:TEE_ReadObjectData failed, 0x%x\n", __func__, res);
150 return res;
151 }
152 tlogi("[%s]:TEE_ReadObjectData success\n", __func__);
153 return 0;
154 }
155
CheckReadBuffer(IntermediateReprestation * ir)156 int CheckReadBuffer(IntermediateReprestation *ir)
157 {
158 TestVector *tv = ir->tv;
159 if (ir->readCount != tv->writeBufferLen) {
160 tloge("[%s]:CheckReadBuffer compare dataLen fail\n", __func__);
161 return -1;
162 }
163
164 int res = strncmp(tv->writeBuffer, ir->readBuffer, ir->readCount);
165 if (res != 0) {
166 tloge("[%s]:CheckReadBuffer compare data fail\n", __func__);
167 return -1;
168 }
169 tlogi("[%s]:CheckReadBuffer success\n", __func__);
170 return 0;
171 }
172
TruncateObject(IntermediateReprestation * ir)173 int TruncateObject(IntermediateReprestation *ir)
174 {
175 TestVector *tv = ir->tv;
176 TEE_Result res = TEE_TruncateObjectData(ir->object, tv->resetSize);
177 if (res != TEE_SUCCESS) {
178 tloge("[%s]:TEE_TruncateObjectData failed, 0x%x\n", __func__, res);
179 return res;
180 }
181 tlogi("[%s]:TEE_TruncateObjectData success\n", __func__);
182 return 0;
183 }
184
RenameObject(IntermediateReprestation * ir)185 int RenameObject(IntermediateReprestation *ir)
186 {
187 TestVector *tv = ir->tv;
188 tv->newObjectLen = strnlen(tv->newObjectID, TEE_DATA_MAX_POSITION);
189 TEE_Result res = TEE_RenamePersistentObject(ir->object, tv->newObjectID, tv->newObjectLen);
190 if (res != TEE_SUCCESS) {
191 tloge("[%s]:TEE_RenamePersistentObject failed, 0x%x\n", __func__, res);
192 return res;
193 }
194
195 tlogi("[%s]:TEE_RenamePersistentObject success\n", __func__);
196 return 0;
197 }
198
GetObjectInfo(IntermediateReprestation * ir)199 int GetObjectInfo(IntermediateReprestation *ir)
200 {
201 TestVector *tv = ir->tv;
202 TEE_Result res = TEE_SUCCESS;
203 if (tv->isTransientObject) {
204 res = TEE_GetObjectInfo1(ir->transientObject[0], &(ir->objectInfo));
205 } else {
206 res = TEE_GetObjectInfo1(ir->object, &(ir->objectInfo));
207 }
208 if (res != TEE_SUCCESS) {
209 tloge("[%s]:TEE_GetObjectInfo1 failed, 0x%x\n", __func__, res);
210 return res;
211 }
212 tlogi("[%s]:TEE_GetObjectInfo1 success\n", __func__);
213 return 0;
214 }
215
InfoObjectData(IntermediateReprestation * ir)216 int InfoObjectData(IntermediateReprestation *ir)
217 {
218 TestVector *tv = ir->tv;
219 TEE_Result res = TEE_SUCCESS;
220 if (tv->isTransientObject) {
221 res = TEE_InfoObjectData(ir->transientObject[0], &(ir->pos), &(ir->len));
222 } else {
223 res = TEE_InfoObjectData(ir->object, &(ir->pos), &(ir->len));
224 }
225 if (res != TEE_SUCCESS) {
226 tloge("[%s]:TEE_InfoObjectData failed, 0x%x\n", __func__, res);
227 return res;
228 }
229 tlogi("[%s]:TEE_InfoObjectData success, ir->pos=%d, ir->len=%d\n", __func__, ir->pos, ir->len);
230 return 0;
231 }
232
CheckObjectSize(IntermediateReprestation * ir)233 int CheckObjectSize(IntermediateReprestation *ir)
234 {
235 TestVector *tv = ir->tv;
236 if (ir->objectInfo.dataSize != tv->resetSize) {
237 tloge("[%s]:CheckObjectSize data size error, get objectInfo.dataSize=%d\n", __func__, ir->objectInfo.dataSize);
238 return -1;
239 }
240 tlogi("[%s]:CheckObjectSize success\n", __func__);
241 return 0;
242 }
243
CheckInfoObject(IntermediateReprestation * ir)244 int CheckInfoObject(IntermediateReprestation *ir)
245 {
246 TestVector *tv = ir->tv;
247 if (ir->len != tv->resetSize) {
248 tloge("[%s]:CheckInfoObject data len error, get len = %d\n", __func__, ir->len);
249 return -1;
250 }
251 if (ir->pos != 0) {
252 tloge("[%s]:CheckInfoObject data pos error, get pos = %d\n", __func__, ir->pos);
253 return -1;
254 }
255 tlogi("[%s]:CheckInfoObject success\n", __func__);
256 return 0;
257 }
258
259 /* Persistent Object Enumeration Functions */
CreateMultiObject(IntermediateReprestation * ir)260 int CreateMultiObject(IntermediateReprestation *ir)
261 {
262 TestVector *tv = ir->tv;
263 TEE_Result res = TEE_SUCCESS;
264 tv->createObjectLen = strnlen(tv->createObjectID, TEE_DATA_MAX_POSITION);
265 tv->initialDataLen = strnlen(tv->initialData, TEE_DATA_MAX_POSITION);
266 for (uint32_t i = 0; i < tv->createNum; ++i) {
267 *((uint8_t *)tv->createObjectID + tv->createObjectLen - 1) = '0' + i; // only change last char
268 res = TEE_CreatePersistentObject(tv->storageID, tv->createObjectID, tv->createObjectLen,
269 tv->createFlags, tv->attributes, tv->initialData, tv->initialDataLen, &(ir->object));
270 if (res != TEE_SUCCESS) {
271 tloge("[%s]:TEE_CreatePersistentObject failed, id %d, res 0x%x\n", __func__, i, res);
272 return res;
273 }
274 TEE_CloseObject(ir->object);
275 }
276
277 int ret = DisbalanceGroupElement(ir->mrpl, ir->mrplSize, CreateMultiObject);
278 if (ret != 0) {
279 tloge("[%s]:DisbalanceGroupElement failed\n", __func__);
280 return -1;
281 }
282
283 tlogi("[%s]:TEE_CreatePersistentObject success\n", __func__);
284 return 0;
285 }
286
DeleteMultiObject(IntermediateReprestation * ir)287 int DeleteMultiObject(IntermediateReprestation *ir)
288 {
289 TestVector *tv = ir->tv;
290 TEE_Result res;
291 int error = 0;
292 for (uint32_t i = 0; i < tv->createNum; ++i) {
293 tv->openObjectLen = strnlen(tv->openObjectID, TEE_DATA_MAX_POSITION);
294 *((uint8_t *)tv->openObjectID + tv->openObjectLen - 1) = '0' + i;
295 res = TEE_OpenPersistentObject(tv->storageID, tv->openObjectID, tv->openObjectLen,
296 tv->openFlags, &(ir->object));
297 if ((res != TEE_SUCCESS) && (res != TEE_ERROR_ITEM_NOT_FOUND)) {
298 error++;
299 tloge("[%s]:TEE_OpenPersistentObject failed, 0x%x\n", __func__, res);
300 continue;
301 }
302
303 if (res == TEE_SUCCESS) {
304 res = TEE_CloseAndDeletePersistentObject1(ir->object);
305 if (res != TEE_SUCCESS) {
306 error++;
307 tloge("[%s]:TEE_CloseAndDeletePersistentObject1 failed, 0x%x\n", __func__, res);
308 continue;
309 }
310 }
311 }
312
313 if (error) {
314 tloge("[%s]:TEE_OpenPersistentObject or TEE_CloseAndDeletePersistentObject1 failed\n", __func__);
315 return -1;
316 }
317
318 int ret = BalanceGroupElement(ir->mrpl, ir->mrplSize, DeleteMultiObject);
319 if (ret != 0) {
320 tloge("[%s]:BalanceGroupElement failed\n", __func__);
321 return -1;
322 }
323
324 tlogi("[%s]:TEE_OpenPersistentObject or TEE_CloseAndDeletePersistentObject1 all object success\n", __func__);
325 return 0;
326 }
327
AllocateEnumerator(IntermediateReprestation * ir)328 int AllocateEnumerator(IntermediateReprestation *ir)
329 {
330 TEE_Result res = TEE_AllocatePersistentObjectEnumerator(&(ir->objectEnumerator));
331 if (res != TEE_SUCCESS) {
332 tloge("[%s]:TEE_AllocatePersistentObjectEnumerator failed, 0x%x\n", __func__, res);
333 return res;
334 }
335
336 int ret = DisbalanceGroupElement(ir->mrpl, ir->mrplSize, AllocateEnumerator);
337 if (ret != 0) {
338 tloge("[%s]:DisbalanceGroupElement failed\n", __func__);
339 return -1;
340 }
341 tlogi("[%s]:TEE_AllocatePersistentObjectEnumerator success\n", __func__);
342 return 0;
343 }
344
FreeEnumerator(IntermediateReprestation * ir)345 int FreeEnumerator(IntermediateReprestation *ir)
346 {
347 TEE_FreePersistentObjectEnumerator(ir->objectEnumerator);
348
349 int ret = BalanceGroupElement(ir->mrpl, ir->mrplSize, FreeEnumerator);
350 if (ret != 0) {
351 tloge("[%s]:BalanceGroupElement failed\n", __func__);
352 return -1;
353 }
354 tlogi("[%s]:TEE_FreePersistentObjectEnumerator success\n", __func__);
355 return 0;
356 }
357
ResetEnumerator(IntermediateReprestation * ir)358 int ResetEnumerator(IntermediateReprestation *ir)
359 {
360 TEE_ResetPersistentObjectEnumerator(ir->objectEnumerator);
361 tlogi("[%s]:TEE_ResetPersistentObjectEnumerator success\n", __func__);
362 return 0;
363 }
364
StartEnumerator(IntermediateReprestation * ir)365 int StartEnumerator(IntermediateReprestation *ir)
366 {
367 TEE_Result res = TEE_StartPersistentObjectEnumerator(ir->objectEnumerator, ir->tv->storageID);
368 if (res != TEE_SUCCESS) {
369 tloge("[%s]:TEE_StartPersistentObjectEnumerator failed, 0x%x\n", __func__, res);
370 return res;
371 }
372 tlogi("[%s]:TEE_StartPersistentObjectEnumerator success\n", __func__);
373 return 0;
374 }
375
EnumerateAllObject(IntermediateReprestation * ir)376 int EnumerateAllObject(IntermediateReprestation *ir)
377 {
378 TestVector *tv = ir->tv;
379 TEE_Result res = TEE_SUCCESS;
380 int object_num = 0;
381 while (1) {
382 ir->enumObjectIDLen = MAX_DATA_LEN;
383 tlogi("########[%s] before TEE_GetNextPersistentObject\n", __func__);
384 res = TEE_GetNextPersistentObject(ir->objectEnumerator, &(ir->objectInfo),
385 ir->enumObjectID, &(ir->enumObjectIDLen));
386 if (res == TEE_ERROR_ITEM_NOT_FOUND) {
387 break;
388 }
389 if (res != TEE_SUCCESS) {
390 tloge("[%s]:TEE_GetNextPersistentObject failed, 0x%x\n", __func__, res);
391 return res;
392 }
393 tlogi("########[%s] before TEE_OpenPersistentObject\n", __func__);
394 res = TEE_OpenPersistentObject(tv->storageID, ir->enumObjectID, ir->enumObjectIDLen,
395 tv->openFlags, &(ir->object));
396 if (res != TEE_SUCCESS) {
397 tloge("[%s]:TEE_GetNextPersistentObject open object failed, 0x%x\n", __func__, res);
398 return res;
399 }
400 object_num++;
401
402 tlogi("########[%s] before TEE_CloseAndDeletePersistentObject1\n", __func__);
403 res = TEE_CloseAndDeletePersistentObject1(ir->object);
404 if (res != TEE_SUCCESS) {
405 tloge("[%s]:TEE_CloseAndDeletePersistentObject1 object failed, 0x%x\n", __func__, res);
406 }
407
408 }
409
410 tlogi("[%s]:EnumerateAllObject success, object num %d\n", __func__, object_num);
411 return 0;
412 }
413
414 /* TransientObject Functions */
AllocateTransientObject(IntermediateReprestation * ir)415 int AllocateTransientObject(IntermediateReprestation *ir)
416 {
417 TestVector *tv = ir->tv;
418 TEE_Result res = TEE_SUCCESS;
419 for (uint32_t i = 0; i < tv->transientObjectNum; ++i) {
420 res = TEE_AllocateTransientObject(tv->objectType[i], tv->maxObjectSize[i], &(ir->transientObject[i]));
421 if (res != TEE_SUCCESS) {
422 tloge("[%s]:TEE_AllocateTransientObject failed, Object %d, 0x%x\n", __func__, i, res);
423 return res;
424 }
425 }
426
427 int ret = DisbalanceGroupElement(ir->mrpl, ir->mrplSize, AllocateTransientObject);
428 if (ret != 0) {
429 tloge("[%s]:DisbalanceGroupElement failed\n", __func__);
430 return -1;
431 }
432 tlogi("[%s]:TEE_AllocateTransientObject success\n", __func__);
433 return 0;
434 }
435
FreeTransientObject(IntermediateReprestation * ir)436 int FreeTransientObject(IntermediateReprestation *ir)
437 {
438 TestVector *tv = ir->tv;
439 for (uint32_t i = 0; i < tv->transientObjectNum; ++i) {
440 TEE_FreeTransientObject(ir->transientObject[i]);
441 }
442
443 int ret = BalanceGroupElement(ir->mrpl, ir->mrplSize, FreeTransientObject);
444 if (ret != 0) {
445 tloge("[%s]:BalanceGroupElement failed\n", __func__);
446 return -1;
447 }
448 tlogi("[%s]:TEE_FreeTransientObject success\n", __func__);
449 return 0;
450 }
451
RestrictObjectUsage(IntermediateReprestation * ir)452 int RestrictObjectUsage(IntermediateReprestation *ir)
453 {
454 TestVector *tv = ir->tv;
455 TEE_Result res = TEE_RestrictObjectUsage1(ir->transientObject[0], tv->objectUsage[ir->restrictUsageCount]);
456 ir->restrictUsageCount++;
457 if (res != TEE_SUCCESS) {
458 tloge("[%s]:TEE_RestrictObjectUsage1 failed, 0x%x\n", __func__, res);
459 return res;
460 }
461 tlogi("[%s]:TEE_RestrictObjectUsage1 success\n", __func__);
462 return 0;
463 }
464
ResetObject(IntermediateReprestation * ir)465 int ResetObject(IntermediateReprestation *ir)
466 {
467 TEE_ResetTransientObject(ir->transientObject[0]);
468 tlogi("[%s]:TEE_ResetTransientObject success\n", __func__);
469 return 0;
470 }
471
CheckObjectUsage(IntermediateReprestation * ir)472 int CheckObjectUsage(IntermediateReprestation *ir)
473 {
474 TestVector *tv = ir->tv;
475 if (ir->objectInfo.objectUsage != tv->objectUsage[ir->checkUsageCount]) {
476 tloge("[%s]:CheckObjectUsage check failed, objectUsage 0x%x, RestrictUsage 0x%x\n",
477 __func__, ir->objectInfo.objectUsage, tv->objectUsage[ir->checkUsageCount]);
478 return -1;
479 }
480 tloge("[%s]:CheckObjectUsage check success, objectUsage 0x%x, RestrictUsage 0x%x\n",
481 __func__, ir->objectInfo.objectUsage, tv->objectUsage[ir->checkUsageCount]);
482 ir->checkUsageCount++;
483 return 0;
484 }
485
486 /* TEE_Attribute Functions */
InitRefAttr(IntermediateReprestation * ir)487 int InitRefAttr(IntermediateReprestation *ir)
488 {
489 TestVector *tv = ir->tv;
490
491 tv->attrInitLength[ir->initRefAddrCount] = strnlen(tv->attrInitBuffer[ir->initRefAddrCount], TEE_DATA_MAX_POSITION);
492 TEE_InitRefAttribute(&(ir->attr[ir->initAttrNum]), tv->attributeID[ir->initAttrNum],
493 tv->attrInitBuffer[ir->initRefAddrCount], tv->attrInitLength[ir->initRefAddrCount]);
494
495 ir->initRefAddrCount++;
496 ir->initAttrNum++;
497 tlogi("[%s]:TEE_InitRefAttribute finish\n", __func__);
498 return 0;
499 }
500
InitValueAttr(IntermediateReprestation * ir)501 int InitValueAttr(IntermediateReprestation *ir)
502 {
503 TestVector *tv = ir->tv;
504 TEE_InitValueAttribute(&(ir->attr[ir->initAttrNum]), tv->attributeID[ir->initAttrNum],
505 tv->attrInitA[ir->initValueAddrCount], tv->attrInitB[ir->initValueAddrCount]);
506
507 ir->initValueAddrCount++;
508 ir->initAttrNum++;
509 tlogi("[%s]:TEE_InitValueAttribute finish\n", __func__);
510 return 0;
511 }
512
PopulateTransientObject(IntermediateReprestation * ir)513 int PopulateTransientObject(IntermediateReprestation *ir)
514 {
515 TestVector *tv = ir->tv;
516 TEE_Result res = TEE_PopulateTransientObject(ir->transientObject[0], &(ir->attr[0]), tv->attrCount);
517 if (res != TEE_SUCCESS) {
518 tloge("[%s]:TEE_PopulateTransientObject failed, 0x%x\n", __func__, res);
519 return res;
520 }
521 tlogi("[%s]:TEE_PopulateTransientObject success\n", __func__);
522 return 0;
523 }
524
CopyObjectAttr(IntermediateReprestation * ir)525 int CopyObjectAttr(IntermediateReprestation *ir)
526 {
527 TEE_Result res = TEE_CopyObjectAttributes1(ir->transientObject[1], ir->transientObject[0]);
528 if (res != TEE_SUCCESS) {
529 tloge("[%s]:TEE_CopyObjectAttributes1 failed, 0x%x\n", __func__, res);
530 return res;
531 }
532 tlogi("[%s]:TEE_CopyObjectAttributes1 success\n", __func__);
533 return 0;
534 }
535
GetObjectBufferAttr(IntermediateReprestation * ir)536 int GetObjectBufferAttr(IntermediateReprestation *ir)
537 {
538 TestVector *tv = ir->tv;
539 ir->attrGetBufferLen[ir->getRefCount] = MAX_DATA_LEN;
540 TEE_Result res = TEE_GetObjectBufferAttribute(ir->transientObject[1], tv->getAttributeID[ir->getAttrNum],
541 &(ir->attrGetBuffer[ir->getRefCount]), &(ir->attrGetBufferLen[ir->getRefCount]));
542 ir->getRefCount++;
543 ir->getAttrNum++;
544 if (res != TEE_SUCCESS) {
545 tloge("[%s]:TEE_GetObjectBufferAttribute failed, 0x%x\n", __func__, res);
546 return res;
547 }
548 tlogi("[%s]:TEE_GetObjectBufferAttribute success\n", __func__);
549 return 0;
550 }
551
GetObjectValueAttr(IntermediateReprestation * ir)552 int GetObjectValueAttr(IntermediateReprestation *ir)
553 {
554 TestVector *tv = ir->tv;
555 TEE_Result res = TEE_GetObjectValueAttribute(ir->transientObject[1], tv->getAttributeID[ir->getAttrNum],
556 &(ir->attrGetA[ir->getValueCount]), &(ir->attrGetB[ir->getValueCount]));
557 ir->getValueCount++;
558 ir->getAttrNum++;
559 if (res != TEE_SUCCESS) {
560 tloge("[%s]:TEE_GetObjectValueAttribute failed, 0x%x\n", __func__, res);
561 return res;
562 }
563 tlogi("[%s]:TEE_GetObjectValueAttribute success\n", __func__);
564 return 0;
565 }
566
CheckAttr(IntermediateReprestation * ir)567 int CheckAttr(IntermediateReprestation *ir)
568 {
569 TestVector *tv = ir->tv;
570 if (ir->attrGetBufferLen[0] != tv->attrInitLength[0] || ir->attrGetBufferLen[1] != tv->attrInitLength[1]) {
571 tlogi("[%s]:CheckAttr attr_length failed\n", __func__);
572 return -1;
573 }
574 if (strncmp(tv->attrInitBuffer[0], (void *)ir->attrGetBuffer[0], ir->attrGetBufferLen[0]) != 0 ||
575 strncmp(tv->attrInitBuffer[1], (void *)ir->attrGetBuffer[1], ir->attrGetBufferLen[1]) != 0) {
576 tlogi("[%s]:CheckAttr attr_buffer failed\n", __func__);
577 return -1;
578 }
579 if (ir->attrGetBufferLen[0] != tv->attrInitLength[0] || ir->attrGetBufferLen[1] != tv->attrInitLength[1]) {
580 tlogi("[%s]:CheckAttr attr_length failed\n", __func__);
581 return -1;
582 }
583
584 tlogi("[%s]:CheckAttr success\n", __func__);
585 return 0;
586 }
587
GenerateKey(IntermediateReprestation * ir)588 int GenerateKey(IntermediateReprestation *ir)
589 {
590 TestVector *tv = ir->tv;
591 TEE_Result res = TEE_GenerateKey(ir->transientObject[0], tv->generateKeySize, ir->attr, tv->attrCount);
592 if (res != TEE_SUCCESS) {
593 tloge("[%s]:TEE_GenerateKey failed, 0x%x\n", __func__, res);
594 return res;
595 }
596 tlogi("[%s]:TEE_GenerateKey success\n", __func__);
597 return 0;
598 }
599