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 <stdlib.h> 17 #include <tee_client_api.h> 18 #include <tee_client_type.h> 19 #include <test_defines.h> 20 #include <test_log.h> 21 #include <test_tcf_cmdid.h> 22 23 using namespace testing::ext; 24 /** 25 * @testcase.name : TEE_Malloc_With_TEE_MALLOC_FILL_ZERO 26 * @testcase.desc : test TA call TEE_Malloc to alloc buffer 16 bytes with hint is TEE_MALLOC_FILL_ZERO 27 * @testcase.expect : return TEEC_SUCCESS 28 */ 29 TEE_TEST(TeeTCF2Test, TEE_Malloc_With_TEE_MALLOC_FILL_ZERO, Function | MediumTest | Level0) 30 { 31 TEEC_Result ret; 32 uint32_t origin; 33 char *buffer = reinterpret_cast<char *>(malloc(MAX_SHARE_SIZE)); 34 ASSERT_STRNE(buffer, NULL); 35 (void)memset_s(buffer, TESTSIZE, 0x41, TESTSIZE); // 0x41 = 'A' 36 37 TestMemData value = { 0 }; 38 value.inMemSize = TESTSIZE; 39 value.inHint = TEE_MALLOC_FILL_ZERO; 40 value.testBuffer = buffer; 41 ret = Invoke_Malloc(GetSession(), CMD_TEE_Malloc, &value, &origin); 42 EXPECT_EQ(ret, TEEC_SUCCESS); 43 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP); 44 EXPECT_STREQ(buffer, EXPECTBUFFER_ZERO); 45 free(buffer); 46 } 47 48 /** 49 * @testcase.name : TEE_Malloc_With_TEE_MALLOC_NO_FILL 50 * @testcase.desc : test TA call TEE_Malloc to alloc buffer 16 bytes with hint is TEE_MALLOC_NO_FILL, not support 51 * @testcase.expect : return TEEC_ERROR_GENERIC 52 */ 53 TEE_TEST(TeeTCF2Test, TEE_Malloc_With_TEE_MALLOC_NO_FILL, Function | MediumTest | Level0) 54 { 55 TEEC_Result ret; 56 uint32_t origin; 57 char *buffer = reinterpret_cast<char *>(malloc(MAX_SHARE_SIZE)); 58 ASSERT_STRNE(buffer, NULL); 59 (void)memset_s(buffer, TESTSIZE, 0x41, TESTSIZE); // 0x41 = 'A' 60 61 TestMemData value = { 0 }; 62 value.inMemSize = TESTSIZE; 63 value.inHint = TEE_MALLOC_NO_FILL; 64 value.testBuffer = buffer; 65 ret = Invoke_Malloc(GetSession(), CMD_TEE_Malloc, &value, &origin); 66 EXPECT_EQ(ret, TEEC_ERROR_GENERIC); 67 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP); 68 EXPECT_STREQ(buffer, EXPECTBUFFER_A); 69 free(buffer); 70 } 71 72 /** 73 * @testcase.name : TEE_Malloc_With_TEE_MALLOC_NO_SHARE 74 * @testcase.desc : test TA call TEE_Malloc to alloc buffer 16 bytes with hint is TEE_MALLOC_NO_SHARE 75 * @testcase.expect : return TEEC_SUCCESS 76 */ 77 TEE_TEST(TeeTCF2Test, TEE_Malloc_With_TEE_MALLOC_NO_SHARE, Function | MediumTest | Level0) 78 { 79 TEEC_Result ret; 80 uint32_t origin; 81 char *buffer = reinterpret_cast<char *>(malloc(MAX_SHARE_SIZE)); 82 ASSERT_STRNE(buffer, NULL); 83 (void)memset_s(buffer, TESTSIZE, 0x41, TESTSIZE); // 0x41 = 'A' 84 85 TestMemData value = { 0 }; 86 value.inMemSize = TESTSIZE; 87 value.inHint = TEE_MALLOC_NO_SHARE; 88 value.testBuffer = buffer; 89 ret = Invoke_Malloc(GetSession(), CMD_TEE_Malloc, &value, &origin); 90 EXPECT_EQ(ret, TEEC_SUCCESS); 91 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP); 92 EXPECT_STRNE(buffer, EXPECTBUFFER_A); 93 free(buffer); 94 } 95 96 /** 97 * @testcase.name : TEE_Malloc_With_TEE_MALLOC_NO_FILL_And_NO_SHARE 98 * @testcase.desc : test TA call TEE_Malloc to alloc 16 bytes with hint is TEE_MALLOC_NO_FILL|TEE_MALLOC_NO_SHARE 99 * @testcase.expect : return TEEC_SUCCESS 100 */ 101 TEE_TEST(TeeTCF2Test, TEE_Malloc_With_TEE_MALLOC_NO_FILL_And_NO_SHARE, Function | MediumTest | Level0) 102 { 103 TEEC_Result ret; 104 uint32_t origin; 105 char *buffer = reinterpret_cast<char *>(malloc(MAX_SHARE_SIZE)); 106 ASSERT_STRNE(buffer, NULL); 107 (void)memset_s(buffer, TESTSIZE, 0x41, TESTSIZE); // 0x41 = 'A' 108 109 TestMemData value = { 0 }; 110 value.inMemSize = TESTSIZE; 111 value.inHint = TEE_MALLOC_NO_FILL | TEE_MALLOC_NO_SHARE; 112 value.testBuffer = buffer; 113 ret = Invoke_Malloc(GetSession(), CMD_TEE_Malloc, &value, &origin); 114 EXPECT_EQ(ret, TEEC_SUCCESS); 115 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP); 116 EXPECT_STRNE(buffer, EXPECTBUFFER_A); 117 free(buffer); 118 } 119 120 /** 121 * @testcase.name : TEE_Malloc_With_HINT_RESERVE 122 * @testcase.desc : test TA call TEE_Malloc to alloc buffer 16 bytes with hint is HINT_RESERVE 123 * @testcase.expect : return TEEC_SUCCESS 124 */ 125 TEE_TEST(TeeTCF2Test, TEE_Malloc_With_HINT_RESERVE, Function | MediumTest | Level0) 126 { 127 TEEC_Result ret; 128 uint32_t origin; 129 char *buffer = reinterpret_cast<char *>(malloc(MAX_SHARE_SIZE)); 130 ASSERT_STRNE(buffer, NULL); 131 (void)memset_s(buffer, TESTSIZE, 0x41, TESTSIZE); // 0x41 = 'A' 132 133 TestMemData value = { 0 }; 134 value.inMemSize = TESTSIZE; 135 value.inHint = HINT_RESERVE; 136 value.testBuffer = buffer; 137 ret = Invoke_Malloc(GetSession(), CMD_TEE_Malloc, &value, &origin); 138 EXPECT_EQ(ret, TEEC_SUCCESS); 139 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP); 140 EXPECT_STRNE(buffer, EXPECTBUFFER_A); 141 free(buffer); 142 } 143 144 /** 145 * @testcase.name : TEE_Malloc_With_SIZEIsZero 146 * @testcase.desc : test TA call TEE_Malloc to alloc buffer with size is zero 147 * @testcase.expect : return TEEC_ERROR_GENERIC 148 */ 149 TEE_TEST(TeeTCF2Test, TEE_Malloc_With_SizeIsZero, Function | MediumTest | Level0) 150 { 151 TEEC_Result ret; 152 uint32_t origin; 153 char *buffer = reinterpret_cast<char *>(malloc(MAX_SHARE_SIZE)); 154 ASSERT_STRNE(buffer, NULL); 155 (void)memset_s(buffer, TESTSIZE, 0x0, TESTSIZE); 156 157 TestMemData value = { 0 }; 158 value.inMemSize = 0; 159 value.inHint = TEE_MALLOC_FILL_ZERO; 160 value.testBuffer = buffer; 161 ret = Invoke_Malloc(GetSession(), CMD_TEE_Malloc, &value, &origin); 162 EXPECT_EQ(ret, TEEC_ERROR_GENERIC); 163 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP); 164 free(buffer); 165 } 166 167 /** 168 * @testcase.name : TEE_Malloc_With_SizeExceedHeapLimit 169 * @testcase.desc : test TA call TEE_Malloc to alloc buffer with size exceed heaplimit 170 * @testcase.expect : return TEEC_ERROR_OUT_OF_MEMORY 171 */ 172 TEE_TEST(TeeTCF2Test, TEE_Malloc_With_SizeExceedHeapLimit, Function | MediumTest | Level0) 173 { 174 TEEC_Result ret; 175 uint32_t origin; 176 char *buffer = reinterpret_cast<char *>(malloc(MAX_SHARE_SIZE)); 177 ASSERT_STRNE(buffer, NULL); 178 (void)memset_s(buffer, TESTSIZE, 0x0, TESTSIZE); 179 180 uint32_t dateSize = get_ta_data_size(GetContext(), GetSession()); 181 EXPECT_GT(dateSize, 0); 182 183 uint32_t stackSize = get_ta_stack_size(GetContext(), GetSession()); 184 EXPECT_GT(stackSize, 0); 185 186 TestMemData value = { 0 }; 187 value.inMemSize = dateSize + stackSize; 188 value.inHint = TEE_MALLOC_FILL_ZERO; 189 value.testBuffer = buffer; 190 ret = Invoke_Malloc(GetSession(), CMD_TEE_Malloc, &value, &origin); 191 EXPECT_EQ(ret, TEEC_ERROR_OUT_OF_MEMORY); 192 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP); 193 free(buffer); 194 } 195 196 /** 197 * @testcase.name : TEE_Malloc_With_MAXDataSize 198 * @testcase.desc : test TA call TEE_Malloc to alloc buffer with size is max data size 199 * @testcase.expect : return TEEC_SUCCESS 200 */ 201 TEE_TEST(TeeTCF1Test, TEE_Malloc_With_MAXDataSize, Function | MediumTest | Level0) 202 { 203 TEEC_Result ret; 204 uint32_t origin; 205 char *buffer = reinterpret_cast<char *>(malloc(MAX_SHARE_SIZE)); 206 ASSERT_STRNE(buffer, NULL); 207 (void)memset_s(buffer, TESTSIZE, 0x41, TESTSIZE); // 0x41 = 'A' 208 209 uint32_t dateSize = get_ta_data_size(GetContext(), GetSession()); 210 EXPECT_GT(dateSize, 0); 211 212 TestMemData value = { 0 }; 213 value.inMemSize = dateSize; 214 value.inHint = TEE_MALLOC_FILL_ZERO; 215 value.testBuffer = buffer; 216 ret = Invoke_Malloc(GetSession(), CMD_TEE_Malloc, &value, &origin); 217 EXPECT_EQ(ret, TEEC_SUCCESS); 218 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP); 219 EXPECT_STREQ(buffer, EXPECTBUFFER_ZERO); 220 free(buffer); 221 } 222