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 EXPECT_TRUE(ohos_malloc_hook_on_end()); 179 } 180 181 /** 182 * @tc.name: native hook 183 * @tc.desc: Test multi hook malloc normal process. 184 * @tc.type: FUNC 185 */ 186 HWTEST_F(NativeHookTest, NormalTest, TestSize.Level1) 187 { 188 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 189 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 190 191 void* mallocBlack = ohos_malloc_hook_malloc(g_size); 192 EXPECT_NE(mallocBlack, nullptr); 193 void* reallocBlack = ohos_malloc_hook_realloc(mallocBlack, g_resize); 194 EXPECT_NE(reallocBlack, nullptr); 195 void* callocBlack = ohos_malloc_hook_calloc(g_size, g_resize); 196 EXPECT_NE(callocBlack, nullptr); 197 void* vallocBlack = ohos_malloc_hook_valloc(g_size); 198 EXPECT_EQ(vallocBlack, nullptr); 199 void* alignedAllocBlack = ohos_malloc_hook_aligned_alloc(g_size, g_resize); 200 EXPECT_NE(alignedAllocBlack, nullptr); 201 202 ohos_malloc_hook_free(alignedAllocBlack); 203 ohos_malloc_hook_free(vallocBlack); 204 ohos_malloc_hook_free(callocBlack); 205 ohos_malloc_hook_free(reallocBlack); 206 207 EXPECT_TRUE(ohos_malloc_hook_on_end()); 208 } 209 210 /** 211 * @tc.name: native hook 212 * @tc.desc: Test other process. 213 * @tc.type: FUNC 214 */ 215 HWTEST_F(NativeHookTest, NormalOtherTest, TestSize.Level1) 216 { 217 EXPECT_TRUE(ohos_malloc_hook_initialize(&__libc_malloc_default_dispatch, nullptr, nullptr)); 218 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 219 220 ohos_malloc_hook_finalize(); 221 222 EXPECT_TRUE(ohos_malloc_hook_on_end()); 223 } 224 225 /** 226 * @tc.name: native hook 227 * @tc.desc: Test failure process. 228 * @tc.type: FUNC 229 */ 230 HWTEST_F(NativeHookTest, FailureTest, TestSize.Level1) 231 { 232 EXPECT_TRUE(ohos_malloc_hook_initialize(nullptr, nullptr, nullptr)); 233 EXPECT_TRUE(ohos_malloc_hook_on_start(nullptr)); 234 EXPECT_TRUE(ohos_malloc_hook_on_end()); 235 } 236 237 /** 238 * @tc.name: native hook 239 * @tc.desc: Test set and get malloc hook flag. 240 * @tc.type: FUNC 241 */ 242 HWTEST_F(NativeHookTest, MallocHookFlag, TestSize.Level1) 243 { 244 bool flag = true; 245 bool flagPrev = ohos_malloc_hook_set_hook_flag(flag); 246 247 EXPECT_EQ(ohos_malloc_hook_get_hook_flag(), flag); 248 EXPECT_EQ(ohos_malloc_hook_set_hook_flag(flagPrev), flag); 249 EXPECT_EQ(ohos_malloc_hook_get_hook_flag(), flagPrev); 250 251 EXPECT_TRUE(ohos_malloc_hook_set_hook_flag(false)); 252 EXPECT_FALSE(ohos_malloc_hook_get_hook_flag()); 253 } 254 } // namespace