1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <dlfcn.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 20 #include "hook_client.h" 21 #include "musl_preinit_common.h" 22 #include "init_param.h" 23 24 using namespace testing::ext; 25 26 namespace { 27 constexpr uint32_t g_size = 1024; 28 constexpr uint32_t g_resize = 2048; 29 const std::string MEM_FILTER("persist.hiviewdfx.profiler.mem.filter"); 30 31 class NativeHookTest : public ::testing::Test { 32 public: SetUpTestCase()33 static void SetUpTestCase() {} TearDownTestCase()34 static void TearDownTestCase() {} SetUp()35 void SetUp() {} TearDown()36 void TearDown() {} 37 }; 38 39 /** 40 * @tc.name: native hook 41 * @tc.desc: Test hook malloc normal process. 42 * @tc.type: FUNC 43 */ 44 HWTEST_F(NativeHookTest, NormalMallocHookTest, TestSize.Level1) 45 { 46 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 47 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 48 49 void* mallocBlack = ohos_malloc_hook_malloc(g_size); 50 EXPECT_NE(mallocBlack, nullptr); 51 52 ohos_malloc_hook_free(mallocBlack); 53 54 EXPECT_TRUE(ohos_malloc_hook_on_end()); 55 56 SystemSetParameter(MEM_FILTER.c_str(), "1,3"); 57 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 58 void* mallocBlack2 = ohos_malloc_hook_malloc(g_size); 59 EXPECT_NE(mallocBlack2, nullptr); 60 61 ohos_malloc_hook_free(mallocBlack2); 62 63 EXPECT_TRUE(ohos_malloc_hook_on_end()); 64 65 SystemSetParameter(MEM_FILTER.c_str(), "0,0"); 66 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 67 void* mallocBlack3 = ohos_malloc_hook_malloc(g_size); 68 EXPECT_NE(mallocBlack3, nullptr); 69 70 ohos_malloc_hook_free(mallocBlack3); 71 72 EXPECT_TRUE(ohos_malloc_hook_on_end()); 73 74 SystemSetParameter(MEM_FILTER.c_str(), "2048,4096"); 75 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 76 void* mallocBlack4 = ohos_malloc_hook_malloc(g_size); 77 EXPECT_NE(mallocBlack4, nullptr); 78 79 ohos_malloc_hook_free(mallocBlack4); 80 81 EXPECT_TRUE(ohos_malloc_hook_on_end()); 82 SystemSetParameter(MEM_FILTER.c_str(), "0"); 83 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 84 void* mallocBlack5 = ohos_malloc_hook_malloc(g_size); 85 EXPECT_NE(mallocBlack5, nullptr); 86 87 ohos_malloc_hook_free(mallocBlack5); 88 89 EXPECT_TRUE(ohos_malloc_hook_on_end()); 90 } 91 92 /** 93 * @tc.name: native hook 94 * @tc.desc: Test hook realloc normal process. 95 * @tc.type: FUNC 96 */ 97 HWTEST_F(NativeHookTest, NormalHookReallocTest, TestSize.Level1) 98 { 99 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 100 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 101 102 void* mallocBlack = ohos_malloc_hook_malloc(g_size); 103 EXPECT_NE(mallocBlack, nullptr); 104 void* reallocBlack = ohos_malloc_hook_realloc(mallocBlack, g_resize); 105 EXPECT_NE(reallocBlack, nullptr); 106 107 ohos_malloc_hook_free(reallocBlack); 108 109 EXPECT_TRUE(ohos_malloc_hook_on_end()); 110 111 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 112 void* mallocBlack2 = ohos_malloc_hook_malloc(g_size); 113 EXPECT_NE(mallocBlack2, nullptr); 114 void* reallocBlack2 = ohos_malloc_hook_realloc(mallocBlack2, g_size); 115 EXPECT_NE(reallocBlack2, nullptr); 116 117 ohos_malloc_hook_free(reallocBlack2); 118 119 EXPECT_TRUE(ohos_malloc_hook_on_end()); 120 } 121 122 /** 123 * @tc.name: native hook 124 * @tc.desc: Test hook calloc normal process. 125 * @tc.type: FUNC 126 */ 127 HWTEST_F(NativeHookTest, NormalHookCallocTest, TestSize.Level1) 128 { 129 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 130 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 131 132 void* callocBlack = ohos_malloc_hook_calloc(g_size, g_resize); 133 EXPECT_NE(callocBlack, nullptr); 134 135 ohos_malloc_hook_free(callocBlack); 136 137 EXPECT_TRUE(ohos_malloc_hook_on_end()); 138 139 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 140 void* callocBlack2 = ohos_malloc_hook_calloc(0, g_resize); 141 EXPECT_NE(callocBlack2, nullptr); 142 143 ohos_malloc_hook_free(callocBlack2); 144 145 EXPECT_TRUE(ohos_malloc_hook_on_end()); 146 } 147 148 /** 149 * @tc.name: native hook 150 * @tc.desc: Test hook valloc normal process. 151 * @tc.type: FUNC 152 */ 153 HWTEST_F(NativeHookTest, NormalHookVallocTest, TestSize.Level1) 154 { 155 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 156 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 157 158 void* vallocBlack = ohos_malloc_hook_valloc(g_size); 159 EXPECT_EQ(vallocBlack, nullptr); 160 161 ohos_malloc_hook_free(vallocBlack); 162 163 EXPECT_TRUE(ohos_malloc_hook_on_end()); 164 } 165 166 /** 167 * @tc.name: native hook 168 * @tc.desc: Test hook memalign normal process. 169 * @tc.type: FUNC 170 */ 171 HWTEST_F(NativeHookTest, NormalHookMemalignTest, TestSize.Level1) 172 { 173 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 174 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 175 176 void* memalignBlack = ohos_malloc_hook_memalign(g_size, g_resize); 177 EXPECT_EQ(memalignBlack, nullptr); 178 EXPECT_EQ(static_cast<int>(ohos_malloc_hook_malloc_usable_size(memalignBlack)), 0); 179 180 ohos_malloc_hook_free(memalignBlack); 181 182 EXPECT_TRUE(ohos_malloc_hook_on_end()); 183 } 184 185 /** 186 * @tc.name: native hook 187 * @tc.desc: Test multi hook malloc normal process. 188 * @tc.type: FUNC 189 */ 190 HWTEST_F(NativeHookTest, NormalTest, TestSize.Level1) 191 { 192 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 193 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 194 195 void* mallocBlack = ohos_malloc_hook_malloc(g_size); 196 EXPECT_NE(mallocBlack, nullptr); 197 void* reallocBlack = ohos_malloc_hook_realloc(mallocBlack, g_resize); 198 EXPECT_NE(reallocBlack, nullptr); 199 void* callocBlack = ohos_malloc_hook_calloc(g_size, g_resize); 200 EXPECT_NE(callocBlack, nullptr); 201 void* vallocBlack = ohos_malloc_hook_valloc(g_size); 202 EXPECT_EQ(vallocBlack, nullptr); 203 void* memalignBlack = ohos_malloc_hook_memalign(g_size, g_resize); 204 EXPECT_EQ(memalignBlack, nullptr); 205 EXPECT_EQ(static_cast<int>(ohos_malloc_hook_malloc_usable_size(memalignBlack)), 0); 206 207 ohos_malloc_hook_free(memalignBlack); 208 ohos_malloc_hook_free(vallocBlack); 209 ohos_malloc_hook_free(callocBlack); 210 ohos_malloc_hook_free(reallocBlack); 211 212 EXPECT_TRUE(ohos_malloc_hook_on_end()); 213 } 214 215 /** 216 * @tc.name: native hook 217 * @tc.desc: Test other process. 218 * @tc.type: FUNC 219 */ 220 HWTEST_F(NativeHookTest, NormalOtherTest, TestSize.Level1) 221 { 222 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 223 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 224 225 ohos_malloc_hook_finalize(); 226 227 EXPECT_TRUE(ohos_malloc_hook_on_end()); 228 } 229 230 /** 231 * @tc.name: native hook 232 * @tc.desc: Test failure process. 233 * @tc.type: FUNC 234 */ 235 HWTEST_F(NativeHookTest, FailureTest, TestSize.Level1) 236 { 237 EXPECT_TRUE(ohos_malloc_hook_initialize(nullptr, nullptr, nullptr)); 238 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 239 EXPECT_TRUE(ohos_malloc_hook_on_end()); 240 } 241 242 /** 243 * @tc.name: native hook 244 * @tc.desc: Test set and get malloc hook flag. 245 * @tc.type: FUNC 246 */ 247 HWTEST_F(NativeHookTest, MallocHookFlag, TestSize.Level1) 248 { 249 bool flag = true; 250 bool flagPrev = ohos_malloc_hook_set_hook_flag(flag); 251 252 EXPECT_EQ(ohos_malloc_hook_get_hook_flag(), flag); 253 EXPECT_EQ(ohos_malloc_hook_set_hook_flag(flagPrev), flag); 254 EXPECT_EQ(ohos_malloc_hook_get_hook_flag(), flagPrev); 255 256 EXPECT_TRUE(ohos_malloc_hook_set_hook_flag(false)); 257 EXPECT_FALSE(ohos_malloc_hook_get_hook_flag()); 258 } 259 } // namespace