Linux fork()、exec() Hook Risk、Design-Principle In Multi-Threadeed Program

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

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

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

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

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

#include <pthread.h>

void* doit() 
{
    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_lock(&mutex);
    struct timespec ts = {10, 0}; 
    nanosleep(&ts, 0); // 10秒sleep
                             
    pthread_mutex_unlock(&mutex);
    return;
}

int main(void) 
{
        pthread_t t;
    
    //启动子进程，并在子进程中试图锁定一个全局锁
        pthread_create(&t, 0, doit, 0);                                 
        if (fork() == 0) 
    {
        //子进程 
        doit();

              return 0;
        }
    // 等待子线程结束
        pthread_join(t, 0);          
}

/*
gcc -Wall -o fork fork.c -lpthread
./fork
*/

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

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

1. malloc:
malloc函数就是一个维持自身固有mutex的典型例子，malloc()在访问全局状态时会加锁，因此通常情况下它是fork-unsafe的。依赖于malloc函数的函数有很多，例如
    1) printf()
    2) dlsym()
它们也是变成fork-unsafe

2. stdio functions like printf() - this is required by the standard.
    1) 因为其他线程可能恰好持有stdout/stderr的锁

3. syslog()

4. 任何可能分配或释放内存的函数，包括
    1) new
    2) map::insert()
    3) snprintf()

5. 任何pthreads函数
    1) 不能用pthread_cond_signal()去通知父进程，只能通过读写pipe(2)来同步 
 
6. 除了man 7 signal中明确列出的"signal安全"函数"之外"的任何函数

/*
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));

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

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

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

1. 系统中可能存在这中代码
while(1000 times)
{
    if(pid = fork() = 0)
    {
        //do some calculate
        execve(new programe);
    }
}

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

#include <stdio.h>

int main(int argc, char* argv[])
{
        printf("hello world\n");

        return 0;
}

//gcc test.c -o test

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

void* doit() 
{
    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_lock(&mutex);
    struct timespec ts = {10, 0}; 
    nanosleep(&ts, 0); // 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 };

    if (argc != 2) 
    {
        fprintf(stderr, "Usage: %s <file-to-exec>\n", argv[0]);
        return 0;
    }
    newargv[0] = argv[1];  

    //启动子进程，并在子进程中锁定一个全局锁
    pthread_create(&t, 0, doit, 0);
    for (times = 0; times < 5000; times++)
    {
        //fork a duplicate process
        pid_t child_pid = fork(); 

        //child
        if (child_pid == 0)  
        {
            doit();
            execve(argv[1], newargv, newenviron); 
        } 
    }

    return 0;
}

/*
gcc -Wall -o fork fork.c -lpthread
./fork test
*/