重要结构
1
| typedef struct { int lock; int cnt; void *owner; } _IO_lock_t;
|
源码分析
gets
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
| char *
_IO_gets (char *buf)
{
size_t count;
int ch;
char *retval;
_IO_acquire_lock (stdin);
ch = _IO_getc_unlocked (stdin);
if (ch == EOF)
{
retval = NULL;
goto unlock_return;
}
if (ch == '\n')
count = 0;
else
{
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
int old_error = stdin->_flags & _IO_ERR_SEEN;
stdin->_flags &= ~_IO_ERR_SEEN;
buf[0] = (char) ch;
count = _IO_getline (stdin, buf + 1, INT_MAX, '\n', 0) + 1;
if (stdin->_flags & _IO_ERR_SEEN)
{
retval = NULL;
goto unlock_return;
}
else
stdin->_flags |= old_error;
}
buf[count] = 0;
retval = buf;
unlock_return:
_IO_release_lock (stdin);
return retval;
}
|
_IO_gets 是 gets 的本体
这里重点关注 _IO_acquire_lock 和 _IO_release_lock
_IO_acquire_lock 和 _IO_release_lock
1
2
3
4
5
6
7
8
| # define _IO_acquire_lock(_fp) \
do { \
FILE *_IO_acquire_lock_file \
__attribute__((cleanup (_IO_acquire_lock_fct))) \
= (_fp); \
_IO_flockfile (_IO_acquire_lock_file);
# define _IO_release_lock(_fp) ; } while (0)
|
注意 cleanup 属性
_IO_flockfile 和 _IO_funlockfile
1
2
3
4
| # define _IO_flockfile(_fp) \
if (((_fp)->_flags & _IO_USER_LOCK) == 0) _IO_lock_lock (*(_fp)->_lock)
# define _IO_funlockfile(_fp) \
if (((_fp)->_flags & _IO_USER_LOCK) == 0) _IO_lock_unlock (*(_fp)->_lock)
|
此处 _lock 为 _IO_lock_t 的结构体指针
_IO_lock_lock 和 _IO_lock_unlock
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
| #define _IO_lock_lock(_name) \
do { \
void *__self = THREAD_SELF; \
if (SINGLE_THREAD_P && (_name).owner == NULL) \
{ \
(_name).lock = LLL_LOCK_INITIALIZER_LOCKED; \
(_name).owner = __self; \
} \
else if ((_name).owner != __self) \
{ \
lll_lock ((_name).lock, LLL_PRIVATE); \
(_name).owner = __self; \
} \
else \
++(_name).cnt; \
} while (0)
#define _IO_lock_unlock(_name) \
do { \
if (SINGLE_THREAD_P && (_name).cnt == 0) \
{ \
(_name).owner = NULL; \
(_name).lock = 0; \
} \
else if ((_name).cnt == 0) \
{ \
(_name).owner = NULL; \
lll_unlock ((_name).lock, LLL_PRIVATE); \
} \
else \
--(_name).cnt; \
} while (0)
|
_IO_acquire_lock_fct
1
2
3
4
5
6
7
8
| static inline void
__attribute__ ((__always_inline__))
_IO_acquire_lock_fct (FILE **p)
{
FILE *fp = *p;
if ((fp->_flags & _IO_USER_LOCK) == 0)
_IO_funlockfile (fp);
}
|
由于 cleanup 属性， gets 执行完成后会调用这个
_IO_stdfile_0_lock
1
| static _IO_lock_t _IO_stdfile_##FD##_lock = _IO_lock_initializer;
|
1
| #define _IO_lock_initializer { LLL_LOCK_INITIALIZER, 0, NULL }
|
gets 执行完成后， rdi 为 _IO_stdfile_0_lock 的地址，指向一个 _IO_lock_t 结构体
THREAD_SELF
1
2
3
4
5
| # define THREAD_SELF \
({ struct pthread *__self; \
asm ("mov %%fs:%c1,%0" : "=r" (__self) \
: "i" (offsetof (struct pthread, header.self))); \
__self;})
|
极其高效地获取“当前线程”的线程控制块（TCB，即 struct pthread 结构体）的内存基地址
利用思路
目标是通过 gets 后 rdi 的残留值传入 puts 以 leak tls
在 _IO_gets 中，获取输入之前会先用 _IO_lock_lock 处理 _IO_stdfile_0_lock ，这使得 (_name).owner = __self = THREAD_SELF
所以只要我们能覆盖前 _IO_stdfile_0_lock 的前 8 字节就可以通过 (_name).owner 去 leak tls
但是要注意 _IO_acquire_lock_fct 即 _IO_funlockfile 即 _IO_lock_unlock 会在 gets 结束时执行，这意味着 (_name).cnt 会被减去 1 ，然后若此时 (_name).cnt 为 0 ，那么 (_name).owner 会被清空，无法 leak tls
由于 puts 的输出截断于 \x00 ，而 gets 会将末尾设置为 \x00 ，我们需要利用上面 cnt 被减去 1 的机制绕过输出截断
若构造 'AAAA\x00\x00\x00' 的 payload ，由于 cnt 只有不为 0 时才会被减去 1 ，而且 cnt 为 0 owner 会被清空，该构造无效
因此我们考虑分两次布置：第一次布置 b'A' * 8 + b'\x00' * 6 ，目的是触发 (_name).owner == NULL ，第二次布置 b'B' * 4 后即可绕过截断
但是在不同 linux 版本的情况下 leak 出的地址与 libc 的偏移会不同，甚至可能 leak 出的是与 ld 相关的部分，这就导致可能需要尝试利用 ld 中的 gadget 再去 leak libc
