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 <gtest/gtest.h> 18 #include "hook_client.h" 19 #include "musl_preinit_common.h" 20 #include "init_param.h" 21 22 using namespace testing::ext; 23 24 namespace { 25 constexpr uint32_t g_size = 1024; 26 constexpr uint32_t g_resize = 2048; 27 constexpr unsigned int WAIT_THREAD_TIME = 3; 28 const std::string MEM_FILTER("persist.hiviewdfx.profiler.mem.filter"); 29 30 class NativeHookTest : public ::testing::Test { 31 public: SetUpTestCase()32 static void SetUpTestCase() {} TearDownTestCase()33 static void TearDownTestCase() {} SetUp()34 void SetUp() {} TearDown()35 void TearDown() {} 36 }; 37 38 /** 39 * @tc.name: native hook 40 * @tc.desc: Test hook malloc normal process. 41 * @tc.type: FUNC 42 */ 43 HWTEST_F(NativeHookTest, NormalMallocHookTest, TestSize.Level1) 44 { 45 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 46 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 47 48 void* mallocBlack = ohos_malloc_hook_malloc(g_size); 49 EXPECT_NE(mallocBlack, nullptr); 50 51 ohos_malloc_hook_free(mallocBlack); 52 53 EXPECT_TRUE(ohos_malloc_hook_on_end()); 54 55 SystemSetParameter(MEM_FILTER.c_str(), "1,3"); 56 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 57 void* mallocBlack2 = ohos_malloc_hook_malloc(g_size); 58 EXPECT_NE(mallocBlack2, nullptr); 59 60 ohos_malloc_hook_free(mallocBlack2); 61 62 EXPECT_TRUE(ohos_malloc_hook_on_end()); 63 64 SystemSetParameter(MEM_FILTER.c_str(), "0,0"); 65 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 66 void* mallocBlack3 = ohos_malloc_hook_malloc(g_size); 67 EXPECT_NE(mallocBlack3, nullptr); 68 69 ohos_malloc_hook_free(mallocBlack3); 70 71 EXPECT_TRUE(ohos_malloc_hook_on_end()); 72 73 SystemSetParameter(MEM_FILTER.c_str(), "2048,4096"); 74 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 75 void* mallocBlack4 = ohos_malloc_hook_malloc(g_size); 76 EXPECT_NE(mallocBlack4, nullptr); 77 78 ohos_malloc_hook_free(mallocBlack4); 79 80 EXPECT_TRUE(ohos_malloc_hook_on_end()); 81 SystemSetParameter(MEM_FILTER.c_str(), "0"); 82 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 83 void* mallocBlack5 = ohos_malloc_hook_malloc(g_size); 84 EXPECT_NE(mallocBlack5, nullptr); 85 86 ohos_malloc_hook_free(mallocBlack5); 87 88 EXPECT_TRUE(ohos_malloc_hook_on_end()); 89 sleep(WAIT_THREAD_TIME); 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 sleep(WAIT_THREAD_TIME); 121 } 122 123 /** 124 * @tc.name: native hook 125 * @tc.desc: Test hook calloc normal process. 126 * @tc.type: FUNC 127 */ 128 HWTEST_F(NativeHookTest, NormalHookCallocTest, TestSize.Level1) 129 { 130 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 131 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 132 133 void* callocBlack = ohos_malloc_hook_calloc(g_size, g_resize); 134 EXPECT_NE(callocBlack, nullptr); 135 136 ohos_malloc_hook_free(callocBlack); 137 138 EXPECT_TRUE(ohos_malloc_hook_on_end()); 139 140 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 141 void* callocBlack2 = ohos_malloc_hook_calloc(0, g_resize); 142 EXPECT_NE(callocBlack2, nullptr); 143 144 ohos_malloc_hook_free(callocBlack2); 145 146 EXPECT_TRUE(ohos_malloc_hook_on_end()); 147 sleep(WAIT_THREAD_TIME); 148 } 149 150 /** 151 * @tc.name: native hook 152 * @tc.desc: Test hook valloc normal process. 153 * @tc.type: FUNC 154 */ 155 HWTEST_F(NativeHookTest, NormalHookVallocTest, TestSize.Level1) 156 { 157 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 158 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 159 160 void* vallocBlack = ohos_malloc_hook_valloc(g_size); 161 EXPECT_EQ(vallocBlack, nullptr); 162 163 ohos_malloc_hook_free(vallocBlack); 164 165 EXPECT_TRUE(ohos_malloc_hook_on_end()); 166 sleep(WAIT_THREAD_TIME); 167 } 168 169 /** 170 * @tc.name: native hook 171 * @tc.desc: Test hook aligned alloc normal process. 172 * @tc.type: FUNC 173 */ 174 HWTEST_F(NativeHookTest, NormalHookAlignedAllocTest, TestSize.Level1) 175 { 176 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 177 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 178 179 void* alignedAllocBlack = ohos_malloc_hook_aligned_alloc(g_size, g_resize); 180 EXPECT_NE(alignedAllocBlack, nullptr); 181 182 ohos_malloc_hook_free(alignedAllocBlack); 183 184 EXPECT_TRUE(ohos_malloc_hook_on_end()); 185 sleep(WAIT_THREAD_TIME); 186 } 187 188 /** 189 * @tc.name: native hook 190 * @tc.desc: Test multi hook malloc normal process. 191 * @tc.type: FUNC 192 */ 193 HWTEST_F(NativeHookTest, NormalTest, TestSize.Level1) 194 { 195 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 196 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 197 198 void* mallocBlack = ohos_malloc_hook_malloc(g_size); 199 EXPECT_NE(mallocBlack, nullptr); 200 void* reallocBlack = ohos_malloc_hook_realloc(mallocBlack, g_resize); 201 EXPECT_NE(reallocBlack, nullptr); 202 void* callocBlack = ohos_malloc_hook_calloc(g_size, g_resize); 203 EXPECT_NE(callocBlack, nullptr); 204 void* vallocBlack = ohos_malloc_hook_valloc(g_size); 205 EXPECT_EQ(vallocBlack, nullptr); 206 void* alignedAllocBlack = ohos_malloc_hook_aligned_alloc(g_size, g_resize); 207 EXPECT_NE(alignedAllocBlack, nullptr); 208 209 ohos_malloc_hook_free(alignedAllocBlack); 210 ohos_malloc_hook_free(vallocBlack); 211 ohos_malloc_hook_free(callocBlack); 212 ohos_malloc_hook_free(reallocBlack); 213 214 EXPECT_TRUE(ohos_malloc_hook_on_end()); 215 sleep(WAIT_THREAD_TIME); 216 } 217 218 /** 219 * @tc.name: native hook 220 * @tc.desc: Test other process. 221 * @tc.type: FUNC 222 */ 223 HWTEST_F(NativeHookTest, NormalOtherTest, TestSize.Level1) 224 { 225 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 226 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 227 228 ohos_malloc_hook_finalize(); 229 230 EXPECT_TRUE(ohos_malloc_hook_on_end()); 231 sleep(WAIT_THREAD_TIME); 232 } 233 234 /** 235 * @tc.name: native hook 236 * @tc.desc: Test failure process. 237 * @tc.type: FUNC 238 */ 239 HWTEST_F(NativeHookTest, FailureTest, TestSize.Level1) 240 { 241 EXPECT_TRUE(ohos_malloc_hook_initialize(nullptr, nullptr, nullptr)); 242 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 243 EXPECT_TRUE(ohos_malloc_hook_on_end()); 244 sleep(WAIT_THREAD_TIME); 245 } 246 247 /** 248 * @tc.name: native hook 249 * @tc.desc: Test set and get malloc hook flag. 250 * @tc.type: FUNC 251 */ 252 HWTEST_F(NativeHookTest, MallocHookFlag, TestSize.Level1) 253 { 254 bool flag = true; 255 bool flagPrev = ohos_malloc_hook_set_hook_flag(flag); 256 257 EXPECT_EQ(ohos_malloc_hook_get_hook_flag(), flag); 258 EXPECT_EQ(ohos_malloc_hook_set_hook_flag(flagPrev), flag); 259 EXPECT_EQ(ohos_malloc_hook_get_hook_flag(), flagPrev); 260 261 EXPECT_TRUE(ohos_malloc_hook_set_hook_flag(false)); 262 EXPECT_FALSE(ohos_malloc_hook_get_hook_flag()); 263 } 264 } // namespace