hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
//SPDX-License-Identifier: BSD-2-Clause
/*
 * Copyright (c) 2021 Open Mobile Platform LLC
 */
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <ta_supp_plugin.h>
#include <tee_internal_api.h>
#include <tee_internal_api_extensions.h>
#include <test_supp_plugin.h>
#include <trace.h>
 
static const TEE_UUID uuid = TEST_PLUGIN_UUID;
 
TEE_Result TA_CreateEntryPoint(void)
{
   return TEE_SUCCESS;
}
 
void TA_DestroyEntryPoint(void)
{
}
 
TEE_Result TA_OpenSessionEntryPoint(uint32_t nParamTypes __unused,
                   TEE_Param pParams[4] __unused,
                   void **ppSessionContext __unused)
{
   /* check the plugin was loaded */
   return tee_invoke_supp_plugin(&uuid, TEST_PLUGIN_CMD_PING, 0, NULL, 0,
                     NULL);
}
 
void TA_CloseSessionEntryPoint(void *pSessionContext __unused)
{
}
 
static TEE_Result pass_values(uint32_t param_types,
                TEE_Param params[TEE_NUM_PARAMS])
{
   uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_VALUE_INOUT,
                     TEE_PARAM_TYPE_VALUE_INPUT,
                     TEE_PARAM_TYPE_NONE,
                     TEE_PARAM_TYPE_NONE);
   TEE_Result res = TEE_ERROR_GENERIC;
   size_t outlen = 0;
   struct add_op {
       uint32_t a;
       uint32_t b;
   } values = { 0 };
 
   if (exp_pt != param_types)
       return TEE_ERROR_BAD_PARAMETERS;
 
   values.a = params[0].value.a;
   values.b = params[0].value.b;
 
   res = tee_invoke_supp_plugin(&uuid, TEST_PLUGIN_CMD_PASS_VALUES,
                    params[1].value.a, (void *)&values,
                    sizeof(struct add_op), &outlen);
   params[0].value.a = values.a;
 
   return res;
}
 
static TEE_Result write_array(uint32_t param_types,
                 TEE_Param params[TEE_NUM_PARAMS])
{
   uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_MEMREF_INPUT,
                     TEE_PARAM_TYPE_VALUE_OUTPUT,
                     TEE_PARAM_TYPE_NONE,
                     TEE_PARAM_TYPE_NONE);
   TEE_Result res = TEE_ERROR_GENERIC;
   size_t outlen = 0;
   uint8_t *d = params[0].memref.buffer;
 
   if (exp_pt != param_types)
       return TEE_ERROR_BAD_PARAMETERS;
 
   res = tee_invoke_supp_plugin(&uuid, TEST_PLUGIN_CMD_WRITE_ARR, 0,
                    params[0].memref.buffer,
                    params[0].memref.size, &outlen);
   params[1].value.a = d[0];
 
   return res;
}
 
static TEE_Result get_array(uint32_t param_types,
               TEE_Param params[TEE_NUM_PARAMS])
{
   uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_MEMREF_OUTPUT,
                     TEE_PARAM_TYPE_VALUE_OUTPUT,
                     TEE_PARAM_TYPE_NONE,
                     TEE_PARAM_TYPE_NONE);
   TEE_Result res = TEE_ERROR_GENERIC;
   size_t outlen = 0;
 
   if (exp_pt != param_types)
       return TEE_ERROR_BAD_PARAMETERS;
 
   res = tee_invoke_supp_plugin(&uuid, TEST_PLUGIN_CMD_GET_ARR, 0,
                    params[0].memref.buffer,
                    params[0].memref.size,
                    &outlen);
   params[1].value.a = (uint32_t)outlen;
 
   return res;
}
 
static TEE_Result bad_input_uuid(uint32_t param_types __unused,
                TEE_Param params[TEE_NUM_PARAMS] __unused)
{
   char data[32] = {  };
   size_t inlen = sizeof(data);
 
   return tee_invoke_supp_plugin(NULL, 0, 0, data, inlen, NULL);
}
 
static TEE_Result bad_input_data(uint32_t param_types __unused,
                TEE_Param params[TEE_NUM_PARAMS] __unused)
{
   return tee_invoke_supp_plugin(&uuid, 0, 0, NULL, 10, NULL);
}
 
static TEE_Result bad_input_inlen(uint32_t param_types __unused,
                 TEE_Param params[TEE_NUM_PARAMS] __unused)
{
   char data[32] = {  };
 
   return tee_invoke_supp_plugin(&uuid, 0, 0, data, 0, NULL);
}
 
static TEE_Result call_unknown_plugin(uint32_t param_types __unused,
                     TEE_Param params[TEE_NUM_PARAMS]
                     __unused)
{
   const TEE_UUID nulluuid = {  };
   char data[32] = {  };
   size_t inlen = sizeof(data);
 
   return tee_invoke_supp_plugin(&nulluuid, 0, 0, data, inlen, NULL);
}
 
TEE_Result TA_InvokeCommandEntryPoint(void *pSessionContext __unused,
                     uint32_t nCommandID,
                     uint32_t nParamTypes,
                     TEE_Param pParams[4])
{
   switch (nCommandID) {
   case TA_SUPP_PLUGIN_CMD_PASS_VALUES:
       return pass_values(nParamTypes, pParams);
   case TA_SUPP_PLUGIN_CMD_WRITE_ARR:
       return write_array(nParamTypes, pParams);
   case TA_SUPP_PLUGIN_CMD_GET_ARR:
       return get_array(nParamTypes, pParams);
   case TA_SUPP_PLUGIN_CMD_BAD_UUID:
       return bad_input_uuid(nParamTypes, pParams);
   case TA_SUPP_PLUGIN_CMD_BAD_IN_DATA:
       return bad_input_data(nParamTypes, pParams);
   case TA_SUPP_PLUGIN_CMD_BAD_IN_LEN:
       return bad_input_inlen(nParamTypes, pParams);
   case TA_SUPP_PLUGIN_CMD_UNKNOWN_UUID:
       return call_unknown_plugin(nParamTypes, pParams);
   default:
       return TEE_ERROR_NOT_SUPPORTED;
   }
}