如何用替換函數(shù)的Trick做正常的事情

浙江溫州皮鞋濕，下雨進水不會胖。周六的雨夜，期待明天的雨會更大更冷。

已經(jīng)多久沒有編程了？很久了吧…其實我本來就不怎么會寫代碼，時不時的也就是為了驗證一個系統(tǒng)特性，寫點玩具而已，工程化的代碼，對于我而言，實在是吃力。

最近遇到一些問題，需要特定的解法，也就有機會手寫點代碼了。其實這個話題記得上一次遇到是在8年前，時間過得好快。

替換一個已經(jīng)在內(nèi)存中的函數(shù)，使得執(zhí)行流流入我們自己的邏輯，然后再調(diào)用原始的函數(shù)，這是一個很古老的話題了。比如有個函數(shù)叫做funcion，而你希望統(tǒng)計一下調(diào)用function的次數(shù)，最直接的方法就是 如果有誰調(diào)用function的時候，調(diào)到下面這個就好了 ：

void new_function()

{

count++;

return function();

}

網(wǎng)上很多文章給出了實現(xiàn)這個思路的Trick，而且一直以來計算機病毒也都采用了這種偷梁換柱的伎倆來實現(xiàn)自己的目的。然而，當你親自去測試時，發(fā)現(xiàn)事情并不那么簡單。

網(wǎng)上給出的許多方法均不再適用了，原因是在早期，這樣做的人比較少，處理器和操作系統(tǒng)大可不必理會一些不符合常規(guī)的做法，但是隨著這類Trick開始做壞事影響到正常的業(yè)務(wù)邏輯時，處理器廠商以及操作系統(tǒng)廠商或者社區(qū)便不得不在底層增加一些限制性機制，以防止這類Trick繼續(xù)起作用。

常見的措施有兩點：

可執(zhí)行代碼段不可寫

這個措施便封堵住了你想通過簡單memcpy的方式替換函數(shù)指令的方案。

內(nèi)存buffer不可執(zhí)行

這個措施便封堵住了你想把執(zhí)行流jmp到你的一個保存指令的buffer的方案。

stack不可執(zhí)行

別看這些措施都比較low，一看誰都懂，它們卻避免了大量的緩沖區(qū)溢出帶來的危害。

那么如果我們想用替換函數(shù)的Trick做正常的事情，怎么辦？

我來簡單談一下我的方法。首先我不會去HOOK用戶態(tài)的進程的函數(shù)，因為這樣意義不大，改一下重啟服務(wù)會好很多。所以說，本文特指HOOK內(nèi)核函數(shù)的做法。畢竟內(nèi)核重新編譯，重啟設(shè)備代價非常大。

我們知道，我們目前所使用的幾乎所有計算機都是馮諾伊曼式的統(tǒng)一存儲式計算機，即指令和數(shù)據(jù)是存在一起的，這就意味著我們必然可以在操作系統(tǒng)層面隨意解釋內(nèi)存空間的含義。

我們在做正當?shù)氖虑?，所以我假設(shè)我們已經(jīng)拿到了系統(tǒng)的root權(quán)限并且可以編譯和插入內(nèi)核模塊。那么接下來的事情似乎就是一個流程了。

是的，修改頁表項即可，即便無法簡單地通過memcpy來替換函數(shù)指令，我們還是可以用以下的步驟來進行指令替換：

重新將函數(shù)地址對應(yīng)的物理內(nèi)存映射成可寫；

用自己的jmp指令替換函數(shù)指令；

解除可寫映射。

非常幸運，內(nèi)核已經(jīng)有了現(xiàn)成的 text_poke/text_poke_smp 函數(shù)來完成上面的事情。

同樣的，針對一個堆上或者棧上分配的buffer不可執(zhí)行，我們依然有辦法。辦法如下：

編寫一個stub函數(shù)，實現(xiàn)隨意，其代碼指令和buffer相當；

用上面重映射函數(shù)地址為可寫的方法用buffer重寫stub函數(shù)；

將stub函數(shù)保存為要調(diào)用的函數(shù)指針。

是不是有點意思呢？下面是一個步驟示意圖：

下面是一個代碼，我稍后會針對這個代碼，說幾個細節(jié)方面的東西：

#include

#include

#include

#include

#include

#define OPTSIZE5

// saved_op保存跳轉(zhuǎn)到原始函數(shù)的指令

char saved_op[OPTSIZE] = {0};

// jump_op保存跳轉(zhuǎn)到hook函數(shù)的指令

char jump_op[OPTSIZE] = {0};

static unsigned int (*ptr_orig_conntrack_in)(const struct nf_hook_ops *ops, struct sk_buff *skb, const struct net_device *in, const struct net_device *out, const struct nf_hook_state *state);

static unsigned int (*ptr_ipv4_conntrack_in)(const struct nf_hook_ops *ops, struct sk_buff *skb, const struct net_device *in, const struct net_device *out, const struct nf_hook_state *state);

// stub函數(shù)，最終將會被保存指令的buffer覆蓋掉

static unsigned int stub_ipv4_conntrack_in(const struct nf_hook_ops *ops, struct sk_buff *skb, const struct net_device *in, const struct net_device *out, const struct nf_hook_state *state)

{

printk("hook stub conntrack\n");

return 0;

}

// 這是我們的hook函數(shù)，當內(nèi)核在調(diào)用ipv4_conntrack_in的時候，將會到達這個函數(shù)。

static unsigned int hook_ipv4_conntrack_in(const struct nf_hook_ops *ops, struct sk_buff *skb, const struct net_device *in, const struct net_device *out, const struct nf_hook_state *state)

{

printk("hook conntrack\n");

// 僅僅打印一行信息后，調(diào)用原始函數(shù)。

return ptr_orig_conntrack_in(ops, skb, in, out, state);

}

static void *(*ptr_poke_smp)(void *addr, const void *opcode, size_t len);

static __init int hook_conn_init(void)

{

s32 hook_offset, orig_offset;

// 這個poke函數(shù)完成的就是重映射，寫text段的事

ptr_poke_smp = kallsyms_lookup_name("text_poke_smp");

if (!ptr_poke_smp) {

printk("err");

return -1;

}

// 嗯，我們就是要hook住ipv4_conntrack_in，所以要先找到它！

ptr_ipv4_conntrack_in = kallsyms_lookup_name("ipv4_conntrack_in");

if (!ptr_ipv4_conntrack_in) {

printk("err");

return -1;

}

// 第一個字節(jié)當然是jump

jump_op[0] = 0xe9;

// 計算目標hook函數(shù)到當前位置的相對偏移

hook_offset = (s32)((long)hook_ipv4_conntrack_in - (long)ptr_ipv4_conntrack_in - OPTSIZE);

// 后面4個字節(jié)為一個相對偏移

(*(s32*)(&jump_op[1])) = hook_offset;

// 事實上，我們并沒有保存原始ipv4_conntrack_in函數(shù)的頭幾條指令，

// 而是直接jmp到了5條指令后的指令，對應(yīng)上圖，應(yīng)該是指令buffer里沒

// 有old inst，直接就是jmp y了，為什么呢？后面細說。

saved_op[0] = 0xe9;

// 計算目標原始函數(shù)將要執(zhí)行的位置到當前位置的偏移

orig_offset = (s32)((long)ptr_ipv4_conntrack_in + OPTSIZE - ((long)stub_ipv4_conntrack_in + OPTSIZE));

(*(s32*)(&saved_op[1])) = orig_offset;

get_online_cpus();

// 替換操作！

ptr_poke_smp(stub_ipv4_conntrack_in, saved_op, OPTSIZE);

ptr_orig_conntrack_in = stub_ipv4_conntrack_in;

barrier();

ptr_poke_smp(ptr_ipv4_conntrack_in, jump_op, OPTSIZE);

put_online_cpus();

return 0;

}

module_init(hook_conn_init);

static __exit void hook_conn_exit(void)

{

get_online_cpus();

ptr_poke_smp(ptr_ipv4_conntrack_in, saved_op, OPTSIZE);

ptr_poke_smp(stub_ipv4_conntrack_in, stub_op, OPTSIZE);

barrier();

put_online_cpus();

}

module_exit(hook_conn_exit);

MODULE_DESCRIPTION("hook test");

MODULE_LICENSE("GPL");

MODULE_VERSION("1.1");

測試是OK的。

在上面的代碼中，saved_op中為什么沒有old inst呢？直接就是一個jmp y，這豈不是將原始函數(shù)中的頭幾個字節(jié)的指令給遺漏了嗎？

其實說到這里，還真有個不好玩的Trick，起初我真的就是老老實實保存了前5個自己的指令，然后當需要調(diào)用原始ipv4_conntrack_in時，就先執(zhí)行那5個保存的指令，也是OK的。隨后我objdump這個函數(shù)發(fā)現(xiàn)了下面的代碼：

0000000000000380 :

380: e8 00 00 00 00 callq 385

385: 55 push %rbp

386: 49 8b 40 18 mov 0x18(%r8),%rax

38a: 48 89 f1 mov %rsi,%rcx

38d: 8b 57 2c mov 0x2c(%rdi),%edx

390: be 02 00 00 00 mov $0x2,%esi

395: 48 89 e5 mov %rsp,%rbp

398: 48 8b b8 e8 03 00 00 mov 0x3e8(%rax),%rdi

39f: e8 00 00 00 00 callq 3a4

3a4: 5d pop %rbp

3a5: c3 retq

3a6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)

3ad: 00 00 00

注意前5個指令： e8 00 00 00 00 callq 385

可以看到，這個是可以忽略的。因為不管怎么說都是緊接著執(zhí)行下面的指令。所以說，我就省去了inst的保存。

如果按照我的圖示中常規(guī)的方法的話，代碼稍微改一下即可：

char saved_op[OPTSIZE+OPTSIZE] = {0};

...

// 增加一個指令拷貝的操作

memcpy(saved_op, (unsigned char *)ptr_ipv4_conntrack_in, OPTSIZE);

saved_op[OPTSIZE] = 0xe9;

orig_offset = (s32)((long)ptr_ipv4_conntrack_in + OPTSIZE - ((long)stub_ipv4_conntrack_in + OPTSIZE + OPTSIZE));

(*(s32*)(&saved_op[OPTSIZE+1])) = orig_offset;

但是以上的只是玩具。

有個非常現(xiàn)實的問題。在我保存原始函數(shù)的頭n條指令的時候，n到底是多少呢？在本例中，顯然n是5，符合如今Linux內(nèi)核函數(shù)第一條指令幾乎都是callq xxx的慣例。

然而，如果一個函數(shù)的第一條指令是下面的樣子：

op d1 d2 d3 d4 d5

即一個操作碼需要5個操作數(shù)，我要是只保存5個字節(jié)，最后在stub中的指令將會是下面的樣子：

op d1 d2 d3 d4 0xe9 off1 off2 off3 off4

這顯然是錯誤的，op操作碼會將jmp指令0xe9解釋成操作數(shù)。

解藥呢？當然有咯。

我們不能魯莽地備份固定長度的指令，而是應(yīng)該這樣做：

curr = 0

if orig[0] 為單字節(jié)操作碼

saved_op[curr] = orig[curr];

curr++;

else if orig[0] 攜帶1個1字節(jié)操作數(shù)

memcpy(saved_op, orig, 2);

curr += 2;

else if orig[0] 攜帶2字節(jié)操作數(shù)

memcpy(saved_op, orig, 3);

curr += 3;

...

saved_op[curr] = 0xe9; // jmp

offset = ...

(*(s32*)(&saved_op[curr+1])) = offset;

這是正確的做法。