House Of Emma

House Of Emma 的利用背景：

学习 House Of Kiwi 大概是一个月之前了，中间由于学校的一些活动确实是有一段时间没怎么学习，回过神来还需要把前面的知识再重新复习一遍，感觉也不算是很扎实。

House Of Kiwi 可以说是和 Emma 一脉相承的一个利用手法吧，我们通常在 _IO_file_jumps 可以写的情况下的利用 Kiwi ，那如果不可写呢，house of emma 就是对其的补充，也可以说是进阶。

如果 vtable 指向的 _IO_file_jumps 不可写，那么 House of Kiwi 这种攻击手法就会失效。这时候就需要考虑劫持 vtable 。但在新版 glibc ，之前的劫持 vtable 的方法已经失效。

  • 由于自 libc-2.24 起对 vtable 指向的地址范围有检查，因此不能随便将 vtable 劫持到某块伪造了 _IO_jump_t 的内存上。
  • 自 glibc-2.28 起，_IO_str_jumps 上的 _IO_str_finish 不再调用 _IO_strfile（IO_FILE 结构体） 上的函数指针。

因此需要寻找其他的危险函数来劫持程序流。

House Of Emma 的利用手法：

vtable 的合法范围内，还有另一个 _IO_jump_t 类型的函数表叫做 _IO_cookie_jumps ，其中有如下危险函数可供我们利用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
static ssize_t
_IO_cookie_read (FILE *fp, void *buf, ssize_t size)
{
    struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
    cookie_read_function_t *read_cb = cfile->__io_functions.read;
    #ifdef PTR_DEMANGLE
    PTR_DEMANGLE (read_cb);
    #endif

    if (read_cb == NULL)
        return -1;

    return read_cb (cfile->__cookie, buf, size);
}

static ssize_t
_IO_cookie_write (FILE *fp, const void *buf, ssize_t size)
{
    struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
    cookie_write_function_t *write_cb = cfile->__io_functions.write;
    #ifdef PTR_DEMANGLE
    PTR_DEMANGLE (write_cb);
    #endif

    if (write_cb == NULL)
    {
        fp->_flags |= _IO_ERR_SEEN;
        return 0;
    }

    ssize_t n = write_cb (cfile->__cookie, buf, size);
    if (n < size)
        fp->_flags |= _IO_ERR_SEEN;

    return n;
}

static off64_t
_IO_cookie_seek (FILE *fp, off64_t offset, int dir)
{
    struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
    cookie_seek_function_t *seek_cb = cfile->__io_functions.seek;
    #ifdef PTR_DEMANGLE
    PTR_DEMANGLE (seek_cb);
    #endif

    return ((seek_cb == NULL
           || (seek_cb (cfile->__cookie, &offset, dir)
           == -1)
           || offset == (off64_t) -1)
          ? _IO_pos_BAD : offset);
}

static int
_IO_cookie_close (FILE *fp)
{
    struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
    cookie_close_function_t *close_cb = cfile->__io_functions.close;
    #ifdef PTR_DEMANGLE
    PTR_DEMANGLE (close_cb);
    #endif

    if (close_cb == NULL)
        return 0;

    return close_cb (cfile->__cookie);
    其中 _IO_cookie_file 有如下定义：

        /* Special file type for fopencookie function.  */
        struct _IO_cookie_file
        {
            struct _IO_FILE_plus __fp;
            void *__cookie;
            cookie_io_functions_t __io_functions;
        };

    typedef struct _IO_cookie_io_functions_t
    {
        cookie_read_function_t *read;        /* Read bytes.  */
        cookie_write_function_t *write;      /* Write bytes.  */
        cookie_seek_function_t *seek;        /* Seek/tell file position.  */
        cookie_close_function_t *close;      /* Close file.  */
    } cookie_io_functions_t;

其中 _IO_cookie_file 有如下定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* Special file type for fopencookie function.  */
struct _IO_cookie_file
{
    struct _IO_FILE_plus __fp;
    void *__cookie;
    cookie_io_functions_t __io_functions;
};

typedef struct _IO_cookie_io_functions_t
{
    cookie_read_function_t *read;        /* Read bytes.  */
    cookie_write_function_t *write;    /* Write bytes.  */
    cookie_seek_function_t *seek;        /* Seek/tell file position.  */
    cookie_close_function_t *close;    /* Close file.  */
} cookie_io_functions_t;

因此攻击手法与前面的 _IO_str_jumps 相似，不过需要绕过指针保护 PTR_DEMANGLE 。

分析汇编可知，这段宏定义的操作是将函数指针循环右移 11 位然后与 fs:[0x30] 异或得到真正的函数地址。

1779182310608-23c30acb-454f-41f8-a328-13dea26e5513.png

我们知道， fs:[0x28] 是 tls 上存储的 canary，根据 tcbhead_t 结构体的定义，fs[0x30] 是 pointer_guard ，用于对指针进行加密。

1
2
3
4
5
6
7
8
9
10
11
12
//sysdeps/x86_64/nptl/tls.h
typedef struct {
    void *tcb;    /* 指向TCB */
    dtv_t *dtv;       /* 指向dtv数组 */
    void *self;   /* 指向自身  */
    int multiple_threads;
    int gscope_flag;
    uintptr_t sysinfo;
    uintptr_t stack_guard;    /* canary值 */
    uintptr_t pointer_guard;  /* 用于保护指针 */
    //...
} tcbhead_t;

因此我们可以先泄露堆地址和 libc 基地址，然后利用 large bin attack 在 tls 对应 pointer_guard 上写一个 chunk 地址，从而绕过指针保护。

在实际调试时可以利用 canary 等方法查找 pointer_guard 地址，然后在攻击时根据 libc 基地址定位 pointer_guard 。

1779182709593-d8c664c8-359f-437a-9a44-7545aa30b748.png

与 house of kiwi 一样，house of emma 也是通过 __malloc_assert 触发漏洞，但是由于 pointer_guard 已被修改，原来受保护的函数指针都已经无法调用，因此要选择最早调用的 vtable 中的函数进行触发，因此这里选择下面这个调用链：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
static void
__malloc_assert (const char *assertion, const char *file, unsigned int line,
                 const char *function)
{
    (void) __fxprintf (NULL, "%s%s%s:%u: %s%sAssertion `%s' failed.\n",
                     __progname, __progname[0] ? ": " : "",
                     file, line,
                     function ? function : "", function ? ": " : "",
                     assertion);
    fflush (stderr);
    abort ();
}

int
__fxprintf (FILE *fp, const char *fmt, ...)
{
    va_list ap;
    va_start (ap, fmt);
    int res = __vfxprintf (fp, fmt, ap, 0);
    va_end (ap);
    return res;
}

int
__vfxprintf (FILE *fp, const char *fmt, va_list ap,
             unsigned int mode_flags)
{
    if (fp == NULL)
        fp = stderr;
    _IO_flockfile (fp);
    int res = locked_vfxprintf (fp, fmt, ap, mode_flags);
    _IO_funlockfile (fp);
    return res;
}

static int
locked_vfxprintf (FILE *fp, const char *fmt, va_list ap,
                  unsigned int mode_flags)
{
    if (_IO_fwide (fp, 0) <= 0)
        return __vfprintf_internal (fp, fmt, ap, mode_flags);
    ...
    }

# define vfprintf   __vfprintf_internal

int
vfprintf (FILE *s, const CHAR_T *format, va_list ap, unsigned int mode_flags)
{
    ...
        outstring ((const UCHAR_T *) format,
             lead_str_end - (const UCHAR_T *) format);
    ...
    }

#define outstring(String, Len)                          \
    do {                                                \
        const void *string_ = (String);                 \
        done = outstring_func(s, string_, (Len), done); \
        if (done < 0)                                   \
            goto all_done;                              \
    } while (0)

# define PUT(F, S, N)   _IO_sputn ((F), (S), (N)) 

static inline int
outstring_func (FILE *s, const UCHAR_T *string, size_t length, int done)
{
    assert ((size_t) done <= (size_t) INT_MAX);
    if ((size_t) PUT (s, string, length) != (size_t) (length))
        return -1;
    return done_add_func (length, done);

具体利用流程：在利用 UAF 泄露 libc 和堆地址后，利用 2 次 large bin attack 分别覆盖 pointer_guard 和 stderr 指针为某 chunk 地址，然后作如下图所示构造。最后通过 __malloc_asserrt 触发漏洞。

1779182767381-b3f57a58-1331-46f0-b32f-3e138cf50f45.png

需要注意的是，由于伪造的 IO_FILE 的 flag 的 _IO_USER_LOCK（0x8000）没有置位，因此在 __vfxprintf 函数中会执行如下代码：

1779182892716-7c165986-44a2-48cc-84eb-f7378c48f5be.png

因此伪造的 IO_FILE 的 _lock 应该指向可读写的内存。

glibc-2.36 的 __malloc_assert 发生重大改变，直接通过系统调用不走 IO，该方法失效。不过只要能够调用 vtable 中的函数我们就能够完成 House Of Emma 利用。

1
2
3
4
5
6
7
8
9
_Noreturn static void
    __malloc_assert (const char *assertion, const char *file, unsigned int line,
                     const char *function)
{
    __libc_message (do_abort, "\
Fatal glibc error: malloc assertion failure in %s: %s\n",
                    function, assertion);
    __builtin_unreachable ();
}

参考资料：https://xz.aliyun.com/news/15458

更新: 2026-05-19 17:29:42
原文: https://www.yuque.com/idcm/wnemg9/qbrsyfxe1dilrnd9