[LINUX C]利用ptrace实现文件读写等linux系统调用的hook（代码）

最新推荐文章于 2024-01-02 00:43:07 发布
最新推荐文章于 2024-01-02 00:43:07 发布
阅读量925 收藏 6
点赞数 1
分类专栏： C/C++ 平台(PLATFORM)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiaoH0_0/article/details/101555790
版权

利用ptrace实现文件读写等系统调用的hook：

#include <stdio.h> 
#include <stdlib.h> 
#include <sys/ptrace.h> 
#include <sys/wait.h> 
#include <sys/types.h> 
#include <sys/reg.h> 
#include <sys/user.h> 
#include <unistd.h> 
#include <errno.h> 
#include <sys/syscall.h> 
#include <sys/mman.h> 
#include <memory.h> 
#include <sys/uio.h> 
#include "util.h" 
//#if defined(__x86_64__) 
//#define REGX ORIG_RAX * 8 
//#else 
//#define REGX ORIG_EAX * 4 
//#endif 
#define RECORD_BEFORE_EXE(a)  static bool arrRunRecord[4194500] = { 0 }; \ 
                                if (bClean) { \
                                    arrRunRecord[a] = false; \ 
                                    return; \ 
                                } \ 
                                if (arrRunRecord[a]) { \ 
                                    arrRunRecord[a] = false; \ 
                                    return; \ 
                                } \ 
                                arrRunRecord[a] = true; 
#define RECORD_AFTER_EXE(a)   static bool arrRunRecord[4194500] = { 0 }; \ 
                                if (bClean) { \ 
                                    arrRunRecord[a] = false; \ 
                                    return; \ 
                                } \ 
                                if (!arrRunRecord[a]) { \ 
                                    arrRunRecord[a] = true; \ 
                                    return; \ 
                                } \ 
                                arrRunRecord[a] = false; 
                                
struct i386_user_regs_struct { 
    unsigned int                ebx; 
    unsigned int                ecx; 
    unsigned int                edx; 
    unsigned int                esi; 
    unsigned int                edi; 
    unsigned int                ebp; 
    unsigned int                eax; 
    unsigned int                xds; 
    unsigned int                xes; 
    unsigned int                xfs; 
    unsigned int                xgs; 
    unsigned int                orig_eax; 
    unsigned int                eip; 
    unsigned int                xcs; 
    unsigned int                eflags; 
    unsigned int                esp; 
    unsigned int                xss; 
}; 

typedef union _UN_REGS { 
    struct user_regs_struct         x86_64_r; 
    struct i386_user_regs_struct    i386_r; 
} UN_REGS;

typedef struct _PROCESS_INFO { 
    bool            bLinux32; 
    int             nSysCallId; 
    unsigned long   nParam1; 
    unsigned long   nParam2; 
    unsigned long   nParam3; 
    unsigned long   nParam4; 
    unsigned long   nParam5; 
    unsigned long   nParam6; 
} ST_PROCESS_INFO; 

typedef void(*pSysCallProcFun)(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean); 

static pSysCallProcFun g_afuncProcessor64[4000] = { 0 }; 
static pSysCallProcFun g_afuncProcessor32[4000] = { 0 }; 
bool g_bArrProcessInfo[4194500]     = { 0 }; 
bool g_bArrProcessLogged[4194500]   = { 0 }; 
long g_nPrograms                    = 0; 

static inline void get_syscall_args(pid_t pid, ST_PROCESS_INFO *pData) 
{ 
    struct iovec iov; 
    UN_REGS regs; 
    iov.iov_base = &regs; 
    iov.iov_len = sizeof(regs); 
    ptrace(PTRACE_GETREGSET, pid, 1, &iov); 
    if (iov.iov_len == sizeof(i386_user_regs_struct)) { 
        // 32-bit 
        pData->bLinux32 = true; 
        pData->nSysCallId   = (unsigned long)((UN_REGS *)iov.iov_base)->i386_r.orig_eax; 
        pData->nParam1      = (unsigned long)((UN_REGS *)iov.iov_base)->i386_r.ebx; 
        pData->nParam2      = (unsigned long)((UN_REGS *)iov.iov_base)->i386_r.ecx; 
        pData->nParam3      = (unsigned long)((UN_REGS *)iov.iov_base)->i386_r.edx; 
        pData->nParam4      = (unsigned long)((UN_REGS *)iov.iov_base)->i386_r.esi; 
        pData->nParam5      = (unsigned long)((UN_REGS *)iov.iov_base)->i386_r.edi; 
        pData->nParam6      = (unsigned long)((UN_REGS *)iov.iov_base)->i386_r.ebp; 
    } 
    else { 
        // 64-bit 
        pData->bLinux32 = false; 
        pData->nSysCallId = ((UN_REGS *)iov.iov_base)->x86_64_r.orig_rax; 
        pData->nParam1 = (unsigned long)((UN_REGS *)iov.iov_base)->x86_64_r.rdi; 
        pData->nParam2 = (unsigned long)((UN_REGS *)iov.iov_base)->x86_64_r.rsi; 
        pData->nParam3 = (unsigned long)((UN_REGS *)iov.iov_base)->x86_64_r.rdx; 
        pData->nParam4 = (unsigned long)((UN_REGS *)iov.iov_base)->x86_64_r.r10; 
        pData->nParam5 = (unsigned long)((UN_REGS *)iov.iov_base)->x86_64_r.r8; 
        pData->nParam6 = (unsigned long)((UN_REGS *)iov.iov_base)->x86_64_r.r9; 
    } 
} 

static inline void ptrace_continue(pid_t pid, int signum) 
{ 
    ptrace(PTRACE_SYSCALL, pid, 0, signum); 
}

static inline void ptrace_trace_child(pid_t pid) 
{ 
    ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_TRACEEXIT | //PTRACE_O_TRACEEXEC | PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACECLONE | PTRACE_O_TRACEVFORK | PTRACE_O_TRACEFORK); 
} 

static inline void ptrace_detach(pid_t pid, int signum) 
{ 
    ptrace(PTRACE_DETACH, pid, 0, signum); 
} 

static inline long ptrace_get_child(pid_t pid) 
{ 
    long child = 0; 
    ptrace(PTRACE_GETEVENTMSG, pid, 0, &child); return child; 
} 

static inline void ptrace_get_regs(pid_t pid, struct user_regs_struct *regs) 
{ 
    ptrace(PTRACE_GETREGS, pid, NULL, regs); 
} 

static inline void record_read_syscall(pid_t pid, int fd) 
{ 
    char abs_file[MY_PATH_MAX] = { '\0' }; 
    ssize_t parese_ret = parse_fd_to_filename(abs_file, sizeof(abs_file), fd, pid); 
    if (parese_ret != -1) { 
        if (!is_directory(abs_file)) { 
            print_dep_file("read", abs_file, "Read", pid); 
        } 
    } 
} 

static inline void record_write_syscall(pid_t pid, int fd) 
{ 
    char abs_file[MY_PATH_MAX] = { '\0' }; 
    ssize_t parese_ret = parse_fd_to_filename(abs_file, sizeof(abs_file), fd, pid); 
    if (parese_ret != -1) { 
        if (!is_directory(abs_file)) { 
            print_dep_file("write", abs_file, "Write", pid); 
        } 
    } 
} 

static inline void record_read_link(pid_t pid, const char *filename) 
{ 
    char abs_file[MY_PATH_MAX]; 
    parse_to_abs_filepath(abs_file, filename, pid); 
    if (!is_directory(abs_file)) { 
        print_dep_file("read", abs_file, "Read", pid); 
    } 
} 

static inline void record_read_linkat(pid_t pid, int dirfd, const char *filename) 
{ 
    char abs_file[MY_PATH_MAX]; 
    parse_to_abs_filepath_with_dirfd(abs_file, dirfd, filename, pid); 
    if (!is_directory(abs_file)) { 
        print_dep_file("read", abs_file, "Read", pid); 
    } 
} 

static inline void record_mmap_syscall(pid_t pid, int prob, int fd) { 
    if (prob & PROT_READ) { 
        char abs_file[MY_PATH_MAX] = { '\0' }; 
        ssize_t parese_ret = parse_fd_to_filename(abs_file, sizeof(abs_file), fd, pid); 
        if (parese_ret != -1) { 
            if (!is_directory(abs_file)) { 
                print_dep_file("read", abs_file, "Read", pid); 
            } 
        } 
    } 

    //if (prob & PROT_WRITE) { 
    //    char abs_file[MY_PATH_MAX] = { '\0' }; 
    //    ssize_t parese_ret = parse_fd_to_filename(abs_file, sizeof(abs_file), fd, pid); 
    //    if (parese_ret != -1) { 
    //        if (!is_directory(abs_file)) { 
    //            print_dep_file("write", abs_file, "Write", pid); 
    //        } 
    //    } 
    //} 
} 

static inline void record_rename_syscall(pid_t pid, const char *old, const char *new_name) 
{ 
    char abs_old_file[MY_PATH_MAX]; 
    parse_to_abs_filepath(abs_old_file, old, pid); 
    char abs_new_file[MY_PATH_MAX]; 
    parse_to_abs_filepath(abs_new_file, new_name, pid); 
    if (!is_directory(abs_new_file)) { 
        print_rename_file("rename", abs_old_file, abs_new_file, "Rename", pid); 
        return; 
    } 

    print_rename_files_in_dir(abs_new_file, abs_old_file, abs_new_file, pid); 
} 

static inline void record_renameat_syscall(pid_t pid, int olddirfd, const char *old_name, int newdirfd, const char *new_name) 
{ 
    char abs_old_file[MY_PATH_MAX]; 
    parse_to_abs_filepath_with_dirfd(abs_old_file, olddirfd, old_name, pid); 
    char abs_new_file[MY_PATH_MAX]; 
    parse_to_abs_filepath_with_dirfd(abs_new_file, newdirfd, new_name, pid); 
    if (!is_directory(abs_new_file)) { 
        print_rename_file("renameat", abs_old_file, abs_new_file, "Rename", pid); 
        return; 
    } 

    print_rename_files_in_dir(abs_new_file, abs_old_file, abs_new_file, pid); 
} 

static inline void record_rmdir_syscall(pid_t pid, const char *file_path) { 
    char abs_file[MY_PATH_MAX] = { 0 }; 
    parse_to_abs_filepath(abs_file, 

        //print_delete_files_in_dir_by_regex("rmdir", abs_file, pid); return; 
    } 

    print_delete_files_in_dir("rmdir", abs_file, abs_file, pid); 
} 

static inline void record_unlink_syscall(pid_t pid, const char *file_path) 
{ 
    char abs_file[MY_PATH_MAX] = { 0 }; 
    parse_to_abs_filepath(abs_file, file_path, pid); 
    if (!is_directory(abs_file)) { 
        print_dep_file("unlink", abs_file, "Delete", pid); 
        //print_delete_files_in_dir_by_regex("unlink", abs_file, pid); return; 
    } 

    print_delete_files_in_dir("unlink", abs_file, abs_file, pid); 
} 

static inline void record_unlinkat_syscall(pid_t pid, int dirfd, const char *file_path) 
{ 
    char abs_file[MY_PATH_MAX] = { 0 }; 
    parse_to_abs_filepath_with_dirfd(abs_file, dirfd, file_path, pid); 
    if (!is_directory(abs_file)) { 
        print_dep_file("unlinkat", abs_file, "Delete", pid); 
        //print_delete_files_in_dir_by_regex("unlinkat", abs_file, pid); 
        return; 
    } 

    print_delete_files_in_dir("unlinkat", abs_file, abs_file, pid); 
} 

static inline void record_process_info(pid_t pid) { 
    print_dep_file("process", "", "Process", pid); 
} 

void sys_execve_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_AFTER_EXE(pid); 
    activate(pid); 
    record_process_info(pid); 
    g_bArrProcessLogged[pid] = true; 
} 

void sys_write_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_write_syscall(pid, (int)pParam->nParam1);
} 

void sys_pwrite64_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_write_syscall(pid, (int)pParam->nParam1); 
} 

void sys_writev_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_write_syscall(pid, (int)pParam->nParam1); 
} 

void sys_pwritev_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_write_syscall(pid, (int)pParam->nParam1); 
} 

void sys_read_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_read_syscall(pid, (int)pParam->nParam1); 
} 

void sys_readv_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_read_syscall(pid, (int)pParam->nParam1); 
} 

void sys_preadv_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_read_syscall(pid, (int)pParam->nParam1); 
} 

void sys_pread64_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_read_syscall(pid, (int)pParam->nParam1); 
} 

void sys_readlink_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    char file_name[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam1, file_name); 
    record_read_link(pid, file_name); 
} 

void sys_readlinkat_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    char file_name[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam2, file_name); 
    record_read_linkat(pid, (int)pParam->nParam1, file_name); 
} 

void sys_mmap_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    record_mmap_syscall(pid, pParam->nParam3, pParam->nParam5); 
} 

void sys_rename_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_AFTER_EXE(pid); 
    char old_file[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam1, old_file); 
    char new_file[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam2, new_file); 
    record_rename_syscall(pid, old_file, new_file); 
} 

void sys_renameat_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_AFTER_EXE(pid); 
    char old_file[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam2, old_file); 
    char new_file[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam4, new_file); 
    record_renameat_syscall(pid, pParam->nParam1, old_file, pParam->nParam3, new_file); 
} 

void sys_rmdir_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    char file_path[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam1, file_path); 
    record_rmdir_syscall(pid, file_path); 
} 

void sys_unlink_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    char file_path[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam1, file_path); 
    record_unlink_syscall(pid, file_path); 
} 

void sys_unlinkat_processor(ST_PROCESS_INFO *pParam, pid_t pid, bool bClean) 
{ 
    RECORD_BEFORE_EXE(pid); 
    char file_path[MY_PATH_MAX] = { '\0' }; 
    read_string(pid, pParam->nParam2, file_path); 
    record_unlinkat_syscall(pid, (int)pParam->nParam1, file_path); 
} 

int main(int argc, char *argv[]) 
{ 
    if (argc < 3) { 
        return -1; 
    } 

    pid_t pid_fock = 0; 
    switch (pid_fock = fork()) { 
    case -1: 
        break; 
    case 0: 
    { 
        //子进程 
        ptrace(PTRACE_TRACEME, 0, NULL, NULL); 
        //execvp(argv[2], &argv[2]); 
        //execvp(argv[1], &argv[1]); 
        execlp(argv[1], argv[1], NULL); 
        break; 
    } 
    default: 
    { 
        //父进程 
        int status      = 0; 
        //init(argv[2], argv[1]); 
        init(argv[1], argv[2]); 
        g_nPrograms                         = 0; 
        g_afuncProcessor64[SYS_execve]      = sys_execve_processor; 
        g_afuncProcessor32[11]              = sys_execve_processor; 
        g_afuncProcessor64[SYS_write]       = sys_write_processor; 
        g_afuncProcessor32[4]               = sys_write_processor; 
        g_afuncProcessor64[SYS_pwrite64]    = sys_pwrite64_processor; 
        g_afuncProcessor32[181]             = sys_pwrite64_processor; 
        g_afuncProcessor64[SYS_writev]      = sys_writev_processor; 
        g_afuncProcessor32[146]             = sys_writev_processor; 
        g_afuncProcessor64[SYS_pwritev]     = sys_pwritev_processor; 
        g_afuncProcessor32[334]             = sys_pwritev_processor; 
        g_afuncProcessor64[SYS_read]        = sys_read_processor; 
        g_afuncProcessor32[3]               = sys_read_processor; 
        g_afuncProcessor64[SYS_readv]       = sys_readv_processor; 
        g_afuncProcessor32[145]             = sys_readv_processor; 
        g_afuncProcessor64[SYS_preadv]      = sys_preadv_processor; 
        g_afuncProcessor32[333]             = sys_preadv_processor; 
        g_afuncProcessor64[SYS_pread64]     = sys_pread64_processor; 
        g_afuncProcessor32[180]             = sys_pread64_processor; 
        g_afuncProcessor64[SYS_readlink]    = sys_readlink_processor; 
        g_afuncProcessor32[85]              = sys_readlink_processor; 
        g_afuncProcessor64[SYS_readlinkat]  = sys_readlinkat_processor; 
        g_afuncProcessor32[305]             = sys_readlinkat_processor; 
        g_afuncProcessor64[SYS_mmap]        = sys_mmap_processor; 
        g_afuncProcessor32[192]             = sys_mmap_processor; 
        g_afuncProcessor64[SYS_rename]      = sys_rename_processor; 
        g_afuncProcessor32[38]              = sys_rename_processor; 
        g_afuncProcessor64[SYS_renameat]    = sys_renameat_processor; 
        g_afuncProcessor32[302]             = sys_renameat_processor; 
        g_afuncProcessor64[SYS_rmdir]       = sys_rmdir_processor; 
        g_afuncProcessor32[40]              = sys_rmdir_processor; 
        g_afuncProcessor64[SYS_unlink]      = sys_unlink_processor; 
        g_afuncProcessor32[10]              = sys_unlink_processor; 
        g_afuncProcessor64[SYS_unlinkat]    = sys_unlinkat_processor; 
        g_afuncProcessor32[301]             = sys_unlinkat_processor; 
        while (true) { 
            pid_t pid = wait3(&status, __WALL, NULL); 
            if (pid < 0 || pid >= 4194499) { 
                continue; 
            } 

            if (!g_bArrProcessInfo[pid]) { 
                g_nPrograms++; 
                g_bArrProcessInfo[pid] = true; 
                ptrace_trace_child(pid); 
                ptrace_continue(pid, 0); 
                activate(pid); 
                if (pid_fock == pid) { 
                    record_process_info(pid_fock); 
                } 
            } 
            // process exit 
            if (WIFEXITED(status) || WIFSIGNALED(status)) { 
                if (g_bArrProcessInfo[pid]) 
                    --g_nPrograms; 
                g_bArrProcessInfo[pid]      = false; 
                g_bArrProcessLogged[pid]    = false; 
                print_pid_write_record(pid); 
                remove_useless_rnode_by_pid(pid); 
                if (g_nPrograms > 0) { 
                    clean(pid); 
                    continue; 
                } 

                print_all_write_record(); 
                free_all_data(); 
                printf("Finished!\n"); 
                break; 
            } 

            if (WIFSTOPPED(status)) { 
                unsigned int event = (status >> 16); 
                unsigned int sig   = WSTOPSIG(status); 
                // trace exit: clean related context 
                if (event == PTRACE_EVENT_EXIT) { 
                    sys_execve_processor(NULL, pid, true); 
                    sys_write_processor(NULL, pid, true); 
                    sys_pwrite64_processor(NULL, pid, true); 
                    sys_writev_processor(NULL, pid, true); 
                    sys_pwritev_processor(NULL, pid, true); 
                    sys_read_processor(NULL, pid, true); 
                    sys_readv_processor(NULL, pid, true); 
                    sys_preadv_processor(NULL, pid, true); 
                    sys_pread64_processor(NULL, pid, true); 
                    sys_readlink_processor(NULL, pid, true); 
                    sys_readlinkat_processor(NULL, pid, true); 
                    sys_mmap_processor(NULL, pid, true); 
                    sys_rename_processor(NULL, pid, true); 
                    sys_renameat_processor(NULL, pid, true); 
                    sys_rmdir_processor(NULL, pid, true); 
                    sys_unlink_processor(NULL, pid, true); 
                    sys_unlinkat_processor(NULL, pid, true); 
                    if (!g_bArrProcessLogged[pid]) { 
                        record_process_info(pid); 
                        remove_useless_rnode_by_pid(pid); 
                    } 

                    ptrace_continue(pid, 0); 
                    continue; 
                } 
                //if ((event == PTRACE_EVENT_FORK) 
                // || (event == PTRACE_EVENT_VFORK) 
                // || (event == PTRACE_EVENT_CLONE) 
                // /*|| (event == PTRACE_EVENT_VFORK_DONE)*/) { 
                //    long child_pid  = ptrace_get_child(pid); 
                //    if(child_pid) { 
                //        //activate(child_pid); 
                //        //ptrace_trace_child(child_pid); 
                //     printf("parent： %d child: %d\n", child_pid); 
                //    } 
                //    //ptrace(PTRACE_ATTACH, child_pid, 0, 0); 
                //    //ptrace_continue(child_pid, 0); 
                //    //ptrace_continue(pid, sig); 
                //    //continue; 
                //} 
                // other signal, not syscall interrupt 
                if (0 == (sig & 0x80)) { 
                    if (5 != sig) 
                        ptrace_continue(pid, sig); 
                    else 
                        ptrace_continue(pid, 0); 
                        continue; 
                } 
                //printf("%d callid: %d %d\n", pid, stProcessInfo.bLinux32, stProcessInfo.nSysCallId); 
                ST_PROCESS_INFO stProcessInfo = { 0 }; 
                get_syscall_args(pid, &stProcessInfo); 
                if (stProcessInfo.nSysCallId >= 0) { 
                    if (!stProcessInfo.bLinux32) { 
                        // 64-bit process 
                        if (g_afuncProcessor64[stProcessInfo.nSysCallId]) 
                            g_afuncProcessor64[stProcessInfo.nSysCallId](&stProcessInfo, pid, false); 
                        } 
                        else { 
                            // 32-bit process 
                            if (g_afuncProcessor32[stProcessInfo.nSysCallId]) 
                                g_afuncProcessor32[stProcessInfo.nSysCallId](&stProcessInfo, pid, false);
                        } 
                    }
                    ptrace_continue(pid, 0); 
                    continue; 
                } 
                printf("strange status: %d!\n", status); 
                ptrace_continue(pid, 0); 
            } 
        } 
    } 

    return 0; 
}
XiaoH0_0
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
论文研究-Linux下Ptrace()调用的安全分析.pdf
07-22
对Linux下的系统调用Ptrace()所拥有的进程跟踪和控制调试功能进行了分析；结合内核漏洞的具体实例研究其对系统可能造成的安全威胁；最后就病毒技术中的一项关键技术——隐藏，讨论了Ptrace()在Linux病毒隐藏技术中的...
论文研究-基于SCI的Linux操作系统扩展研究.pdf
07-22
通过分析SCI原理，使用Linux模块在核心引入Mod_tracer接口，很好地解决了Ptrace接口的局限性，为基于SCI技术对传统操作系统进行扩展提出了一种新框架，并通过用户级网络文件系统实现，验证了其有效性。
（转载兼整理）Linux 2.6 下通过 ptrace 和 plt 实现用户态 API Hook
weixin_33898876的博客
06-11 207
这厮此文写的相当实用，不知道为啥不好好整理一下，得，我代劳了吧。作者：l04m33@gmail.com，原文。去看一眼就知道我干嘛干这个脏活儿了... 感觉这篇文章有上首页的素质，可惜不是我自己写的，那就算了吧。 本来我自己想用类似这篇文章说的方法，仔细琢磨了一下，似乎我的事儿还是用别的方法干比较好。另外感觉和这篇文章需求相似的话，只要不是偷着摸着干事，也还是LD_PRELOAD来的简单直接。L...
利用ptrace hook 系统调用
学习记录
04-10 1255
我们知道gdb的实现原理就是利用ptrace，关于ptrace我就不多介绍了，主要看怎么利用它去hook 首先，利用ptrace可以给被调试进程下断点，也可以改其寄存器，和opcode，我们利用这点可以实现一个简易的调试器，那么我们如果把实现调试器时插入的0xcc字节码换成我们想要执行的hook函数会发生什么呢？ 比如我们 ...
linux ptrace函数
Daniel 的技术笔记 不积跬步无以至千里，不积小流无以成江海。
11-25 5913
【ptrace系统调用】 功能描述： 提供父进程观察和控制另一个进程执行的机制，同时提供查询和修改另一进程的核心影像与寄存器的能力。主要用于执行断点调试和系统调用跟踪。父进程可通过调用fork，接着指定所产生的子进程的PTRACE_TRACEME行为，最后使用exec等操作来初始化一个进程跟踪。可替代的做法是，父进程通过PTRACE_ATTACH请求跟踪一个现存进程的执行。 当子进程
Linux 系统调用 Ptrace 详解
freeking101的博客
06-19 1614
From：https://blog.csdn.net/u012417380/article/details/60470075 一、系统调用 操作系统提供一系列系统调用函数来为应用程序提供服务。关于系统调用的详细相关知识，可以查看<<程序员的自我修养》第十二章。 对于x86操作系统来说，用中断命令“int 0x80”来进行系统调用，系统调用前，需要将系统调用号放入到%EAX寄存器中，将系统的参数依次放入到寄存器%ebx、%ecx、%edx以及%esi和%edi中。...
Linux Hook--ptrace的常用参数使用
钞sir的博客
04-28 1万+
简介 ptrace是一种系统调用,也就是进程追踪(process trace);用于对进程的执行进行干涉以及寄存器状态（值）的读取以及设置，内存的写入与读取;我们常用的Linux下的gdb主要功能实现就是通过ptrace系统调用的: #include <sys/ptrace.h> long ptrace(enum __ptrace_request request, pid_t pid,...
Linux下Ptrace()调用的安全分析.pdf
09-07
Ptrace()是 Linux 操作系统中的一种系统调用，它提供了对运行中的进程进行跟踪和控制的能力。这项技术广泛应用于程序开发和调试中，但是在安全方面，它也存在一定的隐患。本文将对 Ptrace() 调用的安全进行分析，并...
深入LINUX内核：为LINUX增加一条系统调用.pdf
09-07
其主要目的是使得用户可以使用操作系统提供的有关设备管理、输入/输出系统、文件系统和进程控制、通信以及存储管理等方面的功能，而不必了解系统程序的内部结构和有关硬件细节，从而起到减轻用户负担和保护系统以及...
Linux系统调用跟踪和进程错误退出分析.pdf
09-06
每种工具都有其特点和优缺，ftrace采用静态trace_point方法，systemtap利用kprobe和kretprobe对系统调用处理函数的调用和返回信息进行了采集，gdb的catch syscall命令和strace工具，利用ptrace机制对系统调用进行...
Linux监控文件读写
ciaiy的博客
07-25 5185
前言 最近想写deepin编程比赛中的文件管控系统。 如何去监测目标文件， 我思考了很久仍没有头绪，翻了翻开发大赛入围名单， 发现马艺诚同学使用了hook方法来监测进程操作目标文件。于是下午试了试， 确实可行（毕竟人家已经做出来了嘛）。下面讲解一下我下午尝试的read检测功能。 正文 废话不多说， 先贴代码。 #include <stdio.h> #include <string...
c语言Linux钩子函数,在Linux C/C++中对现有函数添加Hook的方法
weixin_30651345的博客
05-03 790
#include #include #include #include #include #include #include #include #define PAGE_SIZE sysconf(_SC_PAGESIZE)#define PAGE_MASK (~(PAGE_SIZE-1))#define PAGE_ALIGN(addr)(unsigned cha...
Linux/C/C++ 文件监控和网络监控的简单实现(利用hook技术)
weixin_45646368的博客
12-19 2651
file_filter.c #include <stdio.h> #include <string.h> #include <stdlib.h> #include <sys/stat.h> #include <unistd.h> #include <dlfcn.h> #define STRMAXLEN 301 const char path[] = "/home/changun/test"; // 受监控的目录 const cha
Linux下Hook一个共享库函数
linuxheik的专栏
04-18 3403
有时程序员需要完成这类任务： 假如你有一个二进制版的系统，例如现在流行的android，你需要为这个系统开发一个软件。这个软件牵涉到系统行为，因此需要对系统做修改。然而你并没有这个系统的所有源码（ Nexus S的源码不一定与 android 官方版本一模一样），或者是你只有这个系统的头文件。当你需要修改部分系统行为的时候，你不可能用源码重新编译一个共享库来替换系统文件。此时，就需要利用 d
[LINUX]用ptrace来监控某一个进程的系统调用
小蜗牛之家
07-24 1000
用ptrace来监控某一个进程的系统调用 方法： 用execpl执行某个程序，并打上TRACE_ME标记即可 如果要解决子进程启动新的进程也想要被监控的问题，可以使用Set Options的功能，来监控所有的fock、vfock等信息 基本原理是在调用fock新生成一个进程的时候，会返回进程pid，如果返回不是0，就是父进程，如果返回0，就是子进程。这样就可以分别在父进程、子进程中执行一些操作:...
hook pte_Linux下Hook方式汇总
weixin_36324426的博客
01-17 179
main代码为了得到存放shellcode的地址，我们需要先执行mmap，而执行mmap也需要一段可执行地址。这里其实我们可以直接使用libc_base。在libc_base处写入下面的opcode，其中int 0x3是为了发出信号，让我们知道该opcode执行完成。call raxint 0x3;"\xff\xd0\xcd\x03"实现mmap调用备份数据，写入opcode，设置mmap参数//...
Linux模块编程使用内核未导出的函数
SweeNeil
08-13 1454
转自：https://blog.csdn.net/jasonLee_lijiaqi/article/details/83089569 作者：jasonLee_lijiaqi 一般我们在编写内核模块时，可以直接使用内核中使用EXPORT_SYMBOL或者EXPORT_SYMBOL_GPL导出的函数，没有导出的内核函数不能直接使用。否则会报错未定义： WARNING:"do_sys_open"...
linux系统下的各种hook方式\Linux内核hook系统调用
热门推荐
西京刀客
08-26 1万+
文章目录一、linux系统下的各种hook方式1. 函数指针hook2. 动态库劫持3. Linux系统调用劫持 hook4. 堆栈式文件系统5. LSM二、Linux内核hook系统调用 一、linux系统下的各种hook方式 在计算机中,基本所有的软件程序都可以通过hook方式进行行为拦截,hook方式就是改变原始的执行流, Linux平台上常见的拦截： 修改函数指针。 用户态动态库拦截。 内核态系统调用拦截。 堆栈式文件系统拦截。 LSM(Linux Security Modules) 1. 函数
Linux C: hook read和write函数
最新发布
Fiyanna的博客
01-02 498
通过拦截软件模块间的函数调用、消息传递、事件传递来修改或扩展操作系统、应用程序或其他软件组件的行为的各种技术。处理被拦截的函数调用、事件、消息的代码，被称为hook。
Linux内核模块设计：利用Hook技术实现文件访问权限监控
本文档主要探讨了如何使用hook技术设计Linux安全模块，以实现对文件的访问控制。实验旨在帮助读者巩固课堂所学内容，并扩展理论知识到实践操作，尤其针对那些希望进行基本内核编程的人员。实验条件包括使用一台具备...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值