目录

. Linux exec指令执行监控Hook方案
. 在"Multi-Threadeed Program"环境中调用fork存在的风险
. Fork When Multi-Threadeed Program的安全设计原则
. Fork When Multi-Threadeed Program Deaklock Demo Code

1. Linux exec指令执行监控Hook方案

. 基于LD_PRELOAD技术的glibc API劫持Hook技术
) 优点: 位于Ring3应用层,基于Linux原生提供的LD_PRELOAD共享库符号加载调试技术,具有很好的兼容性和稳定性
) 缺点: LD_PRELOAD技术的核心是SO加载劫持注入,只要在安装了Hook模块之后启动的程序才能被Hook捕获到,系统先于Hook模块启动的常驻进程无法被捕获到,这对于在持续运行的业务服务器上部署入侵检测系统是非常不利的
. 基于ptrace()进程注入调试技术+内核模块提供进程启动事件的通知机制
) 优点: 能灵活控制需要Hook的进程,可以实现一套Ring3的Whitelist机制,对不需要Hook的进程予以放行
) 缺点: 进程创建的事件通知和Hook模块的处理逻辑之间无法实现串行,当发生瞬发进程执行的时候,有可能发生进程创建事件通知到ptrace注入模块的时候,进程已经exit退出了
. 基于Kernel Inline Hook对指定系统调用进行审计监控
. 基于0x80中断劫持system_call->sys_call_table进行系统调用Hook
. 基于Linux内核机制kprobe机制(kprobes, jprobe和kretprobe)进行系统调用Hook
. LSM(linux security module)钩子技术(linux原生机制)

Relevant Link:

http://www.cnblogs.com/LittleHann/p/3854977.html

2. 在"Multi-Threadeed Program"环境中调用fork存在的风险

0x1: Fork()的实现原理

关于fork()系统调用的实现原理和内核源码分析,请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3853854.html
//搜索:4. sys_execve()函数

在整个过程中,我们关注以下几个重点(完整的详细过程请参阅另一篇文章)

. 子进程复制了父进程的内存页
) 数据段: 静态变量、字符串等数据
) 代码段: 程序代码
) 堆栈区: 保存调用时可能正处于"中间状态"的变量运算结果
. 子进程复制了父进程的文件描述符数组
) 通过current->struct files_struct *files可以寻址、并操作当前进程打开的文件
. 在多线程执行的情况下调用fork()函数,仅会将发起调用的线程复制到子进程中
) 如果父进程包含多个线程,父进程(主线程)在调用fork的时候,其他线程均在子进程中"立即停止并消失",并且不会为这些线程调用清理函数以及针对线程局部存储变量的析构函数

0x2: 共享区、锁(Critical sections, mutexes)中存在的风险

虽然只将发起fork()调用的线程复制到子进程中,但全局变量的状态以及所有的pthreads对象(如互斥量、条件变量等)都会在子进程中得以保留,这就造成一个危险的问题
关于fork when multi-thread risk问题,我们通过一个code case来逐步学习

#include <pthread.h>

void* doit()
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mutex);
struct timespec ts = {, };
nanosleep(&ts, ); // 10秒sleep pthread_mutex_unlock(&mutex);
return;
} int main(void)
{
pthread_t t; //启动子进程,并在子进程中试图锁定一个全局锁
pthread_create(&t, , doit, );
if (fork() == )
{
//子进程
doit(); return ;
}
// 等待子线程结束
pthread_join(t, );
} /*
gcc -Wall -o fork fork.c -lpthread
./fork
*/

分析一下可能产生死锁的原因

以下是说明死锁的理由:

. 子进程只拷贝了调用fork的主线程(进程)的
. 在内存区域里,静态变量mutex的内存会被拷贝到子进程里。而且,父进程里即使存在多个线程,但它们也不会被继承到子进程里
. 父进程产生的线程里的doit()先执行.
) doit执行的时候会给互斥体变量mutex加锁.
) mutex变量的内容会原样拷贝到fork出来的子进程中(在此之前,mutex变量的内容已经被父进程产生的线程改写成锁定状态)
. 父进程fork出的子进程再次调用doit的时候,在锁定互斥体mutex的时候会发现它已经被加锁,所以就只能一直等待,直到拥有该互斥体的进程释放它(但是能够解锁这个mutex的线程并没有通过fork复制到子进程中,sleep 10s模拟了这个情况).
. 父进程的线程的doit执行完成之前会把自己的mutex释放,但是因为copy on write的关系(父子进程在这个互锁的期间有很高概率对内存进行了写草走),所以这个时候父进程的mutex和子进程里的mutex已经是两份内存。所以即使父进程释放了mutex锁也不会对子进程里的mutex造成什么影响,子进程就处于无限等待状态中

0x3: 文件操作中存在的风险

由于子进程会将父进程的大多数数据拷贝一份,这样在文件操作中就意味着子进程会获得父进程所有文件描述符的副本,这些副本的创建方式类似于dup()函数调用,因此父、子进程中对应的文件描述符均指向相同的打开的文件句柄,而且打开的文件句柄包含着当前文件的偏移量以及文件状态标志,所以在父子进程中处理文件时很有可能发生对同一个文件的同时操作,导致文件内容出现混乱或者别的问题

aaarticlea/png;base64,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" alt="" />

0x4: 数据一致性运算中存在的风险

全局变量的状态也可能处于不一致的状态,因为对其更新的操作只做到了一半对应的线程就消失了,或者父子进程同时对同一个数据进行了操作,通常情况下这和锁风险是同时发生的

0x5: 子进程中引用指针引发的错误

因为并未执行清理函数和针对线程局部存储数据的析构函数,所以多线程情况下可能会导致子进程的内存泄露。另外,子进程中的线程可能无法访问(父进程中)由其他线程所创建的线程局部存储变量,因为子进程没有任何相应的引用指针

Relevant Link:

http://www.linuxprogrammingblog.com/threads-and-fork-think-twice-before-using-them
http://mail-index.netbsd.org/tech-userlevel/2014/06/23/msg008609.html
https://sourceware.org/bugzilla/show_bug.cgi?id=4737
https://bugzilla.redhat.com/show_bug.cgi?id=241665

3. Fork When Multi-Threadeed Program的安全设计原则

0x1: 在调用fork()系统调用之后需要避免使用的函数

在多线程里因为fork而引起问题的函数,我们把它叫做"fork-unsafe函数"。反之,不能引起问题的函数叫做"fork-safe函数",典型的"fork-unsafe函数"例如

. malloc:
malloc函数就是一个维持自身固有mutex的典型例子,malloc()在访问全局状态时会加锁,因此通常情况下它是fork-unsafe的。依赖于malloc函数的函数有很多,例如
) printf()
) dlsym()
它们也是变成fork-unsafe . stdio functions like printf() - this is required by the standard.
) 因为其他线程可能恰好持有stdout/stderr的锁 . syslog() . 任何可能分配或释放内存的函数,包括
) new
) map::insert()
) snprintf() . 任何pthreads函数
) 不能用pthread_cond_signal()去通知父进程,只能通过读写pipe()来同步 . 除了man signal中明确列出的"signal安全"函数"之外"的任何函数

0x2: 在fork之后调用"异步信号安全函数"

fork()函数被调用之后,子进程就相当于处于signal handler之中,此时就不能调用线程安全的函数(用锁机制实现安全的函数),因为线程安全函数中的锁操作很可能会导致死锁(deadlock),除非函数是可重入的,而只能调用异步信号安全(async-signal-safe)的函数,调用异步信号安全函数是规格标准
对于那些必须执行fork(),而其后又无exec()紧随其后的程序来说(例如入侵检测Hook程序),pthreads API提供了一种机制:利用函数pthread_atfork()来创建fork()处理函数 pthread_atfork()声明如下

/*
Upon successful completion, pthread_atfork() shall return a value of zero; otherwise, an error number shall be returned to indicate the error.
1. prepare: 新子进程产生之前被调用
2. parent: 新子进程产生之后在父进程被调用
3. child: 新子进程产生之后,在子进程被调用 一些典型的应用场景
1. when in the prepare handler mutexes are locked, in the parent handler unlocked and in the child handler reinitialized
2. 在子进程产生之后,父进程关闭不需要操作的文件句柄
*/
int pthread_atfork (void (*prepare) (void), void (*parent) (void), void (*child) (void));

该函数的作用就是往进程中注册三个函数,以便在不同的阶段调用,有了这三个参数,我们就可以在对应的函数中加入对应的处理功能。同时需要注意的是

. 每次调用pthread_atfork()函数会将prepare添加到一个函数列表中,创建子进程之前会(按与注册次序相反的顺序)自动执行该函数列表中函数
. parent与child也会被添加到一个函数列表中,在fork()返回前,分别在父子进程中自动执行(按注册的顺序)

0x3: 在多线程应用中不使用fork

在程序中fork()与多线程的协作性很差,这是POSIX系列操作系统的历史包袱。因为长期以来程序都是单线程的,fork()运转正常。当20世纪90年代初期引入线程之后,fork()的适用范围就大为缩小了
在多线程应用中用pthread_create来代替fork,这是一个比较好的安全实践

0x4: 在fork之后立刻调用exec

子进程在创建后,是写时复制的,也就是子进程刚创建时,与父进程一样的副本,当exce后,那么老的地址空间被丢弃,而被新的exec的命令的内存的印像覆盖了进程的内存空间(一切和进程相关的资源都会被重置),所以锁的状态无关紧要了。
请注意这里使用的"马上"这个词.即使exec前仅仅只是调用一回printf("I’m child process")

Relevant Link:

http://blog.csdn.net/swgsunhj/article/details/8871758
http://blog.csdn.net/cywosp/article/details/27316803
http://blog.chinaunix.net/uid-26885237-id-3210394.html

4. Fork When Multi-Threadeed Program Deaklock Demo Code

如果在并发多线程(多进程)的场景下采用LD_PRELOAD技术对glibc的API调用进行Hook,造成的直接结果如下

. 系统中可能存在这中代码
while( times)
{
if(pid = fork() = )
{
//do some calculate
execve(new programe);
}
} . 使用LD_PRELOAD技术对execve进行Hook之后,相当于产生了"fork when multi-thread programe"的场景,Hook模块的代码延长了fork和execve之间的代码执行时间
) Hook模块中基本都有对内存的写入操作,也就是说在这种情况下,几乎100%会发生copy on write事件,进程创建的内存复制开销大大增加了
) 子进程调用Hooked execve函数中,调用了dlsym,dlsym中包含malloc的调用,这有可能导致deadlock
) hook延迟了子进程fork和execve之间的代码执行时间,同时有更大的可能性出现父子进程共同操作同一个fs、锁等资源

0x1: Code Example

test.c

#include <stdio.h>

int main(int argc, char* argv[])
{
printf("hello world\n"); return ;
} //gcc test.c -o test

fork.c

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <malloc.h> void* doit()
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mutex);
struct timespec ts = {, };
nanosleep(&ts, ); // 10秒sleep pthread_mutex_unlock(&mutex);
} int main(int argc, char *argv[])
{
int times;
pthread_t t;
char *newargv[] = { NULL, "hello", "world", NULL };
char *newenviron[] = { NULL };
int* p; if (argc != )
{
fprintf(stderr, "Usage: %s <file-to-exec>\n", argv[]);
return ;
}
newargv[] = argv[]; //启动子进程,并在子进程中锁定一个全局锁
//pthread_create(&t, 0, doit, 0); //父进程调用malloc
p = (int*)malloc(sizeof(int)*);
if(NULL == (int*)p)
{
perror("error...");
return ;
} for (times = ; times < ; times++)
{
//fork a duplicate process
pid_t child_pid = fork(); //child
if (child_pid == )
{
//doit();
execve(argv[], newargv, newenviron);
}
} free(p);
p = NULL;
return ;
} /*
gcc -Wall -o fork fork.c -lpthread
./fork test
*/

Copyright (c) 2014 LittleHann All rights reserved

Linux fork()、exec() Hook Risk、Design-Principle In Multi-Threadeed Program的更多相关文章

  1. PHP Datatype Conversion Safety Risk、Floating Point Precision、Operator Security Risk、Safety Coding Principle

    catalog . 引言 . PHP operator introduction . 算术运算符 . 赋值运算符 . 位运算符 . 执行运算符 . 递增/递减运算符 . 数组运算符 . 类型运算符 . ...

  2. 【转】Linux下Fork与Exec使用

    Linux下Fork与Exec使用 转自 Linux下Fork与Exec使用 一.引言 对于没有接触过Unix/Linux操作系统的人来说,fork是最难理解的概念之一:它执行一次却返回两个值.for ...

  3. Linux下Fork与Exec使用

    Linux下Fork与Exec使用   一.引言 对于没有接触过Unix/Linux操作系统的人来说,fork是最难理解的概念之一:它执行一次却返回两个值.fork函数是Unix系统最杰出的成就之一, ...

  4. Jenkins之自动部署、代码安全扫描、自动化接口测试

    搭建Jenkins wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat/jenkins.reporpm --i ...

  5. system()、exec()、fork()三个与进程有关的函数的比较

    启动新进程(system函数) system()函数可以启动一个新的进程. int system (const char *string ) 这个函数的效果就相当于执行sh –c string. 一般 ...

  6. 进程与fork()、wait()、exec函数组

    进程与fork().wait().exec函数组 内容简介:本文将引入进程的基本概念:着重学习exec函数组.fork().wait()的用法:最后,我们将基于以上知识编写Linux shell作为练 ...

  7. [转帖]system()、exec()、fork()三个与进程有关的函数的比较

    system().exec().fork()三个与进程有关的函数的比较 https://www.cnblogs.com/qingergege/p/6601807.html 启动新进程(system函数 ...

  8. fork、exec 和 exit 对 IPC 对象的影响

    GitHub: https://github.com/storagezhang Emai: debugzhang@163.com 华为云社区: https://bbs.huaweicloud.com/ ...

  9. Linux Kernel sys_call_table、Kernel Symbols Export Table Generation Principle、Difference Between System Calls Entrance In 32bit、64bit Linux

    目录 . sys_call_table:系统调用表 . 内核符号导出表:Kernel-Symbol-Table . Linux 32bit.64bit环境下系统调用入口的异同 . Linux 32bi ...

随机推荐

  1. WPF Adorner+附加属性 实现控件友好提示

    标题太空泛,直接上图 无论是在验证啊,还是提示方面等一些右上角的角标之类的效果,我们会怎么做? 这里介绍一种稍微简单一些的方法,利用附加属性和Adorner来完成. 例如WPF自带的控件上要加这样的效 ...

  2. opencv1-安装及资料

    本科用过opencv2..3.1版本,当时按照 http://wiki.opencv.org.cn/index.php/首页 上面的步骤安装的,而且使用的是IplImage和CvMat等C接口的的AP ...

  3. 《DOM启蒙》 随笔

    使用 Javascript 字符串创建并向 DOM 中添加元素与文本节点 innerHTML.outerHTML.textContent 及 insertAdjacentHTML() 属性和方法提供了 ...

  4. 【前端也要学点算法】 归并排序的JavaScript实现

    前文我们了解了快速排序算法的实现,本文我们来了解下另一种流行的排序算法-归并排序算法. 我们先来回顾下快排.快排的核心是找出一个基准元素,把数组中比该元素小的放到左边数组,比该元素大的放到右边数组,如 ...

  5. nios II--实验4——按键中断软件部分

    软件开发 首先,在硬件工程文件夹里面新建一个software的文件夹用于放置软件部分:打开toolsàNios II 11.0 Software Build Tools for Eclipse,需要进 ...

  6. fir2(n,f,m)

    编辑 函数fir2用来设计多通带任意响应FIR滤波器,该滤波器的幅频特性由向量对f和m确定,f为归一化频率向量,m为对应频率点上的幅度.当设计的滤波器在频率为π的幅度响应不是0时,滤波器的阶数n为偶数

  7. android之广播(二)

    广播接受者不仅可以通过清单文件来向系统注册,也可以通过代码来注册.并且有的广播必须通过代码来注册广播接受者. 锁屏和解锁广播 电量改变广播 打开屏幕和关闭屏幕 这里将广播接收者写在服务里面 <? ...

  8. Android开发之AutoCompleteTextView的简单使用

    这里只谈简单的使用: 代码xml: <AutoCompleteTextView android:id="@+id/actv" android:layout_width=&qu ...

  9. Service之来电监听(失败的案例)

    Service:服务,可以理解成一个运行再后台没有界面的Activity,集成于Seriver,是四大组件之一 Service的继承关系:Service-->ContextWrapper--&g ...

  10. 关于图像文章垂直无缝连接滚动——JS实现

    <!-- 作者:chenyehuacecil@163.com 时间:2015-02-04 描述:实现整篇文章从下到上的无缝连接滚动--><html xmlns="http: ...