Skip to content

T
Third Party Musl

OpenHarmony / Third Party Musl
接近 2 年 前同步成功

通知 37
Star 125
Fork 0
T
Third Party Musl
未验证 提交 03a3c130 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!351 加载器地址随机化，RELRO共享机制 

Merge pull request !351 from 王家辉/update_code_rm011_0623_1
上级 1cbbf7c5 6f6a38a5
展开全部 隐藏空白更改
内联 并排
Showing with 3033 addition and 16 deletion
libc-test/src/functionalext/ldso_randomization/BUILD.gn 0 → 100644
浏览文件 @ 03a3c130
# Copyright (c) 2022 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("../../../test_template.gni")
test_unittest("ldso_randomization_test") {
target_dir = "functionalext/ldso_randomization"
}
test_unittest("ldso_randomization_manual") {
target_dir = "functionalext/ldso_randomization"
}
ohos_shared_library("ldso_randomization_dep_e") {
include_dirs = [ "." ]
sources = [ "ldso_randomization_dep_e.c" ]
output_name = "ldso_randomization_dep_e"
output_extension = "so"
subsystem_name = "musl"
part_name = "libc-test-lib"
}
ohos_shared_library("ldso_randomization_dep_d") {
include_dirs = [ "." ]
sources = [ "ldso_randomization_dep_d.c" ]
output_name = "ldso_randomization_dep_d"
output_extension = "so"
subsystem_name = "musl"
part_name = "libc-test-lib"
}
ohos_shared_library("ldso_randomization_dep_c") {
include_dirs = [ "." ]
sources = [ "ldso_randomization_dep_c.c" ]
output_name = "ldso_randomization_dep_c"
output_extension = "so"
subsystem_name = "musl"
part_name = "libc-test-lib"
}
ohos_shared_library("ldso_randomization_dep_b") {
include_dirs = [ "." ]
sources = [ "ldso_randomization_dep_b.c" ]
output_name = "ldso_randomization_dep_b"
output_extension = "so"
deps = [
":ldso_randomization_dep_d",
":ldso_randomization_dep_e",
]
subsystem_name = "musl"
part_name = "libc-test-lib"
}
ohos_shared_library("ldso_randomization_dep_a") {
include_dirs = [ "." ]
sources = [ "ldso_randomization_dep_a.c" ]
output_name = "ldso_randomization_dep_a"
output_extension = "so"
deps = [
":ldso_randomization_dep_b",
":ldso_randomization_dep_c",
]
subsystem_name = "musl"
part_name = "libc-test-lib"
}
ohos_shared_library("ldso_randomization_dep") {
include_dirs = [ "." ]
sources = [ "ldso_randomization_dep.c" ]
output_name = "ldso_randomization_dep"
output_extension = "so"
subsystem_name = "musl"
part_name = "libc-test-lib"
}
group("functionalext_ldso_randomization_test") {
testonly = true
deps = [
":ldso_randomization_dep",
":ldso_randomization_dep_a",
":ldso_randomization_manual",
":ldso_randomization_test",
]
}
libc-test/src/functionalext/ldso_randomization/ldso_randomization_dep.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
int i = 0;
void test(void)
{
i++;
}
\ No newline at end of file
libc-test/src/functionalext/ldso_randomization/ldso_randomization_dep.h 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LDSO_RANDOMIZATION_DEP_H
#define LDSO_RANDOMIZATION_DEP_H
int test(void);
int test_b(void);
int test_c(void);
int test_d(void);
int test_e(void);
#endif
\ No newline at end of file
libc-test/src/functionalext/ldso_randomization/ldso_randomization_dep_a.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ldso_randomization_dep.h"
int i = 0;
int test(void)
{
i++;
return test_b() + test_c();
}
\ No newline at end of file
libc-test/src/functionalext/ldso_randomization/ldso_randomization_dep_b.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ldso_randomization_dep.h"
static int i = 0;
int test_b(void)
{
test_d();
test_e();
return i++;
}
\ No newline at end of file
libc-test/src/functionalext/ldso_randomization/ldso_randomization_dep_c.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ldso_randomization_dep.h"
static int i = 0;
int test_c(void)
{
return i++;
}
\ No newline at end of file
libc-test/src/functionalext/ldso_randomization/ldso_randomization_dep_d.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ldso_randomization_dep.h"
static int i = 0;
int test_d(void)
{
return i++;
}
\ No newline at end of file
libc-test/src/functionalext/ldso_randomization/ldso_randomization_dep_e.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ldso_randomization_dep.h"
static int i = 0;
int test_e(void)
{
return i++;
}
\ No newline at end of file
libc-test/src/functionalext/ldso_randomization/ldso_randomization_manual.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <dlfcn_ext.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include "test.h"
#define PIPE_FD 2
#define TEST_COUNTS 32
const char *LIB_NAME = "./libldso_randomization_dep.so";
const char *LIB_NAME_A = "./libldso_randomization_dep_a.so";
typedef void (*TEST_FUNC)(void);
static uintptr_t compare(const void *a, const void *b)
{
return (*(uintptr_t *)a - *(uintptr_t *)b);
}
static bool check_address(void **array, size_t length)
{
qsort(array, length, sizeof(void *), (void *)compare);
for (size_t i = 0, j = 1; j < length; i++, j++) {
if (array[i] == array[j]) {
return false;
}
}
return true;
}
/**
* @tc.name : dlopen_randomization_0500
* @tc.desc : Repeatedly calling the dlopen interface to load the dynamic library,
* and calling dlclose to unload each time
* @tc.level : Level3
*/
static void dlopen_randomization_0500(void)
{
void *handles[TEST_COUNTS] = {0};
void *handle = 0;
int i = TEST_COUNTS;
do {
handle = dlopen(LIB_NAME, RTLD_NOW);
handles[--i] = handle;
if (handle) {
dlclose(handle);
}
} while (i);
if (check_address(handles, TEST_COUNTS)) {
t_printf("%s handles are randomized\n", __FUNCTION__);
} else {
t_printf("%s exists the same handle!!!!\n", __FUNCTION__);
}
}
/**
* @tc.name : dlopen_randomization_0700
* @tc.desc : Different processes call the dlopen interface to load dynamic libraries
* @tc.level : Level3
*/
static void dlopen_randomization_0700(void)
{
void *parent_handle = 0;
void *get_child_handle = 0;
int fd[PIPE_FD];
if (pipe(fd) < 0) {
t_printf("%s create pipe error!\n", __FUNCTION__);
return;
}
pid_t pid = fork();
if (pid == 0) {
void *child_handle = dlopen(LIB_NAME, RTLD_NOW);
t_printf("%s child handle is %p \n", __FUNCTION__, child_handle);
if (child_handle) {
dlclose(child_handle);
}
write(fd[1], &child_handle, sizeof(void *));
exit(0);
}
parent_handle = dlopen(LIB_NAME, RTLD_NOW);
t_printf("%s parent handle is %p \n", __FUNCTION__, parent_handle);
if (parent_handle) {
dlclose(parent_handle);
}
int status;
waitpid(pid, &status, 0);
read(fd[0], &get_child_handle, sizeof(void *));
t_printf("%s get child handle is %p\n", __FUNCTION__, get_child_handle);
if (parent_handle == get_child_handle) {
t_printf("%s the parent handle is the same as the child handle!!!!\n", __FUNCTION__);
} else {
t_printf("%s the parent handle is different form the child handle.\n", __FUNCTION__);
}
close(fd[0]);
close(fd[1]);
}
/**
* @tc.name : dlopen_ext_randomization_0500
* @tc.desc : Repeatedly calling the dlopen_ext interface to load the dynamic library,
* and calling dlclose to unload each time
* @tc.level : Level3
*/
static void dlopen_ext_randomization_0500(void)
{
dl_extinfo extinfo = {0};
void *handles[TEST_COUNTS] = {0};
void *handle = 0;
int i = TEST_COUNTS;
do {
handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
handles[--i] = handle;
if (handle) {
dlclose(handle);
}
} while (i);
if (check_address(handles, TEST_COUNTS)) {
t_printf("%s handles are randomized\n", __FUNCTION__);
} else {
t_printf("%s exists the same handle!!!!\n", __FUNCTION__);
}
}
/**
* @tc.name : dlopen_ext_randomization_0700
* @tc.desc : Different processes call the dlopen_ext interface to load dynamic libraries
* @tc.level : Level3
*/
static void dlopen_ext_randomization_0700(void)
{
void *parent_handle = 0;
void *get_child_handle = 0;
dl_extinfo extinfo = {0};
int fd[PIPE_FD];
if (pipe(fd) < 0) {
t_printf("%s create pipe error!\n", __FUNCTION__);
return;
}
pid_t pid = fork();
if (pid == 0) {
void *child_handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
t_printf("%s child handle is %p \n", __FUNCTION__, child_handle);
if (child_handle) {
dlclose(child_handle);
}
write(fd[1], &child_handle, sizeof(void *));
exit(0);
}
parent_handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
t_printf("%s parent handle is %p \n", __FUNCTION__, parent_handle);
if (parent_handle) {
dlclose(parent_handle);
}
int status;
waitpid(pid, &status, 0);
read(fd[0], &get_child_handle, sizeof(void *));
t_printf("%s get child handle is %p\n", __FUNCTION__, get_child_handle);
if (parent_handle == get_child_handle) {
t_printf("%s the parent handle is the same as the child handle!!!!\n", __FUNCTION__);
} else {
t_printf("%s the parent handle is different form the child handle.\n", __FUNCTION__);
}
close(fd[0]);
close(fd[1]);
}
/**
* @tc.name : dlopen_ns_randomization_0500
* @tc.desc : Repeatedly calling the dlopen_ns interface to load the dynamic library,
* and calling dlclose to unload each time
* @tc.level : Level3
*/
static void dlopen_ns_randomization_0500(void)
{
Dl_namespace dlns;
dlns_init(&dlns, __FUNCTION__);
dlns_create(&dlns, "./");
void *handles[TEST_COUNTS] = {0};
void *handle = 0;
int i = TEST_COUNTS;
do {
handle = dlopen_ns(&dlns, LIB_NAME, RTLD_NOW);
handles[--i] = handle;
if (handle) {
dlclose(handle);
}
} while (i);
if (check_address(handles, TEST_COUNTS)) {
t_printf("%s handles are randomized\n", __FUNCTION__);
} else {
t_printf("%s exists the same handle!!!!\n", __FUNCTION__);
}
}
/**
* @tc.name : dlopen_ns_randomization_0700
* @tc.desc : Different processes call the dlopen_ns interface to load dynamic libraries
* @tc.level : Level3
*/
static void dlopen_ns_randomization_0700(void)
{
Dl_namespace dlns;
dlns_init(&dlns, __FUNCTION__);
dlns_create(&dlns, "./");
void *parent_handle = 0;
void *get_child_handle = 0;
int fd[PIPE_FD];
if (pipe(fd) < 0) {
t_printf("%s create pipe error!\n", __FUNCTION__);
return;
}
pid_t pid = fork();
if (pid == 0) {
void *child_handle = dlopen_ns(&dlns, LIB_NAME, RTLD_NOW);
t_printf("%s child handle is %p \n", __FUNCTION__, child_handle);
if (child_handle) {
dlclose(child_handle);
}
write(fd[1], &child_handle, sizeof(void *));
exit(0);
}
parent_handle = dlopen_ns(&dlns, LIB_NAME, RTLD_NOW);
t_printf("%s parent handle is %p \n", __FUNCTION__, parent_handle);
if (parent_handle) {
dlclose(parent_handle);
}
int status;
waitpid(pid, &status, 0);
read(fd[0], &get_child_handle, sizeof(void *));
t_printf("%s get child handle is %p\n", __FUNCTION__, get_child_handle);
if (parent_handle == get_child_handle) {
t_printf("%s the parent handle is the same as the child handle!!!!\n", __FUNCTION__);
} else {
t_printf("%s the parent handle is different form the child handle.\n", __FUNCTION__);
}
close(fd[0]);
close(fd[1]);
}
/**
* @tc.name : dlsym_randomization_0100
* @tc.desc : Repeatedly calling the dlsym interface to get symbol address, and calling dlclose to unload each time
* @tc.level : Level3
*/
static void dlsym_randomization_0100(void)
{
void *handle = dlopen(LIB_NAME, RTLD_NOW);
if (!handle) {
t_printf("%s dlopen failed: %s\n", __FUNCTION__, LIB_NAME);
return;
};
void *sym = dlsym(handle, "test");
t_printf("%s symbol address is %p\n", __FUNCTION__, sym);
dlclose(handle);
}
/**
* @tc.name : dlsym_randomization_0200
* @tc.desc : Different processes call the dlsym interface to get symbol address
* @tc.level : Level3
*/
static void dlsym_randomization_0200(void)
{
void *parent_handle = 0;
void *child_handle = 0;
void *parent_sym = 0;
void *child_sym = 0;
void *get_child_sym = 0;
int fd[PIPE_FD];
if (pipe(fd) < 0) {
t_printf("%s create pipe error!\n", __FUNCTION__);
return;
}
pid_t pid = fork();
if (pid == 0) {
child_handle = dlopen(LIB_NAME_A, RTLD_NOW);
if (!child_handle) {
t_printf("%s child process dlopen failed: %s\n", __FUNCTION__, LIB_NAME_A);
exit(-1);
}
child_sym = dlsym(child_handle, "test");
t_printf("%s child sym is %p\n", __FUNCTION__, child_sym);
write(fd[1], &child_sym, sizeof(void *));
dlclose(child_handle);
exit(0);
}
parent_handle = dlopen(LIB_NAME_A, RTLD_NOW);
if (!parent_handle) {
t_printf("%s parent process dlopen failed: %s\n", __FUNCTION__, LIB_NAME_A);
return;
};
parent_sym = dlsym(parent_handle, "test");
t_printf("%s parent sym is %p\n", __FUNCTION__, parent_sym);
dlclose(parent_handle);
int status;
waitpid(pid, &status, 0);
read(fd[0], &get_child_sym, sizeof(void *));
if (parent_sym == get_child_sym) {
t_printf("%s the parent sym is the same as the child sym!!!!\n", __FUNCTION__);
} else {
t_printf("%s the parent sym is different form the child sym.\n", __FUNCTION__);
}
close(fd[0]);
close(fd[1]);
}
TEST_FUNC test_cases[] = {
dlopen_randomization_0500,
dlopen_randomization_0700,
dlopen_ext_randomization_0500,
dlopen_ext_randomization_0700,
dlopen_ns_randomization_0500,
dlopen_ns_randomization_0700,
dlsym_randomization_0100,
dlsym_randomization_0200,
};
int main(int argc, char *argv[])
{
size_t case_counts = sizeof test_cases / sizeof(TEST_FUNC);
for (size_t case_num = 0; case_num < case_counts; case_num++) {
test_cases[case_num]();
}
return t_status;
}
\ No newline at end of file
libc-test/src/functionalext/ldso_randomization/ldso_randomization_test.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <dlfcn_ext.h>
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include "functionalext.h"
#define NUM_OF_BYTE 8
#define BASE_NUM 11
#define TEST_COUNTS 32
const char *LIB_NAME = "./libldso_randomization_dep.so";
const char *LIB_NAME_A = "./libldso_randomization_dep_a.so";
typedef void (*TEST_FUNC)(void);
int g_test = BASE_NUM;
extern void test_f(void)
{
++g_test;
}
/**
* @tc.name : dlopen_randomization_0100
* @tc.desc : Call the dlopen interface to load a valid dynamic library
* @tc.level : Level0
*/
static void dlopen_randomization_0100(void)
{
void *handle = dlopen(LIB_NAME, RTLD_NOW);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (handle) {
EXPECT_EQ(__FUNCTION__, dlclose(handle), 0);
}
}
/**
* @tc.name : dlopen_randomization_0200
* @tc.desc : Call the dlopen interface to load NULL
* @tc.level : Level1
*/
static void dlopen_randomization_0200(void)
{
void *handle = dlopen(NULL, RTLD_NOW);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (!handle) {
return;
};
int *i = dlsym(handle, "g_test");
EXPECT_PTRNE(__FUNCTION__, i, 0);
if (!i) {
dlclose(handle);
return;
}
EXPECT_EQ(__FUNCTION__, BASE_NUM, *i);
TEST_FUNC test = (TEST_FUNC)dlsym(handle, "test_f");
EXPECT_PTRNE(__FUNCTION__, test, 0);
if (!test) {
dlclose(handle);
return;
}
test();
EXPECT_EQ(__FUNCTION__, BASE_NUM + 1, g_test);
g_test = BASE_NUM;
dlclose(handle);
}
/**
* @tc.name : dlopen_randomization_0300
* @tc.desc : Call the dlopen interface to load a invalid dynamic library
* @tc.level : Level2
*/
static void dlopen_randomization_0300(void)
{
void *handle = dlopen("test_invaild.so", RTLD_NOW);
EXPECT_PTREQ(__FUNCTION__, handle, 0);
if (handle) {
dlclose(handle);
}
}
/**
* @tc.name : dlopen_randomization_0400
* @tc.desc : Repeatedly calling the dlopen interface to load the same dynamic library
* @tc.level : Level1
*/
static void dlopen_randomization_0400(void)
{
void *ori_handle = dlopen(LIB_NAME, RTLD_NOW);
void *handle = 0;
EXPECT_PTRNE(__FUNCTION__, ori_handle, 0);
if (!ori_handle) {
return;
}
int i = TEST_COUNTS;
while (i--) {
handle = dlopen(LIB_NAME, RTLD_NOW);
EXPECT_PTREQ(__FUNCTION__, ori_handle, handle);
}
i = TEST_COUNTS + 1;
while (i--) {
dlclose(ori_handle);
}
}
/**
* @tc.name : dlopen_randomization_0600
* @tc.desc : Call the dlopen interface to load a invalid dynamic library,
* and call the dlsym interface to get symbol address
* @tc.level : Level1
*/
static void dlopen_randomization_0600(void)
{
void *handle;
int *i;
TEST_FUNC test;
handle = dlopen(LIB_NAME, RTLD_NOW);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (!handle) {
return;
}
i = dlsym(handle, "i");
EXPECT_PTRNE(__FUNCTION__, i, 0);
if (!i) {
dlclose(handle);
return;
}
EXPECT_EQ(__FUNCTION__, *i, 0);
test = (TEST_FUNC)dlsym(handle, "test");
EXPECT_PTRNE(__FUNCTION__, test, 0);
if (!test) {
dlclose(handle);
return;
}
test();
EXPECT_EQ(__FUNCTION__, *i, 1);
dlclose(handle);
}
/**
* @tc.name : dlopen_ext_randomization_0100
* @tc.desc : Call the dlopen_ext interface to load a valid dynamic library
* @tc.level : Level0
*/
static void dlopen_ext_randomization_0100(void)
{
dl_extinfo extinfo = {0};
void *handle = dlopen_ext(LIB_NAME_A, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (handle) {
EXPECT_EQ(__FUNCTION__, dlclose(handle), 0);
}
}
/**
* @tc.name : dlopen_ext_randomization_0200
* @tc.desc : Call the dlopen interface to load NULL
* @tc.level : Level1
*/
static void dlopen_ext_randomization_0200(void)
{
dl_extinfo extinfo = {0};
void *handle = dlopen_ext(NULL, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (!handle) {
return;
}
int *i = dlsym(handle, "g_test");
EXPECT_PTRNE(__FUNCTION__, i, 0);
if (!i) {
dlclose(handle);
return;
}
EXPECT_EQ(__FUNCTION__, BASE_NUM, *i);
TEST_FUNC test = (TEST_FUNC)dlsym(handle, "test_f");
EXPECT_PTRNE(__FUNCTION__, test, 0);
if (!test) {
dlclose(handle);
return;
}
test();
EXPECT_EQ(__FUNCTION__, BASE_NUM + 1, g_test);
g_test = BASE_NUM;
dlclose(handle);
}
/**
* @tc.name : dlopen_ext_randomization_0300
* @tc.desc : Call the dlopen interface to load a invalid dynamic library
* @tc.level : Level2
*/
static void dlopen_ext_randomization_0300(void)
{
dl_extinfo extinfo = {0};
void *handle = dlopen_ext("test_invaild.so", RTLD_NOW, &extinfo);
EXPECT_PTREQ(__FUNCTION__, handle, 0);
if (handle) {
dlclose(handle);
}
}
/**
* @tc.name : dlopen_ext_randomization_0400
* @tc.desc : Repeatedly calling the dlopen_ext interface to load the same dynamic library
* @tc.level : Level1
*/
static void dlopen_ext_randomization_0400(void)
{
dl_extinfo extinfo = {0};
void *ori_handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
void *handle = 0;
EXPECT_PTRNE(__FUNCTION__, ori_handle, 0);
if (!ori_handle) {
return;
}
int i = TEST_COUNTS;
while (i--) {
handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_PTREQ(__FUNCTION__, ori_handle, handle);
}
i = TEST_COUNTS + 1;
while (i--) {
dlclose(ori_handle);
}
}
/**
* @tc.name : dlopen_ext_randomization_0600
* @tc.desc : Call the dlopen_ext interface to load a invalid dynamic library,
* and call the dlsym interface to get symbol address
* @tc.level : Level1
*/
static void dlopen_ext_randomization_0600(void)
{
void *handle;
int *i;
TEST_FUNC test;
dl_extinfo extinfo = {0};
handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (!handle) {
return;
}
i = dlsym(handle, "i");
EXPECT_PTRNE(__FUNCTION__, i, 0);
if (!i) {
dlclose(handle);
return;
}
EXPECT_EQ(__FUNCTION__, *i, 0);
test = (TEST_FUNC)dlsym(handle, "test");
EXPECT_PTRNE(__FUNCTION__, test, 0);
if (!test) {
dlclose(handle);
return;
}
test();
EXPECT_EQ(__FUNCTION__, *i, 1);
dlclose(handle);
}
/**
* @tc.name : dlopen_ext_randomization_0800
* @tc.desc : The flag of dl_extinfo is set to DL_EXT_RESERVED_ADDRESS_RECURSIVE,
* call the dlopen_ext interface to load a valid dynamic library
* @tc.level : Level1
*/
static void dlopen_ext_randomization_0800(void)
{
dl_extinfo extinfo = {
.flag = DL_EXT_RESERVED_ADDRESS_RECURSIVE,
};
void *handle = dlopen_ext(NULL, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (!handle) {
return;
}
int *i = dlsym(handle, "g_test");
EXPECT_PTRNE(__FUNCTION__, i, 0);
if (!i) {
dlclose(handle);
return;
}
EXPECT_EQ(__FUNCTION__, BASE_NUM, *i);
TEST_FUNC test = (TEST_FUNC)dlsym(handle, "test_f");
EXPECT_PTRNE(__FUNCTION__, test, 0);
if (!test) {
dlclose(handle);
return;
}
test();
EXPECT_EQ(__FUNCTION__, BASE_NUM + 1, *i);
g_test = BASE_NUM;
dlclose(handle);
}
/**
* @tc.name : dlopen_ns_randomization_0100
* @tc.desc : Call the dlopen_ns interface to load a valid dynamic library
* @tc.level : Level0
*/
static void dlopen_ns_randomization_0100(void)
{
Dl_namespace dlns;
dlns_init(&dlns, __FUNCTION__);
dlns_create(&dlns, "./");
void *handle = dlopen_ns(&dlns, LIB_NAME, RTLD_NOW);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (handle) {
EXPECT_EQ(__FUNCTION__, dlclose(handle), 0);
}
}
/**
* @tc.name : dlopen_ns_randomization_0200
* @tc.desc : Call the dlopen_ns interface to load NULL
* @tc.level : Level1
*/
static void dlopen_ns_randomization_0200(void)
{
Dl_namespace dlns;
dlns_init(&dlns, __FUNCTION__);
dlns_create(&dlns, "./");
void *handle = dlopen_ns(&dlns, NULL, RTLD_NOW);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (!handle) {
return;
}
int *i = dlsym(handle, "g_test");
EXPECT_PTRNE(__FUNCTION__, i, 0);
if (!i) {
dlclose(handle);
return;
}
EXPECT_EQ(__FUNCTION__, BASE_NUM, *i);
TEST_FUNC test = (TEST_FUNC)dlsym(handle, "test_f");
EXPECT_PTRNE(__FUNCTION__, test, 0);
if (!test) {
dlclose(handle);
return;
}
test();
EXPECT_EQ(__FUNCTION__, BASE_NUM + 1, g_test);
g_test = BASE_NUM;
dlclose(handle);
}
/**
* @tc.name : dlopen_ns_randomization_0300
* @tc.desc : Call the dlopen_ns interface to load a invalid dynamic library
* @tc.level : Level2
*/
static void dlopen_ns_randomization_0300(void)
{
Dl_namespace dlns;
dlns_init(&dlns, __FUNCTION__);
dlns_create(&dlns, "./");
void *handle = dlopen_ns(&dlns, "test_invaild.so", RTLD_NOW);
EXPECT_PTREQ(__FUNCTION__, handle, 0);
if (handle) {
dlclose(handle);
}
}
/**
* @tc.name : dlopen_ns_randomization_0400
* @tc.desc : Repeatedly calling the dlopen_ns interface to load the same dynamic library
* @tc.level : Level1
*/
static void dlopen_ns_randomization_0400(void)
{
Dl_namespace dlns;
dlns_init(&dlns, __FUNCTION__);
dlns_create(&dlns, "./");
void *ori_handle = dlopen_ns(&dlns, LIB_NAME, RTLD_NOW);
void *handle = 0;
EXPECT_PTRNE(__FUNCTION__, ori_handle, 0);
if (!ori_handle) {
return;
}
int i = TEST_COUNTS;
while (i--) {
handle = dlopen_ns(&dlns, LIB_NAME, RTLD_NOW);
EXPECT_PTREQ(__FUNCTION__, ori_handle, handle);
}
i = TEST_COUNTS + 1;
while (i--) {
dlclose(ori_handle);
}
}
/**
* @tc.name : dlopen_ns_randomization_0600
* @tc.desc : Call the dlopen_ns interface to load a invalid dynamic library,
* and call the dlsym interface to get symbol address
* @tc.level : Level1
*/
static void dlopen_ns_randomization_0600(void)
{
Dl_namespace dlns;
dlns_init(&dlns, __FUNCTION__);
dlns_create(&dlns, "./");
void *handle;
int *i;
TEST_FUNC test;
handle = dlopen_ns(&dlns, LIB_NAME, RTLD_NOW);
EXPECT_PTRNE(__FUNCTION__, handle, 0);
if (!handle) {
return;
}
i = dlsym(handle, "i");
EXPECT_PTRNE(__FUNCTION__, i, 0);
if (!i) {
dlclose(handle);
return;
}
EXPECT_EQ(__FUNCTION__, *i, 0);
test = (TEST_FUNC)dlsym(handle, "test");
EXPECT_PTRNE(__FUNCTION__, test, 0);
if (!test) {
dlclose(handle);
return;
}
test();
EXPECT_EQ(__FUNCTION__, *i, 1);
dlclose(handle);
}
/**
* @tc.name : dlsym_randomization_0300
* @tc.desc : Call the dlsym interface to get symbol address
* @tc.level : Level2
*/
static void dlsym_randomization_0300(void)
{
void *sym = dlsym(NULL, "test");
EXPECT_FALSE(__FUNCTION__, sym);
}
/**
* @tc.name : dlclose_randomization_0100
* @tc.desc : Call the dlclose interface to unload dynamic library
* @tc.level : Level2
*/
static void dlclose_randomization_0100(void)
{
int ret = dlclose(NULL);
EXPECT_EQ(__FUNCTION__, -1, ret);
}
TEST_FUNC test_cases[] = {
dlopen_randomization_0100,
dlopen_randomization_0200,
dlopen_randomization_0300,
dlopen_randomization_0400,
dlopen_randomization_0600,
dlopen_ext_randomization_0100,
dlopen_ext_randomization_0200,
dlopen_ext_randomization_0300,
dlopen_ext_randomization_0400,
dlopen_ext_randomization_0600,
dlopen_ext_randomization_0800,
dlopen_ns_randomization_0100,
dlopen_ns_randomization_0200,
dlopen_ns_randomization_0300,
dlopen_ns_randomization_0400,
dlopen_ns_randomization_0600,
dlsym_randomization_0300,
dlclose_randomization_0100,
};
int main(int argc, char *argv[])
{
size_t case_counts = sizeof(test_cases) / sizeof(TEST_FUNC);
for (size_t case_num = 0; case_num < case_counts; case_num++) {
test_cases[case_num]();
}
return t_status;
}
\ No newline at end of file
libc-test/src/functionalext/relro/BUILD.gn 0 → 100644
浏览文件 @ 03a3c130
# Copyright (c) 2022 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("../../../test_template.gni")
test_unittest("dlopen_ext_relro_test") {
target_dir = "functionalext/relro"
}
ohos_shared_library("dlopen_ext_relro_dso") {
include_dirs = [ "." ]
sources = [ "dlopen_ext_relro_dso.c" ]
output_name = "dlopen_ext_relro_dso"
output_extension = "so"
subsystem_name = "musl"
part_name = "libc-test-lib"
}
group("functionalext_relro_test") {
testonly = true
deps = [
":dlopen_ext_relro_dso",
":dlopen_ext_relro_test",
]
}
libc-test/src/functionalext/relro/dlopen_ext_relro_dso.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
void relro(void)
{
printf ("hello world!\n");
}
\ No newline at end of file
libc-test/src/functionalext/relro/dlopen_ext_relro_test.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <dlfcn_ext.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>
#include <stdbool.h>
#include "functionalext.h"
#include "test.h"
#define LIB_NAME "./libdlopen_ext_relro_dso.so"
#define RELRO_FILE_PATH "./TemporaryFile-XXXXXX"
const char* RELRO_NS_PATH = "./";
const int RELRO_INVALID_FLAG = 0x20;
const int LIB_PATH_SIZE = 512;
typedef void(*TEST_FUN)(void);
static int create_temp_relro_file(char *path)
{
int fd = -1;
#if defined(_WIN32)
fd = mkstemp(path, strlen(RELRO_FILE_PATH) + 1);
#else
fd = mkstemp(path);
#endif
if (fd != -1) {
close(fd);
}
return 0;
}
static void tear_down(const int fd, const char* relro_path)
{
if (fd != -1) {
close(fd);
}
if (relro_path != NULL) {
unlink(relro_path);
}
}
static void clear_handle(void *handle)
{
if (handle) {
dlclose(handle);
}
}
static void test_wirte_relro_file(const char* lib, const int relro_fd)
{
pid_t pid = fork();
if (pid == 0) {
dl_extinfo extinfo = {
.flag = DL_EXT_WIRTE_INFO,
.relro_fd = relro_fd,
};
void* handle = dlopen_ext(lib, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, NULL);
clear_handle(handle);
exit(-1);
}
int status = 0;
waitpid(pid, &status, 0);
}
/**
* @tc.name : dlopen_ext_relro_0100
* @tc.desc : extinfo is NULL, call dlopen_ext, return handle is not NULL.
* @tc.level : Level 1
*/
static void dlopen_ext_relro_0100(void)
{
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, NULL);
EXPECT_PTRNE(__FUNCTION__, handle, NULL);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_0200
* @tc.desc : extinfo flag is 0, call dlopen_ext, return handle is not NULL.
* @tc.level : Level 1
*/
static void dlopen_ext_relro_0200(void)
{
dl_extinfo extinfo = {
.flag = 0,
.relro_fd = -1,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, NULL);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_0300
* @tc.desc : extinfo flag is 20, call dlopen_ext, return handle is NULL.
* @tc.level : Level 2
*/
static void dlopen_ext_relro_0300(void)
{
dl_extinfo extinfo = {
.flag = RELRO_INVALID_FLAG,
.relro_fd = -1,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_EQ(__FUNCTION__, handle, NULL);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_0400
* @tc.desc : extinfo flag is DL_EXT_WIRTE_INFO, relro_fd is valid, call dlopen_ext, return handle is not NULL.
* @tc.level : Level 1
*/
static void dlopen_ext_relro_0400(void)
{
char relro_file[] = RELRO_FILE_PATH;
if (create_temp_relro_file(relro_file) < 0) {
return;
}
int relro_fd = open(relro_file, O_RDWR | O_TRUNC | O_CLOEXEC);
if (relro_fd < 0) {
t_error("%s relro file %s open failed error is : %s \n", __FUNCTION__, relro_file, dlerror());
return;
}
dl_extinfo extinfo = {
.flag = DL_EXT_WIRTE_INFO,
.relro_fd = relro_fd,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, NULL);
tear_down(relro_fd, relro_file);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_0500
* @tc.desc : extinfo flag is DL_EXT_WIRTE_INFO, relro_fd is not valid, call dlopen_ext, return handle is NULL.
* @tc.level : Level 2
*/
static void dlopen_ext_relro_0500(void)
{
dl_extinfo extinfo = {
.flag = DL_EXT_WIRTE_INFO,
.relro_fd = -1,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_EQ(__FUNCTION__, handle, NULL);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_0600
* @tc.desc : extinfo flag is DL_EXT_USE_INFO, relro_fd is valid, call dlopen_ext, return handle is not NULL.
* @tc.level : Level 1
*/
static void dlopen_ext_relro_0600(void)
{
char relro_file[] = RELRO_FILE_PATH;
if (create_temp_relro_file(relro_file) < 0) {
return;
}
int relro_fd = open(relro_file, O_RDWR | O_TRUNC | O_CLOEXEC);
if (relro_fd < 0) {
t_error("%s relro file %s open failed error is : %s \n", __FUNCTION__, relro_file, dlerror());
return;
}
test_wirte_relro_file(LIB_NAME, relro_fd);
dl_extinfo extinfo = {
.flag = DL_EXT_USE_INFO,
.relro_fd = relro_fd,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, NULL);
tear_down(relro_fd, relro_file);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_0700
* @tc.desc : extinfo flag is DL_EXT_USE_INFO, relro_fd is not valid, call dlopen_ext, return handle is NULL.
* @tc.level : Level 2
*/
static void dlopen_ext_relro_0700(void)
{
char relro_file[] = RELRO_FILE_PATH;
if (create_temp_relro_file(relro_file) < 0) {
return;
}
int relro_fd = open(relro_file, O_RDWR | O_TRUNC | O_CLOEXEC);
if (relro_fd < 0) {
t_error("%s relro file %s open failed error is : %s \n", __FUNCTION__, relro_file, dlerror());
return;
}
test_wirte_relro_file(LIB_NAME, relro_fd);
dl_extinfo extinfo = {
.flag = DL_EXT_USE_INFO,
.relro_fd = -1,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_EQ(__FUNCTION__, handle, NULL);
tear_down(relro_fd, relro_file);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_0800
* @tc.desc : extinfo flag is DL_EXT_WIRTE_INFO | DL_EXT_RESERVED_ADDRESS_RECURSIVE, relro_fd is valid,
* call dlopen_ext, return handle is not NULL.
* @tc.level : Level 1
*/
static void dlopen_ext_relro_0800(void)
{
char relro_file[] = RELRO_FILE_PATH;
if (create_temp_relro_file(relro_file) < 0) {
return;
}
int relro_fd = open(relro_file, O_RDWR | O_TRUNC | O_CLOEXEC);
if (relro_fd < 0) {
t_error("%s relro file %s open failed error is : %s \n", __FUNCTION__, relro_file, dlerror());
return;
}
dl_extinfo extinfo = {
.flag = DL_EXT_WIRTE_INFO | DL_EXT_RESERVED_ADDRESS_RECURSIVE,
.relro_fd = relro_fd,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, NULL);
tear_down(relro_fd, relro_file);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_0900
* @tc.desc : extinfo flag is DL_EXT_WIRTE_INFO, relro_fd is not valid, call dlopen_ext, return handle is NULL.
* @tc.level : Level 2
*/
static void dlopen_ext_relro_0900(void)
{
dl_extinfo extinfo = {
.flag = DL_EXT_WIRTE_INFO | DL_EXT_RESERVED_ADDRESS_RECURSIVE,
.relro_fd = -1,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_EQ(__FUNCTION__, handle, NULL);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_1000
* @tc.desc : extinfo flag is DL_EXT_USE_INFO | DL_EXT_RESERVED_ADDRESS_RECURSIVE, relro_fd is valid,
* call dlopen_ext, return handle is not NULL.
* @tc.level : Level 1
*/
static void dlopen_ext_relro_1000(void)
{
char relro_file[] = RELRO_FILE_PATH;
if (create_temp_relro_file(relro_file) < 0) {
return;
}
int relro_fd = open(relro_file, O_RDWR | O_TRUNC | O_CLOEXEC);
if (relro_fd < 0) {
t_error("%s relro file %s open failed error is : %s \n", __FUNCTION__, relro_file, dlerror());
return;
}
test_wirte_relro_file(LIB_NAME, relro_fd);
dl_extinfo extinfo = {
.flag = DL_EXT_USE_INFO | DL_EXT_RESERVED_ADDRESS_RECURSIVE,
.relro_fd = relro_fd,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, NULL);
tear_down(relro_fd, relro_file);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_1100
* @tc.desc : extinfo flag is DL_EXT_USE_INFO | DL_EXT_RESERVED_ADDRESS_RECURSIVE, relro_fd is not valid,
* call dlopen_ext, return handle is NULL.
* @tc.level : Level 2
*/
static void dlopen_ext_relro_1100(void)
{
char relro_file[] = RELRO_FILE_PATH;
if (create_temp_relro_file(relro_file) < 0) {
return;
}
int relro_fd = open(relro_file, O_RDWR | O_TRUNC | O_CLOEXEC);
if (relro_fd < 0) {
t_error("%s relro file %s open failed error is : %s \n", __FUNCTION__, relro_file, dlerror());
return;
}
test_wirte_relro_file(LIB_NAME, relro_fd);
dl_extinfo extinfo = {
.flag = DL_EXT_USE_INFO | DL_EXT_RESERVED_ADDRESS_RECURSIVE,
.relro_fd = -1,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_EQ(__FUNCTION__, handle, NULL);
tear_down(relro_fd, relro_file);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_1200
* @tc.desc : extinfo flag is DL_EXT_USE_INFO when relro file do not wirte,
* when call dlopen_ext, return handle is NULL.
* @tc.level : Level 2
*/
static void dlopen_ext_relro_1200(void)
{
char relro_file[] = RELRO_FILE_PATH;
if (create_temp_relro_file(relro_file) < 0) {
return;
}
int relro_fd = open(relro_file, O_RDWR | O_TRUNC | O_CLOEXEC);
if (relro_fd < 0) {
t_error("%s relro file %s open failed error is : %s \n", __FUNCTION__, relro_file, dlerror());
return;
}
dl_extinfo extinfo = {
.flag = DL_EXT_USE_INFO,
.relro_fd = relro_fd,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_EQ(__FUNCTION__, handle, NULL);
tear_down(relro_fd, relro_file);
clear_handle(handle);
}
/**
* @tc.name : dlopen_ext_relro_1500
* @tc.desc : extinfo flag is DL_EXT_USE_INFO | DL_EXT_WIRTE_INFO, relro_fd is valid,
* call dlopen_ext, return handle is not NULL.
* @tc.level : Level 1
*/
static void dlopen_ext_relro_1500(void)
{
char relro_file[] = RELRO_FILE_PATH;
if (create_temp_relro_file(relro_file) < 0) {
return;
}
int relro_fd = open(relro_file, O_RDWR | O_TRUNC | O_CLOEXEC);
if (relro_fd < 0) {
t_error("%s relro file %s open failed error is : %s \n", __FUNCTION__, relro_file, dlerror());
return;
}
test_wirte_relro_file(LIB_NAME, relro_fd);
dl_extinfo extinfo = {
.flag = DL_EXT_WIRTE_INFO | DL_EXT_USE_INFO,
.relro_fd = relro_fd,
};
void* handle = dlopen_ext(LIB_NAME, RTLD_NOW, &extinfo);
EXPECT_PTRNE(__FUNCTION__, handle, NULL);
tear_down(relro_fd, relro_file);
clear_handle(handle);
}
TEST_FUN g_fun_array[] = {
dlopen_ext_relro_0100,
dlopen_ext_relro_0200,
dlopen_ext_relro_0300,
dlopen_ext_relro_0400,
dlopen_ext_relro_0500,
dlopen_ext_relro_0600,
dlopen_ext_relro_0700,
dlopen_ext_relro_0800,
dlopen_ext_relro_0900,
dlopen_ext_relro_1000,
dlopen_ext_relro_1100,
dlopen_ext_relro_1200,
dlopen_ext_relro_1500,
};
int main(int argc, char *argv[])
{
int num = sizeof(g_fun_array) / sizeof(TEST_FUN);
for (int pos = 0; pos < num; ++pos) {
g_fun_array[pos]();
}
return t_status;
}
\ No newline at end of file
libc-test/src/functionalext/test_src_functionalext.gni
浏览文件 @ 03a3c130
...@@ -20,4 +20,6 @@ functionalext_list = [ ...@@ -20,4 +20,6 @@ functionalext_list = [
"trace:functionalext_trace_test", "trace:functionalext_trace_test",
"dlns:dlns_test", "dlns:dlns_test",
"info:functionalext_info_test", "info:functionalext_info_test",
"ldso_randomization:functionalext_ldso_randomization_test",
"relro:functionalext_relro_test",
] ]
libc-test/test_template.gni
浏览文件 @ 03a3c130
...@@ -118,6 +118,18 @@ template("test_unittest") { ...@@ -118,6 +118,18 @@ template("test_unittest") {
} }
} }
if (target_dir == "functionalext/ldso_randomization") {
if (target_name == "ldso_randomization_test") {
ldflags += [ "-Wl,--export-dynamic,-rpath=./" ]
}
if (target_name == "ldso_randomization_manual") {
ldflags += [ "-Wl,-rpath=./" ]
}
include_dirs += [ "//${test_dir}/src/functionalext/common" ]
}
if (target_dir == "musl") { if (target_dir == "musl") {
cflags_c += [ "-w" ] cflags_c += [ "-w" ]
...@@ -151,6 +163,14 @@ template("test_unittest") { ...@@ -151,6 +163,14 @@ template("test_unittest") {
[ "//${root_out_dir}/${test_lib_dir}/libtls_get_new-dtv_dso.so" ] [ "//${root_out_dir}/${test_lib_dir}/libtls_get_new-dtv_dso.so" ]
} }
} }
if (target_dir == "functionalext/relro") {
if (target_name == "dlopen_ext_relro_test") {
include_dirs += [ "//${test_dir}/src/functionalext/common" ]
ldflags += [ "-Wl,-rpath=./" ]
}
}
} }
} }
......
musl_src.gni
浏览文件 @ 03a3c130
...@@ -1561,6 +1561,7 @@ musl_src_ldso = [ ...@@ -1561,6 +1561,7 @@ musl_src_ldso = [
"ldso/namespace.c", "ldso/namespace.c",
"ldso/ns_config.c", "ldso/ns_config.c",
"ldso/strops.c", "ldso/strops.c",
"ldso/dynlink_rand.c",
] ]
if (musl_arch == "arm") { if (musl_arch == "arm") {
...@@ -1769,6 +1770,7 @@ musl_inc_root_files = [ ...@@ -1769,6 +1770,7 @@ musl_inc_root_files = [
"include/ctype.h", "include/ctype.h",
"include/dirent.h", "include/dirent.h",
"include/dlfcn.h", "include/dlfcn.h",
"include/dlfcn_ext.h",
"include/elf.h", "include/elf.h",
"include/endian.h", "include/endian.h",
"include/err.h", "include/err.h",
...@@ -1871,6 +1873,7 @@ musl_src_porting_file = [ ...@@ -1871,6 +1873,7 @@ musl_src_porting_file = [
"include/trace/trace_marker.h", "include/trace/trace_marker.h",
"include/unistd.h", "include/unistd.h",
"include/dlfcn.h", "include/dlfcn.h",
"include/dlfcn_ext.h",
"src/internal/musl_log.h", "src/internal/musl_log.h",
"src/info/application_target_sdk_version.c", "src/info/application_target_sdk_version.c",
"src/info/device_api_version.c", "src/info/device_api_version.c",
...@@ -1919,6 +1922,8 @@ musl_src_porting_file = [ ...@@ -1919,6 +1922,8 @@ musl_src_porting_file = [
"ldso/namespace.c", "ldso/namespace.c",
"ldso/ns_config.c", "ldso/ns_config.c",
"ldso/strops.c", "ldso/strops.c",
"ldso/dynlink_rand.c",
"ldso/dynlink_rand.h",
"src/thread/pthread_create.c", "src/thread/pthread_create.c",
"src/sched/sched_cpualloc.c", "src/sched/sched_cpualloc.c",
"src/signal/signal.c", "src/signal/signal.c",
......
porting/linux/user/include/dlfcn_ext.h 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DLFCN_EXT_H
#define DLFCN_EXT_H
#include <dlfcn.h>
#ifdef __cplusplus
extern "C" {
#endif
/* for dl_extinfo flag */
#define DL_EXT_WIRTE_INFO 0x1
#define DL_EXT_USE_INFO 0x2
#define DL_EXT_RESERVED_ADDRESS_RECURSIVE 0x4
/** Mask of valid bits. */
#define DL_EXT_VALID_FLAG_BITS (DL_EXT_WIRTE_INFO | DL_EXT_USE_INFO | DL_EXT_RESERVED_ADDRESS_RECURSIVE)
typedef struct {
int flag;
int relro_fd;
} dl_extinfo;
/**
* @brief Loads the dynamic shared object (shared library) file with the extended feature.
* If extinfo is NULL, it is equivalent to dlopen.
* If DL_EXT_WIRTE_INFO is set in extinfo, the GNU RELRO section will be written to relro_fd and allowed to
* reused by other process loading the same library at the same address.
* IF DL_EXT_USE_INFO is set in extinfo, the GNU RELRO section written in relro_fd will be reused.
* @param file Equivalent to the argument of dlopen.
* @param mode Equivalent to the argument of dlopen.
* @param extinfo Indicates the dl_extinfo struct.
* @return Returns a non-NULL handle for the loaded object on success. On error returns NULL.
*/
void *dlopen_ext(const char *file, int mode, const dl_extinfo *extinfo);
#ifdef __cplusplus
}
#endif
#endif
porting/linux/user/ldso/dynlink.c
浏览文件 @ 03a3c130
此差异已折叠。
porting/linux/user/ldso/dynlink_rand.c 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dynlink_rand.h"
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/random.h>
#include <unistd.h>
#define HANDLE_INCREASE 2
#define TASK_BASE_CAPACITY 8
// linked list node for handle randomization
struct handle_node {
struct handle_node *next;
void *handle;
struct dso *dso;
};
// linked list for handle randomization
static struct handle_node *handle_map_list = NULL;
static bool is_first_stage_init(void)
{
static bool ret;
ret = (getpid() == 1 && access("/proc/self/exe", F_OK) == -1);
return ret;
}
void *add_handle_node(void *handle, struct dso *dso)
{
struct handle_node *node = malloc(sizeof(*node));
if (!node) {
return NULL;
}
node->handle = handle;
node->dso = dso;
node->next = handle_map_list;
handle_map_list = node;
return node;
}
struct dso *find_dso_by_handle(void *handle)
{
struct handle_node *node = handle_map_list;
while (node) {
if (node->handle == handle) {
return node->dso;
}
node = node->next;
}
return NULL;
}
static void *find_handle_by_dso(struct dso *dso)
{
struct handle_node *node = handle_map_list;
while (node) {
if (node->dso == dso) {
return node->handle;
}
node = node->next;
}
return 0;
}
void remove_handle_node(void *handle)
{
struct handle_node *node = handle_map_list;
struct handle_node *pre_node = NULL;
while (node) {
if (node->handle == handle) {
if (pre_node) {
pre_node->next = node->next;
} else {
handle_map_list = node->next;
}
free(node);
return;
} else {
pre_node = node;
node = node->next;
}
}
}
static void *gen_handle(void)
{
uintptr_t handle = 0;
do {
if (!is_first_stage_init()) {
getrandom(&handle, sizeof handle, GRND_RANDOM);
} else {
handle += HANDLE_INCREASE;
}
} while (find_dso_by_handle((void *)handle) || handle == 0);
return (void *)handle;
}
void *assign_valid_handle(struct dso *p)
{
void *handle = find_handle_by_dso(p);
if (handle == 0) {
handle = gen_handle();
if (!add_handle_node(handle, p)) {
handle = 0;
}
}
return handle;
}
struct loadtasks *create_loadtasks(void)
{
struct loadtasks *tasks = malloc(sizeof(struct loadtasks));
if (tasks) {
tasks->array = NULL;
tasks->capacity = 0;
tasks->length = 0;
return tasks;
}
return NULL;
}
bool append_loadtasks(struct loadtasks *tasks, struct loadtask *item)
{
if (tasks->length + 1 > tasks->capacity) {
size_t new_cap = 0;
new_cap = tasks->capacity + TASK_BASE_CAPACITY;
void *realloced = NULL;
if (tasks->array) {
realloced = realloc(tasks->array, new_cap * sizeof(struct loadtask *));
} else {
realloced = malloc(TASK_BASE_CAPACITY * sizeof(struct loadtask *));
}
if (realloced) {
tasks->array = realloced;
tasks->capacity = new_cap;
} else {
return false;
}
}
tasks->array[tasks->length] = item;
tasks->length += 1;
return true;
}
void free_task(struct loadtask *task)
{
if (task == NULL) {
return;
}
if (task->allocated_buf) {
free(task->allocated_buf);
task->allocated_buf = NULL;
}
if (task->dyn_map_len) {
munmap(task->dyn_map, task->dyn_map_len);
task->dyn_map = NULL;
task->dyn_map_len = 0;
}
if (task->str_map_len) {
munmap(task->str_map, task->str_map_len);
task->str_map = NULL;
task->str_map_len = 0;
}
if (task->fd != -1 && task->fd) {
close(task->fd);
task->fd = -1;
}
free(task);
}
struct loadtask *get_loadtask(struct loadtasks *tasks, size_t index)
{
if (tasks && tasks->array && (index < tasks->length)) {
return tasks->array[index];
} else {
return NULL;
}
}
void free_loadtasks(struct loadtasks *tasks)
{
if (tasks) {
if (tasks->length) {
for (int i = 0; i < tasks->length; i++) {
free_task(get_loadtask(tasks, i));
}
tasks->length = 0;
}
if (tasks->array) {
free(tasks->array);
tasks->array = NULL;
}
tasks->capacity = 0;
free(tasks);
}
}
void shuffle_loadtasks(struct loadtasks *tasks)
{
size_t index = 0;
struct loadtask *task = NULL;
if (is_first_stage_init()) {
return;
}
for (size_t i = 0; i < tasks->length; i++) {
getrandom(&index, sizeof index, GRND_RANDOM);
index %= tasks->length;
task = tasks->array[i];
tasks->array[i] = tasks->array[index];
tasks->array[index] = task;
}
}
struct loadtask *create_loadtask(const char *name, struct dso *needed_by, ns_t *ns, bool check_inherited)
{
struct loadtask *task = calloc(1, sizeof(struct loadtask));
if (!task) {
return NULL;
}
task->name = name;
task->needed_by = needed_by;
task->namespace = ns;
task->check_inherited = check_inherited;
return task;
}
porting/linux/user/ldso/dynlink_rand.h 0 → 100644
浏览文件 @ 03a3c130
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DYNLINK_RAND_H
#define DYNLINK_RAND_H
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include "libc.h"
#include "dynlink.h"
#include "namespace.h"
#ifdef __cplusplus
extern "C" {
#endif
struct dso;
#define READ_ELF_LENGTH 896
// load library context
hidden struct loadtask {
// parameters
const char *name;
struct dso *needed_by;
ns_t *namespace;
bool check_inherited;
bool isloaded;
// variables for load library
char buf[PATH_MAX + 1];
const char *pathname;
struct dso *p;
int fd;
// variables for map library
Ehdr ehdr_buf[(READ_ELF_LENGTH + sizeof(Ehdr)) / sizeof(Ehdr)];
void *allocated_buf;
size_t phsize;
Ehdr *eh;
Phdr *ph0;
size_t dyn;
size_t tls_image;
void *dyn_map;
size_t dyn_map_len;
size_t *dyn_addr;
void *str_map;
size_t str_map_len;
char *str_addr;
struct tls_module tls;
};
// dynamic array for loadtask
hidden struct loadtasks {
struct loadtask **array;
size_t capacity;
size_t length;
};
hidden void *add_handle_node(void *handle, struct dso *dso);
hidden struct dso *find_dso_by_handle(void *handle);
hidden void remove_handle_node(void *handle);
hidden void *assign_valid_handle(struct dso *p);
hidden struct loadtasks *create_loadtasks(void);
hidden bool append_loadtasks(struct loadtasks *tasks, struct loadtask *item);
hidden void free_task(struct loadtask *task);
hidden struct loadtask *get_loadtask(struct loadtasks *tasks, size_t index);
hidden void free_loadtasks(struct loadtasks *tasks);
hidden void shuffle_loadtasks(struct loadtasks *tasks);
hidden struct loadtask *create_loadtask(const char *name, struct dso *needed_by, ns_t *ns, bool check_inherited);
#ifdef __cplusplus
}
#endif
#endif
\ No newline at end of file
porting/linux/user/ldso/ld_log.h
浏览文件 @ 03a3c130
...@@ -13,11 +13,11 @@ ...@@ -13,11 +13,11 @@
* limitations under the License. * limitations under the License.
*/ */
#include <musl_log.h>
#ifndef LD_LOG_H #ifndef LD_LOG_H
#define LD_LOG_H #define LD_LOG_H
#include <musl_log.h>
#define LD_LOG_ERROR 1 #define LD_LOG_ERROR 1
#define LD_LOG_WARNING 2 #define LD_LOG_WARNING 2
#define LD_LOG_INFO 4 #define LD_LOG_INFO 4
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或