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 13 #include <common_test.h> 14 #include <gtest/gtest.h> 15 #include <securec.h> 16 #include <tee_client_api.h> 17 #include <tee_client_type.h> 18 #include <test_defines.h> 19 #include <test_log.h> 20 #include <test_tcf_cmdid.h> 21 22 using namespace testing::ext; 23 /** 24 * @testcase.name : TEE_CheckMemoryAccessRights_With_Access_Read_Flag 25 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer whether has Access_Read right 26 * @testcase.expect : return TEEC_SUCCESS 27 */ 28 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_Access_Read_Flag, Function | MediumTest | Level0) 29 { 30 TEEC_Result ret; 31 TestMemData value = { 0 }; 32 33 value.oldSize = TESTSIZE; 34 value.accessFlags = TEE_MEMORY_ACCESS_READ; 35 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 36 #ifndef TEST_STUB 37 ASSERT_EQ(ret, TEEC_SUCCESS); 38 #else 39 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 40 #endif 41 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 42 } 43 44 /** 45 * @testcase.name : TEE_CheckMemoryAccessRights_With_Access_Write_Flag 46 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer whether has Access_Write right 47 * @testcase.expect : return TEEC_SUCCESS 48 */ 49 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_Access_Write_Flag, Function | MediumTest | Level0) 50 { 51 TEEC_Result ret; 52 TestMemData value = { 0 }; 53 54 value.oldSize = TESTSIZE; 55 value.accessFlags = TEE_MEMORY_ACCESS_WRITE; 56 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 57 #ifndef TEST_STUB 58 ASSERT_EQ(ret, TEEC_SUCCESS); 59 #else 60 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 61 #endif 62 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 63 } 64 65 /** 66 * @testcase.name : TEE_CheckMemoryAccessRights_With_BufferIsFree 67 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer while assigned buffer is freeed 68 * @testcase.expect : return TEEC_SUCCESS 69 */ 70 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_BufferIsFree, Function | MediumTest | Level0) 71 { 72 TEEC_Result ret; 73 TestMemData value = { 0 }; 74 75 value.oldSize = TESTSIZE; 76 value.accessFlags = TEE_MEMORY_ACCESS_READ; 77 value.caseId = BUFFER_IS_FREE; 78 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 79 #ifndef TEST_STUB 80 ASSERT_EQ(ret, TEEC_SUCCESS); 81 #else 82 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 83 #endif 84 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 85 } 86 87 /** 88 * @testcase.name : TEE_CheckMemoryAccessRights_With_BufferIsNotMalloc 89 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights while buffer is not alloced,it is on stack 90 * @testcase.expect : return TEEC_SUCCESS 91 */ 92 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_BufferIsNotMalloc, Function | MediumTest | Level0) 93 { 94 TEEC_Result ret; 95 TestMemData value = { 0 }; 96 97 value.oldSize = TESTSIZE; 98 value.accessFlags = TEE_MEMORY_ACCESS_READ | TEE_MEMORY_ACCESS_WRITE; 99 value.caseId = BUFFER_ISNOT_MALLOC; 100 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 101 #ifndef TEST_STUB 102 ASSERT_EQ(ret, TEEC_SUCCESS); 103 #else 104 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 105 #endif 106 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 107 } 108 109 /** 110 * @testcase.name : TEE_CheckMemoryAccessRights_With_SizeIsZero 111 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer while size is zero 112 * @testcase.expect : return TEEC_SUCCESS 113 */ 114 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_SizeIsZero, Function | MediumTest | Level0) 115 { 116 TEEC_Result ret; 117 TestMemData value = { 0 }; 118 119 value.oldSize = TESTSIZE; 120 value.accessFlags = TEE_MEMORY_ACCESS_READ | TEE_MEMORY_ACCESS_WRITE; 121 value.caseId = OUTPUTBUFFERSIZE_ISZERO; 122 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 123 #ifndef TEST_STUB 124 ASSERT_EQ(ret, TEEC_SUCCESS); 125 #else 126 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 127 #endif 128 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 129 } 130 131 /** 132 * @testcase.name : TEE_CheckMemoryAccessRights_With_GlobalVar 133 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights while buffer is global variable 134 * @testcase.expect : return TEEC_SUCCESS 135 */ 136 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_GlobalVar, Function | MediumTest | Level0) 137 { 138 TEEC_Result ret; 139 TestMemData value = { 0 }; 140 141 value.oldSize = TESTSIZE; 142 value.accessFlags = TEE_MEMORY_ACCESS_READ | TEE_MEMORY_ACCESS_WRITE; 143 value.caseId = BUFFER_IS_GLOBALVAR; 144 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 145 #ifndef TEST_STUB 146 ASSERT_EQ(ret, TEEC_SUCCESS); 147 #else 148 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 149 #endif 150 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 151 } 152 153 /** 154 * @testcase.name : TEE_CheckMemoryAccessRights_With_ReadRight_GlobalConstVar 155 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights while buffer is global variable 156 * @testcase.expect : return TEEC_SUCCESS 157 */ 158 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_ReadRight_GlobalConstVar, Function | MediumTest | Level0) 159 { 160 TEEC_Result ret; 161 TestMemData value = { 0 }; 162 163 value.oldSize = TESTSIZE; 164 value.accessFlags = TEE_MEMORY_ACCESS_READ; 165 value.caseId = BUFFER_IS_GLOBALCONSTVAR; 166 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 167 #ifndef TEST_STUB 168 ASSERT_EQ(ret, TEEC_SUCCESS); 169 #else 170 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 171 #endif 172 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 173 } 174 175 /** 176 * @testcase.name : TEE_CheckMemoryAccessRights_With_Access_AnyOwner_Flag 177 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer whether has Access_AnyOwner right 178 * @testcase.expect : return TEEC_ERROR_ACCESS_DENIED 179 */ 180 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_Access_AnyOwner_Flag, Function | MediumTest | Level0) 181 { 182 TEEC_Result ret; 183 TestMemData value = { 0 }; 184 185 value.oldSize = TESTSIZE; 186 value.accessFlags = TEE_MEMORY_ACCESS_ANY_OWNER; 187 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 188 #ifndef TEST_STUB 189 ASSERT_EQ(ret, TEEC_ERROR_ACCESS_DENIED); 190 #else 191 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 192 #endif 193 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 194 } 195 196 /** 197 * @testcase.name : TEE_CheckMemoryAccessRights_With_FlagIsZero 198 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer while flag is zero 199 * @testcase.expect : return TEEC_ERROR_ACCESS_DENIED 200 */ 201 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_FlagIsZero, Function | MediumTest | Level0) 202 { 203 TEEC_Result ret; 204 TestMemData value = { 0 }; 205 206 value.oldSize = TESTSIZE; 207 value.accessFlags = 0; 208 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 209 #ifndef TEST_STUB 210 ASSERT_EQ(ret, TEEC_ERROR_ACCESS_DENIED); 211 #else 212 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 213 #endif 214 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 215 } 216 217 /** 218 * @testcase.name : TEE_CheckMemoryAccessRights_With_BufferIsNull 219 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer while assigned buffer is null 220 * @testcase.expect : return TEEC_ERROR_ACCESS_DENIED 221 */ 222 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_BufferIsNull, Function | MediumTest | Level0) 223 { 224 TEEC_Result ret; 225 TestMemData value = { 0 }; 226 227 value.oldSize = TESTSIZE; 228 value.accessFlags = TEE_MEMORY_ACCESS_READ; 229 value.caseId = INPUT_ISNULL; 230 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 231 #ifndef TEST_STUB 232 ASSERT_EQ(ret, TEEC_ERROR_ACCESS_DENIED); 233 #else 234 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 235 #endif 236 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 237 } 238 239 /** 240 * @testcase.name : TEE_CheckMemoryAccessRights_With_BufferIsParam 241 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer while assigned buffer is param type 242 * @testcase.expect : return TEEC_ERROR_ACCESS_DENIED 243 */ 244 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_BufferIsParam, Function | MediumTest | Level0) 245 { 246 TEEC_Result ret; 247 TestMemData value = { 0 }; 248 249 value.oldSize = TESTSIZE; 250 value.accessFlags = TEE_MEMORY_ACCESS_READ; 251 value.caseId = BUFFER_IS_PARAM; 252 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 253 #ifndef TEST_STUB 254 ASSERT_EQ(ret, TEEC_ERROR_ACCESS_DENIED); 255 #else 256 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 257 #endif 258 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 259 } 260 261 /** 262 * @testcase.name : TEE_CheckMemoryAccessRights_With_WriteRight_GlobalConstVar 263 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights while buffer is global variable 264 * @testcase.expect : return TEEC_ERROR_ACCESS_DENIED 265 */ 266 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_WriteRight_GlobalConstVar, Function | MediumTest | Level0) 267 { 268 TEEC_Result ret; 269 TestMemData value = { 0 }; 270 271 value.oldSize = TESTSIZE; 272 value.accessFlags = TEE_MEMORY_ACCESS_WRITE; 273 value.caseId = BUFFER_IS_GLOBALCONSTVAR; 274 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 275 #ifndef TEST_STUB 276 ASSERT_EQ(ret, TEEC_ERROR_ACCESS_DENIED); 277 #else 278 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 279 #endif 280 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 281 } 282 283 /** 284 * @testcase.name : TEE_CheckMemoryAccessRights_With_SizeIsTooBig 285 * @testcase.desc : test TA call TEE_CheckMemoryAccessRights to check buffer while size is too big 286 * @testcase.expect : return TEEC_ERROR_ACCESS_DENIED 287 */ 288 TEE_TEST(TeeTCF2Test, TEE_CheckMemoryAccessRights_With_SizeIsTooBig, Function | MediumTest | Level0) 289 { 290 TEEC_Result ret; 291 TestMemData value = { 0 }; 292 293 value.oldSize = TESTSIZE; 294 value.accessFlags = TEE_MEMORY_ACCESS_READ | TEE_MEMORY_ACCESS_WRITE; 295 value.caseId = BUFFERSIZE_ISTOOBIG; 296 ret = Invoke_CheckMemoryAccessRights(GetSession(), CMD_TEE_CheckMemoryAccessRights, &value); 297 #ifndef TEST_STUB 298 ASSERT_EQ(ret, TEEC_ERROR_ACCESS_DENIED); 299 #else 300 ASSERT_EQ(ret, TEEC_ERROR_NOT_SUPPORTED); 301 #endif 302 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 303 }