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